foldkeep 0.9.2__py3-none-any.whl

foldkeep/diff.py

@@ -0,0 +1,105 @@
+"""Context Diff -- git-like version chain for agent contexts (v0.4).
+
+Store:  old_state + delta = new_state   (full snapshots kept sparse)
+Delta format: [["=",i1,i2] | ["replace"/"delete"/"insert",i1,i2,[new lines]]]
+Reconstruction walks back to the nearest full snapshot and replays deltas.
+"""
+import difflib
+import json
+import os
+import sqlite3
+import time
+
+from .core.compressor import FastLingua
+
+_DB = os.path.join(os.path.dirname(os.path.abspath(__file__)), "memories.db")
+
+def _conn():
+    c = sqlite3.connect(_DB)
+    c.execute("""CREATE TABLE IF NOT EXISTS versions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        project TEXT NOT NULL DEFAULT 'default',
+        label TEXT NOT NULL DEFAULT '',
+        parent_id INTEGER,
+        full_comp TEXT,
+        delta TEXT,
+        orig_chars INTEGER, comp_chars INTEGER,
+        created REAL)""")
+    return c
+
+def _latest(project):
+    with _conn() as c:
+        row = c.execute("SELECT id FROM versions WHERE project=? "
+                        "ORDER BY id DESC LIMIT 1", (project,)).fetchone()
+    return row[0] if row else None
+
+def commit(project, text, label=""):
+    fl = FastLingua("balanced", 0.5)
+    comp, st = fl.compress(text)
+    parent = _latest(project)
+    use_full, delta_json = True, None
+    if parent is not None:
+        ptext = show(parent)
+        if ptext:
+            sm = difflib.SequenceMatcher(None, ptext.split("\n"), comp.split("\n"))
+            ops, churn = [], 0
+            for tag, i1, i2, j1, j2 in sm.get_opcodes():
+                if tag == "equal":
+                    ops.append(["=", i1, i2])
+                else:
+                    ops.append([tag, i1, i2, comp.split("\n")[j1:j2]])
+                    churn += (i2 - i1) + (j2 - j1)
+            if churn / max(len(ptext) + len(comp), 1) < 0.6:
+                use_full, delta_json = False, json.dumps(ops, ensure_ascii=False)
+    with _conn() as c:
+        cur = c.execute(
+            "INSERT INTO versions (project,label,parent_id,full_comp,delta,"
+            "orig_chars,comp_chars,created) VALUES (?,?,?,?,?,?,?,?)",
+            (project, label, None if use_full else parent,
+             comp if use_full else None, delta_json,
+             st["orig"], st["comp"], time.time()))
+        return {"id": cur.lastrowid, "orig": st["orig"], "comp": st["comp"],
+                "ratio": st["ratio"], "stored": "full" if use_full else "delta"}
+
+def _row(vid):
+    with _conn() as c:
+        return c.execute("SELECT id,parent_id,full_comp,delta FROM versions "
+                         "WHERE id=?", (vid,)).fetchone()
+
+def show(vid):
+    chain = []
+    cur = vid
+    while cur is not None:
+        row = _row(cur)
+        if not row:
+            return None
+        _id, pid, full, delta = row
+        if full is not None:
+            base = full
+            break
+        chain.append(delta)
+        cur = pid
+    else:
+        return None
+    for dj in reversed(chain):
+        lines = base.split("\n")
+        out = []
+        for op in json.loads(dj):
+            if op[0] == "=":
+                out.extend(lines[op[1]:op[2]])
+            else:
+                out.extend(op[3])
+        base = "\n".join(out)
+    return base
+
+def restore(vid):
+    return show(vid)
+
+def log(project="default", limit=20):
+    with _conn() as c:
+        rows = c.execute("SELECT id,label,parent_id,orig_chars,comp_chars,"
+                         "(full_comp IS NOT NULL),created FROM versions "
+                         "WHERE project=? ORDER BY id DESC LIMIT ?",
+                         (project, limit)).fetchall()
+    return [{"id": r[0], "label": r[1], "parent": r[2], "orig": r[3],
+             "comp": r[4], "full": bool(r[5]), "ts": r[6]} for r in rows]

