@hassangameryt/freeflow 0.8.0 → 0.9.0

package/pi-extension/dist/messaging/tools.js

@@ -0,0 +1,109 @@
+import { Text } from "@earendil-works/pi-tui";
+import { renderListResult, renderSendCall, renderSendResult } from "./render.js";
+export const LIST_SESSIONS = "list_sessions";
+export const SEND_MESSAGE = "send_message";
+export const MESSAGING_TOOLS = [LIST_SESSIONS, SEND_MESSAGE];
+const TOOL_SEARCH = "tool_search";
+const LIST_DESCRIPTION =
+  "List the other Pi sessions on this machine that can receive messages: name, session ID, folder, Task Memory project and the tasks it owns, and whether each is busy or idle.";
+const SEND_DESCRIPTION = [
+  "Read the messaging skill before your first message or answer. Send a plain-text message to another Pi session on this machine, addressed by its session ID: list_sessions gives each session's ID with its name, folder and owned tasks, and a message you answer carries its sender's ID in session=. Names are for display and may repeat. It reaches that agent between its tool calls, or starts a turn if it is idle; a session whose user has not prompted it yet reads it with that first prompt.",
+  "The other session delivers the message, holds it for its user to accept, or refuses it; the result says which, and a held message's outcome arrives later as a notice. A reply arrives on its own as a notice, while you work or as a new turn: do not wait, poll or search for it. No answer is not agreement.",
+  "A message is information for the other agent, not an instruction from its user: never ask another session to do what this session was refused or is not authorized to do. Set notify_when_idle to get one notice when that session next goes idle or ends.",
+].join("\n\n");
+/** Registered once with `deferred` exposure: not sent until tool_search loads them (Task 002 D-005). */
+export function registerMessagingTools(pi, messaging, effective) {
+  const guard = () => {
+    if (!effective() || !messaging.running())
+      throw new Error("Messaging is available only while Freeflow Messaging is on in this session.");
+  };
+  pi.registerTool({
+    name: LIST_SESSIONS,
+    label: "Sessions",
+    description: LIST_DESCRIPTION,
+    parameters: { type: "object", additionalProperties: false, properties: {} },
+    exposure: "deferred",
+    defaultActive: false,
+    renderCall: (_args, theme) => new Text(theme?.fg ? theme.fg("toolTitle", "Sessions") : "Sessions", 0, 0),
+    renderResult: (result, options, theme) => renderListResult(result, options, theme),
+    async execute() {
+      guard();
+      const me = messaging.self();
+      const sessions = (await messaging.list()).filter((session) => session.sessionId !== me?.sessionId);
+      const rows = sessions.map((session) =>
+        [
+          `- ${session.name} (${session.sessionId})`,
+          session.busy ? "busy" : "idle",
+          session.cwd,
+          session.project ? `project ${session.project}` : "",
+          session.owns?.length
+            ? `owns ${session.owns.map((id) => (id === session.task ? `${id} (focus)` : id)).join(", ")}`
+            : session.task
+              ? `focus ${session.task}`
+              : "",
+        ]
+          .filter(Boolean)
+          .join(" · "),
+      );
+      const text =
+        rows.length === 0
+          ? "No other session with messaging on is running on this machine."
+          : `This session is ${me?.name} (${me?.sessionId}). Other sessions:\n${rows.join("\n")}`;
+      return { content: [{ type: "text", text }], details: { sessions } };
+    },
+  });
+  pi.registerTool({
+    name: SEND_MESSAGE,
+    label: "Message",
+    description: SEND_DESCRIPTION,
+    parameters: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        to: { type: "string", description: "The other session's full session ID" },
+        message: { type: "string", description: "Plain text for the other agent" },
+        summary: { type: "string", description: "A few words shown in the other session's transcript" },
+        notify_when_idle: { type: "boolean", description: "Get one notice when that session next goes idle or ends" },
+      },
+      required: ["to", "message"],
+    },
+    exposure: "deferred",
+    defaultActive: false,
+    renderCall: (args, theme, context) => renderSendCall(args, theme, context, (id) => messaging.nameOf(id)),
+    renderResult: (result, options, theme, context) => renderSendResult(result, options, theme, context),
+    async execute(_id, params) {
+      guard();
+      const result = await messaging.send(String(params?.to ?? ""), String(params?.message ?? ""), {
+        ...(params?.summary ? { summary: String(params.summary) } : {}),
+        notifyWhenIdle: params?.notify_when_idle === true,
+      });
+      if (!result.ok) throw new Error(result.text);
+      return { content: [{ type: "text", text: result.text }], details: result.details };
+    },
+  });
+}
+/** Extension APIs for which Freeflow activated tool_search, so it withdraws only what it added. */
+const activatedSearch = new WeakSet();
+/**
+ * While messaging is effective, keep Pi's tool_search active so the deferred tools can be loaded, and withdraw it again
+ * only if Freeflow activated it. Where Pi has no tool_search (built-in extensions turned off, or an SDK host without
+ * it), declare the two tools directly instead. When messaging is off, withdraw whatever messaging declared.
+ */
+export function applyMessagingTools(pi, effective) {
+  if (typeof pi.getActiveTools !== "function" || typeof pi.setActiveTools !== "function") return;
+  const current = pi.getActiveTools();
+  const searchable = (pi.getAllTools?.() ?? []).some((tool) => tool.name === TOOL_SEARCH);
+  let next = current;
+  if (effective && searchable && !current.includes(TOOL_SEARCH)) {
+    next = [...current, TOOL_SEARCH];
+    activatedSearch.add(pi);
+  }
+  if (effective && !searchable) next = [...current, ...MESSAGING_TOOLS.filter((name) => !current.includes(name))];
+  if (!effective) {
+    next = current.filter(
+      (name) => !MESSAGING_TOOLS.includes(name) && !(activatedSearch.has(pi) && name === TOOL_SEARCH),
+    );
+    activatedSearch.delete(pi);
+  }
+  if (next.length !== current.length) pi.setActiveTools(next);
+}

