devrites 2.5.2 → 2.6.0

package/mcp/devrites-mcp.mjs

@@ -68,6 +68,8 @@ function handle(msg) {
         protocolVersion: (params && params.protocolVersion) || '2024-11-05',
         capabilities: { tools: {} },
         serverInfo: { name: 'devrites', version: '1.0.0' },
+        instructions:
+          'DevRites exposes deterministic workflow state and gates for the current repo. Use devrites_status/orient to inspect the active feature, devrites_ready before build work, devrites_evidence_fresh and devrites_acceptance before seal/ship, and devrites_use only when the user asks to switch the active feature.',
       });
     case 'notifications/initialized':
     case 'initialized':

package/pack/.claude/hooks/devrites-a1-guard.sh

@@ -6,13 +6,13 @@
 #
 # Safety model: FAIL-OPEN, and OBSERVE by default.
 #   - It NEVER blocks unless ALL hold: a build window is open, the edit is to a source file,
-#     it came from the MAIN thread (no agent_id), and enforce mode is on.
+#     it came from the MAIN thread (no agent_id/agent_type), and enforce mode is on.
 #   - On any doubt — no active workspace, no open window, no node, unparseable payload, a
 #     subagent caller, a .devrites/ path, the inline fallback — it exits 0 and stays silent.
 #   - Default mode is "observe": it LOGS what it would block (to .a1-guard.log) and allows.
 #     Flip to enforce only AFTER confirming the log never flags the wright's own edits — that
-#     confirms this Claude Code build populates agent_id for subagents (older builds may not;
-#     if the log flags wright edits, agent_id is unavailable here — stay in observe).
+#     confirms this agent surface populates agent_id/agent_type for subagents (older builds may not;
+#     if the log flags wright edits, subagent identity is unavailable here — stay in observe).
 #
 # Enable enforce (either one):
 #   export DEVRITES_A1_HOOK=enforce          # session-wide
@@ -47,24 +47,42 @@ d="$root/.devrites/work/$slug"
 
 # Parse with node (ships with Claude Code). No node or a parse failure → fail open.
 command -v node >/dev/null 2>&1 || exit 0
-parsed="$(printf '%s' "$input" | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{const j=JSON.parse(s);const ti=j.tool_input||{};const fp=ti.file_path||ti.path||"";process.stdout.write([j.tool_name||"",fp,j.agent_id||""].join("\t"))}catch(e){}})' 2>/dev/null)"
-[ -n "$parsed" ] || exit 0
-IFS=$'\t' read -r tool fpath agent <<EOF
-$parsed
-EOF
+tool="$(printf '%s' "$input" | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{process.stdout.write(JSON.parse(s).tool_name||"")}catch(e){}})' 2>/dev/null)"
+fpath="$(printf '%s' "$input" | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{const ti=JSON.parse(s).tool_input||{};process.stdout.write(ti.file_path||ti.path||"")}catch(e){}})' 2>/dev/null)"
+agent="$(printf '%s' "$input" | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{const p=JSON.parse(s);process.stdout.write(p.agent_id||p.agent_type||"")}catch(e){}})' 2>/dev/null)"
+[ -n "$tool" ] || exit 0
 
 # Only Edit-family writes can touch source.
-case "$tool" in Edit|Write|MultiEdit|NotebookEdit) : ;; *) exit 0 ;; esac
+case "$tool" in Edit|Write|MultiEdit|NotebookEdit|apply_patch) : ;; *) exit 0 ;; esac
 
-# Subagent caller (the wright) → allow. agent_id is present only inside a subagent.
+# Subagent caller (the wright) → allow. Claude uses agent_id; Codex uses agent_type.
 [ -n "$agent" ] && exit 0
 
