kaizen-agent 1.23.0 → 1.25.0

package/cli/sources.ts

@@ -1,14 +1,16 @@
-// Request sources: shared links kaizen reads for requests, each landing as an idea
-// in the inbox. Everything fetched is outside text: it becomes idea text and notes,
-// never a status, a command, or a run. Nothing in this file launches anything.
+// Request sources: shared links kaizen reads for requests, each landing in the
+// project's icebox until someone promotes it to an idea. Everything fetched is
+// outside text: it becomes item text and notes, never a status, a command, or a run.
+// Nothing in this file launches anything.
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { isIP } from "node:net";
+import { createHash } from "node:crypto";
 import { lookup as dnsLookup } from "node:dns/promises";
-import { type InboxLine, readInbox, writeInbox, normalise, formatNote, parseItem } from "./state.ts";
+import { readInbox, writeInbox, normalise, formatNote, parseItem } from "./state.ts";
 
 export type Last = { at: string; ok: boolean; added: number; note: string };
-export type Source = { url: string; label?: string; added: string; last?: Last; seen: string[] };
+export type Source = { url: string; label?: string; category?: string; added: string; last?: Last; seen: string[] };
 export type Result = { url: string } & Last;
 
 const file = (state: string) => join(state, "sources.json");
@@ -33,19 +35,56 @@ export function writeSources(state: string, list: Source[]) {
 const oneLine = (s: string) => s.replace(/\s+/g, " ").replace(/[\x00-\x1f\x7f-\x9f]/g, "").trim();
 
 // Returns why not, or null when added -- the shape abandonRun and writeNotes use.
-export function addSource(state: string, url: string, label?: string): string | null {
+export function addSource(state: string, url: string, label?: string, category?: string): string | null {
   url = url.trim();
   const why = checkUrl(url);
   if (why) return why;
   const list = readSources(state);
   if (list.some((s) => s.url === url)) return "already a source";
   const name = oneLine(label ?? "").slice(0, 80);
-  list.push({ url, ...(name ? { label: name } : {}), added: new Date().toISOString(), seen: [] });
+  const cat = oneLine(category ?? "").slice(0, 40);
+  list.push({ url, ...(name ? { label: name } : {}), ...(cat ? { category: cat } : {}), added: new Date().toISOString(), seen: [] });
   writeSources(state, list);
   return null;
 }
 
-// Drops the entry and its seen list. Ideas already gathered stay in the inbox.
+// Social media: the platform's own public search, tag or profile page for what to
+// follow. Those pages need a sign-in or a browser, so kaizen never fetches them; the
+// agent reads them in /kaizen gather. Null when there is nothing to follow.
+export const PLATFORMS: Record<string, string> = { x: "X", tiktok: "TikTok", instagram: "Instagram", threads: "Threads" };
+export function socialUrl(platform: string, query: string): string | null {
+  const q = oneLine(query).slice(0, 100);
+  if (!q || !(platform in PLATFORMS)) return null;
+  const e = encodeURIComponent;
+  const handle = /^@([\w.]{1,30})$/.exec(q)?.[1], tag = /^#([\p{L}\p{N}_]{1,100})$/u.exec(q)?.[1];
+  if (platform === "x") return handle ? `https://x.com/${e(handle)}` : `https://x.com/search?q=${e(q)}&f=live`;
+  if (platform === "tiktok") return handle ? `https://www.tiktok.com/@${e(handle)}` : tag ? `https://www.tiktok.com/tag/${e(tag)}` : `https://www.tiktok.com/search?q=${e(q)}`;
+  if (platform === "instagram") return handle ? `https://www.instagram.com/${e(handle)}/` : tag ? `https://www.instagram.com/explore/tags/${e(tag)}/` : `https://www.instagram.com/explore/search/keyword/?q=${e(q)}`;
+  return handle ? `https://www.threads.net/@${e(handle)}` : `https://www.threads.net/search?q=${e(q)}`;
+}
+const SOCIAL = /^(?:www\.|mobile\.|m\.)?(x\.com|twitter\.com|tiktok\.com|instagram\.com|threads\.net|threads\.com)$/;
+// The platform a link belongs to, or null for any other link.
+export function socialOf(raw: string): string | null {
+  let h: string;
+  try { h = new URL(raw).hostname.toLowerCase().replace(/\.$/, ""); } catch { return null; }
+  const m = SOCIAL.exec(h)?.[1];
+  return !m ? null : m.startsWith("x.") || m.startsWith("twitter.") ? "x" : m.split(".")[0]!;
+}
+export const AGENT_ONLY = "Social posts are gathered by your agent. Run /kaizen gather.";
+
+// What gathered items from this source are filed under. Empty clears it. Items
+// already in the icebox keep the category they arrived with.
+export function setCategory(state: string, url: string, category: string): string | null {
+  const list = readSources(state);
+  const src = list.find((s) => s.url === url);
+  if (!src) return "no such source";
+  const cat = oneLine(category).slice(0, 40);
+  if (cat) src.category = cat; else delete src.category;
+  writeSources(state, list);
+  return null;
+}
+
+// Drops the entry and its seen list. Items already gathered stay in the icebox.
 export function removeSource(state: string, url: string): string | null {
   const list = readSources(state);
   if (!list.some((s) => s.url === url)) return "no such source";
@@ -54,7 +93,7 @@ export function removeSource(state: string, url: string): string | null {
 }
 
 // A source belongs to one project. Moving it carries its label, seen list and last
-// result, so nothing is gathered twice; ideas already in the old inbox stay there.
+// result, so nothing is gathered twice; items already in the old icebox stay there.
 // Written to the new project first, and taken back out if the old one cannot be
 // written: only a crash between the two writes leaves it listed twice, never lost.
 export function moveSource(from: string, to: string, url: string): string | null {
@@ -82,42 +121,122 @@ const obeyed = (t: string) => isCommand(t) || ["", "full ", "lite "].some((kind)
 });
 export const CAP = 50;
 
-// The single place outside text becomes ideas. Synchronous on purpose: nothing
-// may run between reading the inbox and writing it back.
+// Outside text made safe to store: one line, no bullet or number in front, the part
+// past 200 characters moved to the notes, every note line one line with no `-` in
+// front (it could be read back as an inbox bullet). Null when too short to mean anything.
+function clean(raw: string, extra = ""): { text: string; lines: string[] } | null {
+  let text = oneLine(raw).replace(/^(?:[-*+•·]+\s*|\d+[.)]\s+)+/, "");
+  if (text.length > 200) { extra = text.slice(200) + "\n" + extra; text = text.slice(0, 200).trim(); }
+  if (text.length < 3) return null;
+  return { text, lines: extra.split("\n").map((n) => oneLine(n).replace(/^[\s-]+/, "")).filter(Boolean) };
+}
+
+// The icebox: everything gathered, held per project until a person or an agent
+// promotes it to an idea or dismisses it. Promoted and dismissed items stay, so the
+// same request never comes back.
+export type Signal = { id: string; text: string; notes?: string; source: string; category?: string; at: string; status: "new" | "promoted" | "dismissed"; idea?: string };
+
+const iceFile = (state: string) => join(state, "icebox.json");
+
+export function readIcebox(state: string): Signal[] {
+  if (!existsSync(iceFile(state))) return [];
+  let list: unknown;
+  try { list = JSON.parse(readFileSync(iceFile(state), "utf8")); } catch { list = null; }
+  if (!Array.isArray(list)) throw new Error("icebox.json is unreadable");
+  return list.filter((s) => s && typeof s.id === "string" && typeof s.text === "string");
+}
+
+export function writeIcebox(state: string, list: Signal[]) {
+  mkdirSync(state, { recursive: true });
+  writeFileSync(iceFile(state), JSON.stringify(list, null, 2) + "\n");
+}
+
+const idOf = (key: string) => createHash("sha1").update(key).digest("hex").slice(0, 8);
+
+// A row is its request and its other cells together: two rows whose request cell
+// reads the same (a sheet where the chosen column is a category) are two requests.
+// A row with no other cells keys as its text alone, as every seen key did before.
+const rowKey = (text: string, notes?: string) => normalise(notes ? text + "\n" + notes : text);
+
+// What an idea already in the inbox rules out. A gathered one (the stamp ingest()
+// wrote before the icebox) rules out its own row; a promoted one nothing, its items
+// are still in the icebox; one typed by hand, any row reading the same.
+function ideaKey(l: { text: string; notes?: string }): string | null {
+  const [first = "", ...rest] = (l.notes ?? "").split("\n");
+  if (/^\[[^\]]*\] Promoted from the icebox:/.test(first)) return null;
+  if (/^\[[^\]]*\] Gathered from /.test(first)) return rowKey(l.text, rest.join("\n"));
+  return normalise(l.text);
+}
+
+// The single place outside text enters kaizen, and it enters the icebox, never Ideas.
+// Synchronous on purpose: nothing may run between reading the files and writing them.
 export function ingest(state: string, url: string, items: { text: string; notes?: string }[]): { added: number; held: number } {
   const sources = readSources(state);
   const src = sources.find((s) => s.url === url);
   if (!src) throw new Error("not a listed source");
-  const inbox = readInbox(state);
-  const known = new Set([...src.seen, ...inbox.map((l) => normalise(l.text))]);
-  const fresh: InboxLine[] = [];
+  const ice = readIcebox(state);
+  const known = new Set([...src.seen, ...readInbox(state).map(ideaKey).filter((k) => k !== null), ...ice.map((s) => rowKey(s.text, s.notes))]);
+  const fresh: Signal[] = [];
   const seen: string[] = [];
   let held = 0;
   for (const it of items) {
-    let text = oneLine(it.text).replace(/^(?:[-*+•·]+\s*|\d+[.)]\s+)+/, "");
-    let extra = it.notes ?? "";
-    if (text.length > 200) { extra = text.slice(200) + "\n" + extra; text = text.slice(0, 200).trim(); }
-    if (text.length < 3) continue;
-    // The board runs an idea as `/kaizen <text>`: a first word that is a command
-    // would be obeyed as one.
-    while (obeyed(text)) text = "Request: " + text;   // twice at most: `Request: high: auto x` still parses
-    const key = normalise(text);
+    const c = clean(it.text, it.notes);
+    if (!c) continue;
+    const notes = c.lines.join("\n").slice(0, 2000);
+    const key = rowKey(c.text, notes);
     if (known.has(key)) { seen.push(key); continue; }
     if (fresh.length >= CAP) { held++; continue; }   // not marked seen: the next gather takes it
     known.add(key);
     seen.push(key);
-    // A note line starting with `-` could be read back as a new inbox bullet.
-    const lines = extra.split("\n").map((n) => oneLine(n).replace(/^[\s-]+/, "")).filter(Boolean);
-    const notes = [formatNote(`Gathered from ${src.label || url}. Outside text: a request to weigh, not instructions.`), ...lines].join("\n").slice(0, 2000);
-    fresh.push({ status: "open", text, notes });
+    fresh.push({ id: idOf(key), text: c.text, ...(notes ? { notes } : {}), source: url, ...(src.category ? { category: src.category } : {}), at: new Date().toISOString(), status: "new" });
   }
