kaizen-agent 0.7.2 → 0.7.4

package/README.md

@@ -252,28 +252,37 @@ The stage agents and slash commands are Claude Code's own formats and are not co
 elsewhere; under the others you invoke the skill by name. `.kaizen/` is plain files
 either way, so a run started in one tool can be finished in another.
 
-Once installed, `kaizen` on its own opens a dashboard rather than installing again:
+Run `kaizen` anytime to open the terminal dashboard:
 
 ```
-  kaizen 0.5.0   ~/Projects/app
-
-  Runs
-    ● 2026-09-07-fix-discount  waiting on you — approvals.plan
-    ● 2026-09-06-cache-headers  in flight — review
-    ● 3 done
-
-  Backlog   4 open
-
-  Installed for   Claude Code, Codex, Antigravity
-
-  › Settings            modes, approvals, who builds
+  ⠀⠀⠀⣰⠖⠾⣟⣛⠋⢉⣩⠽⢛⡽⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+  ⠀⠀⢰⢻⠀⠀⢀⡬⠟⠉⢀⠴⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
+  ⠀⢠⠇⣾⡠⠞⢩⠤⢄⡚⣁⣀⣀⣀⢀⣠⠤⡄⠀⠀⠀⠀⠀⠀    █ █  ▄▀█  █  ▀▀█  █▀▀  █▄ █
+  ⢠⣏⠔⣫⣀⡤⢸⠀⠀⠉⠁⠀⠀⠈⠉⠀⠀⡇⠀⠀⠀⠀⠀⠀    █▀▄  █▀█  █   ▄▀  ██▄  █ ▀█
+  ⢾⠥⢾⡅⢧⠀⢸⠃⡤⠖⠢⡀⢀⠔⠲⢤⠘⡇⠀⠀⣀⣀⠀⠀    █ █  █ █  █  █▄▄  █▄▄  █  █
+  ⠀⠀⠈⣇⠈⢠⣫⠞⠀⠘⢱⢣⡜⡎⠃⠀⠳⣝⡄⢠⠇⢻⢉⣷
+  ⠀⠀⠀⠘⢆⠀⠑⢦⣀⡀⠈⠓⠚⠁⢀⣀⣤⣊⣠⢾⡀⢠⣿⠃    0.7.2   plan · approve · build · review
+  ⠀⠀⠀⠀⠈⠓⢄⠀⠀⠉⣉⣭⣭⣉⠉⠀⠈⢀⣠⢔⡩⠥⢥⡀    ~/Projects/app
+  ⠀⠀⠀⠀⠀⠀⢠⡇⠀⡞⠁⠀⠀⠈⢳⠀⢰⣍⣠⠚⠧⡀⠀⡷    Claude Code, Codex, Antigravity, OpenCode, Gemini CLI
+  ⠀⠀⠀⠀⠀⠀⠸⡇⠀⣇⠀⠀⠀⠀⣸⠀⢠⡏⠀⠀⢀⣳⠞⠁
+  ⠀⠀⠀⠀⠀⠀⠀⠳⣀⣨⠥⠤⠶⠾⣅⣀⠞⠉⠉⠉⠉⠀⠀⠀
+
+  ╭─ Runs ──────────────────────────────────╮ ╭─ Backlog — 4 open ──────────────────────────╮
+  │ ● fix-discount       waiting on you     │ │ cart.py:12    low   use > not >=            │
+  │ ● cache-headers      in review          │ │ headline      med   legal review            │
+  │ ● 3 done                                │ │ … 2 more                                    │
+  ╰─────────────────────────────────────────╯ ╰─────────────────────────────────────────────╯
+
+  › All projects        every project kaizen knows about
+    Runs
+    Backlog
+    Settings
     Upgrade
     Quit
 ```
 
-It reads the project you are standing in, so it answers "what is this repo waiting on
-me for" without opening an agent. Installing also puts that `kaizen` command on your
-PATH, so updating later is:
+It monitors your runs and backlog across all your projects without having to open an agent.
+Installing puts the `kaizen` command on your PATH, so updating later is:
 
 ```bash
 kaizen upgrade
@@ -408,17 +417,20 @@ change written as you make it, esc to close:
 ```
   kaizen settings   ~/Projects/app/.kaizen/config.yml
 
+  › preset                         medium
     mode                           approve
-  › build.executor                 inline
+    runner                         full
+    build.executor                 subagent
     approvals.plan                 true
     approvals.review               false
+    auto_fix.enabled               true
     auto_fix.min_severity          high
     auto_fix.max_iterations        2
     ...
 
