kaizen-agent 0.3.0 → 0.5.0

package/cli/install.ts

@@ -1,15 +1,208 @@
 #!/usr/bin/env bun
-import { symlinkSync, mkdirSync, readdirSync, lstatSync, readlinkSync, unlinkSync, existsSync } from "node:fs";
+import {
+  symlinkSync, mkdirSync, readdirSync, lstatSync, readlinkSync, unlinkSync,
+  existsSync, copyFileSync, readFileSync, appendFileSync, rmSync, writeFileSync,
+} from "node:fs";
 import { join, dirname, basename } from "node:path";
 import { homedir } from "node:os";
 
 const home = homedir();
 const REPO_URL = "https://github.com/hfadhlullah/kaizen.git";
+const args = new Set(Bun.argv.slice(2));
+const upgrade = args.has("upgrade") || args.has("--upgrade");
+const wantSettings = args.has("settings") || args.has("config");
+const check = args.has("--check");
+const force = args.has("--force");
+const verbose = args.has("--verbose");
+const interactive = process.stdin.isTTY && !check && !upgrade && !args.has("--yes");
+
+const c = {
+  dim: (s: string) => `\x1b[2m${s}\x1b[0m`,
+  bold: (s: string) => `\x1b[1m${s}\x1b[0m`,
+  cyan: (s: string) => `\x1b[36m${s}\x1b[0m`,
+  green: (s: string) => `\x1b[32m${s}\x1b[0m`,
+};
+
+// Where each agent reads skills from. The skill folders follow the open Agent
+// Skills standard, so every one of these can run the workflow; agents/ and
+// commands/ are Claude Code's own formats and go nowhere else.
+const AGENTS = [
+  { name: "Claude Code", dir: ".claude", full: true },
+  { name: "Codex", dir: ".codex", full: false },
+  { name: "Antigravity", dir: ".agents", full: false },
+  { name: "OpenCode", dir: ".opencode", full: false },
+  { name: "Cursor", dir: ".cursor", full: false },
+  { name: "Gemini CLI", dir: ".gemini", full: false },
+];
+
+// Install into an agent that is actually present. Creating ~/.opencode for someone
+// who does not use OpenCode leaves litter that looks like configuration. Claude Code
+// is always a target: it is the one this is installed from.
+const found = (r: string) => AGENTS.filter((a) => a.dir === ".claude" || existsSync(join(r, a.dir)));
+
+if (wantSettings) {
+  const { settings } = await import("./settings.ts");
+  await settings(await resolveRepoQuietly());
+  process.exit(0);
+}
+
+// Bare `kaizen` on a machine where it is already installed is not an install --
+// show what the project is doing instead, and offer the things you would have
+// opened a terminal for.
+if (interactive && !upgrade && Bun.argv.length === 2) {
+  const repoDir = await resolveRepoQuietly();
+  const here = found(home);
+  const linked = here.every((a) =>
+    ["kaizen", "kaizen-help"].every((n) => existsSync(join(home, a.dir, "skills", n))));
+  if (linked) {
+    const { dashboard } = await import("./dashboard.ts");
+    await dashboard(repoDir, here.map((a) => a.name), async (action) => {
+      if (action === "settings") {
+        const { settings } = await import("./settings.ts");
+        await settings(repoDir, false);
+      } else if (action === "upgrade") {
+        return await runUpgrade(repoDir);
+      } else if (action === "init") {
+        const out = await Bun.$`bun run ${join(repoDir, "cli/install.ts")} --yes`.text();
+        return clean(out);
+      }
+    });
+    process.exit(0);
+  }
+}
+
+if (upgrade) await clearBunxCache();
+if (!check && !upgrade) await welcome();
+
+async function welcome() {
+  const rgb = (r: number, g: number, b: number, s: string) =>
+    `\x1b[38;2;${r};${g};${b}m${s}\x1b[0m`;
+
+  // Fuji: snow on the peak, deepening blue down the slope.
+  const WORD = [
+    "██╗  ██╗ █████╗ ██╗███████╗███████╗███╗   ██╗",
+    "██║ ██╔╝██╔══██╗██║╚══███╔╝██╔════╝████╗  ██║",
+    "█████╔╝ ███████║██║  ███╔╝ █████╗  ██╔██╗ ██║",
+    "██╔═██╗ ██╔══██║██║ ███╔╝  ██╔══╝  ██║╚██╗██║",
+    "██║  ██╗██║  ██║██║███████╗███████╗██║ ╚████║",
+    "╚═╝  ╚═╝╚═╝  ╚═╝╚═╝╚══════╝╚══════╝╚═╝  ╚═══╝",
+  ];
+  const W = 69, C = 34, SNOW = 3;
+  // One constant slope, three columns per row, all the way down. The rows behind
+  // the wordmark keep the same rate, so the edge that goes in above the letters
+  // comes out below them on the same line -- vary it and the cone reads broken.
+  const H = [1, 4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34];
+
+  // Anything that would wrap is worse than the smaller thing that fits: the
+  // mountain needs the full width, the wordmark needs 47, below that use words.
+  const cols = process.stdout.columns || 80;
+  const wide = cols >= W + 4;
+  if (cols < 49) {
+    console.log(`\n  ${c.bold("kaizen")}`);
+  } else {
+
+  const cell: string[][] = H.map(() => Array(W).fill(" "));
+  const isWord: boolean[][] = H.map(() => Array(W).fill(false));
+
+  if (wide) {
+    for (const [i, h] of H.entries()) {
+      const l = C - h, r = C + h;
+      if (i < SNOW) {                       // solid cap
+        cell[i]![l] = "▄"; cell[i]![r] = "▄";
+        for (let x = l + 1; x < r; x++) cell[i]![x] = "█";
+      } else {                              // slope, drawn as two edges
+        // Below the wordmark's top row the letters own the middle, so draw an
+        // edge only where all three of its characters clear them.
+        const band = i >= H.length - WORD.length;
+        const gap = Math.floor((W - 45) / 2) - 2;
+        if (!band || l + 2 < gap) {
+          cell[i]![l] = "▄"; cell[i]![l + 1] = "█"; cell[i]![l + 2] = "▀";
+          cell[i]![r - 2] = "▀"; cell[i]![r - 1] = "█"; cell[i]![r] = "▄";
+        }
+      }
+    }
+  }
+
+  const top = H.length - WORD.length, left = Math.floor((W - 45) / 2);
+  for (let r = top; r < H.length; r++)      // air around the letters
+    for (let x = left - 2; x < left + 47; x++) if (x >= 0 && x < W) cell[r]![x] = " ";
+  for (const [r, line] of WORD.entries())
+    for (const [x, ch] of [...line].entries())
+      if (ch !== " ") { cell[top + r]![left + x] = ch; isWord[top + r]![left + x] = true; }
+
+  console.log();
+  for (const [i, row] of cell.entries()) {
+    if (!wide && i < top) continue;          // no mountain to draw, no blank rows
+    const slope = Math.max(0, i - SNOW) / (H.length - SNOW);
+    const mountain: [number, number, number] = i < SNOW
+      ? [255 - i * 8, 255 - i * 5, 255]
+      : [Math.round(150 - slope * 105), Math.round(190 - slope * 110), Math.round(245 - slope * 80)];
+
+    // With no mountain there is nothing to sit under, so drop its left margin.
+    const off = wide ? 0 : left;
+    const chars = row.slice(off), flags = isWord[i]!.slice(off);
+
+    let out = "  ", run = "", runWord = flags[0]!;
+    const flush = () => {
+      if (!run) return;
+      const t = (i - top) / (WORD.length - 1);
+      const col: [number, number, number] = runWord
+        ? [Math.round(214 - t * 150), Math.round(232 - t * 130), Math.round(255 - t * 45)]
+        : mountain;
+      out += rgb(col[0], col[1], col[2], run);
+      run = "";
+    };
+    for (const [x, ch] of chars.entries()) {
+      if (flags[x] !== runWord) { flush(); runWord = flags[x]!; }
+      run += ch;
+    }
+    flush();
+    console.log(out.replace(/\s+$/, ""));
+  }
+  if (wide) console.log("  " + rgb(38, 66, 130, "▀".repeat(W)));
+  }
+
+  console.log(`
+  ${c.bold("改善")}  ${c.dim("kaizen — continuous improvement")}
+
+  ${c.dim("A staged workflow for AI agents — code, writing, research, operations:")}
+  ${c.dim("plan  ->  you approve  ->  build  ->  independent review  ->  bounded fix loop")}
+`);
+
+  if (interactive) await anyKey();
+}
+
+// A pause before anything touches the filesystem, and the place to back out.
+async function anyKey() {
+  const { stdin, stdout } = process;
+  stdout.write(`  ${c.dim("press")} ${c.cyan("enter")} ${c.dim("to install, or")} ${c.cyan("ctrl-c")} ${c.dim("to leave")}`);
+  stdin.setRawMode(true);
+  stdin.resume();
+  await new Promise<void>((resolve) => {
+    const onData = (chunk: Buffer) => {
+      if (chunk.toString().includes("\x03")) { stdout.write("\n\n  nothing installed\n"); process.exit(130); }
+      stdin.off("data", onData);
+      resolve();
+    };
+    stdin.on("data", onData);
+  });
+  stdin.setRawMode(false);
+  stdin.pause();
+  stdout.write("\r\x1b[2K");
+}
 
