kaizen-agent 1.34.12 → 1.36.0

package/agents/kaizen-builder.md

@@ -68,7 +68,11 @@ change — do not refactor around it. Write what you changed to
 - **Verification** — each check carried out, with its actual result. Quote failures.
 - **Not done** — steps skipped, out-of-scope observations, known gaps.
 - **Preview** — how to see the result: commands to run it locally and the URL for an
-  app; the path to open, or the result itself, for anything else. Then `### How to test`:
+  app; the path to open, or the result itself, for anything else. It must embed at
+  least one screenshot of the result (`![…](attachments/<name>.png)`, saved under
+  `runs/<id>/attachments/`, e.g. `playwright screenshot <url> <path>`) whenever it shows on
+  a screen. On a revise of a run that already shows screenshots, retake them so
+  none shows the result from before the change. Then `### How to test`:
   numbered steps from the plan's gate, each an action and what the person should see,
   plus any test command with its expected result. `###` subheads only — the board ends
   the section at the next `##`. The board shows it.

package/cli/browser.ts

@@ -220,7 +220,9 @@ export async function readPage(page: Page, url: string, platform: string, max =
   const re = POST[platform]!;
   await page.go(url);
   if (!onPlatform(await page.js<string>("location.href")) || (await page.js<boolean>(WALL))) return { ok: false, note: signInNote(platform) };
-  if (await page.js<boolean>(CHECK)) return { ok: false, note: checkNote(platform) };
+  // TikTok lays a closable check over posts it has already shown: close it and read on.
+  // A check that leaves no posts still fails below.
+  await page.js(`document.querySelector("#captcha_close_button")?.click()`);
   const seen = new Map<string, { link: string; text: string; date: string; author?: string; images?: string[] }>();
   for (let i = 0, still = 0; i < 12 && seen.size < max && still < 3; i++) {
     const before = seen.size;

package/cli/install.ts

@@ -91,6 +91,20 @@ if (Bun.argv[2] === "browser") {
   process.exit(0);
 }
 
+// `kaizen card add "<text>" [--parent <run id>]`: what a run files as new work, linked
+// to the run it came from.
+if (Bun.argv[2] === "card") {
+  const { locate, label, addCard } = await import("./state.ts");
+  const state = locate() ?? join(home, ".kaizen");
+  const args = Bun.argv.slice(4), at = args.indexOf("--parent");
+  const parent = at >= 0 ? args.splice(at, 2)[1] : undefined;
+  if (Bun.argv[3] !== "add" || !args.length || (at >= 0 && !parent)) { console.log(`\n  kaizen card add "<text>" [--parent <run id>]\n`); process.exit(1); }
+  const r = addCard(state, args.join(" "), parent);
+  if (typeof r === "string") { console.log(`\n  ${r}\n`); process.exit(1); }
+  console.log(`\n  ${c.green("added")}  ${args.join(" ")}\n  ${c.dim(`parent ${r.parent}  ·  project ${label(state)}`)}\n`);
+  process.exit(0);
+}
+
 if (Bun.argv[2] === "sources" || Bun.argv[2] === "gather" || Bun.argv[2] === "icebox") {
   const { locate, label } = await import("./state.ts");
   const src = await import("./sources.ts");

package/cli/logo.test.ts

@@ -0,0 +1,18 @@
+import { test, expect } from "bun:test";
+import { mkdtempSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { projectLogo } from "./logo.ts";
+
+test("projectLogo finds a fixed-name logo and nothing else", () => {
+  const root = mkdtempSync(join(tmpdir(), "kz-logo-"));
+  mkdirSync(join(root, ".kaizen"));
+  expect(projectLogo(join(root, ".kaizen"))).toBeNull();
+  writeFileSync(join(root, "brand.png"), "x");
+  expect(projectLogo(join(root, ".kaizen"))).toBeNull();
+  mkdirSync(join(root, "public"));
+  writeFileSync(join(root, "public", "favicon.svg"), "<svg/>");
+  expect(projectLogo(join(root, ".kaizen"))).toBe(join(root, "public", "favicon.svg"));
+  writeFileSync(join(root, "logo.png"), "x");
+  expect(projectLogo(join(root, ".kaizen"))).toBe(join(root, "logo.png"));
+});

package/cli/logo.ts

@@ -0,0 +1,20 @@
+// A project's logo, when it has one: the first of a fixed list of files in the project
+// folder (the parent of its .kaizen). Fixed names only, so the board never serves a path
+// a request chose.
+import { existsSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+export const LOGO_TYPES: Record<string, string> = { png: "image/png", svg: "image/svg+xml", jpg: "image/jpeg", webp: "image/webp", ico: "image/x-icon" };
+const NAMES = ["logo", "icon", "favicon"];
+const DIRS = ["", "assets", "public", "static", ".github", "docs", "web"];
+
+export function projectLogo(stateDir: string): string | null {
+  const root = dirname(stateDir);
+  for (const d of DIRS)
+    for (const n of NAMES)
+      for (const e of Object.keys(LOGO_TYPES)) {
+        const f = join(root, d, `${n}.${e}`);
+        try { if (existsSync(f) && statSync(f).isFile() && statSync(f).size < 2_000_000) return f; } catch {}
+      }
+  return null;
+}

package/cli/state.test.ts

@@ -8,7 +8,7 @@ import { issueUrl, systemInfo, scrubHome, REPO_URL, home as realHome, trustFolde
 import * as stateModule from "./state.ts";
 import {
   readRuns, readInbox, writeInbox, replaceIdea, moveIdea, abandonRun, allBacklog, backlog,
-  requestTitle, statusOf, columnOf, parseItem, startedRuns, boardCards, readArchive, setArchived,
+  requestTitle, statusOf, columnOf, parseItem, startedRuns, boardCards, parentOf, addCard, readArchive, setArchived,
   requestOf, agentFlags, plainModel, readNotes, writeNotes, manualCommand, parseNotes, formatNote, appendNote, saveAttachment,
   reviewFindings, pickFindings, fixPrompt, approvalPrompt, sessionLaunch, closeSessions, sweepSessions, readSessions, ownerOf, CLOSE_GRACE_MS, gitStatus, runGit, cardsGit, commitPush, readCommit, findTerminal, nativePath, pruneRuns, unrechecked, notice, notifier, notifyArgs, LOGO, type Card,
 } from "./state.ts";
@@ -1047,3 +1047,31 @@ test("requestTitle: drops the launch command, keeps the first sentence, caps at
   expect(requestTitle("/kaizen lite simplify the card. Then more words")).toBe("simplify the card.");
   expect(requestTitle("x".repeat(200)).length).toBe(90);
 });
+
+test("parent/child: a Parent line links a run and an idea to the run that filed them", () => {
+  expect(parentOf("do x\nFollow-up of: 2026-01-01-a.")).toBe("2026-01-01-a");
+  expect(parentOf("  [2026-10-18 20:57] Parent: 2026-01-01-a")).toBe("2026-01-01-a");
+  expect(parentOf("no parent here")).toBeUndefined();
+  const st = join(mkdtempSync(join(tmpdir(), "kaizen-pc-")), ".kaizen");
+  for (const [id, req] of [["2026-01-01-a", "parent work"], ["2026-01-02-b", "child work\nParent: 2026-01-01-a"]]) {
+    mkdirSync(join(st, "runs", id), { recursive: true });
+    writeFileSync(join(st, "runs", id, "00-request.md"), req + "\n");
+    writeFileSync(join(st, "runs", id, "state.json"), JSON.stringify({ stage: "done", awaiting: null }));
+  }
+  writeFileSync(join(st, "inbox.md"), "# Inbox\n\n- open: follow-on idea\n  Parent: 2026-01-01-a\n");
+  const cards = boardCards([st], Date.now());
+  expect(cards.find((k) => k.id === "2026-01-01-a")!.children).toEqual(["2026-01-02-b"]);
+  expect(cards.find((k) => k.id === "2026-01-02-b")!.parent).toBe("2026-01-01-a");
+  expect(cards.find((k) => k.kind === "idea")!.parent).toBe("2026-01-01-a");
+  // The done child is noted in its parent once, however often the board refreshes.
+  boardCards([st], Date.now());
+  expect(readFileSync(join(st, "runs", "2026-01-01-a", "notes.md"), "utf8").match(/Child 2026-01-02-b done: child work/g)!.length).toBe(1);
+  // card add: no run in flight, so a parent must be named.
+  expect(addCard(st, "next thing")).toMatch(/no run in flight/);
+  writeFileSync(join(st, "runs", "2026-01-02-b", "state.json"), JSON.stringify({ stage: "build", awaiting: null }));
+  expect(addCard(st, "next thing")).toEqual({ parent: "2026-01-02-b" });
+  expect(addCard(st, "next thing")).toMatch(/already/);
+  expect(addCard(st, "other", "nope")).toMatch(/no such run/);
+  expect(boardCards([st], Date.now()).find((k) => k.text === "next thing")!.parent).toBe("2026-01-02-b");
+  rmSync(dirname(st), { recursive: true, force: true });
+});

package/cli/state.ts

@@ -615,8 +615,16 @@ export type Card = {
   branch?: string;                                 // runs only: the run's own branch while it has a worktree
   tags?: string[];                                 // runs only: runner, agent, "yolo", "unrechecked"
   notes?: string;                                  // inbox notes, or runs/<id>/notes.md
+  parent?: string;                                 // the run this card was filed from
+  children?: string[];                             // runs only: runs that name this one as parent
 };
 
+// A `Parent: <run id>` line (or the older `Follow-up of: <run id>`) in a request or
+// an idea's notes is what links a card to the run it came from.
+export function parentOf(text?: string) {
+  return /^\s*(?:\[[^\]]*\]\s*)?(?:Parent|Follow-up of):\s*(\S+)/im.exec(text ?? "")?.[1]?.replace(/[.,]$/, "");
+}
+
 // A run is called running on the evidence that it moved recently; there is no PID
 // to ask. Anything in flight and older than this is stalled, not running -- the
 // difference the board exists to show.
@@ -770,6 +778,20 @@ export function appendNote(state: string, target: { id: string } | { text: strin
   return null;
 }
 
+// A card filed by a run: an open idea whose note names the run as its parent. The
+// parent is the one named, else the newest run still in flight.
+export function addCard(state: string, text: string, parent?: string): { parent: string } | string {
+  text = text.trim().replace(/\s+/g, " ");
+  if (!text) return "empty card";
+  const id = parent ?? readRuns(state).find((r) => r.stage !== "done" && r.stage !== "abandoned")?.id;
+  if (!id) return "no run in flight to be its parent; pass --parent <run id>";
+  if (!existsSync(join(state, "runs", id, "state.json"))) return `no such run: ${id}`;
+  const lines = readInbox(state);
+  if (lines.some((l) => l.status === "open" && l.text === text)) return "that card is already on the board";
+  writeInbox(state, [...lines, { status: "open", text, notes: `Parent: ${id}` }]);
+  return { parent: id };
+}
+
 // A file beside the notes it belongs to: runs/<id>/attachments/ for a run,
 // <state>/attachments/ for an idea. Returns the path relative to the state dir,
 // which is what the note links and what /file serves.
@@ -966,8 +988,8 @@ export function boardCards(states: string[], now: number): Card[] {
       const t = normalise(it.text);
       if (it.status === "started" ? requests.some((r) => r.includes(t)) : lines.some((l) => l === t || l.endsWith(" " + t))) continue;
       next.push(it.status === "started"
-        ? { kind: "idea", status: "starting", text: it.text, state: st, where, column: 1, awaiting: null, dim: true, archived: false, notes: it.notes }
-        : { kind: "idea", status: "idea", text: it.text, state: st, where, column: 0, awaiting: null, dim: false, archived: it.status === "archived", notes: it.notes });
+        ? { kind: "idea", status: "starting", text: it.text, state: st, where, column: 1, awaiting: null, dim: true, archived: false, notes: it.notes, parent: parentOf(it.notes) }
+        : { kind: "idea", status: "idea", text: it.text, state: st, where, column: 0, awaiting: null, dim: false, archived: it.status === "archived", notes: it.notes, parent: parentOf(it.notes) });
     }
     // Runs started in Yolo. Only yolo records are matched to runs, so a project that
     // never used it pays one directory read.
@@ -982,9 +1004,20 @@ export function boardCards(states: string[], now: number): Card[] {
         branch: r.branch,
         tags: [r.runner, r.agent, yolos.has(r.id) ? "yolo" : undefined, unrechecked(st, r.id) ? "unrechecked" : undefined].filter((t): t is string => !!t),
         notes: readNotes(st, r.id) || undefined,
+        parent: parentOf(body(st, r.id)),
       });
     }
   }
+  for (const k of next) if (k.kind === "run") {
+    const kids = next.filter((c) => c.kind === "run" && c.parent === k.id && c.state === k.state);
+    if (kids.length) k.children = kids.map((c) => c.id!);
+    // A child that is done tells its parent once, so the parent has it on record
+    // whether or not the agent remembered to.
+    for (const c of kids) if (c.status === "done" && !(k.notes ?? "").includes(`Child ${c.id} done`)) {
+      const line = `Child ${c.id} done: ${c.title || c.text}`;
+      if (!appendNote(k.state, { id: k.id! }, line)) k.notes = (k.notes ? k.notes + "\n" : "") + line;
+    }
+  }
   // Done reads newest first: by `moved`, the time each card prints as its age.
   // Sorted into the slots the done cards already hold, so no other card moves.
   const done = next.filter((k) => k.column === 4).sort((a, b) => (b.moved ?? 0) - (a.moved ?? 0));

package/cli/web.ts

@@ -11,6 +11,7 @@ import {
 } from "./state.ts";
 import { attachPty, writePty, resizePty, ptyState, ptyKeys, adoptLoginEnv } from "./pty.ts";
 import { readSources, addSource, removeSource, moveSource, setCategory, setWriteback, readIcebox, promote, dismiss, restore, markDone, markReplied, gatherSource, freshImages, gatherAll, gatherDirs, due, socialUrl, socialOf } from "./sources.ts";
+import { projectLogo, LOGO_TYPES } from "./logo.ts";
 import * as chatgpt from "./chatgpt.ts";
 import * as google from "./google.ts";
 import { writeBacks } from "./writeback.ts";
@@ -76,6 +77,23 @@ export function newer(a: string, b: string) {
   return false;
 }
 
+// What each newer release brings, for the update bar's What's new: the GitHub release
+// titles ("v1.35.0: project logos, ...") above `from`, newest first. Cached like
+// npmLatest; GitHub unreachable gives none and the bar shows no What's new.
+let rel: { list: { v: string; text: string }[]; at: number } = { list: [], at: 0 };
+async function releaseNotes(from: string, fresh = false) {
+  if (fresh || !rel.list.length || Date.now() - rel.at > 6 * 3600_000) {
+    try {
+      const r = await fetch("https://api.github.com/repos/hfadhlullah/kaizen/releases?per_page=30", { signal: AbortSignal.timeout(10000) });
+      const list = ((await r.json()) as { tag_name: string; name?: string }[])
+        .map((x) => ({ v: x.tag_name.replace(/^v/, ""), text: (x.name || "").replace(/^v?[\d.]+:\s*/, "") }))
+        .filter((x) => x.text);
+      rel = { list, at: Date.now() };
+    } catch {}
+  }
+  return rel.list.filter((x) => newer(x.v, from));
+}
+
 type Opts = { port?: number; open?: boolean };
 
 export async function web(repoDir: string, opts: Opts = {}) {
@@ -229,7 +247,13 @@ export async function web(repoDir: string, opts: Opts = {}) {
       if (ms) for (const dir of states(true)) {
         let list;
         try { list = readSources(dir); } catch { continue; }   // unreadable: left as it is
-        for (const s of list) if (due(s, ms, Date.now()) && (await gatherSource(dir, s.url)).added) changed();
+        // Social sources need a reader that picks posts: only ChatGPT can do that unattended.
+        const gpt = await setting("sources.agent") === "chatgpt" && chatgpt.status().connected;
+        for (const s of list) {
+          if (!due(s, ms, Date.now())) continue;
+          if (!socialOf(s.url)) { if ((await gatherSource(dir, s.url)).added) changed(); }
+          else if (gpt) { await chatgpt.gatherSource(dir, s.url, await setting("sources.model"), (await setting("sources.effort")) || "low"); changed(); }
+        }
       }
     } catch { /* the next tick tries again */ }
     busy = false;
@@ -370,6 +394,16 @@ export async function web(repoDir: string, opts: Opts = {}) {
         return new Response(Bun.file(LOGO), { headers: { "content-type": "image/png", "cache-control": "max-age=86400" } });
       }
 
+      // A project's own logo, for the project pickers: only a known project, only the fixed
+      // names in LOGOS, sandboxed so an SVG opened directly runs nothing on this origin.
+      if (req.method === "GET" && path === "/project-logo") {
+        const dir = url.searchParams.get("dir") ?? "";
+        const f = states(true).includes(dir) ? projectLogo(dir) : null;
+        if (!f) return bad("no logo", 404);
+        const ext = f.slice(f.lastIndexOf(".") + 1).toLowerCase();
+        return new Response(Bun.file(f), { headers: { "content-type": LOGO_TYPES[ext], "content-security-policy": "sandbox", "x-content-type-options": "nosniff", "cache-control": "max-age=300" } });
+      }
+
       // Lets a phone add the board to its home screen as a standalone app.
       if (req.method === "GET" && path === "/manifest.webmanifest") {
         return new Response(JSON.stringify({
@@ -406,11 +440,14 @@ export async function web(repoDir: string, opts: Opts = {}) {
         const markable = (c: Card) => c.kind === "run" && !c.archived && (c.status === "done" || c.awaiting === "approvals.review") && c.state !== join(home, ".kaizen");
         for (const d of new Set(cards.filter(markable).map((c) => c.state)))
           marks.set(d, cardsGit(d, cards.filter((c) => markable(c) && c.state === d).map((c) => c.id!)));
+        // Open findings the panel's Fix findings form would offer, on the same runs.
+        const openFindings = (c: Card) => c.kind === "run" && !c.archived && (c.status === "done" || c.awaiting === "findings" || c.awaiting === "approvals.review") && c.state !== join(home, ".kaizen")
+          ? reviewFindings(c.state, c.id!).filter((f) => !f.done).length || undefined : undefined;
         return json({
           project, all, dir: state,
-          projects: picker.map((d) => ({ dir: d, label: label(d) })),
+          projects: picker.map((d) => ({ dir: d, label: label(d), logo: !!projectLogo(d) })),
           fresh: unset.map((d) => ({ dir: join(d, ".kaizen"), label: tilde(d) })),
-          cards: cards.map((c) => ({ ...c, notice: notice(c), git: markable(c) ? marks.get(c.state)?.[c.id!] : undefined, pty: ptyOf(c) })),
+          cards: cards.map((c) => ({ ...c, notice: notice(c), git: markable(c) ? marks.get(c.state)?.[c.id!] : undefined, open: openFindings(c), pty: ptyOf(c) })),
           now: Date.now(),
         });
       }
@@ -509,7 +546,9 @@ export async function web(repoDir: string, opts: Opts = {}) {
       // What this board runs and what npm has: the page shows an Update button on a newer one.
       if (req.method === "GET" && path === "/version") {
         const v = await npmLatest(url.searchParams.has("fresh"));
-        return json({ version: VERSION, latest: v, update: !!v && newer(v, VERSION) });
+        const update = !!v && newer(v, VERSION);
+        const notes = update ? await releaseNotes(VERSION, url.searchParams.has("fresh")) : [];
+        return json({ version: VERSION, latest: v, update, notes });
       }
 
       // `kaizen upgrade`, run here with no window, then a new board on this port: it

package/package.json

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

@@ -108,15 +108,26 @@ 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. On a `code` track this is required, not optional: run the result and attach proof.
+Every run whose result shows on a screen must put at least one screenshot of it here,
+on any track and in every runner — this is required, not optional: run the result and capture it.
 A UI (a page, a board, a terminal screen, an app window) gets a screenshot of the changed
-screen; a CLI, library or API gets the real output of the command that exercises it, pasted
-in a code block. A code report with no proof is incomplete. Save each under
+screen; a document gets one of it rendered; a CLI gets one of the terminal running it, with
+the real output also pasted in a code block. Only a result with no screen at all — a
+library, an API — may give command output alone. A report with no screenshot is incomplete. 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.
-A headless browser does it: `playwright screenshot <url> runs/<id>/attachments/<name>.png`.
+A headless browser does it: `playwright screenshot <url> runs/<id>/attachments/<name>.png`,
+or `chromium --headless --screenshot=<abs path>.png --window-size=1280,900 <url>` where
+playwright has no browser installed. A file (document, diff, output) opens as `file://<path>`.
 Where no proof can be produced, say why in one line under `## Preview`.
 
+**A revise retakes the screenshots.** When the run being revised, or the run a follow-up
+names in `Follow-up of:`, already shows screenshots in its `## Preview`, the build that
+answers the revise captures the same views again after the change. In a revised run,
+overwrite each stale image under the same name (or replace its embed) so the Preview tab
+never shows the result from before the revise; in a follow-up run, embed the new ones in
+its own `## Preview`. A view the revise removed is dropped, not left showing the old result.
+
 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
 see — "open Settings → Board, clear the field: it shows `not set`". Derive the steps

package/skills/kaizen/spec-main.md

@@ -118,3 +118,16 @@ change is that it is written down rather than spoken and discarded.
 Set `stage: "done"` in `state.json` once the user accepts.
 
 ---
+
+## Child cards
+
+A run may file new work as its own card instead of growing its scope — under either
+runner. Under `full`, subagents only suggest it in their report; the main thread files it,
+from the project folder: `kaizen card add "<the work, one line>"`. It links the card to
+the run in flight (`--parent <run id>` names another), and the link follows the card into
+the run it becomes. The board shows the parent's name on the child.
+
+When a child run reaches `done`, the board appends `Child <child id> done: <title>` to
+the parent's `notes.md` by itself. The parent documents it from there: if it is still in
+flight its next stage reads `notes.md`; if it is already `done`, the entry is the record.
+Never reopen a finished parent.

package/skills/kaizen/spec-review.md

@@ -43,9 +43,9 @@ Five checks are universal, in every track:
    now is a `high` finding at minimum, whatever else the work achieved. If the builder
    recorded no baseline, that absence is itself the finding. So is a `03-impl.md`
    without a `## Preview` section, or one without `### How to test` steps: `medium`,
-   since the user is left with no way to try the work. A `code` run whose
-   `## Preview` has no proof (screenshot for a UI, real command output otherwise) and gives
-   no reason is `high`.
+   since the user is left with no way to try the work. A run whose result
+   shows on a screen and whose `## Preview` embeds no screenshot, or a `code` run with no
+   proof at all, and that gives no reason, is `high`.
 
 5. **Acceptance** — every criterion, `G-nn` and `R-nn`, answered against the work
    rather than against `03-impl.md`, by trying to falsify it: name the concrete check

package/web/board/cards.ts

@@ -7,7 +7,7 @@ import { draft, undraft } from "./drafts.ts";
 import { COLS, ICON, MARKS, NAMES, WORD, age, d, need } from "./labels.ts";
 import { brief } from "./markdown.ts";
 import { open, toggleArchive } from "./panel.ts";
-import { ideaCombo, list, newDir, short, showList, showable } from "./projects.ts";
+import { ideaCombo, list, newDir, plogo, short, showList, showable } from "./projects.ts";
 import { askNotify, toast } from "./toast.ts";
 
 let filter = null;
@@ -31,6 +31,14 @@ const picked = new Set();
 export const key = (c) =>
   c._k || (c.kind === "idea" ? "idea:" + c.state + ":" + c.text : "run:" + c.state + ":" + c.id);
 
+// Cards filed by a run sit inside it while it is on the board and not done; once the
+// parent is done, archived or gone, they are back in their own columns.
+const kidsOf = (p) => (p.kind === "run" ? store.S.cards.filter((c) => c.parent === p.id && c.state === p.state) : []);
+const nested = (c) =>
+  !!c.parent &&
+  store.S.cards.some((p) => p.kind === "run" && p.id === c.parent && p.state === c.state && !p.archived && p.column !== 4);
+const kidsOpen = new Set();
+
 function card(c) {
   const k = key(c),
     el = document.createElement("div");
@@ -73,6 +81,9 @@ function card(c) {
   // A gathered idea's notes open with the stamp promote() writes (ingest() wrote it before
   // the icebox); its chip names the source.
   const g = c.notes && /^\[[^\]]*\] (?:Gathered from|Promoted from the icebox:) (.+?)\. Outside text/.exec(c.notes);
+  // A card filed by a run names that run; the parent itself shows nothing.
+  if (c.parent)
+    chips.push(`<span class="chip link" title="Filed by ${esc(c.parent)}">${esc(c.parent.replace(/^\d{4}-\d\d-\d\d-/, "").replace(/-/g, " "))}</span>`);
   if (c.branch) chips.push(`<span class="chip" title="Built on its own branch, ${esc(c.branch)}">branch</span>`);
   if (g) chips.push(`<span class="chip" title="From ${esc(g[1])}">gathered</span>`);
   else if (c.notes) chips.push(`<span class="chip">notes</span>`);
@@ -85,12 +96,45 @@ function card(c) {
         c.git === "pushed" ? " ok" : " warn",
       ),
     );
+  if (c.open) marks.push(mk("i-bug", `${c.open} open finding${c.open === 1 ? "" : "s"} to fix`, " warn"));
   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}" role="img" title="${esc(sttl)}" aria-label="${esc(sttl)}"><svg><use href="#s-${st}"/></svg></span><span class="idt">${esc(idt)}</span><span class="age">${c.kind === "run" ? age(c.moved || store.S.now, store.S.now) : ""}</span><button class="ib sm more" data-a="menu" title="Actions" aria-label="Actions" aria-haspopup="menu" aria-expanded="${k === store.menuKey}">${ico("more")}</button></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>
   ${chips.length || marks.length ? `<div class="c-foot"><span class="c-chips">${chips.join("")}</span><span class="c-marks">${marks.join("")}</span></div>` : ""}`;
+  const kids = kidsOf(c);
+  if (kids.length) {
+    const on = kidsOpen.has(k),
+      nDone = kids.filter((x) => x.status === "done").length,
+      wait = kids.some((x) => x.status === "waiting");
+    const box = document.createElement("div");
+    box.className = "kids";
+    box.innerHTML =
+      `<button class="kids-t" aria-expanded="${on}">${on ? "▾" : "▸"} ${kids.length} ${kids.length === 1 ? "child" : "children"}${nDone ? ` · ${nDone} done` : ""}${wait ? `<span class="kids-w" title="A child is waiting on you"></span>` : ""}</button>` +
+      (on
+        ? `<ul>${kids
+            .map((x, i) => {
+              const s = ICON[x.status] || "idea";
+              return `<li data-i="${i}" tabindex="0" role="button" title="Open"><span class="st d-${s}"><svg><use href="#s-${s}"/></svg></span><span class="kids-s">${esc(WORD[x.status] || x.status)}</span><span class="kids-n">${esc(x.kind === "idea" ? brief(x.text).head : x.title || x.id)}</span></li>`;
+            })
+            .join("")}</ul>`
+        : "");
+    box.querySelector(".kids-t").onclick = (e) => {
+      e.stopPropagation();
+      on ? kidsOpen.delete(k) : kidsOpen.add(k);
+      render();
+    };
+    box.querySelectorAll("li").forEach((li) => {
+      const go = (e) => {
+        e.stopPropagation();
+        open(kids[+li.dataset.i]);
+      };
+      li.onclick = go;
+      li.onkeydown = (e) => (e.key === "Enter" || e.key === " ") && (e.preventDefault(), go(e));
+    });
+    el.appendChild(box);
+  }
   if (k === store.menuKey) {
     const items = [];
     if (archive) {
@@ -227,7 +271,7 @@ function inlineForm(c) {
   }
   if (store.mode === "move") {
     const ps = store.S.projects.filter((p) => p.dir !== dir);
-    li.innerHTML = `<div class="q">Move "${esc(c.text)}" to</div><select class="sel" aria-label="Project">${ps.map((p) => `<option value="${esc(p.dir)}">${esc(p.label)}</option>`).join("")}</select><div class="row"><button class="btn ghost" data-a="c">Cancel</button><button class="btn pri" data-a="s">Move</button></div>`;
+    li.innerHTML = `<div class="q">Move "${esc(c.text)}" to</div><select class="sel" aria-label="Project">${ps.map((p) => `<option value="${esc(p.dir)}" title="${esc(p.label)}">${esc(short(p.label))}</option>`).join("")}</select><div class="row"><button class="btn ghost" data-a="c">Cancel</button><button class="btn pri" data-a="s">Move</button></div>`;
     li.querySelector("[data-a=s]").onclick = async () => {
       const sel = li.querySelector("select"),
         to = sel.value,
@@ -400,7 +444,10 @@ export function render() {
     ["Find projects on this PC…", "__find"],
   ];
   const cur = store.all || !store.S.dir ? "All projects" : (store.PL.find((p) => p[1] === store.S.dir) || ["All projects"])[0];
-  $("proj").textContent = short(cur);
+  $("proj").innerHTML =
+    store.all || !store.S.dir
+      ? `<span class="plogo" aria-hidden="true">${ico("board")}</span><span>${esc(cur)}</span>`
+      : `${plogo(store.S.dir, cur)}<span>${esc(short(cur))}</span>`;
   $("proj").title = cur;
   if (!$("projpop").hidden) list();
   $("showc").hidden = !store.all;
@@ -420,7 +467,7 @@ export function render() {
   }
   COLS.forEach((name, ci) => {
     const s = document.createElement("section");
-    const list = cs.filter((c) => c.column === ci && (!filter || c.status === filter));
+    const list = cs.filter((c) => c.column === ci && (!filter || c.status === filter) && (archive || !nested(c)));
     // 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 : store.S.cards.indexOf(c)),

package/web/board/fixes.ts

@@ -40,7 +40,7 @@ export function fixForm(c) {
     fs
       .map((f) => {
         const x = f.done ? " (closed)" : sent(f) ? " (sent)" : "";
-        return `<label class="${x ? "off" : ""}"><input type="checkbox" data-n="${f.n}" ${x ? "checked disabled" : fixOff.has(k(f.n)) ? "" : "checked"}><span>${f.n}. ${md(f.text).replace(/^<p>|<\/p>$/g, "")}${x}</span></label>`;
+        return `<label class="${f.done ? "off done" : x ? "off" : ""}"><input type="checkbox" data-n="${f.n}" ${x ? "checked disabled" : fixOff.has(k(f.n)) ? "" : "checked"}><span>${f.n}. ${md(f.text).replace(/^<p>|<\/p>$/g, "")}${x}</span></label>`;
       })
       .join("") +
     (open.length