kaizen-agent 0.7.3 → 1.0.0

package/cli/dashboard.ts

@@ -41,6 +41,80 @@ const WORDMARK = [
   "█ █  █ █  █  █▄▄  █▄▄  █  █",
 ];
 
+const KNOWN_AGENTS = [
+  { name: "Claude Code", dir: ".claude", cmd: "claude" },
+  { name: "Antigravity", dir: ".agents", cmd: "agy" },
+  { name: "Codex", dir: ".codex", cmd: "codex" },
+  { name: "OpenCode", dir: ".opencode", cmd: "opencode" },
+  { name: "Gemini CLI", dir: ".gemini", cmd: "gemini" },
+  { name: "Cursor", dir: ".cursor", cmd: "cursor" },
+];
+
+function detectDefaultAgent(projectDir: string): { name: string; cmd: string } {
+  const cfgFile = existsSync(join(projectDir, ".kaizen", "config.yml"))
+    ? join(projectDir, ".kaizen", "config.yml")
+    : join(home, ".kaizen", "config.yml");
+  if (existsSync(cfgFile)) {
+    const text = readFileSync(cfgFile, "utf8");
+    const m = /^\s*agent:\s*\n\s*default:\s*(\S+)/m.exec(text) || /^\s*agent\.default:\s*(\S+)/m.exec(text);
+    if (m && m[1] && m[1] !== "auto") {
+      const found = KNOWN_AGENTS.find((a) => a.cmd === m[1] || a.name.toLowerCase() === m[1].toLowerCase());
+      if (found && Bun.which(found.cmd)) return found;
+    }
+  }
+
+  for (const a of KNOWN_AGENTS) {
+    if (existsSync(join(projectDir, a.dir)) && Bun.which(a.cmd)) return a;
+  }
+  if (Bun.which("claude")) return { name: "Claude Code", cmd: "claude" };
+  for (const a of KNOWN_AGENTS) {
+    if (Bun.which(a.cmd)) return a;
+  }
+  return { name: "Claude Code", cmd: "claude" };
+}
+
+function findTerminal(cwd: string, fullCmd: string[]): { cmd: string[]; detached: boolean } | null {
+  const hasDisplay = Boolean(process.env.WAYLAND_DISPLAY || process.env.DISPLAY);
+  const inTmux = Boolean(process.env.TMUX);
+
+  if (process.env.TERMINAL && Bun.which(process.env.TERMINAL)) {
+    const term = process.env.TERMINAL;
+    if (term.includes("kitty")) return { cmd: [term, "--directory", cwd, ...fullCmd], detached: true };
+    if (term.includes("alacritty")) return { cmd: [term, "--working-directory", cwd, "-e", ...fullCmd], detached: true };
+    if (term.includes("ghostty")) return { cmd: [term, `--working-directory=${cwd}`, "-e", ...fullCmd], detached: true };
+    if (term.includes("foot")) return { cmd: [term, "-D", cwd, ...fullCmd], detached: true };
+    return { cmd: [term, "-e", ...fullCmd], detached: true };
+  }
+
+  if (hasDisplay && Bun.which("xdg-terminal-exec")) {
+    return { cmd: ["xdg-terminal-exec", `--dir=${cwd}`, "--", ...fullCmd], detached: true };
+  }
+
+  if (hasDisplay) {
+    if (Bun.which("kitty")) return { cmd: ["kitty", "--directory", cwd, ...fullCmd], detached: true };
+    if (Bun.which("ghostty")) return { cmd: ["ghostty", `--working-directory=${cwd}`, "-e", ...fullCmd], detached: true };
+    if (Bun.which("alacritty")) return { cmd: ["alacritty", "--working-directory", cwd, "-e", ...fullCmd], detached: true };
+    if (Bun.which("foot")) return { cmd: ["foot", "-D", cwd, ...fullCmd], detached: true };
+    if (Bun.which("wezterm")) return { cmd: ["wezterm", "start", "--cwd", cwd, "--", ...fullCmd], detached: true };
+    if (Bun.which("gnome-terminal")) return { cmd: ["gnome-terminal", `--working-directory=${cwd}`, "--", ...fullCmd], detached: true };
+    if (Bun.which("xfce4-terminal")) return { cmd: ["xfce4-terminal", `--default-working-directory=${cwd}`, "-x", ...fullCmd], detached: true };
+    if (Bun.which("konsole")) return { cmd: ["konsole", "--workdir", cwd, "-e", ...fullCmd], detached: true };
+    if (Bun.which("xterm")) return { cmd: ["xterm", "-e", `cd "${cwd}" && ${fullCmd.join(" ")}`], detached: true };
+  }
+
+  if (inTmux && Bun.which("tmux")) {
+    const cmdStr = fullCmd.map((a) => (a.includes(" ") ? JSON.stringify(a) : a)).join(" ");
+    return { cmd: ["tmux", "new-window", "-c", cwd, cmdStr], detached: false };
+  }
+
+  if (process.platform === "darwin") {
+    const cmdStr = fullCmd.map((a) => (a.includes(" ") ? `\\"${a}\\"` : a)).join(" ");
+    const script = `tell application "Terminal" to do script "cd \\"${cwd}\\" && ${cmdStr}"\ntell application "Terminal" to activate`;
+    return { cmd: ["osascript", "-e", script], detached: true };
+  }
+
+  return null;
+}
 
 export async function dashboard(
   repo: string,
@@ -101,16 +175,19 @@ export async function dashboard(
 
   // An action that has something to say says it here, on its own screen, rather
   // than printing to a terminal the dashboard is about to paint over.
-  async function report(lines: string[]) {
+  async function report(lines: string[], footer = "any key to go back"): Promise<string> {
     stdout.write("\x1b[?1049h\x1b[?25l\x1b[H\x1b[2J");
     stdout.write("\n");
     for (const line of lines) stdout.write(`  ${line}\n`);
-    stdout.write(`\n  ${c.dim("any key to go back")}\n`);
+    stdout.write(`\n  ${c.dim(footer)}\n`);
     stdin.setRawMode(true);
     stdin.resume();
+    let key = "";
     await new Promise<void>((resolve) => {
       const once = (chunk: Buffer) => {
-        if (chunk.toString().includes("\x03")) process.exit(130);
+        const s = chunk.toString();
+        if (s.includes("\x03")) process.exit(130);
+        key = s;
         stdin.off("data", once);
         resolve();
       };
@@ -119,6 +196,7 @@ export async function dashboard(
     stdin.setRawMode(false);
     stdin.pause();
     stdout.write("\x1b[?25h\x1b[?1049l");
+    return key;
   }
 
   // ---------------------------------------------------------------- views
@@ -338,17 +416,84 @@ export async function dashboard(
       }
     }
     for (;;) {
-      const { index } = await pick(from ? `Backlog — ${label(from)}` : "Backlog — open items",
-        rows, "enter read · backspace back", (n) => full[n] === null);
+      const { index, key } = await pick(
+        from ? `Backlog — ${label(from)}` : "Backlog — open items",
+        rows,
+        "enter read · r run in agent · backspace back",
+        (n) => full[n] === null,
+        "rR",
+      );
       if (index === null) return;
       // Rows are cut to the window, so reading one means opening it.
       const it = full[index];
       if (!it) continue;
-      await report([
+      if (key === "r" || key === "R") {
+        await startBacklogItem(it, from ?? state!);
+        continue;
+      }
+      const k = await report([
         c.bold(it.where ?? "Backlog item"),
         it.severity ? c.dim(`  ${it.severity}`) : "",
         "",
         ...wrap(it.raw.replace(/`/g, ""), 2),
+      ], "r run in agent · any other key to go back");
+      if (k === "r" || k === "R") {
+        await startBacklogItem(it, from ?? state!);
+      }
+    }
+  }
+
+  async function startBacklogItem(it: Item, from: string) {
+    const projectDir = from === join(home, ".kaizen")
+      ? process.cwd()
+      : (from.endsWith(".kaizen") ? dirname(from) : from);
+    const agent = detectDefaultAgent(projectDir);
+    const agentBin = Bun.which(agent.cmd) ?? agent.cmd;
+    const prompt = it.where ? `/kaizen ${it.text} (${it.where})` : `/kaizen ${it.text}`;
+    const fullCmd = [agentBin, prompt];
+
+    const term = findTerminal(projectDir, fullCmd);
+    if (!term) {
+      await report([
+        c.bold("Could not open terminal"),
+        "",
+        c.dim("No supported terminal emulator found (xdg-terminal-exec, kitty, ghostty, alacritty, tmux)."),
+        "",
+        "Run manually:",
+        `  ${c.cyan(`cd "${projectDir}" && ${agent.cmd} "${prompt}"`)}`,
+      ]);
+      return;
+    }
+
+    try {
+      const proc = Bun.spawn(term.cmd, {
+        cwd: projectDir,
+        stdin: "ignore",
+        stdout: "ignore",
+        stderr: "ignore",
+        detached: term.detached,
+      });
+      if (term.detached) proc.unref();
+
+      await report([
+        c.bold("Started in new terminal"),
+        "",
+        `  ${c.cyan("Agent")}     ${agent.name} (${c.bold(agent.cmd)})`,
+        `  ${c.cyan("Project")}   ${tilde(projectDir)}`,
+        `  ${c.cyan("Task")}      ${it.text}`,
+        ...(it.where ? [`  ${c.cyan("File")}      ${it.where}`] : []),
+        ...(it.severity ? [`  ${c.cyan("Severity")}  ${it.severity}`] : []),
+        "",
+        c.dim(`Opened in new window running: ${agent.cmd} "${prompt}"`),
+      ]);
+    } catch (err: any) {
+      await report([
+        c.bold("Failed to spawn terminal"),
+        "",
+        c.dim(err?.message ?? String(err)),
+        "",
+        "Run manually:",
+        `  ${c.cyan(`cd "${projectDir}" && ${agent.cmd} "${prompt}"`)}`,
       ]);
     }
   }

package/cli/install.ts

@@ -267,8 +267,32 @@ async function anyKey() {
 
 const repo = await resolveRepo();
 const root = await chooseRoot();
+const presetChoice = await choosePreset();
 const targets = found(root);
 
+async function choosePreset(): Promise<PresetName> {
+  if (presetArg) return presetArg;
+  if (!interactive) return "medium";
+
+  return select("Choose workflow preset", [
+    {
+      label: "Medium (Recommended)",
+      hint: "balanced — subagents, plan approval, auto-fix high/critical",
+      value: "medium",
+    },
+    {
+      label: "Low",
+      hint: "inline & manual — lite runner, inline builder, manual approvals, no auto-fix",
+      value: "low",
+    },
+    {
+      label: "Ultra",
+      hint: "autonomous — subagents, auto mode, auto-fix all findings (up to 4 rounds)",
+      value: "ultra",
+    },
+  ]);
+}
+
 // ---------------------------------------------------------------- repo
 
 // Settings only needs the clone's default config, not a pull.
@@ -411,40 +435,15 @@ const inProject = process.cwd() !== home;
 const kaizenDir = join(process.cwd(), ".kaizen");
 const globalKaizen = join(home, ".kaizen");
 const globalConfig = join(globalKaizen, "config.yml");
-const hasConfig = (args.has("onboard") || args.has("--onboard"))
-  ? false
-  : (inProject ? existsSync(localConfig) : existsSync(globalConfig));
-
-let presetChoice: PresetName | null = presetArg;
-if (!hasConfig && !presetChoice && interactive) {
-  presetChoice = await select("Choose workflow preset", [
-    {
-      label: "Medium (Recommended)",
-      hint: "balanced — subagents, plan approval, auto-fix high/critical",
-      value: "medium",
-    },
-    {
-      label: "Low",
-      hint: "inline & manual — lite runner, inline builder, manual approvals, no auto-fix",
-      value: "low",
-    },
-    {
-      label: "Ultra",
-      hint: "autonomous — subagents, auto mode, auto-fix all findings (up to 4 rounds)",
-      value: "ultra",
-    },
-  ]);
-}
 
-if ((!existsSync(globalConfig) && presetChoice) || (presetArg && !args.has("--project"))) {
+if (!args.has("--project")) {
   mkdirSync(globalKaizen, { recursive: true });
   const defPath = join(repo, "skills/kaizen/config.default.yml");
   const def = readFileSync(defPath, "utf8");
   const base = existsSync(globalConfig) ? readFileSync(globalConfig, "utf8") : def;
-  const target = presetChoice ?? "medium";
-  const conf = applyPreset(base, target, def);
+  const conf = applyPreset(base, presetChoice, def);
   writeFileSync(globalConfig, conf);
-  step(`configured ${c.bold(target)} preset in ${tilde(globalConfig)}`);
+  step(`configured ${c.bold(presetChoice)} preset in ${tilde(globalConfig)}`);
 }
 
 // A .kaizen/ in a parent already owns this folder's state, and setting up a child

package/cli/settings.ts

@@ -109,6 +109,7 @@ const SETTINGS: Setting[] = [
   { key: "state.keep_runs", values: ["5", "10", "20", "50"], help: "Completed runs kept before the oldest is pruned" },
   { key: "git.auto_commit", values: ["false", "true"], help: "Commit the work when a run finishes" },
   { key: "git.branch_before_implement", values: ["true", "false"], help: "Branch before building when on the default branch" },
+  { key: "agent.default", values: ["auto", "claude", "codex", "agy", "opencode", "gemini"], help: "Default coding agent to launch from dashboard backlog" },
 ];
 
 const c = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kaizen-agent",
-  "version": "0.7.3",
+  "version": "1.0.0",
   "description": "Staged workflow for AI agents \u2014 code, writing, research, operations: plan, human approval, build, independent review, bounded fix loop.",
   "type": "module",
   "bin": {

package/skills/kaizen/SKILL.md

@@ -94,6 +94,7 @@ whichever the user picks.
 | `review.write_memory` | `true`, `false` | Let the reviewer append lessons to `memory.md` |
 | `git.auto_commit` | `true`, `false` | Commit the work when a run finishes |
 | `git.branch_before_implement` | `true`, `false` | Branch before building when on the default branch |
+| `agent.default` | `auto`, `claude`, `codex`, `agy`, `opencode`, `gemini` | Coding agent to launch from dashboard backlog |
 
 Rules for writing the file:
 

package/skills/kaizen/config.default.yml

@@ -128,3 +128,9 @@ git:
   # Create a branch before the implement stage when on the default branch.
   # Ignored when the project is not a git repository.
   branch_before_implement: true
+
+agent:
+  # Default coding agent to launch from dashboard backlog (auto | claude | codex | agy | opencode | gemini).
+  # auto picks Claude Code if installed, otherwise the first agent found on PATH.
+  default: auto
+

package/skills/kaizen-help/SKILL.md

@@ -94,6 +94,7 @@ Each iteration is written to `runs/<id>/05-iterations/`.
 | `state.keep_runs` | `20` | Completed runs kept before pruning oldest (rescues open backlog first) |
 | `git.auto_commit` | `false` | Never commit/push/PR unless the user explicitly asks |
 | `git.branch_before_implement` | `true` | Branch before implement stage when on the default branch |
+| `agent.default` | `auto` | Coding agent to launch from dashboard backlog |
 
 `.kaizen/config.yml` overrides only the keys it sets; everything else falls back to
 this skill's `config.default.yml`.