flurryx-code-memory 0.7.5__tar.gz → 0.7.6__tar.gz

{flurryx_code_memory-0.7.5 → flurryx_code_memory-0.7.6}/CHANGELOG.md

@@ -8,10 +8,48 @@ when the repo grows.
 This file complements `git log`: commits explain mechanics, this file
 explains intent.
 
+## [0.7.6] — 2026-06-21
+
+Release theme: **Correct tree-sitter pin + Windows console & extras fixes**.
+
+### Fixed
+
+**tree-sitter-language-pack pinned to `==1.8.1`** (was `==1.0.0` in the broken 0.7.5).
+Version 1.0.0 has no bundled language grammars (it uses a download model), so
+`get_language('csharp')` raised `LanguageNotFoundError` and extraction produced
+zero symbols on every platform. Version 1.9.1 is also broken (raises `'bytes'
+object is not an instance of 'str'` even on macOS — a 1.9.x regression). 1.8.1
+is the last known-good release with bundled grammars; the original Windows
+failure was caused by the loose `>=0.7` floor letting fresh installs float to
+1.9.1.
+
+Reason: stop floating into broken 1.9.x and restore symbol extraction everywhere.
+
+**Windows console crash in `code-memory update`**: stdout/stderr are now forced
+to UTF-8 (`errors="replace"`) at the CLI and MCP entry points, so Unicode
+status glyphs (→, •, ✓) no longer raise `UnicodeEncodeError` on cp1252
+PowerShell consoles.
+
+Reason: the updater crashed before doing any work on non-UTF-8 Windows terminals.
+
+### Added
+
+**Optional-extras selection prompt** in `code-memory update` and the install
+one-liner (`install.sh` / `install.ps1`): users are now asked which optional
+extras to enable (`dotnet` for .NET assembly indexing, `hybrid` for in-process
+BGE-M3). TTY-gated with a `CODEMEMORY_EXTRAS` env override and an `--extras`
+flag; non-interactive runs install nothing new. Also fixes the bash installer
+gating the prompt on `[ -t 0 ]`, which was always false under `curl | bash` so
+the prompt never appeared.
+
+Reason: previously there was no way to opt into .NET indexing during update/install.
+
 ## [0.7.5] — 2026-06-21
 
 Release theme: **Windows ingest fix — pin tree-sitter-language-pack**.
 
+**⚠️ Superseded by 0.7.6 — this release pinned tree-sitter-language-pack==1.0.0 which broke extraction (no bundled grammars). Do not use.**
+
 ### Fixed
 
 **What:** pinned `tree-sitter-language-pack` to `==1.0.0` (was `>=0.7`).