foldkeep/estimate.py

@@ -0,0 +1,28 @@
+"""Token & cost estimation heuristics (no tokenizer dependency)."""
+import re
+
+_PRICING = {
+    "gpt-4o": 2.50, "gpt-4o-mini": 0.15,
+    "claude-sonnet": 3.00, "claude-haiku": 0.80,
+    "deepseek-v3": 0.27, "qwen-max": 1.60,
+    "local": 0.0,
+}
+
+def estimate_tokens(text, model=None):
+    # model accepted for API symmetry; token count is a model-agnostic
+    # heuristic (CJK ~1.5 chars/token, other ~4 chars/token).
+    zh = len(re.findall(r"[\u4e00-\u9fff]", text))
+    other = max(len(text) - zh, 0)
+    return int(zh / 1.5 + other / 4.0)
+
+def estimate_cost(text, model="claude-sonnet"):
+    t = estimate_tokens(text)
+    rate = _PRICING.get(model, 0.0)
+    return {"tokens": t, "usd": round(t * rate / 1000000.0, 6), "model": model}
+
+def savings(orig, comp, model="claude-sonnet"):
+    a, b = estimate_cost(orig, model), estimate_cost(comp, model)
+    saved = max(a["tokens"] - b["tokens"], 0)
+    return {"tokens_saved": saved,
+            "usd_saved": round(a["usd"] - b["usd"], 6),
+            "ratio": round(b["tokens"] / max(a["tokens"], 1), 3)}

foldkeep/mcp_server.py

