threadkeeper 0.18.2__tar.gz → 0.18.4__tar.gz

{threadkeeper-0.18.2/threadkeeper.egg-info → threadkeeper-0.18.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: threadkeeper
-Version: 0.18.2
+Version: 0.18.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
@@ -22,7 +22,7 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: mcp<3,>=1.10.0
+Requires-Dist: mcp<3,>=2.2.0
 Requires-Dist: pydantic>=2.13.4
 Requires-Dist: pydantic-settings>=2.14.2
 Requires-Dist: pyyaml>=6.0.3
@@ -217,13 +217,12 @@ Cline, … — so a single registration there reaches all of them at once.
 Adding a new CLI = one file under `threadkeeper/adapters/` implementing
 the `CLIAdapter` contract. See [CONTRIBUTING.md](CONTRIBUTING.md).
 
-### Python MCP SDK compatibility
+### Python MCP SDK surface
 
-thread-keeper supports MCP Python SDK 1.x and 2.x (`mcp>=1.10.0,<3`). Fresh
-installs resolve 2.x. A small internal adapter uses the SDK 2.x `MCPServer`
-name and falls back to its SDK 1.x `FastMCP` predecessor, so tools, resources,
-prompts, annotations, structured content, elicitation, and stdio behavior keep
-the same public contract across both supported SDK majors.
+thread-keeper requires MCP Python SDK 2.2 or later (`mcp>=2.2.0,<3`). Its
+stable Skills extension uses the MCP 2026-07-28 extension surface, while tools,
+resources, prompts, annotations, structured content, elicitation, and stdio
+continue to use the same `MCPServer` instance.
 
 ### MCP primitives (tools, resources, prompts, elicitation)
 
@@ -263,6 +262,29 @@ Hosts without a capability fall back to the SessionStart hook plus the `brief()`
 regression. Static URIs only for now (resource *templates* with `{param}` are
 still unevenly supported across hosts).
 
+### MCP Skills extension
+
+On MCP 2026-07-28 hosts, thread-keeper also advertises the stable
+`io.modelcontextprotocol/skills` extension. `skills/list` pages the canonical
+library deterministically, and `skills/get` returns the full manifest for one
+skill. Each resource URI is origin-qualified, for example
+`skill://thread-keeper/release-check/SKILL.md`, so hosts retain the server
+identity alongside a possibly colliding skill name.
+
+The manifest covers `SKILL.md` and every permitted file below `references/`,
+`templates/`, `scripts/`, or `assets/`, with its byte length and a
+`sha256:<hex>` digest. Files are individually available through ordinary
+`resources/read`; traversal, undeclared files, and reads over 1 MiB are
+rejected. Hosts should compare both size and digest before using a retrieved
+file. The canonical directory is published once; the existing per-CLI
+filesystem mirrors remain the fallback for clients that do not implement the
+extension.
+
+Discovery and `resources/read` are delivery only. Reading `SKILL.md` does not
+activate it, approve its tools, record use telemetry, or approve supporting
+files. Activation and any user approval remain responsibilities of the host's
+skill-loading path.
+
 ### Memory egress (cross-provider privacy)
 
 thread-keeper is "one user model … shared across CLIs," and that sharing is by

{threadkeeper-0.18.2 → threadkeeper-0.18.4}/README.md

@@ -173,13 +173,12 @@ Cline, … — so a single registration there reaches all of them at once.
 Adding a new CLI = one file under `threadkeeper/adapters/` implementing
 the `CLIAdapter` contract. See [CONTRIBUTING.md](CONTRIBUTING.md).
 
-### Python MCP SDK compatibility
+### Python MCP SDK surface
 
-thread-keeper supports MCP Python SDK 1.x and 2.x (`mcp>=1.10.0,<3`). Fresh
-installs resolve 2.x. A small internal adapter uses the SDK 2.x `MCPServer`
-name and falls back to its SDK 1.x `FastMCP` predecessor, so tools, resources,
-prompts, annotations, structured content, elicitation, and stdio behavior keep
-the same public contract across both supported SDK majors.
+thread-keeper requires MCP Python SDK 2.2 or later (`mcp>=2.2.0,<3`). Its
+stable Skills extension uses the MCP 2026-07-28 extension surface, while tools,
+resources, prompts, annotations, structured content, elicitation, and stdio
+continue to use the same `MCPServer` instance.
 
 ### MCP primitives (tools, resources, prompts, elicitation)
 
@@ -219,6 +218,29 @@ Hosts without a capability fall back to the SessionStart hook plus the `brief()`
 regression. Static URIs only for now (resource *templates* with `{param}` are
 still unevenly supported across hosts).
 
+### MCP Skills extension
+
+On MCP 2026-07-28 hosts, thread-keeper also advertises the stable
+`io.modelcontextprotocol/skills` extension. `skills/list` pages the canonical
+library deterministically, and `skills/get` returns the full manifest for one
+skill. Each resource URI is origin-qualified, for example
+`skill://thread-keeper/release-check/SKILL.md`, so hosts retain the server
+identity alongside a possibly colliding skill name.
+
+The manifest covers `SKILL.md` and every permitted file below `references/`,
+`templates/`, `scripts/`, or `assets/`, with its byte length and a
+`sha256:<hex>` digest. Files are individually available through ordinary
+`resources/read`; traversal, undeclared files, and reads over 1 MiB are
+rejected. Hosts should compare both size and digest before using a retrieved
+file. The canonical directory is published once; the existing per-CLI
+filesystem mirrors remain the fallback for clients that do not implement the
+extension.
+
+Discovery and `resources/read` are delivery only. Reading `SKILL.md` does not
+activate it, approve its tools, record use telemetry, or approve supporting
+files. Activation and any user approval remain responsibilities of the host's
+skill-loading path.
+
 ### Memory egress (cross-provider privacy)
 
 thread-keeper is "one user model … shared across CLIs," and that sharing is by

{threadkeeper-0.18.2 → threadkeeper-0.18.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "threadkeeper"
-version = "0.18.2"
+version = "0.18.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" }]
@@ -26,12 +26,10 @@ classifiers = [
     "Topic :: Scientific/Engineering :: Artificial Intelligence",
 ]
 dependencies = [
-    # >=1.10.0 for the MCP 2025-06-18 tool vocabulary: ToolAnnotations
-    # (readOnly/destructive/idempotent hints) + structured outputSchema (#67).
-    # Supports the maintained SDK 1.x and 2.x lines. The narrow adapter in
-    # _mcp.py maps the 1.x FastMCP name to the 2.x MCPServer name; <3 keeps a
-    # future unreviewed major from changing the server at install time.
-    "mcp>=1.10.0,<3",
+    # MCP 2.2 provides the 2026-07-28 extension surface used for the stable
+    # Skills distribution protocol. <3 keeps a future unreviewed major from
+    # changing the server at install time.
+    "mcp>=2.2.0,<3",
     "pydantic>=2.13.4",
     "pydantic-settings>=2.14.2",
     "pyyaml>=6.0.3",

{threadkeeper-0.18.2 → threadkeeper-0.18.4}/tests/test_error_paths.py

@@ -2,7 +2,7 @@
 on bad input rather than raising Python exceptions.
 
 A future error-boundary refactor (a `@safe_tool` decorator, schema validation,
-or a top-level FastMCP wrapper) must keep these tests green.
+or a top-level MCPServer wrapper) must keep these tests green.
 """
 from __future__ import annotations
 

threadkeeper-0.18.4/tests/test_evolve_apply_43.py

@@ -0,0 +1,97 @@
+"""Golden coverage for surfacing the surgical lesson_patch action in brief().
+
+The format should teach a fresh agent to make a narrow lesson correction with
+the atomic operation rather than overwrite an otherwise-correct lesson body.
+The seeded fixture also pins nearby long-lived brief sections.
+"""
+from __future__ import annotations
+
+import sys
+import time
+from pathlib import Path
+
+
+_FAKE_CID = "eeee3333-4444-5555-6666-777788889999"
+
+
+def _bootstrap(tmp_path, monkeypatch):
+    env = {
+        "THREADKEEPER_DB": str(tmp_path / "db.sqlite"),
+        "THREADKEEPER_LESSONS": str(tmp_path / "lessons.md"),
+        "CLAUDE_PROJECTS_DIR": str(tmp_path / "fake_claude_projects"),
+        "THREADKEEPER_INGEST_INTERVAL_S": "0",
+        "THREADKEEPER_INGEST_CAP": "0",
+        "THREADKEEPER_SKILL_WATCH_INTERVAL_S": "0",
+        "THREADKEEPER_SPAWN_BUDGET_POLL_S": "0",
+        "THREADKEEPER_SEARCH_PROXY_POLL_S": "0",
+        "THREADKEEPER_MEMORY_GUARD_POLL_S": "0",
+        "THREADKEEPER_SHADOW_REVIEW_INTERVAL_S": "0",
+        "THREADKEEPER_CURATOR_INTERVAL_S": "0",
+        "THREADKEEPER_EXTRACT_INTERVAL_S": "0",
+        "THREADKEEPER_CANDIDATE_REVIEW_INTERVAL_S": "0",
+        "THREADKEEPER_PROBE_INTERVAL_S": "0",
+        "THREADKEEPER_EVOLVE_REVIEW_INTERVAL_S": "0",
+        "THREADKEEPER_DISABLE_BG_DAEMONS": "1",
+        "THREADKEEPER_TASK_LOG_DIR": str(tmp_path / "tasks"),
+        "THREADKEEPER_CLIENT": "pytest",
+        "THREADKEEPER_FORCE_CID": _FAKE_CID,
+        "THREADKEEPER_NO_EMBEDDINGS": "1",
+    }
+    for key, value in env.items():
+        monkeypatch.setenv(key, value)
+    Path(env["CLAUDE_PROJECTS_DIR"]).mkdir(parents=True, exist_ok=True)
+    for name in [m for m in list(sys.modules) if m.startswith("threadkeeper")]:
+        del sys.modules[name]
+    import threadkeeper.server  # noqa: F401
+    from threadkeeper import _mcp, db
+
+    return {"mcp": _mcp.mcp, "db": db}
+
+
+def _tool(pkg, name):
+    return pkg["mcp"]._tool_manager._tools[name].fn
+
+
+def _add_evolve(conn, suggestion):
+    conn.execute(
+        "INSERT INTO evolve (suggestion, applied, status, created_at) "
+        "VALUES (?,?,?,?)",
+        (suggestion, 0, "promoted", int(time.time())),
+    )
+    conn.commit()
+
+
+def test_brief_surfaces_lesson_patch_and_preserves_existing_sections(
+    tmp_path, monkeypatch,
+):
+    pkg = _bootstrap(tmp_path, monkeypatch)
+    conn = pkg["db"].get_db()
+    lesson_append = _tool(pkg, "lesson_append")
+    open_thread = _tool(pkg, "open_thread")
+
+    lesson_append(
+        title="repair stale cross-links",
+        body="Use the current cross-link target.",
+        summary="Keep links current.",
+        source="foreground",
+    )
+    open_thread(question="a seeded open thread that must survive")
+    _add_evolve(conn, "a promoted suggestion that must surface")
+
+    from threadkeeper.brief import render_brief
+
+    text = render_brief(conn)
+
+    # New: a precise, atomic lesson-edit action is available at session start.
+    assert "lesson_patch" in text
+    assert "lesson_patch(slug, old_string, new_string)" in text
+    assert "unique lesson-body substring" in text
+
+    # Existing: the added section leaves the surrounding brief intact.
+    assert "open" in text
+    assert "a seeded open thread that must survive" in text
+    assert "evolve_pending" in text
+    assert "★" in text
+    assert "a promoted suggestion that must surface" in text
+    assert "user-facing" in text
+    assert "Do NOT cite internal IDs" in text

threadkeeper-0.18.4/tests/test_evolve_apply_45.py

@@ -0,0 +1,107 @@
+"""Golden coverage for lesson recommendation reconciliation in brief()."""
+from __future__ import annotations
+
+import sys
+import time
+from pathlib import Path
+
+
+_FAKE_CID = "bbbb3333-4444-5555-6666-777788889999"
+_OPEN_Q = "seeded open thread remains visible"
+_OLD_LESSON = "aws-sso-preflight-uses-sts"
+_NEW_LESSON = "aws-sso-token-freshness-sts-is-cached"
+_COMMAND = "aws sts get-caller-identity"
+
+
+def _bootstrap(tmp_path, monkeypatch):
+    env = {
+        "THREADKEEPER_DB": str(tmp_path / "db.sqlite"),
+        "CLAUDE_PROJECTS_DIR": str(tmp_path / "fake_claude_projects"),
+        "THREADKEEPER_LESSONS": str(tmp_path / "lessons.md"),
+        "THREADKEEPER_DISABLE_BG_DAEMONS": "1",
+        "THREADKEEPER_INGEST_INTERVAL_S": "0",
+        "THREADKEEPER_INGEST_CAP": "0",
+        "THREADKEEPER_SKILL_WATCH_INTERVAL_S": "0",
+        "THREADKEEPER_SPAWN_BUDGET_POLL_S": "0",
+        "THREADKEEPER_SEARCH_PROXY_POLL_S": "0",
+        "THREADKEEPER_MEMORY_GUARD_POLL_S": "0",
+        "THREADKEEPER_SHADOW_REVIEW_INTERVAL_S": "0",
+        "THREADKEEPER_CURATOR_INTERVAL_S": "0",
+        "THREADKEEPER_EXTRACT_INTERVAL_S": "0",
+        "THREADKEEPER_CANDIDATE_REVIEW_INTERVAL_S": "0",
+        "THREADKEEPER_PROBE_INTERVAL_S": "0",
+        "THREADKEEPER_EVOLVE_REVIEW_INTERVAL_S": "0",
+        "THREADKEEPER_THREAD_JANITOR_INTERVAL_S": "0",
+        "THREADKEEPER_BRIEF_LEAN": "0",
+        "THREADKEEPER_TASK_LOG_DIR": str(tmp_path / "tasks"),
+        "THREADKEEPER_CLIENT": "pytest",
+        "THREADKEEPER_FORCE_CID": _FAKE_CID,
+        "THREADKEEPER_NO_EMBEDDINGS": "1",
+    }
+    for key, value in env.items():
+        monkeypatch.setenv(key, value)
+    Path(env["CLAUDE_PROJECTS_DIR"]).mkdir(parents=True, exist_ok=True)
+    for name in [module for module in list(sys.modules) if module.startswith("threadkeeper")]:
+        del sys.modules[name]
+    import threadkeeper.server  # noqa: F401
+    from threadkeeper import _mcp, db, identity, lessons
+    return {"mcp": _mcp.mcp, "db": db, "identity": identity, "lessons": lessons}
+
+
+def _tool(pkg, name):
+    return pkg["mcp"]._tool_manager._tools[name].fn
+
+
+def _add_evolve(conn, suggestion):
+    conn.execute(
+        "INSERT INTO evolve (suggestion, applied, status, created_at) "
+        "VALUES (?,?,?,?)",
+        (suggestion, 0, "promoted", int(time.time())),
+    )
+    conn.commit()
+
+
+def test_brief_surfaces_lesson_reconciliation_and_keeps_existing_sections(
+    tmp_path, monkeypatch,
+):
+    pkg = _bootstrap(tmp_path, monkeypatch)
+    conn = pkg["db"].get_db()
+
+    pkg["lessons"].append_lesson(
+        _OLD_LESSON,
+        body=(
+            f"Run `{_COMMAND}` to gate an AWS SSO freshness check before "
+            "using fixture-backed cloud tests."
+        ),
+        source="shadow",
+    )
+    pkg["lessons"].append_lesson(
+        _NEW_LESSON,
+        body=(
+            f"Never gate SSO freshness on `{_COMMAND}`: it is cached and can "
+            "return success after the token expires."
+        ),
+        source="shadow",
+    )
+
+    _tool(pkg, "open_thread")(question=_OPEN_Q)
+    _add_evolve(conn, "a promoted suggestion that must remain visible")
+
+    from threadkeeper.brief import render_brief
+    text = render_brief(conn)
+
+    # New behavior: a newer debunk flags the older recommendation by command
+    # and lesson slug, with a concrete reconciliation action.
+    assert "lesson_reconciliation" in text
+    assert f"`{_COMMAND}`" in text
+    assert f"debunked_by={_NEW_LESSON}" in text
+    assert f"still_recommended_by={_OLD_LESSON}" in text
+    assert "patch its recommendation or cross-link the correcting lesson" in text
+
+    # Regression: the established brief sections still survive this addition.
+    assert "open" in text
+    assert _OPEN_Q in text
+    assert "evolve_pending" in text
+    assert "★ \"a promoted suggestion that must remain visible\"" in text
+    assert "user-facing: paraphrase plain" in text
+    assert "Do NOT cite internal IDs" in text

{threadkeeper-0.18.2 → threadkeeper-0.18.4}/tests/test_mcp_resources_prompts.py

@@ -158,10 +158,9 @@ def test_audit_threadkeeper_prompt_renders(fresh_mp):
 # ──────────────────────────────────────────────────────────────────────
 
 def test_server_advertises_resources_and_prompts_capabilities(fresh_mp):
-    mcp = fresh_mp["mcp"]
-    # MCP SDK 2.x renamed the high-level wrapper's low-level server handle.
-    lowlevel = getattr(mcp, "_lowlevel_server", None) or mcp._mcp_server
-    caps = lowlevel.get_capabilities(NotificationOptions(), {})
+    caps = fresh_mp["mcp"]._lowlevel_server.get_capabilities(
+        NotificationOptions(), {}, protocol_version="2026-07-28",
+    )
     assert caps.resources is not None
     assert caps.prompts is not None
     assert caps.tools is not None  # tools unaffected

{threadkeeper-0.18.2 → threadkeeper-0.18.4}/tests/test_mcp_sdk_compat.py

@@ -1,9 +1,8 @@
-"""MCP SDK compatibility and stdio-server smoke coverage.
+"""MCP SDK 2.x stdio-server smoke coverage.
 
-The server keeps one narrow import adapter for MCP SDK 1.x and 2.x. This test
-starts the real ``python -m threadkeeper.server`` process and uses the legacy
-stdio handshake shared by both majors, then verifies the public tools registry
-is available. CI runs it once per supported SDK-major/Python combination.
+The stable Skills extension requires MCP SDK 2.2 or later. This test starts
+the real ``python -m threadkeeper.server`` process and verifies that the public
+tools registry remains available over stdio on the supported SDK surface.
 """
 from __future__ import annotations
 