{flurryx_code_memory-0.7.5 → flurryx_code_memory-0.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flurryx-code-memory
-Version: 0.7.5
+Version: 0.7.6
 Summary: Local lightweight memory layer for coding agents: FalkorDB + Qdrant + Ollama (BGE-M3) + tree-sitter
 Requires-Python: >=3.11
 Requires-Dist: anyio>=4.4
@@ -10,7 +10,7 @@ Requires-Dist: mcp>=1.0
 Requires-Dist: pydantic>=2.8
 Requires-Dist: qdrant-client>=1.12
 Requires-Dist: rich>=13.7
-Requires-Dist: tree-sitter-language-pack==1.0.0
+Requires-Dist: tree-sitter-language-pack==1.8.1
 Requires-Dist: tree-sitter>=0.23
 Requires-Dist: typer>=0.12
 Requires-Dist: watchdog>=4.0

{flurryx_code_memory-0.7.5 → flurryx_code_memory-0.7.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "flurryx-code-memory"
-version = "0.7.5"
+version = "0.7.6"
 description = "Local lightweight memory layer for coding agents: FalkorDB + Qdrant + Ollama (BGE-M3) + tree-sitter"
 requires-python = ">=3.11"
 dependencies = [
@@ -12,7 +12,7 @@ dependencies = [
   "qdrant-client>=1.12",
   "falkordb>=1.0.10",
   "tree-sitter>=0.23",
-  "tree-sitter-language-pack==1.0.0",
+  "tree-sitter-language-pack==1.8.1",
   "pydantic>=2.8",
   "typer>=0.12",
   "rich>=13.7",

{flurryx_code_memory-0.7.5 → flurryx_code_memory-0.7.6}/scripts/install.ps1

@@ -25,6 +25,15 @@
   metadata indexing (Assembly + Type graph nodes from .dll referenced
   via .csproj). Skip if no .NET source in repos you ingest.
 
+.PARAMETER WithHybrid
+  Install the [hybrid] extra (FlagEmbedding, ~2 GB torch). Enables in-process
+  BGE-M3 dense+sparse hybrid reranking. Heavy — skip unless you need it.
+
+.PARAMETER Extras
+  Comma list of optional extras to install (e.g. 'dotnet,hybrid'), or 'none'
+  to bypass the interactive prompt. Overrides -WithDotnet/-WithHybrid and the
+  CODEMEMORY_EXTRAS environment variable.
+
 .PARAMETER Plugins
   Comma-separated whitelist of harness plugins to install:
   'opencode', 'claudecode', 'cursor', 'all', or 'none'. Bypasses the
@@ -37,14 +46,22 @@
   ./.cursor.
 
 .PARAMETER ExtrasInteractive
-  Set to `$false` to skip the interactive extras prompt. The -WithDotnet
-  switch still applies.
+  Set to `$false` to skip the interactive extras prompt entirely. Overridden
+  by -Extras, -WithDotnet, -WithHybrid, and the CODEMEMORY_EXTRAS env var.
 
 .EXAMPLE
   ./scripts/install.ps1
   ./scripts/install.ps1 -NoOllama
   ./scripts/install.ps1 -WithDotnet -Plugins all
+  ./scripts/install.ps1 -WithHybrid
+  ./scripts/install.ps1 -Extras dotnet,hybrid
+  ./scripts/install.ps1 -Extras none
   ./scripts/install.ps1 -Plugins claudecode -PluginsScope project
+
+.NOTES
+  Environment variables:
+    CODEMEMORY_EXTRAS=dotnet,hybrid   same as -Extras (overrides interactive prompt)
+    CODEMEMORY_EXTRAS=none            skip extras entirely
 #>
 
 [CmdletBinding()]
@@ -54,6 +71,8 @@ param(
   [switch]$NoTests,
   [switch]$NoMcp,
   [switch]$WithDotnet,
+  [switch]$WithHybrid,
+  [string]$Extras = '',
   [string]$Plugins = '',
   [ValidateSet('global', 'project')]
   [string]$PluginsScope = 'global',
@@ -195,24 +214,89 @@ Ok "pip upgraded"
 
 # ---------- 3. package install ----------
 # Resolve optional extras up front so we do one pip resolve.
-if ($ExtrasInteractive -and -not $WithDotnet) {
-  $isTty = [Environment]::UserInteractive -and [Console]::IsInputRedirected -eq $false
-  if ($isTty) {
-    Step "Optional extras"
-    Write-Host "  [dotnet]  .NET DLL metadata indexing (dnfile, ~200 KB)."
-    Write-Host "            Skip if no .csproj / .NET source in repos you ingest."
-    Write-Host ""
-    if (Prompt-YesNo "Install [dotnet] extra?" $false) { $WithDotnet = $true }
+#
+# Optional extras — keep in sync with EXTRAS registry in updater.py.
+#   dotnet: .NET assembly metadata indexing (dnfile, ~200 KB).
+#   hybrid: in-process BGE-M3 dense+sparse via FlagEmbedding (~2 GB torch).
+#
+# Priority: -Extras / -WithDotnet / -WithHybrid (CLI) >
+#           CODEMEMORY_EXTRAS env var > interactive prompt > skip.
+#
+# $isTty: true when running interactively (not under irm|iex which redirects stdin).
+$isTty = [Environment]::UserInteractive -and -not [Console]::IsInputRedirected
+
+$installDotnet = [bool]$WithDotnet
+$installHybrid = [bool]$WithHybrid
+
+# Fold legacy switches into -Extras when -Extras is not already set.
+if ([string]::IsNullOrWhiteSpace($Extras)) {
+  $legacyParts = @()
+  if ($WithDotnet) { $legacyParts += 'dotnet' }
+  if ($WithHybrid) { $legacyParts += 'hybrid' }
+  if ($legacyParts.Count -gt 0) { $Extras = $legacyParts -join ',' }
+}
+
+# Determine effective source.
+$effectiveExtras = $Extras
+if ([string]::IsNullOrWhiteSpace($effectiveExtras)) {
+  $envExtras = [System.Environment]::GetEnvironmentVariable('CODEMEMORY_EXTRAS')
+  if (-not [string]::IsNullOrWhiteSpace($envExtras)) {
+    $effectiveExtras = $envExtras.Trim()
   }
 }
 
-$extras = @('dev')
-if ($WithDotnet) { $extras += 'dotnet' }
-$extrasJoined = ($extras -join ',')
+if (-not [string]::IsNullOrWhiteSpace($effectiveExtras)) {
+  # Flag/env path — parse comma list.
+  if ($effectiveExtras -ieq 'none') {
+    $installDotnet = $false
+    $installHybrid = $false
+  } else {
+    foreach ($ep in $effectiveExtras.Split(',')) {
+      switch ($ep.Trim().ToLower()) {
+        'dotnet' { $installDotnet = $true }
+        'hybrid' { $installHybrid = $true }
+        ''       { }
+        default  { Warn "unknown extra '$($ep.Trim())' (known: dotnet, hybrid) — skipped" }
+      }
+    }
+  }
+} elseif ($ExtrasInteractive -and $isTty) {
+  # Interactive TTY path.
+  Step "Optional extras"
+  # Keep descriptions in sync with updater.py EXTRAS registry.
+  Write-Host "  [dotnet]  .NET assembly metadata indexing (dnfile, ~200 KB)."
+  Write-Host "            Skip if no .csproj / .NET source in repos you ingest."
+  Write-Host ""
+  Write-Host "  [hybrid]  In-process BGE-M3 dense+sparse via FlagEmbedding."
+  Write-Host "            Heavy — pulls torch (~2 GB). Skip unless you need hybrid reranking."
+  Write-Host ""
+  if (Prompt-YesNo "Install [dotnet] extra?" $false) { $installDotnet = $true }
+  if (Prompt-YesNo "Install [hybrid] extra?" $false) { $installHybrid = $true }
+} else {
+  # Non-interactive, no env override — dim hint only, no install.
+  Dim "hint: optional extras not installed. Re-run with -Extras dotnet,hybrid or set CODEMEMORY_EXTRAS=dotnet,hybrid."
+}
+
+$extrasBase = @('dev')
+if ($installDotnet) { $extrasBase += 'dotnet' }
+if ($installHybrid) { $extrasBase += 'hybrid' }
+$extrasJoined = ($extrasBase -join ',')
 
 Step "Installing code-memory (editable, extras: $extrasJoined)"
-& pip install -e ".[$extrasJoined]"
+# Base [dev] is hard-fail. Optional extras are non-fatal — a missing build
+# dependency (e.g. torch wheel unavailable) must not abort the whole install.
+& pip install -e ".[dev]"
 if ($LASTEXITCODE -ne 0) { Die "pip install failed" }
+if ($installDotnet -or $installHybrid) {
+  $optionalParts = @()
+  if ($installDotnet) { $optionalParts += 'dotnet' }
+  if ($installHybrid) { $optionalParts += 'hybrid' }
+  $optionalJoined = $optionalParts -join ','
+  & pip install -e ".[dev,$optionalJoined]"
+  if ($LASTEXITCODE -ne 0) {
+    Warn "optional extras install failed (dev install succeeded; re-run: pip install -e '.[$optionalJoined]')"
+  }
+}
 Ok "code-memory installed"
 
 # ---------- 4. .env ----------

{flurryx_code_memory-0.7.5 → flurryx_code_memory-0.7.6}/scripts/install.sh

@@ -10,6 +10,9 @@
 #   ./scripts/install.sh --with-claims   # also pull gemma2:9b for Graphiti-style
 #                                        # user-claim extraction (~5.4 GB)
 #   ./scripts/install.sh --with-dotnet   # install [dotnet] extra (dnfile, ~200 KB; .NET DLL metadata indexing)
+#   ./scripts/install.sh --with-hybrid   # install [hybrid] extra (FlagEmbedding; ~2 GB torch)
+#   ./scripts/install.sh --extras=dotnet,hybrid
+#                                        # install named extras (comma list)
 #   ./scripts/install.sh --extras=none   # bypass interactive prompt; install only [dev]
 #   ./scripts/install.sh --plugins=opencode,claudecode,cursor
 #                                        # install named harness plugins (non-interactive)
@@ -21,6 +24,10 @@
 #                                        # default scope is global (~/.config/opencode,
 #                                        # ~/.claude, ~/.cursor)
 #
+# Environment variables:
+#   CODEMEMORY_EXTRAS=dotnet,hybrid  # same as --extras=... (overrides interactive prompt)
+#   CODEMEMORY_EXTRAS=none           # skip extras entirely
+#
 set -euo pipefail
 
 # ---------- helpers ----------
@@ -48,8 +55,11 @@ SKIP_OLLAMA=0
 SKIP_TESTS=0
 SKIP_MCP=0
 WITH_DOTNET=0
+WITH_HYBRID=0
 WITH_CLAIMS=0
-EXTRAS_ARG=""        # empty = interactive; "none" = skip extras prompt; other ignored
+# EXTRAS_ARG: CLI value of --extras=... (overrides CODEMEMORY_EXTRAS env and interactive).
+# Empty means "not set by CLI"; "none" means skip; comma list means install those extras.
+EXTRAS_ARG=""
 PLUGINS_ARG=""       # empty = interactive; explicit value bypasses prompt
 PLUGINS_SCOPE="global"  # global | project
 for arg in "$@"; do
@@ -58,13 +68,14 @@ for arg in "$@"; do
     --no-ollama) SKIP_OLLAMA=1 ;;
     --no-tests)  SKIP_TESTS=1 ;;
     --no-mcp)    SKIP_MCP=1 ;;
-    --with-dotnet) WITH_DOTNET=1 ;;
-    --with-claims) WITH_CLAIMS=1 ;;
+    --with-dotnet)  WITH_DOTNET=1 ;;
+    --with-hybrid)  WITH_HYBRID=1 ;;
+    --with-claims)  WITH_CLAIMS=1 ;;
     --extras=*)         EXTRAS_ARG="${arg#--extras=}" ;;
     --plugins=*)        PLUGINS_ARG="${arg#--plugins=}" ;;
     --plugins-scope=*)  PLUGINS_SCOPE="${arg#--plugins-scope=}" ;;
     -h|--help)
