threadkeeper 0.17.6__tar.gz → 0.17.7__tar.gz

{threadkeeper-0.17.6 → threadkeeper-0.17.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: threadkeeper
-Version: 0.17.6
+Version: 0.17.7
 Summary: Multi-agent shared brain across Claude Code/Desktop, Codex, Antigravity CLI, Copilot, and VS Code. Cross-session memory, self-improving skill loops, inter-agent signaling — one local MCP server.
 Author: thread-keeper contributors
 License: MIT
@@ -354,7 +354,10 @@ repair partial work, and continue rather than restart blindly.
 `THREADKEEPER_SPAWN_TIMEOUT_RETRY_LIMIT` (default 3; 0 disables) bounds the
 retry chain, with `THREADKEEPER_SPAWN_TIMEOUT_RETRY_DELAY_S` available for a
 non-zero delay. Timed-out children are surfaced as `tasks_timed_out` in
-`mp_dashboard` and `timed_out` in `agent_status`.
+`mp_dashboard` and `timed_out` in `agent_status`. `agent_status` and
+`tk-agent-status` are observation-only and never terminate or respawn a
+child; timeout enforcement and the continuation retry live solely in the
+spawn-budget daemon.
 
 `tk-agent-status` exposes autonomous learning loop status as structured JSON
 or compact text for external monitors:
@@ -868,10 +871,16 @@ runs as **two alternating phases**, never co-granting web research and
 shell/`bypassPermissions` to the same child:
 
 - **research phase** — a read-only child with `WebSearch`/`WebFetch` and
-  read-only repo reads but **no shell, no `bypassPermissions`, and no GitHub
-  access**. It distills external findings into a digest file under
-  `~/.threadkeeper/evolve-research/`. With no `Bash`/`gh`/network-write tool it
-  has no exfiltration channel, so the untrusted pages it reads cannot act.
+  read-only repo reads but **no shell, no generic `Write`, no
+  `bypassPermissions`, and no GitHub access**. Before dispatch, the parent
+  registers one pass ID, owner child, and digest target. The child can submit
+  only that pass through `evolve_research_handoff(...)`; it cannot choose a
+  path. The handoff is one-shot, capped at 12,000 characters / 400 lines,
+  atomically persisted with a SHA-256, and records rejected, failed, expired,
+  and tampered outcomes in Evolve telemetry. The later audit reads only a
+  fresh accepted handoff whose final file still matches that hash. With no
+  `Bash`/`gh`/network-write tool it has no exfiltration channel, so the
+  untrusted pages it reads cannot act.
 - **audit phase** — the privileged child (`bypassPermissions` + `Bash`/`Edit`/
   `Write`) that audits the repo, opens the `docs/ROADMAP.md` PR, and creates or
   updates GitHub issues. It holds **no web tools**; it consumes the research

{threadkeeper-0.17.6 → threadkeeper-0.17.7}/README.md

@@ -310,7 +310,10 @@ repair partial work, and continue rather than restart blindly.
 `THREADKEEPER_SPAWN_TIMEOUT_RETRY_LIMIT` (default 3; 0 disables) bounds the
 retry chain, with `THREADKEEPER_SPAWN_TIMEOUT_RETRY_DELAY_S` available for a
 non-zero delay. Timed-out children are surfaced as `tasks_timed_out` in
-`mp_dashboard` and `timed_out` in `agent_status`.
+`mp_dashboard` and `timed_out` in `agent_status`. `agent_status` and
+`tk-agent-status` are observation-only and never terminate or respawn a
+child; timeout enforcement and the continuation retry live solely in the
+spawn-budget daemon.
 
 `tk-agent-status` exposes autonomous learning loop status as structured JSON
 or compact text for external monitors:
@@ -824,10 +827,16 @@ runs as **two alternating phases**, never co-granting web research and
 shell/`bypassPermissions` to the same child:
 
 - **research phase** — a read-only child with `WebSearch`/`WebFetch` and
-  read-only repo reads but **no shell, no `bypassPermissions`, and no GitHub
-  access**. It distills external findings into a digest file under
-  `~/.threadkeeper/evolve-research/`. With no `Bash`/`gh`/network-write tool it
-  has no exfiltration channel, so the untrusted pages it reads cannot act.
+  read-only repo reads but **no shell, no generic `Write`, no
+  `bypassPermissions`, and no GitHub access**. Before dispatch, the parent
+  registers one pass ID, owner child, and digest target. The child can submit
+  only that pass through `evolve_research_handoff(...)`; it cannot choose a
+  path. The handoff is one-shot, capped at 12,000 characters / 400 lines,
+  atomically persisted with a SHA-256, and records rejected, failed, expired,
+  and tampered outcomes in Evolve telemetry. The later audit reads only a
+  fresh accepted handoff whose final file still matches that hash. With no
+  `Bash`/`gh`/network-write tool it has no exfiltration channel, so the
+  untrusted pages it reads cannot act.
 - **audit phase** — the privileged child (`bypassPermissions` + `Bash`/`Edit`/
   `Write`) that audits the repo, opens the `docs/ROADMAP.md` PR, and creates or
   updates GitHub issues. It holds **no web tools**; it consumes the research

{threadkeeper-0.17.6 → threadkeeper-0.17.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "threadkeeper"
-version = "0.17.6"
+version = "0.17.7"
 description = "Multi-agent shared brain across Claude Code/Desktop, Codex, Antigravity CLI, Copilot, and 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" }]

