@levistudio/redline 0.3.0 → 0.4.1

package/scripts/install-skill.sh

@@ -1,25 +1,66 @@
 #!/usr/bin/env bash
-# Install the redline-review skill into the user's global Claude skills directory
+# Install the redline-review skill into a user's global agent skills directory
 # so it's reachable from any project, not just this repo.
 #
 # This is a copy, not a symlink: the repo lives in paths that move (worktrees,
 # renamed projects), and a stale symlink that vanishes is worse than a copy
 # that needs an explicit refresh after pulling skill changes.
 #
-# We also generate a self-contained launcher next to the installed skill,
-# with absolute paths to `bun` and `src/cli.ts` baked in. SKILL.md points
-# at the launcher. This removes every $PATH dependency from the invocation
-# chain — both `redline` itself AND the `#!/usr/bin/env bun` shebang it would
-# otherwise resolve through PATH at runtime. (Real-usage failure: an outside
-# session hit `env: bun: No such file or directory` because ~/.bun/bin isn't
-# on $PATH in non-interactive Claude Bash subprocesses.)
+# We also generate a self-contained launcher next to the installed skill.
+# When invoked through the packaged `redline` binary, the launcher points back
+# to that durable binary. When invoked from a checkout, it bakes in absolute
+# paths to `bun` and `src/cli.ts`. Either way, the skill does not depend on
+# `redline` being on PATH in non-interactive agent subprocesses.
 
 set -euo pipefail
 
 REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
 SRC="$REPO_ROOT/skills/redline-review"
-DEST="${CLAUDE_HOME:-$HOME/.claude}/skills/redline-review"
 PLACEHOLDER="__REDLINE_BIN__"
+TARGET="both"
+
+usage() {
+  cat >&2 <<'EOF'
+Usage: redline install-skill [--agent claude|codex|both]
+       scripts/install-skill.sh [--agent claude|codex|both]
+
+Installs the bundled redline-review skill into the selected agent environment:
+  claude  -> $CLAUDE_HOME/skills/redline-review or ~/.claude/skills/redline-review
+  codex   -> $CODEX_HOME/skills/redline-review or ~/.codex/skills/redline-review
+  both    -> both locations (default)
+EOF
+}
+
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --agent)
+      TARGET="${2:-}"
+      shift 2
+      ;;
+    --agent=*)
+      TARGET="${1#--agent=}"
+      shift
+      ;;
+    -h|--help)
+      usage
+      exit 0
+      ;;
+    *)
+      echo "error: unknown argument: $1" >&2
+      usage
+      exit 1
+      ;;
+  esac
+done
+
+case "$TARGET" in
+  claude|codex|both) ;;
+  *)
+    echo "error: --agent must be claude, codex, or both" >&2
+    usage
+    exit 1
+    ;;
+esac
 
 if [ ! -d "$SRC" ]; then
   echo "error: skill source not found at $SRC" >&2
@@ -32,47 +73,71 @@ if [ ! -f "$CLI_ABS" ]; then
   exit 1
 fi
 
-# Resolve bun. Prefer $PATH; fall back to ~/.bun/bin/bun.
-if command -v bun >/dev/null 2>&1; then
-  BUN_ABS="$(command -v bun)"
-elif [ -x "$HOME/.bun/bin/bun" ]; then
-  BUN_ABS="$HOME/.bun/bin/bun"
+LAUNCH_CMD=""
+if [ -n "${REDLINE_BIN_ABS:-}" ] && [ -f "$REDLINE_BIN_ABS" ]; then
+  LAUNCH_CMD="exec \"$REDLINE_BIN_ABS\" \"\$@\""
+  BUN_ABS=""
 else
-  echo "error: bun not found in PATH or at ~/.bun/bin/bun (install: https://bun.sh)" >&2
-  exit 1
+  # Resolve bun. Prefer $PATH; fall back to ~/.bun/bin/bun.
+  if command -v bun >/dev/null 2>&1; then
+    BUN_ABS="$(command -v bun)"
+  elif [ -x "$HOME/.bun/bin/bun" ]; then
+    BUN_ABS="$HOME/.bun/bin/bun"
+  else
+    echo "error: bun not found in PATH or at ~/.bun/bin/bun (install: https://bun.sh)" >&2
+    exit 1
+  fi
+  LAUNCH_CMD="exec \"$BUN_ABS\" run \"$CLI_ABS\" \"\$@\""
 fi
 
