@springbrand/agent-runtime 0.3.0-alpha.16 → 0.3.0-alpha.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@springbrand/agent-runtime",
-  "version": "0.3.0-alpha.16",
+  "version": "0.3.0-alpha.18",
   "type": "module",
   "files": [
     "src",
@@ -21,13 +21,15 @@
     "@cloudflare/sandbox": "0.12.4",
     "@cloudflare/shell": "0.4.3",
     "@cloudflare/think": "0.18.0",
-    "@earendil-works/pi-agent-core": "0.86.1",
-    "@earendil-works/pi-ai": "0.86.1",
+    "@earendil-works/pi-agent-core": "1.1.0",
+    "@earendil-works/pi-ai": "1.1.0",
     "@types/lodash-es": "^4.17.12",
     "cron-schedule": "6.0.0",
     "isomorphic-git": "1.38.6",
     "lodash-es": "^4.18.1",
-    "zod": "^4.4.3"
+    "zod": "^4.4.3",
+    "@earendil-works/pi-durable": "1.1.0",
+    "@earendil-works/chord": "1.1.0"
   },
   "peerDependencies": {
     "agents": "^0.23.0",

package/src/adapter/cloudflare/agent.ts

@@ -69,9 +69,9 @@ import type {
   AssistantMessage,
   JsonObject,
 } from "@earendil-works/pi-ai";
-import { BACKGROUND_CONTEXT } from "@earendil-works/pi-agent-core/harness/context";
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
 import { openCloudflareSession } from "../../session";
-import { openSessionHarness, prepareSubmissionOperation } from "../../harness";
+import { ModelRecovery, openSessionHarness, prepareSubmissionOperation } from "../../harness";
 import type { SessionHarness } from "../../harness";
 import {
   compileHarnessTools,
@@ -185,7 +185,7 @@ export abstract class AgentRuntimeKernel<
 
   private activeRuntime?: ActiveRuntime;
   private telemetryCoordinator?: RuntimeTelemetryCoordinator;
-  private activeHarness?: SessionHarness<object | undefined>;
+  private activeHarness?: SessionHarness;
   private piAdapter?: HarnessRuntimeConfig;
   private readonly transcript: ConversationHistory;
   private conversationBridge?: HarnessConversationBridge;
@@ -370,14 +370,14 @@ export abstract class AgentRuntimeKernel<
     runtime: Awaited<ReturnType<typeof openSessionHarness>>,
     submissionId: string,
   ): Promise<void> {
-    const watch = await runtime.lane.watch(BACKGROUND_CONTEXT);
-    try {
-      this.db.transaction(() =>
-        this.db.submissions.associateSessionEntries(submissionId, watch.snapshot)
-      );
-    } finally {
-      watch.unsubscribe();
-    }
+    const native = await runtime.submissionFor(submissionId, BACKGROUND_CONTEXT);
+    if (!native || native.entry === undefined) return;
+    const entries = await runtime.entries();
+    const start = entries.findIndex((entry) => entry.id === native.entry);
+    if (start < 0) throw new Error("Native Submission entry is missing from its conversation");
+    this.db.transaction(() => {
+      for (const entry of entries.slice(start)) this.db.submissions.linkSessionEntry(String(entry.id), submissionId);
+    });
   }
 
   /**
@@ -632,11 +632,16 @@ export abstract class AgentRuntimeKernel<
       releaseAbortedHarness: async () => {
         const runtime = this.activeHarness;
         if (!runtime) return;
-        await runtime.lane.waitForIdle(BACKGROUND_CONTEXT);
-        if (this.activeHarness === runtime) this.activeHarness = undefined;
-        await runtime.close(BACKGROUND_CONTEXT);
+        await runtime.conversation.waitForIdle(BACKGROUND_CONTEXT);
+        // The execution owner closes after transport projections settle.
+
+      },
+      cancelQueued: async (id) => {
+        const runtime = this.activeHarness;
+        if (!runtime) return undefined;
+        const result = await runtime.harness.abortSubmission(Number(id) as import("@earendil-works/pi-durable").SubmissionId, BACKGROUND_CONTEXT, runtime.conversation.id);
+        return { kind: result === "already_placed" || result === "settled" ? "already_consumed" as const : "cancelled" as const };
       },
-      cancelQueued: async (id) => this.activeHarness?.lane.cancelQueued(id, BACKGROUND_CONTEXT),
       submit: (message, options) => this.submitMessage(message, options),
       waitUntil: (promise) => this.ctx.waitUntil(promise),
     });
@@ -784,12 +789,19 @@ export abstract class AgentRuntimeKernel<
       (key) => this.ensureRuntimeVersion(key),
     );
     const activeRuntime = this.requireRuntime();
+    // A fresh provider Session per Submission keeps one failing upstream route from pinning later turns.
+    const recovery = new ModelRecovery(submissionId);
     const harnessInput = this.pi.harnessInputs(
       activeRuntime.pi,
       submission.assemblyDescriptor,
       {
-        modelSessionId: submissionId,
-        onGeneration: (event) => this.telemetry.generation(submissionId, event),
+          modelSessionId: () => recovery.sessionId(),
+          assertRequestAllowed: () => {
+            const current = this.db.submissions.find(submissionId);
+            if (current?.abortReason || current?.unattendedFailure) throw new Error(current.abortReason ?? current.unattendedFailure!);
+          },
+          onGeneration: (event) => this.telemetry.generation(submissionId, event),
+          onCompactionGeneration: (event) => this.runtimeTurnEvents.compactionGeneration(submissionId, event),
       },
     );
     const prepareToolInput = (toolName: string, input: unknown): unknown => {
@@ -848,9 +860,8 @@ export abstract class AgentRuntimeKernel<
       unattendedFailure: () => this.db.submissions.find(submissionId)?.unattendedFailure,
     });
     runtime = await openSessionHarness({
-      session: openCloudflareSession(this.ctx.storage),
+      storage: openCloudflareSession(this.ctx.storage),
       models: harnessInput.models,
-      modelSessionId: submissionId,
       model: harnessInput.model,
       thinkingLevel: harnessInput.thinkingLevel,
       systemPrompt: harnessInput.systemPrompt,
@@ -867,35 +878,20 @@ export abstract class AgentRuntimeKernel<
       streamOptions: { maxRetries: 0 },
       compaction: harnessInput.compaction,
       toolExecution: "parallel",
+      recovery,
+      beforeTool: (call, _api, context) => gate.beforeTool({ toolName: call.name, toolCallId: call.id, args: call.arguments }, context),
+      afterResponse: (message) => {
+        for (const part of message.content) if (part.type === "toolCall") part.arguments = prepareToolInput(part.name, part.arguments) as JsonObject;
+      },
     }, BACKGROUND_CONTEXT);
     this.activeHarness = runtime;
-    let stream: ReturnType<typeof bindHarnessStream> | undefined;
+    let stream: Awaited<ReturnType<typeof bindHarnessStream>> | undefined;
     let deactivate = () => {};
+    let released = false;
     try {
-      runtime.harness.hooks.on("after_response", ({ message }) => {
-        for (const part of message.content) {
-          if (part.type === "toolCall") {
-            part.arguments = prepareToolInput(
-              part.name,
-              part.arguments,
-            ) as JsonObject;
-          }
-        }
-        return { message };
-      });
-      runtime.harness.hooks.on("before_tool", gate.beforeTool);
-      runtime.harness.hooks.on("before_drive", async (event, context) => {
-        const current = this.db.submissions.find(submissionId);
-        if (current?.abortReason || current?.unattendedFailure) {
-          await runtime.requestAbort(event.runId, context);
-        }
-      });
 
       if ((submission.abortReason || submission.unattendedFailure) && runtime.openOperation) {
-        await runtime.requestAbort(
-          runtime.openOperation.operationId,
-          BACKGROUND_CONTEXT,
-        );
+        await runtime.abort(BACKGROUND_CONTEXT);
       }
 
       await this.associateHarnessEntries(runtime, submissionId);
@@ -906,25 +902,6 @@ export abstract class AgentRuntimeKernel<
         (id) => this.transcript.regenerationTarget(id),
         BACKGROUND_CONTEXT,
       );
-      if (preparation.kind === "settled") {
-        const record = preparation.outcome;
-        const unattendedFailure = this.db.submissions.find(submissionId)
-          ?.unattendedFailure;
-        const terminal = await this.submissions.finish(
-          submission,
-          unattendedFailure
-            ? "failed"
-            : record.status === "completed" || record.status === "declined"
-            ? "succeeded" : record.status === "aborted" ? "aborted" : "failed",
-          unattendedFailure ?? record.error?.message,
-        );
-        this.broadcast(json({
-          type: MessageType.CF_AGENT_CHAT_MESSAGES,
-          messages: await this.getMessages(),
-        }));
-        return terminal;
-      }
-
       if (submission.status === "pending") {
         this.db.submissions.transition(submissionId, "running", ["pending"]);
         this.telemetry.capture("turnStarted", {
@@ -938,71 +915,58 @@ export abstract class AgentRuntimeKernel<
         steers: this.db.steers,
         messageUi: this.db.messageUi,
         transaction: (run) => this.db.transaction(run),
-        enqueue: async (message) => {
-          const queued = await runtime.lane.steer(message, undefined, BACKGROUND_CONTEXT);
-          if (!queued.ok) throw queued.error;
-          return queued.value.entryId;
+        enqueue: async (steer) => {
+          const message = JSON.parse(steer.canonicalJson) as PiCanonicalUserInput;
+          const queued = await runtime.conversation.submit({ type: "input", content: message.content, requestId: `steer:${steer.messageId}`, whenBusy: "steer" }, BACKGROUND_CONTEXT);
+          return queued.status(BACKGROUND_CONTEXT);
         },
+        find: (messageId) => runtime.submissionFor(`steer:${messageId}`, BACKGROUND_CONTEXT),
       });
       const uiMessageBody = submission.queuedUiMessageJson;
       let initialUserSidecarPersisted = (await this.transcript.storedMessages())
         .some((entry) =>
           entry.submissionId === submissionId && entry.message.role === "user"
         );
-      runtime.harness.events.on("entry_added", (event) => {
-        const entry = event.entry;
+      const unsubscribeEntries = runtime.harness.subscribeCommits((publication) => {
         this.db.transaction(() => {
-          this.db.submissions.linkSessionEntry(entry.id, submissionId);
-          if (entry.type === "message" && entry.message.role === "user") {
-            if (!steerDelivery.settle(entry.id) && !initialUserSidecarPersisted && uiMessageBody) {
-              this.db.messageUi.upsert(entry.id, uiMessageBody);
+          for (const change of publication.changes) {
+            if (change.type === "submission") steerDelivery.settleRecord(change.value);
+            if (change.type !== "entry" || change.value.conversationId !== runtime.conversation.id) continue;
+            const entry = change.value;
+            this.db.submissions.linkSessionEntry(String(entry.id), submissionId);
+            if (entry.kind === "pi.user" && !initialUserSidecarPersisted && uiMessageBody) {
+              this.db.messageUi.upsert(String(entry.id), uiMessageBody);
               initialUserSidecarPersisted = true;
             }
           }
         });
-
       });
-      const pendingWatch = await runtime.lane.watch(BACKGROUND_CONTEXT);
-      try {
-        await steerDelivery.reconcile(submissionId, pendingWatch.snapshot);
-      } finally {
-        pendingWatch.unsubscribe();
-      }
-
-      this.runtimeTurnEvents.observe(runtime.harness, submissionId, harnessInput.model);
-      stream = bindHarnessStream(runtime.harness.events, {
+      await this.runtimeTurnEvents.observe(runtime, submissionId, harnessInput.model);
+      stream = await bindHarnessStream(runtime, {
         messageId: submission.assistantMessageId,
         userMessageId: submission.userMessageId ?? undefined,
         startedAt: submission.createdAt,
         turnId: submissionId,
         prepareToolInput,
         publish: async (chunks) => {
-          for (const chunk of chunks) {
-            this.conversation.broadcastResponse({
-              id: submission.requestId,
-              body: json(chunk),
-              done: false,
-              continuation,
-            });
-          }
+          for (const chunk of chunks) this.conversation.broadcastResponse({ id: submission.requestId, body: json(chunk), done: false, continuation });
         },
       });
+      deactivate = unsubscribeEntries;
+
       publishApprovalRequest = stream.publishApprovalRequest;
-      this.conversation.activate(runtime.lane, submission);
+      this.conversation.activate(runtime, submission);
 
       const control = {
         abort: async () => {
           if (runtime.openOperation) {
-            await runtime.requestAbort(
-              runtime.openOperation.operationId,
-              BACKGROUND_CONTEXT,
-            );
+            await runtime.abort(BACKGROUND_CONTEXT);
           }
         },
         interrupt: () => void runtime.close(BACKGROUND_CONTEXT),
         steer: async (_message: PiCanonicalUserInput, messageId: string) => {
           const steer = this.db.steers.findByMessageId(messageId);
-          if (steer) await steerDelivery.queue(steer);
+          if (steer && runtime.openOperation) await steerDelivery.queue(steer);
         },
       };
       const turn: ActiveTurn = {
@@ -1013,32 +977,20 @@ export abstract class AgentRuntimeKernel<
         continuation,
         agent: control,
       };
-      deactivate = this.submissions.activate(submission, turn);
-      const outcome = await runtime.run(preparation.request, BACKGROUND_CONTEXT, {
-        pollDeferred: !preparation.request,
-      });
+      const deactivateTurn = this.submissions.activate(submission, turn);
+      const unsubscribeEntriesAndTurn = deactivate;
+      deactivate = () => { unsubscribeEntriesAndTurn(); deactivateTurn(); };
+      await runtime.admit(preparation, BACKGROUND_CONTEXT);
+      await steerDelivery.reconcile(submissionId);
+      const outcome = await runtime.run(undefined, BACKGROUND_CONTEXT);
       this.db.submissions.clearQueuedPayload(submissionId);
       if (outcome.kind === "released") {
-        if (
-          outcome.reason === "slice" ||
-          outcome.reason === "budget" ||
-          outcome.reason === "tool-failure"
-        ) {
+        if (outcome.reason === "slice") {
           await this.schedule(0, "_piHarnessContinuation", { submissionId }, {
             idempotent: true,
           });
         }
-        return this.db.submissions.find(submissionId)!;
-      }
-      if (outcome.kind === "waiting") {
-        await this.schedule(
-          outcome.reason === "retry"
-            ? Math.max(0, Math.ceil((outcome.notBefore - Date.now()) / 1000))
-            : Math.max(0, Math.ceil((outcome.deferred.pollAfterMs ?? 1_000) / 1000)),
-          "_piHarnessContinuation",
-          { submissionId },
-          { idempotent: true },
-        );
+        released = true;
         return this.db.submissions.find(submissionId)!;
       }
       const record = outcome.outcome;
@@ -1072,13 +1024,21 @@ export abstract class AgentRuntimeKernel<
       }));
       throw error;
     } finally {
-      await this.conversation.release(runtime.lane).catch((error) => {
+      await this.conversation.release(runtime).catch((error) => {
         console.warn("[runtime-stream:degraded]", errorText(error));
       });
-      stream?.unsubscribe();
+      await stream?.unsubscribe();
       deactivate();
       if (this.activeHarness === runtime) this.activeHarness = undefined;
       await runtime.close(BACKGROUND_CONTEXT).catch(() => undefined);
+      if (released) {
+        // Pi closes the Harness on release and drops undelivered stream frames; the
+        // canonical transcript gives a paused question or approval its complete input.
+        this.broadcast(json({
+          type: MessageType.CF_AGENT_CHAT_MESSAGES,
+          messages: await this.getMessages(),
+        }));
+      }
     }
   }
 
@@ -1209,10 +1169,8 @@ export abstract class AgentRuntimeKernel<
 
     if (event.type === "clear") {
       if (this.submissions.isBusy()) return;
-      this.db.transaction(() => {
-        this.transcript.clear();
-        this.db.clearAll();
-      });
+      await this.transcript.clear();
+      this.db.transaction(() => this.db.clearAll());
       await this.broadcastApprovals();
       this.broadcast(json({ type: MessageType.CF_AGENT_CHAT_CLEAR }));
       return;
@@ -1354,7 +1312,7 @@ export abstract class AgentRuntimeKernel<
       await this.broadcastApprovals();
       return;
     }
-    this.transcript.append(crypto.randomUUID(), message);
+    await this.transcript.append(crypto.randomUUID(), message);
   }
 
   async _hostGetSessionInfo(): Promise<{ messageCount: number }> {
@@ -1377,7 +1335,7 @@ export abstract class AgentRuntimeKernel<
   async addCanonicalSnapshot(
     snapshot: PiCanonicalTranscriptSnapshot,
   ): Promise<void> {
-    this.transcript.importSnapshot(snapshot);
+    await this.transcript.importSnapshot(snapshot);
   }
 
   /**

package/src/adapter/cloudflare/subagent/definition.ts

@@ -7,7 +7,7 @@ import {
   type FiberRecoveryContext,
   type FiberRecoveryResult,
 } from "agents";
-import type { HarnessEvent } from "@earendil-works/pi-agent-core";
+import type { AgentEvent as HarnessEvent } from "@earendil-works/pi-durable";
 import type { UIMessageChunk } from "ai";
 import {
   AGENT_TYPES,
@@ -96,25 +96,27 @@ function stringifyJson(value: unknown): string {
 function progressFor(
   event: HarnessEvent,
 ): Omit<AgentToolProgressSnapshot, "at"> | null {
-  if (event.type === "run_start" || event.type === "run_resume") {
+  if (event.type === "run_start") {
     return { phase: "running", message: "SubAgent started" };
   }
-  if (event.type === "tool_start") {
+  if (event.type === "tool_execution_start") {
     return {
       phase: "tool",
       message: `Running ${event.toolName}`,
     };
   }
-  if (event.type === "tool_update") {
+  if (event.type === "tool_execution_update") {
     return {
       phase: "tool",
       message: `${event.toolName} is still running`,
     };
   }
-  if (event.type === "tool_end") {
+  if (event.type === "tool_execution_end") {
+    const result = event.entry?.model?.[0];
+    const isError = result?.role !== "toolResult" || result.isError;
     return {
-      phase: event.isError ? "tool-error" : "tool",
-      message: event.isError
+      phase: isError ? "tool-error" : "tool",
+      message: isError
         ? `${event.toolName} failed`
         : `${event.toolName} completed`,
     };
@@ -414,14 +416,24 @@ export abstract class CloudflareSubAgent<
         tools,
         signal,
         onEvent: (event) => {
-          if (event.type === "message_end" && event.message.role === "assistant") {
-            addSubagentUsage(usage, event.message.usage);
+          if (event.type === "message_end" && event.entry.model?.[0]?.role === "assistant") {
+            addSubagentUsage(usage, event.entry.model[0].usage);
             this.persistUsage(runId, usage);
           }
           publish(projection!.event(event));
           const progress = progressFor(event);
           if (progress) this.persistProgress(runId, progress);
         },
+        // Live frames can stop short of the last response; the canonical entries are the billed total.
+        onEntries: (entries) => {
+          const canonical = emptySubagentUsage();
+          for (const entry of entries) {
+            const message = entry.model?.[0];
+            if (message?.role === "assistant") addSubagentUsage(canonical, message.usage);
+          }
+          Object.assign(usage, canonical);
+          this.persistUsage(runId, usage);
+        },
       });
       publish(projection.finish({ status: "completed", endedAt: Date.now() }));
       this.completeRun(runId, output, usage);

package/src/adapter/cloudflare/subagent/runner.ts

@@ -1,14 +1,10 @@
-import {
-  type AgentHarnessTool,
-  type HarnessEvent,
-  type Session,
-  type StreamFn,
-} from "@earendil-works/pi-agent-core";
+import type { StreamFn } from "@earendil-works/pi-agent-core";
+import type { AgentEvent as HarnessEvent, AgentEventStream, EntryRecord, Storage as Session, ToolRegistration } from "@earendil-works/pi-durable";
 import {
   awaitWithContext,
   BACKGROUND_CONTEXT,
   withAbortSignal,
-} from "@earendil-works/pi-agent-core/harness/context";
+} from "@earendil-works/chord/context";
 import type { Api, AssistantMessage, Model, Models } from "@earendil-works/pi-ai";
 import { z } from "zod";
 import { assembleSubagentPrompt } from "../../../lib/prompt";
@@ -39,11 +35,24 @@ export interface CloudflareSubAgentRun {
   openSession(): Session | Promise<Session>;
   operationId?: string;
   /** Tools compiled by the package's single Harness adapter. */
-  tools?: AgentHarnessTool<object | undefined>[];
+  tools?: ToolRegistration<any, any>[];
   signal?: AbortSignal;
   timeoutMs?: number;
-  /** Native operation events for projections that must survive model retries. */
+  /** Native operation events for live projections; they may stop short of the final frame. */
   onEvent?: (event: HarnessEvent, signal: AbortSignal) => void | Promise<void>;
+  /** This operation's canonical entries after each settle or release, the source of its final usage. */
+  onEntries?: (entries: readonly EntryRecord[]) => void | Promise<void>;
+}
+
+/** The first failed Tool result among an operation's canonical entries. */
+function toolFailureOf(entries: readonly EntryRecord[]): { name: string; error: string } | undefined {
+  for (const entry of entries) {
+    const result = entry.model?.[0];
+    if (result?.role !== "toolResult" || !result.isError) continue;
+    const diagnostics = (entry.data as { diagnostics?: Array<{ severity: string; message: string }> } | undefined)?.diagnostics;
+    return { name: result.toolName, error: diagnostics?.find((item) => item.severity === "error")?.message ?? toolErrorText(result) };
+  }
+  return undefined;
 }
 
 function textOf(message: AssistantMessage): string {
@@ -131,9 +140,15 @@ export async function runCloudflareSubAgent(run: CloudflareSubAgentRun): Promise
     streamOptions: { maxRetries: 0 },
     toolExecution: "parallel",
     compaction: { enabled: false, reserveTokens: 1, keepRecentTokens: 1 },
-  } satisfies Omit<SessionHarnessOptions<object | undefined>, "session">;
-  let runtime: SessionHarness<object | undefined> | undefined;
+  } satisfies Omit<SessionHarnessOptions, "storage">;
+  let runtime: SessionHarness | undefined;
+  let events: AgentEventStream | undefined;
   let toolFailure: { name: string; error: string } | undefined;