@@ -0,0 +1,189 @@
+"""FoldKeep MCP Server (zero-dependency, stdio JSON-RPC).
+
+Run:  python -m foldkeep.mcp_server
+Expose three tools to any MCP client (Claude Desktop, Cursor, ...):
+  compress_context(text, ratio?)   -> compressed text + stats
+  save_context(name, text, kind?, project?) -> compress + store in memory bank
+  search_context(query, project?, limit?)   -> ranked memories
+Protocol: newline-delimited JSON-RPC 2.0 (MCP stdio transport).
+"""
+import json
+import sys
+
+from .core.compressor import FastLingua
+from .memory import store
+from .diff import commit as diff_commit, show as diff_show
+from . import session as sess
+
+SERVER_INFO = {"name": "foldkeep", "version": "0.3.0"}
+PROTOCOL = "2024-11-05"
+
+TOOLS = [
+    {"name": "compress_context",
+     "description": "Compress text with entity-preserving FastLingua. Returns compressed text and stats.",
+     "inputSchema": {"type": "object",
+                     "properties": {"text": {"type": "string"},
+                                    "ratio": {"type": "number", "default": 0.5}},
+                     "required": ["text"]}},
+    {"name": "save_context",
+     "description": "Compress text and store it in the memory bank under a name (kind: snapshot|history|decision|summary).",
+     "inputSchema": {"type": "object",
+                     "properties": {"name": {"type": "string"},
+                                    "text": {"type": "string"},
+                                    "kind": {"type": "string",
+                                             "enum": ["snapshot", "history", "decision", "summary"],
+                                             "default": "snapshot"},
+                                    "project": {"type": "string", "default": "default"}},
+                     "required": ["name", "text"]}},
+    {"name": "context_commit",
+     "description": "Commit a new context version for a project (git-like chain, stores delta vs previous).",
+     "inputSchema": {"type": "object",
+                     "properties": {"text": {"type": "string"},
+                                    "project": {"type": "string", "default": "default"},
+                                    "label": {"type": "string", "default": ""}},
+                     "required": ["text"]}},
+    {"name": "context_restore",
+     "description": "Restore (reconstruct) a context version by id.",
+     "inputSchema": {"type": "object",
+                     "properties": {"id": {"type": "number"}},
+                     "required": ["id"]}},
+    {"name": "session_push",
+     "description": "Append a turn to a named long-running session; old turns auto-compress.",
+     "inputSchema": {"type": "object",
+                     "properties": {"name": {"type": "string"},
+                                    "role": {"type": "string",
+                                             "enum": ["user", "assistant", "system"]},
+                                    "text": {"type": "string"}},
+                     "required": ["name", "role", "text"]}},
+    {"name": "session_render",
+     "description": "Render session context within optional token budget (compressed head + raw tail).",
+     "inputSchema": {"type": "object",
+                     "properties": {"name": {"type": "string"},
+                                    "budget": {"type": "number"}},
+                     "required": ["name"]}},
+    {"name": "search_context",
+     "description": "Search stored memories by keywords (matches entity tags and content).",
+     "inputSchema": {"type": "object",
+                     "properties": {"query": {"type": "string"},
+                                    "project": {"type": "string"},
+                                    "limit": {"type": "number", "default": 5}},
+                     "required": ["query"]}},
+]
+
+def _tool_compress(args):
+    text = args.get("text", "")
+    ratio = float(args.get("ratio", 0.5))
+    fl = FastLingua("balanced", ratio)
+    comp, st = fl.compress(text)
+    return ("compressed %d -> %d chars (%.1f%%), entities %d\n\n%s"
+            % (st["orig"], st["comp"], st["ratio"] * 100, st["entities"], comp))
+
+def _tool_save(args):
+    name = args.get("name", "")
+    text = args.get("text", "")
+    kind = args.get("kind", "snapshot")
+    project = args.get("project", "default")
+    fl = FastLingua("balanced", 0.5)
+    comp, st = fl.compress(text)
+    store.save(name, text, comp, project=project, kind=kind)
+    return ("saved [%s/%s] %s | %d -> %d chars (%.1f%%)"
+            % (project, kind, name, st["orig"], st["comp"], st["ratio"] * 100))
+
+def _tool_search(args):
+    query = args.get("query", "")
+    project = args.get("project")
+    limit = int(args.get("limit", 5))
+    hits = store.search(query, project=project, limit=limit)
+    if not hits:
+        return "(no matches)"
+    return "\n".join("%s [%s/%s] score=%d %dchars"
+                      % (h["name"], h["project"], h["kind"], h["score"], h["chars"])
+                      for h in hits)
+
+def _tool_ctx_commit(args):
+    r = diff_commit(args.get("project", "default"), args.get("text", ""),
+                    args.get("label", ""))
+    return ("committed v%d | %d -> %d chars (%.1f%%) | stored %s"
+            % (r["id"], r["orig"], r["comp"], r["ratio"] * 100, r["stored"]))
+
+def _tool_ctx_restore(args):
+    text = diff_show(int(args.get("id", 0)))
+    return text if text is not None else "(version not found)"
+
+def _tool_sess_push(args):
+    r = sess.push(args.get("name", ""), args.get("role", "user"),
+                  args.get("text", ""))
+    st = sess.stat(args.get("name", ""))
+    return ("pushed #%d | rolled %d | session %d turns ~%d tok"
+            % (r["seq"], r["rolled"], st["turns"], st["est_tokens"]))
+
+def _tool_sess_render(args):
+    b = args.get("budget")
+    out, used, dropped = sess.render(args.get("name", ""),
+                                     int(b) if b else None)
+    return out
+
+_HANDLERS = {"session_push": _tool_sess_push,
+             "session_render": _tool_sess_render,
+             "context_commit": _tool_ctx_commit,
+             "context_restore": _tool_ctx_restore,
+             "compress_context": _tool_compress,
+             "save_context": _tool_save,
+             "search_context": _tool_search}
+
+def _reply(msg_id, result):
+    print(json.dumps({"jsonrpc": "2.0", "id": msg_id, "result": result}),
+          flush=True)
+
+def _error(msg_id, code, message):
+    print(json.dumps({"jsonrpc": "2.0", "id": msg_id,
+                      "error": {"code": code, "message": message}}),
+          flush=True)
+
+def handle(msg):
+    method = msg.get("method", "")
+    msg_id = msg.get("id")
+    if method == "initialize":
+        _reply(msg_id, {"protocolVersion": PROTOCOL,
+                        "capabilities": {"tools": {}},
+                        "serverInfo": SERVER_INFO})
+    elif method == "tools/list":
+        _reply(msg_id, {"tools": TOOLS})
+    elif method == "tools/call":
+        params = msg.get("params", {})
+        name = params.get("name", "")
+        args = params.get("arguments", {})
+        fn = _HANDLERS.get(name)
+        if not fn:
+            _error(msg_id, -32602, "unknown tool: %s" % name)
+            return
+        spec = next((t for t in TOOLS if t["name"] == name), None)
+        missing = [k for k in (spec["inputSchema"].get("required", []) if spec else [])
+                   if k not in args]
+        if missing:
+            _reply(msg_id, {"content": [{"type": "text",
+                          "text": "missing required arguments: %s" % ", ".join(missing)}],
+                            "isError": True})
+            return
+        try:
+            _reply(msg_id, {"content": [{"type": "text", "text": fn(args)}]})
+        except Exception as ex:
+            _reply(msg_id, {"content": [{"type": "text", "text": "error: %s" % ex}],
+                            "isError": True})
+    elif method.startswith("notifications/"):
+        pass
+    elif msg_id is not None:
+        _error(msg_id, -32601, "method not found: %s" % method)
+
+def main():
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            handle(json.loads(line))
+        except Exception as ex:
+            _error(None, -32700, "parse error: %s" % ex)
+
+if __name__ == "__main__":
+    main()

