threadkeeper 0.17.2__tar.gz → 0.17.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: threadkeeper
-Version: 0.17.2
+Version: 0.17.4
 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
@@ -310,6 +310,12 @@ uses a SQLite `BEGIN IMMEDIATE` reservation: `spawn()` re-checks the budget and
 inserts the child task row with its RSS estimate before `Popen`, so two
 concurrent spawns cannot both squeeze through the cap.
 
+When `cwd` is inside a Git checkout, `spawn()` also requires the source
+checkout's tracked files to be clean, then starts the child from a unique
+branch/worktree under `THREADKEEPER_TASK_LOG_DIR/worktrees/`. Parallel children
+therefore never share a mutable checkout or Git index. Non-Git directories keep
+their existing behavior; a dirty Git checkout is refused before a child starts.
+
 The spawn wrapper also records each completed child's `duration_s`,
 `tokens_in`, `tokens_out`, `tokens_total`, and `cost_usd` when the underlying
 CLI emits a recognizable usage trailer. Optional daily ceilings
@@ -710,6 +716,12 @@ non-forced direct `curator_review()` calls return `not_due` inside the
 configured interval and record that status without spawning. A manual
 `curator_review(force=True)` bypasses the interval but still respects the lock.
 
+For automation-created skills, the audit keeps foreground consultation separate
+from maintenance: a background-review skill with `fg_uses=0` after 14 days is
+still a false-positive prune candidate even if automatic review or sync loops
+have increased its patch counter. Patches are maintenance activity, not proof
+that a foreground user or agent consulted the skill.
+
 Before spawning, the scheduler hashes lessons, concepts, skill bodies, support
 trees, validators, and mirror state. Repeated manual calls over identical bytes
 return `unchanged_inventory`; the scheduled three-day pass still runs because
@@ -1058,7 +1070,10 @@ Three detection sources per tick:
    from an exhausted subscription; the real outcome only lands in
    `tasks.return_code`. The reason is read from the child's log tail.
 3. **Materialization** — `skill_materialized` / `skill_create` (skill) and
-   `lesson_append` (lesson).
+   `lesson_append` (lesson). Each notification contains one readable artifact
+   name: the skill's first heading (falling back to its directory name), or
+   the lesson name with slug separators replaced by spaces. Paths, provenance,
+   and operation metadata stay out of the notification text.
 
 A per-loop cooldown collapses a lapsed-subscription storm into one actionable
 alert; the first run seeds its cursor to the current position, so historical
@@ -1089,12 +1104,16 @@ will register the app in **System Settings ▸ Notifications** and show banners;
 banners are titled **Thread-Keeper** (`CFBundleDisplayName`). The first launch
 after an update shows a one-time permission prompt.
 
-`agent_status` feeds the app two lists — `recent_results` (positive: captured
-skills/lessons) and `recent_failures` (the two failure sources above) — each item
-tagged with a `notify` flag computed from the toggles below. The app **lists**
+`agent_status` feeds the app two lists — `recent_results` (named skill/lesson
+write events plus completed-task history) and `recent_failures` (the two failure
+sources above) — each item tagged with a `notify` flag computed from the toggles
+below. The app **lists**
 every item in its menu but only **posts a banner** for flagged ones, so turning a
-category off silences the banner without hiding the history. Enabling a toggle
-never replays backlog.
+category off silences the banner without hiding the history. Each materialization
+uses its own skill or lesson toggle; generic task reports are history-only.
+Foreground writes appear too, without waiting for a background child to finish.
+A pathless skill mark only silences its reminder and has no materialization
+banner. Enabling a toggle never replays backlog.
 
 **Settings in the app.** The menu-bar app's **Settings ▸ Notifications** tab
 edits these same `THREADKEEPER_NOTIFY_*` keys visually — switches for the
@@ -1542,8 +1561,9 @@ Spawn task spool files live in `THREADKEEPER_TASK_LOG_DIR` (default
 the hardened `~/.threadkeeper` perimeter by default; explicit overrides are
 refused when the configured directory is a symlink or is not owned by the
 current user. `spawn()` creates captured headless `.log`, stdin prompt spool,
-and visible `.command` files with no-follow owner-only opens. `consolidate()`
-garbage-collects task spool files once their task row is no longer retained.
+and visible `.command` files with no-follow owner-only opens. Git-backed spawns
+also create their isolated worktrees there. `consolidate()` garbage-collects
+task spool files once their task row is no longer retained.
 
 ---
 

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

@@ -266,6 +266,12 @@ uses a SQLite `BEGIN IMMEDIATE` reservation: `spawn()` re-checks the budget and
 inserts the child task row with its RSS estimate before `Popen`, so two
 concurrent spawns cannot both squeeze through the cap.
 
+When `cwd` is inside a Git checkout, `spawn()` also requires the source
+checkout's tracked files to be clean, then starts the child from a unique
+branch/worktree under `THREADKEEPER_TASK_LOG_DIR/worktrees/`. Parallel children
+therefore never share a mutable checkout or Git index. Non-Git directories keep
+their existing behavior; a dirty Git checkout is refused before a child starts.
+
 The spawn wrapper also records each completed child's `duration_s`,
 `tokens_in`, `tokens_out`, `tokens_total`, and `cost_usd` when the underlying
 CLI emits a recognizable usage trailer. Optional daily ceilings
@@ -666,6 +672,12 @@ non-forced direct `curator_review()` calls return `not_due` inside the
 configured interval and record that status without spawning. A manual
 `curator_review(force=True)` bypasses the interval but still respects the lock.
 
+For automation-created skills, the audit keeps foreground consultation separate
+from maintenance: a background-review skill with `fg_uses=0` after 14 days is
+still a false-positive prune candidate even if automatic review or sync loops
+have increased its patch counter. Patches are maintenance activity, not proof
+that a foreground user or agent consulted the skill.
+
 Before spawning, the scheduler hashes lessons, concepts, skill bodies, support
 trees, validators, and mirror state. Repeated manual calls over identical bytes
 return `unchanged_inventory`; the scheduled three-day pass still runs because
@@ -1014,7 +1026,10 @@ Three detection sources per tick:
    from an exhausted subscription; the real outcome only lands in
    `tasks.return_code`. The reason is read from the child's log tail.
 3. **Materialization** — `skill_materialized` / `skill_create` (skill) and
-   `lesson_append` (lesson).
+   `lesson_append` (lesson). Each notification contains one readable artifact
+   name: the skill's first heading (falling back to its directory name), or
+   the lesson name with slug separators replaced by spaces. Paths, provenance,
+   and operation metadata stay out of the notification text.
 
 A per-loop cooldown collapses a lapsed-subscription storm into one actionable
 alert; the first run seeds its cursor to the current position, so historical
@@ -1045,12 +1060,16 @@ will register the app in **System Settings ▸ Notifications** and show banners;
 banners are titled **Thread-Keeper** (`CFBundleDisplayName`). The first launch
 after an update shows a one-time permission prompt.
 
-`agent_status` feeds the app two lists — `recent_results` (positive: captured
-skills/lessons) and `recent_failures` (the two failure sources above) — each item
-tagged with a `notify` flag computed from the toggles below. The app **lists**
+`agent_status` feeds the app two lists — `recent_results` (named skill/lesson
+write events plus completed-task history) and `recent_failures` (the two failure
+sources above) — each item tagged with a `notify` flag computed from the toggles
+below. The app **lists**
 every item in its menu but only **posts a banner** for flagged ones, so turning a
-category off silences the banner without hiding the history. Enabling a toggle
-never replays backlog.
+category off silences the banner without hiding the history. Each materialization
+uses its own skill or lesson toggle; generic task reports are history-only.
+Foreground writes appear too, without waiting for a background child to finish.
+A pathless skill mark only silences its reminder and has no materialization
+banner. Enabling a toggle never replays backlog.
 
 **Settings in the app.** The menu-bar app's **Settings ▸ Notifications** tab
 edits these same `THREADKEEPER_NOTIFY_*` keys visually — switches for the
@@ -1498,8 +1517,9 @@ Spawn task spool files live in `THREADKEEPER_TASK_LOG_DIR` (default
 the hardened `~/.threadkeeper` perimeter by default; explicit overrides are
 refused when the configured directory is a symlink or is not owned by the
 current user. `spawn()` creates captured headless `.log`, stdin prompt spool,
-and visible `.command` files with no-follow owner-only opens. `consolidate()`
-garbage-collects task spool files once their task row is no longer retained.
+and visible `.command` files with no-follow owner-only opens. Git-backed spawns
+also create their isolated worktrees there. `consolidate()` garbage-collects
+task spool files once their task row is no longer retained.
 
 ---
 

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

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

@@ -4,6 +4,8 @@ import json
 import os
 import time
 
+import pytest
+
 
 _FAKE_CID = "33334444-5555-6666-7777-888899990000"
 
@@ -468,6 +470,42 @@ def test_agent_status_recent_results_for_useful_completed_tasks(mp_with_cid):
     assert snap["recent_results"][0]["summary"] == (
         "Processed 2 candidates into durable notes."
     )
+    assert snap["recent_results"][0]["notify"] is False
+
+
+@pytest.mark.parametrize("poll,skill,lesson", [
+    (30, True, True), (30, True, False), (30, False, True), (0, True, True),
+])
+def test_materialization_results_name_actual_writes(mp_with_cid, poll, skill, lesson):
+    pkg = mp_with_cid(_FAKE_CID)
+    pkg["config"].NOTIFY_POLL_S = poll
+    pkg["config"].NOTIFY_SKILL_MATERIALIZED = skill
+    pkg["config"].NOTIFY_LESSON = lesson
+    result = _txt(_tool(pkg, "skill_manage")(
+        action="create", name="api-contract-testing",
+        description="Test API contracts.", content="# API contract testing\n\nUse schemas.",
+    ))
+    assert result.startswith("ok"), result
+    result = _txt(_tool(pkg, "lesson_append")(
+        title="Verify state transitions", body="Assert the state after the action.",
+        source="T1",
+    ))
+    assert result.startswith("ok"), result
+    _insert_completed_task(pkg, "tk_generic_done",
+                           "You are a CANDIDATE REVIEWER for thread-keeper's extract queue.",
+                           "Processed 2 candidates into durable notes.\n")
+
+    from threadkeeper.agent_status import agent_status_snapshot
+
+    items = agent_status_snapshot(refresh=False)["recent_results"]
+    by_role = {item["role"]: item for item in items}
+    assert by_role["skill"]["summary"] == "API contract testing"
+    assert by_role["lesson"]["summary"] == "Verify state transitions"
+    assert by_role["skill"]["notify"] is bool(poll and skill)
+    assert by_role["lesson"]["notify"] is bool(poll and lesson)
+    assert by_role["candidate_reviewer"]["notify"] is False
+    assert all(item["id"].startswith("materialization:")
+               for item in items if item["role"] in ("skill", "lesson"))
 
 
 def test_agent_status_mcp_json_output(mp_with_cid):

{threadkeeper-0.17.2 → threadkeeper-0.17.4}/tests/test_curator.py

@@ -843,6 +843,48 @@ def test_skill_validator_is_exhaustive_and_semantic(tmp_path, monkeypatch):
     assert "3. SKILL second-skill" in checklist
 
 
+def test_curator_prune_rubric_keeps_patched_unconsulted_skill_eligible(
+    tmp_path, monkeypatch,
+):
+    pkg = _bootstrap(tmp_path, monkeypatch, min_lessons="2")
+    pkg["lessons"].append_lesson(title="one", body="b1", source="shadow")
+    pkg["lessons"].append_lesson(title="two", body="b2", source="shadow")
+    _write_audit_skill(
+        pkg["skills_dir"], "patched-background-skill", "# Rule\nDo the test.",
+    )
+    now = int(time.time())
+    conn = pkg["db"].get_db()
+    conn.execute(
+        "INSERT INTO skill_usage "
+        "(name, created_at, created_by_origin, last_patched_at, patch_count, "
+        "foreground_use_count, state) VALUES (?, ?, ?, ?, ?, ?, ?)",
+        (
+            "patched-background-skill", now - 30 * 86400,
+            "background_review", now, 4, 0, "active",
+        ),
+    )
+    conn.commit()
+
+    import threadkeeper.tools.spawn as spawn_mod
+    captured: list[dict] = []
+
+    def fake_spawn(**kwargs):
+        captured.append(kwargs)
+        return "spawn task_id=patched-background-skill pid=0"
+
+    monkeypatch.setattr(spawn_mod, "spawn", fake_spawn)
+    pkg["curator"].run_curator_pass(force=True)
+
+    prompt = captured[0]["prompt"]
+    assert "origin=background_review AND fg_uses=0" in prompt
+    assert "they are not foreground consultation" in prompt
+    assert "SKILL patched-background-skill" in prompt
+    assert "fg_uses=0" in prompt
+    assert "maintenance_patches=4" in prompt
+    assert "created=30d_ago" in prompt
+    assert "patches=0" not in prompt
+
+
 def test_skill_validate_tool_returns_post_change_contract(tmp_path, monkeypatch):
     pkg = _bootstrap(tmp_path, monkeypatch)
     primary = pkg["skills_dir"]

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

@@ -228,8 +228,48 @@ def test_positives_on_fire(tmp_path, monkeypatch, caplog):
     with caplog.at_level(logging.WARNING, logger="threadkeeper.notify"):
         out = notify.run_notify_pass(force=True)
     assert out == "ok fired=2", out
-    assert "skill materialized" in caplog.text
-    assert "lesson added" in caplog.text and "my-lesson" in caplog.text
+    assert "skill materialized | Foo" in caplog.text
+    assert "lesson added | My lesson" in caplog.text
+    assert "/skills/" not in caplog.text
+    assert "op=create" not in caplog.text and "source=shadow" not in caplog.text
+
+
+@pytest.mark.parametrize("directory", [False, True])
+def test_skill_notification_uses_heading(tmp_path, monkeypatch, directory):
+    m = _bootstrap(tmp_path, monkeypatch, skill="true")
+    md = tmp_path / "api-contract-testing" / "SKILL.md"
+    md.parent.mkdir()
+    md.write_text("---\nname: api-contract-testing\ndescription: |\n"
+                  "  Internal description\n---\n\n# API contract testing\n"
+                  "\nLong implementation details that do not belong in a banner.\n")
+    notify = m["notify"]
+    conn = m["db"].get_db()
+    sent = []
+    monkeypatch.setattr(notify, "_dispatch", lambda *args: sent.append(args))
+    assert notify.run_notify_pass(force=True) == "seed"
+    _ev(conn, "skill_materialized", target="T1",
+        summary=str(md.parent if directory else md))
+    assert notify.run_notify_pass(force=True) == "ok fired=1"
+    assert sent == [("Thread-keeper: skill materialized", "API contract testing")]
+    assert notify.run_notify_pass(force=True) == "ok fired=0"
+
+
+@pytest.mark.parametrize("body", [b"---\nname: foo\n---\nNo heading.", b"\xff"])
+def test_skill_notification_falls_back_to_name(tmp_path, monkeypatch, body):
+    notify = _bootstrap(tmp_path, monkeypatch)["notify"]
+    md = tmp_path / "api-contract-testing" / "SKILL.md"
+    md.parent.mkdir()
+    md.write_bytes(body)
+    assert notify._fmt_skill({"kind": "skill_create", "target": "api-contract-testing",
+                              "summary": str(md)})[1] == "Api contract testing"
+
+
+def test_pathless_skill_mark_does_not_claim_a_materialization(tmp_path, monkeypatch):
+    m = _bootstrap(tmp_path, monkeypatch, skill="true")
+    notify, conn = m["notify"], m["db"].get_db()
+    assert notify.run_notify_pass(force=True) == "seed"
+    _ev(conn, "skill_materialized", target="T1", summary="(no path recorded)")
+    assert notify.run_notify_pass(force=True) == "ok fired=0"
 
 
 # ── disabled ────────────────────────────────────────────────────────────────

{threadkeeper-0.17.2 → threadkeeper-0.17.4}/tests/test_spawn_slim.py

@@ -171,7 +171,7 @@ def test_visible_command_script_is_owner_only(mp_with_cid, monkeypatch):
     monkeypatch.setattr(spawn_mod.subprocess, "Popen", _FakePopen)
 
     spawn_fn = pkg["mcp"]._tool_manager._tools["spawn"].fn
-    out = spawn_fn(prompt="do a thing", visible=True)
+    out = spawn_fn(prompt="do a thing", cwd=str(pkg["tmp"]), visible=True)
     assert out.startswith("ok task="), out
 
     cmd_files = list(spawn_mod.TASK_LOG_DIR.glob("*.command"))
@@ -197,7 +197,12 @@ def test_headless_log_file_is_owner_only(mp_with_cid, monkeypatch):
     monkeypatch.setattr(spawn_mod.subprocess, "Popen", _FakePopen)
 
     spawn_fn = pkg["mcp"]._tool_manager._tools["spawn"].fn
-    out = spawn_fn(prompt="do a thing", visible=False, capture_output=True)
+    out = spawn_fn(
+        prompt="do a thing",
+        cwd=str(pkg["tmp"]),
+        visible=False,
+        capture_output=True,
+    )
     assert out.startswith("ok task="), out
 
     log_files = list(spawn_mod.TASK_LOG_DIR.glob("*.log"))

threadkeeper-0.17.4/tests/test_spawn_worktree_isolation.py

@@ -0,0 +1,112 @@
+"""Git worktree isolation on the shared spawn path."""
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+
+_FAKE_CID = "aaaa0000-bbbb-1111-cccc-222233334444"
+
+
+def _git(repo: Path, *args: str) -> str:
+    proc = subprocess.run(
+        ["git", "-C", str(repo), *args],
+        text=True,
+        capture_output=True,
+        check=True,
+    )
+    return proc.stdout.strip()
+
+
+def _init_repo(tmp_path: Path) -> Path:
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    _git(repo, "init", "-b", "main")
+    _git(repo, "config", "user.email", "test@example.com")
+    _git(repo, "config", "user.name", "Test User")
+    (repo / "tracked.txt").write_text("base\n", encoding="utf-8")
+    _git(repo, "add", "tracked.txt")
+    _git(repo, "commit", "-m", "base")
+    return repo
+
+
+def _configure_spawn(monkeypatch, pkg):
+    import threadkeeper.identity as identity
+    import threadkeeper.spawn_config as spawn_config
+    import threadkeeper.tools.spawn as spawn_mod
+
+    monkeypatch.setattr(spawn_mod, "_claude_bin", lambda: "/bin/true")
+    monkeypatch.setattr(identity, "_active_cli", "claude")
+    monkeypatch.setattr(
+        spawn_config, "resolve_agent", lambda role, active_cli=None: "claude"
+    )
+    monkeypatch.setattr(spawn_config, "resolve_model", lambda cli, role="": "")
+    return spawn_mod
+
+
+def test_git_spawns_get_distinct_branch_worktrees(mp_with_cid, monkeypatch):
+    pkg = mp_with_cid(_FAKE_CID)
+    repo = _init_repo(pkg["tmp"])
+    spawn_mod = _configure_spawn(monkeypatch, pkg)
+    child_cwds: list[Path] = []
+
+    class _FakePopen:
+        def __init__(self, _args, **kwargs):
+            child_cwds.append(Path(kwargs["cwd"]))
+            self.pid = 4200 + len(child_cwds)
+
+    monkeypatch.setattr(spawn_mod.subprocess, "Popen", _FakePopen)
+
+    first = spawn_mod.spawn(
+        prompt="first child", cwd=str(repo), visible=False, capture_output=False
+    )
+    second = spawn_mod.spawn(
+        prompt="second child", cwd=str(repo), visible=False, capture_output=False
+    )
+
+    assert first.startswith("ok task="), first
+    assert second.startswith("ok task="), second
+    assert len(child_cwds) == 2
+    assert child_cwds[0] != child_cwds[1]
+    assert all(path != repo and path.is_dir() for path in child_cwds)
+    roots = [
+        spawn_mod._git_result(["rev-parse", "--show-toplevel"], path)[0]
+        for path in child_cwds
+    ]
+    assert roots == [str(path) for path in child_cwds]
+    branches = [
+        spawn_mod._git_result(["branch", "--show-current"], path)[0]
+        for path in child_cwds
+    ]
+    assert len(set(branches)) == 2
+    assert all(branch.startswith("threadkeeper/spawn-tk_") for branch in branches)
+    assert spawn_mod._git_result(
+        ["status", "--porcelain", "--untracked-files=no"], repo
+    )[0] == ""
+
+
+def test_dirty_git_checkout_is_refused_before_child_launch(
+    mp_with_cid, monkeypatch,
+):
+    pkg = mp_with_cid(_FAKE_CID)
+    repo = _init_repo(pkg["tmp"])
+    spawn_mod = _configure_spawn(monkeypatch, pkg)
+    (repo / "tracked.txt").write_text("uncommitted\n", encoding="utf-8")
+
+    def _unexpected_launch(*_args, **_kwargs):
+        raise AssertionError("dirty checkout must be rejected before Popen")
+
+    monkeypatch.setattr(spawn_mod.subprocess, "Popen", _unexpected_launch)
+
+    out = spawn_mod.spawn(
+        prompt="must not launch", cwd=str(repo), visible=False, capture_output=False
+    )
+
+    assert out == "ERR spawn_dirty_worktree mode=git"
+    worktrees, err = spawn_mod._git_result(
+        ["worktree", "list", "--porcelain"], repo
+    )
+    assert not err
+    assert worktrees.count("worktree ") == 1
+    conn = pkg["db"].get_db()
+    assert conn.execute("SELECT COUNT(*) FROM tasks").fetchone()[0] == 0

{threadkeeper-0.17.2 → threadkeeper-0.17.4}/threadkeeper/agent_status.py

@@ -878,17 +878,47 @@ def _extract_useful_result(task_id: str) -> str:
     return ""
 
 
-def _recent_results(conn, now: int, limit: int = 10) -> list[dict[str, Any]]:
+def _recent_materializations(conn, now: int, limit: int) -> list[dict[str, Any]]:
+    """Name actual writes, including foreground writes without a child task."""
     from . import config
-    # Positive materialization notifications (#257). These are captured skills /
-    # lessons surfaced as useful loop output; the app posts a banner only when
-    # notifications are enabled (NOTIFY_POLL_S master gate) and a positive toggle
-    # is on, but the menu always lists them (`notify` flag).
+    from .notify import _fmt_skill, _fmt_lesson
+
     enabled = float(getattr(config, "NOTIFY_POLL_S", 0) or 0) > 0
-    positive_notify = enabled and bool(
-        getattr(config, "NOTIFY_SKILL_MATERIALIZED", False)
-        or getattr(config, "NOTIFY_LESSON", False)
-    )
+    rows = conn.execute(
+        "SELECT id, kind, target, summary, created_at FROM events "
+        "WHERE kind IN ('skill_create', 'skill_materialized', 'lesson_append') "
+        "AND created_at>=? ORDER BY created_at DESC, id DESC LIMIT ?",
+        (now - _RESULT_WINDOW_S, int(limit)),
+    ).fetchall()
+    results = []
+    for row in rows:
+        skill = row["kind"] != "lesson_append"
+        title, summary = (_fmt_skill if skill else _fmt_lesson)(dict(row))
+        if not summary:
+            continue
+        age_s = max(0, now - row["created_at"])
+        results.append({
+            "id": f"materialization:{row['id']}",
+            "task_id": "",
+            "role": "skill" if skill else "lesson",
+            "loop_id": "",
+            "loop_name": "Skill" if skill else "Lesson",
+            "title": title,
+            "summary": summary,
+            "ended_at": row["created_at"],
+            "age_s": age_s,
+            "age": fmt_age(age_s),
+            "notify": enabled and bool(
+                config.NOTIFY_SKILL_MATERIALIZED if skill else config.NOTIFY_LESSON
+            ),
+        })
+    return results
+
+
+def _recent_results(conn, now: int, limit: int = 10) -> list[dict[str, Any]]:
+    # Event-backed materializations carry names and per-category toggles.
+    # Generic completion reports remain in history without duplicate banners.
+    materializations = _recent_materializations(conn, now, limit)
     role_loop = _role_to_loop()
     rows = conn.execute(
         "SELECT id, prompt, ended_at, return_code FROM tasks "
@@ -919,11 +949,12 @@ def _recent_results(conn, now: int, limit: int = 10) -> list[dict[str, Any]]:
             "ended_at": ended_at,
             "age_s": age_s,
             "age": fmt_age(age_s),
-            "notify": positive_notify,
+            "notify": False,
         })
         if len(results) >= limit:
             break
-    return results
+    return sorted(materializations + results, key=lambda r: r["ended_at"],
+                  reverse=True)[:limit]
 
 
 def _recent_failures(conn, now: int, limit: int = 10) -> list[dict[str, Any]]:

{threadkeeper-0.17.2 → threadkeeper-0.17.4}/threadkeeper/curator.py

@@ -248,10 +248,11 @@ promotion and linking plan in REPORT.md for a foreground human instead.
   superseded by a newer entry, or a **FALSE POSITIVE** (auto-created
   by the background-review loop but never validated by actual use).
   Specifically flag as PRUNE:
-    • origin=background_review AND use_count=0 AND patches=0 AND
-      created >14 days ago → strong false-positive signal: nobody ever
-      consulted it, and the agent that created it never came back to
-      refine it.
+    • origin=background_review AND fg_uses=0 AND created >14 days ago
+      → strong false-positive signal: no foreground user or agent ever
+      consulted it. `maintenance_patches` count automated or other maintenance
+      writes; they are not foreground consultation and never reset this
+      eligibility signal.
     • SKILL_OUTCOME signals (in the events table) marking the skill
       as 'wrong' more often than 'helped' → user-judgment override.
   Format:

{threadkeeper-0.17.2 → threadkeeper-0.17.4}/threadkeeper/notify.py

@@ -27,6 +27,8 @@ from __future__ import annotations
 
 import logging
 import os
+from pathlib import Path
+import re
 import sqlite3
 import subprocess
 import threading
@@ -349,11 +351,43 @@ def _fmt_child(c: dict) -> tuple[str, str]:
 
 
 def _fmt_skill(s: dict) -> tuple[str, str]:
-    return ("Thread-keeper: skill materialized", (s["summary"] or s["target"])[:200])
+    path = (s.get("summary") or "").strip()
+    name = s.get("target", "") if s.get("kind") == "skill_create" else ""
+    if path and path != "(no path recorded)":
+        md = Path(path).expanduser()
+        if md.name == "SKILL.md":
+            name = md.parent.name
+        else:
+            name = md.name
+            md = md / "SKILL.md"
+        try:
+            # A title is near the top. Never load an entire skill (or follow
+            # paths mentioned in its body) just to render a notification.
+            body = ""
+            if md.is_file():
+                with md.open(encoding="utf-8") as stream:
+                    body = stream.read(8192)
+            if body.startswith("---\n"):
+                body = body.split("\n---", 1)[-1]
+            heading = re.search(r"^#\s+(.+?)(?:\s+#+)?\s*$", body, re.MULTILINE)
+            if heading:
+                name = heading.group(1)
+        except (OSError, ValueError):
+            pass
+    return ("Thread-keeper: skill materialized", _artifact_name(name))
+
+
+def _artifact_name(name: str) -> str:
+    """One readable name, without slug separators or Markdown decoration."""
+    name = " ".join((name or "").replace("`", "").split())
+    if " " not in name:
+        name = re.sub(r"[-_]+", " ", name)
+        name = name[:1].upper() + name[1:]
+    return name[:200]
 
 
 def _fmt_lesson(l: dict) -> tuple[str, str]:
-    return ("Thread-keeper: lesson added", f"{l['target']} ({l['summary']})"[:200])
+    return ("Thread-keeper: lesson added", _artifact_name(l["target"]))
 
 
 # ── pass + daemon lifecycle ─────────────────────────────────────────────────
@@ -401,8 +435,10 @@ def run_notify_pass(force: bool = False, *, scheduled: bool = False) -> str:
                 _dispatch(*_fmt_child(c))
                 fired += 1
         for s in skills:
-            _dispatch(*_fmt_skill(s))
-            fired += 1
+            title, body = _fmt_skill(s)
+            if body:  # A pathless mark only silences a nudge; no named artifact.
+                _dispatch(title, body)
+                fired += 1
         for l in lessons:
             _dispatch(*_fmt_lesson(l))
             fired += 1

{threadkeeper-0.17.2 → threadkeeper-0.17.4}/threadkeeper/skill_audit.py

@@ -18,6 +18,7 @@ import os
 from pathlib import Path
 import re
 import sqlite3
+import time
 from typing import Iterable
 
 import yaml
@@ -245,7 +246,8 @@ def _telemetry_rows(conn: sqlite3.Connection, include_archived: bool) -> dict[st
         rows = conn.execute(
             "SELECT name, created_at, created_by_origin, last_used_at, "
             "last_viewed_at, last_patched_at, use_count, view_count, "
-            "patch_count, pinned, state, tier FROM skill_usage" + where
+            "patch_count, foreground_use_count, pinned, state, tier "
+            "FROM skill_usage" + where
             + " ORDER BY name"
         ).fetchall()
     except sqlite3.OperationalError:
@@ -327,7 +329,7 @@ def _record_for(
             for key in (
                 "created_at", "last_used_at", "last_viewed_at",
                 "last_patched_at", "use_count", "view_count", "patch_count",
-                "pinned",
+                "foreground_use_count", "pinned",
             )
         },
         "source_path": str(source) if source else None,
@@ -533,9 +535,20 @@ def format_skill_checklist(manifest: dict) -> str:
     for index, record in enumerate(manifest["skills"], start=1):
         flags = ",".join(record["findings"]) or "clean"
         protected = " [PROTECTED]" if record["protected"] else ""
+        telemetry = record["telemetry"]
+        created_at = int(telemetry.get("created_at") or 0)
+        created_age = (
+            max(0, int(time.time()) - created_at) // 86400
+            if created_at else "?"
+        )
         lines.append(
             f"{index}. SKILL {record['name']}{protected} "
             f"state={record['state']} origin={record['origin']} "
+            f"fg_uses={telemetry.get('foreground_use_count') or 0} "
+            f"uses={telemetry.get('use_count') or 0} "
+            f"views={telemetry.get('view_count') or 0} "
+            f"maintenance_patches={telemetry.get('patch_count') or 0} "
+            f"created={created_age}d_ago "
             f"source_kind={record['source_kind']} "
             f"source={record['source_path'] or '-'} findings={flags}"
         )