firekeep-client 1.3.0__tar.gz → 1.4.2__tar.gz

{firekeep_client-1.3.0/firekeep_client.egg-info → firekeep_client-1.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: firekeep-client
-Version: 1.3.0
+Version: 1.4.2
 Summary: Client for Firekeep, the self-hosted operating layer for connected AI agents.
 License-Expression: LicenseRef-Firekeep-BUSL-1.1
 Project-URL: Homepage, https://firekeep.ai
@@ -32,7 +32,8 @@ operating layer for connected AI agents**. It carries durable knowledge,
 working context, procedures, coordination, and replayable evidence across
 sessions, models, machines, and teammates. Agent-facing MCP tools are exposed
 through one local `firekeep` gateway. Shipped adapters configure Claude Code,
-Codex, Kiro, and OpenCode; other MCP clients can connect through the generic
+Claude Desktop (auto-detected when the app's config dir exists), Codex, Kiro,
+and OpenCode; other MCP clients can connect through the generic
 configuration path, without hook-driven lifecycle automation.
 
 mcp-name: io.github.kapella-hub/firekeep
@@ -44,13 +45,16 @@ aggregates your team server's services (memory, sessions, environment,
 coordination) plus the Decision Board and whichever **dexes** — the domain
 indexes the Keep understands — you have registered, the lifecycle hook cores,
 the runtime adapters, and the `firekeep` CLI (`install`, `join`, `doctor`,
-`update`, `dex`, `docdex`).
-
-Two dexes ship today: `firekeep-symdex` (code intelligence) and
-`firekeep-docdex` (folders of documents indexed into the Keep's corpus). The
-managed installer always installs both wheels; `firekeep dex list|add|remove`
-decides which of them actually run. Existing installs keep symdex across an
-update; a fresh install opts in with `firekeep dex add symdex`.
+`update`, `dex`, `docdex`, `maildex`).
+
+Three dexes ship today: `firekeep-symdex` (code intelligence),
+`firekeep-docdex` (folders of documents indexed into the Keep's corpus), and
+`firekeep-maildex` (email over read-only IMAP, always member-private,
+registered with `firekeep maildex add`). The managed installer always installs
+all three wheels; `firekeep dex list|add|remove` decides which of them
+actually run. Symdex and docdex are registered by default — since client 1.2.0
+an absent registry is seeded with both (default-on), `firekeep dex remove` is
+the off-switch, and removals stick across updates.
 
 **Firekeep is self-hosted — this package needs a server to talk to.** A person
 or team runs its own server, with per-key authentication. Current server images

{firekeep_client-1.3.0 → firekeep_client-1.4.2}/README.md

@@ -5,7 +5,8 @@ operating layer for connected AI agents**. It carries durable knowledge,
 working context, procedures, coordination, and replayable evidence across
 sessions, models, machines, and teammates. Agent-facing MCP tools are exposed
 through one local `firekeep` gateway. Shipped adapters configure Claude Code,
-Codex, Kiro, and OpenCode; other MCP clients can connect through the generic
+Claude Desktop (auto-detected when the app's config dir exists), Codex, Kiro,
+and OpenCode; other MCP clients can connect through the generic
 configuration path, without hook-driven lifecycle automation.
 
 mcp-name: io.github.kapella-hub/firekeep
@@ -17,13 +18,16 @@ aggregates your team server's services (memory, sessions, environment,
 coordination) plus the Decision Board and whichever **dexes** — the domain
 indexes the Keep understands — you have registered, the lifecycle hook cores,
 the runtime adapters, and the `firekeep` CLI (`install`, `join`, `doctor`,
-`update`, `dex`, `docdex`).
-
-Two dexes ship today: `firekeep-symdex` (code intelligence) and
-`firekeep-docdex` (folders of documents indexed into the Keep's corpus). The
-managed installer always installs both wheels; `firekeep dex list|add|remove`
-decides which of them actually run. Existing installs keep symdex across an
-update; a fresh install opts in with `firekeep dex add symdex`.
+`update`, `dex`, `docdex`, `maildex`).
+
+Three dexes ship today: `firekeep-symdex` (code intelligence),
+`firekeep-docdex` (folders of documents indexed into the Keep's corpus), and
+`firekeep-maildex` (email over read-only IMAP, always member-private,
+registered with `firekeep maildex add`). The managed installer always installs
+all three wheels; `firekeep dex list|add|remove` decides which of them
+actually run. Symdex and docdex are registered by default — since client 1.2.0
+an absent registry is seeded with both (default-on), `firekeep dex remove` is
+the off-switch, and removals stick across updates.
 
 **Firekeep is self-hosted — this package needs a server to talk to.** A person
 or team runs its own server, with per-key authentication. Current server images

{firekeep_client-1.3.0 → firekeep_client-1.4.2}/firekeep_client/__init__.py

@@ -9,4 +9,4 @@ versions without a verdict (`_check_versions`) and judges staleness against the
 release manifest instead (`_check_client_version`).
 """
 
-__version__ = "1.3.0"
+__version__ = "1.4.2"

{firekeep_client-1.3.0 → firekeep_client-1.4.2}/firekeep_client/adapters/base.py

@@ -516,6 +516,36 @@ instead of asking inline. If it returns pending, keep calling decision_board_che
 until the human answers.
 """
 
+# The handshake text for the `chat` toolset (gateway.py, FIREKEEP_TOOLSET=chat —
+# the ChatGPT tunnel surface). NOT derived from MCP_SERVER_INSTRUCTIONS by
+# replace(): that text instructs agents to call vault_retrieve, vault_store,
+# skill_create, action_before and decision_board — none of which the chat preset
+# serves, and an instruction to call a tool that errors is worse than no
+# instruction. This variant may only name tools the preset carries;
+# test_gateway_toolset pins that mechanically (every tool-shaped name mentioned
+# here must be in CHAT_TOOLSET).
+CHAT_INSTRUCTIONS = """\
+Firekeep — persistent team memory, reachable from this chat.
+
+Recall BEFORE answering, and treat not knowing as the trigger: if the user names
+a host, IP, path, service or convention you cannot name from the current
+conversation ("my VPS", "our server"), or uses history words ("again", "still",
+"last time", "how did we"), call memory_recall(task=<their request>) first.
+Never claim you don't know about the user's own systems before calling it once.
+For operational or repeated-failure tasks, also check skill_recall(task).
+
+Working on something across turns? ctx_start_session(goal) opens a session — its
+response includes prior art: what the team already built or decided near your
+goal. ctx_update as you go, ctx_complete_session(outcome) when done.
+
+memory_learn the moment something worth keeping is decided or fixed (include
+what failed first). Never store secrets — no passwords, tokens or keys in
+memory.
+
+When recalled knowledge shaped what you DID, call memory_feedback(memory_ids,
+useful) with a one-line comment — only for knowledge you acted on.
+"""
+
 
 def _hash12(text: str) -> str:
     """sha256(text utf-8), first 12 hex chars — the contract's hash shape."""
@@ -529,6 +559,9 @@ def _hash12(text: str) -> str:
 # covers the handshake text served fresh from the running wheel every session.
 RENDERED_INSTRUCTIONS_HASH = _hash12(FIREKEEP_INSTRUCTIONS)
 GATEWAY_INSTRUCTIONS_HASH = _hash12(GATEWAY_INSTRUCTIONS)
+# Same contract for the chat-toolset handshake: a session's recorded
+# serverInfo.version names exactly which instruction text it received.
+CHAT_INSTRUCTIONS_HASH = _hash12(CHAT_INSTRUCTIONS)
 # Same definition for the hook-free text. Doctor compares a rendered block
 # against the hash for ITS runtime — a generic block checked against the four's
 # hash would read "edited" forever.

{firekeep_client-1.3.0 → firekeep_client-1.4.2}/firekeep_client/gateway.py

@@ -22,7 +22,12 @@ from pathlib import Path
 from typing import Any
 
 from firekeep_client import dexes
-from firekeep_client.adapters.base import GATEWAY_INSTRUCTIONS, GATEWAY_INSTRUCTIONS_HASH
+from firekeep_client.adapters.base import (
+    CHAT_INSTRUCTIONS,
+    CHAT_INSTRUCTIONS_HASH,
+    GATEWAY_INSTRUCTIONS,
+    GATEWAY_INSTRUCTIONS_HASH,
+)
 from firekeep_client.stdio import force_utf8_stdio, pin_import_paths
 
 
@@ -43,6 +48,56 @@ STATUS_TOOL = {
 }
 
 
+# Named toolsets (FIREKEEP_TOOLSET). A toolset narrows the gateway to a curated
+# surface for hosts where the full ~90 tools are wrong — the ChatGPT tunnel is
+# the founding case: a consumer chat surface, prompt-injection-rich, that still
+# deserves recall, sessions (prior art rides ctx_start_session) and the one
+# write that makes chat valuable (memory_learn — the poisoning risk is carried
+# by replay attribution, runtime: chatgpt, not prevented). Excluded outright:
+# vault, corpus ingest, relay, backup, dex/code tools.
+TOOLSET_PRESETS: dict[str, frozenset[str]] = {
+    "chat": frozenset({
+        "memory_recall", "memory_learn", "memory_feedback",
+        "skill_recall", "skill_list",
+        "ctx_start_session", "ctx_update", "ctx_complete_session",
+        "ctx_abandon_session", "ctx_list_sessions", "ctx_resume_session",
+        "ctx_get_shadow",
+    }),
+}
+
+# A preset that narrows the tool surface also narrows the handshake text: the
+# default GATEWAY_INSTRUCTIONS instructs agents to call vault_retrieve and
+# decision_board, which the chat preset does not serve. An explicit
+# FIREKEEP_TOOLS_ALLOW keeps the default text — the operator overrode the
+# preset and owns the mismatch.
+_PRESET_INSTRUCTIONS: dict[str, tuple[str, str]] = {
+    "chat": (CHAT_INSTRUCTIONS, CHAT_INSTRUCTIONS_HASH),
+}
+
+
+def _active_toolset() -> tuple[str | None, frozenset[str] | None]:
+    """(label, allowlist) from the environment.
+
+    FIREKEEP_TOOLS_ALLOW (explicit comma-list) wins over FIREKEEP_TOOLSET.
+    An UNKNOWN preset refuses to start rather than falling back to the full
+    surface: this gateway may sit behind a tunnel reachable from a consumer
+    chat host, and a typo must fail closed, not open ~90 tools."""
+    allow = os.environ.get("FIREKEEP_TOOLS_ALLOW", "").strip()
+    if allow:
+        names = frozenset(n.strip() for n in allow.split(",") if n.strip())
+        return "allowlist", names
+    preset = os.environ.get("FIREKEEP_TOOLSET", "").strip()
+    if not preset:
+        return None, None
+    if preset not in TOOLSET_PRESETS:
+        raise SystemExit(
+            f"firekeep gateway: unknown FIREKEEP_TOOLSET {preset!r} "
+            f"(valid: {', '.join(sorted(TOOLSET_PRESETS))}); refusing to start "
+            "rather than serve the full tool surface"
+        )
+    return preset, TOOLSET_PRESETS[preset]
+
+
 def _console_script(name: str) -> str:
     suffix = ".exe" if os.name == "nt" else ""
     filename = f"{name}{suffix}"
@@ -210,11 +265,15 @@ class Gateway:
         ]
         self.protocol_version = "2025-03-26"
         self.routes: dict[str, Backend] = {}
+        # Fail-closed at construction: an unknown preset never serves a request.
+        self.toolset_label, self.toolset = _active_toolset()
+        self.tools_filtered = 0
 
     def discover(self) -> list[dict[str, Any]]:
         with ThreadPoolExecutor(max_workers=len(self.backends)) as pool:
             list(pool.map(lambda backend: backend.discover(self.protocol_version), self.backends))
         self.routes = {}
+        self.tools_filtered = 0
         tools = [STATUS_TOOL]
         for backend in self.backends:
             for tool in backend.tools:
@@ -222,6 +281,12 @@ class Gateway:
                 if name in self.routes or name == STATUS_TOOL["name"]:
                     backend.state = f"degraded: duplicate tool name {name}"
                     continue
+                # Toolset filter at the ROUTING layer: an excluded tool never
+                # enters self.routes, so it is invisible in tools/list AND a
+                # tools/call for it returns -32601 — enforcement, not decoration.
+                if self.toolset is not None and name not in self.toolset:
+                    self.tools_filtered += 1
+                    continue
                 self.routes[name] = backend
                 tools.append(tool)
         return tools
@@ -231,6 +296,9 @@ class Gateway:
             "backends": {backend.name: backend.state for backend in self.backends},
             "tool_count": len(self.routes),
             "plan_filtering": False,
+            # Disclosure: a narrowed surface must say so. null when unfiltered.
+            "toolset": self.toolset_label,
+            "tools_filtered": self.tools_filtered,
         }
 
     def handle(self, message: dict[str, Any]) -> dict[str, Any] | None:
@@ -241,6 +309,9 @@ class Gateway:
             return None
         if method == "initialize":
             self.protocol_version = params.get("protocolVersion") or self.protocol_version
+            instructions, instructions_hash = _PRESET_INSTRUCTIONS.get(
+                self.toolset_label or "", (GATEWAY_INSTRUCTIONS, GATEWAY_INSTRUCTIONS_HASH)
+            )
             return {
                 "jsonrpc": "2.0",
                 "id": request_id,
@@ -250,9 +321,9 @@ class Gateway:
                     # version = the handshake text's content hash, so a session's
                     # recorded serverInfo names exactly which instruction text it
                     # received (round-2 measurement contract) — the hardcoded "1"
-                    # said nothing.
-                    "serverInfo": {"name": "firekeep", "version": GATEWAY_INSTRUCTIONS_HASH},
-                    "instructions": GATEWAY_INSTRUCTIONS,
+                    # said nothing. A preset that swaps the text swaps the hash.
+                    "serverInfo": {"name": "firekeep", "version": instructions_hash},
+                    "instructions": instructions,
                 },
             }
         if method == "ping":