-      sed -n '1,22p' "$0"; exit 0 ;;
+      sed -n '1,29p' "$0"; exit 0 ;;
     *) die "unknown flag: $arg" ;;
   esac
 done
@@ -190,22 +201,95 @@ prompt_yes_no() {
   [ "$ans" = "y" ] || [ "$ans" = "yes" ]
 }
 
-if [ -z "$EXTRAS_ARG" ] && [ "$WITH_DOTNET" -eq 0 ]; then
-  # Only interactive if stdin/stdout are a TTY.
-  if [ -t 0 ] && [ -t 1 ]; then
-    step "Optional extras"
-    echo "  [dotnet]  .NET DLL metadata indexing (dnfile, ~200 KB)."
-    echo "            Skip if no .csproj / .NET source in repos you ingest."
-    echo
-    if prompt_yes_no "Install [dotnet] extra?" "n"; then WITH_DOTNET=1; fi
+# ---------- extras resolution (contract mirrors updater.py / install.ps1) ----------
+# Optional extras in pyproject.toml — keep in sync with EXTRAS registry in updater.py.
+#   dotnet: .NET assembly metadata indexing (dnfile, ~200 KB).
+#   hybrid: in-process BGE-M3 dense+sparse via FlagEmbedding (~2 GB torch).
+#
+# Priority: CLI flag (--extras= / --with-dotnet / --with-hybrid) >
+#           CODEMEMORY_EXTRAS env var > interactive prompt > skip.
+#
+# TTY_OK = true when we can safely prompt:
+#   - Both stdin+stdout are a real TTY, OR /dev/tty is readable as a fallback
+#     (handles curl|bash where fd 0 is the pipe but /dev/tty is the terminal).
+TTY_OK=0
+if [ -t 0 ] && [ -t 1 ]; then
+  TTY_OK=1
+elif [ -r /dev/tty ]; then
+  TTY_OK=1
+fi
+
+# Build the effective extras list.
+# We accumulate into INSTALL_DOTNET / INSTALL_HYBRID, then build the pip string.
+INSTALL_DOTNET=0
+INSTALL_HYBRID=0
+
+# Fold legacy --with-dotnet / --with-hybrid into the generic flag path.
+[ "$WITH_DOTNET" -eq 1 ] && EXTRAS_ARG="${EXTRAS_ARG:-dotnet}"
+[ "$WITH_HYBRID" -eq 1 ] && {
+  if [ -n "$EXTRAS_ARG" ] && [ "$EXTRAS_ARG" != "none" ]; then
+    EXTRAS_ARG="${EXTRAS_ARG},hybrid"
+  elif [ -z "$EXTRAS_ARG" ]; then
+    EXTRAS_ARG="hybrid"
+  fi
+}
+
+# Determine effective source of extras selection.
+EFFECTIVE_EXTRAS=""
+if [ -n "$EXTRAS_ARG" ]; then
+  EFFECTIVE_EXTRAS="$EXTRAS_ARG"
+elif [ -n "${CODEMEMORY_EXTRAS:-}" ]; then
+  EFFECTIVE_EXTRAS="$CODEMEMORY_EXTRAS"
+fi
+
+if [ -n "$EFFECTIVE_EXTRAS" ]; then
+  # env/flag path — parse comma list.
+  if [ "$EFFECTIVE_EXTRAS" = "none" ]; then
+    : # install nothing extra
+  else
+    IFS=',' read -r -a _extras_parts <<< "$EFFECTIVE_EXTRAS"
+    for _ep in "${_extras_parts[@]}"; do
+      _ep="$(printf '%s' "$_ep" | tr -d '[:space:]')"
+      case "$_ep" in
+        dotnet)  INSTALL_DOTNET=1 ;;
+        hybrid)  INSTALL_HYBRID=1 ;;
+        "")      ;;
+        *)       warn "unknown extra '$_ep' (known: dotnet, hybrid) — skipped" ;;
+      esac
+    done
   fi
