threadkeeper 0.5.2__tar.gz → 0.5.3__tar.gz

{threadkeeper-0.5.2 → threadkeeper-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: threadkeeper
-Version: 0.5.2
+Version: 0.5.3
 Summary: Multi-agent shared brain across Claude Code/Desktop, Codex, Gemini, Copilot, VS Code. Cross-session memory, self-improving skill loops, inter-agent signaling — one local MCP server.
 Author: thread-keeper contributors
 License: MIT
@@ -82,10 +82,10 @@ make it more than a memory store:
   harvester, candidate-reviewer, weekly Curator) materialize
   class-level skills as the agents work. Adapted to multi-CLI:
   SKILL.md is the primary write target and gets mirrored to every
-  detected CLI's skills directory simultaneously
-  (`~/.claude/skills/`, `~/.codex/skills/`, `~/.threadkeeper/skills/`),
-  with lessons.md as a fallback for CLIs without a native skills
-  loader.
+  known/configured skills root simultaneously (`~/.claude/skills/`,
+  `~/.codex/skills/`, existing `~/.agents/skills/`, extra roots from
+  `THREADKEEPER_EXTRA_SKILLS_DIRS`, and `~/.threadkeeper/skills/`),
+  with lessons.md as a fallback for CLIs without a native skills loader.
 
 ---
 
@@ -223,8 +223,8 @@ shows agents focused on their primary task rarely do).
          brief()    SKILL.md + lessons.md ─► skill_usage   │
             │              │                  │            │
             │              ▼                  ▼            │
-            │         (every detected CLI's   │            │
-            │          skills/ directory)     │            │
+            │         (every configured       │            │
+            │          skills/ root)          │            │
             │              │                  │            │
             │              └──────► [5] Curator daemon ───┘
             │                          (cron, every 7d)
@@ -246,11 +246,11 @@ shows agents focused on their primary task rarely do).
 | 5 | Curator daemon | every 7 days (env knob) | every existing lesson + recently-touched skill | REPORT-`<date>`.md (advisory) or direct PATCH/PRUNE/CONSOLIDATE |
 
 All five write into the universal Skill format (`SKILL.md` under each
-detected CLI's skills directory — `~/.claude/skills/`,
-`~/.codex/skills/`, plus the canonical `~/.threadkeeper/skills/`
-mirror), with `~/.threadkeeper/lessons.md` as a CLI-agnostic fallback
-for clients without a native skills loader (Gemini, Copilot, bare
-MCP).
+known/configured skills root — `~/.claude/skills/`, `~/.codex/skills/`,
+existing `~/.agents/skills/`, optional `THREADKEEPER_EXTRA_SKILLS_DIRS`,
+plus the canonical `~/.threadkeeper/skills/` mirror), with
+`~/.threadkeeper/lessons.md` as a CLI-agnostic fallback for clients
+without a native skills loader (Gemini, Copilot, bare MCP).
 
 #### 1. Auto-review on close_thread
 
@@ -260,9 +260,12 @@ thread's notes. The prompt is rubric-form (Q1–Q5 yes/no) with explicit
 positive examples for incident-vs-rule classification. The fork also
 receives a "recently active skills" block so it prefers PATCHing
 existing umbrellas over creating new ones (*active-update bias*).
-Child appends a lesson via `lesson_append`, optionally mirrors to
-`~/.claude/skills/<name>/SKILL.md`, then closes with
-`mark_skill_materialized`. Opt in with `THREADKEEPER_AUTO_REVIEW=1`.
+Child appends a lesson via `lesson_append`, writes/patches a skill via
+`skill_manage` or writes a skill file directly, then closes with
+`mark_skill_materialized`. If `skill_path` points at a `SKILL.md` (or a
+skill directory), thread-keeper immediately mirrors that whole skill
+into every configured skills root. Opt in with
+`THREADKEEPER_AUTO_REVIEW=1`.
 
 #### 2. Shadow-review daemon
 

