claude-smart 0.2.25 → 0.2.27

package/plugin/skills/claude-smart/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: claude-smart
+description: Codex-only — use when the user asks to run claude-smart commands in Codex, including claude-smart show, learn, restart, dashboard, clear-all, or slash-like requests such as /claude-smart:learn. In Claude Code the native plugin slash commands handle these; do not invoke this skill there.
+---
+
+# claude-smart Commands In Codex
+
+Codex does not currently support plugin-provided slash commands. When the user
+asks for a claude-smart command, run the equivalent shell command through the
+active plugin root. This skill is Codex-specific; under Claude Code the native
+`/claude-smart:*` slash commands already exist, so do not fall back to the
+shell commands there.
+
+## Command Map
+
+- Dashboard: `bash ~/.reflexio/plugin-root/scripts/dashboard-open.sh`
+- Show learned state: `bash ~/.reflexio/plugin-root/scripts/cli.sh show`
+- Learn from the latest turn: `bash ~/.reflexio/plugin-root/scripts/cli.sh learn`
+- Learn with a note: `bash ~/.reflexio/plugin-root/scripts/cli.sh learn --note "<note>"`
+- Restart backend/dashboard: `bash ~/.reflexio/plugin-root/scripts/cli.sh restart`
+- Clear all learned state: `bash ~/.reflexio/plugin-root/scripts/cli.sh clear-all --yes`
+
+## Behavior
+
+1. Treat slash-like prompts such as `/claude-smart:show` as requests to run the
+   matching shell command above.
+2. For `learn`, preserve any user-provided note exactly as the note text.
+3. For `clear-all`, require explicit confirmation before running it because it
+   deletes all reflexio interactions, preferences, and skills.
+4. If `~/.reflexio/plugin-root` is missing or broken, tell the user to restart
+   Codex after installing claude-smart, then rerun the command.
+5. After running a command, summarize the important output concisely.

package/plugin/src/claude_smart/cli.py

@@ -25,6 +25,7 @@ import argparse
 import json
 import os
 import re
+import select
 import shutil
 import subprocess
 import sys
