devops-bot-sdk 1.6.91__tar.gz → 1.6.93__tar.gz

{devops_bot_sdk-1.6.91 → devops_bot_sdk-1.6.93}/PKG-INFO

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

{devops_bot_sdk-1.6.91 → devops_bot_sdk-1.6.93}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.6.91 → devops_bot_sdk-1.6.93}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -165,6 +165,7 @@ tests/test_agent_schedules.py
 tests/test_agent_workspace_settings.py
 tests/test_agents_connectors_builder.py
 tests/test_allowed_tools_config.py
+tests/test_approval_park.py
 tests/test_auto_agent_dispatch.py
 tests/test_auto_ticket_queue.py
 tests/test_browser_profile.py

{devops_bot_sdk-1.6.91 → devops_bot_sdk-1.6.93}/sdk/__init__.py

@@ -1,6 +1,6 @@
 """AgentOS Desktop SDK — thin HTTPS/SSE client for the Electron app.
 
-Version: 1.6.91
+Version: 1.6.93
 
 Public surface:
   BackendClient.from_config()        — create client from ~/.agentos/config.toml
@@ -34,7 +34,7 @@ Rules:
   - All data egress through submit_webhook only
 """
 
-__version__ = "1.6.91"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
+__version__ = "1.6.93"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
 __author__  = "AgentOS"   # sdk.client.SDK_VERSION and the UI server version all read this.
 
 from sdk.client import BackendClient

{devops_bot_sdk-1.6.91 → devops_bot_sdk-1.6.93}/sdk/client.py

@@ -1234,6 +1234,15 @@ class BackendClient:
         try:
             async with httpx.AsyncClient(timeout=20.0) as client:
                 resp = await client.put(url, files={"status": (None, "backlog")}, headers=headers)
+                # The backend 404s a Backlog move on a ticket with no running timer
+                # ("No running timer found") — e.g. an Epic/Story whose approval gate
+                # timed out, which is never marked In Progress. Start a timer (mark In
+                # Progress) and retry once, as set_task_status does.
+                if resp.status_code >= 400 and "no running timer" in resp.text.lower():
+                    await client.put(url, files={"status": (None, "In Progress")},
+                                     headers=headers)
+                    resp = await client.put(url, files={"status": (None, "backlog")},
+                                            headers=headers)
             if resp.status_code >= 400:
                 logger.warning("client.move_to_backlog failed task=%s status=%s body=%s",
                                task_id, resp.status_code, resp.text[:200])

{devops_bot_sdk-1.6.91 → devops_bot_sdk-1.6.93}/sdk/helpdesk.py

@@ -169,6 +169,7 @@ def _loop_state() -> dict:
         "current_ticket": run_auto._read_current(),
         "stop_pending": run_auto._stop_requested(),
         "queue": run_auto._read_queue(),
+        "parked": run_auto._read_parked(),
     }
 
 
@@ -254,12 +255,15 @@ def key_facts() -> list[str]:
 
     facts: list[str] = []
     try:
+        from sdk import run_auto
         st = _loop_state()
         facts.append(f"agentos-auto loop running: {yn(st['running_pid'])}"
                      + (f" (pid {st['running_pid']})" if st["running_pid"] else ""))
         facts.append(f"stop flag set (~/.agentos/auto.stop): {yn(st['stop_pending'])}")
         facts.append(f"ticket in flight: {st['current_ticket'] or 'none'}")
         facts.append(f"queued ticket batches: {len(st['queue'])}")
+        facts.append("parked awaiting approval: "
+                     + (", ".join(run_auto._describe_parked(p) for p in st["parked"]) or "none"))
     except Exception as exc:  # noqa: BLE001
         facts.append(f"agentos-auto loop state: unknown ({exc})")
     try:

{devops_bot_sdk-1.6.91 → devops_bot_sdk-1.6.93}/sdk/ipc/handlers.py

