@armstrongnate/april 0.0.7 → 0.1.0

package/README.md

@@ -2,7 +2,7 @@
 
 She does all the work so you don't have to, and with about the same level of enthusiasm.
 
-april watches for GitHub issues assigned to you with a specific label, then spins up a Claude Code session in a tmux window to work the issue end-to-end — from reading the issue to opening a PR.
+april watches for GitHub issues assigned to you with a specific label, then spins up a coding-agent session in a tmux window to work the issue end-to-end — from reading the issue to opening a PR. Supports [Claude Code](https://claude.ai/claude-code) and [OpenAI Codex CLI](https://developers.openai.com/codex/cli) — pick one per install via config.
 
 ## Prerequisites
 
@@ -10,7 +10,7 @@ april watches for GitHub issues assigned to you with a specific label, then spin
 - [gh](https://cli.github.com/) (authenticated)
 - The [`gh-webhook` extension](https://github.com/cli/gh-webhook): `gh extension install cli/gh-webhook`
 - [tmux](https://github.com/tmux/tmux)
-- [Claude Code](https://claude.ai/claude-code) CLI
+- One of: [Claude Code](https://claude.ai/claude-code) CLI, or [Codex](https://developers.openai.com/codex/cli) CLI
 
 ## Quick install
 
@@ -31,7 +31,7 @@ The minimal flow above leaves out auth setup and a few server-specific gotchas.
 ### 1. System prerequisites
 
 ```bash
-# Install node 22+, tmux, gh, claude code via your usual route, then:
+# Install node 22+, tmux, gh, and your chosen agent CLI (claude or codex) via your usual route, then:
 gh extension install cli/gh-webhook
 ```
 
@@ -44,13 +44,13 @@ Generate one on your GitHub host's web UI: Settings → Developer settings → P
 **Classic PAT scopes:**
 - `repo` — issue read/write, label updates, PR creation, code access (no smaller scope works for private repo issues)
 - `admin:repo_hook` — needed for `gh webhook forward` to register and clean up its temporary `cli` webhook
-- `workflow` — only if Claude might modify `.github/workflows/*` files
+- `workflow` — only if the agent might modify `.github/workflows/*` files
 
 **Fine-grained PAT** (GHES 3.10+):
 - Repository access: select the repos
 - Permissions: Issues R/W, Pull requests R/W, Contents R/W, Webhooks R/W, Metadata R, Workflows R/W (last one optional)
 
-The daemon's own needs are smaller (Issues R/W + Webhooks R/W + Metadata R), but Claude inherits the same env when it runs inside tmux, so the token has to cover both — see [Token inheritance](#token-inheritance) below.
+The daemon's own needs are smaller (Issues R/W + Webhooks R/W + Metadata R), but the agent inherits the same env when it runs inside tmux, so the token has to cover both — see [Token inheritance](#token-inheritance) below.
 
 ### 3. Install the package
 
@@ -112,7 +112,7 @@ Healthy logs include `Starting webhook forwarder for <repo>` and no immediate er
 
 | Command | What it does |
 | --- | --- |
-| `april init` | Copies the bundled `config.example.yaml` to `~/.config/april/config.yaml` and the `issue-worker` skill to `~/.claude/skills/`. **Only writes files that don't already exist** — never overwrites. |
+| `april init` | Copies the bundled `config.example.yaml` to `~/.config/april/config.yaml` and the `issue-worker` skill to the configured agent's skill dir (`~/.claude/skills/` for claude, `~/.agents/skills/` for codex). **Only writes files that don't already exist** — never overwrites. |
 | `april install` | Installs and starts the user service. Pass `--print` to see the unit/plist without writing it. |
 | `april install-skill [-y]` | Install or refresh the issue-worker skill. Prompts before overwriting an existing copy; `--yes` skips the prompt (use in non-interactive scripts). |
 | `april upgrade [VER]` | Upgrade the npm package, regenerate the unit, restart the service, and reconcile the skill. |
@@ -142,13 +142,45 @@ After editing:
 
 ### Token inheritance
 
-`spawner.ts` runs Claude inside tmux with `tmux new-session -d <claudeCommand>` — no login shell. So Claude inherits the daemon's env directly, including any `GH_TOKEN` / `GH_ENTERPRISE_TOKEN` you set in the env file. Practical implication: the PAT you provide has to cover what *both* april and Claude need, not just april. If you want Claude to fall back to your shell's auth (a credential helper, network-level auth, etc.), you'd need to wrap the tmux command in a login shell — not currently supported.
+`spawner.ts` runs the agent inside tmux with `tmux new-session -d <agentCommand>` — no login shell. So the agent inherits the daemon's env directly, including any `GH_TOKEN` / `GH_ENTERPRISE_TOKEN` you set in the env file. Practical implication: the PAT you provide has to cover what *both* april and the agent need, not just april. If you want the agent to fall back to your shell's auth (a credential helper, network-level auth, etc.), you'd need to wrap the tmux command in a login shell — not currently supported.
+
+## Choosing an agent
+
+`llm` selects which CLI april spawns. `skill` is an april-level setting; CLI-specific options live under their own blocks:
+
+```yaml
+llm: "claude"               # or "codex"
+skill: "issue-worker"
+
+claude:
+  # model: "opus"           # defaults to opus
+  # permissionMode: "auto"  # defaults to auto
+
+codex:
+  # model: "gpt-5.1-codex-max" # omit to use codex's configured default
+  # askForApproval: "never"    # defaults to never
+```
+
+| | claude | codex |
+|---|---|---|
+| Launch | `claude --model <model> --permission-mode <permissionMode>` | `codex --model <model> --ask-for-approval <askForApproval>` |
+| Prompt sigil | `/issue-worker …` | `$issue-worker …` |
+| Skill install dir | `~/.claude/skills/` | `~/.agents/skills/` |
+| Default approval behavior | `permissionMode: "auto"` | `askForApproval: "never"` |
+
+The bundled `issue-worker` skill is the same SKILL.md for both; april just installs it under the right tree based on `llm`. Switching agents later: edit `config.yaml`, then run `april install-skill && april restart`.
 
 ## Service backend
 
 - **Linux** uses systemd user services at `~/.config/systemd/user/april.service`. Logs go to the journal (`journalctl --user -u april`).
 - **macOS** uses launchd LaunchAgents at `~/Library/LaunchAgents/dev.april.daemon.plist`. Logs go to `~/Library/Logs/april/april.log`.
 
+### Restarts and tmux sessions
+
+The unit/plist sets `KillMode=process` (systemd) / `AbandonProcessGroup=true` (launchd), which means `april restart` only signals the daemon itself — tmux sessions and the agent processes inside them keep running. The daemon's shutdown handler explicitly terminates the `gh webhook forward` children before exiting.
+
+If the daemon ever has to be SIGKILLed (it hung past the systemd stop timeout), the forwarders will be orphaned to PID 1. Clean them up with `pkill -f 'gh webhook forward'`.
+
 ### Node version managers
 
 `april install` captures the absolute path of the `node` binary it was invoked with (e.g. `~/.nvm/versions/node/v22.x.x/bin/node`) and bakes it into the unit/plist. If you later remove or change that node version, the service will fail to start — re-run `april install` after switching.
@@ -235,7 +267,7 @@ april restart
 
 Means your auth is provided by something other than a stored token (credential helper, network auth, wrapper). The webhook extension still needs an actual token — it doesn't matter how `gh` does its other API calls. Add `GH_TOKEN` / `GH_ENTERPRISE_TOKEN` to the env file.
 
-### Service can't find `gh` / `tmux` / `claude` even though they're on your shell PATH
+### Service can't find `gh` / `tmux` / `claude` / `codex` even though they're on your shell PATH
 
 `april install` captures `$PATH` at install time and bakes it into the unit. If you installed any of those tools after running `april install`, re-run `april install` to recapture PATH.
 
@@ -245,8 +277,8 @@ Once installed, label a GitHub issue with `agent:todo` and assign it to yourself
 
 1. Create a git worktree for the issue
 2. Run any configured post-worktree hooks (e.g. `pnpm i`)
-3. Spawn a tmux session with Claude Code
-4. Claude reads the issue, implements a fix, and opens a PR
+3. Spawn a tmux session with the configured agent (claude or codex)
+4. The agent reads the issue, implements a fix, and opens a PR
 5. Issue labels transition: `agent:todo` → `agent:wip` → `agent:review`
 
 Attach to a running session anytime with `tmux attach -t <session-name>`.

package/config.example.yaml

@@ -1,8 +1,13 @@
 assignee: "your-github-username"
 label: "agent:todo"
-claudeSkill: "issue-worker"
-# claudeModel: "opus"              # optional, defaults to opus
-# claudePermissionMode: "auto"     # optional, defaults to auto (others: default, acceptEdits, plan, bypassPermissions)
+llm: "claude"               # "claude" or "codex"
+skill: "issue-worker"
+claude:
+  # model: "opus"           # defaults to opus
+  # permissionMode: "auto"  # defaults to auto
+codex:
+  # model: "gpt-5.1-codex-max" # omit to use codex's configured default
+  # askForApproval: "never"    # defaults to never; e.g. "on-request"
 port: 7890
 repos:
   - owner: "org"

package/dist/agents.js

@@ -0,0 +1,50 @@
+import { join } from "node:path";
+import { homedir } from "node:os";
+function shellQuote(value) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
+const claude = {
+    kind: "claude",
+    cli: "claude",
+    buildCommand(config) {
+        const cfg = config.claude ?? {};
+        const model = cfg.model || "opus";
+        const permissionMode = cfg.permissionMode || "auto";
+        return `claude --model ${shellQuote(model)} --permission-mode ${shellQuote(permissionMode)}`;
+    },
+    buildPrompt(skill, body) {
+        return `/${skill} ${body}`;
+    },
+    skillDir(skill) {
+        return join(homedir(), ".claude", "skills", skill);
+    },
+    skillFile(skill) {
+        return join(this.skillDir(skill), "SKILL.md");
+    },
+};
+const codex = {
+    kind: "codex",
+    cli: "codex",
+    buildCommand(config) {
+        const cfg = config.codex ?? {};
+        const parts = ["codex"];
+        if (cfg.model)
+            parts.push("--model", shellQuote(cfg.model));
+        parts.push("--ask-for-approval", shellQuote(cfg.askForApproval || "never"));
+        return parts.join(" ");
+    },
+    buildPrompt(skill, body) {
+        return `$${skill} ${body}`;
+    },
+    skillDir(skill) {
+        return join(homedir(), ".agents", "skills", skill);
+    },
+    skillFile(skill) {
+        return join(this.skillDir(skill), "SKILL.md");
+    },
+};
+const AGENTS = { claude, codex };
+export function getAgent(kind) {
+    return AGENTS[kind];
+}
+export const AGENT_KINDS = ["claude", "codex"];

package/dist/cli.js

@@ -9,7 +9,7 @@ Usage:
   april <command> [options]
 
 Commands:
-  init              Copy bundled config + skill to ~/.config/april and ~/.claude (only if missing).
+  init              Copy bundled config, skill, and env file if missing.
   install [--print] Install and start the user service. --print emits the unit/plist to stdout instead.
   install-skill [-y] Install or refresh the issue-worker skill. Prompts before overwriting an existing
                     one; --yes (-y) skips the prompt.

package/dist/commands/init.js

@@ -4,7 +4,7 @@ import { copyFileSync, existsSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { ensureEnvFile, envFilePath } from "../service/envfile.js";
 import { isGhWebhookExtensionInstalled, GH_EXTENSION_INSTALL_CMD } from "../precheck.js";
-import { SKILL_DST, bundledSkillPath, compareSkill } from "../skill.js";
+import { skillDestPath, bundledSkillPath, compareSkill } from "../skill.js";
 // Resolve the bundled package root from this file's installed location.
 // dist/commands/init.js -> dist/.. (the package root, where config.example.yaml lives)
 function packageRoot() {
@@ -37,7 +37,11 @@ export function run(_args) {
         console.error(`  Cannot find bundled skill at ${skillSrc}`);
         return 1;
     }
-    copyIfMissing(skillSrc, SKILL_DST, "skill");
+    // Skill install path depends on the configured LLM. Before init writes
+    // a config, configuredLlmKind() falls back to claude, which matches the
+    // bundled example. If the user switches the agent later, they re-run
+    // `april install-skill`.
+    copyIfMissing(skillSrc, skillDestPath(), "skill");
     const envState = ensureEnvFile();
     console.log(`  env:    ${envState === "created" ? "wrote" : "already exists"} ${envFilePath()}`);
     console.log("");

package/dist/commands/install-skill.js

@@ -2,7 +2,7 @@ import { copyFileSync, existsSync, mkdirSync } from "node:fs";
 import { dirname } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { stdin, stdout } from "node:process";
-import { SKILL_DST, bundledSkillPath, compareSkill } from "../skill.js";
+import { skillDestPath, bundledSkillPath, compareSkill } from "../skill.js";
 export async function run(args) {
     const yes = args.includes("--yes") || args.includes("-y");
     const src = bundledSkillPath();
@@ -10,23 +10,24 @@ export async function run(args) {
         console.error(`Cannot find bundled skill at ${src}`);
         return 1;
     }
+    const dst = skillDestPath();
     const state = compareSkill();
     if (state === "matches-bundled") {
-        console.log(`✓ Skill at ${SKILL_DST} is already up to date`);
+        console.log(`✓ Skill at ${dst} is already up to date`);
         return 0;
     }
     if (state === "missing") {
-        mkdirSync(dirname(SKILL_DST), { recursive: true });
-        copyFileSync(src, SKILL_DST);
-        console.log(`✓ Installed skill at ${SKILL_DST}`);
+        mkdirSync(dirname(dst), { recursive: true });
+        copyFileSync(src, dst);
+        console.log(`✓ Installed skill at ${dst}`);
         return 0;
     }
     // differs-from-bundled
     console.log("Bundled issue-worker skill differs from the installed copy.");
-    console.log(`  installed: ${SKILL_DST}`);
+    console.log(`  installed: ${dst}`);
     console.log(`  bundled:   ${src}`);
     console.log("");
-    console.log(`Diff with: diff ${SKILL_DST} ${src}`);
+    console.log(`Diff with: diff ${dst} ${src}`);
     console.log("");
     if (!yes) {
         if (!stdin.isTTY) {
@@ -44,7 +45,7 @@ export async function run(args) {
             return 0;
         }
     }
-    copyFileSync(src, SKILL_DST);
-    console.log(`✓ Overwrote skill at ${SKILL_DST}`);
+    copyFileSync(src, dst);
+    console.log(`✓ Overwrote skill at ${dst}`);
     return 0;
 }

package/dist/config.js

@@ -5,6 +5,7 @@ import { homedir } from "node:os";
 import { parse as parseYaml } from "yaml";
 import { createLogger } from "./logger.js";
 import { isGhWebhookExtensionInstalled, GH_EXTENSION_INSTALL_CMD } from "./precheck.js";
+import { AGENT_KINDS, getAgent } from "./agents.js";
 const log = createLogger("config");
 function findConfigPath() {
     const envPath = process.env.APRIL_CONFIG;
@@ -28,8 +29,8 @@ function findConfigPath() {
         `  - ${localPath}\n` +
         "Create a config.yaml (see config.example.yaml).");
 }
-function validateTools() {
-    const tools = ["gh", "tmux", "git", "claude"];
+function validateTools(agentCli) {
+    const tools = ["gh", "tmux", "git", agentCli];
     for (const tool of tools) {
         try {
             execSync(`which ${tool}`, { stdio: "pipe" });
@@ -50,20 +51,57 @@ function validateString(obj, key, context) {
     }
     return val.trim();
 }
-export function loadConfig() {
-    validateTools();
-    const configPath = findConfigPath();
-    log.info(`Loading config from ${configPath}`);
-    const raw = readFileSync(configPath, "utf-8");
+function optionalObject(obj, key, context) {
+    const val = obj[key];
+    if (val === undefined || val === null)
+        return undefined;
+    if (typeof val !== "object" || Array.isArray(val)) {
+        throw new Error(`${context}: "${key}" must be an object when provided`);
+    }
+    return val;
+}
+function optionalString(obj, key) {
+    const val = obj[key];
+    return typeof val === "string" && val.trim().length > 0 ? val.trim() : undefined;
+}
+function parseLlm(parsed) {
+    const llmRaw = parsed.llm;
+    if (typeof llmRaw !== "string" || !AGENT_KINDS.includes(llmRaw)) {
+        throw new Error(`config: "llm" is required and must be one of ${AGENT_KINDS.join(", ")}`);
+    }
+    return llmRaw;
+}
+function parseClaudeConfig(parsed) {
+    const raw = optionalObject(parsed, "claude", "config");
+    if (!raw)
+        return undefined;
+    return {
+        model: optionalString(raw, "model"),
+        permissionMode: optionalString(raw, "permissionMode"),
+    };
+}
+function parseCodexConfig(parsed) {
+    const raw = optionalObject(parsed, "codex", "config");
+    if (!raw)
+        return undefined;
+    return {
+        model: optionalString(raw, "model"),
+        askForApproval: optionalString(raw, "askForApproval"),
+    };
+}
+export function parseConfigFile(path) {
+    const raw = readFileSync(path, "utf-8");
     const parsed = parseYaml(raw);
     if (!parsed || typeof parsed !== "object") {
         throw new Error("Config file is empty or not a valid YAML object");
     }
     const assignee = validateString(parsed, "assignee", "config");
     const label = validateString(parsed, "label", "config");
-    const claudeSkill = validateString(parsed, "claudeSkill", "config");
-    const claudeModel = typeof parsed.claudeModel === "string" ? parsed.claudeModel.trim() : undefined;
-    const claudePermissionMode = typeof parsed.claudePermissionMode === "string" ? parsed.claudePermissionMode.trim() : undefined;
+    const root = parsed;
+    const llm = parseLlm(root);
+    const skill = validateString(root, "skill", "config");
+    const claude = parseClaudeConfig(root);
+    const codex = parseCodexConfig(root);
     const port = Number(parsed.port);
     if (!Number.isInteger(port) || port < 1024 || port > 65535) {
         throw new Error(`config: "port" must be an integer between 1024 and 65535, got: ${parsed.port}`);
@@ -94,7 +132,36 @@ export function loadConfig() {
             : undefined;
         return { owner, name, path: resolvedPath, defaultBranch, slackChannel, postWorktreeHook };
     });
-    const config = { assignee, label, claudeSkill, claudeModel, claudePermissionMode, port, repos };
-    log.info(`Config loaded: assignee=${assignee}, label=${label}, repos=${repos.map((r) => `${r.owner}/${r.name}`).join(", ")}`);
+    const config = { assignee, label, llm, skill, claude, codex, port, repos };
+    return config;
+}
+/**
+ * Best-effort lookup of the configured LLM kind, for commands that touch
+ * agent-specific paths (e.g. install-skill) but should still work before the
+ * user has written a config. Returns "claude" as a fallback.
+ */
+export function configuredLlmKind() {
+    try {
+        const path = findConfigPath();
+        const raw = readFileSync(path, "utf-8");
+        const parsed = parseYaml(raw);
+        if (!parsed || typeof parsed !== "object")
+            return "claude";
+        const llm = parsed.llm;
+        return typeof llm === "string" && AGENT_KINDS.includes(llm)
+            ? llm
+            : "claude";
+    }
+    catch {
+        return "claude";
+    }
+}
+export function loadConfig() {
+    const configPath = findConfigPath();
+    log.info(`Loading config from ${configPath}`);
+    const config = parseConfigFile(configPath);
+    validateTools(getAgent(config.llm).cli);
+    log.info(`Config loaded: assignee=${config.assignee}, label=${config.label}, llm=${config.llm}, ` +
+        `repos=${config.repos.map((r) => `${r.owner}/${r.name}`).join(", ")}`);
     return config;
 }

package/dist/service/launchd.js

@@ -58,6 +58,11 @@ ${envEntries}
     <string>${escapeXml(log)}</string>
     <key>ProcessType</key>
     <string>Background</string>
+    <!-- launchd's equivalent of systemd's KillMode=process: when the daemon
+         exits, don't kill children that share its process group. Keeps tmux
+         sessions and any in-flight agent work alive across restarts. -->
+    <key>AbandonProcessGroup</key>
+    <true/>
 </dict>
 </plist>
 `;

package/dist/service/systemd.js

@@ -15,7 +15,7 @@ function runSystemctl(args) {
 export function unitContents() {
     const node = nodeBinaryPath();
     const entry = daemonEntryPath();
-    // Capture caller's PATH so child has access to gh, tmux, git, claude.
+    // Capture caller's PATH so child has access to gh, tmux, git, and the configured agent CLI.
     const path = process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin";
     return `[Unit]
 Description=april — issue worker
@@ -32,6 +32,10 @@ Environment=NODE_ENV=production
 EnvironmentFile=-${envFilePath()}
 StandardOutput=journal
 StandardError=journal
+# Only signal the main process on stop; leave tmux sessions and any other
+# children running so an april restart doesn't trash in-flight agent work.
+# The daemon's own shutdown handler still SIGTERMs the gh webhook forwarders.
+KillMode=process
 
 [Install]
 WantedBy=default.target

package/dist/skill.js

@@ -1,20 +1,25 @@
 import { fileURLToPath } from "node:url";
-import { dirname, join, resolve } from "node:path";
+import { dirname, resolve } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-export const SKILL_DST = join(homedir(), ".claude", "skills", "issue-worker", "SKILL.md");
+import { configuredLlmKind } from "./config.js";
+import { getAgent } from "./agents.js";
+const SKILL_NAME = "issue-worker";
 export function bundledSkillPath() {
     // dist/skill.js -> dist/.. -> package root, then skills/issue-worker/SKILL.md
     const here = fileURLToPath(import.meta.url);
-    return resolve(dirname(here), "..", "skills", "issue-worker", "SKILL.md");
+    return resolve(dirname(here), "..", "skills", SKILL_NAME, "SKILL.md");
 }
-export function compareSkill() {
-    if (!existsSync(SKILL_DST))
+export function skillDestPath(kind = configuredLlmKind()) {
+    return getAgent(kind).skillFile(SKILL_NAME);
+}
+export function compareSkill(kind = configuredLlmKind()) {
+    const dst = skillDestPath(kind);
+    if (!existsSync(dst))
         return "missing";
     const src = bundledSkillPath();
     if (!existsSync(src))
         return "matches-bundled"; // can't compare; don't alarm
-    return readFileSync(SKILL_DST).equals(readFileSync(src))
+    return readFileSync(dst).equals(readFileSync(src))
         ? "matches-bundled"
         : "differs-from-bundled";
 }

package/dist/spawner.js

@@ -3,6 +3,7 @@ import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { createLogger } from "./logger.js";
 import { makeSlug } from "./slug.js";
+import { getAgent } from "./agents.js";
 const log = createLogger("spawner");
 function checkWorktreesIgnored(repoPath) {
     const gitignorePath = join(repoPath, ".gitignore");
@@ -138,7 +139,7 @@ export async function createWorktree(repo, branch) {
     }
     return worktreePath;
 }
-export function spawnClaude(config, repo, issue, worktreePath, sessionName) {
+export function spawnAgent(config, repo, issue, worktreePath, sessionName) {
     // Check if session already exists
     try {
         execSync(`tmux has-session -t ${JSON.stringify(sessionName)}`, { stdio: "pipe" });
@@ -148,20 +149,20 @@ export function spawnClaude(config, repo, issue, worktreePath, sessionName) {
     catch {
         // Session does not exist, proceed
     }
-    const model = config.claudeModel || "opus";
-    const permissionMode = config.claudePermissionMode || "auto";
+    const agent = getAgent(config.llm);
     const slackPart = repo.slackChannel ? ` Post the PR to Slack channel #${repo.slackChannel}.` : "";
-    const prompt = `/${config.claudeSkill} Read GitHub issue #${issue.number} on ${repo.owner}/${repo.name} using the gh CLI. Implement it and open a PR.${slackPart}`;
+    const promptBody = `Read GitHub issue #${issue.number} on ${repo.owner}/${repo.name} using the gh CLI. Implement it and open a PR.${slackPart}`;
+    const prompt = agent.buildPrompt(config.skill, promptBody);
     log.debug(`Prompt: ${prompt}`);
-    const claudeCommand = `claude --model ${model} --permission-mode ${permissionMode}`;
-    log.info(`Spawning tmux session "${sessionName}" with claude`);
-    execSync(`tmux new-session -d -s ${JSON.stringify(sessionName)} -c ${JSON.stringify(worktreePath)} ${JSON.stringify(claudeCommand)}`);
-    // Send the prompt via send-keys after Claude starts
+    const agentCommand = agent.buildCommand(config);
+    log.info(`Spawning tmux session "${sessionName}" with ${agent.kind}`);
+    execSync(`tmux new-session -d -s ${JSON.stringify(sessionName)} -c ${JSON.stringify(worktreePath)} ${JSON.stringify(agentCommand)}`);
+    // Send the prompt via send-keys after the agent starts
     const escapedPrompt = prompt.replace(/'/g, "'\\''");
     const session = JSON.stringify(sessionName);
     setTimeout(() => {
         try {
-            // Send text first, then Enter after a short delay to ensure Claude's input is ready
+            // Send text first, then Enter after a short delay to ensure the agent's input is ready
             execSync(`tmux send-keys -t ${session} '${escapedPrompt}'`, { stdio: "pipe" });
             setTimeout(() => {
                 try {
@@ -195,12 +196,12 @@ export async function handleNewIssue(repo, issue, config) {
         log.error(`Failed to create worktree for #${issue.number}: ${err instanceof Error ? err.message : String(err)}`);
         return;
     }
-    // Spawn tmux + claude
+    // Spawn tmux + agent
     try {
-        spawnClaude(config, repo, issue, worktreePath, slug);
+        spawnAgent(config, repo, issue, worktreePath, slug);
     }
     catch (err) {
-        log.error(`Failed to spawn claude for #${issue.number}: ${err instanceof Error ? err.message : String(err)}`);
+        log.error(`Failed to spawn ${config.llm} for #${issue.number}: ${err instanceof Error ? err.message : String(err)}`);
         return;
     }
     // Apply label transition

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@armstrongnate/april",
-  "version": "0.0.7",
-  "description": "She does all the work so you don't have to. Watches GitHub issues and spawns Claude Code sessions to work them.",
+  "version": "0.1.0",
+  "description": "She does all the work so you don't have to. Watches GitHub issues and spawns coding-agent sessions (Claude Code or Codex) to work them.",
   "type": "module",
   "bin": {
     "april": "./dist/cli.js"

package/skills/issue-worker/SKILL.md

@@ -51,6 +51,10 @@ If the prompt specifies a Slack channel, use the Slack MCP tool to post a messag
 
 After creating the PR, monitor it until all checks pass and all review feedback is addressed.
 
+Note: the "claude review" CI check turns green as soon as Claude *posts* a review — it does
+not indicate the review was clean. Always read the actual review comments before deciding
+the PR is done.
+
 Loop:
 1. Sleep for 3 minutes (`sleep 180`)
 2. Check CI status: `gh pr checks {pr_number} --repo {owner}/{repo}`