zaxy-memory 2.3.2__tar.gz → 2.3.3__tar.gz

{zaxy_memory-2.3.2 → zaxy_memory-2.3.3}/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 All notable Zaxy release changes are recorded here.
 
+## 2.3.3 - 2026-06-13
+
+- Extended deterministic per-turn memory injection to **Codex**. Codex now ships
+  Claude-parity hooks, so its `UserPromptSubmit` event accepts the same
+  `additionalContext` schema. `render_hook_config("codex")` now emits a real
+  `hooks.json` carrying the `UserPromptSubmit` injection hook (plus
+  `SessionStart`/`Stop`/`PreCompact` lifecycle capture), for `.codex/hooks.json`
+  or a `[hooks]` table in `config.toml`. Install with
+  `zaxy hooks codex -o ~/.codex/hooks.json`.
+- Corrects the 2.3.2 note that per-turn injection was Claude Code-only: it now
+  works on Claude Code **and** Codex; only truly generic clients (with no
+  pre-prompt hook that re-injects output) remain advisory.
+- No runtime change — the `zaxy hook-event user-prompt-submit` CLI already
+  emitted the exact JSON both clients consume; this un-gates rendering/install.
+
 ## 2.3.2 - 2026-06-13
 
 - Closed the recall persistence gap with deterministic per-turn memory injection

