release: occam 0.4.0 (occam run + Codex PreToolUse hard-wire)

- engine/run.mjs: occam run <cmd> wraps a command, compacts output, keeps exit
  code (subshell so compound commands redirect + exit cleanly).
- engine/codex.mjs + occam codex-hook: Codex PreToolUse rewrites noisy commands
  to occam run <cmd> (the one non-Claude host whose hook can rewrite a command).
  6 unit tests cover wrap / no-double-wrap / non-noisy / non-Bash / bad input.
- occam init codex writes .codex/hooks.json (idempotent merge, no clobber).
- detectFilter recognizes npm/yarn/pnpm/bun test, so npm test sieves as a test.
- README + CHANGELOG: honest per-agent input story.

18/18 tests, generate --check in sync.

Author: borghei

.claude-plugin/marketplace.json

@@ -2,14 +2,14 @@
   "name": "occam",
   "description": "Occam, write the right amount of code.",
   "owner": { "name": "borghei", "url": "https://github.com/borghei" },
-  "version": "0.3.0",
+  "version": "0.4.0",
   "plugins": [
     {
       "name": "occam",
       "source": "./",
       "displayName": "Occam",
       "description": "Always-on right-sizing ruleset for AI coding agents, fewer tokens, compact code, no under-engineering.",
-      "version": "0.3.0",
+      "version": "0.4.0",
       "author": { "name": "borghei" },
       "homepage": "https://github.com/borghei/occam",
       "repository": "https://github.com/borghei/occam",

.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "occam",
   "displayName": "Occam",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Write the right amount of code. An always-on right-sizing ruleset for AI coding agents, fewer tokens, compact code, no under-engineering.",
   "author": { "name": "borghei", "url": "https://github.com/borghei/occam" },
   "homepage": "https://github.com/borghei/occam",

CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.4.0
+
+- `occam run <cmd>`: run a command, compact its output, keep its exit code. The
+  cross-agent input lever, and it fixes the exit-code-through-a-pipe problem that
+  `occam compact` can't. Full passthrough on a non-zero exit, same as the hook.
+- `occam init codex` hard-wires the input side: a `.codex/hooks.json` `PreToolUse`
+  hook rewrites noisy commands to `occam run` (Codex is the one non-Claude host
+  whose hook can rewrite a command). The merge is idempotent and never clobbers an
+  existing config. Other agents get the same effect from a rule instruction.
+- `detectFilter` now recognizes `npm` / `yarn` / `pnpm` / `bun test` (and `npm run
+  test`), not just runner names, so `npm test` output is sieved as a test run.
+
 ## 0.3.0
 
 - `occam init <agent>`: one line to turn the right-sizing rule on for any agent

README.md

@@ -63,6 +63,9 @@ commands through `occam run`, so the input side compacts too:
 occam run npm test
 ```
 
+On Codex, `occam init codex` goes further and wires a `PreToolUse` hook that does
+the wrapping for you. Trust it once in Codex with `/hooks`.
+
 ## How it works
 
 **Output, an always-on rule.** One short paragraph, injected every turn, that makes
@@ -76,9 +79,10 @@ generates every agent's format, so the rule can't drift. `scripts/generate.mjs
 model reads it. Strip ANSI, drop the `PASS`/`✓` noise, dedupe repeats, truncate
 while keeping head and tail. It knows a test run from an npm install, and on a
 non-zero exit it hands back the full output untouched. On Claude Code this runs on
-every command automatically (the plugin's `PostToolUse` hook). Other agents can't
-rewrite tool output from a hook, so `occam init` tells them to wrap noisy commands
-as `occam run <cmd>`, same engine, same trim.
+every command automatically (the plugin's `PostToolUse` hook). Codex gets a
+`PreToolUse` hook from `occam init codex` that rewrites noisy commands to `occam
+run`. Other hosts can't rewrite output or commands from a hook, so the installed
+rule tells the agent to use `occam run <cmd>` itself. Same engine, same trim.
 
 After install you also get `/occam:review` to shrink what you just wrote, plus
 `/occam:audit`, `/occam:debt` and `occam gain` for your running total.

engine/cli.mjs

@@ -29,6 +29,16 @@ if (cmd === "run") {
   process.exit(run(rest, { ledger: !opt.noLedger }));
 }
 
+if (cmd === "codex-hook") {
+  // Codex PreToolUse: rewrite noisy commands to `occam run <cmd>` (wired by init).
+  const { codexHook } = await import("./codex.mjs");
+  let stdin = "";
+  try { stdin = readFileSync(0, "utf8"); } catch {}
+  const out = codexHook(stdin);
+  if (out) process.stdout.write(out);
+  process.exit(0);
+}
+
 if (cmd === "gain") {
   // IN only, and it's a real measurement: actual bytes the compactor removed from
   // tool output before the model saw it. There's no honest OUT number to self-

engine/codex.mjs

@@ -0,0 +1,34 @@
+// Codex PreToolUse hook. Codex (unlike Cursor) lets a PreToolUse hook rewrite the
+// command before it runs, so occam wraps noisy commands in `occam run` and the
+// model reads the compacted output. Same idea as rtk's command rewrite, done the
+// way Codex actually supports.
+//
+// Input: the PreToolUse JSON on stdin ({ tool_name, tool_input: { command } }).
+// Output: nothing (leave the command as-is) or the rewrite envelope Codex wants:
+//   { hookSpecificOutput: { hookEventName, permissionDecision: "allow",
+//                           updatedInput: { command } } }
+
+import { detectFilter } from "./transforms.mjs";
+
+// Single-quote for /bin/sh so the whole original command survives as one argument
+// to `occam run`, compound commands and all.
+const shellQuote = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
+
+export function codexHook(stdin) {
+  let input;
+  try { input = JSON.parse(stdin); } catch { return ""; }
+  const cmd = input?.tool_input?.command;
+  const tool = input?.tool_name;
+  if (!cmd || (tool && tool !== "Bash" && tool !== "shell")) return "";
+  // Don't touch a command that already goes through occam (no double-wrap).
+  if (/\boccam\s+(run|compact)\b/.test(cmd)) return "";
+  // Only wrap what occam has a real filter for (tests, installs), the safe subset.
+  if (!detectFilter(cmd)) return "";
+  return JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "allow",
+      updatedInput: { command: `occam run ${shellQuote(cmd)}` },
+    },
+  });
+}

engine/init.mjs

@@ -1,10 +1,16 @@
 // `occam init <agent>` — one line to turn the right-sizing rule on for any agent.
 // Writes that agent's rule file into the current project, from the same source
-// (RULES.md) the committed copies come from. The IN-side compaction engine is a
-// Claude Code hook (the plugin wires it); other agents get the rule here and run
-// noisy commands through `occam compact` for the input side.
+// (RULES.md) the committed copies come from.
+//
+// Input compaction:
+//   - Claude Code: the plugin's PostToolUse hook does it (output-rewriting hooks
+//     only work there).
+//   - Codex: a PreToolUse hook can rewrite the command, so we wire `.codex/hooks.json`
+//     to wrap noisy commands in `occam run` (hard, no reliance on the agent).
+//   - Everyone else: their hooks can't rewrite output or command, so the rule tells
+//     the agent to run noisy commands through `occam run` itself.
 
-import { writeFileSync, mkdirSync } from "node:fs";
+import { writeFileSync, readFileSync, mkdirSync, existsSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { alwaysOnRule, buildTargets } from "../scripts/generate.mjs";
@@ -22,10 +28,8 @@ export function init(agent) {
   }
 
   const isClaude = a === "claude" || a === "claude-code";
+  const isCodex = a === "codex" || a === "openai";
 
-  // On Claude Code the plugin's PostToolUse hook compacts output automatically.
-  // Other agents can't rewrite tool output from a hook, so the rule tells the
-  // agent to run noisy commands through `occam run` instead (works on any agent).
   const body = isClaude
     ? target.body
     : target.body +
@@ -36,9 +40,36 @@ export function init(agent) {
   writeFileSync(dest, body);
 
   process.stdout.write(`occam: right-sizing rule on for ${a} → wrote ${target.path}\n`);
-  process.stdout.write(
-    isClaude
-      ? `input compaction is automatic via the plugin: /plugin marketplace add borghei/occam\n`
-      : `input side included: the rule now runs noisy commands through \`occam run\`. keep occam on PATH (npm i -g github:borghei/occam).\n`,
-  );
+  if (isClaude) {
+    process.stdout.write(`input compaction is automatic via the plugin: /plugin marketplace add borghei/occam\n`);
+  } else if (isCodex) {
+    wireCodexHook();
+  } else {
+    process.stdout.write(`input side included: the rule runs noisy commands through \`occam run\`. keep occam on PATH (npm i -g github:borghei/occam).\n`);
+  }
+}
+
+// Wire (or merge into) .codex/hooks.json a PreToolUse hook that rewrites noisy
+// commands to `occam run`. Never clobbers an unparseable file.
+function wireCodexHook() {
+  const file = join(process.cwd(), ".codex", "hooks.json");
+  const entry = { matcher: "^Bash$", hooks: [{ type: "command", command: "occam codex-hook" }] };
+
+  let cfg = { hooks: { PreToolUse: [] } };
+  if (existsSync(file)) {
+    try { cfg = JSON.parse(readFileSync(file, "utf8")); } catch { cfg = null; }
+  }
+  if (!cfg || typeof cfg !== "object") {
+    process.stdout.write(`couldn't parse .codex/hooks.json, add this PreToolUse hook by hand:\n  ${JSON.stringify(entry)}\n`);
+    return;
+  }
+
+  cfg.hooks = cfg.hooks || {};
+  cfg.hooks.PreToolUse = cfg.hooks.PreToolUse || [];
+  if (!JSON.stringify(cfg.hooks.PreToolUse).includes("occam codex-hook")) {
+    cfg.hooks.PreToolUse.push(entry);
+  }
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, JSON.stringify(cfg, null, 2) + "\n");
+  process.stdout.write(`input side: wired Codex PreToolUse hook → .codex/hooks.json. trust it in Codex with /hooks, and keep occam on PATH.\n`);
 }

engine/run.mjs

@@ -16,7 +16,8 @@ export function run(argv, { ledger = true } = {}) {
     return 2;
   }
   // Merge stderr into stdout so the model reads them in order, like a terminal.
-  const res = spawnSync("/bin/sh", ["-c", `${command} 2>&1`], {
+  // Subshell so the redirect and exit code cover a compound command as a whole.
+  const res = spawnSync("/bin/sh", ["-c", `( ${command} ) 2>&1`], {
     encoding: "utf8",
     maxBuffer: 64 * 1024 * 1024,
   });

engine/test/codex.test.mjs

@@ -0,0 +1,38 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { codexHook } from "../codex.mjs";
+
+const pre = (command, tool_name = "Bash") =>
+  JSON.stringify({ tool_name, tool_input: { command } });
+
+test("codex-hook wraps a noisy test command in occam run", () => {
+  const out = JSON.parse(codexHook(pre("npm test")));
+  assert.equal(out.hookSpecificOutput.hookEventName, "PreToolUse");
+  assert.equal(out.hookSpecificOutput.permissionDecision, "allow");
+  assert.equal(out.hookSpecificOutput.updatedInput.command, "occam run 'npm test'");
+});
+
+test("codex-hook wraps an install command too", () => {
+  const out = JSON.parse(codexHook(pre("pnpm install")));
+  assert.equal(out.hookSpecificOutput.updatedInput.command, "occam run 'pnpm install'");
+});
+
+test("codex-hook single-quotes a compound command as one argument", () => {
+  const out = JSON.parse(codexHook(pre("npm test && echo done")));
+  assert.equal(out.hookSpecificOutput.updatedInput.command, "occam run 'npm test && echo done'");
+});
+
+test("codex-hook leaves an already-wrapped command alone (no double-wrap)", () => {
+  assert.equal(codexHook(pre("occam run 'npm test'")), "");
+});
+
+test("codex-hook ignores commands occam has no filter for", () => {
+  assert.equal(codexHook(pre("ls -la")), "");
+  assert.equal(codexHook(pre("git status")), "");
+});
+
+test("codex-hook ignores non-Bash tools and bad input", () => {
+  assert.equal(codexHook(pre("npm test", "Read")), "");
+  assert.equal(codexHook("not json"), "");
+  assert.equal(codexHook("{}"), "");
+});

engine/transforms.mjs

@@ -75,7 +75,7 @@ export const FILTERS = {
 
 export function detectFilter(command = "") {
   const c = command.toLowerCase();
-  if (/\b(jest|vitest|pytest|mocha|rspec|go test|cargo test)\b/.test(c)) return "test";
+  if (/\b(jest|vitest|pytest|mocha|rspec)\b|\b(go|cargo) test\b|\b(npm|pnpm|yarn|bun)\s+(run\s+)?test\b/.test(c)) return "test";
   if (/\b(npm|pnpm|yarn|pip|pip3|bundle)\b.*\b(i|install|ci|add)\b/.test(c)) return "install";
   return null;
 }