kaizen-agent 1.47.0 → 1.49.0

package/cli/web.ts

@@ -17,6 +17,9 @@ import * as google from "./google.ts";
 import { writeBacks } from "./writeback.ts";
 import { postLink, sendReply } from "./browser.ts";
 import { listNotes, saveNote, renameNote, deleteNote, boardIndex, linksTo } from "./notes.ts";
+import * as video from "./video.ts";
+import * as localsend from "./localsend.ts";
+import * as hermes from "./hermes.ts";
 
 const PAGE = join(dirname(import.meta.dir), "web", "board.html");
 // The board's script: web/board/*.ts, bundled into one file by `bun run build:web`.
@@ -28,6 +31,9 @@ const NOTES_JS = join(dirname(import.meta.dir), "web", "notebook.js");
 // The in-card terminal (agent.launch: card): xterm.js, bundled the same way.
 const TERM_JS = join(dirname(import.meta.dir), "web", "term.js");
 const TERM_CSS = join(dirname(import.meta.dir), "web", "term.css");
+// The Video page (kaizen-video's library, editor and renders) and its bundle.
+const VIDEO_PAGE = join(dirname(import.meta.dir), "web", "video.html");
+const VIDEO_JS = join(dirname(import.meta.dir), "web", "video.js");
 const DEFAULT_PORT = 7420;
 // Gathered posts a reply is going out to right now: one send per item at a time.
 const replying = new Set<string>();
@@ -43,7 +49,7 @@ const VERSION = installed();
 // page newer than its server sends ops the server does not know ("unknown op").
 // So the pages are kept as they were at start, and read live (dev edits) only while
 // the installed version is still the one this board runs.
-const AT_START = new Map([PAGE, BOARD_JS, NOTES_PAGE, NOTES_JS, TERM_JS, TERM_CSS].map((f) => [f, existsSync(f) ? readText(f) : null]));
+const AT_START = new Map([PAGE, BOARD_JS, NOTES_PAGE, NOTES_JS, TERM_JS, TERM_CSS, VIDEO_PAGE, VIDEO_JS].map((f) => [f, existsSync(f) ? readText(f) : null]));
 const served = (f: string) => installed() === VERSION && existsSync(f) ? readText(f) : AT_START.get(f) ?? null;
 
 // A board answers at url and runs the installed version. A board from before the
@@ -259,6 +265,18 @@ export async function web(repoDir: string, opts: Opts = {}) {
     return listSettings(repoDir).rows.find((r) => r.key === key)?.value ?? "";
   };
   const every = async () => (await setting("sources.every")) || "off";
