Skip to content
/

cc-plugin-codex (sendbird)

cc-plugin-codex-sendbird · sendbird/cc-plugin-codex · ★ 42 · last commit 2026-05-25

Use Claude Code for review and rescue from inside a Codex session — the semantic inverse of codex-plugin-cc, with Codex as host and Claude as the worker.

Best whenCodex stays in charge of the thread; Claude Code does the review and rescue work — turning the CC↔Codex bridge bidirectional.
Skip ifUsing & or nohup for background execution instead of spawn_agent, Raw claude CLI calls that bypass the companion and job tracking
vs seeds
No seed framework runs inside Codex to delegate work to Claude Code — all seeds are Claude-centric with Claude as the host. The Us…
Primitive shape 11 total
Skills 7 Hooks 4
00

Summary

cc-plugin-codex (sendbird) — Summary

Elevator pitch: A Codex-native plugin (.codex-plugin/plugin.json) that is the semantic inverse of codex-plugin-cc — it runs inside Codex and delegates review/rescue work to Claude Code, rather than running inside Claude Code and delegating to Codex. Published by Sendbird under Apache-2.0. The plugin ships 7 Codex skills ($cc:review, $cc:adversarial-review, $cc:rescue, $cc:status, $cc:result, $cc:cancel, $cc:setup) plus a claude-companion.mjs script that invokes the claude CLI for all work. It uses Codex's native plugin hook system (SessionStart, SessionEnd, Stop, UserPromptSubmit) for job lifecycle management and an unread-result nudge on each user turn. The plugin is described as following "the shape of openai/codex-plugin-cc but runs in the opposite direction." Compared to seeds: this is a mirror of codex-plugin-cc with the host and guest models swapped — a complementary first/second-party plugin pair that together enable bidirectional Claude↔Codex delegation.

01

Overview

cc-plugin-codex (sendbird) — Overview

Origin

By Sendbird, Inc. (jin.ku@sendbird.com). Version 1.2.1, Apache-2.0. 42 stars, 7 forks. Active: last commit 2026-05-25 (most recently updated plugin in this batch). Published to Sendbird's marketplace.

Philosophy (verbatim from README)

"cc-plugin-codex turns Codex into a host for Claude Code work. Codex stays in charge of the thread. Claude Code does the review and rescue work."

"It follows the shape of openai/codex-plugin-cc but runs in the opposite direction."

The design is explicitly positioned as the complement to codex-plugin-cc:

  • codex-plugin-cc: Runs inside Claude Code → delegates to Codex
  • cc-plugin-codex: Runs inside Codex → delegates to Claude Code

Key Differences from Upstream (codex-plugin-cc)

The README explicitly documents how this fork differs from the upstream:

  • Full 4-hook lifecycle (adds UserPromptSubmit for unread-result nudges, missing from upstream)
  • --model / --effort flags on all review commands (upstream lacks effort controls)
  • --scope auto|working-tree|branch explicit scope flag
  • 1M-context model variants (opus-4-7[1m], sonnet-4-6[1m]) as defaults
  • Background review via built-in Codex subagent (uses spawn_agent with gpt-5.4-mini + fork_context: false)
  • Job ownership tracked per Codex session + --all flag to see cross-session jobs
  • GitHub CI on Windows/macOS/Linux

Manifest Data

From .codex-plugin/plugin.json:

  • Name: cc
  • Version: 1.2.1
  • Category: Coding
  • Capabilities: Interactive, Write
  • Default prompts: "Use Claude Code to review my current changes through $cc:review", etc.
02

Architecture

cc-plugin-codex (sendbird) — Architecture

Distribution

  • Type: Codex plugin (.codex-plugin/plugin.json)
  • Marketplace: sendbird/codex-marketplace
  • Plugin ID: cc
  • Version: 1.2.1
  • License: Apache-2.0

Install

codex marketplace add sendbird/codex-marketplace
# Then install 'cc' from the Sendbird marketplace inside Codex, run $cc:setup once.