-mkdir -p "$(dirname "$DEST")"
-rm -rf "$DEST"
-cp -R "$SRC" "$DEST"
+install_one() {
+  local label="$1"
+  local dest="$2"
+
+  mkdir -p "$(dirname "$dest")"
+  rm -rf "$dest"
+  cp -R "$SRC" "$dest"
 
-# Generate a self-contained launcher with absolute paths to bun and cli.ts.
-LAUNCHER="$DEST/redline"
-cat > "$LAUNCHER" <<EOF
+  # Generate a self-contained launcher.
+  local launcher="$dest/redline"
+  cat > "$launcher" <<EOF
 #!/bin/bash
 # Auto-generated by scripts/install-skill.sh — re-run that script to refresh.
-exec "$BUN_ABS" run "$CLI_ABS" "\$@"
+$LAUNCH_CMD
 EOF
-chmod +x "$LAUNCHER"
+  chmod +x "$launcher"
 
-# Substitute the launcher path into the installed SKILL.md.
-SKILL_FILE="$DEST/SKILL.md"
-if ! grep -q "$PLACEHOLDER" "$SKILL_FILE"; then
-  echo "error: placeholder '$PLACEHOLDER' not found in $SKILL_FILE — source skill is out of sync" >&2
-  exit 1
+  # Substitute the launcher path into the installed SKILL.md.
+  local skill_file="$dest/SKILL.md"
+  if ! grep -q "$PLACEHOLDER" "$skill_file"; then
+    echo "error: placeholder '$PLACEHOLDER' not found in $skill_file — source skill is out of sync" >&2
+    exit 1
+  fi
+  if [[ "$OSTYPE" == "darwin"* ]]; then
+    sed -i '' "s|$PLACEHOLDER|$launcher|g" "$skill_file"
+  else
+    sed -i "s|$PLACEHOLDER|$launcher|g" "$skill_file"
+  fi
+
+  echo "Installed redline-review for $label → $dest"
+  echo "  launcher: $launcher"
+}
+
+if [ "$TARGET" = "claude" ] || [ "$TARGET" = "both" ]; then
+  install_one "Claude Code" "${CLAUDE_HOME:-$HOME/.claude}/skills/redline-review"
 fi
-if [[ "$OSTYPE" == "darwin"* ]]; then
-  sed -i '' "s|$PLACEHOLDER|$LAUNCHER|g" "$SKILL_FILE"
-else
-  sed -i "s|$PLACEHOLDER|$LAUNCHER|g" "$SKILL_FILE"
+if [ "$TARGET" = "codex" ] || [ "$TARGET" = "both" ]; then
+  install_one "Codex" "${CODEX_HOME:-$HOME/.codex}/skills/redline-review"
 fi
 
-echo "Installed redline-review → $DEST"
-echo "  launcher: $LAUNCHER"
-echo "  bun:      $BUN_ABS"
-echo "  cli:      $CLI_ABS"
+if [ -n "${BUN_ABS:-}" ]; then
+  echo "  bun:      $BUN_ABS"
+  echo "  cli:      $CLI_ABS"
+else
+  echo "  redline:  $REDLINE_BIN_ABS"
+fi
 echo
-echo "Your AI coding agents (Claude Code, etc.) can now use the redline-review skill."
+echo "Your AI coding agents can now use the redline-review skill."
 echo "Try it: ask your agent to redline a markdown file you'd like feedback on."
 echo
-echo "Re-run this script after pulling skill changes."
+echo "Re-run this command after upgrading Redline if the skill instructions change."

package/skills/redline-review/SKILL.md

@@ -9,9 +9,9 @@ When you've produced a markdown document that the human needs to read, comment o
 
 ## How to invoke it
 
