@suwujs/codex-vault 0.5.3 → 0.7.0

package/plugin/hooks/codex/session-start.py

@@ -0,0 +1,400 @@
+#!/usr/bin/env python3
+"""Session-start hook for Codex CLI — injects vault context into the agent's prompt.
+
+Outputs structured JSON: additionalContext for LLM.
+Banner is written to stderr (Codex CLI does not render systemMessage).
+
+Dynamic context: adapts git log window, reads full North Star,
+shows all active work, and includes uncommitted changes.
+"""
+import json
+import os
+import re
+import subprocess
+import sys
+from collections import Counter
+from datetime import datetime
+from pathlib import Path
+
+
+def _find_vault_root():
+    """Find vault root from CWD — check for Home.md/brain/, then vault/ subdir."""
+    cwd = os.environ.get("CODEX_PROJECT_DIR", os.getcwd())
+    if os.path.isfile(os.path.join(cwd, "Home.md")) or os.path.isdir(os.path.join(cwd, "brain")):
+        return cwd
+    vault_sub = os.path.join(cwd, "vault")
+    if os.path.isdir(vault_sub) and (
+        os.path.isfile(os.path.join(vault_sub, "Home.md")) or
+        os.path.isdir(os.path.join(vault_sub, "brain"))
+    ):
+        return vault_sub
+    return None
+
+
+def _run_git(args, cwd, timeout=5):
+    """Run git command and return stdout lines."""
+    try:
+        result = subprocess.run(
+            ["git"] + args,
+            capture_output=True, text=True, cwd=cwd, timeout=timeout,
+        )
+        return result.stdout.strip().splitlines() if result.stdout.strip() else []
+    except Exception:
+        return []
+
+
+def _git_log_oneline(cwd, since=None, max_count=None):
+    """Get git log --oneline entries."""
+    args = ["log", "--oneline", "--no-merges"]
+    if since:
+        args.append(f"--since={since}")
+    if max_count:
+        args.extend(["-n", str(max_count)])
+    return _run_git(args, cwd)
+
+
+def _git_status_short(cwd):
+    """Get git status --short output."""
+    return _run_git(["status", "--short", "--", "."], cwd)
+
+
+def _read_file(path):
+    """Read file content, return empty string on error."""
+    try:
+        return Path(path).read_text(encoding="utf-8")
+    except Exception:
+        return ""
+
+
+def _find_md_files(vault_dir):
+    """Find all .md files in vault, excluding non-vault directories."""
+    exclude = {".git", ".obsidian", "thinking", ".claude", ".codex",
+               ".codex-vault", ".codex-mem", "node_modules"}
+    files = []
+    for root, dirs, filenames in os.walk(vault_dir):
+        dirs[:] = [d for d in dirs if d not in exclude]
+        for f in filenames:
+            if f.endswith(".md"):
+                rel = os.path.relpath(os.path.join(root, f), vault_dir)
+                files.append(f"./{rel}")
+    return sorted(files)
+
+
+def _folder_summary(all_files):
+    """Generate folder summary with file counts."""
+    folders = Counter()
+    for f in all_files:
+        parts = f[2:].split("/")  # strip ./
+        folders[parts[0] if len(parts) > 1 else "."] += 1
+    return [f"  {folder}/ ({count} files)"
+            for folder, count in folders.most_common()]
+
+
+def _key_files(all_files):
+    """Filter for key vault files."""
+    pattern = re.compile(
+        r"(Home|Index|North Star|Memories|Key Decisions|Patterns|log)\.md$")
+    return [f for f in all_files if pattern.search(f)]
+
+
+def _mtime_ok(vault_dir, rel_path, cutoff):
+    """Check if file was modified after cutoff timestamp."""
+    try:
+        return os.path.getmtime(os.path.join(vault_dir, rel_path.lstrip("./"))) > cutoff
+    except Exception:
+        return False
+
+
+def _north_star_goal(vault_dir):
+    """Extract first goal from North Star for banner display."""
+    ns_path = os.path.join(vault_dir, "brain", "North Star.md")
+    if not os.path.isfile(ns_path):
+        return None
+    content = _read_file(ns_path)
+    in_focus = False
+    for line in content.splitlines():
+        if re.match(r"^## Current Focus", line):
+            in_focus = True
+            continue
+        if in_focus and line.startswith("## "):
+            break
+        if in_focus and re.match(r"^- .+", line):
+            goal = line[2:].strip()
+            return goal[:40] if goal else None
+    return None
+
+
+# ── Context builder (→ additionalContext for LLM) ──────────────────────
+
+
+def _build_context(vault_dir):
+    lines = []
+    lines.append("## Session Context")
+    lines.append("")
+
+    # Date
+    lines.append("### Date")
+    now = datetime.now()
+    lines.append(f"{now.strftime('%Y-%m-%d')} ({now.strftime('%A')})")
+    lines.append("")
+
+    # North Star — full file
+    lines.append("### North Star")
+    ns_path = os.path.join(vault_dir, "brain", "North Star.md")
+    if os.path.isfile(ns_path):
+        lines.append(_read_file(ns_path))
+    else:
+        lines.append("(No North Star found — create brain/North Star.md to set goals)")
+    lines.append("")
+
+    # Recent changes — adaptive window
+    lines.append("### Recent Changes")
+    commits_48h = _git_log_oneline(vault_dir, since="48 hours ago")
+    if commits_48h:
+        lines.append("(last 48 hours)")
+        lines.extend(commits_48h[:15])
+    else:
+        commits_7d = _git_log_oneline(vault_dir, since="7 days ago")
+        if commits_7d:
+            lines.append("(nothing in 48h — showing last 7 days)")
+            lines.extend(commits_7d[:15])
+        else:
+            lines.append("(nothing recent — showing last 5 commits)")
+            commits = _git_log_oneline(vault_dir, max_count=5)
+            lines.extend(commits if commits else ["(no git history)"])
+    lines.append("")
+
+    # Recent operations from log.md
+    lines.append("### Recent Operations")
+    log_path = os.path.join(vault_dir, "log.md")
+    if os.path.isfile(log_path):
+        entries = [l for l in _read_file(log_path).splitlines()
+                   if l.startswith("## [")]
+        lines.extend(entries[-5:] if entries else ["(no entries in log.md)"])
+    else:
+        lines.append("(no log.md)")
+    lines.append("")
+
+    # Active work
+    lines.append("### Active Work")
+    active_dir = os.path.join(vault_dir, "work", "active")
+    if os.path.isdir(active_dir):
+        work_files = sorted(f for f in os.listdir(active_dir) if f.endswith(".md"))
+        if work_files:
+            for f in work_files:
+                lines.append(f.replace(".md", ""))
+        else:
+            lines.append("(none)")
+    else:
+        lines.append("(no work/active/ directory)")
+    lines.append("")
+
+    # Uncommitted changes
+    lines.append("### Uncommitted Changes")
+    changes = _git_status_short(vault_dir)
+    lines.extend(changes[:20] if changes else ["(working tree clean)"])
+    lines.append("")
+
+    # Recently modified brain files
+    lines.append("### Recently Modified Brain Files")
+    brain_dir = os.path.join(vault_dir, "brain")
+    if os.path.isdir(brain_dir):
+        cutoff = datetime.now().timestamp() - 7 * 86400
+        recent = sorted(
+            f.replace(".md", "")
+            for f in os.listdir(brain_dir)
+            if f.endswith(".md") and os.path.getmtime(os.path.join(brain_dir, f)) > cutoff
+        )
+        if recent:
+            lines.append("(modified in last 7 days)")
+            lines.extend(recent)
+        else:
+            lines.append("(no recent changes)")
+    lines.append("")
+
+    # Vault file listing — tiered
+    lines.append("### Vault Files")
+    all_files = _find_md_files(vault_dir)
+    n = len(all_files)
+
+    if n <= 20:
+        lines.extend(all_files)
+
+    elif n <= 50:
+        hot = [f for f in all_files
+               if not re.match(r"\./sources/|\./work/archive/", f)]
+        cold = n - len(hot)
+        lines.extend(hot)
+        if cold > 0:
+            lines.append("")
+            lines.append(f"(+ {cold} files in sources/ and work/archive/ — use /recall to search)")
+
+    elif n <= 150:
+        lines.append(f"({n} files — showing summary)")
+        lines.append("")
+        lines.extend(_folder_summary(all_files))
+        lines.append("")
+        lines.append("Recently modified (7 days):")
+        cutoff = datetime.now().timestamp() - 7 * 86400
+        recent = [f for f in all_files if _mtime_ok(vault_dir, f, cutoff)]
+        lines.extend(recent if recent else ["  (none)"])
+        lines.append("")
+        lines.append("Key files:")
+        lines.extend(_key_files(all_files))
+
+    else:
+        lines.append(f"({n} files — showing summary)")
+        lines.append("")
+        lines.extend(_folder_summary(all_files))
+        lines.append("")
+        lines.append("Recently modified (3 days):")
+        cutoff = datetime.now().timestamp() - 3 * 86400
+        recent = [f for f in all_files if _mtime_ok(vault_dir, f, cutoff)]
+        lines.extend(recent if recent else ["  (none)"])
+        lines.append("")
+        lines.append("Key files:")
+        lines.extend(_key_files(all_files))
+        lines.append("")
+        lines.append("Use /recall <topic> to search the vault.")
+
+    return "\n".join(lines)
+
+
+# ── ANSI colors (oh-my-codex style) ──────────────────────────────────
+
+RESET = "\x1b[0m"
+BOLD = "\x1b[1m"
+DIM = "\x1b[2m"
+CYAN = "\x1b[36m"
+GREEN = "\x1b[32m"
+YELLOW = "\x1b[33m"
+SEP = f" {DIM}|{RESET} "
+
+
+def _c(code, text):
+    return f"{code}{text}{RESET}"
+
+
+# ── Banner builder (→ stderr for terminal) ────────────────────────────
+
+
+def _build_banner(vault_dir):
+    # --- Line 1: statusline ---
+    elements = []
+
+    # Git branch
+    branch = _run_git(["rev-parse", "--abbrev-ref", "HEAD"], vault_dir)
+    if branch:
+        elements.append(_c(CYAN, branch[0]))
+
+    # North Star goal
+    goal = _north_star_goal(vault_dir)
+    if goal:
+        elements.append(f"\U0001f3af {goal}")
+    else:
+        elements.append(_c(DIM, "\U0001f3af no goal set"))
+
+    # Active work
+    active_dir = os.path.join(vault_dir, "work", "active")
+    work_files = sorted(
+        f.replace(".md", "")
+        for f in os.listdir(active_dir) if f.endswith(".md")
+    ) if os.path.isdir(active_dir) else []
+    if work_files:
+        names = ", ".join(work_files[:3])
+        suffix = f" +{len(work_files) - 3}" if len(work_files) > 3 else ""
+        elements.append(_c(GREEN, f"active:{len(work_files)}") + _c(DIM, f" {names}{suffix}"))
+    else:
+        elements.append(_c(DIM, "active:0"))
+
+    # Changes
+    changes = _git_status_short(vault_dir)
+    if changes:
+        elements.append(_c(YELLOW, f"changes:{len(changes)}"))
+    else:
+        elements.append(_c(GREEN, "clean"))
+
+    label = _c(BOLD, "[Vault]")
+    statusline = label + " " + SEP.join(elements)
+
+    # --- Line 2+: recent commits ---
+    lines = ["", statusline]
+    commits = _git_log_oneline(vault_dir, since="7 days ago")
+    if not commits:
+        commits = _git_log_oneline(vault_dir, max_count=3)
+    if commits:
+        for c in commits[:3]:
+            # hash in cyan, message in dim
+            parts = c.split(" ", 1)
+            if len(parts) == 2:
+                lines.append(f"  {_c(DIM, parts[0])} {_c(DIM, parts[1])}")
+            else:
+                lines.append(f"  {_c(DIM, c)}")
+
+    # --- Line: vault file count ---
+    all_files = _find_md_files(vault_dir)
+    lines.append(_c(DIM, f"  {len(all_files)} notes"))
+    lines.append("")
+
+    return "\n".join(lines)
+
+
+# ── Main ───────────────────────────────────────────────────────────────
+
+
+def main():
+    vault_dir = _find_vault_root()
+    if not vault_dir:
+        output = {
+            "hookSpecificOutput": {
+                "hookEventName": "SessionStart",
+                "additionalContext": "## Session Context\n\n(No vault found)"
+            }
+        }
+        sys.stdout.write(json.dumps(output) + "\n")
+        sys.exit(0)
+
+    # Read hook input for session metadata
+    try:
+        event = json.load(sys.stdin)
+    except Exception:
+        event = {}
+
+    context = _build_context(vault_dir)
+
+    # Build a short summary for user-facing display
+    goal = _north_star_goal(vault_dir)
+    active_dir = os.path.join(vault_dir, "work", "active")
+    work_count = len([f for f in os.listdir(active_dir) if f.endswith(".md")]) if os.path.isdir(active_dir) else 0
+    changes = _git_status_short(vault_dir)
+    all_files = _find_md_files(vault_dir)
+
+    summary_parts = ["[Vault]"]
+    branch = _run_git(["rev-parse", "--abbrev-ref", "HEAD"], vault_dir)
+    if branch:
+        summary_parts.append(branch[0])
+    if goal:
+        summary_parts.append(f"goal: {goal}")
+    summary_parts.append(f"active:{work_count}")
+    summary_parts.append(f"changes:{len(changes)}")
+    summary_parts.append(f"{len(all_files)} notes")
+    summary = " | ".join(summary_parts)
+
+    output = {
+        "hookSpecificOutput": {
+            "hookEventName": "SessionStart",
+            "additionalContext": context
+        },
+        "systemMessage": summary
+    }
+    sys.stdout.write(json.dumps(output) + "\n")
+    sys.stdout.flush()
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception:
+        # Never block session start
+        sys.exit(0)

