threadkeeper 0.9.1__tar.gz → 0.10.0__tar.gz

{threadkeeper-0.9.1 → threadkeeper-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: threadkeeper
-Version: 0.9.1
+Version: 0.10.0
 Summary: Multi-agent shared brain across Claude Code/Desktop, Codex, Gemini, Copilot, VS Code. Cross-session memory, self-improving skill loops, inter-agent signaling — one local MCP server.
 Author: thread-keeper contributors
 License: MIT
@@ -96,6 +96,12 @@ make it more than a memory store:
   `THREADKEEPER_EXTRA_SKILLS_DIRS`, and `~/.threadkeeper/skills/`),
   with lessons.md as a fallback for CLIs without a native skills loader.
 
+Foreground MCP servers also run a daily self-update check by default. Source
+checkouts fast-forward their tracked git branch and reinstall the editable
+package; PyPI/pipx/venv installs run `pip install --upgrade` in the current
+interpreter environment. Dirty or diverged git checkouts are skipped rather
+than overwritten.
+
 ---
 
 ## Quickstart
@@ -206,23 +212,56 @@ or compact text for external monitors:
 ```sh
 tk-agent-status
 tk-agent-status --json
+tk-agent-status --cleanup-memory
 ```
 
 `apps/macos-agent-status/` contains a small macOS menu-bar app that polls this
 command every 5 seconds and shows every autonomous learning loop: enabled/off,
 running/idle/ready, last pass, backlog, and active child RSS when that loop has
-spawned a worker. Active loops are sorted first (`running`, then `ready`), so
-background work stays at the top of the panel. The app also requests macOS
-notification permission and sends a notification when a newly completed
+spawned a worker. PyPI wheels and sdists also bundle the same Swift source under
+`threadkeeper/assets/macos-agent-status/`, so a normal `pipx`/`uv tool` install
+does not need a git checkout for the widget to build. Active loops are sorted
+first (`running`, then `ready`), so background work stays at the top of the
+panel. `tk-agent-status --cleanup-memory` runs the safe cleanup path used by the
+widget: request server cache trims, apply the RSS guard, and remove orphan MCP
+server processes without killing active spawned child agents. The menu-bar
+status item is backed by AppKit `NSStatusItem`: it shows the black `memorychip`
+icon while idle, then swaps fixed-center, synchronized gear frames whenever
+`running_loop_count` reports at least one active autonomous loop. The status item is
+icon-only; loop counts live in the popover and tooltip. The app also has a Clean
+memory button, self-restarts when its own RSS crosses
+`THREADKEEPER_MENUBAR_RESTART_RSS_MB` (1024 MB default), requests macOS
+notification permission, and sends a notification when a newly completed
 autonomous child task produces a useful result in `recent_results`; the first
 poll only marks existing results as seen, so old completions do not spam