{threadkeeper-0.5.2 → threadkeeper-0.5.3}/README.md

@@ -48,10 +48,10 @@ make it more than a memory store:
   harvester, candidate-reviewer, weekly Curator) materialize
   class-level skills as the agents work. Adapted to multi-CLI:
   SKILL.md is the primary write target and gets mirrored to every
-  detected CLI's skills directory simultaneously
-  (`~/.claude/skills/`, `~/.codex/skills/`, `~/.threadkeeper/skills/`),
-  with lessons.md as a fallback for CLIs without a native skills
-  loader.
+  known/configured skills root simultaneously (`~/.claude/skills/`,
+  `~/.codex/skills/`, existing `~/.agents/skills/`, extra roots from
+  `THREADKEEPER_EXTRA_SKILLS_DIRS`, and `~/.threadkeeper/skills/`),
+  with lessons.md as a fallback for CLIs without a native skills loader.
 
 ---
 
@@ -189,8 +189,8 @@ shows agents focused on their primary task rarely do).
          brief()    SKILL.md + lessons.md ─► skill_usage   │
             │              │                  │            │
             │              ▼                  ▼            │
-            │         (every detected CLI's   │            │
-            │          skills/ directory)     │            │
+            │         (every configured       │            │
+            │          skills/ root)          │            │
             │              │                  │            │
             │              └──────► [5] Curator daemon ───┘
             │                          (cron, every 7d)
@@ -212,11 +212,11 @@ shows agents focused on their primary task rarely do).
 | 5 | Curator daemon | every 7 days (env knob) | every existing lesson + recently-touched skill | REPORT-`<date>`.md (advisory) or direct PATCH/PRUNE/CONSOLIDATE |
 
 All five write into the universal Skill format (`SKILL.md` under each
-detected CLI's skills directory — `~/.claude/skills/`,
-`~/.codex/skills/`, plus the canonical `~/.threadkeeper/skills/`
-mirror), with `~/.threadkeeper/lessons.md` as a CLI-agnostic fallback
-for clients without a native skills loader (Gemini, Copilot, bare
-MCP).
+known/configured skills root — `~/.claude/skills/`, `~/.codex/skills/`,
+existing `~/.agents/skills/`, optional `THREADKEEPER_EXTRA_SKILLS_DIRS`,
+plus the canonical `~/.threadkeeper/skills/` mirror), with
+`~/.threadkeeper/lessons.md` as a CLI-agnostic fallback for clients
+without a native skills loader (Gemini, Copilot, bare MCP).
 
 #### 1. Auto-review on close_thread
 
@@ -226,9 +226,12 @@ thread's notes. The prompt is rubric-form (Q1–Q5 yes/no) with explicit
 positive examples for incident-vs-rule classification. The fork also
 receives a "recently active skills" block so it prefers PATCHing
 existing umbrellas over creating new ones (*active-update bias*).
-Child appends a lesson via `lesson_append`, optionally mirrors to
-`~/.claude/skills/<name>/SKILL.md`, then closes with
-`mark_skill_materialized`. Opt in with `THREADKEEPER_AUTO_REVIEW=1`.
+Child appends a lesson via `lesson_append`, writes/patches a skill via
+`skill_manage` or writes a skill file directly, then closes with
+`mark_skill_materialized`. If `skill_path` points at a `SKILL.md` (or a
+skill directory), thread-keeper immediately mirrors that whole skill
+into every configured skills root. Opt in with
+`THREADKEEPER_AUTO_REVIEW=1`.
 
 #### 2. Shadow-review daemon
 

{threadkeeper-0.5.2 → threadkeeper-0.5.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "threadkeeper"
-version = "0.5.2"
+version = "0.5.3"
 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.5.2 → threadkeeper-0.5.3}/tests/test_skill_hint.py