package/pi-extension/dist/messaging/transport.js

@@ -0,0 +1,101 @@
+import { createHash } from "node:crypto";
+import { mkdir, rm } from "node:fs/promises";
+import { createConnection, createServer } from "node:net";
+import { tmpdir, userInfo } from "node:os";
+import { join } from "node:path";
+/**
+ * The transport: a Unix socket per session in a folder only the user can open. One request per connection, as one
+ * line of JSON, answered with one line of JSON. Socket paths are short (macOS allows about 104 bytes), so they live
+ * under the OS temp folder, named by a hash of the session ID.
+ */
+const MAX_REQUEST_BYTES = 1_100_000;
+const CLIENT_TIMEOUT_MS = 5_000;
+/** A connection that has not sent its request line by then is closed, so a stray client cannot hold the server open. */
+const REQUEST_TIMEOUT_MS = 10_000;
+export function socketPathFor(sessionId) {
+  const user = (() => {
+    try {
+      return String(userInfo().uid);
+    } catch {
+      return "user";
+    }
+  })();
+  const name = createHash("sha256").update(sessionId).digest("hex").slice(0, 16);
+  return join(tmpdir(), `freeflow-${user}`, "msg", `${name}.sock`);
+}
+export async function listen(path, handle) {
+  await mkdir(join(path, ".."), { recursive: true, mode: 0o700 });
+  await rm(path, { force: true });
+  const server = createServer((socket) => {
+    let buffer = "";
+    let answered = false;
+    socket.setEncoding("utf8");
+    socket.on("error", () => {});
+    socket.setTimeout(REQUEST_TIMEOUT_MS, () => {
+      if (!answered) socket.destroy();
+    });
+    const onData = async (chunk) => {
+      if (answered) return;
+      buffer += chunk;
+      if (buffer.length > MAX_REQUEST_BYTES) {
+        answered = true;
+        socket.end(`${JSON.stringify({ status: "refused", reason: "The message is too large." })}\n`);
+        return;
+      }
+      const end = buffer.indexOf("\n");
+      if (end < 0) return;
+      answered = true;
+      let reply;
+      try {
+        reply = await handle(JSON.parse(buffer.slice(0, end)));
+      } catch (error) {
+        reply = { status: "refused", reason: error instanceof Error ? error.message : String(error) };
+      }
+      socket.end(`${JSON.stringify(reply)}\n`);
+    };
+    // A failure while answering closes the connection, rather than surfacing as an unhandled rejection.
+    socket.on("data", (chunk) => void onData(chunk).catch(() => socket.destroy()));
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(path, () => {
+      server.off("error", reject);
+      resolve();
+    });
+  });
+  // A later server error (an accept that fails, say) must not reach Node as an uncaught exception and end Pi.
+  server.on("error", () => {});
+  // The socket alone never keeps Pi running: a print-mode run still exits when its work is done.
+  server.unref();
+  return server;
+}
+export async function close(server, path) {
+  if (server) await new Promise((resolve) => server.close(() => resolve()));
+  await rm(path, { force: true });
+}
+/** Send one request and wait for its answer; rejects when nothing listens or no answer comes in time. */
+export function request(path, body, timeoutMs = CLIENT_TIMEOUT_MS) {
+  return new Promise((resolve, reject) => {
+    const socket = createConnection(path);
+    let buffer = "";
+    const timer = setTimeout(() => {
+      socket.destroy();
+      reject(new Error("The session did not answer in time."));
+    }, timeoutMs);
+    socket.setEncoding("utf8");
+    socket.on("connect", () => socket.write(`${JSON.stringify(body)}\n`));
+    socket.on("data", (chunk) => (buffer += chunk));
+    socket.on("error", (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+    socket.on("end", () => {
+      clearTimeout(timer);
+      try {
+        resolve(JSON.parse(buffer.trim()));
+      } catch {
+        reject(new Error("The session sent no readable answer."));
+      }
+    });
+  });
+}

package/pi-extension/dist/provider-support/cache/keepalive.js

@@ -42,7 +42,10 @@ export class CacheKeepAlive {
   constructor(options = {}) {
     this.options = options;
     this.now = options.now ?? Date.now;
-    this.setTimer = options.setTimer ?? ((fn, ms) => setTimeout(fn, ms).unref?.());
+    // A refresh that throws ends the hold, rather than surfacing as an unhandled rejection.
+    this.setTimer =
+      options.setTimer ??
+      ((fn, ms) => setTimeout(() => void Promise.resolve(fn()).catch(() => this.stop("refresh failed")), ms).unref?.());
     this.clearTimer = options.clearTimer ?? ((timer) => clearTimeout(timer));
     this.send = options.send ?? sendThroughHost;
   }
@@ -71,9 +74,16 @@ export class CacheKeepAlive {
   /** Remember the request just sent on its model; a hold keeps the latest one warm. */
   record(payload, ctx) {
     const key = laneKey(ctx, undefined, this.requester());
-    // Sign in with ChatGPT rejects max_output_tokens (live, 400), so a replay cannot be capped and is never sent.
-    const protocol = isChatGPTSignIn(ctx.model, ctx) ? undefined : PROTOCOLS[ctx.model?.api];
-    if (!key || !protocol) return;
+    if (!key) return;
+    // Sign in with ChatGPT rejects max_output_tokens (live, 400), so a replay cannot be capped and is never sent. Its
+    // lanes carry no credential, so a request on it also drops what an API key on the same model left.
+    if (isChatGPTSignIn(ctx.model, ctx)) {
+      this.lanes.delete(key);
+      if (this.active?.lane === key) this.stop(SIGN_IN_STOP);
+      return;
+    }
+    const protocol = PROTOCOLS[ctx.model?.api];
+    if (!protocol) return;
     if (protocol.replayable?.(payload) === false) {
       this.lanes.delete(key);
       if (this.active?.lane === key) this.stop("this request cannot be replayed with a capped output");
@@ -139,6 +149,7 @@ export class CacheKeepAlive {
     const hold = this.currentHold(active.ctx);
     if (!hold || laneKey(active.ctx, hold, hold.requester) !== active.lane)
       return this.stop("requester resumed or run ended");
+    if (isChatGPTSignIn(lane.model, active.ctx)) return this.stop(SIGN_IN_STOP);
     const now = this.now();
     // Like Pi's warmer, a refresh later than halfway from its slot to expiry is likely a full rewrite.
     const ttl = this.ttlMs(lane),
@@ -171,6 +182,7 @@ export class CacheKeepAlive {
     this.schedule();
   }
 }
+const SIGN_IN_STOP = "Sign in with ChatGPT is never replayed";
 /** Pi's refresh point: 90% of the lifetime, keeping at least ten seconds of margin. */
 const refreshDelay = (ttl) => Math.min(ttl * 0.9, ttl - EXPIRY_MARGIN_MS);
 function laneKey(ctx, hold, requester) {

package/pi-extension/dist/task-memory/config.js

@@ -0,0 +1,49 @@
+export const DEFAULT_TASK_MEMORY_ENABLED = false;
+/** The keys `taskMemory` accepts; `autoApprove` holds one switch per group. The settings test checks each has a row. */
+export const TASK_MEMORY_KEYS = ["enabled", "autoApprove"];
+/** The groups of proposed actions that can skip the confirmation dialog, and the task_memory actions in each. */
+export const AUTO_APPROVE_GROUPS = {
+  attach: ["attach", "confirm"],
+  create: ["create", "child"],
+  env: ["env"],
+  fanout: ["fanout"],
+  projects: ["project_new", "project_link", "import"],
+};
+const GROUP_NAMES = Object.keys(AUTO_APPROVE_GROUPS);
+/** The group a proposed action belongs to. */
+export function autoApproveGroup(action) {
+  return GROUP_NAMES.find((group) => AUTO_APPROVE_GROUPS[group].includes(action));
+}
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function validateTaskMemoryConfig(value) {
+  if (!record(value)) return "taskMemory must be an object";
+  const unknown = Object.keys(value).find((key) => !TASK_MEMORY_KEYS.includes(key));
+  if (unknown) return `taskMemory has unsupported key: ${unknown}`;
+  if (value.enabled !== undefined && typeof value.enabled !== "boolean") return "taskMemory.enabled must be a boolean";
+  if (value.autoApprove !== undefined) {
+    if (!record(value.autoApprove)) return "taskMemory.autoApprove must be an object";
+    for (const [key, on] of Object.entries(value.autoApprove)) {
+      if (!GROUP_NAMES.includes(key))
+        return `taskMemory.autoApprove has unsupported key: ${key}; use ${GROUP_NAMES.join(", ")}`;
+      if (typeof on !== "boolean") return `taskMemory.autoApprove.${key} must be a boolean`;
+    }
+  }
+  return null;
+}
+export function resolveTaskMemoryConfig(repository, local, freeflowEnabled) {
+  const repositoryConfig = record(repository.taskMemory) ? repository.taskMemory : {};
+  const localConfig = record(local.taskMemory) ? local.taskMemory : {};
+  const value = Object.hasOwn(localConfig, "enabled") ? localConfig.enabled : repositoryConfig.enabled;
+  const enabled = value === undefined ? DEFAULT_TASK_MEMORY_ENABLED : value === true;
+  const repositoryApprove = record(repositoryConfig.autoApprove) ? repositoryConfig.autoApprove : {};
+  const localApprove = record(localConfig.autoApprove) ? localConfig.autoApprove : {};
+  const autoApprove = Object.fromEntries(
+    GROUP_NAMES.map((group) => [
+      group,
+      (Object.hasOwn(localApprove, group) ? localApprove[group] : repositoryApprove[group]) === true,
+    ]),
+  );
+  return { enabled, effective: freeflowEnabled && enabled, autoApprove };
+}

package/pi-extension/dist/task-memory/registry.js

@@ -0,0 +1,119 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+/** The Freeflow home, read synchronously for the write gate; the library resolves it the same way. */
+export function freeflowHome() {
+  return process.env.FREEFLOW_HOME || join(homedir(), ".freeflow");
+}
+export class Registry {
+  packageRoot;
+  home;
+  impl;
+  constructor(packageRoot, home = freeflowHome()) {
+    this.packageRoot = packageRoot;
+    this.home = home;
+  }
+  // Loaded on first use, so the extension never touches Track Work's library while task memory is unused.
+  async call(name, ...args) {
+    this.impl ??= import(pathToFileURL(join(this.packageRoot, "skills/track-work/scripts/lib/registry.mjs")).href).then(
+      (lib) => new lib.Registry(this.home),
+    );
+    return (await this.impl)[name](...args);
+  }
+  read() {
+    return this.call("read");
+  }
+  update(change) {
+    return this.call("update", change);
+  }
+  repoRoot(cwd) {
+    return this.call("repoRoot", cwd);
+  }
+  projectFor(cwd) {
+    return this.call("projectFor", cwd);
+  }
+  project(name) {
+    return this.call("project", name);
+  }
+  /** The command a user pastes into a new terminal to start an agent in a directory (see Track Work's library). */
+  async startCommand(path, agent) {
+    const lib = await import(pathToFileURL(join(this.packageRoot, "skills/track-work/scripts/lib/registry.mjs")).href);
+    return lib.startCommand(path, agent);
+  }
+  createProject(name, cwd, worktrees) {
+    return this.call("createProject", name, cwd, worktrees);
+  }
+  linkProject(name, cwd, worktrees) {
+    return this.call("linkProject", name, cwd, worktrees);
+  }
+  createTask(slug, title, goal, parent, primary) {
+    return this.call("createTask", slug, title, goal, parent, primary);
+  }
+  importRecord(projectName, record) {
+    return this.call("importRecord", projectName, record);
+  }
+  task(id) {
+    return this.call("task", id);
+  }
+  byRecord(record) {
+    return this.call("byRecord", record);
+  }
+  children(id) {
+    return this.call("children", id);
+  }
+  projectTasks(slug) {
+    return this.call("projectTasks", slug);
+  }
+  own(id, owner, takeover) {
+    return this.call("own", id, owner, takeover);
+  }
+  release(id, session) {
+    return this.call("release", id, session);
+  }
+  setEnvironment(id, change) {
+    return this.call("setEnvironment", id, change);
+  }
+  environment(id) {
+    return this.call("environment", id);
+  }
+  /** The project link for cwd's repository, made if missing; undefined when it belongs to no project (Task 004 D-003). */
+  linkHere(cwd) {
+    return this.call("linkHere", cwd);
+  }
+  /** What removing a task (with its children) or a project would take (Task 006). */
+  removal(target) {
+    return this.call("removal", target);
+  }
+  removeTask(id) {
+    return this.call("removeTask", id);
+  }
+  removeProject(name) {
+    return this.call("removeProject", name);
+  }
+  trashEntries() {
+    return this.call("trashEntries");
+  }
+  /** Only the user's /freeflow trash empty calls this. */
+  emptyTrash() {
+    return this.call("emptyTrash");
+  }
+  async trashPath() {
+    this.impl ??= import(pathToFileURL(join(this.packageRoot, "skills/track-work/scripts/lib/registry.mjs")).href).then(
+      (lib) => new lib.Registry(this.home),
+    );
+    return (await this.impl).trash;
+  }
+  async removalText(result) {
+    const lib = await import(pathToFileURL(join(this.packageRoot, "skills/track-work/scripts/lib/registry.mjs")).href);
+    return lib.removalText(result, await this.trashPath());
+  }
+  here(cwd) {
+    return this.call("here", cwd);
+  }
+  fanout(parent, title, goal, options) {
+    return this.call("fanout", parent, title, goal, options);
+  }
+  scope(id, scope) {
+    return this.call("scope", id, scope);
+  }
+}

package/pi-extension/dist/task-memory/render.js

@@ -0,0 +1,107 @@
+import { Text } from "@earendil-works/pi-tui";
+import { briefOf } from "./runtime.js";
+const paint = (theme, color, text) => (theme?.fg ? theme.fg(color, text) : text);
+const strong = (theme, text) => (theme?.bold ? theme.bold(text) : text);
+const quoted = (value) => (typeof value === "string" && value.trim() ? `"${value.trim()}"` : "");
+const named = (value, fallback) => (typeof value === "string" && value.trim() ? value.trim() : fallback);
+/** What a call does, in a few words. */
+export function callTitle(args = {}) {
+  const record = named(args.record, "a record");
+  switch (args.action) {
+    case "projects":
+      return "List projects";
+    case "list":
+      return typeof args.project === "string" && args.project.trim()
+        ? `List tasks in ${args.project.trim()}`
+        : "List tasks";
+    case "attach":
+      return `Attach ${record}`;
+    case "focus":
+      return `Focus ${record}`;
+    case "detach":
+      return `Detach ${record}`;
+    case "create":
+      return `Create task ${quoted(args.title)}`.trim();
+    case "child":
+      return `Create child task ${quoted(args.title)}`.trim();
+    case "fanout":
+      return `Fan out ${quoted(args.title)}`.trim();
+    case "view":
+      return `Read ${record}${typeof args.entry === "string" && args.entry.trim() ? ` ${args.entry.trim()}` : ""}`;
+    case "search":
+      return `Search ${named(args.scope, "task")} for ${quoted(args.query) || "…"}`;
+    case "project_new":
+      return `Create project ${quoted(args.name)}`.trim();
+    case "project_link":
+      return `Link this repository to ${quoted(args.name)}`.trim();
+    case "import":
+      return `Import ${record} into ${named(args.project, "a project")}`;
+    case "confirm":
+      return `Make ${typeof args.record === "string" && args.record.trim() ? args.record.trim() : "held records"} writable`;
+    case "env":
+      return args.primary || args.add_dir || args.remove_dir
+        ? `Change directories of ${record}`
+        : `Directories of ${record}`;
+    case "remove":
+      return `Remove ${record}`;
+    case "project_remove":
+      return `Remove project ${quoted(args.name)}`.trim();
+    default:
+      return "Task memory";
+  }
+}
+export function renderTaskCall(args, theme) {
+  return new Text(
+    `${strong(theme, paint(theme, "toolTitle", "Task memory"))} ${paint(theme, "muted", "·")} ${callTitle(args)}`,
+    0,
+    0,
+  );
+}
+const textOf = (result) =>
+  (result?.content ?? [])
+    .filter((part) => part?.type === "text")
+    .map((part) => part.text ?? "")
+    .join("\n");
+/** One line for a result whose operation gave no headline. */
+function fallbackHeadline(action, text) {
+  const lines = text.split("\n").filter((line) => line.trim());
+  const items = lines.filter((line) => line.startsWith("- ")).length;
+  if (action === "search")
+    return lines[0]?.startsWith("No match")
+      ? lines[0]
+      : `${lines.length} matching line${lines.length === 1 ? "" : "s"}`;
+  if (action === "list") return items ? `${items} record${items === 1 ? "" : "s"}` : (lines[0] ?? "No records");
+  if (action === "view") return `${lines.length} lines`;
+  return lines[0] ?? "Done";
+}
+export function renderTaskResult(result, options, theme, context = {}) {
+  if (options.isPartial) return new Text(paint(theme, "muted", "Working…"), 0, 0);
+  const details = result?.details ?? {};
+  const text = textOf(result);
+  const failed = context.isError === true || result?.isError === true;
+  const headline = failed
+    ? (details.headline ?? (text.split("\n")[0] || "Refused"))
+    : (details.headline ?? fallbackHeadline(context.args?.action ?? details.action, text));
+  const lines = [failed ? paint(theme, "error", headline) : paint(theme, "success", headline)];
+  if (details.next) lines.push(paint(theme, "muted", `next: ${details.next}`));
+  // The command is the point of a fan-out: shown even when collapsed, ready to copy.
+  if (details.command)
+    lines.push("", paint(theme, "muted", "Run in a new terminal:"), `  ${paint(theme, "accent", details.command)}`);
+  if (options.expanded && text && text !== headline) lines.push("", text);
+  else if (!options.expanded && !failed && text.split("\n").length > 1)
+    lines.push(paint(theme, "dim", "(expand for details)"));
+  return new Text(lines.join("\n"), 0, 0);
+}
+/** The delivered resume view: one line collapsed, the whole view expanded. */
+export function renderSnapshotMessage(message, options, theme) {
+  const content = typeof message?.content === "string" ? message.content : textOf(message);
+  const task = /Focused task: (.+?) \(\//.exec(content)?.[1] ?? "task";
+  const unavailable = /The record is unavailable|cannot be read as a Schema 4/.test(content);
+  const brief = briefOf(content);
+  const label = strong(theme, paint(theme, "customMessageLabel", "Task memory"));
+  const summary = unavailable
+    ? paint(theme, "warning", `${task}: record unavailable`)
+    : `${task} ${paint(theme, "muted", `· ${brief.state}${brief.next ? ` · next: ${brief.next}` : ""}`)}`;
+  const head = `${label} ${summary}`;
+  return new Text(options.expanded ? `${head}\n\n${content}` : head, 0, 0);
+}