-# Can't tell the path → fail open.
-[ -n "$fpath" ] || exit 0
-case "$fpath" in /*) abs="$fpath" ;; *) abs="$root/$fpath" ;; esac
-
-# Bookkeeping under .devrites/ is the orchestrator's own legit target → allow.
-case "$abs" in "$root/.devrites/"*) exit 0 ;; esac
+# Can't tell the path or patch target → fail open.
+if [ "$tool" = "apply_patch" ]; then
+  source_patch="$(printf '%s' "$input" | ROOT="$root" node -e '
+    let s=""; process.stdin.on("data", d => s += d).on("end", () => {
+      try {
+        const root = process.env.ROOT || "";
+        const cmd = (JSON.parse(s).tool_input || {}).command || "";
+        const paths = [...cmd.matchAll(/^\*\*\* (?:(?:Add|Update|Delete) File|Move to): (.+)$/gm)].map(m => m[1]);
+        if (!paths.length) return;
+        const source = paths.some(p => {
+          const abs = p.startsWith("/") ? p : `${root}/${p}`;
+          return !abs.startsWith(`${root}/.devrites/`);
+        });
+        process.stdout.write(source ? "1" : "0");
+      } catch {}
+    });
+  ' 2>/dev/null)"
+  [ "$source_patch" = "1" ] || exit 0
+  abs="apply_patch"
+else
+  [ -n "$fpath" ] || exit 0
+  case "$fpath" in /*) abs="$fpath" ;; *) abs="$root/$fpath" ;; esac
+  # Bookkeeping under .devrites/ is the orchestrator's own legit target → allow.
+  case "$abs" in "$root/.devrites/"*) exit 0 ;; esac
+fi
 
 # Reaching here = the MAIN thread is about to edit a SOURCE file mid-build. That is the A1
 # breach. Observe (default) logs and allows; enforce denies.

package/pack/.claude/hooks/devrites-reviewer-readonly.sh

@@ -8,9 +8,18 @@ set -u
 input="$(cat)"
 case "$input" in *'"tool_name"'*) : ;; *) exit 0 ;; esac
 command -v node >/dev/null 2>&1 || exit 0
-parsed="$(printf '%s' "$input" | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{const j=JSON.parse(s);const ti=j.tool_input||{};process.stdout.write((j.tool_name||"")+"
"+(ti.command||""))}catch(e){}})' 2>/dev/null)"
+parsed="$(printf '%s' "$input" | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{const j=JSON.parse(s);const ti=j.tool_input||{};process.stdout.write([j.tool_name||"",ti.command||"",j.agent_type||""].join("\u0001"))}catch(e){}})' 2>/dev/null)"
 [ -n "$parsed" ] || exit 0
-tool="${parsed%%$'\001'*}"; cmd="${parsed#*$'\001'}"
+IFS=$'\001' read -r tool cmd agent_type <<EOF
+$parsed
+EOF
+if [ "${DEVRITES_REVIEWER_AGENT_REQUIRED:-0}" = "1" ]; then
+  case "$agent_type" in
+    devrites-slice-wright|"") exit 0 ;;
+    devrites-*) : ;;
+    *) exit 0 ;;
+  esac
+fi
 [ "$tool" = "Bash" ] || exit 0
 [ -n "$cmd" ] || exit 0
 

package/pack/.claude/hooks/devrites-wright-scope.sh

@@ -16,20 +16,49 @@ tf="$d/touched-files.md"
 [ -f "$tf" ] || exit 0
 
 command -v node >/dev/null 2>&1 || exit 0
-parsed="$(printf '%s' "$input" | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{const j=JSON.parse(s);const ti=j.tool_input||{};process.stdout.write((j.tool_name||"")+"
"+(ti.file_path||ti.path||""))}catch(e){}})' 2>/dev/null)"
-[ -n "$parsed" ] || exit 0
-tool="${parsed%%$'\001'*}"; fpath="${parsed#*$'\001'}"
-case "$tool" in Edit|Write|MultiEdit|NotebookEdit) : ;; *) exit 0 ;; esac
-[ -n "$fpath" ] || exit 0
-case "$fpath" in *.devrites/*) exit 0 ;; esac
+tool="$(printf '%s' "$input" | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{process.stdout.write(JSON.parse(s).tool_name||"")}catch(e){}})' 2>/dev/null)"
+fpath="$(printf '%s' "$input" | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{const ti=JSON.parse(s).tool_input||{};process.stdout.write(ti.file_path||ti.path||"")}catch(e){}})' 2>/dev/null)"
+agent_type="$(printf '%s' "$input" | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{process.stdout.write(JSON.parse(s).agent_type||"")}catch(e){}})' 2>/dev/null)"
+[ -n "$tool" ] || exit 0
+if [ "${DEVRITES_WRIGHT_AGENT_REQUIRED:-0}" = "1" ] && [ "$agent_type" != "devrites-slice-wright" ]; then
+  exit 0
+fi
+case "$tool" in Edit|Write|MultiEdit|NotebookEdit|apply_patch) : ;; *) exit 0 ;; esac
 
-rel="${fpath#"$root"/}"
-if grep -qF "$rel" "$tf" 2>/dev/null || grep -qF "$fpath" "$tf" 2>/dev/null; then exit 0; fi
+bad_paths=""
+if [ "$tool" = "apply_patch" ]; then
+  bad_paths="$(printf '%s' "$input" | TF="$tf" ROOT="$root" node -e '
+    const fs = require("fs");
+    let s = ""; process.stdin.on("data", d => s += d).on("end", () => {
+      try {
+        const root = process.env.ROOT || "";
+        const tf = process.env.TF || "";
+        const touched = fs.existsSync(tf) ? fs.readFileSync(tf, "utf8") : "";
+        const cmd = (JSON.parse(s).tool_input || {}).command || "";
+        const paths = [...cmd.matchAll(/^\*\*\* (?:(?:Add|Update|Delete) File|Move to): (.+)$/gm)].map(m => m[1]);
+        const bad = paths.filter(p => {
+          if (p.startsWith(".devrites/") || p.includes("/.devrites/")) return false;
+          const rel = p.startsWith(`${root}/`) ? p.slice(root.length + 1) : p;
+          return !touched.includes(rel) && !touched.includes(p);
+        });
+        process.stdout.write(bad.join(", "));
+      } catch {}
+    });
+  ' 2>/dev/null)"
+else
+  [ -n "$fpath" ] || exit 0
+  case "$fpath" in *.devrites/*|.devrites/*) exit 0 ;; esac
+  rel="${fpath#"$root"/}"
+  if ! grep -qF "$rel" "$tf" 2>/dev/null && ! grep -qF "$fpath" "$tf" 2>/dev/null; then
+    bad_paths="$fpath"
+  fi
+fi
+[ -n "$bad_paths" ] || exit 0
 
 mode="${DEVRITES_WRIGHT_SCOPE:-observe}"
 if [ "$mode" = "enforce" ]; then
   printf '%s\n' '{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"deny","permissionDecisionReason":"DevRites scope: this path is not in touched-files.md. Build only the slice contract; if the slice genuinely needs this file, return an Escalation so the orchestrator routes it through the Spec Drift Guard — do not widen scope yourself. (devrites-wright-scope)"}}'
   exit 0
 fi
-printf '%s\tWOULD-BLOCK\t%s\n' "$(date '+%Y-%m-%dT%H:%M:%S' 2>/dev/null || echo '?')" "$fpath" >> "$d/.wright-scope.log" 2>/dev/null || true
+printf '%s\tWOULD-BLOCK\t%s\n' "$(date '+%Y-%m-%dT%H:%M:%S' 2>/dev/null || echo '?')" "$bad_paths" >> "$d/.wright-scope.log" 2>/dev/null || true
 exit 0

package/pack/.claude/skills/devrites-lib/scripts/doctor.sh

@@ -3,7 +3,7 @@
 #
 # Checks install integrity + the active .devrites/ workspace for the inconsistencies that
 # silently waste a session: a stale ACTIVE pointer, a corrupt workspace, an orphaned gate,
-# or broken hook wiring. Two surfaces wrap this one core:
+# or broken hook wiring across Claude Code and Codex. Two surfaces wrap this one core:
 #   - the SessionStart orient hook calls it and surfaces issues only when there are any
 #     (silent-when-healthy);
 #   - the /rite-doctor skill calls it with --verbose for a full report on demand.
@@ -52,16 +52,80 @@ else
   ok "devrites-lib core scripts present"
 fi
 
-# 2. Broken hook wiring — every devrites hook referenced in settings.json must exist on disk.
+# 2. Broken Claude hook wiring — every devrites hook referenced in settings.json must exist on disk.
 SET="$ROOT/.claude/settings.json"
 if [ -f "$SET" ]; then
   for h in $(grep -oE 'devrites-[a-z-]+\.sh' "$SET" 2>/dev/null | sort -u); do
     [ -f "$ROOT/.claude/hooks/$h" ] || issue "settings.json wires missing hook: .claude/hooks/$h — reinstall or remove the hook entry"
   done
-  ok "hook wiring checked"
+  ok "Claude hook wiring checked"
 fi
 
-# 3. ACTIVE pointer — if set, it must name a real workspace.
+# 3. Codex support is optional. Only diagnose the Codex surface when DevRites
+# manages it, so unrelated project AGENTS.md/.codex files and --no-codex installs
+# do not produce false failures.
+MF="$ROOT/.claude/devrites.manifest"
+DR_FLAGS=""
+[ -f "$MF" ] && DR_FLAGS="$(sed -n 's/^# devrites-flags:[[:space:]]*//p' "$MF" 2>/dev/null | head -n1)"
+has_flag() {
+  case " $DR_FLAGS " in *" $1 "*) return 0 ;; *) return 1 ;; esac
+}
+manifest_has() {
+  [ -f "$MF" ] && grep -Eq -- "$1" "$MF" 2>/dev/null
+}
+
+codex_managed=0
+if manifest_has '^(\.agents/|\.codex/|AGENTS\.md$|\.claude/devrites\.(agents|codex-config)-merge$)'; then
+  codex_managed=1
+fi
+has_flag --no-codex && codex_managed=0
+
+if [ "$codex_managed" -eq 1 ]; then
+  if ! has_flag --no-skills && manifest_has '^\.agents/skills/'; then
+    [ -f "$ROOT/.agents/skills/rite/SKILL.md" ] \
+      || issue "Codex skill mirror incomplete — missing .agents/skills/rite/SKILL.md — reinstall DevRites"
+  fi
+  if ! has_flag --no-rules && manifest_has '^\.agents/devrites/rules/'; then
+    [ -f "$ROOT/.agents/devrites/rules/core.md" ] \
+      || issue "Codex rules mirror incomplete — missing .agents/devrites/rules/core.md — reinstall DevRites"
+  fi
+  if ! has_flag --no-agents && manifest_has '^\.codex/agents/'; then
+    [ -f "$ROOT/.codex/agents/devrites-code-reviewer.toml" ] \
+      || issue "Codex custom agents incomplete — missing .codex/agents/devrites-code-reviewer.toml — reinstall DevRites"
+  fi
+  if manifest_has '^\.codex/hooks\.json$|^\.codex/hooks/|^\.claude/devrites\.codex-hooks-merge$'; then
+    [ -f "$ROOT/.codex/hooks.json" ] \
+      || issue "Codex hooks incomplete — missing .codex/hooks.json — reinstall DevRites or install with --no-codex"
+    if [ -f "$ROOT/.codex/hooks.json" ]; then
+      grep -q 'devrites-' "$ROOT/.codex/hooks.json" 2>/dev/null \
+        || issue "Codex hooks incomplete — .codex/hooks.json does not reference DevRites hooks — reinstall DevRites"
+      for h in $(grep -oE 'devrites-[a-z-]+\.sh' "$ROOT/.codex/hooks.json" 2>/dev/null | sort -u); do
+        [ -f "$ROOT/.codex/hooks/$h" ] || issue "Codex hooks.json wires missing hook: .codex/hooks/$h — reinstall DevRites"
+      done
+    fi
+  fi
+  if manifest_has '^\.codex/mcp/|^\.codex/config\.toml$|^\.claude/devrites\.codex-config-merge$'; then
+    [ -f "$ROOT/.codex/mcp/devrites-mcp.mjs" ] \
+      || issue "Codex MCP incomplete — missing .codex/mcp/devrites-mcp.mjs — reinstall DevRites or install with --no-codex"
+    if [ -f "$ROOT/.codex/config.toml" ]; then
+      grep -q 'mcp_servers.devrites' "$ROOT/.codex/config.toml" 2>/dev/null \
+        || issue "Codex MCP config missing DevRites server — merge the DevRites block into .codex/config.toml or reinstall DevRites"
+    else
+      issue "Codex config incomplete — missing .codex/config.toml with DevRites MCP server — reinstall DevRites or install with --no-codex"
+    fi
+  fi
+  if manifest_has '^AGENTS\.md$|^\.claude/devrites\.agents-merge$'; then
+    if [ -f "$ROOT/AGENTS.md" ]; then
+      grep -q 'DevRites' "$ROOT/AGENTS.md" 2>/dev/null \
+        || issue "AGENTS.md does not include the DevRites Codex bridge — reinstall with --force or merge the DevRites AGENTS.md guidance"
+    else
+      issue "Codex guidance incomplete — missing AGENTS.md bridge — reinstall DevRites"
+    fi
+  fi
+  ok "Codex support wiring checked"
+fi
+
+# 4. ACTIVE pointer — if set, it must name a real workspace.
 slug="$(cat "$DR/ACTIVE" 2>/dev/null | tr -d '[:space:]')"
 if [ -z "$slug" ]; then
   ok "no active feature (ACTIVE empty)"

