pi-sessions 0.7.2 → 0.9.0

package/extensions/subagents/ledger.ts

@@ -0,0 +1,217 @@
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+import { type Static, Type } from "typebox";
+import { TASK_REPORT_SCHEMA } from "../shared/session-broker/protocol.ts";
+import { safeParseTypeBoxValue } from "../shared/typebox.ts";
+
+export const SUBAGENT_LAUNCHED_CUSTOM_TYPE = "pi-sessions.subagent_launched";
+export const SUBAGENT_REPORT_CUSTOM_TYPE = "pi-sessions.subagent_report";
+export const SUBAGENT_REPORT_RECEIVED_CUSTOM_TYPE = "pi-sessions.subagent_report_received";
+export const SUBAGENT_REPORT_MESSAGE_CUSTOM_TYPE = "pi-sessions.subagent_report_message";
+export const SUBAGENT_CLOSED_CUSTOM_TYPE = "pi-sessions.subagent_closed";
+export const SUBAGENT_REPORT_REMINDER_MESSAGE_CUSTOM_TYPE = "pi-sessions.report_reminder_message";
+export const SUBAGENT_DISOWNED_MESSAGE_CUSTOM_TYPE = "pi-sessions.subagent_disowned_message";
+export const SUBAGENT_CANCELLED_CUSTOM_TYPE = "pi-sessions.subagent_cancelled";
+export const SUBAGENT_SUSPENDED_CUSTOM_TYPE = "pi-sessions.subagent_suspended";
+
+export const SUBAGENT_LAUNCHED_SCHEMA = Type.Object({
+  writerSessionId: Type.String(),
+  childSessionId: Type.String(),
+  childSessionFile: Type.String(),
+  title: Type.String(),
+  goal: Type.String(),
+  requestResponse: Type.Boolean(),
+  model: Type.Optional(Type.String()),
+  cwd: Type.String(),
+  resumeCommand: Type.String(),
+  depth: Type.Integer({ minimum: 1 }),
+});
+
+export const SUBAGENT_REPORT_SCHEMA = Type.Intersect([
+  Type.Object({ reportId: Type.String() }),
+  TASK_REPORT_SCHEMA,
+]);
+
+export const SUBAGENT_REPORT_RECEIVED_SCHEMA = Type.Object({
+  writerSessionId: Type.String(),
+  childSessionId: Type.String(),
+  reportId: Type.String(),
+});
+
+export const SUBAGENT_REPORT_MESSAGE_SCHEMA = Type.Intersect([
+  Type.Object({
+    writerSessionId: Type.String(),
+    childSessionId: Type.String(),
+    reportId: Type.String(),
+    title: Type.Optional(Type.String()),
+    provenance: Type.Union([Type.Literal("live"), Type.Literal("recovered")]),
+  }),
+  TASK_REPORT_SCHEMA,
+]);
+
+export const SUBAGENT_CLOSED_SCHEMA = Type.Object({
+  reason: Type.Union([
+    Type.Literal("no_response_expected"),
+    Type.Literal("no_report_after_reminder"),
+  ]),
+});
+
+export const SUBAGENT_CANCELLED_SCHEMA = Type.Object({
+  writerSessionId: Type.String(),
+  childSessionId: Type.String(),
+});
+export const SUBAGENT_SUSPENDED_SCHEMA = Type.Object({
+  writerSessionId: Type.String(),
+  childSessionIds: Type.Array(Type.String()),
+});
+export const SUBAGENT_DISOWNED_MESSAGE_SCHEMA = Type.Object({
+  writerSessionId: Type.String(),
+});
+
+export type SubagentLaunched = Static<typeof SUBAGENT_LAUNCHED_SCHEMA>;
+export type SubagentReport = Static<typeof SUBAGENT_REPORT_SCHEMA>;
+export type SubagentReportReceived = Static<typeof SUBAGENT_REPORT_RECEIVED_SCHEMA>;
+export type SubagentReportMessage = Static<typeof SUBAGENT_REPORT_MESSAGE_SCHEMA>;
+export type SubagentClosed = Static<typeof SUBAGENT_CLOSED_SCHEMA>;
+
+export interface ChildSubagentLifecycle {
+  reports: readonly SubagentReport[];
+  closed: SubagentClosed | undefined;
+  hasReminder: boolean;
+}
+
+export interface ParentSubagentLaunch extends SubagentLaunched {
+  launchedAt: string;
+}
+
+export interface ParentSubagentLedger {
+  launches: readonly ParentSubagentLaunch[];
+  cancelledChildIds: ReadonlySet<string>;
+  suspendedChildIds: ReadonlySet<string>;
+  receivedReportIds: ReadonlySet<string>;
+  deliveredReportIds: ReadonlySet<string>;
+  hasForeignLaunch: boolean;
+  hasDisownedNotice: boolean;
+}
+
+export function hasSubagentLaunchEntries(branch: readonly SessionEntry[]): boolean {
+  return branch.some(
+    (entry) => entry.type === "custom" && entry.customType === SUBAGENT_LAUNCHED_CUSTOM_TYPE,
+  );
+}
+
+export function findOwnedSubagentLaunch(
+  branch: readonly SessionEntry[],
+  ownerSessionId: string,
+  childSessionId: string,
+): ParentSubagentLaunch | undefined {
+  return collectParentLedger(branch, ownerSessionId).launches.find(
+    (launch) => launch.childSessionId === childSessionId,
+  );
+}
+
+export function collectParentLedger(
+  branch: readonly SessionEntry[],
+  ownerSessionId: string,
+): ParentSubagentLedger {
+  const launches = new Map<string, ParentSubagentLaunch>();
+  const cancelledChildIds = new Set<string>();
+  const suspendedChildIds = new Set<string>();
+  const receivedReportIds = new Set<string>();
+  const deliveredReportIds = new Set<string>();
+  let hasForeignLaunch = false;
+  let hasDisownedNotice = false;
+
+  for (const entry of branch) {
+    if (entry.type === "custom_message") {
+      if (entry.customType === SUBAGENT_REPORT_MESSAGE_CUSTOM_TYPE) {
+        const report = safeParseTypeBoxValue(SUBAGENT_REPORT_MESSAGE_SCHEMA, entry.details);
+        if (report?.writerSessionId === ownerSessionId) {
+          deliveredReportIds.add(report.reportId);
+        }
+      } else if (entry.customType === SUBAGENT_DISOWNED_MESSAGE_CUSTOM_TYPE) {
+        const notice = safeParseTypeBoxValue(SUBAGENT_DISOWNED_MESSAGE_SCHEMA, entry.details);
+        hasDisownedNotice ||= notice?.writerSessionId === ownerSessionId;
+      }
+      continue;
+    }
+    if (entry.type !== "custom") {
+      continue;
+    }
+
+    if (entry.customType === SUBAGENT_LAUNCHED_CUSTOM_TYPE) {
+      const launch = safeParseTypeBoxValue(SUBAGENT_LAUNCHED_SCHEMA, entry.data);
+      if (!launch) {
+        continue;
+      }
+      if (launch.writerSessionId !== ownerSessionId) {
+        hasForeignLaunch = true;
+        continue;
+      }
+      launches.set(launch.childSessionId, { ...launch, launchedAt: entry.timestamp });
+      cancelledChildIds.delete(launch.childSessionId);
+      suspendedChildIds.delete(launch.childSessionId);
+      continue;
+    }
+
+    if (entry.customType === SUBAGENT_CANCELLED_CUSTOM_TYPE) {
+      const cancellation = safeParseTypeBoxValue(SUBAGENT_CANCELLED_SCHEMA, entry.data);
+      if (cancellation?.writerSessionId === ownerSessionId) {
+        cancelledChildIds.add(cancellation.childSessionId);
+      }
+      continue;
+    }
+
+    if (entry.customType === SUBAGENT_SUSPENDED_CUSTOM_TYPE) {
+      const suspension = safeParseTypeBoxValue(SUBAGENT_SUSPENDED_SCHEMA, entry.data);
+      if (suspension?.writerSessionId === ownerSessionId) {
+        for (const childSessionId of suspension.childSessionIds) {
+          suspendedChildIds.add(childSessionId);
+        }
+      }
+      continue;
+    }
+
+    if (entry.customType === SUBAGENT_REPORT_RECEIVED_CUSTOM_TYPE) {
+      const receipt = safeParseTypeBoxValue(SUBAGENT_REPORT_RECEIVED_SCHEMA, entry.data);
+      if (receipt?.writerSessionId === ownerSessionId) {
+        receivedReportIds.add(receipt.reportId);
+      }
+    }
+  }
+
+  return {
+    launches: [...launches.values()],
+    cancelledChildIds,
+    suspendedChildIds,
+    receivedReportIds,
+    deliveredReportIds,
+    hasForeignLaunch,
+    hasDisownedNotice,
+  };
+}
+
+export function getChildSubagentLifecycle(branch: readonly SessionEntry[]): ChildSubagentLifecycle {
+  const reports = new Map<string, SubagentReport>();
+  let closed: SubagentClosed | undefined;
+  let hasReminder = false;
+
+  for (const entry of branch) {
+    if (entry.type === "custom_message") {
+      hasReminder ||= entry.customType === SUBAGENT_REPORT_REMINDER_MESSAGE_CUSTOM_TYPE;
+      continue;
+    }
+    if (entry.type !== "custom") {
+      continue;
+    }
+    if (entry.customType === SUBAGENT_REPORT_CUSTOM_TYPE) {
+      const report = safeParseTypeBoxValue(SUBAGENT_REPORT_SCHEMA, entry.data);
+      if (report) {
+        reports.set(report.reportId, report);
+      }
+    } else if (entry.customType === SUBAGENT_CLOSED_CUSTOM_TYPE) {
+      closed = safeParseTypeBoxValue(SUBAGENT_CLOSED_SCHEMA, entry.data) ?? closed;
+    }
+  }
+
+  return { reports: [...reports.values()], closed, hasReminder };
+}