package/plugin/hooks/codex/validate-write.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+"""PostToolUse hook for Codex CLI — Bash command validation.
+
+Checks Bash command output for hard failures (command not found,
+permission denied, missing paths) and non-zero exit codes with
+informative output. Modeled after oh-my-codex's native PostToolUse.
+"""
+import json
+import re
+import sys
+
+
+HARD_FAILURE_PATTERNS = re.compile(
+    r"command not found|permission denied|no such file or directory",
+    re.IGNORECASE,
+)
+
+
+def _safe_string(value):
+    return value if isinstance(value, str) else ""
+
+
+def _safe_int(value):
+    if isinstance(value, int):
+        return value
+    if isinstance(value, str) and value.strip().lstrip("-").isdigit():
+        return int(value.strip())
+    return None
+
+
+def _parse_tool_response(raw):
+    """Try to parse tool_response as JSON dict."""
+    if isinstance(raw, dict):
+        return raw
+    if isinstance(raw, str):
+        try:
+            parsed = json.loads(raw)
+            if isinstance(parsed, dict):
+                return parsed
+        except (ValueError, TypeError):
+            pass
+    return None
+
+
+def main():
+    try:
+        payload = json.load(sys.stdin)
+    except (ValueError, EOFError, OSError):
+        sys.exit(0)
+
+    tool_name = _safe_string(payload.get("tool_name", "")).strip()
+    if tool_name != "Bash":
+        sys.exit(0)
+
+    # Extract command and response
+    tool_input = payload.get("tool_input") if isinstance(payload.get("tool_input"), dict) else {}
+    command = _safe_string(tool_input.get("command", "")).strip()
+
+    raw_response = payload.get("tool_response")
+    parsed = _parse_tool_response(raw_response)
+
+    exit_code = None
+    stdout_text = ""
+    stderr_text = ""
+
+    if parsed:
+        exit_code = _safe_int(parsed.get("exit_code")) or _safe_int(parsed.get("exitCode"))
+        stdout_text = _safe_string(parsed.get("stdout", "")).strip()
+        stderr_text = _safe_string(parsed.get("stderr", "")).strip()
+    else:
+        stdout_text = _safe_string(raw_response).strip()
+
+    combined = f"{stderr_text}\n{stdout_text}".strip()
+    if not combined:
+        sys.exit(0)
+
+    # Check for hard failures
+    if HARD_FAILURE_PATTERNS.search(combined):
+        output = {
+            "decision": "block",
+            "reason": "Bash output indicates a command/setup failure that should be fixed before retrying.",
+            "hookSpecificOutput": {
+                "hookEventName": "PostToolUse",
+                "additionalContext": (
+                    "Bash reported `command not found`, `permission denied`, or a missing file/path. "
+                    "Verify the command, dependency installation, PATH, file permissions, "
+                    "and referenced paths before retrying."
+                ),
+            },
+        }
+        sys.stdout.write(json.dumps(output) + "\n")
+        sys.stdout.flush()
+        sys.exit(0)
+
+    # Check for non-zero exit code with informative output
+    if exit_code is not None and exit_code != 0 and len(combined) > 0:
+        output = {
+            "decision": "block",
+            "reason": "Bash command returned a non-zero exit code but produced useful output that should be reviewed before retrying.",
+            "hookSpecificOutput": {
+                "hookEventName": "PostToolUse",
+                "additionalContext": (
+                    "The Bash output appears informative despite the non-zero exit code. "
+                    "Review and report the output before retrying instead of assuming the command simply failed."
+                ),
+            },
+        }
+        sys.stdout.write(json.dumps(output) + "\n")
+        sys.stdout.flush()
+        sys.exit(0)
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception:
+        sys.exit(0)

