我讓 codex 挑 Claude 的錯，但不照它說了算

---
name: codex-second-opinion
description: Get an INDEPENDENT second opinion on code, data, or a design by having codex (a different model) review it — without it just agreeing with you. Use when the user asks for a "second opinion", to "have codex review/check this", an "independent review", "cross-check", or to audit security-critical or complex code before trusting it. Trigger words include 第二意見, 獨立審查, 讓 codex 看一下, 交叉驗證, セカンドオピニオン, codex review, double-check this. Requires the codex CLI (logged in) installed locally. Do NOT use for applying fixes — this only surfaces problems; you decide what to do.
allowed-tools: Bash(bash:*)
---

# codex second opinion

Bring in codex (a different model from a different training regime) as an **independent**
reviewer of work — code, data, or design. The whole value is independence: a model reviewing
its own output misses its own blind spots. This skill protects that independence with four rules
so the second opinion does not degrade into agreement.

You run the bundled read-only wrapper `codex-review.sh`. codex runs in a read-only sandbox and
never edits files; it only reports problems. **You** do the final cross-check and decide.

## When to use
- The user asks for a "second opinion", "independent review", "cross-check", or to "have codex look at this".
- Before trusting security-critical code (auth / crypto / payments) or complex logic (race conditions, N+1, deadlocks).
- To sanity-check the credibility of data or an analysis.

## How to run

1. Figure out the target: a path in the project (`--target <path>`) or a snippet/pipeline output (`--stdin`).
2. Write the **review focus** as a neutral assertion or standard to check. Critical: do NOT put your
   own conclusion in it. "Review the token check for timing attacks and KV write races" — NOT
   "I already checked the auth, just confirm it's fine" (that taints codex's independence; the
   wrapper will warn you if you do).
3. Run the wrapper (default reasoning effort is medium; raise to high/xhigh only for security-critical
   or genuinely complex targets):

   ```bash
   # review a file
   bash ~/.claude/skills/codex-second-opinion/codex-review.sh \
     --target src/auth.js "Review token validation, timing attacks, and KV write races"

   # review a snippet / pipeline output via stdin
   cat data.json | bash ~/.claude/skills/codex-second-opinion/codex-review.sh \
     --stdin "Review this data's credibility and field completeness"

   # security-critical + a durable audit record under ./codex-audits/
   bash ~/.claude/skills/codex-second-opinion/codex-review.sh --effort high \
     --target src/payment.ts --audit payment "Review for double-charge and idempotency gaps"
   ```

4. If the wrapper exits non-zero (codex missing / timed out / blank output), do NOT retry or pretend.
   Tell the user this is a single opinion only, and stop.

5. On success, do the cross-check **yourself** (this is the part the wrapper deliberately does not do):
   read codex's findings, compare them against your own reading of the code, and split them into
   **agreed** and **disagreed**. For anything you disagree on, read the code and decide — do not just
   relay what codex said. Treat codex as a probe, not an oracle: a finding both of you reach is almost
   certainly real; a finding only one of you reached needs your own judgment.

## Notes
- No API keys involved — codex uses your own OpenAI/ChatGPT login via the local `codex` CLI.
- The only writes are a log under /tmp and, with `--audit`, a record under `./codex-audits/`.
- These rules are scaffolding for today's models. If a model becomes independent and honest enough
  on its own, drop the rule it was patching rather than keeping it as ritual.
- This is a template — adapt the trigger words, the reviewer model, the paths, and the rules to
  your own workflow. The idea is the four-rule independence protocol, not this exact wording.