{threadkeeper-0.17.6 → threadkeeper-0.17.7}/tests/test_agent_status.py

@@ -784,3 +784,42 @@ def test_recent_failures_notify_flag_off_when_toggle_disabled(
     fails = {f["task_id"]: f for f in snap["recent_failures"]}
     assert "deadchild2" in fails                 # still listed in the menu
     assert fails["deadchild2"]["notify"] is False  # but no banner posted
+
+
+def test_agent_status_tool_default_read_does_not_enforce_lifecycle(
+    fresh_mp, monkeypatch
+):
+    pkg = fresh_mp
+    _insert_task(pkg, "tk_overdue", "Build a compact menu-bar status app.")
+    conn = pkg["db"].get_db()
+    conn.execute(
+        "UPDATE tasks SET started_at=? WHERE id=?",
+        (int(time.time()) - 10000, "tk_overdue"),
+    )
+    conn.commit()
+
+    import threadkeeper.spawn_budget as sb
+
+    reap_calls: list = []
+    respawn_calls: list = []
+    monkeypatch.setattr(
+        sb, "_reap_timed_out",
+        lambda conn, row, now: reap_calls.append(row["id"]) or True,
+    )
+    monkeypatch.setattr(
+        sb, "_respawn_timed_out",
+        lambda conn, row, age: respawn_calls.append(row["id"]),
+    )
+
+    result = _txt(_tool(pkg, "agent_status")())
+
+    assert reap_calls == []
+    assert respawn_calls == []
+    row = conn.execute(
+        "SELECT ended_at, return_code FROM tasks WHERE id='tk_overdue'"
+    ).fetchone()
+    assert row["ended_at"] is None
+    assert row["return_code"] is None
+    count = conn.execute("SELECT COUNT(*) FROM tasks").fetchone()[0]
+    assert count == 1
+    assert "tk_overdue" in result or "agents=1" in result

{threadkeeper-0.17.6 → threadkeeper-0.17.7}/tests/test_daemon_liveness.py

@@ -14,7 +14,7 @@ def test_daemon_health_is_additive_without_schema_version_bump(mp_with_cid):
     db = pkg["db"]
     conn = db.get_db()
     conn.execute("DROP TABLE daemon_health")
-    conn.execute("PRAGMA user_version = 4")
+    conn.execute(f"PRAGMA user_version = {db.CURRENT_SCHEMA_VERSION}")
     conn.commit()
     conn.close()
 
@@ -23,7 +23,9 @@ def test_daemon_health_is_additive_without_schema_version_bump(mp_with_cid):
 
     conn = db.get_db()
     try:
-        assert conn.execute("PRAGMA user_version").fetchone()[0] == 4
+        assert conn.execute("PRAGMA user_version").fetchone()[0] == (
+            db.CURRENT_SCHEMA_VERSION
+        )
         assert conn.execute(
             "SELECT 1 FROM sqlite_master "
             "WHERE type='table' AND name='daemon_health'"

{threadkeeper-0.17.6 → threadkeeper-0.17.7}/tests/test_evolve_daemon.py

@@ -103,23 +103,49 @@ def _add_evolve(conn, suggestion, rationale=None, applied=0, status="pending"):
 
 def _seed_research(pkg, conn, text="- idea: adopt Y\n  sources: https://ex.com\n"):
     """Make run_evolve_pass take the AUDIT branch on its next call: record a
-    prior research spawn so _last_spawn_phase()=='research', and write a fresh
-    digest file the audit phase will fence into its prompt."""
+    prior research spawn so _last_spawn_phase()=='research', and create a
+    fresh, accepted handoff that the audit phase may fence into its prompt."""
     now = int(time.time())
-    rdir = pkg["ed"]._research_dir()
-    rdir.mkdir(parents=True, exist_ok=True)
-    f = rdir / f"RESEARCH-{now}.md"
-    f.write_text(text, encoding="utf-8")
+    pass_id, f = pkg["ed"]._authorize_research_handoff(
+        conn, now, _FAKE_CID,
+    )
+    persisted = text.rstrip() + "\n"
+    f.write_text(persisted, encoding="utf-8")
+    digest = pkg["ed"].hashlib.sha256(persisted.encode("utf-8")).hexdigest()
+    conn.execute(
+        "UPDATE evolve_research_handoffs SET status='accepted', "
+        "content_sha256=?, content_chars=?, completed_at=? WHERE pass_id=?",
+        (digest, len(persisted), now, pass_id),
+    )
     conn.execute(
         "INSERT INTO events (session_id, kind, target, summary, created_at) "
         "VALUES (?, 'evolve_review_pass', ?, ?, ?)",
-        ("s_prev", str(now), "spawned research file=RESEARCH.md ok task=tk pid=1",
+        ("s_prev", str(now), "spawned research pass=seeded ok task=tk pid=1",
          now),
     )
     conn.commit()
     return f, text
 
 
+def _authorize_researcher(pkg, conn, now=None):
+    """Create the parent/task state a real researcher handoff requires."""
+    now = int(time.time()) if now is None else int(now)
+    pass_id, target = pkg["ed"]._authorize_research_handoff(
+        conn, now, _FAKE_CID,
+    )
+    conn.execute(
+        "INSERT INTO tasks "
+        "(id, pid, parent_cid, spawned_cid, cwd, prompt, started_at, role, write_origin) "
+        "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+        (
+            f"tk_research_{pass_id[-6:]}", 0, "parent", _FAKE_CID,
+            str(target.parent), "research", now, "evolve_researcher", "evolve",
+        ),
+    )
+    conn.commit()
+    return pass_id, target
+
+
 def test_audit_prompt_uses_paginated_issue_dedup(tmp_path, monkeypatch):
     pkg = _bootstrap(tmp_path, monkeypatch)
     prompt = pkg["ed"].EVOLVE_AUDIT_PROMPT
@@ -475,7 +501,7 @@ def test_run_evolve_pass_force_spawns_research_first(
     pkg = _bootstrap(tmp_path, monkeypatch)
     calls = {}
     import threadkeeper.tools.spawn as spawn_mod
-    monkeypatch.setattr(spawn_mod, "spawn",
+    monkeypatch.setattr(spawn_mod, "_spawn_impl",
                         lambda **kw: calls.update(kw) or "ok task=tk_ev pid=1")
 
     out = pkg["ed"].run_evolve_pass(force=True)
@@ -513,7 +539,7 @@ def test_run_evolve_pass_below_min(tmp_path, monkeypatch):
     _add_evolve(conn, "only one")
     calls = {}
     import threadkeeper.tools.spawn as spawn_mod
-    monkeypatch.setattr(spawn_mod, "spawn",
+    monkeypatch.setattr(spawn_mod, "_spawn_impl",
                         lambda **kw: calls.update(kw) or "ok task=tk_ev pid=1")
 
     out = pkg["ed"].run_evolve_pass(force=True)
@@ -539,7 +565,7 @@ def test_run_evolve_pass_skips_legacy_backlog_until_interval(
     calls = {}
     import threadkeeper.tools.spawn as spawn_mod
     monkeypatch.setattr(
-        spawn_mod, "spawn",
+        spawn_mod, "_spawn_impl",
         lambda **kw: calls.update(kw) or "ok task=tk_ev pid=1",
     )
 
@@ -558,7 +584,7 @@ def test_run_evolve_pass_research_phase_is_read_only(tmp_path, monkeypatch):
     _add_evolve(conn, "suggestion alpha")
     calls = {}
     import threadkeeper.tools.spawn as spawn_mod
-    monkeypatch.setattr(spawn_mod, "spawn",
+    monkeypatch.setattr(spawn_mod, "_spawn_impl",
                         lambda **kw: calls.update(kw) or "ok task=tk_ev pid=1")
     out = pkg["ed"].run_evolve_pass(force=True)
     assert out.startswith("spawned research")
@@ -567,11 +593,128 @@ def test_run_evolve_pass_research_phase_is_read_only(tmp_path, monkeypatch):
     # web research yes; bypass/shell/GitHub-write no
     assert "WebSearch" in calls["extra_allowed_tools"]
     assert "WebFetch" in calls["extra_allowed_tools"]
+    assert "Write" not in calls["extra_allowed_tools"]
+    assert "evolve_research_handoff" in calls["extra_allowed_tools"]
+    assert calls["allowed_tools_override"] == (
+        "mcp__thread-keeper__broadcast",
+    )
     assert calls["permission_mode"] != "bypassPermissions"
     assert "Bash" not in calls["extra_allowed_tools"]
     assert "Edit" not in calls["extra_allowed_tools"]
     assert "evolve_decide" not in calls["extra_allowed_tools"]
     assert pkg["ed"]._last_evolve_ts(conn) > 0
+    handoff = conn.execute(
+        "SELECT owner_cid, status, target_path FROM evolve_research_handoffs"
+    ).fetchone()
+    assert handoff["owner_cid"] == calls["child_cid_override"]
+    assert handoff["status"] == "pending"
+    assert Path(handoff["target_path"]).name.startswith("RESEARCH-")
+
+
+def test_research_handoff_accepts_only_registered_owner_and_target(
+    tmp_path, monkeypatch,
+):
+    pkg = _bootstrap(tmp_path, monkeypatch)
+    conn = pkg["db"].get_db()
+    pass_id, target = _authorize_researcher(pkg, conn)
+    sentinel = tmp_path / "source.py"
+    sentinel.write_text("unchanged\n", encoding="utf-8")
+    monkeypatch.setenv("THREADKEEPER_SPAWNED_CHILD", "1")
+    monkeypatch.setenv("THREADKEEPER_WRITE_ORIGIN", "evolve")
+
+    out = _tool(pkg, "evolve_research_handoff")(
+        pass_id=pass_id,
+        content="- idea: scoped handoff\n  sources: https://example.test\n",
+    )
+
+    persisted = "- idea: scoped handoff\n  sources: https://example.test\n"
+    assert out.startswith("ok pass_id=")
+    assert target.read_text(encoding="utf-8") == persisted
+    assert sentinel.read_text(encoding="utf-8") == "unchanged\n"
+    row = conn.execute(
+        "SELECT status, content_chars, content_sha256 FROM evolve_research_handoffs "
+        "WHERE pass_id=?", (pass_id,),
+    ).fetchone()
+    assert row["status"] == "accepted"
+    assert row["content_chars"] == len(persisted)
+    assert row["content_sha256"] == pkg["ed"].hashlib.sha256(
+        persisted.encode("utf-8")
+    ).hexdigest()
+    assert pkg["ed"]._latest_research(int(time.time())) == (target, persisted)
+
+
+def test_research_handoff_rejects_wrong_owner_and_malformed_content(
+    tmp_path, monkeypatch,
+):
+    pkg = _bootstrap(tmp_path, monkeypatch)
+    conn = pkg["db"].get_db()
+    monkeypatch.setenv("THREADKEEPER_SPAWNED_CHILD", "1")
+    monkeypatch.setenv("THREADKEEPER_WRITE_ORIGIN", "evolve")
+
+    pass_id, target = _authorize_researcher(pkg, conn)
+    monkeypatch.setattr(pkg["ed"].identity, "_detect_self_cid", lambda: "other")
+    assert _tool(pkg, "evolve_research_handoff")(
+        pass_id=pass_id, content="- harmless\n",
+    ) == "ERR research_handoff_not_authorized"
+    assert not target.exists()
+    assert conn.execute(
+        "SELECT status FROM evolve_research_handoffs WHERE pass_id=?", (pass_id,)
+    ).fetchone()["status"] == "pending"
+
+    monkeypatch.setattr(pkg["ed"].identity, "_detect_self_cid", lambda: _FAKE_CID)
+    malformed_id, malformed_target = _authorize_researcher(pkg, conn)
+    out = _tool(pkg, "evolve_research_handoff")(
+        pass_id=malformed_id, content="bad\x00digest",
+    )
+    assert out == "ERR digest_malformed reason=malformed_nul"
+    malformed = conn.execute(
+        "SELECT status, failure FROM evolve_research_handoffs WHERE pass_id=?",
+        (malformed_id,),
+    ).fetchone()
+    assert malformed["status"] == "failed"
+    assert malformed["failure"] == "malformed_nul"
+    assert not malformed_target.exists()
+    telemetry = conn.execute(
+        "SELECT summary FROM events WHERE kind=? AND summary LIKE ? "
+        "ORDER BY id DESC LIMIT 1",
+        (pkg["ed"].EVOLVE_RESEARCH_HANDOFF_KIND, f"pass_id={malformed_id}%"),
+    ).fetchone()["summary"]
+    assert "status=failed reason=malformed_nul" in telemetry
+
+
+def test_research_handoff_rejects_oversize_and_audit_rejects_tampering(
+    tmp_path, monkeypatch,
+):
+    pkg = _bootstrap(tmp_path, monkeypatch)
+    conn = pkg["db"].get_db()
+    monkeypatch.setenv("THREADKEEPER_SPAWNED_CHILD", "1")
+    monkeypatch.setenv("THREADKEEPER_WRITE_ORIGIN", "evolve")
+
+    oversize_id, _ = _authorize_researcher(pkg, conn)
+    out = _tool(pkg, "evolve_research_handoff")(
+        pass_id=oversize_id,
+        content="x" * (pkg["ed"].EVOLVE_RESEARCH_MAX_CHARS + 1),
+    )
+    assert out == (
+        f"ERR digest_too_large max_chars={pkg['ed'].EVOLVE_RESEARCH_MAX_CHARS}"
+    )
+    assert conn.execute(
+        "SELECT status, failure FROM evolve_research_handoffs WHERE pass_id=?",
+        (oversize_id,),
+    ).fetchone()["failure"] == "too_large"
+
+    pass_id, target = _authorize_researcher(pkg, conn)
+    assert _tool(pkg, "evolve_research_handoff")(
+        pass_id=pass_id, content="- trusted before replacement\n",
+    ).startswith("ok pass_id=")
+    target.write_text("- replacement after handoff\n", encoding="utf-8")
+    assert pkg["ed"]._latest_research(int(time.time())) == (None, "")
+    tampered = conn.execute(
+        "SELECT status, failure FROM evolve_research_handoffs WHERE pass_id=?",
+        (pass_id,),
+    ).fetchone()
+    assert tampered["status"] == "tampered"
+    assert tampered["failure"] == "sha256_mismatch"
 
 
 def test_run_evolve_pass_audit_phase_no_web_consumes_fenced_research(
@@ -708,10 +851,12 @@ def test_web_research_and_privileged_write_never_cogranted(tmp_path, monkeypatch
     _add_evolve(conn, "suggestion alpha")
     captured = []
     import threadkeeper.tools.spawn as spawn_mod
-    monkeypatch.setattr(
-        spawn_mod, "spawn",
-        lambda **kw: captured.append(dict(kw)) or "ok task=tk_ev pid=1",
-    )
+    def capture(**kw):
+        captured.append(dict(kw))
+        return "ok task=tk_ev pid=1"
+
+    monkeypatch.setattr(spawn_mod, "spawn", capture)
+    monkeypatch.setattr(spawn_mod, "_spawn_impl", capture)
 
     # Phase 1 records a real "spawned research" pass, so phase 2 takes the audit
     # branch on the next forced call.
@@ -748,7 +893,7 @@ def test_run_evolve_pass_runs_reviewer_in_repo_root(tmp_path, monkeypatch):
     monkeypatch.setattr(pkg["ed"], "_ensure_repo_ready", lambda: (repo, ""))
     calls = {}
     import threadkeeper.tools.spawn as spawn_mod
-    monkeypatch.setattr(spawn_mod, "spawn",
+    monkeypatch.setattr(spawn_mod, "_spawn_impl",
                         lambda **kw: calls.update(kw) or "ok task=tk_ev pid=1")
 
     out = pkg["ed"].run_evolve_pass(force=True)
@@ -837,7 +982,7 @@ def test_run_evolve_pass_single_flight_lock_race(tmp_path, monkeypatch):
             errors.append(e)
             release_spawn.set()
 
-    monkeypatch.setattr(spawn_mod, "spawn", fake_spawn)
+    monkeypatch.setattr(spawn_mod, "_spawn_impl", fake_spawn)
 
     t = threading.Thread(target=run_pass)
     t.start()

{threadkeeper-0.17.6 → threadkeeper-0.17.7}/tests/test_spawn_watchdog.py

@@ -402,3 +402,39 @@ def test_agent_status_reports_timed_out(mp_with_cid, monkeypatch):
     snap = agent_status_snapshot(refresh=False)
     assert snap["timed_out_count"] == 1
     assert "timed_out=1" in format_agent_status(snap)
+
+
+def test_refresh_all_running_enforce_false_skips_kill_and_respawn(
+    mp_with_cid, monkeypatch
+):
+    monkeypatch.setenv("THREADKEEPER_SPAWN_MAX_RUNTIME_S", "60")
+    pkg = mp_with_cid(_FAKE_CID)
+
+    import threadkeeper.spawn_budget as sb
+
+    reap_calls: list = []
+    respawn_calls: list = []
+    monkeypatch.setattr(
+        sb, "_reap_timed_out",
+        lambda conn, row, now: reap_calls.append(row["id"]) or True,
+    )
+    monkeypatch.setattr(
+        sb, "_respawn_timed_out",
+        lambda conn, row, age: respawn_calls.append(row["id"]),
+    )
+
+    old = int(time.time()) - 200
+    conn = _insert_running(pkg, "tk_enforce", os.getpid(), old)
+
+    sb._refresh_all_running(conn, enforce=False)
+
+    assert reap_calls == []
+    assert respawn_calls == []
+    row = conn.execute(
+        "SELECT ended_at FROM tasks WHERE id='tk_enforce'"
+    ).fetchone()
+    assert row["ended_at"] is None
+
+    sb._refresh_all_running(conn)
+
+    assert len(reap_calls) == 1

{threadkeeper-0.17.6 → threadkeeper-0.17.7}/tests/test_tool_annotations.py

@@ -60,7 +60,8 @@ WRITE_TOOLS = {
     "evolve_apply_roadmap_issue", "evolve_decide",
     "evolve_format", "evolve_issue_create", "evolve_mark_applied",
     "evolve_mark_curator_report_applied",
-    "evolve_mark_roadmap_issue_applied", "export_distillates", "extract_recent",
+    "evolve_mark_roadmap_issue_applied", "evolve_research_handoff",
+    "export_distillates", "extract_recent",
     "idle_thread", "inbox", "ingest", "lesson_append", "lesson_restore",
     "link", "live_status", "lesson_get", "lesson_list", "mark_skill_materialized",
     "memory_guard_reclaim", "note",
@@ -155,7 +156,9 @@ def test_status_tools_emit_validating_structured_content(fresh_mp, name):
     assert tool.output_schema is not None, f"{name} must advertise outputSchema"
 
     fn = pkg["mcp"]._tool_manager._tools[name].fn
-    kwargs = {"refresh": False} if name == "agent_status" else {}
+    # agent_status is now side-effect-free under its default, so the
+    # annotation test exercises the default path.
+    kwargs: dict = {}
     result = fn(**kwargs)
 
     # legacy human-readable text block preserved

{threadkeeper-0.17.6 → threadkeeper-0.17.7}/threadkeeper/agent_metadata.py

@@ -90,7 +90,7 @@ AGENT_ROLES: Final[tuple[dict[str, str], ...]] = (
             "evolve reviewer before a roadmap decision."
         ),
         "reads": "Repository code, documentation, and research sources",
-        "writes": "Research findings for the evolve review",
+        "writes": "One parent-authorized, pass-scoped research digest",
         "impact": "read_only",
         "interval_key": "THREADKEEPER_EVOLVE_REVIEW_INTERVAL_S",
     },

{threadkeeper-0.17.6 → threadkeeper-0.17.7}/threadkeeper/agent_status.py

@@ -330,15 +330,15 @@ def _status_for(pid: int | None, ended_at: int | None) -> str:
 
 
 def _refresh_rss(conn) -> None:
-    """Refresh task liveness/RSS using the existing spawn-budget sweeper.
+    """Refresh task liveness/RSS in observation-only mode.
 
-    This intentionally reuses the production measurement path, so the widget
-    and spawn-budget tool agree on memory numbers.
+    Status reads measure only and never kill or respawn; lifecycle
+    enforcement stays daemon-owned.
     """
     try:
         from .spawn_budget import _refresh_all_running
 
-        _refresh_all_running(conn)
+        _refresh_all_running(conn, enforce=False)
     except Exception:
         # A status widget should degrade to the last cached RSS instead of
         # failing when ps is briefly unavailable or the DB is locked.

{threadkeeper-0.17.6 → threadkeeper-0.17.7}/threadkeeper/db.py

@@ -35,7 +35,7 @@ __all__ = [
     "SCHEMA",
 ]
 
-CURRENT_SCHEMA_VERSION = 4
+CURRENT_SCHEMA_VERSION = 5
 
 # sqlite-vec extension state. We probe once at first get_db() call and
 # cache the verdict. _VEC_AVAILABLE = True means vec0 virtual tables work
@@ -556,6 +556,25 @@ CREATE TABLE IF NOT EXISTS evolve_issues (
     created_at    INTEGER NOT NULL
 );
 
+-- Parent-authorized handoffs from an unprivileged Evolve web-research child.
+-- The child never chooses a path: it can only submit content for the exact
+-- pass row created before it was spawned.  The audit phase accepts only a
+-- completed row whose final on-disk SHA-256 still matches this record.
+CREATE TABLE IF NOT EXISTS evolve_research_handoffs (
+    pass_id        TEXT PRIMARY KEY,
+    target_path    TEXT NOT NULL UNIQUE,
+    owner_cid      TEXT NOT NULL,
+    authorized_at  INTEGER NOT NULL,
+    expires_at     INTEGER NOT NULL,
+    status         TEXT NOT NULL CHECK(status IN (
+        'pending', 'writing', 'accepted', 'failed', 'tampered', 'expired'
+    )),
+    content_sha256 TEXT,
+    content_chars  INTEGER,
+    completed_at   INTEGER,
+    failure        TEXT
+);
+
 CREATE INDEX IF NOT EXISTS idx_notes_thread   ON notes(thread_id);
 CREATE INDEX IF NOT EXISTS idx_notes_created  ON notes(created_at DESC);
 CREATE INDEX IF NOT EXISTS idx_threads_state  ON threads(state);
@@ -582,6 +601,8 @@ CREATE UNIQUE INDEX IF NOT EXISTS idx_evolve_issues_fingerprint
     ON evolve_issues(fingerprint);
 CREATE INDEX IF NOT EXISTS idx_evolve_issues_hash
     ON evolve_issues(content_hash);
+CREATE INDEX IF NOT EXISTS idx_evolve_research_handoffs_ready
+    ON evolve_research_handoffs(status, completed_at DESC);
 CREATE INDEX IF NOT EXISTS idx_evolve_issues_number
     ON evolve_issues(issue_number);
 CREATE INDEX IF NOT EXISTS idx_probes_category    ON probes(category);
@@ -925,7 +946,7 @@ def _rebuild_dialog_fts_if_needed(conn: sqlite3.Connection) -> None:
 
 
 def _run_schema_migrations(conn: sqlite3.Connection, from_version: int) -> None:
-    if from_version not in (0, 1, 2, 3):
+    if from_version not in (0, 1, 2, 3, 4):
         raise RuntimeError(
             f"unsupported SQLite schema version {from_version}; "
             f"expected 0..{CURRENT_SCHEMA_VERSION}"