kaizen-agent 1.43.2 → 1.44.0

package/cli/board.test.ts

@@ -254,3 +254,46 @@ test("a capitalised phrase mid-sentence is prose, not a label", () => {
 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.");
 });
+
+// pretty(): a one-line idea note splits into one paragraph per label.
+test("pretty splits a labelled plain line in a note by its labels", async () => {
+  const { pretty } = await import("../web/board/chat.ts");
+  const t = "Parent: run-x add a timezone. OPEN QUESTION (waiting on Johan): recalc old rows? Context: PR #452.";
+  expect(pretty(t)).toBe("**Parent:** run-x add a timezone.\n\n**OPEN QUESTION (waiting on Johan):** recalc old rows?\n\n**Context:** PR #452.");
+  expect(pretty("just a note")).toBe("just a note");
+  expect(pretty("Goal: a\nScope: b")).toBe("Goal: a\nScope: b");
+  expect(pretty("Parent: x\ndo y. NOTE: a. Context: b.")).toBe("Parent: x\n\ndo y.\n\n**NOTE:** a.\n\n**Context:** b.");
+  expect(pretty("- Goal: a. Scope: b.")).toBe("- Goal: a. Scope: b.");
+});
+
+test("the note editor turns its DOM back into the markdown md() rendered it from", async () => {
+  const { toMd } = await import("../web/board/rich.ts");
+  // A minimal DOM: element nodes from md()'s tag soup, enough for toMd.
+  const parse = (h) => {
+    const root = { nodeType: 1, nodeName: "DIV", childNodes: [], getAttribute: () => null };
+    const stack = [root];
+    for (const m of h.matchAll(/<(\/?)(\w+)([^>]*)>|([^<]+)/g)) {
+      const top = stack[stack.length - 1];
+      if (m[4]) top.childNodes.push({ nodeType: 3, nodeName: "#text", textContent: m[4].replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&") });
+      else if (m[1]) stack.pop();
+      else {
+        const attrs = Object.fromEntries([...m[3].matchAll(/(\w+)="([^"]*)"/g)].map((a) => [a[1], a[2]]));
+        const el = { nodeType: 1, nodeName: m[2].toUpperCase(), childNodes: [], getAttribute: (k) => attrs[k] ?? null };
+        Object.defineProperty(el, "textContent", { get: () => el.childNodes.map((c) => c.textContent).join("") });
+        top.childNodes.push(el);
+        if (!/^(img|br)$/.test(m[2])) stack.push(el);
+      }
+    }
+    return root;
+  };
+  const src = "# Title\n\nsome **bold**, *em* and `code` here  \nnext\n\n- one\n- two\n\n1. first\n2. second\n\n![shot](/f/a.png) [link](http://x)";
+  expect(toMd(parse(md(src)))).toBe(src);
+  // A fresh line typed straight into the box, then one Chrome wrapped in a div.
+  expect(toMd(parse("plain <b>b</b>​<div>next line</div>"))).toBe("plain **b**\n\nnext line");
+});
+
+test("md() renders italic and two-space hard breaks, and leaves globs in code alone", () => {
+  expect(md("an *em* word")).toBe("<p>an <i>em</i> word</p>");
+  expect(md("`*.ts` and `*.md`, a * b * c")).toBe("<p><code>*.ts</code> and <code>*.md</code>, a * b * c</p>");
+  expect(md("one  \ntwo\nthree")).toBe("<p>one<br>two three</p>");
+});

package/cli/install.ts

@@ -96,15 +96,17 @@ 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.
+// `kaizen card add "<title>" [--parent <run id>] [--notes "<details>"]`: 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);
+  const nt = args.indexOf("--notes");
+  const details = nt >= 0 ? args.splice(nt, 2)[1] : undefined;
+  if (Bun.argv[3] !== "add" || !args.length || (at >= 0 && !parent) || (nt >= 0 && !details)) { console.log(`\n  kaizen card add "<title>" [--parent <run id>] [--notes "<details>"]\n`); process.exit(1); }
+  const r = addCard(state, args.join(" "), parent, details);
   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);

package/cli/pty.test.ts

@@ -5,7 +5,7 @@ import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, existsSync, realpa
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { launchMode, closeSessions, readSessions, sweepSessions, CLOSE_GRACE_MS } from "./state.ts";
-import { loginEnv, startPty, writePty, attachPty, ptyState } from "./pty.ts";
+import { loginEnv, startPty, writePty, attachPty, ptyState, exitPty } from "./pty.ts";
 import { conptyHost, innerCommand, resizeSeq } from "./conpty.ts";
 
 const root = realpathSync(mkdtempSync(join(tmpdir(), "kaizen-pty-")));
@@ -198,6 +198,18 @@ test.skipIf(process.platform === "win32")("the done sweep keeps a session the us
   expect(await gone(looked)).toBe(true);
 });
 
+test.skipIf(process.platform === "win32")("exitPty types /exit, and ends an agent that ignores it", async () => {
+  const wait = async (k: string) => { for (let i = 0; i < 100 && ptyState(k)!.alive; i++) await Bun.sleep(30); return ptyState(k)!.alive; };
+  startPty("polite", ["sh", "-c", "while read l; do case $l in */exit*) exit 0;; esac; done"], root);
+  expect(exitPty("polite", 60_000)).toBe(true);
+  expect(await wait("polite")).toBe(false);
+  startPty("stubborn", ["sh", "-c", "trap '' INT; while read l; do :; done"], root);
+  await Bun.sleep(100);
+  exitPty("stubborn", 300);
+  expect(await wait("stubborn")).toBe(false);
+  expect(exitPty("stubborn")).toBe(false);
+});
+
 test("asking: Claude Code and Codex prompts count as a question, ordinary output does not", async () => {
   const { asking } = await import("./pty.ts");
   expect(asking("\x1b[1mWould you like to run the following command?\x1b[0m")).toBe(true);

package/cli/pty.ts

@@ -120,6 +120,17 @@ const send = (p: Pty, d: string) => {
   try { (p.proc.stdin as Bun.FileSink).write(d); (p.proc.stdin as Bun.FileSink).flush(); } catch { /* host gone */ }
 };
 
+// The tile's ×: ask the agent to quit as the user would (/exit), then end it if it is
+// still there after `grace`. Escape first clears whatever is half-typed at its prompt.
+export function exitPty(key: string, grace = 5000): boolean {
+  const p = ptys.get(key);
+  if (!p || p.exit !== null) return false;
+  send(p, "\x1b");
+  setTimeout(() => send(p, "/exit\r"), 100);
+  setTimeout(() => { if (p.exit === null) p.proc.kill(); }, grace).unref();
+  return true;
+}
+
 export function resizePty(key: string, cols: number, rows: number) {
   const p = ptys.get(key);
   const c = Math.max(10, Math.min(500, cols | 0)), r = Math.max(5, Math.min(300, rows | 0));

package/cli/release.test.ts

@@ -0,0 +1,12 @@
+import { test, expect } from "bun:test";
+import { nextVersion, levelOf, summaryOf } from "./release.ts";
+
+test("release picks the bump from the commits and names it from them", () => {
+  expect(levelOf("fix(board): x\ndocs: y")).toBe("patch");
+  expect(levelOf("docs: y\nfeat(board): x")).toBe("minor");
+  expect(levelOf("feat: x\n\nBREAKING: config moved")).toBe("major");
+  expect(nextVersion("1.43.3", "patch")).toBe("1.43.4");
+  expect(nextVersion("1.43.3", "minor")).toBe("1.44.0");
+  expect(nextVersion("1.43.3", "major")).toBe("2.0.0");
+  expect(summaryOf(["feat(board): a", "docs(notes): b", "fix: c"])).toBe("a; c");
+});

package/cli/release.ts

@@ -0,0 +1,67 @@
+// `bun run release [patch|minor|major] [summary]`: bump, commit, test, publish, push.
+// With no level, the commits since the last tag decide it: a `feat` makes a new minor
+// (1.43.3 -> 1.44.0), anything else a patch; "BREAKING" anywhere makes a major.
+// The summary defaults to those commits' subjects, prefixes dropped. A bump commit
+// already made but never published (HEAD is "Release <version>:" with no tag) is reused.
+import { readFileSync, writeFileSync } from "node:fs";
+
+const sh = (cmd: string[]) => {
+  const r = Bun.spawnSync(cmd, { stdout: "pipe", stderr: "inherit" });
+  if (r.exitCode !== 0) throw new Error(`${cmd.join(" ")} failed`);
+  return r.stdout.toString().trim();
+};
+const run = (cmd: string[]) => {
+  if (Bun.spawnSync(cmd, { stdio: ["inherit", "inherit", "inherit"] }).exitCode !== 0) process.exit(1);
+};
+
+export function nextVersion(v: string, level: string) {
+  const [a, b, c] = v.split(".").map(Number);
+  return level === "major" ? `${a + 1}.0.0` : level === "minor" ? `${a}.${b + 1}.0` : `${a}.${b}.${c + 1}`;
+}
+export function levelOf(log: string) {
+  if (/BREAKING/.test(log)) return "major";
+  return /^feat(\(.*?\))?!?:/m.test(log) ? "minor" : "patch";
+}
+export function summaryOf(subjects: string[]) {
+  return subjects
+    .filter((s) => /^(feat|fix|perf)(\(.*?\))?!?:/.test(s))
+    .map((s) => s.replace(/^\w+(\(.*?\))?!?:\s*/, ""))
+    .join("; ");
+}
+
+if (import.meta.main) {
+  const args = process.argv.slice(2);
+  const forced = ["patch", "minor", "major"].includes(args[0]) ? args.shift() : null;
+  const pkg = JSON.parse(readFileSync("package.json", "utf8"));
+  const tagged = (v: string) => sh(["git", "tag", "-l", `v${v}`]) !== "";
+  const head = sh(["git", "log", "-1", "--format=%s"]);
+  if (sh(["git", "status", "--porcelain", "--untracked-files=no"])) {
+    console.error("release: commit or drop your changes first");
+    process.exit(1);
+  }
+  if (head.startsWith(`Release ${pkg.version}:`) && !tagged(pkg.version) && !forced) {
+    console.log(`release: reusing the unpublished bump commit for ${pkg.version}`);
+  } else {
+    const last = sh(["git", "describe", "--tags", "--abbrev=0"]);
+    const log = sh(["git", "log", "--format=%s%n%b", `${last}..HEAD`]);
+    if (!log) {
+      console.error(`release: nothing since ${last}`);
+      process.exit(1);
+    }
+    const level = forced ?? levelOf(log);
+    const v = nextVersion(pkg.version, level);
+    const summary = args.join(" ") || summaryOf(sh(["git", "log", "--reverse", "--format=%s", `${last}..HEAD`]).split("\n")) || "maintenance";
+    writeFileSync("package.json", readFileSync("package.json", "utf8").replace(`"version": "${pkg.version}"`, `"version": "${v}"`));
+    const note = ".kaizen/notes/Project/Release and testing.md";
+    try {
+      writeFileSync(note, readFileSync(note, "utf8").replace(`version ${pkg.version} in this checkout`, `version ${v} in this checkout`));
+    } catch {}
+    sh(["git", "add", "package.json", note]);
+    sh(["git", "commit", "-q", "-m", `Release ${v}: ${summary}`]);
+    console.log(`release: ${pkg.version} -> ${v} (${level})`);
+  }
+  // Tests run in prepublishOnly; a failure stops here with the commit unpushed.
+  run(["bun", "publish"]);
+  run(["git", "push", "origin", "HEAD"]);
+  run(["bun", "run", "publish:gh"]);
+}

package/cli/state.test.ts

@@ -1228,6 +1228,8 @@ test("parent/child: a Parent line links a run and an idea to the run that filed
   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/);
+  addCard(st, "titled", "2026-01-02-b", "the details\nline two");
+  expect(readInbox(st).find((l) => l.text === "titled")?.notes).toContain("Parent: 2026-01-02-b\nthe details");
   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

@@ -915,8 +915,9 @@ export function appendNote(state: string, target: { id: string } | { text: strin
 }
 
 // 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 {
+// parent is the one named, else the newest run still in flight. `details` go in the
+// idea's notes below the Parent line, so the title stays a title.
+export function addCard(state: string, text: string, parent?: string, details?: 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;
@@ -924,7 +925,7 @@ export function addCard(state: string, text: string, parent?: string): { parent:
   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}` }]);
+  writeInbox(state, [...lines, { status: "open", text, notes: [`Parent: ${id}`, details?.trim()].filter(Boolean).join("\n") }]);
   return { parent: id };
 }
 

package/cli/web.ts

@@ -9,7 +9,7 @@ import {
   reviewFindings, pickFindings, backlogCards, backlogItem, startedBacklog, closeBacklog, markBacklogDone, fixPrompt, approvalPrompt, canApproveAwaiting, nativePath, closeSessions, sweepSessions, issueUrl,
   launchMode, readSessions, ownerOf, runIndex, resumePrompt, runAgent, firstSession, webHosts,
 } from "./state.ts";
-import { attachPty, writePty, resizePty, ptyState, ptyKeys, adoptLoginEnv } from "./pty.ts";
+import { attachPty, writePty, resizePty, exitPty, ptyState, ptyKeys, adoptLoginEnv } from "./pty.ts";
 import { readSources, addSource, removeSource, moveSource, setCategory, setWriteback, readIcebox, promote, dismiss, restore, addItem, githubRepo, 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";
@@ -389,6 +389,16 @@ export async function web(repoDir: string, opts: Opts = {}) {
         return bad("websocket expected", 426);
       }
 
+      // The Terminal page's ×: the agent is asked to /exit, and ended if it will not.
+      if (req.method === "POST" && path === "/pty/exit") {
+        if (!local(req)) return bad("cross-origin write refused", 403);
+        let body: any;
+        try { body = await req.json(); } catch { return bad("json body expected"); }
+        const key = String(body.key ?? "");
+        if (!/^[\w-]+$/.test(key) || !ptyState(key)) return bad("no such terminal", 404);
+        return json({ ok: exitPty(key) });
+      }
+
       // Every note of one project, text included: search, tags and backlinks are the page's.
       if (req.method === "GET" && path === "/vault") {
         const dir = url.searchParams.get("dir") ?? state ?? join(home, ".kaizen");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kaizen-agent",
-  "version": "1.43.2",
+  "version": "1.44.0",
   "description": "Staged workflow for AI agents — code, writing, research, operations: plan, human approval, build, independent review, bounded fix loop.",
   "type": "module",
   "bin": {
@@ -28,7 +28,7 @@
     "prepublishOnly": "bun test",
     "postpublish": "sh cli/release.sh",
     "publish:gh": "sh cli/publish-gh.sh",
-    "release": "bun publish && bun run publish:gh"
+    "release": "bun run cli/release.ts"
   },
   "repository": {
     "type": "git",

package/skills/kaizen/SKILL.md

@@ -245,6 +245,12 @@ it. Everything else in this file holds unchanged.
   yourself, in that order, reading only each stage's declared inputs and writing its
   artifact before starting the next. The stage table below still applies; you are the
   agent for every row.
+  Read `spec-build.md` before building and `spec-main.md` before moving the run to
+  `review`: being the main thread does not excuse a stage its contract. Its *Preview
+  gate* holds in full — a result that shows on a screen needs a real screenshot under
+  `runs/<id>/attachments/` embedded in `## Preview`, taken by driving a headless browser
+  against the running app; "no browser session" or "same renderer as before" is not a
+  reason, it is the gate failing. Short path or not, no screenshot means not built.
 - `runner: full` — dispatch each stage as its own subagent, as follows.
 
 Under `full`, each stage runs as a subagent via the Agent tool, with the agent type

package/skills/kaizen/spec-main.md

@@ -183,7 +183,10 @@ failed commit is reported as printed; the run is still `done`. With the setting
 
 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
+from the project folder: `kaizen card add "<short title>" --notes "<details>"`. The title
+is what the card shows — a few words, like a commit subject; everything else (scope,
+context, open questions, where it came from) goes in `--notes`, never in the title.
+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.
 

package/web/board/chat.ts

@@ -4,6 +4,7 @@ import { mic, stopDictation } from "./dictation.ts";
 import { $, html, raw as rawHtml } from "./dom.ts";
 import { DK, draft } from "./drafts.ts";
 import { attach, brief, md } from "./markdown.ts";
+import { rich } from "./rich.ts";
 import { toast } from "./toast.ts";
 
 // Notes are a chat: one entry per message, files attached by paste or picker.
@@ -21,6 +22,23 @@ function parseNotes(src) {
   }
   return out.map((n) => ({ ...n, text: n.text.trim() })).filter((n) => n.text);
 }
+// A plain line written as "Label: … Label: …" reads as one paragraph per label.
+// Markdown lines and fenced code are left as written.
+export function pretty(t) {
+  let fence = false;
+  return t
+    .split("\n")
+    .map((l) => {
+      if (/^```/.test(l)) fence = !fence;
+      if (fence || /^\s*(#|```|\||[-*]\s|\d+\.\s|>)/.test(l)) return l;
+      const b = brief(l);
+      if (!b.parts.length) return l;
+      const head = l.startsWith(b.parts[0].label + ":") ? [] : [b.head];
+      return "\n" + [...head, ...b.parts.map((p) => `**${p.label}:** ${p.body}`)].join("\n\n") + "\n";
+    })
+    .join("\n")
+    .trim();
+}
 let nfocus = null;
 export function chat(c, src, ro) {
   const fix = (t) => attach(t, c);
@@ -28,9 +46,13 @@ export function chat(c, src, ro) {
   const b = c.kind === "idea" ? brief(c.text) : { parts: [] };
   let h =
     (b.parts.length
-      ? html`<section class="desc">${rawHtml(md(b.parts.map((p) => `### ${p.label}\n${p.body}`).join("\n\n")))}</section>`
+      ? html`<section class="desc">
+          ${rawHtml(md(b.parts.map((p) => `### ${p.label}\n${p.body}`).join("\n\n")))}
+        </section>`
       : "") +
-    html`<div class="chat">${entries.map((n) => html`<div class="msg">${n.at ? html`<time>${n.at}</time>` : ""}${rawHtml(md(fix(n.text)))}</div>`)}${entries.length ? "" : html`<p style="color:var(--dim)">No notes yet.</p>`}</div>`;
+    html`<div class="chat">
+      ${entries.map((n) => html`<div class="msg">${n.at ? html`<time>${n.at}</time>` : ""}${rawHtml(md(fix(pretty(n.text))))}</div>`)}${entries.length ? "" : html`<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 = rawHtml(h);
@@ -38,11 +60,12 @@ export function chat(c, src, ro) {
   const ta = $("pbody").querySelector("textarea"),
     files = [];
   draft(ta, "n:" + key(c));
+  const ed = rich(ta);
   // Enter leaves focus in the box, and a focused box blocks the redraw: send blurs it
   // so the note shows, and the new box takes focus back for the next note.
   if (nfocus === key(c)) {
     nfocus = null;
-    ta.focus();
+    ed.focus();
   }
   {
     const m = mic([ta]);
@@ -60,7 +83,7 @@ export function chat(c, src, ro) {
     [...e.target.files].forEach(add);
     e.target.value = "";
   };
-  ta.onpaste = (e) => {
+  ed.onpaste = (e) => {
     for (const it of e.clipboardData.items)
       if (it.kind === "file") {
         const f = it.getAsFile();
@@ -93,12 +116,12 @@ export function chat(c, src, ro) {
       } catch (e) {}
       toast("Noted");
       nfocus = key(c);
-      ta.blur();
+      ed.blur();
       load();
     }
   };
   $("nsend").onclick = send;
-  ta.onkeydown = (e) => {
+  ed.onkeydown = (e) => {
     if (e.key === "Enter" && !e.shiftKey) {
       e.preventDefault();
       send();

package/web/board/markdown.ts

@@ -64,7 +64,8 @@ export function planQuestions(src) {
 export 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,
+  const re =
+      /(^|[.!?)]\s+|\s)((?:[A-Z][A-Z-]+(?: [A-Z][A-Z-]+){1,3}|[A-Z][\w-]*(?: [a-z][\w-]*){0,3})(?: \([^)]*\))?):\s+/g,
     cut = [];
   let m;
   while ((m = re.exec(t)))
@@ -88,7 +89,7 @@ export function brief(t) {
 }
 
 // Enough markdown for kaizen's own files: headings, lists, fences, tables,
-// inline code, bold. Everything is escaped first. With `tick`, a backlog item
+// inline code, bold, italic, hard line breaks. Everything is escaped first. With `tick`, a backlog item
 // (`- open: …`, `- done: …`, `- rejected: …`) shows its status as a checkbox.
 export function md(src, tick) {
   const lines = src.split("\n"),
@@ -99,6 +100,7 @@ export function md(src, tick) {
     esc(s)
       .replace(/`([^`]+)`/g, "<code>$1</code>")
       .replace(/\*\*([^*]+)\*\*/g, "<b>$1</b>")
+      .replace(/(^|[^*])\*([^*\s<][^*<]*?)\*(?!\*)/g, "$1<i>$2</i>")
       .replace(/!\[([^\]]*)\]\(([^)\s]+)\)/g, '<a href="$2" target="_blank"><img src="$2" alt="$1"></a>')
       .replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, '<a href="$2" target="_blank">$1</a>');
   const endList = () => {
@@ -182,7 +184,10 @@ export function md(src, tick) {
     i++;
     while (i < lines.length && lines[i].trim() && !/^(#|```|\||\s*[-*]\s|\s*\d+\.\s|---)/.test(lines[i]))
       buf.push(lines[i++]);
-    out.push(`<p>${inl(buf.join(" "))}</p>`);
+    // A line ending in two spaces is a hard line break.
+    out.push(
+      `<p>${inl(buf.map((l, k) => (k < buf.length - 1 && / {2}$/.test(l) ? l.trimEnd() + "\0" : l)).join(" ")).replace(/\0 /g, "<br>")}</p>`,
+    );
   }
   endList();
   return out.join("");

package/web/board/rich.ts

@@ -0,0 +1,160 @@
+import { esc } from "./dom.ts";
+import { md } from "./markdown.ts";
+
+// The card note box formats as you type: a contenteditable editor over a hidden
+// textarea that stays the field's value, so drafts, dictation and send are unchanged.
+// The editor is turned back into markdown on every edit; typing a markdown pattern
+// (`**b**`, `` `c` ``, `- `, `1. `, `# `) re-renders the editor with md().
+
+const ZW = /\u200b/g;
+// Editor DOM to markdown. Paragraph blocks are separated by a blank line, list items
+// by a newline, so md() renders them back as the same blocks.
+export function toMd(root) {
+  const inl = (n) => {
+    // pre-wrap: a soft break typed in Chrome is a "\n" in the text.
+    if (n.nodeType === 3)
+      return n.textContent
+        .replace(ZW, "")
+        .replace(/\u00a0/g, " ")
+        .replace(/\n/g, "  \n");
+    if (n.nodeType !== 1) return "";
+    const t = n.nodeName.toLowerCase(),
+      kids = () => [...n.childNodes].map(inl).join("");
+    if (t === "br") return "  \n";
+    if (t === "b" || t === "strong") return ((s) => (s.trim() ? `**${s}**` : s))(kids());
+    if (t === "i" || t === "em") return ((s) => (s.trim() ? `*${s}*` : s))(kids());
+    if (t === "code") return ((s) => (s ? "`" + s + "`" : s))(n.textContent.replace(ZW, ""));
+    if (t === "img") return `![${n.getAttribute("alt") || ""}](${n.getAttribute("src")})`;
+    if (t === "a") {
+      const img = [...n.childNodes].find((c) => c.nodeName.toLowerCase() === "img");
+      return img ? inl(img) : `[${kids()}](${n.getAttribute("href")})`;
+    }
+    return kids();
+  };
+  const out = [];
+  let buf = "";
+  const flush = () => {
+    if (buf.trim()) out.push(buf.replace(/^\n+|\s*\n+$/g, ""));
+    buf = "";
+  };
+  for (const n of root.childNodes) {
+    const t = n.nodeType === 1 ? n.nodeName.toLowerCase() : "";
+    if (/^h[1-6]$/.test(t)) {
+      flush();
+      out.push("#".repeat(+t[1]) + " " + inl(n).trim());
+    } else if (t === "ul" || t === "ol") {
+      flush();
+      const lis = [...n.childNodes].filter((c) => c.nodeName.toLowerCase() === "li");
+      out.push(lis.map((li, i) => (t === "ol" ? `${i + 1}. ` : "- ") + inl(li).trim()).join("\n"));
+    } else if (t === "pre") {
+      flush();
+      out.push("```\n" + n.textContent + "\n```");
+    } else if (t === "p" || t === "div") {
+      flush();
+      buf = toMd(n);
+      flush();
+    } else buf += inl(n);
+  }
+  flush();
+  return out.join("\n\n");
+}
+
+// A line just typed into a markdown pattern md() would format. Text already inside
+// code or bold is not raw markdown: a code span showing `**` must not match.
+const INL = /\*\*[^*]+\*\*|`[^`]+`|(^|[^*])\*[^*\s][^*]*\*(?!\*)/;
+const typed = (line) => {
+  const raw = [];
+  const walk = (n) => {
+    if (n.nodeType === 3) raw.push(n.textContent.replace(/\u00a0/g, " "));
+    else if (!/^(CODE|B|STRONG|I|EM)$/.test(n.nodeName)) n.childNodes.forEach(walk);
+  };
+  walk(line);
+  const txt = raw.join("");
+  return (
+    INL.test(txt) ||
+    (!/^(LI|H\d)$/.test(line.nodeName) && /^\s*([-*]|\d+\.|#{1,6})\s/.test(line.textContent.replace(/\u00a0/g, " ")))
+  );
+};
+
+export function rich(ta) {
+  const ed = document.createElement("div");
+  ed.className = "rich";
+  ed.contentEditable = "true";
+  ed.setAttribute("role", "textbox");
+  ed.setAttribute("aria-multiline", "true");
+  ed.dataset.ph = ta.placeholder;
+  ta.hidden = true;
+  ta.after(ed);
+  // Top-level lines, list items counted one each: where the caret goes back to.
+  const lines = () => [...ed.querySelectorAll(":scope > :not(ul):not(ol), :scope > ul > li, :scope > ol > li")];
+  const render = (src) => {
+    // An empty item or heading needs a <br> to hold the caret.
+    ed.innerHTML = md(src).replace(/<(li|h\d)><\/\1>/g, "<$1><br></$1>");
+    for (const l of lines()) {
+      const last = l.lastChild;
+      if (last && last.nodeType === 1 && /^(B|I|CODE|A)$/.test(last.nodeName)) l.append("\u200b");
+    }
+  };
+  const caretAt = (el) => {
+    const r = document.createRange();
+    r.selectNodeContents(el || ed);
+    r.collapse(false);
+    const s = getSelection();
+    s.removeAllRanges();
+    s.addRange(r);
+  };
+  let own = false;
+  const sync = () => {
+    own = true;
+    ta.value = toMd(ed);
+    ta.dispatchEvent(new Event("input", { bubbles: true }));
+    own = false;
+  };
+  ed.addEventListener("input", () => {
+    const s = getSelection();
+    const all = lines();
+    const i = s.rangeCount ? all.findIndex((l) => l.contains(s.anchorNode)) : -1;
+    const line = all[i] || (s.anchorNode && s.anchorNode.parentNode === ed ? ed : null);
+    sync();
+    // Emptied: leave no stray <br>, so the placeholder shows again.
+    if (!ta.value.trim() && !ed.querySelector("img")) ed.replaceChildren();
+    else if (line && typed(line)) {
+      // ponytail: whole-editor re-render, caret to the end of the same line; per-line patching if notes grow long.
+      const at = i < 0 ? 0 : i;
+      render(ta.value);
+      caretAt(lines()[at]);
+    }
+  });
+  // Dictation or a restored draft changed the value: show it.
+  ta.addEventListener("input", () => {
+    if (own) return;
+    render(ta.value);
+    if (document.activeElement === ed) caretAt(null);
+  });
+  ed.addEventListener("keydown", (e) => {
+    const mod = e.ctrlKey || e.metaKey;
+    if (mod && e.key.toLowerCase() === "b") {
+      e.preventDefault();
+      document.execCommand("bold");
+    } else if (mod && e.key.toLowerCase() === "e") {
+      e.preventDefault();
+      const t = String(getSelection());
+      if (t) document.execCommand("insertHTML", false, `<code>${esc(t)}</code>\u200b`);
+    } else if (e.key === "Enter" && e.shiftKey) {
+      e.preventDefault();
+      // A new item in a list or after a heading; a soft line break in a paragraph.
+      const n = getSelection().anchorNode;
+      const el = n && (n.nodeType === 1 ? n : n.parentElement);
+      document.execCommand(el && el.closest("li,h1,h2,h3,h4,h5,h6") ? "insertParagraph" : "insertLineBreak");
+    }
+  });
+  // Files are handled by the caller; text comes in plain, never as foreign HTML.
+  ed.addEventListener("paste", (e) => {
+    if ([...e.clipboardData.items].some((it) => it.kind === "file")) return;
+    const t = e.clipboardData.getData("text/plain");
+    e.preventDefault();
+    if (t) document.execCommand("insertText", false, t);
+  });
+  if (ta.value) render(ta.value);
+  return ed;
+}

package/web/board/terms.ts

@@ -1,6 +1,6 @@
 import { store } from "./store.ts";
 import { $, html, ico } from "./dom.ts";
-import { load } from "./api.ts";
+import { load, post } from "./api.ts";
 import { termLoad } from "./agent-term.ts";
 import { open } from "./panel.ts";
 import { resume } from "./approvals.ts";
@@ -86,7 +86,9 @@ export function openTerms() {
   }
   // An ended session closed with × has nothing to come back to: no chip for it.
   const hid = [...all.keys()].filter((k) => lay.hidden.includes(k) && all.get(k).pty.alive);
-  bar!.innerHTML = html`<span class="bar" role="group" aria-label="Layout">${MODES.map(([v, l]) => html`<button data-mode="${v}" class="${lay.mode === v ? "on" : ""}" aria-pressed="${String(lay.mode === v)}">${l}</button>`)}</span>${hid.length ? html`<span class="dim">Hidden</span>${hid.map((k) => html`<button class="chip" data-show="${k}" title="Show this terminal">${ico("plus")}${nameOf(all.get(k))} - ${projOf(all.get(k))}</button>`)}` : ""}${phone.matches && keys.length > 1 ? html`<span class="ttabs" role="group" aria-label="Terminals">${keys.map((k) => html`<button class="${k === one ? "on" : ""}" data-pick="${k}" aria-pressed="${String(k === one)}"><span class="tdot ${tst(all.get(k))}"></span>${nameOf(all.get(k))} - ${projOf(all.get(k))}</button>`)}</span>` : ""}`.s;
+  // The layout switch sits at the right of the page header.
+  $("tmodes").innerHTML = html`${MODES.map(([v, l]) => html`<button data-mode="${v}" class="${lay.mode === v ? "on" : ""}" aria-pressed="${String(lay.mode === v)}">${l}</button>`)}`.s;
+  bar!.innerHTML = html`${hid.length ? html`<span class="dim">Hidden</span>${hid.map((k) => html`<button class="chip" data-show="${k}" title="Show this terminal">${ico("plus")}${nameOf(all.get(k))} - ${projOf(all.get(k))}</button>`)}` : ""}${phone.matches && keys.length > 1 ? html`<span class="ttabs" role="group" aria-label="Terminals">${keys.map((k) => html`<button class="${k === one ? "on" : ""}" data-pick="${k}" aria-pressed="${String(k === one)}"><span class="tdot ${tst(all.get(k))}"></span>${nameOf(all.get(k))} - ${projOf(all.get(k))}</button>`)}</span>` : ""}`.s;
   bar!.querySelectorAll<HTMLElement>("[data-pick]").forEach(
     (b) =>
       (b.onclick = () => {
@@ -95,7 +97,7 @@ export function openTerms() {
       }),
   );
   bar!.querySelector(".ttabs .on")?.scrollIntoView({ block: "nearest", inline: "nearest" });
-  bar!.querySelectorAll<HTMLElement>("[data-mode]").forEach(
+  $("tmodes").querySelectorAll<HTMLElement>("[data-mode]").forEach(
     (b) =>
       (b.onclick = () => {
         lay.mode = b.dataset.mode!;
@@ -140,7 +142,7 @@ export function openTerms() {
     const hd = t.el.querySelector("header")!;
     hd.title = (c.kind === "run" ? c.id : c.text) + " · " + c.where;
     // An ended run can be resumed from here; an idea whose agent ended has no run to resume.
-    hd.innerHTML = html`<span class="tdot ${st}" role="img" title="${st}" aria-label="${st}"></span><b>${nameOf(c)} - ${projOf(c)}</b>${off ? html`<span class="tend">ended</span>` : ""}<span class="sp"></span>${off && c.kind === "run" ? html`<button class="btn sm" data-a="resume" title="Continue this run's agent">Resume</button>` : ""}<button class="ib sm" data-a="card" title="Open card" aria-label="Open card">${ico("open")}</button><button class="ib sm" data-a="max" title="${lay.max === k ? "Restore" : "Maximise"}" aria-label="${lay.max === k ? "Restore" : "Maximise"}">${ico(lay.max === k ? "min" : "max")}</button><button class="ib sm" data-a="hide" title="${off ? "Close" : "Hide"}" aria-label="${off ? "Close" : "Hide"}">${ico("close")}</button>`.s;
+    hd.innerHTML = html`<span class="tdot ${st}" role="img" title="${st}" aria-label="${st}"></span><b>${nameOf(c)} - ${projOf(c)}</b>${off ? html`<span class="tend">ended</span>` : ""}<span class="sp"></span>${off && c.kind === "run" ? html`<button class="btn sm" data-a="resume" title="Continue this run's agent">Resume</button>` : ""}<button class="ib sm" data-a="card" title="Open card" aria-label="Open card">${ico("open")}</button><button class="ib sm" data-a="max" title="${lay.max === k ? "Restore" : "Maximise"}" aria-label="${lay.max === k ? "Restore" : "Maximise"}">${ico(lay.max === k ? "min" : "max")}</button>${off ? "" : html`<button class="ib sm" data-a="hide" title="Hide" aria-label="Hide">${ico("dash")}</button>`}<button class="ib sm" data-a="${off ? "hide" : "exit"}" title="${off ? "Close" : "Exit session"}" aria-label="${off ? "Close" : "Exit session"}">${ico("close")}</button>`.s;
     t.el.classList.toggle("ended", off);
     t.el.classList.toggle("off", !!one && one !== k);
     t.el.style.gridColumn = "";
@@ -180,6 +182,10 @@ function wire(el: HTMLElement) {
     else if (a === "hide") {
       lay.hidden.push(k);
       if (lay.max === k) lay.max = null;
+    } else if (a === "exit") {
+      // The tile stays, turning "ended" with its Resume button when the agent is gone.
+      if (confirm("End this agent session? A run can be resumed from its tile or card.")) post("/pty/exit", { key: k }).then(() => load(true));
+      return;
     } else if (a === "card") {
       const c = sessions().get(k);
       if (c) open(c);