@springbrand/agent-runtime 0.3.0-alpha.2 → 0.3.0-alpha.21

package/src/conversation/harness-resume.ts

@@ -1,14 +1,14 @@
-import { HarnessClosed, type AgentLane, type LaneSnapshot, type WatchHandle } from "@earendil-works/pi-agent-core";
-import { BACKGROUND_CONTEXT } from "@earendil-works/pi-agent-core/harness/context";
-import type { OperationResultRecord } from "@earendil-works/pi-agent-core/harness/session";
+import type { AgentEventStream } from "@earendil-works/pi-durable";
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
 import type { Connection } from "agents";
-import { MessageType } from "agents/chat";
+import { MessageType, STREAM_RESUME_NONE_REASONS } from "agents/chat";
 import type { UIMessage, UIMessageChunk } from "ai";
+import type { SessionHarness, SessionRunOutcome } from "../harness/session-harness";
 import type { ConversationHistory } from "./history";
 import { HarnessStreamProjection } from "./harness-stream";
 
 interface ActiveConversation {
-  lane: AgentLane;
+  runtime: SessionHarness;
   submissionId: string;
   requestId: string;
   assistantMessageId: string;
@@ -18,271 +18,122 @@ interface ActiveConversation {
 interface ResumeConnection {
   connection: Connection;
   source: ActiveConversation;
-  ready: Promise<void>;
-  watch?: WatchHandle<LaneSnapshot>;
-  projection?: HarnessStreamProjection;
-  acknowledging: boolean;
-  replay?: Promise<void>;
-  terminal?: OperationResultRecord;
-  released?: boolean;
-  finished?: boolean;
+  watch: AgentEventStream;
+  projection: HarnessStreamProjection;
+  delivery: Promise<void>;
+  started: boolean;
 }
 
-
-/** CF's resume handshake, with its replay prefix and subsequent events sourced only from Pi. */
+/** Pi supplies the atomic snapshot and deltas; this boundary owns the CF transport handshake. */
 export class HarnessConversationBridge {
   private active?: ActiveConversation;
   private readonly connections = new Map<string, ResumeConnection>();
-
   constructor(private readonly host: {
     history: Pick<ConversationHistory, "browserMessages" | "browserSnapshot">;
     send: (connection: Connection, body: string) => void | Promise<void>;
     broadcast: (body: string, excludedConnectionIds: string[]) => void;
   }) {}
-
-  activate(lane: AgentLane, submission: Omit<ActiveConversation, "lane">): void {
-    this.active = { lane, ...submission };
+  activate(runtime: SessionHarness, submission: Omit<ActiveConversation, "runtime">): void { this.active = { runtime, ...submission }; }
+  private replayMessage(messages: UIMessage[], submissionId: string) {
+    return [...messages].reverse().find((message) => message.role === "assistant" && (message.metadata as { turnId?: string } | undefined)?.turnId === submissionId);
   }
-
-  private replayMessage(messages: UIMessage[], submissionId: string): UIMessage | undefined {
-    return messages.filter((message) => message.role === "assistant" &&
-      (message.metadata as { turnId?: string } | undefined)?.turnId === submissionId).at(-1);
-  }
-
-  private historyBeforeReplay(messages: UIMessage[], submissionId: string): UIMessage[] {
-    const target = this.replayMessage(messages, submissionId);
-    return target ? messages.filter((message) => message.id !== target.id) : messages;
-  }
-
-  /** Reads never release lifecycle state; hydration leaves the active reply to replay. */
   async messages(view: "full" | "hydration" = "full"): Promise<UIMessage[]> {
-    for (;;) {
-      const source = this.active;
-      let watch: WatchHandle<LaneSnapshot> | undefined;
-      if (source) {
-        try { watch = await source.lane.watch(BACKGROUND_CONTEXT); }
-        catch (error) {
-          if (!(error instanceof HarnessClosed)) throw error;
-        }
-      }
-      try {
-        const messages = watch
-          ? await this.host.history.browserSnapshot(watch.snapshot)
-          : await this.host.history.browserMessages();
-        if (this.active !== source) continue;
-        return view === "hydration" && source && watch?.snapshot.operation?.id === source.submissionId
-          ? this.historyBeforeReplay(messages, source.submissionId)
-          : messages;
-      } finally { watch?.unsubscribe(); }
-    }
-  }
-
-  private async send(connection: Connection, frame: unknown): Promise<void> {
-    const session = this.connections.get(connection.id);
-    try { await this.host.send(connection, JSON.stringify(frame)); }
-    catch { if (session) this.discard(session); }
-  }
-
-  private async sendHistory(connection: Connection, messages: UIMessage[]): Promise<void> {
-    await this.send(connection, { type: MessageType.CF_AGENT_CHAT_MESSAGES, messages });
-  }
-
-  private async sendIdleHistory(connection: Connection, probeId?: string): Promise<void> {
     const source = this.active;
-    const session = this.connections.get(connection.id);
-    const messages = await this.host.history.browserMessages();
-    if (this.connections.get(connection.id) !== session) return;
-    if (this.active !== source) return this.resume(connection, probeId);
-    await this.sendHistory(connection, messages);
-    if (this.connections.get(connection.id) !== session) return;
-    if (this.active !== source) return this.resume(connection, probeId);
-    await this.send(connection, { type: MessageType.CF_AGENT_STREAM_RESUME_NONE, ...(probeId ? { probeId } : {}) });
+    if (!source) return this.host.history.browserMessages();
+    const watch = await source.runtime.watch(BACKGROUND_CONTEXT);
+    try {
+      const messages = await this.host.history.browserSnapshot(watch.snapshot, source.submissionId);
+      const replay = this.replayMessage(messages, source.submissionId);
+      return view === "hydration" && watch.snapshot.run && replay ? messages.filter((message) => message.id !== replay.id) : messages;
+    } finally { await watch.stop(); }
   }
-
-  private async sendChunks(session: ResumeConnection, chunks: readonly UIMessageChunk[], replay = false): Promise<void> {
+  private send(connection: Connection, frame: unknown) { return this.host.send(connection, JSON.stringify(frame)); }
+  private async chunks(session: ResumeConnection, chunks: readonly UIMessageChunk[], replay = false) {
     for (const chunk of chunks) {
       if (this.connections.get(session.connection.id) !== session) return;
-      await this.send(session.connection, {
-        type: MessageType.CF_AGENT_USE_CHAT_RESPONSE,
-        id: session.source.requestId,
-        body: JSON.stringify(chunk), done: false,
-        ...(replay ? { replay: true, continuation: false } : {}),
-      });
+      await this.send(session.connection, { type: MessageType.CF_AGENT_USE_CHAT_RESPONSE, id: session.source.requestId, body: JSON.stringify(chunk), done: false, ...(replay ? { replay: true, continuation: false } : {}) });
     }
   }
-
-  async resume(connection: Connection, probeId?: string): Promise<void> {
+  /**
+   * A socket just opened: offer the live stream if one exists, otherwise only
+   * sync messages. Like Cloudflare's AIChatAgent, an idle connect sends no
+   * STREAM_RESUME_NONE. The client answers its own resume probe from the
+   * reply that carries its probeId; an unsolicited, probe-less "none" arriving
+   * first consumes that pending probe without clearing the client's
+   * server-streaming state, which leaves a reconnected Chat stuck streaming
+   * after a Turn that ended while it was offline.
+   */
+  connect(connection: Connection): Promise<void> {
+    return this.resume(connection, undefined, false);
+  }
+  /** Answer a client's stream-resume request; `announceIdle` is false only for {@link connect}. */
+  async resume(connection: Connection, probeId?: string, announceIdle = true): Promise<void> {
+    this.disconnect(connection);
     const source = this.active;
-    if (!source) {
-      return this.sendIdleHistory(connection, probeId);
-    }
-    let session = this.connections.get(connection.id);
-    if (!session || session.source !== source) {
-      this.disconnect(connection);
-      session = { connection, source, ready: Promise.resolve(), acknowledging: false };
-      this.connections.set(connection.id, session);
-      const current = session;
-      current.ready = (async () => {
-        const watch = await source.lane.watch(BACKGROUND_CONTEXT);
-        if (this.connections.get(connection.id) !== current) { watch.unsubscribe(); return; }
-        current.watch = watch;
-      })();
+    if (!source) return this.idle(connection, probeId, announceIdle);
+    const watch = await source.runtime.watch(BACKGROUND_CONTEXT);
+    if (this.active !== source) { await watch.stop(); return this.resume(connection, probeId, announceIdle); }
+    if (!watch.snapshot.run) {
+      await watch.stop();
+      return this.idle(connection, probeId, announceIdle);
     }
-    try { await session.ready; }
-    catch (error) {
-      if (this.connections.get(connection.id) !== session) return;
-      this.discard(session);
-      if (this.active !== source) return this.resume(connection, probeId);
-      if (error instanceof HarnessClosed) {
-        await this.sendIdleHistory(connection, probeId);
-      }
-      return;
-    }
-    if (this.connections.get(connection.id) !== session) return;
-    if (this.active !== source) {
-      this.discard(session);
-      return this.resume(connection, probeId);
-    }
-    const snapshot = session.watch?.snapshot;
-    if (!snapshot?.operation || snapshot.operation.id !== source.submissionId) {
-      this.discard(session);
-      return this.sendIdleHistory(connection, probeId);
-    }
-    if (!session.acknowledging) {
-      const messages = await this.host.history.browserSnapshot(snapshot);
-      if (this.connections.get(connection.id) !== session) return;
-      if (this.active !== source) { this.discard(session); return this.resume(connection, probeId); }
-      await this.sendHistory(connection, this.historyBeforeReplay(messages, source.submissionId));
-    }
-    if (this.connections.get(connection.id) !== session) return;
-    if (this.active !== source) { this.discard(session); return this.resume(connection, probeId); }
-    await this.send(connection, {
-      type: MessageType.CF_AGENT_STREAM_RESUMING, id: source.requestId,
-      ...(probeId ? { probeId } : {}),
-    });
+    const messages = await this.host.history.browserSnapshot(watch.snapshot, source.submissionId);
+    const replay = this.replayMessage(messages, source.submissionId);
+    const session: ResumeConnection = { connection, source, watch, projection: new HarnessStreamProjection({ messageId: source.assistantMessageId, userMessageId: source.userMessageId, startedAt: source.createdAt, turnId: source.submissionId }), delivery: Promise.resolve(), started: false };
+    this.connections.set(connection.id, session);
+    await this.send(connection, { type: MessageType.CF_AGENT_CHAT_MESSAGES, messages: replay ? messages.filter((message) => message.id !== replay.id) : messages });
+    await this.send(connection, { type: MessageType.CF_AGENT_STREAM_RESUMING, id: source.requestId, ...(probeId ? { probeId } : {}) });
+  }
+  /**
+   * No Turn is running. "None" goes first: while the client still observes the
+   * stream it lost, it keeps its own partial answer over any snapshot that has
+   * no more parts, so the settled answer must arrive after it stops observing.
+   */
+  private async idle(connection: Connection, probeId: string | undefined, announceIdle: boolean): Promise<void> {
+    if (announceIdle) await this.send(connection, { type: MessageType.CF_AGENT_STREAM_RESUME_NONE, reason: STREAM_RESUME_NONE_REASONS.IDLE, ...(probeId ? { probeId } : {}) });
+    await this.send(connection, { type: MessageType.CF_AGENT_CHAT_MESSAGES, messages: await this.host.history.browserMessages() });
   }
-
   async acknowledge(connection: Connection, requestId: string): Promise<void> {
     const session = this.connections.get(connection.id);
-    if (!session || session.source.requestId !== requestId || session.acknowledging) return;
-    if (this.active && this.active.submissionId !== session.source.submissionId) {
-      // A queued Submission may already be live when an older offer is ACKed.
-      // End the old transport, then atomically resume the current lane view.
-      this.disconnect(connection);
-      const current = this.resume(connection);
-      await this.send(connection, { type: MessageType.CF_AGENT_USE_CHAT_RESPONSE, id: requestId, body: "", done: true });
-      await current;
-      return;
-    }
-    session.acknowledging = true;
-    session.replay = this.replay(session);
-    try {
-      await session.replay;
-      if (session.terminal) await this.finish(session, session.terminal);
-      if (session.released) this.discard(session);
-    } catch { this.discard(session); }
-  }
-
-  private async replay(session: ResumeConnection): Promise<void> {
-    const connection = session.connection;
-    const requestId = session.source.requestId;
-    await session.ready;
-    if (this.connections.get(connection.id) !== session) return;
-    if (!session.watch && this.active?.submissionId === session.source.submissionId) {
-      session.source = this.active;
-      session.released = false;
-      const watch = await this.active.lane.watch(BACKGROUND_CONTEXT);
-      if (this.connections.get(connection.id) !== session) { watch.unsubscribe(); return; }
-      session.watch = watch;
-    }
-    const watch = session.watch;
-    const messages = watch ? await this.host.history.browserSnapshot(watch.snapshot) : await this.host.history.browserMessages();
-    if (this.connections.get(connection.id) !== session) return;
-    const source = session.source;
-    const message = this.replayMessage(messages, source.submissionId) ?? {
-      id: source.assistantMessageId, role: "assistant" as const, parts: [],
-      metadata: { turnId: source.submissionId, userMessageId: source.userMessageId,
-        createdAt: source.createdAt, turnStatus: "running" },
-    };
-    const projection = new HarnessStreamProjection({
-      messageId: message.id, startedAt: source.createdAt, turnId: source.submissionId,
-      userMessageId: source.userMessageId,
-    });
-    session.projection = projection;
-    const prefix = projection.restore(message, Boolean(watch?.snapshot.operation?.streamingMessage));
-    await this.sendChunks(session, prefix, true);
-    if (this.connections.get(connection.id) !== session) return;
-    await this.send(connection, { type: MessageType.CF_AGENT_USE_CHAT_RESPONSE,
-      id: requestId, body: "", done: false, replayComplete: true });
-    if (this.connections.get(connection.id) !== session) return;
-    watch?.start(async (event) => {
-      if ("runId" in event && event.runId !== source.submissionId) return;
-      await this.sendChunks(session, projection.event(event));
-    });
+    if (!session || session.source.requestId !== requestId || session.started) return;
+    session.started = true;
+    const messages = await this.host.history.browserSnapshot(session.watch.snapshot, session.source.submissionId);
+    const replay = this.replayMessage(messages, session.source.submissionId);
+    if (replay) await this.chunks(session, session.projection.restore(replay, Boolean(session.watch.snapshot.generation?.message), session.watch.snapshot), true);
+    await this.send(session.connection, { type: MessageType.CF_AGENT_USE_CHAT_RESPONSE, id: session.source.requestId, body: "", done: false, replayComplete: true });
+    session.watch.start((events) => session.delivery = (async () => {
+      for (const event of events) {
+        if (event.type === "snapshot") {
+          await this.resume(session.connection);
+          return;
+        } else await this.chunks(session, session.projection.event(event));
+      }
+    })());
   }
-
-  private async finish(session: ResumeConnection, record: OperationResultRecord): Promise<void> {
-    if (session.finished || !session.projection) return;
-    session.finished = true;
-    await session.watch?.drain();
-    await this.sendChunks(session, session.projection.finish(record));
-    if (this.connections.get(session.connection.id) === session) {
-      await this.send(session.connection, { type: MessageType.CF_AGENT_USE_CHAT_RESPONSE,
-        id: session.source.requestId, body: "", done: true });
+  async settle(outcome: SessionRunOutcome): Promise<void> {
+    for (const session of this.connections.values()) {
+      await session.watch.stop(); await session.delivery;
+      if (session.started) {
+        await this.chunks(session, session.projection.finish(outcome));
+      }
+      await this.send(session.connection, { type: MessageType.CF_AGENT_USE_CHAT_RESPONSE, id: session.source.requestId, body: "", done: true });
     }
+    if (this.active) this.broadcastResponse({ id: this.active.requestId, body: "", done: true });
   }
-
-  /** Called only after the Host has persisted the Submission's terminal result. */
-  async settle(record: OperationResultRecord): Promise<void> {
-    await Promise.all([...this.connections.values()].filter((session) =>
-      session.source.submissionId === record.operationId).map(async (session) => {
-      session.terminal = record;
-      try {
-        if (session.replay) await session.replay;
-        await this.finish(session, record);
-      } catch { this.discard(session); }
-    }));
-    if (this.active?.submissionId === record.operationId) {
-      this.broadcastResponse({ id: this.active.requestId, body: "", done: true });
+  async release(runtime: SessionHarness): Promise<void> {
+    if (this.active?.runtime === runtime) this.active = undefined;
+    for (const session of [...this.connections.values()]) {
+      if (session.source.runtime !== runtime) continue;
+      await session.watch.stop(); await session.delivery; this.connections.delete(session.connection.id);
     }
   }
-
-  /** Called after a drive returns, outside Pi event listeners. */
-  async release(lane: AgentLane): Promise<void> {
-    if (this.active?.lane === lane) this.active = undefined;
-    await Promise.all([...this.connections.values()].filter((session) => session.source.lane === lane)
-      .map(async (session) => {
-        try {
-          await session.ready;
-          if (session.replay) await session.replay;
-          if (session.projection) {
-            await session.watch?.drain();
-            this.discard(session);
-          } else {
-            session.watch?.unsubscribe();
-            session.watch = undefined;
-            session.released = true;
-          }
-        } catch { this.discard(session); }
-      }));
-  }
-
   disconnect(connection: Pick<Connection, "id">): void {
     const session = this.connections.get(connection.id);
-    if (session) this.discard(session);
+    if (session) { this.connections.delete(connection.id); void session.watch.stop(); }
   }
-
-  private discard(session: ResumeConnection): void {
-    if (this.connections.get(session.connection.id) !== session) return;
-    session.watch?.unsubscribe();
-    this.connections.delete(session.connection.id);
-  }
-
   broadcastResponse(frame: { id: string; body: string; done: boolean; error?: boolean; continuation?: boolean }): void {
-    // Approval is a Host fact, so it has no duplicate Pi event for the watch to project.
-    const isApproval = frame.body && JSON.parse(frame.body).type === "tool-approval-request";
-    const excluded = isApproval ? [] : [...this.connections.values()]
-      .filter((session) => session.source.requestId === frame.id).map(({ connection }) => connection.id);
+    const approval = frame.body && JSON.parse(frame.body).type === "tool-approval-request";
+    const excluded = approval ? [] : [...this.connections.values()].filter((session) => session.source.requestId === frame.id).map((session) => session.connection.id);
     this.host.broadcast(JSON.stringify({ type: MessageType.CF_AGENT_USE_CHAT_RESPONSE, ...frame }), excluded);
   }
 }

package/src/conversation/harness-stream.ts

@@ -1,98 +1,114 @@
-import type { AgentEvent, Events, HarnessEvent } from "@earendil-works/pi-agent-core";
-import type { OperationResultRecord } from "@earendil-works/pi-agent-core/harness/session";
+import type { AgentEvent as LoopEvent } from "@earendil-works/pi-agent-core";
+import type { AgentEvent, SnapshotEvent } from "@earendil-works/pi-durable";
 import type { AssistantMessage } from "@earendil-works/pi-ai";
 import type { UIMessage, UIMessageChunk } from "ai";
-import { PiChunkEncoder } from "./message";
+import type { SessionHarness, SessionRunOutcome } from "../harness/session-harness";
+import { PiChunkEncoder, type ToolInputPreparer } from "./message";
 
 export interface HarnessStreamOptions {
   readonly messageId: string;
   readonly startedAt: number;
   readonly turnId: string;
   readonly userMessageId?: string | null;
+  readonly prepareToolInput?: ToolInputPreparer;
 }
-
-/** Project the final Host decision without rewriting Pi's canonical operation result. */
-export function projectSubmissionOutcome(
-  record: OperationResultRecord,
-  submission: { status: string; completedAt?: number | null; error?: string | null },
-): OperationResultRecord {
-  const status = submission.status === "aborted" ? "aborted"
-    : submission.status === "error" ? "failed"
-    : submission.status === "skipped" ? "declined" : "completed";
-  const { error: _previousError, ...result } = record;
-  return {
-    ...result, status, endedAt: submission.completedAt ?? record.endedAt,
-    ...((status === "failed" || status === "aborted") && submission.error
-      ? { error: { code: status, message: submission.error } } : {}),
-  };
+export function projectSubmissionOutcome(record: SessionRunOutcome, submission: { status: string; completedAt?: number | null; error?: string | null }): SessionRunOutcome {
+  const status = submission.status === "aborted" ? "aborted" : submission.status === "error" ? "failed" : submission.status === "skipped" ? "declined" : "completed";
+  return { status, endedAt: submission.completedAt ?? record.endedAt, ...(submission.error ? { error: { code: status, message: submission.error } } : {}) };
 }
 
-/** One projection for both broadcast events and a resumed Pi watch. */
+/** Translates native committed Pi deltas into the browser's AI SDK wire protocol. */
 export class HarnessStreamProjection {
   private readonly encoder: PiChunkEncoder;
-  private terminal: AssistantMessage | undefined;
-
-  constructor(options: HarnessStreamOptions) {
-    this.encoder = new PiChunkEncoder(options);
-  }
-
-  restore(message: UIMessage, streaming: boolean): UIMessageChunk[] {
+  private terminal?: AssistantMessage;
+  private readonly shown = new Map<number, string>();
+  private readonly toolInputStarted = new Set<string>();
+  private readonly toolOutput = new Map<string, string>();
+  constructor(options: HarnessStreamOptions) { this.encoder = new PiChunkEncoder(options); }
+  restore(message: UIMessage, streaming: boolean, snapshot?: SnapshotEvent): UIMessageChunk[] {
+    this.shown.clear();
+    snapshot?.generation?.message?.content.forEach((block, index) => {
+      if (block.type === "text") this.shown.set(index, block.text);
+      if (block.type === "thinking") this.shown.set(index, block.thinking);
+    });
+    for (const tool of snapshot?.tools ?? []) if (tool.output !== undefined) this.toolOutput.set(tool.callId, tool.output);
     return this.encoder.restore(message, streaming);
   }
-
-  event(event: HarnessEvent): UIMessageChunk[] {
+  private block(block: AssistantMessage["content"][number], contentIndex: number, settled = false): UIMessageChunk[] {
+    if (block.type === "toolCall" && (!block.id || !block.name)) return [];
+    if (block.type === "toolCall") {
+      // The encoder keeps the first input it sees, so only a settled message may publish arguments.
+      if (settled) return this.encoder.encode({ type: "tool_execution_start", toolCallId: block.id, toolName: block.name, args: block.arguments } as LoopEvent);
+      if (this.toolInputStarted.has(block.id)) return [];
+      this.toolInputStarted.add(block.id);
+      return [{ type: "tool-input-start", toolCallId: block.id, toolName: block.name, dynamic: true }];
+    }
+    if (block.type !== "text" && block.type !== "thinking") return [];
+    const start = block.type === "thinking"
+      ? this.encoder.encode({ type: "message_update", assistantMessageEvent: { type: "thinking_start", contentIndex } } as LoopEvent)
+      : [];
+    const text = block.type === "text" ? block.text : block.thinking;
+    const previous = this.shown.get(contentIndex) ?? "";
+    const delta = text.startsWith(previous) ? text.slice(previous.length) : text;
+    this.shown.set(contentIndex, text);
+    if (!delta) return start;
+    return [...start, ...this.encoder.encode({ type: "message_update", assistantMessageEvent: { type: block.type === "text" ? "text_delta" : "thinking_delta", contentIndex, delta } } as LoopEvent)];
+  }
+  /**
+   * Pi emits `run_start` only when the live run changes, so a stream bound to a continued run (after an approval or a
+   * slice release) sees tool or message frames first. The encoder's start is idempotent; lead the first frames with it.
+   */
+  private started(chunks: UIMessageChunk[]): UIMessageChunk[] {
+    return chunks.length === 0 ? chunks : [...this.encoder.start(), ...chunks];
+  }
+  event(event: AgentEvent): UIMessageChunk[] { return this.started(this.frames(event)); }
+  private frames(event: AgentEvent): UIMessageChunk[] {
     switch (event.type) {
-      case "run_start":
-      case "run_resume": return this.encoder.start();
-      case "turn_start":
-        this.terminal = undefined;
-        return this.encoder.encode({ type: "turn_start" } as AgentEvent);
-      case "message_update":
-        return event.event.type === "error" ? [] : this.encoder.encode({
-          type: "message_update", message: event.message, assistantMessageEvent: event.event,
-        } as AgentEvent);
-      case "tool_start": return this.encoder.encode({
-        type: "tool_execution_start", toolCallId: event.toolCallId, toolName: event.toolName, args: event.args,
-      } as AgentEvent);
-      case "tool_update": return this.encoder.encode({
-        type: "tool_execution_update", toolCallId: event.toolCallId, toolName: event.toolName, args: {}, partialResult: event.partialResult,
-      } as AgentEvent);
-      case "tool_end": return this.encoder.encode({
-        type: "tool_execution_end", toolCallId: event.toolCallId, toolName: event.toolName, result: event.result, isError: event.isError,
-      } as AgentEvent);
-      case "message_end":
-        if (event.message.role !== "assistant") return [];
-        this.terminal = event.message;
-        return this.encoder.encode({ type: "message_end", message: event.message } as AgentEvent, { terminal: false });
+      case "run_start": return this.encoder.start();
+      case "turn_start": this.terminal = undefined; this.shown.clear(); return this.encoder.encode({ type: "turn_start" } as LoopEvent);
+      case "message_start": return event.message.role === "assistant" ? event.message.content.flatMap((block, index) => this.block(block, index)) : [];
+      case "message_update": return event.changes.flatMap((change) => {
+        if (change.type === "message") return change.message.content.flatMap((block, index) => this.block(block, index));
+        if (change.type === "text_start" || change.type === "thinking_start" || change.type === "block" || change.type === "toolcall_start") return this.block(change.block, change.contentIndex);
+        if (change.type !== "text_delta" && change.type !== "thinking_delta") return [];
+        this.shown.set(change.contentIndex, (this.shown.get(change.contentIndex) ?? "") + change.delta);
+        return this.encoder.encode({ type: "message_update", assistantMessageEvent: change } as LoopEvent);
+      });
+      case "tool_execution_start": return this.encoder.encode(event as LoopEvent);
+      case "tool_execution_update": {
+        let output = this.toolOutput.get(event.toolCallId) ?? "";
+        if (event.output) output = "set" in event.output ? event.output.set : output.slice(event.output.trimStart ?? 0) + (event.output.append ?? "");
+        this.toolOutput.set(event.toolCallId, output);
+        return this.encoder.encode({ type: "tool_execution_update", toolCallId: event.toolCallId, toolName: event.toolName, args: {}, partialResult: { content: [{ type: "text", text: output }], details: event.details } } as LoopEvent);
+      }
+      case "tool_execution_end": {
+        const result = event.entry?.model?.[0];
+        return this.encoder.encode({ type: "tool_execution_end", toolCallId: event.toolCallId, toolName: event.toolName, result: result?.role === "toolResult" ? result : { content: [{ type: "text", text: "Tool execution interrupted" }] }, isError: result?.role !== "toolResult" || result.isError } as LoopEvent);
+      }
+      case "message_end": {
+        const message = event.entry.model?.[0];
+        if (message?.role !== "assistant") return [];
+        this.terminal = message;
+        return [...message.content.flatMap((block, index) => this.block(block, index, true)), ...this.encoder.encode({ type: "message_end", message }, { terminal: false })];
+      }
       default: return [];
     }
   }
-
-  approvalRequested(toolCallId: string, approvalId: string): UIMessageChunk[] {
-    return this.encoder.approvalRequested(toolCallId, approvalId);
-  }
-
-  finish(result: Pick<OperationResultRecord, "status" | "endedAt" | "error">): UIMessageChunk[] {
-    return this.encoder.finish({
-      stopReason: result.status === "aborted" ? "aborted" : result.status === "failed" ? "error" :
-        this.terminal?.stopReason === "length" ? "length" : "stop",
-      timestamp: result.endedAt,
-      ...(result.error?.message ? { errorMessage: result.error.message } : {}),
-    });
+  approvalRequested(toolCallId: string, approvalId: string): UIMessageChunk[] { return this.started(this.encoder.approvalRequested(toolCallId, approvalId)); }
+  finish(result: SessionRunOutcome): UIMessageChunk[] {
+    return this.started(this.encoder.finish({ stopReason: result.status === "aborted" ? "aborted" : result.status === "failed" ? "error" : this.terminal?.stopReason === "length" ? "length" : "stop", timestamp: result.endedAt, ...(result.error ? { errorMessage: result.error.message } : {}) }));
   }
 }
 
-const STREAM_EVENTS = ["run_start", "run_resume", "turn_start", "message_update", "tool_start", "tool_update", "tool_end", "message_end"] as const;
-
-export function bindHarnessStream(
-  events: Events,
-  options: HarnessStreamOptions & { readonly publish: (chunks: readonly UIMessageChunk[]) => Promise<void> },
-) {
+export async function bindHarnessStream(runtime: SessionHarness, options: HarnessStreamOptions & { readonly publish: (chunks: readonly UIMessageChunk[]) => Promise<void> }) {
   const projection = new HarnessStreamProjection(options);
-  const unsubscribers = STREAM_EVENTS.map((type) => events.on(type, (event) => options.publish(projection.event(event))));
+  const watch = await runtime.watch((await import("@earendil-works/chord/context")).BACKGROUND_CONTEXT);
+  let delivery: Promise<void> = Promise.resolve();
+  watch.start((events) => delivery = (async () => { for (const event of events) await options.publish(projection.event(event)); })());
   return {
     publishApprovalRequest: (toolCallId: string, approvalId: string) => options.publish(projection.approvalRequested(toolCallId, approvalId)),
-    flushTerminal: (result: OperationResultRecord) => options.publish(projection.finish(result)),
-    unsubscribe: () => { for (const unsubscribe of unsubscribers) unsubscribe(); },
+    // The Host follows the terminal frame with the canonical transcript, which completes any frame Pi's stop dropped.
+    flushTerminal: async (result: SessionRunOutcome) => { await watch.stop(); await delivery; await options.publish(projection.finish(result)); },
+    unsubscribe: async () => { await watch.stop(); await delivery; },
   };
 }