+elif [ "$TTY_OK" -eq 1 ]; then
+  # Interactive path.
+  step "Optional extras"
+  # Keep descriptions in sync with updater.py EXTRAS registry.
+  echo "  [dotnet]  .NET assembly metadata indexing (dnfile, ~200 KB)."
+  echo "            Skip if no .csproj / .NET source in repos you ingest."
+  echo
+  echo "  [hybrid]  In-process BGE-M3 dense+sparse via FlagEmbedding."
+  echo "            Heavy — pulls torch (~2 GB). Skip unless you need hybrid reranking."
+  echo
+  if prompt_yes_no "Install [dotnet] extra?" "n"; then INSTALL_DOTNET=1; fi
+  if prompt_yes_no "Install [hybrid] extra?" "n"; then INSTALL_HYBRID=1; fi
+else
+  # Non-interactive, no env override — skip silently with a dim hint.
+  printf "${DIM}  hint: optional extras not installed. Re-run with --extras=dotnet,hybrid or set CODEMEMORY_EXTRAS=dotnet,hybrid.${RST}\n"
 fi
 
 EXTRAS="dev"
-[ "$WITH_DOTNET" -eq 1 ] && EXTRAS="${EXTRAS},dotnet"
+[ "$INSTALL_DOTNET" -eq 1 ] && EXTRAS="${EXTRAS},dotnet"
+[ "$INSTALL_HYBRID" -eq 1 ] && EXTRAS="${EXTRAS},hybrid"
 
 step "Installing code-memory (editable, extras: $EXTRAS)"