threadkeeper-0.18.4/tests/test_mcp_skills_extension.py

@@ -0,0 +1,183 @@
+"""Protocol-level coverage for the stable MCP Skills extension (#336)."""
+from __future__ import annotations
+
+import asyncio
+import hashlib
+from types import SimpleNamespace
+
+import pytest
+from mcp.server.mcpserver.exceptions import ResourceNotFoundError
+from mcp.shared.exceptions import MCPError
+
+
+_STABLE_PROTOCOL = "2026-07-28"
+
+
+def _tool(pkg, name):
+    return pkg["mcp"]._tool_manager._tools[name].fn
+
+
+def _write_skill(pkg, name: str, *, extra_frontmatter: str = ""):
+    skill_dir = pkg["config"].CLAUDE_SKILLS_DIR / name
+    skill_dir.mkdir(parents=True, exist_ok=True)
+    (skill_dir / "SKILL.md").write_text(
+        "---\n"
+        f"name: {name}\n"
+        f"description: {name} description\n"
+        f"{extra_frontmatter}"
+        "---\n\n"
+        f"# {name}\n",
+        encoding="utf-8",
+    )
+    return skill_dir
+
+
+def _call_extension(pkg, method: str, params):
+    entry = pkg["mcp"]._lowlevel_server._request_handlers[method]
+    return asyncio.run(
+        entry.handler(SimpleNamespace(protocol_version=_STABLE_PROTOCOL), params)
+    )
+
+
+def test_discovery_advertises_stable_skills_extension_without_changing_core_contracts(fresh_mp):
+    from mcp.server.lowlevel.server import NotificationOptions
+    from threadkeeper.mcp_skills import SKILLS_EXTENSION_ID
+
+    server = fresh_mp["mcp"]._lowlevel_server
+    caps = server.get_capabilities(
+        NotificationOptions(), {}, protocol_version=_STABLE_PROTOCOL,
+    )
+
+    assert caps.extensions == {SKILLS_EXTENSION_ID: {}}
+    assert caps.resources is not None
+    assert caps.prompts is not None
+    assert caps.tools is not None
+    assert {"skills/list", "skills/get"} <= set(server._request_handlers)
+
+
+def test_list_paginates_in_uri_order_and_keeps_the_server_origin_in_each_uri(fresh_mp):
+    from threadkeeper.mcp_skills import ListSkillsParams, SKILL_LIST_PAGE_SIZE
+
+    for index in range(SKILL_LIST_PAGE_SIZE + 1):
+        _write_skill(fresh_mp, f"page-{index:03d}")
+
+    first = _call_extension(fresh_mp, "skills/list", ListSkillsParams())
+    second = _call_extension(
+        fresh_mp, "skills/list", ListSkillsParams(cursor=first["nextCursor"]),
+    )
+
+    first_uris = [entry["uri"] for entry in first["skills"]]
+    second_uris = [entry["uri"] for entry in second["skills"]]
+    assert first["resultType"] == second["resultType"] == "complete"
+    assert len(first_uris) == SKILL_LIST_PAGE_SIZE
+    assert first_uris == sorted(first_uris)
+    assert first_uris + second_uris == sorted(first_uris + second_uris)
+    assert all(uri.startswith("skill://thread-keeper/") for uri in first_uris + second_uris)
+    # The authority is an origin namespace, so a same-named skill from another
+    # server cannot collapse into this server's entry.
+    assert "skill://another-server/page-000/SKILL.md" not in first_uris
+
+
+def test_get_returns_complete_manifest_and_read_bytes_match_each_digest(fresh_mp):
+    from threadkeeper.mcp_skills import GetSkillParams, skill_catalog
+
+    skill_dir = _write_skill(
+        fresh_mp,
+        "manifest-skill",
+        extra_frontmatter="license: MIT\nmetadata:\n  owner: thread-keeper\n",
+    )
+    reference = skill_dir / "references" / "guide.txt"
+    reference.parent.mkdir()
+    reference.write_bytes(b"reference bytes\n")
+
+    entry = next(item for item in skill_catalog() if item.name == "manifest-skill")
+    result = _call_extension(
+        fresh_mp, "skills/get", GetSkillParams(uri=entry.uri),
+    )
+
+    skill = result["skill"]
+    assert result["resultType"] == "complete"
+    assert skill["frontmatter"] == {
+        "name": "manifest-skill",
+        "description": "manifest-skill description",
+        "license": "MIT",
+        "metadata": {"owner": "thread-keeper"},
+    }
+    assert {item["uri"] for item in skill["resources"]} == {
+        item.uri for item in entry.files
+    }
+    listed_resources = {
+        str(resource.uri): resource
+        for resource in asyncio.run(fresh_mp["mcp"].list_resources())
+    }
+    listed_uris = set(listed_resources)
+    assert {item["uri"] for item in skill["resources"]} <= listed_uris
+    for file_entry in skill["resources"]:
+        assert listed_resources[file_entry["uri"]].size == file_entry["size"]
+        contents = asyncio.run(fresh_mp["mcp"].read_resource(file_entry["uri"]))
+        data = contents[0].content
+        assert isinstance(data, bytes)
+        assert len(data) == file_entry["size"]
+        assert f"sha256:{hashlib.sha256(data).hexdigest()}" == file_entry["digest"]
+
+
+def test_get_rejects_unknown_or_non_skill_markdown_uri(fresh_mp):
+    from threadkeeper.mcp_skills import GetSkillParams
+
+    _write_skill(fresh_mp, "known-skill")
+    for uri in (
+        "skill://thread-keeper/known-skill/references/guide.md",
+        "skill://thread-keeper/missing/SKILL.md",
+    ):
+        with pytest.raises(MCPError) as raised:
+            _call_extension(fresh_mp, "skills/get", GetSkillParams(uri=uri))
+        assert raised.value.error.code == -32602
+
+
+def test_resource_reads_reject_traversal_undeclared_and_oversized_files(fresh_mp):
+    from threadkeeper.mcp_skills import skill_catalog
+
+    skill_dir = _write_skill(fresh_mp, "safe-skill")
+    (skill_dir / "private.txt").write_text("not declared", encoding="utf-8")
+    bad_uris = (
+        "skill://thread-keeper/safe-skill/../SKILL.md",
+        "skill://thread-keeper/safe-skill/references/%2e%2e/SKILL.md",
+        "skill://thread-keeper/safe-skill/private.txt",
+    )
+    for uri in bad_uris:
+        with pytest.raises(ResourceNotFoundError):
+            asyncio.run(fresh_mp["mcp"].read_resource(uri))
+
+    large_dir = _write_skill(fresh_mp, "large-skill") / "references"
+    large_dir.mkdir()
+    (large_dir / "large.bin").write_bytes(b"x" * (1_048_576 + 1))
+    assert "large-skill" not in {entry.name for entry in skill_catalog()}
+    with pytest.raises(ResourceNotFoundError):
+        asyncio.run(
+            fresh_mp["mcp"].read_resource(
+                "skill://thread-keeper/large-skill/SKILL.md"
+            )
+        )
+
+
+def test_skill_delivery_is_side_effect_free_and_filesystem_mirrors_remain_fallback(fresh_mp):
+    from threadkeeper.tools.skills import _mirror_targets
+
+    create = _tool(fresh_mp, "skill_manage")
+    assert create(
+        action="create",
+        name="fallback-skill",
+        description="Proves filesystem mirrors remain available.",
+        content="# Fallback\n",
+    ).startswith("ok path=")
+
+    targets = _mirror_targets("fallback-skill")
+    assert targets
+    assert all((target / "SKILL.md").exists() for target in targets)
+
+    conn = fresh_mp["db"].get_db()
+    before = conn.execute("SELECT COUNT(*) AS count FROM events").fetchone()["count"]
+    uri = "skill://thread-keeper/fallback-skill/SKILL.md"
+    assert asyncio.run(fresh_mp["mcp"].read_resource(uri))[0].content.startswith(b"---")
+    after = conn.execute("SELECT COUNT(*) AS count FROM events").fetchone()["count"]
+    assert after == before

