pum-agent 0.2.11-beta.1 → 0.2.12-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pum-agent",
-  "version": "0.2.11-beta.1",
+  "version": "0.2.12-beta.1",
   "description": "A compact terminal coding agent powered by pi and OpenTUI.",
   "license": "MIT",
   "type": "module",

package/src/app.tsx

@@ -1037,9 +1037,15 @@ export function App({
       else if (event.type === "main-pending-add") addPending(event.pending);
       else if (event.type === "main-pending-resolve") resolvePending(event.id);
       else if (event.type === "main-pending-drop") dropPending(event.id);
+      else if (event.type === "news-changed") {
+        const loaded = loadNewsItems(session.sessionFile);
+        newsRef.current = loaded;
+        setNews(loaded);
+        setTx((value) => ({ ...value, lines: tagNewsLines(value.lines, loaded) }));
+      }
       setAgentRevision((revision) => revision + 1);
     }),
-    [subagentManager],
+    [subagentManager, session],
   );
 
   useEffect(() => {
@@ -1506,29 +1512,47 @@ export function App({
   const jumpFromNews = (target: "answer" | "prompt") => {
     const item = newsRef.current[newsCursorRef.current];
     if (!item) return;
-    const lines = txRef.current.lines;
-    const answerIndex = lines.findIndex((line) =>
-      line.kind === "text" && line.role === "assistant" && line.newsId === item.id,
-    );
+    const requesterAgentId = item.completion?.requesterAgentId ?? null;
+    const lines = requesterAgentId === null
+      ? txRef.current.lines
+      : subagentManager.getAgent(requesterAgentId)?.transcript.lines;
+    if (!lines) return;
+    const completionPromptIndex = item.completion
+      ? lines.findIndex((line) =>
+        line.kind === "agent-message" && line.messageId === item.completion?.messageId,
+      )
+      : -1;
+    const answerIndex = item.completion
+      ? lines.findIndex((line, index) =>
+        index > completionPromptIndex
+          && line.kind === "text"
+          && line.role === "assistant"
+          && line.text === item.text,
+      )
+      : lines.findIndex((line) =>
+        line.kind === "text" && line.role === "assistant" && line.newsId === item.id,
+      );
     let targetIndex = answerIndex;
     if (target === "prompt") {
-      const promptText = item.prompts?.find((prompt) => !prompt.steer)?.text
-        ?? item.prompts?.[0]?.text;
-      targetIndex = -1;
-      if (promptText) {
-        const end = answerIndex >= 0 ? answerIndex : lines.length;
-        for (let index = end - 1; index >= 0; index--) {
-          const line = lines[index];
-          if (line?.kind === "text" && line.role === "user" && line.text === promptText) {
-            targetIndex = index;
-            break;
+      targetIndex = completionPromptIndex;
+      if (!item.completion) {
+        const promptText = item.prompts?.find((prompt) => !prompt.steer)?.text
+          ?? item.prompts?.[0]?.text;
+        if (promptText) {
+          const end = answerIndex >= 0 ? answerIndex : lines.length;
+          for (let index = end - 1; index >= 0; index--) {
+            const line = lines[index];
+            if (line?.kind === "text" && line.role === "user" && line.text === promptText) {
+              targetIndex = index;
+              break;
+            }
           }
         }
       }
     }
     if (targetIndex < 0) return;
 
-    if (activeAgentIdRef.current !== null && !selectAgentView(null)) return;
+    if (activeAgentIdRef.current !== requesterAgentId && !selectAgentView(requesterAgentId)) return;
     newsOpenRef.current = false;
     setNewsOpen(false);
     const scrollToTarget = () => {
@@ -1590,8 +1614,12 @@ export function App({
     const firstLine = item.text.split("\n")[0] ?? item.text;
     const preview = firstLine.length > 240 ? `${firstLine.slice(0, 240)} …` : firstLine;
     const quote = `> ${preview}\n\n`;
-    viewDrafts.current.set("main", quote);
-    if (activeAgentIdRef.current !== null) selectAgentView(null);
+    const requesterAgentId = item.completion?.requesterAgentId ?? null;
+    const targetAgentId = requesterAgentId && subagentManager.getAgent(requesterAgentId)
+      ? requesterAgentId
+      : null;
+    viewDrafts.current.set(targetAgentId ?? "main", quote);
+    if (activeAgentIdRef.current !== targetAgentId) selectAgentView(targetAgentId);
     else setEditorText(quote);
     queueMicrotask(() => {
       inputRef.current?.focus();

package/src/check-policy.ts

@@ -549,6 +549,12 @@ export function analyzeBashCommand(command: string, requestedLimits?: Partial<Ch
   let pipeline = 0;
   let annotations = 0;
   let truncated = false;
+  let commandStart = true;
+  const caseContexts: Array<{
+    phase: "subject" | "pattern" | "body";
+    parenDepth: number;
+    braceDepth: number;
+  }> = [];
 
   const addAnnotation = <T>(list: T[], value: T) => {
     annotations++;
@@ -607,9 +613,37 @@ export function analyzeBashCommand(command: string, requestedLimits?: Partial<Ch
       index++;
       continue;
     }
-    if (char === "'" || char === "\"") { quote = char; index++; continue; }
-    if (char === "(") { parenDepth++; index++; continue; }
-    if (char === ")") { if (parenDepth === 0) errors.push(`unexpected ) at ${index}`); else parenDepth--; index++; continue; }
+    if (char === "'" || char === "\"") { quote = char; commandStart = false; index++; continue; }
+
+    const word = command.slice(index).match(/^[A-Za-z_][A-Za-z0-9_]*/)?.[0];
+    if (word) {
+      const next = command[index + word.length];
+      const reservedBoundary = next === undefined || /[\s;&|(){}<>]/.test(next);
+      const activeCase = caseContexts.at(-1);
+      const atCaseLevel = activeCase?.parenDepth === parenDepth && activeCase.braceDepth === braceDepth;
+      if (commandStart && word === "case" && reservedBoundary) {
+        caseContexts.push({ phase: "subject", parenDepth, braceDepth });
+      } else if (activeCase?.phase === "subject" && atCaseLevel && word === "in" && reservedBoundary) {
+        activeCase.phase = "pattern";
+      } else if (commandStart && activeCase && atCaseLevel && word === "esac" && reservedBoundary) {
+        caseContexts.pop();
+      }
+      commandStart = commandStart && reservedBoundary && new Set(["do", "then", "else", "elif"]).has(word);
+      index += word.length;
+      continue;
+    }
+
+    if (char === "(") { parenDepth++; commandStart = true; index++; continue; }
+    if (char === ")") {
+      const activeCase = caseContexts.at(-1);
+      if (activeCase?.phase === "pattern" && activeCase.parenDepth === parenDepth && activeCase.braceDepth === braceDepth) {
+        activeCase.phase = "body";
+        commandStart = true;
+      } else if (parenDepth === 0) errors.push(`unexpected ) at ${index}`);
+      else parenDepth--;
+      index++;
+      continue;
+    }
     if (char === "{") { braceDepth++; index++; continue; }
     if (char === "}") { if (braceDepth === 0) errors.push(`unexpected } at ${index}`); else braceDepth--; index++; continue; }
 
@@ -632,6 +666,15 @@ export function analyzeBashCommand(command: string, requestedLimits?: Partial<Ch
       index = newline + 1;
       continue;
     }
+    const activeCase = caseContexts.at(-1);
+    const inCasePattern = activeCase?.phase === "pattern"
+      && activeCase.parenDepth === parenDepth
+      && activeCase.braceDepth === braceDepth;
+    if (char === "|" && inCasePattern && !command.startsWith("||", index) && !command.startsWith("|&", index)) {
+      commandStart = false;
+      index++;
+      continue;
+    }
     const rawOperator = [";;&", "&&", "||", "|&", ";;", ";&", ";", "|", "&", "\n"].find((item) => command.startsWith(item, index));
     if (rawOperator) {
       const normalized = rawOperator === "\n" ? "newline" : rawOperator as BashOperator["operator"];
@@ -643,9 +686,15 @@ export function analyzeBashCommand(command: string, requestedLimits?: Partial<Ch
         stageStart = index + rawOperator.length;
         operatorBefore = normalized;
       }
+      if (activeCase?.phase === "body" && activeCase.parenDepth === parenDepth && activeCase.braceDepth === braceDepth
+        && (rawOperator === ";;" || rawOperator === ";&" || rawOperator === ";;&")) {
+        activeCase.phase = "pattern";
+      }
+      commandStart = true;
       index += rawOperator.length;
       continue;
     }
+    if (!/\s/.test(char)) commandStart = false;
     index++;
   }
   addStage(command.length);
@@ -655,6 +704,7 @@ export function analyzeBashCommand(command: string, requestedLimits?: Partial<Ch
   if (backtickStart !== undefined) errors.push(`unterminated backtick substitution at ${backtickStart}`);
   if (parenDepth) errors.push("unbalanced parentheses");
   if (braceDepth) errors.push("unbalanced braces");
+  if (caseContexts.length) errors.push("unterminated case statement");
   if (truncated) errors.push("analysis annotation limit exceeded");
 
   const stages: BashStage[] = stageRanges.map((range, index) => {

package/src/news-popup.tsx

@@ -69,6 +69,15 @@ export function NewsPopup({
             <box style={{ flexGrow: 1, width: 1 }} />
             <text content={formatAge(current.at)} fg={theme.dim} bg={theme.popupBg} wrapMode="none" />
           </box>
+          {current.completion ? (
+            <text
+              content={`${current.completion.agentName} → ${current.completion.requesterName} · finish_subagent`}
+              fg={theme.dim}
+              bg={theme.popupBg}
+              wrapMode="none"
+              style={{ height: 1, flexShrink: 0 }}
+            />
+          ) : null}
           <box style={{ height: 1, flexShrink: 0 }} />
           <scrollbox
             id="news-scrollbox"

package/src/news.ts

@@ -8,6 +8,16 @@ export type NewsPrompt = {
   steer: boolean;
 };
 
+export type NewsCompletion = {
+  settlementId: string;
+  messageId: string;
+  agentId: string;
+  agentName: string;
+  requesterAgentId: string | null;
+  requesterName: string;
+  summary: string;
+};
+
 export type NewsItem = {
   /** Stable identifier used to tag the matching transcript line. */
   id: string;
@@ -21,6 +31,8 @@ export type NewsItem = {
   answered: boolean;
   /** User prompt and steers that produced this answer, oldest first. */
   prompts?: NewsPrompt[];
+  /** Managed completion identity for a finish_subagent-triggered answer. */
+  completion?: NewsCompletion;
 };
 
 /** The list never holds more than this many answers. */
@@ -48,10 +60,23 @@ function isNewsItem(value: unknown): value is NewsItem {
             Boolean(prompt) &&
             typeof (prompt as Record<string, unknown>).text === "string" &&
             typeof (prompt as Record<string, unknown>).steer === "boolean",
-        )))
+        ))) &&
+    (item.completion === undefined || isNewsCompletion(item.completion))
   );
 }
 
+function isNewsCompletion(value: unknown): value is NewsCompletion {
+  if (!value || typeof value !== "object") return false;
+  const completion = value as Record<string, unknown>;
+  return typeof completion.settlementId === "string"
+    && typeof completion.messageId === "string"
+    && typeof completion.agentId === "string"
+    && typeof completion.agentName === "string"
+    && (completion.requesterAgentId === null || typeof completion.requesterAgentId === "string")
+    && typeof completion.requesterName === "string"
+    && typeof completion.summary === "string";
+}
+
 /** Load the persisted news list for a session. Never throws. */
 export function loadNewsItems(sessionFile: string | undefined): NewsItem[] {
   if (!sessionFile) return [];
@@ -81,16 +106,79 @@ export function saveNewsItems(
   }
 }
 
+export type FinishNewsSettlement = {
+  id: string;
+  messageId: string;
+  agentId: string;
+  agentName: string;
+  parentAgentId: string | null;
+  requesterName: string;
+  status: "idle" | "completed" | "failed";
+  summary?: string;
+  content: string;
+  createdAt: number;
+  response?: string;
+};
+
+/** Project one completed finish settlement into the persisted News model. */
+export function newsItemFromFinishSettlement(
+  settlement: FinishNewsSettlement,
+): NewsItem | undefined {
+  if (settlement.status !== "completed" || !settlement.response?.trim()) return undefined;
+  if (/^(?:ack(?:nowledged)?|got it|noted|ok(?:ay)?|thanks|thank you|understood)[.!\s]*$/i.test(
+    settlement.response.trim(),
+  )) return undefined;
+  return {
+    id: `subagent-finish:${settlement.messageId}`,
+    text: settlement.response.trim(),
+    at: settlement.createdAt,
+    read: false,
+    answered: false,
+    prompts: [{ text: settlement.content, steer: false }],
+    completion: {
+      settlementId: settlement.id,
+      messageId: settlement.messageId,
+      agentId: settlement.agentId,
+      agentName: settlement.agentName,
+      requesterAgentId: settlement.parentAgentId,
+      requesterName: settlement.requesterName,
+      summary: settlement.summary ?? "",
+    },
+  };
+}
+
+/** Upsert stable News identities while preserving local read and reply state. */
+export function mergeNewsItems(
+  existing: readonly NewsItem[],
+  incoming: readonly NewsItem[],
+): NewsItem[] {
+  const byId = new Map(existing.map((item) => [item.id, item]));
+  for (const item of incoming) {
+    const current = byId.get(item.id);
+    byId.set(item.id, current
+      ? { ...item, read: current.read, answered: current.answered }
+      : item);
+  }
+  return [...byId.values()]
+    .sort((a, b) => b.at - a.at)
+    .slice(0, NEWS_CAPACITY);
+}
+
 /**
  * Attach news identifiers to replayed assistant lines that exactly match a
  * stored answer. Each stored answer claims the first later unmatched line with
  * the same text, so resumed transcripts keep their circle/checkmark markers.
  */
-export function tagNewsLines<T>(lines: readonly T[], items: readonly NewsItem[]): T[] {
+export function tagNewsLines<T>(
+  lines: readonly T[],
+  items: readonly NewsItem[],
+  requesterAgentId: string | null = null,
+): T[] {
   if (items.length === 0 || lines.length === 0) return lines.map((line) => line);
   const claimed = new Set<number>();
   const out = lines.map((line) => line);
   for (const item of items) {
+    if ((item.completion?.requesterAgentId ?? null) !== requesterAgentId) continue;
     const maybe = (value: T) =>
       value as unknown as { kind?: unknown; role?: unknown; text?: unknown; newsId?: unknown };
     const index = out.findIndex((line, i) =>

package/src/replay.ts

@@ -120,6 +120,7 @@ export function replayEntries(
           sender: agentMessage.sender,
           recipient: agentMessage.recipient,
           text: agentMessage.text,
+          messageId: agentMessage.id,
         });
       }
       continue;

package/src/subagents/manager.ts

@@ -19,6 +19,13 @@ import {
   usageFromEntries,
 } from "../agent-usage";
 import { replayEntries } from "../replay";
+import {
+  loadNewsItems,
+  mergeNewsItems,
+  newsItemFromFinishSettlement,
+  saveNewsItems,
+  tagNewsLines,
+} from "../news";
 import { isRejectedToolResult, rejectedToolReason } from "../check-mode";
 import {
   observeSearchCalls,
@@ -185,6 +192,8 @@ type RuntimeRecord = {
    * it to idle and blocking its managed merge.
    */
   statusBeforeTurn?: SubagentStatus;
+  completionMessageIds?: Set<string>;
+  completionResponse?: string;
 };
 
 type IdleOpenReminderState = {
@@ -289,6 +298,8 @@ export class SubagentManager {
   private mainCwd = process.cwd();
   private parentSessionId = "detached";
   private mainRunning = false;
+  private readonly mainCompletionMessageIds = new Set<string>();
+  private mainCompletionResponse = "";
   private maxActiveSubagents: number;
   private worktreeQueue: Promise<void> = Promise.resolve();
   private readonly messageTimes = new Map<string, number[]>();
@@ -365,6 +376,8 @@ export class SubagentManager {
     this.mainCwd = cwd;
     this.parentSessionId = sessionId;
     this.mainRunning = false;
+    this.mainCompletionMessageIds.clear();
+    this.mainCompletionResponse = "";
     this.emit({
       type: "trigger-target",
       sessionId,
@@ -374,6 +387,7 @@ export class SubagentManager {
     });
 
     const restored = new Map<string, Omit<SubagentSnapshot, "transcript">>();
+    const restoredEntries = new Map<string, readonly any[]>();
     const restoredActivity = new Map<string, { activityGeneration: number; idleNotifiedGeneration: number }>();
     const restoredFinish = new Map<string, string>();
     for (const entry of sessionManager.getEntries()) {
@@ -421,6 +435,7 @@ export class SubagentManager {
           const childManager = (await import("@earendil-works/pi-coding-agent")).SessionManager.open(
             snapshot.sessionFile,
           );
+          restoredEntries.set(snapshot.id, childManager.getEntries());
           transcript = {
             lines: replayEntries(childManager.buildContextEntries(), snapshot.worktree.path, true),
             stream: null,
@@ -463,6 +478,8 @@ export class SubagentManager {
         this.persistActivity(this.records.get(snapshot.id)!);
       }
     }
+    this.restoreSettlementResponses(sessionManager.getEntries(), restoredEntries);
+    this.reconcileFinishNews();
     await this.retrySettlementsForParent(null);
     this.emit();
   }
@@ -733,7 +750,14 @@ export class SubagentManager {
           if (typeof id === "string") {
             this.resolvePending(record, id);
             this.acknowledgeSettlementMessage(id);
+            if (message.customType === AGENT_MESSAGE_CUSTOM_TYPE
+              && message.details?.kind === "completion") {
+              record.completionMessageIds ??= new Set<string>();
+              record.completionMessageIds.add(id);
+            }
           }
+        } else if (message?.role === "assistant" && record.completionMessageIds?.size) {
+          record.completionResponse = "";
         } else if (message?.role === "user") {
           const text = typeof message.content === "string"
             ? message.content
@@ -766,6 +790,9 @@ export class SubagentManager {
         const update = event.assistantMessageEvent;
         const kind = update.type === "text_delta" ? "assistant" : update.type === "thinking_delta" ? "thinking" : null;
         if (!kind) return;
+        if (kind === "assistant" && record.completionMessageIds?.size) {
+          record.completionResponse = (record.completionResponse ?? "") + update.delta;
+        }
         this.updateTranscript(record, (value) => {
           if (value.stream?.kind === kind) {
             return { ...value, stream: { kind, text: value.stream.text + update.delta } };
@@ -833,6 +860,13 @@ export class SubagentManager {
       case "agent_settled": {
         this.messageCacheController?.releaseRequester({ kind: "subagent", id: record.snapshot.id });
         this.updateTranscript(record, flushTranscript);
+        if (record.completionMessageIds?.size) {
+          for (const messageId of record.completionMessageIds) {
+            this.recordSettlementResponse(messageId, record.completionResponse ?? "");
+          }
+          record.completionMessageIds.clear();
+          record.completionResponse = "";
+        }
         if (record.session) {
           void this.triggerManager?.markTargetSettled(
             record.session.sessionId,
@@ -1112,6 +1146,13 @@ export class SubagentManager {
         });
         pi.on("agent_settled", () => {
           this.mainRunning = false;
+          if (this.mainCompletionMessageIds.size > 0) {
+            for (const messageId of this.mainCompletionMessageIds) {
+              this.recordSettlementResponse(messageId, this.mainCompletionResponse);
+            }
+            this.mainCompletionMessageIds.clear();
+            this.mainCompletionResponse = "";
+          }
           this.messageCacheController?.releaseRequester({ kind: "main", id: this.parentSessionId });
           void this.triggerManager?.markTargetSettled(this.parentSessionId, null);
           this.emit({
@@ -1126,12 +1167,26 @@ export class SubagentManager {
         pi.on("message_start", (event) => {
           const message = event.message;
           this.acceptIdleOpenReminder(null, message);
+          if (message.role === "assistant" && this.mainCompletionMessageIds.size > 0) {
+            this.mainCompletionResponse = "";
+            return;
+          }
           if (message.role !== "custom"
             || ![AGENT_MESSAGE_CUSTOM_TYPE, TRIGGER_EVENT_CUSTOM_TYPE].includes(message.customType)) return;
-          const id = (message.details as AgentMessageData | undefined)?.id;
+          const details = message.details as AgentMessageData | undefined;
+          const id = details?.id;
           if (typeof id === "string") {
             this.acknowledgeSettlementMessage(id);
             this.emit({ type: "main-pending-resolve", id });
+            if (message.customType === AGENT_MESSAGE_CUSTOM_TYPE && details?.kind === "completion") {
+              this.mainCompletionMessageIds.add(id);
+            }
+          }
+        });
+        pi.on("message_update", (event) => {
+          const update = event.assistantMessageEvent;
+          if (this.mainCompletionMessageIds.size > 0 && update.type === "text_delta") {
+            this.mainCompletionResponse += update.delta;
           }
         });
         pi.on("session_start", async (_event, ctx) => {
@@ -1719,6 +1774,7 @@ export class SubagentManager {
       sender: data.sender,
       recipient: data.recipient,
       text: data.text,
+      messageId: data.id,
     };
   }
 
@@ -1893,6 +1949,89 @@ export class SubagentManager {
     if (!delivered) this.emit({ type: "main-pending-drop", id: pending.id });
   }
 
+  private responseAfterSettlement(entries: readonly any[], messageId: string): string {
+    let active = false;
+    let response = "";
+    for (const entry of entries) {
+      const message = entry?.type === "message"
+        ? entry.message
+        : entry?.type === "custom_message"
+          ? { ...entry, role: "custom" }
+          : entry;
+      if (message?.role === "custom") {
+        if (message.customType === AGENT_MESSAGE_CUSTOM_TYPE && message.details?.id === messageId) {
+          active = true;
+        }
+        continue;
+      }
+      if (!active) continue;
+      if (message?.role === "user") break;
+      if (message?.role !== "assistant" || !Array.isArray(message.content)) continue;
+      const text = message.content
+        .filter((block: any) => block?.type === "text" && typeof block.text === "string")
+        .map((block: any) => block.text)
+        .join("")
+        .trim();
+      if (text) response = text;
+    }
+    return response;
+  }
+
+  private restoreSettlementResponses(
+    mainEntries: readonly any[],
+    childEntries: ReadonlyMap<string, readonly any[]>,
+  ): void {
+    for (const settlement of this.settlements.values()) {
+      if (settlement.status !== "completed" || settlement.response?.trim()) continue;
+      const entries = settlement.parentAgentId === null
+        ? mainEntries
+        : childEntries.get(settlement.parentAgentId) ?? [];
+      const response = this.responseAfterSettlement(entries, settlement.messageId);
+      if (response) this.recordSettlementResponse(settlement.messageId, response, false);
+    }
+  }
+
+  private recordSettlementResponse(messageId: string, response: string, reconcile = true): void {
+    const settlement = [...this.settlements.values()].find((item) => item.messageId === messageId);
+    if (!settlement || settlement.status !== "completed" || !response.trim()) return;
+    if (settlement.response === response.trim()) return;
+    settlement.response = response.trim();
+    settlement.respondedAt = Date.now();
+    this.persist({
+      event: "settlement",
+      id: settlement.agentId,
+      at: settlement.respondedAt,
+      settlement: { ...settlement },
+    });
+    if (reconcile) this.reconcileFinishNews();
+  }
+
+  private reconcileFinishNews(): void {
+    const sessionFile = this.mainSessionManager?.getSessionFile?.();
+    if (!sessionFile) return;
+    const incoming = [...this.settlements.values()]
+      .map((settlement) => newsItemFromFinishSettlement({
+        ...settlement,
+        agentName: settlement.agentName
+          ?? this.records.get(settlement.agentId)?.snapshot.name
+          ?? settlement.agentId,
+        requesterName: settlement.requesterName
+          ?? (settlement.parentAgentId
+            ? this.records.get(settlement.parentAgentId)?.snapshot.name ?? settlement.parentAgentId
+            : "main"),
+      }))
+      .filter((item): item is NonNullable<typeof item> => item !== undefined);
+    const next = mergeNewsItems(loadNewsItems(sessionFile), incoming);
+    saveNewsItems(sessionFile, next);
+    for (const record of this.records.values()) {
+      record.snapshot.transcript = {
+        ...record.snapshot.transcript,
+        lines: tagNewsLines(record.snapshot.transcript.lines, next, record.snapshot.id),
+      };
+    }
+    this.emit({ type: "news-changed" });
+  }
+
   private settlementId(record: RuntimeRecord, status: "idle" | "completed" | "failed"): string {
     return `${record.snapshot.id}:${record.activityGeneration}:${status}`;
   }
@@ -1912,11 +2051,16 @@ export class SubagentManager {
         `worktree: ${record.snapshot.worktree.path}`,
         summary ? `summary: ${summary}` : "",
       ].filter(Boolean).join("\n");
+      const requester = record.snapshot.parentAgentId
+        ? this.records.get(record.snapshot.parentAgentId)?.snapshot.name ?? record.snapshot.parentAgentId
+        : "main";
       settlement = {
         id,
         messageId: `settlement-${id}`,
         agentId: record.snapshot.id,
+        agentName: record.snapshot.name,
         parentAgentId: record.snapshot.parentAgentId,
+        requesterName: requester,
         status,
         summary,
         activityGeneration: record.activityGeneration,

package/src/subagents/types.ts

@@ -60,9 +60,13 @@ export type SubagentSettlement = {
   parentAgentId: string | null;
   status: "idle" | "completed" | "failed";
   summary?: string;
+  agentName?: string;
+  requesterName?: string;
   activityGeneration: number;
   content: string;
   createdAt: number;
+  response?: string;
+  respondedAt?: number;
   acknowledgedAt?: number;
 };
 
@@ -96,6 +100,7 @@ export type TriggerEventData = ExternalTriggerEventData & {
 
 export type SubagentManagerEvent =
   | { type: "changed" }
+  | { type: "news-changed" }
   | { type: "main-line"; line: Line }
   | { type: "main-pending-add"; pending: PendingLine }
   | { type: "main-pending-resolve"; id: string }

package/src/transcript.tsx

@@ -20,7 +20,7 @@ export type Role = "user" | "assistant" | "thinking" | "system" | "error";
 export type Line =
   | { kind: "text"; role: Role; text: string; newsId?: string }
   | { kind: "tool"; call: ToolCall }
-  | { kind: "agent-message"; sender: string; recipient: string; text: string };
+  | { kind: "agent-message"; sender: string; recipient: string; text: string; messageId?: string };
 
 export type PendingLine = {
   id: string;