@@ -75,6 +76,8 @@ _CODEX_REQUIRED_FILES = (
     Path(".agents/plugins/marketplace.json"),
     Path("plugin/.codex-plugin/plugin.json"),
     Path("plugin/hooks/codex-hooks.json"),
+    Path("plugin/scripts/codex-claude-compat.py"),
+    Path("plugin/scripts/codex-hook.js"),
     Path("plugin/scripts/_codex_env.sh"),
 )
 _COPYTREE_IGNORE = shutil.ignore_patterns(
@@ -109,7 +112,10 @@ def _seed_reflexio_env() -> list[str]:
     _REFLEXIO_ENV_PATH.parent.mkdir(parents=True, exist_ok=True)
     _REFLEXIO_ENV_PATH.touch(exist_ok=True)
     existing = _REFLEXIO_ENV_PATH.read_text()
-    flags = ("CLAUDE_SMART_USE_LOCAL_CLI", "CLAUDE_SMART_USE_LOCAL_EMBEDDING")
+    flags = (
+        "CLAUDE_SMART_USE_LOCAL_CLI",
+        "CLAUDE_SMART_USE_LOCAL_EMBEDDING",
+    )
     missing = [f for f in flags if f"{f}=" not in existing]
     if not missing:
         return []
@@ -337,6 +343,191 @@ def _set_codex_plugin_enabled(path: Path) -> bool:
     return True
 
 
+def _toml_dotted_quoted(name: str) -> str:
+    """Quote a TOML bare-key segment whose name may contain ``"`` or ``\\``."""
+    return '"' + name.replace("\\", "\\\\").replace('"', '\\"') + '"'
+
+
+def _set_codex_hook_states(path: Path, states: dict[str, str]) -> bool:
+    """Trust and enable Codex hook state entries for the given hook hashes."""
+    if not states:
+        return False
+    if not _remove_toml_sections(
+        path,
+        exact=set(),
+        prefixes=(f'hooks.state."{_CODEX_PLUGIN_ID}:',),
+    ):
+        return False
+    try:
+        text = path.read_text() if path.exists() else ""
+    except OSError:
+        return False
+    if text and not text.endswith("\n"):
+        text += "\n"
+    if "[hooks.state]" not in text:
+        if text.strip():
+            text += "\n"
+        text += "[hooks.state]\n"
+    if text.strip():
+        text += "\n"
+    for key, current_hash in sorted(states.items()):
+        text += (
+            f"[hooks.state.{_toml_dotted_quoted(key)}]\n"
+            "enabled = true\n"
+            f'trusted_hash = "{current_hash}"\n\n'
+        )
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(text.rstrip() + "\n")
+    except OSError:
+        return False
+    return True
+
+
+def _read_codex_app_server_response(
+    proc: subprocess.Popen[str], response_id: int, deadline: float
+) -> dict[str, object]:
+    """Read JSON-RPC lines from ``proc.stdout`` until ``response_id`` arrives.
+
+    Skips unrelated notifications and non-JSON output. Raises ``RuntimeError``
+    if the child exits, ``TimeoutError`` once ``deadline`` is reached, or
+    re-raises Codex's own error payload as ``RuntimeError``.
+    """
+    if proc.stdout is None:
+        raise RuntimeError("Codex app-server stdout pipe is not available")
+    while time.monotonic() < deadline:
+        ready, _, _ = select.select([proc.stdout], [], [], 0.2)
+        if not ready:
+            if proc.poll() is not None:
+                raise RuntimeError("Codex app-server exited before responding")
+            continue
+        line = proc.stdout.readline()
+        if not line:
+            continue
+        try:
+            message = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if message.get("id") == response_id:
+            if "error" in message:
+                raise RuntimeError(str(message["error"]))
+            return message
+    raise TimeoutError("Codex app-server did not respond in time")
+
+
+def _codex_app_server_request(
+    proc: subprocess.Popen[str],
+    response_id: int,
+    method: str,
+    params: dict[str, object],
+    deadline: float,
+) -> dict[str, object]:
+    """Send one JSON-RPC request to the Codex app-server and await the response."""
+    if proc.stdin is None:
+        raise RuntimeError("Codex app-server stdin pipe is not available")
+    proc.stdin.write(
+        json.dumps({"id": response_id, "method": method, "params": params})
+    )
+    proc.stdin.write("\n")
+    proc.stdin.flush()
+    return _read_codex_app_server_response(proc, response_id, deadline)
+
+
+def _list_codex_plugin_hooks(cwd: Path) -> tuple[bool, list[dict[str, object]], str]:
+    """Ask Codex for discovered hook metadata, including current trust hashes."""
+    try:
+        popen = subprocess.Popen(
+            ["codex", "app-server", "--listen", "stdio://"],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            text=True,
+        )
+    except OSError as exc:
+        return False, [], f"could not start Codex app-server: {exc}"
+
+    proc = popen
+    try:
+        deadline = time.monotonic() + _CODEX_CLI_TIMEOUT_SECONDS
+        _codex_app_server_request(
+            proc,
+            1,
+            "initialize",
+            {
+                "clientInfo": {
+                    "name": "claude_smart_installer",
+                    "title": "claude-smart installer",
+                    "version": "0.0.0",
+                },
+                "capabilities": {"experimentalApi": True},
+            },
+            deadline,
+        )
+        if proc.stdin is None:
+            return False, [], "Codex app-server stdin pipe is not available"
+        proc.stdin.write(json.dumps({"method": "initialized", "params": {}}) + "\n")
+        proc.stdin.flush()
+        response = _codex_app_server_request(
+            proc,
+            2,
+            "hooks/list",
+            {"cwds": [str(cwd)]},
+            deadline,
+        )
+    except (OSError, RuntimeError, TimeoutError) as exc:
+        return False, [], str(exc)
+    finally:
+        proc.terminate()
+        try:
+            proc.wait(timeout=2)
+        except subprocess.TimeoutExpired:
+            proc.kill()
+            proc.wait(timeout=2)
+
+    result = response.get("result")
+    data = result.get("data") if isinstance(result, dict) else None
+    if not isinstance(data, list) or not data:
+        return False, [], "Codex app-server returned no hook metadata"
+    hooks = data[0].get("hooks") if isinstance(data[0], dict) else None
+    if not isinstance(hooks, list):
+        return False, [], "Codex app-server hook metadata was malformed"
+    plugin_hooks = [
+        hook
+        for hook in hooks
+        if isinstance(hook, dict)
+        and (
+            hook.get("pluginId") == _CODEX_PLUGIN_ID
+            or str(hook.get("key", "")).startswith(f"{_CODEX_PLUGIN_ID}:")
+        )
+    ]
+    return True, plugin_hooks, f"found {len(plugin_hooks)} claude-smart hooks"
+
+
+def _trust_codex_plugin_hooks(cwd: Path) -> tuple[bool, str]:
+    """Seed Codex per-hook trust state for the installed claude-smart plugin."""
+    ok, hooks, message = _list_codex_plugin_hooks(cwd)
+    if not ok:
+        return False, message
+    states: dict[str, str] = {}
+    for hook in hooks:
+        key = hook.get("key")
+        current_hash = hook.get("currentHash")
+        if (
+            isinstance(key, str)
+            and key.startswith(f"{_CODEX_PLUGIN_ID}:")
+            and isinstance(current_hash, str)
+        ):
+            states[key] = current_hash
+    if not states:
+        return False, "Codex did not report trust hashes for claude-smart hooks"
+    if not _set_codex_hook_states(_CODEX_CONFIG_PATH, states):
+        return (
+            False,
+            f"could not write claude-smart hook trust state to {_CODEX_CONFIG_PATH}",
+        )
+    return True, f"trusted and enabled {len(states)} claude-smart Codex hooks"
+
+
 def _codex_plugin_version(plugin_root: Path) -> str | None:
     try:
         manifest = json.loads(
@@ -401,21 +592,28 @@ def _cleanup_codex_install_state() -> bool:
 
 
 def _enable_codex_plugin_hooks() -> tuple[bool, str]:
-    """Enable Codex's ``plugin_hooks`` feature, falling back to editing config.toml.
+    """Enable Codex hook feature flags, falling back to editing config.toml.
 
     Returns:
         tuple[bool, str]: ``(success, message)``. The message describes
-            either the successful path taken (CLI vs. direct config write)
-            or the failure mode.
+        either the successful path taken (CLI vs. direct config write)
+        or the failure mode.
     """
-    result = _run_codex(["features", "enable", "plugin_hooks"])
-    if result.returncode == 0:
-        return True, "codex features enable plugin_hooks"
-    if _set_toml_feature(_CODEX_CONFIG_PATH, "plugin_hooks", True):
-        return True, f"set plugin_hooks = true in {_CODEX_CONFIG_PATH}"
-    return False, (
-        result.stderr or result.stdout or "could not update Codex config"
-    ).strip()
+    messages: list[str] = []
+    for feature in ("hooks", "plugin_hooks"):
+        result = _run_codex(["features", "enable", feature])
+        if result.returncode == 0:
+            messages.append(f"codex features enable {feature}")
+            continue
+        if _set_toml_feature(_CODEX_CONFIG_PATH, feature, True):
+            messages.append(f"set {feature} = true in {_CODEX_CONFIG_PATH}")
+            continue
+        detail = (
+            result.stderr or result.stdout or "could not update Codex config"
+        ).strip()
+        prior = f" (succeeded earlier: {'; '.join(messages)})" if messages else ""
+        return False, f"{feature}: {detail}{prior}"
+    return True, "; ".join(messages)
 
 
 def _register_codex_marketplace(root: Path) -> tuple[bool, str]:
@@ -501,22 +699,41 @@ def cmd_install_codex(_args: argparse.Namespace) -> int:
 
     installed = False
     install_msg = "marketplace registration failed"
+    trusted = False
+    trust_msg = "plugin was not installed"
     if registered:
         installed, install_msg = _install_codex_plugin_cache(
             marketplace_root / _CODEX_LOCAL_PLUGIN_PATH
         )
         if installed:
             sys.stdout.write(f"{install_msg}.\n")
+            trusted, trust_msg = _trust_codex_plugin_hooks(Path.cwd())
+            if not trusted:
+                # The app-server can race against the just-installed cache.
+                # Retry once before giving up; the manual /hooks recovery is
+                # available either way.
+                time.sleep(0.5)
+                trusted, trust_msg = _trust_codex_plugin_hooks(Path.cwd())
+            if trusted:
+                sys.stdout.write(f"{trust_msg}.\n")
+            else:
+                sys.stderr.write(f"warning: {trust_msg}\n")
         else:
             sys.stderr.write(f"warning: {install_msg}\n")
 
-    if registered and installed:
+    if registered and installed and trusted:
         sys.stdout.write(
             "\nclaude-smart Codex support is installed.\n"
-            "Restart Codex so the installed plugin and hooks reload. /plugins should "
+            "Restart Codex so the installed plugin and trusted hooks reload. /plugins should "
             f"show claude-smart as installed from the {_CODEX_MARKETPLACE_DISPLAY_NAME} marketplace. "
             "Uninstall removes the plugin cache and marketplace registration but leaves "
-            "shared claude-smart data and Codex's global plugin_hooks feature intact.\n"
+            "shared claude-smart data and Codex's global hook feature flags intact.\n"
+        )
+    elif registered and installed:
+        sys.stdout.write(
+            "\nclaude-smart Codex support is installed, but hook trust could not be completed.\n"
+            "Fully quit and reopen Codex in this repo, run /hooks, trust the claude-smart hooks, "
+            "and restart Codex so hooks reload.\n"
         )
     elif registered:
         sys.stdout.write(
@@ -531,7 +748,7 @@ def cmd_install_codex(_args: argparse.Namespace) -> int:
             "then fully quit and reopen Codex, run /plugins, install claude-smart from the "
             f"{_CODEX_MARKETPLACE_DISPLAY_NAME} marketplace, and restart Codex so hooks reload.\n"
         )
-    return 0 if hooks_ok and registered and installed else 1
+    return 0 if hooks_ok and registered and installed and trusted else 1
 
 
 def cmd_install(args: argparse.Namespace) -> int:
@@ -674,7 +891,7 @@ def cmd_uninstall_codex(_args: argparse.Namespace) -> int:
         sys.stderr.write(f"warning: could not update {_CODEX_CONFIG_PATH}\n")
     sys.stdout.write(
         "claude-smart Codex plugin and marketplace state removed. Restart Codex to apply. "
-        "Codex's global plugin_hooks feature and local data under ~/.reflexio "
+        "Codex's global hook feature flags and local data under ~/.reflexio "
         "and ~/.claude-smart were left in place.\n"
     )
     return 0

package/plugin/src/claude_smart/events/stop.py

@@ -8,7 +8,7 @@ import time
 from pathlib import Path
 from typing import Any
 
-from claude_smart import cs_cite, ids, publish, runtime, state
+from claude_smart import cs_cite, ids, internal_call, publish, runtime, state
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -112,6 +112,16 @@ def _scan_transcript_for_assistant_text(entries: list[dict[str, Any]]) -> str:
     return "\n\n".join(parts)
 
 
+def _scan_transcript_for_user_text(entries: list[dict[str, Any]]) -> str:
+    """Return the user text that opened the current transcript turn."""
+    for entry in reversed(entries):
+        if not _is_user_turn_boundary(entry):
+            continue
+        message = entry.get("message") or {}
+        return "\n\n".join(_extract_text_blocks(message.get("content")))
+    return ""
+
+
 def _is_user_turn_boundary(entry: dict[str, Any]) -> bool:
     """True if ``entry`` is the user message that opened the current turn.
 
@@ -350,6 +360,11 @@ def handle(payload: dict[str, Any]) -> None:
         if path.is_file():
             entries = _load_transcript_with_retry(path)
 
+    if runtime.is_codex():
+        prompt = payload.get("prompt") or _scan_transcript_for_user_text(entries)
+        if internal_call.is_codex_internal_prompt(prompt):
+            return
+
     last_assistant_message = payload.get("last_assistant_message")
     assistant_text = (
         last_assistant_message

package/plugin/src/claude_smart/internal_call.py

@@ -29,6 +29,9 @@ Detection signals, OR'd:
   - ``payload.cwd`` resolves inside the reflexio submodule. Catches
     direct interactive ``claude`` runs from inside reflexio (manual
     debugging) that would otherwise pollute the corpus.
+  - Known Codex-internal prompt templates (title generation and home-screen
+    suggestions). These are model calls made by Codex itself, not user
+    coding turns, and must never be reflected into claude-smart memory.
 """
 
 from __future__ import annotations
@@ -41,6 +44,19 @@ from claude_smart import runtime
 
 _ENTRYPOINT_VAR = "CLAUDE_CODE_ENTRYPOINT"
 _INTERACTIVE_ENTRYPOINT = "cli"
+_CODEX_TITLE_PROMPT_PREFIX = (
+    "You are a helpful assistant. You will be presented with a user prompt, "
+    "and your job is to provide a short title for a task"
+)
+_CODEX_SUGGESTIONS_PROMPT_PREFIX = "# Overview\n\nGenerate 0 to 3 "
+_CODEX_SUGGESTIONS_PROMPT_MARKER = (
+    "hyperpersonalized suggestions for what this user can do with Codex "
+    "in this local project:"
+)
+_CODEX_SUGGESTIONS_APPS_MARKER = (
+    "Get an understanding of the user's intent and goals by deeply viewing "
+    "their connected apps."
+)
 
 # Reflexio submodule lives at <repo>/reflexio when this package runs from
 # a dev checkout (<repo>/plugin/src/claude_smart/internal_call.py); anchor
@@ -75,6 +91,8 @@ def is_internal_invocation(payload: dict[str, Any]) -> bool:
     entrypoint = os.environ.get(_ENTRYPOINT_VAR)
     if entrypoint and entrypoint != _INTERACTIVE_ENTRYPOINT:
         return True
+    if runtime.is_codex() and is_codex_internal_prompt(payload.get("prompt")):
+        return True
     cwd = payload.get("cwd")
     if not isinstance(cwd, str) or not cwd:
         return False
@@ -87,3 +105,15 @@ def is_internal_invocation(payload: dict[str, Any]) -> bool:
     except ValueError:
         return False
     return True
+
+
+def is_codex_internal_prompt(prompt: Any) -> bool:
+    """True for Codex's own UI/task prompts, not user-authored turns."""
+    if not isinstance(prompt, str):
+        return False
+    text = prompt.strip()
+    return text.startswith(_CODEX_TITLE_PROMPT_PREFIX) or (
+        text.startswith(_CODEX_SUGGESTIONS_PROMPT_PREFIX)
+        and _CODEX_SUGGESTIONS_PROMPT_MARKER in text
+        and _CODEX_SUGGESTIONS_APPS_MARKER in text
+    )

package/plugin/src/claude_smart/optimizer_assistant.py

@@ -2,22 +2,24 @@
 
 Reflexio's ``LocalScriptAssistant`` sends one JSON payload on stdin and expects
 one JSON object on stdout. This module bridges that protocol to a guarded
-``claude -p`` subprocess so candidate playbooks can be evaluated against Claude
-Code without re-entering claude-smart/reflexio hooks.
+local CLI subprocess so candidate playbooks can be evaluated against the active
+host without re-entering claude-smart/reflexio hooks.
 """
 
 from __future__ import annotations
 
 import json
 import os
+from pathlib import Path
 import shutil
 import subprocess
 import sys
+import tempfile
 from typing import Any
 
 from claude_smart import internal_call, runtime
 
-_CLAUDE_TIMEOUT_SECONDS = 300
+_CLI_TIMEOUT_SECONDS = 300
 _READ_ONLY_TOOLS = "Read,Grep,Glob,LS"
 _MUTATING_TOOLS = "Bash,Edit,Write,MultiEdit,NotebookEdit"
 
@@ -33,7 +35,7 @@ def main() -> int:
         messages = _validated_list(payload, "messages")
         playbooks = _validated_list(payload, "playbooks")
         prompt, system_prompt = _build_prompt(messages, playbooks)
-        content = _run_claude(prompt=prompt, system_prompt=system_prompt)
+        content = _run_local_cli(prompt=prompt, system_prompt=system_prompt)
     except Exception as exc:  # noqa: BLE001 - script errors become LocalScript failures.
         sys.stderr.write(f"{type(exc).__name__}: {exc}\n")
         return 1
@@ -134,6 +136,12 @@ def _render_transcript(messages: list[dict[str, str]]) -> str:
     )
 
 
+def _run_local_cli(*, prompt: str, system_prompt: str) -> str:
+    if runtime.is_codex():
+        return _run_codex(prompt=prompt, system_prompt=system_prompt)
+    return _run_claude(prompt=prompt, system_prompt=system_prompt)
+
+
 def _run_claude(*, prompt: str, system_prompt: str) -> str:
     cli_path = shutil.which("claude") or "claude"
     # This is an evaluation rollout, not a real user session: allow local
@@ -167,13 +175,13 @@ def _run_claude(*, prompt: str, system_prompt: str) -> str:
             input=prompt,
             capture_output=True,
             text=True,
-            timeout=_CLAUDE_TIMEOUT_SECONDS,
+            timeout=_CLI_TIMEOUT_SECONDS,
             check=False,
             env=env,
         )
     except subprocess.TimeoutExpired as exc:
         raise OptimizerAssistantError(
-            f"claude CLI timed out after {_CLAUDE_TIMEOUT_SECONDS}s"
+            f"claude CLI timed out after {_CLI_TIMEOUT_SECONDS}s"
         ) from exc
     except FileNotFoundError as exc:
         raise OptimizerAssistantError("claude CLI not found on PATH") from exc
@@ -199,5 +207,77 @@ def _run_claude(*, prompt: str, system_prompt: str) -> str:
     return content
 
 
+def _run_codex(*, prompt: str, system_prompt: str) -> str:
+    cli_path = shutil.which("codex") or "codex"
+    output_path = _temporary_output_path()
+    cmd = [
+        cli_path,
+        "exec",
+        "--sandbox",
+        "read-only",
+        "--skip-git-repo-check",
+        "--ephemeral",
+        "--ignore-rules",
+        "--output-last-message",
+        str(output_path),
+        "-",
+    ]
+
+    env = os.environ.copy()
+    env[runtime.HOST_ENV] = runtime.HOST_CODEX
+    env[runtime.INTERNAL_ENV] = "1"
+    env[internal_call._ENTRYPOINT_VAR] = "optimizer"  # noqa: SLF001
+
+    try:
+        proc = subprocess.run(  # noqa: S603 - command is fixed plus resolved executable.
+            cmd,
+            input=_codex_prompt(prompt=prompt, system_prompt=system_prompt),
+            capture_output=True,
+            text=True,
+            timeout=_CLI_TIMEOUT_SECONDS,
+            check=False,
+            env=env,
+        )
+    except subprocess.TimeoutExpired as exc:
+        raise OptimizerAssistantError(
+            f"codex CLI timed out after {_CLI_TIMEOUT_SECONDS}s"
+        ) from exc
+    except FileNotFoundError as exc:
+        raise OptimizerAssistantError("codex CLI not found on PATH") from exc
+
+    try:
+        content = output_path.read_text(encoding="utf-8").strip()
+    except OSError as exc:
+        raise OptimizerAssistantError("codex CLI did not write output") from exc
+    finally:
+        try:
+            output_path.unlink()
+        except OSError:
+            pass
+
+    if proc.returncode != 0:
+        stderr = proc.stderr.strip()
+        raise OptimizerAssistantError(
+            f"codex CLI exited {proc.returncode}: {stderr[:500]}"
+        )
+    if not content:
+        raise OptimizerAssistantError("codex CLI returned empty output")
+    return content
+
+
+def _temporary_output_path() -> Path:
+    handle = tempfile.NamedTemporaryFile(prefix="claude-smart-codex-", delete=False)
+    try:
+        return Path(handle.name)
+    finally:
+        handle.close()
+
+
+def _codex_prompt(*, prompt: str, system_prompt: str) -> str:
+    if not system_prompt:
+        return prompt
+    return f"{system_prompt}\n\n## Task\n{prompt}"
+
+
 if __name__ == "__main__":
     raise SystemExit(main())

package/plugin/uv.lock

@@ -419,10 +419,11 @@ wheels = [
 
 [[package]]
 name = "claude-smart"
-version = "0.2.25"
+version = "0.2.27"
 source = { editable = "." }
 dependencies = [
     { name = "chromadb" },
+    { name = "einops" },
     { name = "reflexio-ai" },
 ]
 
@@ -434,6 +435,7 @@ dev = [
 [package.metadata]
 requires-dist = [
     { name = "chromadb", specifier = ">=0.5" },
+    { name = "einops", specifier = ">=0.8.0" },
     { name = "reflexio-ai", specifier = ">=0.2.22" },
 ]
 
@@ -616,6 +618,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/51/79/119091c98e2bf49e24ed9f3ae69f816d715d2904aefa6a2baa039a2ba0b0/ecdsa-0.19.2-py2.py3-none-any.whl", hash = "sha256:840f5dc5e375c68f36c1a7a5b9caad28f95daa65185c9253c0c08dd952bb7399", size = 150818, upload-time = "2026-03-26T09:58:15.808Z" },
 ]
 
+[[package]]
+name = "einops"
+version = "0.8.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2c/77/850bef8d72ffb9219f0b1aac23fbc1bf7d038ee6ea666f331fa273031aa2/einops-0.8.2.tar.gz", hash = "sha256:609da665570e5e265e27283aab09e7f279ade90c4f01bcfca111f3d3e13f2827", size = 56261, upload-time = "2026-01-26T04:13:17.638Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/09/f8d8f8f31e4483c10a906437b4ce31bdf3d6d417b73fe33f1a8b59e34228/einops-0.8.2-py3-none-any.whl", hash = "sha256:54058201ac7087911181bfec4af6091bb59380360f069276601256a76af08193", size = 65638, upload-time = "2026-01-26T04:13:18.546Z" },
+]
+
 [[package]]
 name = "email-validator"
 version = "2.3.0"