kaizen-agent 1.3.7 → 1.3.9

package/cli/dashboard.ts

@@ -437,7 +437,12 @@ export async function dashboard(
   async function sync() {
     const before = knownProjects().length;
     const started = Date.now();
-    const found = findProjects(home);
+    // Only searching under $HOME misses every project on another drive or mount,
+    // which on Windows is most of them. The folder the dashboard was opened in is
+    // searched too, and it is where the projects being worked on actually are.
+    const roots = [home, dirname(state ?? process.cwd()), process.cwd()]
+      .filter((d, i, all) => all.indexOf(d) === i);
+    const found = [...new Set(roots.flatMap((r) => findProjects(r)))];
     for (const dir of found) remember(dir);
     const added = knownProjects().length - before;
     await report([
@@ -445,7 +450,7 @@ export async function dashboard(
       "",
       ...found.map((d) => "  " + c.dim(tilde(d))),
       "",
-      c.dim(`${found.length} found in ${((Date.now() - started) / 1000).toFixed(1)}s under ${tilde(home)}`),
+      c.dim(`${found.length} found in ${((Date.now() - started) / 1000).toFixed(1)}s under ${roots.map(tilde).join(", ")}`),
       c.dim(`the list lives in ${tilde(join(home, ".kaizen", "projects"))} and can be edited`),
     ]);
   }
@@ -1311,7 +1316,9 @@ function findProjects(root: string, depth = 4): string[] {
     try { entries = readdirSync(dir); } catch { return; }
     // $HOME holds ~/.kaizen, the global state, which is not a project and must not
     // stop the walk before it has looked at anything.
-    if (dir !== root && entries.includes(".kaizen")) { found.push(dir); return; }
+    // A project can hold projects of its own -- a monorepo, or a folder of them --
+    // so finding one is not a reason to stop looking underneath it.
+    if (dir !== root && entries.includes(".kaizen")) found.push(dir);
     if (left === 0) return;
     for (const name of entries) {
       if (name.startsWith(".") || name === "node_modules") continue;

package/cli/install.ts

@@ -165,7 +165,18 @@ if (upgrade && !existsSync(join(dirname(import.meta.dir), ".git"))) {
   const now = versionOf(dirname(import.meta.dir));
   if (latest && latest !== now) {
     step(`fetching kaizen ${latest} from npm`);
-    await Bun.$`${process.execPath} x kaizen-agent@${latest} --yes`.catch(() => {});
+    // --force so a stale package manifest cannot resolve the version away, and the
+    // failure is printed rather than swallowed: a silent catch here looked exactly
+    // like a successful upgrade that changed nothing.
+    const r = await Bun.$`${process.execPath} x --force kaizen-agent@${latest} --yes`
+      .quiet().nothrow();
+    const out = clean(r.stdout.toString() + r.stderr.toString()).filter((l) => l.trim());
+    for (const l of out) console.log(l.startsWith("  ") ? l : `  ${l}`);
+    if (r.exitCode !== 0) {
+      console.log(`\n  ${c.bold(`could not fetch kaizen ${latest}`)}`);
+      console.log(`  ${c.dim("try:")} ${c.cyan(`bunx kaizen-agent@${latest}`)}\n`);
+      process.exit(1);
+    }
     process.exit(0);
   }
 }
@@ -344,14 +355,17 @@ async function resolveRepo() {
     }
     return dest;
   }
-  if (Bun.which("git")) {
+  // Cloning needs an empty directory, and a copy made on a machine that had no git
+  // is anything but: installing git later must not turn every run into a fatal.
+  // An existing directory is updated in place whichever way it was made.
+  if (Bun.which("git") && !existsSync(dest)) {
     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)")}`);
+  // 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(existsSync(dest) ? "(over the copy already there)" : "(no git)")}`);
   cpSync(here, dest, {
     recursive: true, dereference: true,
     filter: (src) => basename(src) !== "node_modules",
@@ -682,6 +696,28 @@ async function clearBunxCache() {
       }
     }
   } catch { /* an unreadable temp directory is not worth failing an upgrade over */ }
+
+  // bun caches the package manifest too, which is what answers "no version
+  // matching 1.3.7 found (but package exists)" hours after it was published.
+  // Only kaizen's own entries go: another package's cache is not ours to clear.
+  // Where that cache lives depends on the platform and on how bun was installed,
+  // so try the lot; a directory that is not there reads as an empty one.
+  const caches = [
+    process.env.BUN_INSTALL_CACHE_DIR,
+    join(process.env.BUN_INSTALL ?? join(home, ".bun"), "install", "cache"),
+    join(process.env.XDG_CACHE_HOME ?? join(home, ".cache"), "bun"),
+    process.env.LOCALAPPDATA ? join(process.env.LOCALAPPDATA, "bun", "install", "cache") : null,
+  ].filter((d): d is string => Boolean(d));
+  for (const dir of caches) {
+    try {
+      for (const name of readdirSync(dir)) {
+        if (!name.includes("kaizen-agent")) continue;
+        rmSync(join(dir, name), { recursive: true, force: true });
+        removed++;
+      }
+    } catch { /* no cache directory is the same as an empty one */ }
+  }
+
   step(removed ? `cleared ${removed} cached copy of the installer` : "no installer cache to clear");
 }
 function tilde(p: string) { return p.startsWith(home) ? "~" + p.slice(home.length) : p; }

package/package.json

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