package/extensions/subagents/reconcile.ts

@@ -0,0 +1,386 @@
+import { type SessionEntry, SessionManager } from "@earendil-works/pi-coding-agent";
+import { isSessionStarting } from "../session-handoff/metadata.ts";
+import {
+  createTmuxWindow,
+  killTmuxSession,
+  killTmuxWindow,
+  listTmuxWindows,
+  type TmuxExecutor,
+  tmuxSessionName,
+} from "../shared/tmux.ts";
+import { classifySubagent, type SubagentEvidence, type SubagentState } from "./classify.ts";
+import {
+  type ChildSubagentLifecycle,
+  collectParentLedger,
+  getChildSubagentLifecycle,
+  type ParentSubagentLedger,
+  SUBAGENT_DISOWNED_MESSAGE_CUSTOM_TYPE,
+  SUBAGENT_LAUNCHED_CUSTOM_TYPE,
+  SUBAGENT_REPORT_MESSAGE_CUSTOM_TYPE,
+  SUBAGENT_REPORT_RECEIVED_CUSTOM_TYPE,
+  SUBAGENT_SUSPENDED_CUSTOM_TYPE,
+  type SubagentLaunched,
+  type SubagentReport,
+  type SubagentReportMessage,
+} from "./ledger.ts";
+import { formatReportForModel } from "./report.ts";
+
+export interface ReconcileParentSession {
+  sessionId: string;
+  epoch: number;
+  getBranch(): readonly SessionEntry[];
+  isIdle(): boolean;
+}
+
+export interface ReconcileSessionManager {
+  getBranch(): readonly SessionEntry[];
+}
+
+export interface ReconcileMessaging {
+  listSessions(): Promise<string[]>;
+}
+
+export interface ReconcileActions extends TmuxExecutor {
+  appendEntry(customType: string, data: unknown): void;
+  sendMessage(
+    message: { customType: string; content: string; display: boolean; details: unknown },
+    options?: { triggerTurn: true } | { deliverAs: "steer" },
+  ): void;
+}
+
+export interface ReconcileDependencies {
+  executor: ReconcileActions;
+  messaging: ReconcileMessaging;
+  getParent(): ReconcileParentSession | undefined;
+  isCurrent(epoch: number): boolean;
+  openSession(path: string): ReconcileSessionManager;
+}
+
+interface ChildLifecycle extends ChildSubagentLifecycle {
+  awaitingKickoff: boolean;
+  readable: boolean;
+}
+
+interface ChildEvidence {
+  launch: SubagentLaunched;
+  classification: SubagentEvidence;
+  state: SubagentState;
+  reports: readonly SubagentReport[];
+}
+
+export interface ReconcileResult {
+  states: ReadonlyMap<string, SubagentState>;
+  registered: ReadonlySet<string>;
+}
+
+/**
+ * Converges the runtime view of a parent's owned subagents from their durable ledgers.
+ * It intentionally does not cache child files: every trigger observes current branch truth.
+ */
+export class SubagentReconciler {
+  private inFlight: Promise<ReconcileResult> | undefined;
+  private dirty = false;
+  private restoreSuspended = false;
+  private shuttingDown = false;
+  private registered: { epoch: number; sessionIds: Set<string> } | undefined;
+  private latestResult: ReconcileResult = emptyReconcileResult();
+
+  constructor(private readonly deps: ReconcileDependencies) {}
+
+  beginSession(): void {
+    this.shuttingDown = false;
+    this.dirty = false;
+    this.restoreSuspended = false;
+    this.registered = undefined;
+    this.latestResult = emptyReconcileResult();
+  }
+
+  reconcile(): Promise<ReconcileResult> {
+    return this.requestReconciliation(false);
+  }
+
+  reconcileAndRestoreSuspended(): Promise<ReconcileResult> {
+    return this.requestReconciliation(true);
+  }
+
+  private requestReconciliation(restoreSuspended: boolean): Promise<ReconcileResult> {
+    if (this.shuttingDown) {
+      return this.inFlight ?? Promise.resolve(this.latestResult);
+    }
+    this.dirty = true;
+    this.restoreSuspended ||= restoreSuspended;
+    if (this.inFlight) {
+      return this.inFlight;
+    }
+
+    const run = this.run().finally(() => {
+      if (this.inFlight === run) {
+        this.inFlight = undefined;
+      }
+    });
+    this.inFlight = run;
+    return run;
+  }
+
+  async suspendForShutdown(): Promise<void> {
+    this.shuttingDown = true;
+    await this.inFlight;
+
+    const parent = this.deps.getParent();
+    if (!parent) {
+      return;
+    }
+
+    const tmuxSession = tmuxSessionName(parent.sessionId);
+    const ledger = collectParentLedger(parent.getBranch(), parent.sessionId);
+    const windows = await listTmuxWindows(this.deps.executor, tmuxSession);
+    const ownedChildIds = new Set(ledger.launches.map((launch) => launch.childSessionId));
+    const childSessionIds = windows
+      .map((window) => window.piSessionId)
+      .filter((childSessionId) => ownedChildIds.has(childSessionId));
+
+    if (childSessionIds.length > 0) {
+      this.append(parent, SUBAGENT_SUSPENDED_CUSTOM_TYPE, {
+        writerSessionId: parent.sessionId,
+        childSessionIds,
+      });
+    }
+    this.requireCurrent(parent);
+    await killTmuxSession(this.deps.executor, tmuxSession);
+  }
+
+  private async run(): Promise<ReconcileResult> {
+    while (this.dirty && !this.shuttingDown) {
+      this.dirty = false;
+      const restoreSuspended = this.restoreSuspended;
+      this.restoreSuspended = false;
+      this.latestResult = await this.reconcileOnce(restoreSuspended);
+    }
+    return this.latestResult;
+  }
+
+  private async reconcileOnce(restoreSuspended: boolean): Promise<ReconcileResult> {
+    const parent = this.deps.getParent();
+    if (!parent) {
+      return emptyReconcileResult();
+    }
+
+    const branch = parent.getBranch();
+    const ledger = collectParentLedger(branch, parent.sessionId);
+    const tmuxSession = tmuxSessionName(parent.sessionId);
+    const [windows, liveSessionIds] = await Promise.all([
+      listTmuxWindows(this.deps.executor, tmuxSession),
+      this.deps.messaging.listSessions(),
+    ]);
+    const liveSessions = new Set(liveSessionIds);
+    const registered = this.getRegistered(parent.epoch);
+    for (const sessionId of liveSessionIds) {
+      registered.add(sessionId);
+    }
+    const windowSessionIds = new Set(windows.map((window) => window.piSessionId));
+    const evidence = ledger.launches.map((launch) =>
+      this.readChildEvidence(
+        launch,
+        ledger,
+        windowSessionIds.has(launch.childSessionId),
+        liveSessions.has(launch.childSessionId),
+        registered.has(launch.childSessionId),
+      ),
+    );
+
+    let runtimeChanged = false;
+
+    if (ledger.hasForeignLaunch && !ledger.hasDisownedNotice) {
+      this.sendDisownedMessage(parent);
+    }
+
+    for (const child of evidence) {
+      if (child.state === "unknown") {
+        continue;
+      }
+
+      for (const report of child.reports) {
+        if (!ledger.receivedReportIds.has(report.reportId)) {
+          this.append(parent, SUBAGENT_REPORT_RECEIVED_CUSTOM_TYPE, {
+            writerSessionId: parent.sessionId,
+            childSessionId: child.launch.childSessionId,
+            reportId: report.reportId,
+          });
+        }
+        if (!ledger.deliveredReportIds.has(report.reportId)) {
+          this.deliverRecoveredReport(parent, child.launch, report);
+        }
+      }
+
+      if (child.state === "suspended" && restoreSuspended) {
+        this.append(parent, SUBAGENT_LAUNCHED_CUSTOM_TYPE, child.launch);
+        await createTmuxWindow(this.deps.executor, {
+          tmuxSession,
+          name: child.launch.title,
+          cwd: child.launch.cwd,
+          command: child.launch.resumeCommand,
+          piSessionId: child.launch.childSessionId,
+        });
+        child.classification = {
+          ...child.classification,
+          cancelled: false,
+          suspended: false,
+        };
+        runtimeChanged = true;
+      } else if (child.state === "stopping") {
+        this.requireCurrent(parent);
+        await killTmuxWindow(this.deps.executor, tmuxSession, child.launch.childSessionId);
+        runtimeChanged = true;
+      }
+    }
+
+    const ownedIds = new Set(ledger.launches.map((launch) => launch.childSessionId));
+    for (const window of windows) {
+      if (!ownedIds.has(window.piSessionId)) {
+        this.requireCurrent(parent);
+        await killTmuxWindow(this.deps.executor, tmuxSession, window.piSessionId);
+        runtimeChanged = true;
+      }
+    }
+
+    if (runtimeChanged) {
+      const [currentWindows, currentLiveSessionIds] = await Promise.all([
+        listTmuxWindows(this.deps.executor, tmuxSession),
+        this.deps.messaging.listSessions(),
+      ]);
+      const currentWindowSessionIds = new Set(currentWindows.map((window) => window.piSessionId));
+      const currentLiveSessions = new Set(currentLiveSessionIds);
+      for (const sessionId of currentLiveSessionIds) {
+        registered.add(sessionId);
+      }
+      for (const child of evidence) {
+        child.classification = {
+          ...child.classification,
+          hasWindow: currentWindowSessionIds.has(child.launch.childSessionId),
+          brokerLive: currentLiveSessions.has(child.launch.childSessionId),
+          hasRegistered: registered.has(child.launch.childSessionId),
+          awaitingKickoff: child.classification.awaitingKickoff,
+        };
+        child.state = classifySubagent(child.classification);
+      }
+    }
+
+    return {
+      states: new Map(evidence.map((child) => [child.launch.childSessionId, child.state])),
+      registered: new Set(registered),
+    };
+  }
+
+  private readChildEvidence(
+    launch: SubagentLaunched,
+    ledger: ParentSubagentLedger,
+    hasWindow: boolean,
+    brokerLive: boolean,
+    hasRegistered: boolean,
+  ): ChildEvidence {
+    const lifecycle = this.readChildLifecycle(launch.childSessionFile);
+    const classification: SubagentEvidence = {
+      hasWindow,
+      brokerLive,
+      hasRegistered,
+      awaitingKickoff: lifecycle.awaitingKickoff,
+      cancelled: ledger.cancelledChildIds.has(launch.childSessionId),
+      suspended: ledger.suspendedChildIds.has(launch.childSessionId),
+      hasReportOrClosure: lifecycle.reports.length > 0 || lifecycle.closed !== undefined,
+      childReadable: lifecycle.readable,
+    };
+    return {
+      launch,
+      classification,
+      reports: lifecycle.reports,
+      state: classifySubagent(classification),
+    };
+  }
+
+  private readChildLifecycle(path: string): ChildLifecycle {
+    try {
+      const branch = this.deps.openSession(path).getBranch();
+      return {
+        ...getChildSubagentLifecycle(branch),
+        awaitingKickoff: isSessionStarting(branch),
+        readable: true,
+      };
+    } catch {
+      return {
+        reports: [],
+        closed: undefined,
+        hasReminder: false,
+        awaitingKickoff: false,
+        readable: false,
+      };
+    }
+  }
+
+  private getRegistered(epoch: number): Set<string> {
+    if (this.registered?.epoch !== epoch) {
+      this.registered = { epoch, sessionIds: new Set() };
+    }
+    return this.registered.sessionIds;
+  }
+
+  private append(parent: ReconcileParentSession, customType: string, data: unknown): void {
+    this.requireCurrent(parent);
+    this.deps.executor.appendEntry(customType, data);
+  }
+
+  private deliverRecoveredReport(
+    parent: ReconcileParentSession,
+    launch: SubagentLaunched,
+    report: SubagentReport,
+  ): void {
+    const message: SubagentReportMessage = {
+      writerSessionId: parent.sessionId,
+      childSessionId: launch.childSessionId,
+      title: launch.title,
+      ...report,
+      provenance: "recovered",
+    };
+    this.sendMessage(parent, {
+      customType: SUBAGENT_REPORT_MESSAGE_CUSTOM_TYPE,
+      content: formatReportForModel(launch.title, message),
+      display: true,
+      details: message,
+    });
+  }
+
+  private sendDisownedMessage(parent: ReconcileParentSession): void {
+    this.requireCurrent(parent);
+    this.deps.executor.sendMessage({
+      customType: SUBAGENT_DISOWNED_MESSAGE_CUSTOM_TYPE,
+      content:
+        "[system] copied subagent records belong to the original session; this fork owns none.",
+      display: true,
+      details: { writerSessionId: parent.sessionId },
+    });
+  }
+
+  private sendMessage(
+    parent: ReconcileParentSession,
+    message: { customType: string; content: string; display: boolean; details: unknown },
+  ): void {
+    this.requireCurrent(parent);
+    const delivery = parent.isIdle()
+      ? { triggerTurn: true as const }
+      : { deliverAs: "steer" as const };
+    this.deps.executor.sendMessage(message, delivery);
+  }
+
+  private requireCurrent(parent: ReconcileParentSession): void {
+    if (!this.deps.isCurrent(parent.epoch)) {
+      throw new Error("The parent session changed during subagent reconciliation.");
+    }
+  }
+}
+
+export function openReconcileSession(path: string): ReconcileSessionManager {
+  return SessionManager.open(path);
+}
+
+function emptyReconcileResult(): ReconcileResult {
+  return { states: new Map(), registered: new Set() };
+}

