kaizen-agent 1.3.0 → 1.3.2

package/README.md

@@ -463,7 +463,6 @@ Everything a run knows lives in files next to the work, not in a chat window:
 
 ```
 .kaizen/
-  config.yml            # how much it asks you, what it fixes on its own
   memory.md             # what past reviews learned about this project
   runs/2026-09-07-onboarding-email/
     00-request.md       # what you asked, word for word
@@ -480,7 +479,7 @@ in one can be finished in another. See [adapters.md](https://github.com/hfadhlul
 
 ## Settings
 
-`.kaizen/config.yml`, written when the project is set up. The three worth knowing:
+`~/.kaizen/config.yml` — one file, every project. The three worth knowing:
 
 | Setting | Default | Meaning |
 |---|---|---|
@@ -499,7 +498,7 @@ opens a full-screen browser over the whole file — arrows to move and change, e
 change written as you make it, esc to close:
 
 ```
-  kaizen settings   ~/Projects/app/.kaizen/config.yml
+  kaizen settings   ~/.kaizen/config.yml
 
   › preset                         medium
     mode                           approve
@@ -517,6 +516,8 @@ change written as you make it, esc to close:
   ↑↓ move · ←→ change · esc close     saved preset = medium
 ```
 
+One project can differ: put a `.kaizen/config.yml` in it with just the keys to
+override, and it wins there while everything else follows the global file.
 It edits each line in place, so the comment above every key survives. `/kaizen-config`
 does the same thing from inside your agent if you would rather not leave it. Everything is also
 in [`config.default.yml`](https://github.com/hfadhlullah/kaizen/blob/main/skills/kaizen/config.default.yml),

package/cli/dashboard.ts

@@ -140,8 +140,12 @@ function readMouse(rest: string): { ev: MouseEv; len: number } | null {
 const WHEEL_UP = 64, WHEEL_DOWN = 65;
 const isClick = (e: MouseEv) => e.press && e.button === 0;
 
+// Re-sent even when this module thinks it is already armed: settings runs as an
+// action, tracks arming with its own flag, and turns reporting off in the terminal
+// on the way out. Enabling twice costs nothing; trusting the stale flag costs the
+// mouse for the rest of the session.
 function mouseOn() {
-  if (!mouseWanted || mouseArmed) return;
+  if (!mouseWanted) return;
   process.stdout.write("\x1b[?1000h\x1b[?1006h");
   mouseArmed = true;
 }
@@ -208,7 +212,7 @@ export async function dashboard(
       { key: "backlog", label: "Backlog", hint: "what runs noticed and did not do" },
     ] : []),
     { key: "settings", label: "Settings", hint: "modes, approvals, who builds" },
-    ...(state && !existsSync(join(state, "config.yml"))
+    ...(state && !existsSync(join(state, "spec.md"))
       ? [{ key: "init", label: "Set up this project", hint: "write .kaizen/ here" }] : []),
     ...(!state ? [{ key: "init", label: "Set up this project", hint: "write .kaizen/ here" }] : []),
     { key: "upgrade", label: "Upgrade", hint: "pull, relink, clear the installer cache" },

package/cli/install.ts

@@ -271,9 +271,11 @@ const root = await chooseRoot();
 const presetChoice = await choosePreset();
 const targets = found(root);
 
-async function choosePreset(): Promise<PresetName> {
+// null means "leave the config alone": an upgrade or a --yes run never asked, and
+// answering "medium" for the user overwrote whatever preset they had chosen.
+async function choosePreset(): Promise<PresetName | null> {
   if (presetArg) return presetArg;
-  if (!interactive) return "medium";
+  if (!interactive) return null;
 
   return select("Choose workflow preset", [
     {
@@ -467,14 +469,22 @@ const kaizenDir = join(process.cwd(), ".kaizen");
 const globalKaizen = join(home, ".kaizen");
 const globalConfig = join(globalKaizen, "config.yml");
 
-if (!args.has("--project")) {
+// Always global: a project keeps no config of its own, so ~/.kaizen/config.yml is
+// what every project follows.
+{
   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)}`);
+  const existing = existsSync(globalConfig) ? readFileSync(globalConfig, "utf8") : null;
+  if (presetChoice) {
+    writeFileSync(globalConfig, applyPreset(existing ?? def, presetChoice, def));
+    step(`configured ${c.bold(presetChoice)} preset in ${tilde(globalConfig)}`);
+  } else if (!existing) {
+    writeFileSync(globalConfig, def);
+    step(`wrote ${tilde(globalConfig)}`);
+  } else {
+    step(`kept your settings in ${tilde(globalConfig)} ${c.dim(`(${detectPreset(existing, def)})`)}`);
+  }
 }
 
 // A .kaizen/ in a parent already owns this folder's state, and setting up a child
@@ -507,25 +517,19 @@ if (inProject && !kaizenAbove()) {
           { label: "Yes", hint: "writes .kaizen/ and a CLAUDE.md line so it runs by default", value: true },
         ])
       : false;
-  if (now) initProject(presetChoice);
+  if (now) initProject();
 } else if (existsSync(kaizenDir)) {
   step(`${basename(process.cwd())}/.kaizen already set up`);
 }
 
-function initProject(preset?: PresetName | null) {
+function initProject() {
   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));
   }
-  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);
+  // No config.yml here on purpose: a project without one follows
+  // ~/.kaizen/config.yml, so a setting changed once applies everywhere. Write one
+  // only to make this project deliberately different.
 
   // 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

