@rune-kit/rune 2.26.0 → 2.26.2

package/README.md

@@ -103,11 +103,19 @@ Plus **9 domain packs** (product, sales, data-science, support, growth, media, p
 
 ---
 
-## What's New (v2.26.0 — Motion Craft)
+## What's New (v2.26.2 — Hook Output Contract)
+
+> **v2.26.2 (2026-07-22):** The other half of the Codex wiring fix — v2.26.1 made the hook matchers fire, this makes the hooks **succeed**. Codex parses hook stdout as JSON and reports anything else as `hook: <Event> Failed`, discarding the output; Rune's hooks printed bare `[Rune: ...]` lines, so every hook that loaded on Codex ran, exited 0, and had its output thrown away. Hooks now emit the envelope both runtimes accept — `hookSpecificOutput.additionalContext` for context events, `systemMessage` otherwise — which is Claude Code's documented contract too, not a Codex branch. Verified live against codex-cli 0.145: the same hook goes `SessionStart Failed` → `SessionStart Completed`.
+
+### Previous (v2.26.1 — Codex Wiring)
+
+> **v2.26.1 (2026-07-22):** Rune's runtime hooks were silently inert on **Codex CLI**. `hooks/hooks.json` is loaded by both Claude Code and Codex — Codex reads `<plugin>/hooks/hooks.json`, the same path, and maps the event names — but every tool matcher named only Claude's tools. Codex has no `Read`, `Write`, `Edit` or `Bash` tool; it issues `shell_command`, `exec`, `apply_patch`, `view_image`, `spawn_agent`. So the privacy gate and the secret scanner matched nothing and never fired. Matchers now name both platforms' tools (plain alternation — Claude behaviour is byte-for-byte unchanged), and `pre-tool-guard` reads the target path out of a Codex `apply_patch` payload (`*** Update File: <path>`), which is what makes it an actual gate there instead of a no-op. Note that Codex does not support `async` hooks yet and skips them, so Rune's six background hooks stay inactive on Codex — `async` is kept because Claude Code honours it.
+
+#### Earlier (v2.26.0 — Motion Craft)
 
 > **v2.26.0 (2026-07-18):** Rune's UI mesh gains a deep **motion authority**. New reference `skills/design/MOTION-CRAFT.md` is the canonical source for animation decisions: the *should-it-animate* frequency gate (never animate keyboard/100+-per-day actions), easing decision tree with strong custom curves, per-element duration budgets (UI under 300ms, modals/drawers exempt to 500ms), physicality rules (never `scale(0)`, origin-aware popovers, press feedback), spring physics (damping/response, velocity handoff, momentum projection, rubber-banding), interruptibility (transitions vs keyframes, `@starting-style`), motion performance, reduced-motion, and a reverse-lookup vocabulary glossary. `design` (v0.8.0) loads it whenever a domain involves motion and gains an advisory motion-audit mode. `review` (v1.5.0) adds **Motion Craft Checks** — an advisory lens that fires only on motion diffs, flagging `ease-in` on UI, `scale(0)` entrances, animation on high-frequency actions, layout-property animation, and more, citing MOTION-CRAFT for exact fixes. `perf` (v0.6.0) adds **Step 5.5 Motion Performance** — GPU-property, Framer-Motion-shorthand, and recalc-storm detection ranked in the Cost Impact Hierarchy. Advisory-first throughout (no new HARD-GATEs) — enrichment only, mesh unchanged at 66 skills.
 
-### Previous (v2.25.0 — Council)
+#### Earlier (v2.25.0 — Council)
 
 > **v2.25.0 (2026-07-11):** New **`council`** L3 primitive — genuinely decorrelated multi-perspective gathering. Detects installed AI CLIs, fans a question across distinct model families (external CLIs when present, subagents when not), gates off-topic/malformed voices, normalizes claims (anchor-first + shared-evidence arbiter fallback — prose similarity never counts), and arbitrates inline with an honest `NO_DECORRELATION` stamp when fewer than 2 real model families answered. Wired into 4 consumers: `adversary` (CRITICAL-tier plans), `review` (high-blast-radius diffs), `brainstorm` (Design-It-Twice candidate judgment), `problem-solver` (high-stakes conclusions) — every integration explicitly refuses to launder a same-family run as independent confirmation. **Live-dogfooded same day**: a real 3-voice self-test (external `grok` dispatch + 2 subagent fallbacks) independently converged on a real gap — "confirmed" `model_family` was CLI-brand identity, not verified backend identity, letting two CLIs redirected to the same backend (BYOK/proxy override) defeat the gate — fixed before shipping. **Pro**: `council-cockpit` (separate repo) adds a read-only live panel + cost-aware allocation + history-informed family weighting, PRE-council advisory only — Free never depends on Pro. Mesh now 66 skills / 208 connections / 45 signals.
 

package/hooks/hooks.json

@@ -26,7 +26,7 @@
     ],
     "PreToolUse": [
       {
-        "matcher": "Read|Write|Edit",
+        "matcher": "Read|Write|Edit|apply_patch|view_image",
         "hooks": [
           {
             "type": "command",
@@ -46,7 +46,7 @@
         ]
       },
       {
-        "matcher": "Bash",
+        "matcher": "Bash|shell_command",
         "hooks": [
           {
             "type": "command",
@@ -58,7 +58,7 @@
     ],
     "PostToolUse": [
       {
-        "matcher": "Edit|Write",
+        "matcher": "Edit|Write|apply_patch",
         "hooks": [
           {
             "type": "command",
@@ -73,7 +73,7 @@
         ]
       },
       {
-        "matcher": "Skill|Task|Agent",
+        "matcher": "Skill|Task|Agent|spawn_agent",
         "hooks": [
           {
             "type": "command",
@@ -83,7 +83,7 @@
         ]
       },
       {
-        "matcher": "mcp__.*|WebFetch|Read",
+        "matcher": "mcp__.*|WebFetch|Read|web_search",
         "hooks": [
           {
             "type": "command",

package/hooks/lib/hook-output.cjs

@@ -0,0 +1,102 @@
+'use strict';
+
+// Hook stdout envelope — the one format both runtimes accept.
+//
+// Claude Code tolerates bare text on a hook's stdout. Codex CLI does not: it
+// parses stdout as its `HookUniversalOutputWire` JSON and reports anything else
+// as `hook: <Event> Failed`, discarding the output. Every Rune hook that printed
+// a plain `[Rune: ...]` line was therefore failing on Codex — the hooks loaded,
+// ran, exited 0, and had their output thrown away.
+//
+// Both runtimes accept the same envelope, so emitting it is not a Codex-specific
+// branch — it is simply the correct output contract:
+//
+//   {"hookSpecificOutput":{"hookEventName":"SessionStart","additionalContext":"…"}}
+//   {"systemMessage":"…"}
+//
+// Verified against codex-cli 0.145 (schema read from the binary: decision,
+// reason, continue, stopReason, suppressOutput, systemMessage, and
+// hookSpecificOutput.{hookEventName,additionalContext,permissionDecision,…};
+// unknown keys are rejected) and Claude Code's documented hook output.
+//
+// Buffer-then-emit, because the envelope is ONE JSON object: a hook that prints
+// three lines must accumulate them and emit once at exit, not three times.
+
+/** Events where the model-facing payload is `additionalContext`. */
+const CONTEXT_EVENTS = new Set(['SessionStart', 'UserPromptSubmit']);
+
+/**
+ * Collects a hook's output and emits a single valid envelope.
+ *
+ * @param {string} hookEventName  Claude/Codex event name, e.g. 'SessionStart'
+ * @returns {{line: (text: string) => void, emit: () => void, isEmpty: () => boolean}}
+ */
+function outputBuffer(hookEventName) {
+  const parts = [];
+  return {
+    /** Queue one line of output. Empty/blank input is ignored. */
+    line(text) {
+      if (typeof text !== 'string') return;
+      const trimmed = text.replace(/\s+$/, '');
+      if (trimmed.trim()) parts.push(trimmed);
+    },
+    isEmpty() {
+      return parts.length === 0;
+    },
+    /** Write the envelope. Emits nothing at all when there is nothing to say. */
+    emit() {
+      if (parts.length === 0) return;
+      const text = parts.join('\n');
+      const payload = CONTEXT_EVENTS.has(hookEventName)
+        ? { hookSpecificOutput: { hookEventName, additionalContext: text } }
+        : { systemMessage: text };
+      process.stdout.write(`${JSON.stringify(payload)}\n`);
+    },
+  };
+}
+
+/**
+ * One-shot form for hooks with a single message.
+ *
+ * @param {string} hookEventName
+ * @param {string} text
+ */
+function emit(hookEventName, text) {
+  const buf = outputBuffer(hookEventName);
+  buf.line(text);
+  buf.emit();
+}
+
+/**
+ * Route a hook's existing `console.log` calls into one envelope.
+ *
+ * Hooks build their message across many prints and several early `process.exit`
+ * paths. Rewriting each print site into an explicit buffer would mean touching
+ * every branch — and missing one silently reintroduces the bare-text bug. So
+ * capture at the boundary instead: the message logic stays exactly as written,
+ * and the envelope is emitted once on exit no matter which branch got there.
+ *
+ * `console.error` is untouched — stderr is not parsed as the output contract.
+ *
+ * @param {string} hookEventName
+ * @returns {{buffer: ReturnType<typeof outputBuffer>, restore: () => void}}
+ */
+function captureConsole(hookEventName) {
+  const buffer = outputBuffer(hookEventName);
+  const original = console.log;
+  console.log = (...args) => {
+    buffer.line(args.map((a) => (typeof a === 'string' ? a : String(a))).join(' '));
+  };
+  const restore = () => {
+    console.log = original;
+  };
+  // Fires for a natural end AND for process.exit(), which is how the BLOCK
+  // paths leave — those messages must survive too.
+  process.on('exit', () => {
+    restore();
+    buffer.emit();
+  });
+  return { buffer, restore };
+}
+
+module.exports = { outputBuffer, emit, captureConsole, CONTEXT_EVENTS };

package/hooks/post-session-reflect/index.cjs

@@ -5,6 +5,11 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { captureConsole } = require('../lib/hook-output.cjs');
+// Hook stdout is a JSON contract, not free text (Codex rejects bare lines and
+// discards the output). Capture the prints below and emit one envelope on exit.
+captureConsole('Stop');
+
 
 const cwd = process.cwd();
 const hash = Buffer.from(cwd).toString('base64url').slice(0, 16);

package/hooks/pre-compact/index.cjs

@@ -9,6 +9,12 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
+const { captureConsole } = require('../lib/hook-output.cjs');
+// Hook stdout is a JSON contract, not free text (Codex rejects bare lines and
+// discards the output). Capture the prints below and emit one envelope on exit.
+captureConsole('PreCompact');
+
+
 const cwd = process.cwd();
 const runeDir = path.join(cwd, '.rune');
 

package/hooks/pre-tool-guard/index.cjs

@@ -15,6 +15,12 @@
 const fs = require('fs');
 const path = require('path');
 
+const { captureConsole } = require('../lib/hook-output.cjs');
+// Hook stdout is a JSON contract, not free text (Codex rejects bare lines and
+// discards the output). Capture the prints below and emit one envelope on exit.
+captureConsole('PreToolUse');
+
+
 /**
  * Append a structured gate-outcome record to .rune/metrics/gate-outcomes.jsonl
  * relative to process.cwd(). Best-effort: any error is silently swallowed so
@@ -50,6 +56,26 @@ function appendGateOutcome(gate, outcome, detail) {
   }
 }
 
+/**
+ * Path a Codex `apply_patch` call is about to write.
+ *
+ * Codex has no Edit/Write tool — file writes arrive as one `apply_patch` call
+ * whose payload is raw patch text, so there is no `file_path` to read. The
+ * target is in the patch header. Without this the privacy gate is a no-op on
+ * Codex: every write sails past.
+ *
+ * @param {string} toolName
+ * @param {object} toolInput
+ * @returns {string} target path, or '' when this is not a patch we understand
+ */
+function patchTargetPath(toolName, toolInput) {
+  if (toolName !== 'apply_patch') return '';
+  const patch = typeof toolInput === 'string' ? toolInput : toolInput.input || toolInput.patch || '';
+  if (typeof patch !== 'string') return '';
+  const match = patch.match(/^\*\*\* (?:Update|Add|Delete) File:\s*(.+)$/m);
+  return match ? match[1].trim() : '';
+}
+
 // Read tool_input from Claude Code hook stdin
 let input = '';
 process.stdin.setEncoding('utf-8');
@@ -66,7 +92,7 @@ process.stdin.on('end', () => {
     process.exit(0);
   }
 
-  const filePath = toolInput.file_path || toolInput.path || '';
+  const filePath = toolInput.file_path || toolInput.path || patchTargetPath(toolName, toolInput);
   if (!filePath) process.exit(0);
 
   const basename = path.basename(filePath);

package/hooks/session-start/index.cjs

@@ -4,6 +4,11 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { captureConsole } = require('../lib/hook-output.cjs');
+// Hook stdout is a JSON contract, not free text (Codex rejects bare lines and
+// discards the output). Capture the prints below and emit one envelope on exit.
+captureConsole('SessionStart');
+
 
 const cwd = process.cwd();
 const runeDir = path.join(cwd, '.rune');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rune-kit/rune",
-  "version": "2.26.0",
+  "version": "2.26.2",
   "description": "65-skill mesh for AI coding assistants — runtime auto-discipline via native hooks (Claude/Cursor/Windsurf/Antigravity), 5-layer architecture, 204 connections + 43 signals, multi-platform compiler. converge (L3) scans spec vs code so dead-button/frontend-only implementations can't ship.",
   "type": "module",
   "bin": {