devops-bot-sdk 1.6.24__tar.gz → 1.6.25__tar.gz

{devops_bot_sdk-1.6.24 → devops_bot_sdk-1.6.25}/PKG-INFO

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

{devops_bot_sdk-1.6.24 → devops_bot_sdk-1.6.25}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.6.24 → devops_bot_sdk-1.6.25}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -130,8 +130,11 @@ tests/test_graph_recon.py
 tests/test_graphify_build.py
 tests/test_graphify_hook_install.py
 tests/test_health.py
+tests/test_intake_plan_review.py
 tests/test_otp_login.py
 tests/test_phase_timer.py
+tests/test_plan_new_command.py
+tests/test_plan_run_activity.py
 tests/test_recon_session_isolation.py
 tests/test_run_auto_agent_only.py
 tests/test_run_outputs.py
@@ -139,6 +142,7 @@ tests/test_schedule_api.py
 tests/test_scheduler.py
 tests/test_service_token_warning.py
 tests/test_task_file_and_plan_run.py
+tests/test_task_file_format_doc.py
 tests/test_ticket_fields.py
 tests/test_ticket_run_resolve_by_id.py
 tests/test_ticket_speed_fixes.py

{devops_bot_sdk-1.6.24 → devops_bot_sdk-1.6.25}/sdk/__init__.py

@@ -1,6 +1,6 @@
 """AgentOS Desktop SDK — thin HTTPS/SSE client for the Electron app.
 
-Version: 1.6.24
+Version: 1.6.25
 
 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.24"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
+__version__ = "1.6.25"   # 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.24 → devops_bot_sdk-1.6.25}/sdk/client.py

@@ -896,17 +896,11 @@ class BackendClient:
             return "pending"
 
     async def github_token_record(self) -> dict | None:
-        """GET /ml-api/github/token → the caller's WHOLE GitHub link record.
+        """GET /ml-api/github/token → the full record for the caller's GitHub link.
 
-        Returns the ``data`` object — ``{id, userId, githubId, username,
-        accessToken, scope, …}`` — or None when this user has no GitHub link, the
-        token is rejected, or the backend is unreachable. Inherently per-user: the
-        ML backend resolves WHICH link to return from the ``co_`` token, so there
-        is no list-all form.
-
-        ``github_token()`` below is the accessToken-only view of this. The daily
-        PR-ingest cron (``sdk.github_ingest``) needs ``username`` too, which is why
-        the full record is exposed. Best-effort — never raises.
+        ``{id, userId, githubId, username, accessToken, scope, createdAt, updatedAt}``
+        or None when the user has no GitHub link, the token is rejected, or the
+        backend is unreachable. Best-effort: never raises.
         """
         from sdk.config import BE_DEFAULT_URL
 
@@ -923,7 +917,7 @@ class BackendClient:
             if resp.status_code >= 400:
                 return None
             return (resp.json() or {}).get("data") or None
-        except Exception:  # noqa: BLE001
+        except Exception:
             return None
 
     async def github_token(self) -> str | None:
@@ -933,121 +927,52 @@ class BackendClient:
         endpoint lives on the ML backend (devopsbot-be), authorised by the same
         co_ token. Best-effort: returns None on any failure so a run without a
         connected GitHub account still proceeds (clone/PR steps just won't auth).
-
-        Memoized for _GITHUB_TOKEN_TTL_S. The auto-loop asks for this once per
-        ticket and again inside epic/story handling, so a long queue made the same
-        round-trip dozens of times for a value that does not change between
-        tickets. A TTL rather than a permanent cache so a token refreshed on the
-        backend is picked up without restarting the daemon; a failed fetch is not
-        cached, so a transient outage cannot pin None for the whole window.
         """
-        import time as _time
-
-        now = _time.monotonic()
-        cached = _GITHUB_TOKEN_CACHE.get(self._token)
-        if cached and now < cached[1]:
-            return cached[0]
         record = await self.github_token_record()
-        token = (record or {}).get("accessToken") or None
-        if token:
-            _GITHUB_TOKEN_CACHE[self._token] = (token, now + _GITHUB_TOKEN_TTL_S)
-        return token
+        return (record or {}).get("accessToken") or None
 
-    async def ingest_github_prs(
-        self,
-        *,
-        github_username: str,
-        github_access_token: str,
-        since: str | None = None,
-        user_id: str = "",
-    ) -> dict | None:
-        """POST /api/v1/github/prs — queue PR ingestion for THIS user on the backend.
-
-        This is the daily GitHub ingestion trigger. It runs on the AI backend
-        (``devopsbot-ai.apiswagger.co.uk`` — ``self._url``, the same base every other
-        ``/api/v1`` call uses), NOT the ML gateway: the backend owns the LLM
-        summarise, the downstream daily-summary forward, and the Qdrant upsert.
-        The SDK only decides WHEN, because only this machine knows this user's
-        schedule and its own last-success watermark.
-
-        ``since`` is an ISO date (``YYYY-MM-DD``) → the backend's
-        ``GetUserPRsRequest.date_from``. Omitted means "today", which is what a
-        never-missed daily run wants; ``sdk.github_ingest`` sends the catch-up
-        watermark instead so a machine that was off does not silently lose days.
-
-        The credentials are sent in the body because that is what the endpoint
-        accepts today. The ``Authorization: co_`` header goes with every request
-        regardless, so once the backend resolves the GitHub link server-side from
-        that token (see docs/GITHUB_SCHEDULING_SDK_MIGRATION.md §3 step 1) it can
-        ignore the body fields without breaking this client.
-
-        Returns the response JSON (``{job_id, …}``) or None on any failure —
-        never raises into the cron.
+    async def ingest_github_prs(self, since: str | None = None) -> dict:
+        """POST {AI}/api/v1/github/prs — trigger this user's daily PR ingestion.
+
+        The backend resolves the caller's GitHub link server-side from the co_
+        token in ``Authorization`` (see ``docs/GITHUB_SCHEDULING_SDK_MIGRATION.md``);
+        ``githubUsername``/``githubAccessToken`` below are placeholders kept only
+        for backends that predate that resolution and are otherwise ignored.
+        ``since`` (ISO-8601 date) scopes the fetch — omit for "today".
+
+        Returns the backend's ``{status, job_id, status_url, ...}`` envelope.
+        Raises BackendUnreachable / HTTP errors — the github_ingest cron catches
+        and logs these itself rather than treating them as success.
         """
-        payload = [{
-            "userId": user_id or self._user_id_from_token(),
-            "githubUsername": github_username,
-            "githubAccessToken": github_access_token,
-            "apiTokenHash": self._token,   # downstream daily-summary Authorization
+        body = [{
+            "userId": self._user_id_from_token(),
+            "githubUsername": "",
+            "githubAccessToken": "",
+            "apiTokenHash": self._token,
+            "date_from": since,
         }]
-        if since:
-            payload[0]["date_from"] = since
-        self.last_ingest_error = {}
-        try:
-            async with httpx.AsyncClient(timeout=60.0) as client:
-                resp = await client.post(
-                    self._url("/api/v1/github/prs"), json=payload, headers=self._headers,
-                )
-            if resp.status_code >= 400:
-                body = resp.text[:500]
-                logger.warning("client.ingest_github_prs failed status=%s body=%s",
-                               resp.status_code, body[:200])
-                self.last_ingest_error = {
-                    "status": resp.status_code,
-                    "body": body,
-                    "retryable": is_retryable_backend_error(resp.status_code, body),
-                }
-                return None
-            return resp.json()
-        except Exception as exc:  # noqa: BLE001
-            logger.warning("client.ingest_github_prs error err=%s", exc)
-            # A transport failure (timeout, connection reset, DNS blip) is as
-            # retryable as an exhausted pool — the backend may simply be busy.
-            self.last_ingest_error = {"status": 0, "body": str(exc)[:500], "retryable": True}
-            return None
-
-    async def get_task_status(self, task_id: str) -> str | None:
-        """GET {BE}/tasks-ml/{id} → the ticket's CURRENT board status, or None.
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            resp = await client.post(
+                self._url("/api/v1/github/prs"), json=body, headers=self._headers,
+            )
+        _check_status(resp.status_code, self._url("/api/v1/github/prs"))
+        return resp.json()
 
-        The authority on "did this ticket actually move". The local run finalizes
-        server-side and then reads back a session status, but a session reporting
-        ``completed`` is not evidence that the BOARD transitioned — the two are
-        separate systems and the Jira-side transition can lag or fail on its own.
-        Reading the ticket is the only way to tell them apart.
+    async def report_vps_health(self, payload: dict) -> dict:
+        """PATCH {AI}/api/v1/vps/health — heartbeat this machine's resource usage.
 
-        Returns None when the ticket cannot be read (network, auth, 404). Callers
-        must treat None as "unknown", NOT as "not Done" — forcing a status on an
-        unreadable ticket would be guessing.
+        Feeds the backend's ``contabo_allocation`` row (VPS health shown in chat /
+        activity reports) — a live GET of the same path answers on-demand checks,
+        this PATCH is what keeps that data from going stale. Raises on failure
+        (BackendUnreachable / HTTP error); the vps_health cron logs and continues
+        rather than crashing the loop.
         """
-        from sdk.config import BE_DEFAULT_URL
-
-        url = f"{BE_DEFAULT_URL.rstrip('/')}/tasks-ml/{task_id}"
-        headers = {**self._headers, "accept": "*/*", "developer-name": "null", "product": ""}
-        try:
-            async with httpx.AsyncClient(timeout=20.0) as client:
-                resp = await client.get(url, headers=headers)
-            if resp.status_code >= 400:
-                logger.warning("client.get_task_status failed task=%s status=%s",
-                               task_id, resp.status_code)
-                return None
-            rec = (resp.json() or {}).get("data") or {}
-            if isinstance(rec, dict):
-                rec = rec.get("record") or rec
-            status = str(rec.get("status") or "").strip()
-            return status or None
-        except Exception as exc:  # noqa: BLE001
-            logger.warning("client.get_task_status error task=%s err=%s", task_id, exc)
-            return None
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            resp = await client.request(
+                "PATCH", self._url("/api/v1/vps/health"), json=payload, headers=self._headers,
+            )
+        _check_status(resp.status_code, self._url("/api/v1/vps/health"))
+        return resp.json()
 
     async def move_to_backlog(self, task_id: str) -> bool:
         """PUT {BE}/tasks-ml/{id} status=backlog (best-effort).

devops_bot_sdk-1.6.25/sdk/github_ingest.py

@@ -0,0 +1,161 @@
+"""Per-machine daily GitHub PR ingestion trigger.
+
+See ``docs/GITHUB_SCHEDULING_SDK_MIGRATION.md`` (Option A) in ``devops-bot-ai``:
+the SDK owns the trigger only — one authenticated POST a day to
+``/api/v1/github/prs``; the backend keeps the LLM summarise + SQL + Qdrant work.
+
+Slot-based, not interval-based: ticks every 15 min and fires once the UTC clock
+has passed ``AGENTOS_GITHUB_INGEST_AT`` (default ``13:30``) *and* no success is
+recorded for today. A machine that's asleep at the slot catches up on wake
+instead of silently losing that day's run (a central Celery-beat schedule fires
+regardless of machine state; a per-VPS cron does not — see the doc's §6).
+
+Catch-up watermark: ``~/.agentos/github_ingest.json`` holds ``last_success_at``.
+The request sends ``since = last_success_at`` (capped by
+``AGENTOS_GITHUB_INGEST_LOOKBACK_DAYS``, default 7), never a bare "today". A
+failed run does NOT advance the watermark, so the window is re-covered next tick.
+
+Disable with ``AGENTOS_GITHUB_INGEST=0``.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+from datetime import date, datetime, timedelta, timezone
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+_ENABLED_ENV   = "AGENTOS_GITHUB_INGEST"
+_AT_ENV        = "AGENTOS_GITHUB_INGEST_AT"
+_LOOKBACK_ENV  = "AGENTOS_GITHUB_INGEST_LOOKBACK_DAYS"
+_DEFAULT_AT       = "13:30"  # UTC — the old beat slot (18:30 PKT)
+_DEFAULT_LOOKBACK = 7
+_TICK_SECONDS     = 15 * 60  # check the slot every 15 min
+
+_STATE_FILE = Path.home() / ".agentos" / "github_ingest.json"
+
+
+def enabled() -> bool:
+    return os.environ.get(_ENABLED_ENV, "1").strip() not in ("0", "false", "False")
+
+
+def _target_time() -> tuple[int, int]:
+    raw = os.environ.get(_AT_ENV, "") or _DEFAULT_AT
+    try:
+        hh, mm = raw.split(":", 1)
+        return int(hh) % 24, int(mm) % 60
+    except (ValueError, TypeError):
+        return 13, 30
+
+
+def lookback_days() -> int:
+    try:
+        return max(1, int(os.environ.get(_LOOKBACK_ENV, "") or _DEFAULT_LOOKBACK))
+    except ValueError:
+        return _DEFAULT_LOOKBACK
+
+
+def _load_state() -> dict:
+    try:
+        return json.loads(_STATE_FILE.read_text(encoding="utf-8"))
+    except Exception:  # noqa: BLE001 — first run, corrupt file, etc.
+        return {}
+
+
+def _save_state(state: dict) -> None:
+    try:
+        _STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
+        _STATE_FILE.write_text(json.dumps(state), encoding="utf-8")
+    except Exception as exc:  # noqa: BLE001 — a failed write just costs one retry
+        logger.warning("github_ingest.state_write_failed: %s", exc)
+
+
+def _since(state: dict) -> str:
+    """The ``date_from`` to send — last success, capped, never a bare 'today'."""
+    last = state.get("last_success_at")
+    floor = date.today() - timedelta(days=lookback_days())
+    if not last:
+        return floor.isoformat()
+    try:
+        last_date = datetime.fromisoformat(last).date()
+    except ValueError:
+        return floor.isoformat()
+    return max(last_date, floor).isoformat()
+
+
+def _due_now(state: dict, now: datetime) -> bool:
+    last = state.get("last_success_at")
+    if last:
+        try:
+            if datetime.fromisoformat(last).date() >= now.date():
+                return False  # already succeeded today
+        except ValueError:
+            pass
+    hh, mm = _target_time()
+    return (now.hour, now.minute) >= (hh, mm)
+
+
+async def run_once(force: bool = False) -> dict:
+    """Trigger ingestion now (unconditionally if ``force``). Updates the watermark
+    on success only. Never raises — the outcome is always returned, never thrown.
+    """
+    from sdk.client import BackendClient
+
+    state = _load_state()
+    if not force and not _due_now(state, datetime.now(timezone.utc)):
+        return {"ok": True, "skipped": "not_due", **state}
+
+    since = _since(state)
+    try:
+        client = BackendClient.from_config()
+        result = await client.ingest_github_prs(since=since)
+        # BackendClient._check_status only raises on 401/426/5xx — a 4xx business
+        # error (no linked GitHub account, validation failure, ...) comes back as
+        # a normal JSON body with no exception. Only a genuine accepted-job
+        # response advances the watermark; anything else is a failure that must
+        # be retried, not silently marked done.
+        if str(result.get("status", "")).lower() != "accepted" or not result.get("job_id"):
+            raise RuntimeError(result.get("detail") or f"unexpected response: {result}")
+        state["last_success_at"] = datetime.now(timezone.utc).date().isoformat()
+        state["last_outcome"] = {"ok": True, "since": since, "result": result}
+        _save_state(state)
+        logger.info("github_ingest.triggered since=%s", since)
+        return state["last_outcome"]
+    except Exception as exc:  # noqa: BLE001 — failure must not advance the watermark
+        outcome = {"ok": False, "since": since, "error": str(exc)}
+        state["last_outcome"] = outcome
+        _save_state(state)
+        logger.warning("github_ingest.failed: %s", exc)
+        return outcome
+
+
+def status() -> dict:
+    """Config + watermark + last outcome — the ``GET /api/ui/github-ingest`` body."""
+    hh, mm = _target_time()
+    state = _load_state()
+    return {
+        "enabled": enabled(),
+        "at_utc": f"{hh:02d}:{mm:02d}",
+        "lookback_days": lookback_days(),
+        "last_success_at": state.get("last_success_at"),
+        "last_outcome": state.get("last_outcome"),
+    }
+
+
+async def run_forever() -> None:
+    while True:
+        try:
+            await run_once()
+        except Exception as exc:  # noqa: BLE001 — the tick loop must never die
+            logger.warning("github_ingest.tick_failed: %s", exc)
+        await asyncio.sleep(_TICK_SECONDS)
+
+
+def start() -> "asyncio.Task | None":
+    if not enabled():
+        logger.info("github_ingest.disabled")
+        return None
+    return asyncio.create_task(run_forever(), name="github-ingest-cron")

{devops_bot_sdk-1.6.24 → devops_bot_sdk-1.6.25}/sdk/intake.py

@@ -115,8 +115,124 @@ async def finalize(conversation_id: str, *, requirements: dict[str, Any],
     )
 
 
+async def build_plan(conversation_id: str, *, requirements: dict[str, Any],
+                     history: list[dict[str, Any]] | None = None,
+                     plan: dict[str, Any] | None = None,
+                     feedback: str | None = None) -> dict[str, Any]:
+    """Draft — or revise — the plan WITHOUT creating anything.
+
+    The step `finalize` skips. `finalize` builds a plan and commits it in one
+    call, which is right for "just make the tickets" but leaves no way to read
+    the plan first; the control panel has always had the review step and the CLI
+    had not. Pass BOTH `plan` and `feedback` to revise: the revise prompt requires
+    that anything the feedback does not mention comes back unchanged.
+    """
+    payload: dict[str, Any] = {
+        "conversation_id": conversation_id,
+        "requirements": requirements,
+        "history": history or [],
+    }
+    if plan is not None:
+        payload["plan"] = plan
+    if feedback:
+        payload["feedback"] = feedback
+    return await _post(
+        f"/api/v1/tickets/intake/{conversation_id}/plan",
+        payload, _FINALIZE_TIMEOUT_S,
+    )
+
+
+async def create(conversation_id: str, *, plan: dict[str, Any],
+                 product_id: str, requirements: dict[str, Any] | None = None,
+                 pv_id: str | None = None,
+                 project: dict[str, Any] | None = None,
+                 assignee_email: str | None = None,
+                 autorun: bool = True) -> dict[str, Any]:
+    """Commit a REVIEWED plan — the plan is sent back rather than rebuilt.
+
+    That is deliberate and matches the panel: what a person approved on screen is
+    exactly what gets created, edits included. Rebuilding it here would quietly
+    create something the reviewer never saw.
+    """
+    payload: dict[str, Any] = {
+        "conversation_id": conversation_id,
+        "plan": plan,
+        "requirements": requirements or {},
+        "product_id": product_id,
+        "autorun": autorun,
+    }
+    if pv_id:
+        payload["pv_id"] = pv_id
+    if project:
+        payload["project"] = project
+    if assignee_email:
+        payload["assignee_email"] = assignee_email
+    return await _post(
+        f"/api/v1/tickets/intake/{conversation_id}/create",
+        payload, _FINALIZE_TIMEOUT_S,
+    )
+
+
 # ── Terminal loop ─────────────────────────────────────────────────────────
 
+def render_plan(plan: dict[str, Any]) -> str:
+    """The plan as text, laid out the way the User Story format reads.
+
+    What the plan step returns is the SHAPE of the work — per epic an overview,
+    scope in/out, dependencies and acceptance criteria; per story a title, a
+    summary and points. The full four-section `## User Story` body is written at
+    CREATE time by the backend's generator (which injects the same
+    `USER_STORY_FORMAT` this SDK ships). So this renders the review copy under the
+    same headings, and says where the rest arrives — rather than printing a raw
+    dict and calling it a user story.
+    """
+    out: list[str] = []
+    title = str(plan.get("title") or "(untitled plan)")
+    out.append(f"# {title}")
+    if plan.get("summary"):
+        out.append(f"\n{plan['summary']}")
+
+    for dept in plan.get("departments") or []:
+        out.append(f"\n\n── Department: {dept.get('tag') or '—'} ──")
+        if dept.get("objective"):
+            out.append(f"Objective: {dept['objective']}")
+        for i, epic in enumerate(dept.get("epics") or [], 1):
+            out.append(f"\nEPIC {i}: {epic.get('title') or '—'}")
+            if epic.get("overview"):
+                out.append(f"  {epic['overview']}")
+            for label, key in (("Scope IN", "scope_in"), ("Scope OUT", "scope_out"),
+                               ("Dependencies", "dependencies")):
+                vals = epic.get(key) or []
+                if vals:
+                    out.append(f"  {label}: " + "; ".join(str(v) for v in vals))
+            crit = epic.get("acceptance_criteria") or []
+            if crit:
+                out.append("  ## Acceptance Criteria")
+                out.extend(f"    - {c}" for c in crit)
+            stories = epic.get("stories") or []
+            out.append(f"  ## User Stories ({len(stories)})")
+            for j, st in enumerate(stories, 1):
+                pts = st.get("points")
+                out.append(f"    {i}.{j} {st.get('title') or st.get('summary') or '—'}"
+                           + (f"  [{pts} pts]" if pts else ""))
+                if st.get("summary") and st.get("title"):
+                    out.append(f"        {st['summary']}")
+    out.append("\n\nEach story's full `## User Story / ## Acceptance Criteria / "
+               "## Notes & Constraints / ## Definition of Done` body is written when "
+               "the tickets are created.")
+    return "\n".join(out)
+
+
+def _plan_counts(plan: dict[str, Any]) -> tuple[int, int]:
+    """(epics, stories) across every department in a plan."""
+    epics = stories = 0
+    for dept in plan.get("departments") or []:
+        eps = dept.get("epics") or []
+        epics += len(eps)
+        stories += sum(len(e.get("stories") or []) for e in eps)
+    return epics, stories
+
+
 def _print_status(requirements: dict[str, Any], missing: list[str]) -> None:
     """Show what is known and what is still needed.
 
@@ -156,10 +272,16 @@ def chat_cli(argv: list[str]) -> None:
     autorun = "--no-autorun" not in argv
 
     print("agentos chat — describe the work you want done.")
-    print("  Answer the questions; type 'done' to build the ticket, 'quit' to abandon.\n")
+    print("  Answer the questions, then:")
+    print("    plan              build the plan and read it (creates nothing)")
+    print("    revise <change>   adjust the plan")
+    print("    show              re-print the current plan")
+    print("    create / done     create the tickets")
+    print("    quit              abandon; nothing is created\n")
 
     history: list[dict[str, Any]] = []
     requirements: dict[str, Any] = {}
+    plan: dict[str, Any] | None = None
     conversation_id: str | None = None
     index = 0
 
@@ -177,7 +299,46 @@ def chat_cli(argv: list[str]) -> None:
                 print("abandoned — nothing was created.")
                 return
 
-            if message.lower() == "done":
+            # ── plan / revise / show: read the plan BEFORE anything is created ──
+            verb, _, rest = message.partition(" ")
+            if verb.lower() in ("plan", "revise", "show"):
+                if verb.lower() == "show":
+                    if not plan:
+                        print("  no plan yet — type 'plan' to build one.")
+                    else:
+                        print("\n" + render_plan(plan) + "\n")
+                    continue
+                missing = [k for k, v in requirements.items() if not str(v or "").strip()]
+                if not requirements or missing:
+                    print(f"  not yet — still needed: "
+                          f"{', '.join(missing) or 'everything'}")
+                    continue
+                if verb.lower() == "revise" and not plan:
+                    print("  nothing to revise yet — type 'plan' first.")
+                    continue
+                if verb.lower() == "revise" and not rest.strip():
+                    print('  say what to change, e.g. revise split the first epic in two')
+                    continue
+                print("\n  building the plan … (nothing is created by this)")
+                try:
+                    res = await build_plan(
+                        conversation_id or "", requirements=requirements,
+                        history=history,
+                        plan=plan if verb.lower() == "revise" else None,
+                        feedback=rest.strip() if verb.lower() == "revise" else None,
+                    )
+                except IntakeError as exc:
+                    print(f"  ✗ {exc}")
+                    continue
+                plan = res.get("plan") or plan
+                epics, stories = _plan_counts(plan or {})
+                print("\n" + render_plan(plan or {}))
+                print(f"\n  {epics} epic(s), {stories} story(ies) — nothing created yet.")
+                print("  'revise <what to change>' to adjust · 'create' to make the "
+                      "tickets · 'quit' to abandon.\n")
+                continue
+
+            if message.lower() in ("done", "create"):
                 missing = [k for k, v in requirements.items() if not str(v or "").strip()]
                 if not requirements or missing:
                     print(f"  not yet — still needed: "
@@ -187,13 +348,26 @@ def chat_cli(argv: list[str]) -> None:
                     print("  a product id is required to create tickets. Re-run with "
                           "`agentos chat --product-id <ID>`.")
                     return
-                print("\n  building the plan and creating tickets … (this takes a minute)")
                 try:
-                    result = await finalize(
-                        conversation_id or "", requirements=requirements,
-                        product_id=product_id, history=history, pv_id=pv_id,
-                        autorun=autorun,
-                    )
+                    if plan:
+                        # A reviewed plan is committed AS REVIEWED — sent back
+                        # rather than rebuilt, so what was on screen is what gets
+                        # created. Rebuilding here would create something the
+                        # reviewer never saw.
+                        print("\n  creating tickets from the reviewed plan …")
+                        result = await create(
+                            conversation_id or "", plan=plan, product_id=product_id,
+                            requirements=requirements, pv_id=pv_id, autorun=autorun,
+                        )
+                    else:
+                        print("\n  building the plan and creating tickets … "
+                              "(this takes a minute; type 'plan' first if you want "
+                              "to read it before it is committed)")
+                        result = await finalize(
+                            conversation_id or "", requirements=requirements,
+                            product_id=product_id, history=history, pv_id=pv_id,
+                            autorun=autorun,
+                        )
                 except IntakeError as exc:
                     print(f"  ✗ {exc}")
                     return