@codyswann/lisa 2.119.0 → 2.121.0

package/plugins/lisa-typescript/.codex-plugin/hooks/sg-scan-on-edit.sh

@@ -0,0 +1,71 @@
+#!/bin/bash
+# This file is managed by Lisa.
+# Do not edit directly — changes will be overwritten on the next `lisa` run.
+
+# Hook script to run ast-grep scan after Claude edits files
+# This script receives JSON input via stdin with tool information
+# Reference: https://docs.claude.com/en/docs/claude-code/hooks
+# Note: This hook is BLOCKING - it returns non-zero exit codes so Claude must fix issues
+
+# Extract file path from JSON input. Use jq for robust JSON parsing (never
+# grep/sed/cut — a shape change would turn this blocking scan into a silent
+# no-op). Fail open without jq so we never hard-block an edit.
+command -v jq >/dev/null 2>&1 || exit 0
+FILE_PATH=$(cat | jq -r '.tool_input.file_path // empty')
+
+if [ -z "$FILE_PATH" ] || [ ! -f "$FILE_PATH" ]; then
+    exit 0
+fi
+
+# Check if file type is supported (TypeScript, JavaScript)
+case "${FILE_PATH##*.}" in
+    ts|tsx|js|jsx|mjs|cjs) ;;
+    *) exit 0 ;;
+esac
+
+# Validate project directory
+if [ -z "${CLAUDE_PROJECT_DIR:-}" ]; then
+    exit 0
+fi
+
+# Check if file is in a source directory
+RELATIVE_PATH="${FILE_PATH#$CLAUDE_PROJECT_DIR/}"
+case "$RELATIVE_PATH" in
+    src/*|apps/*|libs/*|test/*|tests/*|features/*|components/*|hooks/*|screens/*|app/*|constants/*|utils/*|providers/*|stores/*) ;;
+    *) exit 0 ;;
+esac
+
+cd "$CLAUDE_PROJECT_DIR" || exit 0
+
+# Verify ast-grep configuration exists
+if [ ! -f "sgconfig.yml" ]; then
+    exit 0
+fi
+
+# Verify rules are defined
+RULE_COUNT=$(find ast-grep/rules -name "*.yml" -o -name "*.yaml" 2>/dev/null | grep -v ".gitkeep" | wc -l | tr -d ' ')
+if [ "$RULE_COUNT" -eq 0 ]; then
+    exit 0
+fi
+
+# Detect package manager
+if [ -f "bun.lockb" ] || [ -f "bun.lock" ]; then
+    PKG_MANAGER="bun"
+elif [ -f "pnpm-lock.yaml" ]; then
+    PKG_MANAGER="pnpm"
+elif [ -f "yarn.lock" ]; then
+    PKG_MANAGER="yarn"
+else
+    PKG_MANAGER="npm"
+fi
+
+# Run ast-grep scan
+echo "Running ast-grep scan on: $FILE_PATH"
+if OUTPUT=$($PKG_MANAGER run sg:scan "$FILE_PATH" 2>&1); then
+    echo "ast-grep: No issues found in $(basename "$FILE_PATH")"
+    exit 0
+else
+    echo "ast-grep found issues in: $FILE_PATH" >&2
+    echo "$OUTPUT" >&2
+    exit 1
+fi

package/plugins/lisa-typescript/.codex-plugin/hooks.json

@@ -0,0 +1,34 @@
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "./hooks/block-suppress-directives.sh"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "./hooks/format-on-edit.sh"
+          },
+          {
+            "type": "command",
+            "command": "./hooks/sg-scan-on-edit.sh"
+          },
+          {
+            "type": "command",
+            "command": "./hooks/lint-on-edit.sh"
+          }
+        ]
+      }
+    ]
+  }
+}

package/plugins/lisa-typescript/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa-typescript",
-  "version": "2.119.0",
+  "version": "2.121.0",
   "description": "TypeScript-specific hooks for formatting, linting, and ast-grep scanning on edit.",
   "author": {
     "name": "Cody Swann"
@@ -14,6 +14,7 @@
   "dependencies": [
     "lisa"
   ],
+  "hooks": "./hooks.json",
   "interface": {
     "displayName": "Lisa TypeScript",
     "shortDescription": "TypeScript lifecycle checks",

package/plugins/lisa-typescript/hooks/format-on-edit.sh

@@ -9,9 +9,11 @@
 # Read the JSON input from stdin
 JSON_INPUT=$(cat)
 
-# Extract the file path from the tool_input
-# The Edit tool input contains a "file_path" field in the tool_input object
-FILE_PATH=$(echo "$JSON_INPUT" | grep -o '"tool_input":{[^}]*"file_path":"[^"]*"' | grep -o '"file_path":"[^"]*"' | cut -d'"' -f4)
+# Extract the file path from the tool_input. Use jq for robust JSON parsing
+# (never grep/sed/cut — a JSON shape change silently skips formatting). Fail
+# open without jq so we never hard-block an edit.
+command -v jq >/dev/null 2>&1 || exit 0
+FILE_PATH=$(printf '%s' "$JSON_INPUT" | jq -r '.tool_input.file_path // empty')
 
 # Check if we successfully extracted a file path
 if [ -z "$FILE_PATH" ]; then

package/plugins/lisa-typescript/hooks/lint-on-edit.sh

@@ -19,8 +19,11 @@
 # @see .claude/rules/verfication.md "Self-Correction Loop" section
 # =============================================================================
 
-# Extract file path from JSON input
-FILE_PATH=$(cat | grep -o '"file_path":"[^"]*"' | head -1 | cut -d'"' -f4)
+# Extract file path from JSON input. Use jq for robust JSON parsing (never
+# grep/sed/cut — a shape change would silently skip the blocking lint gate).
+# Fail open without jq so we never hard-block an edit.
+command -v jq >/dev/null 2>&1 || exit 0
+FILE_PATH=$(cat | jq -r '.tool_input.file_path // empty')
 
 if [ -z "$FILE_PATH" ] || [ ! -f "$FILE_PATH" ]; then
     exit 0

package/plugins/lisa-typescript/hooks/sg-scan-on-edit.sh

@@ -7,8 +7,11 @@
 # Reference: https://docs.claude.com/en/docs/claude-code/hooks
 # Note: This hook is BLOCKING - it returns non-zero exit codes so Claude must fix issues
 
-# Extract file path from JSON input
-FILE_PATH=$(cat | grep -o '"file_path":"[^"]*"' | head -1 | cut -d'"' -f4)
+# Extract file path from JSON input. Use jq for robust JSON parsing (never
+# grep/sed/cut — a shape change would turn this blocking scan into a silent
+# no-op). Fail open without jq so we never hard-block an edit.
+command -v jq >/dev/null 2>&1 || exit 0
+FILE_PATH=$(cat | jq -r '.tool_input.file_path // empty')
 
 if [ -z "$FILE_PATH" ] || [ ! -f "$FILE_PATH" ]; then
     exit 0

package/plugins/lisa-wiki/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa-wiki",
-  "version": "2.119.0",
+  "version": "2.121.0",
   "description": "LLM Wiki — a distributable, git-native markdown knowledge base for Claude Code and Codex",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa-wiki/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa-wiki",
-  "version": "2.119.0",
+  "version": "2.121.0",
   "description": "Distributable LLM Wiki kernel — ingest, query, lint, and maintain a git-native markdown knowledge base across Claude and Codex.",
   "author": {
     "name": "Cody Swann"

package/plugins/src/typescript/hooks/format-on-edit.sh

@@ -9,9 +9,11 @@
 # Read the JSON input from stdin
 JSON_INPUT=$(cat)
 
-# Extract the file path from the tool_input
-# The Edit tool input contains a "file_path" field in the tool_input object
-FILE_PATH=$(echo "$JSON_INPUT" | grep -o '"tool_input":{[^}]*"file_path":"[^"]*"' | grep -o '"file_path":"[^"]*"' | cut -d'"' -f4)
+# Extract the file path from the tool_input. Use jq for robust JSON parsing
+# (never grep/sed/cut — a JSON shape change silently skips formatting). Fail
+# open without jq so we never hard-block an edit.
+command -v jq >/dev/null 2>&1 || exit 0
+FILE_PATH=$(printf '%s' "$JSON_INPUT" | jq -r '.tool_input.file_path // empty')
 
 # Check if we successfully extracted a file path
 if [ -z "$FILE_PATH" ]; then

package/plugins/src/typescript/hooks/lint-on-edit.sh

@@ -19,8 +19,11 @@
 # @see .claude/rules/verfication.md "Self-Correction Loop" section
 # =============================================================================
 
-# Extract file path from JSON input
-FILE_PATH=$(cat | grep -o '"file_path":"[^"]*"' | head -1 | cut -d'"' -f4)
+# Extract file path from JSON input. Use jq for robust JSON parsing (never
+# grep/sed/cut — a shape change would silently skip the blocking lint gate).
+# Fail open without jq so we never hard-block an edit.
+command -v jq >/dev/null 2>&1 || exit 0
+FILE_PATH=$(cat | jq -r '.tool_input.file_path // empty')
 
 if [ -z "$FILE_PATH" ] || [ ! -f "$FILE_PATH" ]; then
     exit 0

package/plugins/src/typescript/hooks/sg-scan-on-edit.sh

@@ -7,8 +7,11 @@
 # Reference: https://docs.claude.com/en/docs/claude-code/hooks
 # Note: This hook is BLOCKING - it returns non-zero exit codes so Claude must fix issues
 
-# Extract file path from JSON input
-FILE_PATH=$(cat | grep -o '"file_path":"[^"]*"' | head -1 | cut -d'"' -f4)
+# Extract file path from JSON input. Use jq for robust JSON parsing (never
+# grep/sed/cut — a shape change would turn this blocking scan into a silent
+# no-op). Fail open without jq so we never hard-block an edit.
+command -v jq >/dev/null 2>&1 || exit 0
+FILE_PATH=$(cat | jq -r '.tool_input.file_path // empty')
 
 if [ -z "$FILE_PATH" ] || [ ! -f "$FILE_PATH" ]; then
     exit 0

package/scripts/build-plugins.sh

@@ -43,6 +43,20 @@ build_plugin() {
   echo "Built plugins/$out_name (v$VERSION)"
 }
 
+# Generate a Pattern B per-agent variant for the base plugin only.
+# Variants are derived from the built Claude artifact at plugins/lisa/
+# and land at plugins/lisa-<agent>/.
+build_per_agent_variant() {
+  local agent="$1"
+  local src="$PLUGINS_DIR/lisa"
+  if [ ! -d "$src" ]; then
+    echo "Skipping per-agent variant lisa-$agent (no plugins/lisa source)"
+    return 0
+  fi
+  local out="$PLUGINS_DIR/lisa-$agent"
+  node "$ROOT_DIR/scripts/generate-${agent}-plugin-artifacts.mjs" "$src" "$out" "$VERSION"
+}
+
 # Base plugin
 build_plugin base lisa
 
@@ -57,3 +71,13 @@ STANDALONE=(wiki openclaw)
 for name in "${STANDALONE[@]}"; do
   build_plugin "$name" "lisa-$name"
 done
+
+# Pattern B per-agent variants of the base Lisa plugin.
+# Codex is NOT generated as a separate plugins/lisa-codex/ artifact — Codex
+# reads .codex-plugin/plugin.json from plugins/lisa/ directly (the existing
+# dual-pointer pattern, preserved per
+# wiki/architecture/pattern-b-fan-out-spec.md).
+PER_AGENT_VARIANTS=(cursor agy copilot)
+for agent in "${PER_AGENT_VARIANTS[@]}"; do
+  build_per_agent_variant "$agent"
+done

package/scripts/generate-agy-plugin-artifacts.mjs

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+/**
+ * Generate the agy (Antigravity) variant of a Lisa plugin from the built
+ * Claude artifact.
+ *
+ * agy's plugin manifest is a bare `plugin.json` at the plugin root (NOT
+ * `.claude-plugin/plugin.json`). The Wave 1 audit also established that agy
+ * plugin-bundled hooks DO NOT FIRE in `-p` headless mode, so the agy variant
+ * ships no hooks at all — the manifest's `hooks` field is dropped and the
+ * `hooks/` directory is omitted. Rules-injection for agy uses the AGENTS.md
+ * bake-in alternative implemented in `src/agy/rules-bake.ts` (per the parity
+ * research artifact's Cluster 4-agy / Option α).
+ *
+ * Usage: node scripts/generate-agy-plugin-artifacts.mjs <source-plugin-dir> <out-dir> <version>
+ *
+ * @module scripts/generate-agy-plugin-artifacts
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const REPO_ROOT = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  ".."
+);
+const POLICY_PATH = path.join(
+  REPO_ROOT,
+  "scripts",
+  "internal-agy-skill-policy.json"
+);
+
+/**
+ * Read the per-agent skill policy file.
+ *
+ * @returns {{ denylist?: string[] }}
+ */
+function readPolicy() {
+  if (!fs.existsSync(POLICY_PATH)) return {};
+  try {
+    return JSON.parse(fs.readFileSync(POLICY_PATH, "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Recursive directory copy with optional path-level filter.
+ *
+ * @param {string} src
+ * @param {string} dst
+ * @param {(relPath: string, stat: fs.Stats) => boolean} keep
+ */
+function copyDir(src, dst, keep = () => true) {
+  if (!fs.existsSync(src)) return;
+  fs.mkdirSync(dst, { recursive: true });
+  const walk = (current, rel) => {
+    for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+      const srcPath = path.join(current, entry.name);
+      const relPath = path.join(rel, entry.name);
+      const dstPath = path.join(dst, relPath);
+      const stat = fs.statSync(srcPath);
+      if (!keep(relPath, stat)) continue;
+      if (entry.isDirectory()) {
+        fs.mkdirSync(dstPath, { recursive: true });
+        walk(srcPath, relPath);
+      } else if (entry.isFile()) {
+        fs.copyFileSync(srcPath, dstPath);
+      }
+    }
+  };
+  walk(src, "");
+}
+
+/**
+ * Generate the agy variant.
+ *
+ * Transformation steps (from Wave 2 pattern-b-fan-out-spec.md):
+ *   0. Filter skills/ against scripts/internal-agy-skill-policy.json.
+ *   1. Copy source to outDir minus filtered skills, .codex-plugin/, hooks/, and rules/.
+ *   2. Move .claude-plugin/plugin.json to bare plugin.json at root; drop .claude-plugin/.
+ *   3. Drop the hooks field from the manifest (agy plugin hooks don't fire in -p).
+ *   4. Inject the version.
+ *
+ * @param {string} srcDir Built Claude plugin directory (input).
+ * @param {string} outDir agy variant output directory.
+ * @param {string} version Version string for the manifest.
+ */
+export function generateAgyVariant(srcDir, outDir, version) {
+  const claudeManifest = path.join(srcDir, ".claude-plugin", "plugin.json");
+  if (!fs.existsSync(claudeManifest)) return;
+
+  const policy = readPolicy();
+  const denylist = new Set(policy.denylist ?? []);
+
+  fs.rmSync(outDir, { recursive: true, force: true });
+  fs.mkdirSync(outDir, { recursive: true });
+
+  // 1. Copy source minus structural strips.
+  copyDir(srcDir, outDir, relPath => {
+    // Strip directories that don't apply to agy.
+    if (relPath.startsWith(".codex-plugin/") || relPath === ".codex-plugin") {
+      return false;
+    }
+    if (relPath.startsWith("hooks/") || relPath === "hooks") return false; // hooks don't fire on agy
+    if (relPath.startsWith("rules/") || relPath === "rules") return false; // rules not a plugin component on agy
+    // Drop Codex-specific per-skill openai.yaml artifacts.
+    if (/^skills\/[^/]+\/agents\/openai\.ya?ml$/.test(relPath)) return false;
+    // Apply skill denylist.
+    const skillsPrefix = path.join("skills") + path.sep;
+    if (relPath.startsWith(skillsPrefix)) {
+      const skillName = relPath.slice(skillsPrefix.length).split(path.sep)[0];
+      if (denylist.has(skillName)) return false;
+    }
+    // Skip the .claude-plugin manifest — we'll write a bare plugin.json instead.
+    if (
+      relPath === path.join(".claude-plugin", "plugin.json") ||
+      relPath === ".claude-plugin"
+    ) {
+      return false;
+    }
+    return true;
+  });
+
+  // 1a. Remove any now-empty `skills/<n>/agents/` directories left by the openai.yaml strip.
+  const skillsDir = path.join(outDir, "skills");
+  if (fs.existsSync(skillsDir)) {
+    for (const skillName of fs.readdirSync(skillsDir)) {
+      const agentsDir = path.join(skillsDir, skillName, "agents");
+      if (fs.existsSync(agentsDir) && fs.readdirSync(agentsDir).length === 0) {
+        fs.rmdirSync(agentsDir);
+      }
+    }
+  }
+
+  // 2. Read the Claude manifest, drop hooks, rename to bare plugin.json.
+  const manifest = JSON.parse(fs.readFileSync(claudeManifest, "utf8"));
+  manifest.version = version;
+  delete manifest.hooks;
+
+  // 3. Drop any pointer fields that agy doesn't understand.
+  // agy reads bare plugin.json with components: skills, agents, commands,
+  // mcpServers, hooks. We omit hooks above. MCP is not a plugin component on
+  // agy, so drop any `mcpServers` if present (Lisa's base today does not
+  // emit one, but be defensive).
+  delete manifest.mcpServers;
+
+  const bareManifestPath = path.join(outDir, "plugin.json");
+  fs.writeFileSync(bareManifestPath, JSON.stringify(manifest, null, 2) + "\n");
+
+  // 4. Ensure no .claude-plugin/ directory survives.
+  const ghostDir = path.join(outDir, ".claude-plugin");
+  if (fs.existsSync(ghostDir)) {
+    fs.rmSync(ghostDir, { recursive: true, force: true });
+  }
+}
+
+// CLI entrypoint.
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const [srcDir, outDir, version] = process.argv.slice(2);
+  if (!srcDir || !outDir || !version) {
+    console.error(
+      "Usage: generate-agy-plugin-artifacts.mjs <src> <out> <version>"
+    );
+    process.exit(1);
+  }
+  generateAgyVariant(srcDir, outDir, version);
+  console.log(`Generated agy variant at ${outDir} (v${version})`);
+}

package/scripts/generate-codex-plugin-artifacts.mjs

@@ -3,18 +3,29 @@
  * Generate Codex plugin artifacts from the built Claude plugin directories.
  *
  * Claude remains Lisa's production path; this script derives the .codex-plugin
- * metadata (skills + MCP pointers) every time plugins are rebuilt.
- *
- * NOTE ON HOOKS: this script does NOT emit Codex hooks. Codex (codex-cli
- * 0.125.0) does not execute plugin-bundled hooks — its plugin manifest parser
- * only honors `skills`, `mcpServers`, `apps`, and interface fields, and a
- * runtime test confirmed a bundled `hooks/hooks.json` never fires. Lisa's
- * Codex hooks are instead installed into the project's `.codex/hooks.json`
- * by `src/codex/hooks-installer.ts` (run during `lisa` apply). Hooks with no
- * Codex equivalent are intentionally not ported: `enforce-team-first.sh`
- * (Claude-team-specific), `inject-flow-context.sh` and any SubagentStart hook
- * (Codex has no SubagentStart event), and the SessionEnd `entire` hook (Codex
- * has no SessionEnd event).
+ * metadata (skills + MCP pointers + hooks) every time plugins are rebuilt.
+ *
+ * HOOKS: as of Codex 0.125.0 (verified via codex features list showing
+ * codex_hooks as `stable`), the plugin manifest accepts a `hooks` field
+ * pointing at a sibling `hooks.json`. `emitCodexHooks` below derives the
+ * Codex-shape hooks block from the Claude manifest by applying the Wave 1
+ * per-agent ship-list audit
+ * (wiki/architecture/lisa-hook-per-agent-ship-list.md):
+ *   - Drop every `entire hooks claude-code *` command (Claude-only analytics).
+ *   - Drop every reference to `enforce-team-first.sh` (Claude-team-specific).
+ *   - Drop `inject-flow-context.sh` ONLY when targeting an agent without
+ *     SubagentStart (Codex 0.125.0 has SubagentStart, so we ship it).
+ *   - Rewrite ${CLAUDE_PLUGIN_ROOT}/hooks/<n>.sh to ./hooks/<n>.sh so the
+ *     hooks.json sibling can resolve the script path relative to itself.
+ *   - Copy the surviving scripts into .codex-plugin/hooks/.
+ *
+ * SessionEnd is documented as unsupported by Codex; the `entire hooks
+ * claude-code session-end` hook is stripped per the Claude-only rule above
+ * regardless of event support.
+ *
+ * src/codex/hooks-installer.ts remains as the documented fallback for users
+ * who install Lisa via `lisa apply` without enabling the marketplace plugin —
+ * src/codex/lisa-plugin-detection.ts is the helper that gates that fallback.
  */
 import fs from "node:fs";
 import path from "node:path";
@@ -441,10 +452,55 @@ function main() {
   const pluginName = claudeManifest.name;
 
   pruneInternalCodexSkills(pluginDir);
+  emitCodexHooks(pluginDir, claudeManifest);
   writeCodexManifest(pluginDir, claudeManifest, pluginName, versionArg);
   writeSkillAgents(pluginDir);
 }
 
+/**
+ * Per Wave 1 audit + Codex 0.125.0 supporting plugin-bundled hooks: derive
+ * a Codex-shaped hooks.json from the Claude manifest's hooks block and copy
+ * the surviving scripts into .codex-plugin/hooks/.
+ *
+ * No-op when the input has no hooks block or every entry is stripped.
+ *
+ * @param {string} pluginDir Built Claude plugin directory.
+ * @param {object} claudeManifest Parsed contents of .claude-plugin/plugin.json.
+ */
+function emitCodexHooks(pluginDir, claudeManifest) {
+  const codexPluginDir = path.join(pluginDir, ".codex-plugin");
+  const hooksJsonPath = path.join(codexPluginDir, "hooks.json");
+  const hooksScriptsDir = path.join(codexPluginDir, "hooks");
+  const filtered = filterCodexHooks(claudeManifest.hooks);
+  if (filtered === null) {
+    // Nothing survived the filter. Remove any stale hooks artifacts from a
+    // prior build so componentPointers() doesn't keep advertising removed
+    // hooks via the ./hooks.json pointer.
+    fs.rmSync(hooksJsonPath, { force: true });
+    fs.rmSync(hooksScriptsDir, { force: true, recursive: true });
+    return;
+  }
+  fs.mkdirSync(codexPluginDir, { recursive: true });
+  fs.writeFileSync(
+    hooksJsonPath,
+    `${JSON.stringify(buildCodexHooksDocument(filtered), null, 2)}\n`
+  );
+  copyCodexHookScripts(pluginDir, filtered);
+}
+
+/**
+ * Wrap a filtered events block in the document shape Codex's hooks.json parser
+ * expects: events nested under a top-level "hooks" key (see the HooksFile
+ * contract in src/codex/hooks-merger.ts). Writing the events block at the root
+ * would not be recognized as hooks.
+ *
+ * @param {object} filtered Codex-shaped events block from filterCodexHooks.
+ * @returns {{ hooks: object }} The hooks.json document root.
+ */
+export function buildCodexHooksDocument(filtered) {
+  return { hooks: filtered };
+}
+
 function writeCodexManifest(pluginDir, claudeManifest, pluginName, version) {
   const metadata = metadataFor(pluginName, claudeManifest);
   const manifest = {
@@ -484,9 +540,111 @@ function componentPointers(pluginDir) {
     ...(fs.existsSync(path.join(pluginDir, ".mcp.json"))
       ? { mcpServers: "./.mcp.json" }
       : {}),
+    ...(fs.existsSync(path.join(pluginDir, ".codex-plugin", "hooks.json"))
+      ? { hooks: "./hooks.json" }
+      : {}),
   };
 }
 
+/**
+ * Per the Wave 1 hook audit, derive Codex-shaped hooks.json from the
+ * Claude plugin.json hooks block:
+ *   - Drop every `entire hooks claude-code *` command (Claude-only).
+ *   - Drop every reference to `enforce-team-first.sh` (Claude-team-specific).
+ *   - Rewrite ${CLAUDE_PLUGIN_ROOT}/hooks/<script>.sh to ./hooks/<script>.sh
+ *     (Codex resolves plugin paths relative to .codex-plugin/plugin.json).
+ *   - Drop matchers that produce no surviving handlers.
+ *
+ * When the resulting block is empty, no hooks.json is written and the
+ * manifest pointer omits the hooks field.
+ *
+ * @param {object} hooksBlock The hooks field from the Claude plugin manifest.
+ * @returns {object | null} A Codex-shape hooks block or null when empty.
+ */
+export function filterCodexHooks(hooksBlock) {
+  if (!hooksBlock || typeof hooksBlock !== "object") return null;
+  const codexStrip = new Set(["enforce-team-first.sh"]);
+  const isEntire = cmd =>
+    typeof cmd === "string" &&
+    /command -v entire >\/dev\/null 2>&1 && entire hooks claude-code /.test(
+      cmd
+    );
+  const scriptName = cmd => {
+    if (typeof cmd !== "string") return null;
+    const m = /\$\{CLAUDE_PLUGIN_ROOT\}\/hooks\/([^/\s]+\.sh)/.exec(cmd);
+    return m ? m[1] : null;
+  };
+  const out = {};
+  for (const [event, entries] of Object.entries(hooksBlock)) {
+    if (!Array.isArray(entries)) continue;
+    const keptEntries = [];
+    for (const entry of entries) {
+      const handlers = entry?.hooks;
+      if (!Array.isArray(handlers)) continue;
+      const keptHandlers = handlers.flatMap(h => {
+        if (!h || typeof h.command !== "string") return [];
+        if (isEntire(h.command)) return [];
+        const script = scriptName(h.command);
+        if (script !== null) {
+          if (codexStrip.has(script)) return [];
+          return [
+            {
+              ...h,
+              // Codex hook commands resolve relative to .codex-plugin/plugin.json;
+              // rewrite to a path the hooks.json sibling will find.
+              command: h.command.replaceAll(
+                "${CLAUDE_PLUGIN_ROOT}/hooks/",
+                "./hooks/"
+              ),
+            },
+          ];
+        }
+        // Unknown command shape — ship verbatim.
+        return [h];
+      });
+      if (keptHandlers.length > 0) {
+        keptEntries.push({ ...entry, hooks: keptHandlers });
+      }
+    }
+    if (keptEntries.length > 0) {
+      out[event] = keptEntries;
+    }
+  }
+  return Object.keys(out).length > 0 ? out : null;
+}
+
+/**
+ * Copy hook scripts that survived filterCodexHooks into the Codex artifact.
+ *
+ * Scripts land at <pluginDir>/.codex-plugin/hooks/ so the hooks.json pointer
+ * "./hooks/<n>.sh" resolves correctly when Codex loads the plugin.
+ *
+ * @param {string} pluginDir Built Claude plugin directory.
+ * @param {object} hooks Codex-shaped hooks block from filterCodexHooks.
+ */
+function copyCodexHookScripts(pluginDir, hooks) {
+  const srcHooksDir = path.join(pluginDir, "hooks");
+  if (!fs.existsSync(srcHooksDir)) return;
+  const referenced = new Set();
+  for (const entries of Object.values(hooks)) {
+    for (const entry of entries) {
+      for (const h of entry.hooks ?? []) {
+        if (typeof h.command !== "string") continue;
+        const m = /^\.\/hooks\/([^/\s]+\.sh)/.exec(h.command);
+        if (m) referenced.add(m[1]);
+      }
+    }
+  }
+  if (referenced.size === 0) return;
+  const dstHooksDir = path.join(pluginDir, ".codex-plugin", "hooks");
+  fs.mkdirSync(dstHooksDir, { recursive: true });
+  for (const name of referenced) {
+    const src = path.join(srcHooksDir, name);
+    if (!fs.existsSync(src)) continue;
+    fs.copyFileSync(src, path.join(dstHooksDir, name));
+  }
+}
+
 function metadataFor(pluginName, claudeManifest) {
   const map = {
     lisa: {