openshain 0.2.0 → 0.4.0

package/src/tui/controller.ts

@@ -1,17 +1,27 @@
-import { createSession, type Session, type TurnResult } from "@openshain/agent";
 import {
-  type AnyEvent,
-  createRuntime,
+  type ApprovalAnswer,
+  type ApprovalChoice,
+  connectInMemory,
+  createSession,
+  type HeldApproval,
+  type Session,
+  type TurnResult,
+} from "@openshain/agent";
+import {
   type Event,
-  type Runtime,
+  loadConfig,
+  OpenshainError,
   type RuntimeProviders,
   type WorkId,
+  WorkStore,
 } from "@openshain/core";
-import { progressLine, report } from "../commands/run.ts";
+import { createMcpServer } from "@openshain/mcp";
 import { toolsList } from "../commands/tools.ts";
-import { workList, workResume, workShow } from "../commands/work.ts";
-import { plain } from "../format.ts";
+import { workList, workShow } from "../commands/work.ts";
+import { describeInput, plain } from "../format.ts";
 import { statusLabel } from "../labels.ts";
+import { type PreviewLine, previewCall } from "../preview.ts";
+import { progressLine, report } from "../report.ts";
 import { LOGO_ROWS, VERSION } from "./banner.ts";
 
 /** logo and banner are the rows shown once when the screen opens: the wordmark, the version, the folder. */