foldkeep/memory/store.py

@@ -0,0 +1,92 @@
+"""FoldKeep memory bank (SQLite, stdlib only).
+
+Kinds: snapshot | history | decision | summary
+API kept compatible with v0.1 JSON store, plus search() and projects.
+"""
+import os
+import re
+import sqlite3
+import time
+
+from ..core.compressor import ENT_RE, KEEP_KEYWORDS
+from ..estimate import estimate_tokens
+
+_DB = os.path.join(os.path.dirname(os.path.abspath(__file__)), "memories.db")
+
+def _conn():
+    c = sqlite3.connect(_DB)
+    c.execute("""CREATE TABLE IF NOT EXISTS memories (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        project TEXT NOT NULL DEFAULT 'default',
+        kind TEXT NOT NULL DEFAULT 'snapshot',
+        name TEXT NOT NULL UNIQUE,
+        tags TEXT NOT NULL DEFAULT '',
+        orig_chars INTEGER, comp_chars INTEGER, tokens_est INTEGER,
+        text_comp TEXT NOT NULL,
+        created REAL)""")
+    return c
+
+def _tags_of(text):
+    ents = sorted(set(ENT_RE.findall(text)))
+    kws = [k for k in KEEP_KEYWORDS if k in text]
+    return " ".join(ents + kws)[:500]
+
+def save(name, orig_text, comp_text, meta=None, project="default", kind="snapshot"):
+    with _conn() as c:
+        c.execute("INSERT OR REPLACE INTO memories "
+                  "(project,kind,name,tags,orig_chars,comp_chars,tokens_est,text_comp,created) "
+                  "VALUES (?,?,?,?,?,?,?,?,?)",
+                  (project, kind, name, _tags_of(orig_text),
+                   len(orig_text), len(comp_text),
+                   estimate_tokens(orig_text), comp_text, time.time()))
+    return _DB
+
+def get(name):
+    with _conn() as c:
+        row = c.execute("SELECT * FROM memories WHERE name=?", (name,)).fetchone()
+    if not row:
+        return None
+    cols = ["id", "project", "kind", "name", "tags", "orig_chars",
+            "comp_chars", "tokens_est", "text_comp", "created"]
+    return dict(zip(cols, row))
+
+def delete(name):
+    with _conn() as c:
+        cur = c.execute("DELETE FROM memories WHERE name=?", (name,))
+        return cur.rowcount > 0
+
+def list_all(project=None):
+    q = "SELECT name, project, kind, orig_chars, comp_chars, created FROM memories"
+    args = ()
+    if project:
+        q += " WHERE project=?"
+        args = (project,)
+    q += " ORDER BY created DESC"
+    with _conn() as c:
+        rows = c.execute(q, args).fetchall()
+    return [{"name": r[0], "project": r[1], "kind": r[2],
+             "orig": r[3], "comp": r[4], "ts": r[5]} for r in rows]
+
+def search(query, project=None, limit=5):
+    terms = [t for t in re.split(r"\s+", query.strip()) if t]
+    if not terms:
+        return []
+    q = "SELECT name, project, kind, tags, text_comp, comp_chars FROM memories"
+    args = []
+    conds = []
+    if project:
+        conds.append("project=?")
+        args.append(project)
+    with _conn() as c:
+        rows = c.execute(q + (" WHERE " + " AND ".join(conds) if conds else ""), args).fetchall()
+    scored = []
+    for name, proj, kind, tags, text, nchars in rows:
+        hay_t = tags.lower()
+        hay_c = (text or "").lower()
+        score = sum(2 for t in terms if t.lower() in hay_t)
+        score += sum(1 for t in terms if t.lower() in hay_c)
+        if score:
+            scored.append({"name": name, "project": proj, "kind": kind,
+                           "score": score, "chars": nchars})
+    scored.sort(key=lambda x: -x["score"])
+    return scored[:limit]

