kaizen-agent 1.17.0 → 1.19.0

package/cli/board.test.ts

@@ -168,3 +168,33 @@ test("card menu items: appropriate actions and distinct icons across phases", ()
   const archIdea = getItems(idea, true);
   expect(archIdea.map((i: any) => i ? i[1] : null)).toEqual(["Restore", "Open", null, "Delete"]);
 });
+
+// brief() lifted the same way: a one-line structured idea split for display only.
+const bat = html.indexOf("function brief(");
+const brief = new Function(`${html.slice(bat, html.indexOf("\n\n", bat))}\nreturn brief`)() as (t: string) => { head: string; parts: { label: string; body: string }[] };
+
+test("a labelled idea splits into a head and one part per label", () => {
+  const b = brief("Improve previews Problem: one dense block. Non-goals: no rewrites. Acceptance criteria: (1) scannable. (2) full text kept.");
+  expect(b.head).toBe("Improve previews");
+  expect(b.parts.map(p => p.label)).toEqual(["Problem", "Non-goals", "Acceptance criteria"]);
+  expect(b.parts[2].body).toBe("1. scannable.\n2. full text kept.");
+  expect(md(`### ${b.parts[2].label}\n${b.parts[2].body}`)).toBe("<h3>Acceptance criteria</h3><ol><li>scannable.</li><li>full text kept.</li></ol>");
+});
+
+test("plain ideas, and a single label, are left whole", () => {
+  for (const t of ["fix the typo in README", "Bug: clicking twice opens two panels"]) expect(brief(t)).toEqual({ head: t, parts: [] });
+});
+
+test("an idea that opens with a label heads with its first part", () => {
+  expect(brief("Goal: faster board. Scope: cards only.").head).toBe("Goal: faster board.");
+});
+
+test("a capitalised phrase mid-sentence is prose, not a label", () => {
+  const b = brief("Fix cards Problem: the Board shows: nothing useful. Scope: cards.");
+  expect(b.parts.map(p => p.label)).toEqual(["Problem", "Scope"]);
+  expect(b.parts[0].body).toBe("the Board shows: nothing useful.");
+});
+
+test("criteria not numbered from 1 keep their own numbers", () => {
+  expect(brief("X Goal: g. Criteria: (2) two. (3) three.").parts[1].body).toBe("- (2) two.\n- (3) three.");
+});

package/cli/install.test.ts

@@ -4,7 +4,7 @@
 // Skipped on Windows: there uninstall also walks every drive (searchRoots) and
 // strips kaizen links from real projects, whatever HOME says.
 import { test, expect } from "bun:test";
-import { mkdtempSync, mkdirSync, writeFileSync, existsSync, rmSync, symlinkSync } from "node:fs";
+import { mkdtempSync, mkdirSync, writeFileSync, existsSync, rmSync, symlinkSync, cpSync, readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -83,3 +83,58 @@ it.skipIf(!Bun.which("git"))("uninstall removes a clean clone of kaizen and keep
   expect(unpushed.left).toBe(true);
   expect(unpushed.out).toContain("commits not pushed");
 });