{firekeep_client-1.3.0 → firekeep_client-1.4.2/firekeep_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: firekeep-client
-Version: 1.3.0
+Version: 1.4.2
 Summary: Client for Firekeep, the self-hosted operating layer for connected AI agents.
 License-Expression: LicenseRef-Firekeep-BUSL-1.1
 Project-URL: Homepage, https://firekeep.ai
@@ -32,7 +32,8 @@ operating layer for connected AI agents**. It carries durable knowledge,
 working context, procedures, coordination, and replayable evidence across
 sessions, models, machines, and teammates. Agent-facing MCP tools are exposed
 through one local `firekeep` gateway. Shipped adapters configure Claude Code,
-Codex, Kiro, and OpenCode; other MCP clients can connect through the generic
+Claude Desktop (auto-detected when the app's config dir exists), Codex, Kiro,
+and OpenCode; other MCP clients can connect through the generic
 configuration path, without hook-driven lifecycle automation.
 
 mcp-name: io.github.kapella-hub/firekeep
@@ -44,13 +45,16 @@ aggregates your team server's services (memory, sessions, environment,
 coordination) plus the Decision Board and whichever **dexes** — the domain
 indexes the Keep understands — you have registered, the lifecycle hook cores,
 the runtime adapters, and the `firekeep` CLI (`install`, `join`, `doctor`,
-`update`, `dex`, `docdex`).
-
-Two dexes ship today: `firekeep-symdex` (code intelligence) and
-`firekeep-docdex` (folders of documents indexed into the Keep's corpus). The
-managed installer always installs both wheels; `firekeep dex list|add|remove`
-decides which of them actually run. Existing installs keep symdex across an
-update; a fresh install opts in with `firekeep dex add symdex`.
+`update`, `dex`, `docdex`, `maildex`).
+
+Three dexes ship today: `firekeep-symdex` (code intelligence),
+`firekeep-docdex` (folders of documents indexed into the Keep's corpus), and
+`firekeep-maildex` (email over read-only IMAP, always member-private,
+registered with `firekeep maildex add`). The managed installer always installs
+all three wheels; `firekeep dex list|add|remove` decides which of them
+actually run. Symdex and docdex are registered by default — since client 1.2.0
+an absent registry is seeded with both (default-on), `firekeep dex remove` is
+the off-switch, and removals stick across updates.
 
 **Firekeep is self-hosted — this package needs a server to talk to.** A person
 or team runs its own server, with per-key authentication. Current server images

{firekeep_client-1.3.0 → firekeep_client-1.4.2}/firekeep_client.egg-info/SOURCES.txt

@@ -103,6 +103,7 @@ tests/test_doctor_embeddings.py
 tests/test_doctor_no_server.py
 tests/test_e2e_bootstrap.py
 tests/test_gateway.py
+tests/test_gateway_toolset.py
 tests/test_generic_config.py
 tests/test_hooklog.py
 tests/test_import_boundary.py

{firekeep_client-1.3.0 → firekeep_client-1.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "firekeep-client"
-version = "1.3.0"
+version = "1.4.2"
 description = "Client for Firekeep, the self-hosted operating layer for connected AI agents."
 readme = "README.md"
 requires-python = ">=3.10"

{firekeep_client-1.3.0 → firekeep_client-1.4.2}/tests/test_gateway.py

@@ -74,6 +74,8 @@ def test_gateway_advertises_reachable_tools_and_diagnostic_status_only():
         },
         "tool_count": 1,
         "plan_filtering": False,
+        "toolset": None,
+        "tools_filtered": 0,
     }
 
 

firekeep_client-1.4.2/tests/test_gateway_toolset.py

@@ -0,0 +1,153 @@
+"""FIREKEEP_TOOLSET / FIREKEEP_TOOLS_ALLOW — the gateway's curated surfaces.
+
+The invariants:
+  - filtering happens at the ROUTING layer: an excluded tool is invisible in
+    tools/list AND uncallable (-32601), never decoratively hidden;
+  - an unknown preset fails CLOSED (refuses to start) — this gateway can sit
+    behind a tunnel reachable from a consumer chat host, and a typo must not
+    open the full ~90-tool surface;
+  - unset env is byte-identical to today (pinned by test_gateway.py's exact
+    status assertion plus the unfiltered case here);
+  - the narrowing is disclosed via firekeep_gateway_status;
+  - a preset that narrows the tools narrows the handshake text with it, and
+    the chat instructions may only name tools the chat preset serves.
+"""
+from __future__ import annotations
+
+import re
+
+import pytest
+
+from firekeep_client.adapters.base import (
+    CHAT_INSTRUCTIONS,
+    CHAT_INSTRUCTIONS_HASH,
+    GATEWAY_INSTRUCTIONS_HASH,
+)
+from firekeep_client.gateway import STATUS_TOOL, TOOLSET_PRESETS, Gateway, _active_toolset
+
+
+class FakeBackend:
+    def __init__(self, name, tools):
+        self.name = name
+        self.tools = tools
+        self.state = "not checked"
+
+    def discover(self, protocol_version):
+        self.state = f"ready ({len(self.tools)} tools)"
+
+    def request(self, method, params, **kwargs):
+        return {"jsonrpc": "2.0", "id": "up", "result": {"content": []}}
+
+    def close(self):
+        pass
+
+
+def _tool(name):
+    return {"name": name, "inputSchema": {}}
+
+
+def _gateway(monkeypatch, **env):
+    for key in ("FIREKEEP_TOOLSET", "FIREKEEP_TOOLS_ALLOW"):
+        monkeypatch.delenv(key, raising=False)
+    for key, value in env.items():
+        monkeypatch.setenv(key, value)
+    gateway = Gateway()
+    gateway.backends = [
+        FakeBackend("cortex", [_tool("memory_recall"), _tool("memory_learn"),
+                               _tool("vault_retrieve"), _tool("corpus_ingest")]),
+        FakeBackend("bridge", [_tool("ctx_start_session"), _tool("ctx_update")]),
+        FakeBackend("relay", [_tool("relay_broadcast")]),
+    ]
+    return gateway
+
+
+def test_chat_preset_filters_list_and_routes(monkeypatch):
+    gateway = _gateway(monkeypatch, FIREKEEP_TOOLSET="chat")
+    reply = gateway.handle({"jsonrpc": "2.0", "id": 1, "method": "tools/list"})
+    names = {tool["name"] for tool in reply["result"]["tools"]}
+    assert names == {STATUS_TOOL["name"], "memory_recall", "memory_learn",
+                     "ctx_start_session", "ctx_update"}
+    # Routing-layer enforcement: the excluded tool is UNCALLABLE, and the
+    # handler's re-discover retry must not resurrect it.
+    call = gateway.handle({"jsonrpc": "2.0", "id": 2, "method": "tools/call",
+                           "params": {"name": "vault_retrieve", "arguments": {}}})
+    assert call["error"]["code"] == -32601
+
+
+def test_allowlist_overrides_preset(monkeypatch):
+    gateway = _gateway(monkeypatch, FIREKEEP_TOOLSET="chat",
+                       FIREKEEP_TOOLS_ALLOW="vault_retrieve, relay_broadcast")
+    reply = gateway.handle({"jsonrpc": "2.0", "id": 1, "method": "tools/list"})
+    names = {tool["name"] for tool in reply["result"]["tools"]}
+    assert names == {STATUS_TOOL["name"], "vault_retrieve", "relay_broadcast"}
+
+
+def test_unset_env_serves_everything(monkeypatch):
+    gateway = _gateway(monkeypatch)
+    reply = gateway.handle({"jsonrpc": "2.0", "id": 1, "method": "tools/list"})
+    assert len(reply["result"]["tools"]) == 8  # 7 fakes + status tool
+    assert gateway.status()["toolset"] is None
+    assert gateway.status()["tools_filtered"] == 0
+
+
+def test_unknown_preset_fails_closed(monkeypatch):
+    monkeypatch.delenv("FIREKEEP_TOOLS_ALLOW", raising=False)
+    monkeypatch.setenv("FIREKEEP_TOOLSET", "chta")
+    with pytest.raises(SystemExit) as exc:
+        _active_toolset()
+    assert "chta" in str(exc.value)
+    assert "refusing" in str(exc.value)
+
+
+def test_status_discloses_narrowing(monkeypatch):
+    gateway = _gateway(monkeypatch, FIREKEEP_TOOLSET="chat")
+    gateway.discover()
+    status = gateway.status()
+    assert status["toolset"] == "chat"
+    assert status["tools_filtered"] == 3  # vault_retrieve, corpus_ingest, relay_broadcast
+    assert status["tool_count"] == 4
+
+
+def test_status_tool_is_never_filtered(monkeypatch):
+    gateway = _gateway(monkeypatch, FIREKEEP_TOOLS_ALLOW="memory_recall")
+    reply = gateway.handle({"jsonrpc": "2.0", "id": 1, "method": "tools/list"})
+    assert STATUS_TOOL["name"] in {tool["name"] for tool in reply["result"]["tools"]}
+
+
+def test_chat_preset_swaps_handshake_text_and_hash(monkeypatch):
+    gateway = _gateway(monkeypatch, FIREKEEP_TOOLSET="chat")
+    reply = gateway.handle({"jsonrpc": "2.0", "id": 1, "method": "initialize",
+                            "params": {"protocolVersion": "2025-03-26"}})
+    result = reply["result"]
+    assert result["instructions"] == CHAT_INSTRUCTIONS
+    assert result["serverInfo"]["version"] == CHAT_INSTRUCTIONS_HASH
+    assert "decision_board" not in result["instructions"]
+    assert "vault" not in result["instructions"]
+
+
+def test_allowlist_keeps_default_handshake(monkeypatch):
+    # The operator overrode the preset; the default text stays and they own
+    # any tool/instruction mismatch.
+    gateway = _gateway(monkeypatch, FIREKEEP_TOOLS_ALLOW="memory_recall")
+    reply = gateway.handle({"jsonrpc": "2.0", "id": 1, "method": "initialize",
+                            "params": {"protocolVersion": "2025-03-26"}})
+    assert reply["result"]["serverInfo"]["version"] == GATEWAY_INSTRUCTIONS_HASH
+
+
+def test_chat_instructions_only_name_preset_tools():
+    """Mechanical honesty: every tool-shaped name the chat handshake mentions
+    must be a tool the chat preset actually serves — an instruction to call a
+    tool that errors is worse than no instruction."""
+    mentioned = set(re.findall(r"\b[a-z]+_[a-z_]+\b", CHAT_INSTRUCTIONS))
+    non_tools = {"memory_ids"}  # a parameter name, not a tool
+    assert mentioned - non_tools <= TOOLSET_PRESETS["chat"]
+
+
+def test_chat_preset_is_exactly_the_decided_surface():
+    assert TOOLSET_PRESETS["chat"] == {
+        "memory_recall", "memory_learn", "memory_feedback",
+        "skill_recall", "skill_list",
+        "ctx_start_session", "ctx_update", "ctx_complete_session",
+        "ctx_abandon_session", "ctx_list_sessions", "ctx_resume_session",
+        "ctx_get_shadow",
+    }

{firekeep_client-1.3.0 → firekeep_client-1.4.2}/tests/test_package.py

@@ -7,7 +7,7 @@ from pathlib import Path
 def test_package_imports_and_exposes_frozen_version():
     import firekeep_client
 
-    assert firekeep_client.__version__ == "1.3.0"
+    assert firekeep_client.__version__ == "1.4.2"
 
 
 def test_frozen_module_layout_is_present():