threadkeeper 0.18.3__tar.gz → 0.19.0__tar.gz

{threadkeeper-0.18.3/threadkeeper.egg-info → threadkeeper-0.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: threadkeeper
-Version: 0.18.3
+Version: 0.19.0
 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
@@ -1269,6 +1291,17 @@ loops: a claim that surfaces in `brief()` and then gets "confirmed" by a
 review-fork reading the same dialog can't ride that internal evidence
 all the way to high confidence — internal evidence buys half as much.
 
+**Immutable authority and action confirmation.** Confidence and tier describe
+how useful a claim seems; they do not upgrade the authority of its evidence.
+New dialog, claim, evidence, lesson, and skill artifacts retain a write-time
+authority class plus their source principal/channel. Declared references such
+as `dialog:<uuid>`, `claim:<id>`, `lesson:<slug>`, and `skill:<name>` form a
+derivation graph; summaries and promotions inherit the least-authoritative
+root. Unknown writer origins are rejected. Before any consequential action,
+call `memory_authorize_action`: observed memory needs either an independent
+trusted principal or explicit `confirmed=True`. `forget` quarantines every
+derived descendant, so it can no longer be retrieved or authorize an action.
+
 **Discrete tier on each claim** — `hypothesis → observed → validated`
 (plus `disputed`). Independent of the continuous confidence band; tier
 is the **action-gating** signal:
@@ -1385,6 +1418,9 @@ The most-used env knobs (full list in `threadkeeper/config.py`):
 | `THREADKEEPER_EMBED_BACKEND` | `onnx` | embedding runtime: `onnx` (fastembed, no PyTorch) or `sentence-transformers` (legacy fallback) |
 | `THREADKEEPER_EMBED_MODEL` | `paraphrase-multilingual-MiniLM-L12-v2` | 384-dim cross-lingual embedding model |
 | `THREADKEEPER_EMBED_REVISION` | backend-specific immutable commit | Hugging Face snapshot pin; set an intentional replacement commit only together with a re-embedding plan |
+| `THREADKEEPER_WRITER_PROVIDER` | active client | optional provider identity recorded for newly derived lessons, skills, notes, and claims |
+| `THREADKEEPER_WRITER_MODEL` | resolved model / `unknown` | optional writer-model identity recorded with derived-memory provenance |
+| `THREADKEEPER_WRITER_REVISION` | `unknown` | optional immutable writer-model revision recorded with derived-memory provenance |
 | `THREADKEEPER_EMBED_CACHE_DIR` | `~/.cache/huggingface/hub` | durable Hugging Face snapshot cache |
 | `THREADKEEPER_EMBED_LOCAL_FILES_ONLY` | false | require the pinned snapshot in the local Hugging Face cache (offline / air-gapped mode) |
 | `THREADKEEPER_SPAWNED_CHILD` | "" | spawn-internal marker; disables autonomous daemons in children |
@@ -1721,26 +1757,37 @@ export THREADKEEPER_EMBED_BACKEND=sentence-transformers
 
 # After any backend switch, homogenize the stored corpus so queries and
 # stored vectors live in the same space:
-tk-migrate-embeddings --all          # or --notes-only / --dialog-only
-tk-migrate-embeddings --dry-run      # report stale counts only
+tk-migrate-embeddings --all          # stage both stores, validate, atomically activate
+tk-migrate-embeddings --notes-only   # build part of a target; activation stays pending
+tk-migrate-embeddings --status       # active/staging/coverage/validation report
+tk-migrate-embeddings --rollback     # atomically return to the prior generation
 ```
 
-The migration is batched, resumable, and idempotent (a second run finds
-nothing stale). Both backends emit 384-dim vectors, so the `vec0` schema is
-unchanged.
+The migration is batched, resumable, and idempotent. It stores target vectors
+under a separate generation while the durable active-generation pointer keeps
+the prior space queryable. An interrupted command resumes the staged target;
+readers never see it until `--all` validates full note/dialog coverage and
+switches the one pointer in a SQLite transaction. `--rollback` is the inverse
+transaction and leaves the failed target available for inspection or a later
+retry. Both backends emit 384-dim vectors, so the `vec0` schema is unchanged.
 
 **Intentional model revision upgrade.** Set `THREADKEEPER_EMBED_REVISION` to
 the immutable commit for the selected backend's Hugging Face artifact, restart
 the host, then run `tk-migrate-embeddings --all`. A changed revision is a new
-embedding generation; until migration, old vectors remain available through
-FTS rather than being compared against the new vector space.
+embedding generation. During staging, queries are encoded against the durable
+old generation and keep their semantic recall; the new configuration is not
+exposed until activation. The migration output and `mp_dashboard()` show
+active, staging, coverage, validation, and activation state.
 
 Stored rows carry an embedding-generation fingerprint, not just the backend:
 backend, model ID, vector dimension, pooling contract, and compatible runtime
-version. Search never compares a current query vector with a stale generation;
-those rows remain retrievable through FTS until `tk-migrate-embeddings` refreshes
-them. `mp_dashboard()` shows total/current-generation/vec coverage for notes and
-dialog rows.
+version. Newly derived lessons, skills, notes, and dialectic claims additionally
+record writer provider/model/revision plus source event or thread references;
+those records contain pointers and hashes, not another copy of transcript text.
+The fixed anonymized upgrade corpus runs both old→new and new→old paths before
+activation, with explicit recall, abstention, knowledge-update, and
+derived-memory decision thresholds. Run `python -m threadkeeper.eval` to print
+that release-gate report.
 
 Retrieval is hybrid by default. FTS candidate generation always runs, even
 when embeddings are installed or only part of the corpus has vectors. Dense

{threadkeeper-0.18.3 → threadkeeper-0.19.0}/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
@@ -1225,6 +1247,17 @@ loops: a claim that surfaces in `brief()` and then gets "confirmed" by a
 review-fork reading the same dialog can't ride that internal evidence
 all the way to high confidence — internal evidence buys half as much.
 
+**Immutable authority and action confirmation.** Confidence and tier describe
+how useful a claim seems; they do not upgrade the authority of its evidence.
+New dialog, claim, evidence, lesson, and skill artifacts retain a write-time
+authority class plus their source principal/channel. Declared references such
+as `dialog:<uuid>`, `claim:<id>`, `lesson:<slug>`, and `skill:<name>` form a
+derivation graph; summaries and promotions inherit the least-authoritative
+root. Unknown writer origins are rejected. Before any consequential action,
+call `memory_authorize_action`: observed memory needs either an independent
+trusted principal or explicit `confirmed=True`. `forget` quarantines every
+derived descendant, so it can no longer be retrieved or authorize an action.
+
 **Discrete tier on each claim** — `hypothesis → observed → validated`
 (plus `disputed`). Independent of the continuous confidence band; tier
 is the **action-gating** signal:
@@ -1341,6 +1374,9 @@ The most-used env knobs (full list in `threadkeeper/config.py`):
 | `THREADKEEPER_EMBED_BACKEND` | `onnx` | embedding runtime: `onnx` (fastembed, no PyTorch) or `sentence-transformers` (legacy fallback) |
 | `THREADKEEPER_EMBED_MODEL` | `paraphrase-multilingual-MiniLM-L12-v2` | 384-dim cross-lingual embedding model |
 | `THREADKEEPER_EMBED_REVISION` | backend-specific immutable commit | Hugging Face snapshot pin; set an intentional replacement commit only together with a re-embedding plan |
+| `THREADKEEPER_WRITER_PROVIDER` | active client | optional provider identity recorded for newly derived lessons, skills, notes, and claims |
+| `THREADKEEPER_WRITER_MODEL` | resolved model / `unknown` | optional writer-model identity recorded with derived-memory provenance |
+| `THREADKEEPER_WRITER_REVISION` | `unknown` | optional immutable writer-model revision recorded with derived-memory provenance |
 | `THREADKEEPER_EMBED_CACHE_DIR` | `~/.cache/huggingface/hub` | durable Hugging Face snapshot cache |
 | `THREADKEEPER_EMBED_LOCAL_FILES_ONLY` | false | require the pinned snapshot in the local Hugging Face cache (offline / air-gapped mode) |
 | `THREADKEEPER_SPAWNED_CHILD` | "" | spawn-internal marker; disables autonomous daemons in children |
@@ -1677,26 +1713,37 @@ export THREADKEEPER_EMBED_BACKEND=sentence-transformers
 
 # After any backend switch, homogenize the stored corpus so queries and
 # stored vectors live in the same space:
-tk-migrate-embeddings --all          # or --notes-only / --dialog-only
-tk-migrate-embeddings --dry-run      # report stale counts only
+tk-migrate-embeddings --all          # stage both stores, validate, atomically activate
+tk-migrate-embeddings --notes-only   # build part of a target; activation stays pending
+tk-migrate-embeddings --status       # active/staging/coverage/validation report
+tk-migrate-embeddings --rollback     # atomically return to the prior generation
 ```
 
-The migration is batched, resumable, and idempotent (a second run finds
-nothing stale). Both backends emit 384-dim vectors, so the `vec0` schema is
-unchanged.
+The migration is batched, resumable, and idempotent. It stores target vectors
+under a separate generation while the durable active-generation pointer keeps
+the prior space queryable. An interrupted command resumes the staged target;
+readers never see it until `--all` validates full note/dialog coverage and
+switches the one pointer in a SQLite transaction. `--rollback` is the inverse
+transaction and leaves the failed target available for inspection or a later
+retry. Both backends emit 384-dim vectors, so the `vec0` schema is unchanged.
 
 **Intentional model revision upgrade.** Set `THREADKEEPER_EMBED_REVISION` to
 the immutable commit for the selected backend's Hugging Face artifact, restart
 the host, then run `tk-migrate-embeddings --all`. A changed revision is a new
-embedding generation; until migration, old vectors remain available through
-FTS rather than being compared against the new vector space.
+embedding generation. During staging, queries are encoded against the durable
+old generation and keep their semantic recall; the new configuration is not
+exposed until activation. The migration output and `mp_dashboard()` show
+active, staging, coverage, validation, and activation state.
 
 Stored rows carry an embedding-generation fingerprint, not just the backend:
 backend, model ID, vector dimension, pooling contract, and compatible runtime
-version. Search never compares a current query vector with a stale generation;
-those rows remain retrievable through FTS until `tk-migrate-embeddings` refreshes
-them. `mp_dashboard()` shows total/current-generation/vec coverage for notes and
-dialog rows.
+version. Newly derived lessons, skills, notes, and dialectic claims additionally
+record writer provider/model/revision plus source event or thread references;
+those records contain pointers and hashes, not another copy of transcript text.
+The fixed anonymized upgrade corpus runs both old→new and new→old paths before
+activation, with explicit recall, abstention, knowledge-update, and
+derived-memory decision thresholds. Run `python -m threadkeeper.eval` to print
+that release-gate report.
 
 Retrieval is hybrid by default. FTS candidate generation always runs, even
 when embeddings are installed or only part of the corpus has vectors. Dense

{threadkeeper-0.18.3 → threadkeeper-0.19.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "threadkeeper"
-version = "0.18.3"
+version = "0.19.0"
 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.3 → threadkeeper-0.19.0}/tests/test_daemon_liveness.py

@@ -9,7 +9,7 @@ def _loop(snapshot, loop_id: str):
     return {row["id"]: row for row in snapshot["loops"]}[loop_id]
 
 
-def test_daemon_health_is_additive_without_schema_version_bump(mp_with_cid):
+def test_daemon_health_is_recreated_during_schema_migration(mp_with_cid):
     pkg = mp_with_cid("33334444-5555-6666-7777-888899990000")
     db = pkg["db"]
     conn = db.get_db()

{threadkeeper-0.18.3 → threadkeeper-0.19.0}/tests/test_dialectic_tier.py

@@ -125,18 +125,12 @@ def test_explicit_base_weight_still_multiplied_by_discount(
     assert row["weight"] == pytest.approx(0.4)
 
 
-def test_unknown_origin_no_discount(tmp_path, monkeypatch):
-    """Falls back to multiplier 1.0 for write_origins not in the table.
-    Tests don't break under custom origins; default behavior is no-op."""
+def test_unknown_origin_fails_closed(tmp_path, monkeypatch):
+    """An unrecognised writer cannot mint a durable authority record."""
     pkg = _bootstrap(tmp_path, monkeypatch, write_origin="random_unknown")
     t = _tools(pkg)
     out = t["dialectic_claim"].fn(claim="probe", domain="style")
-    cid = out.split()[1].split("=", 1)[1]
-    t["dialectic_evidence"].fn(claim_id=cid, kind="support")
-    row = pkg["db"].get_db().execute(
-        "SELECT weight FROM dialectic_evidence WHERE claim_id=?", (cid,)
-    ).fetchone()
-    assert row["weight"] == 1.0
+    assert out == "ERR authority_unknown_origin"
 
 
 # ── weighted confidence formula ─────────────────────────────────────────

{threadkeeper-0.18.3 → threadkeeper-0.19.0}/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.3 → threadkeeper-0.19.0}/tests/test_eval_harness.py

@@ -191,6 +191,19 @@ def test_cli_golden_baseline_is_clean():
     assert r["shadow"]["ready"] and r["candidate"]["ready"] and r["quality"]["ready"]
 
 
+def test_upgrade_replay_regression_fails_the_release_gate(tmp_path):
+    """A one-way model regression must not be downgraded to PARTIAL."""
+    for fixture in FIXTURES.iterdir():
+        (tmp_path / fixture.name).write_text(fixture.read_text())
+    replay = json.loads((tmp_path / "upgrade_replay.json").read_text())
+    replay["items"][0]["new_to_old"]["retrieved_memory_ids"] = []
+    (tmp_path / "upgrade_replay.json").write_text(json.dumps(replay))
+
+    report = h.run_eval(tmp_path)
+    assert not report["upgrade"]["passed"]
+    assert report["verdict"] == "FAIL"
+
+
 def test_cli_llm_judge_without_key_exits_cleanly():
     env = {k: v for k, v in os.environ.items() if k != "ANTHROPIC_API_KEY"}
     proc = _run_cli("--judge", "llm", env=env)
@@ -211,7 +224,8 @@ _SECRET_PATTERNS = [
 
 
 def test_fixtures_have_no_secrets_or_private_paths():
-    for name in ("shadow.json", "candidates.json", "skill_quality.json"):
+    for name in ("shadow.json", "candidates.json", "skill_quality.json",
+                 "upgrade_replay.json"):
         text = (FIXTURES / name).read_text()
         # valid JSON
         json.loads(text)

threadkeeper-0.19.0/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.19.0/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.3 → threadkeeper-0.19.0}/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.3 → threadkeeper-0.19.0}/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