dev-autopilot 0.4.0__tar.gz → 0.5.0__tar.gz

{dev_autopilot-0.4.0 → dev_autopilot-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dev-autopilot
-Version: 0.4.0
+Version: 0.5.0
 Summary: Autopilot builds your software project while you are away. You write what you want in plain words and start it once. You get working software, tested, with a record of every step.
 License: MIT
 Project-URL: Homepage, https://github.com/manishjnv/AutoPilot
@@ -46,8 +46,7 @@ It is for one developer, or for a person with an idea and a developer friend.
 | Questions | The chat waits for you. | That task waits. Other tasks continue. |
 | Status | You scroll the chat. | `ap watch` shows tasks, output, progress and usage. |
 
-The [full comparison](ARCHITECTURE.md#13-claude-code-alone-and-with-autopilot) has ten rows. Use Claude Code alone
-for a small change, a question, or an open design.
+The [full comparison](ARCHITECTURE.md#13-claude-code-alone-and-with-autopilot) has ten rows.
 
 ## How it works
 
@@ -95,28 +94,41 @@ Two real projects built from a plan:
 | Agent time | 2.2 hours, 38 sessions | 1.4 hours, 42 sessions |
 | Cost at API prices | $17.13 | $19.01 |
 
-Both runs used a subscription. The envguard audits found 8 real bugs; Autopilot fixed all. envguard is private; numbers come from the run log. A lean rerun of envguard used 39.5 percent fewer tokens per task.
+Both runs used a subscription. The envguard audits found 8 real bugs; Autopilot fixed all. envguard is private; numbers come from the run log.
 
 ## Install
 
-One line. It installs what is missing for your user, with no administrator prompt.
-Windows (PowerShell):
+Three steps, no administrator prompt.
 
-```powershell
-irm https://raw.githubusercontent.com/manishjnv/AutoPilot/main/install.ps1 | iex
-```
+1. Run one line in your shell.
 
-macOS, Linux or WSL:
+   Windows (PowerShell):
 
-```bash
-curl -fsSL https://raw.githubusercontent.com/manishjnv/AutoPilot/main/install.sh | bash
-```
+   ```powershell
+   irm https://raw.githubusercontent.com/manishjnv/AutoPilot/main/install.ps1 | iex
+   ```
+
+   macOS, Linux, WSL or Git Bash:
+
+   ```bash
+   curl -fsSL https://raw.githubusercontent.com/manishjnv/AutoPilot/main/install.sh | bash
+   ```
+
+   Windows (CMD):
+
+   ```bat
+   curl -o %TEMP%\install.cmd https://raw.githubusercontent.com/manishjnv/AutoPilot/main/install.cmd && %TEMP%\install.cmd
+   ```
+
+   Have Python 3.10 or newer? `pip install dev-autopilot && ap setup`.
+
+2. Answer one question: which AI do you pay for (Claude, GitHub Copilot, Codex, Cursor or Kiro)? The script
+   installs that one CLI and prints its login command. Copilot in VS Code is not a command-line tool. Autopilot
+   needs the Copilot CLI, which uses the same subscription.
+3. Open a project folder and type `ap`.
 
-On Windows pick Windows or WSL, not both; WSL only for the sandbox. With [uv](https://docs.astral.sh/uv/) already
-installed, `uv tool install dev-autopilot` is the same.
-Open a project folder and type `ap`. The first run logs you in to Claude (a paid plan, Pro or Max), then starts.
-See [What `ap` does](HOWTO.md#what-ap-does-in-a-folder). After a release, run `ap upgrade`. For a repair or a
-second machine, run `ap install`. Checksums and each step: [Install with one script](HOWTO.md#install-with-one-script).
+See [What `ap` does](HOWTO.md#what-ap-does-in-a-folder). Autopilot updates itself once a day; `ap uninstall --all`
+removes it. Checksums and each step: [Install with one script](HOWTO.md#install-with-one-script).
 
 ## Example output
 
@@ -144,5 +156,5 @@ audit: completion audit: 92% complete, 8 corrective tasks (FIX001)
 > Use a sandbox on a server: sessions run without permission prompts. See
 > [Run Autopilot on a server](HOWTO.md#run-autopilot-on-a-server).
 
-- Version 0.3.0, an early release. [MIT license](LICENSE).
+- Version 0.4.0, an early release. [MIT license](LICENSE).
 - One CLI agent per session. See [limits and runners](HOWTO.md#limits-and-supported-agent-clis).

{dev_autopilot-0.4.0 → dev_autopilot-0.5.0}/README.md

@@ -19,8 +19,7 @@ It is for one developer, or for a person with an idea and a developer friend.
 | Questions | The chat waits for you. | That task waits. Other tasks continue. |
 | Status | You scroll the chat. | `ap watch` shows tasks, output, progress and usage. |
 
-The [full comparison](ARCHITECTURE.md#13-claude-code-alone-and-with-autopilot) has ten rows. Use Claude Code alone
-for a small change, a question, or an open design.
+The [full comparison](ARCHITECTURE.md#13-claude-code-alone-and-with-autopilot) has ten rows.
 
 ## How it works
 
@@ -68,28 +67,41 @@ Two real projects built from a plan:
 | Agent time | 2.2 hours, 38 sessions | 1.4 hours, 42 sessions |
 | Cost at API prices | $17.13 | $19.01 |
 
-Both runs used a subscription. The envguard audits found 8 real bugs; Autopilot fixed all. envguard is private; numbers come from the run log. A lean rerun of envguard used 39.5 percent fewer tokens per task.
+Both runs used a subscription. The envguard audits found 8 real bugs; Autopilot fixed all. envguard is private; numbers come from the run log.
 
 ## Install
 
-One line. It installs what is missing for your user, with no administrator prompt.
-Windows (PowerShell):
+Three steps, no administrator prompt.
 
-```powershell
-irm https://raw.githubusercontent.com/manishjnv/AutoPilot/main/install.ps1 | iex
-```
+1. Run one line in your shell.
 
-macOS, Linux or WSL:
+   Windows (PowerShell):
 
-```bash
-curl -fsSL https://raw.githubusercontent.com/manishjnv/AutoPilot/main/install.sh | bash
-```
+   ```powershell
+   irm https://raw.githubusercontent.com/manishjnv/AutoPilot/main/install.ps1 | iex
+   ```
+
+   macOS, Linux, WSL or Git Bash:
+
+   ```bash
+   curl -fsSL https://raw.githubusercontent.com/manishjnv/AutoPilot/main/install.sh | bash
+   ```
+
+   Windows (CMD):
+
+   ```bat
+   curl -o %TEMP%\install.cmd https://raw.githubusercontent.com/manishjnv/AutoPilot/main/install.cmd && %TEMP%\install.cmd
+   ```
+
+   Have Python 3.10 or newer? `pip install dev-autopilot && ap setup`.
+
+2. Answer one question: which AI do you pay for (Claude, GitHub Copilot, Codex, Cursor or Kiro)? The script
+   installs that one CLI and prints its login command. Copilot in VS Code is not a command-line tool. Autopilot
+   needs the Copilot CLI, which uses the same subscription.
+3. Open a project folder and type `ap`.
 
-On Windows pick Windows or WSL, not both; WSL only for the sandbox. With [uv](https://docs.astral.sh/uv/) already
-installed, `uv tool install dev-autopilot` is the same.
-Open a project folder and type `ap`. The first run logs you in to Claude (a paid plan, Pro or Max), then starts.
-See [What `ap` does](HOWTO.md#what-ap-does-in-a-folder). After a release, run `ap upgrade`. For a repair or a
-second machine, run `ap install`. Checksums and each step: [Install with one script](HOWTO.md#install-with-one-script).
+See [What `ap` does](HOWTO.md#what-ap-does-in-a-folder). Autopilot updates itself once a day; `ap uninstall --all`
+removes it. Checksums and each step: [Install with one script](HOWTO.md#install-with-one-script).
 
 ## Example output
 
@@ -117,5 +129,5 @@ audit: completion audit: 92% complete, 8 corrective tasks (FIX001)
 > Use a sandbox on a server: sessions run without permission prompts. See
 > [Run Autopilot on a server](HOWTO.md#run-autopilot-on-a-server).
 
-- Version 0.3.0, an early release. [MIT license](LICENSE).
+- Version 0.4.0, an early release. [MIT license](LICENSE).
 - One CLI agent per session. See [limits and runners](HOWTO.md#limits-and-supported-agent-clis).

{dev_autopilot-0.4.0 → dev_autopilot-0.5.0}/autopilot/__init__.py

@@ -1,4 +1,4 @@
 """Autopilot — autonomous, plan-driven development orchestrator for Claude Code."""
 
-__version__ = "0.4.0"
+__version__ = "0.5.0"
 AGENT_DIR = ".agent"

{dev_autopilot-0.4.0 → dev_autopilot-0.5.0}/autopilot/backends/__init__.py

@@ -10,6 +10,10 @@ from datetime import datetime, timedelta
 LIMIT_RX = re.compile(r"^\s*(?:you've|you have) hit your (?:[\w-]+ ){0,3}limit"
                       r"(?:\s*[·•|\-–—,.]*\s*resets?\s+(?P<reset>[^\n]+))?", re.I | re.M)
 API_LIMIT_RX = re.compile(r"^\s*API Error: (?:429|529)\b|^\s*API Error:.*(?:rate_limit_error|overloaded_error)", re.I | re.M)
+# Q2 copilot: the premium-request quota message. Docs checked 2026-10-12, not run live: the exact wording and the exit
+# code are recorded in Q9; until then any line that names premium requests with a limit word counts.
+COPILOT_LIMIT_RX = re.compile(r"^\s*.{0,60}\b(?:premium requests? (?:limit|quota)|(?:limit|quota) (?:of|for|on) premium requests?"
+                              r"|premium requests? .{0,20}\b(?:exhausted|exceeded|used up))", re.I | re.M)
 _RESET_RX = re.compile(r"^(?:(?P<mon>[a-z]{3,9})\.?\s+(?P<day>\d{1,2})\s*(?:,|at)?\s*)?(?P<h>\d{1,2})(?::(?P<m>\d{2}))?"
                        r"\s*(?P<ap>am|pm)?\s*(?:\((?P<tz>[^)]+)\))?$", re.I)
 _MONTHS = {m: i + 1 for i, m in enumerate("jan feb mar apr may jun jul aug sep oct nov dec".split())}
@@ -57,7 +61,7 @@ def detect_limit(text: str, now: datetime | None = None) -> tuple[bool, float |
     m = LIMIT_RX.search(text)
     if m:
         return True, (parse_reset(m["reset"], now or datetime.now().astimezone()) if m["reset"] else None)
-    return bool(API_LIMIT_RX.search(text)), None
+    return bool(API_LIMIT_RX.search(text) or COPILOT_LIMIT_RX.search(text)), None
 
 
 # Failures of the machinery, not of the work: retried by the orchestrator, never counted as a task attempt.

{dev_autopilot-0.4.0 → dev_autopilot-0.5.0}/autopilot/backends/command.py

@@ -1,8 +1,10 @@
 """Generic backend: any CLI agent (Aider, Codex, a LiteLLM wrapper...). Prompt on stdin, report in stdout."""
 from __future__ import annotations
 
+import os
 import re
 import shlex
+import shutil
 import tempfile
 from pathlib import Path
 
@@ -21,30 +23,58 @@ PRESETS = {
     # https://cursor.com/docs/cli/headless , https://cursor.com/docs/cli/reference/parameters ,
     # https://aider.chat/docs/config/options.html , https://aider.chat/docs/scripting.html
     # kiro: no _ASK, because a positional argument stops kiro-cli from reading the prompt on stdin.
-    # cursor: stdin is not documented (the Chief project, PR #48, uses it), so the short _ASK argument stays.
+    # cursor: stdin is not documented (the Chief project, PR #48, uses it), so the short _ASK argument stays. The binary
+    # is `agent` since the rename (docs checked 2026-10-12); `command_template` falls back to an installed `cursor-agent`.
     # aider: no stdin prompt, so it reads {prompt_file} (a temp file outside the worktree); git stays with the orchestrator.
     # --trust-all-tools (kiro) and --force (cursor) approve every tool, not only the workspace (like gemini yolo).
     "kiro": "kiro-cli chat --no-interactive --trust-all-tools{model_flag}",
-    "cursor": "cursor-agent -p --force --trust{model_flag} " + _ASK,
+    "cursor": "agent -p --force --trust{model_flag} " + _ASK,
     "aider": "aider --message-file {prompt_file} --yes-always --no-auto-commits --no-dirty-commits --no-gitignore"
              " --no-check-update --no-analytics --no-pretty --no-stream{model_flag}",
+    # Q2 copilot: docs checked 2026-10-12, not run live (the live task is Q9). Sources: https://docs.github.com/en/copilot
+    # /how-tos/use-copilot-agents/use-copilot-cli . `-p` takes the prompt as an argument (stdin is not documented), so the
+    # prompt goes to a temp file outside the worktree (the aider pattern) and `--add-dir` lets copilot read that folder.
+    # --allow-all-tools and --no-ask-user approve every tool and never wait for a person; -s is the silent output.
+    "copilot": 'copilot -p "Your full instructions are in the file {prompt_path}. Read it, follow it, end with the '
+               'requested JSON report." --allow-all-tools --no-ask-user -s --add-dir {prompt_dir}{model_flag}',
 }
-_MODEL_OPT = {"kiro": "--model", "cursor": "--model", "aider": "--model"}  # P03-T01: aider -m means --message
+_MODEL_OPT = {"kiro": "--model", "cursor": "--model", "aider": "--model", "copilot": "--model"}  # aider -m = --message
 CLAUDE_ALIASES = ("haiku", "sonnet", "opus")
+# Q2: a preset's own names for the ladder aliases, used when agent.model_map does not map them. Copilot accepts Claude
+# model names (docs checked 2026-10-12, not run live: only `claude-haiku-4.5` is named in the docs; sonnet and opus stay
+# unmapped = Copilot's default model until Q9 records the exact names).
+DEFAULT_MODEL_MAP = {"copilot": {"haiku": "claude-haiku-4.5"}}
+_FILE_KEYS = ("{prompt_file}", "{prompt_path}", "{prompt_dir}")
 SAFE_MODEL = re.compile(r"[A-Za-z0-9][A-Za-z0-9._:/@-]{0,127}")
 
 
 def command_template(cfg) -> str:
-    return cfg.get("agent.command") or PRESETS.get(str(cfg.get("agent.preset") or ""), "")
+    """The shell template: `agent.command`, or the preset. When the preset's binary is not on PATH but an older name
+    of it is (the doctor table's aliases, for example `cursor-agent`), that name is used."""
+    own = cfg.get("agent.command")
+    if own:
+        return own
+    preset = str(cfg.get("agent.preset") or "")
+    tpl = PRESETS.get(preset, "")
+    if tpl:
+        from ..doctor import runner
+        row = runner(preset)
+        if row is not None and not shutil.which(row.binary):
+            alias = next((a for a in row.aliases if shutil.which(a)), "")
+            if alias:
+                tpl = alias + tpl[len(row.binary):]
+    return tpl
 
 
 def model_flag(cfg, model: str) -> str:
     """` -m <model>` (` --model <model>` for kiro, cursor, aider) after `agent.model_map` (ladder names → this CLI's
     models); an unmapped Claude alias gets no flag, so the CLI uses its own default model."""
-    m = str((cfg.get("agent.model_map", {}) or {}).get(model, model))
+    preset = str(cfg.get("agent.preset") or "")
+    own = (cfg.get("agent.model_map", {}) or {})
+    m = str(own.get(model, DEFAULT_MODEL_MAP.get(preset, {}).get(model, model)))
     if not SAFE_MODEL.fullmatch(m):  # the command runs through a shell (sh or cmd.exe): no quoting tricks needed
         raise ValueError(f"unsafe model name for agent.preset: {m!r}")
-    opt = _MODEL_OPT.get(str(cfg.get("agent.preset") or ""), "-m")
+    opt = _MODEL_OPT.get(preset, "-m")
     return "" if m in CLAUDE_ALIASES else f" {opt} {m}"
 
 
@@ -57,7 +87,7 @@ class CommandBackend:
         # the project context lives in system_append (U7); a generic CLI has no system prompt, so it leads the prompt
         prompt = f"{req.system_append}\n\n---\n\n{req.prompt}" if req.system_append else req.prompt
         pf = ""
-        if "{prompt_file}" in self.template:  # P03-T01: for CLIs without a stdin prompt (aider); outside the worktree
+        if any(k in self.template for k in _FILE_KEYS):  # P03-T01: CLIs without a stdin prompt (aider, copilot); outside the worktree
             with tempfile.NamedTemporaryFile("w", encoding="utf-8", prefix="autopilot-prompt-", suffix=".md",
                                              delete=False) as f:
                 f.write(prompt)
@@ -70,7 +100,7 @@ class CommandBackend:
     def _run(self, req: SessionRequest, prompt: str, pf: str) -> SessionResult:
         cmd = self.template.format(model=shlex.quote(req.model), budget=req.budget_usd or 0,
                                    read_only=int(req.read_only), model_flag=model_flag(self.cfg, req.model),
-                                   prompt_file=f'"{pf}"')
+                                   prompt_file=f'"{pf}"', prompt_path=pf, prompt_dir=f'"{os.path.dirname(pf)}"')
         env = {**agent_env(self.cfg), "AUTOPILOT_MODEL": req.model, "AUTOPILOT_READ_ONLY": str(int(req.read_only)),
                "AUTOPILOT_SYSTEM_APPEND": req.system_append}
         env.update({"AUTODEV_" + k[10:]: v for k, v in list(env.items()) if k.startswith("AUTOPILOT_")})

{dev_autopilot-0.4.0 → dev_autopilot-0.5.0}/autopilot/cli.py

@@ -383,36 +383,49 @@ def remember_setup(proj_path: Path, cmds: list[str]) -> None:
 
 
 def runner_set(root: Path) -> bool:
-    """N3: does the project's own project.yaml choose the agent CLI? Read raw: Config merges the claude_cli default.
-    An unusual `agent:` value (not a mapping) counts as set, so the file is left alone."""
-    path = Path(root) / AGENT_DIR / "project.yaml"
-    try:
-        agent = (load_yaml(path) if path.exists() else {}).get("agent") or {}
-    except (yaml.YAMLError, AttributeError):
-        return True  # a file preflight cannot read is never edited; validate reports it
-    return not isinstance(agent, dict) or any(agent.get(k) for k in ("backend", "command", "preset"))
+    """N3: does the project's own project.yaml choose the agent CLI? One reader: `doctor.runner_chosen`."""
+    from .doctor import runner_chosen
+    return runner_chosen(root)
 
 
 def pick_runner(root: Path) -> bool:
-    """N3: no runner set -> write the first installed, logged-in agent CLI on PATH. False = none (install hint printed).
-    A claude that is installed but logged out stays the default with no write, so the H2 login offer still runs."""
+    """N3: no runner set -> write the first installed, logged-in agent CLI on PATH. False = none: the neutral list of
+    every runner with its install command (Q1), never 'Install Claude Code' first. A claude that is installed but
+    logged out stays the default with no write, so the H2 login offer still runs. The runner `ap setup` chose on this
+    PC (Q3, `~/.autopilot/runner`) is written when it is installed and nothing else is logged in."""
     from .backends.claude_cli import ClaudeCLIBackend
-    from .doctor import INSTALL, RUNNERS, detect_runner
+    from .doctor import detect_runner, installed_runners, no_runner_text, runner
     if os.environ.get("AUTOPILOT_CLAUDE_BIN") or os.environ.get("AUTODEV_CLAUDE_BIN"):
         return True  # an explicit claude binary is a choice: keep the claude_cli default
     choice = detect_runner()
+    if not choice:
+        row = runner(setup_choice())
+        if row is not None and row.which():
+            choice = row.key
     if choice:
         if not remember_runner(Path(root) / AGENT_DIR / "project.yaml", choice):
             return False
-        print(f"runner: {next(b for b, be, *_ in RUNNERS if be == choice)} (found on PATH)")
+        print(f"runner: {runner(choice).binary} (found on PATH)")
         return True
     if shutil.which(ClaudeCLIBackend.resolve_binary()):
         return True
-    print(f"FAIL  no agent CLI found. Install Claude Code with: {INSTALL['native'][1]}\n"
-          f"      supported: {', '.join(b for b, *_ in RUNNERS)}")
+    found = installed_runners()
+    if found:  # installed, logged out: say which login is missing, nothing else
+        row = found[0][0]
+        print(f"FAIL  {row.binary} is installed but not logged in: run `{row.login}`, then start again")
+        return False
+    print(f"FAIL  {no_runner_text()}")
     return False
 
 
+def setup_choice() -> str:
+    """Q3: the runner `ap setup` chose on this PC (one word in `~/.autopilot/runner`), '' when none."""
+    try:
+        return (_recent_file().with_name("runner").read_text(encoding="utf-8").strip())
+    except OSError:
+        return ""
+
+
 def remember_runner(proj_path: Path, choice: str) -> bool:
     """N3: write agent.backend (and agent.preset) as a text edit after the `agent:` line, so comments stay. The new
     text is parsed first: when it would not give exactly the wanted values, nothing is written."""
@@ -1379,12 +1392,37 @@ def cmd_approve(args):
     return 0
 
 
-def cmd_uninstall(args):
-    """N8: `ap uninstall --rights` removes the scheduled task / the sudoers file the installer created."""
-    from .rights import remove_rights
+def cmd_uninstall(args, spawn=None):
+    """N8: `ap uninstall --rights` removes the scheduled task / the sudoers file the installer created.
+    T3: `ap uninstall --all` removes the rights, `~/.autopilot`, and the package itself (last, after this process has
+    exited: `ap.exe` is locked while it runs). `--dry-run` lists the steps. Projects' `.agent/` folders and the AI CLIs stay."""
+    from .rights import have_rights, remove_rights
+    from .upgrade import detect_install, spawn_after_exit
+    dry = getattr(args, "dry_run", False)
+    if getattr(args, "all", False):
+        say = (lambda s: print(("would " if dry else "") + s))
+        if have_rights():
+            say("remove the rights the installer took (scheduled task / sudoers file)")
+            if not dry:
+                for line in remove_rights():
+                    print(line)
+        home = _recent_file().parent
+        say(f"delete {home} (recent projects, the install log, the runner choice)")
+        if not dry and home.is_dir():
+            shutil.rmtree(home, ignore_errors=True)
+        kind = detect_install()
+        cmd = {"uv": ["uv", "tool", "uninstall", "dev-autopilot"], "pip": [sys.executable, "-m", "pip", "uninstall", "-y", "dev-autopilot"]}.get(kind)
+        if cmd is None:
+            say("remove the package: this is a git checkout; run `pip uninstall dev-autopilot`, then delete the folder")
+        else:
+            say(f"remove the package ({kind}), after this command has exited: {' '.join(cmd)}")
+            if not dry:
+                (spawn or spawn_after_exit)(cmd)
+        print("Kept: uv, Python, git, your AI CLI and its login, and each project's .agent/ folder (delete it to start clean).")
+        return 0
     if not getattr(args, "rights", False):
         print("ap uninstall --rights   removes the rights the installer took (scheduled task / sudoers file)\n"
-              "uv tool uninstall dev-autopilot   removes Autopilot itself")
+              "ap uninstall --all      removes the rights, ~/.autopilot and Autopilot itself (--dry-run lists the steps)")
         return 0
     for line in remove_rights():
         print(line)
@@ -1479,7 +1517,7 @@ def pick_project() -> str | None:
         print("This folder is no Autopilot project, and no other project is known on this PC.\n"
               "Go to the project folder, or name it with -C <folder>. To start a new one: autopilot quickstart")
         return None
-    print(f"project: {chosen}")
+    print(f"this folder is no project, using the last one used: {chosen}")  # Q10: say why, not only which
     return str(chosen)
 
 
@@ -1499,6 +1537,8 @@ def main(argv=None):
         if hasattr(s, "reconfigure"):
             s.reconfigure(encoding="utf-8", errors="replace")
     called = Path(sys.argv[0]).stem.lower() if argv is None else ""
+    if called not in ("ap", "autopilot"):  # `python -m autopilot` arrives as `__main__`: never a name a user reads
+        called = ""
     argv = list(sys.argv[1:] if argv is None else argv)
     if argv[:1] == ["start"]:  # J2: one plain word to start or continue the build in the background
         argv[:1] = ["run", "--clear-stop", "--detach"]
@@ -1567,13 +1607,20 @@ def main(argv=None):
     p = add("skip", cmd_skip, "skip task(s)"); p.add_argument("task_ids", nargs="+")
     p = add("approve", cmd_approve, "deploy an approved phase to prod"); p.add_argument("phase")
     add("mcp", cmd_mcp, "MCP server on stdin/stdout for IDE chats: ap_status, ap_next, ap_start, ap_stop, ap_answer")
-    p = add("uninstall", cmd_uninstall, "--rights: remove the scheduled task / sudoers file the installer created")
-    p.add_argument("--rights", action="store_true")
+    p = add("uninstall", cmd_uninstall, "--rights: remove the rights the installer took; --all: remove Autopilot from this PC")
+    p.add_argument("--rights", action="store_true"); p.add_argument("--all", action="store_true")
+    p.add_argument("--dry-run", action="store_true", help="list the steps, change nothing")
     from .upgrade import cmd_install, cmd_upgrade
     p = add("upgrade", cmd_upgrade, "get the newest Autopilot; --check only prints")
     p.add_argument("--check", action="store_true"); p.add_argument("--ref"); p.add_argument("--daily", action="store_true", help=argparse.SUPPRESS)
     p = add("install", cmd_install, "install or repair Autopilot for this user; --rights = the one rights step")
     p.add_argument("--rights", action="store_true")
+    from .commands.setup import cmd_setup
+    p = add("setup", cmd_setup, "find the AI you pay for, install its CLI, check the login, write the choice (one question at most)")
+    p.add_argument("--dry-run", action="store_true", help="scan and print the plan; install and write nothing")
+    p.add_argument("--runner", help="answer the question in advance: claude, copilot, codex, cursor or kiro")
+    p.add_argument("--yes", action="store_true", help="take the default answer")
+    p.add_argument("--skip-login", action="store_true", help="do not check or start a login")
     add("stop", cmd_stop, "graceful stop before the next session")
     add("resume", cmd_resume, "clear the stop flag")
     p = add("report", cmd_report, "the run report; --tokens = tokens and cost per step type")
@@ -1597,7 +1644,7 @@ def main(argv=None):
         print(f"autopilot {__version__}: {DESCRIPTION.split('. ')[0]}.")
         print(next_steps_text(Path.cwd()))
         return 0
-    if args.cmd in ("upgrade", "install"):  # no project: nothing to find or remember
+    if args.cmd in ("upgrade", "install", "setup", "uninstall"):  # no project needed: nothing to find or remember
         return args.fn(args) or 0
     if args.path is None:  # J2: no -C
         found = "." if args.cmd in NEW_PROJECT or (Path.cwd() / AGENT_DIR / "project.yaml").exists() else pick_project()
@@ -1607,7 +1654,13 @@ def main(argv=None):
     remember(Path(args.path).resolve())
     if getattr(args, "detach", False):
         return start_detached(Path(args.path).resolve(), [a for a in (argv or sys.argv[1:]) if a != "--detach"])
-    return args.fn(args) or 0
+    rc = args.fn(args) or 0
+    from .upgrade import auto_update  # T2: after the command, once a day, never during a run
+
+    line = auto_update(args.cmd, Path(args.path).resolve())
+    if line:
+        print(line)
+    return rc
 
 
 if __name__ == "__main__":