foldkeep/packing.py

@@ -0,0 +1,63 @@
+"""Budget packing: fit multiple documents into a token budget (v0.2).
+
+Strategy:
+  1. compress every document (FastLingua, balanced)
+  2. score importance = entities*3 + keep-keywords*2 + 1
+  3. greedy knapsack by importance-per-token
+  4. overflow items get a second, harder compression pass
+  5. still overflowing -> dropped and reported (never exceed budget)
+"""
+from .core.compressor import FastLingua, ENT_RE, KEEP_KEYWORDS
+from .estimate import estimate_tokens
+
+def _importance(text):
+    ents = len(set(ENT_RE.findall(text)))
+    kw = sum(1 for k in KEEP_KEYWORDS if k in text)
+    return 1.0 + ents * 3.0 + kw * 2.0
+
+def pack(items, budget, ratio=0.5):
+    """items: list of (name, text). Returns a result dict (never exceeds budget)."""
+    fl = FastLingua("balanced", ratio)
+    cands = []
+    for name, text in items:
+        comp, st = fl.compress(text)
+        tok = estimate_tokens(comp)
+        imp = _importance(text)
+        cands.append({"name": name, "orig": text, "text": comp,
+                      "tokens": tok, "imp": imp,
+                      "density": imp / max(tok, 1)})
+    cands.sort(key=lambda c: -c["density"])
+    used, packed, dropped = 0, [], []
+    for c in cands:
+        if c["tokens"] <= 0 and c["orig"].strip():
+            dropped.append(c)
+            continue
+        if used + c["tokens"] <= budget:
+            packed.append(c)
+            used += c["tokens"]
+            continue
+        fl2 = FastLingua("balanced", max(ratio * 0.5, 0.15))
+        comp2, _st2 = fl2.compress(c["orig"])
+        tok2 = estimate_tokens(comp2)
+        if tok2 > 0 and used + tok2 <= budget:
+            c["text"], c["tokens"] = comp2, tok2
+            c["hard"] = True
+            packed.append(c)
+            used += tok2
+        else:
+            dropped.append(c)
+    return {"budget": budget, "used": used,
+            "packed": packed, "dropped": dropped}
+
+def render(result):
+    lines = ["=== FoldKeep Pack | budget %d tok | used %d tok ==="
+             % (result["budget"], result["used"])]
+    for c in result["packed"]:
+        tag = " (hard-compressed)" if c.get("hard") else ""
+        lines.append("--- [%s] %d tok%s ---" % (c["name"], c["tokens"], tag))
+        lines.append(c["text"])
+    if result["dropped"]:
+        names = ", ".join("%s(~%dtok)" % (c["name"], c["tokens"])
+                          for c in result["dropped"])
+        lines.append("=== DROPPED (over budget): %s ===" % names)
+    return "\n".join(lines)

