threadkeeper 0.7.0__tar.gz → 0.8.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: threadkeeper
-Version: 0.7.0
+Version: 0.8.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

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

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

{threadkeeper-0.7.0 → threadkeeper-0.8.0}/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.0/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.0}/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),

threadkeeper-0.8.0/tests/test_panel.py

@@ -0,0 +1,188 @@
+"""Judge panel — spawned independent voters fill the distill/dialectic
+promotion quorum, with an adversarial guard so a rubber-stamp panel can't
+self-promote (the panel_vote origin is granted by the spawner only when a
+skeptic is present).
+"""
+from __future__ import annotations
+
+import sys
+import time
+from pathlib import Path
+
+
+_FAKE_CID = "cccc3333-4444-5555-6666-777788889999"
+
+
+def _bootstrap(tmp_path, monkeypatch, **env_extra):
+    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_TASK_LOG_DIR": str(tmp_path / "tasks"),
+        "THREADKEEPER_CLIENT": "pytest",
+        "THREADKEEPER_FORCE_CID": _FAKE_CID,
+        "THREADKEEPER_NO_EMBEDDINGS": "1",
+    }
+    env.update(env_extra)
+    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
+    return {"mcp": _mcp.mcp, "db": db}
+
+
+def _tool(pkg, name):
+    return pkg["mcp"]._tool_manager._tools[name].fn
+
+
+# ── role / adversarial composition logic ───────────────────────────────
+
+def test_roles_default_from_config(tmp_path, monkeypatch):
+    _bootstrap(tmp_path, monkeypatch)
+    from threadkeeper.tools import panel
+    assert panel._roles() == ["skeptic", "critic", "generator"]
+
+
+def test_roles_override_and_size(tmp_path, monkeypatch):
+    _bootstrap(tmp_path, monkeypatch)
+    from threadkeeper.tools import panel
+    assert panel._roles(size=2, override="a,b,c") == ["a", "b"]
+    # size larger than role set cycles
+    assert panel._roles(size=4, override="x,y") == ["x", "y", "x", "y"]
+
+
+def test_panel_with_skeptic_is_adversarial_full_weight(tmp_path, monkeypatch):
+    _bootstrap(tmp_path, monkeypatch)
+    from threadkeeper.tools import panel
+    assert panel._panel_origin(["skeptic", "critic"]) == "panel_vote"
+
+
+def test_panel_without_skeptic_is_discounted(tmp_path, monkeypatch):
+    _bootstrap(tmp_path, monkeypatch)  # PANEL_REQUIRE_SKEPTIC defaults on
+    from threadkeeper.tools import panel
+    assert panel._panel_origin(["critic", "generator"]) == "background_review"
+
+
+def test_require_skeptic_off_accepts_diverse_panel(tmp_path, monkeypatch):
+    _bootstrap(tmp_path, monkeypatch,
+               THREADKEEPER_PANEL_REQUIRE_SKEPTIC="0")
+    from threadkeeper.tools import panel
+    assert panel._panel_origin(["critic", "generator"]) == "panel_vote"
+    assert panel._panel_origin(["critic", "critic"]) == "background_review"
+
+
+# ── panel_vote origin lifts dialectic evidence to full weight ──────────
+
+def test_panel_vote_origin_full_weight(tmp_path, monkeypatch):
+    _bootstrap(tmp_path, monkeypatch)
+    from threadkeeper.tools.dialectic import _evidence_weight
+    assert _evidence_weight("panel_vote", 1.0) == 1.0
+    assert _evidence_weight("background_review", 1.0) == 0.5
+
+
+def test_panel_vote_weight_configurable(tmp_path, monkeypatch):
+    _bootstrap(tmp_path, monkeypatch, THREADKEEPER_PANEL_VOTE_WEIGHT="0.75")
+    from threadkeeper.tools.dialectic import _evidence_weight
+    assert _evidence_weight("panel_vote", 1.0) == 0.75
+
+
+# ── convene_panel dispatch (spawn monkeypatched) ───────────────────────
+
+def _seed_distill(pkg, did="Dtest", content="reusable insight X"):
+    conn = pkg["db"].get_db()
+    conn.execute(
+        "INSERT INTO threads (id, question, state, opened_at, last_touched_at) "
+        "VALUES ('Tsrc','q','active',1,1)"
+    )
+    conn.execute(
+        "INSERT INTO distill (id, content, kind, confidence, source_thread, "
+        "created_at) VALUES (?,?,?,?,?,?)",
+        (did, content, "pattern", "high", "Tsrc", int(time.time())),
+    )
+    conn.commit()
+
+
+def test_convene_panel_distill_spawns_voters(tmp_path, monkeypatch):
+    pkg = _bootstrap(tmp_path, monkeypatch)
+    _seed_distill(pkg, "Dabc", "always reset network before WDA start")
+    calls = []
+    import threadkeeper.tools.spawn as spawn_mod
+
+    def _fake_spawn(**kw):
+        calls.append(kw)
+        return f"ok task=tk_{len(calls)} pid={len(calls)} child_cid=c{len(calls)}"
+    monkeypatch.setattr(spawn_mod, "spawn", _fake_spawn)
+
+    out = _tool(pkg, "convene_panel")(target_kind="distill", target_id="Dabc")
+    assert "adversarial" in out and "origin=panel_vote" in out
+    assert len(calls) == 3
+    for c in calls:
+        assert c["write_origin"] == "panel_vote"
+        assert "mcp__thread-keeper__vote_distill" in c["extra_allowed_tools"]
+        # the distillate content reached the child
+        assert "always reset network" in c["prompt"]
+        # explicit permission to dissent
+        assert "may vote against" in c["prompt"].lower()
+
+
+def test_convene_panel_claim_uses_dialectic_tool(tmp_path, monkeypatch):
+    pkg = _bootstrap(tmp_path, monkeypatch)
+    conn = pkg["db"].get_db()
+    conn.execute(
+        "INSERT INTO user_dialectic (id, claim, domain, confidence, state, "
+        "tier, created_at) VALUES ('UCx','user prefers spawn','workflow',"
+        "'medium','active','hypothesis',?)",
+        (int(time.time()),),
+    )
+    conn.commit()
+    calls = []
+    import threadkeeper.tools.spawn as spawn_mod
+    monkeypatch.setattr(spawn_mod, "spawn",
+                        lambda **kw: calls.append(kw) or "ok task=tk1")
+
+    out = _tool(pkg, "convene_panel")(target_kind="claim", target_id="UCx")
+    assert "origin=panel_vote" in out
+    assert all(
+        "mcp__thread-keeper__dialectic_evidence" in c["extra_allowed_tools"]
+        for c in calls
+    )
+    assert all("user prefers spawn" in c["prompt"] for c in calls)
+
+
+def test_convene_panel_unknown_target(tmp_path, monkeypatch):
+    pkg = _bootstrap(tmp_path, monkeypatch)
+    out = _tool(pkg, "convene_panel")(target_kind="distill", target_id="Dnope")
+    assert out.startswith("ERR target_not_found")
+
+
+def test_convene_panel_bad_kind(tmp_path, monkeypatch):
+    pkg = _bootstrap(tmp_path, monkeypatch)
+    out = _tool(pkg, "convene_panel")(target_kind="banana", target_id="x")
+    assert out.startswith("ERR bad_target_kind")
+
+
+def test_convene_panel_no_skeptic_is_discounted(tmp_path, monkeypatch):
+    pkg = _bootstrap(tmp_path, monkeypatch)
+    _seed_distill(pkg, "Dq", "some insight")
+    import threadkeeper.tools.spawn as spawn_mod
+    seen = []
+    monkeypatch.setattr(spawn_mod, "spawn",
+                        lambda **kw: seen.append(kw) or "ok task=t")
+    out = _tool(pkg, "convene_panel")(
+        target_kind="distill", target_id="Dq", roles="critic,generator"
+    )
+    assert "discounted" in out and "origin=background_review" in out
+    assert all(c["write_origin"] == "background_review" for c in seen)