The design language that makes your AI harness better at design.
JavaScript
Fix: emit Codex Stop hook as decision/block (#603)
Abdul Wahabc9e7cd8a641c
diff --git a/skill/scripts/hook-lib.mjs b/skill/scripts/hook-lib.mjsindex 794ac59a1..0a2d827e7 100644--- a/skill/scripts/hook-lib.mjs+++ b/skill/scripts/hook-lib.mjs@@ -1251,7 +1251,8 @@ export function resolveHarness(env = {}, event = null) {const explicit = env?.IMPECCABLE_HOOK_HARNESS;if (explicit === 'cursor') return 'cursor';if (explicit === 'github') return 'github';- if (explicit === 'claude' || explicit === 'codex') return 'claude';+ if (explicit === 'claude') return 'claude';+ if (explicit === 'codex') return 'codex';// GitHub Copilot's postToolUse event uses camelCase `toolName`/`toolArgs` and// has no `tool_name`/`tool_input`. That shape is the discriminator.if (event && typeof event === 'object'@@ -1260,6 +1261,11 @@ export function resolveHarness(env = {}, event = null) {return 'github';}if (typeof event?.conversation_id === 'string' && event.conversation_id) return 'cursor';+ // Codex turn-scoped events carry `turn_id`. Claude Code does not. Detecting+ // it here means an already-installed Codex hook emits the Codex Stop+ // contract without rewriting the hook command to set IMPECCABLE_HOOK_HARNESS.+ // https://developers.openai.com/codex/hooks#stop+ if (typeof event?.turn_id === 'string' && event.turn_id) return 'codex';return 'claude';}@@ -2163,8 +2169,11 @@ export const STOP_MAX_FILES = 20;* { exitCode, stdout, audit, emission? }** Never throws; exits silent (and fast) when the session touched no UI- * files. Output uses the Stop hookSpecificOutput channel: additionalContext- * is delivered to the model and the conversation continues so it can act.+ * files. Output goes out on the harness's Stop continuation channel: Claude+ * Code reads hookSpecificOutput.additionalContext, Codex takes a+ * decision: "block" whose reason becomes the continuation prompt. Either+ * way the findings reach the model and the conversation continues so it+ * can act.*/export async function runStopHook({ stdinJson, env = {}, cwd = process.cwd(), now = Date.now, detector } = {}) {const audit = { ts: new Date(now()).toISOString(), event: 'Stop' };@@ -2191,16 +2200,21 @@ export async function runStopHook({ stdinJson, env = {}, cwd = process.cwd(), noreturn result({ skipped: 'stdin-empty', durationMs: Date.now() - started });}- // Claude Code's Stop-hook contract: `stop_hook_active` is true when this- // hook is being re-invoked only because a prior invocation kept the turn- // alive (here, via hookSpecificOutput.additionalContext). Re-scanning and- // re-blocking now would loop until Claude Code's consecutive-block cap- // force-ends the turn (issue #400). The prior fire already surfaced the- // findings; whether to act on them is the agent's call. Exit fast with no- // output before any scan. Only Claude Code sends this field; other- // harnesses omit it, so the strict `=== true` is a no-op for them. This- // guard makes the loop impossible regardless of the finding cache key's- // line-number sensitivity (out of scope here; see findingCacheKey).+ // Stop-hook re-entry guard: `stop_hook_active` is true when this hook is+ // being re-invoked only because a prior invocation kept the turn alive+ // (Claude Code via hookSpecificOutput.additionalContext, Codex via a+ // decision: "block" continuation). Re-scanning and re-blocking now could+ // loop (issue #400). The prior fire already surfaced the findings;+ // whether to act on them is the agent's call. Exit fast with no output+ // before any scan. Claude Code and Codex both send this field: Codex+ // mirrors the Claude contract (StopCommandInput in+ // codex-rs/hooks/src/schema.rs) and latches it true for the rest of the+ // turn once a block is honored (codex-rs/core/src/session/turn.rs), so+ // this guard is also what caps the Codex deep pass at one continuation+ // per turn. Cursor and GitHub Copilot omit the field, so the strict+ // `=== true` is a no-op for them. The guard makes the loop impossible+ // regardless of the finding cache key's line-number sensitivity (out of+ // scope here; see findingCacheKey).if (event.stop_hook_active === true) {return result({ skipped: 'stop-hook-active', durationMs: Date.now() - started });}@@ -2337,6 +2351,15 @@ export function payload(text, eventName = 'PostToolUse', harness = 'claude') {if (harness === 'github') {return JSON.stringify({ additionalContext: text });}+ // Codex shares Claude Code's PostToolUse additional-context shape, but its+ // Stop schema rejects unknown fields. Findings that should continue the+ // turn must be a top-level blocking decision.+ // https://developers.openai.com/codex/hooks#stop (schema of record:+ // codex-rs/hooks/src/schema.rs, StopCommandOutputWire)+ if (harness === 'codex' && eventName === 'Stop') {+ if (!String(text ?? '').trim()) return '';+ return JSON.stringify({ decision: 'block', reason: text });+ }return JSON.stringify({hookSpecificOutput: { hookEventName: eventName, additionalContext: text },});diff --git a/skill/scripts/hook.mjs b/skill/scripts/hook.mjsindex 5813ea4f2..9dd67b1c7 100644--- a/skill/scripts/hook.mjs+++ b/skill/scripts/hook.mjs@@ -10,7 +10,7 @@* `hookSpecificOutput.additionalContext` when findings exist.* - Stop: runs the FULL detector rule set over every UI file touched this* session (the deep pass), deduped against what the per-edit pass already- * surfaced, and emits once via the Stop additionalContext channel.+ * surfaced, and emits once via the harness-specific continuation channel.** Contract: never break a turn. Always exit 0. Clean files emit a small ack* unless quiet mode is enabled; a clean Stop pass is silent.diff --git a/tests/hook.test.mjs b/tests/hook.test.mjsindex cfcbf26dc..1152ccb5f 100644--- a/tests/hook.test.mjs+++ b/tests/hook.test.mjs@@ -1365,12 +1365,33 @@ describe('writeAuditLog()', () => {});describe('payload()', () => {- it('produces hookSpecificOutput for Claude/Codex', () => {+ it('produces hookSpecificOutput for Claude', () => {const obj = JSON.parse(payload('hello'));assert.equal(obj.hookSpecificOutput.hookEventName, 'PostToolUse');assert.equal(obj.hookSpecificOutput.additionalContext, 'hello');});+ it('keeps Codex PostToolUse on the Claude-compatible context channel', () => {+ const obj = JSON.parse(payload('hello', 'PostToolUse', 'codex'));+ assert.equal(obj.hookSpecificOutput.hookEventName, 'PostToolUse');+ assert.equal(obj.hookSpecificOutput.additionalContext, 'hello');+ });++ it('produces a blocking decision for Codex Stop', () => {+ const obj = JSON.parse(payload('hello', 'Stop', 'codex'));+ assert.deepEqual(obj, { decision: 'block', reason: 'hello' });+ });++ it('emits nothing for a Codex Stop with no findings text', () => {+ assert.equal(payload('', 'Stop', 'codex'), '');+ });++ it('keeps Claude Stop on the additional-context channel', () => {+ const obj = JSON.parse(payload('hello', 'Stop', 'claude'));+ assert.equal(obj.hookSpecificOutput.hookEventName, 'Stop');+ assert.equal(obj.hookSpecificOutput.additionalContext, 'hello');+ });+it('produces additional_context for Cursor', () => {const obj = JSON.parse(payload('hello', 'PostToolUse', 'cursor'));assert.equal(obj.additional_context, 'hello');@@ -2712,10 +2733,19 @@ describe('resolveTargetFiles()', () => {describe('resolveHarness() / normalizeHookEvent()', () => {it('routes explicit env and Cursor conversation_id to cursor harness', () => {assert.equal(resolveHarness({ IMPECCABLE_HOOK_HARNESS: 'cursor' }), 'cursor');+ assert.equal(resolveHarness({ IMPECCABLE_HOOK_HARNESS: 'codex' }), 'codex');assert.equal(resolveHarness({}, { conversation_id: 'c1' }), 'cursor');+ assert.equal(resolveHarness({}, { turn_id: 'turn-1' }), 'codex');assert.equal(resolveHarness({}), 'claude');});+ it('prefers explicit harness and Cursor detection over the Codex turn_id', () => {+ assert.equal(resolveHarness({ IMPECCABLE_HOOK_HARNESS: 'claude' }, { turn_id: 'turn-1' }), 'claude');+ assert.equal(resolveHarness({}, { conversation_id: 'c1', turn_id: 'turn-1' }), 'cursor');+ assert.equal(resolveHarness({}, { turn_id: '' }), 'claude');+ assert.equal(resolveHarness({}, { turn_id: 42 }), 'claude');+ });+it('maps Cursor postToolUse Write path into file_path + cwd', () => {const normalized = normalizeHookEvent({conversation_id: 'c1',@@ -3818,6 +3848,51 @@ describe('runStopHook()', () => {assert.equal(stop.emission.kind, 'stop-deep-pass');});+ it('emits Codex Stop findings as a blocking decision', async () => {+ const sid = 'stop-codex';+ write('package.json', '{}');+ const file = write('src/Card.tsx', 'noop');+ const det = fakeDetector([finding('marketing-buzzword', 3)]);+ const editEventCodex = { ...editEvent(file, sid), turn_id: 'turn-1' };+ const stopEventCodex = { ...stopEvent(sid), turn_id: 'turn-1' };++ const edit = await runHook({ stdinJson: JSON.stringify(editEventCodex), env: {}, cwd, detector: det });+ assert.equal(edit.audit.harness, 'codex');+ assert.equal(edit.audit.deferred, 1);+ const editOut = JSON.parse(edit.stdout);+ assert.ok(editOut.hookSpecificOutput, 'Codex per-edit output stays on the PostToolUse context channel');+ assert.equal(editOut.decision, undefined);++ const stop = await runStopHook({ stdinJson: JSON.stringify(stopEventCodex), env: {}, cwd, detector: det });+ assert.equal(stop.exitCode, 0);+ assert.equal(stop.audit.harness, 'codex');+ assert.equal(stop.audit.emitted, true, JSON.stringify(stop.audit));+ const out = JSON.parse(stop.stdout);+ assert.equal(out.decision, 'block');+ assert.match(out.reason, /marketing-buzzword/);+ assert.ok(out.reason.trim().length > 0, 'Codex ignores a block whose reason trims empty');+ assert.equal(out.hookSpecificOutput, undefined);+ });++ it('skips the Codex Stop re-fire after a block instead of blocking again', async () => {+ const sid = 'stop-codex-refire';+ write('package.json', '{}');+ const file = write('src/Card.tsx', 'noop');+ const det = fakeDetector([finding('marketing-buzzword', 3)]);++ await runHook({+ stdinJson: JSON.stringify({ ...editEvent(file, sid), turn_id: 'turn-1' }),+ env: {},+ cwd,+ detector: det,+ });+ const refire = { ...stopEvent(sid), turn_id: 'turn-1', stop_hook_active: true };+ const stop = await runStopHook({ stdinJson: JSON.stringify(refire), env: {}, cwd, detector: det });+ assert.equal(stop.exitCode, 0);+ assert.equal(stop.stdout, '');+ assert.equal(stop.audit.skipped, 'stop-hook-active');+ });+it('keeps a policy footer when the grouped Stop render is clamped to the minimum budget', async () => {const sid = 'stop-clamp';fs.mkdirSync(path.join(cwd, '.impeccable'), { recursive: true });