tycho-cli 0.0.5__tar.gz → 0.0.7__tar.gz

{tycho_cli-0.0.5 → tycho_cli-0.0.7}/.gitignore

@@ -151,6 +151,7 @@ activemq-data/
 .env
 .envrc
 .venv
+.venv-release
 env/
 venv/
 ENV/

{tycho_cli-0.0.5 → tycho_cli-0.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tycho-cli
-Version: 0.0.5
+Version: 0.0.7
 Summary: Tycho — a free, offline, open-source local verifier that proves an AI agent actually did what it claims, from git, the filesystem, process exit codes, and the harness event stream. No account, no LLM in the trust path.
 Project-URL: Homepage, https://swail.dev/tycho
 Project-URL: Repository, https://github.com/swail-labs/tycho

{tycho_cli-0.0.5 → tycho_cli-0.0.7}/tests/test_update.py

@@ -151,8 +151,9 @@ def test_update_offline_is_reported_not_fatal(_online, monkeypatch, capsys):
 def test_update_prints_the_upgrade_command_then_runs_it(_online, monkeypatch, capsys):
     import subprocess
 
+    monkeypatch.setattr(cli.sys, "platform", "linux")  # POSIX runs the upgrade in place
     _fetches(monkeypatch, "9.9.9")
-    monkeypatch.setattr(cli, "_upgrade_command", lambda: ["echo", "upgrading"])
+    monkeypatch.setattr(cli, "_upgrade_command", lambda force=False: ["echo", "upgrading"])
     ran = {}
 
     class _Done:
@@ -165,6 +166,23 @@ def test_update_prints_the_upgrade_command_then_runs_it(_online, monkeypatch, ca
     assert ran["cmd"] == ["echo", "upgrading"]
 
 
+def test_update_on_windows_defers_the_upgrade_past_process_exit(_online, monkeypatch, capsys):
+    # A running .exe can't have its own shim replaced on Windows, so the upgrade must be deferred
+    # to a detached child that waits for us to exit — never run synchronously (TYCHO-108 follow-up).
+    import subprocess
+
+    monkeypatch.setattr(cli.sys, "platform", "win32")
+    _fetches(monkeypatch, "9.9.9")
+    monkeypatch.setattr(cli, "_upgrade_command", lambda force=False: ["uv", "tool", "upgrade", "tycho-cli"])
+    monkeypatch.setattr(subprocess, "run", lambda *a, **k: pytest.fail("must not upgrade in-process on Windows"))
+    spawned = {}
+    monkeypatch.setattr(cli, "_spawn_deferred_upgrade", lambda cmd: spawned.setdefault("cmd", list(cmd)))
+    assert cli.main(["update"]) == cli.ExitCode.OK
+    out = capsys.readouterr().out
+    assert "9.9.9" in out and "once this process exits" in out
+    assert spawned["cmd"] == ["uv", "tool", "upgrade", "tycho-cli"]
+
+
 @pytest.mark.parametrize("prefix", ["/home/u/.local/pipx/venvs/tycho-cli",
                                     "/home/u/.local/share/uv/tools/tycho-cli",
                                     "/usr"])  # pipx, uv, plain-pip branches
@@ -174,8 +192,18 @@ def test_upgrade_command_names_the_distribution_not_the_taken_tycho(monkeypatch,
     # the installed tool (TYCHO-96).
     monkeypatch.setattr(cli.sys, "prefix", prefix)
     cmd = cli._upgrade_command()
-    assert "tycho-cli" in cmd
-    assert "tycho" not in cmd  # the plain command name must never be the upgrade target
+    assert "tycho-cli" in " ".join(cmd)
+    assert "tycho" not in cmd  # the bare command name must never be a standalone upgrade target
+
+
+@pytest.mark.parametrize("prefix", ["/home/u/.local/pipx/venvs/tycho-cli",
+                                    "/home/u/.local/share/uv/tools/tycho-cli"])  # pip has no persisted pin
+def test_force_crosses_a_version_pin_plain_respects_it(monkeypatch, prefix):
+    # A user who installed `tycho-cli==X` on purpose: plain `update` must stay within that pin
+    # (`upgrade`), and only `--force` reinstalls the latest across it (`install …@latest`/`--force`).
+    monkeypatch.setattr(cli.sys, "prefix", prefix)
+    assert "upgrade" in cli._upgrade_command(force=False)
+    assert "install" in cli._upgrade_command(force=True)
 
 
 def test_update_skip_dismisses_and_counts(_online, monkeypatch, capsys):
@@ -248,3 +276,78 @@ def test_session_start_never_raises_and_prints_nothing_on_error(monkeypatch, cap
     _stdin(monkeypatch)
     assert hook.session_start() == 0  # a bootup hook must never break the session
     assert capsys.readouterr().out == ""
+
+
+# --- Stop-hook update notice (TYCHO-116) -------------------------------------
+#
+# The Stop hook appends a human-only "newer Tycho available" line to the verdict the user is
+# already reading — cache-only (no network on the hot path), never in the model-facing
+# additionalContext, and suppressed where there's no human-only channel (Cursor).
+
+from pathlib import Path as _Path  # noqa: E402
+
+_CLAUDE_FIXTURE = _Path(__file__).parent / "fixtures" / "transcript_sample.jsonl"
+
+
+def _claude_stop(repo) -> str:
+    import json
+    return json.dumps({"cwd": str(repo), "transcript_path": str(_CLAUDE_FIXTURE.resolve())})
+
+
+def test_stop_hook_appends_update_line_to_human_output(_online, tmp_path):
+    from tycho import hook
+    state.write_update_cache(latest="9.9.9", checked_at=time.time())
+    out = hook.run(_claude_stop(tmp_path))
+    assert out is not None and "9.9.9" in out["systemMessage"]  # verdict + update line, together
+
+
+def test_stop_hook_update_line_is_never_model_facing(_online, tmp_path):
+    # With the relay on there IS an additionalContext (model-facing) copy — the update line must
+    # ride only the human systemMessage, never that (TYCHO-35: don't tell the model to self-update).
+    from tycho import hook
+    state.set_relay_enabled(tmp_path, True)
+    state.write_update_cache(latest="9.9.9", checked_at=time.time())
+    out = hook.run(_claude_stop(tmp_path))
+    assert "9.9.9" in out["systemMessage"]
+    assert "9.9.9" not in out["hookSpecificOutput"]["additionalContext"]
+
+
+def test_stop_hook_silent_when_up_to_date(_online, tmp_path):
+    from tycho import hook
+    state.write_update_cache(latest=tycho.__version__, checked_at=time.time())
+    out = hook.run(_claude_stop(tmp_path))
+    assert "newer Tycho" not in out["systemMessage"]
+
+
+def test_stop_hook_respects_dismissal(_online, tmp_path):
+    from tycho import hook
+    state.write_update_cache(latest="9.9.9", checked_at=time.time())
+    state.dismiss_update("9.9.9")  # `tycho update --skip` waved this version off
+    out = hook.run(_claude_stop(tmp_path))
+    assert "9.9.9" not in out["systemMessage"]
+
+
+def test_stop_hook_silent_when_opted_out(tmp_path):
+    # conftest sets TYCHO_NO_UPDATE_CHECK=1; even a fresh cache with a newer version stays silent.
+    from tycho import hook
+    state.write_update_cache(latest="9.9.9", checked_at=time.time())
+    out = hook.run(_claude_stop(tmp_path))
+    assert out is not None and "9.9.9" not in out["systemMessage"]
+
+
+def test_stop_hook_update_notice_never_hits_the_network(_online, monkeypatch, tmp_path):
+    from tycho import hook
+    monkeypatch.setattr(version_mod, "_fetch", lambda: pytest.fail("Stop path must not hit the network"))
+    state.write_update_cache(latest="9.9.9", checked_at=time.time())
+    out = hook.run(_claude_stop(tmp_path))
+    assert "9.9.9" in out["systemMessage"]  # served from the cache only
+
+
+def test_stop_hook_suffix_suppressed_without_a_human_channel(_online):
+    # Cursor: format_output is model-facing and notice_output is None, so a notice would reach the
+    # model — suppress it, exactly as the bootup notice does (TYCHO-35/72).
+    from types import SimpleNamespace
+
+    from tycho import hook
+    state.write_update_cache(latest="9.9.9", checked_at=time.time())
+    assert hook._update_suffix(SimpleNamespace(notice_output=None)) == ""

{tycho_cli-0.0.5 → tycho_cli-0.0.7}/tycho/__init__.py

@@ -6,4 +6,4 @@ trust path. Free, open source (Apache 2.0), offline, no account needed.
 """
 
 # Alpha. Bumped to 0.1.0 for the first public release (TYCHO-10).
-__version__ = "0.0.5"
+__version__ = "0.0.7"

{tycho_cli-0.0.5 → tycho_cli-0.0.7}/tycho/cli.py

@@ -157,6 +157,7 @@ def main(argv: Sequence[str] | None = None) -> int:
     )
     up = sub.add_parser("update", help=_COMMANDS["update"])
     up.add_argument("--skip", action="store_true", help="dismiss the current update notice (records the dismissal)")
+    up.add_argument("--force", action="store_true", help="reinstall the latest even across a pinned version (uv/pipx)")
     sub.add_parser("help", help=_COMMANDS["help"])
 
     args = parser.parse_args(argv)
@@ -169,7 +170,7 @@ def main(argv: Sequence[str] | None = None) -> int:
     if args.command == "scope":
         return _scope(Path.cwd(), args.action, args.paths, args.exclude)
     if args.command == "update":
-        return _update(skip=args.skip)
+        return _update(skip=args.skip, force=args.force)
     if args.command == "relay":
         return _relay(Path.cwd(), on=args.on, off=args.off)
     if args.command in ("statusline", "status"):
@@ -363,7 +364,7 @@ def _print_update_notice() -> None:
         pass
 
 
-def _upgrade_command() -> list[str]:
+def _upgrade_command(force: bool = False) -> list[str]:
     """The upgrade command for however Tycho was installed — best-effort from the install
     path. Falls back to pip, which works for a plain `pip install` (TYCHO-10).
 
@@ -371,21 +372,26 @@ def _upgrade_command() -> list[str]:
     `tycho` on PyPI is an unrelated project, so `pip install --upgrade tycho` would pull that,
     and `pipx/uv upgrade tycho` wouldn't find the tool (installed as `tycho-cli`) — TYCHO-96.
     Single-sourced from the same constant the update check queries, so the two can't drift.
+
+    `force` reinstalls the latest even across a version pin set at install time (`uv tool
+    install tycho-cli==X` / `pipx install tycho-cli==X`). Without it, `uv tool upgrade` /
+    `pipx upgrade` only move within that pin — respecting a version the user chose on purpose.
     """
     from . import version as version_mod
 
     pkg = version_mod._DIST_NAME or "tycho-cli"
     prefix = sys.prefix.replace("\\", "/").lower()
     if "pipx" in prefix:
-        return ["pipx", "upgrade", pkg]
+        return ["pipx", "install", "--force", pkg] if force else ["pipx", "upgrade", pkg]
     if "/uv/tools/" in prefix or "/uv/" in prefix:
-        return ["uv", "tool", "upgrade", pkg]
+        return ["uv", "tool", "install", f"{pkg}@latest"] if force else ["uv", "tool", "upgrade", pkg]
     return [sys.executable, "-m", "pip", "install", "--upgrade", pkg]
 
 
-def _update(skip: bool) -> int:
+def _update(skip: bool, force: bool = False) -> int:
     """`tycho update` — check the index and upgrade in place, or `--skip` to dismiss the
-    notice for this version. Offline/failure is reported, never fatal (TYCHO-10/53)."""
+    notice for this version. `--force` reinstalls the latest across a pinned version (uv/pipx);
+    plain update respects the pin. Offline/failure is reported, never fatal (TYCHO-10/53)."""
     from . import state
     from . import version as version_mod
 
@@ -406,8 +412,23 @@ def _update(skip: bool) -> int:
     if not behind:
         print(f"tycho {__version__} is up to date.")
         return ExitCode.OK
-    cmd = _upgrade_command()
-    print(f"Updating tycho {__version__} → {newest}:  {' '.join(cmd)}")
+    cmd = _upgrade_command(force=force)
+    hint = "" if force else "  (if it's pinned and doesn't move, `tycho update --force`)"
+    if sys.platform == "win32":
+        # A running .exe can't have its own launcher shim replaced on Windows — an in-process
+        # `uv tool upgrade` fails to copy `…\.local\bin\tycho.exe` with os error 32 ("being used
+        # by another process"). So defer: a detached child waits for THIS process to exit (which
+        # releases the lock), then upgrades against a free shim. POSIX replaces a running exe fine.
+        try:
+            _spawn_deferred_upgrade(cmd)
+            print(f"Updating tycho {__version__} → {newest}. The upgrade runs once this process "
+                  f"exits; re-open your shell and run `tycho --version` to confirm.{hint}")
+            return ExitCode.OK
+        except Exception as exc:
+            print(f"tycho: couldn't schedule the upgrade ({type(exc).__name__}). Run it yourself:\n  {' '.join(cmd)}",
+                  file=sys.stderr)
+            return ExitCode.OK
+    print(f"Updating tycho {__version__} → {newest}:  {' '.join(cmd)}{hint}")
     try:
         import subprocess
 
@@ -418,6 +439,32 @@ def _update(skip: bool) -> int:
         return ExitCode.OK
 
 
+def _spawn_deferred_upgrade(cmd: Sequence[str]) -> None:
+    """Windows only: run `cmd` in a detached process that first waits for us to exit, so the
+    running tycho.exe's shim is unlocked before the upgrade copies over it (TYCHO-108 follow-up).
+
+    Waits on THIS PID (deterministic, not a fixed sleep) with a 30s ceiling, then upgrades. Fully
+    detached — no console window, survives our exit — so `tycho update` returns immediately and the
+    swap happens a beat later against a released lock."""
+    import os
+    import subprocess
+
+    ppid = os.getpid()
+    call = "& " + " ".join("'" + str(a).replace("'", "''") + "'" for a in cmd)  # PS call-operator
+    script = (
+        "$ErrorActionPreference='SilentlyContinue';"
+        f"Wait-Process -Id {ppid} -Timeout 30;"
+        f"{call}"
+    )
+    # CREATE_NO_WINDOW (no console flash) + CREATE_NEW_PROCESS_GROUP (survives our exit, ignores
+    # our console signals). NOT DETACHED_PROCESS — Windows rejects it alongside CREATE_NO_WINDOW.
+    flags = getattr(subprocess, "CREATE_NO_WINDOW", 0) | getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0)
+    subprocess.Popen(
+        ["powershell", "-NoProfile", "-NonInteractive", "-Command", script],
+        creationflags=flags, close_fds=True,
+    )
+
+
 def _install(lines: Sequence[str]) -> int:
     """Print init/uninstall status lines; exit non-zero if we refused to touch a file.
 

{tycho_cli-0.0.5 → tycho_cli-0.0.7}/tycho/hook.py

@@ -76,8 +76,33 @@ def run(stdin_text: str) -> dict | None:
         if harness.name == "opencode":
             Path(transcript).unlink(missing_ok=True)
     report = render(verdict, results)
-    relayed = _relay_output(repo, harness, verdict, report)
-    return relayed if relayed is not None else harness.format_output(report)
+    # A human-only "newer Tycho available" line, appended to the verdict the user is already
+    # reading (TYCHO-116). Cache-only — never a network call on the hot Stop path.
+    update = _update_suffix(harness)
+    relayed = _relay_output(repo, harness, verdict, report, update)
+    return relayed if relayed is not None else harness.format_output(report + update)
+
+
+def _update_suffix(harness) -> str:
+    """The Stop-hook update notice as a human-only suffix (leading blank line), or "" (TYCHO-116).
+
+    Only on harnesses with a human-only Stop channel: there, `format_output` writes the same field
+    `notice_output` does (systemMessage / message), so appending here stays human-facing. On Cursor
+    `format_output` is model-facing (`followup_message`) and `notice_output is None`, so a notice
+    would reach the model (TYCHO-35's rule) — suppress it, exactly as the bootup notice does.
+
+    Cache-only (`refresh_first=False`): the Stop path must never hit the network — the once-a-day
+    fetch is the doctor/init/bootup job. Respects opt-out + dismissal via `version.notice`. Never
+    raises: an update line is never worth breaking a Stop over."""
+    if harness.notice_output is None:
+        return ""
+    try:
+        from . import version as version_mod
+
+        note = version_mod.notice(refresh_first=False)
+        return f"\n\n{note}" if note else ""
+    except Exception:
+        return ""
 
 
 # --- verdict relay (TYCHO-35, opt-in, default OFF) --------------------------
@@ -95,12 +120,15 @@ def run(stdin_text: str) -> dict | None:
 # exactly the human-only output they always did (no agent context used, no extra generations).
 
 
-def _relay_output(repo: Path, harness, verdict, report: str) -> dict | None:
+def _relay_output(repo: Path, harness, verdict, report: str, update: str = "") -> dict | None:
     """The relay output dict, or None to fall through to the normal human-only output.
 
     Returns None (unchanged behaviour) unless the relay is enabled here, the harness is Claude,
     and the verdict is worth acting on. VERIFIED clears the streak and ends the turn (nothing to
     fix); once the streak reaches relay_max() the relay goes quiet and hands control back.
+
+    `update` is the human-only update line (TYCHO-116): it rides the human-facing `systemMessage`
+    only, never `additionalContext` — the model-facing copy must not be told to go update Tycho.
     """
     if harness.name != "claude" or not state.relay_enabled(repo):
         return None
@@ -119,10 +147,10 @@ def _relay_output(repo: Path, harness, verdict, report: str) -> dict | None:
     # relay (TYCHO-114); additionalContext is the model-facing copy that also drives the continuation.
     manage = "[TYCHO] Relay is on — the agent keeps working until VERIFIED. Manage or turn it off: `tycho relay` (/tycho-relay)."
     return {
-        "systemMessage": f"{report}\n\n{manage}",
+        "systemMessage": f"{report}\n\n{manage}{update}",  # update line is human-only
         "hookSpecificOutput": {
             "hookEventName": "Stop",
-            "additionalContext": f"{report}\n\n{guard}",
+            "additionalContext": f"{report}\n\n{guard}",  # model-facing — never the update line
         },
     }
 

{tycho_cli-0.0.5 → tycho_cli-0.0.7}/tycho-target.ps1.example

@@ -1,9 +1,11 @@
-# Toggle tycho hooks/statusline between local editable venv and global uv-tool release.
+# Toggle tycho hooks/statusline between the local editable venv (.venv, tracks live repo source)
+# and the pinned release venv (.venv-release, a fixed non-editable install). Both live in the repo
+# and are fully isolated — editing source or `tycho update`-ing one never touches the other.
 # Copy to tycho-target.ps1 (gitignored) and run from the repo root.
 # Usage: .\tycho-target.ps1   (flips)   |   .\tycho-target.ps1 local   |   .\tycho-target.ps1 release
 $settings = Join-Path $PSScriptRoot ".claude\settings.json"
 $local   = (Join-Path $PSScriptRoot ".venv\Scripts\tycho.EXE").Replace("\", "/")
-$release = (Join-Path $HOME ".local\bin\tycho.exe").Replace("\", "/")
+$release = (Join-Path $PSScriptRoot ".venv-release\Scripts\tycho.EXE").Replace("\", "/")
 
 $text = Get-Content $settings -Raw
 $isLocal = $text.Contains($local)