-notifications. Probe backlog is due objective probes only, not every registered
-probe, so a healthy cooldown shows `0 due probes` instead of looking stuck. On
-macOS, `python -m threadkeeper.server` automatically installs and launches it
-on MCP startup. Set `THREADKEEPER_MENUBAR_AUTO_LAUNCH=0` to disable that
-behavior.
-
-Manual fallback:
+notifications. Probe backlog is due objective
+probes only, not every registered probe, so a healthy cooldown shows `0 due
+probes` instead of looking stuck. On macOS, `python -m threadkeeper.server`
+automatically installs and launches it on MCP startup, and restarts the app when
+the installed bundle has changed while an older menu-bar process is still
+running. Set
+`THREADKEEPER_MENUBAR_AUTO_LAUNCH=0` to disable that behavior.
+
+### Auto Update
+
+The MCP server starts an auto-update daemon in foreground parent processes.
+By default it checks once per day (`THREADKEEPER_AUTO_UPDATE_INTERVAL_S=86400`):
+
+- editable git checkout: skip if tracked files are dirty, otherwise fetch the
+  tracked remote branch, fast-forward with `git pull --ff-only`, reinstall the
+  editable package, and rerun `threadkeeper._setup`;
+- installed package: run `pip install --upgrade threadkeeper` or
+  `threadkeeper[semantic]` in the current interpreter environment, preserving
+  semantic extras when they are already installed, then rerun setup when the
+  installed version changes.
+
+After a successful update, the daemon exits the current MCP process by default
+so the host can restart it on the new code. Disable that with
+`THREADKEEPER_AUTO_UPDATE_RESTART=0`, or disable the updater entirely with
+`THREADKEEPER_AUTO_UPDATE_INTERVAL_S=0`. Each real check records an
+`auto_update_pass` event that appears in dashboard/status telemetry.
+
+Manual fallback from a source checkout:
 
 ```sh
 cd apps/macos-agent-status
@@ -510,6 +549,9 @@ The most-used env knobs (full list in `threadkeeper/config.py`):
 |---|---|---|
 | `THREADKEEPER_DB` | `~/.threadkeeper/db.sqlite` | SQLite file |
 | `THREADKEEPER_AUTO_REVIEW` | "" (off) | auto-review on `close_thread` |
+| `THREADKEEPER_AUTO_UPDATE_INTERVAL_S` | 86400 | MCP self-update check interval; 0 disables |
+| `THREADKEEPER_AUTO_UPDATE_RESTART` | "1" | exit MCP process after applying an update so the host restarts on new code |
+| `THREADKEEPER_AUTO_UPDATE_TIMEOUT_S` | 600 | max seconds for git/pip update commands |
 | `THREADKEEPER_SHADOW_REVIEW_INTERVAL_S` | 0 (off) | shadow daemon tick (s) |
 | `THREADKEEPER_SHADOW_REVIEW_WINDOW_S` | 900 | sliding window for shadow scan (s) |
 | `THREADKEEPER_EXTRACT_INTERVAL_S` | 0 (off) | extract daemon tick (s); 600 = 10 min recommended |
@@ -523,6 +565,7 @@ The most-used env knobs (full list in `threadkeeper/config.py`):
 | `THREADKEEPER_PROBE_COOLDOWN_S` | 604800 | per-category probe cooldown; 86400 = 1d recommended for active reliability tracking |
 | `THREADKEEPER_SPAWN_BUDGET_MB` | 3072 | combined child RSS cap (MB); 0 disables |
 | `THREADKEEPER_MENUBAR_AUTO_LAUNCH` | true | macOS: auto install/launch status menu-bar app on MCP startup |
+| `THREADKEEPER_MENUBAR_RESTART_RSS_MB` | 1024 | macOS widget self-restart RSS threshold; 0 disables |
 | `THREADKEEPER_MEMORY_GUARD_POLL_S` | 30 | server RSS guard tick (s); 0 disables |
 | `THREADKEEPER_MEMORY_GUARD_WARN_MB` | 1536 | notify/log when a server crosses this RSS |
 | `THREADKEEPER_MEMORY_GUARD_KILL_MB` | 3072 | SIGTERM server above this RSS; 0 disables killing |

{threadkeeper-0.9.1 → threadkeeper-0.10.0}/README.md

@@ -55,6 +55,12 @@ make it more than a memory store:
   `THREADKEEPER_EXTRA_SKILLS_DIRS`, and `~/.threadkeeper/skills/`),
   with lessons.md as a fallback for CLIs without a native skills loader.
 
+Foreground MCP servers also run a daily self-update check by default. Source
+checkouts fast-forward their tracked git branch and reinstall the editable
+package; PyPI/pipx/venv installs run `pip install --upgrade` in the current
+interpreter environment. Dirty or diverged git checkouts are skipped rather
+than overwritten.
+
 ---
 
 ## Quickstart
@@ -165,23 +171,56 @@ or compact text for external monitors:
 ```sh
 tk-agent-status
 tk-agent-status --json