@@ -1,5 +1,5 @@
 """brief() skill_hint nudge — fires when a recently-closed thread is rich
-enough to be worth materializing as a Claude skill under ~/.claude/skills/.
+enough to be worth materializing as a mirrored reusable skill.
 
 After complex tasks, the agent should turn distilled insights into
 reusable skills, not let them sit only in notes. The nudge surfaces

{threadkeeper-0.5.2 → threadkeeper-0.5.3}/tests/test_skills.py

@@ -535,7 +535,7 @@ def test_skill_manage_mirrors_skill_across_detected_clis(
     skills_pkg, monkeypatch,
 ):
     """skill_manage(create) must write SKILL.md not only to the canonical
-    ~/.claude/skills/ but also to every detected CLI's skills_dir() —
+    primary skills root but also to every configured skills_dir() —
     so one materialization reaches Claude AND Codex at once."""
     # Pin two mirror targets that we own (in tmp_path) so the test is
     # hermetic — don't touch the developer's ~/.codex/ or ~/.threadkeeper/.
@@ -568,6 +568,71 @@ def test_skill_manage_mirrors_skill_across_detected_clis(
         canonical.read_text()
 
 
+def test_mirror_targets_include_known_skill_roots_without_install_detection(
+    skills_pkg, monkeypatch,
+):
+    """Mirror planning should include native skill roots even when an
+    adapter's executable/config detection would be false. Skill roots are
+    cheap paths; creation should not depend on whether the CLI has already
+    written a config file."""
+    from threadkeeper.tools import skills as st
+    import threadkeeper.adapters as adapters
+
+    class FakeAdapter:
+        def skills_dir(self):
+            return skills_pkg["tmp"] / "future_cli_skills"
+
+    monkeypatch.setattr(adapters, "ADAPTERS", [FakeAdapter()])
+
+    targets = st._mirror_targets("future-skill")
+    assert skills_pkg["tmp"] / "future_cli_skills" / "future-skill" in targets
+
+
+def test_mark_skill_materialized_mirrors_external_skill_dir(
+    skills_pkg, monkeypatch,
+):
+    """If an agent created a skill directly in Codex/Claude and then calls
+    mark_skill_materialized(skill_path=...), thread-keeper should copy the
+    whole skill dir to canonical + mirrors."""
+    mirror_codex = skills_pkg["tmp"] / "fake_codex_skills"
+    mirror_agents = skills_pkg["tmp"] / "fake_agents_skills"
+
+    from threadkeeper.tools import skills as st
+
+    def fake_mirror_targets(name):
+        return [mirror_codex / name, mirror_agents / name]
+
+    monkeypatch.setattr(st, "_mirror_targets", fake_mirror_targets)
+
+    external = skills_pkg["tmp"] / "external_codex" / "external-sync"
+    (external / "agents").mkdir(parents=True)
+    (external / "SKILL.md").write_text(
+        "---\n"
+        "name: external-sync\n"
+        "description: Use when testing external skill sync.\n"
+        "---\n\n"
+        "# external-sync\n",
+        encoding="utf-8",
+    )
+    (external / "agents" / "openai.yaml").write_text(
+        "interface:\n"
+        "  display_name: \"External Sync\"\n",
+        encoding="utf-8",
+    )
+
+    open_t = _tool(skills_pkg, "open_thread")
+    mark = _tool(skills_pkg, "mark_skill_materialized")
+    tid = open_t(question="external skill sync")
+
+    assert mark(thread_id=tid, skill_path=str(external / "SKILL.md")) == "ok"
+
+    canonical = skills_pkg["skills_root"] / "external-sync"
+    assert (canonical / "SKILL.md").exists()
+    assert (canonical / "agents" / "openai.yaml").exists()
+    assert (mirror_codex / "external-sync" / "SKILL.md").exists()
+    assert (mirror_agents / "external-sync" / "agents" / "openai.yaml").exists()
+
+
 def test_skill_manage_delete_removes_mirrors(skills_pkg, monkeypatch):
     """delete must propagate to every mirror target — otherwise stale
     SKILL.md files keep auto-triggering in Codex / canonical store."""

{threadkeeper-0.5.2 → threadkeeper-0.5.3}/threadkeeper/brief.py

@@ -355,7 +355,7 @@ def render_brief(conn: sqlite3.Connection, query: str = "", k: int = 6) -> str:
     # ── skill_hint ────────────────────────────────────────────────────────
     # Behavioral nudge: after a rich thread closes, the lessons inside
     # it (insights + repeated moves) should
-    # be materialized as a reusable Claude skill under ~/.claude/skills/,
+    # be materialized as a reusable skill mirrored across configured roots,
     # not just sit in notes. Trigger only on threads recently closed AND
     # rich enough to be worth a class-level skill — never on one-off chatter.
     #
@@ -413,7 +413,7 @@ def render_brief(conn: sqlite3.Connection, query: str = "", k: int = 6) -> str:
             warn = "⚠️ " if consecutive_ignored >= 3 else ""
             out.append(
                 f"  → {warn}closed thread is rich (≥5 notes, ≥2 insight/move). "
-                "MATERIALIZE: invoke skill-creator to write ~/.claude/skills/"
+                "MATERIALIZE: invoke skill-creator or skill_manage to write "
                 "<class-level-name>/SKILL.md from the insights — don't let "
                 "learnings sit only in notes"
             )

{threadkeeper-0.5.2 → threadkeeper-0.5.3}/threadkeeper/review_prompts.py

@@ -139,7 +139,7 @@ MEMORY_REVIEW_PROMPT = (
 SKILL_REVIEW_PROMPT = (
     "Review the closed thread above and materialize any class-level "
     "lessons.\n\n"
-    "PRIMARY output: a SKILL.md under ~/.claude/skills/<name>/ via "
+    "PRIMARY output: a SKILL.md via "
     "skill_manage(action='create'|'patch'|'write_file'|'delete'). The "
     "Skill format is the universal format — Claude Code, Claude "
     "Desktop, Codex, the Anthropic IDE plugins, and any MCP-aware tool "
@@ -149,8 +149,8 @@ SKILL_REVIEW_PROMPT = (
     "FALLBACK output (only when target CLI has no skills/ directory — "
     "Gemini / Copilot / generic MCP clients without a skill loader): "
     "lesson_append(title, body, summary, source=thread_id) writes into "
-    "~/.threadkeeper/lessons.md. Use this only if the primary path "
-    "isn't available; otherwise the SKILL.md is strictly better.\n\n"
+    "~/.threadkeeper/lessons.md. Use this only if a SKILL.md is not "
+    "appropriate; otherwise the mirrored SKILL.md is strictly better.\n\n"
     + RUBRIC_QUESTIONS + "\n\n"
     "PREFERENCE ORDER (pick the earliest action that fits):\n"
     "  1. PATCH an existing skill. If the conversation referenced (or "
@@ -192,7 +192,7 @@ COMBINED_REVIEW_PROMPT = (
     "/ note as appropriate.\n\n"
     "  **Skills** — how to handle this class of task. PRIMARY: "
     "skill_manage(action='create'|'patch'|'write_file'|'delete') → "
-    "~/.claude/skills/<name>/SKILL.md. The Skill format auto-triggers "
+    "a mirrored SKILL.md under every configured skills root. The Skill format auto-triggers "
     "via frontmatter description and is consumed by every modern "
     "agentic CLI (Claude Code/Desktop, Codex CLI/desktop, IDE plugins) "
     "— strictly better than an opt-in lessons.md scan. FALLBACK: "

{threadkeeper-0.5.2 → threadkeeper-0.5.3}/threadkeeper/shadow_review.py

@@ -51,9 +51,9 @@ from .review_prompts import POSITIVE_EXAMPLES
 
 SHADOW_REVIEW_PROMPT = f"""\
 You are a SHADOW LEARNING OBSERVER for thread-keeper. You read a slice
