@pi9/ask 0.2.0 → 0.3.0

package/src/session.ts

@@ -0,0 +1,254 @@
+import type {
+  ContextEvent,
+  SessionEntry,
+  SessionTreeEvent,
+} from "@earendil-works/pi-coding-agent";
+import { Check } from "typebox/value";
+
+import {
+  AskAnsweredDetailsSchema,
+  AskParamsSchema,
+  answerMatchesAsk,
+  normalizeAsk,
+  parseAskReplayDetails,
+  type Ask,
+  type AskAnswer,
+  type AskParams,
+  type AskReplayDetails,
+} from "./domain.js";
+
+export const ASK_REPLAY_CUSTOM_TYPE = "ask:reanswer" as const;
+const ASK_SUMMARY_CUSTOM_TYPE = "ask:summary" as const;
+
+type AgentMessage = ContextEvent["messages"][number];
+type AssistantMessage = Extract<AgentMessage, { role: "assistant" }>;
+type ToolResultMessage = Extract<AgentMessage, { role: "toolResult" }>;
+type CustomMessage = Extract<AgentMessage, { role: "custom" }>;
+
+type AskCall = {
+  ask: Ask;
+  message: AssistantMessage;
+};
+
+type ReplayRecord = {
+  message: CustomMessage;
+  details?: AskReplayDetails;
+};
+
+type AskSummaryPayload = {
+  type: "ask_response";
+  question: string;
+  context?: string;
+  selectionMode: "single" | "multi";
+  answer: {
+    selections: Array<{ label: string; description?: string; comment?: string }>;
+    freeform?: string;
+  };
+};
+
+export type AskReplayMessage = {
+  customType: typeof ASK_REPLAY_CUSTOM_TYPE;
+  content: "";
+  display: false;
+  details: AskReplayDetails;
+};
+
+export type AskReplayResolution =
+  | { status: "resolved"; toolCallId: string; ask: Ask }
+  | {
+      status: "not-replayable";
+      reason: "no-entry" | "not-assistant" | "not-ask" | "multiple-tool-calls" | "mixed-tools" | "invalid-arguments";
+    };
+
+export function buildAskReplayMessage(toolCallId: string, answer: AskAnswer): AskReplayMessage {
+  return {
+    customType: ASK_REPLAY_CUSTOM_TYPE,
+    content: "",
+    display: false,
+    details: { toolCallId, answer },
+  };
+}
+
+/** Resolve only the selected leaf, or its immediate parent when Pi created a branch summary. */
+export function resolveAskReplayTarget(
+  event: Pick<SessionTreeEvent, "newLeafId" | "summaryEntry">,
+  getEntry: (id: string) => SessionEntry | undefined | null,
+): AskReplayResolution {
+  if (!event.newLeafId) return rejected("no-entry");
+
+  let entry = getEntry(event.newLeafId);
+  const summary = event.summaryEntry?.id === event.newLeafId
+    ? event.summaryEntry
+    : entry?.type === "branch_summary" ? entry : undefined;
+  if (summary) entry = summary.parentId ? getEntry(summary.parentId) : undefined;
+  if (!entry) return rejected("no-entry");
+
+  let selectedToolCallId: string | undefined;
+  if (entry.type === "message" && entry.message.role === "toolResult" && entry.message.toolName === "ask") {
+    selectedToolCallId = entry.message.toolCallId;
+    entry = entry.parentId ? getEntry(entry.parentId) : undefined;
+  }
+  if (!entry) return rejected("no-entry");
+  if (entry.type !== "message" || entry.message.role !== "assistant") return rejected("not-assistant");
+
+  const calls = entry.message.content.filter(item => item.type === "toolCall");
+  const askCalls = calls.filter(call => call.name === "ask");
+  if (calls.length !== 1) {
+    if (askCalls.length > 0 && askCalls.length < calls.length) return rejected("mixed-tools");
+    if (askCalls.length > 1) return rejected("multiple-tool-calls");
+    return rejected("not-ask");
+  }
+
+  const call = calls[0]!;
+  if (call.name !== "ask" || (selectedToolCallId !== undefined && call.id !== selectedToolCallId)) {
+    return rejected("not-ask");
+  }
+
+  const ask = parseStoredAsk(call.arguments);
+  if (!ask) return rejected("invalid-arguments");
+  return { status: "resolved", toolCallId: call.id, ask };
+}
+
+export function parseStoredAsk(value: unknown): Ask | undefined {
+  if (!Check(AskParamsSchema, value)) return undefined;
+  try {
+    return normalizeAsk(value as AskParams);
+  } catch {
+    return undefined;
+  }
+}
+
+/** Replace completed standalone Ask exchanges with their decision-focused answer. */
+export function rewriteAskContext(messages: readonly AgentMessage[]): AgentMessage[] {
+  const calls = collectCalls(messages);
+  const nativeResults = collectNativeResults(messages);
+  const replayRecords = collectReplayRecords(messages);
+
+  const summaries = new Map<AgentMessage, AgentMessage>();
+  const removals = new Set<AgentMessage>();
+  for (const [toolCallId, call] of calls) {
+    if (!call) continue;
+
+    const results = nativeResults.get(toolCallId) ?? [];
+    if (results.length > 1) continue;
+    const result = results[0];
+
+    const replays = replayRecords.get(toolCallId) ?? [];
+    let answer: AskAnswer | undefined;
+    let replay: ReplayRecord | undefined;
+    if (replays.length > 0) {
+      if (replays.length !== 1) continue;
+      const candidate = replays[0]!;
+      if (!candidate.details || !answerMatchesAsk(candidate.details.answer, call.ask)) continue;
+      replay = candidate;
+      answer = candidate.details.answer;
+    }
+
+    if (result) {
+      if (result.toolName !== "ask") continue;
+      if (!replay) {
+        if (result.isError) continue;
+        const details = parseNativeDetails(result.details);
+        if (!details || !answerMatchesAsk(details.answer, call.ask)) continue;
+        answer = details.answer;
+      }
+    } else if (!replay) {
+      continue;
+    }
+
+    if (!answer) continue;
+    const timestamp = replay ? replay.message.timestamp : result!.timestamp;
+    summaries.set(call.message, makeSummary(call, answer, timestamp));
+    removals.add(call.message);
+    if (result) removals.add(result);
+    if (replay) removals.add(replay.message);
+  }
+
+  return messages.flatMap((message) => {
+    const summary = summaries.get(message);
+    if (summary) return [summary];
+    return removals.has(message) ? [] : [message];
+  });
+}
+
+function collectCalls(messages: readonly AgentMessage[]): Map<string, AskCall | undefined> {
+  const calls = new Map<string, AskCall | undefined>();
+  for (const message of messages) {
+    if (message.role !== "assistant") continue;
+    const toolCalls = message.content.filter(block => block.type === "toolCall");
+    for (const block of toolCalls) {
+      if (block.name !== "ask") continue;
+      const ask = toolCalls.length === 1 ? parseStoredAsk(block.arguments) : undefined;
+      const call = ask ? { ask, message } : undefined;
+      calls.set(block.id, calls.has(block.id) ? undefined : call);
+    }
+  }
+  return calls;
+}
+
+function collectNativeResults(messages: readonly AgentMessage[]): Map<string, ToolResultMessage[]> {
+  const results = new Map<string, ToolResultMessage[]>();
+  for (const message of messages) {
+    if (message.role !== "toolResult") continue;
+    const matching = results.get(message.toolCallId) ?? [];
+    matching.push(message);
+    results.set(message.toolCallId, matching);
+  }
+  return results;
+}
+
+function collectReplayRecords(messages: readonly AgentMessage[]): Map<string, ReplayRecord[]> {
+  const records = new Map<string, ReplayRecord[]>();
+  for (const message of messages) {
+    if (message.role !== "custom" || message.customType !== ASK_REPLAY_CUSTOM_TYPE) continue;
+    const rawToolCallId = isRecord(message.details) && typeof message.details.toolCallId === "string"
+      ? message.details.toolCallId
+      : undefined;
+    const details = parseAskReplayDetails(message.details);
+    const toolCallId = details?.toolCallId ?? rawToolCallId;
+    if (toolCallId === undefined) continue;
+    const matching = records.get(toolCallId) ?? [];
+    matching.push({ message, ...(details ? { details } : {}) });
+    records.set(toolCallId, matching);
+  }
+  return records;
+}
+
+function parseNativeDetails(value: unknown): { status: "answered"; answer: AskAnswer } | undefined {
+  return Check(AskAnsweredDetailsSchema, value) ? value : undefined;
+}
+
+function makeSummary(call: AskCall, answer: AskAnswer, timestamp: number): AgentMessage {
+  const payload: AskSummaryPayload = {
+    type: "ask_response",
+    question: call.ask.question,
+    ...(call.ask.context !== undefined ? { context: call.ask.context } : {}),
+    selectionMode: call.ask.allowMultiple ? "multi" : "single",
+    answer: {
+      selections: answer.selections.map((selection) => {
+        const option = call.ask.options[selection.option]!;
+        return {
+          label: option.label,
+          ...(option.description !== undefined ? { description: option.description } : {}),
+          ...(selection.comment !== undefined ? { comment: selection.comment } : {}),
+        };
+      }),
+      ...(answer.freeform !== undefined ? { freeform: answer.freeform } : {}),
+    },
+  };
+  return {
+    role: "custom",
+    customType: ASK_SUMMARY_CUSTOM_TYPE,
+    display: false,
+    content: JSON.stringify(payload),
+    timestamp,
+  };
+}
+
+function rejected(reason: Exclude<AskReplayResolution, { status: "resolved" }>["reason"]): AskReplayResolution {
+  return { status: "not-replayable", reason };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/state.ts

@@ -1,6 +1,6 @@
-import type { AskAnswer, AskOption, ValidatedAskParams } from "./types.js";
+import type { Ask, AskAnswer, AskOption } from "./domain.js";
 
-export type QuestionnaireOptionRow = { kind: "option"; option: AskOption };
+export type QuestionnaireOptionRow = { kind: "option"; index: number; option: AskOption };
 export type QuestionnaireFreeformRow = { kind: "freeform" };
 export type QuestionnaireSubmitRow = { kind: "submit" };
 export type QuestionnaireRow =
@@ -13,15 +13,15 @@ export type QuestionnaireEditor =
   | { kind: "comment"; target: QuestionnaireOptionRow; draft: string }
   | { kind: "freeform"; target: QuestionnaireFreeformRow; draft: string };
 
-type QuestionnaireConfig = Pick<ValidatedAskParams, "allowMultiple" | "allowFreeform">;
-type QuestionnaireInput = QuestionnaireConfig & Pick<ValidatedAskParams, "options">;
+type QuestionnaireConfig = Pick<Ask, "allowMultiple" | "allowFreeform">;
+type QuestionnaireInput = QuestionnaireConfig & Pick<Ask, "options">;
 
 export interface QuestionnaireState {
   config: QuestionnaireConfig;
   rows: readonly QuestionnaireRow[];
   highlightedRow: number;
-  checked: Set<string>;
-  comments: Map<string, string>;
+  checked: Set<number>;
+  comments: Map<number, string>;
   freeformDraft: string;
   freeformChecked: boolean;
   editor: QuestionnaireEditor;
@@ -80,7 +80,7 @@ export function transitionQuestionnaire(state: QuestionnaireState, event: Questi
       next.editor = {
         kind: "comment",
         target: row,
-        draft: next.comments.get(row.option.label) ?? "",
+        draft: next.comments.get(row.index) ?? "",
       };
       break;
     }
@@ -92,9 +92,9 @@ export function transitionQuestionnaire(state: QuestionnaireState, event: Questi
       const editor = next.editor;
       const saved = editor.draft.trim();
       if (editor.kind === "comment") {
-        const label = editor.target.option.label;
-        if (saved) next.comments.set(label, saved);
-        else next.comments.delete(label);
+        const option = editor.target.index;
+        if (saved) next.comments.set(option, saved);
+        else next.comments.delete(option);
       } else {
         next.freeformDraft = saved;
         if (next.config.allowMultiple) next.freeformChecked = saved.length > 0;
@@ -117,7 +117,7 @@ export function transitionQuestionnaire(state: QuestionnaireState, event: Questi
 
 function createRows(input: QuestionnaireInput): QuestionnaireRow[] {
   return [
-    ...input.options.map((option): QuestionnaireOptionRow => ({ kind: "option", option })),
+    ...input.options.map((option, index): QuestionnaireOptionRow => ({ kind: "option", index, option })),
     ...(input.allowFreeform ? [{ kind: "freeform" } as const] : []),
     ...(input.allowMultiple ? [{ kind: "submit" } as const] : []),
   ];
@@ -131,7 +131,7 @@ function activateRow(state: QuestionnaireState): void {
   const row = currentRow(state);
   switch (row.kind) {
     case "option":
-      toggleOption(state, row.option);
+      toggleOption(state, row.index);
       break;
     case "freeform":
       openFreeform(state, row);
@@ -146,7 +146,7 @@ function toggleRow(state: QuestionnaireState): void {
   const row = currentRow(state);
   switch (row.kind) {
     case "option":
-      toggleOption(state, row.option);
+      toggleOption(state, row.index);
       break;
     case "freeform":
       if (state.config.allowMultiple) state.freeformChecked = !state.freeformChecked;
@@ -158,14 +158,14 @@ function toggleRow(state: QuestionnaireState): void {
   }
 }
 
-function toggleOption(state: QuestionnaireState, option: AskOption): void {
+function toggleOption(state: QuestionnaireState, option: number): void {
   if (!state.config.allowMultiple) {
-    state.checked = new Set([option.label]);
+    state.checked = new Set([option]);
     state.answer = finalAnswer(state);
-  } else if (state.checked.has(option.label)) {
-    state.checked.delete(option.label);
+  } else if (state.checked.has(option)) {
+    state.checked.delete(option);
   } else {
-    state.checked.add(option.label);
+    state.checked.add(option);
   }
 }
 
@@ -175,13 +175,9 @@ function openFreeform(state: QuestionnaireState, target: QuestionnaireFreeformRo
 
 function finalAnswer(state: QuestionnaireState): AskAnswer {
   const selections = state.rows.flatMap((row) => {
-    if (row.kind !== "option" || !state.checked.has(row.option.label)) return [];
-    const comment = state.comments.get(row.option.label);
-    return [{
-      label: row.option.label,
-      ...(row.option.description === undefined ? {} : { description: row.option.description }),
-      ...(comment ? { comment } : {}),
-    }];
+    if (row.kind !== "option" || !state.checked.has(row.index)) return [];
+    const comment = state.comments.get(row.index);
+    return [{ option: row.index, ...(comment ? { comment } : {}) }];
   });
   const freeform = state.config.allowMultiple && !state.freeformChecked ? "" : state.freeformDraft.trim();
   return {

package/src/config.ts

@@ -1,30 +0,0 @@
-export const MAX_TIMEOUT_MS = 2_147_483_647;
-
-type AskEnvironment = Readonly<{
-  PI9_ASK_TIMEOUT_MS?: string;
-}>;
-
-export function resolveTimeoutMs(
-  perCallTimeout: number | undefined,
-  env: AskEnvironment,
-): number | undefined {
-  if (perCallTimeout !== undefined) {
-    return Number.isFinite(perCallTimeout)
-      && Number.isInteger(perCallTimeout)
-      && perCallTimeout > 0
-      && perCallTimeout <= MAX_TIMEOUT_MS
-      ? perCallTimeout
-      : undefined;
-  }
-
-  const envTimeout = env.PI9_ASK_TIMEOUT_MS;
-  if (envTimeout === undefined || !/^\d+$/.test(envTimeout)) return undefined;
-
-  const timeout = Number(envTimeout);
-  return Number.isFinite(timeout)
-    && Number.isInteger(timeout)
-    && timeout > 0
-    && timeout <= MAX_TIMEOUT_MS
-    ? timeout
-    : undefined;
-}

package/src/context.ts

@@ -1,209 +0,0 @@
-import type { ContextEvent } from "@earendil-works/pi-coding-agent";
-import { Check } from "typebox/value";
-
-import { AskAnsweredDetailsSchema } from "./schema.js";
-import {
-  ASK_REPLAY_CUSTOM_TYPE,
-  parseAskReplayDetails,
-  validateStoredArgs,
-} from "./replay.js";
-import type { AskAnswer, AskReplayDetails, ValidatedAskParams } from "./types.js";
-
-type AgentMessage = ContextEvent["messages"][number];
-type AssistantMessage = Extract<AgentMessage, { role: "assistant" }>;
-type ToolResultMessage = Extract<AgentMessage, { role: "toolResult" }>;
-type CustomMessage = Extract<AgentMessage, { role: "custom" }>;
-type AskCall = {
-  args: ValidatedAskParams;
-  message: AssistantMessage;
-  standalone: boolean;
-};
-type ReplayRecord = {
-  message: CustomMessage;
-  details?: AskReplayDetails;
-};
-
-const ASK_SUMMARY_CUSTOM_TYPE = "ask:summary" as const;
-
-type AskSummaryPayload = {
-  type: "ask_response";
-  question: string;
-  context?: string;
-  selectionMode: "single" | "multi";
-  answer: AskAnswer;
-};
-
-/**
- * Replace completed Ask exchanges with the small custom message that is useful
- * to the model. The session still contains the original protocol messages; the
- * projection must not leave a tool call without its result.
- */
-export function rewriteAskContext(messages: readonly AgentMessage[]): AgentMessage[] {
-  const calls = collectCalls(messages);
-  const nativeResults = collectNativeResults(messages);
-  const replayRecords = collectReplayRecords(messages);
-
-  const summaries = new Map<AgentMessage, AgentMessage>();
-  const removals = new Set<AgentMessage>();
-  for (const [toolCallId, call] of calls) {
-    if (!call || !call.standalone) continue;
-
-    const results = nativeResults.get(toolCallId) ?? [];
-    if (results.length > 1) continue;
-    const result = results[0];
-
-    const replays = replayRecords.get(toolCallId) ?? [];
-    let answer: AskAnswer | undefined;
-    let replay: ReplayRecord | undefined;
-    if (replays.length > 0) {
-      // A replay is a revision only when it is the one well-formed marker for
-      // this call. In particular, do not hide malformed or duplicate markers.
-      if (replays.length !== 1) continue;
-      const candidate = replays[0]!;
-      if (!candidate.details
-        || !matchesCall(candidate.details, call.args)
-        || !answerMatchesCall(candidate.details.answer, call.args)) continue;
-      replay = candidate;
-      answer = candidate.details.answer;
-    }
-
-    if (result) {
-      if (result.toolName !== "ask") continue;
-      // A valid replay is the latest answer and takes precedence regardless
-      // of whether the earlier native attempt completed successfully.
-      if (!replay) {
-        if (result.isError) continue;
-        const details = parseNativeDetails(result.details);
-        if (!details
-          || details.question !== call.args.question
-          || !answerMatchesCall(details.answer, call.args)) continue;
-        answer = details.answer;
-      }
-    } else if (!replay) {
-      continue;
-    }
-
-    if (!answer) continue;
-    const timestamp = replay ? replay.message.timestamp : result!.timestamp;
-    const summary = makeSummary(call, answer, timestamp);
-    summaries.set(call.message, summary);
-    removals.add(call.message);
-    if (result) removals.add(result);
-    if (replay) removals.add(replay.message);
-  }
-
-  const rewritten: AgentMessage[] = [];
-  for (const message of messages) {
-    const summary = summaries.get(message);
-    if (summary) {
-      rewritten.push(summary);
-      continue;
-    }
-    if (!removals.has(message)) rewritten.push(message);
-  }
-  return rewritten;
-}
-
-function collectCalls(messages: readonly AgentMessage[]): Map<string, AskCall | undefined> {
-  const calls = new Map<string, AskCall | undefined>();
-  for (const message of messages) {
-    if (message.role !== "assistant") continue;
-    const toolCalls = message.content.filter(block => block.type === "toolCall");
-    for (const block of toolCalls) {
-      if (block.name !== "ask") continue;
-      const args = validateStoredArgs(block.arguments);
-      const call = args
-        ? { args, message, standalone: toolCalls.length === 1 }
-        : undefined;
-      // Keep an invalid entry as ambiguous too. A later valid call with the
-      // same ID must not make an otherwise malformed exchange transformable.
-      calls.set(block.id, calls.has(block.id) ? undefined : call);
-    }
-  }
-  return calls;
-}
-
-function collectNativeResults(messages: readonly AgentMessage[]): Map<string, ToolResultMessage[]> {
-  const results = new Map<string, ToolResultMessage[]>();
-  for (const message of messages) {
-    if (message.role !== "toolResult") continue;
-    const matching = results.get(message.toolCallId) ?? [];
-    matching.push(message);
-    results.set(message.toolCallId, matching);
-  }
-  return results;
-}
-
-function collectReplayRecords(messages: readonly AgentMessage[]): Map<string, ReplayRecord[]> {
-  const records = new Map<string, ReplayRecord[]>();
-  for (const message of messages) {
-    if (message.role !== "custom" || message.customType !== ASK_REPLAY_CUSTOM_TYPE) continue;
-    const rawDetails = isRecord(message.details) && typeof message.details.toolCallId === "string"
-      ? message.details.toolCallId
-      : undefined;
-    const details = parseAskReplayDetails(message.details);
-    const toolCallId = details?.toolCallId ?? rawDetails;
-    if (toolCallId === undefined) continue;
-    const matching = records.get(toolCallId) ?? [];
-    matching.push({ message, ...(details ? { details } : {}) });
-    records.set(toolCallId, matching);
-  }
-  return records;
-}
-
-function parseNativeDetails(value: unknown): { question: string; answer: AskAnswer } | undefined {
-  return Check(AskAnsweredDetailsSchema, value) ? value : undefined;
-}
-
-function matchesCall(replay: AskReplayDetails, args: ValidatedAskParams): boolean {
-  return replay.question === args.question
-    && replay.context === args.context
-    && replay.allowMultiple === args.allowMultiple;
-}
-
-function answerMatchesCall(answer: AskAnswer, args: ValidatedAskParams): boolean {
-  if (answer.selections.length > 1 && !args.allowMultiple) return false;
-  if (answer.freeform !== undefined && !args.allowFreeform) return false;
-
-  const labels = new Set(args.options.map(option => option.label));
-  const selected = new Set<string>();
-  for (const selection of answer.selections) {
-    if (!labels.has(selection.label) || selected.has(selection.label)) return false;
-    selected.add(selection.label);
-  }
-  return true;
-}
-
-function makeSummary(call: AskCall, answer: AskAnswer, timestamp: number): AgentMessage {
-  const payload: AskSummaryPayload = {
-    type: "ask_response",
-    question: call.args.question,
-    ...(call.args.context !== undefined ? { context: call.args.context } : {}),
-    selectionMode: call.args.allowMultiple ? "multi" : "single",
-    answer: {
-      selections: answer.selections.map(selection => selectedOption(selection, call.args)),
-      ...(answer.freeform !== undefined ? { freeform: answer.freeform } : {}),
-    },
-  };
-  return {
-    role: "custom",
-    customType: ASK_SUMMARY_CUSTOM_TYPE,
-    display: false,
-    content: JSON.stringify(payload),
-    timestamp,
-  };
-}
-
-function selectedOption(selection: AskAnswer["selections"][number], args: ValidatedAskParams): AskAnswer["selections"][number] {
-  const original = args.options.find(option => option.label === selection.label);
-  const description = selection.description ?? original?.description;
-  return {
-    label: selection.label,
-    ...(description !== undefined ? { description } : {}),
-    ...(selection.comment !== undefined ? { comment: selection.comment } : {}),
-  };
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/src/replay-renderer.ts

@@ -1,85 +0,0 @@
-import type { MessageRenderOptions, Theme } from "@earendil-works/pi-coding-agent";
-import { Text } from "@earendil-works/pi-tui";
-
-import { parseAskReplayDetails, type AskReplayDetails } from "./replay.js";
-
-interface RenderMessage {
-  content?: unknown;
-  details?: unknown;
-}
-
-type Selection = AskReplayDetails["answer"]["selections"][number];
-type RecordValue = Record<string, unknown>;
-
-/**
- * Render a completed ask replay for registration with
- * `pi.registerMessageRenderer("ask:reanswer", renderAskReanswerMessage)`.
- *
- * The renderer deliberately returns a Text component rather than pre-wrapped
- * strings. Text performs wrapping using terminal column widths, including
- * when the theme has added ANSI styling to the label.
- */
-export const renderAskReanswerMessage = (
-  message: RenderMessage,
-  options: Pick<MessageRenderOptions, "expanded">,
-  theme: Pick<Theme, "fg"> | undefined,
-): Text => renderMessage(message, options, theme);
-
-function renderMessage(
-  message: RenderMessage,
-  options: Pick<MessageRenderOptions, "expanded">,
-  theme: Pick<Theme, "fg"> | undefined,
-): Text {
-  const details = parseAskReplayDetails(message.details);
-  const content = details
-    ? formatDetails(details, options.expanded, theme)
-    : textualContent(message.content);
-  return new Text(content, 0, 0);
-}
-
-function formatDetails(details: AskReplayDetails, expanded: boolean, theme: Pick<Theme, "fg"> | undefined): string {
-  const label = colorLabel("Revised answer", theme);
-  const selections = details.answer.selections;
-  const freeform = details.answer.freeform;
-
-  if (!expanded) {
-    const lines: string[] = [label];
-    if (selections.length > 0) lines.push(`Selected: ${selections.map(selection => selection.label).join(", ")}`);
-    if (freeform) lines.push(`Freeform: ${freeform}`);
-    if (selections.length === 0 && !freeform) lines.push("No answer provided.");
-    return lines.join(" · ");
-  }
-
-  const lines: string[] = [label, `Question: ${details.question}`];
-  if (details.context) lines.push(`Context: ${details.context}`);
-  if (selections.length > 0) {
-    lines.push("Selections:");
-    for (const selection of selections) {
-      let line = `- ${selection.label}`;
-      if (selection.description) line += ` — ${selection.description}`;
-      if (selection.comment) line += ` (${selection.comment})`;
-      lines.push(line);
-    }
-  }
-  if (freeform) lines.push(`Freeform: ${freeform}`);
-  if (selections.length === 0 && !freeform) lines.push("No answer provided.");
-  return lines.join("\n");
-}
-
-function textualContent(content: unknown): string {
-  if (typeof content === "string") return content;
-  if (!Array.isArray(content)) return "";
-  return content
-    .filter(isRecord)
-    .filter(item => item.type === "text" && typeof item.text === "string")
-    .map(item => item.text as string)
-    .join("\n");
-}
-
-function colorLabel(label: string, theme: Pick<Theme, "fg"> | undefined): string {
-  return typeof theme?.fg === "function" ? theme.fg("customMessageLabel", label) : label;
-}
-
-function isRecord(value: unknown): value is RecordValue {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}