+  // Where videos live: the library folder (board.video_dir, default ~/.kaizen), then
+  // every known project with a videos/ folder. The page names one by its index.
+  const videoPlaces = async () => {
+    let d = await setting("board.video_dir");
+    if (d.startsWith("~")) d = home + d.slice(1);
+    return video.places(d ? resolve(nativePath(d)) : join(home, ".kaizen"), knownProjects());
+  };
+  video.onJobChange(() => changed());
+  // Send targets as last listed: a send may only go to a device the last search found
+  // or a chat Hermes listed, never to an address the page makes up.
+  let devices: { at: number; list: localsend.Device[]; note: string | null } = { at: 0, list: [], note: null };
+  let chats: hermes.Chat[] = [];
   let busy = false;
   const gather = setInterval(async () => {
     if (busy) return;
@@ -368,6 +386,54 @@ export async function web(repoDir: string, opts: Opts = {}) {
         return new Response(body, { headers: { "content-type": type, "cache-control": "no-store" } });
       }
 
+      if (req.method === "GET" && (path === "/video" || path === "/video.js")) {
+        const [f, type] = path === "/video" ? [VIDEO_PAGE, "text/html; charset=utf-8"] : [VIDEO_JS, "application/javascript; charset=utf-8"];
+        const body = served(f);
+        if (body === null) return new Response(`${path} missing; run bun run build:web`, { status: 500 });
+        return new Response(body, { headers: { "content-type": type, "cache-control": "no-store" } });
+      }
+
+      if (req.method === "GET" && path.startsWith("/video/")) {
+        const all = await videoPlaces();
+        const at = (v: { place: string }) => all.findIndex((p) => p.dir === v.place);
+        if (path === "/video/presets") {
+          const place = all[Number(url.searchParams.get("p") ?? 0)] ?? all[0]!;
+          return json({ presets: video.presets(place.dir), limits: video.LIMITS });
+        }
+        // Agents the page started, while the board still holds their terminal.
+        const agents = video.agentsOf().flatMap((a) => {
+          const s = ptyState(a.key), p = at(a);
+          return s && p >= 0 ? [{ place: p, name: a.name, pty: a.key, alive: s.alive, asking: !!s.asking, at: a.at }] : [];
+        });
+        if (path === "/video/list")
+          return json({ places: all.map((p, i) => ({ i, label: p.label, dir: tilde(p.dir) })), agents, jobs: video.jobList().map((j) => ({ ...j, place: at(j) })),
+            videos: video.listVideos(all).map((v) => ({ ...v, place: at(v), job: v.job && { ...v.job, place: at(v) },
+              send: video.sendOf(v.place, v.name), sends: video.sendLog(v.place, v.name).slice(-5).reverse() })) });
+        if (path === "/video/film") {
+          const place = all[Number(url.searchParams.get("p"))], name = url.searchParams.get("name");
+          if (!place || !video.okName(name)) return bad("unknown video", 404);
+          const film = video.readFilm(place.dir, name);
+          if (!film) return bad("not a film", 404);
+          return json({ ...film, stills: video.stills(place.dir, name), job: video.jobOf(place.dir, name), log: video.logOf(place.dir, name) });
+        }
+        if (path.startsWith("/video/f/")) return video.serveFile(all, path.slice("/video/f/".length).split("/"), req);
+        // LocalSend devices, searched again on ?fresh=1 or after two minutes.
+        if (path === "/video/devices") {
+          if (url.searchParams.get("fresh") === "1" || Date.now() - devices.at > 120_000) {
+            const r = await localsend.discover();
+            devices = { at: Date.now(), list: r.devices, note: r.note };
+          }
+          return json({ devices: devices.list.map(({ fingerprint, alias, deviceModel, deviceType }) => ({ id: fingerprint, alias, deviceModel, deviceType })), note: devices.note });
+        }
+        if (path === "/video/chats") {
+          const r = await hermes.targets();
+          if ("error" in r) return json({ chats: [], error: r.error });
+          chats = r.chats;
+          return json({ chats });
+        }
+        return bad("not found", 404);
+      }
+
       if (req.method === "GET" && (path === "/term.js" || path === "/term.css")) {
         const [f, type] = path === "/term.js" ? [TERM_JS, "application/javascript; charset=utf-8"] : [TERM_CSS, "text/css; charset=utf-8"];
         const body = served(f);
@@ -723,6 +789,66 @@ export async function web(repoDir: string, opts: Opts = {}) {
         let body: any;
         try { body = await req.json(); } catch { return bad("json body expected"); }
 
+        // The Video page: a place by index, a video folder by name, both checked in video.ts.
+        if (path.startsWith("/video/")) {
+          const all = await videoPlaces();
+          if (path === "/video/cancel") return video.cancelJob(Number(body.id)) ? json({ ok: true }) : bad("no such job", 404);
+          // New video and Ask Claude: kaizen-video in a board terminal, in the place's folder.
+          if (path === "/video/new" || path === "/video/ask") {
+            const place = all[Number(body.p)];
+            if (!place || !Number.isInteger(Number(body.p))) return bad("unknown place", 404);
+            if (path === "/video/ask" && !video.okName(body.name)) return bad("unknown video", 404);
+            const r = path === "/video/new" ? video.requestFor(place.dir, body) : video.askFor(place.dir, body.name, body.text);
+            if ("error" in r) return bad(r.error);
+            const name = "name" in r ? r.name : body.name as string;
+            const launched = launchRun({ severity: null, where: null, text: r.text, raw: r.text }, place.dir, undefined,
+              { skill: "kaizen-video", cwd: place.dir, card: true, onChange: changed });
+            if (!launched.ok) return json({ ok: false, why: launched.why, manual: launched.manual }, 500);
+            if (launched.pty) video.noteAgent(launched.pty, place.dir, name);
+            changed();
+            return json({ ok: true, name, pty: launched.pty ?? null, agent: launched.agent.name });
+          }
+          const place = all[Number(body.p)];
+          if (!place || !Number.isInteger(Number(body.p)) || !video.okName(body.name)) return bad("unknown video", 404);
+          if (path === "/video/save") {
+            const err = video.saveFilm(place.dir, body.name, body.edits ?? [], body.platforms);
+            if (err) return bad(err);
+            const job = body.build === false ? null : video.startJob(place.dir, body.name, "build");
+            changed();
+            return json({ ok: true, job: typeof job === "string" ? null : { ...job, place: Number(body.p) }, note: typeof job === "string" ? job : null });
+          }
+          // A finished file to a device the last search found, or a chat Hermes listed.
+          if (path === "/video/send") {
+            const file = video.outputFile(place.dir, body.name, body.file);
+            if (!file) return bad("not one of this video's finished files", 404);
+            let err: string | null;
+            if (body.via === "localsend") {
+              const dev = devices.list.find((d) => d.fingerprint === body.to);
+              if (!dev) return bad("that device is not in the last search; search again", 404);
+              err = video.startSend(place.dir, body.name, { via: "localsend", to: dev.alias, file: body.file }, (step) => localsend.sendFile(dev, file, step));
+            } else if (body.via === "whatsapp") {
+              const chat = chats.find((c) => c.id === body.to);
+              if (!chat) return bad("that chat is not in Hermes' list", 404);
+              const text = typeof body.text === "string" ? body.text : "";
+              const m = hermes.message(text, file);
+              if (typeof m !== "string") return bad(m.error);
+              err = video.startSend(place.dir, body.name, { via: "whatsapp", to: chat.name, file: body.file }, () => hermes.sendMedia(chat.id, text, file));
+            } else return bad("send by localsend or whatsapp");
+            if (err) return bad(err, 409);
+            changed();
+            return json({ ok: true });
+          }
+          if (path === "/video/job") {
+            if (!["build", "preview", "render"].includes(body.kind)) return bad("unknown job");
+            const formats = Array.isArray(body.formats) ? body.formats : video.formatsFor(Array.isArray(body.platforms) ? body.platforms : []);
+            const job = video.startJob(place.dir, body.name, body.kind, formats);
+            if (typeof job === "string") return bad(job, 409);
+            changed();
+            return json({ ok: true, job: { ...job, place: Number(body.p) } });
+          }
+          return bad("not found", 404);
+        }
+
         // The same search as the TUI's "find more": every .kaizen under $HOME, the
         // drives, and where the board was started, added to the registry.
         // ponytail: synchronous walk, the board stalls for its length; move to a worker if a big disk makes that seconds.

package/cli/worktree.test.ts

@@ -6,6 +6,8 @@ import { tmpdir } from "node:os";
 import { startWorktree, landWorktree, codeDir, projectFromWorktree, run, type Run } from "./worktree.ts";
 
 const ID = "2026-10-17-demo";
+// CI runners have no git identity, and landWorktree's rebase writes commits.
+const idRun: Run = (cmd, cwd) => run(cmd[0] === "git" ? ["git", "-c", "user.email=a@b.c", "-c", "user.name=t", ...cmd.slice(1)] : cmd, cwd);
 let remote: string, project: string, other: string;
 const g = (cwd: string, ...a: string[]) => { const r = run(["git", "-c", "user.email=a@b.c", "-c", "user.name=t", ...a], cwd); if (!r.ok) throw new Error(r.why); return r.out; };
 const commit = (cwd: string, f: string, text: string) => { writeFileSync(join(cwd, f), text); g(cwd, "add", f); g(cwd, "commit", "-qm", `feat: ${f}`); };
@@ -46,7 +48,7 @@ test("G-02 lands by rebase and push after main moved on", () => {
   const w = (startWorktree(project, ID) as { path: string }).path;
   commit(w, "run.txt", "mine");
   commit(other, "theirs.txt", "x"); g(other, "push", "-q", "origin", "HEAD:main"); // main moves ahead
-  const r = landWorktree(project, ID, run, false);
+  const r = landWorktree(project, ID, idRun, false);
   expect(r).toEqual({ ok: true, how: "push", url: undefined });
   g(project, "fetch", "-q", "origin");
   expect(g(project, "ls-tree", "--name-only", "origin/main").split("\n")).toEqual(["a.txt", "run.txt", "theirs.txt"]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kaizen-agent",
-  "version": "1.47.0",
+  "version": "1.49.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/config.default.yml

@@ -152,6 +152,10 @@ board:
   # not itself a project (no .git, no package.json) is read as a group, and the
   # folders inside it are offered too.
   projects_dir: ""
+  # The Video page's library: new videos go to <folder>/videos/<name>/ and their
+  # renders to <folder>/output/<name>/. Empty means ~/.kaizen. Known projects that
+  # have a videos/ folder are listed on the Video page too.
+  video_dir: ""
   # Where `kaizen web` opens the board: browser (a tab in your default browser) or
   # app (a Chrome, Edge or Brave window with no tabs or address bar).
   open: browser

package/skills/media/kaizen-book/SKILL.md

@@ -0,0 +1,107 @@
+---
+name: kaizen-book
+description: Write, proofread and publish a book. Interviews the author first (kind of book, genre such as sci-fi, romance, fantasy, thriller, memoir or non-fiction, readers, language, length, voice, look), then outlines and drafts it chapter by chapter with a style sheet, proofreads with a numbered change list, and builds a single-file offline e-book that reads like a real book (cover that opens, page-flip, paper, themes, font size, resume), an A5 colour print PDF, a black-and-white print PDF, optional volume PDFs, and a website folder with WhatsApp/social link previews. Use when the user wants to write a book, novel, novella, memoir or story collection, turn a manuscript (Markdown or .docx) into an e-book or printable PDF, proofread a manuscript, or publish a book online.
+---
+
+# Kaizen book
+
+A book lives in `book/` in the user's project folder, and everything it produces goes to `output/`:
+
+```
+book/
+  brief.md        interview answers, approved by the author
+  outline.md      chapter plan, approved by the author
+  style.md        style sheet: names, spellings, voice rules, facts so far
+  manuscript.md   the text (# Part, ## Chapter | subtitle, ### Section, [^1] footnotes)
+  book.json       title, author, lang, style, cover, url, volumes…
+  images/         cover and figures
+  proofread.md    numbered change list, marked applied / declined
+output/
+  book.html       the e-book: one file, works offline
+  book.pdf        A5 colour print
+  book-mono.pdf   A5 black and white (white typeset cover, greyscale images and emoji)
+  book-vol-N.pdf  one per volume, black and white (or colour), continuous page numbers
+  og.jpg          1200×630 link-preview image
+  shots/          screenshots from verify.mjs
+  deploy/         static site: index.html (preview loader), reader.html, PDFs, og.jpg
+```
+
+Run every script from the project folder. `S=<this skill>/scripts`. Worked example: [`examples/`](examples/).
+
+## 0. Setup, once per machine
+`$S/check.sh` lists what is missing (python3, node, poppler's `pdfinfo`, Playwright). `$S/setup.sh` installs
+Playwright 1.62.1 and Chromium into `~/.kaizen/kaizen-book` (override with `KAIZEN_BOOK_HOME`), which is about 150 MB.
+Tell the user before you run it. Building the HTML needs only python3. PDFs and screenshots need the rest.
+
+## 1. Where to start
+- **A new book**: interview first. Read [`references/interview.md`](references/interview.md) and follow it.
+  Nothing is written until `brief.md` is approved.
+- **An existing manuscript** (.md, .docx, pasted text): convert it as described at the end of
+  [`references/writing.md`](references/writing.md), write `book.json`, and go to step 3. Ask only what
+  `book.json` needs (title, author, language, style, cover, url).
+- **A revision of a built book**: change `manuscript.md`, then repeat steps 3–5. Never hand-edit `output/`.
+
+## 2. Write
+Follow [`references/writing.md`](references/writing.md): the outline, approved; the style sheet; chapters
+in batches of three to five, with a stop for the author after each batch. Never invent facts, sources or quotes.
+Mark open questions `[[CHECK: …]]`.
+
+## 3. Proofread
+Follow [`references/proofread.md`](references/proofread.md). Run `python3 $S/check_book.py book` for
+structure, then write `book/proofread.md` as a numbered change list. Apply only the numbers the author
+accepts. The build does not go ahead while `check_book.py` reports errors.
+
+## 4. Build and look
+```
+python3 $S/build_book.py book            # → output/book.html (fonts embedded, cached in ~/.kaizen/kaizen-book/fonts)
+node $S/verify.mjs output/book.html      # phone + spread smoke test, screenshots in output/shots/
+node $S/pdf.mjs output/book.html         # → book.pdf, book-mono.pdf, book-vol-N.pdf, og.jpg
+```
+- `verify.mjs` must report `all checks passed`: no page errors, every chapter opens, nothing clipped
+  past a page, no horizontal scroll, flips cross chapters, and resume keeps the chapter, page, theme and font size.
+  Look at the screenshots yourself, and show the cover and one spread to the author.
+- `pdf.mjs` prints the book twice so the contents page carries real page numbers, read from the PDF's
+  named destinations with `pdfinfo -dests`. `--only color,mono,volumes,og` limits what it makes.
+- Look at the PDF pages before handing them over (`pdftoppm -r 40 -png output/book.pdf /tmp/p` then a contact sheet):
+  the cover, the contents, a part page, a chapter opening, a page with an image, and the mono cover.
+
+### book.json
+| Key | Meaning |
+|---|---|
+| `title`, `subtitle`, `author`, `tagline` | Used on the cover, title page, contents and link preview |
+| `lang` | `id`, `en`, or another code. `id`/`en` have built-in interface labels; override any with `"labels": {…}` (keys are in `build_book.py`) |
+| `style` | `classic` · `romance` · `scifi` · `fantasy` · `thriller` · `literary` · `children` (from `assets/styles.json`) |
+| `theme` | Per-book overrides of the style, e.g. `{"cover": {"bg": "#123"}, "accent": "#a33"}` |
+| `cover` | Path in `book/` to a 2:3 image. Empty means a typeset cover in the style's colours. The mono PDF always uses the typeset cover |
+| `copyright`, `dedication` | Front-matter pages in the PDFs (`\n` for line breaks) |
+| `description`, `url` | Link preview text, and the site's absolute URL (needed for `og:image`) |
+| `volumes` | `[{"label": "Volume 1"}, {"label": "Volume 2", "from_part": 6}]`. `from_part` is the 1-based number of the `#` part a volume starts at |
+| `volume_print` | `mono` (default) or `color`: which print the volume PDFs are cut from. An image cover gets the volume label on a band |
+| `manuscript`, `id` | Other manuscript file name; storage key for reading position (defaults to the title) |
+
+To add a style, copy an entry in `assets/styles.json` (Google Fonts family names; cover `pattern` is one of
+`frame grid petals slash dots none`).
+
+## 5. Publish
+`python3 $S/deploy.py book` assembles `output/deploy/`, which can be hosted anywhere static (`cd output/deploy && npx vercel --prod`,
+Netlify, GitHub Pages, or a Cloudflare tunnel). Publishing is outward-facing, so confirm with the user before deploying.
+- `index.html` is a 2 KB page carrying the og tags that then loads `reader.html`. WhatsApp and other previewers
+  give up on a multi-MB page before they read its head. Don't replace index.html with the book.
+- The reader's "Print / PDF" button opens `book.pdf` when the site has one, because iOS Safari ignores `@page` and
+  prints with white margins. Opened as a file, the button prints the built-in print layout instead.
+- The PDFs are snapshots. After any change to the text, rebuild everything in step 4 and redeploy. Volumes are found
+  by part, so they follow the text without hand-kept page numbers.
+
+## What the reader does
+Cover board with cloth grain that swings open onto a half-title page, contents, and CSS-column pages on textured
+paper. Phones show one page, and landscape screens 900 px or wider show a spread. Pages turn with a 3D flip (a fade with reduced motion)
+by swipe, by tapping the outer 30% of the page, or with arrow keys, PageUp/PageDown or Space. Running heads and page numbers on every page (numbered through the whole book; in a spread each chapter starts on a left page),
+drop cap at each chapter opening, part opener pages, text before the first heading shown as a lead-in before the first chapter, fenced code blocks, footnote markers that open the note, and themes (paper / sepia / night). Font size
+13–28 px, and the position is saved per book in localStorage. Text is justified only when a column is at least 380 px wide, to avoid
+rivers on phones. Paragraphs use `dir="auto"`, so Arabic or Hebrew passages in a left-to-right book display correctly. A fully
+right-to-left book is not supported yet.
+
+## Kaizen
+Inside a kaizen run, the brief and outline approvals are the plan approval, each batch of chapters is a build, and the
+review reads the chapters against `brief.md`, `style.md` and the outline. For a built book, the review also needs
+`verify.mjs` passing and the PDF contact sheets. Screenshots go in the run's `attachments/` for the Preview gate.