-of recent dialog from across ALL Claude sessions on this machine and
+of recent dialog from across ALL agent sessions on this machine and
 decide whether any CLASS-LEVEL learning emerged that's worth a durable
-skill under ~/.claude/skills/.
+skill.
 
 CLASS-LEVEL signals (materialize):
 {SHADOW_CLASS_SIGNAL_EXAMPLES}\
@@ -84,7 +84,7 @@ PROCEDURE
       - body: markdown rationale + procedure
       - summary: optional one-line TL;DR
    b. OPTIONAL: also call `mcp__thread-keeper__skill_manage(...)` to mirror
-      under ~/.claude/skills/ when Claude-specific frontmatter
+      SKILL.md into every configured skills root when frontmatter
       auto-triggering adds value beyond the lesson alone.
    c. Output `MATERIALIZED: <slug>` on success.
 

{threadkeeper-0.5.2 → threadkeeper-0.5.3}/threadkeeper/tools/skills.py

@@ -1,8 +1,9 @@
-"""Claude-skills lifecycle: create/edit/patch/delete + usage telemetry +
+"""Multi-CLI skills lifecycle: create/edit/patch/delete + usage telemetry +
 curator + background-review fork.
 
 Bridges thread-keeper (working memory across sessions) and Claude's
-~/.claude/skills/ store (procedural memory). The Learning loop:
+primary ~/.claude/skills/ store plus mirrored CLI skill roots
+(procedural memory). The Learning loop:
 
     rich thread closes → brief() surfaces skill_hint nudge →
     agent calls review_thread(...) → spawned child reads notes,