-pip install -e ".[${EXTRAS}]"
+# The base [dev] install is hard-fail; optional extras are non-fatal so a
+# missing build dependency (e.g. torch wheel not available) does not abort
+# the whole install under set -e.
+pip install -e ".[dev]"
+if [ "$INSTALL_DOTNET" -eq 1 ] || [ "$INSTALL_HYBRID" -eq 1 ]; then
+  _optional_extras="${EXTRAS#dev}"
+  _optional_extras="${_optional_extras#,}"
+  pip install -e ".[dev,${_optional_extras}]" \
+    || warn "optional extras install failed (dev install succeeded; re-run: pip install -e '.[${_optional_extras}]')"
+fi
 ok "code-memory installed"
 
 # ---------- 4. .env ----------

flurryx_code_memory-0.7.6/src/code_memory/_console.py

@@ -0,0 +1,32 @@
+"""Console encoding utilities.
+
+Ensures stdout/stderr are safe on non-UTF-8 consoles (e.g. Windows cp1252).
+Must be imported with zero heavy dependencies so it can be called at the
+earliest point of every CLI entry point.
+"""
+
+from __future__ import annotations
+
+import sys
+
+
+def _force_utf8_console() -> None:
+    """Reconfigure stdout and stderr to UTF-8 with errors='replace'.
+
+    On Windows the console inherits the active code page (often cp1252 / cp850).
+    Python's ``TextIOWrapper.reconfigure`` switches to UTF-8 while keeping the
+    same underlying buffer, so Unicode decoration chars (→ • ✓ —) render
+    correctly on a real Windows console (Python uses the Unicode console API)
+    and degrade to ``?`` when redirected to a cp1252 pipe — never a crash.
+
+    The ``getattr`` guard + bare ``except Exception`` make this a safe no-op
+    on stream types that lack ``reconfigure`` (e.g. pytest's ``CaptureFixture``
+    or ``io.StringIO``).
+    """
+    for stream in (sys.stdout, sys.stderr):
+        reconfigure = getattr(stream, "reconfigure", None)
+        if reconfigure is not None:
+            try:
+                reconfigure(encoding="utf-8", errors="replace")
+            except Exception:  # noqa: BLE001
+                pass

