kaizen-agent 0.6.0 → 0.7.0

package/cli/install.ts

@@ -287,10 +287,10 @@ async function chooseRoot() {
   if (args.has("--project")) return process.cwd();
   if (args.has("--global") || !interactive) return home;
   // A project install only means something in a project. Standing in the home
-  // directory it is the global install under another name, and outside a
-  // repository there is nothing for it to belong to.
+  // directory it is the global install under another name; any other folder is
+  // a project worth installing into, git repository or not.
   const cwd = process.cwd();
-  if (cwd === home || !existsSync(join(cwd, ".git"))) return home;
+  if (cwd === home) return home;
 
   const names = (r: string) => found(r).map((a) => a.name).join(", ");
   return select("Install kaizen for", [
@@ -390,22 +390,43 @@ function installLauncher() {
   }
 }
 
-const inGitRepo = existsSync(join(process.cwd(), ".git"));
+const inProject = process.cwd() !== home;
 const kaizenDir = join(process.cwd(), ".kaizen");
 
-if (inGitRepo && !existsSync(kaizenDir)) {
+// 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
+// .gitignore. Deliberately not shared with cli/dashboard.ts locate(): that one
+// resolves which state directory to read and so falls back to a global ~/.kaizen,
+// while this one decides whether a folder is already owned and must stop *before*
+// $HOME — a global ~/.kaizen would otherwise suppress the setup offer for every
+// non-repo folder under the home directory. Do not re-sync the two walks.
+function kaizenAbove() {
+  let dir = process.cwd();
+  for (;;) {
+    if (dir === home) return false;
+    if (existsSync(join(dir, ".kaizen"))) return true;
+    if (existsSync(join(dir, ".git"))) return false;
+    const up = dirname(dir);
+    if (up === dir) return false;
+    dir = up;
+  }
+}
+
+if (inProject && !kaizenAbove()) {
   const now = interactive
     ? await select(`Set up ${basename(process.cwd())}/ for kaizen now`, [
-        { label: "Yes", hint: "writes .kaizen/ and a CLAUDE.md line so it runs by default", value: true },
+        // "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) initRepo();
+  if (now) initProject();
 } else if (existsSync(kaizenDir)) {
   step(`${basename(process.cwd())}/.kaizen already set up`);
 }
 
-function initRepo() {
+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));
@@ -413,13 +434,18 @@ function initRepo() {
   copyFileSync(join(repo, "skills/kaizen/config.default.yml"), join(kaizenDir, "config.yml"));
 
   // Run state is local; the workflow itself is shared, so those files stay tracked.
-  const rules = ".kaizen/*\n!.kaizen/spec*.md\n!.kaizen/config.yml\n";
-  const gi = join(process.cwd(), ".gitignore");
-  const current = existsSync(gi) ? readFileSync(gi, "utf8") : "";
-  if (!current.includes(".kaizen/*")) {
-    appendFileSync(gi, (current && !current.endsWith("\n") ? "\n" : "") + "\n# kaizen run state\n" + rules);
+  // Nothing to ignore where there is no git, so a plain folder gets no .gitignore.
+  let ignored = false;
+  if (existsSync(join(process.cwd(), ".git"))) {
+    const rules = ".kaizen/*\n!.kaizen/spec*.md\n!.kaizen/config.yml\n";
+    const gi = join(process.cwd(), ".gitignore");
+    const current = existsSync(gi) ? readFileSync(gi, "utf8") : "";
+    if (!current.includes(".kaizen/*")) {
+      appendFileSync(gi, (current && !current.endsWith("\n") ? "\n" : "") + "\n# kaizen run state\n" + rules);
+      ignored = true;
+    }
   }
-  step("wrote .kaizen/ and the gitignore entry");
+  step(ignored ? "wrote .kaizen/ and the gitignore entry" : "wrote .kaizen/");
   writePointer();
 }
 

package/commands/kaizen-init.md

@@ -1,5 +1,5 @@
 ---
-description: Install .kaizen/ (spec, config, gitignore entry) into the current repository
+description: Set up this project folder for kaizen (spec, config, and a gitignore entry when it is a git repo)
 ---
 
 Invoke the `kaizen` skill with argument `init`.

package/package.json

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

@@ -47,7 +47,7 @@ Porting the workflow to Codex or Antigravity is covered in [`adapters.md`](adapt
 | `/kaizen reject <reason>` | Reject it; the reason is fed back to the stage that produced it |
 | `/kaizen abort` | Mark the current run abandoned |
 | `/kaizen config` | Show this project's settings and change them, one picker per setting |
-| `/kaizen init` | Install `.kaizen/` with the `spec*.md` files, config, and the gitignore entry into the current repository |
+| `/kaizen init` | Set up this project folder: `.kaizen/` with the `spec*.md` files, config, and — in a git repo — the gitignore entry |
 | `/kaizen install` | Install the workflow itself globally or per-project (see below) |
 
 If the user typed `/kaizen` with no argument and a run is in progress, treat it as
@@ -55,10 +55,11 @@ If the user typed `/kaizen` with no argument and a run is in progress, treat it
 
 ## Before doing anything
 
-1. Locate the state directory: `.kaizen/` in the repository 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
-   the gitignore entry (see [`adapters.md`](adapters.md)).
+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
+   (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.
 3. Read `.kaizen/runs/<current>/state.json` if a run is active. Never assume the
@@ -293,9 +294,11 @@ shown automatically.
 }
 ```
 
-`init` adds a gitignore entry that ignores run state but keeps the workflow: it
-ignores `.kaizen/*` and un-ignores `.kaizen/spec*.md` and `.kaizen/config.yml`, which
-are meant to be committed (see [`adapters.md`](adapters.md)).
+In a git repository, `init` also adds a gitignore entry that ignores run state but
+keeps the workflow: it ignores `.kaizen/*` and un-ignores `.kaizen/spec*.md` and
+`.kaizen/config.yml`, which are meant to be committed (see
+[`adapters.md`](adapters.md)). A project folder that is not a repository gets no
+gitignore.
 
 ## Install
 

package/skills/kaizen/adapters.md

@@ -64,8 +64,9 @@ completes. A stale `state.json` is the one way this breaks.
 
 ## Installing the adapter files
 
-`/kaizen init` writes `.kaizen/` with the `spec*.md` files, `config.yml`, and the gitignore
-entry. `/kaizen install` additionally offers to append the `AGENTS.md` block above.
+`/kaizen init` writes `.kaizen/` with the `spec*.md` files and `config.yml` 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
 is ignored — the workflow is shared, the run data is not:
 

package/skills/kaizen/config.default.yml

@@ -55,12 +55,27 @@ review:
   # Additional checks per track, chosen by what the run actually is. The planner may
   # name a track not listed here; the reviewer then derives its checks from the
   # track's "what would make it wrong".
+  # Each check below is one question the reviewer asks; the line beside it says which.
   track_checks:
+    # security - no new way in, no secret or user data exposed
+    # reuse_simplification - nothing rebuilt that the codebase already had
+    # test_coverage - the changed behaviour has a check that fails when it breaks
     software: [security, reuse_simplification, test_coverage]
     # blast_radius and regression are universal — see spec-review.md — not listed here.
+    # completeness - every part the piece promises is actually present
+    # claim_accuracy - every checkable claim traced to a source
+    # reader_usability - its intended reader can act on it without asking
     writing: [completeness, claim_accuracy, reader_usability]
+    # audience_fit - written for the people who will actually read it
+    # voice_consistency - reads as the same voice as the surrounding material
     communication: [claim_accuracy, audience_fit, voice_consistency]
+    # prerequisites - everything needed before step one is stated
+    # rollback - a way back exists for every step that changes something
+    # executability - someone else can run it start to finish unaided
     operations: [prerequisites, rollback, executability]
+    # evidence_support - the conclusion follows from evidence shown, not asserted
+    # selection_bias - the evidence was not picked to fit the answer
+    # alternatives - the readings that were rejected are named and why
     research: [evidence_support, selection_bias, alternatives]
   # Let the reviewer append durable lessons to .kaizen/memory.md.
   write_memory: true
@@ -90,6 +105,8 @@ state:
 
 git:
   # Never commit, push, or open a PR unless the user explicitly asks.
+  # Ignored when the project is not a git repository.
   auto_commit: false
   # 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

package/skills/kaizen/spec-build.md

@@ -35,6 +35,9 @@ Rules:
   abstraction, a new file, a new section — is allowed, and costs one written line
   saying what it serves. The line is the price of the technique, not a request for
   permission. No line means the reviewer records a finding.
+- The `git.*` settings apply only where the work sits in a git repository. In a plain
+  folder there is no branch to make and no commit to skip, and that absence is not a
+  finding.
 
 **Baseline first, in any track with an existing suite of checks.** Before changing
 anything, run whatever already proves the existing material correct — the test suite,

package/skills/kaizen-help/SKILL.md

@@ -31,7 +31,7 @@ anything.
 | `/kaizen reject <reason>` | Reject it; the reason decides revise (back to planner) vs kill (abandon) |
 | `/kaizen abort` | Mark the current run abandoned |
 | `/kaizen config` | Show this project's settings and change them, one picker per setting |
-| `/kaizen init` | Install `.kaizen/` with `spec.md`, config, and the gitignore entry into the current repository |
+| `/kaizen init` | Set up this project folder: `.kaizen/` with `spec.md`, config, and — in a git repo — the gitignore entry |
 | `/kaizen install` | Install the workflow itself globally or per-project |
 
 `/kaizen` with no argument: `status` if a run is in progress, else ask what to build.