@@ -24,6 +25,7 @@ Validator enforces the agentskills.io-compatible frontmatter shape:
 from __future__ import annotations
 
 import json
+import os
 import re
 import shutil
 import sqlite3
@@ -143,55 +145,90 @@ def _archive_dir() -> Path:
 
 
 # ──────────────────────────────────────────────────────────────────────────
-# Multi-mirror — propagate SKILL.md across every detected CLI's skills/
-# directory so a single skill_manage call reaches Claude AND Codex AND
-# the canonical ~/.threadkeeper/skills/ fallback at once. Best-effort:
-# per-mirror failures are logged but don't fail the canonical write.
+# Multi-mirror — propagate a whole skill directory across every known
+# native skills/ root so a single materialization reaches Claude, Codex,
+# shared ~/.agents skills, and the canonical ~/.threadkeeper/skills/
+# fallback at once. Best-effort: per-mirror failures are logged but
+# don't fail the canonical write.
 # ──────────────────────────────────────────────────────────────────────────
 
-def _mirror_targets(name: str) -> list[Path]:
-    """Per-CLI skill directories that should hold a copy of <name>.
+def _extra_skill_roots() -> list[Path]:
+    """Additional skills roots outside CLI adapters.
 
-    Always includes the canonical ~/.threadkeeper/skills/<name>/ fallback
-    (consumed by lessons.md-style scans from CLIs without a native
-    skills/ loader). Plus every installed adapter whose skills_dir() is
-    distinct from CLAUDE_SKILLS_DIR (the canonical write target)."""
-    from ..adapters import installed_adapters
+    THREADKEEPER_EXTRA_SKILLS_DIRS is os.pathsep-separated. We also mirror
+    into ~/.agents/skills when that shared OpenAI-agent skill root already
+    exists on the machine.
+    """
+    roots: list[Path] = []
+    raw = os.environ.get("THREADKEEPER_EXTRA_SKILLS_DIRS", "").strip()
+    if raw:
+        for item in raw.split(os.pathsep):
+            item = item.strip()
+            if item:
+                roots.append(Path(item).expanduser())
+    agents_root = Path("~/.agents/skills").expanduser()
+    if agents_root.exists():
+        roots.append(agents_root)
+    return roots
+
+
+def _skill_roots() -> list[Path]:
+    """Every root that should receive mirrored skill directories.
+
+    Use all adapters, not only installed adapters. Skill roots are cheap
+    filesystem paths, and relying on install-detection can miss a CLI that
+    is present but has not written its config yet.
+    """
+    from ..adapters import ADAPTERS
     from ..config import DB_PATH
 