package/pack/.claude/skills/rite-doctor/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: rite-doctor
-description: Diagnose DevRites install + workspace health on demand and print a full report — install integrity, a stale `.devrites/ACTIVE` pointer, a corrupt workspace, orphaned gates, and broken hook wiring. Use when the user says "rite doctor", "check my DevRites install", or "why isn't the workflow picking up my feature". Not for debugging the user's own code (use `devrites-debug-recovery`) or for feature progress / next-action (use `/rite-status`).
+description: Diagnose DevRites install + workspace health on demand and print a full report — install integrity, Codex/Claude hook wiring, Codex support mirrors, a stale `.devrites/ACTIVE` pointer, a corrupt workspace, and orphaned gates. Use when the user says "rite doctor", "check my DevRites install", or "why isn't the workflow picking up my feature". Not for debugging the user's own code (use `devrites-debug-recovery`) or for feature progress / next-action (use `/rite-status`).
 argument-hint: ""
 user-invocable: true
 ---
@@ -10,6 +10,7 @@ user-invocable: true
 The on-demand deep report. The same checks run **silently at session start** (the orient
 hook surfaces issues only when there are any); `/rite-doctor` runs them **verbosely** —
 printing every check, pass or fail — so you can inspect health even when nothing is broken.
+It covers both Claude Code wiring and optional Codex mirrors/hooks when those files are present.
 
 It is **read-only**: it never edits the workspace, never advances a phase, never blocks.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "devrites",