#!/usr/bin/env bash
# codex-review.sh — a "second opinion" wrapper that has codex review code/data/design
#                   written by another model (e.g. Claude), as an INDEPENDENT reviewer.
#
# Why this exists: a model reviewing its own output tends to miss its own blind spots,
# and tends to nod along with its prior judgments. A model from a different training
# regime (codex / gpt-5.5) can catch what the first one missed — but only if you protect
# its independence. This script bakes four rules into the default behavior:
#   #1 Independence : the prompt forces codex to evaluate on its own, never assume a prior
#                     reviewer was right, never agree just to agree (see build_prompt).
#   #2 Fail fast    : codex missing / times out / exits non-zero / returns blank → it
#                     degrades to "single opinion", tells you, and STOPS. No silent retries.
#   #3 Protocol     : (a) the prompt carries none of YOUR conclusions  (b) raw output is
#                     logged  (c) codex only describes problems + severity, never edits code
#                     (d) you do the cross-check yourself — this script only does (a)(b)(c).
#   #4 Cost         : reasoning effort defaults to "medium"; raise with --effort only when
#                     a real security/complexity signal warrants it.
#
# SAFETY (read before you run):
#   • codex runs in a READ-ONLY sandbox (`-s read-only`): it can read the files you point it
#     at, but it cannot modify, delete, or write anything in your project.
#   • This script contains NO API keys. codex authenticates with YOUR OWN OpenAI/ChatGPT
#     login (whatever your local `codex` CLI is already configured with).
#   • The only files this script writes are a log under /tmp and, if you pass --audit, a
#     markdown record under ./codex-audits/ in your current directory. Nothing else.
#   • No network calls of its own, no eval, no curl|bash. Read the whole thing — it's short.
#
# PREREQUISITES:
#   • The `codex` CLI installed and logged in (https://developers.openai.com/codex/cli).
#   • bash + perl (perl only needed if you use --timeout; preinstalled on macOS/Linux).
#
# USAGE:
#   bash codex-review.sh [options] "<review focus>"
#   echo "<content to review>" | bash codex-review.sh --stdin "<review focus>"
#
# OPTIONS:
#   --target <path>   file/dir for codex to read (repeatable; read in the read-only sandbox)
#   --stdin           read the content to review from stdin (good for snippets / pipeline data)
#   --dir <path>      directory codex runs in (default: current directory)
#   --effort LEVEL    low|medium|high|xhigh  (default: medium)                       [rule #4]
#   --audit <slug>    also write a durable record to ./codex-audits/<slug>-<date>.md  [rule 3b]
#   --timeout <sec>   max seconds before giving up (default 0 = no limit; uses perl) [rule #2]
#   --model <id>      override codex model (default: whatever your codex config uses)
#   -h | --help
#
# EXIT CODES: 0 ok & non-empty / 2 usage error / 3 codex missing / 4 codex failed or empty
#             / 124 timeout. (3/4/124 = the "single opinion" degrade path.)
#
# License: MIT — free to use, modify, and adapt into your own version. No attribution required.
#
# This is a generic, self-contained template. It assumes nothing about your project layout,
# names no tools or services beyond the `codex` CLI, and stores no identity. Make it yours:
# change the rules, the prompt, the paths, the model — the four-rule structure is the idea,
# not the exact wording.
set -uo pipefail

WORKDIR="$(pwd)"
TS="$(date +%Y%m%d-%H%M%S)"
DATE="$(date +%Y-%m-%d)"

EFFORT="medium"
declare -a TARGETS=()
USE_STDIN=0
AUDIT_SLUG=""
TIMEOUT=0
MODEL=""
FOCUS=""

usage() { sed -n '2,57p' "$0"; exit "${1:-0}"; }
# Guards for value-taking options: (1) bail gracefully instead of a set -u unbound crash when
# the value is missing; (2) if the next token looks like another option (-?*), the value was
# probably forgotten — error out instead of silently misparsing.
req() {
  [ "$2" -ge 2 ] || { echo "ERROR: $1 needs a value" >&2; exit 2; }
  case "$3" in -?*) echo "ERROR: the value for $1 looks like another option ($3) — did you forget the value?" >&2; exit 2 ;; esac
}

