minitest-cli 0.42.0__tar.gz → 0.43.0__tar.gz

{minitest_cli-0.42.0 → minitest_cli-0.43.0}/.github/workflows/release.yml

@@ -78,53 +78,3 @@ jobs:
         with:
           generate_release_notes: true
           files: dist/*
-
-  update-homebrew:
-    needs: publish-pypi
-    runs-on: ubuntu-latest
-    steps:
-      - name: Fetch PyPI metadata
-        id: pypi
-        run: |
-          VERSION="${GITHUB_REF_NAME#v}"
-          echo "version=$VERSION" >> "$GITHUB_OUTPUT"
-
-          echo "Waiting for minitest-cli $VERSION to be available on PyPI..."
-          for i in $(seq 1 30); do
-            if curl -sSf --connect-timeout 5 --max-time 15 \
-              "https://pypi.org/pypi/minitest-cli/$VERSION/json" -o /tmp/pypi.json.tmp; then
-              mv /tmp/pypi.json.tmp /tmp/pypi.json
-              echo "Package is available on PyPI"
-              break
-            fi
-            echo "Attempt $i/30 - not yet available, waiting 10s..."
-            sleep 10
-          done
-
-          if [ ! -f /tmp/pypi.json ]; then
-            echo "::error::Package not found on PyPI after 5 minutes"
-            exit 1
-          fi
-
-          SDIST_URL=$(jq -r '.urls[] | select(.packagetype == "sdist") | .url' /tmp/pypi.json)
-          SDIST_SHA256=$(jq -r '.urls[] | select(.packagetype == "sdist") | .digests.sha256' /tmp/pypi.json)
-          if [ -z "$SDIST_URL" ] || [ "$SDIST_URL" = "null" ] || [ -z "$SDIST_SHA256" ] || [ "$SDIST_SHA256" = "null" ]; then
-            echo "::error::sdist metadata is missing from PyPI response"
-            exit 1
-          fi
-          echo "sdist_url=$SDIST_URL" >> "$GITHUB_OUTPUT"
-          echo "sdist_sha256=$SDIST_SHA256" >> "$GITHUB_OUTPUT"
-
-      - name: Trigger Homebrew tap update
-        uses: peter-evans/repository-dispatch@v3
-        with:
-          token: ${{ secrets.HOMEBREW_TAP_TOKEN }}
-          repository: minitap-ai/homebrew-tap
-          event-type: update-formula
-          client-payload: |
-            {
-              "formula": "minitest-cli",
-              "version": "${{ steps.pypi.outputs.version }}",
-              "sdist_url": "${{ steps.pypi.outputs.sdist_url }}",
-              "sdist_sha256": "${{ steps.pypi.outputs.sdist_sha256 }}"
-            }

{minitest_cli-0.42.0 → minitest_cli-0.43.0}/AGENTS.md

@@ -22,7 +22,8 @@ uv add <package>                                   # Add new dependency (always
 - `api/client.py` - httpx async client with auto auth + X-Minitest-Channel header
 - `utils/`
   - `output.py` - --json helpers: stdout=data, stderr=diagnostics
-  - `update_check.py` - PyPI version check (cached 24h, non-blocking)
+  - `update_check.py` - PyPI version check (cached 1h, non-blocking); hands newer releases to auto-update
+  - `auto_update*.py` - background self-update of the CLI and agent skill: eligibility and plan (`auto_update.py`), lock/state/running-command registry and the saved on/off preference (`auto_update_state.py`, toggled by `minitest upgrade auto`, `commands/upgrade_auto.py`), one-time notices, and the detached worker (`python -m minitest_cli.utils.auto_update_worker`). Tests run with `MINITEST_NO_AUTO_UPDATE=1` (conftest) so they never touch the real install.
 - `main.py` - Typer app entry point, global flags, command group registration
 - `tests/` - Unit tests
 

{minitest_cli-0.42.0 → minitest_cli-0.43.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: minitest-cli
-Version: 0.42.0
+Version: 0.43.0
 Summary: Minitest CLI – command-line interface for the Minitest testing platform
 Project-URL: Homepage, https://minitap.ai/
 Project-URL: Source, https://github.com/minitap-ai/minitest-cli
@@ -62,12 +62,6 @@ Both scripts use `uv` if available, or install it automatically.
 uv tool install minitest-cli
 ```
 
-**Homebrew** (macOS):
-
-```bash
-brew install minitap-ai/tap/minitest-cli
-```
-
 **uvx** (zero-install, all platforms):
 
 ```bash
@@ -83,6 +77,33 @@ uv sync
 uv run minitest --help
 ```
 
+### Staying up to date
+
+A CLI installed with `uv tool install` or the one-liner keeps itself
+current. When a command sees a newer release on PyPI, it updates the CLI in the
+background and your next command runs the new version. The update waits until
+no other `minitest` command is running, and only installs releases that have
+been out for at least an hour. The same background job refreshes the agent
+skill (`npx skills update minitest-cli`) when it has changed. The next command
+prints one line saying what was updated; the details go to
+`~/.minitest/auto_update.log`.
+
+Auto-update never runs in CI (`CI` set), in containers, on Windows, or for
+`uvx` and source checkouts; those keep printing an "Update available" notice.
+
+```bash
+minitest upgrade auto        # show the setting, why it is off, the last update
+minitest upgrade auto off    # turn it off for this user (saved in ~/.minitest/preferences.json)
+minitest upgrade auto on     # turn it back on
+minitest upgrade             # update by hand at any time
+```
+
+`MINITEST_NO_AUTO_UPDATE=1` also turns it off, and wins over the saved setting.
+
+> **Installed with Homebrew?** The `minitap-ai/tap/minitest-cli` formula is
+> retired: it stopped at 0.24.0 and is now disabled. Switch to uv with
+> `brew uninstall minitest-cli && uv tool install minitest-cli`.
+
 ## Quick Start
 
 ```bash
@@ -191,6 +212,7 @@ app defaults.
 | `MINITEST_WEBAPP_URL`         | Minitest webapp base URL (used for review links)            | No (defaults to production)        |
 | `MINITEST_SUPABASE_URL`       | Supabase project URL used for OAuth login                  | No (defaults to production)        |
 | `MINITEST_SUPABASE_PUBLISHABLE_KEY` | Supabase publishable (anon) key used for OAuth login | No (defaults to production)        |
+| `MINITEST_NO_AUTO_UPDATE`     | Set to `1` to stop the CLI and agent skill from updating themselves (or run `minitest upgrade auto off`) | No |
 
 > The recommended way to set these is to copy `.env.example` to `.env` — the CLI loads `.env` automatically. The shipped `.env.example` already targets the **dev** environment (see below).
 

{minitest_cli-0.42.0 → minitest_cli-0.43.0}/README.md

@@ -28,12 +28,6 @@ Both scripts use `uv` if available, or install it automatically.
 uv tool install minitest-cli
 ```
 
-**Homebrew** (macOS):
-
-```bash
-brew install minitap-ai/tap/minitest-cli
-```
-
 **uvx** (zero-install, all platforms):
 
 ```bash
@@ -49,6 +43,33 @@ uv sync
 uv run minitest --help
 ```
 
+### Staying up to date
+
+A CLI installed with `uv tool install` or the one-liner keeps itself
+current. When a command sees a newer release on PyPI, it updates the CLI in the
+background and your next command runs the new version. The update waits until
+no other `minitest` command is running, and only installs releases that have
+been out for at least an hour. The same background job refreshes the agent
+skill (`npx skills update minitest-cli`) when it has changed. The next command
+prints one line saying what was updated; the details go to
+`~/.minitest/auto_update.log`.
+
+Auto-update never runs in CI (`CI` set), in containers, on Windows, or for
+`uvx` and source checkouts; those keep printing an "Update available" notice.
+
+```bash
+minitest upgrade auto        # show the setting, why it is off, the last update
+minitest upgrade auto off    # turn it off for this user (saved in ~/.minitest/preferences.json)
+minitest upgrade auto on     # turn it back on
+minitest upgrade             # update by hand at any time
+```
+
+`MINITEST_NO_AUTO_UPDATE=1` also turns it off, and wins over the saved setting.
+
+> **Installed with Homebrew?** The `minitap-ai/tap/minitest-cli` formula is
+> retired: it stopped at 0.24.0 and is now disabled. Switch to uv with
+> `brew uninstall minitest-cli && uv tool install minitest-cli`.
+
 ## Quick Start
 
 ```bash
@@ -157,6 +178,7 @@ app defaults.
 | `MINITEST_WEBAPP_URL`         | Minitest webapp base URL (used for review links)            | No (defaults to production)        |
 | `MINITEST_SUPABASE_URL`       | Supabase project URL used for OAuth login                  | No (defaults to production)        |
 | `MINITEST_SUPABASE_PUBLISHABLE_KEY` | Supabase publishable (anon) key used for OAuth login | No (defaults to production)        |
+| `MINITEST_NO_AUTO_UPDATE`     | Set to `1` to stop the CLI and agent skill from updating themselves (or run `minitest upgrade auto off`) | No |
 
 > The recommended way to set these is to copy `.env.example` to `.env` — the CLI loads `.env` automatically. The shipped `.env.example` already targets the **dev** environment (see below).
 

{minitest_cli-0.42.0 → minitest_cli-0.43.0}/RELEASE.md

@@ -3,8 +3,10 @@
 ## Overview
 
 Releases are automated via GitHub Actions. Pushing a version tag triggers the
-full pipeline: build, publish to PyPI, create a GitHub Release, and update the
-Homebrew formula.
+full pipeline: build, publish to PyPI, and create a GitHub Release. uv is the
+only distribution channel (the Homebrew formula is retired); users
+on a `uv tool install` pick the release up automatically through auto-update
+once it has been on PyPI for an hour.
 
 ## Steps
 
@@ -38,8 +40,6 @@ The tag push triggers `.github/workflows/release.yml`, which:
 2. **Publish to PyPI** — uses trusted publishing (OIDC), no API token needed
 3. **GitHub Release** — creates a release with auto-generated notes and attaches
    the built artifacts
-4. **Homebrew update** — dispatches an event to `minitap-ai/homebrew-tap` with
-   the new version, sdist URL, and SHA256 hash
 
 ### 4. Verify
 
@@ -52,11 +52,6 @@ minitest --version
 
 # uvx
 uvx --from minitest-cli@X.Y.Z minitest --version
-
-# Homebrew (after tap update completes)
-brew update
-brew install minitap-ai/tap/minitest-cli
-minitest --version
 ```
 
 ## Prerequisites
@@ -76,11 +71,6 @@ Configure on PyPI at https://pypi.org/manage/project/minitest-cli/settings/publi
 
 Create a GitHub Actions environment named `pypi` in the repository settings.
 
-### Homebrew tap token
-
-A `HOMEBREW_TAP_TOKEN` secret must be set in this repository with a GitHub
-personal access token that has write access to `minitap-ai/homebrew-tap`.
-
 ## Version scheme
 
 We follow [Semantic Versioning](https://semver.org/):

{minitest_cli-0.42.0 → minitest_cli-0.43.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "minitest-cli"
-version = "0.42.0"
+version = "0.43.0"
 description = "Minitest CLI – command-line interface for the Minitest testing platform"
 readme = "README.md"
 license = "MIT"

{minitest_cli-0.42.0 → minitest_cli-0.43.0}/src/minitest_cli/commands/upgrade.py

@@ -8,16 +8,13 @@ import httpx
 import typer
 
 from minitest_cli import __version__
+from minitest_cli.commands.upgrade_auto import auto
 from minitest_cli.utils.output import err_console, print_error, print_success
 from minitest_cli.utils.skill_refresh import UpgradeStatus, check_and_refresh
-from minitest_cli.utils.update_check import (
-    CHECK_TIMEOUT_SECONDS,
-    PYPI_URL,
-    _is_brew_install,
-    _is_newer,
-)
+from minitest_cli.utils.update_check import CHECK_TIMEOUT_SECONDS, PYPI_URL, _is_newer
 
 app = typer.Typer(name="upgrade", help="Upgrade the CLI and refresh the agent skill.")
+app.command("auto")(auto)
 
 
 def _get_latest_pypi_version() -> str | None:
@@ -44,31 +41,22 @@ def _upgrade_cli() -> UpgradeStatus:
 
     err_console.print(f"\n[bold]Upgrading minitest-cli:[/bold] {__version__} → {latest}\n")
 
-    # Check the install method first, then fall back to uv on PATH.
-    if _is_brew_install():
-        cmd = ["brew", "upgrade", "minitest-cli"]
+    # minitest-cli is distributed through uv only (the Homebrew formula is retired).
+    uv_bin = shutil.which("uv")
+    if uv_bin:
+        cmd = [uv_bin, "tool", "upgrade", "--reinstall", "minitest-cli"]
     else:
-        uv_bin = shutil.which("uv")
-        if uv_bin:
-            cmd = [uv_bin, "tool", "upgrade", "--reinstall", "minitest-cli"]
-        else:
-            cmd = [sys.executable, "-m", "uv", "tool", "upgrade", "--reinstall", "minitest-cli"]
+        cmd = [sys.executable, "-m", "uv", "tool", "upgrade", "--reinstall", "minitest-cli"]
 
-    is_uv = "uv" in cmd[0] or cmd[:2] == [sys.executable, "-m"]
     err_console.print(f"[dim]Running: {' '.join(cmd)}[/dim]\n")
 
-    # Capture output for uv to detect its "Nothing to upgrade" false-success.
-    # Let brew stream to the terminal so the user sees real-time progress.
-    if is_uv:
-        result = subprocess.run(
-            cmd, check=False, capture_output=True, text=True, stdin=subprocess.DEVNULL
-        )
-        output = result.stdout + result.stderr
-        if output.strip():
-            err_console.print(output)
-    else:
-        result = subprocess.run(cmd, check=False, stdin=subprocess.DEVNULL)
-        output = ""
+    # Capture output to detect uv's "Nothing to upgrade" false-success.
+    result = subprocess.run(
+        cmd, check=False, capture_output=True, text=True, stdin=subprocess.DEVNULL
+    )
+    output = result.stdout + result.stderr
+    if output.strip():
+        err_console.print(output)
 
     if result.returncode != 0:
         print_error("CLI upgrade failed. Try running the command manually.")
@@ -76,7 +64,7 @@ def _upgrade_cli() -> UpgradeStatus:
 
     # uv tool upgrade exits 0 with "Nothing to upgrade" when the package
     # isn't managed by it (e.g. editable / dev install).
-    if is_uv and "nothing to upgrade" in output.lower():
+    if "nothing to upgrade" in output.lower():
         print_error(
             f"Upgrade tool reported nothing to upgrade, but version {__version__} "
             f"is behind {latest}. Try upgrading manually."

minitest_cli-0.43.0/src/minitest_cli/commands/upgrade_auto.py

@@ -0,0 +1,81 @@
+"""`minitest upgrade auto [on|off]` – show or change background auto-update."""
+
+from enum import StrEnum
+from typing import Annotated, Any
+
+import typer
+from rich.console import Console
+
+from minitest_cli.commands.user_story_helpers import is_json_mode
+from minitest_cli.core.config import Settings, get_settings
+from minitest_cli.utils import auto_update
+from minitest_cli.utils.auto_update_state import (
+    log_path,
+    read_state,
+    save_auto_update_enabled,
+    section,
+)
+from minitest_cli.utils.output import print_json, print_success
+
+
+class Switch(StrEnum):
+    ON = "on"
+    OFF = "off"
+
+
+def _status(settings: Settings) -> dict[str, Any]:
+    reason = auto_update.blocker(settings)
+    cli = section(read_state(settings), "cli")
+    return {
+        "autoUpdate": "off" if reason else "on",
+        "reason": reason,
+        "installCanUpdate": auto_update.cli_upgrade_supported(),
+        "lastUpdate": (
+            {"target": cli.get("target"), "status": cli.get("status")}
+            if cli.get("target")
+            else None
+        ),
+        "log": str(log_path(settings)),
+    }
+
+
+def _print_status(status: dict[str, Any]) -> None:
+    console = Console()
+    reason = f" ({status['reason']})" if status["reason"] else ""
+    console.print(f"Auto-update: [bold]{status['autoUpdate']}[/bold]{reason}")
+    if status["autoUpdate"] == "on" and not status["installCanUpdate"]:
+        console.print(
+            "This install cannot update itself (it is not a `uv tool install`): "
+            "run `minitest upgrade` to update."
+        )
+    if status["lastUpdate"]:
+        last = status["lastUpdate"]
+        console.print(f"Last update: {last['target']} ({last['status']})")
+    console.print(f"Log: {status['log']}")
+
+
+def auto(
+    switch: Annotated[
+        Switch | None,
+        typer.Argument(help="Turn background auto-update on or off; omit to show the setting."),
+    ] = None,
+) -> None:
+    """Show, or turn on/off, background updates of the CLI and its agent skill.
+
+    The choice is saved in ~/.minitest/preferences.json. MINITEST_NO_AUTO_UPDATE=1
+    and CI environments keep auto-update off whatever is saved here.
+    """
+    settings = get_settings()
+    if switch is not None:
+        save_auto_update_enabled(settings, switch is Switch.ON)
+        if not is_json_mode():
+            print_success(
+                "Auto-update turned on."
+                if switch is Switch.ON
+                else "Auto-update turned off. `minitest upgrade` still updates by hand."
+            )
+    status = _status(settings)
+    if is_json_mode():
+        print_json(status)
+    else:
+        _print_status(status)

{minitest_cli-0.42.0 → minitest_cli-0.43.0}/src/minitest_cli/main.py

@@ -84,6 +84,7 @@ def _version_callback(value: bool) -> None:
 
 @app.callback()
 def main(
+    context: typer.Context,
     _version: Annotated[
         bool,
         typer.Option(
@@ -118,5 +119,5 @@ def main(
     ctx.app_flag = app_id  # type: ignore[attr-defined]
     ctx.settings = settings  # type: ignore[attr-defined]
 
-    # Non-blocking update check
-    check_for_updates(settings)
+    # Non-blocking update check; `minitest upgrade` does the update itself.
+    check_for_updates(settings, allow_auto_update=context.invoked_subcommand != "upgrade")

minitest_cli-0.43.0/src/minitest_cli/utils/auto_update.py

@@ -0,0 +1,156 @@
+"""Keep the CLI and its agent skill current without anyone running `minitest upgrade`.
+
+When a command sees a newer release on PyPI, it starts a detached worker
+(``auto_update_worker``) and carries on: the worker waits until no minitest
+command is running, upgrades the CLI with `uv tool upgrade` (uv is the only
+distribution channel),
+then refreshes the agent skill. The next command runs the new version.
+"""
+
+import os
+import shutil
+import subprocess
+import sys
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from minitest_cli import __version__
+from minitest_cli.core.config import Settings
+from minitest_cli.utils.auto_update_state import (
+    LOG_MAX_BYTES,
+    acquire_lock,
+    auto_update_enabled,
+    hand_lock_to,
+    log_path,
+    read_state,
+    release_lock,
+    section,
+    update_section,
+)
+from minitest_cli.utils.versions import is_newer
+
+ENV_OPT_OUT = "MINITEST_NO_AUTO_UPDATE"
+OFF_COMMAND = "minitest upgrade auto off"
+RELEASE_COOLDOWN_SECONDS = 3600
+RETRY_AFTER_SECONDS = 24 * 3600
+SKILL_CHECK_INTERVAL_SECONDS = 6 * 3600
+WORKER_MODULE = "minitest_cli.utils.auto_update_worker"
+DOCKERENV_PATH = Path("/.dockerenv")
+_HOME = Path.home()
+_UV_FALLBACKS = (_HOME / ".local/bin/uv", _HOME / ".cargo/bin/uv", Path("/opt/homebrew/bin/uv"))
+
+
+@dataclass(frozen=True)
+class Plan:
+    cli_target: str | None
+    skill: bool
+
+
+def _truthy(value: str | None) -> bool:
+    return value is not None and value.strip().lower() not in ("", "0", "false", "no", "off")
+
+
+def environment_blocker() -> str | None:
+    """Why auto-update must not run here at all, or None when it may."""
+    if _truthy(os.environ.get(ENV_OPT_OUT)):
+        return f"{ENV_OPT_OUT} is set"
+    if _truthy(os.environ.get("CI")):
+        return "running in CI"
+    if os.environ.get("KUBERNETES_SERVICE_HOST") or DOCKERENV_PATH.exists():
+        return "running in a container"
+    if sys.platform == "win32":
+        return "not supported on Windows"
+    return None
+
+
+def blocker(settings: Settings) -> str | None:
+    """Why auto-update is off for this user/environment, or None when it is on."""
+    reason = environment_blocker()
+    if reason is None and not auto_update_enabled(settings):
+        reason = f"turned off with `{OFF_COMMAND}`"
+    return reason
+
+
+def is_uv_tool_install() -> bool:
+    """True for `uv tool install` (and the one-line installers, which use it).
+
+    uvx, pip and source checkouts are left alone: they have no receipt.
+    """
+    return (Path(sys.prefix) / "uv-receipt.toml").exists()
+
+
+def _find_uv() -> str | None:
+    found = shutil.which("uv")
+    if found:
+        return found
+    return next((str(path) for path in _UV_FALLBACKS if path.exists()), None)
+
+
+def upgrade_command() -> list[str] | None:
+    uv = _find_uv()
+    return [uv, "tool", "upgrade", "minitest-cli"] if uv else None
+
+
+def cli_upgrade_supported() -> bool:
+    return is_uv_tool_install() and upgrade_command() is not None
+
+
+def plan(settings: Settings, latest: str, released_at: float | None, now: float) -> Plan:
+    """Decide what the background worker should do on this command."""
+    state = read_state(settings)
+    cli = section(state, "cli")
+    attempted = (
+        cli.get("target") == latest
+        and cli.get("status") != "deferred"
+        and now - float(cli.get("startedAt") or 0) < RETRY_AFTER_SECONDS
+    )
+    settled = released_at is not None and now - released_at >= RELEASE_COOLDOWN_SECONDS
+    upgrade = (
+        is_newer(latest, __version__) and settled and not attempted and cli_upgrade_supported()
+    )
+    skill_checked_at = float(section(state, "skill").get("checkedAt") or 0)
+    skill_due = now - skill_checked_at >= SKILL_CHECK_INTERVAL_SECONDS
+    target = latest if upgrade else None
+    return Plan(cli_target=target, skill=skill_due or upgrade)
+
+
+def start(settings: Settings, todo: Plan, now: float) -> bool:
+    """Start the detached worker for ``todo``; False when another update is underway."""
+    if not (todo.cli_target or todo.skill) or not acquire_lock(settings):
+        return False
+    args = [sys.executable, "-m", WORKER_MODULE]
+    if todo.cli_target:
+        args += ["--cli-target", todo.cli_target]
+        update_section(
+            settings,
+            "cli",
+            target=todo.cli_target,
+            previous=__version__,
+            startedAt=now,
+            finishedAt=None,
+            status="running",
+            notified=False,
+        )
+    if todo.skill:
+        args.append("--skill")
+        update_section(settings, "skill", checkedAt=now)
+    log = log_path(settings)
+    mode = "w" if log.exists() and log.stat().st_size > LOG_MAX_BYTES else "a"
+    try:
+        with log.open(mode) as handle:
+            worker = subprocess.Popen(  # noqa: S603 - fixed argv, no shell
+                args,
+                stdin=subprocess.DEVNULL,
+                stdout=handle,
+                stderr=subprocess.STDOUT,
+                start_new_session=True,
+                close_fds=True,
+            )
+    except OSError:
+        release_lock(settings)
+        if todo.cli_target:
+            update_section(settings, "cli", status="failed", finishedAt=time.time())
+        return False
+    hand_lock_to(settings, worker.pid)
+    return True

minitest_cli-0.43.0/src/minitest_cli/utils/auto_update_notices.py

@@ -0,0 +1,41 @@
+"""Tell the user, once, what the last background update did."""
+
+from minitest_cli import __version__
+from minitest_cli.core.config import Settings
+from minitest_cli.utils.auto_update import OFF_COMMAND
+from minitest_cli.utils.auto_update_state import log_path, read_state, section, update_section
+from minitest_cli.utils.versions import is_newer
+
+FINISHED_STATUSES = ("done", "failed")
+
+
+def pending_notices(settings: Settings) -> list[str]:
+    """Return the notices not shown yet and mark them as shown."""
+    state = read_state(settings)
+    notices: list[str] = []
+
+    cli = section(state, "cli")
+    target = cli.get("target")
+    if target and not cli.get("notified") and cli.get("status") in FINISHED_STATUSES:
+        if is_newer(str(target), __version__):
+            notices.append(
+                f"minitest-cli could not update itself to {target} "
+                f"(details: {log_path(settings)}). Run `minitest upgrade`, "
+                f"or `{OFF_COMMAND}` to stop trying."
+            )
+        else:
+            notices.append(f"minitest-cli updated itself to {__version__}.")
+        update_section(settings, "cli", notified=True)
+
+    skill = section(state, "skill")
+    if not skill.get("notified") and skill.get("status") in ("upgraded", "failed"):
+        if skill["status"] == "upgraded":
+            notices.append("The minitest-cli agent skill was refreshed to its latest version.")
+        else:
+            notices.append(
+                "The minitest-cli agent skill could not be refreshed "
+                f"(details: {log_path(settings)}). Run `minitest upgrade`."
+            )
+        update_section(settings, "skill", notified=True)
+
+    return notices