+tk-agent-status --cleanup-memory
 ```
 
 `apps/macos-agent-status/` contains a small macOS menu-bar app that polls this
 command every 5 seconds and shows every autonomous learning loop: enabled/off,
 running/idle/ready, last pass, backlog, and active child RSS when that loop has
-spawned a worker. Active loops are sorted first (`running`, then `ready`), so
-background work stays at the top of the panel. The app also requests macOS
-notification permission and sends a notification when a newly completed
+spawned a worker. PyPI wheels and sdists also bundle the same Swift source under
+`threadkeeper/assets/macos-agent-status/`, so a normal `pipx`/`uv tool` install
+does not need a git checkout for the widget to build. Active loops are sorted
+first (`running`, then `ready`), so background work stays at the top of the
+panel. `tk-agent-status --cleanup-memory` runs the safe cleanup path used by the
+widget: request server cache trims, apply the RSS guard, and remove orphan MCP
+server processes without killing active spawned child agents. The menu-bar
+status item is backed by AppKit `NSStatusItem`: it shows the black `memorychip`
+icon while idle, then swaps fixed-center, synchronized gear frames whenever
+`running_loop_count` reports at least one active autonomous loop. The status item is
+icon-only; loop counts live in the popover and tooltip. The app also has a Clean
+memory button, self-restarts when its own RSS crosses
+`THREADKEEPER_MENUBAR_RESTART_RSS_MB` (1024 MB default), requests macOS
+notification permission, and sends a notification when a newly completed
 autonomous child task produces a useful result in `recent_results`; the first
 poll only marks existing results as seen, so old completions do not spam
-notifications. Probe backlog is due objective probes only, not every registered
-probe, so a healthy cooldown shows `0 due probes` instead of looking stuck. On
-macOS, `python -m threadkeeper.server` automatically installs and launches it
-on MCP startup. Set `THREADKEEPER_MENUBAR_AUTO_LAUNCH=0` to disable that
-behavior.
-
-Manual fallback:
+notifications. Probe backlog is due objective
+probes only, not every registered probe, so a healthy cooldown shows `0 due
+probes` instead of looking stuck. On macOS, `python -m threadkeeper.server`
+automatically installs and launches it on MCP startup, and restarts the app when
+the installed bundle has changed while an older menu-bar process is still
+running. Set
+`THREADKEEPER_MENUBAR_AUTO_LAUNCH=0` to disable that behavior.
+
+### Auto Update
+
+The MCP server starts an auto-update daemon in foreground parent processes.
+By default it checks once per day (`THREADKEEPER_AUTO_UPDATE_INTERVAL_S=86400`):
+
+- editable git checkout: skip if tracked files are dirty, otherwise fetch the
+  tracked remote branch, fast-forward with `git pull --ff-only`, reinstall the
+  editable package, and rerun `threadkeeper._setup`;
+- installed package: run `pip install --upgrade threadkeeper` or
+  `threadkeeper[semantic]` in the current interpreter environment, preserving
+  semantic extras when they are already installed, then rerun setup when the
+  installed version changes.
+
+After a successful update, the daemon exits the current MCP process by default
+so the host can restart it on the new code. Disable that with
+`THREADKEEPER_AUTO_UPDATE_RESTART=0`, or disable the updater entirely with
+`THREADKEEPER_AUTO_UPDATE_INTERVAL_S=0`. Each real check records an
+`auto_update_pass` event that appears in dashboard/status telemetry.
+
+Manual fallback from a source checkout:
 
 ```sh
 cd apps/macos-agent-status
@@ -469,6 +508,9 @@ The most-used env knobs (full list in `threadkeeper/config.py`):
 |---|---|---|
 | `THREADKEEPER_DB` | `~/.threadkeeper/db.sqlite` | SQLite file |
 | `THREADKEEPER_AUTO_REVIEW` | "" (off) | auto-review on `close_thread` |
