kaizen-agent 1.2.2 → 1.3.1

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

@@ -208,7 +208,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

@@ -2,10 +2,11 @@
 import {
   symlinkSync, mkdirSync, readdirSync, lstatSync, readlinkSync, unlinkSync,
   existsSync, copyFileSync, readFileSync, appendFileSync, rmSync, writeFileSync,
+  statSync, cpSync,
 } from "node:fs";
 import { join, dirname, basename } from "node:path";
-import { homedir } from "node:os";
-import { applyPreset, detectPreset, PRESETS, type PresetName } from "./settings.ts";
+import { homedir, tmpdir } from "node:os";
+import { applyPreset, PRESETS, type PresetName } from "./settings.ts";
 
 const home = homedir();
 const REPO_URL = "https://github.com/hfadhlullah/kaizen.git";
@@ -319,8 +320,18 @@ async function resolveRepo() {
     }
     return dest;
   }
-  step(`cloning into ${tilde(dest)}`);
-  await Bun.$`git clone --quiet ${REPO_URL} ${dest}`;
+  if (Bun.which("git")) {
+    step(`cloning into ${tilde(dest)}`);
+    await Bun.$`git clone --quiet ${REPO_URL} ${dest}`;
+    return dest;
+  }
+  // No git: the bunx download already holds everything a clone would, so copy it
+  // in place. Upgrades then come from re-running bunx rather than a pull.
+  step(`copying into ${tilde(dest)} ${c.dim("(no git)")}`);
+  cpSync(here, dest, {
+    recursive: true, dereference: true,
+    filter: (src) => basename(src) !== "node_modules",
+  });
   return dest;
 }
 
@@ -356,10 +367,30 @@ const links = targets.flatMap((a) => [
   ] : []),
 ]);
 
+const isWindows = process.platform === "win32";
+
+// Windows only hands out file symlinks to an admin or a Developer Mode box, so
+// there the link is a directory junction (allowed for everyone) or, for a plain
+// file, a copy that is refreshed whenever the source moves ahead.
+function makeLink(src: string, dest: string) {
+  if (!isWindows) { symlinkSync(src, dest); return; }
+  if (statSync(src).isDirectory()) { symlinkSync(src, dest, "junction"); return; }
+  copyFileSync(src, dest);
+}
+
+function sameFile(a: string, b: string) {
+  try { return readFileSync(a).equals(readFileSync(b)); } catch { return false; }
+}
+
 function linkState(src: string, dest: string) {
   try {
     const st = lstatSync(dest);
-    if (!st.isSymbolicLink()) return "occupied";
+    if (!st.isSymbolicLink()) {
+      // A copied link on Windows is a real file; it is ours as long as it still
+      // matches the source, and stale once the source changes.
+      if (isWindows && st.isFile()) return sameFile(src, dest) ? "linked" : "stale";
+      return "occupied";
+    }
     return readlinkSync(dest) === src ? "linked" : "stale";
   } catch {
     return "missing";
@@ -385,8 +416,8 @@ for (const [src, sub] of links) {
     continue;
   }
   mkdirSync(dir, { recursive: true });
-  if (state !== "missing") unlinkSync(dest);
-  symlinkSync(src, dest);
+  if (state !== "missing") rmSync(dest, { recursive: true, force: true });
+  makeLink(src, dest);
   wrote++;
   if (verbose) console.log(c.dim(`  link  ${name}`));
 }
@@ -436,7 +467,9 @@ 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");
@@ -476,25 +509,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.
@@ -603,7 +630,7 @@ function clean(out: string) {
 // without re-resolving, so an upgrade that only pulls the clone still leaves the
 // next `bunx kaizen-agent` running whatever was cached the first time.
 async function clearBunxCache() {
-  const tmp = process.env.TMPDIR ?? "/tmp";
+  const tmp = process.env.TMPDIR ?? tmpdir();
   let removed = 0;
   try {
     for (const name of readdirSync(tmp)) {

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,7 +1,7 @@
 {
   "name": "kaizen-agent",
-  "version": "1.2.2",
-  "description": "Staged workflow for AI agents \u2014 code, writing, research, operations: plan, human approval, build, independent review, bounded fix loop.",
+  "version": "1.3.1",
+  "description": "Staged workflow for AI agents — code, writing, research, operations: plan, human approval, build, independent review, bounded fix loop.",
   "type": "module",
   "bin": {
     "kaizen-agent": "./cli/install.ts",

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,