# Optional npx helper:
npx cc-plugin-codex install

The plugin copy lives under Codex's plugin cache. Commands resolve through $PLUGIN_ROOT.

Required Runtime

  • Codex CLI with hook support
  • Node.js 18+
  • claude CLI installed and authenticated
  • npm install -g @anthropic-ai/claude-code && claude auth login

Directory Tree

.codex-plugin/
└── plugin.json          # Codex plugin manifest

hooks/
├── hooks.json           # 4 Codex hooks
├── session-lifecycle-hook.mjs
├── stop-review-gate-hook.mjs
└── unread-result-hook.mjs

skills/
├── review/SKILL.md
├── adversarial-review/SKILL.md
├── rescue/SKILL.md
├── status/SKILL.md
├── result/SKILL.md
├── cancel/SKILL.md
└── setup/SKILL.md

internal-skills/
└── review-runtime/runtime.md    # Internal reference

scripts/
└── claude-companion.mjs         # Runtime bridge: invokes claude CLI

prompts/
├── adversarial-review.md
└── stop-review-gate.md

schemas/                         # JSON schemas for skill arguments

Key Architectural Difference from codex-plugin-cc

The companion script is claude-companion.mjs (invokes claude CLI) vs. codex-plugin-cc's codex-companion.mjs (invokes codex CLI). The hook system uses Codex's native hook events (SessionStart, SessionEnd, Stop, UserPromptSubmit) vs. Claude Code's hook events.

Target AI Tools

  • Primary: OpenAI Codex CLI (as host / orchestrator)
  • Peer: Claude Code (as reviewer / rescue worker)
03

Components

cc-plugin-codex (sendbird) — Components

Skills (7)

Name Trigger Purpose
review $cc:review Read-only Claude Code review of local git changes
adversarial-review $cc:adversarial-review Design-challenging Claude Code review — tradeoffs, hidden assumptions
rescue $cc:rescue Hand a task to Claude Code — bugs, fixes, investigations, refactors
status $cc:status List running and recent Claude Code jobs
result $cc:result Open finished Claude Code job output
cancel $cc:cancel Cancel an active background Claude Code job
setup $cc:setup Verify installation, auth, hooks, and review gate

Hooks (4 Codex hook events)

Event Script Purpose
SessionStart session-lifecycle-hook.mjs Initialize session state for job tracking
SessionEnd session-lifecycle-hook.mjs SessionEnd Cleanup session-scoped jobs
Stop stop-review-gate-hook.mjs Optional stop-time review gate (900s timeout)
UserPromptSubmit unread-result-hook.mjs Nudge user toward unread results on each turn

The UserPromptSubmit hook is the key differentiator from codex-plugin-cc — it checks for unread Claude Code results and surfaces a notification at the start of each user turn.

Scripts (3)

Name Purpose
scripts/claude-companion.mjs Runtime bridge: wraps Claude CLI for review/rescue/status/result/cancel operations
hooks/session-lifecycle-hook.mjs Session state management
hooks/stop-review-gate-hook.mjs Stop-time review gate
hooks/unread-result-hook.mjs Per-turn unread result detection

Internal Skills (1)

  • internal-skills/review-runtime/runtime.md — Internal reference document for the review runtime contract (not user-invocable)

Schemas

JSON schemas for skill argument validation in schemas/.

Review Model Defaults

  • $cc:review defaults: model=opus (claude-opus-4-7[1m], 1M context), effort=xhigh
  • $cc:rescue defaults: model=opus (1M context), effort=xhigh
  • Sonnet resolves to claude-sonnet-4-6[1m]; effort defaults to high
  • --model and --effort flags accepted on all review/rescue commands
05

Prompts

cc-plugin-codex (sendbird) — Prompts

Prompt 1: review skill — Background Flow Precision (verbatim)

Source: skills/review/SKILL.md

