Skip to content

A self-improving RLM agent for coding workflows and long-running autonomous tasks.

Rust

represent agent message in tui (#379)

ktc20468cd5c9c
diff --git a/packages/coding-agent/CHANGELOG.md b/packages/coding-agent/CHANGELOG.md
index 64910a35c4..f2f2f70c2e 100644
--- a/packages/coding-agent/CHANGELOG.md
+++ b/packages/coding-agent/CHANGELOG.md
@@ -2,6 +2,7 @@
## [Unreleased]
+- Changed agent-to-agent messages to render as directional rows, with received messages expandable in chat and sent messages shown below their Python cell ([ENG-4531](https://linear.app/primeintellect/issue/ENG-4531/collapse-and-simplify-agent2agent-messages-in-chat-tui)).
- Fixed IPython state restore notices rendering as full user messages when prompts were queued or restored ([ENG-4530](https://linear.app/primeintellect/issue/ENG-4530/collapse-ipython-state-restore-messages-in-chat-tui)).
- Changed bare `/mcp` to open the Services menu while preserving explicit `list`, `login`, and `logout` subcommands ([ENG-4535](https://linear.app/primeintellect/issue/ENG-4535/open-services-mcp-menu-from-mcp)).
- Added `/btw` and `/side` for one-turn inline side questions that use the current context without changing the main session ([ENG-4509](https://linear.app/primeintellect/issue/ENG-4509/add-btw-and-side-side-question-flows)).
diff --git a/packages/coding-agent/skills/agent-message/src/agent_message/__init__.py b/packages/coding-agent/skills/agent-message/src/agent_message/__init__.py
index 0c57dfc0e6..5e5ee6de52 100644
--- a/packages/coding-agent/skills/agent-message/src/agent_message/__init__.py
+++ b/packages/coding-agent/skills/agent-message/src/agent_message/__init__.py
@@ -8,9 +8,11 @@ from __future__ import annotations
from typing import Any, Literal
+from IPython.display import display
from rlm import host_request
MessageMode = Literal["auto", "follow_up", "steer"]
+_MESSAGE_DISPLAY_MIME = "application/vnd.prime-agent.agent-message+json"
async def list_agents() -> dict[str, Any]:
@@ -38,7 +40,7 @@ async def send(target: str, message: str, mode: MessageMode = "auto") -> dict[st
raise TypeError(f"message must be str, got {type(message).__name__}")
if mode not in ("auto", "follow_up", "steer"):
raise ValueError('mode must be "auto", "follow_up", or "steer"')
- return await host_request(
+ receipt = await host_request(
"agent_message.send",
{
"target": target,
@@ -46,3 +48,23 @@ async def send(target: str, message: str, mode: MessageMode = "auto") -> dict[st
"mode": mode,
},
)
+ _emit_sent_message(receipt)
+ return receipt
+
+
+def _emit_sent_message(receipt: dict[str, Any]) -> None:
+ try:
+ label = (
+ "Agent message queued"
+ if receipt.get("deliveryStatus") == "queued"
+ else "Agent message sent"
+ )
+ display(
+ {
+ _MESSAGE_DISPLAY_MIME: receipt,
+ "text/plain": label,
+ },
+ raw=True,
+ )
+ except Exception:
+ pass
diff --git a/packages/coding-agent/src/core/agent-messages.ts b/packages/coding-agent/src/core/agent-messages.ts
index 5e8ac18f97..f066e9b742 100644
--- a/packages/coding-agent/src/core/agent-messages.ts
+++ b/packages/coding-agent/src/core/agent-messages.ts
@@ -1,9 +1,13 @@
import { randomUUID } from "node:crypto";
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
import type { HostRequestHandler } from "./kernel/index.js";
+import type { CustomMessage } from "./messages.js";
+export const AGENT_MESSAGE_CUSTOM_TYPE = "agent_message";
export const AGENT_MESSAGE_SKILL_NAME = "agent-message";
export const AGENT_MESSAGE_IMPORT_NAME = "agent_message";
export const AGENT_MESSAGE_SOURCE = "agent_message";
+export const AGENT_MESSAGE_RECEIVED_PREVIEW_LABEL = "Agent message received";
export const DEFAULT_AGENT_MESSAGE_MAX_CHARS = 16_384;
export const DEFAULT_AGENT_MESSAGE_MAX_PENDING_PER_SESSION = 20;
export const DEFAULT_AGENT_MESSAGE_RATE_LIMIT_CAPACITY = 3;
@@ -46,6 +50,19 @@ export interface AgentSessionMessagePayload {
deliveryMode: AgentSessionMessageDeliveryMode;
}
+export interface AgentSessionMessageDetails {
+ id: string;
+ message: string;
+ from?: AgentSessionMessageSender;
+ target?: AgentSessionMessageEndpoint;
+}
+
+export interface AgentSessionMessage extends CustomMessage<AgentSessionMessageDetails> {
+ customType: typeof AGENT_MESSAGE_CUSTOM_TYPE;
+ content: string;
+ details: AgentSessionMessageDetails;
+}
+
export interface AgentSessionMessageReceipt {
id: string;
source: typeof AGENT_MESSAGE_SOURCE;
@@ -173,6 +190,38 @@ export function createAgentSessionMessagePrompt(payload: AgentSessionMessagePayl
return lines.join("\n");
}
+export function createAgentSessionMessage(
+ payload: AgentSessionMessagePayload,
+ timestamp = Date.now(),
+): AgentSessionMessage {
+ return {
+ role: "custom",
+ customType: AGENT_MESSAGE_CUSTOM_TYPE,
+ content: createAgentSessionMessagePrompt(payload),
+ display: true,
+ details: {
+ id: payload.id,
+ message: payload.message,
+ from: payload.from,
+ target: payload.target,
+ },
+ timestamp,
+ };
+}
+
+export function isAgentSessionMessage(message: AgentMessage): message is AgentSessionMessage {
+ if (message.role !== "custom" || message.customType !== AGENT_MESSAGE_CUSTOM_TYPE) {
+ return false;
+ }
+ const details = message.details;
+ return (
+ typeof details === "object" &&
+ details !== null &&
+ typeof (details as { id?: unknown }).id === "string" &&
+ typeof (details as { message?: unknown }).message === "string"
+ );
+}
+
export function createAgentSessionMessageReceipt(
payload: AgentSessionMessagePayload,
status: AgentSessionMessageDeliveryStatus,
diff --git a/packages/coding-agent/src/core/agent-session.ts b/packages/coding-agent/src/core/agent-session.ts
index 4544393ac0..53864575d1 100644
--- a/packages/coding-agent/src/core/agent-session.ts
+++ b/packages/coding-agent/src/core/agent-session.ts
@@ -43,12 +43,15 @@ import { stripFrontmatter } from "../utils/frontmatter.js";
import { sleep } from "../utils/sleep.js";
import { ensureTool, MISSING_RIPGREP_MESSAGE } from "../utils/tools-manager.js";
import {
+ AGENT_MESSAGE_RECEIVED_PREVIEW_LABEL,
AGENT_MESSAGE_SKILL_NAME,
+ type AgentSessionMessage,
type AgentSessionMessageController,
type AgentSessionMessageListResult,
type AgentSessionMessageReceipt,
assertDirectAgentMessageTarget,
createAgentMessageHostHandlers,
+ isAgentSessionMessage,
normalizeAgentSessionMessage,
normalizeAgentSessionMessageDeliveryMode,
parseAgentSessionMessagePromptId,
@@ -140,7 +143,7 @@ import {
validateGoalBudget,
validateGoalObjective,
} from "./goals.js";
-import type { HostRequestHandlers } from "./kernel/index.js";
+import type { HostRequestHandlers, KernelSentAgentMessage } from "./kernel/index.js";
import { type RestoreResult, snapshotPathIn } from "./kernel/state-snapshot.js";
import type { McpManager } from "./mcp/mcp-manager.js";
import {
@@ -183,7 +186,7 @@ import {
type RlmUsage,
type SubagentRuntimeHost,
} from "./rlm-runtime.js";
-import type { BranchSummaryEntry, CompactionEntry, SessionMessageEntry } from "./session-manager.js";
+import type { BranchSummaryEntry, CompactionEntry, SessionContext, SessionMessageEntry } from "./session-manager.js";
import {
CURRENT_SESSION_VERSION,
getLatestCompactionEntry,
@@ -239,6 +242,7 @@ export type CompactionReason = "manual" | "threshold" | "overflow" | "requested"
/** Session-specific events that extend the core AgentEvent */
export type AgentSessionEvent =
| AgentEvent
+ | { type: "ipython_sent_agent_message"; toolCallId: string; message: KernelSentAgentMessage }
| {
type: "queue_update";
steering: readonly string[];
@@ -405,6 +409,7 @@ export interface PromptOptions {
skipInputHandlers?: boolean;
agentMessageId?: string;
content?: (TextContent | ImageContent)[];
+ customMessage?: CustomMessage;
}
interface InternalPromptOptions extends PromptOptions {
@@ -488,6 +493,71 @@ function queuedMessagePreview(message: { text: string; previewLabel?: string }):
return message.previewLabel ? `${message.previewLabel}: ${message.text}` : message.text;
}
+function queuedAgentMessagePreview(message: QueuedSteeringMessage | QueuedFollowUpMessage): string {
+ if (isAgentSessionMessage(message.message)) {
+ return `${AGENT_MESSAGE_RECEIVED_PREVIEW_LABEL}: ${message.message.details.message}`;
+ }
+ return queuedMessagePreview(message);
+}
+
+const IPYTHON_SENT_AGENT_MESSAGE_CUSTOM_ENTRY = "ipython_sent_agent_message";
+
+interface PersistedIpythonSentAgentMessage {
+ toolCallId: string;
+ message: KernelSentAgentMessage;
+}
+
+function isObjectRecord(value: unknown): value is Record<string, unknown> {
+ return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function parsePersistedIpythonSentAgentMessage(value: unknown): PersistedIpythonSentAgentMessage | undefined {
+ if (!isObjectRecord(value) || typeof value.toolCallId !== "string" || !isObjectRecord(value.message)) {
+ return undefined;
+ }
+ const { id, message, deliveryStatus, target } = value.message;
+ if (
+ typeof id !== "string" ||
+ typeof message !== "string" ||
+ (deliveryStatus !== "delivered" && deliveryStatus !== "queued") ||
+ !isObjectRecord(target) ||
+ typeof target.activeSessionId !== "string" ||
+ typeof target.sessionId !== "string"
+ ) {
+ return undefined;
+ }
+ return {
+ toolCallId: value.toolCallId,
+ message: {
+ id,
+ message,
+ deliveryStatus,
+ target: {
+ activeSessionId: target.activeSessionId,
+ sessionId: target.sessionId,
+ ...(typeof target.sessionName === "string" ? { sessionName: target.sessionName } : {}),
+ },
+ },
+ };
+}
+
+function appendSentAgentMessageToToolResult(
+ message: AgentMessage,
+ toolCallId: string,
+ sentMessage: KernelSentAgentMessage,
+): boolean {
+ if (message.role !== "toolResult" || message.toolName !== "ipython" || message.toolCallId !== toolCallId) {
+ return false;
+ }
+ const details = isObjectRecord(message.details) ? message.details : {};
+ const current = Array.isArray(details.sentAgentMessages) ? details.sentAgentMessages : [];
+ if (current.some((entry) => isObjectRecord(entry) && entry.id === sentMessage.id)) {
+ return true;
+ }
+ message.details = { ...details, sentAgentMessages: [...current, sentMessage] };
+ return true;
+}
+
function injectedMessagePreviewLabel(message: CustomMessage): string | undefined {
switch (message.customType) {
case HEARTBEAT_PROMPT_CUSTOM_TYPE:
@@ -502,7 +572,7 @@ function injectedMessagePreviewLabel(message: CustomMessage): string | undefined
interface AcceptedAgentMessagePrompt {
text: string;
agentMessageId: string;
- message: UserMessage;
+ message: QueuedAgentMessage;
messages: Set<AgentMessage>;
/** Pending nextTurn messages drained into this prompt; restored to the queue if the prompt is cleared. */
pendingNextTurnMessages: CustomMessage[];
@@ -702,6 +772,7 @@ export class AgentSession {
private _agentMessageDeliveryWaiters = new Map<string, AgentMessageDeliveryWaiter>();
private _deliveredAgentMessageIds = new Set<string>();
private _failedAgentMessageDeliveries = new Map<string, Error>();
+ private _lateIpythonSentAgentMessages = new Map<string, KernelSentAgentMessage[]>();
// Bash execution state
private _bashAbortController: AbortController | undefined = undefined;
@@ -820,6 +891,7 @@ export class AgentSession {
this._rlmParentNodeId = config.rlmParentNodeId;
this._subagentRuntimeHost = config.subagentRuntimeHost;
this._goalState = this._loadPersistedGoalState();
+ this._restoreLateIpythonSentAgentMessages();
if (this._goalState.status === "active") {
this._goalAccountingStartedAt = Date.now();
}
@@ -950,11 +1022,60 @@ export class AgentSession {
private _emitQueueUpdate(): void {
this._emit({
type: "queue_update",
- steering: this._steeringMessages.map(queuedMessagePreview),
- followUp: this._followUpMessages.map(queuedMessagePreview),
+ steering: this._steeringMessages.map(queuedAgentMessagePreview),
+ followUp: this._followUpMessages.map(queuedAgentMessagePreview),
});
}
+ private _restoreLateIpythonSentAgentMessages(): void {
+ this._lateIpythonSentAgentMessages.clear();
+ for (const entry of this.sessionManager.getBranch()) {
+ if (entry.type !== "custom" || entry.customType !== IPYTHON_SENT_AGENT_MESSAGE_CUSTOM_ENTRY) {
+ continue;
+ }
+ const persisted = parsePersistedIpythonSentAgentMessage(entry.data);
+ if (persisted) {
+ this._rememberLateIpythonSentAgentMessage(persisted.toolCallId, persisted.message);
+ }
+ }
+ }
+
+ private _rememberLateIpythonSentAgentMessage(toolCallId: string, message: KernelSentAgentMessage): boolean {
+ const messages = this._lateIpythonSentAgentMessages.get(toolCallId) ?? [];
+ const isNew = !messages.some((entry) => entry.id === message.id);
+ if (isNew) {
+ messages.push(message);
+ this._lateIpythonSentAgentMessages.set(toolCallId, messages);
+ }
+ for (let index = this.agent.state.messages.length - 1; index >= 0; index -= 1) {
+ if (appendSentAgentMessageToToolResult(this.agent.state.messages[index], toolCallId, message)) {
+ break;
+ }
+ }
+ return isNew;
+ }
+
+ private _applyLateIpythonSentAgentMessages(message: AgentMessage): void {
+ if (message.role !== "toolResult" || message.toolName !== "ipython") {
+ return;
+ }
+ for (const sentMessage of this._lateIpythonSentAgentMessages.get(message.toolCallId) ?? []) {
+ appendSentAgentMessageToToolResult(message, message.toolCallId, sentMessage);
+ }
+ }
+
+ private _recordLateIpythonSentAgentMessage(toolCallId: string, message: KernelSentAgentMessage): void {
+ const record = () => {
+ if (this._disposed || !this._rememberLateIpythonSentAgentMessage(toolCallId, message)) {
+ return;
+ }
+ this.sessionManager.appendCustomEntry(IPYTHON_SENT_AGENT_MESSAGE_CUSTOM_ENTRY, { toolCallId, message });
+ this._emit({ type: "ipython_sent_agent_message", toolCallId, message });
+ };
+ this._agentEventQueue = this._agentEventQueue.then(record, record);
+ this._agentEventQueue.catch(() => {});
+ }
+
private _emitGoalUpdate(): void {
this._emit({ type: "goal_update", goal: this.goalState });
}
@@ -1811,6 +1932,9 @@ export class AgentSession {
}
private async _processAgentEvent(event: AgentEvent): Promise<void> {
+ if ((event.type === "message_start" || event.type === "message_end") && event.message.role === "toolResult") {
+ this._applyLateIpythonSentAgentMessages(event.message);
+ }
const acceptedPrompt = this._acceptedAgentMessagePrompt;
if (acceptedPrompt && (event.type === "message_start" || event.type === "message_end")) {
if (event.message === acceptedPrompt.message) {
@@ -1988,7 +2112,9 @@ export class AgentSession {
private _isPromptTurnStartMessage(message: AgentMessage): boolean {
return (
- message.role === "user" || (message.role === "custom" && message.customType === HEARTBEAT_PROMPT_CUSTOM_TYPE)
+ message.role === "user" ||
+ isAgentSessionMessage(message) ||
+ (message.role === "custom" && message.customType === HEARTBEAT_PROMPT_CUSTOM_TYPE)
);
}
@@ -2324,6 +2450,14 @@ export class AgentSession {
return this.agent.state.messages;
}
+ buildSessionContext(): SessionContext {
+ const context = this.sessionManager.buildSessionContext();
+ for (const message of context.messages) {
+ this._applyLateIpythonSentAgentMessages(message);
+ }
+ return context;
+ }
+
/** Current steering mode */
get steeringMode(): "all" | "one-at-a-time" {
return this.agent.steeringMode;
@@ -2449,23 +2583,30 @@ export class AgentSession {
}
async acceptAgentMessagePrompt(text: string, options?: PromptOptions): Promise<void> {
+ const customMessage =
+ options?.customMessage && isAgentSessionMessage(options.customMessage) ? options.customMessage : undefined;
return this._prompt(text, {
...options,
expandPromptTemplates: false,
skipInputHandlers: true,
skipPrePromptWork: true,
returnAfterAccepted: true,
- agentMessageId: options?.agentMessageId ?? parseAgentSessionMessagePromptId(text),
+ agentMessageId: options?.agentMessageId ?? customMessage?.details.id ?? parseAgentSessionMessagePromptId(text),
+ customMessage,
});
}
- async queueAgentMessagePrompt(text: string, streamingBehavior: "steer" | "followUp"): Promise<boolean> {
- const agentMessageId = parseAgentSessionMessagePromptId(text);
+ async queueAgentMessagePrompt(
+ text: string,
+ streamingBehavior: "steer" | "followUp",
+ customMessage?: AgentSessionMessage,
+ ): Promise<boolean> {
+ const agentMessageId = customMessage?.details.id ?? parseAgentSessionMessagePromptId(text);
if (streamingBehavior === "steer") {
- await this._queueSteer(text, undefined, { agentMessageId });
+ await this._queueSteer(text, undefined, { agentMessageId, message: customMessage });
return true;
}
- return this._queueFollowUp(text, undefined, { agentMessageId });
+ return this._queueFollowUp(text, undefined, { agentMessageId, message: customMessage });
}
async promptHeartbeat(job: AgentCronJob, options?: PromptOptions): Promise<void> {
@@ -2715,6 +2856,7 @@ export class AgentSession {
{
queueKey: options.followUpQueueKey,
agentMessageId: options.agentMessageId,
+ customMessage: options.customMessage,
},
);
if (!queued) {
@@ -2763,12 +2905,14 @@ export class AgentSession {
if (!options?.content && currentImages) {
userContent.push(...currentImages);
}
- const userMessage: AgentMessage = {
- role: "user",
- content: userContent,
- timestamp: Date.now(),
- };
- messages.push(userMessage);
+ const promptMessage: QueuedAgentMessage = options.customMessage
+ ? cloneCustomMessage(options.customMessage)
+ : {
+ role: "user",
+ content: userContent,
+ timestamp: Date.now(),
+ };
+ messages.push(promptMessage);
if (options.agentMessageId !== undefined && options.returnAfterAccepted) {
let resolveAccepted = () => {};
let rejectAccepted = (_error: Error) => {};
@@ -2779,8 +2923,8 @@ export class AgentSession {
acceptedAgentMessagePrompt = {
text: expandedText,
agentMessageId: options.agentMessageId,
- message: userMessage,
- messages: new Set<AgentMessage>([...drainedNextTurnMessages, userMessage]),
+ message: promptMessage,
+ messages: new Set<AgentMessage>([...drainedNextTurnMessages, promptMessage]),
pendingNextTurnMessages: drainedNextTurnMessages,
deliveredPendingNextTurnMessages: new Set(),
accepted,
@@ -2807,19 +2951,21 @@ export class AgentSession {
}
this._pendingNextTurnMessages = [];
- // Add user message
- const userContent: (TextContent | ImageContent)[] = options?.content
- ? options.content.map((block) => ({ ...block }))
- : [{ type: "text", text: expandedText }];
- if (!options?.content && currentImages) {
- userContent.push(...currentImages);
+ if (options?.customMessage) {
+ messages.push(cloneCustomMessage(options.customMessage));
+ } else {
+ const userContent: (TextContent | ImageContent)[] = options?.content
+ ? options.content.map((block) => ({ ...block }))
+ : [{ type: "text", text: expandedText }];
+ if (!options?.content && currentImages) {
+ userContent.push(...currentImages);
+ }
+ messages.push({
+ role: "user",
+ content: userContent,
+ timestamp: Date.now(),
+ });
}
- const userMessage: AgentMessage = {
- role: "user",
- content: userContent,
- timestamp: Date.now(),
- };
- messages.push(userMessage);
// Emit before_agent_start extension event
const result = await this._extensionRunner.emitBeforeAgentStart(
@@ -2902,6 +3048,7 @@ export class AgentSession {
{
queueKey: options.followUpQueueKey,
agentMessageId: options.agentMessageId,
+ customMessage: options.customMessage,
},
);
if (!queued) {
@@ -3147,14 +3294,16 @@ export class AgentSession {
text: string,
images: ImageContent[] | undefined,
streamingBehavior: "steer" | "followUp",
- options: { queueKey?: string; agentMessageId?: string } = {},
+ options: { queueKey?: string; agentMessageId?: string; customMessage?: CustomMessage } = {},
): Promise<boolean> {
const pendingNextTurnMessages = this._pendingNextTurnMessages;
this._pendingNextTurnMessages = [];
try {
if (streamingBehavior === "followUp") {
const queued = await this._queueFollowUp(text, images, {
- ...options,
+ queueKey: options.queueKey,
+ agentMessageId: options.agentMessageId,
+ message: options.customMessage,
prefixMessages: pendingNextTurnMessages,
});
if (!queued) {
@@ -3165,6 +3314,7 @@ export class AgentSession {
await this._queueSteer(text, images, {
agentMessageId: options.agentMessageId,
queueKey: options.queueKey,
+ message: options.customMessage,
prefixMessages: pendingNextTurnMessages,
});
return true;
@@ -3414,12 +3564,10 @@ export class AgentSession {
if (steering.length === 0 && followUp.length === 0 && !acceptedMatches) {
return { steering: [], followUp: [] };
}
- const steeringToRemove = new Set(steering.map((message) => message.message));
- const followUpToRemove = new Set(followUp.map((message) => message.message));
+ const steeringToRemove = new Set<AgentMessage>(steering.map((message) => message.message));
+ const followUpToRemove = new Set<AgentMessage>(followUp.map((message) => message.message));
const removedQueuedMessages = new Set(
- this.agent.removeQueuedMessages(
- (message) => message.role === "user" && (steeringToRemove.has(message) || followUpToRemove.has(message)),
- ),
+ this.agent.removeQueuedMessages((message) => steeringToRemove.has(message) || followUpToRemove.has(message)),
);
const removedSteeringMessages = steering.filter((message) => removedQueuedMessages.has(message.message));
const removedFollowUpMessages = followUp.filter((message) => removedQueuedMessages.has(message.message));
@@ -3473,7 +3621,7 @@ export class AgentSession {
}
getSteeringMessagePreviews(): readonly string[] {
- return this._steeringMessages.map(queuedMessagePreview);
+ return this._steeringMessages.map(queuedAgentMessagePreview);
}
/** Get pending follow-up messages (read-only) */
@@ -3482,7 +3630,7 @@ export class AgentSession {
}
getFollowUpMessagePreviews(): readonly string[] {
- return this._followUpMessages.map(queuedMessagePreview);
+ return this._followUpMessages.map(queuedAgentMessagePreview);
}
getSteeringQueueSnapshots(): readonly QueuedAgentInputSnapshot[] {
@@ -4098,6 +4246,7 @@ export class AgentSession {
);
const newEntries = this.sessionManager.getEntries();
this.agent.state.messages = this.sessionManager.buildSessionContext().messages;
+ this._restoreLateIpythonSentAgentMessages();
// Get the saved compaction entry for the extension event
const savedCompactionEntry = newEntries.find((e) => e.type === "compaction" && e.summary === summary) as
@@ -5177,6 +5326,8 @@ export class AgentSession {
provisioner: this._ipythonKernelProvisioner,
commandPrefix: this.settingsManager.getShellCommandPrefix(),
shellPath: this.settingsManager.getShellPath(),
+ onLateSentAgentMessage: (toolCallId, message) =>
+ this._recordLateIpythonSentAgentMessage(toolCallId, message),
},
});
}
@@ -6704,6 +6855,7 @@ export class AgentSession {
// Update agent state
const sessionContext = this.sessionManager.buildSessionContext();
this.agent.state.messages = sessionContext.messages;
+ this._restoreLateIpythonSentAgentMessages();
this._reloadGoalStateFromBranch();
// Emit session_tree event
diff --git a/packages/coding-agent/src/core/kernel/index.ts b/packages/coding-agent/src/core/kernel/index.ts
index c3b0bd900d..e05bf44bdf 100644
--- a/packages/coding-agent/src/core/kernel/index.ts
+++ b/packages/coding-agent/src/core/kernel/index.ts
@@ -41,6 +41,7 @@ const SNAPSHOT_DISPOSE_TIMEOUT_MS = 5000;
const KERNEL_ABORT_GRACE_MS = 1000;
const KERNEL_BUSY_REUSE_WAIT_MS = 5000;
const KERNEL_BUSY_INTERRUPT_INTERVAL_MS = 500;
+const MAX_LATE_SENT_AGENT_MESSAGE_HANDLERS = 256;
const KERNEL_BUSY_AFTER_INTERRUPT_MESSAGE =
"IPython kernel is still running the previously interrupted cell. Wait and try again, or kill the IPython kernel to start fresh.";
@@ -98,6 +99,7 @@ export interface ExecuteOptions {
/** Aborting interrupts the kernel via the control channel. */
signal?: AbortSignal;
onStream?: (chunk: string, name: "stdout" | "stderr") => void;
+ onLateSentAgentMessage?: (message: KernelSentAgentMessage) => void;
/** Cap stdout / stderr / result at this many characters. Default 65536. */
maxOutputChars?: number;
/** Synthetic host cell (snapshot/restore/list); excluded from lastCellCode attribution. */
@@ -110,6 +112,9 @@ export const DIFF_DISPLAY_MIME = "application/vnd.prime-agent.diff+json";
/** MIME tag the `attach-image` skill emits media payloads under, via `display_data`. */
export const ATTACHMENT_DISPLAY_MIME = "application/vnd.prime-agent.attachment+json";
+/** MIME tag the `agent-message` skill emits after sending a message. */
+export const AGENT_MESSAGE_DISPLAY_MIME = "application/vnd.prime-agent.agent-message+json";
+
/**
* Hard ceiling on a single attachment's base64 payload, a defensive guard
* against a runaway direct `display_data` emit. The `attach-image` skill caps
@@ -136,6 +141,17 @@ export interface KernelAttachment {
path?: string;
}
+export interface KernelSentAgentMessage {
+ id: string;
+ message: string;
+ deliveryStatus: "delivered" | "queued";
+ target: {
+ activeSessionId: string;
+ sessionId: string;
+ sessionName?: string;
+ };
+}
+
export interface ExecuteResult {
stdout: string;
stderr: string;
@@ -145,6 +161,8 @@ export interface ExecuteResult {
diffs?: KernelDiffDisplay[];
/** Media attachments emitted via display_data, in order. */
attachments?: KernelAttachment[];
+ /** Agent messages sent from this cell, in order. */
+ sentAgentMessages?: KernelSentAgentMessage[];
status: "ok" | "error" | "aborted";
error?: { ename: string; evalue: string; traceback: string[] };
durationMs: number;
@@ -182,6 +200,33 @@ function parseAttachmentDisplay(payload: unknown): KernelAttachment | "oversized
return { mimeType, data, path: typeof path === "string" ? path : undefined };
}
+function parseSentAgentMessage(payload: unknown): KernelSentAgentMessage | undefined {
+ if (!isRecord(payload) || !isRecord(payload.target)) {
+ return undefined;
+ }
+ const { id, message, deliveryStatus, target } = payload;
+ const { activeSessionId, sessionId, sessionName } = target;
+ if (
+ typeof id !== "string" ||
+ typeof message !== "string" ||
+ (deliveryStatus !== "delivered" && deliveryStatus !== "queued") ||
+ typeof activeSessionId !== "string" ||
+ typeof sessionId !== "string"
+ ) {
+ return undefined;
+ }
+ return {
+ id,
+ message,
+ deliveryStatus,
+ target: {
+ activeSessionId,
+ sessionId,
+ ...(typeof sessionName === "string" ? { sessionName } : {}),
+ },
+ };
+}
+
function createKernelStartupAbortError(): Error {
return new Error("Kernel startup aborted");
}
@@ -267,8 +312,10 @@ interface ActiveExecution {
result?: string;
diffs: KernelDiffDisplay[];
attachments: KernelAttachment[];
+ sentAgentMessages: KernelSentAgentMessage[];
error?: ExecuteResult["error"];
status: ExecuteResult["status"];
+ settled: boolean;
resolve: (result: ExecuteResult) => void;
reject: (error: Error) => void;
}
@@ -485,6 +532,7 @@ export class KernelManager {
private executionQueue: Promise<unknown> = Promise.resolve();
private activeExecution?: ActiveExecution;
private readonly activeExecutionIdleWaiters = new Set<() => void>();
+ private readonly lateSentAgentMessageHandlers = new Map<string, (message: KernelSentAgentMessage) => void>();
// Source of the most recently started cell, retained after it finishes so
// rlm.run spawns from detached asyncio tasks (cell already idle) can still
// attribute their spawning program.
@@ -832,7 +880,9 @@ export class KernelManager {
stderrTruncated: false,
diffs: [],
attachments: [],
+ sentAgentMessages: [],
status: "ok",
+ settled: false,
resolve: result.resolve,
reject: result.reject,
};
@@ -926,14 +976,22 @@ export class KernelManager {
private handleExecutionMessage(incoming: JupyterMessage): void {
const execution = this.activeExecution;
- if (!execution) {
- return;
- }
- if ((incoming.parent_header as { msg_id?: string }).msg_id !== execution.requestMsgId) {
+ const parentMessageId = (incoming.parent_header as { msg_id?: string }).msg_id;
+ if (!execution || parentMessageId !== execution.requestMsgId) {
+ if (incoming.header.msg_type === "display_data" || incoming.header.msg_type === "update_display_data") {
+ const content = incoming.content as { data?: Record<string, unknown> };
+ this.dispatchLateSentAgentMessage(parentMessageId, content.data?.[AGENT_MESSAGE_DISPLAY_MIME]);
+ }
return;
}
const t = incoming.header.msg_type;
+ if (execution.settled && (t === "display_data" || t === "update_display_data")) {
+ const content = incoming.content as { data?: Record<string, unknown> };
+ if (this.dispatchLateSentAgentMessage(parentMessageId, content.data?.[AGENT_MESSAGE_DISPLAY_MIME])) {
+ return;
+ }
+ }
if (t === "stream") {
const c = incoming.content as { name: "stdout" | "stderr"; text: string };
if (c.name === "stdout") {
@@ -968,6 +1026,8 @@ export class KernelManager {
} else if (attachment) {
execution.attachments.push(attachment);
}
+ const sentAgentMessage = parseSentAgentMessage(c.data?.[AGENT_MESSAGE_DISPLAY_MIME]);
+ if (sentAgentMessage) execution.sentAgentMessages.push(sentAgentMessage);
} else if (t === "error") {
const c = incoming.content as { ename: string; evalue: string; traceback: string[] };
execution.error = c;
@@ -992,34 +1052,70 @@ export class KernelManager {
if (options.clearActive && this.activeExecution === execution) {
this.activeExecution = undefined;
}
+ if (!execution.settled) {
+ execution.settled = true;
+ if (execution.opts.onLateSentAgentMessage) {
+ this.registerLateSentAgentMessageHandler(execution.requestMsgId, execution.opts.onLateSentAgentMessage);
+ }
- let stdout = execution.stdout;
- let stderr = execution.stderr;
- let result = execution.result;
- let status = execution.status;
- if (execution.stdoutTruncated) stdout += `\n[... output truncated at ${execution.maxChars} chars ...]`;
- if (execution.stderrTruncated) stderr += `\n[... output truncated at ${execution.maxChars} chars ...]`;
- if (result !== undefined && result.length > execution.maxChars) {
- result = `${result.slice(0, execution.maxChars)}\n[... output truncated at ${execution.maxChars} chars ...]`;
- }
+ let stdout = execution.stdout;
+ let stderr = execution.stderr;
+ let result = execution.result;
+ let status = execution.status;
+ if (execution.stdoutTruncated) stdout += `\n[... output truncated at ${execution.maxChars} chars ...]`;
+ if (execution.stderrTruncated) stderr += `\n[... output truncated at ${execution.maxChars} chars ...]`;
+ if (result !== undefined && result.length > execution.maxChars) {
+ result = `${result.slice(0, execution.maxChars)}\n[... output truncated at ${execution.maxChars} chars ...]`;
+ }
- if (execution.opts.signal?.aborted) status = "aborted";
-
- execution.resolve({
- stdout,
- stderr,
- result,
- diffs: execution.diffs.length > 0 ? execution.diffs : undefined,
- attachments: execution.attachments.length > 0 ? execution.attachments : undefined,
- error: execution.error,
- status,
- durationMs: Date.now() - execution.started,
- });
+ if (execution.opts.signal?.aborted) status = "aborted";
+
+ execution.resolve({
+ stdout,
+ stderr,
+ result,
+ diffs: execution.diffs.length > 0 ? execution.diffs : undefined,
+ attachments: execution.attachments.length > 0 ? execution.attachments : undefined,
+ sentAgentMessages: execution.sentAgentMessages.length > 0 ? execution.sentAgentMessages : undefined,
+ error: execution.error,
+ status,
+ durationMs: Date.now() - execution.started,
+ });
+ }
if (didClearActive) {
this.notifyActiveExecutionIdle();
}
}
+ private dispatchLateSentAgentMessage(parentMessageId: string | undefined, value: unknown): boolean {
+ const sentAgentMessage = parseSentAgentMessage(value);
+ if (!sentAgentMessage || !parentMessageId) {
+ return false;
+ }
+ const handler = this.lateSentAgentMessageHandlers.get(parentMessageId);
+ if (!handler) {
+ return false;
+ }
+ this.lateSentAgentMessageHandlers.delete(parentMessageId);
+ this.lateSentAgentMessageHandlers.set(parentMessageId, handler);
+ handler(sentAgentMessage);
+ return true;
+ }
+
+ private registerLateSentAgentMessageHandler(
+ requestMessageId: string,
+ handler: (message: KernelSentAgentMessage) => void,
+ ): void {
+ this.lateSentAgentMessageHandlers.set(requestMessageId, handler);
+ while (this.lateSentAgentMessageHandlers.size > MAX_LATE_SENT_AGENT_MESSAGE_HANDLERS) {
+ const oldestRequestMessageId = this.lateSentAgentMessageHandlers.keys().next().value;
+ if (oldestRequestMessageId === undefined) {
+ break;
+ }
+ this.lateSentAgentMessageHandlers.delete(oldestRequestMessageId);
+ }
+ }
+
private rejectActiveExecution(error: Error): void {
const execution = this.activeExecution;
if (!execution) {
@@ -1189,6 +1285,7 @@ export class KernelManager {
private cleanupResources(killSignal: NodeJS.Signals = "SIGTERM"): void {
this.clearSnapshotTimer();
+ this.lateSentAgentMessageHandlers.clear();
if (this.forkedLivenessTimer) {
globalThis.clearInterval(this.forkedLivenessTimer);
this.forkedLivenessTimer = undefined;
diff --git a/packages/coding-agent/src/core/tools/ipython.ts b/packages/coding-agent/src/core/tools/ipython.ts
index 78a0ae6b19..a58407d732 100644
--- a/packages/coding-agent/src/core/tools/ipython.ts
+++ b/packages/coding-agent/src/core/tools/ipython.ts
@@ -14,6 +14,7 @@ import {
KernelBusyAfterInterruptError,
type KernelDiffDisplay,
KernelManager,
+ type KernelSentAgentMessage,
} from "../kernel/index.js";
import { manifestPathIn, type RestoreResult, snapshotPathIn } from "../kernel/state-snapshot.js";
import type { PythonSkillRuntimeInfo } from "../skills.js";
@@ -239,6 +240,8 @@ export interface IpythonToolDetails {
diffs?: KernelDiffDisplay[];
/** Media attachments loaded into context (e.g. by the attach-image skill). */
attachments?: KernelAttachment[];
+ /** Agent messages sent from this cell. */
+ sentAgentMessages?: KernelSentAgentMessage[];
/** True when this result came after killing and restarting a busy kernel. */
kernelRestarted?: boolean;
error?: {
@@ -272,6 +275,7 @@ export interface IpythonToolOptions {
* (some names restored or some failed), so the session can tell the model.
*/
onRestore?: (result: RestoreResult) => void;
+ onLateSentAgentMessage?: (toolCallId: string, message: KernelSentAgentMessage) => void;
/** Shared provisioner owning the kernel lifecycle. When provided, the remaining options are ignored. */
provisioner?: IpythonKernelProvisioner;
}
@@ -546,17 +550,28 @@ async function chooseBusyKernelAction(
async function executeWithBusyKernelChoice(
provisioner: IpythonKernelProvisioner,
reportStartupProgress: KernelBootstrapProgressHandler,
+ toolCallId: string,
code: string,
signal: AbortSignal | undefined,
onStream: (chunk: string, name: "stdout" | "stderr") => void,
onWorkingMessage: (message?: string) => void,
+ onLateSentAgentMessage: ((toolCallId: string, message: KernelSentAgentMessage) => void) | undefined,
ctx: ExtensionContext | undefined,
): Promise<{ result: ExecuteResult; kernelRestarted: boolean }> {
let kernelRestarted = false;
while (true) {
const m = await provisioner.ensure(reportStartupProgress, signal);
try {
- return { result: await m.execute(code, { signal, onStream }), kernelRestarted };
+ return {
+ result: await m.execute(code, {
+ signal,
+ onStream,
+ onLateSentAgentMessage: onLateSentAgentMessage
+ ? (message) => onLateSentAgentMessage(toolCallId, message)
+ : undefined,
+ }),
+ kernelRestarted,
+ };
} catch (error) {
if (!(error instanceof KernelBusyAfterInterruptError) || signal?.aborted) {
throw error;
@@ -600,7 +615,7 @@ export function createIpythonToolDefinition(
// The kernel is single-threaded — pi must not run two ipython calls in parallel within a batch.
executionMode: "sequential",
parameters: ipythonSchema,
- execute: async (_toolCallId, params, signal, onUpdate, ctx) => {
+ execute: async (toolCallId, params, signal, onUpdate, ctx) => {
let hasWorkingMessage = false;
const setToolWorkingMessage = (message?: string) => {
setWorkingMessage(ctx, message);
@@ -619,6 +634,7 @@ export function createIpythonToolDefinition(
const { result: r, kernelRestarted } = await executeWithBusyKernelChoice(
provisioner,
reportStartupProgress,
+ toolCallId,
code,
signal,
(chunk) => {
@@ -628,6 +644,7 @@ export function createIpythonToolDefinition(
});
},
setToolWorkingMessage,
+ options?.onLateSentAgentMessage,
ctx,
);
@@ -655,6 +672,7 @@ export function createIpythonToolDefinition(
result: r.result,
diffs: r.diffs,
attachments: r.attachments,
+ sentAgentMessages: r.sentAgentMessages,
kernelRestarted,
error: r.error,
},
diff --git a/packages/coding-agent/src/index.ts b/packages/coding-agent/src/index.ts
index 749baa0a88..9c0e1e8cc2 100644
--- a/packages/coding-agent/src/index.ts
+++ b/packages/coding-agent/src/index.ts
@@ -334,6 +334,7 @@ export {
} from "./modes/index.js";
// UI components for extensions
export {
+ AgentMessageComponent,
ArminComponent,
AssistantMessageComponent,
BashExecutionComponent,
diff --git a/packages/coding-agent/src/modes/agent-connection/in-process-agent-connection.ts b/packages/coding-agent/src/modes/agent-connection/in-process-agent-connection.ts
index 0c2aa61d51..9f7ba42f34 100644
--- a/packages/coding-agent/src/modes/agent-connection/in-process-agent-connection.ts
+++ b/packages/coding-agent/src/modes/agent-connection/in-process-agent-connection.ts
@@ -121,7 +121,7 @@ export class InProcessAgentConnection implements AgentConnection {
}
async getSessionContext(): Promise<AgentConnectionSessionContext> {
- return this.session.sessionManager.buildSessionContext();
+ return this.session.buildSessionContext();
}
async getSessionTree(): Promise<{ tree: AgentConnectionSessionTreeNode[]; leafId: string | null }> {
diff --git a/packages/coding-agent/src/modes/agent-connection/snapshot.ts b/packages/coding-agent/src/modes/agent-connection/snapshot.ts
index 79e7e247b0..511ae2d3da 100644
--- a/packages/coding-agent/src/modes/agent-connection/snapshot.ts
+++ b/packages/coding-agent/src/modes/agent-connection/snapshot.ts
@@ -67,7 +67,7 @@ export function createAgentConnectionSnapshot(
return {
state: createAgentConnectionState(runtime, activeSessionId),
messages: [...session.messages],
- sessionContext: sessionManager.buildSessionContext(),
+ sessionContext: session.buildSessionContext(),
sessionTree: {
tree: sessionManager.getTree(),
leafId: sessionManager.getLeafId(),
diff --git a/packages/coding-agent/src/modes/agent-connection/types.ts b/packages/coding-agent/src/modes/agent-connection/types.ts
index 69b4f4e202..5d7398a128 100644
--- a/packages/coding-agent/src/modes/agent-connection/types.ts
+++ b/packages/coding-agent/src/modes/agent-connection/types.ts
@@ -6,6 +6,7 @@ import type { ContextTreeNode } from "../../core/context-tree.js";
import type { AgentCronJob, AgentHeartbeatDeliveryMode, AgentHeartbeatUpdateAction } from "../../core/cron-jobs.js";
import type { ReplayBuiltInToolName } from "../../core/extensions/index.js";
import type { GoalState } from "../../core/goals.js";
+import type { KernelSentAgentMessage } from "../../core/kernel/index.js";
import type { RefinementResult } from "../../core/refinement/index.js";
import type { DeleteSessionFileResult } from "../../core/session-file-actions.js";
import type { SessionStats } from "../../core/session-stats.js";
@@ -464,6 +465,7 @@ export interface AgentConnectionRlmChildAgentSnapshot {
export type AgentConnectionSessionEvent =
| AgentEvent
+ | { type: "ipython_sent_agent_message"; toolCallId: string; message: KernelSentAgentMessage }
| {
type: "queue_update";
steering: readonly string[];
diff --git a/packages/coding-agent/src/modes/daemon/daemon-mode.ts b/packages/coding-agent/src/modes/daemon/daemon-mode.ts
index 8c37a0785a..68ac8258b1 100644
--- a/packages/coding-agent/src/modes/daemon/daemon-mode.ts
+++ b/packages/coding-agent/src/modes/daemon/daemon-mode.ts
@@ -29,8 +29,8 @@ import {
type AgentSessionMessageSender,
assertAgentMessageQueueCapacity,
assertDirectAgentMessageTarget,
+ createAgentSessionMessage,
createAgentSessionMessageId,
- createAgentSessionMessagePrompt,
createAgentSessionMessageReceipt,
DEFAULT_AGENT_MESSAGE_MAX_CHARS,
DEFAULT_AGENT_MESSAGE_MAX_PENDING_PER_SESSION,
@@ -1637,6 +1637,7 @@ export class AgentDaemon {
streamingBehavior: command.streamingBehavior,
expandPromptTemplates: command.expandPromptTemplates,
agentMessageId: command.agentMessageId,
+ customMessage: command.customMessage,
skipInputHandlers: command.expandPromptTemplates === false ? true : undefined,
source: "rpc",
preflightResult: (didSucceed) => {
@@ -2153,7 +2154,7 @@ export class AgentDaemon {
case "get_session_context": {
const state = this.getSessionState(command.activeSessionId);
return success(command.id, "get_session_context", {
- context: state.runtime.session.sessionManager.buildSessionContext(),
+ context: state.runtime.session.buildSessionContext(),
});
}
@@ -2502,10 +2503,11 @@ export class AgentDaemon {
const streamingBehavior =
resolveAgentSessionMessageStreamingBehavior(shouldQueue, payload.deliveryMode) ??
(payload.deliveryMode === "follow_up" ? "followUp" : "steer");
- const prompt = createAgentSessionMessagePrompt(payload);
+ const message = createAgentSessionMessage(payload);
+ const prompt = message.content;
if (shouldQueue) {
- const didQueue = await session.queueAgentMessagePrompt(prompt, streamingBehavior);
+ const didQueue = await session.queueAgentMessagePrompt(prompt, streamingBehavior, message);
if (!didQueue) {
throw new Error("Agent message was not queued");
}
@@ -2521,11 +2523,7 @@ export class AgentDaemon {
let preflightFailed = false;
let preflightQueued = false;
try {
- const acceptPrompt =
- typeof session.acceptAgentMessagePrompt === "function"
- ? session.acceptAgentMessagePrompt.bind(session)
- : session.prompt.bind(session);
- await acceptPrompt(prompt, {
+ const promptOptions: PromptOptions = {
expandPromptTemplates: false,
streamingBehavior,
queueIfBusy: true,
@@ -2533,7 +2531,12 @@ export class AgentDaemon {
preflightFailed = !didSucceed;
preflightQueued = didSucceed && didQueue === true;
},
- });
+ };
+ if (typeof session.acceptAgentMessagePrompt === "function") {
+ await session.acceptAgentMessagePrompt(prompt, { ...promptOptions, customMessage: message });
+ } else {
+ await session.prompt(prompt, promptOptions);
+ }
if (preflightFailed) {
throw new Error("Agent message was not accepted");
}
@@ -2621,6 +2624,7 @@ export class AgentDaemon {
message: acceptedPrompt.text,
...(acceptedPrompt.content ? { content: acceptedPrompt.content } : {}),
...(acceptedPrompt.images ? { images: acceptedPrompt.images } : {}),
+ ...(acceptedPrompt.customMessage ? { customMessage: acceptedPrompt.customMessage } : {}),
agentMessageId: acceptedPrompt.agentMessageId,
nextTurn: acceptedPrompt.nextTurn,
},
diff --git a/packages/coding-agent/src/modes/daemon/daemon-protocol.ts b/packages/coding-agent/src/modes/daemon/daemon-protocol.ts
index 058db840c4..d08b246312 100644
--- a/packages/coding-agent/src/modes/daemon/daemon-protocol.ts
+++ b/packages/coding-agent/src/modes/daemon/daemon-protocol.ts
@@ -278,6 +278,7 @@ export type DaemonCommand =
streamingBehavior?: "steer" | "followUp";
expandPromptTemplates?: boolean;
agentMessageId?: string;
+ customMessage?: CustomMessage;
}
| {
id?: string;
diff --git a/packages/coding-agent/src/modes/interactive/agent-activity.ts b/packages/coding-agent/src/modes/interactive/agent-activity.ts
index 0be2ab176d..703cdabad2 100644
--- a/packages/coding-agent/src/modes/interactive/agent-activity.ts
+++ b/packages/coding-agent/src/modes/interactive/agent-activity.ts
@@ -1,3 +1,4 @@
+import { isAgentSessionMessage } from "../../core/agent-messages.js";
import type { AgentConnectionSessionEvent } from "../agent-connection/index.js";
export type AgentActivity = "waiting" | "thinking" | "writing" | "writing-code" | "executing";
@@ -45,7 +46,7 @@ export class AgentActivityTracker {
break;
case "message_start":
- if (event.message.role === "user") {
+ if (event.message.role === "user" || isAgentSessionMessage(event.message)) {
this.reset();
} else if (event.message.role === "assistant") {
this.activity = "waiting";
diff --git a/packages/coding-agent/src/modes/interactive/components/agent-message.ts b/packages/coding-agent/src/modes/interactive/components/agent-message.ts
new file mode 100644
index 0000000000..f99e0bbecb
--- /dev/null
+++ b/packages/coding-agent/src/modes/interactive/components/agent-message.ts
@@ -0,0 +1,82 @@
+import {
+ Container,
+ Markdown,
+ type MarkdownTheme,
+ Spacer,
+ Text,
+ truncateToWidth,
+ visibleWidth,
+} from "@earendil-works/pi-tui";
+import type { AgentSessionMessage, AgentSessionMessageDetails } from "../../../core/agent-messages.js";
+import { getMarkdownTheme, theme } from "../theme/theme.js";
+import { keyText } from "./keybinding-hints.js";
+
+function senderLabel(details: AgentSessionMessageDetails): string {
+ return (
+ details.from?.sessionName?.trim() ||
+ details.from?.activeSessionId?.trim() ||
+ details.from?.clientId?.trim() ||
+ "Unknown agent"
+ );
+}
+
+function collapseText(text: string): string {
+ return text.replace(/\s+/g, " ").trim();
+}
+
+export class AgentMessageComponent extends Container {
+ private readonly content = new Container();
+ private readonly header = new Text("", 1, 0);
+ private expanded = false;
+
+ constructor(
+ private readonly message: AgentSessionMessage,
+ private readonly markdownTheme: MarkdownTheme = getMarkdownTheme(),
+ ) {
+ super();
+ this.addChild(new Spacer(1));
+ this.addChild(this.content);
+ this.updateDisplay();
+ }
+
+ setExpanded(expanded: boolean): void {
+ if (this.expanded === expanded) {
+ return;
+ }
+ this.expanded = expanded;
+ this.updateDisplay();
+ }
+
+ override invalidate(): void {
+ super.invalidate();
+ this.updateDisplay();
+ }
+
+ private updateDisplay(): void {
+ this.content.clear();
+ this.header.setText(this.headerText());
+ this.content.addChild(this.header);
+ if (this.expanded) {
+ this.content.addChild(
+ new Markdown(this.message.details.message, 1, 0, this.markdownTheme, {
+ color: (text: string) => theme.fg("customMessageText", text),
+ }),
+ );
+ }
+ }
+
+ private headerText(): string {
+ const icon = theme.fg("accent", "◆");
+ const title = theme.fg("muted", "Agent message received");
+ const sender = theme.fg("muted", senderLabel(this.message.details));
+ const separator = theme.fg("dim", " · ");
+ if (this.expanded) {
+ return `${icon} ${title}${separator}${sender}`;
+ }
+
+ const prefixWidth = visibleWidth(`◆ Agent message received · ${senderLabel(this.message.details)} · `);
+ const preview = truncateToWidth(collapseText(this.message.details.message), Math.max(20, 100 - prefixWidth));
+ const hint = theme.fg("dim", ` (${keyText("app.tools.expand")} to expand)`);
+ return `${icon} ${title}${separator}${sender}${separator}${theme.fg("muted", preview)}${hint}`;
+ }
+}
diff --git a/packages/coding-agent/src/modes/interactive/components/conversation-components.ts b/packages/coding-agent/src/modes/interactive/components/conversation-components.ts
index 0b0c78e18a..64568e51ec 100644
--- a/packages/coding-agent/src/modes/interactive/components/conversation-components.ts
+++ b/packages/coding-agent/src/modes/interactive/components/conversation-components.ts
@@ -1,5 +1,7 @@
import type { AgentMessage } from "@earendil-works/pi-agent-core";
import type { Component, MarkdownTheme, TUI } from "@earendil-works/pi-tui";
+import { isAgentSessionMessage } from "../../../core/agent-messages.js";
+import { AgentMessageComponent } from "./agent-message.js";
import { AssistantMessageComponent } from "./assistant-message.js";
import { InjectedPromptMessageComponent, isInjectedPromptMessage } from "./injected-prompt-message.js";
import { ToolExecutionComponent, type ToolExecutionDefinition, type ToolExecutionOptions } from "./tool-execution.js";
@@ -78,6 +80,10 @@ export function buildConversationComponents(
} else if (message.role === "toolResult") {
pendingTools.get(message.toolCallId)?.updateResult(message);
pendingTools.delete(message.toolCallId);
+ } else if (isAgentSessionMessage(message) && message.display) {
+ const component = new AgentMessageComponent(message, options.markdownTheme);
+ component.setExpanded(expanded);
+ components.push(component);
} else if (isInjectedPromptMessage(message) && message.display) {
const component = new InjectedPromptMessageComponent(message, options.markdownTheme);
component.setExpanded(expanded);
diff --git a/packages/coding-agent/src/modes/interactive/components/index.ts b/packages/coding-agent/src/modes/interactive/components/index.ts
index 69404d3c1b..8ba2745fb9 100644
--- a/packages/coding-agent/src/modes/interactive/components/index.ts
+++ b/packages/coding-agent/src/modes/interactive/components/index.ts
@@ -1,4 +1,6 @@
// UI Components for extensions
+
+export { AgentMessageComponent } from "./agent-message.js";
export { ArminComponent } from "./armin.js";
export { AssistantMessageComponent } from "./assistant-message.js";
export { BashExecutionComponent } from "./bash-execution.js";
diff --git a/packages/coding-agent/src/modes/interactive/components/ipython-cell.ts b/packages/coding-agent/src/modes/interactive/components/ipython-cell.ts
index 98aeebb00f..f5909eb033 100644
--- a/packages/coding-agent/src/modes/interactive/components/ipython-cell.ts
+++ b/packages/coding-agent/src/modes/interactive/components/ipython-cell.ts
@@ -44,6 +44,17 @@ interface DiffDisplay {
startLine?: number;
}
+interface SentAgentMessageDisplay {
+ id: string;
+ message: string;
+ deliveryStatus: "delivered" | "queued";
+ target: {
+ activeSessionId: string;
+ sessionId: string;
+ sessionName?: string;
+ };
+}
+
interface IpythonDetails {
durationMs?: number;
status?: string;
@@ -52,6 +63,7 @@ interface IpythonDetails {
stderr?: string;
result?: string;
diffs?: DiffDisplay[];
+ sentAgentMessages?: SentAgentMessageDisplay[];
error?: IpythonErrorDetails;
}
@@ -131,10 +143,50 @@ function readDetails(details: unknown): IpythonDetails {
stderr: typeof record.stderr === "string" ? record.stderr : undefined,
result: typeof record.result === "string" ? record.result : undefined,
diffs: readDiffDisplays(record.diffs),
+ sentAgentMessages: readSentAgentMessages(record.sentAgentMessages),
error,
};
}
+function readSentAgentMessages(value: unknown): SentAgentMessageDisplay[] | undefined {
+ if (!Array.isArray(value)) {
+ return undefined;
+ }
+ const messages = value.flatMap((entry): SentAgentMessageDisplay[] => {
+ if (!entry || typeof entry !== "object") {
+ return [];
+ }
+ const record = entry as Record<string, unknown>;
+ const target = record.target;
+ if (!target || typeof target !== "object") {
+ return [];
+ }
+ const targetRecord = target as Record<string, unknown>;
+ if (
+ typeof record.id !== "string" ||
+ typeof record.message !== "string" ||
+ (record.deliveryStatus !== "delivered" && record.deliveryStatus !== "queued") ||
+ typeof targetRecord.activeSessionId !== "string" ||
+ typeof targetRecord.sessionId !== "string"
+ ) {
+ return [];
+ }
+ return [
+ {
+ id: record.id,
+ message: record.message,
+ deliveryStatus: record.deliveryStatus,
+ target: {
+ activeSessionId: targetRecord.activeSessionId,
+ sessionId: targetRecord.sessionId,
+ ...(typeof targetRecord.sessionName === "string" ? { sessionName: targetRecord.sessionName } : {}),
+ },
+ },
+ ];
+ });
+ return messages.length > 0 ? messages : undefined;
+}
+
function readDiffDisplays(value: unknown): DiffDisplay[] | undefined {
if (!Array.isArray(value)) {
return undefined;
@@ -310,6 +362,9 @@ export class IPythonCellComponent implements Component {
if (hasDiffs) {
this.renderDiffs(lines, safeWidth, details.diffs ?? [], this.marker(details));
}
+ if ((details.sentAgentMessages?.length ?? 0) > 0) {
+ this.renderSentAgentMessages(lines, safeWidth, details.sentAgentMessages ?? []);
+ }
if (!this.state.expanded) {
return this.renderCache.set(safeWidth, cacheVersion, lines);
@@ -418,6 +473,7 @@ export class IPythonCellComponent implements Component {
details.result !== undefined ||
details.error !== undefined ||
(details.diffs?.length ?? 0) > 0 ||
+ (details.sentAgentMessages?.length ?? 0) > 0 ||
(this.state.content?.length ?? 0) > 0
);
}
@@ -523,6 +579,7 @@ export class IPythonCellComponent implements Component {
!traceback &&
!details.error &&
diffs.length === 0 &&
+ (details.sentAgentMessages?.length ?? 0) === 0 &&
this.state.executionStarted &&
imageCount === 0
) {
@@ -551,6 +608,26 @@ export class IPythonCellComponent implements Component {
}
}
+ private renderSentAgentMessages(lines: string[], width: number, messages: readonly SentAgentMessageDisplay[]): void {
+ for (const message of messages) {
+ this.addPlain(lines, "");
+ const target =
+ message.target.sessionName?.trim() ||
+ message.target.activeSessionId.trim() ||
+ message.target.sessionId.trim() ||
+ "Unknown agent";
+ const label = message.deliveryStatus === "delivered" ? "Agent message sent" : "Agent message queued";
+ const text = message.message.replace(/\s+/g, " ").trim();
+ const line =
+ theme.fg("accent", "◆") +
+ ` ${theme.fg("muted", label)}${theme.fg("dim", " · ")}` +
+ theme.fg("muted", target) +
+ theme.fg("dim", " · ") +
+ theme.fg("muted", text);
+ this.addPlain(lines, truncateToWidth(line, Math.max(1, width - 1), "…"));
+ }
+ }
+
// Edits always render in full, regardless of expand state. Grouped by file.
private renderDiffs(lines: string[], width: number, diffs: readonly DiffDisplay[], marker: string): void {
const diffsByPath = new Map<string, DiffDisplay[]>();
diff --git a/packages/coding-agent/src/modes/interactive/components/tool-execution.ts b/packages/coding-agent/src/modes/interactive/components/tool-execution.ts
index de15387890..bfe731bd34 100644
--- a/packages/coding-agent/src/modes/interactive/components/tool-execution.ts
+++ b/packages/coding-agent/src/modes/interactive/components/tool-execution.ts
@@ -1,6 +1,7 @@
import type { AgentToolResult } from "@earendil-works/pi-agent-core";
import { type Component, Container, getCapabilities, Image, Spacer, Text, type TUI } from "@earendil-works/pi-tui";
import type { ToolDefinition, ToolRenderContext, ToolRenderResultOptions } from "../../../core/extensions/types.js";
+import type { KernelSentAgentMessage } from "../../../core/kernel/index.js";
import { createBashToolDefinition } from "../../../core/tools/bash.js";
import { createEditToolDefinition } from "../../../core/tools/edit.js";
import { createAllToolDefinitions } from "../../../core/tools/index.js";
@@ -94,6 +95,7 @@ export class ToolExecutionComponent extends Container {
private cwd: string;
private executionStarted = false;
private argsComplete = false;
+ private pendingSentAgentMessages: KernelSentAgentMessage[] = [];
private result?: {
content: Array<{ type: string; text?: string; data?: string; mimeType?: string }>;
isError: boolean;
@@ -245,12 +247,36 @@ export class ToolExecutionComponent extends Container {
},
isPartial = false,
): void {
- this.result = result;
+ const details =
+ typeof result.details === "object" && result.details !== null
+ ? (result.details as Record<string, unknown>)
+ : {};
+ const sentAgentMessages = Array.isArray(details.sentAgentMessages) ? [...details.sentAgentMessages] : [];
+ for (const message of this.pendingSentAgentMessages) {
+ if (
+ !sentAgentMessages.some(
+ (entry) => typeof entry === "object" && entry !== null && "id" in entry && entry.id === message.id,
+ )
+ ) {
+ sentAgentMessages.push(message);
+ }
+ }
+ this.result = sentAgentMessages.length > 0 ? { ...result, details: { ...details, sentAgentMessages } } : result;
this.isPartial = isPartial;
this.updateDisplay();
this.maybeConvertImagesForKitty();
}
+ appendSentAgentMessage(message: KernelSentAgentMessage): void {
+ if (this.pendingSentAgentMessages.some((entry) => entry.id === message.id)) {
+ return;
+ }
+ this.pendingSentAgentMessages.push(message);
+ if (this.result) {
+ this.updateResult(this.result, this.isPartial);
+ }
+ }
+
private maybeConvertImagesForKitty(): void {
if (!this.allowInlineImages) return;
const caps = getCapabilities();
diff --git a/packages/coding-agent/src/modes/interactive/interactive-mode.ts b/packages/coding-agent/src/modes/interactive/interactive-mode.ts
index d30b767fc6..9ff6a820b8 100644
--- a/packages/coding-agent/src/modes/interactive/interactive-mode.ts
+++ b/packages/coding-agent/src/modes/interactive/interactive-mode.ts
@@ -61,6 +61,7 @@ import {
SELF_UPDATE_NOT_ATTEMPTED_EXIT_CODE,
VERSION,
} from "../../config.js";
+import { AGENT_MESSAGE_RECEIVED_PREVIEW_LABEL, isAgentSessionMessage } from "../../core/agent-messages.js";
import {
type AgentTraceUploadResult,
getPrimeAgentTraceCredential,
@@ -81,6 +82,7 @@ import type {
} from "../../core/extensions/index.js";
import { FooterDataProvider, type ReadonlyFooterDataProvider } from "../../core/footer-data-provider.js";
import { emptyGoalState, formatGoalUsage, GOAL_CONTEXT_PREVIEW_LABEL, type GoalState } from "../../core/goals.js";
+import type { KernelSentAgentMessage } from "../../core/kernel/index.js";
import { type AppKeybinding, KeybindingsManager } from "../../core/keybindings.js";
import {
createCompactionSummaryMessage,
@@ -144,6 +146,7 @@ import {
ProviderAuthFlows,
type ProviderLoginOptions,
} from "./auth-flows.js";
+import { AgentMessageComponent } from "./components/agent-message.js";
import { ArminComponent } from "./components/armin.js";
import { AssistantMessageComponent } from "./components/assistant-message.js";
import { BashExecutionComponent } from "./components/bash-execution.js";
@@ -244,10 +247,16 @@ export function getRandomStartHint(random = Math.random): (typeof START_HINTS)[n
function isLabeledQueuedPreview(message: string): boolean {
return (
- message.startsWith(`${HEARTBEAT_PROMPT_PREVIEW_LABEL}: `) || message.startsWith(`${GOAL_CONTEXT_PREVIEW_LABEL}: `)
+ message.startsWith(`${HEARTBEAT_PROMPT_PREVIEW_LABEL}: `) ||
+ message.startsWith(`${GOAL_CONTEXT_PREVIEW_LABEL}: `) ||
+ message.startsWith(`${AGENT_MESSAGE_RECEIVED_PREVIEW_LABEL}: `)
);
}
+export function formatQueuedMessagePreview(message: string, label: "Steering" | "Follow-up"): string {
+ return isLabeledQueuedPreview(message) ? message : `${label}: ${message}`;
+}
+
function isExpandable(obj: unknown): obj is Expandable {
return typeof obj === "object" && obj !== null && "setExpanded" in obj && typeof obj.setExpanded === "function";
}
@@ -686,6 +695,8 @@ export class InteractiveMode {
// Tool execution tracking: toolCallId -> component
private pendingTools = new Map<string, ToolExecutionComponent>();
+ private ipythonToolComponents = new Map<string, ToolExecutionComponent>();
+ private lateIpythonSentAgentMessages = new Map<string, KernelSentAgentMessage[]>();
private pendingToolCreations = new Set<string>();
private startedToolCalls = new Set<string>();
private pendingToolGeneration = 0;
@@ -2418,6 +2429,8 @@ export class InteractiveMode {
this.activityTracker.reset();
this.contextUsageTokenBaseline = 0;
this.resetPendingToolState();
+ this.ipythonToolComponents.clear();
+ this.lateIpythonSentAgentMessages.clear();
this.resetChildAgentInspector();
this.setGoalAnnouncementBaseline(this.getGoalState());
this.syncGoalTray(this.getGoalState());
@@ -2459,6 +2472,16 @@ export class InteractiveMode {
);
}
+ private registerIpythonToolComponent(toolName: string, toolCallId: string, component: ToolExecutionComponent): void {
+ if (toolName !== "ipython") {
+ return;
+ }
+ this.ipythonToolComponents.set(toolCallId, component);
+ for (const lateMessage of this.lateIpythonSentAgentMessages.get(toolCallId) ?? []) {
+ component.appendSentAgentMessage(lateMessage);
+ }
+ }
+
private async getOrCreatePendingToolComponent(
toolCall: PendingToolCallRenderInput,
): Promise<ToolExecutionComponent | undefined> {
@@ -2504,6 +2527,7 @@ export class InteractiveMode {
}
this.chatContainer.addChild(component);
this.pendingTools.set(latestToolCall.id, component);
+ this.registerIpythonToolComponent(latestToolCall.name, latestToolCall.id, component);
return component;
} finally {
this.pendingToolCreations.delete(toolCall.id);
@@ -4271,7 +4295,7 @@ export class InteractiveMode {
this.updateConnectionStateFromEvent(event);
// A new user message resets the activity tracker to 0, so the in-flight baseline must
// reset with it. (agent_start on auto-retry does not reset the tracker.)
- if (event.type === "message_start" && event.message.role === "user") {
+ if (event.type === "message_start" && (event.message.role === "user" || isAgentSessionMessage(event.message))) {
this.contextUsageTokenBaseline = 0;
this.setSessionHasMessages(true);
this.clearShortcutGuide();
@@ -4466,6 +4490,17 @@ export class InteractiveMode {
break;
}
+ case "ipython_sent_agent_message": {
+ const messages = this.lateIpythonSentAgentMessages.get(event.toolCallId) ?? [];
+ if (!messages.some((message) => message.id === event.message.id)) {
+ messages.push(event.message);
+ this.lateIpythonSentAgentMessages.set(event.toolCallId, messages);
+ }
+ this.ipythonToolComponents.get(event.toolCallId)?.appendSentAgentMessage(event.message);
+ this.ui.requestRender();
+ break;
+ }
+
case "agent_end":
if (this.settingsManager.getShowTerminalProgress()) {
this.ui.terminal.setProgress(false);
@@ -5366,15 +5401,17 @@ export class InteractiveMode {
}
case "custom": {
if (message.display) {
- const component = isInjectedPromptMessage(message)
- ? new InjectedPromptMessageComponent(message, this.getMarkdownThemeWithSettings())
- : new CustomMessageComponent(
- message,
- this.bindLocalSessionExtensions
- ? this.getLocalSessionHost().getExtensionRunner().getMessageRenderer(message.customType)
- : undefined,
- this.getMarkdownThemeWithSettings(),
- );
+ const component = isAgentSessionMessage(message)
+ ? new AgentMessageComponent(message, this.getMarkdownThemeWithSettings())
+ : isInjectedPromptMessage(message)
+ ? new InjectedPromptMessageComponent(message, this.getMarkdownThemeWithSettings())
+ : new CustomMessageComponent(
+ message,
+ this.bindLocalSessionExtensions
+ ? this.getLocalSessionHost().getExtensionRunner().getMessageRenderer(message.customType)
+ : undefined,
+ this.getMarkdownThemeWithSettings(),
+ );
component.setExpanded(this.toolOutputExpanded);
this.chatContainer.addChild(component);
}
@@ -5474,6 +5511,8 @@ export class InteractiveMode {
options: { updateFooter?: boolean; populateHistory?: boolean; clearChat?: boolean } = {},
): Promise<void> {
this.resetPendingToolState();
+ this.ipythonToolComponents.clear();
+ this.lateIpythonSentAgentMessages.clear();
const renderedPendingTools = new Map<string, ToolExecutionComponent>();
const toolNames: string[] = [];
for (const message of sessionContext.messages) {
@@ -5520,6 +5559,7 @@ export class InteractiveMode {
);
component.setExpanded(this.toolOutputExpanded);
this.chatContainer.addChild(component);
+ this.registerIpythonToolComponent(content.name, content.id, component);
if (message.stopReason === "aborted" || message.stopReason === "error") {
let errorMessage: string;
@@ -6225,11 +6265,11 @@ export class InteractiveMode {
if (steeringMessages.length > 0 || followUpMessages.length > 0) {
this.queuedMessagesContainer.addChild(new Spacer(1));
for (const message of steeringMessages) {
- const text = theme.fg("dim", isLabeledQueuedPreview(message) ? message : `Steering: ${message}`);
+ const text = theme.fg("dim", formatQueuedMessagePreview(message, "Steering"));
this.queuedMessagesContainer.addChild(new TruncatedText(text, 1, 0));
}
for (const message of followUpMessages) {
- const text = theme.fg("dim", isLabeledQueuedPreview(message) ? message : `Follow-up: ${message}`);
+ const text = theme.fg("dim", formatQueuedMessagePreview(message, "Follow-up"));
this.queuedMessagesContainer.addChild(new TruncatedText(text, 1, 0));
}
const dequeueHint = this.getAppKeyDisplay("app.message.dequeue");
diff --git a/packages/coding-agent/src/package-manager-cli.ts b/packages/coding-agent/src/package-manager-cli.ts
index fa02ff52c2..c428bd07b6 100644
--- a/packages/coding-agent/src/package-manager-cli.ts
+++ b/packages/coding-agent/src/package-manager-cli.ts
@@ -890,6 +890,7 @@ async function restoreDaemonUpdateRestartSession(
images: acceptedPrompt.images,
expandPromptTemplates: false,
agentMessageId: acceptedPrompt.agentMessageId,
+ customMessage: acceptedPrompt.customMessage,
},
120000,
);
diff --git a/packages/coding-agent/test/agent-connection-in-process.test.ts b/packages/coding-agent/test/agent-connection-in-process.test.ts
index 6d89d92fd7..6afdb4c600 100644
--- a/packages/coding-agent/test/agent-connection-in-process.test.ts
+++ b/packages/coding-agent/test/agent-connection-in-process.test.ts
@@ -69,6 +69,11 @@ function createFakeSession(id: string, messages: AgentMessage[]): FakeSessionCon
const listeners = new Set<AgentSessionEventListener>();
let unsubscriptions = 0;
const thinkingLevel: AgentConnectionState["thinkingLevel"] = "medium";
+ const buildSessionContext = () => ({
+ messages,
+ thinkingLevel,
+ model: null,
+ });
const session = {
sessionManager: {
getCwd: () => `/tmp/${id}`,
@@ -76,12 +81,9 @@ function createFakeSession(id: string, messages: AgentMessage[]): FakeSessionCon
getLeafId: () => `${id}-leaf`,
getEntries: () => [],
getTree: () => [],
- buildSessionContext: () => ({
- messages,
- thinkingLevel,
- model: null,
- }),
+ buildSessionContext,
},
+ buildSessionContext,
model: undefined,
thinkingLevel,
getAvailableThinkingLevels: () => ["minimal", "low", "medium", "high", "xhigh"],
diff --git a/packages/coding-agent/test/interactive-mode-prompt-stash.test.ts b/packages/coding-agent/test/interactive-mode-prompt-stash.test.ts
index 0085294032..853d3ed336 100644
--- a/packages/coding-agent/test/interactive-mode-prompt-stash.test.ts
+++ b/packages/coding-agent/test/interactive-mode-prompt-stash.test.ts
@@ -55,6 +55,8 @@ type ResetHarness = PromptStashLiveMarkerHarness & {
pendingBashComponents: unknown[];
activityTracker: { reset: Mock };
contextUsageTokenBaseline: number;
+ ipythonToolComponents: Map<string, unknown>;
+ lateIpythonSentAgentMessages: Map<string, unknown>;
resetPendingToolState: Mock;
resetChildAgentInspector: Mock;
setGoalAnnouncementBaseline: Mock;
@@ -348,6 +350,8 @@ describe("InteractiveMode prompt stash", () => {
pendingBashComponents: [],
activityTracker: { reset: vi.fn() },
contextUsageTokenBaseline: 1,
+ ipythonToolComponents: new Map(),
+ lateIpythonSentAgentMessages: new Map(),
resetPendingToolState: vi.fn(),
resetChildAgentInspector: vi.fn(),
setGoalAnnouncementBaseline: vi.fn(),
@@ -379,6 +383,8 @@ describe("InteractiveMode prompt stash", () => {
pendingBashComponents: [],
activityTracker: { reset: vi.fn() },
contextUsageTokenBaseline: 1,
+ ipythonToolComponents: new Map(),
+ lateIpythonSentAgentMessages: new Map(),
resetPendingToolState: vi.fn(),
resetChildAgentInspector: vi.fn(),
setGoalAnnouncementBaseline: vi.fn(),
diff --git a/packages/coding-agent/test/interactive-mode-status.test.ts b/packages/coding-agent/test/interactive-mode-status.test.ts
index 3087ea993c..2dc494cb47 100644
--- a/packages/coding-agent/test/interactive-mode-status.test.ts
+++ b/packages/coding-agent/test/interactive-mode-status.test.ts
@@ -205,8 +205,12 @@ describe("InteractiveMode.renderSessionContext", () => {
setCapabilities({ images: "kitty", trueColor: true, hyperlinks: true });
try {
const chatContainer = new Container();
+ const ipythonToolComponents = new Map([["stale-tool", {}]]);
+ const lateIpythonSentAgentMessages = new Map([["stale-tool", []]]);
const fakeThis: any = {
pendingTools: new Map(),
+ ipythonToolComponents,
+ lateIpythonSentAgentMessages,
toolOutputExpanded: false,
chatContainer,
footer: { invalidate: vi.fn() },
@@ -225,6 +229,7 @@ describe("InteractiveMode.renderSessionContext", () => {
chatContainer.addChild({ render: () => ["assistant"], invalidate: () => {} });
}),
};
+ Object.setPrototypeOf(fakeThis, InteractiveMode.prototype);
await (InteractiveMode as any).prototype.renderSessionContext.call(fakeThis, {
messages: [
@@ -246,6 +251,8 @@ describe("InteractiveMode.renderSessionContext", () => {
const rendered = renderAll(chatContainer);
expect(rendered).not.toContain("\x1b_G");
expect(normalizeRenderedOutput(chatContainer)).toContain("[Image: [image/png]]");
+ expect(ipythonToolComponents.size).toBe(0);
+ expect(lateIpythonSentAgentMessages.size).toBe(0);
} finally {
resetCapabilitiesCache();
}
@@ -258,6 +265,8 @@ describe("InteractiveMode.renderSessionContext", () => {
const pendingTools = new Map<string, ToolExecutionComponent>();
const fakeThis: any = {
pendingTools,
+ ipythonToolComponents: new Map(),
+ lateIpythonSentAgentMessages: new Map(),
toolOutputExpanded: false,
chatContainer,
footer: { invalidate: vi.fn() },
@@ -276,6 +285,7 @@ describe("InteractiveMode.renderSessionContext", () => {
chatContainer.addChild({ render: () => ["assistant"], invalidate: () => {} });
}),
};
+ Object.setPrototypeOf(fakeThis, InteractiveMode.prototype);
await (InteractiveMode as any).prototype.renderSessionContext.call(fakeThis, {
messages: [
@@ -583,6 +593,8 @@ describe("InteractiveMode pending bash components", () => {
activeBashComponent: component,
pendingBashComponents: [component],
activityTracker: { reset: vi.fn() },
+ ipythonToolComponents: new Map(),
+ lateIpythonSentAgentMessages: new Map(),
resetPendingToolState: vi.fn(),
resetChildAgentInspector: vi.fn(),
setGoalAnnouncementBaseline: vi.fn(),
@@ -767,6 +779,8 @@ describe("InteractiveMode tool event rendering", () => {
pendingTools: new Map<string, ToolExecutionComponent>(),
pendingToolCreations: new Set<string>(),
startedToolCalls: new Set<string>(),
+ ipythonToolComponents: new Map(),
+ lateIpythonSentAgentMessages: new Map(),
loadToolDefinition: vi.fn(() => definitionPromise),
uiServices: {
settingsManager: {
diff --git a/packages/coding-agent/test/kernel-abort.test.ts b/packages/coding-agent/test/kernel-abort.test.ts
index b1bd136293..91d544cd1f 100644
--- a/packages/coding-agent/test/kernel-abort.test.ts
+++ b/packages/coding-agent/test/kernel-abort.test.ts
@@ -1,5 +1,5 @@
import { afterEach, describe, expect, it, vi } from "vitest";
-import { KernelManager } from "../src/core/kernel/index.js";
+import { AGENT_MESSAGE_DISPLAY_MIME, KernelManager, type KernelSentAgentMessage } from "../src/core/kernel/index.js";
async function waitForCalls(mock: { mock: { calls: unknown[][] } }, count: number): Promise<void> {
for (let i = 0; i < 20; i++) {
@@ -113,8 +113,12 @@ describe("KernelManager abort handling", () => {
},
);
const controller = new AbortController();
+ const lateSentAgentMessages: KernelSentAgentMessage[] = [];
- const executePromise = manager.execute("while True: pass", { signal: controller.signal });
+ const executePromise = manager.execute("while True: pass", {
+ signal: controller.signal,
+ onLateSentAgentMessage: (message) => lateSentAgentMessages.push(message),
+ });
await waitForCalls(shellSend, 1);
expect(shellSend).toHaveBeenCalledTimes(1);
@@ -139,6 +143,29 @@ describe("KernelManager abort handling", () => {
if (!activeExecution) {
throw new Error("Expected active execution to remain until kernel idle");
}
+ internals.handleExecutionMessage({
+ header: { msg_type: "display_data" },
+ parent_header: { msg_id: activeExecution.requestMsgId },
+ metadata: {},
+ content: {
+ data: {
+ [AGENT_MESSAGE_DISPLAY_MIME]: {
+ id: "agentmsg-after-abort",
+ message: "still sent",
+ deliveryStatus: "delivered",
+ target: { activeSessionId: "beta", sessionId: "session-beta" },
+ },
+ },
+ },
+ });
+ expect(lateSentAgentMessages).toEqual([
+ {
+ id: "agentmsg-after-abort",
+ message: "still sent",
+ deliveryStatus: "delivered",
+ target: { activeSessionId: "beta", sessionId: "session-beta" },
+ },
+ ]);
const secondExecutePromise = manager.execute("x = 1");
await Promise.resolve();
expect(shellSend).toHaveBeenCalledTimes(1);
diff --git a/packages/coding-agent/test/kernel-agent-message-skill.test.ts b/packages/coding-agent/test/kernel-agent-message-skill.test.ts
index 3bc28a6f4f..ec9bd1ebe1 100644
--- a/packages/coding-agent/test/kernel-agent-message-skill.test.ts
+++ b/packages/coding-agent/test/kernel-agent-message-skill.test.ts
@@ -3,6 +3,7 @@ import { tmpdir } from "node:os";
import { join } from "node:path";
import { afterEach, beforeEach, describe, expect, it } from "vitest";
import { getBundledSkillsDir } from "../src/config.js";
+import { KernelManager, type KernelSentAgentMessage } from "../src/core/kernel/index.js";
import type { PythonSkillRuntimeInfo } from "../src/core/skills.js";
import { IpythonKernelProvisioner } from "../src/core/tools/ipython.js";
@@ -16,6 +17,14 @@ function bundledAgentMessageSkill(): PythonSkillRuntimeInfo {
};
}
+type LateHandlerRetentionHost = {
+ lateSentAgentMessageHandlers: Map<string, (message: KernelSentAgentMessage) => void>;
+ registerLateSentAgentMessageHandler: (
+ requestMessageId: string,
+ handler: (message: KernelSentAgentMessage) => void,
+ ) => void;
+};
+
describe("agent-message skill over the kernel host bridge", () => {
let tempDir: string;
let provisioner: IpythonKernelProvisioner | undefined;
@@ -64,7 +73,7 @@ describe("agent-message skill over the kernel host bridge", () => {
return {
id: "agentmsg-test",
source: "agent_message",
- target: { activeSessionId: payload.target, sessionId: "session-beta" },
+ target: { activeSessionId: payload.target, sessionId: "session-beta", sessionName: "Beta" },
from: { activeSessionId: "alpha", sessionId: "session-alpha" },
message: payload.message,
deliveryStatus: "queued",
@@ -93,6 +102,14 @@ print(json.dumps({"agents": agents, "receipt": receipt}, sort_keys=True))
deliveryStatus: "queued",
deliveryMode: "follow_up",
});
+ expect(result.sentAgentMessages).toEqual([
+ {
+ id: "agentmsg-test",
+ message: "hello beta",
+ deliveryStatus: "queued",
+ target: { activeSessionId: "beta", sessionId: "session-beta", sessionName: "Beta" },
+ },
+ ]);
expect(requests[0]).toMatchObject({ type: "agent_message.list", payload: { type: "agent_message.list" } });
expect(requests[1]).toMatchObject({
type: "agent_message.send",
@@ -126,4 +143,59 @@ except ValueError as error:
expect(result.status).toBe("ok");
expect(result.stdout.trim()).toBe('ValueError: mode must be "auto", "follow_up", or "steer"');
});
+
+ it("captures sent messages from detached tasks after the cell is idle", async () => {
+ provisioner = new IpythonKernelProvisioner(tempDir, {
+ pythonSkills: [bundledAgentMessageSkill()],
+ hostHandlers: {
+ "agent_message.send": async (payload) => ({
+ id: "agentmsg-background",
+ source: "agent_message",
+ target: { activeSessionId: payload.target, sessionId: "session-beta", sessionName: "Beta" },
+ message: payload.message,
+ deliveryStatus: "delivered",
+ deliveredAt: "2026-07-10T00:00:00.000Z",
+ deliveryMode: payload.mode,
+ }),
+ },
+ });
+
+ const manager = await provisioner.ensure();
+ let resolveLateMessage!: (message: KernelSentAgentMessage) => void;
+ const lateMessage = new Promise<KernelSentAgentMessage>((resolve) => {
+ resolveLateMessage = resolve;
+ });
+ const result = await manager.execute(
+ `async def send_later():
+ await asyncio.sleep(0.05)
+ await agent_message.send("beta", "background hello")
+
+background_send = asyncio.create_task(send_later())`,
+ { onLateSentAgentMessage: (message) => resolveLateMessage(message) },
+ );
+
+ expect(result.status).toBe("ok");
+ expect(result.sentAgentMessages).toBeUndefined();
+ await expect(lateMessage).resolves.toEqual({
+ id: "agentmsg-background",
+ message: "background hello",
+ deliveryStatus: "delivered",
+ target: { activeSessionId: "beta", sessionId: "session-beta", sessionName: "Beta" },
+ });
+ });
+
+ it("bounds retained handlers for late sent messages", async () => {
+ const manager = new KernelManager({ cwd: tempDir });
+ const host = manager as unknown as LateHandlerRetentionHost;
+ const handler = () => {};
+
+ for (let index = 0; index < 300; index += 1) {
+ host.registerLateSentAgentMessageHandler(`request-${index}`, handler);
+ }
+
+ expect(host.lateSentAgentMessageHandlers.size).toBe(256);
+ expect(host.lateSentAgentMessageHandlers.has("request-0")).toBe(false);
+ expect(host.lateSentAgentMessageHandlers.has("request-299")).toBe(true);
+ await manager.dispose();
+ });
});
diff --git a/packages/coding-agent/test/suite/regressions/4167-thinking-toggle-pending-tool-render.test.ts b/packages/coding-agent/test/suite/regressions/4167-thinking-toggle-pending-tool-render.test.ts
index c240be90c3..6080fb4f4f 100644
--- a/packages/coding-agent/test/suite/regressions/4167-thinking-toggle-pending-tool-render.test.ts
+++ b/packages/coding-agent/test/suite/regressions/4167-thinking-toggle-pending-tool-render.test.ts
@@ -32,6 +32,8 @@ const EMPTY_USAGE: Usage = {
type RenderSessionContextThis = {
pendingTools: Map<string, ToolExecutionComponent>;
+ ipythonToolComponents: Map<string, ToolExecutionComponent>;
+ lateIpythonSentAgentMessages: Map<string, unknown[]>;
pendingToolCreations: Set<string>;
startedToolCalls: Set<string>;
resetPendingToolState(): void;
@@ -68,8 +70,10 @@ function createFakeInteractiveModeThis(): RenderSessionContextThis {
const pendingTools = new Map<string, ToolExecutionComponent>();
const pendingToolCreations = new Set<string>();
const startedToolCalls = new Set<string>();
- return {
+ const fakeThis: RenderSessionContextThis = {
pendingTools,
+ ipythonToolComponents: new Map(),
+ lateIpythonSentAgentMessages: new Map(),
pendingToolCreations,
startedToolCalls,
resetPendingToolState() {
@@ -98,6 +102,8 @@ function createFakeInteractiveModeThis(): RenderSessionContextThis {
chatContainer.addChild(new Text(message.role, 0, 0));
},
};
+ Object.setPrototypeOf(fakeThis, InteractiveMode.prototype);
+ return fakeThis;
}
function createAssistantToolCallMessage(): AssistantMessage {
diff --git a/packages/coding-agent/test/suite/regressions/4531-agent-message-ui.test.ts b/packages/coding-agent/test/suite/regressions/4531-agent-message-ui.test.ts
new file mode 100644
index 0000000000..47368d56e5
--- /dev/null
+++ b/packages/coding-agent/test/suite/regressions/4531-agent-message-ui.test.ts
@@ -0,0 +1,343 @@
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import { fauxAssistantMessage, fauxToolCall, type Message, type ToolResultMessage } from "@earendil-works/pi-ai";
+import { Type } from "typebox";
+import { afterEach, beforeAll, describe, expect, it } from "vitest";
+import {
+ AGENT_MESSAGE_SOURCE,
+ type AgentSessionMessagePayload,
+ createAgentSessionMessage,
+ createAgentSessionMessagePrompt,
+ isAgentSessionMessagePrompt,
+} from "../../../src/core/agent-messages.js";
+import type { KernelSentAgentMessage } from "../../../src/core/kernel/index.js";
+import { AgentMessageComponent } from "../../../src/modes/interactive/components/agent-message.js";
+import { IPythonCellComponent } from "../../../src/modes/interactive/components/ipython-cell.js";
+import { formatQueuedMessagePreview } from "../../../src/modes/interactive/interactive-mode.js";
+import { initTheme } from "../../../src/modes/interactive/theme/theme.js";
+import { createHarness, getMessageText, getUserTexts, type Harness } from "../harness.js";
+
+function createPayload(message: string): AgentSessionMessagePayload {
+ return {
+ id: "agentmsg_4531",
+ source: AGENT_MESSAGE_SOURCE,
+ message,
+ deliveryMode: "auto",
+ from: {
+ activeSessionId: "planner-active",
+ sessionId: "planner-session",
+ sessionName: "Planner",
+ },
+ target: {
+ activeSessionId: "worker-active",
+ sessionId: "worker-session",
+ sessionName: "Worker",
+ },
+ };
+}
+
+function stripAnsi(text: string): string {
+ return text.replace(/\u001b\[[0-9;]*m/g, "");
+}
+
+function render(component: AgentMessageComponent): string {
+ return stripAnsi(component.render(120).join("\n"));
+}
+
+type LateSentAgentMessageHost = {
+ _recordLateIpythonSentAgentMessage: (toolCallId: string, message: KernelSentAgentMessage) => void;
+ _agentEventQueue: Promise<void>;
+ _lateIpythonSentAgentMessages: Map<string, KernelSentAgentMessage[]>;
+ _restoreLateIpythonSentAgentMessages: () => void;
+};
+
+describe("ENG-4531 agent message UI", () => {
+ const harnesses: Harness[] = [];
+
+ beforeAll(() => {
+ initTheme("dark");
+ });
+
+ afterEach(() => {
+ while (harnesses.length > 0) {
+ harnesses.pop()?.cleanup();
+ }
+ });
+
+ it("records delivered agent messages as custom transcript entries while preserving provider input", async () => {
+ const harness = await createHarness();
+ harnesses.push(harness);
+ const payload = createPayload("Review the benchmark notes.");
+ const prompt = createAgentSessionMessagePrompt(payload);
+ const message = createAgentSessionMessage(payload);
+ let providerMessages: Message[] = [];
+ harness.setResponses([
+ (context) => {
+ providerMessages = [...context.messages];
+ return fauxAssistantMessage("Reviewed.");
+ },
+ ]);
+
+ await harness.session.acceptAgentMessagePrompt(prompt, { customMessage: message });
+ await harness.session.agent.waitForIdle();
+
+ expect(getUserTexts(harness)).toEqual([]);
+ expect(harness.session.messages[0]).toMatchObject({
+ role: "custom",
+ customType: "agent_message",
+ display: true,
+ });
+ expect(getMessageText(providerMessages.at(-1))).toBe(prompt);
+ expect(providerMessages.at(-1)?.role).toBe("user");
+ expect(
+ harness.session.sessionManager
+ .getEntries()
+ .some((entry) => entry.type === "custom_message" && entry.customType === "agent_message"),
+ ).toBe(true);
+ });
+
+ it("leaves text-only agent envelopes as user messages", async () => {
+ const harness = await createHarness();
+ harnesses.push(harness);
+ const prompt = createAgentSessionMessagePrompt(createPayload("Previously persisted message."));
+ harness.setResponses([fauxAssistantMessage("Handled.")]);
+
+ await harness.session.acceptAgentMessagePrompt(prompt);
+ await harness.session.agent.waitForIdle();
+
+ expect(getUserTexts(harness)).toEqual([prompt]);
+ expect(harness.session.messages[0]?.role).toBe("user");
+ });
+
+ it("preserves structured messages passed through the normal prompt path", async () => {
+ const harness = await createHarness();
+ harnesses.push(harness);
+ const payload = createPayload("Run the idle-session review.");
+ const prompt = createAgentSessionMessagePrompt(payload);
+ harness.setResponses([fauxAssistantMessage("Handled.")]);
+
+ await harness.session.prompt(prompt, {
+ expandPromptTemplates: false,
+ customMessage: createAgentSessionMessage(payload),
+ });
+ await harness.session.agent.waitForIdle();
+
+ expect(getUserTexts(harness)).toEqual([]);
+ expect(harness.session.messages[0]).toMatchObject({
+ role: "custom",
+ customType: "agent_message",
+ details: { id: "agentmsg_4531", message: "Run the idle-session review." },
+ });
+ });
+
+ it("keeps queued agent messages structured and removable by message identity", async () => {
+ const harness = await createHarness();
+ harnesses.push(harness);
+ const payload = createPayload("Use shard seven.");
+ const prompt = createAgentSessionMessagePrompt(payload);
+ const message = createAgentSessionMessage(payload);
+
+ await harness.session.queueAgentMessagePrompt(prompt, "followUp", message);
+
+ expect(harness.session.getFollowUpMessagePreviews()).toEqual(["Agent message received: Use shard seven."]);
+ expect(harness.session.getFollowUpQueueSnapshots()[0]?.customMessage).toMatchObject({
+ customType: "agent_message",
+ details: { id: "agentmsg_4531", message: "Use shard seven." },
+ });
+ expect(harness.session.clearQueuedUserMessagesMatching(isAgentSessionMessagePrompt)).toEqual({
+ steering: [],
+ followUp: [prompt],
+ });
+ });
+
+ it("does not add a second queue label to agent message previews", () => {
+ expect(formatQueuedMessagePreview("Agent message received: Use shard seven.", "Follow-up")).toBe(
+ "Agent message received: Use shard seven.",
+ );
+ expect(formatQueuedMessagePreview("Run the remaining checks.", "Steering")).toBe(
+ "Steering: Run the remaining checks.",
+ );
+ });
+
+ it("persists sent messages that arrive after their Python cell completes", async () => {
+ const harness = await createHarness();
+ harnesses.push(harness);
+ const toolResult: ToolResultMessage = {
+ role: "toolResult",
+ toolCallId: "ipython_4531",
+ toolName: "ipython",
+ content: [{ type: "text", text: "" }],
+ details: { status: "ok" },
+ isError: false,
+ timestamp: Date.now(),
+ };
+ harness.session.sessionManager.appendMessage(
+ fauxAssistantMessage(fauxToolCall("ipython", { code: "background_send" }), { stopReason: "toolUse" }),
+ );
+ harness.session.sessionManager.appendMessage(toolResult);
+ harness.session.agent.state.messages.push(toolResult);
+ const lateMessage = {
+ id: "agentmsg_late_4531",
+ message: "Background review finished.",
+ deliveryStatus: "delivered" as const,
+ target: {
+ activeSessionId: "worker-active",
+ sessionId: "worker-session",
+ sessionName: "Worker",
+ },
+ };
+ const events: string[] = [];
+ const unsubscribe = harness.session.subscribe((event) => events.push(event.type));
+ const host = harness.session as unknown as LateSentAgentMessageHost;
+
+ host._recordLateIpythonSentAgentMessage(toolResult.toolCallId, lateMessage);
+ await host._agentEventQueue;
+ unsubscribe();
+
+ expect(toolResult.details).toMatchObject({ sentAgentMessages: [lateMessage] });
+ expect(
+ harness.session.sessionManager
+ .getEntries()
+ .some((entry) => entry.type === "custom" && entry.customType === "ipython_sent_agent_message"),
+ ).toBe(true);
+ expect(events).toContain("ipython_sent_agent_message");
+ expect(
+ harness.session
+ .buildSessionContext()
+ .messages.find(
+ (message): message is ToolResultMessage =>
+ message.role === "toolResult" && message.toolCallId === toolResult.toolCallId,
+ )?.details,
+ ).toMatchObject({ sentAgentMessages: [lateMessage] });
+
+ toolResult.details = { status: "ok" };
+ host._restoreLateIpythonSentAgentMessages();
+ expect(toolResult.details).toMatchObject({ sentAgentMessages: [lateMessage] });
+
+ toolResult.details = { status: "ok" };
+ host._lateIpythonSentAgentMessages = new Map();
+ host._restoreLateIpythonSentAgentMessages();
+ expect(toolResult.details).toMatchObject({ sentAgentMessages: [lateMessage] });
+
+ host._lateIpythonSentAgentMessages.set("ipython_other_branch", [
+ {
+ id: "agentmsg_other_branch",
+ message: "Stale branch receipt.",
+ deliveryStatus: "delivered",
+ target: { activeSessionId: "other", sessionId: "other-session" },
+ },
+ ]);
+ host._restoreLateIpythonSentAgentMessages();
+ expect(host._lateIpythonSentAgentMessages.has("ipython_other_branch")).toBe(false);
+ });
+
+ it("preserves the custom message when direct delivery races with active work", async () => {
+ let releaseToolExecution: (() => void) | undefined;
+ const toolRelease = new Promise<void>((resolve) => {
+ releaseToolExecution = resolve;
+ });
+ const waitTool: AgentTool = {
+ name: "wait",
+ label: "Wait",
+ description: "Wait for release",
+ parameters: Type.Object({}),
+ execute: async () => {
+ await toolRelease;
+ return { content: [{ type: "text", text: "released" }], details: {} };
+ },
+ };
+ const harness = await createHarness({ tools: [waitTool] });
+ harnesses.push(harness);
+ harness.setResponses([
+ fauxAssistantMessage(fauxToolCall("wait", {}), { stopReason: "toolUse" }),
+ fauxAssistantMessage("Original turn complete."),
+ fauxAssistantMessage("Agent message handled."),
+ ]);
+ const sawToolStart = new Promise<void>((resolve) => {
+ const unsubscribe = harness.session.subscribe((event) => {
+ if (event.type === "tool_execution_start") {
+ unsubscribe();
+ resolve();
+ }
+ });
+ });
+ const promptPromise = harness.session.prompt("Start work.");
+ await sawToolStart;
+ const payload = createPayload("Queue behind the active turn.");
+ const prompt = createAgentSessionMessagePrompt(payload);
+
+ await harness.session.acceptAgentMessagePrompt(prompt, {
+ customMessage: createAgentSessionMessage(payload),
+ streamingBehavior: "followUp",
+ queueIfBusy: true,
+ });
+
+ expect(harness.session.getFollowUpQueueSnapshots()[0]?.customMessage).toMatchObject({
+ customType: "agent_message",
+ details: { message: "Queue behind the active turn." },
+ });
+ releaseToolExecution?.();
+ await promptPromise;
+ await harness.session.agent.waitForIdle();
+ expect(
+ harness.session.messages.some(
+ (message) => message.role === "custom" && message.customType === "agent_message",
+ ),
+ ).toBe(true);
+ });
+
+ it("renders a compact subagent-style row and expands only the message body", () => {
+ const body = `${"Inspect the benchmark results and compare every shard. ".repeat(4)}Final instruction.`;
+ const component = new AgentMessageComponent(createAgentSessionMessage(createPayload(body)));
+ const collapsed = render(component);
+
+ expect(collapsed).toContain("◆ Agent message received · Planner");
+ expect(collapsed).toContain("to expand");
+ expect(collapsed).not.toContain("Final instruction.");
+ expect(collapsed).not.toContain("Source: agent_message");
+ expect(collapsed).not.toContain("Message id:");
+
+ component.setExpanded(true);
+ const expanded = render(component);
+ expect(expanded.replace(/\s+/g, " ")).toContain("Final instruction.");
+ expect(expanded).not.toContain("Source: agent_message");
+ expect(expanded).not.toContain("To: Worker");
+ expect(expanded).not.toContain("Message id:");
+ });
+
+ it("renders sent messages beneath collapsed Python cells", () => {
+ const component = new IPythonCellComponent({
+ code: 'await agent_message.send("worker-active", "Review shard seven.")',
+ executionStarted: true,
+ details: {
+ status: "ok",
+ sentAgentMessages: [
+ {
+ id: "agentmsg_4531",
+ message: "Review shard seven.",
+ deliveryStatus: "queued",
+ target: {
+ activeSessionId: "worker-active",
+ sessionId: "worker-session",
+ sessionName: "Worker",
+ },
+ },
+ {
+ id: "agentmsg_4531_delivered",
+ message: "Continue with shard eight.",
+ deliveryStatus: "delivered",
+ target: {
+ activeSessionId: "worker-active",
+ sessionId: "worker-session",
+ sessionName: "Worker",
+ },
+ },
+ ],
+ },
+ });
+
+ const rendered = stripAnsi(component.render(120).join("\n"));
+ expect(rendered).toContain("◆ Agent message queued · Worker · Review shard seven.");
+ expect(rendered).toContain("◆ Agent message sent · Worker · Continue with shard eight.");
+ expect(rendered).not.toContain("Agent message received");
+ });
+});