-The redline binary lives at `__REDLINE_BIN__` (substituted at install time — if you see the literal placeholder string, the skill was installed incorrectly; tell the human to re-run `scripts/install-skill.sh` from the redline repo). Always invoke it by this absolute path. Do not call bare `redline` and do not try to "fix" PATH issues by running `bun link` or guessing where the repo lives.
+The redline launcher lives at `__REDLINE_BIN__` (substituted at install time — if you see the literal placeholder string, the skill was installed incorrectly; tell the human to re-run `redline install-skill`). Always invoke it by this absolute path. Do not call bare `redline` and do not try to "fix" PATH issues by running `bun link` or guessing where the repo lives.
 
-**Always background the launcher and poll.** Never run `__REDLINE_BIN__` as a foreground/blocking Bash call: the Bash tool buffers stdout until the process exits, so you would never see the URL the human needs to click and your "I'll wait while you review" message would be a lie. Use this pattern:
+**Always background the launcher and poll.** Never run `__REDLINE_BIN__` as a foreground/blocking shell call: agent shell tools often buffer stdout until the process exits, so you would never see the URL the human needs to click and your "I'll wait while you review" message would be a lie. Use this pattern:
 
 ```bash
 FILE=/abs/path/to/file.md
@@ -20,8 +20,8 @@ STARTUP="$DIR/.review/$BASE.startup.json"
 RESULT="$DIR/.review/$BASE.result"
 LOG=/tmp/redline-$BASE.log
 
-# Kick off the review in the background.
-__REDLINE_BIN__ "$FILE" > "$LOG" 2>&1 &
+# Kick off the review in the background and open it in the user's real browser.
+__REDLINE_BIN__ "$FILE" --open > "$LOG" 2>&1 &
 
 # Step 1: wait for startup, read the URL.
 for i in $(seq 1 60); do [ -f "$STARTUP" ] && break; sleep 0.5; done
@@ -34,7 +34,7 @@ PID=$(grep -o '"pid": *[0-9]*' "$STARTUP" | grep -o '[0-9]*')
 echo "REDLINE_URL: $URL"
 echo "REDLINE_PID: $PID"
 
-# Step 2: surface the URL to the human (you do this after the Bash call returns
+# Step 2: tell the human the browser opened (you do this after the first shell call returns
 # — see the next section), then wait for the redline process to exit. Watching
 # the PID (essentially free) instead of polling for the result file means you
 # wake up within ~0.5s of the human clicking Done, not up to 30s later.
@@ -44,12 +44,12 @@ cat "$RESULT"
 
 The startup file at `.review/<basename>.startup.json` is written synchronously when the server begins listening; it contains `url`, `port`, `file`, `result_file`, `started_at`, `pid`. The result file at `.review/<basename>.result` is written when the session ends (approved, abandoned, or error).
 
-In practice, run the script above as **two separate Bash calls** so you can tell the human the URL between steps:
+In practice, run the script above as **two separate shell calls** so you can tell the human the URL between steps:
 1. First call: everything through `echo "REDLINE_PID: $PID"`. Returns in ~1s with the URL and PID on stdout.
-2. Surface the URL to the human in your reply text (see "Surfacing the URL" below).
+2. Tell the human Redline opened in their browser, and include the URL only as a fallback (see "Surfacing the URL" below).
 3. Second call: just the `while kill -0` loop waiting for the PID, then `cat "$RESULT"`. Long timeout (`timeout: 1800000` = 30 min, or longer).
 
-If invocation fails (binary missing, startup file never appears, etc.), surface the error verbatim and stop — do not try to recover. The human will re-run the install script.
+If invocation fails (binary missing, startup file never appears, etc.), surface the error verbatim and stop — do not try to recover. The human will re-run `redline install-skill`.
 
 ### Pass context with `--context`
 
@@ -61,15 +61,13 @@ The context string is shown in the reader's header so the human knows what they'
 
 ### Surfacing the URL
 
-After the first Bash call returns with `REDLINE_URL: http://localhost:NNNN`, surface that URL in your reply text. The human has no other signal that something is waiting for them. One short sentence:
+The `--open` flag launches the review in the user's real browser via the OS opener (`open` on macOS, `xdg-open` on Linux, `start` on Windows). After the first shell call returns with `REDLINE_URL: http://localhost:NNNN`, tell the human the browser opened and include the URL only as a fallback. Do **not** make the URL the primary action; in some agent UIs, clicking localhost opens an embedded preview panel instead of the user's browser.
 