+| `THREADKEEPER_AUTO_UPDATE_INTERVAL_S` | 86400 | MCP self-update check interval; 0 disables |
+| `THREADKEEPER_AUTO_UPDATE_RESTART` | "1" | exit MCP process after applying an update so the host restarts on new code |
+| `THREADKEEPER_AUTO_UPDATE_TIMEOUT_S` | 600 | max seconds for git/pip update commands |
 | `THREADKEEPER_SHADOW_REVIEW_INTERVAL_S` | 0 (off) | shadow daemon tick (s) |
 | `THREADKEEPER_SHADOW_REVIEW_WINDOW_S` | 900 | sliding window for shadow scan (s) |
 | `THREADKEEPER_EXTRACT_INTERVAL_S` | 0 (off) | extract daemon tick (s); 600 = 10 min recommended |
@@ -482,6 +524,7 @@ The most-used env knobs (full list in `threadkeeper/config.py`):
 | `THREADKEEPER_PROBE_COOLDOWN_S` | 604800 | per-category probe cooldown; 86400 = 1d recommended for active reliability tracking |
 | `THREADKEEPER_SPAWN_BUDGET_MB` | 3072 | combined child RSS cap (MB); 0 disables |
 | `THREADKEEPER_MENUBAR_AUTO_LAUNCH` | true | macOS: auto install/launch status menu-bar app on MCP startup |
+| `THREADKEEPER_MENUBAR_RESTART_RSS_MB` | 1024 | macOS widget self-restart RSS threshold; 0 disables |
 | `THREADKEEPER_MEMORY_GUARD_POLL_S` | 30 | server RSS guard tick (s); 0 disables |
 | `THREADKEEPER_MEMORY_GUARD_WARN_MB` | 1536 | notify/log when a server crosses this RSS |
 | `THREADKEEPER_MEMORY_GUARD_KILL_MB` | 3072 | SIGTERM server above this RSS; 0 disables killing |