package/plugin/install.sh

@@ -90,13 +90,14 @@ fi
 # --- Copy hooks into vault (makes vault self-contained) ---
 
 HOOKS_DIR="$VAULT_DIR/.codex-vault/hooks"
-mkdir -p "$HOOKS_DIR"
-cp "$REPO_DIR/plugin/hooks/"* "$HOOKS_DIR/"
-chmod +x "$HOOKS_DIR/"*.sh "$HOOKS_DIR/"*.py 2>/dev/null || true
-echo "[+] Hook scripts copied to vault/.codex-vault/hooks/"
+mkdir -p "$HOOKS_DIR/claude" "$HOOKS_DIR/codex"
+cp "$REPO_DIR/plugin/hooks/claude/"* "$HOOKS_DIR/claude/"
+cp "$REPO_DIR/plugin/hooks/codex/"* "$HOOKS_DIR/codex/"
+chmod +x "$HOOKS_DIR/claude/"*.py "$HOOKS_DIR/codex/"*.py 2>/dev/null || true
+echo "[+] Hook scripts copied to vault/.codex-vault/hooks/{claude,codex}/"
 echo ""
 
-# --- Helper: merge hooks into existing settings.json ---
+# --- Helper: merge hooks into existing settings.json (Claude Code) ---
 # Uses python3 for reliable JSON manipulation.
 
 merge_hooks_json() {
@@ -153,6 +154,60 @@ with open(target_file, "w") as f:
 PYEOF
 }
 