-> "Opening this in Redline for review at http://localhost:NNNN — cmd-click to open. I'll continue once you click Done."
-
-(There is an `--open` flag that auto-launches the browser, but prefer leaving it off — the human may not be at the keyboard the moment the session starts, and a stolen-focus browser tab is worse than a URL they click when ready.)
+> "I opened this in Redline in your browser. Fallback URL: http://localhost:NNNN. I'll continue once you click Done."
 
 ## How to interpret the result
 
-When the polling loop's Bash call returns, the `cat "$RESULT"` at the end of it has printed the result JSON to stdout.
+When the polling loop's shell call returns, the `cat "$RESULT"` at the end of it has printed the result JSON to stdout.
 
 ```json
 { "status": "approved", "file": "/abs/path/to/file.md", "rounds": 2, "comments": 5 }
@@ -87,9 +85,9 @@ The full loop, when you are the outer agent producing the doc:
 
 1. Write the markdown file to disk at an absolute path.
 2. Tell the human in one sentence what's about to happen.
-3. First Bash call: launch `__REDLINE_BIN__ <abs-path> --context "<one-liner>"` in the background and poll for `.startup.json`. Returns in ~1s with the URL.
-4. Surface the URL to the human in your reply text so they can cmd-click to open.
-5. Second Bash call: wait on the redline PID (`while kill -0 "$PID" 2>/dev/null; do sleep 0.5; done`) then `cat "$RESULT"`, with a long timeout (30+ min). While the session runs, you are idle — do not start unrelated work, do not run other tools.
+3. First shell call: launch `__REDLINE_BIN__ <abs-path> --context "<one-liner>" --open` in the background and poll for `.startup.json`. Returns in ~1s with the URL.
+4. Tell the human Redline opened in their browser and include the URL only as a fallback.
+5. Second shell call: wait on the redline PID (`while kill -0 "$PID" 2>/dev/null; do sleep 0.5; done`) then `cat "$RESULT"`, with a long timeout (30+ min). While the session runs, you are idle — do not start unrelated work, do not run other tools.
 6. On `approved`: re-read the file from disk (it may have been revised) and continue with whatever required sign-off.
 7. On `abandoned` or `error`: stop and ask the human how to proceed; do not retry automatically.
 

package/src/agent.ts

@@ -7,6 +7,7 @@ import { parseReply } from "./parseReply";
 import { newEnvelope } from "./promptEnvelope";
 import { contextBlock } from "./contextBlock";
 import { loadSidecar } from "./sidecar";
+import { getAgentProvider, resolveProviderId } from "./agentProvider";
 
 const filePath = process.argv[2];
 if (!filePath) {
@@ -42,6 +43,7 @@ if (process.env.REDLINE_AGENT_CRASH_ALWAYS === "1") {
 
 const BASE_URL = `http://localhost:${process.env.REDLINE_PORT ?? "3000"}`;
 const CSRF_TOKEN = process.env.REDLINE_TOKEN ?? "";
+const provider = getAgentProvider(resolveProviderId());
 
 // Inject `X-Redline-Token` on every mutating call back to the server. The
 // server rejects unauthenticated POST/DELETE/PUT/PATCH on /api/*; without
@@ -89,7 +91,7 @@ const REPLY_SYSTEM_PROMPT_BODY =
   "Good: message: \"Got it.\"  reason: \"Add a third line to the hard line breaks example\"\n" +
   "When requires_revision is false, leave reason empty (or a very short note about why no edit). The reply IS the answer.\n" +
   "\n" +
