8646cd5 · eb1f81c · c1ddab9 · d47315e · 060eccc · 0f9bbbe
@@ -329,6 +329,17 @@
$ forge tell "make the header smaller"
told alice/shop: issue #12  https://forge.example.com/alice/shop/issues/12
```
## forge talk
Say something to the forge's own agent, as you, and print what it answers.
The agent works through the forge's MCP with your permissions; a write it
would make is held for your yes (Confirm or Cancel on `/talk`). Words are 1 to
20000 characters. It waits up to two minutes, then says where to read the rest.
```console
$ forge talk "what is waiting on me?"
```
## forge new
Makes an app from the shell, as `POST /api/v1/apps` does, then clones its
@@ -0,0 +1,14 @@
# Talk
`/talk` (#7652) is the person's one conversation with the forge: a log, a composer, and Confirm and Cancel for a held action.
- `.talk` — the page's column: at most 760px, centred, `min-width: 0` so nothing pushes the page sideways at 375px.
- `.talk-log` — the ordered list of turns; its `data-last` is the last turn id the stream resumes from.
- `.talk-turn` — one turn; wraps anywhere, so a long word or URL never scrolls the page.
- `.talk-person` — the person's words: a right-aligned bubble, pre-wrapped.
- `.talk-agent` — the agent's reply, markdown, full width, no bubble.
- `.talk-tool` — what the agent did, one muted small line.
- `.talk-confirm` — a held action's card: the sentence, then Confirm and Cancel at 44px high.
- `.talk-compose` — the composer, sticky to the bottom of the viewport (padded for the phone's safe area), so it stays reachable; its textarea is 16px so iOS does not zoom.
- `.talk-status` — one polite line (sending, answering, an error); it always takes its line, so nothing shifts.
- `.talk-more` — the "Earlier" link above the log.
@@ -60,6 +60,7 @@
Machine routes are not pages and have no entry: `/audit.csv`,
- `/asked` — `studio/asked_page.ts` · what I answered, as a record · `/asks` · none seen.
- `/review` — `studio/review_page.ts` · every ask waiting on me, one row each, newest first · `/asks` (same asks, with buttons) · none seen.
- `/flow` — `pages/flow.ts` · the pipeline from ready issue to live deploy, and the bottleneck · `/system`, `/board`, `/` · none seen. A topbar button points here.
- `/talk` — `pages/talk.ts` · the person's one conversation with the forge: history, composer, Confirm and Cancel; replies stream in over `/talk/stream` · `/settings/confirms` (the same yes, as a list), the home tell box (one line to an app's crew) · none seen; styles in `docs/design/areas/talk.md`.
- `/pipeline` — `pages/pipeline.ts` · the four steps a change follows (check, review, land, live), for a newcomer · a pull page's step line, `/flow` · none seen.
- `/map` — `pages/map.ts` (1,806 lines) · the dependency map of work across the forge · `/board`, issue dependency lists, `/:owner/:name/map` · colours 3, sizes 12: the largest private vocabulary.
- `/audit` — `pages/audit.ts` · every app's contract, who can do what · the app page's one-line policy · none seen. Names the audit of apps, not this document.
@@ -9,3 +9,11 @@
One door, `talk()` in `src/actions/talk.ts`, three ways in. It sends the words a
It needs a granted Claude account (`no_account`), and says `resting` when none can serve it or your daily ceiling is spent. At most four turns run across the forge at once (`TURNS_LIVE_MAX`); a new one past that is `busy` (429, `retry-after: 60`), while a message into your running turn always goes through. A message that is refused is not kept in the conversation.
`GET /api/v1/conversation/turns?limit=` takes 1 to 200 turns; absent, empty or not a number is 50.
## On the web: `/talk`
Reached from the Talk icon in every page's top bar, "Talk to the forge" in the palette (`Ctrl/Cmd+K`), `g t`, and the Talk button beside the tell box on home. Signed out, it sends you to /signin and back. It shows your own conversation (the last 50 turns, "Earlier" pages back) and a composer; Ctrl+Enter sends.
A reply streams in over `GET /talk/stream?after=<turn id>` (server-sent events, one `turn` frame per turn, each carrying the server-rendered markup). The stream ends with the turn (`done`), or after 40 seconds (`more`), well inside the edge's timeout; the page then reconnects from the last turn id it saw (`Last-Event-ID` works too). Without the script the composer is a plain form and a reload shows the answer.
When the agent asks first (`needs_confirm`), the turn draws **Confirm** (the existing yes) and **Cancel** (a no: the confirm is spent, nothing runs, a turn says it was cancelled). A result shown once (an invite link) is drawn by Settings → Confirms instead, where Confirm leads.
@@ -3,7 +3,7 @@
    "api.anthropic.com"
  ],
  "app": {
    "looks": ["/", "/forges", "/family", "/front", "/explore", "/board", "/boards", "/asked", "/feed", "/review", "/search", "/new", "/audit", "/releases", "/changelog", "/apps", "/migrate", "/map", "/system", "/contribute", "/pipeline", "/resilience", "/settings"],
    "looks": ["/", "/forges", "/family", "/front", "/explore", "/board", "/boards", "/asked", "/feed", "/review", "/search", "/new", "/audit", "/releases", "/changelog", "/apps", "/migrate", "/map", "/system", "/talk", "/contribute", "/pipeline", "/resilience", "/settings"],
    "run": "bun run src/main.ts",
    "install": "",
    "health": "/healthz",
@@ -92,3 +92,18 @@
export async function sayYes(ctx: Ctx, user: User, confirmId: string): Promise<Y
  appendTurn(ctx.app.db, user.id, conversation.id, { role: "tool", text: JSON.stringify(turn) });
  return { ok: true, done: ran.ok, turn, ...(ran.ok ? { result: ran.value } : {}) };
}
/**
 * The person's no: the confirm is claimed so it can never be said yes to
 * later, nothing is run, and a `tool` turn says it was cancelled. Same door
 * rules as a yes — the person's own session, decided by the caller.
 */
export function sayNo(ctx: Pick<Ctx, "app">, user: User, confirmId: string): { ok: true; turn: Record<string, unknown> } | { ok: false; error: YesRefusal } {
  if (!CONFIRM_ID.test(confirmId)) return { ok: false, error: "not_found" };
  const answered = answerHeld(ctx.app.db, confirmId, user.id);
  if (!answered.ok) return answered;
  const turn = { confirm: answered.value.id, tool: answered.value.tool, done: false, cancelled: true };
  const conversation = openConversation(ctx.app.db, user.id);
  appendTurn(ctx.app.db, user.id, conversation.id, { role: "tool", text: JSON.stringify(turn) });
  return { ok: true, turn };
}
@@ -136,6 +136,22 @@
export function listTurns(
  return ok(rows.reverse().map(turnOf));
}
/**
 * The turns after the turn id `after`, oldest first, at most `MAX_PAGE`; an
 * empty `after` is the whole conversation's start, an id this conversation
 * does not have is nothing. The stream reads this to follow an answer being
 * written and to resume from the last turn a client saw.
 */
export function turnsAfter(db: Database, userId: string, conversationId: string, after: string): Turn[] {
  if (!owned(db, userId, conversationId)) return [];
  const rows = db
    .query(
      "SELECT * FROM conversation_turn WHERE conversation_id = ?1 AND rowid > COALESCE(CASE WHEN ?2 = '' THEN 0 ELSE (SELECT rowid FROM conversation_turn WHERE id = ?2 AND conversation_id = ?1) END, 9223372036854775807) ORDER BY rowid LIMIT ?3",
    )
    .all(conversationId, after, MAX_PAGE) as TurnRow[];
  return rows.map(turnOf);
}
/** What a Claude session id may look like: short, and only id characters. */
export const SESSION_ID = /^[A-Za-z0-9._-]{1,128}$/;
@@ -108,6 +108,7 @@
export const SYSTEM_NAMES: readonly string[] = [
  "releases.json",
  "sw.js",
  "tell",
  "talk",
  "theme",
  "verify",
  "recover",
@@ -136,6 +136,7 @@
import {
  themeSubmit,
} from "../web/pages/site.ts";
import { confirmsList, confirmYes } from "../web/pages/confirms.ts";
import { talkConfirm, talkSend, talkStream, talkView } from "../web/pages/talk.ts";
import {
  passkeyAdd,
  passkeyDelete,
@@ -914,6 +915,10 @@
export function buildRouter(): Router<Handler> {
  router.add("POST", "/settings/tokens", tokenCreate);
  router.add("POST", "/settings/tokens/:id/delete", tokenDelete);
  router.add("POST", "/settings/sessions/:id/delete", sessionDelete);
  router.add("GET", "/talk", talkView);
  router.add("POST", "/talk", talkSend);
  router.add("GET", "/talk/stream", talkStream);
  router.add("POST", "/talk/confirm/:id", talkConfirm);
  router.add("GET", "/settings/confirms", confirmsList);
  router.add("POST", "/settings/confirms/:id", confirmYes);
  router.add("GET", "/settings/passkeys", passkeysPage);
@@ -5,10 +5,11 @@
 * sentence, through the same action the web and the API call
 * (`actions/conversation_confirms.ts`): it does the stored call once. A
 * result shown only once (a link, a credential) opens in a dialog and is not
 * kept in the conversation.
 * kept in the conversation. `n` cancels the one under the cursor the same way
 * (`sayNo`): the confirm is spent, nothing runs, and the conversation says so.
 */
import { REFUSED, sayYes, waitingConfirms } from "../../actions/conversation_confirms.ts";
import { REFUSED, sayNo, sayYes, waitingConfirms } from "../../actions/conversation_confirms.ts";
import { ASKING } from "../../crew/conversation_confirm.ts";
import type { Ctx, Screen } from "../app/app.ts";
import { binding } from "../app/keys.ts";
@@ -28,7 +29,7 @@
export function confirmsScreen(f: Session, ctx: Ctx): Screen {
  const screen: Screen = {
    title: "Confirms",
    keys: [binding(["j", "k"], "move cursor"), binding(["y"], "yes")],
    keys: [binding(["j", "k"], "move cursor"), binding(["y"], "yes"), binding(["n"], "cancel")],
    render(area, s) {
      const c = ctx.theme.c;
      const [head, body] = split(area, "v", [len(1), fill(1)]);
@@ -37,16 +38,32 @@
export function confirmsScreen(f: Session, ctx: Ctx): Screen {
          ? note
          : items().length === 0
            ? "Nothing waiting for your yes."
            : "What the forge's agent asked to do; y does it once, as you.";
            : "What the forge's agent asked to do; y does it once, as you; n cancels it.";
      s.text(head!.x, head!.y, truncate(text, head!.w), style(c.mutedFg, c.bg), head!.x + head!.w);
      drawList(s, body!, c, state, rows());
    },
    key(e) {
      if (state.key(e, items().length)) return true;
      if (e.ctrl || e.alt || e.key !== "y") return false;
      if (e.ctrl || e.alt || (e.key !== "y" && e.key !== "n")) return false;
      const w = items()[state.index];
      const user = f.user;
      if (w === undefined || user === undefined) return false;
      if (e.key === "n") {
        ctx.push(
          confirmScreen(ctx, screen, {
            title: "Cancel this",
            body: [w.does],
            actions: [{ label: "Keep", variant: "ghost" }, { label: "Cancel it", variant: "default" }],
            onChoose: (i) => {
              if (i !== 1) return;
              const no = sayNo(f, user, w.id);
              note = no.ok ? `Cancelled: ${w.tool}.` : `Nothing was done: ${REFUSED[no.error][1]}.`;
              ctx.invalidate();
            },
          }),
        );
        return true;
      }
      ctx.push(
        confirmScreen(ctx, screen, {
          title: "Say yes",
@@ -237,6 +237,7 @@
function userMenu(
    { label: "Your profile", href: `/${user.username}`, icon: "user" },
    { label: "Your repositories", href: "/", icon: "repo" },
    { label: "Apps", href: "/apps", icon: "rocket" },
    { label: "Talk", href: "/talk", icon: "comment" },
    { label: "Explore", href: "/explore", icon: "search" },
    { label: "Map", href: "/map", icon: "map" },
    { separator: true, label: "" },
@@ -314,6 +315,7 @@
const STATIC_PALETTE: PaletteItem[] = [
  { t: "New repository", h: "/new", c: "Create" },
  { t: "Migrate a repository", h: "/migrate", c: "Create" },
  { t: "New organization", h: "/organizations/new", c: "Create" },
  { t: "Talk to the forge", h: "/talk", c: "Go to" },
  { t: "Search", h: "/search", c: "Go to" },
  { t: "Account settings", h: "/settings", c: "Settings" },
  { t: "Access tokens", h: "/settings/tokens", c: "Settings" },
@@ -564,7 +566,9 @@
function topbar(
      <span class="topbar-tools">
        ${searchBar()}
        ${user
          ? html`<a class="small" href="/asks" data-shortcut="g q">Asks</a
          ? html`<a class="btn btn-icon" href="/talk" aria-label="Talk to the forge" title="Talk to the forge" data-shortcut="g t"
                >${icon("comment")}</a
              ><a class="small" href="/asks" data-shortcut="g q">Asks</a
              >${newMenu(ctx)}${userMenu(
                ctx,
                user,
@@ -0,0 +1,227 @@
/**
 * /talk (#7652): the person's one conversation with the forge, on a page.
 * The history and the composer are server-rendered; a reply streams in over
 * `http/sse.ts` as it is written, each turn drawn by the same function the
 * first paint uses. A stream ends with the turn (or after `STREAM_MS`, well
 * inside the edge's timeout) and the client reconnects from the last turn id
 * it saw. A held action draws Confirm and Cancel buttons; Confirm is the
 * existing yes (`actions/conversation_confirms.ts`), Cancel is the no.
 *
 * Everything is the signed-in person's own: the conversation is found by
 * their id, the agent acts with their permissions (`crew/conversation.ts`).
 */
import { TALK_WORDS, talk } from "../../actions/talk.ts";
import { REFUSED, sayNo, sayYes, waitingConfirms } from "../../actions/conversation_confirms.ts";
import { DEFAULT_PAGE, listTurns, MAX_PAGE, openConversation, turnsAfter, type Turn } from "../../core/conversations.ts";
import { WORDS_MAX } from "../../core/fence.ts";
import { notePhase, takeSessionTime, timePhase } from "../../core/route_timing.ts";
import { ASKING } from "../../crew/conversation_confirm.ts";
import { turnRunning } from "../../crew/conversation.ts";
import type { Ctx } from "../../http/context.ts";
import { json } from "../../http/respond.ts";
import { eventStream } from "../../http/sse.ts";
import { signInFirst } from "../chrome.ts";
import { readForm } from "../form.ts";
import { html, type Html } from "../html.ts";
import { flashTo, page } from "../layout.ts";
import { renderMarkdown } from "../markdown.ts";
import { btn } from "../ui.ts";
import { talkCss, talkJs } from "./talk_client.ts";
/** A stream lasts this long at most; the client reconnects from its last turn id. */
export const STREAM_MS = 40_000;
/** How often a stream looks for a turn the agent has written. */
export const POLL_MS = 400;
/** Streams one person may hold open at once; a fourth is told to wait. */
export const STREAMS_MAX = 3;
/** What a stream consults: how long it lasts and whether a turn runs. Tests move it; nothing else does. */
export const clock = { streamMs: STREAM_MS, running: turnRunning };
const open = new Map<string, number>();
const TURN_ID = /^[0-9a-z]{0,40}$/;
const HERE = "/talk";
const parse = (text: string): Record<string, unknown> | undefined => {
  try {
    const value: unknown = JSON.parse(text);
    return typeof value === "object" && value !== null && !Array.isArray(value) ? (value as Record<string, unknown>) : undefined;
  } catch {
    return undefined;
  }
};
/** Confirm and Cancel for a held action; each its own form, so each posts alone. */
function confirmButtons(id: string, tool: string): Html {
  // A result shown once is drawn by Settings → Confirms, never kept in a turn.
  const once = ASKING[tool]?.once !== undefined;
  return html`<div class="bar">
    <form method="post" action="${once ? `/settings/confirms/${id}` : `${HERE}/confirm/${id}`}" ${once ? null : html`data-confirm`}>
      <input type="hidden" name="answer" value="yes" />
      ${btn("Confirm", { variant: "primary", icon: "check", label: `Confirm: ${tool}`, name: "answer", value: "yes" })}
    </form>
    <form method="post" action="${HERE}/confirm/${id}" data-confirm>
      ${btn("Cancel", { icon: "x", label: `Cancel: ${tool}`, name: "answer", value: "no" })}
    </form>
  </div>`;
}
/** One turn as the page and the stream both draw it; `waiting` is the confirms still open. */
export function turnHtml(turn: Turn, waiting: ReadonlySet<string>): Html {
  const id = `t-${turn.id}`;
  if (turn.role === "person") return html`<li class="talk-turn talk-person" id="${id}">${turn.text}</li>`;
  if (turn.role === "agent") return html`<li class="talk-turn talk-agent" id="${id}">${renderMarkdown(turn.text)}</li>`;
  const data = parse(turn.text);
  if (turn.role === "confirm") {
    const confirm = String(data?.["confirm"] ?? "");
    const tool = String(data?.["tool"] ?? "");
    return html`<li class="talk-turn talk-confirm" id="${id}">
      <p>${String(data?.["does"] ?? turn.text)}</p>
      ${waiting.has(confirm) ? confirmButtons(confirm, tool) : html`<p class="muted small">Answered or past its ten minutes.</p>`}
    </li>`;
  }
  // A tool turn: the confirm's outcome as JSON, or the call the agent made as text.
  if (data !== undefined && "confirm" in data) {
    const tool = String(data["tool"] ?? "");
    const says = data["cancelled"] === true ? `Cancelled: ${tool}.` : data["done"] === true ? `Done: ${tool}.${typeof data["undo"] === "string" ? ` To undo: ${data["undo"]}.` : ""}` : `${tool} did not go through: ${String(data["message"] ?? data["error"] ?? "")}`;
    return html`<li class="talk-turn talk-tool" id="${id}">${says}</li>`;
  }
  return html`<li class="talk-turn talk-tool" id="${id}">${turn.text.slice(0, 300)}</li>`;
}
function talkPage(ctx: Ctx, before: string | undefined): Response {
  const user = ctx.auth.user!;
  const conversation = openConversation(ctx.app.db, user.id);
  const listed = listTurns(ctx.app.db, user.id, conversation.id, {
    limit: DEFAULT_PAGE,
    ...(before === undefined ? {} : { before }),
  });
  const turns = listed.ok ? listed.value : [];
  const waiting = new Set(waitingConfirms(ctx, user).map((w) => w.id));
  const running = clock.running(ctx.app, user.id);
  // Paging back, the log ends before the newest turn: it does not follow.
  const last = turns.at(-1)?.id ?? "";
  const body = html`<div class="page-head"><h1>Talk</h1></div>
    <div class="talk" data-talk data-paged="${before === undefined ? "0" : "1"}" data-running="${running && before === undefined ? "1" : "0"}">
      <div>
        ${turns.length === DEFAULT_PAGE && turns[0] !== undefined
          ? html`<p class="talk-more small"><a href="${HERE}?before=${turns[0].id}">Earlier</a></p>`
          : null}
        ${before === undefined ? null : html`<p class="talk-more small"><a href="${HERE}">Latest</a></p>`}
        <ol class="talk-log" data-last="${last}" aria-label="Conversation with the forge">
          ${turns.length === 0
            ? html`<li class="muted talk-turn">Ask the forge anything, or tell it what to change. It acts as you, with your permissions, and asks before anything hard to undo.</li>`
            : turns.map((t) => turnHtml(t, waiting))}
        </ol>
        <div id="end"></div>
      </div>
      <form class="talk-compose" method="post" action="${HERE}">
        <p class="talk-status small muted" role="status" aria-live="polite">${running ? "The forge is answering…" : ""}</p>
        <textarea class="input" name="text" rows="2" maxlength="${WORDS_MAX}" required placeholder="Talk to the forge" aria-label="Talk to the forge"></textarea>
        <div class="bar">
          <span class="muted small">Ctrl+Enter sends</span>
          <span class="spacer"></span>
          ${btn("Send", { variant: "primary" })}
        </div>
      </form>
    </div>`;
  return page({ ctx, title: "Talk", body, styleCss: talkCss, scriptJs: talkJs, description: "Talk to the forge." });
}
// GET /talk
export function talkView(ctx: Ctx): Response {
  if (ctx.auth.user === undefined) return signInFirst(ctx);
  notePhase(ctx.request, "session", takeSessionTime(ctx.request));
  const before = ctx.url.searchParams.get("before");
  return timePhase(ctx.request, "render", () => talkPage(ctx, before !== null && TURN_ID.test(before) && before !== "" ? before : undefined));
}
// POST /talk — the plain form, for a browser without the script.
export async function talkSend(ctx: Ctx): Promise<Response> {
  const user = ctx.auth.user;
  if (user === undefined) return signInFirst(ctx);
  const form = await readForm(ctx, "rw");
  if (form instanceof Response) return form;
  const text = form.get("text");
  if (typeof text !== "string" || text.trim() === "" || text.length > WORDS_MAX)
    return flashTo(ctx, `${HERE}#end`, { tone: "danger", message: `Say something, up to ${WORDS_MAX} characters.` });
  const said = talk(ctx.app, user, text);
  if (!said.ok) return flashTo(ctx, `${HERE}#end`, { tone: "danger", message: TALK_WORDS[said.error][1] });
  return flashTo(ctx, `${HERE}#end`, { tone: "success", message: "Sent. Reload to see the answer." });
}
// POST /talk/confirm/:id — the person's yes or no, from their own session.
export async function talkConfirm(ctx: Ctx): Promise<Response> {
  const user = ctx.auth.user;
  if (user === undefined) return signInFirst(ctx);
  if (ctx.auth.via !== "session") return new Response("forbidden", { status: 403 });
  const form = await readForm(ctx);
  if (form instanceof Response) return form;
  const answer = form.get("answer");
  if (answer !== "yes" && answer !== "no") return new Response("bad request", { status: 400 });
  const asJson = (ctx.request.headers.get("accept") ?? "").includes("application/json");
  const id = ctx.params["id"] ?? "";
  let refused: string | undefined;
  let status = 422;
  if (answer === "no") {
    const no = sayNo(ctx, user, id);
    if (!no.ok) [status, refused] = REFUSED[no.error];
  } else if (waitingConfirms(ctx, user).some((w) => w.id === id && ASKING[w.tool]?.once !== undefined)) {
    // A result shown once is drawn by Settings → Confirms; here it would be thrown away.
    status = 409;
    refused = "this result is shown once: confirm it in Settings → Confirms";
  } else {
    const yes = await sayYes(ctx, user, id);
    if (!yes.ok) [status, refused] = REFUSED[yes.error];
    else if (!yes.done) refused = `${String(yes.turn["tool"])} did not go through: ${String(yes.turn["message"] ?? yes.turn["error"])}`;
  }
  if (asJson) return json(refused === undefined ? { ok: true } : { ok: false, message: refused }, refused === undefined ? 200 : status);
  return flashTo(ctx, `${HERE}#end`, refused === undefined ? { tone: "success", message: answer === "yes" ? "Confirmed." : "Cancelled." } : { tone: "danger", message: `Nothing was done: ${refused}` });
}
// GET /talk/stream?after=<turn id> — turns as they are written, ended with the turn.
export function talkStream(ctx: Ctx): Response {
  const user = ctx.auth.user;
  if (user === undefined) return new Response("sign in", { status: 401 });
  if ((open.get(user.id) ?? 0) >= STREAMS_MAX) return new Response("too many streams", { status: 429, headers: { "retry-after": "5" } });
  const after = ctx.url.searchParams.get("after") ?? ctx.request.headers.get("last-event-id") ?? "";
  if (!TURN_ID.test(after)) return new Response("bad turn id", { status: 400 });
  const { app } = ctx;
  const conversation = openConversation(app.db, user.id);
  let cursor = after;
  return eventStream(app, ctx.request, (emit, close) => {
    const started = Date.now();
    let told = false;
    const tick = (): void => {
      // Asked before the read: a turn that ends after this look is read whole next time.
      const running = clock.running(app, user.id);
      const fresh = turnsAfter(app.db, user.id, conversation.id, cursor);
      if (fresh.length > 0) {
        const waiting = new Set(waitingConfirms(ctx, user).map((w) => w.id));
        for (const turn of fresh) {
          emit("turn", { id: turn.id, html: turnHtml(turn, waiting).text }, turn.id);
          cursor = turn.id;
        }
      }
      if (fresh.length >= MAX_PAGE) return;
      if (!running) {
        emit("done", {});
        close();
      } else if (Date.now() - started >= clock.streamMs) {
        emit("more", {});
        close();
      } else if (!told) {
        told = true;
        emit("running", {});
      }
    };
    open.set(user.id, (open.get(user.id) ?? 0) + 1);
    const timer = setInterval(tick, POLL_MS);
    queueMicrotask(tick);
    return () => {
      clearInterval(timer);
      const left = (open.get(user.id) ?? 1) - 1;
      if (left <= 0) open.delete(user.id);
      else open.set(user.id, left);
    };
  });
}
@@ -0,0 +1,111 @@
/**
 * The /talk page's own stylesheet and script (#7652), kept apart from the
 * page so each is one idea. The script is static code, never built from
 * user text; every turn it draws arrives as markup the server escaped.
 */
