threadkeeper 0.17.0__tar.gz → 0.17.2__tar.gz

{threadkeeper-0.17.0 → threadkeeper-0.17.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: threadkeeper
-Version: 0.17.0
+Version: 0.17.2
 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
@@ -599,10 +599,13 @@ daemon even if a CLI drops the no-embeddings env. Idempotent through
 `events.kind='shadow_review_pass'`.
 
 Before writing memory, the observer now checks existing lessons/skills and
-prefers patching broad skills. Shadow-origin `lesson_append` is a compact
-fallback only: oversized bodies are rejected, near-duplicate slugs are blocked,
-and semantic body matches are routed to the incumbent lesson or surfaced for
-curation instead of minting a sibling lesson.
+prefers patching broad skills. `lesson_patch(slug, old_string, new_string)`
+can correct one unique substring without reserializing a lesson. Shadow-origin
+`lesson_append` is a compact fallback only: oversized new bodies are rejected,
+though an existing same-slug long lesson may be corrected without increasing
+its body size; near-duplicate slugs are blocked, and semantic body matches are
+routed to the incumbent lesson or surfaced for curation instead of minting a
+sibling lesson.
 
 #### 3. Extract daemon
 
@@ -682,7 +685,12 @@ ThreadKeeper/Claude Code/Codex/Agent Skills compatibility, resource/link
 findings, mirror hashes, exact-body duplicate groups, and lexical candidates
 for semantic review. System and installed-plugin sources are resolved from
 their read-only caches rather than misreported as missing mirrors; telemetry
-rows with no real `SKILL.md` remain explicit orphans. The child reads every
+rows with no real `SKILL.md` remain explicit orphans. The same inventory also
+flags a dense lesson subtopic when at least
+`THREADKEEPER_CURATOR_PROMOTION_MIN_LESSONS` lessons (default 3) share a pair
+of meaningful title terms. A non-protected candidate must become one validated,
+checklist-style canonical skill before its source lessons are retired; protected
+clusters are left for human review. The child reads every
 complete skill and relevant support file, performs current web research against
 official docs and comparable
 public skills, then writes numbered per-skill verdicts to
@@ -751,7 +759,11 @@ cross-process, while foreground/human deletes are unaffected. `mp_dashboard`
 shows admitted and refused operations with `status=HIT` when the Curator reaches
 the ceiling.
 Before `lesson_remove` or `skill_manage(action='delete')` removes anything, it
-also writes a recovery artifact under `<db dir>/curator/trash/`: lessons store
+also rewrites inbound `[[wikilinks]]` when a consolidation provides
+`replacement_slug` / `replacement_name` for the surviving umbrella. A plain
+removal returns its complete `dangling_wikilinks=` source list instead, so
+those links can be repaired immediately. It writes a recovery artifact under
+`<db dir>/curator/trash/`: lessons store
 the exact sentinel section plus usage row, and skills store the full skill
 directory plus usage row. Restore trash artifacts with `lesson_restore(slug=...)`
 or `skill_manage(action='restore', name=...)`. Trash retention is bounded by
@@ -762,14 +774,14 @@ also the Curator apply worker: after the roadmap issue queue is empty, it looks
 for the latest complete Curator report (`CURATOR_PASS_COMPLETE`) whose path and
 current SHA-256 match an unapplied `curator_report_provenance` event, then
 spawns an `evolve_applier` child to apply only safe, still-current memory
-maintenance through `lesson_append` / `lesson_remove` / `skill_manage` /
+maintenance through `lesson_append` / `lesson_patch` / `lesson_remove` / `skill_manage` /
 `concept_manage`. It never touches `[PROTECTED]`,
 foreground/user, pinned, or validated entries. Only after the child finishes
 does it call `evolve_mark_curator_report_applied(...)` with the verified hash;
 the mark rechecks that hash and prevents replaying the same report.
 
 The shared lesson file has its own write serialization: `lesson_append`,
-`lesson_remove`, and `lesson_restore` hold a blocking `fcntl.flock` on
+`lesson_patch`, `lesson_remove`, and `lesson_restore` hold a blocking `fcntl.flock` on
 `lessons.md.lock` around file creation/read/mutate/write, so foreground calls
 and learning-loop children cannot last-writer-win over each other's sections.
 
@@ -891,7 +903,12 @@ throttling the roadmap loop.
 Before any PR-producing reviewer/audit or applier child is spawned, the parent
 checks the target checkout with `git status --porcelain --untracked-files=no`.
 Tracked-file WIP records `skipped_dirty_worktree` and no child is dispatched;
-untracked scratch files do not block. Each managed-checkout child fetches the
+the default managed checkout first preserves orphaned untracked files under
+`~/.threadkeeper/evolve-recovery/untracked-*/` and removes them from the next
+task’s tree. This prevents unrelated unfinished tests from blocking every PR
+repair. Ignored files (including `.venv`) and explicit operator checkouts stay
+in place; live writers prevent recovery, and backup failures block dispatch.
+Each managed-checkout child fetches the
 configured branch only to retrieve the configured immutable commit, then
 prepares or resumes its deterministic local/remote feature branch from
 `THREADKEEPER_EVOLVE_REPO_COMMIT`, never from the branch's moving tip. Retries
@@ -1374,7 +1391,7 @@ Three tools keep the memory tidy. `consolidate()` and `forget()` default to
   `thread_janitor`), and
   **outcomes** (what those loops actually produced — skills materialized,
   tier promotions, candidate accept-vs-reject rate, plus knowledge-store
-  mutation counts: `lesson_append` / `lesson_remove`,
+  mutation counts: `lesson_append` (including patches) / `lesson_remove`,
   `curator_report_applied`, `roadmap_issue_applied`,
   `roadmap_issue_skipped`, `evolve_applied`, `dialectic_claim` /
   `dialectic_supersede`). A `curator_net_change

{threadkeeper-0.17.0 → threadkeeper-0.17.2}/README.md

@@ -555,10 +555,13 @@ daemon even if a CLI drops the no-embeddings env. Idempotent through
 `events.kind='shadow_review_pass'`.
 
 Before writing memory, the observer now checks existing lessons/skills and
-prefers patching broad skills. Shadow-origin `lesson_append` is a compact
-fallback only: oversized bodies are rejected, near-duplicate slugs are blocked,
-and semantic body matches are routed to the incumbent lesson or surfaced for
-curation instead of minting a sibling lesson.
+prefers patching broad skills. `lesson_patch(slug, old_string, new_string)`
+can correct one unique substring without reserializing a lesson. Shadow-origin
+`lesson_append` is a compact fallback only: oversized new bodies are rejected,
+though an existing same-slug long lesson may be corrected without increasing
+its body size; near-duplicate slugs are blocked, and semantic body matches are
+routed to the incumbent lesson or surfaced for curation instead of minting a
+sibling lesson.
 
 #### 3. Extract daemon
 
@@ -638,7 +641,12 @@ ThreadKeeper/Claude Code/Codex/Agent Skills compatibility, resource/link
 findings, mirror hashes, exact-body duplicate groups, and lexical candidates
 for semantic review. System and installed-plugin sources are resolved from
 their read-only caches rather than misreported as missing mirrors; telemetry
-rows with no real `SKILL.md` remain explicit orphans. The child reads every
+rows with no real `SKILL.md` remain explicit orphans. The same inventory also
+flags a dense lesson subtopic when at least
+`THREADKEEPER_CURATOR_PROMOTION_MIN_LESSONS` lessons (default 3) share a pair
+of meaningful title terms. A non-protected candidate must become one validated,
+checklist-style canonical skill before its source lessons are retired; protected
+clusters are left for human review. The child reads every
 complete skill and relevant support file, performs current web research against
 official docs and comparable
 public skills, then writes numbered per-skill verdicts to
@@ -707,7 +715,11 @@ cross-process, while foreground/human deletes are unaffected. `mp_dashboard`
 shows admitted and refused operations with `status=HIT` when the Curator reaches
 the ceiling.
 Before `lesson_remove` or `skill_manage(action='delete')` removes anything, it
-also writes a recovery artifact under `<db dir>/curator/trash/`: lessons store
+also rewrites inbound `[[wikilinks]]` when a consolidation provides
+`replacement_slug` / `replacement_name` for the surviving umbrella. A plain
+removal returns its complete `dangling_wikilinks=` source list instead, so
+those links can be repaired immediately. It writes a recovery artifact under
+`<db dir>/curator/trash/`: lessons store
 the exact sentinel section plus usage row, and skills store the full skill
 directory plus usage row. Restore trash artifacts with `lesson_restore(slug=...)`
 or `skill_manage(action='restore', name=...)`. Trash retention is bounded by
@@ -718,14 +730,14 @@ also the Curator apply worker: after the roadmap issue queue is empty, it looks
 for the latest complete Curator report (`CURATOR_PASS_COMPLETE`) whose path and
 current SHA-256 match an unapplied `curator_report_provenance` event, then
 spawns an `evolve_applier` child to apply only safe, still-current memory
-maintenance through `lesson_append` / `lesson_remove` / `skill_manage` /
+maintenance through `lesson_append` / `lesson_patch` / `lesson_remove` / `skill_manage` /
 `concept_manage`. It never touches `[PROTECTED]`,
 foreground/user, pinned, or validated entries. Only after the child finishes
 does it call `evolve_mark_curator_report_applied(...)` with the verified hash;
 the mark rechecks that hash and prevents replaying the same report.
 
 The shared lesson file has its own write serialization: `lesson_append`,
-`lesson_remove`, and `lesson_restore` hold a blocking `fcntl.flock` on
+`lesson_patch`, `lesson_remove`, and `lesson_restore` hold a blocking `fcntl.flock` on
 `lessons.md.lock` around file creation/read/mutate/write, so foreground calls
 and learning-loop children cannot last-writer-win over each other's sections.
 
@@ -847,7 +859,12 @@ throttling the roadmap loop.
 Before any PR-producing reviewer/audit or applier child is spawned, the parent
 checks the target checkout with `git status --porcelain --untracked-files=no`.
 Tracked-file WIP records `skipped_dirty_worktree` and no child is dispatched;
-untracked scratch files do not block. Each managed-checkout child fetches the
+the default managed checkout first preserves orphaned untracked files under
+`~/.threadkeeper/evolve-recovery/untracked-*/` and removes them from the next
+task’s tree. This prevents unrelated unfinished tests from blocking every PR
+repair. Ignored files (including `.venv`) and explicit operator checkouts stay
+in place; live writers prevent recovery, and backup failures block dispatch.
+Each managed-checkout child fetches the
 configured branch only to retrieve the configured immutable commit, then
 prepares or resumes its deterministic local/remote feature branch from
 `THREADKEEPER_EVOLVE_REPO_COMMIT`, never from the branch's moving tip. Retries
@@ -1330,7 +1347,7 @@ Three tools keep the memory tidy. `consolidate()` and `forget()` default to
   `thread_janitor`), and
   **outcomes** (what those loops actually produced — skills materialized,
   tier promotions, candidate accept-vs-reject rate, plus knowledge-store
-  mutation counts: `lesson_append` / `lesson_remove`,
+  mutation counts: `lesson_append` (including patches) / `lesson_remove`,
   `curator_report_applied`, `roadmap_issue_applied`,
   `roadmap_issue_skipped`, `evolve_applied`, `dialectic_claim` /
   `dialectic_supersede`). A `curator_net_change

{threadkeeper-0.17.0 → threadkeeper-0.17.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "threadkeeper"
-version = "0.17.0"
+version = "0.17.2"
 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.0 → threadkeeper-0.17.2}/tests/test_curator.py

@@ -51,6 +51,7 @@ def _bootstrap(
     monkeypatch,
     interval="0",
     min_lessons="3",
+    promotion_min_lessons="3",
     destructive=None,
     retention=None,
     max_destructive=None,
@@ -70,6 +71,7 @@ def _bootstrap(
         "THREADKEEPER_CURATOR_INTERVAL_S": interval,
         "THREADKEEPER_CURATOR_MANAGE_FOREGROUND_SKILLS": "0",
         "THREADKEEPER_CURATOR_MIN_LESSONS": min_lessons,
+        "THREADKEEPER_CURATOR_PROMOTION_MIN_LESSONS": promotion_min_lessons,
         "THREADKEEPER_CURATOR_REPORTS_DIR": str(tmp_path / "curator"),
         "THREADKEEPER_LESSONS": str(tmp_path / "lessons.md"),
         "THREADKEEPER_TASK_LOG_DIR": str(tmp_path / "tasks"),
@@ -178,6 +180,61 @@ def test_collect_inventory_counts_lessons_and_skills(tmp_path, monkeypatch):
     assert "STALE LESSONS (dry-run decay ranking)" in dump
 
 
+def test_dense_lesson_cluster_crosses_promotion_threshold(tmp_path, monkeypatch):
+    pkg = _bootstrap(tmp_path, monkeypatch, write_origin="shadow_review")
+    for title in (
+        "curator snapshot protects lesson rollback",
+        "curator snapshot keeps lesson evidence",
+    ):
+        pkg["lessons"].append_lesson(title=title, body="procedure", source="shadow")
+
+    conn = pkg["db"].get_db()
+    candidates = pkg["curator"]._detect_lesson_promotion_candidates(
+        list(pkg["lessons"].iter_lessons()),
+        pkg["lessons"].lesson_usage_map(conn),
+    )
+    assert candidates == []
+
+    pkg["lessons"].append_lesson(
+        title="curator snapshot restores lesson recovery",
+        body="procedure",
+        source="shadow",
+    )
+    candidates = pkg["curator"]._detect_lesson_promotion_candidates(
+        list(pkg["lessons"].iter_lessons()),
+        pkg["lessons"].lesson_usage_map(conn),
+    )
+    assert len(candidates) == 1
+    candidate = candidates[0]
+    assert candidate.topic_terms == ("curator", "snapshot")
+    assert candidate.decision == "PROMOTE_TO_SKILL"
+    assert candidate.protected_slugs == ()
+    assert candidate.lesson_slugs == (
+        "curator-snapshot-keeps-lesson-evidence",
+        "curator-snapshot-protects-lesson-rollback",
+        "curator-snapshot-restores-lesson-recovery",
+    )
+
+
+def test_protected_dense_cluster_requires_human_review(tmp_path, monkeypatch):
+    pkg = _bootstrap(tmp_path, monkeypatch)
+    for title in (
+        "curator snapshot protects lesson rollback",
+        "curator snapshot keeps lesson evidence",
+        "curator snapshot restores lesson recovery",
+    ):
+        pkg["lessons"].append_lesson(title=title, body="procedure", source="T123")
+
+    conn = pkg["db"].get_db()
+    candidates = pkg["curator"]._detect_lesson_promotion_candidates(
+        list(pkg["lessons"].iter_lessons()),
+        pkg["lessons"].lesson_usage_map(conn),
+    )
+    assert len(candidates) == 1
+    assert candidates[0].decision == "HUMAN_REVIEW"
+    assert candidates[0].protected_slugs == candidates[0].lesson_slugs
+
+
 def test_collect_inventory_marks_legacy_and_unknown_skills_protected(
     tmp_path, monkeypatch,
 ):
@@ -293,11 +350,13 @@ def test_run_curator_pass_spawns_when_threshold_met(tmp_path, monkeypatch):
     assert "lesson-one" in kw["prompt"]
     assert "lesson-two" in kw["prompt"]
     # Scoped toolset — destructive default (the new default) includes
-    # lesson_append / lesson_remove / skill_manage, but never shell or spawn.
+    # lesson_append / lesson_patch / lesson_remove / skill_manage, but never
+    # shell or spawn.
     allowed = kw["extra_allowed_tools"]
     assert "lesson_list" in allowed
     assert "lesson_get" in allowed
     assert "lesson_append" in allowed
+    assert "lesson_patch" in allowed
     assert "lesson_remove" in allowed
     assert "skill_manage" in allowed
     assert "evolve_format" in allowed
@@ -319,6 +378,42 @@ def test_run_curator_pass_spawns_when_threshold_met(tmp_path, monkeypatch):
     assert "THREADKEEPER_CURATOR_SNAPSHOT_DIR" not in os.environ
 
 
+def test_run_curator_pass_hands_dense_cluster_to_skill_promotion(
+    tmp_path, monkeypatch,
+):
+    pkg = _bootstrap(
+        tmp_path,
+        monkeypatch,
+        min_lessons="3",
+        write_origin="shadow_review",
+    )
+    for title in (
+        "curator snapshot protects lesson rollback",
+        "curator snapshot keeps lesson evidence",
+        "curator snapshot restores lesson recovery",
+    ):
+        pkg["lessons"].append_lesson(title=title, body="procedure", source="shadow")
+
+    import threadkeeper.tools.spawn as spawn_mod
+    captured: list[dict] = []
+
+    def fake_spawn(**kwargs):
+        captured.append(kwargs)
+        return "spawn task_id=fake-promotion-curator pid=0"
+
+    monkeypatch.setattr(spawn_mod, "spawn", fake_spawn)
+
+    out = pkg["curator"].run_curator_pass(force=True)
+    assert "fake-promotion-curator" in out
+    assert len(captured) == 1
+    prompt = captured[0]["prompt"]
+    assert "LESSON CLUSTER PROMOTION CANDIDATES (n=1)" in prompt
+    assert "PROMOTE_TO_SKILL: topic=curator snapshot lesson_count=3" in prompt
+    assert "Create one new, clearly named canonical skill" in prompt
+    assert "## Retired lessons" in prompt
+    assert "Only after it passes may you call" in prompt
+
+
 def test_run_curator_pass_batches_large_inventory_without_oversize_prompt(
     tmp_path, monkeypatch,
 ):
@@ -1089,6 +1184,7 @@ def test_destructive_mode_widens_allowed_tools(tmp_path, monkeypatch):
     # Destructive mode → widened toolset (incl. lesson_remove for prune/consolidate)
     assert "skill_manage" in allowed
     assert "lesson_append" in allowed
+    assert "lesson_patch" in allowed
     assert "lesson_remove" in allowed
     assert "evolve_format" in allowed
     # Prompt explicitly flips into destructive mode
@@ -1102,8 +1198,9 @@ def test_advisory_mode_excludes_destructive_tools(
     tmp_path, monkeypatch,
 ):
     """With THREADKEEPER_CURATOR_DESTRUCTIVE=0 the curator child is read-only:
-    prompt forbids skill_manage/lesson_append/lesson_remove and they aren't in
-    allowed_tools. (Destructive is the default, so advisory is now opt-in.)"""
+    prompt forbids skill_manage/lesson_append/lesson_patch/lesson_remove and
+    they aren't in allowed_tools. (Destructive is the default, so advisory is
+    now opt-in.)"""
     monkeypatch.setenv("THREADKEEPER_CURATOR_DESTRUCTIVE", "0")
     pkg = _bootstrap(tmp_path, monkeypatch, min_lessons="2")
     pkg["lessons"].append_lesson(

{threadkeeper-0.17.0 → threadkeeper-0.17.2}/tests/test_evolve_applier.py

@@ -2540,6 +2540,9 @@ def test_ensure_repo_ready_recovers_dirty_managed_base_before_refresh(
     (repo / "shared.txt").write_text(
         "issue implementation left on main\n", encoding="utf-8"
     )
+    (repo / "tests").mkdir()
+    orphan = repo / "tests" / "test_other_issue.py"
+    orphan.write_text("raise AssertionError('unrelated unfinished feature')\n")
     monkeypatch.setattr(
         pkg["ea"], "_prs_for_head_branch",
         lambda *args, **kwargs: (_ for _ in ()).throw(
@@ -2568,6 +2571,67 @@ def test_ensure_repo_ready_recovers_dirty_managed_base_before_refresh(
     ).fetchone()
     assert row["target"] == "managed_repo_refresh"
     assert "recovered_abandoned_wip branch=main" in row["summary"]
+    assert not orphan.exists()
+    saved = list((tmp_path / "evolve-recovery").glob("untracked-*/tests/*.py"))
+    assert len(saved) == 1
+    assert "unrelated unfinished feature" in saved[0].read_text()
+
+
+@pytest.mark.parametrize("mode", ["recover", "explicit", "live", "copy_error"])
+def test_untracked_recovery_preserves_work_and_isolates_next_validation(
+    tmp_path, monkeypatch, mode,
+):
+    pkg = _bootstrap(tmp_path, monkeypatch, pin_repo=False)
+    ea = pkg["ea"]
+    repo = ea._managed_repo_dir()
+    subprocess.run(["git", "init", str(repo)], check=True, capture_output=True)
+    # Use Git's actual ignore rules, including filenames with spaces/newlines.
+    (repo / ".git" / "info" / "exclude").write_text(".venv/\n")
+    (repo / ".venv").mkdir()
+    runtime = repo / ".venv" / "runtime"
+    runtime.write_text("keep runtime")
+    (repo / "tests").mkdir()
+    source = repo / "tests" / "test_orphan with\nnewline.py"
+    source.write_text("unfinished work\n")
+    outside = tmp_path / "outside.txt"
+    outside.write_text("external target")
+    link = repo / "orphan-link"
+    link.symlink_to(outside)
+    if mode == "explicit":
+        monkeypatch.setattr(ea, "EVOLVE_REPO_ROOT", str(repo))
+    if mode == "live":
+        monkeypatch.setattr(ea, "_running_git_writer_children", lambda conn: ["live"])
+    if mode == "copy_error":
+        def fail_copy(*args, **kwargs):
+            raise OSError("backup unavailable")
+        monkeypatch.setattr(ea.shutil, "copy2", fail_copy)
+
+    result = pkg["orig"]["_git_worktree_precondition"](
+        pkg["db"].get_db(), repo, "conflict_repair"
+    )
+
+    assert runtime.read_text() == "keep runtime"
+    assert outside.read_text() == "external target"
+    if mode == "recover":
+        assert result == ""
+        assert not source.exists() and not link.is_symlink()
+        backups = list((tmp_path / "evolve-recovery").glob("untracked-*"))
+        assert len(backups) == 1
+        assert backups[0].stat().st_mode & 0o777 == 0o700
+        assert (backups[0] / source.relative_to(repo)).read_text() == "unfinished work\n"
+        assert (backups[0] / "orphan-link").is_symlink()
+        assert pkg["orig"]["_git_worktree_precondition"](
+            pkg["db"].get_db(), repo, "conflict_repair"
+        ) == ""
+        assert len(list((tmp_path / "evolve-recovery").glob("untracked-*"))) == 1
+    else:
+        assert source.read_text() == "unfinished work\n" and link.is_symlink()
+        if mode == "live":
+            assert result.startswith("evolve_git_writer_running")
+        elif mode == "copy_error":
+            assert "untracked_quarantine_failed" in result
+        else:
+            assert result == ""
 
 
 def test_managed_refresh_checks_live_writer_before_dirty_recovery(

{threadkeeper-0.17.0 → threadkeeper-0.17.2}/tests/test_host_main.py

@@ -36,3 +36,29 @@ def test_serve_wires_local_encoder(monkeypatch, tmp_path):
     assert seen["sock"] == config.HOST_SOCK_PATH
     # the wired encoder delegates to embeddings._encode
     assert callable(seen["enc"])
+
+
+def test_wedge_deadline_self_heal(monkeypatch, tmp_path):
+    host = _reimport(monkeypatch, tmp_path)
+    f = host._wedge_deadline_passed
+    # no starvation streak → never heals
+    assert f(None, 1000.0, 600.0) is False
+    # streak shorter than the window → hold on
+    assert f(1000.0, 1000.0 + 599.0, 600.0) is False
+    # streak reached the window → self-heal
+    assert f(1000.0, 1000.0 + 600.0, 600.0) is True
+    assert f(1000.0, 1000.0 + 900.0, 600.0) is True
+    # feature disabled (wedge_s <= 0) → never heals even when long-starved
+    assert f(1000.0, 1000.0 + 100000.0, 0.0) is False
+
+
+def test_heartbeat_returns_bool(monkeypatch, tmp_path):
+    host = _reimport(monkeypatch, tmp_path)
+    import threadkeeper.db as db
+    monkeypatch.setattr(db, "run_write", lambda *a, **k: None)
+    monkeypatch.setattr(host, "_heartbeat", host._heartbeat)  # ensure real fn
+    assert host._heartbeat() is True
+    def _boom(*a, **k):
+        raise RuntimeError("wedged")
+    monkeypatch.setattr(db, "run_write", _boom)
+    assert host._heartbeat() is False

{threadkeeper-0.17.0 → threadkeeper-0.17.2}/tests/test_identity.py

@@ -13,6 +13,17 @@ from __future__ import annotations
 
 import re
 
+import pytest
+
+
+def test_emit_requires_session_setup(fresh_mp):
+    """A forgotten session setup must fail instead of dropping telemetry."""
+    identity = fresh_mp["identity"]
+    conn = fresh_mp["db"].get_db()
+
+    with pytest.raises(RuntimeError, match="requires session setup"):
+        identity._emit(conn, "test_missing_session")
+
 
 def test_session_id_set_after_ensure_session(fresh_mp):
     identity = fresh_mp["identity"]

{threadkeeper-0.17.0 → threadkeeper-0.17.2}/tests/test_lessons.py

@@ -205,6 +205,40 @@ def test_mcp_lesson_append_validates_inputs(tmp_path, monkeypatch):
     assert out.startswith("ok slug=ok-one")
 
 
+def test_mcp_lesson_patch_replaces_one_unique_substring(tmp_path, monkeypatch):
+    pkg = _bootstrap(tmp_path, monkeypatch)
+    la = _tool(pkg, "lesson_append")
+    lp = _tool(pkg, "lesson_patch")
+    la(
+        title="retry strategy",
+        summary="Retry only transient failures.",
+        body=(
+            "Use equal jitter for transient errors; do not retry errors "
+            "indefinitely."
+        ),
+        source="shadow",
+    )
+
+    out = lp(
+        slug="retry-strategy",
+        old_string="equal jitter",
+        new_string="decorrelated jitter",
+    )
+
+    assert out.startswith("ok slug=retry-strategy")
+    section = pkg["path"].read_text()
+    assert "decorrelated jitter" in section
+    assert "equal jitter" not in section
+    assert "source=shadow" in section
+    assert "Retry only transient failures." in section
+    assert lp(
+        slug="retry-strategy", old_string="missing", new_string="x",
+    ) == "ERR old_string_not_found"
+    assert lp(
+        slug="retry-strategy", old_string="errors", new_string="x",
+    ).startswith("ERR old_string_ambiguous")
+
+
 def test_shadow_lesson_append_rejects_overlong_body(tmp_path, monkeypatch):
     pkg = _bootstrap(tmp_path, monkeypatch)
     la = _tool(pkg, "lesson_append")
@@ -214,6 +248,28 @@ def test_shadow_lesson_append_rejects_overlong_body(tmp_path, monkeypatch):
     assert "max=450" in out
 
 
+def test_shadow_lesson_append_allows_non_growing_same_slug_repair(
+    tmp_path, monkeypatch,
+):
+    pkg = _bootstrap(tmp_path, monkeypatch, write_origin="shadow_review")
+    la = _tool(pkg, "lesson_append")
+    original = "word " * 451
+    repaired = "rule " + "word " * 450
+    pkg["lessons"].append_lesson(
+        title="long shadow lesson", body=original, source="shadow",
+    )
+
+    out = la(title="long shadow lesson", body=repaired, source="shadow")
+
+    assert out.startswith("ok slug=long-shadow-lesson")
+    assert "rule" in pkg["path"].read_text()
+    assert la(
+        title="long shadow lesson",
+        body="longer " + "word " * 450,
+        source="shadow",
+    ).startswith("ERR shadow_lesson_too_long")
+
+
 def test_shadow_lesson_append_rejects_near_duplicate_slug(
     tmp_path, monkeypatch,
 ):
@@ -477,6 +533,41 @@ def test_mcp_lesson_remove_deletes_nonprotected_section(tmp_path, monkeypatch):
     )
 
 
+def test_lesson_consolidation_rewrites_inbound_wikilinks(tmp_path, monkeypatch):
+    pkg = _bootstrap(tmp_path, monkeypatch, write_origin="shadow_review")
+    la = _tool(pkg, "lesson_append")
+    lr = _tool(pkg, "lesson_remove")
+    la(title="umbrella rule", body="new canonical rule", source="shadow")
+    la(title="retired rule", body="old duplicate rule", source="shadow")
+    la(
+        title="consumer rule",
+        body="See [[retired-rule]], [[retired-rule|this rule]], and "
+        "[[retired-rule#details]].",
+        source="shadow",
+    )
+
+    out = lr(slug="retired-rule", replacement_slug="umbrella rule")
+
+    assert out == "ok removed=retired-rule inbound_rewritten=lesson:consumer-rule"
+    consumer = _tool(pkg, "lesson_get")(slug="consumer-rule")
+    assert "[[umbrella-rule]]" in consumer
+    assert "[[umbrella-rule|this rule]]" in consumer
+    assert "[[umbrella-rule#details]]" in consumer
+    assert "[[retired-rule" not in consumer
+
+
+def test_lesson_remove_reports_dangling_wikilink_sources(tmp_path, monkeypatch):
+    pkg = _bootstrap(tmp_path, monkeypatch, write_origin="shadow_review")
+    la = _tool(pkg, "lesson_append")
+    lr = _tool(pkg, "lesson_remove")
+    la(title="retired rule", body="old duplicate rule", source="shadow")
+    la(title="consumer rule", body="See [[retired-rule]].", source="shadow")
+
+    out = lr(slug="retired-rule")
+
+    assert out == "ok removed=retired-rule dangling_wikilinks=lesson:consumer-rule"
+
+
 def test_mcp_lesson_restore_recreates_original_bytes(tmp_path, monkeypatch):
     pkg = _bootstrap(tmp_path, monkeypatch, write_origin="shadow_review")
     la = _tool(pkg, "lesson_append")

{threadkeeper-0.17.0 → threadkeeper-0.17.2}/tests/test_notify_daemon.py

@@ -131,6 +131,41 @@ def test_timeout_and_zero_exit_children_ignored(tmp_path, monkeypatch):
     assert out == "ok fired=0", out
 
 
+def test_dead_child_returncode_null_with_fatal_log_fires(tmp_path, monkeypatch, caplog):
+    # A child reaped after the DB writer wedged closes its row with the exit
+    # code lost (return_code NULL). It must still alert when the captured log
+    # shows a fatal degradation signature — the quota-exhaustion case that
+    # first exposed the gap.
+    m = _bootstrap(tmp_path, monkeypatch)
+    notify, db = m["notify"], m["db"]
+    conn = db.get_db()
+    assert notify.run_notify_pass(force=True) == "seed"
+    (tmp_path / "tasks" / "child-q.log").write_text(
+        "booting\nYou have exceeded your monthly quota\n")
+    _task(conn, "child-q", rc=None, role="candidate_reviewer",
+          ended_at=int(time.time()))
+    with caplog.at_level(logging.WARNING, logger="threadkeeper.notify"):
+        out = notify.run_notify_pass(force=True)
+    assert out == "ok fired=1", out
+    assert "candidate_reviewer child died (rc=unknown)" in caplog.text
+    assert "exceeded your monthly quota" in caplog.text
+
+
+def test_dead_child_returncode_null_clean_log_ignored(tmp_path, monkeypatch):
+    # return_code NULL with no failure evidence in the log is indistinguishable
+    # from a clean completion — must NOT fire (no false positives).
+    m = _bootstrap(tmp_path, monkeypatch)
+    notify, db = m["notify"], m["db"]
+    conn = db.get_db()
+    assert notify.run_notify_pass(force=True) == "seed"
+    (tmp_path / "tasks" / "child-clean.log").write_text(
+        "starting\nall done, wrote 2 notes\n")
+    _task(conn, "child-clean", rc=None, role="curator",
+          ended_at=int(time.time()))
+    out = notify.run_notify_pass(force=True)
+    assert out == "ok fired=0", out
+
+
 # ── cooldown / de-dup ───────────────────────────────────────────────────────
 
 def test_cooldown_dedups_repeat_failures(tmp_path, monkeypatch):

{threadkeeper-0.17.0 → threadkeeper-0.17.2}/tests/test_shadow_review.py

@@ -375,6 +375,7 @@ def test_run_shadow_pass_spawns_when_threshold_met(tmp_path, monkeypatch):
     assert "lesson_list(k=80)" in kw["prompt"]
     assert "hard cap 450" in kw["prompt"]
     assert "mcp__thread-keeper__lesson_get" in kw["extra_allowed_tools"]
+    assert "mcp__thread-keeper__lesson_patch" in kw["extra_allowed_tools"]
     assert long_msg.strip()[:40] in kw["prompt"]
     # De-privileged (issue #76): no bare Read/Write — path-scoped skill/
     # lesson MCP tools only.