+
+// An npm package of this checkout, at a version no real release has: no .git, so its
+// installer runs as `bunx kaizen-agent` would. Scratch HOME only; ~/kaizen is a fake.
+const fromPackage = (make: (k: string) => void, custom = false) => {
+  const root = mkdtempSync(join(tmpdir(), "kz-replace-"));
+  const home = join(root, "home"), pkg = join(root, "pkg");
+  const k = custom ? join(root, "kaizen") : join(home, "kaizen");
+  mkdirSync(home);
+  const src = dirname(dirname(import.meta.path));
+  for (const d of ["cli", "skills", "agents", "commands", "web", "package.json"]) {
+    cpSync(join(src, d), join(pkg, d), { recursive: true, filter: (p) => !p.includes("node_modules") });
+  }
+  const pj = join(pkg, "package.json");
+  writeFileSync(pj, readFileSync(pj, "utf8").replace(/"version": "[^"]*"/, '"version": "9.9.9"'));
+  make(k);
+  const env: Record<string, string> = { PATH: process.env.PATH ?? "", HOME: home, USERPROFILE: home, TMPDIR: root };
+  if (custom) env.KAIZEN_HOME = k;
+  const p = Bun.spawnSync([process.execPath, join(pkg, "cli", "install.ts"), "--yes", "--global"], { cwd: home, env });
+  const r = {
+    out: p.stdout.toString(),
+    version: existsSync(join(k, "package.json")) ? JSON.parse(readFileSync(join(k, "package.json"), "utf8")).version : null,
+    oldKept: existsSync(join(`${k}.old`, "mine.txt")),
+    mineInPlace: existsSync(join(k, "mine.txt")),
+  };
+  rmSync(root, { recursive: true, force: true });
+  return r;
+};
+
+it.skipIf(!Bun.which("git"))("an npm package replaces a ~/kaizen clone with local edits, keeping it as .old", () => {
+  const r = fromPackage(clone(REPO, true));
+  expect(r.version).toBe("9.9.9");
+  expect(r.mineInPlace).toBe(false);
+  expect(r.oldKept).toBe(true);
+  expect(r.out).toContain("replaced");
+});
+
+it.skipIf(!Bun.which("git"))("an npm package never replaces a development checkout", () => {
+  expect(fromPackage(clone(REPO, true), true).mineInPlace).toBe(true);
+  const unpushed = fromPackage(clone(REPO, true, commit));
+  expect(unpushed.mineInPlace).toBe(true);
+  expect(unpushed.out).toContain("commits not pushed");
+});
+
+it("upgrade with npm unreachable says not upgraded, never up to date", () => {
+  const root = mkdtempSync(join(tmpdir(), "kz-offline-"));
+  const home = join(root, "home");
+  mkdirSync(home);
+  kaizenFiles(join(home, "kaizen"));
+  const env = { PATH: process.env.PATH ?? "", HOME: home, TMPDIR: root, HTTPS_PROXY: "http://127.0.0.1:9", https_proxy: "http://127.0.0.1:9" };
+  const p = Bun.spawnSync([process.execPath, script, "upgrade"], { cwd: home, env });
+  rmSync(root, { recursive: true, force: true });
+  expect(p.exitCode).not.toBe(0);
+  expect(p.stdout.toString()).toContain("Not upgraded");
+  expect(p.stdout.toString()).not.toContain("Up to date");
+});

package/cli/install.ts

@@ -407,35 +407,40 @@ if (interactive && !upgrade && Bun.argv.length === 2) {
 
 if (upgrade) await clearBunxCache();
 
-// An install made without git is a copy, not a clone, so there is nothing to pull:
-// upgrading itself would copy ~/kaizen over ~/kaizen and report "already up to
-// date" forever. The new version comes from npm, and the installer inside it does
-// the copying and relinking, so hand the job over and stop.
-if (upgrade && !existsSync(join(dirname(import.meta.dir), ".git"))) {
+// Upgrade means the newest release on npm, whatever the install on disk is: a clone
+// with local edits used to fail its pull and still report "Up to date". The npm
+// package's own installer replaces the install (see resolveRepo), so hand it over.
+if (upgrade) {
+  const dest = installDir();
+  const now = versionOf(dest);
+  const why = await devCheckout(dest);
+  if (why) {
+    console.log(`\n  ${c.bold("Not upgraded")}  ${c.dim(`${tilde(dest)} is ${why}; update it with git`)}\n`);
+    process.exit(1);
+  }
   const latest = await npmLatest();
-  const now = versionOf(dirname(import.meta.dir));
-  // A copy can only upgrade through npm. When the version lookup fails, bun still
-  // resolves "latest" its own way, so ask for that rather than falling through --
-  // which would copy this install over itself and call it up to date.
-  if (latest !== now) {
-    const want = latest ?? "latest";
-    step(`fetching kaizen ${want} from npm`);
-    // --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@${want} --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 ${want}`)}`);
-      console.log(`  ${c.dim("try:")} ${c.cyan(`bunx kaizen-agent@${want}`)}\n`);
-      process.exit(1);
-    }
-    const after = versionOf(process.env.KAIZEN_HOME ?? join(home, "kaizen"));
-    if (after === now) console.log(`\n  ${c.bold(`kaizen ${now} is the latest on npm`)}\n`);
+  if (!latest) {
+    console.log(`\n  ${c.bold("Not upgraded")}  ${c.dim(`could not reach npm (kaizen ${now})`)}\n`);
+    process.exit(1);
+  }
+  if (latest === now) {
+    console.log(`\n  ${c.bold("Up to date")}${c.dim(`  —  kaizen ${now}`)}\n`);
     process.exit(0);
   }
+  step(`fetching kaizen ${latest} from npm`);
+  // --force so a stale package manifest cannot resolve the version away, and the
+  // failure is printed rather than swallowed.
+  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}`);
+  const after = versionOf(dest);
+  if (r.exitCode !== 0 || after !== latest) {
+    console.log(`\n  ${c.bold(`could not install kaizen ${latest}`)}`);
+    console.log(`  ${c.dim("try:")} ${c.cyan(`bunx kaizen-agent@${latest}`)}\n`);
+    process.exit(1);
+  }
+  console.log(`\n  ${c.bold("Upgraded")}  ${c.dim(now)} → ${c.green(after)}\n  ${c.dim("Restart Claude Code to pick up any new slash commands.")}\n`);
+  process.exit(0);
 }
 if (!check && !upgrade) await welcome();
 
@@ -597,41 +602,34 @@ async function resolveRepoQuietly() {
 
 async function resolveRepo() {
   const here = dirname(import.meta.dir);
-  const dest = process.env.KAIZEN_HOME ?? join(home, "kaizen");
-  // The launcher runs the clone itself, so an upgrade from inside it must pull
-  // that clone -- returning it untouched was "Up to date" at whatever was there.
-  for (const dir of [here, dest]) {
-    if (!existsSync(join(dir, ".git"))) continue;
-    if (!upgrade && dir === here) return dir;
-    // 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 ${dir} pull --ff-only`.quiet();
-      step(`updated ${tilde(dir)}`);
-    } catch {
-      step(`kept ${tilde(dir)} ${c.dim("(could not pull)")}`);
+  const dest = installDir();
+  // Running from a checkout (development, or the launcher's old clone): link it as is.
+  if (existsSync(join(here, ".git"))) return here;
+  // Running from an npm package: that package is the version wanted, so it replaces
+  // whatever ~/kaizen holds -- local edits included -- rather than a pull that any
+  // edit makes fail. The previous install is kept as <dest>.old, one deep.
+  if (here !== dest && existsSync(dest)) {
+    const why = await devCheckout(dest);
+    if (why) {
+      step(`kept ${tilde(dest)} ${c.dim(`(${why}; not replaced)`)}`);
+      return dest;
     }
-    return dir;
-  }
-  // A copy made before git was installed can never be pulled, so it keeps upgrading
-  // through npm and its caches. Once git is here, replace it with a real clone --
-  // into a sibling first, so a clone that fails leaves the working copy alone.
-  if (Bun.which("git") && existsSync(join(dest, "cli", "install.ts"))) {
-    const fresh = `${dest}.new`;
-    try {
+    const fresh = `${dest}.new`, old = `${dest}.old`;
+    rmSync(fresh, { recursive: true, force: true });
+    cpSync(here, fresh, { recursive: true, dereference: true, filter: (src) => basename(src) !== "node_modules" });
+    rmSync(old, { recursive: true, force: true });
+    // Windows refuses to move a folder a running kaizen still holds open. The
+    // install stays as it was; say how to finish rather than throwing.
+    try { renameSync(dest, old); } catch {
       rmSync(fresh, { recursive: true, force: true });
-      await Bun.$`git clone --quiet ${REPO_URL} ${fresh}`;
-      rmSync(dest, { recursive: true, force: true });
-      renameSync(fresh, dest);
-      step(`re-cloned ${tilde(dest)} ${c.dim("(git is available now)")}`);
+      step(`kept ${tilde(dest)} ${c.dim("(in use; close kaizen and any dashboard, then run bunx kaizen-agent@latest)")}`);
       return dest;
-    } catch {
-      rmSync(fresh, { recursive: true, force: true });
-      // Fall through to the copy below: an unreachable network is not a reason to
-      // leave the install untouched.
     }
+    renameSync(fresh, dest);
+    step(`replaced ${tilde(dest)} with kaizen ${versionOf(dest)} ${c.dim(`(previous install kept in ${tilde(old)})`)}`);
+    return dest;
   }
+  if (here === dest) return dest;
 
   // 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.
@@ -906,14 +904,7 @@ function writePointer() {
 
 // ---------------------------------------------------------------- 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")}
@@ -948,14 +939,26 @@ async function runUpgrade(repoDir: string) {
       .map((l) => c.dim(l.trim())),
   ];
   if (latest && latest !== after) {
-    lines.push("", c.dim(existsSync(join(repoDir, ".git"))
-      ? `npm publishes ${latest}; this install follows the git clone.`
-      : `npm publishes ${latest} — run: bunx kaizen-agent@${latest}`));
+    lines.push("", c.dim(`npm publishes ${latest} — run: bunx kaizen-agent@${latest}`));
   }
   lines.push("", c.dim("Restart your agent to pick up new slash commands."));
   return lines;
 }
 
+function installDir() { return process.env.KAIZEN_HOME ?? join(home, "kaizen"); }
+
+// A folder someone develops kaizen in must never be replaced by a release: a git
+// checkout KAIZEN_HOME points at, or any checkout holding commits on no remote.
+// ~/kaizen as the installer cloned it is fair game, edits and all (kept in .old).
+async function devCheckout(dir: string) {
+  if (!existsSync(join(dir, ".git"))) return "";
+  if (resolve(dir) !== join(home, "kaizen")) return "a git checkout named by KAIZEN_HOME";
+  try {
+    const ahead = (await Bun.$`git -C ${dir} rev-list --branches --not --remotes`.quiet().text()).trim();
+    return ahead ? "a git checkout with commits not pushed" : "";
+  } catch { return ""; }
+}
+
 function versionOf(dir: string) {
   try { return JSON.parse(readFileSync(join(dir, "package.json"), "utf8")).version as string; }
   catch { return "?"; }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kaizen-agent",
-  "version": "1.17.0",
+  "version": "1.19.0",
   "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/spec-build.md

@@ -86,6 +86,9 @@ commands to start it locally and the URL to open, copied from the material's own
 where one exists. For anything else — a document, copy, a runbook, a memo — the path
 to open, or the result itself when it fits in a screen. The board shows this section on
 the run's card, so a person can try the work without reading the rest of the report.
+Where the result can be seen, put screenshots of it here: save each under
+`runs/<id>/attachments/` (letters, digits, `.`, `-`, `_` only) and embed it as
+`![what it shows](attachments/<name>.png)`; the board shows them in the Preview tab.
 
 It also says how to test the result, under a `### How to test` subhead: numbered steps a
 person follows to check the run did what was asked, each an action and what they should

package/web/board.html

@@ -35,11 +35,12 @@ select.sel,button.sel{cursor:pointer;appearance:none;padding-right:30px;max-widt
 /* project picker: a select-shaped button over a searchable list */
 .combo{position:relative;max-width:100%;display:flex}
 .combo .menu-pop{left:0;right:auto;top:calc(100% + 4px);width:320px;max-width:calc(100vw - 32px);gap:6px;z-index:9}
-.combo .menu-pop[hidden]{display:none}
+.combo[hidden],.combo .menu-pop[hidden]{display:none}
 .combo input.sel{width:100%;max-width:none}
 #projs{display:flex;flex-direction:column;max-height:300px;overflow-y:auto}
 #projs button{display:block;flex:none;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
 #projs button.on{background:var(--hover)}
+#shows{display:flex;flex-direction:column;max-height:300px;overflow-y:auto}#shows label{display:flex;gap:8px;align-items:center;padding:6px 10px;font-size:13px;border-radius:var(--r-s);cursor:pointer;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}#shows label:hover{background:var(--hover)}#shows .grp{padding:8px 10px 4px;font-size:11px;color:var(--dim)}
 #projs .grp{padding:8px 10px 4px;font-size:11px;color:var(--dim)}
 .sp{flex:1}
 .ib{width:34px;height:34px;display:grid;place-items:center;color:var(--dim);border-radius:var(--r-s);transition:background .12s,color .12s}
@@ -86,6 +87,7 @@ ul{list-style:none;margin:0;padding:8px 0 0;display:flex;flex-direction:column;g
 .card.menu{z-index:2}
 .card.open{border-color:var(--accent);box-shadow:0 0 0 1px var(--accent)}
 .card.archived .c-title,.card.archived .c-id{opacity:.7}
+section h2 .ord{min-height:22px;padding:0 8px;font-weight:500}
 section h2 .clear{margin-left:auto;min-height:22px;padding:0 8px}
 .clear-pop{top:30px;right:0;min-width:200px}
 .clear-pop button i{font-style:normal;color:var(--dim);margin-left:auto;background:none;padding:0}
@@ -137,6 +139,8 @@ section h2 .clear{margin-left:auto;min-height:22px;padding:0 8px}
 .inl input::placeholder,.inl textarea::placeholder,.notes textarea::placeholder{color:var(--dim)}
 .inl .row,.notes .row{display:flex;gap:6px;justify-content:flex-end}
 .notes{display:flex;flex-direction:column;gap:8px}
+#pbody img{max-width:100%;border-radius:var(--r-s)}
+.desc{border-bottom:1px solid var(--line);padding-bottom:6px;margin-bottom:14px}.desc h3{margin-top:14px}
 .chat{display:flex;flex-direction:column;gap:10px;margin:0 0 14px}.msg{border:1px solid var(--line);border-radius:var(--r);padding:10px 12px;background:var(--bg)}.msg time{display:block;font-size:11px;color:var(--dim);margin-bottom:4px}.msg p:last-child{margin-bottom:0}.msg img{max-width:100%;max-height:260px;border-radius:var(--r-s);display:block;margin:4px 0}
 .notes .tools{display:flex;gap:6px;align-items:center}.notes .tools span{flex:1;font-size:11px;color:var(--dim)}.notes .att{font-size:11px;color:var(--dim)}
 .inl pre.files{margin:0;max-height:140px;overflow:auto;font:12px/1.5 var(--mono);color:var(--dim)}
@@ -329,6 +333,7 @@ aside .foot .more .menu-pop{left:0;right:auto;top:auto;bottom:calc(100% + 4px)}.
 <span>█▀▄  █▀█  █   ▄▀  ██▄  █ ▀█</span>
 <span>█ █  █ █  █  █▄▄  █▄▄  █  █</span></pre>
   <div class="combo" id="combo"><button class="sel" id="proj" aria-label="project" aria-haspopup="listbox" aria-expanded="false"></button><div class="menu-pop" id="projpop" hidden><input class="sel" id="projq" aria-label="Search projects" placeholder="Search projects…" spellcheck="false" autocomplete="off"><div id="projs" role="listbox"></div></div></div>
+  <div class="combo" id="showc" hidden><button class="sel" id="show" aria-label="Projects shown" aria-haspopup="true" aria-expanded="false"></button><div class="menu-pop" id="showpop" hidden><input class="sel" id="showq" aria-label="Search projects" placeholder="Search projects…" spellcheck="false" autocomplete="off"><div id="shows"></div><button id="showall">Show all</button></div></div>
   <span class="sp"></span>
   <button class="btn pri" id="newtop">New idea</button>
   <a class="ib" href="/notebook" title="Notebook" aria-label="Notebook"><svg><use href="#i-note"/></svg></a>
@@ -446,6 +451,8 @@ let S={project:null,projects:[],cards:[],now:Date.now(),all:false};
 let all=new URLSearchParams(location.search).get("all")!=="0",openKey=null,mode=null,modeKey=null,filter=null,menuKey=null,tab=0,runDoc=null;
 // A column shows this many cards, then a "more" line; Done is where it matters.
 const FOLD=6;const unfolded=new Set();
+// Per column: "old" puts the oldest first; anything else is newest first.
+let order=(()=>{try{return JSON.parse(localStorage.getItem("kz-order"))||{}}catch(e){return{}}})();
 let archive=false;
 let clearMenu=false,picking=false;const picked=new Set();     // Clear on Done: menu, then cherry-pick mode                                   // showing the archive instead of the board
 // The server writes notifier() from state.ts over the marker: one rule for both UIs.
@@ -501,7 +508,7 @@ function card(c){
  if(c.git){const t=c.git==="pushed"?"Committed & pushed":"Not committed & pushed yet";chips.push(`<span class="chip ${c.git==="pushed"?"ok":"warn"}" role="img" title="${t}" aria-label="${t}"><svg><use href="#c-git"/></svg></span>`)}
  const pick=picking&&!archive&&c.column===4;
  el.innerHTML=(pick?`<input type="checkbox" class="pick" ${picked.has(k)?"checked":""} aria-label="Select">`:"")+`<div class="c-id"><span class="st d-${st}"><svg><use href="#s-${st}"/></svg></span><span class="idt">${esc(idt)}</span><span class="age">${c.kind==="run"?age(c.moved||S.now,S.now):""}</span><button class="ib sm more" data-a="menu" title="Actions" aria-label="Actions" aria-haspopup="menu" aria-expanded="${k===menuKey}">${ico("more")}</button></div>
-  <div class="c-title">${esc(c.kind==="idea"?c.text:(c.title||c.id))}</div>
+  <div class="c-title"${c.kind==="idea"&&brief(c.text).parts.length?` title="${esc(c.text)}"`:""}>${esc(c.kind==="idea"?brief(c.text).head:(c.title||c.id))}</div>
   <div class="c-chips">${chips.join("")}</div>`;
  if(k===menuKey){
   const items=[];
@@ -581,7 +588,9 @@ function render(){
  if(!mode)undraft("f:");try{sessionStorage.setItem("kz-form",JSON.stringify(["new","edit","reject"].includes(mode)?[mode,modeKey]:null))}catch(e){}
  // The board is rebuilt below; the card that had focus gets it back.
  const fk=focusedKey();
- const cs=S.cards.filter(c=>c.archived===archive),b=$("board");b.innerHTML="";
+ // All projects: only the ones ticked in the filter, or every one when none is.
+ const only=all&&shown.size&&showable().some(p=>shown.has(p.dir));
+ const cs=S.cards.filter(c=>c.archived===archive&&(!only||shown.has(c.state))),b=$("board");b.innerHTML="";
  const nArch=S.cards.filter(c=>c.archived).length;
  const n=s=>cs.filter(c=>c.status===s).length;
  const strip=[];
@@ -595,16 +604,21 @@ function render(){
  PL=[["All projects","all"],...S.projects.map(p=>[p.label,p.dir]),...S.fresh.map(p=>[p.label,p.dir,1]),["Find projects on this PC…","__find"]];
  $("proj").textContent=all||!S.dir?"All projects":(PL.find(p=>p[1]===S.dir)||["All projects"])[0];
  if(!$("projpop").hidden)list();
+ $("showc").hidden=!all;const sp=showable(),ns=sp.filter(p=>shown.has(p.dir)).length;$("show").textContent=ns?`Showing ${ns} of ${sp.length}`:"Showing all";
+ if(!$("showpop").hidden)showList();
  if(!cs.length&&mode!=="new"){b.innerHTML=archive?'<div class="empty"><div class="mascot"></div><b>Nothing archived</b></div>':'<div class="empty"><div class="mascot"></div><b>Nothing here yet</b><p>Add an idea and kaizen will plan it, build it, and check the result.</p><button class="btn pri" id="newempty">New idea</button></div>';if(!archive)$("newempty").onclick=()=>{mode="new";render()};}
  COLS.forEach((name,ci)=>{
   const s=document.createElement("section");const list=cs.filter(c=>c.column===ci&&(!filter||c.status===filter));
+  // Runs age by their last move, ideas by inbox position (new ones are appended).
+  if(ci<4){const at=c=>c.kind==="run"?c.moved||0:S.cards.indexOf(c),old=order[ci]==="old";list.sort((a,b)=>old?at(a)-at(b):at(b)-at(a))}
   const clearable=ci===4&&!archive&&list.length;
   const olderThan=days=>list.filter(c=>S.now-(c.moved||S.now)>days*d);
-  let head=`<h2>${name}<i>${list.length||""}</i>${ci===0&&!archive?`<button class="ib sm" title="New idea" aria-label="New idea">${ico("plus")}</button>`:""}`;
+  let head=`<h2>${name}<i>${list.length||""}</i>${ci<4&&list.length>1?`<button class="btn sm ghost ord" title="Sort order">${order[ci]==="old"?"Oldest":"Newest"}</button>`:""}${ci===0&&!archive?`<button class="ib sm" title="New idea" aria-label="New idea">${ico("plus")}</button>`:""}`;
   if(clearable&&picking)head+=`<span class="pickbar"><button class="btn sm ghost" data-p="cancel">Cancel</button><button class="btn sm pri" data-p="go" ${picked.size?"":"disabled"}>Archive ${picked.size||""}</button></span>`;
   else if(clearable)head+=`<button class="btn sm ghost clear" title="Archive finished runs">Clear ▾</button>`;
   if(clearable&&clearMenu)head+=`<div class="menu-pop clear-pop"><button data-c="7">Older than a week <i>${olderThan(7).length}</i></button><button data-c="3">Older than 3 days <i>${olderThan(3).length}</i></button><button data-c="0">Everything <i>${list.length}</i></button><hr><button data-c="pick">Pick which…</button></div>`;
   s.innerHTML=head+`</h2>`;
+  {const o=s.querySelector(".ord");if(o)o.onclick=e=>{e.stopPropagation();order[ci]=order[ci]==="old"?"new":"old";try{localStorage.setItem("kz-order",JSON.stringify(order))}catch(e){}render()}}
   if(ci===0&&!archive)s.querySelector(".ib").onclick=()=>{mode="new";render()};
   if(clearable){
    const cl=s.querySelector(".clear");if(cl)cl.onclick=e=>{e.stopPropagation();clearMenu=!clearMenu;render()};
@@ -645,7 +659,7 @@ const tabOf=k=>TABS.findIndex(t=>t[1]===k);
 // keepTab: a link already chose the tab.
 function open(c,keepTab){
  stopDictation(true); // the panel body is about to be replaced
- fixOff.clear();openKey=key(c);$("panel").classList.add("open");$("scrim").classList.add("on");$("ptitle").textContent=c.text;render();
+ fixOff.clear();openKey=key(c);$("panel").classList.add("open");$("scrim").classList.add("on");$("ptitle").textContent=c.kind==="idea"?brief(c.text).head:c.text;render();
  if(c.kind==="idea"){runDoc=null;$("psub").textContent="Idea · "+c.where;$("ptabs").innerHTML="";chat(c,c.notes,c.archived||c.status!=="idea");
   const foot=$("pfoot");foot.innerHTML=c.archived?`<button class="btn pri" data-a="restore">Restore</button>`:c.status==="idea"?`<button class="btn ghost danger" data-a="delete">Delete</button><button class="btn ghost" data-a="archive">Archive</button><span class="dec"><button class="btn" data-a="reject">Reject</button><button class="btn" data-a="edit">Edit</button><button class="btn pri" data-a="run">Run</button></span>`:`<span class="note">Starting: a run was launched for this idea. No terminal with your agent? Run it again.</span><span class="dec"><button class="btn" data-a="run">Run again</button></span>`;
   foot.querySelectorAll("[data-a]").forEach(b=>b.onclick=()=>{const a=b.dataset.a;if(a==="archive"||a==="restore"){toggleArchive(c,a==="archive");return}const k=key(c);close();mode=a;modeKey=k;render()});return}
@@ -655,10 +669,10 @@ function open(c,keepTab){
 function parseNotes(src){const out=[];for(const raw of (src||"").split("\n")){const m=/^\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2})\]\s?(.*)$/.exec(raw);if(m){out.push({at:m[1],text:m[2]});continue}const last=out[out.length-1];if(last)last.text+="\n"+raw.replace(/^\s{2}/,"");else if(raw.trim())out.push({at:"",text:raw})}return out.map(n=>({...n,text:n.text.trim()})).filter(n=>n.text)}
 let nfocus=null;
 function chat(c,src,ro){
- const base=c.kind==="run"?`runs/${c.id}/`:"";
- const fix=t=>t.replace(/\]\((attachments\/[^)]+)\)/g,(_,p)=>`](/file?dir=${encodeURIComponent(c.state)}&p=${encodeURIComponent(base+p)})`);
+ const fix=t=>attach(t,c);
  const entries=parseNotes(src);
- let h=`<div class="chat">${entries.map(n=>`<div class="msg">${n.at?`<time>${esc(n.at)}</time>`:""}${md(fix(n.text))}</div>`).join("")||`<p style="color:var(--dim)">No notes yet.</p>`}</div>`;
+ const b=c.kind==="idea"?brief(c.text):{parts:[]};
+ let h=(b.parts.length?`<section class="desc">${md(b.parts.map(p=>`### ${p.label}\n${p.body}`).join("\n\n"))}</section>`:"")+`<div class="chat">${entries.map(n=>`<div class="msg">${n.at?`<time>${esc(n.at)}</time>`:""}${md(fix(n.text))}</div>`).join("")||`<p style="color:var(--dim)">No notes yet.</p>`}</div>`;
  if(!ro)h+=`<div class="notes"><textarea placeholder="Add a note. Paste a screenshot, or attach files."></textarea><div class="att" id="natt"></div><div class="tools"><input type="file" id="nfile" multiple hidden><button class="btn ghost" id="npick">Attach</button><span>Enter sends, Shift+Enter newline</span><button class="btn pri" id="nsend">Send</button></div></div>`;
  $("pbody").innerHTML=h;
  if(ro)return;
@@ -681,6 +695,8 @@ function chat(c,src,ro){
 // "## Commit" is the message the builder wrote for the work, offered at commit and push.
 function section(impl,name){const m=impl&&impl.match(new RegExp(`^##\\s+${name}\\s*\\n([\\s\\S]*?)(?=\\n##\\s|$(?![\\s\\S]))`,"m"));return m?m[1].trim():null}
 const preview=impl=>section(impl,"Preview");
+// Links to a card's attachments/ (notes, or screenshots the builder put in Preview) via /file.
+const attach=(t,c)=>t.replace(/\]\((attachments\/[^)]+)\)/g,(_,p)=>`](/file?dir=${encodeURIComponent(c.state)}&p=${encodeURIComponent((c.kind==="run"?`runs/${c.id}/`:"")+p)})`);
 const commitMsg=impl=>(section(impl,"Commit")||"").replace(/^```\w*\n|\n```$/g,"").trim();
 // A plan's Open questions as a pick list: `Q: question` lines with `- option` lines under
 // each, "(recommended)" marking the default and "multi-select" in the question allowing
@@ -717,7 +733,7 @@ async function openRun(c,refresh,again){
  const tabs=TABS;
  $("ptabs").innerHTML=tabs.map((t,i)=>`<button class="${i===tab?"on":""}" data-i="${i}">${t[0]}</button>`).join("");
  [...$("ptabs").children].forEach(b=>b.onclick=()=>{tab=+b.dataset.i;openRun(c,true)});
- const k=tabs[tab][1],doc=k==="preview"?preview(runDoc.impl):runDoc[k];
+ const k=tabs[tab][1],doc=k==="preview"?(preview(runDoc.impl)&&attach(preview(runDoc.impl),c)):runDoc[k];
  if(k==="notes"){const ro=c.archived||c.status==="done"||c.status==="abandoned";
   chat(c,doc,ro);}
  else $("pbody").innerHTML=doc?md(doc,k==="backlog"):`<p style="color:var(--dim)">No ${({request:"request",plan:"plan",impl:"work report",preview:"preview",review:"review",backlog:"backlog"})[k]} yet.</p>`;
@@ -831,6 +847,22 @@ async function commitPush(c,message,b){b.disabled=true;b.dataset.busy=1;b.textCo
 async function toggleArchive(c,archived){const r=await post("/archive",c.kind==="idea"?{dir:c.state,text:c.text,archived}:{dir:c.state,id:c.id,archived});if(r.ok)toast(archived?"Archived":"Restored");close();load()}
 function close(){const k=openKey;stopDictation(true);openKey=null;runDoc=null;$("panel").classList.remove("open");$("scrim").classList.remove("on");render();if(k)cardEl(k)?.focus({preventScroll:true})}
 $("pclose").onclick=close;$("scrim").onclick=close;
+// An idea is one inbox line, so a structured request arrives as one wall:
+// "Fix x Problem: … Scope: … Acceptance criteria: (1) … (2) …". Split it, for display
+// only, into the text before the first label and one part per label; inline (1) (2)
+// become a numbered list. Fewer than two labels is plain text and is left whole.
+function brief(t){
+ // A label opens a sentence; only the first may follow the head without punctuation,
+ // and then only as one word ("… previews Problem:"), so "the Board shows: x" is prose.
+ const re=/(^|[.!?)]\s+|\s)([A-Z][\w-]*(?: [a-z][\w-]*){0,3}):\s+/g,cut=[];let m;
+ while((m=re.exec(t)))if(!/^\s+$/.test(m[1])||(!cut.length&&!m[2].includes(" ")))cut.push([m.index+m[1].length,m[2],re.lastIndex]);
+ if(cut.length<2)return {head:t,parts:[]};
+ // Inline (1) (2) … become a list; numbers that do not run 1, 2, 3 keep their own text.
+ const parts=cut.map(([,label,from],i)=>{const body=t.slice(from,i+1<cut.length?cut[i+1][0]:t.length).trim(),n=body.split(/\s*\((\d+)\)\s+/);
+  if(n.length<5)return {label,body};const its=[];for(let k=1;k<n.length;k+=2)its.push([n[k],n[k+1]]);
+  const seq=its.every(([d],k)=>+d===k+1);
+  return {label,body:(n[0]?n[0]+"\n":"")+its.map(([d,x],k)=>seq?`${k+1}. ${x}`:`- (${d}) ${x}`).join("\n")}});
+ return {head:t.slice(0,cut[0][0]).trim()||`${parts[0].label}: ${t.slice(cut[0][2],cut[1][0]).trim()}`,parts}}
 
 // Enough markdown for kaizen's own files: headings, lists, fences, tables,
 // inline code, bold. Everything is escaped first. With `tick`, a backlog item
@@ -986,6 +1018,21 @@ async function pick(v){
  else if(v==="all"){all=true;keep()}
  else{const j=await post("/cd",{dir:v});if(j.ok){all=false;keep(v)}}
  load()}
+// The all-projects filter: tick the projects to show; none ticked shows every one. Kept per browser.
+let shown=new Set((()=>{try{return JSON.parse(localStorage.getItem("kz-show"))||[]}catch(e){return[]}})());
+// Known projects, plus any folder a card comes from that is not one (the global inbox).
+function showable(){const l=[...S.projects];for(const c of S.cards)if(!l.some(p=>p.dir===c.state))l.push({dir:c.state,label:c.where});return l}
+let SP=[];
+function showList(){const q=$("showq").value.trim().toLowerCase();SP=showable();
+ $("shows").innerHTML=SP.map((p,i)=>p.label.toLowerCase().includes(q)?`<label title="${esc(p.label)}"><input type="checkbox" data-i="${i}" ${shown.has(p.dir)?"checked":""}>${esc(p.label)}</label>`:"").join("")||`<div class="grp">No match</div>`}
+function setShown(){try{localStorage.setItem("kz-show",JSON.stringify([...shown]))}catch(e){}render()}
+$("show").onclick=()=>{const on=$("showpop").hidden;$("showpop").hidden=!on;$("show").setAttribute("aria-expanded",on);if(on){$("showq").value="";showList();$("showq").focus()}};
+$("showq").oninput=showList;
+$("showq").onkeydown=e=>{if(e.key==="Escape"){$("showpop").hidden=true;$("show").setAttribute("aria-expanded",false);$("show").focus()}};
+// render() redraws the list; the ticked box keeps keyboard focus.
+$("shows").onchange=e=>{const i=e.target.dataset.i,d=SP[i]?.dir;if(!d)return;e.target.checked?shown.add(d):shown.delete(d);setShown();$("shows").querySelector(`[data-i="${i}"]`)?.focus()};
+$("showall").onclick=()=>{shown.clear();setShown()};
+document.addEventListener("click",e=>{if(!e.target.closest("#showc")){$("showpop").hidden=true;$("show").setAttribute("aria-expanded",false)}});
 $("newtop").onclick=()=>{mode="new";render();$("board").scrollTo(0,0)};
 $("settings").onclick=()=>{setQ="";openSettings()};$("sources").onclick=openSources;
 try{const t=localStorage.getItem("kz-theme");if(t)document.documentElement.dataset.theme=t}catch(e){}