Background flow:
- For background review, use Codex's built-in `default` subagent instead of a detached background shell command.
- Do not satisfy background review by using a generic `claude_review_runner`-style helper role, raw Claude CLI, or any other review executor that bypasses the resolved companion command.
- Never satisfy background review by running the companion command itself with shell backgrounding such as `&`, `nohup`, detached `spawn`, or any equivalent direct background process launch.
- Background here means "spawn the forwarding child via `spawn_agent` and do not wait in the parent turn." The companion review command inside that child still runs once, in the foreground, inside the child thread.
- Spawn exactly one transient forwarding child through `spawn_agent` with:
  - agent_type: "default"
  - fork_context: false
  - model: "gpt-5.4-mini"
  - reasoning_effort: "medium"

Prompting technique: Anti-pattern enumeration for background execution. The skill explicitly lists all the wrong ways to implement background execution (&, nohup, spawn, claude_review_runner) before stating the correct way. This negative enumeration pattern forces the agent to recognize and reject shortcuts.


Prompt 2: rescue skill — Resume Behavior (verbatim)

Source: skills/rescue/SKILL.md

**Resume behavior:** If you don't pass `--resume` or `--fresh`, rescue checks for a resumable Claude session and asks once whether to continue or start fresh. Your phrasing guides the recommendation — "continue the last run" → resume, "start over" → fresh.

Background rescue runs through a built-in Codex subagent. When the child finishes, the plugin tries to nudge the parent thread with the exact `$cc:result <job-id>` to open.

Prompting technique: Natural-language intent mapping to flag routing. The skill maps casual phrasing ("continue the last run", "start over") to explicit flag values (--resume, --fresh) with a one-ask limit, reducing friction without requiring users to memorize flag names.


Prompt 3: review skill — Fallback Prohibition (verbatim)

Source: skills/review/SKILL.md

Foreground flow:
- Do not fall back to raw `claude`, `claude-code`, `claude review`, `bash -lc ...claude...`, or any other direct Claude CLI syntax when the companion path is available. The foreground syntax contract here is the resolved companion command above, not a hand-rolled Claude invocation.
- If the resolved companion command fails, surface that failure. Do not silently retry foreground review through a different CLI shape, a generic review runner, or a custom shell wrapper.

Prompting technique: Explicit CLI invocation contract with failure-surfacing mandate. The skill prohibits 5 specific alternative invocation patterns to prevent the agent from "solving" a broken companion by substituting a different approach that bypasses job tracking.

09

Uniqueness

cc-plugin-codex (sendbird) — Uniqueness

differs_from_seeds

The closest comparison is codex-plugin-cc (not a seed, but the direct upstream). Among seeds, the closest is superpowers (plugin architecture, single peer interaction model). This plugin differs from all seeds by being the only framework that runs inside Codex and uses Claude Code as its worker — the reverse of every other Claude-centric framework. The UserPromptSubmit hook-based unread-result nudge is unique in the corpus — no seed uses hook events to surface push notifications about completed background work. The 3-model pipeline (Codex parent → gpt-5.4-mini forwarder child → Claude opus-4-7[1m] worker) is the only three-tier model routing in this batch.

Mirror Relationship with codex-plugin-cc

Dimension codex-plugin-cc cc-plugin-codex (sendbird)
Host Claude Code Codex
Worker Codex Claude Code
Plugin format Claude plugin (.claude-plugin) Codex plugin (.codex-plugin)
Runtime bridge codex-companion.mjs claude-companion.mjs
Additional hook UserPromptSubmit (unread nudge)
Background method CC Bash run_in_background Codex spawn_agent
Model defaults Codex user's model claude-opus-4-7[1m]

Most Unusual Feature

The UserPromptSubmit hook that automatically checks for unread Claude Code results at the start of every user turn. No other framework in this batch or the 11 seeds uses a hook event to implement a push notification mechanism for completed background work.

