devops-bot-sdk 1.7.48__tar.gz → 1.7.50__tar.gz

{devops_bot_sdk-1.7.48 → devops_bot_sdk-1.7.50}/PKG-INFO

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

{devops_bot_sdk-1.7.48 → devops_bot_sdk-1.7.50}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.7.48 → devops_bot_sdk-1.7.50}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -210,6 +210,8 @@ tests/test_epic_session_isolation.py
 tests/test_estimator.py
 tests/test_fallback_cli.py
 tests/test_fallback_cli_upgrade.py
+tests/test_fallback_folder_changes.py
+tests/test_fallback_parity.py
 tests/test_fallback_rate_limit.py
 tests/test_faqs.py
 tests/test_firewall_open_on_update.py

{devops_bot_sdk-1.7.48 → devops_bot_sdk-1.7.50}/sdk/__init__.py

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

@@ -35,6 +35,15 @@
   "latest_pr": 183,
   "latest_date": "2026-10-28"
  },
+ {
+  "area": "AI fallback",
+  "changes_30d": 4,
+  "features_30d": 2,
+  "fixes_30d": 2,
+  "latest": "AI Draftsman fallback resumes, fails loudly when blocked, sees non-git edits",
+  "latest_pr": 192,
+  "latest_date": "2026-11-04"
+ },
  {
   "area": "Windows",
   "changes_30d": 4,
@@ -44,15 +53,6 @@
   "latest_pr": 165,
   "latest_date": "2026-10-24"
  },