{flurryx_code_memory-0.7.5 → flurryx_code_memory-0.7.6}/src/code_memory/cli.py

@@ -12,12 +12,15 @@ from rich import print as rprint
 
 from dataclasses import asdict as _asdict
 
+from ._console import _force_utf8_console
 from .config import CONFIG, detect_project_slug
 from .episodic import Episode
 from .graph import FalkorStore
 from .orchestrator import Pipeline, Retriever, list_projects, reset_all, reset_project
 from .orchestrator import git_delta as _git_delta
 
+_force_utf8_console()
+
 
 def _graph_for(project: str | None) -> FalkorStore:
     slug = project or detect_project_slug()
@@ -1269,6 +1272,14 @@ def update(
         "--bleeding",
         help="Install CLI from git+main instead of PyPI.",
     ),
+    extras: str | None = typer.Option(
+        None,
+        "--extras",
+        help=(
+            "Comma list of optional extras to install (e.g. dotnet,hybrid), or 'none'."
+            " Overrides the interactive prompt and CODEMEMORY_EXTRAS env var."
+        ),
+    ),
 ) -> None:
     """Smart-update code-memory: refresh only components already installed locally.
 
@@ -1278,10 +1289,12 @@ def update(
     stay untouched — no prompts, no re-asking.
 
     Use ``--check`` for a dry-run, ``--full`` to behave like a fresh install.
+    Use ``--extras dotnet,hybrid`` to install optional Python extras, or
+    ``--extras none`` to suppress the interactive prompt.
     """
     from .updater import run_update
 
