smartmemory 1.4.0__tar.gz → 1.4.3__tar.gz

{smartmemory-1.4.0 → smartmemory-1.4.3}/CHANGELOG.md

@@ -1,5 +1,52 @@
 # Changelog — smartmemory
 
+## [Unreleased]
+
+### Fixed (MCP `memory_search` broken in local mode, 2026-05-18)
+
+- **MCP `memory_search` completely broken in local mode.** `storage.search()` only accepted `(query, top_k, filters, include_reference)`. The MCP server calls it with `memory_type`, `enable_hybrid`, `decompose_query`, `multi_hop`, `max_hops`, and `budget_ms` — any of those raised `TypeError: search() got an unexpected keyword argument`. Every `memory_search` call in local mode crashed. `storage.search` now accepts `memory_type` (forwarded as a post-filter) and `**search_kwargs` (allowlisted to `decompose_query`, `channel_weights`, `multi_hop`, `max_hops`, `budget_ms`, `semantic_hops`); unknown keys such as `enable_hybrid` are silently dropped instead of raising. Regression test added (`test_search_accepts_mcp_recall_kwargs`).
+
+### Fixed (DEMO-WALKTHROUGH-1, `smartmemory search` CLI, 2026-05-17)
+
+- **`smartmemory search` no longer crashes with `AttributeError: 'str' object has no attribute 'get'`.** The daemon `/memory/search` returns the CORE-CRUD-LIST contract shape `{"items": [...]}`, but `cli.py search_cmd` iterated the dict directly — so `for r in results` yielded the key string `"items"` and `r.get("content")` threw. Now unwraps `results["items"]` (daemon) vs bare list (storage fallback), with a defensive non-dict skip. Regression test added (`test_search_cmd_daemon_items_contract`); fixed two stale `assert_called_once_with` expectations that predated the `include_reference` fallback kwarg.
+
+## [1.4.3] - 2026-05-17
+
+### Changed (lockstep relock — ships the competitive-response sprint)
+
+- **Pinned `smartmemory-core[lite]==0.9.8`** (was `==0.9.1`, 7 versions stale despite the "move in lockstep" comment). The wrapper now actually pulls the shipped sprint core: CORE-BITEMPORAL-1 transaction-time activation, CORE-ATTENTION-FUSION-1 Phase 1, APP-VAULT-SYNC-1 Phase 0, RECALL-CITATIONS-1. Without this, `pip install smartmemory` resolved core 0.9.1 — none of the differentiator. Supersedes the never-published 1.4.2 (committed but no Release was cut; wrapper publishes only on GitHub Release / workflow_dispatch).
+
+### Fixed (DEMO-WALKTHROUGH-1, lite-mode graph viewer SSE, 2026-05-17)
+
+- **Lite daemon now serves `GET /memory/progress/stream` (SSE).** `smart-memory-graph`'s `useGraphStream` migrated WS→SSE; the lite daemon only exposed the legacy `sm.v1` WebSocket on `:9015`, so the local graph viewer never connected ("Not connected to event stream", 0 nodes).
+  - `smartmemory_app/events_server.py`: SSE subscriber registry + `_to_progress_event()` reshaping raw sink items into ProgressEvent contract frames (`kind: graph.node|graph.edge`) + `_fanout_sse()` at the **single** existing `sink._q` drain point. The `ws://:9015` broadcast is byte-for-byte unchanged (SSE is an additional broadcast target, not a second queue consumer — preserves existing WS clients incl. the recorder). Cross-loop hand-off via `call_soon_threadsafe` (same bridge as `InProcessQueueSink.emit`).
+  - `smartmemory_app/local_api.py`: `GET /memory/progress/stream` `StreamingResponse` (per-connection queue, 15s keepalive, disconnect cleanup), declared before `/{memory_id}` routes.
+  - Verified: one ingest yields 6 `graph.node` + 10 `graph.edge` contract frames with `payload.data.memory_id`+`label`; legacy WS path unaffected.
+- **Events server port now tracks the API port.** `smartmemory_app/viewer_server.py` starts the events WS on `port + 1` instead of a hardcoded `9015`. Default `9014 → 9015` is unchanged; a non-default daemon (e.g. an isolated demo on `9114`) now gets its own events server (`9115`) instead of colliding with the dev daemon's `:9015`. Enables running an isolated demo daemon alongside the launchd dev daemon.
+
+### Added (LAUNCH-METRICS-1, Wave 2 Stream I, 2026-05-10)
+
+- **`smartmemory_app.launch_metrics`** module — best-effort `emit(event_type, props)` POSTing to the daemon HTTP API at `/launch/event`. Honors `SMARTMEMORY_DISABLE_LAUNCH_METRICS=1` opt-out. Failures log WARNING; never raises into a CLI command path.
+- Funnel emission wired into the three Stream A entry points:
+  - `sm setup` / `sm init` -> `setup.complete` with `{mode: local|remote}`
+  - `sm code index` -> `index.start` and `index.complete` with `{repo, files, entities, edges, elapsed_s}`
+  - `sm mcp install <client>` -> `mcp.install` with `{client, dry_run}`
+- **Daemon-side ingest** at `POST /launch/event` in `local_api.py`. Local mode appends to `launch_events.jsonl` in the data dir.
+
+Contract: `smart-memory-docs/docs/features/LAUNCH-METRICS-1/launch-event-contract.json`.
+
+## [1.4.2] — 2026-05-10
+
+### Added (Launch Sprint Wave 1, Stream A)
+
+- **`sm init`** — alias for `sm setup`. Same Click command registered under a second name; option/flag parity is automatic.
+- **`sm code index <path>`** — wraps `SmartMemory.ingest_code()` from the core library to index Python (and optionally TypeScript) repos into the local knowledge graph. Streams structured progress to stdout (`[code:index] phase=start|done …`). Default exclusions cover `node_modules`, virtualenvs, build artifacts, and VCS dirs. Every entity is tagged with `origin = code:index` (Tier 1 user content per `smartmemory/origin_policy.py`) — set by the indexer itself, not the wrapper. Flags: `--repo`, `--language` (repeatable, `python|typescript`), `--exclude` (repeatable), `--commit-hash`.
+- **`sm mcp install <client>`** — writes MCP config for `claude-code` (→ `~/.claude.json`), `cursor` (→ `~/.cursor/mcp.json`), or `codex` (→ `~/.codex/config.toml`). Pointer-only wrapper around the already-shipped `smartmemory-mcp` PyPI package — no new server logic. Flags: `--dry-run` prints the would-be config without touching disk; `--path` overrides the destination. Existing config files are merged (JSON) or section-replaced (TOML); malformed configs raise loudly rather than being clobbered.
+
+### Changed (CORE-EXPERTISE-1 Phase 4b, 2026-05-08)
+
+- **README "Memory Types" listing extended** with `Constraint Memory` and `Learned Memory` entries plus a new "Expertise vs knowledge" callout that explains the knowledge / expertise cohort split, points to the canonical 1-pager at `docs.smartmemory.ai/smartmemory/concepts/expertise-vs-knowledge`, and surfaces `mem.search(query, expertise=True)` for partitioned recall. No code change.
+
 ## [1.1.5] — 2026-03-24
 
 ### Fixed