package/extensions/subagents/report-message-presenter.ts

@@ -0,0 +1,36 @@
+import type { RenderTheme } from "../shared/rendering/theme.ts";
+import type { SubagentReportMessageViewModel } from "./report-message-view-model.ts";
+
+export function presentSubagentReportMessage(
+  report: SubagentReportMessageViewModel,
+  theme: RenderTheme,
+): string {
+  const status = report.status === "done" ? "" : `[${report.status}] `;
+  const sections = [
+    theme.fg("toolTitle", theme.bold(`Report from subagent ${status}“${report.title}”`)),
+    presentSection("Summary", report.summary, theme),
+  ];
+
+  if (report.details) {
+    sections.push(presentSection("Details", report.details, theme));
+  }
+  if (report.references.length > 0) {
+    const references = report.references.map((reference) =>
+      reference.description
+        ? `- ${reference.reference} — ${reference.description}`
+        : `- ${reference.reference}`,
+    );
+    sections.push(presentSection("References", references.join("\n"), theme));
+  }
+  if (report.nextSteps.length > 0) {
+    sections.push(
+      presentSection("Next steps", report.nextSteps.map((step) => `- ${step}`).join("\n"), theme),
+    );
+  }
+
+  return sections.join("\n\n");
+}
+
+function presentSection(heading: string, body: string, theme: RenderTheme): string {
+  return `${theme.fg("toolTitle", theme.bold(heading))}\n${theme.fg("toolOutput", body)}`;
+}

