Redact Codex reasoning content from retained raw stdout

Normalized events and reports already redacted reasoning items; the
retained raw-stdout.log run artifact still carried the provider's
reasoning text verbatim. Retention now happens after parsing and replaces
each reasoning item's text with a length marker, matching the Ollama
adapter's thinking redaction — retained raw streams keep only safe status
metadata for reasoning. Caught by the final-verification artifact scan;
covered by the strengthened codex events test.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: HelloThisWorld

integrations/claude-code-plugin/specbridge/dist/checksums.json

@@ -7,8 +7,8 @@
       "bytes": 153474
     },
     "cli.cjs": {
-      "sha256": "1f1551f92dc99853fed30301ef845dd3dae61faa847170e0f09932ee5861b98b",
-      "bytes": 2391312
+      "sha256": "5f9792d574e8964d8f9a76469ef3304db3da595d000382ff1d6b2815a0b05acf",
+      "bytes": 2392021
     },
     "mcp-server.cjs": {
       "sha256": "a817ad7e791bd2a40296cc2543cb4d38e05dd6ed13be9f59396280a859ebcee0",

integrations/claude-code-plugin/specbridge/dist/cli.cjs

@@ -39204,6 +39204,21 @@ function itemPayload(item) {
   }
   return payload;
 }
+function redactCodexStdoutForRetention(stdout) {
+  return stdout.split(/\r?\n/).map((line) => {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{") || !trimmed.includes('"reasoning"')) return line;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed.item?.type === "reasoning" && typeof parsed.item.text === "string") {
+        parsed.item.text = `[redacted reasoning: ${parsed.item.text.length} chars]`;
+        return JSON.stringify(parsed);
+      }
+    } catch {
+    }
+    return line;
+  }).join("\n");
+}
 function normalizeCodexEvents(stream, context, timestamp) {
   const normalized = [];
   const push = (type, providerEventType, payload) => {
@@ -39554,7 +39569,9 @@ var CodexCliRunner = class {
     const usage = usageFromStream(stream, processResult.observation.durationMs, this.config.model);
     const base = {
       runner: this.name,
-      rawStdout: processResult.stdout,
+      // Parsing already happened on the pristine stream; the RETAINED bytes
+      // carry only safe status metadata for reasoning items.
+      rawStdout: redactCodexStdoutForRetention(processResult.stdout),
       rawStderr: processResult.stderr,
       process: processResult.observation,
       durationMs: Math.max(0, Date.now() - started),

packages/runners/src/codex-cli/events.ts

@@ -172,6 +172,33 @@ function itemPayload(item: z.infer<typeof codexItemSchema>): Record<string, stri
   return payload;
 }
 
+/**
+ * Redact reasoning content from a raw JSONL stdout stream before it is
+ * retained as a run artifact. Parsing happens BEFORE this: the retained
+ * bytes keep every event's structure (and non-reasoning content) but
+ * reasoning text is replaced with a length marker — raw retention keeps
+ * only safe status metadata for reasoning, matching the Ollama adapter.
+ */
+export function redactCodexStdoutForRetention(stdout: string): string {
+  return stdout
+    .split(/\r?\n/)
+    .map((line) => {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith('{') || !trimmed.includes('"reasoning"')) return line;
+      try {
+        const parsed = JSON.parse(trimmed) as { item?: { type?: string; text?: string } };
+        if (parsed.item?.type === 'reasoning' && typeof parsed.item.text === 'string') {
+          parsed.item.text = `[redacted reasoning: ${parsed.item.text.length} chars]`;
+          return JSON.stringify(parsed);
+        }
+      } catch {
+        // Not JSON — leave the line untouched.
+      }
+      return line;
+    })
+    .join('\n');
+}
+
 /**
  * Normalize parsed Codex events. Reasoning items become `message.completed`
  * with a redacted payload — their content is intentionally absent.

packages/runners/src/codex-cli/runner.ts

@@ -41,7 +41,11 @@ import {
   runCodexInvocation,
 } from './invocation.js';
 import type { CodexEventStream } from './events.js';
-import { normalizeCodexEvents, parseCodexEventStream } from './events.js';
+import {
+  normalizeCodexEvents,
+  parseCodexEventStream,
+  redactCodexStdoutForRetention,
+} from './events.js';
 
 /**
  * Codex CLI runner (v0.6): invokes the locally installed `codex` CLI in
@@ -413,7 +417,9 @@ export class CodexCliRunner implements AgentRunner {
     const usage = usageFromStream(stream, processResult.observation.durationMs, this.config.model);
     const base = {
       runner: this.name,
-      rawStdout: processResult.stdout,
+      // Parsing already happened on the pristine stream; the RETAINED bytes
+      // carry only safe status metadata for reasoning items.
+      rawStdout: redactCodexStdoutForRetention(processResult.stdout),
       rawStderr: processResult.stderr,
       process: processResult.observation,
       durationMs: Math.max(0, Date.now() - started),

packages/runners/src/index.ts

@@ -60,6 +60,7 @@ export {
 export {
   parseCodexEventStream,
   normalizeCodexEvents,
+  redactCodexStdoutForRetention,
   MAX_RETAINED_EVENTS,
   type CodexEvent,
   type CodexEventStream,

tests/runners/codex-cli.test.ts

@@ -233,7 +233,7 @@ describe('codex authoring (read-only boundary)', () => {
     expect(existsSync(path.join(workspaceRoot, 'rogue-authoring-write.txt'))).toBe(false);
   });
 
-  it('normalizes machine-readable events and redacts reasoning content', async () => {
+  it('normalizes machine-readable events and redacts reasoning content everywhere', async () => {
     withScenario('success');
     const runner = new CodexCliRunner(fakeCodexConfig());
     const { workspaceRoot, runDir } = scratchDirs();
@@ -252,6 +252,11 @@ describe('codex authoring (read-only boundary)', () => {
       (event) => event.providerEventType === 'item.completed:reasoning',
     );
     expect(reasoning?.payload['redacted']).toBe(true);
+    // Reasoning content never survives into the RETAINED raw stream either —
+    // only a length marker does (the non-reasoning events stay intact).
+    expect(result.rawStdout).not.toContain('REASONING-SECRET-DO-NOT-EXPOSE');
+    expect(result.rawStdout).toContain('[redacted reasoning:');
+    expect(result.rawStdout).toContain('thread.started');
   });
 
   it('malformed final output fails safely', async () => {