- {
-  "area": "AI fallback",
-  "changes_30d": 3,
-  "features_30d": 2,
-  "fixes_30d": 1,
-  "latest": "continue a limit-hit ticket on the AI Draftsman CLI with its context",
-  "latest_pr": 164,
-  "latest_date": "2026-10-24"
- },
  {
   "area": "Agents",
   "changes_30d": 2,

{devops_bot_sdk-1.7.48 → devops_bot_sdk-1.7.50}/sdk/help_data/releases.json

@@ -1,4 +1,14 @@
 [
+ {
+  "pr": 192,
+  "date": "2026-11-04",
+  "merged_at": "2026-11-04T14:03:12+05:00",
+  "type": "Fix",
+  "area": "AI fallback",
+  "title": "AI Draftsman fallback resumes, fails loudly when blocked, sees non-git edits",
+  "version": "1.7.50",
+  "url": "https://github.com/consultancy-outfit/DevOpsBot-SDK/pull/192"
+ },
  {
   "pr": 191,
   "date": "2026-11-03",

devops_bot_sdk-1.7.50/sdk/help_data/snapshot.json

@@ -0,0 +1,17 @@
+[
+ {
+  "version": "1.7.50",
+  "commit": "4f370e5",
+  "pushed_at": "2026-11-04T14:03:12+05:00",
+  "generated_at": "2026-11-04T09:04:20+00:00",
+  "commands": 60,
+  "commands_invalid": 0,
+  "commands_undocumented": 0,
+  "panel_pages": 11,
+  "tests": 2624,
+  "prs_7d": 10,
+  "prs_30d": 44,
+  "features_30d": 13,
+  "fixes_30d": 19
+ }
+]

{devops_bot_sdk-1.7.48 → devops_bot_sdk-1.7.50}/sdk/ipc/handlers.py

@@ -3125,7 +3125,10 @@ async def _code_one_repo(
             and not result.get("auth_expired"):
         errored = not result.get("ok")
         # "did real work happen?" — actual Write/Edit count, not files merely read.
-        empty = result.get("ok") and _write_count == 0
+        # `ad` (the fallback CLI) streams no tool events, so _write_count stays
+        # 0 on it — its folder diff (files_changed) is the evidence there.
+        empty = (result.get("ok") and _write_count == 0
+                 and not result.get("files_changed"))
         if not (errored or empty):
             break
         repair += 1
@@ -3300,8 +3303,13 @@ async def _code_one_repo(
         # have errored out.
         if not result.get("ok"):
             issues.append(f"run errored: {(result.get('error') or 'failed')[:160]}")
-        elif _write_count == 0:
-            issues.append("task produced no files/deliverables")
+        elif _write_count == 0 and not result.get("files_changed"):
+            # Say what the agent itself reported: "produced no files" alone gave
+            # the operator nothing to act on (e.g. a fallback run that could not
+            # run the script needed to edit a binary .xlsx).
+            said = " ".join(str(result.get("result") or "").split())
+            issues.append("task produced no files/deliverables"
+                          + (f" — agent said: {said[-240:]}" if said else ""))
     if issues:
         await send(Envelope(
             type="step_update", thread_id=thread_id,
@@ -3556,7 +3564,10 @@ async def handle_pipeline_approve(
             type=Envelope.TYPE_ERROR, thread_id=thread_id,
             data={"code": "LOCAL_EXEC_INCOMPLETE", "message": err[:300], "task_id": task_id},
         ).model_dump())
-        return
+        # Tell the ticket loop too: it used to see None here, count the ticket as
+        # carried through, and print "✓ completed — 1/1" under a ticket it had
+        # just moved to Backlog.
+        return {"status": "incomplete", "task_id": task_id, "error": err[:300]}
 
     # Surface deliberate no-ops so a skipped repo is transparent, not invisible.
     if out_of_scope:
@@ -5817,6 +5828,11 @@ async def _run_one_task_steps(
                 send,
             )
 
+            # Ran, but non-compliant (no deliverable, no push/PR …): the handler
+            # already moved it to Backlog and said why — it was NOT carried through.
+            if isinstance(outcome, dict) and outcome.get("status") == "incomplete":
+                return "skipped"
+
             # ── Claude CLI auth expired ────────────────────────────────────
             # The runner's `claude` login lapsed. Waiting won't fix it, so we
             # PAUSE (not drain-to-Backlog): keep the ticket In Progress, alert

{devops_bot_sdk-1.7.48 → devops_bot_sdk-1.7.50}/sdk/local_exec.py

@@ -1077,19 +1077,46 @@ async def _run_claude_cli(
 # AD_API_KEY in the env. `agentos fallback status --verify` checks it against
 # the server.
 #
-# What it does NOT do: honour the PreToolUse approval guard, resume a Claude
-# session, or stream progress events. So a resumed run never falls back (the
-# prompt would be "continue" with no context behind it), and the permission
-# mode defaults to acceptEdits — file edits apply, but a shell command that is
-# not read-only is denied rather than run unguarded. Set
+# Sessions: an `ad` run's session id comes back as ``ad:<id>``, so every caller
+# that resumes a run (the repair loop, a usage-limit resume, recon follow-ups)
+# resumes it on `ad` with ``ad -p -r <id>`` — never on claude, which has no such
+# session. A CLAUDE session is still never resumed on `ad` (the prompt would be
+# "continue" with no context behind it).
+#
+# What it does NOT do yet: honour the PreToolUse approval guard or stream
+# progress events (that needs `ad` itself to grow `stream-json`, `--allowedTools`
+# and a pre-tool hook). So the permission mode defaults to acceptEdits — file
+# edits apply, but a shell command that is not read-only, and every web fetch,
+# is denied rather than run unguarded. A run that was denied what it needed and
+# produced nothing fails LOUDLY with the denied calls named (`ad` reports them
+# as `permission_denials`), instead of "ran fine, made nothing". Set
 # AGENTOS_FALLBACK_PERMISSION_MODE=bypass to let it run every command.
 #
 # Settings (process env or ~/.agentos/.env):
+#   AGENTOS_ENGINE                    claude (default) | ad — `ad` runs every fresh
+#                                     run on the AI Draftsman CLI first, for a box
+#                                     with no Claude login at all
 #   AGENTOS_FALLBACK_CLI              path to the CLI (default: `ad` on PATH), or "off"
 #   AGENTOS_FALLBACK_AGENT            agent id/name for `--agent` (default: gateway's choice)
+#   AGENTOS_FALLBACK_MODEL            model slug for `--model` (overrides the agent)
 #   AGENTOS_FALLBACK_PERMISSION_MODE  default | acceptEdits | plan | bypass
 
 _FALLBACK_MODES = ("default", "acceptEdits", "plan", "bypass")
+#: Marks a session id as an `ad` one, so a resume goes back to `ad`.
+AD_SESSION_PREFIX = "ad:"
+
+
+def ad_session_id(session_id: str | None) -> str | None:
+    """The raw `ad` session id inside ``ad:<id>``, or None for a claude session."""
+    if session_id and session_id.startswith(AD_SESSION_PREFIX):
+        return session_id[len(AD_SESSION_PREFIX):] or None
+    return None
+
+
+def engine() -> str:
+    """``"ad"`` when AGENTOS_ENGINE asks for the AI Draftsman CLI first, else ``"claude"``."""
+    value = _setting("AGENTOS_ENGINE").lower()
+    return "ad" if value in ("ad", "aidraftsman", "ai-draftsman", "fallback") else "claude"
 
 
 def _setting(key: str) -> str:
@@ -1440,6 +1467,48 @@ def _git_changed_files(path: Path) -> set[str] | None:
     return out
 
 
+# Folders a working-folder snapshot never looks in: VCS/tool state, caches and the
+# graphify index the SDK itself rebuilds — a change there is not a deliverable.
+_SNAPSHOT_SKIP_DIRS = {"node_modules", "graphify-out", "__pycache__", "venv", ".venv"}
+_SNAPSHOT_MAX_FILES = 20000
+
+
+def _folder_snapshot(path: Path) -> dict[str, tuple[int, int]] | None:
+    """``{file: (mtime_ns, size)}`` for a plain (non-git) working folder.
+
+    `_git_changed_files` answers None outside a repo, which left a fallback run
+    in a documentation / analyst folder with NO record of what it wrote — so a
+    task that updated a workbook in place was judged "produced no files". This
+    is the non-git equivalent. None when the folder is too big to walk cheaply.
+    """
+    out: dict[str, tuple[int, int]] = {}
+    try:
+        for root, dirs, files in os.walk(path):
+            dirs[:] = [d for d in dirs if not d.startswith(".") and d not in _SNAPSHOT_SKIP_DIRS]
+            for f in files:
+                if f.startswith("~$"):  # Office lock file, not a deliverable
+                    continue
+                fp = os.path.join(root, f)
+                try:
+                    st = os.stat(fp)
+                except OSError:
+                    continue
+                out[fp] = (st.st_mtime_ns, st.st_size)
+                if len(out) > _SNAPSHOT_MAX_FILES:
+                    return None
+    except OSError:
+        return None
+    return out
+
+
+def _snapshot_changes(before: dict[str, tuple[int, int]] | None,
+                      after: dict[str, tuple[int, int]] | None) -> list[str]:
+    """Files created or modified between two `_folder_snapshot`s."""
+    if before is None or after is None:
+        return []
+    return sorted(fp for fp, sig in after.items() if before.get(fp) != sig)
+
+
 # A 429 / RESOURCE_EXHAUSTED from the AI Draftsman gateway is a "slow down", not
 # a failure: `ad` (≥ 1.1.2) retries a few in-stream frames itself, but when it
 # gives up the whole run used to fail — a ticket went to Backlog, `agentos help`
@@ -1479,12 +1548,17 @@ async def run_fallback_cli(
     extra_env: dict[str, str] | None = None,
     tier: str | None = None,
     provider: str | None = None,
+    resume_session_id: str | None = None,
     _upgraded: bool = False,
     _rl_attempt: int = 0,
     _rl_waited: float = 0.0,
 ) -> dict[str, Any]:
     """Run ``prompt`` on the AI Draftsman CLI. Same result shape as the claude run.
 
+    ``resume_session_id`` is an ``ad:<id>`` from an earlier `ad` run: the prompt
+    continues that conversation (``-r <id>``). The result's ``session_id`` is
+    ``ad:<id>`` too, so the caller's repair / resume paths come back here.
+
     An outdated `ad` fails its first request (its tool schema is rejected) before
     touching anything, so that one failure upgrades the CLI and runs again, once.
     A rate limit (429 / RESOURCE_EXHAUSTED) waits and runs again — see above.
@@ -1502,9 +1576,15 @@ async def run_fallback_cli(
     if mode not in _FALLBACK_MODES:
         mode = "acceptEdits"
     args = ["-p", "--output-format", "json", "--permission-mode", mode]
+    fb_model = _setting("AGENTOS_FALLBACK_MODEL")
     agent = _setting("AGENTOS_FALLBACK_AGENT")
-    if agent:
+    if fb_model:
+        args += ["--model", fb_model]
+    elif agent:
         args += ["--agent", agent]
+    ad_resume = ad_session_id(resume_session_id)
+    if ad_resume:
+        args += ["-r", ad_resume]
     cmd = _fallback_argv(cli, *args)
 
     env = dict(os.environ)
@@ -1520,7 +1600,11 @@ async def run_fallback_cli(
         env["GIT_CONFIG_VALUE_0"] = "https://github.com/"
 
     before = _git_changed_files(path)
-    print(f"aidraftsman fallback spawn | mode={mode} | {path}", flush=True)
+    # Not a git repo: track the folder's files directly, so an in-place edit of
+    # a workbook / document still counts as a deliverable.
+    snap_before = _folder_snapshot(path) if before is None else None
+    print(f"aidraftsman fallback spawn | mode={mode}"
+          + (f" | resume {ad_resume}" if ad_resume else "") + f" | {path}", flush=True)
     proc = await asyncio.create_subprocess_exec(
         *cmd, cwd=str(path), env=env,
         stdin=asyncio.subprocess.PIPE,
@@ -1542,7 +1626,10 @@ async def run_fallback_cli(
         raise
 
     after = _git_changed_files(path)
-    files_changed = sorted(after - before) if before is not None and after is not None else []
+    if before is not None and after is not None:
+        files_changed = sorted(after - before)
+    else:
+        files_changed = _snapshot_changes(snap_before, _folder_snapshot(path))
     err_text = stderr.decode("utf-8", errors="replace").strip()
 
     data: dict[str, Any] = {}
@@ -1563,7 +1650,8 @@ async def run_fallback_cli(
             if done.startswith("AI Draftsman CLI updated"):
                 return await run_fallback_cli(
                     prompt, project_path, timeout=timeout, github_token=github_token,
-                    extra_env=extra_env, tier=tier, provider=provider, _upgraded=True)
+                    extra_env=extra_env, tier=tier, provider=provider,
+                    resume_session_id=resume_session_id, _upgraded=True)
             err += f" — the AI Draftsman CLI is outdated; run `{FALLBACK_INSTALL_HINT}`"
         auth_expired = proc.returncode == 2 or _is_auth_error(err)
         if not auth_expired and _is_fallback_rate_limited(err):
@@ -1577,7 +1665,8 @@ async def run_fallback_cli(
                 await asyncio.sleep(wait)
                 return await run_fallback_cli(
                     prompt, project_path, timeout=timeout, github_token=github_token,
-                    extra_env=extra_env, tier=tier, provider=provider, _upgraded=_upgraded,
+                    extra_env=extra_env, tier=tier, provider=provider,
+                    resume_session_id=resume_session_id, _upgraded=_upgraded,
                     _rl_attempt=attempt, _rl_waited=_rl_waited + wait)
             err += (f" — still rate-limited after {_rl_attempt} retr{'y' if _rl_attempt == 1 else 'ies'} "
                     f"and {_rl_waited / 60:.0f} min of waiting")
@@ -1591,8 +1680,33 @@ async def run_fallback_cli(
     in_tok = int(usage.get("prompt_tokens", 0) or 0)
     out_tok = int(usage.get("completion_tokens", 0) or 0)
     text = str(data.get("result") or "")
+    sid = str(data.get("session_id") or "")
+    session_id = f"{AD_SESSION_PREFIX}{sid}" if sid else None
+    denied = [str(d) for d in (data.get("permission_denials") or []) if d]
+    if denied:
+        print(f"aidraftsman was denied {len(denied)} call(s) in {mode} mode: "
+              + "; ".join(d[:120] for d in denied[:5]), flush=True)
+    if denied and not files_changed:
+        # `ad -p` exits 0 after a denial and answers around it, which read as
+        # "ran fine, made nothing" (MWM-217: every web fetch and the Python
+        # that edits the .xlsx were refused). Name what was blocked and how to
+        # allow it — this is the failure, not the task.
+        shown = "; ".join(d[:120] for d in denied[:5])
+        more = f" (+{len(denied) - 5} more)" if len(denied) > 5 else ""
+        return _result(
+            ok=False,
+            error=(f"AI Draftsman was blocked from {len(denied)} action(s) it needed "
+                   f"in {mode} mode and produced nothing: {shown}{more} — set "
+                   "AGENTOS_FALLBACK_PERMISSION_MODE=bypass to allow shell commands "
+                   "and web fetches, or log Claude in"),
+            result=text, longest_text=text, session_id=session_id,
+            input_tokens=in_tok, output_tokens=out_tok,
+            total_tokens=int(usage.get("total_tokens", 0) or 0) or in_tok + out_tok,
+            tier=tier, provider=provider, model="aidraftsman",
+        )
     return _result(
         ok=True,
+        session_id=session_id,
         result=text,
         longest_text=text,
         input_tokens=in_tok,
@@ -1715,6 +1829,20 @@ async def _run_claude_local(
     if force_fallback:
         print("claude usage limit — continuing this ticket on the AI Draftsman CLI",
               flush=True)
+        return await run_fallback_cli(
+            prompt, project_path, timeout=timeout, github_token=github_token,
+            extra_env=extra_env, tier=tier, provider=provider,
+            resume_session_id=resume_session_id if ad_session_id(resume_session_id) else None,
+        )
+    if ad_session_id(resume_session_id):
+        # The session being continued is an `ad` one: it only exists there.
+        return await run_fallback_cli(
+            prompt, project_path, timeout=timeout, github_token=github_token,
+            extra_env=extra_env, tier=tier, provider=provider,
+            resume_session_id=resume_session_id,
+        )
+    if not resume_session_id and engine() == "ad":
+        print("AGENTOS_ENGINE=ad — running on the AI Draftsman CLI", flush=True)
         return await run_fallback_cli(
             prompt, project_path, timeout=timeout, github_token=github_token,
             extra_env=extra_env, tier=tier, provider=provider,
@@ -1747,6 +1875,14 @@ async def _run_claude_local(
     )
     if fallback["ok"]:
         return fallback
+    if fallback.get("session_id") and not fallback.get("auth_expired") \
+            and not fallback.get("limit_exceeded"):
+        # `ad` really ran and failed on its own terms (e.g. blocked actions):
+        # that is the actionable reason, and its session can be repaired. Keep
+        # claude's reason alongside it.
+        fallback["error"] = (f"{fallback.get('error')} | claude: "
+                             f"{(result.get('error') or 'not working')[:160]}")
+        return fallback
     # Both failed: keep the claude result (its limit/auth flags drive the
     # caller's parking and alerts) and say what the fallback hit too.
     result["error"] = f"{result.get('error')} | aidraftsman fallback: {fallback.get('error')}"

devops_bot_sdk-1.7.50/tests/test_fallback_folder_changes.py

@@ -0,0 +1,39 @@
+"""A fallback (`ad`) run in a plain, non-git working folder must still report
+the files it changed — otherwise an in-place workbook edit is judged "task
+produced no files/deliverables" and the ticket goes to Backlog (MWM-217)."""
+from __future__ import annotations
+
+import os
+
+from sdk import local_exec
+
+
+def test_in_place_edit_and_new_file_are_seen(tmp_path):
+    wb = tmp_path / "UK_Shopping_Centres_list_Review_v3.xlsx"
+    wb.write_bytes(b"old")
+    untouched = tmp_path / "notes.txt"
+    untouched.write_text("same")
+    before = local_exec._folder_snapshot(tmp_path)
+
+    wb.write_bytes(b"new and longer")
+    st = os.stat(wb)
+    os.utime(wb, ns=(st.st_atime_ns, st.st_mtime_ns + 1_000_000_000))
+    (tmp_path / "summary.md").write_text("done")
+
+    changed = local_exec._snapshot_changes(before, local_exec._folder_snapshot(tmp_path))
+    assert changed == sorted([str(wb), str(tmp_path / "summary.md")])
+
+
+def test_tool_state_and_office_lock_files_are_not_deliverables(tmp_path):
+    before = local_exec._folder_snapshot(tmp_path)
+    (tmp_path / "graphify-out").mkdir()
+    (tmp_path / "graphify-out" / "graph.json").write_text("{}")
+    (tmp_path / ".claude").mkdir()
+    (tmp_path / ".claude" / "x").write_text("x")
+    (tmp_path / "~$Book.xlsx").write_text("lock")
+    assert local_exec._snapshot_changes(before, local_exec._folder_snapshot(tmp_path)) == []
+
+
+def test_no_snapshot_means_no_claim(tmp_path):
+    assert local_exec._snapshot_changes(None, {}) == []
+    assert local_exec._snapshot_changes({}, None) == []

devops_bot_sdk-1.7.50/tests/test_fallback_parity.py

@@ -0,0 +1,127 @@
+"""The AI Draftsman CLI (`ad`) as a full fallback: its sessions resume on `ad`,
+blocked actions fail loudly, AGENTOS_ENGINE=ad runs it first, and
+AGENTOS_FALLBACK_MODEL picks its model."""
+from __future__ import annotations
+
+import asyncio
+import json
+import sys
+
+import pytest
+
+from sdk import local_exec
+
+pytestmark = pytest.mark.skipif(sys.platform == "win32", reason="POSIX script stand-in")
+
+
+def _fake_ad(tmp_path, payload, *, write=True):
+    """An `ad` stand-in: records argv, optionally writes a file, prints ``payload``."""
+    record = tmp_path / "record.json"
+    script = tmp_path / "ad"
+    script.write_text(f"""#!{sys.executable}
+import json, os, sys
+sys.stdin.read()
+json.dump({{"argv": sys.argv[1:]}}, open({str(record)!r}, "w"))
+if {write!r}:
+    open("out.txt", "w").write("x")
+print(json.dumps({payload!r}))
+""")
+    script.chmod(0o755)
+    return script, record
+
+
+def _claude_must_not_run(monkeypatch):
+    async def _boom(*a, **k):
+        raise AssertionError("claude must not be spawned")
+    monkeypatch.setattr(local_exec, "_run_claude_cli", _boom)
+
+
+def test_an_ad_run_returns_a_resumable_ad_session(tmp_path, monkeypatch):
+    cli, _ = _fake_ad(tmp_path, {"result": "ok", "session_id": "abc123", "usage": {}})
+    monkeypatch.setenv("AGENTOS_FALLBACK_CLI", str(cli))
+    result = asyncio.run(local_exec.run_fallback_cli("x", str(tmp_path / "p")))
+    assert result["ok"] is True
+    assert result["session_id"] == "ad:abc123"
+
+
+def test_an_ad_session_resumes_on_ad_not_claude(tmp_path, monkeypatch):
+    cli, record = _fake_ad(tmp_path, {"result": "ok", "session_id": "abc123", "usage": {}})
+    monkeypatch.setenv("AGENTOS_FALLBACK_CLI", str(cli))
+    _claude_must_not_run(monkeypatch)
+    result = asyncio.run(local_exec.run_claude_local(
+        "fix the failing step", str(tmp_path / "p"), resume_session_id="ad:abc123"))
+    assert result["ok"] is True
+    argv = json.loads(record.read_text())["argv"]
+    assert argv[-2:] == ["-r", "abc123"]
+
+
+def test_engine_ad_runs_ad_first(tmp_path, monkeypatch):
+    cli, record = _fake_ad(tmp_path, {"result": "ok", "session_id": "s", "usage": {}})
+    monkeypatch.setenv("AGENTOS_FALLBACK_CLI", str(cli))
+    monkeypatch.setenv("AGENTOS_ENGINE", "ad")
+    _claude_must_not_run(monkeypatch)
+    result = asyncio.run(local_exec.run_claude_local("x", str(tmp_path / "p")))
+    assert result["ok"] is True and record.exists()
+
+
+def test_default_engine_is_claude(monkeypatch):
+    monkeypatch.delenv("AGENTOS_ENGINE", raising=False)
+    monkeypatch.setattr(local_exec, "_setting", lambda key: "")
+    assert local_exec.engine() == "claude"
+
+
+def test_fallback_model_is_passed_instead_of_the_agent(tmp_path, monkeypatch):
+    cli, record = _fake_ad(tmp_path, {"result": "ok", "usage": {}})
+    monkeypatch.setenv("AGENTOS_FALLBACK_CLI", str(cli))
+    monkeypatch.setenv("AGENTOS_FALLBACK_MODEL", "gemini-2.5-pro")
+    monkeypatch.setenv("AGENTOS_FALLBACK_AGENT", "dev")
+    asyncio.run(local_exec.run_fallback_cli("x", str(tmp_path / "p")))
+    argv = json.loads(record.read_text())["argv"]
+    assert "--model" in argv and argv[argv.index("--model") + 1] == "gemini-2.5-pro"
+    assert "--agent" not in argv
+
+
+def test_blocked_and_nothing_produced_is_a_loud_failure(tmp_path, monkeypatch):
+    """MWM-217: `ad` exits 0 after its web fetches and the .xlsx script were denied."""
+    cli, _ = _fake_ad(tmp_path, {
+        "result": "I could not fetch the sources.", "session_id": "s1", "usage": {},
+        "permission_denials": ["web_fetch(https://example.org)", "bash(python fill.py)"],
+    }, write=False)
+    monkeypatch.setenv("AGENTOS_FALLBACK_CLI", str(cli))
+    result = asyncio.run(local_exec.run_fallback_cli("x", str(tmp_path / "p")))
+    assert result["ok"] is False
+    assert "blocked from 2 action(s)" in result["error"]
+    assert "bash(python fill.py)" in result["error"]
+    assert "AGENTOS_FALLBACK_PERMISSION_MODE=bypass" in result["error"]
+    assert result["session_id"] == "ad:s1"  # still repairable on `ad`
+
+
+def test_blocked_but_produced_work_still_succeeds(tmp_path, monkeypatch):
+    cli, _ = _fake_ad(tmp_path, {
+        "result": "done", "session_id": "s1", "usage": {},
+        "permission_denials": ["bash(npm test)"],
+    })
+    monkeypatch.setenv("AGENTOS_FALLBACK_CLI", str(cli))
+    result = asyncio.run(local_exec.run_fallback_cli("x", str(tmp_path / "p")))
+    assert result["ok"] is True
+    assert result["files_changed"]
+
+
+def test_logged_out_claude_and_blocked_ad_reports_the_block(tmp_path, monkeypatch):
+    """Both failed, but `ad` really ran: its reason is the one to act on, not a
+    pause waiting for a Claude login."""
+    cli, _ = _fake_ad(tmp_path, {
+        "result": "", "session_id": "s1", "usage": {},
+        "permission_denials": ["web_fetch(https://example.org)"],
+    }, write=False)
+    monkeypatch.setenv("AGENTOS_FALLBACK_CLI", str(cli))
+
+    async def _logged_out(*a, **k):
+        return local_exec._result(ok=False, error="Not logged in · Please run /login",
+                                  auth_expired=True)
+    monkeypatch.setattr(local_exec, "_run_claude_cli", _logged_out)
+    result = asyncio.run(local_exec.run_claude_local("x", str(tmp_path / "p")))
+    assert result["ok"] is False
+    assert result["auth_expired"] is False
+    assert "blocked from 1 action(s)" in result["error"]
+    assert "claude: Not logged in" in result["error"]

devops_bot_sdk-1.7.48/sdk/help_data/snapshot.json

@@ -1,17 +0,0 @@
-[
- {
-  "version": "1.7.48",
-  "commit": "84377c8",
-  "pushed_at": "2026-11-03T14:46:05+05:00",
-  "generated_at": "2026-11-03T09:47:28+00:00",
-  "commands": 60,
-  "commands_invalid": 0,
-  "commands_undocumented": 0,
-  "panel_pages": 11,
-  "tests": 2613,
-  "prs_7d": 11,
-  "prs_30d": 43,
-  "features_30d": 13,
-  "fixes_30d": 18
- }
-]