@@ -4715,13 +4715,15 @@ async def _poll_fresh_approval(
 async def _gate_transform_approval(
     client: BackendClient, tid: str, jira_key: str, summary: str | None, action: str,
     send: Callable, thread_id: str, should_stop: Callable[[], bool] | None,
+    on_park: Callable[[dict], None] | None = None,
 ) -> str:
     """Human-approval gate for a non-coding TRANSFORM (Epic decomposition /
     Story→Task conversion) when agentMode=True. Sends the WhatsApp request and WAITS
-    for the decision. Returns 'approved' | 'rejected' | 'stopped'. On a 15-min timeout
-    the ticket goes to Backlog and we keep polling for a late reply. Does NOT change
-    ticket status itself — the handler owns that (an Epic marks itself In Progress; a
-    Story never does)."""
+    for the decision. Returns 'approved' | 'rejected' | 'stopped' | 'parked'. On a
+    15-min timeout the ticket goes to Backlog; with ``on_park`` it is handed to the
+    caller to watch (see :func:`_park_or_wait`), otherwise we keep polling for a late
+    reply. Does NOT change ticket status itself — the handler owns that (an Epic marks
+    itself In Progress; a Story never does)."""
     label = jira_key or tid
     wa_summary = summary or jira_key or "task"
     await send(Envelope(
@@ -4753,18 +4755,58 @@ async def _gate_transform_approval(
     )
     if decision == "timeout":
         await client.move_to_backlog(tid)
+        return await _park_or_wait(client, tid, jira_key, send, thread_id,
+                                   should_stop, on_park)
+    return decision
+
+
+async def _park_or_wait(
+    client: BackendClient, tid: str, jira_key: str, send: Callable, thread_id: str,
+    should_stop: Callable[[], bool] | None, on_park: Callable[[dict], None] | None,
+) -> str:
+    """After a 15-min approval timeout (ticket already in Backlog): park it, or wait.
+
+    With ``on_park`` (the `agentos-auto` loop) the ticket is handed over and we
+    return 'parked' at once, so the rest of the run and every queued batch keep
+    going; the loop re-runs the ticket when a late approval lands. Without it (a
+    caller with nothing to watch the parked set) we poll for the late reply as
+    before — which blocks everything behind this ticket until someone answers.
+    Returns 'parked' | 'approved' | 'rejected' | 'stopped'.
+    """
+    label = jira_key or tid
+    if on_park is not None:
+        on_park({"task_id": tid, "jira_key": jira_key})
         await send(Envelope(
             type="step_update", thread_id=thread_id,
-            data={"current_step": f"{label}: no approval in 15m — Backlog; polling for late approval"},
+            data={"current_step": f"{label}: no approval in 15m — Backlog; parked, "
+                                  "moving on (runs when approved)"},
         ).model_dump())
-        while True:
-            if should_stop is not None and should_stop():
-                return "stopped"
-            late = await client.approval_status(tid)
-            if late in ("approved", "rejected"):
-                return late
-            await asyncio.sleep(_APPROVAL_POLL_INTERVAL_S)
-    return decision
+        try:
+            await client.log_activity(
+                f"Task {tid}: no approval in 15m — parked in Backlog; the loop moves on "
+                "and runs it when a late approval arrives", task_id=tid)
+        except Exception:  # noqa: BLE001
+            pass
+        return "parked"
+    await send(Envelope(
+        type="step_update", thread_id=thread_id,
+        data={"current_step": f"{label}: no approval in 15m — Backlog; polling for late approval"},
+    ).model_dump())
+    while True:
+        if should_stop is not None and should_stop():
+            return "stopped"
+        late = await client.approval_status(tid)
+        if late in ("approved", "rejected"):
+            return late
+        await asyncio.sleep(_APPROVAL_POLL_INTERVAL_S)
+
+
+def _take(ids: set[str], tid: str) -> bool:
+    """Remove ``tid`` from ``ids``; True if it was there (a one-shot pre-approval)."""
+    if tid in ids:
+        ids.discard(tid)
+        return True
+    return False
 
 
 # ── Agent routing (a ticket that names its own agent) ──────────────────────
@@ -5011,6 +5053,7 @@ async def _dispatch_ticket_agent(
 async def handle_orchestrate_auto_local_run(
     client: BackendClient, payload: dict, send: Callable,
     should_stop: Callable[[], bool] | None = None,
+    on_park: Callable[[dict], None] | None = None,
 ) -> None:
     """Backs orchestrate-auto:run — run every To Do task on the USER's machine.
 
@@ -5019,7 +5062,13 @@ async def handle_orchestrate_auto_local_run(
     The server plans + gates; the user's local `claude` writes the code locally and
     the result is reported back. Code never lands on the AI server.
 
-    payload: {thread_id?, workspace_root?, project_paths?: {task_id: path}, role_slug?}
+    payload: {thread_id?, workspace_root?, project_paths?: {task_id: path}, role_slug?,
+              approved_ids?: [task_id]}
+
+    ``on_park``: called with ``{task_id, jira_key}`` when a ticket's approval gate
+    times out; the ticket is then skipped instead of blocking the run (see
+    :func:`_park_or_wait`). ``approved_ids``: tickets whose late approval the caller
+    already saw — their first gate is skipped, once.
     """
     from sdk import local_exec
     from sdk.client import ActivityFlusher, _ACTIVE_ACTIVITY_FLUSHER
@@ -5081,6 +5130,9 @@ async def handle_orchestrate_auto_local_run(
 
         processed = 0
         total = len(tasks)
+        # A late approval stands in for a parked ticket's FIRST gate only — a Story
+        # approved for conversion still gates the coding of the Task it becomes.
+        pre_approved = {str(t) for t in (payload.get("approved_ids") or []) if t}
         for idx, task in enumerate(tasks, 1):
             # Cooperative stop: pause after the previous task when a stop was
             # requested (e.g. `agentos-auto stop` wrote the flag file). Already
@@ -5220,11 +5272,11 @@ async def handle_orchestrate_auto_local_run(
                         processed += 1
                         continue
                     # agentMode gate: wait for human approval before decomposing.
-                    if agent_mode:
+                    if agent_mode and not _take(pre_approved, tid):
                         dec = await _gate_transform_approval(
                             client, tid, jira_key, task.get("summary"),
                             "decompose this Epic into user stories",
-                            send, thread_id, should_stop,
+                            send, thread_id, should_stop, on_park,
                         )
                         if dec == "stopped":
                             await send(Envelope(
@@ -5264,7 +5316,7 @@ async def handle_orchestrate_auto_local_run(
                         continue
                     # agentMode gate: wait for human approval before actioning the
                     # Story (update-in-place when instructed, else convert to Task).
-                    if agent_mode:
+                    if agent_mode and not _take(pre_approved, tid):
                         action = (
                             # A routed Story is neither PRD-enriched nor converted,
                             # so the approval request must describe what will
@@ -5278,7 +5330,7 @@ async def handle_orchestrate_auto_local_run(
                         )
                         dec = await _gate_transform_approval(
                             client, tid, jira_key, task.get("summary"), action,
-                            send, thread_id, should_stop,
+                            send, thread_id, should_stop, on_park,
                         )
                         if dec == "stopped":
                             await send(Envelope(
@@ -5366,6 +5418,8 @@ async def handle_orchestrate_auto_local_run(
                 # dropped the next iteration back to `attempt == 1` and re-entered the
                 # approval gate → forever-poll for a late approval (a permanent hang).
                 limit_retries = 0
+                # A parked ticket's late approval: plan without the gate, like a retry.
+                approved_already = _take(pre_approved, tid)
                 while True:
                     attempt += 1
                     # Mark In Progress before any work begins.
@@ -5376,7 +5430,7 @@ async def handle_orchestrate_auto_local_run(
                     # Human already approved on attempt 1; a new timer firing mid-run
                     # would erroneously demote the ticket to Backlog while claude works.
                     run_payload = (
-                        task_payload if attempt == 1
+                        task_payload if attempt == 1 and not approved_already
                         else {**task_payload, "agent_mode": False}
                     )
 
@@ -5414,7 +5468,7 @@ async def handle_orchestrate_auto_local_run(
                     # ── First-approval gate (agentMode=True, attempt 1 only) ──────
                     # Skipped on retries — human already approved; re-running the gate
                     # would time out and advance to the next ticket instead of retrying.
-                    if agent_mode and attempt == 1:
+                    if agent_mode and attempt == 1 and not approved_already:
                         await send(Envelope(
                             type=Envelope.TYPE_AWAITING_APPROVAL, thread_id=thread_id,
                             data={"jira_key": jira_key, "session_id": session_id, "task_id": tid,
@@ -5473,25 +5527,16 @@ async def handle_orchestrate_auto_local_run(
                             return
 
                         if decision == "timeout":
-                            # 15 min elapsed with no WhatsApp reply.
-                            # Move to Backlog; keep the terminal ALIVE and poll
-                            # indefinitely — no tickets start until approval arrives.
+                            # 15 min elapsed with no WhatsApp reply. Move to Backlog,
+                            # then park it (the loop moves on and re-runs it on a
+                            # late approval) or, with no one to watch, wait for one.
                             await client.move_to_backlog(tid)
-                            await send(Envelope(
-                                type="step_update", thread_id=thread_id,
-                                data={"current_step": f"{jira_key}: no approval in 15m — moved to"
-                                                      " Backlog; polling for late approval "
-                                                      "(terminal stays alive)"},
-                            ).model_dump())
-                            while True:
-                                if should_stop is not None and should_stop():
-                                    _PENDING_LOCAL.pop(session_id, None)
-                                    return
-                                late = await client.approval_status(tid)
-                                if late in ("approved", "rejected"):
-                                    decision = late
-                                    break
-                                await asyncio.sleep(_APPROVAL_POLL_INTERVAL_S)
+                            decision = await _park_or_wait(
+                                client, tid, jira_key, send, thread_id, should_stop, on_park,
+                            )
+                            if decision == "stopped":
+                                _PENDING_LOCAL.pop(session_id, None)
+                                return
                             if decision == "approved":
                                 # Late approval — move back to In Progress before executing.
                                 await client.mark_in_progress(tid)

{devops_bot_sdk-1.6.91 → devops_bot_sdk-1.6.93}/sdk/run_auto.py

@@ -33,7 +33,9 @@ Commands:
     agentos-auto set-status …    change ticket status from one status to another, by
                                  key or in bulk by current status (alias: move)
     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 status          show whether the background loop is running / stop pending,
+                                 the queue, and tickets parked awaiting approval
+    agentos-auto skip KEY [...]  stop waiting on a parked ticket's approval (stays in Backlog)
     agentos-auto logs [-f]       print the loop log (~/.agentos/auto.log); -f to follow live
     agentos-auto update          upgrade the SDK to the latest version
 
@@ -59,6 +61,13 @@ A `ticket`/`story` command while a loop is running is QUEUED (~/.agentos/auto.qu
 and runs after the current work, first-asked first-run; `status` lists the queue
 and `stop` drops it.
 
+Approval timeouts never block the queue: a ticket with no WhatsApp reply in 15 min
+goes to Backlog and is PARKED (~/.agentos/auto.parked) while the loop moves on. The
+loop re-checks parked tickets between batches and while idle: a late approval
+queues the ticket first (its gate is not asked again), a rejection drops it, and
+after AGENTOS_APPROVAL_PARK_MAX_H hours (default 24) it is dropped. A targeted run
+stays alive while anything is parked; `skip KEY` stops waiting on one.
+
 Auto-update: on `run`/`resume`, the SDK checks for a newer version and upgrades
 itself (then re-runs on the new code) BEFORE detaching, so non-technical users
 never reinstall.
@@ -108,6 +117,13 @@ _WAKE_FILE = _AGENTOS_DIR / "auto.wake"
 _QUEUE_FILE = _AGENTOS_DIR / "auto.queue"
 _QUEUE_LOCK = _AGENTOS_DIR / "auto.queue.lock"
 _QUEUE_LOCK_STALE_S = 30.0
+# Tickets whose approval gate timed out (15 min, no WhatsApp reply). The loop no
+# longer waits on them — it moves on, re-checks each one between batches and while
+# idle, and queues it (gate already passed) once a late approval lands. Dropped on
+# rejection, on `skip`, or after _PARK_MAX_AGE_S. Lives as long as the loop does.
+_PARKED_FILE = _AGENTOS_DIR / "auto.parked"
+_PARK_MAX_AGE_S = float(os.getenv("AGENTOS_APPROVAL_PARK_MAX_H", "") or 24.0) * 3600
+_PARK_RECHECK_S = float(os.getenv("AGENTOS_PARK_RECHECK_S", "") or 60.0)
 
 
 def _stop_requested() -> bool:
@@ -200,11 +216,16 @@ def _write_queue(batches: list[dict]) -> None:
     os.replace(tmp, _QUEUE_FILE)  # atomic: a reader never sees half a file
 
 
-def _enqueue_batch(batch: dict) -> int | None:
+def _enqueue_batch(batch: dict, *, front: bool = False) -> int | None:
     """Append a batch; return its 1-based position, or None when every key in it
-    is already waiting in the queue (re-running the same command is a no-op)."""
+    is already waiting in the queue (re-running the same command is a no-op).
+    ``front`` puts it first and skips that check — a late-approved parked ticket,
+    which was asked for before anything now waiting."""
     with _queue_lock():
         queue = _read_queue()
+        if front:
+            _write_queue([batch, *queue])
+            return 1
         if batch.get("keys"):
             # Same key with a DIFFERENT --agent is a different request, not a repeat.
             pending = {k for b in queue for k in (b.get("keys") or [])
@@ -259,9 +280,144 @@ def _batch_payload(batch: dict, workspace_root: str | None) -> dict:
         payload["agent_only"] = True
     if batch.get("agent_id"):
         payload["agent_override"] = batch["agent_id"]
+    if batch.get("approved_ids"):
+        payload["approved_ids"] = list(batch["approved_ids"])
     return payload
 
 
+def _read_parked() -> list[dict]:
+    try:
+        data = json.loads(_PARKED_FILE.read_text())
+    except (FileNotFoundError, ValueError, TypeError):
+        return []
+    return [p for p in data if isinstance(p, dict)] if isinstance(data, list) else []
+
+
+def _write_parked(entries: list[dict]) -> None:
+    if not entries:
+        try:
+            _PARKED_FILE.unlink()
+        except FileNotFoundError:
+            pass
+        return
+    _AGENTOS_DIR.mkdir(parents=True, exist_ok=True)
+    tmp = _PARKED_FILE.with_suffix(".tmp")
+    tmp.write_text(json.dumps(entries))
+    os.replace(tmp, _PARKED_FILE)
+
+
+def _park(entry: dict, payload: dict) -> None:
+    """Record a ticket whose approval timed out, with what is needed to re-run it
+    the way it was asked for (same workspace, agent and story-only mode)."""
+    import time as _t
+
+    tid = str(entry.get("task_id") or "")
+    if not tid:
+        return
+    with _queue_lock():  # `skip` edits this file from another process
+        kept = [p for p in _read_parked() if p.get("task_id") != tid]
+        kept.append({
+            "task_id": tid,
+            "jira_key": str(entry.get("jira_key") or ""),
+            "parked_at": _t.time(),
+            "workspace_root": payload.get("workspace_root") or "",
+            "agent_id": payload.get("agent_override") or "",
+            "stories_only": bool(payload.get("stories_only")),
+        })
+        _write_parked(kept)
+    print(f"⏸ parked {entry.get('jira_key') or tid} — waiting for approval; moving on")
+
+
+def _unpark(ref: str) -> dict | None:
+    """Drop the parked ticket whose Jira key or id is ``ref``; return it."""
+    ref = ref.strip().upper()
+    with _queue_lock():
+        entries = _read_parked()
+        hit = next((p for p in entries
+                    if ref in (str(p.get("jira_key") or "").upper(),
+                               str(p.get("task_id")).upper())), None)
+        if hit is not None:
+            _write_parked([p for p in entries if p is not hit])
+    return hit
+
+
+def _describe_parked(p: dict) -> str:
+    import time as _t
+
+    mins = int((_t.time() - float(p.get("parked_at") or 0)) // 60)
+    age = f"{mins // 60}h{mins % 60:02d}m" if mins >= 60 else f"{mins}m"
+    return f"{p.get('jira_key') or p.get('task_id')} (waiting {age})"
+
+
+def _release_parked(client) -> int:
+    """Act on parked tickets' late decisions. Returns how many were queued to run.
+
+    approved → queued FIRST, flagged so its gate is not asked again;
+    rejected → dropped (stays in Backlog); older than _PARK_MAX_AGE_S → dropped
+    with an activity note (stays in Backlog). Pending ones stay parked.
+    """
+    import time as _t
+
+    entries = _read_parked()
+    if not entries:
+        return 0
+
+    async def _check() -> list[tuple[dict, str]]:
+        out = []
+        for p in entries:
+            if _t.time() - float(p.get("parked_at") or 0) > _PARK_MAX_AGE_S:
+                out.append((p, "expired"))
+                continue
+            try:
+                out.append((p, await client.approval_status(p["task_id"])))
+            except Exception:  # noqa: BLE001 — unreadable = still pending
+                out.append((p, "pending"))
+        return out
+
+    async def _expire(p: dict) -> None:
+        hours = int(_PARK_MAX_AGE_S // 3600)
+        try:
+            await client.log_activity(
+                f"Task {p['task_id']}: no approval within {hours}h of parking — "
+                "dropped; left in Backlog (move it to To Do to try again)",
+                task_id=p["task_id"], immediate=True)
+        except Exception:  # noqa: BLE001
+            pass
+
+    try:
+        decisions = asyncio.run(_check())
+    except Exception as exc:  # noqa: BLE001 — a blip leaves everything parked
+        print(f"note: could not check parked approvals ({exc})")
+        return 0
+
+    queued = 0
+    for p, status in decisions:
+        if status not in ("approved", "rejected", "expired"):
+            continue
+        _unpark(p["task_id"])
+        label = p.get("jira_key") or p["task_id"]
+        if status == "rejected":
+            print(f"✗ {label}: rejected — left in Backlog")
+        elif status == "expired":
+            print(f"✗ {label}: no approval within {int(_PARK_MAX_AGE_S // 3600)}h — "
+                  "dropped, left in Backlog")
+            with contextlib.suppress(Exception):
+                asyncio.run(_expire(p))
+        elif p.get("jira_key"):
+            _enqueue_batch({"keys": [p["jira_key"]], "approved_ids": [p["task_id"]],
+                            "workspace_root": p.get("workspace_root") or None,
+                            "agent_id": p.get("agent_id") or "",
+                            "stories_only": bool(p.get("stories_only"))}, front=True)
+            print(f"✓ {label}: late approval — queued to run next")
+            queued += 1
+        else:
+            # No Jira key to target it by: send it back to To Do for the next fetch.
+            with contextlib.suppress(Exception):
+                asyncio.run(client.move_to_todo(p["task_id"]))
+            print(f"✓ {label}: late approval — moved to To Do")
+    return queued
+
+
 def _write_current(task_id: str) -> None:
     try:
         _AGENTOS_DIR.mkdir(parents=True, exist_ok=True)
@@ -1549,22 +1705,33 @@ def _run_loop(workspace_root: str | None, only_keys: list[str] | None = None,
     _clear_stop()  # a fresh run/resume clears any stale stop flag
     _clear_wake()  # ditto for a wake left behind by an earlier loop
     _clear_backlogged()  # session-scoped: only track Backlog moves from THIS run
+    _write_parked([])  # ditto: a parked ticket is watched only by the loop that parked it
     register_status_observer(_track_status)  # keep the run's Backlog set current
     base_payload = payload
     try:
         import time as _t
+        # A targeted run waiting only on parked approvals has nothing to re-run; it
+        # just re-checks them (below), so the handler is skipped on those passes.
+        run_handler = True
+        last_wait = None
         while True:
-            asyncio.run(
-                handlers.handle_orchestrate_auto_local_run(
-                    client, payload, _send, should_stop=_stop_requested,
+            if run_handler:
+                asyncio.run(
+                    handlers.handle_orchestrate_auto_local_run(
+                        client, payload, _send, should_stop=_stop_requested,
+                        # Parked with THIS batch's settings (bound, not late-bound).
+                        on_park=lambda entry, _p=payload: _park(entry, _p),
+                    )
                 )
-            )
-            if _stop_requested():
-                break
+                if _stop_requested():
+                    break
+            run_handler = True
+            # A late approval puts its ticket at the head of the queue.
+            _release_parked(client)
             # Batches queued by `ticket`/`story` while we were busy run next, in
             # the order they were asked for.
             nxt = _dequeue_batch()
-            if nxt is None and not continuous:
+            if nxt is None and not continuous and not _read_parked():
                 # About to exit. Drop our PID record FIRST, then look once more: a
                 # command that queued a batch just now either sees us gone (and runs
                 # the queue itself) or its batch is found here — never neither.
@@ -1581,21 +1748,39 @@ def _run_loop(workspace_root: str | None, only_keys: list[str] | None = None,
                 payload = _batch_payload(nxt, workspace_root)
                 print(f"▶ next queued batch — {_describe_batch(nxt)}")
                 continue
-            if payload is not base_payload:
+            if continuous and payload is not base_payload:
                 # Queue drained; a continuous run goes straight back to To Do.
                 payload = base_payload
                 continue
             # Idle between batches, polling the stop flag so `agentos-auto stop`
             # stays responsive; then loop back and the handler re-fetches To Do.
-            print(f"… idle — watching for new To Do tickets "
-                  f"(re-checking every {int(_idle_refetch_s)}s; `agentos-auto stop` to end)")
+            parked = _read_parked()
+            waiting = (f"; {len(parked)} parked awaiting approval: "
+                       + ", ".join(_describe_parked(p) for p in parked)) if parked else ""
+            if continuous:
+                _idle_s = _idle_refetch_s
+                print(f"… idle — watching for new To Do tickets "
+                      f"(re-checking every {int(_idle_s)}s{waiting}; "
+                      f"`agentos-auto stop` to end)")
+            else:
+                _idle_s = _PARK_RECHECK_S
+                if waiting != last_wait:  # say it once per change, not every minute
+                    print(f"… waiting{waiting} (re-checking every {int(_idle_s)}s; "
+                          f"`agentos-auto skip KEY` drops one, `agentos-auto stop` ends)")
+                last_wait = waiting
             _waited = 0.0
-            while (_waited < _idle_refetch_s and not _stop_requested()
+            while (_waited < _idle_s and not _stop_requested()
                    and not _wake_requested()):
-                _t.sleep(min(2.0, _idle_refetch_s - _waited))
+                _t.sleep(min(2.0, _idle_s - _waited))
                 _waited += 2.0
             if _stop_requested():
                 break
+            if not continuous:
+                # Nothing to re-fetch: go back up, re-check parked, take the queue.
+                # The wake (a newly queued batch) is consumed there via the dequeue.
+                _clear_wake()
+                run_handler = False
+                continue
             if _wake_requested():
                 # Consume the signal BEFORE re-fetching, so a ticket created while
                 # this batch runs still leaves a wake behind for the next idle.
@@ -1620,6 +1805,7 @@ def _run_loop(workspace_root: str | None, only_keys: list[str] | None = None,
                 pass
         _clear_current()
         _clear_backlogged()
+        _write_parked([])
 
 
 def main() -> None:
@@ -1731,6 +1917,9 @@ def main() -> None:
         pid = _daemon_running()
         cur = _read_current()
         backlogged = _read_backlogged()  # tickets THIS run parked in Backlog
+        # Parked approvals too — normally already in `backlogged`, unless the move
+        # to Backlog itself failed.
+        backlogged |= {str(p.get("task_id")) for p in _read_parked() if p.get("task_id")}
 
         # 1. Kill the loop's ENTIRE process group first (daemon + any child
         #    `claude` it spawned) so nothing keeps mutating the ticket. The daemon
@@ -1766,7 +1955,7 @@ def main() -> None:
                 print(f"warning: could not restore tickets to To Do ({exc})")
 
         # 3. Clean up state files.
-        for f in (_PID_FILE, _CURRENT_FILE, _BACKLOGGED_FILE, _WAKE_FILE):
+        for f in (_PID_FILE, _CURRENT_FILE, _BACKLOGGED_FILE, _WAKE_FILE, _PARKED_FILE):
             try:
                 f.unlink()
             except FileNotFoundError:
@@ -1788,9 +1977,28 @@ def main() -> None:
             print(f"queued batches: {len(queue)}")
             for i, batch in enumerate(queue, 1):
                 print(f"  {i}. {_describe_batch(batch)}")
+        parked = _read_parked()
+        if parked:
+            print(f"parked awaiting approval: {len(parked)} (they run when approved; "
+                  "`agentos-auto skip KEY` drops one)")
+            for p in parked:
+                print(f"  · {_describe_parked(p)}")
         print("stop pending: yes" if _stop_requested() else "stop pending: no")
         return
 
+    if cmd == "skip":
+        # Stop waiting on a parked ticket's approval, without stopping the loop.
+        refs = [a for a in argv[1:] if not a.startswith("-")]
+        if not refs:
+            print("usage: agentos-auto skip KEY [KEY …]   (see `agentos-auto status`)")
+            return
+        for ref in refs:
+            hit = _unpark(ref)
+            print(f"dropped {hit.get('jira_key') or hit['task_id']} — no longer waiting "
+                  "for its approval; it stays in Backlog" if hit
+                  else f"{ref}: not parked (nothing to skip)")
+        return
+
     if cmd == "logs":
         _show_logs(argv)
         return