package/extensions/subagents/report-message-renderer.ts

@@ -0,0 +1,21 @@
+import type { MessageRenderer } from "@earendil-works/pi-coding-agent";
+import { Box, Text } from "@earendil-works/pi-tui";
+import { safeParseTypeBoxValue } from "../shared/typebox.ts";
+import { SUBAGENT_REPORT_MESSAGE_SCHEMA } from "./ledger.ts";
+import { presentSubagentReportMessage } from "./report-message-presenter.ts";
+import { buildSubagentReportMessageView } from "./report-message-view-model.ts";
+
+export const renderSubagentReportMessage: MessageRenderer = (message, _options, theme) => {
+  const details = safeParseTypeBoxValue(SUBAGENT_REPORT_MESSAGE_SCHEMA, message.details);
+  if (!details) {
+    return undefined;
+  }
+  const report = buildSubagentReportMessageView(details);
+  if (!report) {
+    return undefined;
+  }
+
+  const box = new Box(1, 1, (text) => theme.bg("customMessageBg", text));
+  box.addChild(new Text(presentSubagentReportMessage(report, theme), 0, 0));
+  return box;
+};

package/extensions/subagents/report-message-view-model.ts

@@ -0,0 +1,29 @@
+import type { TaskReportReference } from "../shared/session-broker/protocol.ts";
+import type { SubagentReportMessage } from "./ledger.ts";
+
+export interface SubagentReportMessageViewModel {
+  title: string;
+  status: SubagentReportMessage["status"];
+  summary: string;
+  details?: string | undefined;
+  references: readonly TaskReportReference[];
+  nextSteps: readonly string[];
+}
+
+export function buildSubagentReportMessageView(
+  report: SubagentReportMessage,
+): SubagentReportMessageViewModel | undefined {
+  const title = report.title?.trim();
+  if (!title) {
+    return undefined;
+  }
+
+  return {
+    title,
+    status: report.status,
+    summary: report.summary,
+    details: report.details,
+    references: report.references ?? [],
+    nextSteps: report.nextSteps ?? [],
+  };
+}