Observable Failure Modes

  1. Claude auth expiry: If Claude CLI authentication expires during a background job, the job fails silently. $cc:setup checks auth at setup time but not during job execution.
  2. Codex job scope ambiguity: $cc:status by default shows only current-session jobs. Users may miss results from sibling sessions without --all flag.
  3. gpt-5.4-mini forwarder errors: If the cheap forwarder child fails (e.g., token limit), the background review fails. No fallback to direct execution.
  4. Stop gate zombie: 900s timeout on the Stop hook can leave Codex in a non-completable state if Claude Code hangs.
  5. Windows compatibility: README notes Codex CLI Windows support is experimental; the Claude CLI supports Windows natively. Mixed Windows compatibility creates uncertain behavior.
04

Workflow

cc-plugin-codex (sendbird) — Workflow

Core Flow

Codex session (active)
    ↓ user invokes $cc:review or $cc:rescue
claude-companion.mjs called with action + arguments
    ↓
Claude Code CLI invoked (review: read-only, rescue: write-capable)
    ↓ (background) → job tracked, Codex session continues
    ↓ (foreground) → result returned immediately
User retrieves via $cc:result when ready
    ↑
unread-result-hook.mjs nudges on each UserPromptSubmit event

Background Review Flow (Key Pattern)

User: $cc:review --background
$cc:review skill: call claude-companion.mjs background-routing-context --kind review --json
                  → returns { jobId, ownerSessionId, parentThreadId }
spawn_agent("default", fork_context: false, model: gpt-5.4-mini, reasoning_effort: medium)
  Child: claude-companion.mjs review --view-state on-success <args> --job-id <id> --owner-session-id <id>
  Child: runs claude review (foreground in child, background in parent)
  Child: on completion → notifies parent thread via parentThreadId
Parent: continues Codex session
Next user turn: unread-result-hook.mjs detects unread result → nudges user

Phases + Artifacts

Phase Trigger Artifact
1. Setup $cc:setup Auth verified, hooks wired, Claude CLI available
2a. Review $cc:review [flags] Claude Code review output (verbatim)
2b. Adversarial Review $cc:adversarial-review [focus text] Claude challenge review output
2c. Rescue $cc:rescue <task> Claude Code investigation/fix output
3. Monitor $cc:status [job-id] Active/recent job list
4. Retrieve $cc:result [job-id] Final output + Claude session ID for resume
5. Cancel $cc:cancel [job-id] Active job cancelled

Approval Gates

Gate Type
Background vs foreground selection choice-list (AskUserQuestion)
Resume vs new Claude session choice-list (AskUserQuestion in rescue)

Supported Flags

$cc:review: --base <ref>, --scope auto|working-tree|branch, --wait, --background, --model opus|sonnet|haiku, --effort low|medium|high|xhigh|max $cc:rescue: All review flags + --resume, --resume-last, --fresh, --write, --prompt-file <path>

06

Memory Context

cc-plugin-codex (sendbird) — Memory and Context

State Storage

  • Session-scoped job tracking: session-lifecycle-hook.mjs (SessionStart/SessionEnd) manages background job IDs and ownership per Codex session.
  • Job ownership: Tracked per Codex session; $cc:status shows current-session jobs by default, --all shows all jobs for the repository workspace across older/sibling sessions.
  • Background routing context: claude-companion.mjs background-routing-context --json returns { jobId, ownerSessionId, parentThreadId } used to correlate background child results with the parent session.
  • Claude session IDs: $cc:result surfaces the Claude session ID for claude --resume ... continuations.

Persistence

  • Session-scoped: Job tracking is cleared at SessionEnd. Jobs may show status via $cc:status --all across sessions in the same repository workspace.
  • Claude-side persistence: Claude Code maintains its own session state; the plugin surfaces the session ID for manual resume.

Unread Result Detection

unread-result-hook.mjs runs on every UserPromptSubmit event. It checks the job registry for completed-but-unread results and injects a nudge into the Codex thread context (e.g., "You have an unread Claude Code result: $cc:result task-abc123"). This is a push notification mechanism that doesn't require the user to poll.

Cross-Session Handoff

Enabled via Claude session IDs. $cc:rescue --resume continues the most recent Claude session in the repo; $cc:result shows the session ID for manual claude --resume outside Codex.

Memory Type