-// Links point back at the clone, so the clone has to be somewhere permanent. Run
-// from a git checkout and that checkout is it; run through `bunx`, and the package
-// lives in a temp cache that gets evicted, so clone to KAIZEN_HOME first.
 const repo = await resolveRepo();
+const root = await chooseRoot();
+const targets = found(root);
+
+// ---------------------------------------------------------------- repo
+
+// Settings only needs the clone's default config, not a pull.
+async function resolveRepoQuietly() {
+  const here = dirname(import.meta.dir);
+  if (existsSync(join(here, ".git"))) return here;
+  return process.env.KAIZEN_HOME ?? join(home, "kaizen");
+}
 
 async function resolveRepo() {
   const here = dirname(import.meta.dir);
@@ -17,29 +210,39 @@ async function resolveRepo() {
 
   const dest = process.env.KAIZEN_HOME ?? join(home, "kaizen");
   if (existsSync(join(dest, ".git"))) {
-    // A pull can refuse for reasons that have nothing to do with linking — local
-    // edits, a detached head, no network. Linking the checkout that is already
-    // there still works, so say what happened and carry on rather than failing
-    // the install over it.
+    // A pull can refuse for reasons that have nothing to do with linking -- local
+    // edits, a detached head, no network. Linking the checkout already on disk
+    // still works, so say what happened and carry on.
     try {
       await Bun.$`git -C ${dest} pull --ff-only`.quiet();
-      console.log(`update ${dest}`);
+      step(`updated ${tilde(dest)}`);
     } catch {
-      console.log(`skip   ${dest} — could not pull, linking what is there`);
+      step(`kept ${tilde(dest)} ${c.dim("(could not pull)")}`);
     }
     return dest;
   }
-  console.log(`clone  ${REPO_URL} -> ${dest}`);
+  step(`cloning into ${tilde(dest)}`);
   await Bun.$`git clone --quiet ${REPO_URL} ${dest}`;
   return dest;
 }
 
-// Each entry: source path in the repo -> directory it is linked into.
-const links = [
-  ...["kaizen", "kaizen-help"].map((n) => [join(repo, "skills", n), "skills"] as const),
-  ...dirEntries("agents").map((f) => [f, "agents"] as const),
-  ...dirEntries("commands").map((f) => [f, "commands"] as const),
-];
+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.
+  const cwd = process.cwd();
+  if (cwd === home || !existsSync(join(cwd, ".git"))) return home;
+
+  const names = (r: string) => found(r).map((a) => a.name).join(", ");
+  return select("Install kaizen for", [
+    { label: "Globally", hint: `every project \u2014 ${names(home)}`, value: home },
+    { label: "This project only", hint: `${basename(cwd)}/ \u2014 ${names(cwd)}`, value: cwd },
+  ]);
+}
+
+// ---------------------------------------------------------------- linking
 
 function dirEntries(sub: string) {
   return readdirSync(join(repo, sub))
@@ -47,6 +250,14 @@ function dirEntries(sub: string) {
     .map((f) => join(repo, sub, f));
 }
 
+const links = targets.flatMap((a) => [
+  ...["kaizen", "kaizen-help"].map((n) => [join(repo, "skills", n), join(a.dir, "skills")] as const),
+  ...(a.full ? [
+    ...dirEntries("agents").map((f) => [f, join(a.dir, "agents")] as const),
+    ...dirEntries("commands").map((f) => [f, join(a.dir, "commands")] as const),
+  ] : []),
+]);
+
 function linkState(src: string, dest: string) {
   try {
     const st = lstatSync(dest);
@@ -57,62 +268,247 @@ function linkState(src: string, dest: string) {
   }
 }
 
-const args = new Set(Bun.argv.slice(2));
-const check = args.has("--check");
-const force = args.has("--force");
-const base = join(await chooseRoot(), ".claude");
+let blocked = 0, wrote = 0, already = 0;
+for (const [src, sub] of links) {
+  const dir = join(root, sub);
+  const dest = join(dir, basename(src));
+  const state = linkState(src, dest);
+  const name = `${sub}/${basename(src)}`;
 
-async function chooseRoot() {
-  if (args.has("--project")) return process.cwd();
-  if (args.has("--global") || check) return home;
+  if (check) {
+    if (state !== "linked") blocked++;
+    console.log(`${state === "linked" ? "ok  " : "MISS"} ${name}${state === "linked" ? "" : ` (${state})`}`);
+    continue;
+  }
+  if (state === "linked") { already++; if (verbose) console.log(c.dim(`  ok    ${name}`)); continue; }
+  if (state === "occupied" && !force) {
+    console.log(`  ${c.bold("skip")}  ${name} — real file present, use --force`);
+    blocked++;
+    continue;
+  }
+  mkdirSync(dir, { recursive: true });
+  if (state !== "missing") unlinkSync(dest);
+  symlinkSync(src, dest);
+  wrote++;
+  if (verbose) console.log(c.dim(`  link  ${name}`));
+}
 
-  // Only ask when there is someone to answer. Piped, scripted, or CI runs take the
-  // global install silently rather than hanging on a prompt nobody sees.
-  if (!process.stdin.isTTY) return home;
+if (check) {
+  console.log(blocked ? `\n${blocked} link(s) missing — run: bunx kaizen-agent` : "\nall linked");
+  process.exit(blocked ? 1 : 0);
+}
 
-  const choice = await select("Install where?", [
-    { label: "Every project", hint: join(home, ".claude"), value: home },
-    { label: "This one only", hint: join(process.cwd(), ".claude"), value: process.cwd() },
-  ]);
-  return choice;
+const into = targets.map((a) => a.name).join(", ");
+step(
+  wrote && already ? `linked ${wrote} new, ${already} already in place — ${into}`
+  : wrote ? `linked ${wrote} files into ${into}`
+  : `already installed for ${into} ${c.dim("(nothing to change)")}`,
+);
+if (targets.length === 1) {
+  console.log(`    ${c.dim("Codex, Antigravity, OpenCode, Cursor and Gemini CLI get it too,")}`);
+  console.log(`    ${c.dim("if their directory exists when you install.")}`);
+}
+
+// ---------------------------------------------------------------- repo setup
+
+if (!args.has("--project")) installLauncher();
+
+// bunx runs from a temp copy and leaves nothing behind, so there is no `kaizen` to
+// type afterwards. A launcher pointed at the clone gives one, and keeps working
+// after the clone updates.
+function installLauncher() {
+  const binDir = join(home, ".local", "bin");
+  const bin = join(binDir, "kaizen");
+  const script = `#!/bin/sh\n# kaizen launcher -- installed by kaizen-agent\nexec bun run ${join(repo, "cli/install.ts")} "$@"\n`;
+  try {
+    if (existsSync(bin) && readFileSync(bin, "utf8") === script) return;
+    mkdirSync(binDir, { recursive: true });
+    writeFileSync(bin, script, { mode: 0o755 });
+    const onPath = (process.env.PATH ?? "").split(":").includes(binDir);
+    step(onPath
+      ? `${c.cyan("kaizen upgrade")} is now on your PATH`
+      : `wrote ${tilde(bin)} ${c.dim("— add ~/.local/bin to PATH to use it")}`);
+  } catch {
+    /* a read-only home is not worth failing the install over */
+  }
+}
+
+const inGitRepo = existsSync(join(process.cwd(), ".git"));
+const kaizenDir = join(process.cwd(), ".kaizen");
+
+if (inGitRepo && !existsSync(kaizenDir)) {
+  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 },
+        { label: "Not now", hint: "the first /kaizen run will do it", value: false },
+      ])
+    : false;
+  if (now) initRepo();
+} else if (existsSync(kaizenDir)) {
+  step(`${basename(process.cwd())}/.kaizen already set up`);
+}
+
+function initRepo() {
+  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"));
+
+  // 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);
+  }
+  step("wrote .kaizen/ and the gitignore entry");
+  writePointer();
+}
+
+// Claude Code loads a skill by matching its description, so an ordinary request
+// ("add a discount cap") does not reach kaizen unless the project says it should.
+// One line in the agent instructions is what makes it the default here.
+function writePointer() {
+  const block = `\n## Kaizen workflow\n\nNon-trivial work in this repository follows the staged workflow in\n\`.kaizen/spec.md\`: plan, human approval, build, independent review, bounded fix\nloop. Invoke the \`kaizen\` skill for it — do not carry the stages out inline.\n\nNon-trivial means work worth a plan: a change across more than one file, anything\nwith a migration or a rollback, or a document someone else will act on. Answering a\nquestion, reading code, or a one-line fix is not, and should not start a run.\n\nRun state lives in \`.kaizen/runs/<id>/\`. Read \`state.json\` first and continue from\nthe stage it names; never advance a run whose \`awaiting\` field is non-null without a\nrecorded human decision.\n`;
+
+  for (const name of ["CLAUDE.md", "AGENTS.md"]) {
+    const f = join(process.cwd(), name);
+    const current = existsSync(f) ? readFileSync(f, "utf8") : "";
+    if (current.includes("## Kaizen workflow")) continue;
+    if (!current && name === "AGENTS.md") continue;   // do not create one that was never there
+    const text = current ? (current.endsWith("\n") ? "" : "\n") + block : block.slice(1);
+    appendFileSync(f, text);
+    step(`${existsSync(f) && current ? "added to" : "wrote"} ${name} ${c.dim("— kaizen now runs without being asked for")}`);
+  }
+}
+
+// ---------------------------------------------------------------- done
+
+if (upgrade) {
+  let version = "";
+  try { version = JSON.parse(readFileSync(join(repo, "package.json"), "utf8")).version; } catch {}
+  console.log(`
+  ${c.bold("Up to date")}${version ? c.dim(`  —  kaizen ${version}`) : ""}
+  ${c.dim("Restart Claude Code to pick up any new slash commands.")}
+`);
+} else {
+  console.log(`
+  ${c.bold("Next")}
+    1  restart Claude Code ${c.dim("— skills load live, slash commands only at session start")}
+    2  ${c.cyan("/kaizen <what you want done>")} ${c.dim("in any project — it sets itself up on first run")}
+
+  ${c.dim("/kaizen-help lists every command.  kaizen upgrade updates all of this.")}
+`);
+}
+if (blocked) process.exit(1);
+
+// ---------------------------------------------------------------- helpers
+
+function step(msg: string) { console.log(`  ${c.green("+")} ${msg}`); }
+
+// Runs the upgrade and reports what it actually did, version to version, so the
+// dashboard can show a result rather than the user wondering whether it worked.
+async function runUpgrade(repoDir: string) {
+  const before = versionOf(repoDir);
+  const out = await Bun.$`bun run ${join(repoDir, "cli/install.ts")} upgrade`.text().catch(() => "");
+  const after = versionOf(repoDir);
+  const latest = await npmLatest();
+
+  const lines = [
+    before === after
+      ? `${c.bold("Already up to date")}  ${c.dim(after)}`
+      : `${c.bold("Upgraded")}  ${c.dim(before)} → ${c.green(after)}`,
+    "",
+    // Only the step lines: the captured run's own heading and restart notice
+    // repeat what this panel already says above them.
+    ...clean(out)
+      .filter((l) => l.trim().startsWith("+") || l.trim().startsWith("skip"))
+      .map((l) => c.dim(l.trim())),
+  ];
+  if (latest && latest !== after) {
+    lines.push("", c.dim(`npm publishes ${latest}; this install follows the git clone.`));
+  }
+  lines.push("", c.dim("Restart your agent to pick up new slash commands."));
+  return lines;
 }
 