-  "Separately, decide whether this comment needs the agent that LAUNCHED this review rather than you. That outer agent has the project context, tools, and authority you don't — e.g. an external style guide or canon you can't see, a spec to check the document against, or a decision that depends on the wider project. When the comment asks for something like that, set ESCALATE: true and briefly tell the reviewer in your message that you've routed it to the launching agent. Otherwise ESCALATE: false. Escalating does not change requires_revision — judge that on its own.\n" +
+  "Separately, decide whether this comment needs the agent that LAUNCHED this review rather than you. ESCALATE is rare: set ESCALATE: true only when the reviewer explicitly asks for information, tools, authority, or project context you cannot access from the document and comment thread — for example an external style guide, a hidden spec, repo-wide code context, or a decision the launching agent must make. Do NOT escalate ordinary requested edits, reframes, emphasis changes, priority changes, rewrites, or approvals; those are handled by requires_revision. If the comment can be satisfied by editing this document, set ESCALATE: false. When you do escalate, briefly tell the reviewer in your message that you've routed it to the launching agent. Escalating does not change requires_revision — judge that on its own.\n" +
   "\n" +
   "Output exactly this format and nothing else (no prose before/after, no code fences). Use these literal markers — do not escape quotes inside the message:\n" +
   "REQUIRES_REVISION: <true|false>\n" +
@@ -123,7 +125,7 @@ async function postReply(
   await fetch(`${BASE_URL}/api/comment/${commentId}/reply`, {
     method: "POST",
     headers: { "Content-Type": "application/json", ...CSRF_HEADER },
-    body: JSON.stringify({ role: "agent", name: "Claude", message, requires_revision, revision_reason, escalate }),
+    body: JSON.stringify({ role: "agent", name: provider.displayName, message, requires_revision, revision_reason, escalate }),
   });
 }
 
