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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: firekeep-client
-Version: 1.4.2
+Version: 1.5.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

{firekeep_client-1.4.2 → firekeep_client-1.5.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.4.2"
+__version__ = "1.5.2"

{firekeep_client-1.4.2 → firekeep_client-1.5.2}/firekeep_client/cli.py

@@ -7,6 +7,7 @@ from __future__ import annotations
 
 import argparse
 import contextlib
+import http.client
 import os
 import re
 import shutil
@@ -41,7 +42,7 @@ from firekeep_client.adapters.base import (
     rendered_instructions_path,
 )
 from firekeep_client.adapters.codex import mcp_block_is_current
-from firekeep_client.transport import get_json, TransportError
+from firekeep_client.transport import get_json, post_json, TransportError
 
 
 def _config_path() -> Path:
@@ -1701,6 +1702,51 @@ def run_doctor(cfg=None) -> list[tuple[str, str, str]]:
     return results
 
 
+# --- doctor --report: opt-in, per-invocation, redacted -----------------------
+#
+# Design record: firekeep.ai/privacy.html discloses this exact mechanism.
+# There is deliberately NO persisted config toggle (no [telemetry] section) —
+# every send is one explicit act (typing --report on this one command), never
+# a standing "always send" setting that could be flipped once and forgotten.
+# Nothing about doctor's automatic behavior changes; without the flag this
+# code path is never reached and no network call to firekeep.ai happens.
+DOCTOR_REPORT_URL = "https://firekeep.ai/doctor-report.php"
+
+
+def _redact_for_report(results: list[tuple[str, str, str]]) -> dict:
+    """Check name + status ONLY. The third tuple element — `detail`, the
+    human-readable message doctor prints locally — is dropped entirely and
+    never touches this function's return value. `detail` is where paths,
+    hostnames, and config contents live (see e.g. `_check_health`'s
+    `f"{_ep_url(svc, cfg)}: {exc}"` and `_check_config_perms`'s literal path),
+    so the redaction is structural — no field to forget to strip — rather
+    than a scrub applied after the fact."""
+    return {
+        "client_version": __version__,
+        "checks": [{"id": name, "status": status} for name, status, _detail in results],
+    }
+
+
+def _send_doctor_report(results: list[tuple[str, str, str]]) -> str:
+    """POST the redacted summary; return one line describing what happened.
+    Never raises — a failed report must never affect doctor's own exit code
+    or hide the check results already printed above it."""
+    body = _redact_for_report(results)
+    try:
+        # No auth headers: this is an anonymous, unauthenticated report to a
+        # public collection endpoint, not a call to the user's own server.
+        post_json(DOCTOR_REPORT_URL, body, headers={})
+        return "firekeep: anonymous report sent (check names + status only — see firekeep.ai/privacy.html)"
+    except (TransportError, OSError, http.client.HTTPException) as exc:
+        # http.client.HTTPException (IncompleteRead, BadStatusLine, ...) is
+        # NOT an OSError -- it's raised deep inside urlopen()'s response read
+        # (transport._request), and without this clause a truncated response
+        # from a hostile proxy or captive portal would escape as an
+        # unhandled traceback AFTER doctor's own results already printed,
+        # discarding the exit code the fail rows above earned.
+        return f"firekeep: report NOT sent ({exc}) — doctor results above are unaffected"
+
+
 def cmd_restore(args) -> int:
     """Browse or restore local snapshots of uncommitted work.
 
@@ -2480,6 +2526,8 @@ def cmd_doctor(args) -> int:
     hint = _generic_hint()
     if hint is not None:
         print(hint)
+    if getattr(args, "report", False):
+        print(_send_doctor_report(results))
     return rc
 
 
@@ -2909,6 +2957,16 @@ def _build_parser() -> argparse.ArgumentParser:
         "doctor", aliases=["status"],
         help="preflight health / skew / perm checks",
     )
+    # Opt-in, per-invocation, no persisted setting — see cmd_doctor and
+    # _redact_for_report. Off unless this exact flag is typed; doctor's own
+    # output and exit code are unaffected either way.
+    doc.add_argument(
+        "--report", action="store_true",
+        help="also send an ANONYMOUS report (check names + pass/warn/fail "
+             "status and your client version only — never messages, paths, "
+             "or hostnames) to firekeep.ai. Off by default; see "
+             "firekeep.ai/privacy.html.",
+    )
     doc.set_defaults(func=cmd_doctor)
 
     shift = sub.add_parser(

{firekeep_client-1.4.2 → firekeep_client-1.5.2}/firekeep_client/contract/matrix.py

@@ -76,12 +76,47 @@ def _precompact_claude(hooks: tuple[tuple[str, str, str | None, int], ...]) -> s
 # (firekeep_client/adapters/opencode.py). VALIDATED live on opencode 1.14.22
 # (2026-07-18, docs/OPENCODE-VALIDATION.md): pre-edit block is a HARD gate (the
 # write tool aborted with the policy reason), prompt-core inbox surfaced, stop
-# fired on session.deleted. Caveats: session.created publishes before plugins
+# fired on session.deleted. Caveat: session.created publishes before plugins
 # subscribe in `run` mode (bridge fires session_start from its first hook
-# instead), and briefing/inbox text lands in opencode's console log, NOT the
-# model context — opencode has no systemMessage channel.
+# instead).
+#
+# CORRECTION (2026-08-21) — this comment used to say opencode's briefing lands
+# in the console "NOT the model context" BECAUSE it has no systemMessage
+# channel. That reasoning was wrong, and the rows below inherited the error.
+#
+# Firekeep's dict hook cores all return {"systemMessage": ...}. On Claude Code
+# `systemMessage` is shown to the HUMAN; the channel that reaches the model is
+# `hookSpecificOutput.additionalContext`, which appears nowhere in this client.
+# Measured in one session by comparing every SessionStart hook attachment: the
+# three emitting `additionalContext` were verbatim in the model's context, the
+# two emitting `systemMessage` (Firekeep's pre-flight briefing, the symdex
+# banner) were absent. Claude Code's own docs are explicit — "To surface a
+# message to the user on any platform, return systemMessage" — while for
+# SessionStart and UserPromptSubmit "Claude Code adds plain-text stdout as
+# context that Claude can see and act on".
+#
+# FIXED in the same series: hooks/__main__.py now emits BOTH channels for the
+# two events Claude Code documents as accepting model-facing context —
+# session_start (SessionStart) and prompt (UserPromptSubmit). Verified on the
+# real rendered command line: hookEventName SessionStart, 2,265 characters of
+# briefing in additionalContext, systemMessage retained so the human still sees
+# it. The claude cells below are therefore true again — but they were wrong for
+# as long as this comment's first half describes, which is why the history
+# stays here rather than being tidied away.
+#
+# Still human-only, deliberately: stop, precompact and session_end. Claude Code
+# does not document a model-facing channel for those events and nobody has
+# measured one; emitting a plausible-looking shape at an event that ignores it
+# would put the text back where it started while looking fixed.
+#
+# kiro stays marked unverified: its channel is a different mechanism
+# (agentSpawn), nobody has run the same measurement on it, and the fix above is
+# scoped to the claude runtime for exactly that reason. Do not assume it shares
+# Claude Code's semantics; measure before changing the cell.
 MATRIX: dict[str, dict[str, str]] = {
-    "briefing": {"claude": "hook", "kiro": "agentSpawn hook", "codex": "manual/memory_recall",
+    "briefing": {"claude": "hook",
+                 "kiro": "agentSpawn hook (delivery unverified)",
+                 "codex": "manual/memory_recall",
                  "opencode": "plugin (first event, console log only)",
                  "claude-desktop": "none (MCP only)",
                  "generic": "none (MCP only)"},
@@ -95,7 +130,8 @@ MATRIX: dict[str, dict[str, str]] = {
     # deciding whether opencode support is a wiring job or a protocol limit gets the
     # answer from the cell. For all four non-claude/kiro runtimes the session-start
     # briefing remains the only push.
-    "proactive_recall": {"claude": "per-prompt push", "kiro": "per-prompt push",
+    "proactive_recall": {"claude": "per-prompt push",
+                         "kiro": "per-prompt push (delivery unverified)",
                          "codex": "none (no hooks)", "opencode": "none (no prompt text)",
                          "claude-desktop": "none (no hooks)",
                          "generic": "none (no hooks)"},

{firekeep_client-1.4.2 → firekeep_client-1.5.2}/firekeep_client/decision/server.py

@@ -56,7 +56,23 @@ _DEFAULT_SYNTH_TIMEOUT = 30.0
 _INGEST_TIMEOUT_HEADROOM = 15.0
 # Bounded long-poll ceiling — kept under the MCP tool-call ceiling so a single
 # decision_board / decision_board_check call returns before the runtime times out.
-_DEFAULT_POLL_SECONDS = 24.0
+#
+# This is a TOKEN-COST setting as much as a latency one. Every expiry costs the
+# agent one more model turn, and a model turn re-sends the whole conversation:
+# measured 2026-08-21 across 5 sessions and 13 boards, 197 poll-only turns cost
+# 93.5M raw token units / 9.8M price-weighted — ~49,800 weighted tokens per
+# poll. Raising the ceiling is free when the human is responsive, because the
+# loop below returns the instant an answer lands; it only ever bounds the
+# UNANSWERED case.
+#
+# 50s, not more, because the ceiling has to survive the most constrained host
+# rather than the one we happen to run on. Claude Code resolves a per-call
+# timeout of ~27.8h for STDIO servers (the gateway's path) but 60s for REMOTE
+# HTTP/SSE servers — which is the path deploy/chatgpt-tunnel/ takes. 60s is the
+# tightest ceiling we can actually name, so this sits 10s under it.
+# DECISION_POLL_SECONDS overrides for an operator who knows their host.
+# Guarded by tests/test_decision_poll_ceiling.py.
+_DEFAULT_POLL_SECONDS = 50.0
 # Poll granularity — MUST be a real ``await anyio.sleep`` (never a blocking wait),
 # so the event loop stays responsive.
 _POLL_INTERVAL = 0.5

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

@@ -98,6 +98,60 @@ def _active_toolset() -> tuple[str | None, frozenset[str] | None]:
     return preset, TOOLSET_PRESETS[preset]
 
 
+def _slim_schema(schema: Any) -> Any:
+    """Collapse Pydantic's ``X | None`` rendering into JSON Schema's type array.
+
+    Pydantic emits an optional field as
+    ``{"anyOf": [{"type": "X"}, {"type": "null"}]}`` — 43 characters where
+    ``{"type": ["X", "null"]}`` is 24, for the same meaning. Measured on the
+    live gateway (2026-08-21): 66 such fields across 98 tools. Tool definitions
+    sit in the cached prompt prefix, so on a runtime WITHOUT tool deferral that
+    is bytes re-sent every turn for the life of the session.
+
+    Only the exact two-branch ``[T, null]`` shape collapses, and only into the
+    type-array form. Dropping the null branch outright would be shorter and is
+    deliberately NOT done: it would make an explicit ``null`` invalid where the
+    server accepts it, which is a behaviour change wearing a token saving's
+    clothes. ``tests/test_gateway_schema_slimming.py`` proves the equivalence
+    against a real validator rather than asserting it.
+
+    Never raises. A backend may serve any shape it likes, and a schema this
+    cannot parse must reach the model unmodified rather than take the surface
+    down — the same failure isolation the rest of the gateway is built on.
+    """
+    try:
+        return _slim(schema)
+    except Exception:  # noqa: BLE001 - pass-through beats a broken tool surface
+        return schema
+
+
+def _slim(node: Any) -> Any:
+    if isinstance(node, list):
+        return [_slim(item) for item in node]
+    if not isinstance(node, dict):
+        return node
+
+    branches = node.get("anyOf")
+    if isinstance(branches, list) and len(branches) == 2:
+        nulls = [b for b in branches if b == {"type": "null"}]
+        others = [b for b in branches if isinstance(b, dict) and b != {"type": "null"}]
+        # Exactly one null branch and one non-null branch whose own `type` is a
+        # plain string. Anything richer (a nested anyOf, a branch with no type,
+        # a $ref) is left alone: this collapse is only provably lossless for
+        # the simple shape, and "left alone" costs bytes, not correctness.
+        if len(nulls) == 1 and len(others) == 1 and isinstance(others[0].get("type"), str):
+            collapsed = {k: v for k, v in node.items() if k != "anyOf"}
+            # The branch's own keywords (items, additionalProperties, ...) come
+            # with it; the field's siblings (default, description) stay put.
+            for key, value in others[0].items():
+                if key != "type":
+                    collapsed.setdefault(key, value)
+            collapsed["type"] = [others[0]["type"], "null"]
+            return {k: _slim(v) for k, v in collapsed.items()}
+
+    return {k: _slim(v) for k, v in node.items()}
+
+
 def _console_script(name: str) -> str:
     suffix = ".exe" if os.name == "nt" else ""
     filename = f"{name}{suffix}"
@@ -288,6 +342,11 @@ class Gateway:
                     self.tools_filtered += 1
                     continue
                 self.routes[name] = backend
+                # Slim the ADVERTISED schema only. Routing, calls and the
+                # upstream's own validation are untouched: _slim_schema returns
+                # new objects and the backend's tool dict is left as served.
+                if isinstance(tool.get("inputSchema"), dict):
+                    tool = {**tool, "inputSchema": _slim_schema(tool["inputSchema"])}
                 tools.append(tool)
         return tools
 

{firekeep_client-1.4.2 → firekeep_client-1.5.2}/firekeep_client/hooks/__main__.py

@@ -70,6 +70,71 @@ _CORE_MODULES = {
 _INT_CORES = frozenset({"pre_tool", "post_tool"})
 _DICT_CORES = frozenset({"session_start", "stop", "session_end", "prompt", "precompact"})
 
+# Cores whose text must reach the MODEL, and the Claude Code event name that
+# carries it.
+#
+# `systemMessage` is shown to the human; the channel that reaches the model is
+# `hookSpecificOutput.additionalContext`. Measured 2026-08-21 by comparing every
+# SessionStart hook attachment in one session: the three hooks emitting
+# additionalContext were verbatim in the model's context, the two emitting
+# systemMessage (Firekeep's pre-flight briefing, the symdex banner) were absent.
+# Claude Code's docs say the same thing from the other side — "To surface a
+# message to the user on any platform, return systemMessage", against "for
+# SessionStart and UserPromptSubmit Claude Code adds plain-text stdout as
+# context that Claude can see and act on".
+#
+# The text was always written for the model: the briefing opens "You are
+# agent-...", proactive recall pushes memories for the agent to act on, and the
+# bypass notice says "you should NOT use firekeep_* tools" — an instruction a
+# human reader cannot follow. All of it was landing in the terminal.
+#
+# ONLY these two events. `stop`, `precompact` and `session_end` are absent
+# because nobody has verified those events accept model-facing context, and
+# emitting a plausible-looking shape at an event that ignores it would leave the
+# text exactly where it started while looking fixed — which is how this bug
+# happened the first time.
+_MODEL_CONTEXT_EVENTS = {
+    "session_start": "SessionStart",
+    "prompt": "UserPromptSubmit",
+}
+
+# ONLY the runtime whose channel has actually been measured. kiro, opencode and
+# the rest use different mechanisms; handing them a Claude Code-shaped payload
+# would be the same guess in a new place. An OLD rendered hook command carries
+# no `--runtime` at all and must keep working unchanged.
+_MODEL_CONTEXT_RUNTIMES = frozenset({"claude"})
+
+
+def _with_model_context(result: dict, core_name: str, runtime: str | None) -> dict:
+    """Add the model-facing channel alongside the human-facing one.
+
+    Dual channel on purpose: only `additionalContext` enters the context window,
+    so keeping `systemMessage` costs no model tokens and is what lets the human
+    see what their agent was just handed.
+
+    Never raises — a hook that cannot decorate its output must still emit it.
+    """
+    try:
+        event = _MODEL_CONTEXT_EVENTS.get(core_name)
+        if not event or runtime not in _MODEL_CONTEXT_RUNTIMES:
+            return result
+        if not isinstance(result, dict) or result.get("hookSpecificOutput"):
+            return result
+        text = result.get("systemMessage")
+        # Only promote text destined for a reader. A core returning control
+        # fields (decision/reason) is not describing something to inject.
+        if not isinstance(text, str) or not text.strip():
+            return result
+        return {
+            **result,
+            "hookSpecificOutput": {
+                "hookEventName": event,
+                "additionalContext": text,
+            },
+        }
+    except Exception:  # noqa: BLE001 — decoration must never break a hook
+        return result
+
 # Cores that must run even while personal mode is ON, because they self-handle
 # bypass and own end-of-session cleanup: `stop` clears the personal marker
 # itself, and `session_end` must be free to decline comms without the dispatcher
@@ -191,6 +256,7 @@ def main(argv: list[str] | None = None) -> int:
     # the resolver seam carries the X-Firekeep-* attribution headers
     # (resolver._runtime_attribution). Best-effort — attribution must never be
     # able to break a hook.
+    runtime: str | None = None
     try:
         runtime = _parse_runtime(argv[1:])
         if runtime:
@@ -198,6 +264,16 @@ def main(argv: list[str] | None = None) -> int:
     except Exception as e:  # noqa: BLE001
         hooklog.log_failure(core_name, f"runtime flag parse failed: {e!r}")
 
+    def _emit(result: dict) -> None:
+        """The ONE place a dict core's output reaches stdout.
+
+        Routed through _with_model_context so every message a core produces —
+        briefing, recall push, personal-mode notice, migration refusal — takes
+        the same channel decision. Four separate print sites is how one of them
+        silently keeps the old behaviour.
+        """
+        print(json.dumps(_with_model_context(result, core_name, runtime)))
+
     # `/personal` as chat text: intercepted BEFORE the bypass gate below — while
     # personal mode is ON the prompt core is short-circuited, so an in-core
     # intercept could never toggle OFF again.
@@ -206,7 +282,7 @@ def main(argv: list[str] | None = None) -> int:
         payload = _read_payload(core_name)
         personal_msg = _personal_text_command(payload)
         if personal_msg is not None:
-            print(json.dumps({"systemMessage": personal_msg}))
+            _emit({"systemMessage": personal_msg})
             return 0
 
     # Personal / bypass mode: Firekeep goes dormant for this session. Checked LIVE
@@ -219,7 +295,7 @@ def main(argv: list[str] | None = None) -> int:
         if core_name not in _BYPASS_EXEMPT and resolver.is_bypassed():
             if core_name in _INT_CORES:
                 return 0  # allow the edit; no policy/gateway call reaches the server
-            print(json.dumps({"systemMessage": _BYPASS_MSG}))  # session_start / prompt
+            _emit({"systemMessage": _BYPASS_MSG})  # session_start / prompt
             return 0
     except Exception as e:  # noqa: BLE001 — a gate failure must never break the session
         hooklog.log_failure(core_name, f"bypass check failed: {e!r}")
@@ -238,11 +314,11 @@ def main(argv: list[str] | None = None) -> int:
 
         # dict core (session_start/stop/prompt).
         if result:
-            print(json.dumps(result))
+            _emit(result)
         return 0
     except resolver.ConfigMigrationConflict as e:
         hooklog.log_failure(core_name, f"config migration refused: {e}")
-        print(json.dumps({"systemMessage": str(e)}))
+        _emit({"systemMessage": str(e)})
         return 0
     except Exception as e:  # noqa: BLE001 — the dispatcher itself must never raise.
         hooklog.log_failure(core_name, f"dispatcher crashed: {e!r}")

{firekeep_client-1.4.2 → firekeep_client-1.5.2}/firekeep_client/hooks/prompt.py

@@ -57,7 +57,13 @@ def _dedup_lines(items: list[str]) -> list[str]:
 
 
 def _task_line(task: dict) -> str:
-    title = str(task.get("title") or task.get("description") or task.get("id") or "task")
+    # The title is server-supplied free text with no length contract, so it is
+    # trimmed to promptrecall's shared line budget. The id and creator stay
+    # OUTSIDE the trim: a title over 200 chars is already a description, and the
+    # id is how the agent asks relay_task_list for the rest. Pointer, not payload.
+    title = promptrecall.trim_line(
+        task.get("title") or task.get("description") or task.get("id") or "task"
+    )
     tid = str(task.get("id") or "")
     creator = str(task.get("creator") or task.get("created_by") or "")
     line = f"- {title}"
@@ -122,7 +128,8 @@ def run(payload: dict) -> dict:
             if ts <= last_seen or str(m.get("sender") or "") == agent:
                 continue
             sender = str(m.get("sender") or "?")
-            content = " ".join(str(m.get("content") or "").split())
+            # Same contract as _task_line: trim the body, keep the sender.
+            content = promptrecall.trim_line(m.get("content"))
             fresh.append(f"- {content} — {sender}")
         if newest > last_seen:
             state.write_scratch(seen_key, repr(newest))

{firekeep_client-1.4.2 → firekeep_client-1.5.2}/firekeep_client/promptrecall.py

@@ -181,15 +181,32 @@ def _source_id(source: dict) -> str:
     return "sha:" + hashlib.sha256(text.encode("utf-8", "replace")).hexdigest()[:16]
 
 
+def trim_line(text: object) -> str:
+    """Collapse whitespace and cap at MAX_LINE_CHARS with a visible ellipsis.
+
+    Exported because the prompt hook's two older neighbours — relay task titles
+    and channel message bodies — render server-supplied strings into the SAME
+    systemMessage and had no cap at all: a hostile fixture drove that hook to
+    28,418 characters from one task and one message (measured 2026-08-21). They
+    share this function rather than re-declaring 200, so the budget stays one
+    number in one place.
+
+    Callers keep identifiers (task id, sender) OUTSIDE the trim: the point is to
+    hand over a pointer, not to lose the handle that fetches the full text.
+    """
+    if not isinstance(text, str):
+        return ""
+    collapsed = " ".join(text.split())
+    if len(collapsed) > MAX_LINE_CHARS:
+        return collapsed[:MAX_LINE_CHARS - 3] + "..."
+    return collapsed
+
+
 def _line(source: dict, score: float) -> str:
     """One collapsed, trimmed line. The score shown is the one that was actually
     thresholded (`_relevance`), never the normalized rank — a displayed number the
     filter did not use would misdescribe why the memory is on screen."""
-    content = source.get("content")
-    text = " ".join(content.split()) if isinstance(content, str) else ""
-    if len(text) > MAX_LINE_CHARS:
-        text = text[:MAX_LINE_CHARS - 3] + "..."
-    return f"- {text} (score {score:.2f})"
+    return f"- {trim_line(source.get('content'))} (score {score:.2f})"
 
 
 def select(sources, *, seen, floor: float) -> list[tuple[str, str]]:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: firekeep-client
-Version: 1.4.2
+Version: 1.5.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

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

@@ -80,6 +80,7 @@ tests/test_cli_dex.py
 tests/test_cli_docdex.py
 tests/test_cli_doctor.py
 tests/test_cli_doctor_generic.py
+tests/test_cli_doctor_report.py
 tests/test_cli_entry.py
 tests/test_cli_generic_install.py
 tests/test_cli_install.py
@@ -93,6 +94,7 @@ tests/test_config_migration.py
 tests/test_connect.py
 tests/test_decision_board_html.py
 tests/test_decision_bypass.py
+tests/test_decision_poll_ceiling.py
 tests/test_decision_registration.py
 tests/test_decision_server.py
 tests/test_dexes.py
@@ -103,12 +105,15 @@ tests/test_doctor_embeddings.py
 tests/test_doctor_no_server.py
 tests/test_e2e_bootstrap.py
 tests/test_gateway.py
+tests/test_gateway_schema_slimming.py
 tests/test_gateway_toolset.py
 tests/test_generic_config.py
 tests/test_hooklog.py
 tests/test_import_boundary.py
 tests/test_init_self_enroll.py
 tests/test_init_stale_bundle.py
+tests/test_install_skill_contract.py
+tests/test_instruction_budget.py
 tests/test_join.py
 tests/test_join_config_write.py
 tests/test_joincode.py

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

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