@springbrand/agent-runtime 0.1.3-alpha.8 → 0.2.0-alpha.13

package/src/runtime.ts

@@ -20,6 +20,7 @@ import {
 import { InteractionLifecycle } from "./kernel/interaction-lifecycle";
 import {
   SubmissionLifecycle,
+  MAX_PENDING_SUBMISSIONS,
   SubmissionQueueFullError,
   type SubmissionInput,
   type SubmissionStore,
@@ -88,10 +89,21 @@ import { serializeOutput } from "./lib/artifacts";
 import type {
   RuntimeModelUsageEvent,
   RuntimeToolSettlementEvent,
+  RuntimeLifecycleFact,
+  RuntimeSubagentUsageEvent,
 } from "./kernel/bindings";
+import { RuntimeSubagentLifecycleRecorder } from "./kernel/durable-lifecycle";
+import {
+  decodeSubagentCompletion,
+  isZeroSubagentUsage,
+  runtimeSubagentRunMetadata,
+  subagentTerminalStatus,
+  type RuntimeSubagentRunMetadata,
+} from "./kernel/subagent-runtime";
 import {
   isTerminalSubmissionStatus,
   RuntimeDatabase,
+  type StoredSubmissionAdmission,
   type SubmissionStatus,
 } from "./db/index";
 import {
@@ -114,6 +126,11 @@ import {
 
 const SCHEDULED_STABLE_TIMEOUT_MS = 30_000;
 const TURN_EVENT_RETRY_SECONDS = 10;
+// 一次 Host admission 调用最多被视为「在途」多久。停在 pending 的准入行永久保留
+// —— 它固定了同一 identity 重投时必须复用的 runId,不能靠删行来让容量回收 ——
+// 但一次远端失败或崩溃留下的行超过这个窗口后就不再占用 pending 容量,否则
+// Host 侧的一次抖动会把 Session 永久卡在「队列已满」。
+const ADMISSION_ATTEMPT_WINDOW_MS = 60_000;
 export const CHAT_RECOVERY_MAX_ATTEMPTS = 5;
 // stall 单独收窄。理由不是「stall 更不值得救」,而是它的重试**期望值和别的错不一样**:
 // 瞬时错(5xx / 断流)重跑一次往往就好了;stall 的重跑是拿同一份 transcript 让模型
@@ -129,7 +146,9 @@ type RuntimeEventOutboxPayload =
   | {
       readonly type: "tool-settlement";
       readonly event: RuntimeToolSettlementEvent;
-    };
+    }
+  | { readonly type: "subagent-usage"; readonly event: RuntimeSubagentUsageEvent }
+  | { readonly type: "lifecycle"; readonly event: RuntimeLifecycleFact };
 interface StoredSubmission extends SubmissionReceipt {
   status: SubmissionStatus;
   requestId: string;
@@ -144,6 +163,10 @@ interface StoredSubmission extends SubmissionReceipt {
   regenerateMessageId?: string | null;
   recoveryErrorCount: number;
   recoveryReason?: "no_meaningful_model_progress" | "transient_model_error";
+  runId: string | null;
+  accountId: string | null;
+  rateVersion: number | null;
+  slotIdentity: string | null;
 }
 
 interface SubmitMessageOptions {
@@ -178,6 +201,32 @@ function json(value: unknown): string {
   return JSON.stringify(value);
 }
 
+function validateAdmissionResult(
+  result: import("./kernel/bindings").RuntimeSubmissionAdmissionResult,
+): import("./kernel/bindings").RuntimeSubmissionAdmissionResult {
+  if (!result || typeof result !== "object" || typeof result.accepted !== "boolean") {
+    throw new Error("Runtime admission result is invalid");
+  }
+  if (!result.accepted) {
+    if (
+      typeof result.code !== "string" || !result.code.trim() ||
+      (result.retryable !== undefined && typeof result.retryable !== "boolean")
+    ) {
+      throw new Error("Runtime admission rejection is invalid");
+    }
+    return result;
+  }
+  if (
+    typeof result.accountId !== "string" || !result.accountId.trim() ||
+    typeof result.slotIdentity !== "string" || !result.slotIdentity.trim() ||
+    !Number.isSafeInteger(result.rateVersion) ||
+    result.rateVersion <= 0
+  ) {
+    throw new Error("Runtime admission context is invalid");
+  }
+  return result;
+}
+
 async function closeRuntimeGatewaySession(
   session: RuntimeGatewaySession | undefined,
   step: string,
@@ -192,10 +241,17 @@ function assistantUsageEvent(
   eventId: string,
   submissionId: string,
   message: AssistantMessage,
+  pinned?: Pick<StoredSubmission, "accountId" | "rateVersion" | "slotIdentity">,
 ): RuntimeModelUsageEvent {
   return {
     eventId,
     submissionId,
+    runId: submissionId,
+    ...(pinned?.accountId ? { accountId: pinned.accountId } : {}),
+    ...(pinned?.rateVersion !== null && pinned?.rateVersion !== undefined
+      ? { rateVersion: pinned.rateVersion }
+      : {}),
+    ...(pinned?.slotIdentity ? { slotIdentity: pinned.slotIdentity } : {}),
     kind: "assistant",
     api: message.api,
     provider: message.provider,
@@ -327,6 +383,10 @@ export abstract class AgentRuntimeKernel<
   private migratedSubmissionIds?: Set<string>;
   private db!: RuntimeDatabase;
   private readonly temporaryAgents = new TemporaryAgentCoordinator();
+  private readonly admissionsInFlight = new Map<
+    string,
+    Promise<import("./kernel/bindings").RuntimeSubmissionAdmissionResult>
+  >();
   private readonly temporaryAgentApprovals =
     new Map<string, PendingTemporaryAgentApproval>();
 
@@ -663,6 +723,37 @@ export abstract class AgentRuntimeKernel<
     } = {},
   ): PreparedPiTurnAdapter {
     const startedAt = output.startedAt ?? Date.now();
+    const snapshot = this.assembly();
+    const runMetadata: RuntimeSubagentRunMetadata = {
+      submissionId: submission.submissionId,
+      parentRunId: submission.runId ?? submission.submissionId,
+      ...(submission.accountId ? { accountId: submission.accountId } : {}),
+      ...(submission.rateVersion !== null
+        ? { rateVersion: submission.rateVersion }
+        : {}),
+      ...(submission.slotIdentity
+        ? { slotIdentity: submission.slotIdentity }
+        : {}),
+    };
+    const lifecycle = this.subagentLifecycle(runMetadata);
+    const toolExecutors = snapshot.bindings.subagents
+      ? this.pi.subagentToolExecutors(
+          snapshot.bindings.subagents,
+          snapshot.profile.enabledSubagents,
+          {
+            ...runMetadata,
+            onRegistered: async (runId) => {
+              await lifecycle.register(runId);
+            },
+            onUsage: async (event) => {
+              await lifecycle.usage(event);
+            },
+            onTerminal: async (terminal) => {
+              await lifecycle.terminal(terminal);
+            },
+          },
+        )
+      : undefined;
     return this.pi.createTurn({
       prepared: this.preparedPi(),
       pinnedDescriptor: submission.assemblyDescriptor,
@@ -707,6 +798,9 @@ export abstract class AgentRuntimeKernel<
         settleTool: (call) =>
           this.settleTool(submission.submissionId, call),
       },
+      ...(toolExecutors && Object.keys(toolExecutors).length > 0
+        ? { toolExecutors }
+        : {}),
       onToolTelemetry: (event) => {
         this._emit("ua:tool" as never, { ...event });
       },
@@ -732,6 +826,7 @@ export abstract class AgentRuntimeKernel<
                 persisted.id,
                 submission.submissionId,
                 commit.message,
+                submission,
               );
               this.db.runtimeEvents.insert({
                 eventId: event.eventId,
@@ -774,6 +869,29 @@ export abstract class AgentRuntimeKernel<
     });
   }
 
+  private subagentLifecycle(
+    input: RuntimeSubagentRunMetadata,
+  ): RuntimeSubagentLifecycleRecorder {
+    return new RuntimeSubagentLifecycleRecorder(input, {
+      save: async (event) => {
+        this.db.transaction(() => {
+          this.db.runtimeEvents.insert({
+            eventId: event.eventId,
+            body: json({
+              type: event.kind === "subagent" ? "subagent-usage" : "lifecycle",
+              event,
+            }),
+            createdAt: Date.now(),
+          });
+        });
+        await this.drainRuntimeEvents();
+      },
+      has: (eventId) => this.db.runtimeEvents.has(eventId),
+      hasSubagentUsage: (submissionId, subagentRunId) =>
+        this.db.runtimeEvents.hasSubagentUsage(submissionId, subagentRunId),
+    });
+  }
+
   /**
    * 在 Agent 实例启动或从休眠唤醒后恢复 Session 本地后台状态。
    *
@@ -822,9 +940,23 @@ export abstract class AgentRuntimeKernel<
         if (payload.type === "model-usage") {
           if (!turnEvents.onModelUsage) continue;
           await turnEvents.onModelUsage(payload.event);
-        } else {
+        } else if (payload.type === "tool-settlement") {
           if (!turnEvents.onToolSettled) continue;
           await turnEvents.onToolSettled(payload.event);
+        } else if (payload.type === "subagent-usage") {
+          if (!turnEvents.onSubagentUsage) continue;
+          const confirmation = await turnEvents.onSubagentUsage(payload.event);
+          if (confirmation?.confirmed !== true) {
+            failed = true;
+            break;
+          }
+        } else {
+          if (!turnEvents.onLifecycleFact) continue;
+          const confirmation = await turnEvents.onLifecycleFact(payload.event);
+          if (confirmation?.confirmed !== true) {
+            failed = true;
+            break;
+          }
         }
         this.db.transaction(() =>
           this.db.runtimeEvents.markDelivered(row.eventId, Date.now())
@@ -835,6 +967,7 @@ export abstract class AgentRuntimeKernel<
           "[runtime-turn-event:degraded]",
           json({ eventId: row.eventId, error: errorText(error) }),
         );
+        break;
       }
     }
     if (!failed) return;
@@ -1255,7 +1388,23 @@ export abstract class AgentRuntimeKernel<
       onCompactionPersisted: (event) =>
         this.db.runtimeEvents.insert({
           eventId: event.eventId,
-          body: json({ type: "model-usage", event }),
+          body: json({
+            type: "model-usage",
+            event: {
+              ...event,
+              runId: submissionId,
+              ...(this.readSubmission(submissionId)?.accountId
+                ? { accountId: this.readSubmission(submissionId)!.accountId! }
+                : {}),
+              ...(this.readSubmission(submissionId)?.rateVersion !== null &&
+                this.readSubmission(submissionId)?.rateVersion !== undefined
+                ? { rateVersion: this.readSubmission(submissionId)!.rateVersion! }
+                : {}),
+              ...(this.readSubmission(submissionId)?.slotIdentity
+                ? { slotIdentity: this.readSubmission(submissionId)!.slotIdentity! }
+                : {}),
+            },
+          }),
           createdAt: Date.now(),
         }),
     });
@@ -1303,31 +1452,147 @@ export abstract class AgentRuntimeKernel<
         ? { idempotencyKey: options.idempotencyKey }
         : {}),
       prepareAdmission: async () => {
+        await this.ensureRuntimeReady();
         const regenerateEntry =
           options.regenerate && options.userMessageId
             ? await this.transcript.findUserMessage(options.userMessageId)
             : undefined;
+        if (
+          options.regenerate &&
+          (!regenerateEntry ||
+            userContentKey(regenerateEntry) !== userContentKey(userMessage))
+        ) {
+          throw new Error(
+            "Regenerate request must match an existing user message",
+          );
+        }
+        const hook = this.runtimeHooks?.onSubmissionAdmission;
+        let existing: StoredSubmissionAdmission | null = null;
+        if (hook) {
+          const attemptedAt = Date.now();
+          const reservedRunId = crypto.randomUUID();
+          this.db.transaction(() => {
+            const current = this.db.submissionAdmissions.find(
+              options.requestId,
+              options.idempotencyKey,
+            );
+            if (current) {
+              // 同一 identity 重投：沿用已固定的 runId，只把这次尝试的时间推到现在，
+              // 使它重新占住一个在途名额。
+              if (current.status === "pending") {
+                this.db.submissionAdmissions.recordAttempt(
+                  current.requestId,
+                  attemptedAt,
+                );
+              }
+              return;
+            }
+            if (
+              this.db.submissions.countPending() +
+                  this.db.submissionAdmissions.countPending(
+                    attemptedAt - ADMISSION_ATTEMPT_WINDOW_MS,
+                  ) >=
+                MAX_PENDING_SUBMISSIONS
+            ) {
+              throw new SubmissionQueueFullError();
+            }
+            this.db.submissionAdmissions.begin(
+              options.requestId,
+              options.idempotencyKey ?? null,
+              reservedRunId,
+              attemptedAt,
+            );
+          });
+          existing = this.db.submissionAdmissions.find(
+            options.requestId,
+            options.idempotencyKey,
+          );
+        }
+        const runId = existing?.runId ?? crypto.randomUUID();
+        const admissionRequestId = existing?.requestId ?? options.requestId;
+        const admissionIdempotencyKey = existing
+          ? existing.idempotencyKey ?? undefined
+          : options.idempotencyKey;
+        const admissionKey = admissionIdempotencyKey
+          ? `idempotency:${admissionIdempotencyKey}`
+          : `request:${admissionRequestId}`;
+        const pendingAdmission = hook && existing?.status === "pending"
+          ? this.admissionsInFlight.get(admissionKey)
+          : undefined;
+        const admissionPromise = pendingAdmission ?? (hook && (!existing || existing.status === "pending")
+          ? hook({
+              requestId: admissionRequestId,
+              ...(admissionIdempotencyKey
+                ? { idempotencyKey: admissionIdempotencyKey }
+                : {}),
+              runId,
+            }).then(validateAdmissionResult).catch((error) => {
+              this.admissionsInFlight.delete(admissionKey);
+              throw error;
+            })
+          : undefined);
+        if (hook && admissionPromise && !pendingAdmission) {
+          this.admissionsInFlight.set(
+            admissionKey,
+            admissionPromise,
+          );
+        }
+        let admission = existing?.status === "accepted"
+          ? {
+              accepted: true as const,
+              accountId: existing.accountId!,
+              rateVersion: existing.rateVersion!,
+              slotIdentity: existing.slotIdentity!,
+            }
+          : existing?.status === "rejected"
+            ? {
+                accepted: false as const,
+                code: existing.code ?? "admission_rejected",
+                retryable: existing.retryable ?? false,
+              }
+            : admissionPromise
+              ? await admissionPromise
+              : undefined;
         return () => {
-          const submissionId = crypto.randomUUID();
+          if (admission && !admission.accepted) {
+            this.db.submissionAdmissions.saveRejected(
+              admissionRequestId,
+              runId,
+              admission.code,
+              admission.retryable ?? false,
+            );
+            const rejected = this.insertSkippedSubmission({
+              submissionId: runId,
+              requestId: admissionRequestId,
+              idempotencyKey: admissionIdempotencyKey ?? null,
+              createdAt: userMessage.timestamp,
+              code: admission.code,
+              retryable: admission.retryable ?? false,
+            });
+            this.admissionsInFlight.delete(admissionKey);
+            return {
+              ...rejected,
+              admissionRejected: true,
+            };
+          }
+          const submissionId = runId;
           const assistantMessageId = crypto.randomUUID();
           const createdAt = userMessage.timestamp;
           const userMessageId =
             options.userMessageId ?? crypto.randomUUID();
-          if (options.regenerate) {
-            if (
-              !regenerateEntry ||
-              userContentKey(regenerateEntry) !==
-                userContentKey(userMessage)
-            ) {
-              throw new Error(
-                "Regenerate request must match an existing user message",
-              );
-            }
+          if (admission?.accepted) {
+            this.db.submissionAdmissions.saveAccepted(
+              admissionRequestId,
+              runId,
+              admission.accountId,
+              admission.rateVersion,
+              admission.slotIdentity,
+            );
           }
           this.db.submissions.insert({
             submissionId,
-            requestId: options.requestId,
-            idempotencyKey: options.idempotencyKey ?? null,
+            requestId: admissionRequestId,
+            idempotencyKey: admissionIdempotencyKey ?? null,
             createdAt,
             assemblyRevision: "",
             assemblyDescriptor: "",
@@ -1340,7 +1605,28 @@ export abstract class AgentRuntimeKernel<
             regenerateMessageId: options.regenerate
               ? options.userMessageId ?? null
               : null,
+            runId,
+            accountId: admission?.accepted ? admission.accountId : null,
+            rateVersion: admission?.accepted ? admission.rateVersion : null,
+            slotIdentity: admission?.accepted ? admission.slotIdentity : null,
           });
+          if (admission?.accepted) {
+            const fact: RuntimeLifecycleFact = {
+              kind: "submission-admitted",
+              eventId: `${submissionId}:admitted`,
+              submissionId,
+              runId: submissionId,
+              accountId: admission.accountId,
+              rateVersion: admission.rateVersion,
+              slotIdentity: admission.slotIdentity,
+            };
+            this.db.runtimeEvents.insert({
+              eventId: fact.eventId,
+              body: json({ type: "lifecycle", event: fact }),
+              createdAt,
+            });
+          }
+          if (hook) this.admissionsInFlight.delete(admissionKey);
           return this.readSubmission(submissionId)!;
         };
       },
@@ -1364,6 +1650,7 @@ export abstract class AgentRuntimeKernel<
     const submitted = await this.submissions.submit(
       this.submissionInput(userMessage, options),
     );
+    await this.drainRuntimeEvents();
     await this.broadcastApprovals();
     return submitted;
   }
@@ -1380,7 +1667,10 @@ export abstract class AgentRuntimeKernel<
       this.submissionInput(userMessage, options),
       timeoutMs,
     );
-    if (submitted) await this.broadcastApprovals();
+    if (submitted) {
+      await this.drainRuntimeEvents();
+      await this.broadcastApprovals();
+    }
     return submitted;
   }
 
@@ -1410,6 +1700,46 @@ export abstract class AgentRuntimeKernel<
     return submission;
   }
 
+  private insertSubmissionTerminalFact(submission: StoredSubmission): void {
+    const terminalFact: RuntimeLifecycleFact = {
+      kind: "submission-terminal",
+      eventId: `${submission.submissionId}:terminal`,
+      submissionId: submission.submissionId,
+      runId: submission.runId ?? submission.submissionId,
+      status: submission.status as "completed" | "aborted" | "skipped" | "error",
+      childRegistrationClosed: true,
+      zeroUsage: !this.db.runtimeEvents.hasNonZeroModelUsage(
+        submission.submissionId,
+      ),
+      ...(submission.accountId ? { accountId: submission.accountId } : {}),
+      ...(submission.rateVersion !== null
+        ? { rateVersion: submission.rateVersion }
+        : {}),
+      ...(submission.slotIdentity
+        ? { slotIdentity: submission.slotIdentity }
+        : {}),
+    };
+    this.db.runtimeEvents.insert({
+      eventId: terminalFact.eventId,
+      body: json({ type: "lifecycle", event: terminalFact }),
+      createdAt: submission.completedAt ?? Date.now(),
+    });
+  }
+
+  private insertSkippedSubmission(input: {
+    submissionId: string;
+    requestId: string;
+    idempotencyKey: string | null;
+    createdAt: number;
+    code: string;
+    retryable: boolean;
+  }): StoredSubmission {
+    this.db.submissions.insertRejected(input);
+    const skipped = this.readSubmission(input.submissionId)!;
+    this.insertSubmissionTerminalFact(skipped);
+    return skipped;
+  }
+
   // 作用：读取某个 Submission 已持久的全部 Pi 恢复里程碑。
   // 调用：恢复决策器每次检查或应用命令前调用。
   // 原因：决策只依赖持久事实，重启后才会得到同样结果。
@@ -1713,6 +2043,23 @@ export abstract class AgentRuntimeKernel<
     }
     if (isTerminalSubmissionStatus(latest.status)) return latest;
 
+    for (const steer of this.db.steers.listForSubmission(latest.submissionId)) {
+      const userMessage = JSON.parse(steer.canonicalJson) as PiCanonicalUserInput;
+      const uiMessage = steer.uiMessageJson
+        ? JSON.parse(steer.uiMessageJson) as UIMessage & { role: "user" }
+        : undefined;
+      const submitted = await this.submitMessage(userMessage, {
+        requestId: steer.messageId,
+        idempotencyKey: steer.messageId,
+        userMessageId: steer.messageId,
+        ...(uiMessage ? { userMessage: uiMessage } : {}),
+      });
+      this.ctx.waitUntil(submitted.completion);
+      this.db.transaction(() =>
+        this.db.steers.deleteByMessageId(steer.messageId)
+      );
+    }
+
     const durableIntent = this.decidePiRecovery(latest).terminal;
     const effectiveOutcome = latest.abortReason
       ? "aborted"
@@ -1742,31 +2089,12 @@ export abstract class AgentRuntimeKernel<
           : effectiveOutcome === "aborted"
             ? "aborted"
             : "error";
-      for (const steer of this.db.steers.listForSubmission(
-        latest.submissionId,
-      )) {
-        if (!this.db.submissions.findByRequestId(steer.messageId)) {
-          this.db.submissions.insert({
-            submissionId: steer.steerId,
-            requestId: steer.messageId,
-            idempotencyKey: steer.messageId,
-            createdAt: steer.createdAt,
-            assemblyRevision: latest.assemblyRevision,
-            assemblyDescriptor: latest.assemblyDescriptor,
-            assistantMessageId: crypto.randomUUID(),
-            queuedInputJson: steer.canonicalJson,
-            queuedUiMessageJson: steer.uiMessageJson,
-            userMessageId: steer.messageId,
-            regenerateMessageId: null,
-          });
-        }
-        this.db.steers.deleteByMessageId(steer.messageId);
-      }
       const terminal = this.updateSubmission(
         latest.submissionId,
         status,
         effectiveMessage,
       );
+      this.insertSubmissionTerminalFact(terminal);
       if (
         effectiveOutcome === "aborted" &&
         effectiveMessage === USER_STOP_REASON
@@ -3048,7 +3376,9 @@ export abstract class AgentRuntimeKernel<
       const reason = "Moved to active Turn";
       this.appendTerminalIntent(latest, "aborted", reason);
       this.db.submissions.updateAbortReason(submissionId, reason);
-      this.updateSubmission(submissionId, "aborted", reason);
+      this.insertSubmissionTerminalFact(
+        this.updateSubmission(submissionId, "aborted", reason),
+      );
       return true;
     });
     if (!moved) {
@@ -3064,6 +3394,7 @@ export abstract class AgentRuntimeKernel<
         active.agent.steer(message, queued.userMessageId);
       }
     } finally {
+      await this.drainRuntimeEvents();
       await this.broadcastApprovals();
     }
     return {
@@ -3101,13 +3432,22 @@ export abstract class AgentRuntimeKernel<
       SCHEDULED_STABLE_TIMEOUT_MS,
     );
     if (!submitted) {
-      return {
-        submissionId: crypto.randomUUID(),
-        status: "skipped",
-        accepted: false,
-        error: "Runtime not stable within timeout",
-        createdAt: Date.now(),
-      };
+      const skipped = this.db.transaction(() => {
+        const duplicate = options?.idempotencyKey
+          ? this.db.submissions.findByIdempotencyKey(options.idempotencyKey)
+          : this.db.submissions.findByRequestId(requestId);
+        return duplicate ?? this.insertSkippedSubmission({
+          submissionId: requestId,
+          requestId,
+          idempotencyKey: options?.idempotencyKey ?? null,
+          createdAt: Date.now(),
+          code: "Runtime not stable within timeout",
+          retryable: true,
+        });
+      }) as StoredSubmission;
+      await this.drainRuntimeEvents();
+      await this.broadcastApprovals();
+      return skipped;
     }
     this.ctx.waitUntil(submitted.completion.then(() => undefined));
     return submitted.receipt;
@@ -3352,6 +3692,10 @@ export abstract class AgentRuntimeKernel<
   // 原因：分离的子运行不进 Submission 表，不在这里重算，Host 的列表会显示成已经空闲。
   override async onAgentToolStart(run: AgentToolRunInfo): Promise<void> {
     await super.onAgentToolStart(run);
+    const metadata = runtimeSubagentRunMetadata(run.inputPreview);
+    if (metadata) {
+      await this.subagentLifecycle(metadata).register(run.runId);
+    }
     await this.broadcastApprovals();
   }
 
@@ -3363,6 +3707,40 @@ export abstract class AgentRuntimeKernel<
     result: AgentToolLifecycleResult,
   ): Promise<void> {
     await super.onAgentToolFinish(run, result);
+    const metadata = runtimeSubagentRunMetadata(run.inputPreview);
+    if (metadata) {
+      const lifecycle = this.subagentLifecycle(metadata);
+      await lifecycle.register(run.runId);
+      if (!(result.status === "interrupted" && result.childStillRunning)) {
+        const completion = decodeSubagentCompletion(result.summary);
+        const hasUsage = completion && !isZeroSubagentUsage(completion.usage);
+        const status = subagentTerminalStatus(result.status);
+        if (completion && hasUsage) {
+          await lifecycle.usage({
+            eventId: `${run.runId}:usage`,
+            submissionId: metadata.submissionId,
+            runId: run.runId,
+            subagentRunId: run.runId,
+            parentRunId: metadata.parentRunId,
+            ...(metadata.accountId ? { accountId: metadata.accountId } : {}),
+            ...(metadata.rateVersion !== undefined
+              ? { rateVersion: metadata.rateVersion }
+              : {}),
+            ...(metadata.slotIdentity
+              ? { slotIdentity: metadata.slotIdentity }
+              : {}),
+            kind: "subagent",
+            status,
+            usage: completion.usage,
+          });
+        }
+        await lifecycle.terminal({
+          subagentRunId: run.runId,
+          status,
+          zeroUsage: !hasUsage,
+        });
+      }
+    }
     await this.broadcastApprovals();
   }
 
@@ -3370,8 +3748,11 @@ export abstract class AgentRuntimeKernel<
     run: AgentToolRunInfo,
     result: AgentToolLifecycleResult,
   ): Promise<void> {
+    const completion = decodeSubagentCompletion(result.summary);
     const outcome = result.status === "completed"
-      ? result.summary ?? "Completed without a result."
+      ? completion
+        ? JSON.stringify(completion.output)
+        : result.summary ?? "Completed without a result."
       : result.error ?? `Background run ${result.status}.`;
     await this.submitPrompt(
       [