@@ -168,24 +170,16 @@ async function handleComment(commentId: string) {
       `Thread:\n${env.wrap("thread", threadText)}`;
 
     const lastMessage = thread[thread.length - 1].message as string;
-    const model = pickReplyModel(lastMessage);
-    console.log(`[agent] replying to ${commentId} with ${model}`);
-
-    const cliBin = process.env.CLAUDE_CODE_EXECPATH ?? "claude";
-    const proc = Bun.spawn(
-      [cliBin, "-p", "--system-prompt", replySystemPrompt(env.systemPromptHint()), "--model", model],
-      { stdin: "pipe", stdout: "pipe", stderr: "inherit" }
-    );
-    proc.stdin.write(userMessage);
-    proc.stdin.end();
-
-    let reply = "";
-    const reader = proc.stdout.getReader();
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      reply += new TextDecoder().decode(value);
-    }
+    const tier = pickReplyModel(lastMessage);
+    const model = provider.modelForTier(tier);
+    console.log(`[agent] replying to ${commentId} with ${provider.id}/${model}`);
+
+    const reply = await provider.runReply({
+      systemPrompt: replySystemPrompt(env.systemPromptHint()),
+      userMessage,
+      model,
+      cwd: process.cwd(),
+    });
 
     if (reply.trim()) {
       const parsed = parseReply(reply);

package/src/agentProvider.ts

@@ -0,0 +1,267 @@
+import { existsSync } from "fs";
+import { mkdtemp, readFile, rm } from "fs/promises";
+import os from "os";
+import path from "path";
+import type { ModelTier } from "./pickModel";
+
+export type AgentProviderId = "claude" | "codex";
+
+export type RevisionChunkKind = "thinking" | "text";
+
+export interface RevisionRunResult {
+  revised: string;
+  stderr: string;
+  exitCode: number;
+  durationMs: number;
+}
+
+export interface AgentProvider {
+  id: AgentProviderId;
+  displayName: string;
+  executable(): string;
+  preflight(): void;
+  modelForTier(tier: ModelTier): string;
+  runReply(input: {
+    systemPrompt: string;
+    userMessage: string;
+    model: string;
+    cwd: string;
+  }): Promise<string>;
+  runRevision(input: {
+    systemPrompt: string;
+    userMessage: string;
+    model: string;
+    cwd: string;
+    onChunk?: (text: string, kind: RevisionChunkKind) => void;
+  }): Promise<RevisionRunResult>;
+}
+
+export const PROVIDER_IDS: AgentProviderId[] = ["claude", "codex"];
+
+export function parseAgentProviderId(value: string | undefined): AgentProviderId | null {
+  if (!value) return null;
+  return PROVIDER_IDS.includes(value as AgentProviderId) ? value as AgentProviderId : null;
+}
+
+export function resolveProviderId(raw?: string): AgentProviderId {
+  const explicit = parseAgentProviderId(raw ?? process.env.REDLINE_AGENT);
+  if (explicit) return explicit;
+
+  if (process.env.CLAUDE_CODE_EXECPATH && existsSync(process.env.CLAUDE_CODE_EXECPATH)) return "claude";
+  if (Bun.which("claude")) return "claude";
+  if (process.env.CODEX_EXECPATH && existsSync(process.env.CODEX_EXECPATH)) return "codex";
+  if (Bun.which("codex")) return "codex";
+  // Preserve the published behavior: if nothing can be detected, the
+  // preflight on the default provider prints the actionable install message.
+  return "claude";
+}
+
+export function invalidProviderMessage(value: string): string {
+  return `[redline] Unknown agent provider "${value}". Supported providers: ${PROVIDER_IDS.join(", ")}.`;
+}
+
+function requireExecutable(provider: AgentProviderId, envPath: string | undefined, bin: string): string {
+  if (envPath && existsSync(envPath)) return envPath;
+  const found = Bun.which(bin);
+  if (found) return found;
+  const install =
+    provider === "claude"
+      ? "Install Claude Code from https://claude.com/claude-code and re-run."
+      : "Install Codex and make sure `codex` is on PATH, or set CODEX_EXECPATH.";
+  throw new Error(
+    `\n[redline] Could not find the ${provider} CLI.\n` +
+    `Redline shells out to a local ${provider} agent for replies and revisions.\n` +
+    `${install}\n`
+  );
+}
+
+function drainStderr(stream: ReadableStream<Uint8Array>): Promise<string> {
+  return (async () => {
+    let out = "";
+    const r = stream.getReader();
+    const dec = new TextDecoder();
+    while (true) {
+      const { done, value } = await r.read();
+      if (done) break;
+      const chunk = dec.decode(value);
+      out += chunk;
+      process.stderr.write(chunk);
+    }
+    return out;
+  })();
+}
+
+async function readAll(stream: ReadableStream<Uint8Array>): Promise<string> {
+  let out = "";
+  const r = stream.getReader();
+  const dec = new TextDecoder();
+  while (true) {
+    const { done, value } = await r.read();
+    if (done) break;
+    out += dec.decode(value);
+  }
+  return out;
+}
+
+function combinedPrompt(systemPrompt: string, userMessage: string): string {
+  return `${systemPrompt}\n\n---\n\n${userMessage}`;
+}
+
+export function getAgentProvider(id: AgentProviderId): AgentProvider {
+  if (id === "codex") return codexProvider;
+  return claudeProvider;
+}
+
+export const claudeProvider: AgentProvider = {
+  id: "claude",
+  displayName: "Claude",
+  executable() {
+    return requireExecutable("claude", process.env.CLAUDE_CODE_EXECPATH, "claude");
+  },
+  preflight() {
+    this.executable();
+  },
+  modelForTier(tier) {
+    return tier === "smart" ? "claude-sonnet-4-6" : "claude-haiku-4-5-20251001";
+  },
+  async runReply(input) {
+    const proc = Bun.spawn(
+      [this.executable(), "-p", "--system-prompt", input.systemPrompt, "--model", input.model],
+      { stdin: "pipe", stdout: "pipe", stderr: "inherit", cwd: input.cwd }
+    );
+    proc.stdin.write(input.userMessage);
+    proc.stdin.end();
+    const reply = await readAll(proc.stdout);
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) throw new Error(`claude CLI exited with code ${exitCode}`);
+    return reply;
+  },
+  async runRevision(input) {
+    const startedAt = Date.now();
+    const proc = Bun.spawn(
+      [this.executable(), "-p", "--system-prompt", input.systemPrompt, "--model", input.model,
+       "--output-format", "stream-json", "--include-partial-messages", "--verbose"],
+      { stdin: "pipe", stdout: "pipe", stderr: "pipe", cwd: input.cwd }
+    );
+
+    proc.stdin.write(input.userMessage);
+    proc.stdin.end();
+
+    const stderrDone = drainStderr(proc.stderr);
+    let revised = "";
+    let buffer = "";
+    const reader = proc.stdout.getReader();
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += new TextDecoder().decode(value);
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const obj = JSON.parse(line);
+          if (obj.type === "stream_event" && obj.event?.type === "content_block_delta") {
+            const delta = obj.event.delta;
+            if (delta?.type === "text_delta" && delta.text) {
+              revised += delta.text;
+              process.stdout.write(delta.text);
+              input.onChunk?.(delta.text, "text");
+            } else if (delta?.type === "thinking_delta" && delta.thinking) {
+              input.onChunk?.(delta.thinking, "thinking");
+            }
+          }
+        } catch { /* malformed JSON line, skip */ }
+      }
+    }
+    const exitCode = await proc.exited;
+    const stderr = await stderrDone;
+    return { revised, stderr, exitCode, durationMs: Date.now() - startedAt };
+  },
+};
+
+export const codexProvider: AgentProvider = {
+  id: "codex",
+  displayName: "Codex",
+  executable() {
+    return requireExecutable("codex", process.env.CODEX_EXECPATH, "codex");
+  },
+  preflight() {
+    this.executable();
+  },
+  modelForTier(tier) {
+    return tier === "smart"
+      ? (process.env.REDLINE_CODEX_SMART_MODEL ?? "gpt-5.4")
+      : (process.env.REDLINE_CODEX_FAST_MODEL ?? "gpt-5.4-mini");
+  },
+  async runReply(input) {
+    const tmpDir = await mkdtemp(path.join(os.tmpdir(), "redline-codex-"));
+    const lastMessagePath = path.join(tmpDir, "last-message.md");
+    const proc = Bun.spawn(
+      [
+        this.executable(), "--ask-for-approval", "never", "exec",
+        "--model", input.model,
+        "--cd", input.cwd,
+        "--sandbox", "read-only",
+        "--skip-git-repo-check",
+        "--ephemeral",
+        "--color", "never",
+        "--output-last-message", lastMessagePath,
+        "-",
+      ],
+      { stdin: "pipe", stdout: "pipe", stderr: "inherit", cwd: input.cwd }
+    );
+    proc.stdin.write(combinedPrompt(input.systemPrompt, input.userMessage));
+    proc.stdin.end();
+    const stdout = await readAll(proc.stdout);
+    const exitCode = await proc.exited;
+    let reply = stdout;
+    try {
+      const fromFile = await readFile(lastMessagePath, "utf-8");
+      if (fromFile.trim()) reply = fromFile;
+    } catch { /* fall back to stdout */ }
+    await rm(tmpDir, { recursive: true, force: true }).catch(() => {});
+    if (exitCode !== 0) throw new Error(`codex CLI exited with code ${exitCode}`);
+    return reply;
+  },
+  async runRevision(input) {
+    const startedAt = Date.now();
+    const tmpDir = await mkdtemp(path.join(os.tmpdir(), "redline-codex-"));
+    const lastMessagePath = path.join(tmpDir, "last-message.md");
+    const proc = Bun.spawn(
+      [
+        this.executable(), "--ask-for-approval", "never", "exec",
+        "--model", input.model,
+        "--cd", input.cwd,
+        "--sandbox", "read-only",
+        "--skip-git-repo-check",
+        "--ephemeral",
+        "--color", "never",
+        "--output-last-message", lastMessagePath,
+        "-",
+      ],
+      { stdin: "pipe", stdout: "pipe", stderr: "pipe", cwd: input.cwd }
+    );
+
+    proc.stdin.write(combinedPrompt(input.systemPrompt, input.userMessage));
+    proc.stdin.end();
+
+    const stderrDone = drainStderr(proc.stderr);
+    const stdoutDone = readAll(proc.stdout);
+    const exitCode = await proc.exited;
+    const [stderr, stdout] = await Promise.all([stderrDone, stdoutDone]);
+
+    let revised = stdout;
+    try {
+      const fromFile = await readFile(lastMessagePath, "utf-8");
+      if (fromFile.trim()) revised = fromFile;
+    } catch { /* fall back to stdout */ }
+    await rm(tmpDir, { recursive: true, force: true }).catch(() => {});
+
+    if (revised) {
+      process.stdout.write(revised);
+      input.onChunk?.(revised, "text");
+    }
+    return { revised, stderr, exitCode, durationMs: Date.now() - startedAt };
+  },
+};