threadkeeper 0.7.0__tar.gz → 0.8.1__tar.gz

{threadkeeper-0.7.0/threadkeeper.egg-info → threadkeeper-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: threadkeeper
-Version: 0.7.0
+Version: 0.8.1
 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
@@ -82,10 +82,12 @@ make it more than a memory store:
   concurrent sessions signal each other across CLIs. Parent /
   children / sibling agents become a coordinated swarm, not isolated
   chats.
-- **Self-improving skill library** — five autonomous background loops
+- **Self-improving skill library** — autonomous background loops
   (auto-review on thread close, shadow-review daemon, extract
-  harvester, candidate-reviewer, weekly Curator) materialize
-  class-level skills as the agents work. Adapted to multi-CLI:
+  harvester, candidate-reviewer, weekly Curator, and a thread-janitor
+  that auto-closes idle threads so abandoned work reaches the harvest
+  path — closing is reversible, a note reopens a closed thread)
+  materialize class-level skills as the agents work. Adapted to multi-CLI:
   SKILL.md is the primary write target and gets mirrored to every
   known/configured skills root simultaneously (`~/.claude/skills/`,
   `~/.codex/skills/`, existing `~/.agents/skills/`, extra roots from
@@ -519,6 +521,22 @@ them with `dry_run=False` to apply:
 
 ---
 
+## Telemetry
+
+- **`mp_dashboard(window_days=7)`** — one-call rollup of the whole
+  system, read-only. Three sections: **stores** (threads by state,
+  notes/dialog/distill/concepts counts, skills + claims by tier,
+  extract-candidate and evolve queues, probe/task counts), **loops**
+  (how many times each autonomous daemon fired in the window vs 30 days,
+  plus last-fire age), and **outcomes** (what those loops actually
+  produced — skills materialized, tier promotions, candidate
+  accept-vs-reject rate). Surfaces the gaps the point-tools can't:
+  a loop firing constantly while its outcomes stay flat, or a queue
+  backing up. Complements the per-loop `*_status` tools (`mp_health`,
+  `spawn_budget_status`, `shadow_review_status`).
+
+---
+
 ## Storage
 
 `~/.threadkeeper/db.sqlite` (overridable via `THREADKEEPER_DB`). WAL

{threadkeeper-0.7.0 → threadkeeper-0.8.1}/README.md

@@ -43,10 +43,12 @@ make it more than a memory store:
   concurrent sessions signal each other across CLIs. Parent /
   children / sibling agents become a coordinated swarm, not isolated
   chats.
-- **Self-improving skill library** — five autonomous background loops
+- **Self-improving skill library** — autonomous background loops
   (auto-review on thread close, shadow-review daemon, extract
-  harvester, candidate-reviewer, weekly Curator) materialize
-  class-level skills as the agents work. Adapted to multi-CLI:
+  harvester, candidate-reviewer, weekly Curator, and a thread-janitor
+  that auto-closes idle threads so abandoned work reaches the harvest
+  path — closing is reversible, a note reopens a closed thread)
+  materialize class-level skills as the agents work. Adapted to multi-CLI:
   SKILL.md is the primary write target and gets mirrored to every
   known/configured skills root simultaneously (`~/.claude/skills/`,
   `~/.codex/skills/`, existing `~/.agents/skills/`, extra roots from
@@ -480,6 +482,22 @@ them with `dry_run=False` to apply:
 
 ---
 
+## Telemetry
+
+- **`mp_dashboard(window_days=7)`** — one-call rollup of the whole
+  system, read-only. Three sections: **stores** (threads by state,
+  notes/dialog/distill/concepts counts, skills + claims by tier,
+  extract-candidate and evolve queues, probe/task counts), **loops**
+  (how many times each autonomous daemon fired in the window vs 30 days,
+  plus last-fire age), and **outcomes** (what those loops actually
+  produced — skills materialized, tier promotions, candidate
+  accept-vs-reject rate). Surfaces the gaps the point-tools can't:
+  a loop firing constantly while its outcomes stay flat, or a queue
+  backing up. Complements the per-loop `*_status` tools (`mp_health`,
+  `spawn_budget_status`, `shadow_review_status`).
+
+---
+
 ## Storage
 
 `~/.threadkeeper/db.sqlite` (overridable via `THREADKEEPER_DB`). WAL

{threadkeeper-0.7.0 → threadkeeper-0.8.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "threadkeeper"
-version = "0.7.0"
+version = "0.8.1"
 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" }]

{threadkeeper-0.7.0 → threadkeeper-0.8.1}/tests/test_curator.py

@@ -321,3 +321,85 @@ def test_advisory_mode_default_excludes_destructive_tools(
     assert "lesson_append" not in allowed
     assert "ADVISORY MODE" in kw["prompt"]
     assert "DESTRUCTIVE MODE ENABLED" not in kw["prompt"]
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Concepts review (F1) — curator also audits the concepts store
+# ──────────────────────────────────────────────────────────────────────
+
+def _add_concept(conn, cid, desc, confidence="medium",
+                 registered_at=None, last_evidence_at=None):
+    now = int(time.time())
+    conn.execute(
+        "INSERT INTO concepts (id, description, confidence, registered_at, "
+        "last_evidence_at) VALUES (?,?,?,?,?)",
+        (cid, desc, confidence, registered_at or now, last_evidence_at),
+    )
+    conn.commit()
+
+
+def test_collect_concepts_empty(tmp_path, monkeypatch):
+    pkg = _bootstrap(tmp_path, monkeypatch)
+    conn = pkg["db"].get_db()
+    text, n = pkg["curator"]._collect_concepts(conn)
+    assert n == 0
+    assert text == ""
+
+
+def test_collect_concepts_lists_with_age(tmp_path, monkeypatch):
+    pkg = _bootstrap(tmp_path, monkeypatch)
+    conn = pkg["db"].get_db()
+    now = int(time.time())
+    _add_concept(conn, "Cfresh", "fresh high-conf idea",
+                 confidence="high", last_evidence_at=now - 86400)  # 1d
+    _add_concept(conn, "Cstale", "stale low-conf idea",
+                 confidence="low",
+                 registered_at=now - 40 * 86400,
+                 last_evidence_at=None)  # never corroborated, 40d old
+    text, n = pkg["curator"]._collect_concepts(conn)
+    assert n == 2
+    assert "Cfresh" in text and "Cstale" in text
+    assert "CONCEPTS (n=2)" in text
+    # stale concept (no last_evidence, registered 40d ago) shows ~40d age
+    assert "40d_ago" in text
+    # oldest-first ordering: stale concept appears before fresh one
+    assert text.index("Cstale") < text.index("Cfresh")
+
+
+def test_run_curator_pass_includes_concepts_in_inventory(
+    tmp_path, monkeypatch,
+):
+    pkg = _bootstrap(tmp_path, monkeypatch, min_lessons="2")
+    pkg["lessons"].append_lesson(title="a", body="b1", source="shadow")
+    pkg["lessons"].append_lesson(title="b", body="b2", source="shadow")
+    conn = pkg["db"].get_db()
+    _add_concept(conn, "Cabc", "asymmetric in-band reactivity",
+                 confidence="high")
+
+    import threadkeeper.tools.spawn as spawn_mod
+    captured: list[dict] = []
+    monkeypatch.setattr(
+        spawn_mod, "spawn",
+        lambda **kw: captured.append(kw) or "spawn task_id=fake pid=0",
+    )
+    pkg["curator"].run_curator_pass(force=True)
+    prompt = captured[0]["prompt"]
+    assert "CONCEPTS (n=1)" in prompt
+    assert "Cabc" in prompt
+    assert "asymmetric in-band reactivity" in prompt
+
+
+def test_concepts_alone_do_not_trigger_pass(tmp_path, monkeypatch):
+    """Concepts enrich the review but don't lower the lesson threshold —
+    a pass still requires CURATOR_MIN_LESSONS lessons."""
+    pkg = _bootstrap(tmp_path, monkeypatch, min_lessons="3")
+    conn = pkg["db"].get_db()
+    _add_concept(conn, "Conly", "a lone concept", confidence="high")
+
+    import threadkeeper.tools.spawn as spawn_mod
+    called = []
+    monkeypatch.setattr(spawn_mod, "spawn",
+                        lambda **kw: called.append(kw) or "x")
+    out = pkg["curator"].run_curator_pass(force=True)
+    assert out.startswith("below_threshold")
+    assert called == []

threadkeeper-0.8.1/tests/test_dashboard.py

@@ -0,0 +1,123 @@
+"""mp_dashboard — aggregate rollup tool.
+
+Verifies the tool renders all sections, counts seeded stores, reflects
+loop-pass + outcome events, and degrades without crashing on an empty DB.
+
+NOTE on isolation: assertions are DELTA-based, never absolute counts. The
+suite's `test_tools_smoke.py` does a `del sys.modules` + package re-import
++ every-tool invocation at COLLECTION time in the parent process, which
+`os.environ.setdefault`-pins a DB path and seeds rows. So "exactly N
+threads" is not guaranteed across the full suite even with `fresh_mp`'s
+tmp DB — we assert that the dashboard reflects the rows THIS test adds
+(before/after delta), which is the real contract anyway.
+"""
+from __future__ import annotations
+
+import re
+import time
+
+
+def _tool(pkg, name):
+    return pkg["mcp"]._tool_manager._tools[name].fn
+
+
+def _count(out: str, key: str) -> int:
+    """Pull `<key>=N` from the dashboard text. Absence means zero: when a
+    store is empty the grouped `threads:` line collapses to `threads: 0`
+    (no `active=` token), and that genuinely means 0 active threads — so a
+    missing key reads as 0, which keeps before/after deltas correct."""
+    m = re.search(rf"\b{re.escape(key)}=(\d+)", out)
+    return int(m.group(1)) if m else 0
+
+
+def _active_count(out: str) -> int:
+    return _count(out, "active")
+
+
+def _notes_count(out: str) -> int:
+    return _count(out, "notes")
+
+
+def _concepts_count(out: str) -> int:
+    return _count(out, "concepts")
+
+
+def test_dashboard_registered(fresh_mp):
+    assert "mp_dashboard" in fresh_mp["mcp"]._tool_manager._tools
+
+
+def test_dashboard_empty_db_no_crash(fresh_mp):
+    out = _tool(fresh_mp, "mp_dashboard")()
+    for section in ("dashboard", "stores", "loops", "outcomes", "reliability"):
+        assert section in out, (section, out)
+
+
+def test_dashboard_counts_stores_delta(fresh_mp):
+    dash = _tool(fresh_mp, "mp_dashboard")
+    before = dash()
+    a0, n0, c0 = (_active_count(before), _notes_count(before),
+                  _concepts_count(before))
+
+    open_thread = _tool(fresh_mp, "open_thread")
+    note = _tool(fresh_mp, "note")
+    t1 = open_thread(question="alpha")
+    open_thread(question="beta")
+    note(thread_id=t1, content="a note here", kind="insight")
+    note(thread_id=t1, content="another move", kind="move")
+    _tool(fresh_mp, "register_concept")(description="a concept by example",
+                                        confidence="low")
+
+    after = dash()
+    assert _active_count(after) - a0 == 2, (a0, after)
+    assert _notes_count(after) - n0 == 2, (n0, after)
+    assert _concepts_count(after) - c0 == 1, (c0, after)
+
+
+def _shadow_win(out: str) -> int:
+    m = re.search(r"shadow\s+(\d+) / \d+", out)
+    return int(m.group(1)) if m else 0
+
+
+def test_dashboard_reflects_loop_and_outcome_events(fresh_mp):
+    # Delta measured THROUGH the tool itself (before vs after), so both reads
+    # go through the identical DB-resolution path — immune to whatever DB a
+    # contaminated parent env pinned. Insert the loop/outcome events the
+    # daemons would write, then confirm the dashboard's own count rises by 3.
+    conn = fresh_mp["db"].get_db()
+    now = int(time.time())
+    before = _shadow_win(_tool(fresh_mp, "mp_dashboard")(window_days=7))
+    for _ in range(3):
+        conn.execute(
+            "INSERT INTO events (session_id, kind, target, summary, created_at) "
+            "VALUES ('s', 'shadow_review_pass', ?, '', ?)", (str(now), now))
+    conn.execute(
+        "INSERT INTO events (session_id, kind, target, summary, created_at) "
+        "VALUES ('s', 'skill_materialized', 'Tx', 'path', ?)", (now,))
+    conn.commit()
+    after_out = _tool(fresh_mp, "mp_dashboard")(window_days=7)
+    assert _shadow_win(after_out) - before == 3, (before, after_out)
+    assert "skill_materialized" in after_out, after_out
+
+
+def test_dashboard_accept_rate(fresh_mp):
+    conn = fresh_mp["db"].get_db()
+    now = int(time.time())
+    # Snapshot existing decisions so the ratio assertion is exact regardless
+    # of pre-seeded rows.
+    acc0 = conn.execute(
+        "SELECT COUNT(*) FROM events WHERE kind LIKE 'accept_candidate%'"
+    ).fetchone()[0]
+    rej0 = conn.execute(
+        "SELECT COUNT(*) FROM events WHERE kind='reject_candidate'"
+    ).fetchone()[0]
+    conn.execute(
+        "INSERT INTO events (session_id, kind, target, created_at) "
+        "VALUES ('s','accept_candidate:note','1',?)", (now,))
+    for _ in range(3):
+        conn.execute(
+            "INSERT INTO events (session_id, kind, target, created_at) "
+            "VALUES ('s','reject_candidate','x',?)", (now,))
+    conn.commit()
+    out = _tool(fresh_mp, "mp_dashboard")()
+    acc, dec = acc0 + 1, acc0 + 1 + rej0 + 3
+    assert f"candidate_accept_rate {acc}/{dec}" in out, (acc0, rej0, out)

threadkeeper-0.8.1/tests/test_evolve_daemon.py

@@ -0,0 +1,187 @@
+"""Evolve reviewer daemon — autonomous triage of the format-evolution queue.
+
+The daemon never APPLIES a suggestion (that edits format/code). It spawns a
+child that calls evolve_decide(promote|dismiss) to keep the queue honest.
+Tests exercise the pure logic + dispatch with spawn monkeypatched; no real
+child is launched.
+"""
+from __future__ import annotations
+
+import sys
+import time
+from pathlib import Path
+
+
+_FAKE_CID = "dddd4444-5555-6666-7777-888899990000"
+
+
+def _bootstrap(tmp_path, monkeypatch, interval="0", review_min="2"):
+    env = {
+        "THREADKEEPER_DB": str(tmp_path / "db.sqlite"),
+        "CLAUDE_PROJECTS_DIR": str(tmp_path / "fake_claude_projects"),
+        "THREADKEEPER_INGEST_INTERVAL_S": "0",
+        "THREADKEEPER_INGEST_CAP": "0",
+        "THREADKEEPER_SKILL_WATCH_INTERVAL_S": "0",
+        "THREADKEEPER_SPAWN_BUDGET_POLL_S": "0",
+        "THREADKEEPER_SEARCH_PROXY_POLL_S": "0",
+        "THREADKEEPER_MEMORY_GUARD_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": interval,
+        "THREADKEEPER_EVOLVE_REVIEW_MIN": review_min,
+        "THREADKEEPER_TASK_LOG_DIR": str(tmp_path / "tasks"),
+        "THREADKEEPER_CLIENT": "pytest",
+        "THREADKEEPER_FORCE_CID": _FAKE_CID,
+        "THREADKEEPER_NO_EMBEDDINGS": "1",
+    }
+    for k, v in env.items():
+        monkeypatch.setenv(k, v)
+    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 _mcp, db, evolve_daemon, identity
+    return {"mcp": _mcp.mcp, "db": db, "ed": evolve_daemon, "identity": identity}
+
+
+def _tool(pkg, name):
+    return pkg["mcp"]._tool_manager._tools[name].fn
+
+
+def _add_evolve(conn, suggestion, rationale=None, applied=0, status="pending"):
+    conn.execute(
+        "INSERT INTO evolve (suggestion, rationale, applied, status, created_at) "
+        "VALUES (?,?,?,?,?)",
+        (suggestion, rationale, applied, status, int(time.time())),
+    )
+    conn.commit()
+
+
+# ── pending selection ──────────────────────────────────────────────────
+
+def test_pending_excludes_applied_and_decided(tmp_path, monkeypatch):
+    pkg = _bootstrap(tmp_path, monkeypatch)
+    conn = pkg["db"].get_db()
+    _add_evolve(conn, "pending one")
+    _add_evolve(conn, "already applied", applied=1)
+    _add_evolve(conn, "already dismissed", status="dismissed")
+    _add_evolve(conn, "already promoted", status="promoted")
+    pend = pkg["ed"]._pending(conn)
+    sugg = [r["suggestion"] for r in pend]
+    assert sugg == ["pending one"]
+
+
+# ── evolve_decide tool ─────────────────────────────────────────────────
+
+def test_evolve_decide_promote(tmp_path, monkeypatch):
+    pkg = _bootstrap(tmp_path, monkeypatch)
+    conn = pkg["db"].get_db()
+    _add_evolve(conn, "make briefs shorter")
+    eid = conn.execute("SELECT id FROM evolve").fetchone()["id"]
+    out = _tool(pkg, "evolve_decide")(evolve_id=eid, decision="promote",
+                                      reason="clear win")
+    assert "status=promoted" in out
+    row = conn.execute("SELECT status, review_reason, reviewed_at FROM evolve "
+                       "WHERE id=?", (eid,)).fetchone()
+    assert row["status"] == "promoted"
+    assert row["review_reason"] == "clear win"
+    assert row["reviewed_at"] is not None
+
+
+def test_evolve_decide_dismiss_and_bad_inputs(tmp_path, monkeypatch):
+    pkg = _bootstrap(tmp_path, monkeypatch)
+    conn = pkg["db"].get_db()
+    _add_evolve(conn, "dup suggestion")
+    eid = conn.execute("SELECT id FROM evolve").fetchone()["id"]
+    assert "status=dismissed" in _tool(pkg, "evolve_decide")(
+        evolve_id=eid, decision="dismiss", reason="duplicate of #1")
+    assert _tool(pkg, "evolve_decide")(
+        evolve_id=eid, decision="banana").startswith("ERR bad_decision")
+    assert _tool(pkg, "evolve_decide")(
+        evolve_id=9999, decision="promote").startswith("ERR evolve_not_found")
+
+
+# ── run_evolve_pass dispatch ────────────────────────────────────────────
+
+def test_run_evolve_pass_disabled(tmp_path, monkeypatch):
+    pkg = _bootstrap(tmp_path, monkeypatch)
+    assert pkg["ed"].run_evolve_pass() == "disabled"
+
+
+def test_run_evolve_pass_no_pending(tmp_path, monkeypatch):
+    pkg = _bootstrap(tmp_path, monkeypatch)
+    assert pkg["ed"].run_evolve_pass(force=True) == "no_pending"
+
+
+def test_run_evolve_pass_below_min(tmp_path, monkeypatch):
+    pkg = _bootstrap(tmp_path, monkeypatch, review_min="2")
+    conn = pkg["db"].get_db()
+    _add_evolve(conn, "only one")
+    assert pkg["ed"].run_evolve_pass(force=True) == "below_min n=1"
+
+
+def test_run_evolve_pass_spawns_reviewer(tmp_path, monkeypatch):
+    pkg = _bootstrap(tmp_path, monkeypatch, review_min="2")
+    conn = pkg["db"].get_db()
+    _add_evolve(conn, "suggestion alpha", rationale="friction A")
+    _add_evolve(conn, "suggestion beta")
+    calls = {}
+    import threadkeeper.tools.spawn as spawn_mod
+    monkeypatch.setattr(spawn_mod, "spawn",
+                        lambda **kw: calls.update(kw) or "ok task=tk_ev pid=1")
+    out = pkg["ed"].run_evolve_pass(force=True)
+    assert out.startswith("spawned n=2")
+    # both suggestions reached the child prompt
+    assert "suggestion alpha" in calls["prompt"]
+    assert "suggestion beta" in calls["prompt"]
+    assert "friction A" in calls["prompt"]
+    assert calls["write_origin"] == "evolve"
+    assert calls["role"] == "evolve_reviewer"
+    # narrow tool surface: triage only, never applies
+    assert "evolve_decide" in calls["extra_allowed_tools"]
+    assert "skill_manage" not in calls["extra_allowed_tools"]
+    assert pkg["ed"]._last_evolve_ts(conn) > 0
+
+
+def test_run_evolve_pass_single_flight(tmp_path, monkeypatch):
+    pkg = _bootstrap(tmp_path, monkeypatch, review_min="1")
+    conn = pkg["db"].get_db()
+    _add_evolve(conn, "s1")
+    import os
+    conn.execute(
+        "INSERT INTO tasks (id, pid, cwd, prompt, started_at) "
+        "VALUES (?,?,?,?,?)",
+        ("tk_evr", os.getpid(), "/tmp",
+         "You are an EVOLVE REVIEWER triaging the queue.", int(time.time())),
+    )
+    conn.commit()
+
+    def _boom(**kw):
+        raise AssertionError("must not spawn while a reviewer runs")
+    import threadkeeper.tools.spawn as spawn_mod
+    monkeypatch.setattr(spawn_mod, "spawn", _boom)
+    assert "reviewer_running" in pkg["ed"].run_evolve_pass(force=True)
+
+
+# ── brief surfaces promoted ★ first, drops dismissed ───────────────────
+
+def test_brief_evolve_promoted_marked_dismissed_hidden(tmp_path, monkeypatch):
+    pkg = _bootstrap(tmp_path, monkeypatch)
+    conn = pkg["db"].get_db()
+    _add_evolve(conn, "promoted one", status="promoted")
+    _add_evolve(conn, "pending one", status="pending")
+    _add_evolve(conn, "dismissed one", status="dismissed")
+    from threadkeeper.brief import render_brief
+    text = render_brief(conn)
+    # suggestion text is wrapped by q(); assert on the ★ marker + substring
+    assert "★" in text
+    assert "promoted one" in text
+    assert "pending one" in text
+    assert "dismissed one" not in text
+    # the ★ marker attaches to the promoted suggestion, not the pending one
+    assert text.index("★") < text.index("promoted one")
+    # promoted sorts before pending
+    assert text.index("promoted one") < text.index("pending one")

{threadkeeper-0.7.0 → threadkeeper-0.8.1}/tests/test_extract_daemon.py

@@ -347,6 +347,61 @@ def test_extract_filters_shadow_observer_sessions(tmp_path, monkeypatch):
     assert not any(r["source_cid"] == "shadow-sess" for r in rows)
 
 
+def test_extract_filters_spawned_child_sessions(tmp_path, monkeypatch):
+    """A session whose cid is a tasks.spawned_cid is one of OUR spawned
+    children (curator, panel voter, ad-hoc research agent, ...). Its dialog
+    is system-injected task framing + work artifacts, never user intent —
+    exclude it wholesale, regardless of how its prompt opens. This catches
+    the noise the prompt-prefix list misses: real rejects included children
+    opening with 'You are auditing…', 'You are analyzing whether…',
+    'Use the Write tool to…' — none matched _INTERNAL_PROMPT_PREFIXES, so
+    66/107 historical rejects were exactly this class."""
+    pkg = _bootstrap(tmp_path, monkeypatch)
+    conn = pkg["db"].get_db()
+    now = int(time.time())
+    child_cid = "child-cid-xyz"
+    # Register the child in tasks (parent spawned it). Prompt text is
+    # deliberately NOT in any prefix list — the link is what identifies it.
+    conn.execute(
+        "INSERT INTO tasks (id, pid, parent_cid, spawned_cid, cwd, prompt, "
+        "started_at) VALUES ('tk_x', 0, 'parent-cid', ?, '/x', "
+        "'You are auditing a slice of lessons. Analyze each one.', ?)",
+        (child_cid, now - 200),
+    )
+    # The child emits substantive-looking dialog that WOULD trip H1/H2/H3.
+    _seed_dialog(
+        conn, "user",
+        "I want you to record the decision: always reset the network "
+        "before WDA start, every single run.",
+        now - 90, session_id=child_cid,
+    )
+    _seed_dialog(
+        conn, "assistant",
+        "## Findings\n\nWe want the pipeline to always dedup first.\n"
+        "Therefore the rule is: dedup before enrich. In conclusion, that "
+        "is the durable pattern here for every future run of this job.",
+        now - 85, session_id=child_cid,
+    )
+    # A genuine foreground user session — must still be picked up.
+    _seed_dialog(
+        conn, "user",
+        "I want you to record decision notes automatically without "
+        "waiting for the agent to remember each time.",
+        now - 60, session_id="real-sess",
+    )
+    conn.commit()
+
+    out = pkg["extract_daemon"].run_extract_pass(force=True)
+    assert "ok" in out
+    rows = conn.execute(
+        "SELECT source_cid FROM extract_candidates WHERE status='pending'"
+    ).fetchall()
+    assert any(r["source_cid"] == "real-sess" for r in rows), \
+        "real user session should still yield candidates"
+    assert not any(r["source_cid"] == child_cid for r in rows), \
+        "spawned-child session must be fully excluded"
+
+
 # ──────────────────────────────────────────────────────────────────────
 # Daemon lifecycle
 # ──────────────────────────────────────────────────────────────────────

{threadkeeper-0.7.0 → threadkeeper-0.8.1}/tests/test_nudges.py

@@ -37,6 +37,19 @@ def _bootstrap_with_env(tmp_path, monkeypatch,
         "CLAUDE_PROJECTS_DIR": str(tmp_path / "fake_claude_projects"),
         "THREADKEEPER_INGEST_INTERVAL_S": "0",
         "THREADKEEPER_INGEST_CAP": "0",
+        # Zero every background-daemon interval so no daemon thread fires a
+        # pass mid-test and emits a counted `spawn` event that races the
+        # nudge-counter assertions. Inherited from the real shell env
+        # otherwise (a dev box with probe/evolve daemons enabled in
+        # settings.json leaks the interval into pytest).
+        "THREADKEEPER_PROBE_INTERVAL_S": "0",
+        "THREADKEEPER_EVOLVE_REVIEW_INTERVAL_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_SPAWN_BUDGET_POLL_S": "0",
+        "THREADKEEPER_MEMORY_GUARD_POLL_S": "0",
         "THREADKEEPER_TASK_LOG_DIR": str(tmp_path / "tasks"),
         "THREADKEEPER_CLIENT": "pytest",
         "THREADKEEPER_MEMORY_NUDGE_INTERVAL": str(memory_interval),