while [ $# -gt 0 ]; do
  case "$1" in
    --target)   req "$1" "$#" "${2:-}"; TARGETS+=("$2"); shift 2 ;;
    --stdin)    USE_STDIN=1; shift ;;
    --dir)      req "$1" "$#" "${2:-}"; WORKDIR="$2"; shift 2 ;;
    --effort)   req "$1" "$#" "${2:-}"; EFFORT="$2"; shift 2 ;;
    --audit)    req "$1" "$#" "${2:-}"; AUDIT_SLUG="$2"; shift 2 ;;
    --timeout)  req "$1" "$#" "${2:-}"; TIMEOUT="$2"; shift 2 ;;
    --model)    req "$1" "$#" "${2:-}"; MODEL="$2"; shift 2 ;;
    -h|--help)  usage 0 ;;
    --) shift
        if [ $# -gt 1 ]; then echo "ERROR: multiple positional args after -- ; wrap the focus in one quoted string" >&2; exit 2; fi
        [ $# -ge 1 ] && FOCUS="$1"; break ;;
    -*) echo "Unknown option: $1" >&2; usage 2 ;;
    *)  if [ -n "$FOCUS" ]; then echo "ERROR: multiple review-focus positional args; wrap the focus in one quoted string" >&2; exit 2; fi
        FOCUS="$1"; shift ;;
  esac
done

# --- validation ---
case "$EFFORT" in low|medium|high|xhigh) ;; *) echo "ERROR: --effort must be low|medium|high|xhigh (got: $EFFORT)" >&2; exit 2 ;; esac
case "$TIMEOUT" in ''|*[!0-9]*) echo "ERROR: --timeout must be a non-negative integer of seconds (got: $TIMEOUT)" >&2; exit 2 ;; esac
if [ -z "$FOCUS" ]; then echo "ERROR: missing <review focus> (the last positional argument)" >&2; usage 2; fi
if [ "${#TARGETS[@]}" -eq 0 ] && [ "$USE_STDIN" -eq 0 ]; then
  echo "ERROR: need at least one --target <path> or --stdin" >&2; usage 2
fi

# rule #2: codex missing = fail fast to the single-opinion path. No retry, no pretending.
if ! command -v codex >/dev/null 2>&1; then
  echo "DEGRADE: no 'codex' CLI found on this machine (not installed / broken). Honestly note this is a single opinion and stop. Install: https://developers.openai.com/codex/cli" >&2
  exit 3
fi

STDIN_CONTENT=""
if [ "$USE_STDIN" -eq 1 ]; then STDIN_CONTENT="$(cat)"; fi

# rule #3(a) soft guard: warn if the focus carries YOUR conclusion (which would taint codex's
# independence). Warn only, never block. Matches common English/Chinese "already checked" phrasings.
if printf '%s' "$FOCUS" | grep -qiE 'i already|already (checked|verified|confirmed|reviewed)|no (bug|issue|problem)|looks (fine|good|correct)|should be (fine|ok|correct)|我已|已檢查|已確認|沒問題|應該沒'; then
  echo "WARNING (rule a): your review focus looks like it carries your own conclusion (e.g. \"already checked / no issues\")." >&2
  echo "    codex should judge independently — restate it as a neutral \"what to review / what the bar is\", don't feed it your verdict." >&2
fi

# --- build the prompt (rules a + c: independent framing + describe-only, no code edits) ---
build_prompt() {
  local stdin_block=""
  if [ "$USE_STDIN" -eq 1 ]; then
    stdin_block=$'\n## Inlined target content\n```\n'"$STDIN_CONTENT"$'\n```\n'
  fi
  local target_lines=""
  if [ "${#TARGETS[@]}" -gt 0 ]; then
    target_lines="## Review targets (read these yourself in the read-only sandbox)"$'\n'
    local t
    for t in "${TARGETS[@]}"; do target_lines+="- $t"$'\n'; done
  fi
  cat <<EOF
You are an independent second-opinion reviewer (codex / gpt-5.5). Evaluate the target entirely on your own: do not assume any other reviewer (human or AI) has already checked anything. Your judgment must come only from what you read yourself.

$target_lines$stdin_block
## Review focus (the original request)
$FOCUS

## Output rules (follow strictly)
1. Only describe "problem + severity (high/medium/low)". Do not rewrite code, do not apply fixes, do not output diffs.
2. One finding per item: problem / location (file:line) / severity / why it is a problem / your confidence.
3. Where you judge there is no problem, say "no finding" — do not invent issues to pad the list.
4. Do not rely on or agree with any external conclusion; be faithful only to the facts you read yourself.
EOF
}

PROMPT="$(build_prompt)"

