devops-bot-sdk 1.6.73__tar.gz → 1.6.76__tar.gz

{devops_bot_sdk-1.6.73 → devops_bot_sdk-1.6.76}/PKG-INFO

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

{devops_bot_sdk-1.6.73 → devops_bot_sdk-1.6.76}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.6.73 → devops_bot_sdk-1.6.76}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -141,7 +141,7 @@ sdk/ui/static/schedules.html
 sdk/ui/static/setup.html
 sdk/ui/static/styles.css
 sdk/ui/static/tickets.html
-sdk/vendor/aidraftsman-cli-0.1.0.tgz
+tests/test_activity_claude_runs.py
 tests/test_activity_collectors.py
 tests/test_activity_core.py
 tests/test_activity_live_tracking.py
@@ -230,5 +230,6 @@ tests/test_url_access.py
 tests/test_vps_health.py
 tests/test_vps_only_reporting.py
 tests/test_windows_loop_identity.py
+tests/test_windows_panel_task.py
 tests/test_windows_task_paths.py
 tests/test_write_hook.py

{devops_bot_sdk-1.6.73 → devops_bot_sdk-1.6.76}/pyproject.toml

@@ -68,7 +68,7 @@ where = ["."]
 include = ["sdk*"]
 
 [tool.setuptools.package-data]
-sdk = ["py.typed", "ui/static/*", "vendor/*.tgz"]
+sdk = ["py.typed", "ui/static/*"]
 
 [tool.ruff]
 line-length   = 100

{devops_bot_sdk-1.6.73 → devops_bot_sdk-1.6.76}/sdk/__init__.py

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

@@ -19,6 +19,7 @@ from __future__ import annotations
 import logging
 import time
 import uuid
+from contextvars import ContextVar
 from typing import Any
 
 from sdk.activity import settings
@@ -41,6 +42,17 @@ _FILE_TOOLS = {"Write", "Edit", "MultiEdit", "NotebookEdit", "Read"}
 #: SDK-origin records are exact, not inferred — hence full confidence.
 _SDK_CONFIDENCE = 100
 
+#: The agent run open in THIS task's context. ``local_exec.run_claude_local``
+#: records every claude run it starts, unless a caller (agentd) already opened one
+#: around it — this is how the two avoid recording the same run twice. A
+#: ContextVar, not a global: concurrent runs live in separate asyncio tasks.
+_open_run: ContextVar[str | None] = ContextVar("agentos_open_agent_run", default=None)
+
+
+def active_run_id() -> str | None:
+    """The agent run already open in the current context, if any."""
+    return _open_run.get()
+
 
 def record_session(session: ActivitySession) -> bool:
     """Queue a session (or its update). ``False`` when disabled or on any failure."""
@@ -94,6 +106,7 @@ def agent_run_started(
 ) -> str:
     """Record that agentos started an agent run. Returns the session key."""
     key = agent_session_key(run_id)