+  const operationEntries = async (active: SessionHarness): Promise<EntryRecord[]> => {
+    const submission = await active.submissionFor(operationId, BACKGROUND_CONTEXT);
+    const entries = await active.entries(BACKGROUND_CONTEXT);
+    return submission?.entry === undefined ? [] : entries.filter((entry) => entry.id >= submission.entry!);
+  };
 
   let timedOut = false;
   const timeout = setTimeout(() => {
@@ -141,61 +156,43 @@ export async function runCloudflareSubAgent(run: CloudflareSubAgentRun): Promise
     controller.abort(new Error("SubAgent run timed out"));
   }, run.timeoutMs ?? DEFAULT_TIMEOUT_MS);
   try {
-    let settled: Awaited<ReturnType<SessionHarness<object | undefined>["run"]>>;
+    let settled: Awaited<ReturnType<SessionHarness["run"]>>;
     while (true) {
       signal.throwIfAborted();
       if (!runtime) {
         runtime = await openSessionHarness({
           ...options,
-          session: await run.openSession(),
+          storage: await run.openSession(),
         }, context);
         if (runtime.openOperation && runtime.openOperation.operationId !== operationId) {
           throw new Error("SubAgent Session has an unrelated open operation");
         }
-        const harness = runtime.harness;
-        const onEvent = run.onEvent;
-        if (onEvent) {
-          for (const type of ["run_start", "run_resume", "run_end", "turn_start", "message_start", "message_update", "message_end", "tool_start", "tool_update", "tool_end"] as const) {
-            harness.events.on(type, (event) => onEvent(event, signal));
-          }
-        }
-        harness.events.on("tool_end", (event) => {
-          if (event.isError) {
-            toolFailure ??= { name: event.toolName, error: toolErrorText(event.result) };
-          }
+        events = await runtime.watch(context);
+        events.start(async (batch) => {
+          for (const event of batch) await run.onEvent?.(event, signal);
         });
       }
       const result = await runtime.run(
         !runtime.openOperation
           ? {
-              kind: "prompt",
               operationId,
               prompt: taskPrompt(input.data, structuredStream ? undefined : outputSchema),
             }
           : undefined,
         context,
-        { waitForRetry: true, pollDeferred: true },
       );
+      await events?.stop();
+      events = undefined;
       if (result.kind === "released") {
         await runtime.close(BACKGROUND_CONTEXT);
         runtime = undefined;
         continue;
       }
-      if (result.kind === "waiting") {
-        const delay = result.reason === "deferred"
-          ? result.deferred.pollAfterMs ?? 1_000
-          : Math.max(0, result.notBefore - Date.now());
-        let timer: ReturnType<typeof setTimeout> | undefined;
-        try {
-          await awaitWithContext(new Promise<void>((resolve) => {
-            timer = setTimeout(resolve, delay);
-          }), context);
-        } finally {
-          clearTimeout(timer);
-        }
-        continue;
-      }
       settled = result;
+      // Pi's stop may drop the last frames; failures and usage come from the canonical record.
+      const owned = await operationEntries(runtime);
+      toolFailure = toolFailureOf(owned);
+      await run.onEntries?.(owned);
       break;
     }
     if (timedOut) throw new Error("SubAgent run timed out");
@@ -212,14 +209,9 @@ export async function runCloudflareSubAgent(run: CloudflareSubAgentRun): Promise
     if (toolFailure) {
       throw new Error(`SubAgent tool "${toolFailure.name}" failed: ${toolFailure.error}`);
     }
-    const assistant = (await runtime.lane.findEntries(
-      { type: "message", order: "newestFirst" },
-      context,
-    )).find((entry) => entry.type === "message" && entry.message.role === "assistant");
-    if (!assistant || assistant.type !== "message" || assistant.message.role !== "assistant") {
-      throw new Error("SubAgent produced no structured output");
-    }
-    const text = textOf(assistant.message);
+    const assistant = [...await runtime.entries(context)].reverse().flatMap((entry) => entry.model ?? []).find((message) => message.role === "assistant");
+    if (assistant?.role !== "assistant") throw new Error("SubAgent produced no structured output");
+    const text = textOf(assistant);
     if (!text) throw new Error("SubAgent produced no structured output");
     let output: unknown;
     try {
@@ -239,9 +231,10 @@ export async function runCloudflareSubAgent(run: CloudflareSubAgentRun): Promise
   } finally {
     clearTimeout(timeout);
     if (signal.aborted && runtime?.openOperation) {
-      await runtime.requestAbort(operationId, BACKGROUND_CONTEXT).catch(() => undefined);
+      await runtime.abort(BACKGROUND_CONTEXT).catch(() => undefined);
       await runtime.run(undefined, BACKGROUND_CONTEXT).catch(() => undefined);
     }
+    await events?.stop();
     await runtime?.close(BACKGROUND_CONTEXT).catch(() => undefined);
   }
 }

package/src/adapter/cloudflare/subagent/tools.ts

@@ -1,3 +1,4 @@
+import type { ToolRegistration } from "@earendil-works/pi-durable";
 import {
   DynamicWorkerExecutor,
   resolveProvider,
@@ -9,7 +10,6 @@ import {
 } from "@cloudflare/shell";
 import { stateToolsFromBackend } from "@cloudflare/shell/workers";
 import type {
-  AgentHarnessTool,
   AgentTool,
   AgentToolResult,
 } from "@earendil-works/pi-agent-core";
@@ -221,7 +221,7 @@ export function createCloudflareSubAgentTools(options: {
   loader: WorkerLoader;
   outbound: Fetcher;
   settle: NonNullable<CompileHarnessToolsOptions["onSettlement"]>;
-}): AgentHarnessTool<object | undefined>[] {
+}): ToolRegistration<any, any>[] {
   const workspace = workspacePiToolCandidates(options.workspace).filter(
     (candidate) =>
       options.profile === "capable" ||