# --- assemble the codex command ---
LOG="/tmp/codex-review-${TS}.log"
LASTMSG="/tmp/codex-review-${TS}.last.md"
declare -a CMD=(codex exec --skip-git-repo-check -s read-only -C "$WORKDIR"
                -c "model_reasoning_effort=\"$EFFORT\"" -o "$LASTMSG")
[ -n "$MODEL" ] && CMD+=(-m "$MODEL")
CMD+=("$PROMPT")

# perl alarm wrapper (macOS has no `timeout` binary). Exit codes are faithfully propagated:
# timeout=124, signal-killed=128+sig (so a killed child is NOT misreported as success),
# exec failure=1, else the child's exit code. TIMEOUT=0 → prefix is empty, run directly.
declare -a TPREFIX=()
if [ "$TIMEOUT" -gt 0 ]; then
  TPREFIX=(perl -e 'my $t=shift; my $rc; eval { local $SIG{ALRM}=sub{die "TIMEOUT\n"}; alarm $t; $rc=system(@ARGV); alarm 0; }; if($@ eq "TIMEOUT\n"){exit 124} if($rc==-1){exit 1} if($rc & 127){exit(128+($rc & 127))} exit($rc>>8);' "$TIMEOUT")
fi
runit() { if [ "${#TPREFIX[@]}" -gt 0 ]; then "${TPREFIX[@]}" "$@"; else "$@"; fi; }

echo "codex-review: effort=$EFFORT  targets=[${TARGETS[*]:-stdin}]  dir=$WORKDIR  log=$LOG"

# --- run (rule b: raw output goes to the log) ---
runit "${CMD[@]}" 2>&1 | tee "$LOG"
rc="${PIPESTATUS[0]}"

# rule #2: "done" = exit 0 AND a non-empty final message. A half-success must not be silently
# reported as success.
if [ "$rc" -eq 124 ]; then
  echo "DEGRADE: codex timed out after ${TIMEOUT}s. No retry. Note it's a single opinion and tell the human. log=$LOG" >&2
  exit 124
fi
if [ "$rc" -ne 0 ]; then
  echo "DEGRADE: codex exited non-zero (rc=$rc, incl. signal-killed). No retry. Single opinion only. log=$LOG" >&2
  exit 4
fi
# The trustworthiness invariant is "the final message (-o) has non-whitespace content", NOT
# "the log is non-empty" (the log always contains the codex banner). Blank/missing = no real
# review happened = treat as failure.
if ! grep -q '[^[:space:]]' "$LASTMSG" 2>/dev/null; then
  echo "DEGRADE: codex exited 0 but the final message is blank/missing (half-success, no trustworthy review). Treating as failure. log=$LOG" >&2
  exit 4
fi

# --- rule 3(b) durable: --audit writes a record (ensure dir first, verify non-empty before claiming success) ---
if [ -n "$AUDIT_SLUG" ]; then
  AUDIT_DIR="$WORKDIR/codex-audits"
  AUDIT="$AUDIT_DIR/${AUDIT_SLUG}-${DATE}.md"
  mkdir -p "$AUDIT_DIR"
  if {
    echo "---"
    echo "source: codex-review.sh"
    echo "date: $DATE"
    echo "effort: $EFFORT"
    echo "targets: ${TARGETS[*]:-(stdin)}"
    echo "raw_log: $LOG"
    echo "---"
    echo ""
    echo "# codex second-opinion raw output — ${AUDIT_SLUG}"
    echo ""
    echo "**Review focus**: $FOCUS"
    echo ""
    echo '```'
    cat "$LASTMSG"
    echo '```'
  } >"$AUDIT" && [ -s "$AUDIT" ]; then
    echo "audit record: $AUDIT"
  else
    echo "WARNING: failed to write audit record: $AUDIT" >&2
  fi
fi

# --- rule (d) reminder: YOU do the cross-check, splitting "agreed" vs "disagreed" ---
echo ""
echo "OK: codex finished (rc=0). raw log: $LOG"
echo "    final message: $LASTMSG"
echo "Next (rule d, you do this): independently cross-check codex's findings against your own"
echo "    judgment. Split them into \"agreed\" and \"disagreed\", each with a reason. For"
echo "    disagreements, read the code yourself and decide — don't just relay what codex said."