-    targets: list[Path] = []
-    seen: set[Path] = {CLAUDE_SKILLS_DIR.resolve()}
-    # CLI-native skills/ dirs from each installed adapter.
-    for a in installed_adapters():
-        sd = a.skills_dir()
-        if sd is None:
-            continue
-        sd_r = sd.resolve() if sd.exists() else sd
-        if sd_r in seen:
-            continue
-        seen.add(sd_r)
-        targets.append(sd / name)
-    # Canonical thread-keeper-side mirror (always written, used as the
-    # source of truth for restore / curator audit / non-skills CLIs).
-    tk_canonical = (DB_PATH.parent / "skills").resolve()
-    if tk_canonical not in seen:
-        targets.append((DB_PATH.parent / "skills") / name)
-    return targets
+    roots: list[Path] = []
+    seen: set[Path] = set()
+
+    def add(root: Path | None) -> None:
+        if root is None:
+            return
+        root = root.expanduser()
+        key = root.resolve()
+        if key in seen:
+            return
+        seen.add(key)
+        roots.append(root)
+
+    add(CLAUDE_SKILLS_DIR)
+    for adapter in ADAPTERS:
+        add(adapter.skills_dir())
+    for root in _extra_skill_roots():
+        add(root)
+    add(DB_PATH.parent / "skills")
+    return roots
+
+
+def _mirror_targets(name: str) -> list[Path]:
+    """All non-primary skill directories that should hold <name>/."""
+    primary = CLAUDE_SKILLS_DIR.resolve()
+    return [root / name for root in _skill_roots() if root.resolve() != primary]
+
+
+def _copy_skill_tree(src: Path, dst: Path) -> None:
+    """Replace dst with a recursive copy of src unless they are identical."""
+    if src.resolve() == dst.resolve():
+        return
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    if dst.exists():
+        shutil.rmtree(dst)
+    shutil.copytree(src, dst)
 
 
 def _mirror_skill_dir(name: str) -> None:
     """Copy CLAUDE_SKILLS_DIR/<name>/ → every mirror target (recursive).
     Pre-existing mirror is replaced atomically. Best-effort per target."""
-    import shutil as _sh
     src = _skill_dir(name)
     if not src.exists():
         return
     for dst in _mirror_targets(name):
         try:
-            dst.parent.mkdir(parents=True, exist_ok=True)
-            if dst.exists():
-                _sh.rmtree(dst)
-            _sh.copytree(src, dst)
+            _copy_skill_tree(src, dst)
         except Exception:
             # Per-mirror failure (permission denied / disk full / etc.)
             # doesn't fail the canonical write. The user can re-sync
@@ -199,6 +236,43 @@ def _mirror_skill_dir(name: str) -> None:
             pass
 
 
+def mirror_skill_from_path(skill_path: str) -> Optional[str]:
+    """Mirror an existing external skill dir into every configured root.
+
+    `skill_path` may point at SKILL.md or at the skill directory. The
+    frontmatter `name` is authoritative; the source directory does not
+    need to be under CLAUDE_SKILLS_DIR. Returns the mirrored skill name,
+    or None if the path is absent/invalid. Best-effort mirrors are still
+    handled by _mirror_skill_dir after the canonical copy lands.
+    """
+    raw = skill_path.strip()
+    if not raw:
+        return None
+    p = Path(raw).expanduser()
+    src = p.parent if p.name == "SKILL.md" else p
+    md = src / "SKILL.md"
+    if not md.is_file():
+        return None
+    try:
+        body = md.read_text(encoding="utf-8")
+    except OSError:
+        return None
+    fields, err = _parse_frontmatter(body)
+    if err or not fields:
+        return None
+    name = fields["name"]
+    if err := _validate_name(name):
+        return None
+    if err := _validate_skill_md(body, name):
+        return None
+    try:
+        _copy_skill_tree(src, _skill_dir(name))
+    except Exception:
+        return None
+    _mirror_skill_dir(name)
+    return name
+
+
 def _unmirror_skill(name: str) -> None:
     """Remove <name>/ from every mirror target. Best-effort per target."""
     import shutil as _sh