+# --- Helper: merge hooks into existing hooks.json (Codex CLI) ---
+# Codex CLI differences:
+#   - SessionStart matcher: "startup|resume" (no compact)
+#   - No PostToolUse hook (Codex only supports Bash matcher, not Write|Edit)
+
+merge_codex_hooks_json() {
+  local target_file="$1"
+  local hooks_rel="$2"
+
+  CVAULT_TARGET_FILE="$target_file" CVAULT_HOOKS_REL="$hooks_rel" python3 <<'PYEOF'
+import json, os
+
+target_file = os.environ["CVAULT_TARGET_FILE"]
+hooks_rel = os.environ["CVAULT_HOOKS_REL"]
+
+new_hooks = {
+    "SessionStart": [{
+        "matcher": "startup|resume",
+        "hooks": [{"type": "command", "command": f"python3 {hooks_rel}/session-start.py", "timeout": 30,
+                    "statusMessage": "\U0001f4da Codex-Vault loading..."}]
+    }],
+    "UserPromptSubmit": [{
+        "hooks": [{"type": "command", "command": f"python3 {hooks_rel}/classify-message.py", "timeout": 15}]
+    }],
+}
+
+if os.path.isfile(target_file):
+    with open(target_file) as f:
+        existing = json.load(f)
+else:
+    existing = {}
+
+if "hooks" not in existing:
+    existing["hooks"] = {}
+
+for event, entries in new_hooks.items():
+    if event not in existing["hooks"]:
+        existing["hooks"][event] = entries
+    else:
+        existing_cmds = set()
+        for rule in existing["hooks"][event]:
+            for h in rule.get("hooks", []):
+                existing_cmds.add(h.get("command", ""))
+        for entry in entries:
+            cmds = [h.get("command", "") for h in entry.get("hooks", [])]
+            if not any(c in existing_cmds for c in cmds):
+                existing["hooks"][event].append(entry)
+
+with open(target_file, "w") as f:
+    json.dump(existing, f, indent=2)
+    f.write("\n")
+PYEOF
+}
+
 # --- Helper: append codex-vault section to instruction file ---
 
 append_instructions() {
@@ -208,7 +263,7 @@ setup_claude() {
   if [ "$MODE" = "integrated" ]; then
     # Integrated: merge hooks into project root .claude/settings.json
     mkdir -p "$CONFIG_DIR/.claude"
-    merge_hooks_json "$CONFIG_DIR/.claude/settings.json" "$HOOKS_REL"
+    merge_hooks_json "$CONFIG_DIR/.claude/settings.json" "$HOOKS_REL/claude"
     echo "  [+] .claude/settings.json (hooks merged at project root)"
 
     # Append instructions to project root CLAUDE.md
@@ -219,7 +274,7 @@ setup_claude() {
     install_skills "$CONFIG_DIR" ".claude"
   else
     # Standalone: write directly into vault/ (original behavior)
-    merge_hooks_json "$VAULT_DIR/.claude/settings.json" "$HOOKS_REL"
+    merge_hooks_json "$VAULT_DIR/.claude/settings.json" "$HOOKS_REL/claude"
     echo "  [+] .claude/settings.json (3 hooks)"
 
     # Install skills into vault/.claude/skills/
@@ -270,7 +325,7 @@ setup_codex() {
   if [ "$MODE" = "integrated" ]; then
     # Integrated: merge hooks into project root .codex/hooks.json
     mkdir -p "$CONFIG_DIR/.codex"
-    merge_hooks_json "$CONFIG_DIR/.codex/hooks.json" "$HOOKS_REL"
+    merge_codex_hooks_json "$CONFIG_DIR/.codex/hooks.json" "$HOOKS_REL/codex"
     echo "  [+] .codex/hooks.json (hooks merged at project root)"
 
     if [ "$has_claude" = true ]; then
@@ -290,8 +345,8 @@ setup_codex() {
     # Standalone: write directly into vault/ (original behavior)
     mkdir -p "$VAULT_DIR/.codex"
 
-    merge_hooks_json "$VAULT_DIR/.codex/hooks.json" "$HOOKS_REL"
-    echo "  [+] .codex/hooks.json (3 hooks)"
+    merge_codex_hooks_json "$VAULT_DIR/.codex/hooks.json" "$HOOKS_REL/codex"
+    echo "  [+] .codex/hooks.json (2 hooks)"
 
     # Enable hooks feature flag
     enable_codex_hooks "$VAULT_DIR"

package/vault/.claude/settings.json

@@ -6,7 +6,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "python3 .codex-vault/hooks/session-start.py",
+            "command": "python3 .codex-vault/hooks/claude/session-start.py",
             "timeout": 30
           }
         ]
@@ -17,7 +17,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "python3 .codex-vault/hooks/classify-message.py",
+            "command": "python3 .codex-vault/hooks/claude/classify-message.py",
             "timeout": 15
           }
         ]
@@ -29,7 +29,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "python3 .codex-vault/hooks/validate-write.py",
+            "command": "python3 .codex-vault/hooks/claude/validate-write.py",
             "timeout": 15
           }
         ]

package/vault/.codex/hooks.json

@@ -6,9 +6,9 @@
         "hooks": [
           {
             "type": "command",
-            "command": "python3 .codex-vault/hooks/session-start.py",
+            "command": "python3 .codex-vault/hooks/codex/session-start.py",
             "timeout": 30,
-            "statusMessage": "📚 Codex-Vault loading..."
+            "statusMessage": "\ud83d\udcda Codex-Vault loading..."
           }
         ]
       }
@@ -18,19 +18,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "python3 .codex-vault/hooks/classify-message.py",
-            "timeout": 15
-          }
-        ]
-      }
-    ],
-    "PostToolUse": [
-      {
-        "matcher": "Write|Edit",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "python3 .codex-vault/hooks/validate-write.py",
+            "command": "python3 .codex-vault/hooks/codex/classify-message.py",
             "timeout": 15
           }
         ]