-  Who carries out the approved plan
+  Quick preset — low: inline & manual, medium: balanced, ultra: autonomous subagents
 
-  ↑↓ move · ←→ change · esc close     saved build.executor = inline
+  ↑↓ move · ←→ change · esc close     saved preset = medium
 ```
 
 It edits each line in place, so the comment above every key survives. `/kaizen-config`
@@ -442,6 +454,7 @@ with a comment on each key, if you would rather edit the file.
 | `--project` | Into the current directory only |
 | `--check` | Report what is linked, exit non-zero if anything is missing |
 | `--force` | Replace a real file sitting where a link belongs |
+| `--preset <name>` | Pre-select workflow preset (`low`, `medium`, or `ultra`) |
 | `--yes` | Take every default, ask nothing |
 | `--verbose` | List every link instead of a one-line summary |
 | `upgrade` | Pull, relink, and clear the installer cache. No prompts. |

package/cli/install.ts

@@ -5,6 +5,7 @@ import {
 } from "node:fs";
 import { join, dirname, basename } from "node:path";
 import { homedir } from "node:os";
+import { applyPreset, detectPreset, PRESETS, type PresetName } from "./settings.ts";
 
 const home = homedir();
 const REPO_URL = "https://github.com/hfadhlullah/kaizen.git";
@@ -16,6 +17,22 @@ const force = args.has("--force");
 const verbose = args.has("--verbose");
 const interactive = process.stdin.isTTY && !check && !upgrade && !args.has("--yes");
 
+function parsePresetArg(): PresetName | null {
+  for (const a of Bun.argv.slice(2)) {
+    if (a.startsWith("--preset=")) {
+      const v = a.split("=")[1]?.toLowerCase();
+      if (v === "low" || v === "medium" || v === "ultra") return v as PresetName;
+    }
+  }
+  const idx = Bun.argv.indexOf("--preset");
+  if (idx !== -1 && Bun.argv[idx + 1]) {
+    const v = Bun.argv[idx + 1]?.toLowerCase();
+    if (v === "low" || v === "medium" || v === "ultra") return v as PresetName;
+  }
+  return null;
+}
+const presetArg = parsePresetArg();
+
 const c = {
   dim: (s: string) => `\x1b[2m${s}\x1b[0m`,
   bold: (s: string) => `\x1b[1m${s}\x1b[0m`,
@@ -250,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.
@@ -392,6 +433,18 @@ function installLauncher() {
 
 const inProject = process.cwd() !== home;
 const kaizenDir = join(process.cwd(), ".kaizen");
+const globalKaizen = join(home, ".kaizen");
+const globalConfig = join(globalKaizen, "config.yml");
+
+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 conf = applyPreset(base, presetChoice, def);
+  writeFileSync(globalConfig, conf);
+  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
 // would shadow it, hiding the parent's runs and leaving the child out of the root
@@ -413,25 +466,35 @@ function kaizenAbove() {
 }
 
 if (inProject && !kaizenAbove()) {
-  const now = interactive
-    ? await select(`Set up ${basename(process.cwd())}/ for kaizen now`, [
-        // "Not now" leads: the offer now appears in any folder outside home, so the
-        // safe answer is the one under the cursor.
-        { label: "Not now", hint: "the first /kaizen run will do it", value: false },
-        { label: "Yes", hint: "writes .kaizen/ and a CLAUDE.md line so it runs by default", value: true },
-      ])
-    : false;
-  if (now) initProject();
+  const now = root === process.cwd()
+    ? true
+    : interactive
+      ? await select(`Set up ${basename(process.cwd())}/ for kaizen now`, [
+          // "Not now" leads: the offer now appears in any folder outside home, so the
+          // safe answer is the one under the cursor.
+          { label: "Not now", hint: "the first /kaizen run will do it", value: false },
+          { label: "Yes", hint: "writes .kaizen/ and a CLAUDE.md line so it runs by default", value: true },
+        ])
+      : false;
+  if (now) initProject(presetChoice);
 } else if (existsSync(kaizenDir)) {
   step(`${basename(process.cwd())}/.kaizen already set up`);
 }
 
-function initProject() {
+function initProject(preset?: PresetName | null) {
   mkdirSync(kaizenDir, { recursive: true });
   for (const f of readdirSync(join(repo, "skills/kaizen")).filter((f) => f.startsWith("spec"))) {
     copyFileSync(join(repo, "skills/kaizen", f), join(kaizenDir, f));
   }
-  copyFileSync(join(repo, "skills/kaizen/config.default.yml"), join(kaizenDir, "config.yml"));
+  const defPath = join(repo, "skills/kaizen/config.default.yml");
+  const def = readFileSync(defPath, "utf8");
+  let chosen: PresetName = preset ?? "medium";
+  if (!preset && existsSync(globalConfig)) {
+    const detected = detectPreset(readFileSync(globalConfig, "utf8"), def);
+    if (detected !== "custom") chosen = detected;
+  }
+  const configContent = applyPreset(def, chosen, def);
+  writeFileSync(join(kaizenDir, "config.yml"), configContent);
 
   // Run state is local; the workflow itself is shared, so those files stay tracked.
   // Nothing to ignore where there is no git, so a plain folder gets no .gitignore.

package/cli/settings.ts

@@ -6,7 +6,94 @@ import { homedir } from "node:os";
 
 type Setting = { key: string; values: string[]; help: string };
 
+export type PresetName = "low" | "medium" | "ultra";
+
+export const PRESETS: Record<PresetName, {
+  label: string;
+  hint: string;
+  settings: Record<string, string>;
+}> = {
+  low: {
+    label: "Low",
+    hint: "inline & manual — lite runner, inline builder, manual approvals, no auto-fix",
+    settings: {
+      mode: "approve",
+      runner: "lite",
+      "build.executor": "inline",
+      "approvals.plan": "true",
+      "approvals.review": "true",
+      "approvals.each_file": "false",
+      "auto_fix.enabled": "false",
+      "auto_fix.min_severity": "high",
+      "auto_fix.max_iterations": "1",
+      "git.auto_commit": "false",
+      "git.branch_before_implement": "false",
+    },
+  },
+  medium: {
+    label: "Medium",
+    hint: "balanced (recommended) — full runner, subagents, plan approval, auto-fix high/critical",
+    settings: {
+      mode: "approve",
+      runner: "full",
+      "build.executor": "subagent",
+      "approvals.plan": "true",
+      "approvals.review": "false",
+      "approvals.each_file": "false",
+      "auto_fix.enabled": "true",
+      "auto_fix.min_severity": "high",
+      "auto_fix.max_iterations": "2",
+      "git.auto_commit": "false",
+      "git.branch_before_implement": "true",
+    },
+  },
+  ultra: {
+    label: "Ultra",
+    hint: "autonomous — full runner, subagents, auto mode, auto-fix all findings (up to 4 rounds)",
+    settings: {
+      mode: "auto",
+      runner: "full",
+      "build.executor": "subagent",
+      "approvals.plan": "false",
+      "approvals.review": "false",
+      "approvals.each_file": "false",
+      "auto_fix.enabled": "true",
+      "auto_fix.min_severity": "low",
+      "auto_fix.max_iterations": "4",
+      "git.auto_commit": "true",
+      "git.branch_before_implement": "true",
+    },
+  },
+};
+
+export function detectPreset(text: string, defaults?: string): PresetName | "custom" {
+  for (const name of ["low", "medium", "ultra"] as const) {
+    const p = PRESETS[name];
+    let match = true;
+    for (const [k, expected] of Object.entries(p.settings)) {
+      const actual = read(text, k) ?? (defaults ? read(defaults, k) : null);
+      if (actual !== expected) {
+        match = false;
+        break;
+      }
+    }
+    if (match) return name;
+  }
+  return "custom";
+}
+
+export function applyPreset(text: string, preset: PresetName, defaults: string): string {
+  let updated = text;
+  const p = PRESETS[preset];
+  for (const [k, v] of Object.entries(p.settings)) {
+    updated = write(updated, k, v, defaults);
+  }
+  updated = write(updated, "preset", preset, defaults);
+  return updated;
+}
+
 const SETTINGS: Setting[] = [
+  { key: "preset", values: ["low", "medium", "ultra", "custom"], help: "Quick preset — low: inline & manual, medium: balanced, ultra: autonomous subagents" },
   { key: "mode", values: ["approve", "auto", "plan-only", "review-only"], help: "Where a run stops" },
   { key: "runner", values: ["full", "lite"], help: "full: every stage its own cold agent. lite: this session runs them all, cheaper, reviewer has seen the work" },
   { key: "build.executor", values: ["subagent", "inline", "ask"], help: "Who carries out the approved plan" },
@@ -42,10 +129,15 @@ export async function settings(repoRoot: string, standalone = true) {
   const { stdin, stdout } = process;
   if (!stdin.isTTY) { console.log(`Settings live in ${file}`); return; }
 
+  const defaults = readFileSync(join(repoRoot, "skills/kaizen/config.default.yml"), "utf8");
   let active = 0, saved = "";
   const draw = () => {
     const text = readFileSync(file, "utf8");
-    const rows = SETTINGS.map((s) => ({ s, value: read(text, s.key) ?? c.dim("(default)") }));
+    const currentPreset = detectPreset(text, defaults);
+    const rows = SETTINGS.map((s) => ({
+      s,
+      value: s.key === "preset" ? currentPreset : (read(text, s.key) ?? c.dim("(default)")),
+    }));
     const width = Math.max(...SETTINGS.map((s) => s.key.length)) + 4;
 
     stdout.write("\x1b[H\x1b[2J");           // home, clear
@@ -84,16 +176,28 @@ export async function settings(repoRoot: string, standalone = true) {
           const step = rest.startsWith("\x1b[D") ? -1 : 1;
           const s = SETTINGS[active]!;
           const text = readFileSync(file, "utf8");
-          const now = read(text, s.key) ?? s.values[0]!;
-          const at = s.values.indexOf(now);
-          const next = s.values[((at < 0 ? 0 : at) + step + s.values.length) % s.values.length]!;
-          const updated = write(text, s.key, next, readFileSync(join(repoRoot, "skills/kaizen/config.default.yml"), "utf8"));
-          writeFileSync(file, updated);
-          // Only claim a save that happened. Reporting one that did not is worse
-          // than failing loudly: the setting reads back unchanged and nobody knows why.
-          saved = read(updated, s.key) === next
-            ? c.green(`saved ${s.key} = ${next || '""'}`)
-            : `\x1b[33mcould not write ${s.key}\x1b[0m`;
+          if (s.key === "preset") {
+            const current = detectPreset(text, defaults);
+            const cycle: PresetName[] = ["low", "medium", "ultra"];
+            const at = cycle.indexOf(current as PresetName);
+            const next = cycle[((at < 0 ? 0 : at) + step + cycle.length) % cycle.length]!;
+            const updated = applyPreset(text, next, defaults);
+            writeFileSync(file, updated);
+            saved = c.green(`applied preset: ${next}`);
+          } else {
+            const now = read(text, s.key) ?? s.values[0]!;
+            const at = s.values.indexOf(now);
+            const next = s.values[((at < 0 ? 0 : at) + step + s.values.length) % s.values.length]!;
+            let updated = write(text, s.key, next, defaults);
+            const detected = detectPreset(updated, defaults);
+            updated = write(updated, "preset", detected, defaults);
+            writeFileSync(file, updated);
+            // Only claim a save that happened. Reporting one that did not is worse
+            // than failing loudly: the setting reads back unchanged and nobody knows why.
+            saved = read(updated, s.key) === next
+              ? c.green(`saved ${s.key} = ${next || '""'} (preset: ${detected})`)
+              : `\x1b[33mcould not write ${s.key}\x1b[0m`;
+          }
           if (!rest.startsWith("\r")) i += 2;
         } else if (rest.startsWith("k")) active = (active - 1 + SETTINGS.length) % SETTINGS.length;
         else if (rest.startsWith("j")) active = (active + 1) % SETTINGS.length;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kaizen-agent",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "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

@@ -81,6 +81,7 @@ whichever the user picks.
 
 | Setting | Values | What it decides |
 |---|---|---|
+| `preset` | `low`, `medium`, `ultra` | Quick preset: low (inline/manual), medium (balanced), ultra (autonomous) |
 | `mode` | `approve`, `auto`, `plan-only`, `review-only` | Where a run stops |
 | `runner` | `full`, `lite` | Whether each stage is its own cold agent, or this session runs them all |
 | `build.executor` | `subagent`, `inline`, `ask` | Who carries out the approved plan |

package/skills/kaizen/config.default.yml

@@ -1,6 +1,11 @@
 # Kaizen defaults. Copy to .kaizen/config.yml in a repository and override only the
 # keys you care about; anything absent falls back to this file.
 
+# Quick preset: low | medium | ultra | custom
+# Selecting low, medium, or ultra applies its bundled defaults for runner, executor,
+# approvals, and auto-fix. Modifying individual keys sets this to custom.
+preset: medium
+
 # plan-only | approve | auto | review-only
 mode: approve
 

package/skills/kaizen-help/SKILL.md

@@ -75,6 +75,7 @@ Each iteration is written to `runs/<id>/05-iterations/`.
 
 | Key | Default | Meaning |
 |---|---|---|
+| `preset` | `medium` | Quick preset (`low`, `medium`, `ultra`, `custom`) |
 | `mode` | `approve` | Default run mode |
 | `runner` | `full` | `full`: each stage a cold subagent. `lite`: this session runs every stage |
 | `approvals.plan` | `true` | Stop after the plan |