@@ -14,6 +61,12 @@
 
 ## [Unreleased]
 
+## [1.4.1] — 2026-05-07
+
+### Changed
+
+- **Track core 0.9.1.** Pin updated from `smartmemory-core[lite]==0.9.0` to `==0.9.1`. Wrapper itself unchanged; bump pairs with the core release that lands the bounded `EventStream.read_recent(count)` API plus `read_all` deprecation (INSIGHTS-PROGRESS-MIGRATE-1 prep), CORE-EXPERTISE-1 Phase 1 (Decision schema extension), and ONTO-READER-MIGRATE-1 (`OntologyGraph` `:EntityType` → `:OntologyType` reader migration). Per `feedback_bump_wrapper_with_core` policy.
+
 ## [1.4.0] — 2026-05-04
 
 ### Changed

{smartmemory-1.4.0 → smartmemory-1.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smartmemory
-Version: 1.4.0
+Version: 1.4.3
 License-File: LICENSE
 License-File: LICENSE.agpl-v3
 License-File: LICENSE.header
@@ -10,7 +10,7 @@ Requires-Dist: fastapi>=0.110
 Requires-Dist: filelock>=3.12
 Requires-Dist: httpx>=0.27
 Requires-Dist: keyring>=24.0
-Requires-Dist: smartmemory-core[lite]==0.9.0
+Requires-Dist: smartmemory-core[lite]==0.9.8
 Requires-Dist: smartmemory-mcp>=0.2.0
 Requires-Dist: textual>=8.0
 Requires-Dist: tomli-w>=1.0

{smartmemory-1.4.0 → smartmemory-1.4.3}/README.md

@@ -162,7 +162,11 @@ SmartMemory implements a multi-layered memory architecture:
 - **Reasoning Memory**: Chain-of-thought traces capturing "why" decisions were made (System 2)
 - **Opinion Memory**: Beliefs with confidence scores, reinforced or contradicted over time
 - **Observation Memory**: Synthesized entity summaries from scattered facts
-- **Decision Memory**: First-class decisions with confidence tracking, provenance chains, and lifecycle management
+- **Decision Memory**: First-class decisions with confidence tracking, provenance chains, and lifecycle management. Now structured: `rejected_alternatives`, `rationale`, `constraints`. Capture: `mem.add_decision(...)`.
+- **Constraint Memory**: Hard rules — discovered or imposed. Capture: `mem.add_constraint(...)`.
+- **Learned Memory**: Lessons learned the hard way. Capture: `mem.add_learning(...)`.
+
+> **Expertise vs knowledge.** The five core types above (Pending/Semantic/Episodic/Procedural/Zettelkasten) plus Reasoning are best read as the **knowledge layer** — what's *true*. Decision/Constraint/Learned/Opinion/Observation form the **expertise layer** — what to *do*, and what *not* to do. The expertise layer is what makes an agent's memory useful for *acting*: captured choices, rejected alternatives, hard constraints, lessons learned. Recall partitioned by expertise type via `mem.search(query, expertise=True)`. See [Expertise vs Knowledge](https://docs.smartmemory.ai/smartmemory/concepts/expertise-vs-knowledge) for the full mapping.
 
 ### Storage Backends
 

{smartmemory-1.4.0 → smartmemory-1.4.3}/pyproject.toml

@@ -4,10 +4,10 @@ build-backend = "hatchling.build"
 
 [project]
 name = "smartmemory"
-version = "1.4.0"
+version = "1.4.3"
 requires-python = ">=3.11"
 dependencies = [
-    "smartmemory-core[lite]==0.9.0",   # EXACT pin — wrapper and core versions move in lockstep
+    "smartmemory-core[lite]==0.9.8",   # EXACT pin — wrapper and core versions move in lockstep
     "filelock>=3.12",                    # cross-process SQLite write locking
     "smartmemory-mcp>=0.2.0",          # unified MCP server (PLAT-MCP-UNIFY-1)
     "httpx>=0.27",             # remote API calls (DIST-LITE-5)

{smartmemory-1.4.0 → smartmemory-1.4.3}/smartmemory_app/cli.py

@@ -18,7 +18,11 @@ def _parse_extra_props(args: list[str]) -> dict[str, str]:
     props = {}
     i = 0
     while i < len(args):
-        if args[i].startswith("--") and i + 1 < len(args) and not args[i + 1].startswith("--"):
+        if (
+            args[i].startswith("--")
+            and i + 1 < len(args)
+            and not args[i + 1].startswith("--")
+        ):
             props[args[i][2:]] = args[i + 1]
             i += 2
         else:
@@ -44,7 +48,9 @@ def _daemon_request(method: str, path: str, timeout: int = 120, **kwargs):
 
     for attempt in range(2):
         try:
-            r = httpx.request(method, f"{_daemon_url()}{path}", timeout=timeout, **kwargs)
+            r = httpx.request(
+                method, f"{_daemon_url()}{path}", timeout=timeout, **kwargs
+            )
             r.raise_for_status()
             return r.json() if r.status_code != 204 else {}
         except (httpx.ConnectError, httpx.ConnectTimeout, httpx.RemoteProtocolError):
@@ -72,14 +78,29 @@ def cli() -> None:
 from smartmemory_app.setup import setup as _setup_cmd, uninstall as _uninstall_cmd  # noqa: E402
 
 cli.add_command(_setup_cmd, name="setup")
+# `sm init` — alias for `sm setup`. Same Click command registered under a
+# second name so option/flag parity is automatic.
+cli.add_command(_setup_cmd, name="init")
 cli.add_command(_uninstall_cmd, name="uninstall")
 
+# `sm code …` and `sm mcp …` subgroups
+from smartmemory_app.cli_code import code_group as _code_group  # noqa: E402
+from smartmemory_app.cli_mcp import mcp_group as _mcp_group  # noqa: E402
+
+cli.add_command(_code_group, name="code")
+cli.add_command(_mcp_group, name="mcp")
+
 
 # ── Daemon lifecycle ────────────────────────────────────────────────────────
 
 
 @cli.command("start")
-@click.option("--num-workers", default=1, show_default=True, help="Number of enrichment worker processes.")
+@click.option(
+    "--num-workers",
+    default=1,
+    show_default=True,
+    help="Number of enrichment worker processes.",
+)
 def start_cmd(num_workers: int) -> None:
     """Start the SmartMemory daemon and enrichment workers."""
     from smartmemory_app.daemon import start_daemon, is_running
@@ -109,7 +130,12 @@ def stop_cmd() -> None:
 
 
 @cli.command("restart")
-@click.option("--num-workers", default=1, show_default=True, help="Number of enrichment worker processes.")
+@click.option(
+    "--num-workers",
+    default=1,
+    show_default=True,
+    help="Number of enrichment worker processes.",
+)
 def restart_cmd(num_workers: int) -> None:
     """Restart the SmartMemory daemon and enrichment workers."""
     from smartmemory_app.daemon import stop_daemon, start_daemon, is_running
@@ -162,7 +188,9 @@ def viewer_cmd(port: int | None) -> None:
 
 
 @cli.command("worker")
-@click.option("--loop", is_flag=True, help="Poll continuously instead of drain-and-exit.")
+@click.option(
+    "--loop", is_flag=True, help="Poll continuously instead of drain-and-exit."
+)
 def worker_cmd(loop: bool) -> None:
     """Run the enrichment worker (Tier 2 LLM extraction).
 
@@ -180,8 +208,15 @@ def worker_cmd(loop: bool) -> None:
 # ── Memory operations ───────────────────────────────────────────────────────
 
 _VALID_MEMORY_TYPES = {
-    "pending", "semantic", "episodic", "procedural", "zettel",
-    "reasoning", "opinion", "observation", "decision",
+    "pending",
+    "semantic",
+    "episodic",
+    "procedural",
+    "zettel",
+    "reasoning",
+    "opinion",
+    "observation",
+    "decision",
 }
 
 
@@ -194,12 +229,27 @@ def _validate_memory_type(ctx, param, value: str) -> str:
     return value
 
 
-@cli.command("add", context_settings=dict(
-    ignore_unknown_options=True, allow_extra_args=True,
-))
+@cli.command(
+    "add",
+    context_settings=dict(
+        ignore_unknown_options=True,
+        allow_extra_args=True,
+    ),
+)
 @click.argument("text", default="-")
-@click.option("--type", "memory_type", default="episodic", show_default=True, callback=_validate_memory_type)
-@click.option("--all", "as_whole", is_flag=True, help="Add stdin as one memory instead of line-by-line.")
+@click.option(
+    "--type",
+    "memory_type",
+    default="episodic",
+    show_default=True,
+    callback=_validate_memory_type,
+)
+@click.option(
+    "--all",
+    "as_whole",
+    is_flag=True,
+    help="Add stdin as one memory instead of line-by-line.",
+)
 @click.pass_context
 def add_cmd(ctx, text: str, memory_type: str, as_whole: bool) -> None:
     """Add text as a memory. Use - or pipe stdin to read from a file.
@@ -219,11 +269,17 @@ def add_cmd(ctx, text: str, memory_type: str, as_whole: bool) -> None:
 
     if text == "-":
         if sys.stdin.isatty():
-            raise click.ClickException("No input. Pipe text or use: smartmemory add \"text\"")
+            raise click.ClickException(
+                'No input. Pipe text or use: smartmemory add "text"'
+            )
         raw = sys.stdin.read()
         if not raw.strip():
             raise click.ClickException("Content cannot be empty.")
-        chunks = [raw.strip()] if as_whole else [l.strip() for l in raw.splitlines() if l.strip()]
+        chunks = (
+            [raw.strip()]
+            if as_whole
+            else [l.strip() for l in raw.splitlines() if l.strip()]
+        )
         if not chunks:
             raise click.ClickException("Content cannot be empty.")
         props = _parse_extra_props(ctx.args)
@@ -261,14 +317,27 @@ def add_cmd(ctx, text: str, memory_type: str, as_whole: bool) -> None:
 @cli.command("recall")
 @click.option("--cwd", default=None, help="Current working directory for context.")
 @click.option("--top-k", default=10, show_default=True)
-@click.option("--query", default=None, help="Optional prompt query (UserPromptSubmit hook).")
-@click.option("--workspace", "workspace_id", default=None, help="Workspace ID override.")
-@click.option("--strict/--no-strict", default=False,
-              help="Drop legacy items without workspace_id (kills cross-workspace leak).")
-@click.option("--no-snapshot", "no_snapshot", is_flag=True, default=False,
-              help="Skip snapshot frame.")
-def recall_cmd(cwd: str, top_k: int, query: str, workspace_id: str,
-               strict: bool, no_snapshot: bool) -> None:
+@click.option(
+    "--query", default=None, help="Optional prompt query (UserPromptSubmit hook)."
+)
+@click.option(
+    "--workspace", "workspace_id", default=None, help="Workspace ID override."
+)
+@click.option(
+    "--strict/--no-strict",
+    default=False,
+    help="Drop legacy items without workspace_id (kills cross-workspace leak).",
+)
+@click.option(
+    "--no-snapshot",
+    "no_snapshot",
+    is_flag=True,
+    default=False,
+    help="Skip snapshot frame.",
+)
+def recall_cmd(
+    cwd: str, top_k: int, query: str, workspace_id: str, strict: bool, no_snapshot: bool
+) -> None:
     """Recall memories (SessionStart / UserPromptSubmit hook)."""
     params = {
         "cwd": cwd or "",
@@ -285,24 +354,42 @@ def recall_cmd(cwd: str, top_k: int, query: str, workspace_id: str,
         from smartmemory_app.storage import recall
 
         context = recall(
-            cwd, top_k,
-            query=query, workspace_id=workspace_id,
-            include_snapshot=not no_snapshot, strict=strict,
+            cwd,
+            top_k,
+            query=query,
+            workspace_id=workspace_id,
+            include_snapshot=not no_snapshot,
+            strict=strict,
         )
     if context:
         click.echo(context)
 
 
 @cli.command("retag")
-@click.option("--content", "content_substring", required=True,
-              help="Substring to match in item content (case-insensitive).")
-@click.option("--origin", "new_origin", required=True,
-              help='New origin value, e.g. "seed:demo" (tier 4, hidden from recall).')
-@click.option("--dry-run", is_flag=True, default=False,
-              help="Show items that would be retagged without modifying.")
-@click.option("--limit", default=100, show_default=True,
-              help="Max items to retag in one run.")
-def retag_cmd(content_substring: str, new_origin: str, dry_run: bool, limit: int) -> None:
+@click.option(
+    "--content",
+    "content_substring",
+    required=True,
+    help="Substring to match in item content (case-insensitive).",
+)
+@click.option(
+    "--origin",
+    "new_origin",
+    required=True,
+    help='New origin value, e.g. "seed:demo" (tier 4, hidden from recall).',
+)
+@click.option(
+    "--dry-run",
+    is_flag=True,
+    default=False,
+    help="Show items that would be retagged without modifying.",
+)
+@click.option(
+    "--limit", default=100, show_default=True, help="Max items to retag in one run."
+)
+def retag_cmd(
+    content_substring: str, new_origin: str, dry_run: bool, limit: int
+) -> None:
     """Retag items by content match (HOOK-RECALL-RELEVANCE-1 G3.C).
 
     Use to clean up legacy seed/fixture data that leaks into recall:
@@ -327,7 +414,11 @@ def retag_cmd(content_substring: str, new_origin: str, dry_run: bool, limit: int
         # Content lives in `properties.content` for SQLite/FalkorDB serialize shape;
         # fall back to top-level `content` for forward-compat.
         props = raw.get("properties") or {}
-        content = (props.get("content") if isinstance(props, dict) else None) or raw.get("content") or ""
+        content = (
+            (props.get("content") if isinstance(props, dict) else None)
+            or raw.get("content")
+            or ""
+        )
         if needle not in content.lower():
             continue
         item_id = raw.get("item_id") or raw.get("id")
@@ -358,12 +449,21 @@ def retag_cmd(content_substring: str, new_origin: str, dry_run: bool, limit: int
     click.echo(f"Retagged {updated}/{len(matched)} items with origin={new_origin!r}.")
 
 
-@cli.command("search", context_settings=dict(
-    ignore_unknown_options=True, allow_extra_args=True,
-))
+@cli.command(
+    "search",
+    context_settings=dict(
+        ignore_unknown_options=True,
+        allow_extra_args=True,
+    ),
+)
 @click.argument("query")
 @click.option("--top-k", default=5, show_default=True)
-@click.option("--include-reference", is_flag=True, default=False, help="Include reference data in results")
+@click.option(
+    "--include-reference",
+    is_flag=True,
+    default=False,
+    help="Include reference data in results",
+)
 @click.pass_context
 def search_cmd(ctx, query: str, top_k: int, include_reference: bool) -> None:
     """Search memories by semantic similarity. Use '*' to list all.
@@ -381,13 +481,23 @@ def search_cmd(ctx, query: str, top_k: int, include_reference: bool) -> None:
         from smartmemory_app.storage import search
 
         try:
-            results = search(query, top_k, filters=props, include_reference=include_reference)
+            results = search(
+                query, top_k, filters=props, include_reference=include_reference
+            )
         except NotImplementedError as e:
             raise click.ClickException(str(e))
+    # The daemon returns the CORE-CRUD-LIST contract shape {"items": [...]};
+    # the storage fallback returns a bare list. Unwrap so we always iterate
+    # result dicts (iterating the dict directly yielded its keys -> "items"
+    # string -> AttributeError: 'str' object has no attribute 'get').
+    if isinstance(results, dict):
+        results = results.get("items", [])
     if not results:
         click.echo("No results.")
         return
     for r in results:
+        if not isinstance(r, dict):
+            continue
         content = r.get("content", "")[:200]
         mem_type = r.get("memory_type", "?")
         item_id = r.get("item_id", "?")
@@ -434,6 +544,7 @@ def lifecycle_group() -> None:
 def lifecycle_orient() -> None:
     """Orient phase: recall context at session start."""
     import sys
+
     body = json.loads(sys.stdin.read()) if not sys.stdin.isatty() else {}
     session_id = body.get("session_id", "unknown")
     cwd = body.get("cwd")
@@ -441,7 +552,9 @@ def lifecycle_orient() -> None:
     from smartmemory_app.lifecycle import MemoryLifecycle
     from smartmemory_app.lifecycle_config import LifecycleConfig
 
-    lc = MemoryLifecycle(session_id, LifecycleConfig.from_config(_load_lifecycle_toml()))
+    lc = MemoryLifecycle(
+        session_id, LifecycleConfig.from_config(_load_lifecycle_toml())
+    )
     result = lc.orient(cwd=cwd)
     if result:
         click.echo(result)
@@ -451,6 +564,7 @@ def lifecycle_orient() -> None:
 def lifecycle_recall() -> None:
     """Recall phase: inject prompt-relevant context."""
     import sys
+
     body = json.loads(sys.stdin.read()) if not sys.stdin.isatty() else {}
     session_id = body.get("session_id", "unknown")
     prompt = body.get("prompt", "")
@@ -458,7 +572,9 @@ def lifecycle_recall() -> None:
     from smartmemory_app.lifecycle import MemoryLifecycle
     from smartmemory_app.lifecycle_config import LifecycleConfig
 
-    lc = MemoryLifecycle(session_id, LifecycleConfig.from_config(_load_lifecycle_toml()))
+    lc = MemoryLifecycle(
+        session_id, LifecycleConfig.from_config(_load_lifecycle_toml())
+    )
     result = lc.recall(prompt)
     if result:
         click.echo(result)
@@ -468,13 +584,16 @@ def lifecycle_recall() -> None:
 def lifecycle_observe() -> None:
     """Observe phase: capture tool call."""
     import sys
+
     body = json.loads(sys.stdin.read()) if not sys.stdin.isatty() else {}
     session_id = body.get("session_id", "unknown")
 
     from smartmemory_app.lifecycle import MemoryLifecycle
     from smartmemory_app.lifecycle_config import LifecycleConfig
 
-    lc = MemoryLifecycle(session_id, LifecycleConfig.from_config(_load_lifecycle_toml()))
+    lc = MemoryLifecycle(
+        session_id, LifecycleConfig.from_config(_load_lifecycle_toml())
+    )
     lc.observe(
         tool_name=body.get("tool_name", "unknown"),
         tool_input=body.get("tool_input", {}),
@@ -486,13 +605,16 @@ def lifecycle_observe() -> None:
 def lifecycle_distill() -> None:
     """Distill phase: pair response with stored prompt."""
     import sys
+
     body = json.loads(sys.stdin.read()) if not sys.stdin.isatty() else {}
     session_id = body.get("session_id", "unknown")
 
     from smartmemory_app.lifecycle import MemoryLifecycle
     from smartmemory_app.lifecycle_config import LifecycleConfig
 
-    lc = MemoryLifecycle(session_id, LifecycleConfig.from_config(_load_lifecycle_toml()))
+    lc = MemoryLifecycle(
+        session_id, LifecycleConfig.from_config(_load_lifecycle_toml())
+    )
     lc.distill(response=body.get("last_assistant_message", ""))
 
 
@@ -500,13 +622,16 @@ def lifecycle_distill() -> None:
 def lifecycle_learn() -> None:
     """Learn phase: capture error pattern."""
     import sys
+
     body = json.loads(sys.stdin.read()) if not sys.stdin.isatty() else {}
     session_id = body.get("session_id", "unknown")
 
     from smartmemory_app.lifecycle import MemoryLifecycle
     from smartmemory_app.lifecycle_config import LifecycleConfig
 
-    lc = MemoryLifecycle(session_id, LifecycleConfig.from_config(_load_lifecycle_toml()))
+    lc = MemoryLifecycle(
+        session_id, LifecycleConfig.from_config(_load_lifecycle_toml())
+    )
     lc.learn(
         tool_name=body.get("tool_name", "unknown"),
         error=body.get("error", body.get("tool_response", "")),
@@ -517,13 +642,16 @@ def lifecycle_learn() -> None:
 def lifecycle_persist() -> None:
     """Persist phase: save session summary."""
     import sys
+
     body = json.loads(sys.stdin.read()) if not sys.stdin.isatty() else {}
     session_id = body.get("session_id", "unknown")
 
     from smartmemory_app.lifecycle import MemoryLifecycle
     from smartmemory_app.lifecycle_config import LifecycleConfig
 
-    lc = MemoryLifecycle(session_id, LifecycleConfig.from_config(_load_lifecycle_toml()))
+    lc = MemoryLifecycle(
+        session_id, LifecycleConfig.from_config(_load_lifecycle_toml())
+    )
     lc.persist()
 
 
@@ -531,12 +659,15 @@ def lifecycle_persist() -> None:
 def lifecycle_status() -> None:
     """Show lifecycle configuration and session stats."""
     from smartmemory_app.lifecycle_config import LifecycleConfig
+
     cfg = LifecycleConfig.from_config(_load_lifecycle_toml())
     click.echo(f"Lifecycle enabled: {cfg.enabled}")
     click.echo(f"Recall strategy: {cfg.recall_strategy.value}")
     click.echo(f"Orient budget: {cfg.orient_budget} tokens")
     click.echo(f"Recall budget: {cfg.recall_budget} tokens")
-    click.echo(f"Observe: {cfg.observe_tool_calls}, Distill: {cfg.distill_turns}, Learn: {cfg.learn_from_errors}")
+    click.echo(
+        f"Observe: {cfg.observe_tool_calls}, Distill: {cfg.distill_turns}, Learn: {cfg.learn_from_errors}"
+    )
 
 
 def _load_lifecycle_toml() -> dict:
@@ -544,6 +675,7 @@ def _load_lifecycle_toml() -> dict:
     try:
         import tomllib
         from smartmemory_app.config import config_path
+
         path = config_path()
         if path.exists():
             with open(path, "rb") as f:
@@ -684,8 +816,10 @@ def config_cmd(key: str | None, value: str | None) -> None:
 
     if key is None:
         from smartmemory_app import __version__ as wrapper_version
+
         try:
             from importlib.metadata import version as _pkg_version
+
             core_version = _pkg_version("smartmemory-core")
         except Exception:
             core_version = "?"
@@ -1183,7 +1317,9 @@ def reextract_cmd() -> None:
 @cli.command("server", hidden=True)
 def server_cmd() -> None:
     """Start the SmartMemory MCP server (called by MCP clients, not users)."""
-    click.echo("MCP server is now 'smartmemory-mcp'. It's included in your installation.")
+    click.echo(
+        "MCP server is now 'smartmemory-mcp'. It's included in your installation."
+    )
     click.echo("Run: smartmemory-mcp")