-// Arrow-key picker. Raw mode delivers keys unbuffered, one escape sequence at a
-// time; the alternative is a dependency for forty lines of escape codes.
+function versionOf(dir: string) {
+  try { return JSON.parse(readFileSync(join(dir, "package.json"), "utf8")).version as string; }
+  catch { return "?"; }
+}
+
+async function npmLatest() {
+  try {
+    const r = await fetch("https://registry.npmjs.org/kaizen-agent/latest", {
+      signal: AbortSignal.timeout(4000),
+    });
+    return ((await r.json()) as { version?: string }).version ?? null;
+  } catch { return null; }        // offline is not an upgrade failure
+}
+
+// Captured output still carries its own colour codes, which stop any test on the
+// text from matching and would nest inside this panel's own styling.
+function clean(out: string) {
+  return out.split("\n").map((l) => l.replace(/\x1b\[[0-9;]*m/g, "").replace(/\r$/, "").trimEnd());
+}
+
+// bunx keeps an extracted copy per package under the temp directory and reuses it
+// 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";
+  let removed = 0;
+  try {
+    for (const name of readdirSync(tmp)) {
+      if (/^bunx-.*kaizen-agent/.test(name)) {
+        rmSync(join(tmp, name), { recursive: true, force: true });
+        removed++;
+      }
+    }
+  } catch { /* an unreadable temp directory is not worth failing an upgrade over */ }
+  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; }
+
+// Arrow-key picker. Raw mode delivers keys unbuffered; the alternative is a
+// dependency for two options and forty lines of escape codes.
 async function select<T>(question: string, options: { label: string; hint: string; value: T }[]) {
   const { stdin, stdout } = process;
   let active = 0;
 
   const draw = (first: boolean) => {
-    if (!first) stdout.write(`\x1b[${options.length}A`); // back up over the list
+    if (!first) stdout.write(`\x1b[${options.length}A`);
     for (const [i, o] of options.entries()) {
       const on = i === active;
       stdout.write(
-        `\x1b[2K  ${on ? "\x1b[36m>\x1b[0m" : " "} ${on ? "\x1b[1m" : "\x1b[2m"}${o.label}\x1b[0m` +
-          `  \x1b[2m${o.hint}\x1b[0m\n`,
+        `\x1b[2K    ${on ? c.cyan(">") : " "} ${on ? c.bold(o.label) : c.dim(o.label)}` +
+          `  ${c.dim(o.hint)}\n`,
       );
     }
   };
 
-  stdout.write(`\n\x1b[1m${question}\x1b[0m  \x1b[2m(arrows, enter)\x1b[0m\n`);
-  stdout.write("\x1b[?25l"); // hide cursor
+  stdout.write(`\n  ${c.bold(question)}  ${c.dim("(arrows, enter)")}\n`);
+  stdout.write("\x1b[?25l");
   draw(true);
   stdin.setRawMode(true);
   stdin.resume();
 
-  try {
-    outer: for await (const chunk of stdin) {
+  // Read via events rather than `for await`: breaking out of an async iterator
+  // destroys stdin, and a second prompt would then have no stream to read.
+  await new Promise<void>((resolve) => {
+    const onData = (chunk: Buffer) => {
       // A chunk can hold more than one keypress -- an arrow and the enter behind
       // it arrive together when input is piped -- so walk it rather than
       // comparing the whole thing to one key.
       const keys = chunk.toString();
       for (let i = 0; i < keys.length; i++) {
         const rest = keys.slice(i);
-        if (rest.startsWith("\x03")) {                  // ctrl-c
-          stdout.write("\ncancelled\n");
-          process.exit(130);
+        if (rest.startsWith("\x03")) { stdout.write("\ncancelled\n"); process.exit(130); }
+        if (rest.startsWith("\r") || rest.startsWith("\n")) {
+          stdin.off("data", onData);
+          return resolve();
         }
-        if (rest.startsWith("\r") || rest.startsWith("\n")) break outer;
         if (rest.startsWith("\x1b[A") || rest.startsWith("\x1b[B")) {
           active = rest[2] === "A"
             ? (active - 1 + options.length) % options.length
@@ -123,42 +519,12 @@ async function select<T>(question: string, options: { label: string; hint: strin
         else continue;
         draw(false);
       }
-    }
-  } finally {
-    stdin.setRawMode(false);
-    stdin.pause();
-    stdout.write("\x1b[?25h\n"); // show cursor again
-  }
-  return options[active]!.value;
-}
+    };
+    stdin.on("data", onData);
+  });
 
-let bad = 0;
-for (const [src, sub] of links) {
-  const dir = join(base, sub);
-  const dest = join(dir, basename(src));
-  const state = linkState(src, dest);
-
-  if (check) {
-    if (state !== "linked") bad++;
-    console.log(`${state === "linked" ? "ok  " : "MISS"} ${sub}/${basename(src)}${state === "linked" ? "" : ` (${state})`}`);
-    continue;
-  }
-  if (state === "linked") { console.log(`ok   ${sub}/${basename(src)}`); continue; }
-  if (state === "occupied" && !force) {
-    console.log(`skip ${sub}/${basename(src)} — real file present, use --force`);
-    bad++;
-    continue;
-  }
-  mkdirSync(dir, { recursive: true });
-  if (state !== "missing") unlinkSync(dest);
-  symlinkSync(src, dest);
-  console.log(`link ${sub}/${basename(src)}`);
-}
-
-if (check) {
-  console.log(bad ? `\n${bad} link(s) missing — run: bun run ${repo}/cli/install.ts` : "\nall linked");
-  process.exit(bad ? 1 : 0);
+  stdin.setRawMode(false);
+  stdin.pause();
+  stdout.write("\x1b[?25h");
+  return options[active]!.value;
 }
-console.log(`\nInstalled into ${base}. Restart Claude Code: skills load live, slash commands only on session start.`);
-console.log(`Then, in a repository you want to use it on: /kaizen-init`);
-if (bad) process.exit(1);