-  "version": "2.5.2",
-  "description": "DevRites — disciplined senior-engineer workflow skills pack for Claude Code",
+  "version": "2.6.0",
+  "description": "DevRites — disciplined senior-engineer workflow skills pack for Claude Code and Codex",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://github.com/ViktorsBaikers/DevRites#readme",
   "repository": {
@@ -13,6 +13,7 @@
   },
   "keywords": [
     "claude-code",
+    "codex",
     "skills",
     "agent-skills",
     "workflow",

package/scripts/check-no-global-writes.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # check-no-global-writes.sh — static guard that the installer/uninstaller never
-# writes to the user's global ~/.claude, and that the global guard is present.
+# writes to the user's global ~/.claude or ~/.codex, and that the global guard is present.
 # Exits non-zero on violation.
 
 set -u
@@ -18,12 +18,12 @@ else
   echo "ok: install.sh contains the no-global guard"
 fi
 
-# 2) no write operation may target ~/.claude or \$HOME/.claude.
+# 2) no write operation may target ~/.claude, ~/.codex, or their $HOME forms.
 #    Write verbs are actual file-writing commands / redirections. ('install' is
 #    intentionally excluded: the installer uses cp/mkdir, and "install" appears in
 #    prose like "install into a project", which is not a write.)
 WRITE_RE='(\bmkdir\b|\bcp\b|\btee\b|\brsync\b|\bmv\b|\bln\b|>>?)'
-GLOBAL_RE='(\$HOME/\.claude|~/\.claude)'
+GLOBAL_RE='(\$HOME/\.(claude|codex)|~/\.(claude|codex))'
 for f in $SCRIPTS; do
   [ -f "$f" ] || continue
   # lines that contain a global-claude path AND a write verb, excluding comments
@@ -34,7 +34,7 @@ for f in $SCRIPTS; do
     fail=1
   fi
 done
-[ "$fail" -eq 0 ] && echo "ok: no write operations target ~/.claude"
+[ "$fail" -eq 0 ] && echo "ok: no write operations target global agent homes"
 
 if [ "$fail" -eq 0 ]; then
   echo "PASS: no global-write risks detected"

package/scripts/install-lib.sh

@@ -48,7 +48,7 @@ dr_manifest_contains() {
 # ---- misc ----------------------------------------------------------------
 dr_lc() { printf '%s' "$1" | tr '[:upper:]' '[:lower:]'; }
 
-# Is $1 (canonical) equal to, or inside, the user's global ~/.claude?
+# Is $1 (canonical) equal to, or inside, a global agent home?
 # Used to refuse global writes. No write verbs here — read-only comparison.
 dr_is_global_claude() {
   _t="$1"
@@ -60,6 +60,16 @@ dr_is_global_claude() {
   return 1
 }
 
+dr_is_global_codex() {
+  _t="$1"
+  _home_codex="$HOME/.codex"
+  [ "$_t" = "$_home_codex" ] && return 0
+  case "$_t/" in
+    "$_home_codex"/*) return 0 ;;
+  esac
+  return 1
+}
+
 # ---- alias wrapper template ----------------------------------------------
 # Generate a thin SKILL.md that delegates to a DevRites skill. Used by:
 #   - install.sh (--short-aliases=all → /define, /build, /prove, /seal)

package/scripts/merge-codex-hooks.mjs

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+
+const [, , mode, ...args] = process.argv;
+let existingPath;
+let devritesPath;
+let outPath;
+
+if (mode === 'merge') {
+  [existingPath, devritesPath, outPath] = args;
+} else if (mode === 'strip') {
+  [existingPath, outPath] = args;
+}
+
+if (!['merge', 'strip'].includes(mode) || !existingPath || !outPath || (mode === 'merge' && !devritesPath)) {
+  console.error('usage: merge-codex-hooks.mjs merge EXISTING DEVRITES OUT');
+  console.error('   or: merge-codex-hooks.mjs strip EXISTING OUT');
+  process.exit(2);
+}
+
+function readJson(path) {
+  return JSON.parse(fs.readFileSync(path, 'utf8'));
+}
+
+function isDevRitesHook(value) {
+  const s = JSON.stringify(value);
+  return s.includes('.codex/hooks/devrites-') || s.includes('DevRites:') || s.includes('DEVRITES_');
+}
+
+function stripDevRitesHooks(config) {
+  if (!config || typeof config !== 'object' || Array.isArray(config)) return {};
+  const next = { ...config };
+  if (typeof next.$comment === 'string' && next.$comment.includes('DevRites hooks for Codex')) {
+    delete next.$comment;
+  }
+  const hooks = next.hooks && typeof next.hooks === 'object' && !Array.isArray(next.hooks)
+    ? { ...next.hooks }
+    : {};
+
+  for (const [event, entries] of Object.entries(hooks)) {
+    const kept = Array.isArray(entries) ? entries.filter((entry) => !isDevRitesHook(entry)) : entries;
+    if (Array.isArray(kept) && kept.length === 0) {
+      delete hooks[event];
+    } else {
+      hooks[event] = kept;
+    }
+  }
+
+  if (Object.keys(hooks).length) {
+    next.hooks = hooks;
+  } else {
+    delete next.hooks;
+  }
+  return next;
+}
+
+const existing = stripDevRitesHooks(readJson(existingPath));
+
+if (mode === 'merge') {
+  const devrites = readJson(devritesPath);
+  const hooks = existing.hooks && typeof existing.hooks === 'object' && !Array.isArray(existing.hooks)
+    ? existing.hooks
+    : {};
+  const devritesHooks = devrites.hooks && typeof devrites.hooks === 'object' && !Array.isArray(devrites.hooks)
+    ? devrites.hooks
+    : {};
+
+  for (const [event, entries] of Object.entries(devritesHooks)) {
+    hooks[event] = [
+      ...(Array.isArray(hooks[event]) ? hooks[event] : []),
+      ...(Array.isArray(entries) ? entries : []),
+    ];
+  }
+
+  existing.hooks = hooks;
+}
+
+fs.writeFileSync(outPath, `${JSON.stringify(existing, null, 2)}\n`);

package/scripts/pin.sh

@@ -3,7 +3,7 @@
 #
 # Adopts the same "thin wrapper SKILL.md that delegates" pattern as install.sh
 # uses for --short-aliases=all, but exposes it as a runtime verb so users can
-# add / remove arbitrary aliases against any rite-*  skill without re-running
+# add / remove arbitrary aliases against any rite-* skill without re-running
 # the installer.
 #
 # Usage:
@@ -18,11 +18,12 @@
 #   ./scripts/pin.sh remove b
 #
 # Targets:
-#   - Default: $PWD (the installed project, which holds .claude/skills/).
+#   - Default: $PWD (the installed project, which holds .claude/skills/
+#     and may also hold .agents/skills/ for Codex).
 #   - --target <dir> to operate on a project elsewhere.
 #
 # Safety:
-#   - Refuses to write inside ~/.claude (DevRites is project-local only).
+#   - Refuses to write inside global Claude/Codex homes (DevRites is project-local only).
 #   - Refuses to overwrite a non-alias skill at .claude/skills/<alias>/.
 #   - Refuses if <target> is not a known rite-* skill in the target's pack.
 #   - Manifest-managed: pinned wrappers are recorded in .claude/devrites.manifest
@@ -66,8 +67,10 @@ done
 
 TARGET="$(dr_abspath_dir "$TARGET")" || dr_die "target dir not found: $TARGET"
 dr_is_global_claude "$TARGET" && dr_die "refusing to operate on ~/.claude — DevRites is project-local only"
+dr_is_global_codex "$TARGET" && dr_die "refusing to operate on ~/.codex — DevRites is project-local only"
 
 SKILLS_DIR="$TARGET/.claude/skills"
+CODEX_SKILLS_DIR="$TARGET/.agents/skills"
 MF="$TARGET/$DR_MANIFEST_NAME"
 
 [ -d "$SKILLS_DIR" ] || dr_die "no .claude/skills at $TARGET — run install.sh first?"
@@ -97,6 +100,11 @@ is_pinned_alias() {
   grep -q 'description: Alias of DevRites /' "$SKILLS_DIR/$1/SKILL.md"
 }
 
+is_pinned_alias_file() {
+  [ -f "$1" ] || return 1
+  grep -q 'description: Alias of DevRites /' "$1"
+}
+
 # ---- subcommands ---------------------------------------------------------
 do_add() {
   valid_alias_name "$ALIAS"    || dr_die "invalid alias name '$ALIAS' (lowercase / digits / hyphens; not 'rite' or 'rite-*')"
@@ -106,6 +114,9 @@ do_add() {
   ALIAS_DIR="$SKILLS_DIR/$ALIAS"
   ALIAS_FILE="$ALIAS_DIR/SKILL.md"
   ALIAS_REL=".claude/skills/$ALIAS/SKILL.md"
+  CODEX_ALIAS_DIR="$CODEX_SKILLS_DIR/$ALIAS"
+  CODEX_ALIAS_FILE="$CODEX_ALIAS_DIR/SKILL.md"
+  CODEX_ALIAS_REL=".agents/skills/$ALIAS/SKILL.md"
 
   if [ -e "$ALIAS_FILE" ]; then
     if is_pinned_alias "$ALIAS"; then
@@ -114,15 +125,33 @@ do_add() {
       dr_die "$ALIAS_FILE exists and is NOT a pinned alias — refusing to overwrite"
     fi
   fi
+  if [ -d "$CODEX_SKILLS_DIR" ] && [ -e "$CODEX_ALIAS_FILE" ]; then
+    if is_pinned_alias_file "$CODEX_ALIAS_FILE"; then
+      dr_warn "already pinned for Codex: /$ALIAS — overwriting"
+    else
+      dr_die "$CODEX_ALIAS_FILE exists and is NOT a pinned alias — refusing to overwrite"
+    fi
+  fi
 
   mkdir -p "$ALIAS_DIR"
   dr_gen_alias_wrapper "$ALIAS" "$DEST" "$ALIAS_FILE"
+  if [ -d "$CODEX_SKILLS_DIR" ]; then
+    mkdir -p "$CODEX_ALIAS_DIR"
+    dr_gen_alias_wrapper "$ALIAS" "$DEST" "$CODEX_ALIAS_FILE"
+  fi
 
   if ! dr_manifest_contains "$MF" "$ALIAS_REL"; then
     printf '%s\n' "$ALIAS_REL" >> "$MF"
   fi
+  if [ -d "$CODEX_SKILLS_DIR" ] && ! dr_manifest_contains "$MF" "$CODEX_ALIAS_REL"; then
+    printf '%s\n' "$CODEX_ALIAS_REL" >> "$MF"
+  fi
 
-  dr_ok "pinned: /$ALIAS → /$DEST   ($ALIAS_FILE)"
+  if [ -d "$CODEX_SKILLS_DIR" ]; then
+    dr_ok "pinned: /$ALIAS → /$DEST   ($ALIAS_FILE, $CODEX_ALIAS_FILE)"
+  else
+    dr_ok "pinned: /$ALIAS → /$DEST   ($ALIAS_FILE)"
+  fi
 }
 
 do_remove() {
@@ -130,16 +159,24 @@ do_remove() {
   ALIAS_DIR="$SKILLS_DIR/$ALIAS"
   ALIAS_FILE="$ALIAS_DIR/SKILL.md"
   ALIAS_REL=".claude/skills/$ALIAS/SKILL.md"
+  CODEX_ALIAS_DIR="$CODEX_SKILLS_DIR/$ALIAS"
+  CODEX_ALIAS_FILE="$CODEX_ALIAS_DIR/SKILL.md"
+  CODEX_ALIAS_REL=".agents/skills/$ALIAS/SKILL.md"
 
   [ -f "$ALIAS_FILE" ]      || dr_die "no pinned alias at $ALIAS_FILE"
   is_pinned_alias "$ALIAS"  || dr_die "$ALIAS_FILE exists but is not a pinned alias — refusing to remove"
 
   rm -f "$ALIAS_FILE"
   rmdir "$ALIAS_DIR" 2>/dev/null || true
+  if [ -f "$CODEX_ALIAS_FILE" ]; then
+    is_pinned_alias_file "$CODEX_ALIAS_FILE" || dr_die "$CODEX_ALIAS_FILE exists but is not a pinned alias — refusing to remove"
+    rm -f "$CODEX_ALIAS_FILE"
+    rmdir "$CODEX_ALIAS_DIR" 2>/dev/null || true
+  fi
 
   # Drop the alias line from the manifest (preserve header + the rest)
   TMP="$(mktemp)"
-  grep -Fvx "$ALIAS_REL" "$MF" > "$TMP" && mv "$TMP" "$MF"
+  grep -Fvx "$ALIAS_REL" "$MF" | grep -Fvx "$CODEX_ALIAS_REL" > "$TMP" && mv "$TMP" "$MF"
 
   dr_ok "unpinned: /$ALIAS"
 }

package/uninstall.sh

@@ -86,10 +86,70 @@ PRUNE_TMP="$(mktemp 2>/dev/null || echo "${TMPDIR:-/tmp}/devrites-prune.$$")"
 : > "$PRUNE_TMP"
 trap 'rm -f "$PRUNE_TMP"' EXIT
 
+# If DevRites was merged into a pre-existing AGENTS.md, remove only the managed
+# marker block. Fresh AGENTS.md files created by DevRites are still removed
+# below through the ordinary manifest entry.
+if [ -f "$TARGET/.claude/devrites.agents-merge" ] && [ -f "$TARGET/AGENTS.md" ]; then
+  if [ "$DRYRUN" -eq 1 ]; then
+    dr_say "  [merge-remove] AGENTS.md DevRites block"
+  else
+    tmp_agents="$(mktemp 2>/dev/null || echo "${TMPDIR:-/tmp}/devrites-agents.$$")"
+    awk '
+      $0 == "<!-- BEGIN DEVRITES CODEX -->" { in_block = 1; next }
+      $0 == "<!-- END DEVRITES CODEX -->" { in_block = 0; next }
+      in_block { next }
+      { print }
+    ' "$TARGET/AGENTS.md" > "$tmp_agents" && cp "$tmp_agents" "$TARGET/AGENTS.md"
+    rm -f "$tmp_agents"
+    grep -q '[^[:space:]]' "$TARGET/AGENTS.md" 2>/dev/null || rm -f "$TARGET/AGENTS.md"
+  fi
+fi
+
+if [ -f "$TARGET/.claude/devrites.codex-config-merge" ] && [ -f "$TARGET/.codex/config.toml" ]; then
+  if [ "$DRYRUN" -eq 1 ]; then
+    dr_say "  [merge-remove] .codex/config.toml DevRites MCP block"
+  else
+    tmp_codex_config="$(mktemp 2>/dev/null || echo "${TMPDIR:-/tmp}/devrites-codex-config.$$")"
+    awk '
+      $0 == "# BEGIN DEVRITES CODEX MCP" { in_block = 1; next }
+      $0 == "# END DEVRITES CODEX MCP" { in_block = 0; next }
+      in_block { next }
+      { print }
+    ' "$TARGET/.codex/config.toml" > "$tmp_codex_config" && cp "$tmp_codex_config" "$TARGET/.codex/config.toml"
+    rm -f "$tmp_codex_config"
+    grep -q '[^[:space:]]' "$TARGET/.codex/config.toml" 2>/dev/null || rm -f "$TARGET/.codex/config.toml"
+  fi
+fi
+
+if [ -f "$TARGET/.claude/devrites.codex-hooks-merge" ] && [ -f "$TARGET/.codex/hooks.json" ]; then
+  if [ "$DRYRUN" -eq 1 ]; then
+    dr_say "  [merge-remove] .codex/hooks.json DevRites hooks"
+  else
+    if grep -q 'DevRites hooks for Codex' "$TARGET/.codex/hooks.json" 2>/dev/null \
+      && ! grep '"command"[[:space:]]*:' "$TARGET/.codex/hooks.json" 2>/dev/null | grep -vq 'devrites-\|DEVRITES_\|DevRites:'; then
+      rm -f "$TARGET/.codex/hooks.json" || dr_die "cannot remove .codex/hooks.json"
+    else
+      command -v node >/dev/null 2>&1 || dr_die "node is required to remove DevRites hooks from .codex/hooks.json"
+      tmp_codex_hooks="$(mktemp 2>/dev/null || echo "${TMPDIR:-/tmp}/devrites-codex-hooks.$$")"
+      node "$SELF_DIR/scripts/merge-codex-hooks.mjs" strip "$TARGET/.codex/hooks.json" "$tmp_codex_hooks" \
+        || dr_die "cannot remove DevRites hooks from .codex/hooks.json"
+      cp "$tmp_codex_hooks" "$TARGET/.codex/hooks.json" || dr_die "cannot write .codex/hooks.json"
+      rm -f "$tmp_codex_hooks"
+      [ "$(tr -d '[:space:]' < "$TARGET/.codex/hooks.json" 2>/dev/null)" != "{}" ] || rm -f "$TARGET/.codex/hooks.json"
+    fi
+    [ -e "$TARGET/.codex/hooks.json" ] || printf '%s\n' "$TARGET/.codex" >> "$PRUNE_TMP"
+  fi
+fi
+
 # Remove each manifest-listed file.
 while IFS= read -r rel; do
   case "$rel" in ''|\#*) continue ;; esac          # skip blanks/comments
   case "$rel" in /*|*..*) dr_warn "ignoring suspicious manifest entry: $rel"; continue ;; esac
+  case "$rel" in
+    AGENTS.md) [ -f "$TARGET/.claude/devrites.agents-merge" ] && continue ;;
+    .codex/config.toml) [ -f "$TARGET/.claude/devrites.codex-config-merge" ] && continue ;;
+    .codex/hooks.json) [ -f "$TARGET/.claude/devrites.codex-hooks-merge" ] && continue ;;
+  esac
   dest="$TARGET/$rel"
   if [ -e "$dest" ] || [ -L "$dest" ]; then
     if [ "$DRYRUN" -eq 1 ]; then