+    _open_run.set(run_id)
     record_session(
         ActivitySession(
             externalKey=key,
@@ -134,6 +147,8 @@ def agent_run_finished(
 ) -> None:
     """Record the end of an agent run and close its session."""
     key = agent_session_key(run_id)
+    if _open_run.get() == run_id:
+        _open_run.set(None)
     now = time.time()
     record_session(
         ActivitySession(

{devops_bot_sdk-1.6.73 → devops_bot_sdk-1.6.76}/sdk/cli.py

@@ -1383,13 +1383,15 @@ def _browser_command(args: list[str]) -> None:
 # ── fallback ─────────────────────────────────────────────────────────────
 
 def _fallback_usage() -> None:
-    print("usage: agentos fallback install                 # npm-install the bundled CLI now")
+    print("usage: agentos fallback install                 # where `ad` is, or how to install it")
     print("       agentos fallback login [--browser | --api-key [KEY]] [--base-url URL] [--no-browser]")
     print("       agentos fallback status [--verify]       # --verify asks the server too")
     print("       agentos fallback logout")
     print()
-    print("  When the `claude` CLI is not working, tickets re-run on the AI Draftsman CLI")
-    print("  bundled with the SDK. It needs its own login, made as the user the SDK runs as.")
+    print("  When the `claude` CLI is not available (not installed or logged out), tickets")
+    print("  run on the AI Draftsman CLI (`ad`) installed on this machine. A claude usage")
+    print("  limit is NOT a fallback: that run pauses and resumes on claude.")
+    print("  `ad` needs its own login, made as the user the SDK runs as.")
     print()
     print("  --browser       prints a sign-in code and a link; approve it on the AI Draftsman")
     print("                  frontend from any machine — works on a headless VPS")
@@ -1409,14 +1411,15 @@ def _fallback_command(args: list[str]) -> None:
         if le._fallback_disabled():
             print("error: the fallback is disabled (AGENTOS_FALLBACK_CLI=off)")
             sys.exit(1)
-        cli = asyncio.run(le.ensure_fallback_cli())
+        # The SDK no longer installs the CLI: it is updated continuously, so the
+        # copy on the machine is the one to use. This only reports where it is.
+        cli = le.fallback_cli_path()
         if not cli:
-            print("error: could not install the AI Draftsman CLI (Node.js 20+ and npm are needed)")
+            print(f"error: the AI Draftsman CLI (`ad`) was not found. Install it with:\n"
+                  f"  {le.FALLBACK_INSTALL_HINT}\n"
+                  "or point AGENTOS_FALLBACK_CLI at it in ~/.agentos/.env")
             sys.exit(1)
-        print(f"installed: {cli}")
-        ad = Path(cli).with_name("ad.cmd" if cli.lower().endswith(".cmd") else "ad")
-        if ad.exists():
-            print(f"also as  : {ad}   (the same CLI under its short name)")
+        print(f"found    : {cli}")
         print("next     : agentos fallback login")
         return
 

{devops_bot_sdk-1.6.73 → devops_bot_sdk-1.6.76}/sdk/local_exec.py

@@ -1045,16 +1045,23 @@ async def _run_claude_cli(
 
 
 # ── Fallback: the AI Draftsman CLI ─────────────────────────────────────────
-# When the `claude` CLI is not working — not installed, logged out, out of
-# usage, or dying before it even starts a session — the ticket is re-run on
-# our own AI Draftsman CLI (`aidraftsman`, npm package @aidraftsman/cli) instead
-# of failing or parking. It is the same job against the same project dir: the
-# prompt goes in on stdin, `-p --output-format json` prints one JSON object.
-# The CLI is bundled in sdk/vendor/ and npm-installed into ~/.agentos/aidraftsman
-# the first time it is needed; one already on PATH is used instead. It needs
-# its own login on the box, as the user the SDK runs as: `agentos fallback
-# login` (browser sign-in code or an API key), or AD_API_KEY in the env.
-# `agentos fallback status --verify` checks it against the server.
+# When the `claude` CLI is not AVAILABLE — not installed, logged out, or dying
+# before it even starts a session — the ticket runs on our own AI Draftsman CLI
+# (`ad`, npm package @aidraftsman/cli) instead of failing or parking. It is the
+# same job against the same project dir: the prompt goes in on stdin,
+# `-p --output-format json` prints one JSON object.
+#
+# A claude USAGE LIMIT is not "unavailable": that run parks and resumes on the
+# same claude session when the window resets, and is never handed to another
+# model mid-ticket.
+#
+# The CLI is the one already installed on the machine (`ad` on PATH, or an npm
+# global bin dir the service's PATH may not include). The SDK never installs it:
+# it is updated continuously, and a copy pinned inside the SDK went stale the
+# day after it shipped. It needs its own login on the box, as the user the SDK
+# runs as: `agentos fallback login` (browser sign-in code or an API key), or
+# 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
@@ -1064,7 +1071,7 @@ async def _run_claude_cli(
 # AGENTOS_FALLBACK_PERMISSION_MODE=bypass to let it run every command.
 #
 # Settings (process env or ~/.agentos/.env):
-#   AGENTOS_FALLBACK_CLI              path to the CLI (default: PATH, then bundled), or "off"
+#   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_PERMISSION_MODE  default | acceptEdits | plan | bypass
 
@@ -1082,91 +1089,54 @@ def _setting(key: str) -> str:
         return ""
 
 
-#: The CLI ships inside the SDK (sdk/vendor/*.tgz) so every box has it without
-#: a separate install step; it is npm-installed from there on first use.
-_VENDOR_DIR = Path(__file__).parent / "vendor"
+#: How to get the CLI when it is missing — shown in every "not found" message.
+FALLBACK_INSTALL_HINT = "npm install -g @aidraftsman/cli"
 
 
 def _fallback_disabled() -> bool:
     return _setting("AGENTOS_FALLBACK_CLI").lower() in ("off", "0", "false", "no", "none")
 
 
-def _bundled_tarball() -> Path | None:
-    tarballs = sorted(_VENDOR_DIR.glob("aidraftsman-cli-*.tgz"))
-    return tarballs[-1] if tarballs else None
-
-
-def _bundled_bin(tarball: Path) -> Path:
-    """Where the bundled tarball's `aidraftsman` lands once installed.
-
-    One prefix per tarball name, so an SDK update that ships a new CLI version
-    installs it fresh rather than reusing the old one.
-    """
-    prefix = config._CONFIG_DIR / "aidraftsman" / tarball.name.removesuffix(".tgz")
-    name = "aidraftsman.cmd" if sys.platform == "win32" else "aidraftsman"
-    return prefix / "node_modules" / ".bin" / name
+def _npm_global_bins() -> list[Path]:
+    """npm's global bin dirs, for a service whose PATH does not include them."""
+    if sys.platform == "win32":
+        appdata = os.environ.get("APPDATA")
+        return [Path(appdata) / "npm"] if appdata else []
+    home = Path.home()
+    return [home / ".npm-global" / "bin", home / ".local" / "bin",
+            Path("/usr/local/bin"), Path("/usr/bin")]
 
 
 def fallback_cli_path() -> str | None:
-    """Absolute path to an installed `aidraftsman` CLI, or None if absent or disabled.
+    """Absolute path to the installed AI Draftsman CLI, or None if absent or disabled.
 
-    Resolution order: ``AGENTOS_FALLBACK_CLI``, then ``aidraftsman`` or ``ad``
-    on ``PATH``, then the copy installed from the bundled tarball. Never installs anything — see
-    :func:`ensure_fallback_cli` for that.
+    Resolution order: ``AGENTOS_FALLBACK_CLI``, then ``ad`` (and its long name
+    ``aidraftsman``) on ``PATH``, then npm's global bin dirs. Never installs
+    anything — the CLI on the machine is the one kept up to date.
     """
     if _fallback_disabled():
         return None
     override = _setting("AGENTOS_FALLBACK_CLI")
     if override and Path(override).exists():
         return override
-    # The package installs the same entry point under two names; a box may
-    # only have `ad` on PATH.
-    for name in ("aidraftsman", "ad"):
+    names = ("ad", "aidraftsman")
+    for name in names:
         found = shutil.which(name)
         if found:
             return found
-    tarball = _bundled_tarball()
-    if tarball and _bundled_bin(tarball).exists():
-        return str(_bundled_bin(tarball))
+    suffixes = (".cmd", ".exe", "") if sys.platform == "win32" else ("",)
+    for d in _npm_global_bins():
+        for name in names:
+            for suffix in suffixes:
+                candidate = d / f"{name}{suffix}"
+                if candidate.is_file():
+                    return str(candidate)
     return None
 
 
-def _install_bundled(tarball: Path) -> str | None:
-    """``npm install`` the bundled tarball into a private prefix (no sudo, no -g)."""
-    npm = shutil.which("npm")
-    if not npm:
-        print("aidraftsman fallback unavailable: npm not found (Node.js 20+ required)", flush=True)
-        return None
-    bin_path = _bundled_bin(tarball)
-    prefix = bin_path.parents[2]
-    prefix.mkdir(parents=True, exist_ok=True)
-    cmd = [npm, "install", "--prefix", str(prefix), "--no-audit", "--no-fund",
-           "--omit=dev", str(tarball)]
-    if sys.platform == "win32" and npm.lower().endswith((".cmd", ".bat")):
-        cmd = [os.environ.get("COMSPEC", "cmd.exe"), "/c", *cmd]
-    print(f"installing bundled {tarball.name} into {prefix}", flush=True)
-    try:
-        proc = subprocess.run(cmd, capture_output=True, text=True, errors="replace",
-                              timeout=600)
-    except Exception as exc:  # noqa: BLE001 — never raise into a ticket run
-        print(f"aidraftsman install failed: {exc}", flush=True)
-        return None
-    if proc.returncode != 0 or not bin_path.exists():
-        print(f"aidraftsman install failed: {(proc.stderr or proc.stdout).strip()[-300:]}",
-              flush=True)
-        return None
-    return str(bin_path)
-
-
 async def ensure_fallback_cli() -> str | None:
-    """:func:`fallback_cli_path`, installing the bundled CLI first if needed."""
-    found = fallback_cli_path()
-    if found or _fallback_disabled():
-        return found
-    tarball = _bundled_tarball()
-    if not tarball:
-        return None
-    return await asyncio.to_thread(_install_bundled, tarball)
+    """:func:`fallback_cli_path`. Kept for callers; it no longer installs anything."""
+    return fallback_cli_path()
 
 
 def _fallback_argv(cli: str, *args: str) -> list[str]:
@@ -1200,7 +1170,7 @@ def fallback_status(*, verify: bool = False, timeout: float = 20.0) -> dict:
         return out
     cli = fallback_cli_path()
     if not cli:
-        out["error"] = "not installed — run `agentos fallback install`"
+        out["error"] = f"`ad` not found — install it with `{FALLBACK_INSTALL_HINT}`"
         return out
     out.update(installed=True, path=cli)
     try:
@@ -1238,8 +1208,8 @@ def fallback_status(*, verify: bool = False, timeout: float = 20.0) -> dict:
 #: Shown when neither CLI can take a ticket; the entry points' "CLI missing" error.
 NO_LOCAL_CLI_MESSAGE = (
     "Neither the Claude Code CLI nor the AI Draftsman fallback is ready on this "
-    "machine. Install claude and run `claude setup-token`, or run "
-    "`agentos fallback install` then `agentos fallback login`."
+    "machine. Install claude and run `claude setup-token`, or install the AI "
+    f"Draftsman CLI (`{FALLBACK_INSTALL_HINT}`) and run `agentos fallback login`."
 )
 
 
@@ -1274,13 +1244,12 @@ def fallback_login(*, method: str | None = None, api_key: str | None = None,
     a link to approve on the AI Draftsman frontend (works on a headless VPS: open
     the link on any machine), ``method="api-key"`` validates and stores a key
     from Settings → API keys (prompted with hidden input when ``api_key`` is not
-    given). ``None`` shows the CLI's own menu. Installs the bundled CLI first.
+    given). ``None`` shows the CLI's own menu.
     """
-    cli = asyncio.run(ensure_fallback_cli())
+    cli = fallback_cli_path()
     if not cli:
-        print("error: the AI Draftsman CLI is not available "
-              "(Node.js 20+ and npm are needed to install the bundled copy, "
-              "or it is disabled with AGENTOS_FALLBACK_CLI=off)")
+        print("error: the AI Draftsman CLI (`ad`) was not found — install it with "
+              f"`{FALLBACK_INSTALL_HINT}` (or it is disabled with AGENTOS_FALLBACK_CLI=off)")
         return 1
     args = ["auth", "login"]
     if api_key:
@@ -1317,7 +1286,11 @@ def _claude_not_working(result: dict[str, Any]) -> bool:
     """
     if result.get("ok"):
         return False
-    if result.get("auth_expired") or result.get("limit_exceeded"):
+    if result.get("limit_exceeded"):
+        # Out of usage is not "unavailable": the run parks and resumes on the same
+        # claude session when the window resets (local_exec's limit handling).
+        return False
+    if result.get("auth_expired"):
         return True
     if result.get("context_exceeded") or result.get("output_cap_exceeded"):
         return False
@@ -1356,9 +1329,8 @@ async def run_fallback_cli(
     """Run ``prompt`` on the AI Draftsman CLI. Same result shape as the claude run."""
     cli = await ensure_fallback_cli()
     if not cli:
-        return _result(ok=False, error="AI Draftsman CLI not available (needs Node.js 20+ "
-                                       "and npm to install the bundled copy; "
-                                       "`agentos fallback install`).",
+        return _result(ok=False, error="AI Draftsman CLI (`ad`) not found on this "
+                                       f"machine — install it with `{FALLBACK_INSTALL_HINT}`.",
                        tier=tier, provider=provider)
 
     path = Path(project_path).expanduser()
@@ -1462,11 +1434,94 @@ async def run_claude_local(
     settings_env: dict[str, str] | None = None,
     tier: str | None = None,
     provider: str | None = None,
+    activity_label: str | None = None,
 ) -> dict[str, Any]:
     """Run the local `claude` CLI; if the CLI itself is not working, re-run on
     the AI Draftsman CLI. See ``_run_claude_cli`` for the arguments and the
     result shape, and the fallback notes above ``run_fallback_cli``.
+
+    Every run is recorded in the VPS activity trail as an AGENT_RUN session with
+    its tool calls — ticket runs, scheduled runs and panel runs alike, since they
+    all come through here. Before this only agentd recorded its runs, so the
+    trail showed no agent work at all for most VPSes. A caller that already
+    opened a run (agentd) is left to record its own; ``activity_label`` names the
+    run, defaulting to the repository it ran in.
     """
+    from sdk.activity import recorder as _audit
+
+    if _audit.active_run_id() is not None:
+        return await _run_claude_local(
+            prompt, project_path, allowed_tools=allowed_tools, on_event=on_event,
+            timeout=timeout, github_token=github_token,
+            resume_session_id=resume_session_id, approval_dir=approval_dir,
+            idle_timeout=idle_timeout, max_output_tokens=max_output_tokens,
+            extra_env=extra_env, unset_env=unset_env, settings_env=settings_env,
+            tier=tier, provider=provider,
+        )
+
+    import uuid as _uuid
+
+    run_id = str(_uuid.uuid4())
+    label = activity_label or f"claude: {Path(project_path).name or project_path}"
+    _audit.agent_run_started(run_id, agent_name=label[:255])
+
+    async def _audited(event: dict) -> None:
+        if isinstance(event, dict) and event.get("type") == "assistant":
+            content = (event.get("message") or {}).get("content") or []
+            for block in content:
+                if isinstance(block, dict) and block.get("type") == "tool_use":
+                    _audit.agent_tool_call(run_id, str(block.get("name") or "tool"),
+                                           block.get("input"))
+        if on_event is not None:
+            await on_event(event)
+
+    try:
+        result = await _run_claude_local(
+            prompt, project_path, allowed_tools=allowed_tools, on_event=_audited,
+            timeout=timeout, github_token=github_token,
+            resume_session_id=resume_session_id, approval_dir=approval_dir,
+            idle_timeout=idle_timeout, max_output_tokens=max_output_tokens,
+            extra_env={**(extra_env or {}), "AGENTOS_ACTOR": "agent",
+                       "AGENTOS_RUN_ID": run_id},
+            unset_env=unset_env, settings_env=settings_env, tier=tier, provider=provider,
+        )
+    except BaseException as exc:  # incl. CancelledError: the session must still close
+        _audit.agent_run_finished(run_id, ok=False, agent_name=label[:255],
+                                  detail=(str(exc) or type(exc).__name__)[:500])
+        raise
+    ok = bool(result.get("ok"))
+    _audit.agent_run_finished(run_id, ok=ok, agent_name=label[:255],
+                              detail=None if ok else str(result.get("error") or "")[:500])
+    return result
+
+
+async def _run_claude_local(
+    prompt: str,
+    project_path: str,
+    *,
+    allowed_tools: list[str] | None,
+    on_event: EventHandler | None,
+    timeout: float,
+    github_token: str | None,
+    resume_session_id: str | None,
+    approval_dir: str | None,
+    idle_timeout: float,
+    max_output_tokens: int | None,
+    extra_env: dict[str, str] | None,
+    unset_env: list[str] | None,
+    settings_env: dict[str, str] | None,
+    tier: str | None,
+    provider: str | None,
+) -> dict[str, Any]:
+    """The un-audited body of :func:`run_claude_local`."""
+    if not resume_session_id and not is_available() and fallback_cli_path():
+        # No claude here at all: go straight to `ad` rather than spawn a
+        # process that cannot exist just to learn that it failed.
+        print("claude CLI not installed — 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,
+        )
     result = await _run_claude_cli(
         prompt, project_path,
         allowed_tools=allowed_tools, on_event=on_event, timeout=timeout,

{devops_bot_sdk-1.6.73 → devops_bot_sdk-1.6.76}/sdk/ui/service.py

@@ -410,20 +410,118 @@ def _uninstall_launchd() -> tuple[bool, str]:
 
 # ── Windows (Scheduled Task) ────────────────────────────────────────────────
 
+#: Written when Windows refused the logged-out (S4U) panel task, so ``ensure`` does
+#: not rebuild the task on every update only to be refused again.
+_S4U_REFUSED_MARKER = Path.home() / ".agentos" / "panel_task_s4u_refused"
+
+
+def _windows_account() -> str:
+    """``DOMAIN\\user`` for the task principal — the user whose ~/.agentos holds the token."""
+    import getpass
+
+    user = os.environ.get("USERNAME") or getpass.getuser()
+    domain = os.environ.get("USERDOMAIN") or os.environ.get("COMPUTERNAME") or ""
+    return f"{domain}\\{user}" if domain else user
+
+
+def _panel_task_xml(exe: str, args: str, home: str, account: str) -> str:
+    """Task Scheduler XML for the panel: runs whether or not anyone is signed in.
+
+    The old task was ``/SC ONLOGON`` with an interactive token, so the panel — and
+    with it the health ping, the activity collector and the shipper — stopped the
+    moment the user signed out of RDP. A VPS used all day then reported nothing
+    from sign-out until the next sign-in ("VPS not reporting since 8h ago").
+
+    * ``S4U`` logon: runs without a stored password, signed in or not. It has no
+      Windows network credentials, which the panel does not use (HTTPS only).
+    * Boot AND logon triggers: up after a reboot with nobody signed in, and started
+      again at sign-in if it was down.
+    * Restart on failure, no execution time limit (the default is 72 h).
+    * ``HighestAvailable``: the collector reads the Security log, which needs an
+      elevated token — same as the old ``/RL HIGHEST``.
+    """
+    from xml.sax.saxutils import escape
+
+    who = escape(account)
+    return (
+        '<?xml version="1.0" encoding="UTF-16"?>\n'
+        '<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">\n'
+        "  <RegistrationInfo><Description>AgentOS control panel (health, activity, "
+        "ticket runs)</Description></RegistrationInfo>\n"
+        "  <Triggers>\n"
+        "    <BootTrigger><Enabled>true</Enabled><Delay>PT1M</Delay></BootTrigger>\n"
+        f"    <LogonTrigger><Enabled>true</Enabled><UserId>{who}</UserId></LogonTrigger>\n"
+        "  </Triggers>\n"
+        f'  <Principals><Principal id="Author"><UserId>{who}</UserId>'
+        "<LogonType>S4U</LogonType><RunLevel>HighestAvailable</RunLevel>"
+        "</Principal></Principals>\n"
+        "  <Settings>\n"
+        "    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>\n"
+        "    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>\n"
+        "    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>\n"
+        "    <StartWhenAvailable>true</StartWhenAvailable>\n"
+        "    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>\n"
+        "    <RestartOnFailure><Interval>PT1M</Interval><Count>999</Count></RestartOnFailure>\n"
+        "  </Settings>\n"
+        '  <Actions Context="Author"><Exec>'
+        f"<Command>{escape(exe)}</Command><Arguments>{escape(args)}</Arguments>"
+        f"<WorkingDirectory>{escape(home)}</WorkingDirectory>"
+        "</Exec></Actions>\n"
+        "</Task>\n"
+    )
+
+
+def _create_task_from_xml(task: str, xml: str) -> tuple[int, str]:
+    import tempfile
+
+    fd, path = tempfile.mkstemp(suffix=".xml")
+    try:
+        with os.fdopen(fd, "w", encoding="utf-16") as fh:   # schtasks /XML wants UTF-16
+            fh.write(xml)
+        return _run(["schtasks", "/Create", "/TN", task, "/XML", path, "/F"])
+    except OSError as exc:
+        return 1, str(exc)
+    finally:
+        try:
+            os.unlink(path)
+        except OSError:
+            pass
+
+
 def _install_schtask(host: str, port: int) -> tuple[bool, str]:
     exe = _exe()
     refusal = _require_absolute(exe, WIN_TASK)
     if refusal:
         return False, refusal
-    tr = f'"{exe}" --host {host} --port {port} --no-browser'
-    rc, out = _run(["schtasks", "/Create", "/TN", WIN_TASK, "/TR", tr,
-                    "/SC", "ONLOGON", "/RL", "HIGHEST", "/F"])
+    args = f"--host {host} --port {port} --no-browser"
+    rc, out = _create_task_from_xml(
+        WIN_TASK, _panel_task_xml(exe, args, str(Path.home()), _windows_account()))
+    if rc == 0:
+        try:
+            _S4U_REFUSED_MARKER.unlink()
+        except OSError:
+            pass
+        _run(["schtasks", "/Run", "/TN", WIN_TASK])
+        return True, (f"installed scheduled task '{WIN_TASK}' — runs whether or not anyone "
+                      f"is signed in, restarts on failure, and is running now.")
+
+    # Windows refused it (e.g. a policy denying "Log on as a batch job"). Fall back to
+    # the at-logon task: worse — it stops at sign-out — but never worse than before.
+    try:
+        _S4U_REFUSED_MARKER.parent.mkdir(parents=True, exist_ok=True)
+        _S4U_REFUSED_MARKER.write_text(out[-2000:], encoding="utf-8")
+    except OSError:
+        pass
+    tr = f'"{exe}" {args}'
+    rc, out2 = _run(["schtasks", "/Create", "/TN", WIN_TASK, "/TR", tr,
+                     "/SC", "ONLOGON", "/RL", "HIGHEST", "/F"])
     if rc != 0:
-        return False, f"schtasks create failed:\n{out}"
+        return False, f"schtasks create failed:\n{out}\n{out2}"
     _run(["schtasks", "/Run", "/TN", WIN_TASK])
     return True, (f"installed scheduled task '{WIN_TASK}' — starts at logon and is "
-                  f"running now.\n  For crash-restart and no-login start, mark the task "
-                  f"'Run whether user is logged on' + 'Restart on failure' in Task Scheduler.")
+                  f"running now. NOTE: Windows refused the run-while-signed-out task, so "
+                  f"the panel STOPS when you sign out — disconnect from RDP instead of "
+                  f"signing out. Reason: {out.strip()[-300:]}")
 
 
 def _update_task_xml(exe: str, home: str) -> str:
@@ -527,6 +625,19 @@ def _schtask_points_nowhere(task: str) -> bool:
     return cmd is not None and not (Path(cmd).is_absolute() and Path(cmd).is_file())
 
 
+def _schtask_runs_signed_out(task: str) -> bool | None:
+    """True when ``task`` keeps running after sign-out; ``None`` if it cannot be read."""
+    rc, out = _run(["schtasks", "/Query", "/TN", task, "/XML"])
+    if rc != 0:
+        return None
+    return bool(re.search(r"<LogonType>\s*(S4U|Password)\s*</LogonType>", out))
+
+
+def _panel_task_needs_upgrade() -> bool:
+    """An at-logon panel task (pre-1.6.76) that Windows has not already refused to replace."""
+    return _schtask_runs_signed_out(WIN_TASK) is False and not _S4U_REFUSED_MARKER.exists()
+
+
 def _uninstall_schtask() -> tuple[bool, str]:
     _run(["schtasks", "/Delete", "/TN", WIN_UPDATE_TASK, "/F"])
     _run(["schtasks", "/End", "/TN", WIN_TASK])
@@ -855,6 +966,10 @@ def ensure(restart_running: bool = False) -> tuple[bool, str]:
         rok, rmsg = refresh()               # rebuilds the task with an absolute path
         return rok, (_with_token_warning(f"panel task pointed at a missing program — "
                                          f"rebuilt; {rmsg}") if rok else rmsg)
+    if IS_WINDOWS and _panel_task_needs_upgrade():
+        rok, rmsg = refresh()               # at-logon task → runs while signed out
+        return rok, (_with_token_warning(f"panel task now runs while signed out; {rmsg}")
+                     if rok else rmsg)
     if _is_active():
         stale = _restart_if_stale()
         if stale is not None: