threadkeeper 0.17.3__tar.gz → 0.17.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: threadkeeper
-Version: 0.17.3
+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
@@ -1549,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.3 → 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
@@ -1505,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.3 → threadkeeper-0.17.4}/pyproject.toml

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

{threadkeeper-0.17.3 → threadkeeper-0.17.4}/threadkeeper/tools/spawn.py

@@ -16,6 +16,7 @@ import sys
 import secrets
 import time
 import json as _json
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Optional
 
@@ -57,6 +58,30 @@ _BYPASS_ENV_OVERRIDE = "THREADKEEPER_ALLOW_BYPASS_PERMISSIONS_SPAWN"
 # that and feed larger prompts through the existing owner-only stdin spool.
 CLAUDE_PROMPT_ARGV_MAX_BYTES = 96 * 1024
 
+# A child that starts from a repository must never share that repository's
+# mutable checkout with another child.  Worktrees live in the protected task
+# spool rather than beside the caller's checkout, where they cannot surprise a
+# developer scanning their project tree.
+_SPAWN_WORKTREE_DIRNAME = "worktrees"
+_SPAWN_WORKTREE_BRANCH_PREFIX = "threadkeeper/spawn-"
+# Keep git preflight independent from tests (and callers) that replace the
+# child-launcher `subprocess.Popen` below.
+_GIT_POPEN = subprocess.Popen
+
+
+@dataclass(frozen=True)
+class _SpawnWorktree:
+    """A per-task checkout derived from a clean caller worktree."""
+
+    repo_root: Path
+    relative_cwd: Path
+    path: Path
+    branch: str
+
+    @property
+    def child_cwd(self) -> Path:
+        return self.path / self.relative_cwd
+
 
 def _utf8_len(text: str) -> int:
     return len(text.encode("utf-8"))
@@ -402,6 +427,102 @@ def _build_slim_mcp_config(
     return slim_path
 
 
+def _git_result(args: list[str], cwd: Path) -> tuple[str, str]:
+    """Run a short git query and return stdout plus a compact error string."""
+    try:
+        proc = _GIT_POPEN(
+            ["git", *args],
+            cwd=str(cwd),
+            text=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        stdout, stderr = proc.communicate(timeout=15)
+    except subprocess.TimeoutExpired:
+        proc.kill()
+        proc.communicate()
+        return "", "git command timed out"
+    except (FileNotFoundError, OSError) as e:
+        return "", str(e)
+    if proc.returncode == 0:
+        return stdout.strip(), ""
+    detail = (stderr or stdout or f"exit={proc.returncode}").strip()
+    return "", detail.replace("\n", " ")[:240]
+
+
+def _spawn_worktree_plan(
+    cwd: str, task_id: str
+) -> tuple[Optional[_SpawnWorktree], str]:
+    """Return an isolated worktree plan or safely decline a git checkout.
+
+    Non-git directories keep the historic behavior.  Git directories must be
+    clean before a child can run: copying uncommitted tracked changes into a
+    second checkout would either lose them or reintroduce the shared-WIP race.
+    """
+    source_cwd = Path(cwd).resolve()
+    root_text, root_err = _git_result(
+        ["rev-parse", "--show-toplevel"], source_cwd
+    )
+    if root_err:
+        if "not a git repository" in root_err.lower():
+            return None, ""
+        return None, f"ERR spawn_worktree_check_failed={root_err}"
+    repo_root = Path(root_text).resolve()
+    try:
+        relative_cwd = source_cwd.relative_to(repo_root)
+    except ValueError:
+        return None, "ERR spawn_worktree_check_failed=cwd_outside_repo"
+
+    dirty, status_err = _git_result(
+        ["status", "--porcelain", "--untracked-files=no"], repo_root
+    )
+    if status_err:
+        return None, f"ERR spawn_worktree_check_failed={status_err}"
+    if dirty:
+        return None, "ERR spawn_dirty_worktree mode=git"
+
+    try:
+        parent = ensure_task_spool_dir(TASK_LOG_DIR / _SPAWN_WORKTREE_DIRNAME)
+    except OSError as e:
+        return None, f"ERR spawn_worktree_spool_unavailable={e}"
+    path = parent / task_id
+    if path.exists() or path.is_symlink():
+        return None, "ERR spawn_worktree_path_in_use"
+    return _SpawnWorktree(
+        repo_root=repo_root,
+        relative_cwd=relative_cwd,
+        path=path,
+        branch=_SPAWN_WORKTREE_BRANCH_PREFIX + task_id,
+    ), ""
+
+
+def _remove_spawn_worktree(worktree: _SpawnWorktree) -> None:
+    """Best-effort cleanup for a worktree whose child never launched."""
+    _git_result(
+        ["worktree", "remove", "--force", str(worktree.path)],
+        worktree.repo_root,
+    )
+    _git_result(["branch", "-D", worktree.branch], worktree.repo_root)
+
+
+def _create_spawn_worktree(worktree: _SpawnWorktree) -> str:
+    """Create the task's branch/worktree after the spawn budget is reserved."""
+    _, err = _git_result(
+        [
+            "worktree", "add", "--quiet", "-b", worktree.branch,
+            str(worktree.path), "HEAD",
+        ],
+        worktree.repo_root,
+    )
+    if err:
+        _remove_spawn_worktree(worktree)
+        return f"ERR spawn_worktree_create_failed={err}"
+    if not worktree.child_cwd.is_dir():
+        _remove_spawn_worktree(worktree)
+        return "ERR spawn_worktree_create_failed=cwd_not_in_clean_checkout"
+    return ""
+
+
 def _spawn_impl(prompt: str, cwd: str = "", append_system: str = "",
                 model: str = "", effort: str = "",
                 permission_mode: str = "auto",
@@ -519,6 +640,9 @@ def _spawn_impl(prompt: str, cwd: str = "", append_system: str = "",
         for c in task_id
     ):
         return "ERR invalid_task_id"
+    worktree, worktree_err = _spawn_worktree_plan(cwd, task_id)
+    if worktree_err:
+        return worktree_err
     sys_extra = sys_extra_template.format(
         parent=parent_cid or "(unknown)",
         child=child_cid,
@@ -778,6 +902,13 @@ def _spawn_impl(prompt: str, cwd: str = "", append_system: str = "",
                 retry_root or None, int(retry_attempt or 0),
             ),
         )
+        if worktree is not None:
+            worktree_create_err = _create_spawn_worktree(worktree)
+            if worktree_create_err:
+                conn.rollback()
+                return worktree_create_err
+            cwd = str(worktree.child_cwd)
+            conn.execute("UPDATE tasks SET cwd=? WHERE id=?", (cwd, task_id))
     except sqlite3.Error as e:
         conn.rollback()
         return f"ERR spawn_reservation_failed={e}"
@@ -943,6 +1074,8 @@ exit $rc
                 stdin_f.close()
             proc_pid = proc.pid
     except (FileNotFoundError, OSError) as e:
+        if worktree is not None:
+            _remove_spawn_worktree(worktree)
         conn.rollback()
         return f"ERR spawn_failed={e}"
     try:

{threadkeeper-0.17.3 → threadkeeper-0.17.4}/threadkeeper.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: threadkeeper
-Version: 0.17.3
+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
@@ -1549,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.3 → threadkeeper-0.17.4}/threadkeeper.egg-info/SOURCES.txt

@@ -99,6 +99,7 @@ tests/test_spawn_permission_gate.py
 tests/test_spawn_reap.py
 tests/test_spawn_slim.py
 tests/test_spawn_watchdog.py
+tests/test_spawn_worktree_isolation.py
 tests/test_spawn_wrap.py
 tests/test_sync_capture.py
 tests/test_sync_identity.py