@@ -359,7 +433,7 @@ _VALID_OUTCOMES: set[str] = {"helped", "partial", "wrong"}
 
 @mcp.tool()
 def skill_record(name: str, kind: str = "use", outcome: str = "") -> str:
-    """Record usage telemetry for a Claude skill.
+    """Record usage telemetry for a mirrored skill.
 
     `kind`: 'use' | 'view' | 'patch' | 'create'. Bumps the corresponding
     counter + timestamp in skill_usage. The curator reads these to decide
@@ -425,9 +499,10 @@ def skill_manage(action: str,
                  new_string: str = "",
                  sub_path: str = "",
                  description: str = "") -> str:
-    """Create, edit, patch, or delete Claude skills under ~/.claude/skills/.
+    """Create, edit, patch, or delete skills under the primary skills root.
 
-    Atomic write with frontmatter validation before disk hits.
+    Atomic primary write with frontmatter validation before disk hits, then
+    best-effort mirror into every configured skill root.
 
     Actions:
       create      — write a brand-new skill. Requires `name` + `description`
@@ -627,7 +702,7 @@ def _action_delete(name: str) -> str:
 
 @mcp.tool()
 def skill_list(include_archived: bool = False) -> str:
-    """List Claude skills with telemetry. Format:
+    """List skills with telemetry. Format:
         <name> tier=<hypothesis|observed|validated> origin=<...>
             state=<active|stale|archived> uses=N fg_uses=N
             views=N patches=N wrong=N pinned=0/1 last_active=<age>