export const talkCss = /* css */ `
.talk { display: grid; grid-template-rows: auto 1fr auto; gap: 0.75rem; max-width: min(48rem, 100%); margin: 0 auto; min-width: 0; }
.talk-log { list-style: none; margin: 0; padding: 0; display: grid; gap: 0.625rem; min-width: 0; align-content: start; min-height: 40dvh; }
.talk-turn { min-width: 0; max-width: 100%; overflow-wrap: anywhere; word-break: break-word; }
.talk-turn p { margin: 0 0 8px; }
.talk-turn p:last-child { margin-bottom: 0; }
.talk-turn pre { max-width: 100%; overflow-x: auto; }
.talk-person { justify-self: end; max-width: 85%; background: var(--muted); border: 1px solid var(--border); border-radius: var(--radius-lg); padding: 0.5rem 0.75rem; white-space: pre-wrap; }
.talk-agent { justify-self: start; max-width: 100%; padding: 4px 0; }
.talk-tool { color: var(--muted); font-size: var(--fs-min); padding: 0 4px; }
.talk-confirm { border: 1px solid var(--border); border-radius: var(--radius-lg); padding: 0.75rem; background: var(--card); }
.talk-confirm .bar { margin-top: 8px; gap: 8px; }
.talk-confirm .btn { min-height: 2.75rem; flex: 1 1 8rem; }
.talk-compose { position: sticky; bottom: 0; background: var(--bg); padding: 0.5rem 0 max(0.5rem, env(safe-area-inset-bottom)); border-top: 1px solid var(--border); z-index: 8; }
.talk-compose textarea { width: 100%; min-height: 56px; max-height: 40dvh; font-size: 16px; resize: vertical; box-sizing: border-box; }
.talk-compose .bar { margin-top: 6px; gap: 8px; align-items: center; }
.talk-compose .btn { min-height: 2.75rem; }
.talk-status { min-height: 1.5em; margin: 0; }
.talk-more { text-align: center; }
`;
/** Runs after DOMContentLoaded (`pageScriptAsset`). Reads the page's own `data-talk-*`; sends with fetch, follows with EventSource. */
export const talkJs = `
const root = document.querySelector("[data-talk]");
if (root) {
  const log = root.querySelector(".talk-log");
  const form = root.querySelector("form.talk-compose");
  const box = form.querySelector("textarea");
  const status = root.querySelector(".talk-status");
  let last = log.dataset.last || "";
  let source = null;
  let retry = 0;
  const paged = root.dataset.paged === "1";
  const say = (words) => { status.textContent = words; };
  const toEnd = () => { const end = document.getElementById("end"); if (end) end.scrollIntoView({ block: "end" }); };
  const follow = () => {
    if (paged) return;
    if (source) source.close();
    source = new EventSource("/talk/stream?after=" + encodeURIComponent(last));
    source.addEventListener("turn", (e) => {
      const turn = JSON.parse(e.data);
      last = turn.id;
      if (!document.getElementById("t-" + turn.id)) log.insertAdjacentHTML("beforeend", turn.html);
      retry = 0;
      toEnd();
    });
    source.addEventListener("running", () => say("The forge is answering…"));
    source.addEventListener("done", () => { say(""); source.close(); source = null; });
    source.addEventListener("more", () => { source.close(); follow(); });
    source.addEventListener("drain", () => { source.close(); setTimeout(follow, 1000); });
    source.onerror = () => {
      source.close();
      source = null;
      if (++retry < 6) setTimeout(follow, Math.min(1000 * retry, 5000));
      else say("Lost the connection. Reload to see the rest.");
    };
  };
  const send = async (e) => {
    e.preventDefault();
    const text = box.value.trim();
    if (!text) return;
    say("Sending…");
    try {
      const res = await fetch("/api/v1/conversation/messages", {
        method: "POST",
        headers: { "content-type": "application/json" },
        body: JSON.stringify({ text }),
      });
      if (!res.ok) {
        const body = await res.json().catch(() => ({}));
        say(body.message || "That was not sent.");
        return;
      }
      box.value = "";
      if (paged) { location.href = "/talk"; return; }
      follow();
    } catch (_) {
      say("That was not sent: no connection.");
    }
  };
  form.addEventListener("submit", send);
  box.addEventListener("keydown", (e) => {
    if (e.key === "Enter" && (e.metaKey || e.ctrlKey)) form.requestSubmit();
  });
  log.addEventListener("submit", async (e) => {
    const f = e.target.closest("form[data-confirm]");
    if (!f) return;
    e.preventDefault();
    const answer = e.submitter ? e.submitter.value : "no";
    const body = new URLSearchParams({ answer });
    say(answer === "yes" ? "Confirming…" : "Cancelling…");
    try {
      const res = await fetch(f.action, { method: "POST", headers: { accept: "application/json" }, body });
      const out = await res.json().catch(() => ({}));
      say(res.ok ? "" : out.message || "Nothing was done.");
      f.replaceWith(Object.assign(document.createElement("p"), { className: "muted small", textContent: res.ok ? (answer === "yes" ? "Confirmed." : "Cancelled.") : "Not done." }));
      follow();
    } catch (_) {
      say("That was not sent: no connection.");
    }
  });
  toEnd();
  if (root.dataset.running === "1" && !paged) follow();
}
`;
@@ -112,6 +112,7 @@
export function tellBox(ctx: Ctx, user: User): Html {
          <option value="${FORGE_TARGET}">the forge</option>
        </select>`}
    ${btn("Tell", { variant: "primary" })}
    ${btn("Talk", { href: "/talk", icon: "comment", title: "Talk to the forge" })}
  </form>`;
}
@@ -416,6 +416,38 @@
describe("the yes, reached by a person", () => {
    expect(getRepoById(app.db, w.repoId)!.archivedAt).toBeNull();
  });
  test("the terminal's Confirms: n, then Cancel it, spends the confirm and runs nothing", async () => {
    const w = await world(alice);
    const asked = JSON.parse((await call(w.token, "archive", { repo: w.repo, archived: true, dryRun: false })).text);
    const terminal = headlessTerminal(160, 32);
    const { app: tui } = createForgeApp(app, { sshUsername: "t", remoteAddress: "127.0.0.1", user: alice }, { terminal, exitHooks: false });
    tui.start();
    const key = (k: string, ctrl = false) => tui.dispatch({ type: "key", key: k, ctrl, alt: false, shift: false });
    try {
      key("k", true);
      await settleApp(tui);
      for (const ch of "Confirms") key(ch);
      await settleApp(tui);
      key("enter");
      await settleApp(tui);
      for (const h of waitingFor(app.db, alice.id)) if (h.id !== asked.needs_confirm) key("j");
      await settleApp(tui);
      key("n");
      await settleApp(tui);
      expect(tui.screen.toText()).toContain("Cancel this");
      key("right");
      key("enter");
      await settleApp(tui);
      expect(tui.screen.toText()).toContain("Cancelled: archive.");
      expect(getRepoById(app.db, w.repoId)!.archivedAt).toBeNull();
      expect(waitingFor(app.db, alice.id).some((h) => h.id === asked.needs_confirm)).toBe(false);
      const turns = listTurns(app.db, alice.id, openConversation(app.db, alice.id).id, { limit: 200 });
      expect(JSON.stringify(turns)).toContain("cancelled");
    } finally {
      tui.stop();
    }
  });
  test("the terminal's Confirms: y, then Yes, does it once", async () => {
    const w = await world(alice);
    const asked = JSON.parse((await call(w.token, "archive", { repo: w.repo, archived: true, dryRun: false })).text);
@@ -11,11 +11,10 @@
const web = join(root, "src", "web");
/** Today's danger POST buttons that do not ask first, one `file — reason` per line. */
const allowed: readonly { file: string; button: string; reason: string }[] = [
  { file: "src/web/pages/boards-view.ts", button: `"Delete this board"`, reason: "board delete; waits for its confirm issue" },
  { file: "src/web/pages/org.ts", button: `"Remove"`, reason: "team member remove; waits for its confirm issue" },
  { file: "src/web/pages/edit.ts", button: `"Delete this file"`, reason: "the delete page is the confirmation, reached by a link" },
  { file: "src/web/pages/pull.ts", button: `"Land past the gate"`, reason: "asks for a typed reason of at least 8 characters" },
  { file: "src/web/studio/notes.ts", button: "label", reason: "owner note ban; undone by unban on the same row" },
  { file: "src/web/studio/change.ts", button: `"Send it back"`, reason: "a changes-requested review with an optional why; the next review replaces it" },
];
type DangerPost = { file: string; line: number; button: string };
@@ -11,7 +11,7 @@
const doc = readFileSync("docs/design/audit.md", "utf8");
/** Routes that answer a file, a fragment, a redirect hop or a callback. */
const NOT_PAGES =
  /^\/(assets\/|\.well-known\/|icons\/|og\/|live\/|__forge\/|go\/|events$|system\/stream$|settings\/teams\/stream$|sw\.js$|robots\.txt$|favicon\.ico$|apple-touch-icon(-precomposed)?\.png$|sitemap\.xml$|manifest\.webmanifest$|opensearch\.xml$|llms\.txt$|releases\.json$|audit\.csv$|fleet\/graph\/live$|fleet\/graph\.csv$|settings\/origins\/callback$|home\/archived\/|settings\/backups\/live$)/;
  /^\/(assets\/|\.well-known\/|icons\/|og\/|live\/|__forge\/|go\/|events$|system\/stream$|talk\/stream$|settings\/teams\/stream$|sw\.js$|robots\.txt$|favicon\.ico$|apple-touch-icon(-precomposed)?\.png$|sitemap\.xml$|manifest\.webmanifest$|opensearch\.xml$|llms\.txt$|releases\.json$|audit\.csv$|fleet\/graph\/live$|fleet\/graph\.csv$|settings\/origins\/callback$|home\/archived\/|settings\/backups\/live$)/;
const getRoutes = [
  ...server.matchAll(/router\.add\(\s*"GET",\s*"([^"]+)"/g),
@@ -10,6 +10,7 @@
import { Glob } from "bun";
/** file -> the patterns it may carry, and why */
const ALLOWED: Record<string, { allow: string[]; why: string }> = {
  "src/web/sw.ts": { allow: ['http-equiv="refresh"'], why: "the restart page: the forge is down, so there is no /events to hear" },
  "src/web/pages/talk.ts": { allow: ["setInterval"], why: "server side: the stream of one turn watches the run's row, which has no event to hear" },
  "src/web/client.ts": { allow: ["data-live-every", "setInterval"], why: "the data-live-every mechanism itself, and clocks that only redraw text" },
};
@@ -0,0 +1,312 @@
/**
 * /talk (#7652): the page renders the person's own history and a composer,
 * a reply streams over SSE and ends with the turn, resuming from a turn id;
 * a held action draws Confirm and Cancel that post the person's yes or no;
 * signed out goes to /signin; Talk is in the chrome, the palette and home;
 * a stream is capped per person; a once-result is never confirmed here.
 */
import { afterAll, beforeAll, describe, expect, test } from "bun:test";
import { mkdtemp, rm } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { createApp, type App } from "../src/app.ts";
import { createRepo } from "../src/actions/repos.ts";
import { sayNo } from "../src/actions/conversation_confirms.ts";
import { clock, STREAMS_MAX } from "../src/web/pages/talk.ts";
import { appendTurn, listTurns, openConversation } from "../src/core/conversations.ts";
import { hold, waitingFor } from "../src/core/fence.ts";
import { getRepoById } from "../src/core/repos.ts";
import { createSession } from "../src/core/sessions.ts";
import { createUser, type User } from "../src/core/users.ts";
import { serve, type Servers } from "../src/http/server.ts";
import { promote } from "./helpers/members.ts";
import { quietLogs } from "./helpers/globals.ts";
quietLogs();
let dir: string;
let app: App;
let servers: Servers;
let alice: User;
let bob: User;
const cookie = (u: User) => `forge_session=${createSession(app.db, u.id).token}`;
const get = (path: string, u?: User, headers: Record<string, string> = {}) =>
  fetch(`${servers.url}${path}`, { redirect: "manual", headers: { ...(u ? { cookie: cookie(u) } : {}), ...headers } });
const post = (path: string, u: User, form: Record<string, string>, headers: Record<string, string> = {}) =>
  fetch(`${servers.url}${path}`, {
    method: "POST",
    redirect: "manual",
    headers: { origin: servers.url, cookie: cookie(u), ...headers },
    body: new URLSearchParams(form),
  });
const say = (u: User, role: string, text: string) =>
  appendTurn(app.db, u.id, openConversation(app.db, u.id).id, { role, text });
/** The frames of a stream that ended on its own. */
async function frames(path: string, u: User, headers: Record<string, string> = {}) {
  const res = await get(path, u, headers);
  const text = await res.text();
  return text
    .split("\n\n")
    .map((f) => ({
      event: /^event: (.*)$/m.exec(f)?.[1],
      id: /^id: (.*)$/m.exec(f)?.[1],
      data: /^data: (.*)$/m.exec(f)?.[1],
    }))
    .filter((f) => f.event !== undefined);
}
beforeAll(async () => {
  dir = await mkdtemp(join(tmpdir(), "forge-talk-page-"));
  app = createApp({ dataDir: dir, port: 0 });
  servers = await serve(app);
  const mk = async (username: string, first = false) => {
    const u = await createUser(app.db, { origin: "seed", trusted: true, username, email: `${username}@forge.local`, password: "a-good-passphrase", adminIfFirst: first });
    if (!u.ok) throw new Error(u.error);
    promote(app.db, u.value);
    return u.value;
  };
  alice = await mk("alice", true);
  bob = await mk("bob");
}, 30_000);
afterAll(async () => {
  servers.stop();
  app.close();
  await rm(dir, { recursive: true, force: true });
});
describe("the page", () => {
  test("signed out goes to /signin and comes back", async () => {
    const res = await get("/talk");
    expect(res.status).toBe(303);
    expect(res.headers.get("location")).toStartWith("/signin?next=%2Ftalk");
    expect((await get("/talk/stream")).status).toBe(401);
  });
  test("renders your history escaped, a composer, and keeps the log in order", async () => {
    say(alice, "person", "hello <b>there</b>");
    say(alice, "agent", "Hi **alice**");
    const res = await get("/talk", alice);
    expect(res.status).toBe(200);
    const page = await res.text();
    expect(page).toContain("hello &lt;b&gt;there&lt;/b&gt;");
    expect(page).not.toContain("<b>there</b>");
    expect(page).toContain("<strong>alice</strong>");
    expect(page).toContain('action="/talk"');
    expect(page).toContain('name="text"');
    expect(page.indexOf("hello")).toBeLessThan(page.indexOf("Hi "));
    expect(res.headers.get("content-security-policy")).toBeTruthy();
  });
  test("each person has their own conversation", async () => {
    say(alice, "person", "alice-only secret");
    const bobs = await (await get("/talk", bob)).text();
    expect(bobs).not.toContain("alice-only secret");
    expect(bobs).toContain("Ask the forge anything");
  });
  test("a message with no agent running says so and is not kept", async () => {
    const res = await post("/talk", bob, { text: "do a thing" });
    expect(res.status).toBe(303);
    const after = await (await get("/talk", bob)).text();
    expect(after).not.toContain("do a thing");
    expect((await post("/talk", bob, { text: "x" }, { origin: "https://elsewhere.example" })).status).toBe(403);
    expect((await post("/talk", bob, { text: "  " })).status).toBe(303);
  });
  test("Talk is one tap away: the chrome, the palette and home", async () => {
    const home = await (await get("/explore", alice)).text();
    expect(home).toContain('href="/talk"');
    expect(home).toContain('aria-label="Talk to the forge"');
    expect(home).toContain('"h":"/talk"');
  });
});
describe("the stream", () => {
  test("replays turns after an id, then ends with the turn", async () => {
    const a = say(bob, "person", "first");
    const b = say(bob, "agent", "second");
    if (!a.ok || !b.ok) throw new Error("turns");
    const all = await frames("/talk/stream?after=", bob);
    expect(all.map((f) => f.event)).toEqual(["turn", "turn", "done"]);
    expect(all[0]!.id).toBe(a.value.id);
    expect(JSON.parse(all[1]!.data!).html).toContain("second");
    const rest = await frames(`/talk/stream?after=${a.value.id}`, bob);
    expect(rest.map((f) => f.id ?? f.event)).toEqual([b.value.id, "done"]);
    // A reconnect that names the last turn it saw gets only what is new.
    const resumed = await frames("/talk/stream", bob, { "last-event-id": b.value.id });
    expect(resumed.map((f) => f.event)).toEqual(["done"]);
  });
  test("never shows another person's turns, and refuses a bad id", async () => {
    const mine = say(bob, "agent", "bob private");
    if (!mine.ok) throw new Error("turn");
    const theirs = await frames(`/talk/stream?after=${mine.value.id}`, alice);
    expect(theirs.map((f) => f.event)).toEqual(["done"]);
    const seen = await frames("/talk/stream?after=", alice);
    expect(JSON.stringify(seen)).not.toContain("bob private");
    expect((await get("/talk/stream?after=%3Cscript%3E", alice)).status).toBe(400);
  });
});
describe("confirm and cancel", () => {
  async function held(u: User) {
    const made = await createRepo(app, u, { name: `r${Math.random().toString(36).slice(2, 8)}`, visibility: "public" });
    if (!made.ok) throw new Error(String(made.error));
    const id = hold(app.db, "conversation:talk", u.id, "archive", { repo: `${u.username}/${made.value.name}`, archived: true, dryRun: false });
    if (id === null) throw new Error("hold");
    say(u, "confirm", JSON.stringify({ confirm: id, tool: "archive", does: "This will archive the app." }));
    return { id, repoId: made.value.id };
  }
  test("a waiting confirm draws Confirm and Cancel; Cancel does nothing and cannot be undone by a yes", async () => {
    const h = await held(alice);
    const page = await (await get("/talk", alice)).text();
    expect(page).toContain("This will archive the app.");
    expect(page).toContain(`action="/talk/confirm/${h.id}"`);
    expect(page).toContain("Confirm");
    expect(page).toContain("Cancel");
    const no = await post(`/talk/confirm/${h.id}`, alice, { answer: "no" }, { accept: "application/json" });
    expect(no.status).toBe(200);
    expect(getRepoById(app.db, h.repoId)!.archivedAt).toBeNull();
    const yes = await post(`/talk/confirm/${h.id}`, alice, { answer: "yes" }, { accept: "application/json" });
    expect(yes.status).toBe(409);
    expect(getRepoById(app.db, h.repoId)!.archivedAt).toBeNull();
    const after = await (await get("/talk", alice)).text();
    expect(after).toContain("Cancelled: archive.");
    expect(after).not.toContain(`action="/talk/confirm/${h.id}"`);
  });
  test("Confirm does the stored call once", async () => {
    const h = await held(alice);
    const yes = await post(`/talk/confirm/${h.id}`, alice, { answer: "yes" }, { accept: "application/json" });
    expect(yes.status).toBe(200);
    expect(getRepoById(app.db, h.repoId)!.archivedAt).not.toBeNull();
    expect((await post(`/talk/confirm/${h.id}`, alice, { answer: "yes" }, { accept: "application/json" })).status).toBe(409);
    expect(await (await get("/talk", alice)).text()).toContain("Done: archive.");
  });
  test("nobody else's yes or no counts, nor a cross-origin one, nor a bad answer", async () => {
    const h = await held(alice);
    expect((await post(`/talk/confirm/${h.id}`, bob, { answer: "yes" }, { accept: "application/json" })).status).toBe(404);
    expect((await post(`/talk/confirm/${h.id}`, bob, { answer: "no" }, { accept: "application/json" })).status).toBe(404);
    expect((await post(`/talk/confirm/${h.id}`, alice, { answer: "yes" }, { origin: "https://elsewhere.example" })).status).toBe(403);
    expect((await post(`/talk/confirm/${h.id}`, alice, { answer: "maybe" })).status).toBe(400);
    expect(getRepoById(app.db, h.repoId)!.archivedAt).toBeNull();
  });
});
describe("a once-result", () => {
  test("a yes posted here is refused, runs nothing and keeps the confirm for Settings", async () => {
    const id = hold(app.db, "conversation:talk", alice.id, "mint_invite", {});
    if (id === null) throw new Error("hold");
    say(alice, "confirm", JSON.stringify({ confirm: id, tool: "mint_invite", does: "This will mint an invite." }));
    const page = await (await get("/talk", alice)).text();
    expect(page).toContain(`action="/settings/confirms/${id}"`);
    const yes = await post(`/talk/confirm/${id}`, alice, { answer: "yes" }, { accept: "application/json" });
    expect(yes.status).toBe(409);
    expect(((await yes.json()) as { message: string }).message).toContain("Settings");
    expect(waitingFor(app.db, alice.id).some((h) => h.id === id)).toBe(true);
    // Cancel is still allowed here.
    expect((await post(`/talk/confirm/${id}`, alice, { answer: "no" }, { accept: "application/json" })).status).toBe(200);
  });
});
describe("sayNo", () => {
  test("spends the confirm, writes a cancelled tool turn, and is not another person's to say", () => {
    const id = hold(app.db, "conversation:talk", bob.id, "archive", { repo: "bob/none", archived: true, dryRun: false });
    if (id === null) throw new Error("hold");
    expect(sayNo({ app }, alice, id)).toEqual({ ok: false, error: "not_found" });
    const no = sayNo({ app }, bob, id);
    expect(no.ok).toBe(true);
    expect(sayNo({ app }, bob, id)).toEqual({ ok: false, error: "answered" });
    const turns = listTurns(app.db, bob.id, openConversation(app.db, bob.id).id, { limit: 200 });
    if (!turns.ok) throw new Error("turns");
    const last = JSON.parse(turns.value.at(-1)!.text);
    expect(last).toMatchObject({ confirm: id, tool: "archive", done: false, cancelled: true });
    expect(sayNo({ app }, bob, "../x")).toEqual({ ok: false, error: "not_found" });
  });
});
describe("paging back", () => {
  test("?before= shows older turns, does not follow, and validates the id", async () => {
    const carol = await createUser(app.db, { origin: "seed", trusted: true, username: "carol", email: "[email protected]", password: "a-good-passphrase" });
    if (!carol.ok) throw new Error("user");
    promote(app.db, carol.value);
    let ids: string[] = [];
    for (let i = 0; i < 55; i++) {
      const t = say(carol.value, "person", `turn-${String(i).padStart(2, "0")}`);
      if (t.ok) ids.push(t.value.id);
    }
    const first = await (await get("/talk", carol.value)).text();
    expect(first).toContain("turn-54");
    expect(first).not.toContain("turn-04");
    expect(first).toContain('data-paged="0"');
    const link = /href="\/talk\?before=([0-9a-z]+)"/.exec(first);
    expect(link).not.toBeNull();
    clock.running = () => true;
    try {
      const older = await (await get(`/talk?before=${link![1]}`, carol.value)).text();
      expect(older).toContain("turn-04");
      expect(older).not.toContain("turn-54");
      expect(older).toContain('data-paged="1"');
      expect(older).toContain('data-running="0"');
      const latest = await (await get("/talk", carol.value)).text();
      expect(latest).toContain('data-running="1"');
    } finally {
      clock.running = (await import("../src/crew/conversation.ts")).turnRunning;
    }
    // A bad id is ignored, not echoed.
    const bad = await get("/talk?before=%3Cscript%3E", carol.value);
    expect(bad.status).toBe(200);
    expect(await bad.text()).not.toContain("<script>alert");
  });
});
describe("a long stream", () => {
  test("while a turn runs it says running, then asks the client to reconnect", async () => {
    const { turnRunning } = await import("../src/crew/conversation.ts");
    clock.running = () => true;
    clock.streamMs = 700;
    try {
      const seen = await frames("/talk/stream?after=", alice);
      const events = seen.map((f) => f.event);
      expect(events.at(-1)).toBe("more");
      expect(events).toContain("running");
      expect(events).not.toContain("done");
    } finally {
      clock.running = turnRunning;
      clock.streamMs = 40_000;
    }
  });
  test("a person holds at most STREAMS_MAX at once; the next waits, and a slot frees", async () => {
    const { turnRunning } = await import("../src/crew/conversation.ts");
    clock.running = () => true;
    clock.streamMs = 60_000;
    const aborts = Array.from({ length: STREAMS_MAX }, () => new AbortController());
    try {
      const open = await Promise.all(aborts.map((a) => fetch(`${servers.url}/talk/stream?after=`, { headers: { cookie: cookie(bob) }, signal: a.signal })));
      expect(open.map((r) => r.status)).toEqual(Array(STREAMS_MAX).fill(200));
      const extra = await get("/talk/stream?after=", bob);
      expect(extra.status).toBe(429);
      expect(extra.headers.get("retry-after")).toBeTruthy();
      // Another person is not held back.
      const other = new AbortController();
      expect((await fetch(`${servers.url}/talk/stream?after=`, { headers: { cookie: cookie(alice) }, signal: other.signal })).status).toBe(200);
      other.abort();
      aborts[0]!.abort();
      await new Promise((r) => setTimeout(r, 300));
      const again = new AbortController();
      expect((await fetch(`${servers.url}/talk/stream?after=`, { headers: { cookie: cookie(bob) }, signal: again.signal })).status).toBe(200);
      again.abort();
    } finally {
      for (const a of aborts) a.abort();
      clock.running = turnRunning;
      clock.streamMs = 40_000;
      await new Promise((r) => setTimeout(r, 300));
    }
  });
});
		@@ -329,6 +329,17 @@ $ forge tell "make the header smaller"
329	329	told alice/shop: issue #12 https://forge.example.com/alice/shop/issues/12
330	330	```
331	331
	332	## forge talk
	333
	334	Say something to the forge's own agent, as you, and print what it answers.
	335	The agent works through the forge's MCP with your permissions; a write it
	336	would make is held for your yes (Confirm or Cancel on `/talk`). Words are 1 to
	337	20000 characters. It waits up to two minutes, then says where to read the rest.
	338
	339	```console
	340	$ forge talk "what is waiting on me?"
	341	```
	342
332	343	## forge new
333	344
334	345	Makes an app from the shell, as `POST /api/v1/apps` does, then clones its
		@@ -0,0 +1,14 @@
	1	# Talk
	2
	3	`/talk` (#7652) is the person's one conversation with the forge: a log, a composer, and Confirm and Cancel for a held action.
	4
	5	- `.talk` — the page's column: at most 760px, centred, `min-width: 0` so nothing pushes the page sideways at 375px.
	6	- `.talk-log` — the ordered list of turns; its `data-last` is the last turn id the stream resumes from.
	7	- `.talk-turn` — one turn; wraps anywhere, so a long word or URL never scrolls the page.
	8	- `.talk-person` — the person's words: a right-aligned bubble, pre-wrapped.
	9	- `.talk-agent` — the agent's reply, markdown, full width, no bubble.
	10	- `.talk-tool` — what the agent did, one muted small line.
	11	- `.talk-confirm` — a held action's card: the sentence, then Confirm and Cancel at 44px high.
	12	- `.talk-compose` — the composer, sticky to the bottom of the viewport (padded for the phone's safe area), so it stays reachable; its textarea is 16px so iOS does not zoom.
	13	- `.talk-status` — one polite line (sending, answering, an error); it always takes its line, so nothing shifts.
	14	- `.talk-more` — the "Earlier" link above the log.
		@@ -60,6 +60,7 @@ Machine routes are not pages and have no entry: `/audit.csv`,
60	60	- `/asked` — `studio/asked_page.ts` · what I answered, as a record · `/asks` · none seen.
61	61	- `/review` — `studio/review_page.ts` · every ask waiting on me, one row each, newest first · `/asks` (same asks, with buttons) · none seen.
62	62	- `/flow` — `pages/flow.ts` · the pipeline from ready issue to live deploy, and the bottleneck · `/system`, `/board`, `/` · none seen. A topbar button points here.
	63	- `/talk` — `pages/talk.ts` · the person's one conversation with the forge: history, composer, Confirm and Cancel; replies stream in over `/talk/stream` · `/settings/confirms` (the same yes, as a list), the home tell box (one line to an app's crew) · none seen; styles in `docs/design/areas/talk.md`.
63	64	- `/pipeline` — `pages/pipeline.ts` · the four steps a change follows (check, review, land, live), for a newcomer · a pull page's step line, `/flow` · none seen.
64	65	- `/map` — `pages/map.ts` (1,806 lines) · the dependency map of work across the forge · `/board`, issue dependency lists, `/:owner/:name/map` · colours 3, sizes 12: the largest private vocabulary.
65	66	- `/audit` — `pages/audit.ts` · every app's contract, who can do what · the app page's one-line policy · none seen. Names the audit of apps, not this document.
		@@ -9,3 +9,11 @@ One door, `talk()` in `src/actions/talk.ts`, three ways in. It sends the words a
9	9	It needs a granted Claude account (`no_account`), and says `resting` when none can serve it or your daily ceiling is spent. At most four turns run across the forge at once (`TURNS_LIVE_MAX`); a new one past that is `busy` (429, `retry-after: 60`), while a message into your running turn always goes through. A message that is refused is not kept in the conversation.
10	10
11	11	`GET /api/v1/conversation/turns?limit=` takes 1 to 200 turns; absent, empty or not a number is 50.
	12
	13	## On the web: `/talk`
	14
	15	Reached from the Talk icon in every page's top bar, "Talk to the forge" in the palette (`Ctrl/Cmd+K`), `g t`, and the Talk button beside the tell box on home. Signed out, it sends you to /signin and back. It shows your own conversation (the last 50 turns, "Earlier" pages back) and a composer; Ctrl+Enter sends.
	16
	17	A reply streams in over `GET /talk/stream?after=<turn id>` (server-sent events, one `turn` frame per turn, each carrying the server-rendered markup). The stream ends with the turn (`done`), or after 40 seconds (`more`), well inside the edge's timeout; the page then reconnects from the last turn id it saw (`Last-Event-ID` works too). Without the script the composer is a plain form and a reload shows the answer.
	18
	19	When the agent asks first (`needs_confirm`), the turn draws Confirm (the existing yes) and Cancel (a no: the confirm is spent, nothing runs, a turn says it was cancelled). A result shown once (an invite link) is drawn by Settings → Confirms instead, where Confirm leads.
		@@ -3,7 +3,7 @@
3	3	"api.anthropic.com"
4	4	],
5	5	"app": {
6		"looks": ["/", "/forges", "/family", "/front", "/explore", "/board", "/boards", "/asked", "/feed", "/review", "/search", "/new", "/audit", "/releases", "/changelog", "/apps", "/migrate", "/map", "/system", "/contribute", "/pipeline", "/resilience", "/settings"],
	6	"looks": ["/", "/forges", "/family", "/front", "/explore", "/board", "/boards", "/asked", "/feed", "/review", "/search", "/new", "/audit", "/releases", "/changelog", "/apps", "/migrate", "/map", "/system", "/talk", "/contribute", "/pipeline", "/resilience", "/settings"],
7	7	"run": "bun run src/main.ts",
8	8	"install": "",
9	9	"health": "/healthz",
		@@ -92,3 +92,18 @@ export async function sayYes(ctx: Ctx, user: User, confirmId: string): Promise<Y
92	92	appendTurn(ctx.app.db, user.id, conversation.id, { role: "tool", text: JSON.stringify(turn) });
93	93	return { ok: true, done: ran.ok, turn, ...(ran.ok ? { result: ran.value } : {}) };
94	94	}
	95
	96	/**
	97	* The person's no: the confirm is claimed so it can never be said yes to
	98	* later, nothing is run, and a `tool` turn says it was cancelled. Same door
	99	* rules as a yes — the person's own session, decided by the caller.
	100	*/
	101	export function sayNo(ctx: Pick<Ctx, "app">, user: User, confirmId: string): { ok: true; turn: Record<string, unknown> } \| { ok: false; error: YesRefusal } {
	102	if (!CONFIRM_ID.test(confirmId)) return { ok: false, error: "not_found" };
	103	const answered = answerHeld(ctx.app.db, confirmId, user.id);
	104	if (!answered.ok) return answered;
	105	const turn = { confirm: answered.value.id, tool: answered.value.tool, done: false, cancelled: true };
	106	const conversation = openConversation(ctx.app.db, user.id);
	107	appendTurn(ctx.app.db, user.id, conversation.id, { role: "tool", text: JSON.stringify(turn) });
	108	return { ok: true, turn };
	109	}
		@@ -136,6 +136,22 @@ export function listTurns(
136	136	return ok(rows.reverse().map(turnOf));
137	137	}
138	138
	139	/**
	140	* The turns after the turn id `after`, oldest first, at most `MAX_PAGE`; an
	141	* empty `after` is the whole conversation's start, an id this conversation
	142	* does not have is nothing. The stream reads this to follow an answer being
	143	* written and to resume from the last turn a client saw.
	144	*/
	145	export function turnsAfter(db: Database, userId: string, conversationId: string, after: string): Turn[] {
	146	if (!owned(db, userId, conversationId)) return [];
	147	const rows = db
	148	.query(
	149	"SELECT * FROM conversation_turn WHERE conversation_id = ?1 AND rowid > COALESCE(CASE WHEN ?2 = '' THEN 0 ELSE (SELECT rowid FROM conversation_turn WHERE id = ?2 AND conversation_id = ?1) END, 9223372036854775807) ORDER BY rowid LIMIT ?3",
	150	)
	151	.all(conversationId, after, MAX_PAGE) as TurnRow[];
	152	return rows.map(turnOf);
	153	}
	154
139	155	/** What a Claude session id may look like: short, and only id characters. */
140	156	export const SESSION_ID = /^[A-Za-z0-9._-]{1,128}$/;
141	157
		@@ -108,6 +108,7 @@ export const SYSTEM_NAMES: readonly string[] = [
108	108	"releases.json",
109	109	"sw.js",
110	110	"tell",
	111	"talk",
111	112	"theme",
112	113	"verify",
113	114	"recover",
		@@ -136,6 +136,7 @@ import {
136	136	themeSubmit,
137	137	} from "../web/pages/site.ts";
138	138	import { confirmsList, confirmYes } from "../web/pages/confirms.ts";
	139	import { talkConfirm, talkSend, talkStream, talkView } from "../web/pages/talk.ts";
139	140	import {
140	141	passkeyAdd,
141	142	passkeyDelete,
		@@ -914,6 +915,10 @@ export function buildRouter(): Router<Handler> {
914	915	router.add("POST", "/settings/tokens", tokenCreate);
915	916	router.add("POST", "/settings/tokens/:id/delete", tokenDelete);
916	917	router.add("POST", "/settings/sessions/:id/delete", sessionDelete);
	918	router.add("GET", "/talk", talkView);
	919	router.add("POST", "/talk", talkSend);
	920	router.add("GET", "/talk/stream", talkStream);
	921	router.add("POST", "/talk/confirm/:id", talkConfirm);
917	922	router.add("GET", "/settings/confirms", confirmsList);
918	923	router.add("POST", "/settings/confirms/:id", confirmYes);
919	924	router.add("GET", "/settings/passkeys", passkeysPage);
		@@ -5,10 +5,11 @@
5	5	* sentence, through the same action the web and the API call
6	6	* (`actions/conversation_confirms.ts`): it does the stored call once. A
7	7	* result shown only once (a link, a credential) opens in a dialog and is not
8		* kept in the conversation.
	8	* kept in the conversation. `n` cancels the one under the cursor the same way
	9	* (`sayNo`): the confirm is spent, nothing runs, and the conversation says so.
9	10	*/
10	11
11		import { REFUSED, sayYes, waitingConfirms } from "../../actions/conversation_confirms.ts";
	12	import { REFUSED, sayNo, sayYes, waitingConfirms } from "../../actions/conversation_confirms.ts";
12	13	import { ASKING } from "../../crew/conversation_confirm.ts";
13	14	import type { Ctx, Screen } from "../app/app.ts";
14	15	import { binding } from "../app/keys.ts";
		@@ -28,7 +29,7 @@ export function confirmsScreen(f: Session, ctx: Ctx): Screen {
28	29
29	30	const screen: Screen = {
30	31	title: "Confirms",
31		keys: [binding(["j", "k"], "move cursor"), binding(["y"], "yes")],
	32	keys: [binding(["j", "k"], "move cursor"), binding(["y"], "yes"), binding(["n"], "cancel")],
32	33	render(area, s) {
33	34	const c = ctx.theme.c;
34	35	const [head, body] = split(area, "v", [len(1), fill(1)]);
		@@ -37,16 +38,32 @@ export function confirmsScreen(f: Session, ctx: Ctx): Screen {
37	38	? note
38	39	: items().length === 0
39	40	? "Nothing waiting for your yes."
40		: "What the forge's agent asked to do; y does it once, as you.";
	41	: "What the forge's agent asked to do; y does it once, as you; n cancels it.";
41	42	s.text(head!.x, head!.y, truncate(text, head!.w), style(c.mutedFg, c.bg), head!.x + head!.w);
42	43	drawList(s, body!, c, state, rows());
43	44	},
44	45	key(e) {
45	46	if (state.key(e, items().length)) return true;
46		if (e.ctrl \|\| e.alt \|\| e.key !== "y") return false;
	47	if (e.ctrl \|\| e.alt \|\| (e.key !== "y" && e.key !== "n")) return false;
47	48	const w = items()[state.index];
48	49	const user = f.user;
49	50	if (w === undefined \|\| user === undefined) return false;
	51	if (e.key === "n") {
	52	ctx.push(
	53	confirmScreen(ctx, screen, {
	54	title: "Cancel this",
	55	body: [w.does],
	56	actions: [{ label: "Keep", variant: "ghost" }, { label: "Cancel it", variant: "default" }],
	57	onChoose: (i) => {
	58	if (i !== 1) return;
	59	const no = sayNo(f, user, w.id);
	60	note = no.ok ? `Cancelled: ${w.tool}.` : `Nothing was done: ${REFUSED[no.error][1]}.`;
	61	ctx.invalidate();
	62	},
	63	}),
	64	);
	65	return true;
	66	}
50	67	ctx.push(
51	68	confirmScreen(ctx, screen, {
52	69	title: "Say yes",