{threadkeeper-0.9.1 → threadkeeper-0.10.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "threadkeeper"
-version = "0.9.1"
+version = "0.10.0"
 description = "Multi-agent shared brain across Claude Code/Desktop, Codex, Gemini, Copilot, VS Code. Cross-session memory, self-improving skill loops, inter-agent signaling — one local MCP server."
 requires-python = ">=3.11"
 authors = [{ name = "thread-keeper contributors" }]
@@ -78,6 +78,15 @@ tk-agent-status = "threadkeeper.agent_status:main"
 include = ["threadkeeper*"]
 exclude = ["tests*", "scripts*"]
 
+[tool.setuptools.package-data]
+threadkeeper = [
+    "assets/macos-agent-status/Info.plist",
+    "assets/macos-agent-status/README.md",
+    "assets/macos-agent-status/ThreadKeeperAgentStatus.swift",
+    "assets/macos-agent-status/build.sh",
+    "assets/macos-agent-status/install.sh",
+]
+
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 addopts = "-q --strict-markers"

{threadkeeper-0.9.1 → threadkeeper-0.10.0}/tests/test_agent_status.py

@@ -87,6 +87,8 @@ def test_agent_status_snapshot_reports_running_agents(mp_with_cid):
     assert by_id["tk_generic"]["name"] == "child-tk"
     assert by_id["tk_generic"]["description"].startswith("Spawned child task")
     by_loop = {loop["id"]: loop for loop in snap["loops"]}
+    assert "auto_update" in by_loop
+    assert "daily updates" in by_loop["auto_update"]["description"]
     assert "Reviews extracted conversation candidates" in by_loop[
         "candidate_reviewer"
     ]["description"]
@@ -273,6 +275,145 @@ def test_agent_status_mcp_json_output(mp_with_cid):
     assert data["agents"][0]["rss_mb"] == 100
 
 
+def test_agent_memory_cleanup_runs_guard_and_orphan_cleanup(mp_with_cid, monkeypatch):
+    pkg = mp_with_cid(_FAKE_CID)
+    from threadkeeper import agent_status, memory_guard, process_health
+
+    _insert_task(pkg, "tk_status", "Build a compact menu-bar status app.", rss_mb=100)
+    calls = []
+    monkeypatch.setattr(agent_status, "_refresh_rss", lambda conn: calls.append("refresh"))
+    monkeypatch.setattr(
+        memory_guard,
+        "request_reclaim",
+        lambda reason: calls.append(("trim", reason)) or {
+            "requested": [11, 22],
+            "count": 2,
+            "reason": reason,
+        },
+    )
+    monkeypatch.setattr(
+        memory_guard,
+        "check_once",
+        lambda dry_run, notify: calls.append(("guard", dry_run, notify)) or {
+            "warn": [{}],
+            "kill": [{}],
+            "killed": [33],
+            "retired": [44],
+            "failed": [],
+            "aggregate": {"warn": True, "rss_mb": 2048},
+            "reclaim_requests": {"count": 1, "requested": [55]},
+            "local_reclaim": {
+                "before_mb": 1500,
+                "after_mb": 900,
+                "freed_mb": 600,
+            },
+            "handled_controls": [],
+        },
+    )
+    monkeypatch.setattr(
+        process_health,
+        "cleanup",
+        lambda dry_run, force: calls.append(("orphans", dry_run, force)) or {
+            "orphans": [{"pid": 66}],
+            "killed": [66],
+            "failed": [],
+        },
+    )
+
+    result = agent_status.memory_cleanup(dry_run=False, force=True)
+    text = agent_status.format_memory_cleanup(result)
+
+    assert result["peer_trim_requested"]["count"] == 2
+    assert result["guard"]["killed"] == [33]
+    assert result["guard"]["retired"] == [44]
+    assert result["orphans"]["killed"] == [66]
+    assert ("guard", False, False) in calls
+    assert ("orphans", False, True) in calls
+    assert "local_reclaim before=1500MB after=900MB freed=600MB" in text
+
+
+def test_agent_memory_cleanup_dry_run_does_not_request_peer_trim(
+    mp_with_cid,
+    monkeypatch,
+):
+    mp_with_cid(_FAKE_CID)
+    from threadkeeper import agent_status, memory_guard, process_health
+
+    calls = []
+    monkeypatch.setattr(agent_status, "_refresh_rss", lambda conn: None)
+    monkeypatch.setattr(
+        memory_guard,
+        "request_reclaim",
+        lambda reason: calls.append(("trim", reason)) or {
+            "requested": [11],
+            "count": 1,
+            "reason": reason,
+        },
+    )
+    monkeypatch.setattr(
+        memory_guard,
+        "check_once",
+        lambda dry_run, notify: {
+            "warn": [],
+            "kill": [],
+            "killed": [],
+            "retired": [],
+            "failed": [],
+            "aggregate": {},
+            "reclaim_requests": {},
+            "local_reclaim": None,
+            "handled_controls": [],
+        },
+    )
+    monkeypatch.setattr(
+        process_health,
+        "cleanup",
+        lambda dry_run, force: {"orphans": [], "killed": [], "failed": []},
+    )
+
+    result = agent_status.memory_cleanup(dry_run=True)
+
+    assert result["dry_run"] is True
+    assert result["peer_trim_requested"]["count"] == 0
+    assert calls == []
+
+
+def test_agent_memory_cleanup_tool_json_output(mp_with_cid, monkeypatch):
+    pkg = mp_with_cid(_FAKE_CID)
+    from threadkeeper import agent_status as agent_status_mod
+
+    monkeypatch.setattr(
+        "threadkeeper.tools.agent_status.memory_cleanup",
+        lambda dry_run, force: {
+            "dry_run": dry_run,
+            "force": force,
+            "before": {"running_count": 0, "child_rss_mb": 0},
+            "after": {"running_count": 0, "child_rss_mb": 0},
+            "peer_trim_requested": {"requested": [], "count": 0},
+            "guard": {
+                "warn": 0,
+                "kill": 0,
+                "killed": [],
+                "retired": [],
+                "failed": [],
+                "local_reclaim": None,
+            },
+            "orphans": {"count": 0, "killed": [], "failed": []},
+        },
+    )
+
+    raw = _tool(pkg, "agent_memory_cleanup")(
+        json_output=True,
+        dry_run=True,
+        force=True,
+    )
+    data = json.loads(raw)
+
+    assert data["dry_run"] is True
+    assert data["force"] is True
+    assert agent_status_mod.format_memory_cleanup(data).startswith("dry_run:")
+
+
 def test_agent_status_text_output(mp_with_cid):
     pkg = mp_with_cid(_FAKE_CID)
     _insert_task(pkg, "tk_status", "Build a compact menu-bar status app.", rss_mb=100)

threadkeeper-0.10.0/tests/test_auto_update.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+import sys
+import time
+from pathlib import Path
+from types import SimpleNamespace
+
+
+def _bootstrap(tmp_path, monkeypatch, *, interval="86400", disable_bg="1"):
+    env = {
+        "THREADKEEPER_DB": str(tmp_path / "db.sqlite"),
+        "CLAUDE_PROJECTS_DIR": str(tmp_path / "fake_claude_projects"),
+        "THREADKEEPER_AUTO_UPDATE_INTERVAL_S": interval,
+        "THREADKEEPER_AUTO_UPDATE_RESTART": "0",
+        "THREADKEEPER_DISABLE_BG_DAEMONS": disable_bg,
+        "THREADKEEPER_INGEST_INTERVAL_S": "0",
+        "THREADKEEPER_INGEST_CAP": "0",
+        "THREADKEEPER_SKILL_WATCH_INTERVAL_S": "0",
+        "THREADKEEPER_SPAWN_BUDGET_POLL_S": "0",
+        "THREADKEEPER_MEMORY_GUARD_POLL_S": "0",
+        "THREADKEEPER_SEARCH_PROXY_POLL_S": "0",
+        "THREADKEEPER_SHADOW_REVIEW_INTERVAL_S": "0",
+        "THREADKEEPER_CURATOR_INTERVAL_S": "0",
+        "THREADKEEPER_EXTRACT_INTERVAL_S": "0",
+        "THREADKEEPER_CANDIDATE_REVIEW_INTERVAL_S": "0",
+        "THREADKEEPER_PROBE_INTERVAL_S": "0",
+        "THREADKEEPER_EVOLVE_REVIEW_INTERVAL_S": "0",
+        "THREADKEEPER_THREAD_JANITOR_INTERVAL_S": "0",
+        "THREADKEEPER_TASK_LOG_DIR": str(tmp_path / "tasks"),
+        "THREADKEEPER_CLIENT": "pytest",
+        "THREADKEEPER_NO_EMBEDDINGS": "1",
+    }
+    for key, value in env.items():
+        monkeypatch.setenv(key, value)
+    Path(env["CLAUDE_PROJECTS_DIR"]).mkdir(parents=True, exist_ok=True)
+    for name in [m for m in list(sys.modules) if m.startswith("threadkeeper")]:
+        del sys.modules[name]
+    import threadkeeper.server  # noqa: F401
+    from threadkeeper import auto_update, db
+
+    return {"auto_update": auto_update, "db": db}
+
+
+def test_disabled_without_force(tmp_path, monkeypatch):
+    pkg = _bootstrap(tmp_path, monkeypatch, interval="0")
+
+    assert pkg["auto_update"].run_auto_update_pass() == "disabled"
+
+
+def test_force_pass_records_event(tmp_path, monkeypatch):
+    pkg = _bootstrap(tmp_path, monkeypatch, interval="86400")
+    monkeypatch.setattr(
+        pkg["auto_update"],
+        "_request_and_apply_update",
+        lambda: "no_update mode=test",
+    )
+
+    out = pkg["auto_update"].run_auto_update_pass(
+        force=True,
+        restart_on_update=False,
+    )
+
+    assert out == "no_update mode=test"
+    row = pkg["db"].get_db().execute(
+        "SELECT summary FROM events WHERE kind='auto_update_pass' "
+        "ORDER BY id DESC LIMIT 1"
+    ).fetchone()
+    assert row is not None
+    assert row["summary"] == "no_update mode=test"
+
+
+def test_recent_pass_makes_daemon_tick_not_due(tmp_path, monkeypatch):
+    pkg = _bootstrap(tmp_path, monkeypatch, interval="86400")
+    conn = pkg["db"].get_db()
+    conn.execute(
+        "INSERT INTO events (session_id, kind, target, summary, created_at) "
+        "VALUES ('s', 'auto_update_pass', '', 'no_update', ?)",
+        (int(time.time()),),
+    )
+    conn.commit()
+    called = {"value": False}
+
+    def fake_update():
+        called["value"] = True
+        return "updated mode=test"
+
+    monkeypatch.setattr(pkg["auto_update"], "_request_and_apply_update", fake_update)
+
+    out = pkg["auto_update"].run_auto_update_pass(restart_on_update=False)
+
+    assert out.startswith("not_due age_s=")
+    assert called["value"] is False
+
+
+def test_git_checkout_with_dirty_tracked_files_is_skipped(tmp_path, monkeypatch):
+    pkg = _bootstrap(tmp_path, monkeypatch)
+
+    def fake_git_stdout(repo, *args, timeout=60):
+        if args[:2] == ("status", "--porcelain"):
+            return 0, " M threadkeeper/server.py", ""
+        raise AssertionError(f"unexpected git call: {args}")
+
+    monkeypatch.setattr(pkg["auto_update"], "_git_stdout", fake_git_stdout)
+
+    assert (
+        pkg["auto_update"]._update_git_checkout(tmp_path)
+        == "skipped_dirty_checkout mode=git"
+    )
+
+
+def test_pip_update_runs_setup_when_version_changes(tmp_path, monkeypatch):
+    pkg = _bootstrap(tmp_path, monkeypatch)
+    versions = iter(["0.9.2", "0.9.3"])
+    calls: list[list[str]] = []
+
+    def fake_run(args, *, cwd=None, timeout=None):
+        calls.append(args)
+        return SimpleNamespace(returncode=0, stdout="", stderr="")
+
+    monkeypatch.setattr(pkg["auto_update"], "_installed_version", lambda: next(versions))
+    monkeypatch.setattr(pkg["auto_update"], "_package_spec", lambda: "threadkeeper")
+    monkeypatch.setattr(pkg["auto_update"], "_run", fake_run)
+    monkeypatch.setattr(pkg["auto_update"], "_run_setup", lambda: " setup=ok")
+
+    out = pkg["auto_update"]._update_installed_package()
+
+    assert out == "updated mode=pip old=0.9.2 new=0.9.3 setup=ok"
+    assert calls == [
+        [sys.executable, "-m", "pip", "install", "--upgrade", "threadkeeper"]
+    ]
+
+
+def test_daemon_does_not_start_when_background_daemons_disabled(tmp_path, monkeypatch):
+    pkg = _bootstrap(tmp_path, monkeypatch, interval="86400", disable_bg="1")
+
+    pkg["auto_update"].start_auto_update_daemon()
+
+    assert pkg["auto_update"]._started is False

{threadkeeper-0.9.1 → threadkeeper-0.10.0}/tests/test_config_settings.py

@@ -31,6 +31,8 @@ def test_defaults_match(monkeypatch):
     assert c.SKILL_NUDGE_INTERVAL == 10
     assert c.BRIEF_LEAN is False
     assert c.SPAWN_BUDGET_MB == 3072
+    assert c.AUTO_UPDATE_INTERVAL_S == 86400
+    assert c.AUTO_UPDATE_RESTART is True
     assert str(c.DB_PATH).endswith("/.threadkeeper/db.sqlite")
 
 
@@ -70,6 +72,9 @@ def test_all_exported_names_present(monkeypatch):
     c = _fresh_config(monkeypatch)
     required = [
         "AUTO_REVIEW_ENABLED",
+        "AUTO_UPDATE_INTERVAL_S",
+        "AUTO_UPDATE_RESTART",
+        "AUTO_UPDATE_TIMEOUT_S",
         "BACKGROUND_DAEMONS_ALLOWED",
         "BRIEF_LEAN",
         "BRIEF_NO_THREAD_NUDGE",