{threadkeeper-0.18.2 → threadkeeper-0.18.4}/tests/test_release_workflows.py

@@ -98,29 +98,25 @@ def test_glama_dockerfile_pin_matches_the_project_release():
     assert f"threadkeeper=={version}" in DOCKERFILE.read_text()
 
 
-def test_mcp_requirement_supports_both_sdk_majors_through_one_adapter():
+def test_mcp_requirement_uses_the_2x_skills_extension_surface():
     deps = tomllib.loads((ROOT / "pyproject.toml").read_text())["project"]["dependencies"]
     mcp_req = next(d for d in deps if d.split(">")[0].split("<")[0].strip() == "mcp")
-    assert mcp_req == "mcp>=1.10.0,<3"
+    assert mcp_req == "mcp>=2.2.0,<3"
 
-    adapter = (ROOT / "threadkeeper" / "_mcp.py").read_text()
-    assert "mcp.server.mcpserver" in adapter
-    assert "mcp.server.fastmcp" in adapter
     for importer in (
+        ROOT / "threadkeeper" / "_mcp.py",
         ROOT / "threadkeeper" / "elicitation.py",
         ROOT / "threadkeeper" / "tools" / "dialectic.py",
     ):
         text = importer.read_text()
         assert "mcp.server.fastmcp" not in text
-        assert "mcp.server.mcpserver" not in text
+    assert "mcp.server.mcpserver" in (ROOT / "threadkeeper" / "_mcp.py").read_text()
 
 
-def test_ci_matrix_covers_both_supported_mcp_sdk_majors():
+def test_ci_matrix_covers_the_supported_mcp_sdk_surface():
     matrix = _workflow("test.yml")["jobs"]["pytest-shard"]["strategy"]["matrix"]
-    majors = set(matrix["mcp"]) | {
-        extra["mcp"] for extra in matrix.get("include", [])
-    }
-    assert majors == {">=1.10.0,<2", ">=2.0.0,<3"}
+    assert matrix["mcp"] == [">=2.2.0,<3"]
+    assert "include" not in matrix
     assert '"mcp${{ matrix.mcp }}"' in _workflow_text("test.yml")
 
 def test_ci_security_scanning_covers_code_and_resolved_dependencies():