@@ -256,11 +256,14 @@ export async function settings(repoRoot: string, standalone = true) {
   if (standalone) console.log(`  ${c.green("+")} settings saved to ${tilde(file)}\n`);
 }
 
-// The nearest .kaizen wins, exactly as the workflow resolves it.
+// The nearest .kaizen/config.yml wins, exactly as the workflow resolves it. A
+// project that has not written one of its own is edited globally, so one setting
+// changed in ~/.kaizen/config.yml reaches every project.
 function locate() {
   let dir = process.cwd();
   for (;;) {
-    if (existsSync(join(dir, ".kaizen"))) return join(dir, ".kaizen", "config.yml");
+    const conf = join(dir, ".kaizen", "config.yml");
+    if (existsSync(conf)) return conf;
     if (existsSync(join(dir, ".git"))) break;
     const up = dirname(dir);
     if (up === dir) break;

package/package.json

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

package/skills/kaizen/README.md

@@ -189,9 +189,11 @@ software or writing?"
 
 ## Configuration
 
-Defaults live in [`config.default.yml`](config.default.yml). Copy it to
-`.kaizen/config.yml` in a repository and override only the keys you care about;
-anything absent falls back to the defaults.
+Your settings live in `~/.kaizen/config.yml` and apply to every project — `/kaizen
+config` edits that file. To make one project different, copy
+[`config.default.yml`](config.default.yml) to `.kaizen/config.yml` there and override
+only the keys you care about; anything absent falls back to the global file, then to
+the defaults.
 
 | Key | Default | Change it when |
 |---|---|---|

package/skills/kaizen/SKILL.md

@@ -60,10 +60,12 @@ If the user typed `/kaizen` with no argument and a run is in progress, treat it
 1. Locate the state directory: `.kaizen/` in the project folder's root, else
    `~/.kaizen/` keyed by working directory. If neither exists and the user is starting
    work, run `/kaizen init` first: it creates `.kaizen/` with a copy of the `spec*.md`
-   files, a config, and — where the folder is a git repository — the gitignore entry
+   files and — where the folder is a git repository — the gitignore entry
    (see [`adapters.md`](adapters.md)).
-2. Read `.kaizen/config.yml`, falling back to `config.default.yml` in this skill for
-   any key it does not set. `runner` decides whether this run dispatches subagents at
+2. Read the config in this order, each file filling in the keys the one before it
+   does not set: `.kaizen/config.yml`, then `~/.kaizen/config.yml`, then
+   `config.default.yml` in this skill. A project usually has no `config.yml` of its
+   own, so the global one is what settings changes reach. `runner` decides whether this run dispatches subagents at
    all; read it before the first stage, not when you reach one.
 3. Read `.kaizen/runs/<current>/state.json` if a run is active. Never assume the
    stage from conversation memory — the run may have been advanced by another tool
@@ -73,11 +75,12 @@ If the user typed `/kaizen` with no argument and a run is in progress, treat it
 
 ## Settings
 
-`/kaizen config` reads `.kaizen/config.yml`, falling back to `config.default.yml` for
-anything it does not set, and prints the current value of each setting below with a
+`/kaizen config` reads the same chain — `.kaizen/config.yml`, then `~/.kaizen/config.yml`,
+then `config.default.yml` — and prints the current value of each setting below with a
 one-line meaning. Then it offers the settings as choices — the tool's structured
 question mechanism, one option per legal value, never free text — and writes back
-whichever the user picks.
+whichever the user picks. Write to whichever file in the chain already exists,
+nearest first, so a change lands globally unless this project keeps its own config.
 
 | Setting | Values | What it decides |
 |---|---|---|

package/skills/kaizen/adapters.md

@@ -24,7 +24,7 @@ Codex reads `AGENTS.md` from the repository root. Append:
 
 Non-trivial work in this repo follows the staged workflow in
 `.kaizen/spec.md`: plan, human approval, implement, independent review, bounded
-fix loop. Read that file before starting, and read `.kaizen/config.yml` for the
+fix loop. Read that file before starting, and read the config chain (`.kaizen/config.yml`, `~/.kaizen/config.yml`, `config.default.yml`) for the
 mode and approval settings.
 
 Run state lives in `.kaizen/runs/<id>/`. Always read `state.json` first and
@@ -38,7 +38,7 @@ from its stage file, and write its artifact before moving on. When reviewing, ju
 diff on its own terms rather than defending the reasoning you used while writing it.
 ```
 
-Copy `spec*.md` and `config.yml` into `.kaizen/` so the reference resolves
+Copy `spec*.md` into `.kaizen/` so the reference resolves
 without this skill installed.
 
 ## Antigravity
@@ -64,7 +64,7 @@ completes. A stale `state.json` is the one way this breaks.
 
 ## Installing the adapter files
 
-`/kaizen init` writes `.kaizen/` with the `spec*.md` files and `config.yml` into the
+`/kaizen init` writes `.kaizen/` with the `spec*.md` files into the
 project folder, plus the gitignore entry when that folder is a git repository.
 `/kaizen install` additionally offers to append the `AGENTS.md` block above.
 `.kaizen/spec*.md` and `.kaizen/config.yml` should be committed even though run state

package/skills/kaizen/config.default.yml

@@ -1,5 +1,7 @@
-# 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.
+# Kaizen defaults. Settings live in ~/.kaizen/config.yml and apply to every project.
+# To make one project different, copy this to .kaizen/config.yml there and override
+# only the keys you care about; anything absent falls back to the global file, then
+# to this one.
 
 # Quick preset: low | medium | ultra | custom
 # Selecting low, medium, or ultra applies its bundled defaults for runner, executor,