@@ -40,6 +50,19 @@ export interface ControllerState {
   busy: boolean;
   /** A question a work is asking; the next line the person types answers it. */
   question?: string;
+  /** A call held for approval; the person picks one of its choices before the work goes on. */
+  approval?: {
+    approvalId: string;
+    title: string;
+    ruleId: string;
+    preview: PreviewLine[];
+    choices: { key: ApprovalChoice | "reject_with_reason"; label: string }[];
+    at: number;
+  };
+  /** After "no, and tell the agent why": the next line the person types is that reason. */
+  reason?: string;
+  /** Lines typed while the screen was busy. They are sent in order once it is free. */
+  queued: string[];
   closed: boolean;
   status: {
     company: string;
@@ -59,6 +82,10 @@ export interface Controller {
   submit(line: string): Promise<void>;
   /** Ctrl-C: stops the running work, taking back a question it waits on; false when nothing was running. */
   interrupt(): boolean;
+  /** Moves the highlight in the approval choices. */
+  moveApproval(delta: number): void;
+  /** Answers the approval being shown: the highlighted choice, or the one given. */
+  decideApproval(choice?: ApprovalChoice | "reject_with_reason"): void;
   /** Stops whatever is running, then ends the session. A second call waits for the same close. */
   close(): Promise<void>;
 }
@@ -66,13 +93,15 @@ export interface Controller {
 export interface ControllerOptions {
   workspaceRoot: string;
   providers: RuntimeProviders;
-  runtime?: Runtime;
 }
 
 const HELP = [
   "/work list         Work の一覧",
   "/work show <id>    Work の詳細",
-  "/work resume <id>  止まった Work を続ける",
+  "/work resume <id>  止まった Work を候補にする。次の依頼がそれに沿えば続ける",
+  "/approvals         承認待ちの一覧",
+  "/approve <id>      承認して実行する。/reject <id> [理由] で拒否する",
+  "/review <id> approve|reject  資格者の判断を記録する。名前と本文を順に聞く",
   "/tools             使える Tool",
   "/quit              終わる",
   "↑ ↓                前に送った行を入力欄に呼び戻す。いちばん下は新しい入力",
@@ -81,24 +110,61 @@ const HELP = [
   "Ctrl-C             動いている Work を止める。質問待ちなら質問を取り下げる。何も動いていなければ終わる",
 ];
 
+/** The choices the screen offers for a held call, in the order they are shown. */
+const APPROVAL_CHOICES: { key: ApprovalChoice | "reject_with_reason"; label: string }[] = [
+  { key: "approve", label: "はい。実行する" },
+  { key: "always", label: "はい。この会話では同じ規則の呼び出しを常に承認する" },
+  { key: "reject", label: "いいえ。実行しない" },
+  { key: "reject_with_reason", label: "いいえ。理由を伝えて実行しない" },
+];
+
 /** What the session's model hears when the person stops a work that waits for their answer. */
 const QUESTION_WITHDRAWN =
   "the person stopped the work while it waited for their answer; the question is still pending and the work can be resumed";
 
-/** The state behind the screen: a session, the works it starts, and the lines to show. */
+/** What the loop hears when the person leaves a held call undecided. */
+const APPROVAL_WITHDRAWN = "the person left the approval undecided";
+
+/**
+ * The state behind the screen: a session, the works it starts, and the lines to show. The
+ * conversation reaches the runtime only as an MCP client of the workspace's own server, the way
+ * any other agent does; the records are read directly for the closing lines.
+ */
 export async function createController(options: ControllerOptions): Promise<Controller> {
-  const runtime =
-    options.runtime ??
-    (await createRuntime({ workspaceRoot: options.workspaceRoot, providers: options.providers }));
+  const { workspaceRoot, providers } = options;
+  const config = await loadConfig(workspaceRoot, { modelProviders: Object.keys(providers.models) });
+  if (!config.model) {
+    throw new OpenshainError(
+      "config",
+      "対話にはモデルが要ります。openshain.yaml に model を書いてください。Claude Code や Codex から使うだけなら要りません。",
+    );
+  }
+  const modelFactory = Object.hasOwn(providers.models, config.model.provider)
+    ? providers.models[config.model.provider]
+    : undefined;
+  if (!modelFactory) {
+    throw new OpenshainError("config", `unknown model provider "${config.model.provider}"`);
+  }
+  const model = modelFactory(config.model);
+  if (!model.describe().capabilities.tools) {
+    throw new OpenshainError(
+      "config",
+      `model ${config.model.provider}/${config.model.model} cannot call tools; openshain needs a model with tool support`,
+    );
+  }
+  const server = await createMcpServer({ workspaceRoot, tools: providers.tools });
+  const client = await connectInMemory(server);
+  const store = new WorkStore(workspaceRoot);
   const listeners = new Set<() => void>();
   let nextId = 1;
   const state: ControllerState = {
     entries: [],
     busy: false,
     closed: false,
+    queued: [],
     status: {
-      company: runtime.config.company.name,
-      model: `${runtime.config.model.provider}/${runtime.config.model.model}`,
+      company: config.company.name,
+      model: `${config.model.provider}/${config.model.model}`,
       usage: { modelCalls: 0, inputTokens: 0, outputTokens: 0 },
     },
   };
@@ -126,13 +192,23 @@ export async function createController(options: ControllerOptions): Promise<Cont
   };
 
   let pending: { resolve: (text: string) => void; reject: (reason: Error) => void } | undefined;
+  let deciding:
+    | { resolve: (answer: ApprovalAnswer) => void; reject: (reason: Error) => void }
+    | undefined;
   let aborter: AbortController | undefined;
   let running: Promise<void> | undefined;
   let closing: Promise<void> | undefined;
-  /** The child work of the current turn while it is unfinished. */
-  let lastWorkId: WorkId | undefined;
   const names = new Map<string, string>();
 
+  /** Asks the person for one line and waits for it. The next line they type is the answer. */
+  const askLine = (question: string): Promise<string> => {
+    state.question = question;
+    push("question", question);
+    notify();
+    return new Promise((resolve, reject) => {
+      pending = { resolve, reject };
+    });
+  };
   const ask = (workId: WorkId, question: string): Promise<string> => {
     state.question = question;
     push("question", `${question}(${workId})`);
@@ -140,6 +216,51 @@ export async function createController(options: ControllerOptions): Promise<Cont
       pending = { resolve, reject };
     });
   };
+  /** Shows a held call and waits for the person to pick one of the choices. */
+  const askApproval = async (approval: HeldApproval): Promise<ApprovalAnswer> => {
+    const preview = await previewCall(workspaceRoot, {
+      name: approval.name,
+      input: approval.input,
+    }).catch((err) => [{ kind: "note", text: message(err) } as PreviewLine]);
+    const title = `${approval.name} ${describeInput(approval.input)}`.trimEnd();
+    state.approval = {
+      approvalId: approval.approvalId,
+      title,
+      ruleId: approval.ruleId,
+      preview,
+      choices: APPROVAL_CHOICES,
+      at: 0,
+    };
+    push("question", `承認が要ります: ${title}`);
+    for (const line of preview) {
+      push(
+        "progress",
+        `${line.kind === "added" ? "+ " : line.kind === "removed" ? "- " : "  "}${line.text}`,
+      );
+    }
+    return new Promise<ApprovalAnswer>((resolve, reject) => {
+      deciding = { resolve, reject };
+    });
+  };
+  /** Settles the approval being shown, or takes it back when there is no choice. */
+  const settleApproval = (choice?: ApprovalChoice, comment?: string) => {
+    const waiting = deciding;
+    deciding = undefined;
+    if (state.reason !== undefined) {
+      delete state.reason;
+      notify();
+    }
+    if (state.approval !== undefined) {
+      const decided = choice ? APPROVAL_CHOICES.find((c) => c.key === choice)?.label : undefined;
+      delete state.approval;
+      if (decided) push("line", `> ${decided}`);
+      notify();
+    }
+    if (!waiting) return;
+    if (choice === undefined) waiting.reject(new Error(APPROVAL_WITHDRAWN));
+    else waiting.resolve({ choice, ...(comment !== undefined && comment !== "" && { comment }) });
+  };
+
   /** Answers the pending question, or takes it back when there is no answer. */
   const settleQuestion = (answer?: string) => {
     const waiting = pending;
@@ -155,66 +276,98 @@ export async function createController(options: ControllerOptions): Promise<Cont
 
   /** The lines the CLI prints when a work ends, shown among the progress lines. */
   const closingLines = async (workId: WorkId) => {
-    for (const line of await workReport(runtime, workId)) push("progress", line.trimStart());
-  };
-
-  const onWorkEvent = (workId: WorkId, event: AnyEvent): void | Promise<void> => {
-    lastWorkId = workId;
-    if (event.type === "work.status_changed") {
-      state.status.work = {
-        id: workId,
-        status: (event as Event<"work.status_changed">).payload.to,
-      };
-    } else if (event.type === "work.completed" || event.type === "work.failed") {
-      lastWorkId = undefined;
-      state.status.work = {
-        id: workId,
-        status: event.type === "work.completed" ? "completed" : "failed",
-      };
-      return closingLines(workId);
-    }
-    const line = progressLine(event, names);
-    if (line) push("progress", line);
-    else notify();
+    for (const line of await workReport(store, workId)) push("progress", line.trimStart());
   };
 
-  const session: Session = await createSession(runtime, {
-    onEvent: (event) => {
-      if (event.type === "usage.recorded") {
-        const { payload } = event as Event<"usage.recorded">;
-        if (payload.kind === "model_inference") {
-          state.status.usage.modelCalls += 1;
-          state.status.usage.inputTokens += payload.usage.inputTokens;
-          state.status.usage.outputTokens += payload.usage.outputTokens;
-          notify();
+  let sessionId: WorkId | undefined;
+  /** Summaries of the works completed in this turn, until the agent reports them itself. */
+  let unreported: string[] = [];
+  const session: Session = await createSession(client, {
+    model,
+    config,
+    onEvent: (workId, event) => {
+      if (workId === sessionId) {
+        if (event.type === "usage.recorded") {
+          const { payload } = event as Event<"usage.recorded">;
+          if (payload.kind === "model_inference") {
+            state.status.usage.modelCalls += 1;
+            state.status.usage.inputTokens += payload.usage.inputTokens;
+            state.status.usage.outputTokens += payload.usage.outputTokens;
+            notify();
+          }
         }
+        return;
+      }
+      if (event.type === "work.status_changed") {
+        state.status.work = {
+          id: workId,
+          status: (event as Event<"work.status_changed">).payload.to,
+        };
+        notify();
+        return;
       }
+      if (event.type === "work.completed" || event.type === "work.failed") {
+        state.status.work = {
+          id: workId,
+          status: event.type === "work.completed" ? "completed" : "failed",
+        };
+        if (event.type === "work.completed") {
+          // Held, not shown: the agent is the one who tells the person what happened. It is
+          // shown only if the turn ends without the agent saying anything (see submit).
+          const { summary } = (event as Event<"work.completed">).payload;
+          if (summary.trim() !== "") unreported.push(summary.trim());
+        }
+        return closingLines(workId);
+      }
+      // The work_* calls are the loop's own bookkeeping; the closing lines already say the work ended.
+      if (
+        event.type === "tool.called" &&
+        (event as Event<"tool.called">).payload.name.startsWith("work_")
+      ) {
+        names.set(
+          (event as Event<"tool.called">).payload.callId,
+          (event as Event<"tool.called">).payload.name,
+        );
+        return;
+      }
+      const line = progressLine(event, names);
+      if (line) push("progress", line);
+      else notify();
     },
-    onWorkEvent,
     onInput: ask,
+    onApproval: askApproval,
   });
+  sessionId = session.id;
   state.status.agentName = session.agentName;
   for (const row of LOGO_ROWS) push("logo", row);
   push("banner", `openshain ${VERSION}`);
-  push("banner", runtime.workspaceRoot);
+  push("banner", workspaceRoot);
 
-  const stopped = (workId: string | undefined) =>
+  const stopped = (workId: WorkId | undefined) =>
     workId
-      ? `止めました。${workId} は途中のまま残っています。/work resume ${workId} で続けられます。`
+      ? `止めました。${workId} は途中のまま残っています。/work resume ${workId} で続けられるようにします。`
       : "止めました。";
 
   const explain = (result: TurnResult) => {
     switch (result.stopped) {
       case "turn_limit":
-        return "社員エージェントが 1 回の返答でできる回数を超えたので、ここで止めました。続きを依頼できます。";
+        return "社員エージェントが 1 回の返答でできる回数を超えたので、ここで止めました。続きは改めて依頼してください。";
       case "aborted":
-        return stopped(lastWorkId);
+        return stopped(result.work);
       case "max_tokens":
         return "返答が長さの上限で切れました。";
       case "refusal":
         return "社員エージェントが続けられないと言っています。";
       case "model_error":
         return `model の呼び出しに失敗しました。${result.detail ?? ""}`.trim();
+      case "approval": {
+        const a = result.approval;
+        if (!a) return "承認が要ります。/approvals で確かめてください。";
+        if (a.kind === "review") {
+          return `${a.reviewer?.role ?? "資格者"}の判断が要ります: ${a.name} ${describeInput(a.input)}(${a.approvalId})。Review Package は work/${a.workId}/review/ にあります。返答が届いたら /review ${a.approvalId} approve か /review ${a.approvalId} reject で記録します。`;
+        }
+        return `承認が要ります: ${a.name} ${describeInput(a.input)}(${a.approvalId})。/approve ${a.approvalId} で実行、/reject ${a.approvalId} で拒否します。`;
+      }
       default:
         return undefined;
     }
@@ -239,6 +392,16 @@ export async function createController(options: ControllerOptions): Promise<Cont
     }
   };
 
+  /** Sends what the person typed while the agent was working, oldest first. */
+  const drainQueue = async () => {
+    while (state.queued.length > 0 && !closing) {
+      const [next, ...rest] = state.queued as [string, ...string[]];
+      state.queued = rest;
+      notify();
+      await self.submit(next);
+    }
+  };
+
   const capture = async (fn: (write: (line: string) => void) => Promise<unknown>) => {
     try {
       await fn((line) => push("line", line));
@@ -261,21 +424,69 @@ export async function createController(options: ControllerOptions): Promise<Cont
     else if (name === "work" && sub === "show" && id)
       await capture((write) => workShow({ workspaceRoot: options.workspaceRoot, id, write }));
     else if (name === "work" && sub === "resume" && id) {
-      await stoppable(async (signal) => {
-        try {
-          await workResume({
-            workspaceRoot: options.workspaceRoot,
-            providers: options.providers,
-            id,
-            signal,
-            write: (text) => push("line", text),
-            ask: (q) => ask(id as WorkId, q),
-          });
-        } catch (err) {
-          if (!signal.aborted) push("notice", message(err));
+      try {
+        const work = await session.select(id as WorkId);
+        push(
+          "notice",
+          `${work.id}(${statusLabel(work.status)}、${work.objective})を候補にしました。次の依頼がこの Work に沿えば続けます。`,
+        );
+      } catch (err) {
+        push("notice", message(err));
+      }
+    } else if (name === "approvals") {
+      try {
+        const held = await session.approvals();
+        if (held.length === 0) push("line", "承認待ちはありません。");
+        for (const a of held) {
+          push("line", `${a.approvalId}  ${a.name} ${describeInput(a.input)}  (${a.workId})`);
         }
-        if (signal.aborted) push("notice", stopped(id));
-      });
+      } catch (err) {
+        push("notice", message(err));
+      }
+    } else if ((name === "approve" || name === "reject") && sub) {
+      try {
+        const comment = args.slice(1).join(" ");
+        const { text } = await session.decide(sub, name, comment || undefined);
+        push("line", text);
+      } catch (err) {
+        push("notice", message(err));
+      }
+    } else if (name === "approve" || name === "reject") {
+      push("notice", `/${name} には承認の id が要ります。/approvals で確かめてください。`);
+    } else if (name === "review" && sub && (args[1] === "approve" || args[1] === "reject")) {
+      const decision = args[1];
+      try {
+        // The rule already says which role has to decide; the person only says who they are.
+        const held = (await session.approvals()).find((a) => a.approvalId === sub);
+        if (!held)
+          throw new Error(`${sub} は承認待ちにありません。/approvals で確かめてください。`);
+        if (held.kind !== "review") {
+          throw new Error(`${sub} は人の承認待ちです。/approve か /reject で決めます。`);
+        }
+        const role = held.reviewer?.role ?? "reviewer";
+        const who = await askLine(
+          `${role} の名前と資格(例: 田中 太郎 / 税理士)。会社の申告として記録します`,
+        );
+        const [reviewerName, qualification] = who.split("/").map((part) => part.trim());
+        const interpretation = await askLine(
+          decision === "approve" ? "判断の本文(そのまま記録します)" : "認めない理由",
+        );
+        const { text } = await session.review({
+          approvalId: sub,
+          decision,
+          reviewer: {
+            name: reviewerName || who,
+            role,
+            ...(qualification && { qualification }),
+          },
+          interpretation,
+        });
+        push("line", text);
+      } catch (err) {
+        push("notice", message(err));
+      }
+    } else if (name === "review") {
+      push("notice", "/review <id> approve か /review <id> reject の形です。");
     } else if (name === "resume") {
       push(
         "notice",
@@ -290,15 +501,22 @@ export async function createController(options: ControllerOptions): Promise<Cont
     closing ??= (async () => {
       aborter?.abort();
       settleQuestion();
+      settleApproval();
       await running;
-      await session.close();
-      state.closed = true;
-      notify();
+      try {
+        await session.close();
+      } catch (err) {
+        push("notice", `会話の記録を閉じられませんでした。${message(err)}`);
+      } finally {
+        await client.close().catch(() => undefined);
+        state.closed = true;
+        notify();
+      }
     })();
     return closing;
   }
 
-  return {
+  const self: Controller = {
     sessionId: session.id,
     state: () => state,
     subscribe(listener) {
@@ -308,6 +526,15 @@ export async function createController(options: ControllerOptions): Promise<Cont
     async submit(line) {
       const text = line.trim();
       if (text === "" || closing) return;
+      if (state.approval) {
+        push("notice", "承認を先に決めてください。数字か ↑↓ と Enter で選びます。");
+        return;
+      }
+      if (state.reason !== undefined) {
+        push("user", text);
+        settleApproval("reject", text);
+        return;
+      }
       if (pending) {
         push("user", text);
         // Everything typed answers the question, except leaving: that takes the question back.
@@ -316,7 +543,10 @@ export async function createController(options: ControllerOptions): Promise<Cont
         return;
       }
       if (state.busy) {
-        push("notice", "いま動いています。止めるなら Ctrl-C。");
+        // Typing while the agent works is not a mistake: the line waits its turn.
+        state.queued = [...state.queued, text];
+        push("notice", `順番待ち(${state.queued.length} 件): ${text}`);
+        notify();
         return;
       }
       if (text.startsWith("/")) {
@@ -325,31 +555,62 @@ export async function createController(options: ControllerOptions): Promise<Cont
         return;
       }
       push("user", text);
+      unreported = [];
       await stoppable(async (signal) => {
         try {
           const result = await session.turn(text, { signal });
-          if (result.reply) push("assistant", result.reply);
+          // What the work recorded is the agent's own writing, so it stands in when the turn
+          // ends with nothing said. Without this the person is left with a work that finished
+          // and no answer, which is what a model that skips its summary leaves behind.
+          const reply = result.reply.trim() === "" ? unreported.join("\n\n") : result.reply;
+          if (reply) push("assistant", reply);
           const note = explain(result);
           if (note) push("notice", note);
         } catch (err) {
           push("notice", message(err));
         }
       });
+      await drainQueue();
     },
     interrupt() {
       if (!aborter) return false;
       aborter.abort();
       settleQuestion();
+      settleApproval();
       return true;
     },
+    moveApproval(delta) {
+      const approval = state.approval;
+      if (!approval) return;
+      const count = approval.choices.length;
+      state.approval = { ...approval, at: (approval.at + delta + count) % count };
+      notify();
+    },
+    decideApproval(choice) {
+      const approval = state.approval;
+      if (!approval) return;
+      const picked = choice ?? approval.choices[approval.at]?.key ?? "reject";
+      if (picked === "reject_with_reason") {
+        // The palette closes and the input box takes the reason; the loop still waits.
+        const shown = APPROVAL_CHOICES.find((c) => c.key === picked)?.label;
+        delete state.approval;
+        state.reason = "実行しない理由(社員エージェントに伝わります)";
+        if (shown) push("line", `> ${shown}`);
+        push("question", state.reason);
+        notify();
+        return;
+      }
+      settleApproval(picked);
+    },
     close,
   };
+  return self;
 }
 
-/** Lines that close a work in the screen: the CLI's closing lines without the summary, which the clerk relays. */
-export async function workReport(runtime: Runtime, workId: WorkId): Promise<string[]> {
-  const work = await runtime.works.get(workId);
-  const events = await runtime.works.events(workId);
+/** Lines that close a work in the screen: the CLI's closing lines without the summary, which the agent relays. */
+export async function workReport(store: WorkStore, workId: WorkId): Promise<string[]> {
+  const work = await store.get(workId);
+  const events = await store.events(workId);
   const lines = report(work, events);
   return work.status === "completed" ? ["完了。", ...lines.slice(1)] : lines;
 }

package/src/tui/index.ts

@@ -46,6 +46,8 @@ export async function startTui(options: TuiOptions): Promise<number> {
   } finally {
     leave();
   }
-  console.log(`会話を終えました。記録は openshain work show ${controller.sessionId} で読めます。`);
+  console.log(
+    `会話を終えました。記録は openshain work show ${controller.sessionId} で参照します。`,
+  );
   return 0;
 }

package/src/tui/lines.ts

@@ -1,12 +1,14 @@
 import { displayWidth } from "../format.ts";
-import { logoSegments, type Segment } from "./banner.ts";
+import { logoSegments } from "./banner.ts";
 import type { Entry, EntryKind } from "./controller.ts";
+import { markdownRows, type Span } from "./markdown.ts";
 
 export interface ScreenLine {
   kind: EntryKind | "blank";
+  /** The row as plain characters, marker included. */
   text: string;
-  /** Colored pieces of a logo row; the other rows are one color. */
-  segments?: Segment[];
+  /** The row as styled pieces: a logo row, or a reply the screen drew from its markdown. */
+  spans?: Span[];
 }
 
 /** What starts a line of each kind. The continuation lines of a wrapped entry are indented to match. */
@@ -42,6 +44,20 @@ export function wrapText(text: string, width: number): string[] {
   return out;
 }
 
+/**
+ * The rows of one reply, kept until the entry goes or the width changes. The screen redraws
+ * every entry whenever a line is added, and reading markdown is the expensive part of that.
+ */
+const drawn = new WeakMap<Entry, { width: number; rows: Span[][] }>();
+
+export function rowsFor(entry: Entry, width: number): Span[][] {
+  const held = drawn.get(entry);
+  if (held && held.width === width) return held.rows;
+  const rows = markdownRows(entry.text, width);
+  drawn.set(entry, { width, rows });
+  return rows;
+}
+
 /** A blank row goes before an entry that starts something new: a message, a reply, a notice, a question. */
 function startsBlock(kind: EntryKind, previous: EntryKind | undefined): boolean {
   if (previous === undefined) return false;
@@ -59,14 +75,28 @@ export function screenLines(entries: readonly Entry[], width: number): ScreenLin
     if (startsBlock(entry.kind, previous)) lines.push({ kind: "blank", text: "" });
     if (entry.kind === "logo") {
       // Never wrapped: a cut row of the wordmark reads better than a broken one.
-      lines.push({ kind: "logo", text: entry.text, segments: logoSegments(entry.text) });
+      lines.push({ kind: "logo", text: entry.text, spans: logoSegments(entry.text) });
       previous = entry.kind;
       continue;
     }
     const marker = MARKERS[entry.kind];
     const indent = " ".repeat(displayWidth(marker));
-    const body = wrapText(entry.text, Math.max(8, width - displayWidth(marker)));
-    for (const [i, text] of body.entries()) {
+    const room = Math.max(8, width - displayWidth(marker));
+    if (entry.kind === "assistant") {
+      // The reply is written in markdown; the screen draws it rather than showing its marks.
+      for (const [i, row] of rowsFor(entry, room).entries()) {
+        // A row with nothing on it is drawn as an empty one: no marker, no indent, no pieces.
+        if (row.length === 0) {
+          lines.push({ kind: entry.kind, text: "" });
+          continue;
+        }
+        const spans = [{ text: i === 0 ? marker : indent }, ...row];
+        lines.push({ kind: entry.kind, text: spans.map((s) => s.text).join(""), spans });
+      }
+      previous = entry.kind;
+      continue;
+    }
+    for (const [i, text] of wrapText(entry.text, room).entries()) {
       lines.push({ kind: entry.kind, text: (i === 0 ? marker : indent) + text });
     }
     previous = entry.kind;