agentic-dev-loop 0.10.4__tar.gz → 0.10.5__tar.gz

{agentic_dev_loop-0.10.4/src/agentic_dev_loop.egg-info → agentic_dev_loop-0.10.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-dev-loop
-Version: 0.10.4
+Version: 0.10.5
 Summary: Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase.
 Author: Luke Wilson
 License-Expression: Apache-2.0
@@ -492,8 +492,10 @@ before.
 `agentic-dev-loop doctor --fast` is the per-run gate the trigger runs first.
 Hard failures abort the run (engine pin mismatch, engine runtime availability,
 API version, git repo, `.env*` files); warnings print and continue. `doctor
---json` emits the same results mechanically. The trigger repairs a pin/install
-mismatch exactly once, then fails hard.
+--json` emits the same results mechanically. On a hard failure the trigger
+runs `agentic-dev-loop upgrade` exactly once: it installs the latest release
+with pipx and rewrites `.engine-version` to match, then the run fails hard if
+doctor still fails.
 
 A consumer repo needs a pipeline file and the agent files it names, both
 committed before the first run (the host-boundary check refuses dirty tooling,

{agentic_dev_loop-0.10.4 → agentic_dev_loop-0.10.5}/README.md

@@ -448,8 +448,10 @@ before.
 `agentic-dev-loop doctor --fast` is the per-run gate the trigger runs first.
 Hard failures abort the run (engine pin mismatch, engine runtime availability,
 API version, git repo, `.env*` files); warnings print and continue. `doctor
---json` emits the same results mechanically. The trigger repairs a pin/install
-mismatch exactly once, then fails hard.
+--json` emits the same results mechanically. On a hard failure the trigger
+runs `agentic-dev-loop upgrade` exactly once: it installs the latest release
+with pipx and rewrites `.engine-version` to match, then the run fails hard if
+doctor still fails.
 
 A consumer repo needs a pipeline file and the agent files it names, both
 committed before the first run (the host-boundary check refuses dirty tooling,

{agentic_dev_loop-0.10.4 → agentic_dev_loop-0.10.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agentic-dev-loop"
-version = "0.10.4"
+version = "0.10.5"
 description = "Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase."
 readme = "README.md"
 requires-python = ">=3.12"

{agentic_dev_loop-0.10.4 → agentic_dev_loop-0.10.5}/src/agentic_dev_loop/core/profiles/__init__.py

@@ -81,18 +81,16 @@ def parse_version(text: str) -> tuple[int, int, int, int, int]:
     return (int(major), int(minor), int(patch), _RANK[pre], int(num))
 
 
-def check_engine_min(engine_min: str, installed: str,
-                     latest: str | None = None) -> None:
+def check_engine_min(engine_min: str, installed: str) -> None:
     """Raise unless ``installed`` satisfies ``engine_min``.
 
-    ``latest`` is substituted into the fix line by the caller (doctor); when
-    omitted the floor itself is used.
+    The fix line names the upgrade command: it installs the latest release,
+    which always satisfies the floor.
     """
     if parse_version(installed) < parse_version(engine_min):
-        target = latest or engine_min
         raise ProfileError(
             f"profile requires engine >= {engine_min}; installed {installed}. "
-            f'Upgrade: pipx install --force "agentic-dev-loop=={target}"')
+            "Upgrade: run agentic-dev-loop upgrade")
 
 
 def _data_dir():

{agentic_dev_loop-0.10.4 → agentic_dev_loop-0.10.5}/src/agentic_dev_loop/engine/cli.py

@@ -171,6 +171,9 @@ def main(argv: list[str] | None = None) -> int:
     if argv and argv[0] == "doctor":
         from .onboarding.doctor import run_doctor
         return run_doctor(argv[1:])
+    if argv and argv[0] == "upgrade":
+        from .onboarding.upgrade import run_upgrade
+        return run_upgrade(argv[1:])
     probe = argparse.ArgumentParser(add_help=False)
     probe.add_argument("pipeline", type=Path, nargs="?")
     _add_version_flag(probe)

{agentic_dev_loop-0.10.4 → agentic_dev_loop-0.10.5}/src/agentic_dev_loop/engine/onboarding/checks.py

@@ -25,6 +25,7 @@ __all__ = ["Check", "HostProbes", "collect_checks"]
 ENV_WHITELIST = frozenset({".env.example", ".env.template", ".env.sample"})
 MIN_API = (1, 43)
 PYPI_URL = "https://pypi.org/pypi/agentic-dev-loop/json"
+FIX_UPGRADE = "run agentic-dev-loop upgrade"
 
 
 @dataclass(frozen=True)
@@ -171,12 +172,12 @@ def collect_checks(profile: Profile | None, pipeline, installed: str,
     if pin is None:
         checks.append(_hard(
             "pin", False, f"no engine pin file at {pin_path}",
-            "run agentic-dev-loop init (or write agentic-dev-loop/.engine-version)"))
+            FIX_UPGRADE))
     else:
         checks.append(_hard(
             "pin", pin == installed,
             f"installed {installed}, pin {pin}",
-            f'pipx install --force "agentic-dev-loop=={pin}"'))
+            FIX_UPGRADE))
         latest = probes.latest_release()
         if latest is None:
             checks.append(_hard("pin-latest", True,
@@ -189,7 +190,7 @@ def collect_checks(profile: Profile | None, pipeline, installed: str,
             checks.append(_hard(
                 "pin-latest", not behind,
                 f"pin {pin} is behind latest release {latest}",
-                f'pipx install --force "agentic-dev-loop=={latest}"'))
+                FIX_UPGRADE))
 
     present = probes.docker_present()
     checks.append(_hard(

{agentic_dev_loop-0.10.4 → agentic_dev_loop-0.10.5}/src/agentic_dev_loop/engine/onboarding/templates/trigger-agentic-dev-loop.sh

@@ -5,7 +5,6 @@ ROOT="$(cd "$(dirname "$0")" && pwd)"
 cd "$ROOT"
 
 PIPELINE="$ROOT/agentic-dev-loop/pipeline.yaml"
-PIN_FILE="$ROOT/agentic-dev-loop/.engine-version"
 
 # Optional host environment file. The default lives outside the workspace so
 # secrets never enter the repo; set AGENTIC_DEV_LOOP_ENV_FILE to override.
@@ -25,24 +24,17 @@ if ! command -v agentic-dev-loop >/dev/null 2>&1; then
   exit 1
 fi
 
-if [[ ! -f "$PIN_FILE" ]]; then
-  echo "error: missing engine pin file: $PIN_FILE" >&2
-  echo "       run 'agentic-dev-loop init' in this repo to write it" >&2
-  exit 1
-fi
-PIN="$(cat "$PIN_FILE")"
-
 # doctor --fast is the per-run gate: hard failures abort, warnings continue.
-# A pin/install mismatch is repaired exactly once, then the run fails hard.
+# A failing gate is repaired exactly once by upgrading to the latest engine
+# release (which also rewrites the project pin), then the run fails hard.
 if ! agentic-dev-loop doctor --fast; then
-  echo "error: doctor --fast failed - repairing the engine pin $PIN once" >&2
-  if ! pipx install --force "agentic-dev-loop==$PIN"; then
-    echo "error: could not install agentic-dev-loop==$PIN" >&2
-    echo "       the install may not be pipx-managed, or the index is unreachable" >&2
+  echo "doctor --fast failed - upgrading to the latest engine release" >&2
+  if ! agentic-dev-loop upgrade; then
+    echo "error: agentic-dev-loop upgrade failed" >&2
     exit 1
   fi
   if ! agentic-dev-loop doctor --fast; then
-    echo "error: doctor --fast still fails after repairing the engine pin" >&2
+    echo "error: doctor --fast still fails after upgrading the engine" >&2
     exit 1
   fi
 fi

agentic_dev_loop-0.10.5/src/agentic_dev_loop/engine/onboarding/upgrade.py

@@ -0,0 +1,76 @@
+"""``agentic-dev-loop upgrade``: install the latest engine and sync the pin.
+
+Installs the latest release with pipx and rewrites
+``agentic-dev-loop/.engine-version`` to the installed version, so the host
+install and the committed pin converge in one action.
+"""
+
+from __future__ import annotations
+
+import argparse
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from agentic_dev_loop.core.profiles import ProfileError, parse_version
+
+__all__ = ["run_upgrade"]
+
+
+def _resolve(name: str, env: dict | None) -> str | None:
+    if env is not None:
+        return shutil.which(name, path=env.get("PATH", ""))
+    return shutil.which(name)
+
+
+def run_upgrade(argv: list[str], *, workspace: Path | None = None,
+                env: dict | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="agentic-dev-loop upgrade",
+        description="Install the latest engine release and rewrite the "
+                    "project pin file to match.")
+    parser.parse_args(argv)
+
+    root = Path(workspace or Path.cwd()).resolve()
+    pipx = _resolve("pipx", env)
+    if pipx is None:
+        print("error: pipx is not on PATH; the engine install must be "
+              "pipx-managed", file=sys.stderr)
+        return 1
+
+    result = subprocess.run(
+        [pipx, "install", "--force", "agentic-dev-loop"],
+        capture_output=True, text=True, check=False, env=env)
+    if result.returncode != 0:
+        detail = (result.stderr or "unknown error").strip()
+        print(f"error: pipx install failed: {detail}", file=sys.stderr)
+        return 1
+
+    cli = _resolve("agentic-dev-loop", env)
+    if cli is None:
+        print("error: agentic-dev-loop is not on PATH", file=sys.stderr)
+        return 1
+    version_result = subprocess.run(
+        [cli, "--version"], capture_output=True, text=True,
+        check=False, env=env)
+    if version_result.returncode != 0:
+        detail = (version_result.stderr or "unknown error").strip()
+        print(f"error: could not read the installed version: {detail}",
+              file=sys.stderr)
+        return 1
+
+    tokens = version_result.stdout.split()
+    version = tokens[-1] if tokens else ""
+    try:
+        parse_version(version)
+    except ProfileError:
+        print("error: unreadable version from --version output: "
+              f"{version_result.stdout.strip()!r}", file=sys.stderr)
+        return 1
+
+    out = root / "agentic-dev-loop"
+    out.mkdir(parents=True, exist_ok=True)
+    (out / ".engine-version").write_text(version + "\n", encoding="utf-8")
+    print(f"upgraded agentic-dev-loop to {version}; .engine-version updated")
+    return 0

{agentic_dev_loop-0.10.4 → agentic_dev_loop-0.10.5/src/agentic_dev_loop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-dev-loop
-Version: 0.10.4
+Version: 0.10.5
 Summary: Turn an LLM into a gated, sandboxed, resumable construction loop over your codebase.
 Author: Luke Wilson
 License-Expression: Apache-2.0
@@ -492,8 +492,10 @@ before.
 `agentic-dev-loop doctor --fast` is the per-run gate the trigger runs first.
 Hard failures abort the run (engine pin mismatch, engine runtime availability,
 API version, git repo, `.env*` files); warnings print and continue. `doctor
---json` emits the same results mechanically. The trigger repairs a pin/install
-mismatch exactly once, then fails hard.
+--json` emits the same results mechanically. On a hard failure the trigger
+runs `agentic-dev-loop upgrade` exactly once: it installs the latest release
+with pipx and rewrites `.engine-version` to match, then the run fails hard if
+doctor still fails.
 
 A consumer repo needs a pipeline file and the agent files it names, both
 committed before the first run (the host-boundary check refuses dirty tooling,

{agentic_dev_loop-0.10.4 → agentic_dev_loop-0.10.5}/src/agentic_dev_loop.egg-info/SOURCES.txt

@@ -55,6 +55,7 @@ src/agentic_dev_loop/engine/onboarding/doctor.py
 src/agentic_dev_loop/engine/onboarding/init.py
 src/agentic_dev_loop/engine/onboarding/recipes.py
 src/agentic_dev_loop/engine/onboarding/templates.py
+src/agentic_dev_loop/engine/onboarding/upgrade.py
 src/agentic_dev_loop/engine/onboarding/recipes/dotnet-node.yaml
 src/agentic_dev_loop/engine/onboarding/recipes/python.yaml
 src/agentic_dev_loop/engine/onboarding/templates/dev.agent.md
@@ -81,6 +82,7 @@ tests/test_055_profiles.py
 tests/test_055_recipes.py
 tests/test_055_schema_lock.py
 tests/test_055_templates.py
+tests/test_055_upgrade.py
 tests/test_actions.py
 tests/test_agent_error_guide.py
 tests/test_agents.py

{agentic_dev_loop-0.10.4 → agentic_dev_loop-0.10.5}/tests/test_055_cli.py

@@ -1,4 +1,4 @@
-"""055 Task 8: CLI dispatch for init and doctor."""
+"""055 Task 8: CLI dispatch for init, doctor, and upgrade."""
 
 from __future__ import annotations
 
@@ -24,6 +24,13 @@ def test_init_help_exits_zero(capsys):
     assert "usage" in capsys.readouterr().out.lower()
 
 
+def test_upgrade_help_exits_zero(capsys):
+    with pytest.raises(SystemExit) as exc:
+        main(["upgrade", "--help"])
+    assert exc.value.code == 0
+    assert "usage" in capsys.readouterr().out.lower()
+
+
 def test_doctor_json_fast_returns_int(monkeypatch, capsys):
     from agentic_dev_loop.engine.onboarding import checks
 

{agentic_dev_loop-0.10.4 → agentic_dev_loop-0.10.5}/tests/test_055_doctor.py

@@ -95,7 +95,7 @@ def test_installed_pin_mismatch_is_hard_with_fix_text(tmp_path: Path, capsys):
     out = capsys.readouterr().out
     assert code == 1
     assert "HARD" in out
-    assert 'pipx install --force "agentic-dev-loop==0.9.2"' in out
+    assert "run agentic-dev-loop upgrade" in out
 
 
 def test_missing_placeholder_on_path_is_hard(tmp_path: Path, capsys):

{agentic_dev_loop-0.10.4 → agentic_dev_loop-0.10.5}/tests/test_055_profiles.py

@@ -41,7 +41,7 @@ def test_check_engine_min_blocks_with_exact_message():
         check_engine_min("0.10.0", "0.9.2")
     assert str(exc.value) == (
         'profile requires engine >= 0.10.0; installed 0.9.2. '
-        'Upgrade: pipx install --force "agentic-dev-loop==0.10.0"'
+        'Upgrade: run agentic-dev-loop upgrade'
     )
 
 

{agentic_dev_loop-0.10.4 → agentic_dev_loop-0.10.5}/tests/test_055_templates.py

@@ -63,9 +63,9 @@ def test_dev_template_missing_heading_reports_actual_headings():
 
 def test_trigger_template_contract():
     text = load_template("trigger-agentic-dev-loop.sh")
-    assert ".engine-version" in text
     assert "doctor --fast" in text
-    assert "pipx install --force" in text
+    assert "agentic-dev-loop upgrade" in text
+    assert "pipx install --force" not in text
     assert "pipx upgrade" not in text
     assert "AGENTIC_DEV_LOOP_ENV_FILE" in text
     assert "exec agentic-dev-loop" in text

agentic_dev_loop-0.10.5/tests/test_055_upgrade.py

@@ -0,0 +1,125 @@
+"""055 follow-up: the ``upgrade`` command.
+
+``agentic-dev-loop upgrade`` installs the latest engine release with pipx and
+rewrites ``agentic-dev-loop/.engine-version`` to the installed version, so
+the host install and the committed pin converge in one action. Tests drive
+the real function with stub executables on PATH - no network, no mocks of
+the upgrade logic.
+"""
+
+import os
+from pathlib import Path
+
+import pytest
+
+from agentic_dev_loop.engine.onboarding.upgrade import run_upgrade
+
+
+def _make_stub(bin_dir: Path, name: str, body: str) -> None:
+    path = bin_dir / name
+    path.write_text(f"#!/bin/bash\n{body}\n")
+    path.chmod(0o755)
+    if not os.access(path, os.X_OK):
+        pytest.skip("tmp filesystem is mounted noexec; stub executables cannot run")
+
+
+def _env_with(bin_dir: Path | None = None) -> dict:
+    entries = ["/usr/bin", "/bin"]
+    if bin_dir is not None:
+        entries.insert(0, str(bin_dir))
+    return {**os.environ, "PATH": ":".join(entries)}
+
+
+def _stub_env(tmp_path: Path, *, pipx_body: str, cli_body: str) -> Path:
+    bin_dir = tmp_path / "bin"
+    bin_dir.mkdir()
+    _make_stub(bin_dir, "pipx", pipx_body)
+    _make_stub(bin_dir, "agentic-dev-loop", cli_body)
+    return bin_dir
+
+
+def test_upgrade_installs_latest_and_writes_pin(tmp_path, capsys):
+    pipx_log = tmp_path / "pipx.log"
+    bin_dir = _stub_env(
+        tmp_path,
+        pipx_body=f'echo "$*" >> "{pipx_log}"',
+        cli_body='echo "agentic-dev-loop 0.10.4"',
+    )
+
+    code = run_upgrade([], workspace=tmp_path, env=_env_with(bin_dir))
+
+    assert code == 0
+    assert pipx_log.read_text().strip() == "install --force agentic-dev-loop"
+    pin = tmp_path / "agentic-dev-loop" / ".engine-version"
+    assert pin.read_text(encoding="utf-8") == "0.10.4\n"
+    assert "upgraded agentic-dev-loop to 0.10.4" in capsys.readouterr().out
+
+
+def test_upgrade_overwrites_existing_pin(tmp_path):
+    out = tmp_path / "agentic-dev-loop"
+    out.mkdir()
+    (out / ".engine-version").write_text("0.10.2\n", encoding="utf-8")
+    bin_dir = _stub_env(
+        tmp_path,
+        pipx_body="exit 0",
+        cli_body='echo "agentic-dev-loop 0.10.4"',
+    )
+
+    code = run_upgrade([], workspace=tmp_path, env=_env_with(bin_dir))
+
+    assert code == 0
+    assert (out / ".engine-version").read_text(encoding="utf-8") == "0.10.4\n"
+
+
+def test_upgrade_pipx_failure_is_loud(tmp_path, capsys):
+    bin_dir = _stub_env(
+        tmp_path,
+        pipx_body="echo index-unreachable >&2; exit 1",
+        cli_body='echo "agentic-dev-loop 0.10.4"',
+    )
+
+    code = run_upgrade([], workspace=tmp_path, env=_env_with(bin_dir))
+
+    assert code == 1
+    captured = capsys.readouterr()
+    assert "index-unreachable" in captured.err
+    assert not (tmp_path / "agentic-dev-loop" / ".engine-version").exists()
+
+
+def test_upgrade_version_read_failure_is_loud(tmp_path, capsys):
+    bin_dir = _stub_env(
+        tmp_path,
+        pipx_body="exit 0",
+        cli_body="echo version-unknown >&2; exit 1",
+    )
+
+    code = run_upgrade([], workspace=tmp_path, env=_env_with(bin_dir))
+
+    assert code == 1
+    assert "could not read the installed version" in capsys.readouterr().err
+    assert not (tmp_path / "agentic-dev-loop" / ".engine-version").exists()
+
+
+def test_upgrade_unparseable_version_is_loud(tmp_path, capsys):
+    bin_dir = _stub_env(
+        tmp_path,
+        pipx_body="exit 0",
+        cli_body='echo "agentic-dev-loop nope"',
+    )
+
+    code = run_upgrade([], workspace=tmp_path, env=_env_with(bin_dir))
+
+    assert code == 1
+    assert "unreadable version" in capsys.readouterr().err
+    assert not (tmp_path / "agentic-dev-loop" / ".engine-version").exists()
+
+
+def test_upgrade_missing_pipx_is_loud(tmp_path, capsys):
+    bin_dir = tmp_path / "bin"
+    bin_dir.mkdir()
+    _make_stub(bin_dir, "agentic-dev-loop", 'echo "agentic-dev-loop 0.10.4"')
+
+    code = run_upgrade([], workspace=tmp_path, env=_env_with(bin_dir))
+
+    assert code == 1
+    assert "pipx is not on PATH" in capsys.readouterr().err

{agentic_dev_loop-0.10.4 → agentic_dev_loop-0.10.5}/tests/test_publish.py

@@ -73,11 +73,21 @@ def make_repo(tmp_path: Path, version: str = "0.2.0", unreleased: str = "",
     return repo, bare
 
 
-def run_publish(repo: Path, *args: str) -> subprocess.CompletedProcess:
+def run_publish(repo: Path, *args: str, yes: bool = True,
+                stdin=None, input=None) -> subprocess.CompletedProcess:
+    """Drive the CLI. Real cuts pass --yes by default so they skip the
+    release-note confirmation prompt; pass yes=False with stdin=DEVNULL
+    (closed) or input='y\\n' (typed answer) to test the prompt."""
+    cmd = [sys.executable, str(PUBLISH), "--cwd", str(repo)]
+    if yes:
+        cmd.append("--yes")
+    cmd.extend(args)
     return subprocess.run(
-        [sys.executable, str(PUBLISH), "--cwd", str(repo), *args],
+        cmd,
         capture_output=True,
         text=True,
+        stdin=stdin,
+        input=input,
         env={**os.environ,
              "GIT_AUTHOR_NAME": "t", "GIT_AUTHOR_EMAIL": "t@example.com",
              "GIT_COMMITTER_NAME": "t", "GIT_COMMITTER_EMAIL": "t@example.com"},
@@ -207,13 +217,17 @@ class TestChangelog:
         assert "feat: alpha" in section
         assert "fix: beta" in section
 
-    def test_inferred_includes_uncommitted_work(self, tmp_path):
+    def test_dirty_tree_reported_but_not_in_changelog(self, tmp_path):
         repo, _ = make_repo(tmp_path)
         (repo / "extra.txt").write_text("uncommitted")
         proc = run_publish(repo, "--patch")
         assert proc.returncode == 0, proc.stderr
         text = read_changelog(repo)
-        assert "extra.txt" in text[text.index("## [0.2.1]"):]
+        assert "extra.txt" not in text[text.index("## [0.2.1]"):]
+        assert "extra.txt" in proc.stdout  # reported in the cut report only
+        assert _git(repo, "status", "--porcelain").stdout == ""
+        assert "extra.txt" in _git(repo, "show", "--stat", "--oneline",
+                                   "HEAD").stdout
 
     def test_missing_unreleased_heading_fails(self, tmp_path):
         repo, _ = make_repo(tmp_path)
@@ -225,6 +239,64 @@ class TestChangelog:
         assert "Unreleased" in proc.stderr
         assert read_version(repo) == "0.2.0"
 
+    def test_dry_run_shows_rendered_section(self, tmp_path):
+        """The dry run is the notes preview: it prints the rendered release
+        section so the /publish flow can ask for approval before the cut."""
+        repo, _ = make_repo(tmp_path, commits=(("a.txt", "a\n", "feat: alpha"),))
+        proc = run_publish(repo, "--patch", "--dry-run", yes=False)
+        assert proc.returncode == 0, proc.stderr
+        assert "Release notes to be written:" in proc.stdout
+        assert "## [0.2.1]" in proc.stdout
+        assert "feat: alpha" in proc.stdout
+
+
+class TestReleaseConfirmation:
+    def test_closed_stdin_without_yes_fails(self, tmp_path):
+        repo, _ = make_repo(tmp_path)
+        proc = run_publish(repo, "--patch", yes=False, stdin=subprocess.DEVNULL)
+        assert proc.returncode != 0
+        assert "--yes" in proc.stderr
+        assert read_version(repo) == "0.2.0"
+        assert tags(repo) == []
+        assert last_subject(repo) == "chore: initial"
+
+    def test_declined_confirmation_aborts(self, tmp_path):
+        repo, _ = make_repo(tmp_path)
+        proc = run_publish(repo, "--patch", yes=False, input="n\n")
+        assert proc.returncode != 0
+        assert "aborted" in proc.stderr.lower()
+        assert read_version(repo) == "0.2.0"
+        assert tags(repo) == []
+        assert last_subject(repo) == "chore: initial"
+
+    def test_confirmed_cut_proceeds(self, tmp_path):
+        repo, _ = make_repo(tmp_path)
+        proc = run_publish(repo, "--patch", yes=False, input="y\n")
+        assert proc.returncode == 0, proc.stderr
+        assert read_version(repo) == "0.2.1"
+        assert tags(repo) == ["v0.2.1"]
+
+    def test_prompt_shows_rendered_entry(self, tmp_path):
+        repo, _ = make_repo(tmp_path, commits=(("a.txt", "a", "feat: alpha"),))
+        proc = run_publish(repo, "--patch", yes=False, input="y\n")
+        assert proc.returncode == 0, proc.stderr
+        assert "## [0.2.1]" in proc.stdout
+        assert "feat: alpha" in proc.stdout
+
+    def test_yes_flag_skips_prompt(self, tmp_path):
+        repo, _ = make_repo(tmp_path)
+        proc = run_publish(repo, "--patch", yes=True, stdin=subprocess.DEVNULL)
+        assert proc.returncode == 0, proc.stderr
+        assert read_version(repo) == "0.2.1"
+
+    def test_dry_run_needs_no_confirmation(self, tmp_path):
+        repo, _ = make_repo(tmp_path)
+        proc = run_publish(repo, "--patch", "--dry-run", yes=False,
+                           stdin=subprocess.DEVNULL)
+        assert proc.returncode == 0, proc.stderr
+        assert read_version(repo) == "0.2.0"
+        assert tags(repo) == []
+
 
 class TestConsumerAdoption:
     def test_marker_without_adoption_section_fails(self, tmp_path):
@@ -255,6 +327,16 @@ class TestConsumerAdoption:
         assert proc.returncode == 0, proc.stderr
         assert read_version(repo) == "0.2.1"
 
+    def test_plan_number_reference_without_marker_passes(self, tmp_path):
+        """Number-only plan mentions do not trigger the gate: consumers need
+        the concrete list of changes in the subsection, not plan references."""
+        repo, _ = make_repo(
+            tmp_path,
+            unreleased="### Changed\n\n- fix: 056 slug matching in the loader\n",
+        )
+        proc = run_publish(repo, "--patch", "--dry-run")
+        assert proc.returncode == 0, proc.stderr
+
     def test_no_marker_passes_without_section(self, tmp_path):
         repo, _ = make_repo(
             tmp_path,
@@ -341,6 +423,35 @@ class TestGitOps:
         assert last_subject(repo) == "chore: initial"
 
 
+class TestNoAdd:
+    def test_no_add_excludes_unstaged_files(self, tmp_path):
+        """--no-add commits only the files publish.py writes; the WIP stays
+        uncommitted in the tree instead of being swept into the release."""
+        repo, _ = make_repo(tmp_path, commits=(("extra.txt", "old\n",
+                                                "feat: alpha"),))
+        (repo / "extra.txt").write_text("dirty\n")
+        proc = run_publish(repo, "--patch", "--no-add")
+        assert proc.returncode == 0, proc.stderr
+        assert read_version(repo) == "0.2.1"
+        assert "v0.2.1" in tags(repo)
+        assert last_subject(repo) == "release: v0.2.1"
+        committed = _git(repo, "show", "--pretty=format:", "--name-only",
+                         "HEAD").stdout.split()
+        assert "pyproject.toml" in committed
+        assert "CHANGELOG.md" in committed
+        assert "extra.txt" not in committed
+        assert (repo / "extra.txt").read_text() == "dirty\n"
+        assert "extra.txt" in _git(repo, "status", "--porcelain").stdout
+
+    def test_no_add_dry_run_reports_exclusion(self, tmp_path):
+        repo, _ = make_repo(tmp_path)
+        (repo / "extra.txt").write_text("dirty\n")
+        proc = run_publish(repo, "--patch", "--dry-run", "--no-add",
+                           yes=False)
+        assert proc.returncode == 0, proc.stderr
+        assert "excluded from the release commit" in proc.stdout
+
+
 class TestArgs:
     def test_no_selector_fails(self, tmp_path):
         repo, _ = make_repo(tmp_path)
@@ -353,3 +464,48 @@ class TestArgs:
         proc = run_publish(repo, "--major", "--minor")
         assert proc.returncode != 0
         assert read_version(repo) == "0.2.0"
+
+
+class TestPublishCommandFile:
+    """The /publish command file is the source of truth for the release flow.
+
+    Shell blocks in a command file run when OpenCode evaluates the command,
+    before the agent sees the prompt, so a real (non-dry-run) publish must
+    never live in a shell block. Confirmation must route through the
+    `question` tool instead of publish.py's stdin prompt, which has no
+    stdin to read when the command runs in a session.
+    """
+
+    COMMAND_FILE = REPO_ROOT / ".opencode" / "commands" / "publish.md"
+
+    def test_real_publish_never_runs_in_shell_block(self):
+        text = self.COMMAND_FILE.read_text()
+        for line in text.splitlines():
+            if line.strip().startswith("!") and "publish.py" in line:
+                assert "--dry-run" in line, (
+                    "a publish.py shell block without --dry-run would cut "
+                    "a release before the user is asked: %r" % line
+                )
+
+    def test_confirmation_routes_through_question_tool(self):
+        text = self.COMMAND_FILE.read_text()
+        assert "`question` tool" in text
+
+    def test_mandate_present(self):
+        text = self.COMMAND_FILE.read_text()
+        assert "### Consumer adoption" in text
+        assert "CONSUMER_ADOPTION_PLANS" in text
+
+    def test_unstaged_files_confirmation_present(self):
+        """The flow must ask whether the reported uncommitted files are
+        added to the release commit before the cut."""
+        text = self.COMMAND_FILE.read_text()
+        assert "uncommitted files" in text
+        assert "--no-add" in text
+
+    def test_notes_happiness_confirmation_present(self):
+        """The flow must ask whether the user is happy with the rendered
+        release notes, and offer a changes loop."""
+        text = self.COMMAND_FILE.read_text()
+        assert "happy" in text
+        assert "--description" in text