Session-scoped job tracking (no persistent DB). Claude Code maintains its own session persistence separately.

07

Orchestration

cc-plugin-codex (sendbird) — Orchestration

Multi-Agent Pattern

Hierarchical (Codex session as orchestrator → Claude Code as worker/reviewer).

Background reviews spawn a transient Codex "default" subagent (gpt-5.4-mini, medium effort, fork_context: false) as a forwarding child that runs claude-companion.mjs. This is a 3-level hierarchy: Codex parent → Codex forwarding child → Claude Code subprocess.

Isolation Mechanism

  • Process: Claude Code runs as a separate process invoked by claude-companion.mjs
  • Context isolation: Background subagent uses fork_context: false so it doesn't inherit the parent Codex session's conversation history
  • Model isolation: Background forwarding child uses gpt-5.4-mini + medium reasoning (cheap and fast) as the forwarder; Claude Code uses its full model (opus or sonnet) for the actual work

Multi-Model

Yes:

Role Process Model
Orchestrator Codex (parent session) User's active Codex model
Background forwarder Codex (transient child) gpt-5.4-mini + medium effort
Reviewer / rescue worker Claude Code claude-opus-4-7[1m] (default) or sonnet-4-6[1m]

This 3-model pipeline is unique in the batch — the intermediate forwarder model is deliberately cheap.

Execution Mode

  • Foreground: synchronous (suitable for small reviews)
  • Background: spawn_agent with fork_context: false, parent continues immediately

Prompt Chaining

Minimal. The forwarding child's only job is to call claude-companion.mjs and return stdout. No prompt transformation.

Consensus Mechanism

None. Single Claude Code worker.

08

Ui Cli Surface

cc-plugin-codex (sendbird) — UI and CLI Surface

Dedicated CLI Binary

None (for end users). The npx cc-plugin-codex install helper manages the marketplace/cache install path — it's an install tool, not a runtime binary.

Skill Invocation (in Codex)

All skills are invoked via Codex CLI's $skill-name syntax:

$cc:setup
$cc:review
$cc:review --background
$cc:review --base main --scope branch --model sonnet --effort high
$cc:adversarial-review --background question the retry design
$cc:rescue investigate the flaky test
$cc:rescue --model sonnet --effort medium investigate the regression
$cc:status
$cc:status task-abc123
$cc:result
$cc:result task-abc123
$cc:cancel task-abc123

Local UI

None.

IDE Integration

Codex CLI only (Codex plugin system). Claude Code is invoked as a subprocess via claude-companion.mjs, not as a UI.

Observability

  • Job tracking: $cc:status with --all flag for cross-session visibility
  • Unread result nudge: UserPromptSubmit hook injects unread-result notifications automatically
  • Background routing context: companion returns { jobId, ownerSessionId, parentThreadId } for explicit tracing
  • Stop gate: optional 900s timeout gate at session end

Cross-Tool Portability

Low / single-tool. Designed exclusively for Codex CLI's plugin system.

Related frameworks

same archetype · same primary tool · same memory type

Claude-Flow / Ruflo ★ 55k

Eliminates single-agent context limits and sequential bottlenecks by orchestrating fault-tolerant swarms of specialized AI agents…

Hermes Agent (NousResearch) ★ 168k

Self-improving personal AI agent with closed learning loop, 7 terminal backends, and messaging gateway — not tied to any AI…

OpenCode ★ 165k

Terminal-first AI coding agent with multi-model routing, native desktop app, and a typed .opencode/ configuration system for…

OpenHands ★ 75k

Open-source AI software development platform (open-source Devin alternative) with Docker sandbox isolation, 77.6% SWE-bench…

DeerFlow ★ 70k

Long-horizon superagent that researches, codes, and creates by orchestrating parallel sub-agents with isolated contexts in Docker…

oh-my-openagent (omo) ★ 60k

Multi-provider AI agent orchestration for OpenCode: escape vendor lock-in by routing Sisyphus (Claude/Kimi/GLM) and Hephaestus…