tycho-cli 0.0.4__tar.gz → 0.0.6__tar.gz

{tycho_cli-0.0.4 → tycho_cli-0.0.6}/.gitignore

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

{tycho_cli-0.0.4 → tycho_cli-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tycho-cli
-Version: 0.0.4
+Version: 0.0.6
 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.4 → tycho_cli-0.0.6}/tests/test_update.py

@@ -151,6 +151,7 @@ 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"])
     ran = {}
@@ -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: ["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
@@ -248,3 +266,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.4 → tycho_cli-0.0.6}/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.4"
+__version__ = "0.0.6"

{tycho_cli-0.0.4 → tycho_cli-0.0.6}/tycho/cli.py

@@ -407,6 +407,20 @@ def _update(skip: bool) -> int:
         print(f"tycho {__version__} is up to date.")
         return ExitCode.OK
     cmd = _upgrade_command()
+    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.")
+            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)}")
     try:
         import subprocess
@@ -418,6 +432,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.4 → tycho_cli-0.0.6}/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.4 → tycho_cli-0.0.6}/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)