kaizen-agent 1.10.0 → 1.11.1

package/cli/web.ts

@@ -4,9 +4,9 @@ import { existsSync, readdirSync, statSync, watch, appendFileSync, mkdirSync, ty
 import { join, dirname, resolve, sep } from "node:path";
 import {
   home, type Item, type Card, boardCards, knownProjects, remember, locate, label, tilde, searchRoots, findProjects,
-  readInbox, writeInbox, replaceIdea, abandonRun, launchRun, parseItem, short, setArchived, writeNotes,
+  readInbox, writeInbox, replaceIdea, abandonRun, launchRun, parseItem, agentChoices, projectOf, KNOWN_AGENTS, plainModel, short, setArchived, writeNotes,
   appendNote, saveAttachment, pidOnPort, readText, cmdExe, sysExe, powershellExe, runGit, cardsGit, readCommit, commitPush, notice, notifier, LOGO,
-  reviewFindings, pickFindings, fixPrompt, approvalPrompt, nativePath, closeSessions, sweepSessions,
+  reviewFindings, pickFindings, fixPrompt, approvalPrompt, nativePath, closeSessions, sweepSessions, issueUrl,
 } from "./state.ts";
 import { readSources, addSource, removeSource, moveSource, gatherSource, gatherAll, gatherDirs, due } from "./sources.ts";
 import { listNotes, saveNote, renameNote, deleteNote, boardIndex, linksTo } from "./notes.ts";
@@ -315,6 +315,19 @@ export async function web(repoDir: string, opts: Opts = {}) {
         return json({ sources, failed, every: await every() });
       }
 
+      // The Run form's choices for one project: installed tools and their models.
+      // A prefilled GitHub bug form. A redirect, so a plain link opens it with no script
+      // and no popup blocker in the way.
+      if (req.method === "GET" && path === "/issue") {
+        return Response.redirect(issueUrl({ title: url.searchParams.get("title") ?? "", what: url.searchParams.get("what") ?? "" }), 302);
+      }
+
+      if (req.method === "GET" && path === "/agents") {
+        const dir = url.searchParams.get("dir");
+        if (!dir || !states(true).includes(dir)) return bad("unknown state dir", 404);
+        return json(agentChoices(projectOf(dir)));
+      }
+
       if (req.method === "GET" && path === "/settings") {
         const { listSettings } = await import("./settings.ts");
         return json(listSettings(repoDir));
@@ -329,6 +342,28 @@ export async function web(repoDir: string, opts: Opts = {}) {
         return "error" in r ? bad(r.error) : json(r);
       }
 
+      // A page cannot learn a real path from a file input, so the board, which runs
+      // on the user's machine, opens the system's own folder dialog and answers it.
+      if (req.method === "POST" && path === "/pick-folder") {
+        if (!local(req)) return bad("cross-origin write refused", 403);
+        if (picking) return bad("a folder dialog is already open", 409);
+        const cmd = folderDialog();
+        if (!cmd) return bad("No folder dialog found: install zenity or kdialog, or type the path");
+        picking = true;
+        try {
+          const p = Bun.spawn(cmd, { stdin: "ignore", stdout: "pipe", stderr: "pipe" });
+          const [out, err, code] = await Promise.all([new Response(p.stdout).text(), new Response(p.stderr).text(), p.exited]);
+          // osascript ends a folder with "/"; a bare root (/, C:\) keeps its own.
+          const picked = /^([A-Za-z]:)?[\\/]$/.test(out.trim()) ? out.trim() : out.trim().replace(/[\\/]+$/, "");
+          if (code === 0 && picked) return json({ path: picked });
+          // Cancel: exit 1 with nothing said (zenity, kdialog), -128 (osascript), or exit 0 with no path (PowerShell).
+          if (code === 0 || !err.trim() || err.includes("-128")) return json({ cancelled: true });
+          return bad(err.trim().split("\n")[0]);
+        } catch (e) {
+          return bad(e instanceof Error ? e.message : String(e));
+        } finally { picking = false; }
+      }
+
       // Attachments only, never a run's own files: the path must sit under an
       // attachments/ directory of a known state dir, with no way back up.
       if (req.method === "GET" && path === "/file") {
@@ -452,11 +487,15 @@ export async function web(repoDir: string, opts: Opts = {}) {
           const text = String(body.text ?? "").trim();
           const kind = body.kind === "full" || body.kind === "lite" ? body.kind : "";
           if (!text) return bad("empty idea");
+          const agent = typeof body.agent === "string" && body.agent ? body.agent : undefined;
+          if (agent && !KNOWN_AGENTS.some((a) => a.cmd === agent)) return bad("unknown agent");
+          const model = typeof body.model === "string" ? body.model.trim() : "";
+          if (model && !plainModel(model)) return bad("A model name is letters, digits and . : / @ _ - only");
           const it: Item = parseItem(`${kind} ${text}`.trim());
           // A `started` idea may be run again: the terminal the first launch opened
           // can come up empty, and nothing else tells the board a run never began.
           it.notes = readInbox(dir).find((l) => (l.status === "open" || l.status === "started") && l.text === text)?.notes;
-          const r = launchRun(it, dir);
+          const r = launchRun(it, dir, undefined, { agent, model: model || undefined, yolo: body.yolo === true });
           if (r.ok) replaceIdea(dir, text, { status: "started", text });
           changed();
           return json(r.ok
@@ -651,6 +690,29 @@ export async function openApp(url: string) {
 }
 
 // Windows keeps browsers out of PATH; the usual install roots are the next best guess.
+// One dialog at a time: a second click while one is open would stack another.
+let picking = false;
+
+// The system folder picker for this platform, printing the chosen path on stdout.
+// macOS and Windows always have one; on Linux it is whichever desktop tool exists.
+export function folderDialog(platform: string = process.platform): string[] | null {
+  const prompt = "Choose your projects folder";
+  // osascript is a background process: without `activate` its dialog can open behind
+  // the browser. Plain `activate` targets osascript itself, so no Automation prompt.
+  if (platform === "darwin") return ["osascript", "-e", "activate", "-e", `POSIX path of (choose folder with prompt "${prompt}")`];
+  if (platform === "win32") {
+    // An owner form kept on top, or the dialog opens behind the browser.
+    const ps = `[Console]::OutputEncoding=[Text.Encoding]::UTF8;Add-Type -AssemblyName System.Windows.Forms;`
+      + `$o=New-Object System.Windows.Forms.Form -Property @{TopMost=$true};$d=New-Object System.Windows.Forms.FolderBrowserDialog;`
+      + `$d.Description='${prompt}';if($d.ShowDialog($o) -eq 'OK'){[Console]::Out.Write($d.SelectedPath)}`;
+    return [powershellExe(), "-NoProfile", "-STA", "-Command", ps];
+  }
+  const zenity = Bun.which("zenity", { PATH: process.env.PATH });
+  if (zenity) return [zenity, "--file-selection", "--directory", `--title=${prompt}`];
+  const kdialog = Bun.which("kdialog", { PATH: process.env.PATH });
+  return kdialog ? [kdialog, "--getexistingdirectory", home, "--title", prompt] : null;
+}
+
 function winChrome(exe: string) {
   const roots = [process.env["ProgramFiles"], process.env["ProgramFiles(x86)"], process.env["LOCALAPPDATA"]].filter(Boolean) as string[];
   const sub: Record<string, string> = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kaizen-agent",
-  "version": "1.10.0",
+  "version": "1.11.1",
   "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/SKILL.md

@@ -62,7 +62,10 @@ 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 project folder's root, else
-   `~/.kaizen/` keyed by working directory. If neither exists and the user is starting
+   `~/.kaizen/` keyed by working directory. The project folder is the working
+   directory this session started in — never the folder this skill was read from, nor
+   the repository it lives in, even when that has a `.kaizen/` of its own. A run
+   written there is invisible to the board the user launched it from. If neither exists and the user is starting
    work, run `/kaizen init` first: it creates `.kaizen/` with a copy of the `spec*.md`
    files and — where the folder is a git repository — the gitignore entry
    (see [`adapters.md`](adapters.md)). Also append the project folder's absolute path
@@ -105,6 +108,17 @@ worth two more stages to confirm a one-line message now reads correctly. A findi
 `high` or above pulls the run back onto the full path whatever its size, since that
 severity is the loop's whole reason for existing.
 
+**Trivial changes take the direct path.** Where the request is one obvious change with
+nothing to decide — a typo, a label, a one-line copy or config tweak — a plan is longer
+than the work and a review re-reads what the user is about to look at anyway. Write
+`00-request.md`, build straight away, write `03-impl.md`, and stop at
+`stage: "review"`, `awaiting: "approvals.review"`: the user checks the result and
+approves it or says what to change. No `01-plan.md`, no plan approval, no
+`04-review.md` — the user's check is the review. Never the direct path for money, data,
+a migration, security, anything hard to undo, or a request with an open question; in
+`plan-only`, `auto`, or `/kaizen full`; or when in doubt. Work that turns out bigger
+mid-build stops and goes back to a plan.
+
 This is a judgement, not a threshold to enforce: fifty lines that change how money is
 rounded are not a small change. Say which path you took and why, in one line, when the
 run starts.

package/skills/kaizen/spec-build.md

@@ -9,6 +9,11 @@ builder's contract. The planner and reviewer do not read it.
 **Agent:** builder. **Input:** `01-plan.md`, `02-approval.md`, the track.
 **Output:** the deliverable itself, plus `03-impl.md`.
 
+On the direct path (see `spec.md`, Stage 0) there is no plan: the input is
+`00-request.md`, and the request is the scope. If the work turns out to need a
+decision, more than the one obvious change, or anything the direct path excludes,
+stop and send the run back to `stage: "plan"`.
+
 The builder produces whatever the track's deliverable is — code, a chapter, the
 campaign copy, the runbook — and nothing else.
 

package/skills/kaizen/spec-main.md

@@ -84,12 +84,15 @@ subagents at all.
 
 ## Final approval
 
-Controlled by `approvals.review`, skipped in `auto`.
+Controlled by `approvals.review`, skipped in `auto`. A direct-path run always stops here,
+whatever `approvals.review` says: the user's check is its only review.
 
 Report: what was built, verification results, findings fixed, findings still open,
 and anything the builder noted as out of scope. Where the run used `runner: lite`, say
 so in that report — the reviewer saw the work, and nobody should read a same-session
-review as an independent one because the output looked the same. Then stop. Committing, pushing, or
+review as an independent one because the output looked the same. Where the run took
+the direct path, say there was no plan and no review: the user's check is the review.
+Then stop. Committing, pushing, or
 opening a pull request happens only if the user asks.
 
 **Open findings are offered by number.** List them with the reviewer's numbering

package/skills/kaizen/spec.md

@@ -5,7 +5,8 @@ follow this document; only the way stages are dispatched differs per tool. If an
 adapter and this file disagree, this file wins.
 
 A stage may only start when the previous stage's artifact exists on disk and the approval
-between them, if enabled, has been resolved.
+between them, if enabled, has been resolved. The one exception is the direct path
+(see *Stage 0*), which skips the plan and the review on purpose.
 
 ---
 
@@ -108,7 +109,10 @@ write, refreshed on every later one.
 `stage` takes exactly one of five words, and boards key their columns on them:
 `plan`, `build`, `review`, `done`, `abandoned`. Set it when the stage starts —
 `build` before the builder touches anything, `review` before the reviewer reads — as
-its own write, not tacked onto a longer command that may not finish. Any other word
+its own write, not tacked onto a longer command that may not finish. Fixing findings
+is building and a recheck is reviewing, whoever runs them and whether the loop or the
+user picked the findings: `build` with `iteration` raised and `awaiting: null` before
+each iteration's first edit, `review` before its recheck reads. Any other word
 (`implement`, `fix`, `building`) is unknown to every reader and shows as still planning.
 
 `awaiting` is `null` or the config key of the approval being waited on —
@@ -131,6 +135,16 @@ the config said the day someone came back to it.
 If the request remains ambiguous enough that a plan would be guesswork, ask now. One
 round of questions here is cheaper than a rejected plan.
 
+**The direct path.** Where the request is one obvious change with nothing to decide —
+a typo, a label, a one-line copy or config tweak — and being wrong is cheap and
+visible, intake may skip the plan and the review: say so in one line, set
+`stage: "build"`, build against `00-request.md`, write `03-impl.md`, then set
+`stage: "review"`, `awaiting: "approvals.review"` and stop for the user to check the
+result. No `01-plan.md` or `04-review.md` is written, and no `02-approval.md` unless
+the user revises at that stop. Never for money, data, a migration, security, anything
+hard to undo, or a request with an open question; never in `plan-only` or `auto`
+mode or under `runner: full`; and when in doubt, not.
+
 ---
 
 ## Stage files