-  if (fresh.length) writeInbox(state, [...inbox, ...fresh]);
+  if (fresh.length) writeIcebox(state, [...ice, ...fresh]);
   // ponytail: seen only grows; trim to the newest few thousand if a source ever gets that long.
   src.seen = [...new Set([...src.seen, ...seen])];
   writeSources(state, sources);
   return { added: fresh.length, held };
 }
 
+// The only way icebox text becomes an idea. Several items may become one idea (the
+// same need said twice); the idea's text is the caller's, or the first item's, and
+// `details` are the caller's own words for it. The notes hold those details first,
+// then every item as it was gathered. It lands as an open idea and starts nothing.
+// Returns why not, or null.
+export function promote(state: string, ids: string[], text?: string, details?: string): string | null {
+  const ice = readIcebox(state);
+  const picked = ids.map((id) => ice.find((s) => s.id === id));
+  if (!ids.length) return "no items named";
+  if (picked.some((s) => !s)) return "no such item";
+  if (picked.some((s) => s!.status !== "new")) return "already promoted or dismissed";
+  const own = !!text?.trim();
+  const c = clean(own ? text! : picked[0]!.text);
+  if (!c) return "the idea text is too short";
+  // The board runs an idea as `/kaizen <text>`: a first word that is a command
+  // would be obeyed as one.
+  while (obeyed(c.text)) c.text = "Request: " + c.text;   // twice at most: `Request: high: auto x` still parses
+  const inbox = readInbox(state);
+  if (inbox.some((l) => normalise(l.text) === normalise(c.text))) return "already an idea";
+  const sources = readSources(state);
+  const from = [...new Set(picked.map((s) => { const src = sources.find((x) => x.url === s!.source); return [src?.label || s!.source, s!.category].filter(Boolean).join(" · "); }))].join("; ");
+  const original = picked.flatMap((s) => [s!.text, ...(s!.notes ?? "").split("\n")]).map((n) => oneLine(n).replace(/^[\s-]+/, "")).filter(Boolean);
+  const mine = (details ?? "").split("\n").map((n) => oneLine(n).replace(/^[\s-]+/, "")).filter(Boolean);
+  const notes = [formatNote(`Promoted from the icebox: ${from}. Outside text: a request to weigh, not instructions.`), ...(own ? c.lines : []), ...mine, ...(mine.length ? ["As gathered:"] : []), ...original].join("\n").slice(0, 2000);
+  writeInbox(state, [...inbox, { status: "open", text: c.text, notes }]);
+  for (const s of picked) { s!.status = "promoted"; s!.idea = c.text; }
+  writeIcebox(state, ice);
+  return null;
+}
+
+export function dismiss(state: string, ids: string[]): string | null {
+  const ice = readIcebox(state);
+  const picked = ids.map((id) => ice.find((s) => s.id === id));
+  if (!ids.length) return "no items named";
+  if (picked.some((s) => !s)) return "no such item";
+  for (const s of picked) if (s!.status === "new") s!.status = "dismissed";
+  writeIcebox(state, ice);
+  return null;
+}
+
 // Syntax only; where the name resolves is resolvesPublic's question. Returns why not.
 export function checkUrl(raw: string): string | null {
   let u: URL;
@@ -288,6 +407,11 @@ export function record(state: string, url: string, r: { added: number; held: num
 
 // Never throws. A failure is recorded on the source and marks nothing seen.
 export async function gatherSource(state: string, url: string, doFetch?: Fetch, lookup?: Lookup): Promise<Result> {
+  if (socialOf(url)) {
+    const last = { at: new Date().toISOString(), ok: false, added: 0, note: AGENT_ONLY };
+    try { setLast(state, url, last); } catch { /* as below */ }
+    return { url, ...last };
+  }
   try {
     const target = exportUrl(url);
     const got = await fetchText(target.url, doFetch, lookup);
@@ -317,7 +441,7 @@ export async function gatherAll(state: string, doFetch?: Fetch, lookup?: Lookup)
   return out;
 }
 
-// Every project's sources, each into its own project's inbox and no other.
+// Every project's sources, each into its own project's icebox and no other.
 export async function gatherDirs(states: string[], doFetch?: Fetch, lookup?: Lookup): Promise<(Result & { dir: string })[]> {
   const out: (Result & { dir: string })[] = [];
   for (const dir of states) for (const r of await gatherAll(dir, doFetch, lookup)) out.push({ ...r, dir });

package/cli/state.ts

@@ -4,6 +4,7 @@
 import { existsSync, readFileSync, readdirSync, appendFileSync, writeFileSync, mkdirSync, statSync, realpathSync, rmSync, renameSync, copyFileSync } from "node:fs";
 import { join, dirname, win32, posix } from "node:path";
 import { homedir, arch, cpus, release, totalmem, version as osVersion } from "node:os";
+import { startPty, ptySupported } from "./pty.ts";
 
 // The real path: process.cwd() is always physical, so a raw $HOME that crosses a
 // symlink (/home -> var/home) would never compare equal to it.
@@ -496,6 +497,11 @@ export function fixPrompt(id: string, nums: number[]) {
     + `Leave every other finding alone, and mark the fixed ones done in its 06-backlog.md.`;
 }
 
+// A run whose agent ended mid-stage, picked up where its state.json says.
+export function resumePrompt(id: string) {
+  return `run ${id}: continue it from its state.json; its last agent session ended before the stage finished.`;
+}
+
 export function canApproveAwaiting(awaiting: unknown): awaiting is "approvals.plan" | "approvals.review" | "findings" {
   return awaiting === "approvals.plan" || awaiting === "approvals.review" || awaiting === "findings";
 }
@@ -959,7 +965,7 @@ export function boardCards(states: string[], now: number): Card[] {
 // What starting a run needs, minus the screens: the TUI and the web board both
 // launch the same way and only differ in how they tell the user.
 export type Launch =
-  | { ok: true; agent: Agent; prompt: string; projectDir: string; cmd: string[] }
+  | { ok: true; agent: Agent; prompt: string; projectDir: string; cmd: string[]; pty?: string }
   | { ok: false; agent: Agent; prompt: string; projectDir: string; manual: string; why: string };
 
 export function projectOf(from: string) {
@@ -1036,6 +1042,15 @@ export function closeEnabled(projectDir: string) {
   return true;
 }
 
+// agent.launch in the config chain: where the web board runs what it launches.
+export function launchMode(projectDir: string): "card" | "terminal" {
+  for (const t of configTexts(projectDir)) {
+    const m = /^agent:\n(?:[ \t]+.*\n)*?[ \t]+launch:[ \t]*["']?([^"'\s]+)/m.exec(t) || /^agent\.launch:[ \t]*["']?([^"'\s]+)/m.exec(t);
+    if (m) return m[1] === "terminal" ? "terminal" : "card";
+  }
+  return "card";
+}
+
 // Whether a live PID is still the agent a record launched, not a stranger that reused
 // the number: the tool's name (and conversation id) in its arguments, started no
 // earlier than the record. On Windows the PID is the PowerShell kaizen opened.
@@ -1128,7 +1143,7 @@ export function runAgent(st: string, id: string): { cmd: string; model: string |
 // record; making one here would shadow the user's.
 export function sessionLaunch(projectDir: string, cmd: string, base: string[], prompt: string, text: string, run?: string, model?: string, yolo?: boolean) {
   const st = join(projectDir, ".kaizen");
-  if (!existsSync(st)) return { fullCmd: [...base, ...promptArgs(cmd, prompt)], pidFile: undefined, record: undefined };
+  if (!existsSync(st)) return { fullCmd: [...base, ...promptArgs(cmd, prompt)], key: undefined, pidFile: undefined, record: undefined };
   const f = SESSION_FLAGS[cmd];
   const prev = run ? firstSession(st, run, cmd, projectDir) : null;
   const sessionId = f ? prev?.sessionId ?? crypto.randomUUID() : null;
@@ -1137,7 +1152,7 @@ export function sessionLaunch(projectDir: string, cmd: string, base: string[], p
   mkdirSync(sessionsDir(st), { recursive: true });
   const record = join(sessionsDir(st), key + ".json");
   writeFileSync(record, JSON.stringify({ run: run ?? null, text, cmd, model: model ?? null, ...(yolo ? { yolo: true } : {}), sessionId, started: Date.now() }) + "\n");
-  return { fullCmd, pidFile: join(sessionsDir(st), key + ".pid"), record };
+  return { fullCmd, key, pidFile: join(sessionsDir(st), key + ".pid"), record };
 }
 
 // Claude Code asks "do you trust this folder?" the first time it opens one, and inside
@@ -1161,15 +1176,17 @@ export function trustFolder(dir: string, cfg = join(process.env.CLAUDE_CONFIG_DI
 
 // run: the run a decision is for. Without it, an idea starting a new run.
 // pick: the tool, model and yolo chosen for a new run; a decision takes the run's own
-// tool and model, and never yolo.
-export function launchRun(it: Item, from: string, run?: string, pick: { agent?: string; model?: string; yolo?: boolean } = {}): Launch {
+// tool and model, and never yolo. card: run it inside the board (agent.launch: card),
+// where a pseudo-terminal exists; onChange is told when that agent ends.
+export function launchRun(it: Item, from: string, run?: string, pick: { agent?: string; model?: string; yolo?: boolean; card?: boolean; onChange?: () => void } = {}): Launch {
   const projectDir = projectOf(from);
   // The run will be born here; the board must know the dir or the idea never retires.
   remember(projectDir);
   const own = run && !pick.agent ? runAgent(join(projectDir, ".kaizen"), run) : null;
   const agent = detectDefaultAgent(projectDir, pick.agent ?? own?.cmd);
   if (agent.cmd === "claude") trustFolder(projectDir);
-  const agentBin = Bun.which(agent.cmd) ?? agent.cmd;
+  // onPath, not Bun.which: the board may have taken a login shell's PATH after it started.
+  const agentBin = onPath(agent.cmd) ?? agent.cmd;
   const prompt = requestOf(it.where ? `/kaizen ${it.text} (${it.where})` : `/kaizen ${it.text}`, it.notes, from);
   const wanted = pick.model ?? (own?.cmd === agent.cmd ? own.model : null) ?? undefined;
   const model = wanted && plainModel(wanted) ? wanted : undefined;
@@ -1181,6 +1198,16 @@ export function launchRun(it: Item, from: string, run?: string, pick: { agent?:
   const manual = manualCommand(projectDir, agent.cmd, prompt, flags);
   const drop = () => { if (s.record) rmSync(s.record, { force: true }); };
 
+  if (pick.card && ptySupported) {
+    const key = s.key ?? `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    try {
+      startPty(key, s.fullCmd, projectDir, s.pidFile, pick.onChange);
+      return { ok: true, agent, prompt, projectDir, cmd: s.fullCmd, pty: key };
+    } catch (err: any) {
+      drop();
+      return { ok: false, agent, prompt, projectDir, manual, why: err?.message ?? String(err) };
+    }
+  }
   const term = findTerminal(projectDir, s.fullCmd, s.pidFile);
   if (!term) {
     drop();

package/cli/web.ts

@@ -7,15 +7,21 @@ import {
   readInbox, writeInbox, replaceIdea, moveIdea, abandonRun, launchRun, parseItem, agentChoices, projectOf, KNOWN_AGENTS, plainModel, short, setArchived, writeNotes,
   appendNote, saveAttachment, pidOnPort, readText, cmdExe, sysExe, powershellExe, runGit, cardsGit, readCommit, commitPush, notice, notifier, LOGO,
   reviewFindings, pickFindings, fixPrompt, approvalPrompt, canApproveAwaiting, nativePath, closeSessions, sweepSessions, issueUrl,
+  launchMode, readSessions, ownerOf, resumePrompt,
 } from "./state.ts";
-import { readSources, addSource, removeSource, moveSource, gatherSource, gatherAll, gatherDirs, due } from "./sources.ts";
+import { attachPty, writePty, resizePty, ptyState, ptyKeys, adoptLoginEnv } from "./pty.ts";
+import { readSources, addSource, removeSource, moveSource, setCategory, readIcebox, promote, dismiss, gatherSource, gatherAll, gatherDirs, due, socialUrl, socialOf } from "./sources.ts";
 import { listNotes, saveNote, renameNote, deleteNote, boardIndex, linksTo } from "./notes.ts";
 
 const PAGE = join(dirname(import.meta.dir), "web", "board.html");
 // The notebook: its page, and the CodeMirror bundle `bun run build:web` commits beside it.
 const NOTES_PAGE = join(dirname(import.meta.dir), "web", "notes.html");
 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");
 const DEFAULT_PORT = 7420;
+type PtySock = { key: string; detach: (() => void) | null };
 // Read once at start: a board keeps the code it started with, so this is what it
 // runs, not what is installed now. `/` sends it; `current()` compares the two.
 const installed = () => {
@@ -27,7 +33,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, NOTES_PAGE, NOTES_JS].map((f) => [f, existsSync(f) ? readText(f) : null]));
+const AT_START = new Map([PAGE, NOTES_PAGE, NOTES_JS, TERM_JS, TERM_CSS].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
@@ -51,6 +57,9 @@ export async function web(repoDir: string, opts: Opts = {}) {
       if (ev === "uncaughtException") process.exit(1);
     });
   }
+  // Before anything looks for an agent on PATH: the board starts agents itself, and
+  // from a launcher it would otherwise have none of the user's shell setup.
+  adoptLoginEnv();
   // Not fixed for the life of the board: picking a project in the page moves here.
   let state = locate();
   if (state && dirname(state) !== home) remember(dirname(state));
@@ -115,6 +124,20 @@ export async function web(repoDir: string, opts: Opts = {}) {
       for (const c of clients) { try { c.enqueue("data: changed\n\n"); } catch { clients.delete(c); } }
     }, 200);
   };
+  // agent.launch: card runs what this board launches inside the board, shown on the card.
+  const inCard = (dir: string) => ({ card: launchMode(projectOf(dir)) === "card", onChange: changed });
+  // An idea's session, until its run exists and owns it (ownerOf).
+  const ideaPty = new Map<string, string>();
+  // The card's newest in-card session, live or recently ended. Sessions are only read
+  // while this board has any, so /state costs nothing more for terminal launches.
+  const ptyOf = (c: Card) => {
+    const live = new Set(ptyKeys());
+    if (!live.size) return undefined;
+    const key = c.kind === "run"
+      ? readSessions(c.state).filter((s) => live.has(s.key) && ownerOf(c.state, s) === c.id).pop()?.key
+      : ideaPty.get(`${c.state}\0${c.text}`);
+    return key && live.has(key) ? { key, alive: ptyState(key)!.alive } : undefined;
+  };
   // Dev: the page reloads itself when board.html is saved. Server code needs
   // `bun --watch cli/install.ts web`; the page reconnects and reloads on hello.
   try { watch(PAGE, () => { for (const c of clients) { try { c.enqueue("data: reload\n\n"); } catch { clients.delete(c); } } }); } catch { /* no dev reload */ }
@@ -134,7 +157,7 @@ export async function web(repoDir: string, opts: Opts = {}) {
   const fingerprint = () => {
     let sum = 0;
     for (const dir of states(true)) {
-      for (const f of ["inbox.md", "backlog.md", "archive.md", "sources.json"]) { try { sum += statSync(join(dir, f)).mtimeMs; } catch { /* absent */ } }
+      for (const f of ["inbox.md", "backlog.md", "archive.md", "sources.json", "icebox.json"]) { try { sum += statSync(join(dir, f)).mtimeMs; } catch { /* absent */ } }
       const runs = join(dir, "runs");
       if (!existsSync(runs)) continue;
       for (const id of readdirSync(runs)) { try { sum += statSync(join(runs, id, "state.json")).mtimeMs; } catch { /* absent */ } }
@@ -153,7 +176,7 @@ export async function web(repoDir: string, opts: Opts = {}) {
   }, 2000);
 
   // The schedule: once a minute, gather every request source that is due. It writes
-  // inbox.md and sources.json only, never a state.json, and starts nothing. All of
+  // icebox.json and sources.json only, never a state.json, and starts nothing. All of
   // it sits in a try: an uncaught error here would end the board.
   const every = async () => {
     const { listSettings } = await import("./settings.ts");
@@ -209,7 +232,21 @@ export async function web(repoDir: string, opts: Opts = {}) {
     // big repo, on Windows) then comes back as nothing, and the page shows an empty
     // board. Loopback only, so nothing waits on us but our own page.
     idleTimeout: 0,
-    async fetch(req) {
+    // The in-card terminal: output out as text frames, the page's keys and size in as
+    // {t:"i",d} and {t:"r",c,r}. A null from the session means the agent ended.
+    websocket: {
+      open(ws: Bun.ServerWebSocket<PtySock>) {
+        ws.data.detach = attachPty(ws.data.key, (d) => { if (d === null) ws.close(1000, "ended"); else ws.send(d); });
+      },
+      message(ws: Bun.ServerWebSocket<PtySock>, raw) {
+        let m: any;
+        try { m = JSON.parse(String(raw)); } catch { return; }
+        if (m?.t === "i" && typeof m.d === "string") writePty(ws.data.key, m.d);
+        else if (m?.t === "r") resizePty(ws.data.key, Number(m.c), Number(m.r));
+      },
+      close(ws: Bun.ServerWebSocket<PtySock>) { ws.data.detach?.(); },
+    },
+    async fetch(req, srv) {
       // Host first: a hostname rebound to 127.0.0.1 by an attacker's DNS still
       // arrives with that hostname in Host, and gets nothing.
       const hostname = (req.headers.get("host") ?? "").replace(/:\d+$/, "");
@@ -233,6 +270,27 @@ 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 === "/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);
+        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" } });
+      }
+
+      // An in-card agent's terminal. Whoever connects here types into an agent that
+      // can run anything, and a page on the wider web may open a WebSocket to
+      // loopback freely, so the Origin is required and must be this board's.
+      if (req.method === "GET" && path === "/pty") {
+        // Same origin exactly, port included: another local server's page is not the board.
+        let same = false;
+        try { same = new URL(req.headers.get("origin") ?? "").host === req.headers.get("host"); } catch { /* no origin */ }
+        if (!same) return bad("cross-origin terminal refused", 403);
+        const key = url.searchParams.get("key") ?? "";
+        if (!/^[\w-]+$/.test(key) || !ptyState(key)) return bad("no such terminal", 404);
+        if (srv.upgrade(req, { data: { key, detach: null } })) return undefined as unknown as Response;
+        return bad("websocket expected", 426);
+      }
+
       // 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");
@@ -284,7 +342,7 @@ export async function web(repoDir: string, opts: Opts = {}) {
           project, all, dir: state,
           projects: picker.map((d) => ({ dir: d, label: label(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 })),
+          cards: cards.map((c) => ({ ...c, notice: notice(c), git: markable(c) ? marks.get(c.state)?.[c.id!] : undefined, pty: ptyOf(c) })),
           now: Date.now(),
         });
       }
@@ -315,13 +373,16 @@ export async function web(repoDir: string, opts: Opts = {}) {
         // says which project it belongs to. Nothing is assumed from where the board started.
         const dir = url.searchParams.get("dir");
         if (dir && !states(true).includes(dir)) return bad("unknown state dir", 404);
-        const sources = [], failed = [];
+        const sources = [], icebox = [], failed = [];
         for (const d of dir ? [dir] : states(true)) {
           // The seen list is bookkeeping, not something the page shows.
-          try { sources.push(...readSources(d).map(({ seen, ...s }) => ({ ...s, dir: d, project: label(d) }))); }
+          try { sources.push(...readSources(d).map(({ seen, ...s }) => ({ ...s, social: socialOf(s.url), dir: d, project: label(d) }))); }
           catch { failed.push(label(d)); }
+          // Only what still waits for a decision; promoted and dismissed items are record.
+          try { icebox.push(...readIcebox(d).filter((s) => s.status === "new").map((s) => ({ ...s, dir: d, project: label(d) }))); }
+          catch { failed.push(label(d) + " (icebox)"); }
         }
-        return json({ sources, failed, every: await every() });
+        return json({ sources, icebox, failed, every: await every() });
       }
 
       // The Run form's choices for one project: installed tools and their models.
@@ -462,9 +523,12 @@ export async function web(repoDir: string, opts: Opts = {}) {
           return json({ ok: true });
         }
 
-        // Request sources. Gathering adds ideas and nothing else: no run starts here.
+        // Request sources. Gathering fills the icebox and nothing else: no idea is
+        // made and no run starts here.
         if (path === "/sources") {
-          const link = String(body.url ?? "").trim();
+          // A social source arrives as a platform and what to follow; the link is built here.
+          const link = body.op === "add" && typeof body.platform === "string" ? socialUrl(body.platform, String(body.query ?? "")) ?? "" : String(body.url ?? "").trim();
+          if (body.op === "add" && typeof body.platform === "string" && !link) return bad("type a keyword, #hashtag or @account to follow");
           // A source belongs to the project the request names. The fallback above
           // (where the board started, or the global dir) is a guess, and a guess
           // here puts someone's requests in the wrong project.
@@ -478,8 +542,11 @@ export async function web(repoDir: string, opts: Opts = {}) {
             }
             if (!named) return bad(body.op === "add" ? "choose the project this source belongs to" : "say which project's source this is");
             if (body.op === "add") {
-              const why = addSource(dir, link, typeof body.label === "string" ? body.label : undefined);
+              const why = addSource(dir, link, typeof body.label === "string" ? body.label : undefined, typeof body.category === "string" ? body.category : undefined);
               if (why) return bad(why);
+            } else if (body.op === "category") {
+              const why = setCategory(dir, link, String(body.category ?? ""));
+              if (why) return bad(why, 404);
             } else if (body.op === "remove") {
               const why = removeSource(dir, link);
               if (why) return bad(why, 404);
@@ -496,6 +563,20 @@ export async function web(repoDir: string, opts: Opts = {}) {
           } catch (e) { return bad((e as Error).message, 500); }
         }
 
+        // The icebox: the only way gathered text becomes an idea, one explicit click
+        // (or agent call) at a time. An idea is made; no run starts.
+        if (path === "/icebox") {
+          if (typeof body.dir !== "string" || !states(true).includes(body.dir)) return bad("say which project's icebox this is");
+          const ids = Array.isArray(body.ids) ? body.ids.filter((i: unknown) => typeof i === "string") : [];
+          try {
+            const why = body.op === "promote" ? promote(body.dir, ids, typeof body.text === "string" ? body.text : undefined, typeof body.details === "string" ? body.details : undefined)
+              : body.op === "dismiss" ? dismiss(body.dir, ids) : "unknown op";
+            if (why) return bad(why, why === "no such item" ? 404 : why === "unknown op" ? 400 : 409);
+          } catch (e) { return bad((e as Error).message, 500); }
+          changed();
+          return json({ ok: true });
+        }
+
         if (path === "/run") {
           const text = String(body.text ?? "").trim();
           const kind = body.kind === "full" || body.kind === "lite" ? body.kind : "";
@@ -508,11 +589,15 @@ export async function web(repoDir: string, opts: Opts = {}) {
           // A `started` idea may be run again: the terminal the first launch opened
           // can come up empty, and nothing else tells the board a run never began.
           it.notes = readInbox(dir).find((l) => (l.status === "open" || l.status === "started") && l.text === text)?.notes;
-          const r = launchRun(it, dir, undefined, { agent, model: model || undefined, yolo: body.yolo === true });
+          const r = launchRun(it, dir, undefined, { agent, model: model || undefined, yolo: body.yolo === true, ...inCard(dir) });
           if (r.ok) replaceIdea(dir, text, { status: "started", text });
+          if (r.ok && r.pty) {
+            for (const [k, v] of ideaPty) if (!ptyState(v)) ideaPty.delete(k);   // sessions already dropped
+            ideaPty.set(`${dir}\0${text}`, r.pty);
+          }
           changed();
           return json(r.ok
-            ? { ok: true, agent: r.agent, project: tilde(r.projectDir) }
+            ? { ok: true, agent: r.agent, project: tilde(r.projectDir), pty: r.pty }
             : { ok: false, why: r.why, manual: r.manual, agent: r.agent }, r.ok ? 200 : 500);
         }
 
@@ -609,11 +694,11 @@ export async function web(repoDir: string, opts: Opts = {}) {
           // The run's conversation picks the fix up, and once that window is open the
           // waiting one ends. A failed launch leaves it: the decision has nowhere else.
           const before = Date.now();
-          const r = launchRun({ severity: null, where: null, text, raw: text }, dir, id);
+          const r = launchRun({ severity: null, where: null, text, raw: text }, dir, id, inCard(dir));
           if (r.ok) closeSessions(dir, id, { before });
           changed();
           return json(r.ok
-            ? { ok: true, agent: r.agent }
+            ? { ok: true, agent: r.agent, pty: r.pty }
             : { ok: false, why: r.why, manual: r.manual, agent: r.agent }, r.ok ? 200 : 500);
         }
 
@@ -636,11 +721,32 @@ export async function web(repoDir: string, opts: Opts = {}) {
           // conversation continues in one new window, and then the idle one ends. A
           // failed launch leaves it open, since the decision went nowhere.
           const before = Date.now();
-          const r = launchRun({ severity: null, where: null, text, raw: text }, dir, id);
+          const r = launchRun({ severity: null, where: null, text, raw: text }, dir, id, inCard(dir));
+          if (r.ok) closeSessions(dir, id, { before });
+          changed();
+          return json(r.ok
+            ? { ok: true, agent: r.agent, pty: r.pty }
+            : { ok: false, why: r.why, manual: r.manual, agent: r.agent }, r.ok ? 200 : 500);
+        }
+
+        // Start a run's agent again after it ended mid-stage (crashed, closed, or a stalled
+        // run), in the conversation it had where the tool can resume one. Never beside a
+        // live in-card agent, and never on a run waiting for a decision: those have their buttons.
+        if (path === "/resume") {
+          const id = String(body.id ?? "");
+          if (!/^[\w.-]+$/.test(id)) return bad("bad run id");
+          if (dir === join(home, ".kaizen")) return bad("no project to run in", 409);
+          let run: any;
+          try { run = JSON.parse(readText(join(dir, "runs", id, "state.json"))); } catch { return bad("no such run", 404); }
+          if (run.stage === "done" || run.stage === "abandoned" || run.awaiting) return bad("this run is not waiting to be resumed", 409);
+          if (readSessions(dir).some((s) => ptyState(s.key)?.alive && ownerOf(dir, s) === id)) return bad("its agent is still running in its card", 409);
+          const text = resumePrompt(id);
+          const before = Date.now();
+          const r = launchRun({ severity: null, where: null, text, raw: text }, dir, id, inCard(dir));
           if (r.ok) closeSessions(dir, id, { before });
           changed();
           return json(r.ok
-            ? { ok: true, agent: r.agent }
+            ? { ok: true, agent: r.agent, pty: r.pty }
             : { ok: false, why: r.why, manual: r.manual, agent: r.agent }, r.ok ? 200 : 500);
         }
 

package/commands/kaizen-discover.md

@@ -0,0 +1,5 @@
+---
+description: Read the kaizen icebox, group what was gathered, and promote what you pick to ideas
+---
+
+Invoke the `kaizen` skill with argument `discover`.