{zaxy_memory-2.3.2 → zaxy_memory-2.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zaxy-memory
-Version: 2.3.2
+Version: 2.3.3
 Summary: Coordinator memory for auditable multi-agent projects
 Project-URL: Homepage, https://syndicalt.github.io/zaxy/
 Project-URL: Documentation, https://syndicalt.github.io/zaxy/docs/getting-started.html

{zaxy_memory-2.3.2 → zaxy_memory-2.3.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "zaxy-memory"
-version = "2.3.2"
+version = "2.3.3"
 description = "Coordinator memory for auditable multi-agent projects"
 readme = "README.md"
 requires-python = ">=3.11"

{zaxy_memory-2.3.2 → zaxy_memory-2.3.3}/src/zaxy/hooks.py

@@ -28,6 +28,39 @@ HIGH_VALUE_OBSERVATION_TYPES = (
 )
 
 
+def _command_hook_config(
+    events: list[tuple[str, str, str | None]],
+    *,
+    eventloom_path: str,
+    session_id: str,
+    source: str,
+) -> str:
+    """Render a Claude-Code/Codex-style hooks JSON for the given (event, trigger, matcher) set.
+
+    Both Claude Code and Codex consume the same `{"hooks": {Event: [{"hooks": [...]}]}}`
+    schema, including `UserPromptSubmit` with `additionalContext` injection.
+    """
+    hooks: dict[str, Any] = {}
+    for event_name, trigger, matcher in events:
+        group: dict[str, Any] = {
+            "hooks": [
+                {
+                    "type": "command",
+                    "command": _hook_command(
+                        trigger,
+                        eventloom_path=eventloom_path,
+                        session_id=session_id,
+                        source=source,
+                    ),
+                }
+            ]
+        }
+        if matcher is not None:
+            group["matcher"] = matcher
+        hooks[event_name] = [group]
+    return json.dumps({"hooks": hooks}, indent=2, sort_keys=True)
+
+
 def render_hook_config(
     client: HookClient | str,
     *,
@@ -41,64 +74,36 @@ def render_hook_config(
     session_id = domain_default_session(resolved_domain)
     hook_source = source or normalized
     if normalized == "claude-code":
-        return json.dumps(
-            {
-                "hooks": {
-                    "UserPromptSubmit": [
-                        {
-                            "hooks": [
-                                {
-                                    "type": "command",
-                                    "command": _hook_command(
-                                        "user-prompt-submit",
-                                        eventloom_path=eventloom_path,
-                                        session_id=session_id,
-                                        source=hook_source,
-                                    ),
-                                }
-                            ],
-                        }
-                    ],
-                    "Stop": [
-                        {
-                            "matcher": "*",
-                            "hooks": [
-                                {
-                                    "type": "command",
-                                    "command": _hook_command(
-                                        "stop",
-                                        eventloom_path=eventloom_path,
-                                        session_id=session_id,
-                                        source=hook_source,
-                                    ),
-                                }
-                            ],
-                        }
-                    ],
-                    "PreCompact": [
-                        {
-                            "hooks": [
-                                {
-                                    "type": "command",
-                                    "command": _hook_command(
-                                        "precompact",
-                                        eventloom_path=eventloom_path,
-                                        session_id=session_id,
-                                        source=hook_source,
-                                    ),
-                                }
-                            ],
-                        }
-                    ],
-                }
-            },
-            indent=2,
-            sort_keys=True,
+        return _command_hook_config(
+            [
+                ("UserPromptSubmit", "user-prompt-submit", None),
+                ("Stop", "stop", "*"),
+                ("PreCompact", "precompact", None),
+            ],
+            eventloom_path=eventloom_path,
+            session_id=session_id,
+            source=hook_source,
+        )
+    if normalized == "codex":
+        # Codex ships Claude-parity hooks: its UserPromptSubmit accepts the same
+        # additionalContext schema, so the deterministic per-turn recall injection
+        # works here too. Config lives in .codex/hooks.json or a [hooks] table in
+        # config.toml. SessionStart/Stop/PreCompact add lifecycle capture boundaries.
+        return _command_hook_config(
+            [
+                ("UserPromptSubmit", "user-prompt-submit", None),
+                ("SessionStart", "session-start", None),
+                ("Stop", "stop", None),
+                ("PreCompact", "precompact", None),
+            ],
+            eventloom_path=eventloom_path,
+            session_id=session_id,
+            source=hook_source,
         )
-    # NOTE: per-turn recall injection (UserPromptSubmit -> additionalContext) is
-    # Claude Code-only. Codex/generic clients expose no equivalent per-prompt hook,
-    # so they get capture (session-start/resume/stop/precompact) but NOT the
-    # deterministic re-injection lever; on those clients recall stays advisory.
+    # NOTE: per-turn recall injection (UserPromptSubmit -> additionalContext) needs a
+    # client that fires a pre-prompt hook and re-injects the hook's output -- Claude
+    # Code and Codex both do. Truly generic clients expose no such hook, so they get
+    # capture commands only and recall stays advisory there.
     return "\n".join(
         [
             "# Zaxy observer hook commands",

{zaxy_memory-2.3.2 → zaxy_memory-2.3.3}/tests/test_memory_injection.py

@@ -59,6 +59,24 @@ def test_render_hook_config_emits_user_prompt_submit() -> None:
     cmd = hooks["UserPromptSubmit"][0]["hooks"][0]["command"]
     assert "hook-event user-prompt-submit" in cmd
     assert "zaxy-default" in cmd  # canonical session derived from domain
+    # UserPromptSubmit takes no matcher.
+    assert "matcher" not in hooks["UserPromptSubmit"][0]
+
+
+def test_render_hook_config_emits_user_prompt_submit_for_codex() -> None:
+    # Codex ships Claude-parity hooks with the same additionalContext schema, so the
+    # injection lever must render for Codex too (config -> .codex/hooks.json).
+    config = json.loads(render_hook_config("codex", eventloom_path=".eventloom", domain="zaxy"))
+    hooks = config["hooks"]
+    assert "UserPromptSubmit" in hooks
+    cmd = hooks["UserPromptSubmit"][0]["hooks"][0]["command"]
+    assert "hook-event user-prompt-submit" in cmd
+    assert "--source codex" in cmd
+    assert "zaxy-default" in cmd
+    # Codex omits matcher for non-tool events.
+    assert "matcher" not in hooks["UserPromptSubmit"][0]
+    # Lifecycle capture boundaries also present.
+    assert {"SessionStart", "Stop", "PreCompact"} <= set(hooks)
 
 
 def test_cli_emits_additional_context_when_stale(tmp_path) -> None:  # type: ignore[no-untyped-def]