@suwujs/codex-vault 0.1.0

package/plugin/install.sh

@@ -0,0 +1,350 @@
+#!/bin/bash
+set -eo pipefail
+
+# Codex-Vault installer
+# Detects installed LLM agents and generates the appropriate configuration.
+# Supports: Claude Code, Codex CLI.
+#
+# Two modes:
+#   Standalone — run from within the codex-vault repo (vault/ is the working directory)
+#   Integrated — run from a user's project root (vault/ becomes a subdirectory)
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+REPO_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+PROJECT_DIR="$(pwd)"
+
+echo "=== Codex-Vault Installer ==="
+echo ""
+
+# --- Detect mode ---
+# If CWD is the codex-vault repo (or vault/), use standalone mode.
+# Otherwise, use integrated mode (install into user's project).
+
+MODE="integrated"
+if [ "$PROJECT_DIR" = "$REPO_DIR" ] || [ "$PROJECT_DIR" = "$REPO_DIR/vault" ]; then
+  MODE="standalone"
+fi
+# Also detect if inside repo subdirectories
+case "$PROJECT_DIR" in
+  "$REPO_DIR"/*) MODE="standalone" ;;
+esac
+
+if [ "$MODE" = "standalone" ]; then
+  VAULT_DIR="$REPO_DIR/vault"
+  CONFIG_DIR="$VAULT_DIR"            # configs go inside vault/
+  HOOKS_REL=".codex-vault/hooks"       # relative to vault/
+  echo "[*] Standalone mode — vault is the working directory"
+else
+  VAULT_DIR="$PROJECT_DIR/vault"
+  CONFIG_DIR="$PROJECT_DIR"          # configs go at project root
+  HOOKS_REL="vault/.codex-vault/hooks" # relative to project root
+  echo "[*] Integrated mode — installing into $(basename "$PROJECT_DIR")/"
+fi
+
+echo ""
+
+# --- Detect agents ---
+
+AGENTS=()
+
+if command -v claude &>/dev/null; then
+  AGENTS+=("claude")
+  echo "[+] Claude Code detected"
+fi
+
+if command -v codex &>/dev/null; then
+  AGENTS+=("codex")
+  echo "[+] Codex CLI detected"
+fi
+
+if [ ${#AGENTS[@]} -eq 0 ]; then
+  echo "[!] No supported agents found."
+  echo "    Install Claude Code: https://docs.anthropic.com/en/docs/claude-code"
+  echo "    Install Codex CLI:   https://github.com/openai/codex"
+  echo ""
+  echo "    You can still use the vault manually — just open it in Obsidian."
+  exit 0
+fi
+
+echo ""
+
+# --- Copy vault template (integrated mode only) ---
+
+if [ "$MODE" = "integrated" ]; then
+  if [ -d "$VAULT_DIR" ] && [ -f "$VAULT_DIR/Home.md" ]; then
+    echo "[*] Vault already exists at vault/ — skipping template copy"
+  else
+    echo "[+] Creating vault from template..."
+    mkdir -p "$VAULT_DIR"
+    # Copy vault contents, excluding agent-specific configs (we generate those)
+    # Use cp -r (universally available) instead of rsync
+    cp -r "$REPO_DIR/vault/"* "$VAULT_DIR/" 2>/dev/null || true
+    cp -r "$REPO_DIR/vault/".* "$VAULT_DIR/" 2>/dev/null || true
+    # Remove agent configs — we generate fresh ones for the target layout
+    rm -rf "$VAULT_DIR/.claude" "$VAULT_DIR/.codex" "$VAULT_DIR/CLAUDE.md" "$VAULT_DIR/AGENTS.md" 2>/dev/null || true
+    echo "    Copied template to vault/"
+  fi
+  echo ""
+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/"
+echo ""
+
+# --- Helper: merge hooks into existing settings.json ---
+# Uses python3 for reliable JSON manipulation.
+
+merge_hooks_json() {
+  local target_file="$1"
+  local hooks_rel="$2"
+
+  # Pass data via env vars to python3 — no shell interpolation in python code.
+  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|compact",
+        "hooks": [{"type": "command", "command": f"bash {hooks_rel}/session-start.sh", "timeout": 30}]
+    }],
+    "UserPromptSubmit": [{
+        "hooks": [{"type": "command", "command": f"python3 {hooks_rel}/classify-message.py", "timeout": 15}]
+    }],
+    "PostToolUse": [{
+        "matcher": "Write|Edit",
+        "hooks": [{"type": "command", "command": f"python3 {hooks_rel}/validate-write.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 each hook event, append entries (avoid duplicates by checking command)
+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() {
+  local target_file="$1"
+
+  # Generate instructions: heading + blank line + body (skip first 2 lines of instructions.md)
+  local section_content
+  section_content="$(printf '# Codex-Vault\n\n'; tail -n +3 "$REPO_DIR/plugin/instructions.md")"
+
+  if [ -f "$target_file" ]; then
+    # Check if section already exists
+    if grep -q "^# Codex-Vault" "$target_file"; then
+      echo "    (codex-vault section already present — skipping)"
+      return
+    fi
+    # Append with separator
+    printf '\n---\n%s\n' "$section_content" >> "$target_file"
+  else
+    echo "$section_content" > "$target_file"
+  fi
+}
+
+# --- Setup functions ---
+
+# --- Helper: install skills into .<agent>/skills/<name>/SKILL.md ---
+
+install_skills() {
+  local target_dir="$1"
+  local agent_dir="$2"   # .claude or .codex
+  local src_dir="$REPO_DIR/plugin/skills"
+  local count=0
+
+  if [ ! -d "$src_dir" ]; then
+    return
+  fi
+
+  for src_file in "$src_dir"/*.md; do
+    [ -f "$src_file" ] || continue
+    local skill_name
+    skill_name=$(basename "$src_file" .md)
+    local skill_dir="$target_dir/$agent_dir/skills/$skill_name"
+    mkdir -p "$skill_dir"
+    cp "$src_file" "$skill_dir/SKILL.md"
+    ((count++))
+  done
+
+  echo "  [+] $agent_dir/skills/ ($count skills)"
+}
+
+setup_claude() {
+  echo "--- Setting up Claude Code ---"
+
+  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"
+    echo "  [+] .claude/settings.json (hooks merged at project root)"
+
+    # Append instructions to project root CLAUDE.md
+    append_instructions "$CONFIG_DIR/CLAUDE.md"
+    echo "  [+] CLAUDE.md (codex-vault section appended at project root)"
+
+    # Install skills into project root .claude/skills/
+    install_skills "$CONFIG_DIR" ".claude"
+  else
+    # Standalone: write directly into vault/ (original behavior)
+    merge_hooks_json "$VAULT_DIR/.claude/settings.json" "$HOOKS_REL"
+    echo "  [+] .claude/settings.json (3 hooks)"
+
+    # Install skills into vault/.claude/skills/
+    install_skills "$VAULT_DIR" ".claude"
+
+    append_instructions "$VAULT_DIR/CLAUDE.md"
+    echo "  [+] CLAUDE.md"
+  fi
+  echo ""
+}
+
+# --- Helper: enable codex hooks feature flag in config.toml ---
+
+enable_codex_hooks() {
+  local config_file="$1/.codex/config.toml"
+  mkdir -p "$(dirname "$config_file")"
+
+  if [ -f "$config_file" ]; then
+    if grep -q "codex_hooks" "$config_file"; then
+      # Already has the flag — ensure it's true
+      sed -i.bak 's/codex_hooks *= *false/codex_hooks = true/' "$config_file"
+      rm -f "${config_file}.bak"
+    elif grep -q "\[features\]" "$config_file"; then
+      # Has [features] section but no codex_hooks — append under it
+      sed -i.bak '/\[features\]/a\
+codex_hooks = true' "$config_file"
+      rm -f "${config_file}.bak"
+    else
+      # No [features] section — append it
+      printf '\n[features]\ncodex_hooks = true\n' >> "$config_file"
+    fi
+  else
+    printf '[features]\ncodex_hooks = true\n' > "$config_file"
+  fi
+
+  echo "  [+] .codex/config.toml (hooks enabled)"
+}
+
+setup_codex() {
+  echo "--- Setting up Codex CLI ---"
+
+  # Check if Claude Code is also installed — if so, AGENTS.md just references CLAUDE.md
+  local has_claude=false
+  for a in "${AGENTS[@]}"; do
+    [ "$a" = "claude" ] && has_claude=true
+  done
+
+  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"
+    echo "  [+] .codex/hooks.json (hooks merged at project root)"
+
+    if [ "$has_claude" = true ]; then
+      echo "@CLAUDE.md" > "$CONFIG_DIR/AGENTS.md"
+      echo "  [+] AGENTS.md (references @CLAUDE.md)"
+    else
+      append_instructions "$CONFIG_DIR/AGENTS.md"
+      echo "  [+] AGENTS.md (codex-vault section appended at project root)"
+    fi
+
+    # Enable hooks feature flag
+    enable_codex_hooks "$CONFIG_DIR"
+
+    # Install skills into project root .codex/skills/
+    install_skills "$CONFIG_DIR" ".codex"
+  else
+    # 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)"
+
+    # Enable hooks feature flag
+    enable_codex_hooks "$VAULT_DIR"
+
+    if [ "$has_claude" = true ]; then
+      echo "@CLAUDE.md" > "$VAULT_DIR/AGENTS.md"
+      echo "  [+] AGENTS.md (references @CLAUDE.md)"
+    else
+      append_instructions "$VAULT_DIR/AGENTS.md"
+      echo "  [+] AGENTS.md"
+    fi
+
+    # Install skills into vault/.codex/skills/
+    install_skills "$VAULT_DIR" ".codex"
+  fi
+  echo ""
+}
+
+# --- Run setup for each detected agent ---
+
+for agent in "${AGENTS[@]}"; do
+  "setup_$agent"
+done
+
+# --- Done ---
+
+echo "=== Done ==="
+echo ""
+
+if [ "$MODE" = "integrated" ]; then
+  echo "Vault created at: $VAULT_DIR"
+  echo "Hooks registered at: $CONFIG_DIR/"
+  echo ""
+  echo "Next steps:"
+  echo "  cd $PROJECT_DIR"
+  for agent in "${AGENTS[@]}"; do
+    case $agent in
+      claude) echo "  claude                  # hooks + vault work out of the box" ;;
+      codex)  echo "  codex                   # hooks + vault work out of the box" ;;
+    esac
+  done
+else
+  echo "Your vault is ready at: $VAULT_DIR"
+  echo ""
+  echo "Next steps:"
+  echo "  cd $VAULT_DIR"
+  for agent in "${AGENTS[@]}"; do
+    case $agent in
+      claude) echo "  claude                  # start with Claude Code" ;;
+      codex)  echo "  codex                   # start with Codex CLI" ;;
+    esac
+  done
+fi
+
+echo ""
+echo "  Fill in brain/North Star.md with your goals, then start talking."

package/plugin/instructions.md

@@ -0,0 +1,118 @@
+# Codex-Vault — Core Instructions
+
+A structured knowledge vault maintained by an LLM agent. You write notes, maintain links, and keep indexes current. The human curates sources, directs analysis, and asks questions.
+
+## Vault Structure
+
+| Folder | Purpose |
+|--------|---------|
+| `Home.md` | Vault entry point — quick links, current focus |
+| `brain/` | Persistent memory — goals, decisions, patterns |
+| `work/` | Work notes index (`Index.md`) |
+| `work/active/` | Current projects (move to archive when done) |
+| `work/archive/` | Completed work |
+| `templates/` | Note templates with YAML frontmatter |
+| `sources/` | Raw source documents — immutable, LLM reads only |
+| `thinking/` | Scratchpad — promote findings, then delete |
+| `reference/` | Saved answers and analyses from query writeback |
+
+## Session Lifecycle
+
+### Start
+
+The SessionStart hook injects: North Star goals, recent git changes, active work, vault file listing. You start with context, not a blank slate.
+
+### Work
+
+1. The classify hook detects intent and suggests skills — **do not auto-execute**. Suggest the skill to the user and let them decide.
+2. Available skills: `/dump`, `/recall`, `/ingest`, `/wrap-up`
+3. Search before creating — check if a related note exists (use `/recall <topic>` for targeted vault search)
+4. Update `work/Index.md` if a new note was created
+
+### End
+
+When the user says "wrap up" or similar:
+1. Verify new notes have frontmatter and wikilinks
+2. Update `work/Index.md` with any new or completed notes
+3. Archive completed projects: move from `work/active/` to `work/archive/`
+4. Check if `brain/` notes need updating with new decisions or patterns
+
+## Creating Notes
+
+1. **Always use YAML frontmatter**: `date`, `description` (~150 chars), `tags`
+2. **Use templates** from `templates/`
+3. **Place files correctly**: active work in `work/active/`, completed in `work/archive/`, source summaries in `work/active/` (tag: `source-summary`), drafts in `thinking/`
+4. **Name files descriptively** — use the note title as filename
+
+## Linking — Critical
+
+**Graph-first.** Folders group by purpose, links group by meaning. A note lives in one folder but links to many notes.
+
+**A note without links is a bug.** Every new note must link to at least one existing note via `[[wikilinks]]`.
+
+Link syntax:
+- `[[Note Title]]` — standard wikilink
+- `[[Note Title|display text]]` — aliased
+- `[[Note Title#Heading]]` — deep link
+
+### When to Link
+
+- Work note ↔ Decision Record (bidirectional)
+- Index → all work notes
+- North Star → active projects
+- Memories → source notes
+
+## Memory System
+
+All persistent memory lives in `brain/`:
+
+| File | Stores |
+|------|--------|
+| `North Star.md` | Goals and focus areas — read every session |
+| `Memories.md` | Index of memory topics |
+| `Key Decisions.md` | Decisions worth recalling across sessions |
+| `Patterns.md` | Recurring patterns discovered across work |
+
+When asked to "remember" something: write to the appropriate `brain/` file with a wikilink to context.
+
+## Sources & Ingest
+
+`sources/` holds raw source documents (articles, papers, web clips). This is the immutable layer — the agent reads from it but never modifies source files.
+
+- Drop raw files into `sources/` (markdown preferred) or use `/ingest` with a URL
+- `/ingest` reads the source, discusses key takeaways, then creates a **Source Summary** in `work/active/` with tag `source-summary`
+- The summary uses the Source Summary template: Key Takeaways, Summary, Connections, Quotes/Data Points
+- Every ingest updates `work/Index.md` (Sources section) and checks for cross-links to existing notes
+- If the source contains decisions or patterns, update the relevant `brain/` notes too
+- Source summaries link back to the raw source via the `source` frontmatter field
+
+## Operation Log
+
+Append to `log.md` after significant operations: ingests, decisions, project archives, maintenance passes.
+
+- Format: `## [YYYY-MM-DD] <type> | <title>` followed by bullet points
+- Types: `ingest`, `session`, `query`, `maintenance`, `decision`, `archive`
+- Don't log every small edit — only operations that change the vault's knowledge state
+- Entries are append-only; never edit or delete previous entries
+
+## Query Writeback
+
+When answering a substantial question that synthesizes multiple vault notes:
+
+1. Offer: "This answer could be useful later — want me to save it as a reference note?"
+2. If yes, create a Reference Note in `reference/` using the template
+3. Link the reference note from related work notes in `## Related`
+4. Add the reference note to `work/Index.md` under `## Reference`
+5. Don't prompt for trivial questions — only for answers that synthesize, compare, or analyze
+
+## Vault Location
+
+The vault may live at the project root or in a `vault/` subdirectory. Use the SessionStart context to determine the actual path. All folder references above (e.g. `brain/`, `work/active/`) are relative to the vault root.
+
+## Rules
+
+- Preserve existing frontmatter when editing notes
+- Always check for and suggest connections between notes
+- Every note must have a `description` field (~150 chars)
+- When reorganizing, never delete without user confirmation
+- Use `[[wikilinks]]` not markdown links

package/plugin/skills/dump.md

@@ -0,0 +1,29 @@
+---
+name: dump
+description: "Freeform capture — dump anything (notes, ideas, decisions, links) and it gets classified and routed to the right vault location. Triggers: 'dump this', 'capture', 'save this thought', 'note this down', 'remember this', 'jot down'."
+license: MIT
+metadata:
+  author: sukbearai
+  version: "1.0.0"
+  homepage: "https://github.com/sukbearai/codex-vault"
+---
+
+Process the following freeform dump. For each distinct piece of information:
+
+1. **Classify** it: decision, project update, win/achievement, or general work note.
+2. **Search first**: Check if a related note already exists. Prefer updating over creating.
+3. **Create or update** the appropriate note:
+   - Correct folder (work/active/, brain/, etc.)
+   - Full YAML frontmatter (date, description, tags)
+   - All relevant [[wikilinks]]
+4. **Update indexes**: `work/Index.md`, `brain/` notes as needed.
+5. **Cross-link**: Every new note links to at least one existing note.
+
+After processing, summarize:
+- What was captured and where
+- New notes created (with paths)
+- Existing notes updated
+- Anything unclear (ask the user)
+
+Content to process:
+$ARGUMENTS

package/plugin/skills/ingest.md

@@ -0,0 +1,63 @@
+---
+name: ingest
+description: "Import external content (URLs, files, text) into the vault as structured source notes. Triggers: 'ingest', 'import this', 'save this article', 'add source', 'read and save'."
+license: MIT
+metadata:
+  author: sukbearai
+  version: "1.0.0"
+  homepage: "https://github.com/sukbearai/codex-vault"
+---
+
+Ingest a source into the vault. Follow these steps:
+
+### 1. Locate the Source
+
+The user provides either:
+- A filename in `sources/` (e.g., `sources/karpathy-llm-wiki.md`)
+- A URL to fetch (use `defuddle parse <url> --md` or `curl` to save to `sources/` first)
+
+If a URL, save the raw content to `sources/` before proceeding — sources are the immutable record.
+
+### 2. Read the Source
+
+Read the full source document. Do not skim — ingestion depends on thorough reading.
+
+### 3. Discuss Key Takeaways
+
+Present the top 3-5 takeaways to the user. Ask:
+- Which points are most relevant to current work?
+- Any connections to existing vault notes?
+- Anything to skip or emphasize?
+
+Wait for user input before proceeding.
+
+### 4. Create a Source Summary
+
+Create a note in `work/active/` using the **Source Summary** template:
+- Fill in all YAML frontmatter (date, description, source, tags)
+- Write Key Takeaways, Summary, Connections (with [[wikilinks]]), Quotes/Data Points
+- The `source` field should reference the file in `sources/` or the original URL
+
+### 5. Update Indexes
+
+- Add the summary to `work/Index.md` under a "Sources" section (create the section if it doesn't exist)
+- Update relevant `brain/` notes if the source contains decisions (`Key Decisions.md`), patterns (`Patterns.md`), or context worth remembering (`Memories.md`)
+
+### 6. Cross-Link
+
+Check existing vault notes for connections:
+- Do any active projects relate to this source?
+- Does the source reinforce or challenge any existing decisions?
+- Add [[wikilinks]] in both directions where relevant
+
+### 7. Report
+
+Summarize what was done:
+- Source file location
+- Summary note created (path)
+- Indexes updated
+- Cross-links added
+- Brain notes updated (if any)
+
+Source to process:
+$ARGUMENTS

package/plugin/skills/recall.md

@@ -0,0 +1,54 @@
+---
+name: recall
+description: "Search vault memory for a topic — finds relevant notes across brain, work, reference, and sources. Triggers: 'recall', 'what do I know about', 'search memory', 'find notes about', 'look up'."
+license: MIT
+metadata:
+  author: sukbearai
+  version: "1.0.0"
+  homepage: "https://github.com/sukbearai/codex-vault"
+---
+
+Search the vault for information about the given topic.
+
+### 1. Parse the Query
+
+Extract the key topic or question from the user's input.
+
+### 2. Search the Vault
+
+Two-pass search — semantic first, keyword fallback:
+
+**Pass 1 — Frontmatter scan (semantic):**
+Read the first 5 lines (YAML frontmatter) of every `.md` file in the vault. Use the `description` and `tags` fields to judge relevance semantically — match by meaning, not just keywords. For example, a query about "caching" should match a note with description "Redis selection for session storage".
+
+Scan in priority order:
+1. `brain/` — persistent memory
+2. `work/active/` — current projects
+3. `reference/` — saved analyses
+4. `work/archive/` — completed work
+5. `sources/` — raw source documents
+
+**Pass 2 — Keyword grep (fallback):**
+If Pass 1 finds fewer than 2 relevant files, supplement with a keyword grep across file contents.
+
+### 3. Read Matches
+
+Read the top 3-5 relevant files in full. Prioritize files where the topic appears in:
+- The description or tags (strongest signal)
+- Headings
+- Multiple times in the body
+
+### 4. Synthesize
+
+Present what the vault knows about this topic:
+- **Found in**: list the files (as [[wikilinks]])
+- **Summary**: synthesize the relevant information across all matches
+- **Connections**: note any links between the matched notes
+- **Gaps**: flag if the vault has limited or no information on this topic
+
+### 5. Offer Writeback
+
+If the synthesis is substantial (combines 3+ sources), offer to save it as a reference note.
+
+Topic to recall:
+$ARGUMENTS

package/plugin/skills/wrap-up.md

@@ -0,0 +1,35 @@
+---
+name: wrap-up
+description: "End-of-session wrap-up — commits changes, updates indexes, captures decisions made. Triggers: 'wrap up', 'end session', 'save progress', 'commit and close', 'done for today'."
+license: MIT
+metadata:
+  author: sukbearai
+  version: "1.0.0"
+  homepage: "https://github.com/sukbearai/codex-vault"
+---
+
+Session wrap-up. Review what was done and leave the vault clean.
+
+### 1. Review
+Scan the conversation for notes created or modified. List them all.
+
+### 2. Verify Quality
+For each note: frontmatter complete? At least one [[wikilink]]? Correct folder?
+
+### 3. Check Indexes
+- `work/Index.md` — new notes linked? Completed projects moved?
+- `brain/Memories.md` — Recent Context updated?
+- `brain/Key Decisions.md` — new decisions captured?
+- `brain/Patterns.md` — new patterns observed?
+
+### 4. Check for Orphans
+Any new notes not linked from at least one other note?
+
+### 5. Archive Check
+Notes in `work/active/` that should move to `work/archive/`?
+
+### 6. Report
+- **Done**: what was captured
+- **Fixed**: issues resolved
+- **Flagged**: needs user input
+- **Suggested**: improvements for next time

package/vault/.claude/settings.json

@@ -0,0 +1,39 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|resume|compact",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash .codex-vault/hooks/session-start.sh",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "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",
+            "timeout": 15
+          }
+        ]
+      }
+    ]
+  }
+}