foldkeep/selftest.py

@@ -0,0 +1,154 @@
+"""FoldKeep self-test battery (16 edge cases). Run: oc selftest"""
+import json
+import re
+import subprocess
+import sys
+
+def run(verbose=True):
+    from .core.compressor import FastLingua
+    from . import store, diff, session as sess, packing
+    from .estimate import estimate_cost
+
+    R = []
+    def case(name, fn):
+        try:
+            fn(); R.append((name, "PASS", ""))
+        except Exception as ex:
+            R.append((name, "FAIL", "%s: %s" % (type(ex).__name__, ex)))
+
+    def c1():
+        fl = FastLingua("balanced", 0.5)
+        comp, st = fl.compress("")
+        assert st["orig"] == 0 and comp == ""
+    case("compress empty", c1)
+
+    def c2():
+        fl = FastLingua("balanced", 0.5)
+        t = "\u4f1a\u8bae\u8bb0\u5f55\uff1a\u4eca\u5929\u4e0ealice\u8ba8\u8bba\u4e86FastDeploy\u7684\u4e0a\u7ebf\u5ef6\u671f\u95ee\u9898\uff0c\u539f\u56e0\u662f\u6570\u636e\u5e93\u8fde\u63a5\u8d85\u65f6\uff0c\u51b3\u5b9a\u4e0b\u5468\u4fee\u590d\u3002" * 6
+        comp, st = fl.compress(t)
+        assert 0 < st["ratio"] <= 1.0 and len(comp) > 0
+    case("compress zh long", c2)
+
+    def c3():
+        fl = FastLingua("balanced", 0.5)
+        comp, st = fl.compress("https://api.example.com/ticket/42 https://db.internal.net/x")
+        assert "https://api.example.com/ticket/42" in comp
+    case("url preserved", c3)
+
+    def c4():
+        info = estimate_cost("hello world this is a test", "no-such-model")
+        assert info["usd"] >= 0
+    case("unknown model cost", c4)
+
+    def c5():
+        store.save("qa-uni", "\u5185\u5bb9\uff1aConnectionTimeout \u51b3\u7b56 \u56de\u6eda",
+                   "\u5185\u5bb9 ConnectionTimeout")
+        g = store.get("qa-uni")
+        assert g and "ConnectionTimeout" in g["text_comp"]
+        store.delete("qa-uni")
+    case("store unicode", c5)
+
+    def c6():
+        store.save("qa-zh", "\u51b3\u7b56\uff1amax_connections 200 ConnectionTimeout",
+                   "\u51b3\u7b56 max_connections")
+        hits = store.search("\u6570\u636e\u5e93 \u51b3\u7b56")
+        assert isinstance(hits, list)
+        store.delete("qa-zh")
+    case("store search", c6)
+
+    def c7():
+        fl = FastLingua("balanced", 0.5)
+        txt = ("Incident A: ConnectionTimeout on db.internal.net ticket 77. "
+               "Root cause pool exhaustion. Fix config.yaml.")
+        for i in range(5):
+            r = diff.commit("qa-chain", txt, "v%d" % i)
+            exp, _st = fl.compress(txt)
+            assert diff.show(r["id"]) == exp, "mismatch at %d" % i
+            txt = txt.replace("ticket 77", "ticket 7%d" % (i + 8))
+            txt = txt.replace("pool exhaustion", "pool exhaustion level %d" % i)
+    case("diff chain x5 exact", c7)
+
+    def c8():
+        t = "Same content decision alice bob ticket 42"
+        a = diff.commit("qa-same", t, "a")
+        b = diff.commit("qa-same", t, "b")
+        assert diff.show(b["id"]) == diff.show(a["id"])
+    case("diff identical", c8)
+
+    def c9():
+        sess.push("qa-empty", "user", "")
+        out, used, dropped = sess.render("qa-empty")
+        assert "[01]" in out
+    case("session empty turn", c9)
+
+    def c10():
+        sess.push("qa-tiny", "user", "x " * 500)
+        out, used, dropped = sess.render("qa-tiny", budget=5)
+        # v0.7.2 contract: min-viable floor -> never empty, bounded output
+        assert "/floor]" in out and 0 < used <= 100, (used, out[:80])
+    case("session micro budget", c10)
+
+    def c11():
+        r = packing.pack([], 100)
+        assert r["used"] == 0 and not r["packed"]
+    case("pack empty", c11)
+
+    def c12():
+        r = packing.pack([("big", "word " * 3000)], 10)
+        assert r["used"] <= 10 and len(r["dropped"]) == 1, (r["used"], len(r["dropped"]))
+    case("pack over-budget drop", c12)
+
+    def c13():
+        fl = FastLingua("balanced", 0.5, anchors=True)
+        comp, st = fl.compress(
+            "Incident A: ConnectionTimeout on db.internal.net ticket 77 "
+            "because pool exhaustion. "
+            "Meeting B: alice delayed FastDeploy v2.3 since worker.js OOM. "
+            "Decision C: raise max_connections to 200 so p99 recovers.")
+        tags = re.findall(r"\[F\d+\]", comp)
+        assert len(tags) >= 2 and len(tags) == len(set(tags)), repr(comp)
+    case("anchors multi unique", c13)
+
+    def c14():
+        t = "repeat block alpha beta gamma. " * 40
+        a, _s1 = FastLingua("balanced", 0.5, collapse=False).compress(t)
+        b, _s2 = FastLingua("balanced", 0.5, collapse=True).compress(t)
+        assert len(b) <= len(a)
+    case("collapse repetition", c14)
+
+    def _mcp(msgs):
+        p = subprocess.run([sys.executable, "-m", "foldkeep.mcp_server"],
+                           input=msgs.encode("utf-8"), cwd=_pkg_root(),
+                           capture_output=True, timeout=60)
+        return [l for l in p.stdout.decode("utf-8").strip().split("\n") if l.strip()]
+
+    def _pkg_root():
+        import os
+        return os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+    def c15():
+        msgs = "\n".join(["not-json",
+                           '{"jsonrpc":"2.0","id":1,"method":"tools/list"}']) + "\n"
+        lines = _mcp(msgs)
+        assert any('"tools"' in l for l in lines) and any("-32700" in l for l in lines), lines
+    case("mcp bad-line resilient", c15)
+
+    def c16():
+        msg = json.dumps({"jsonrpc": "2.0", "id": 9, "method": "tools/call",
+                          "params": {"name": "save_context",
+                                     "arguments": {"name": "x"}}}) + "\n"
+        out = "\n".join(_mcp(msg))
+        assert '"isError": true' in out, out[:200]
+    case("mcp missing arg -> isError", c16)
+
+    if verbose:
+        for name, status, detail in R:
+            print("%-28s %s %s" % (name, status, detail))
+    fails = [r for r in R if r[1] == "FAIL"]
+    return R, fails
+
+if __name__ == "__main__":
+    R, fails = run()
+    print("---")
+    print("TOTAL %d | PASS %d | FAIL %d" % (len(R), len(R) - len(fails), len(fails)))
+    sys.exit(1 if fails else 0)