-    rc = run_update(check_only=check, full=full, bleeding=bleeding)
+    rc = run_update(check_only=check, full=full, bleeding=bleeding, extras_override=extras)
     raise typer.Exit(code=rc)
 
 

{flurryx_code_memory-0.7.5 → flurryx_code_memory-0.7.6}/src/code_memory/mcp_server.py

@@ -1984,6 +1984,9 @@ async def _run() -> None:
 
 
 def main() -> None:
+    from ._console import _force_utf8_console
+
+    _force_utf8_console()
     logging.basicConfig(
         level=os.environ.get("CODE_MEMORY_LOG_LEVEL", "INFO"),
         format="%(asctime)s %(levelname)s %(name)s %(message)s",

{flurryx_code_memory-0.7.5 → flurryx_code_memory-0.7.6}/src/code_memory/updater.py

@@ -464,12 +464,21 @@ def upgrade_npm_pkg(pkg: str = "code-memory-opencode") -> tuple[bool, str]:
 # ---------- orchestrator ----------
 
 
-def run_update(*, check_only: bool, full: bool, bleeding: bool) -> int:
+def run_update(
+    *,
+    check_only: bool,
+    full: bool,
+    bleeding: bool,
+    extras_override: str | None = None,
+) -> int:
     """Top-level entry point used by the CLI.
 
     ``check_only`` prints the plan and exits 0/1 based on whether anything
     is behind. ``full`` re-runs the one-liner installer (curl … | bash).
     Default is the smart path: upgrade-in-place only what is already present.
+
+    ``extras_override`` is the value of the ``--extras`` CLI flag (highest
+    priority over the ``CODEMEMORY_EXTRAS`` env var).
     """
     plan = build_plan()
     _print_plan(plan)
@@ -511,6 +520,7 @@ def run_update(*, check_only: bool, full: bool, bleeding: bool) -> int:
         ok, detail = upgrade_docker_images()
         print(f"  Docker stack: {'ok' if ok else 'skip'} — {detail}")
 
+    rc |= offer_missing_extras(plan.install_method, extras_override=extras_override)
     return rc
 
 
@@ -525,6 +535,141 @@ def _print_plan(plan: UpdatePlan) -> None:
         print(f"    {mark} {c.name}{suffix}{state}")
 
 
+def resolve_extras_selection(
+    *,
+    env_value: str | None,
+    is_tty: bool,
+    missing: list[str],
+) -> tuple[list[str], str]:
+    """Pure helper — no I/O — that decides which extras to install.
+
+    Returns ``(selected_names, mode)`` where ``mode`` is one of
+    ``"env"``, ``"interactive"``, or ``"skip"``.
+
+    Priority:
+    1. ``env_value`` not None → parse comma list; ``"none"`` or empty → nothing.
+    2. ``is_tty`` True → caller must run the interactive loop (mode=``"interactive"``).
+    3. Otherwise → skip (non-interactive, no env override).
+    """
+    if env_value is not None:
+        stripped = env_value.strip()
+        if stripped.lower() == "none" or stripped == "":
+            return [], "env"
+        names = [n.strip() for n in stripped.split(",") if n.strip()]
+        valid = [n for n in names if n in EXTRAS and n in missing]
+        return valid, "env"
+    if is_tty:
+        return [], "interactive"
+    return [], "skip"
+
+
+def _install_selected_extras(names: list[str], method: InstallMethod) -> int:
+    """Install a list of extras; returns OR of per-extra return codes.
+
+    A single failed extra does not abort the rest — each failure sets the
+    nonzero bit in ``rc`` but installation continues.
+    """
+    rc = 0
+    for name in names:
+        print()
+        print(f"Installing extra: {name}")
+        ok, detail = install_extra(name, method)
+        marker = "ok" if ok else "FAILED"
+        print(f"  {marker} — {detail}")
+        rc |= 0 if ok else 1
+    return rc
+
+
+def offer_missing_extras(
+    method: InstallMethod,
+    *,
+    extras_override: str | None = None,
+) -> int:
+    """Offer to install extras that are not yet present.
+
+    Called automatically at the end of the smart ``run_update`` path.
+    Never blocks ``--check`` / ``--full`` (those return before reaching here).
+
+    Priority: ``extras_override`` (CLI ``--extras`` flag) >
+    ``CODEMEMORY_EXTRAS`` env var > interactive prompt > skip silently.
+    """
+    missing = [n for n in EXTRAS if not _python_module_present(EXTRAS[n]["module"])]
+    if not missing:
+        return 0
+
+    if method in ("unknown",):
+        print(
+            f"\033[2m  hint: optional extras not yet installed: {', '.join(missing)}.\n"
+            "  Run `code-memory extras` or set CODEMEMORY_EXTRAS=dotnet,hybrid.\033[0m"
+        )
+        return 0
+
+    # For editable installs, we need a valid pyproject.toml to install extras.
+    if method == "editable":
+        repo_root = Path(__file__).resolve().parents[2]
+        if not (repo_root / "pyproject.toml").exists():
+            print(
+                f"\033[2m  hint: editable install without pyproject.toml at {repo_root};\n"
+                "  cannot install optional extras automatically.\033[0m"
+            )
+            return 0
+
+    # Determine TTY status safely.
+    try:
+        is_tty = sys.stdin.isatty()
+    except Exception:  # noqa: BLE001
+        is_tty = False
+
+    # CLI flag takes precedence over env var.
+    effective_env = extras_override if extras_override is not None else os.environ.get("CODEMEMORY_EXTRAS")
+
+    selected, mode = resolve_extras_selection(
+        env_value=effective_env,
+        is_tty=is_tty,
+        missing=missing,
+    )
+
+    if mode == "env":
+        if effective_env is not None:
+            # Warn about any names that were not in EXTRAS or already installed.
+            raw_names = [n.strip() for n in effective_env.split(",") if n.strip() and n.strip().lower() != "none"]
+            unknown = [n for n in raw_names if n not in EXTRAS]
+            already = [n for n in raw_names if n in EXTRAS and n not in missing]
+            for n in unknown:
+                print(f"\033[33m  [warn]\033[0m unknown extra '{n}' (known: {', '.join(EXTRAS)})")
+            for n in already:
+                print(f"  · {n} already installed — skipped")
+        if not selected:
+            return 0
+        return _install_selected_extras(selected, method)
+
+    if mode == "interactive":
+        todo: list[str] = []
+        print()
+        print("Optional extras available:")
+        for name in missing:
+            info = EXTRAS[name]
+            print(f"  · {name}  — not installed")
+            print(f"      {info['desc']}")
+            try:
+                answer = input(f"      Install `{name}`? [y/N] ").strip().lower()
+            except EOFError:
+                answer = ""
+            if answer in ("y", "yes"):
+                todo.append(name)
+        if not todo:
+            print("Nothing to install.")
+            return 0
+        return _install_selected_extras(todo, method)
+
+    # mode == "skip"
+    print(
+        f"\033[2m  hint: optional extras not yet installed: {', '.join(missing)}.\n"
+        "  Re-run with CODEMEMORY_EXTRAS=dotnet,hybrid or `code-memory extras`.\033[0m"
+    )
+    return 0
+
+
 def install_extra(name: str, method: InstallMethod) -> tuple[bool, str]:
     """Install a single optional extra using whichever channel owns the CLI.