@@ -763,7 +838,7 @@ def curator_run(stale_after_days: int = 30,
     Lifecycle:
       active  → stale     when last activity > stale_after_days
       stale   → archived  when last activity > archive_after_days
-                          (also moves directory to ~/.claude/skills/.archive/)
+                          (also moves primary directory to .archive/)
 
     Tier-aware adjustments (the discrete trust signal trumps raw activity):
       • tier='validated' skills are NEVER stale-aged or archived — proven

{threadkeeper-0.5.2 → threadkeeper-0.5.3}/threadkeeper/tools/threads.py

@@ -140,20 +140,29 @@ def close_thread(thread_id: str, outcome: str) -> str:
 @mcp.tool()
 def mark_skill_materialized(thread_id: str, skill_path: str = "") -> str:
     """Close the Learning loop: record that a closed thread's insights were
-    written into a Claude skill under ~/.claude/skills/.
+    written into a skill.
 
     Stops the brief()'s `skill_hint` nudge from firing for this thread. Also
     appends a `move` note pointing at the skill path so future briefs surface
     the link.
 
     Pass the absolute path to the SKILL.md (or skill directory) when known;
-    leave empty if you only want to silence the hint without recording a path."""
+    leave empty if you only want to silence the hint without recording a path.
+    When a path is provided, thread-keeper also mirrors that skill directory
+    into every configured native skills root (Claude, Codex, shared agents,
+    and ~/.threadkeeper/skills) on a best-effort basis."""
     conn = get_db()
     _ensure_session(conn)
     if not conn.execute("SELECT 1 FROM threads WHERE id=?", (thread_id,)).fetchone():
         return f"ERR thread_not_found={thread_id}"
     now = int(time.time())
     path = skill_path.strip()
+    if path:
+        try:
+            from .skills import mirror_skill_from_path
+            mirror_skill_from_path(path)
+        except Exception:
+            pass
     summary = path or "(no path recorded)"
     conn.execute(
         "INSERT INTO events (session_id, kind, target, summary, created_at) "
@@ -163,7 +172,7 @@ def mark_skill_materialized(thread_id: str, skill_path: str = "") -> str:
     )
     note_body = (
         f"materialized into {path}" if path
-        else "materialized into a Claude skill (path not recorded)"
+        else "materialized into a skill (path not recorded)"
     )
     emb = _embed(note_body)
     cur = conn.execute(

{threadkeeper-0.5.2 → threadkeeper-0.5.3}/threadkeeper.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: threadkeeper
-Version: 0.5.2
+Version: 0.5.3
 Summary: Multi-agent shared brain across Claude Code/Desktop, Codex, Gemini, Copilot, VS Code. Cross-session memory, self-improving skill loops, inter-agent signaling — one local MCP server.
 Author: thread-keeper contributors
 License: MIT
@@ -82,10 +82,10 @@ make it more than a memory store:
   harvester, candidate-reviewer, weekly Curator) materialize
   class-level skills as the agents work. Adapted to multi-CLI:
   SKILL.md is the primary write target and gets mirrored to every
-  detected CLI's skills directory simultaneously
-  (`~/.claude/skills/`, `~/.codex/skills/`, `~/.threadkeeper/skills/`),
-  with lessons.md as a fallback for CLIs without a native skills
-  loader.
+  known/configured skills root simultaneously (`~/.claude/skills/`,
+  `~/.codex/skills/`, existing `~/.agents/skills/`, extra roots from
+  `THREADKEEPER_EXTRA_SKILLS_DIRS`, and `~/.threadkeeper/skills/`),
+  with lessons.md as a fallback for CLIs without a native skills loader.
 
 ---
 
@@ -223,8 +223,8 @@ shows agents focused on their primary task rarely do).
          brief()    SKILL.md + lessons.md ─► skill_usage   │
             │              │                  │            │
             │              ▼                  ▼            │
-            │         (every detected CLI's   │            │
-            │          skills/ directory)     │            │
+            │         (every configured       │            │
+            │          skills/ root)          │            │
             │              │                  │            │
             │              └──────► [5] Curator daemon ───┘
             │                          (cron, every 7d)
@@ -246,11 +246,11 @@ shows agents focused on their primary task rarely do).
 | 5 | Curator daemon | every 7 days (env knob) | every existing lesson + recently-touched skill | REPORT-`<date>`.md (advisory) or direct PATCH/PRUNE/CONSOLIDATE |
 
 All five write into the universal Skill format (`SKILL.md` under each
-detected CLI's skills directory — `~/.claude/skills/`,
-`~/.codex/skills/`, plus the canonical `~/.threadkeeper/skills/`
-mirror), with `~/.threadkeeper/lessons.md` as a CLI-agnostic fallback
-for clients without a native skills loader (Gemini, Copilot, bare
-MCP).
+known/configured skills root — `~/.claude/skills/`, `~/.codex/skills/`,
+existing `~/.agents/skills/`, optional `THREADKEEPER_EXTRA_SKILLS_DIRS`,
+plus the canonical `~/.threadkeeper/skills/` mirror), with
+`~/.threadkeeper/lessons.md` as a CLI-agnostic fallback for clients
+without a native skills loader (Gemini, Copilot, bare MCP).
 
 #### 1. Auto-review on close_thread
 
@@ -260,9 +260,12 @@ thread's notes. The prompt is rubric-form (Q1–Q5 yes/no) with explicit
 positive examples for incident-vs-rule classification. The fork also
 receives a "recently active skills" block so it prefers PATCHing
 existing umbrellas over creating new ones (*active-update bias*).
-Child appends a lesson via `lesson_append`, optionally mirrors to
-`~/.claude/skills/<name>/SKILL.md`, then closes with
-`mark_skill_materialized`. Opt in with `THREADKEEPER_AUTO_REVIEW=1`.
+Child appends a lesson via `lesson_append`, writes/patches a skill via
+`skill_manage` or writes a skill file directly, then closes with
+`mark_skill_materialized`. If `skill_path` points at a `SKILL.md` (or a
+skill directory), thread-keeper immediately mirrors that whole skill
+into every configured skills root. Opt in with
+`THREADKEEPER_AUTO_REVIEW=1`.
 
 #### 2. Shadow-review daemon