@springbrand/agent-runtime 0.2.0-alpha.16 → 0.2.0-alpha.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@springbrand/agent-runtime",
-  "version": "0.2.0-alpha.16",
+  "version": "0.2.0-alpha.17",
   "type": "module",
   "files": [
     "src",

package/src/adapter/cloudflare/sandbox/adapter.ts

@@ -436,10 +436,10 @@ function mappedError(error: unknown): SandboxPortError {
 
 function workspaceToSandboxPath(
   path: string,
-  root: "/" | "/shared",
+  root: "/" | "/userspace",
 ): string {
-  if (root === "/shared") {
-    return path === "/shared" ? "/shared" : path;
+  if (root === "/userspace") {
+    return path === "/userspace" ? "/userspace" : path;
   }
   return path === "/" ? "/workspace" : `/workspace${path}`;
 }
@@ -493,7 +493,7 @@ export class CloudflareSandboxAdapter implements RuntimeSandboxPort {
         await this.ensureHydrated();
         const cwd = normalizedPath(
           input.cwd,
-          ["/workspace", "/shared", "/tmp"],
+          ["/workspace", "/userspace", "/tmp"],
           "/workspace",
         );
         const timeout = Math.min(
@@ -564,7 +564,7 @@ export class CloudflareSandboxAdapter implements RuntimeSandboxPort {
         await this.ensureHydrated();
         const cwd = normalizedPath(
           input.cwd,
-          ["/workspace", "/shared", "/tmp"],
+          ["/workspace", "/userspace", "/tmp"],
           "/workspace",
         );
         const session = await this.ensureSession(
@@ -880,32 +880,32 @@ export class CloudflareSandboxAdapter implements RuntimeSandboxPort {
     return next;
   }
 
+  /**
+   * Make the container's copy of the Workspace current.
+   *
+   * A hydrated container used to be treated as done, forever. That is only
+   * true if nothing else can change the Workspace — and something always can:
+   * the Agent writes files between commands, and a person can restore an
+   * earlier version at any time. A script would then run against files its
+   * author had already replaced, and produce a confidently wrong answer with no
+   * error anywhere.
+   *
+   * So every hydration reconciles. The manifest records each copied file's size
+   * and modification time, so an unchanged Workspace transfers nothing and only
+   * what actually moved is copied again.
+   */
   private async ensureHydrated(): Promise<SandboxSyncResult> {
     if (!this.hydration) {
       this.hydration = (async () => {
         try {
-          if (this.manifest) {
-            return this.freezeSyncResult({
-              files: [],
-              skipped: [],
-              failed: [],
-              bytes: 0,
+          const previous =
+            this.manifest ?? (await this.readHydrationManifest());
+          if (!previous) {
+            this.emit("sandbox.container.cold_start", {
+              markerMissing: true,
             });
           }
-          const existing = await this.readHydrationManifest();
-          if (existing) {
-            this.manifest = existing;
-            return this.freezeSyncResult({
-              files: [],
-              skipped: [],
-              failed: [],
-              bytes: 0,
-            });
-          }
-          this.emit("sandbox.container.cold_start", {
-            markerMissing: true,
-          });
-          const result = await this.pullWorkspaceInternal();
+          const result = await this.pullWorkspaceInternal(previous);
           if (result.failed.length > 0) {
             throw new Error("Workspace hydration was partial");
           }
@@ -929,7 +929,9 @@ export class CloudflareSandboxAdapter implements RuntimeSandboxPort {
     return this.hydration;
   }
 
-  private async pullWorkspaceInternal(): Promise<SandboxSyncResult> {
+  private async pullWorkspaceInternal(
+    previous?: HydrationManifest | null,
+  ): Promise<SandboxSyncResult> {
     const result: {
       files: string[];
       skipped: string[];
@@ -945,10 +947,13 @@ export class CloudflareSandboxAdapter implements RuntimeSandboxPort {
       files: new Map(),
     };
     let visitedEntries = 0;
+    // Counted separately from `result.bytes`: the cap is about how much the
+    // container holds, while `result.bytes` reports what this pass moved.
+    let hydratedBytes = 0;
     await this.client.mkdir("/workspace");
-    await this.client.mkdir("/shared");
+    await this.client.mkdir("/userspace");
 
-    for (const root of ["/", "/shared"] as const) {
+    for (const root of ["/", "/userspace"] as const) {
       const pending: string[] = [root];
       while (pending.length > 0) {
         const directory = pending.pop()!;
@@ -1003,7 +1008,7 @@ export class CloudflareSandboxAdapter implements RuntimeSandboxPort {
               );
             }
             if (
-              result.bytes + entry.size >
+              hydratedBytes + entry.size >
               SANDBOX_HOST_POLICY.maxHydrationBytes
             ) {
               throw new SandboxPortError(
@@ -1011,6 +1016,18 @@ export class CloudflareSandboxAdapter implements RuntimeSandboxPort {
                 "Workspace hydration exceeds the total byte limit",
               );
             }
+            const copied = previous?.files.get(destination);
+            if (
+              copied &&
+              copied.updatedAt === entry.updatedAt &&
+              copied.size === entry.size &&
+              (await this.client.exists(destination))
+            ) {
+              // Already the same bytes in the container. Nothing to move.
+              currentManifest.files.set(destination, copied);
+              hydratedBytes += entry.size;
+              continue;
+            }
             const bytes =
               await this.options.workspace.readFileBytes(sourcePath);
             if (!bytes) {
@@ -1022,7 +1039,7 @@ export class CloudflareSandboxAdapter implements RuntimeSandboxPort {
             }
             if (
               bytes.byteLength > MAX_PUBLISH_FILE_BYTES ||
-              result.bytes + bytes.byteLength >
+              hydratedBytes + bytes.byteLength >
                 SANDBOX_HOST_POLICY.maxHydrationBytes
             ) {
               throw new SandboxPortError(
@@ -1041,6 +1058,7 @@ export class CloudflareSandboxAdapter implements RuntimeSandboxPort {
             });
             result.files.push(destination);
             result.bytes += bytes.byteLength;
+            hydratedBytes += bytes.byteLength;
           }
           if (entries.length < WORKSPACE_PAGE_SIZE) break;
           offset += entries.length;
@@ -1048,6 +1066,13 @@ export class CloudflareSandboxAdapter implements RuntimeSandboxPort {
       }
     }
     if (result.failed.length === 0) {
+      // A file the Workspace no longer has must not survive in the container:
+      // a script globbing a directory would still find it and treat deleted
+      // work as current.
+      for (const path of previous?.files.keys() ?? []) {
+        if (currentManifest.files.has(path)) continue;
+        await this.client.deleteFile(path).catch(() => undefined);
+      }
       await this.writeHydrationManifest(currentManifest);
     }
     return this.freezeSyncResult(result);
@@ -1096,8 +1121,8 @@ export class CloudflareSandboxAdapter implements RuntimeSandboxPort {
         ) {
           return null;
         }
-        const root = pathInside("/shared", item.path)
-          ? "/shared"
+        const root = pathInside("/userspace", item.path)
+          ? "/userspace"
           : "/workspace";
         files.set(canonicalPathInside(item.path, root), {
           updatedAt: item.updatedAt,
@@ -1365,8 +1390,8 @@ export class CloudflareSandboxAdapter implements RuntimeSandboxPort {
   private async assertNoSymlinkComponents(
     path: string,
   ): Promise<void> {
-    const root = pathInside("/shared", path)
-      ? "/shared"
+    const root = pathInside("/userspace", path)
+      ? "/userspace"
       : "/workspace";
     if (path === root) return;
 
@@ -1402,8 +1427,8 @@ export class CloudflareSandboxAdapter implements RuntimeSandboxPort {
     selectedPath: string,
     entry: SandboxFileEntry,
   ): void {
-    const root = pathInside("/shared", selectedPath)
-      ? "/shared"
+    const root = pathInside("/userspace", selectedPath)
+      ? "/userspace"
       : "/workspace";
     const absolutePath = canonicalPathInside(
       entry.absolutePath,

package/src/adapter/cloudflare/universal-agent/preparation.ts

@@ -34,7 +34,6 @@ export type PlatformLoader = () => Promise<RuntimePlatformPort>;
 export interface CloudflarePlatformBindings {
   LOADER: WorkerLoader;
   BROWSER?: RuntimeBrowserPort;
-  TELEMETRY_CONSOLE?: string;
 }
 
 export interface WorkspaceRequirement {
@@ -110,7 +109,6 @@ export function createPlatformLoader<
       loader: context.env.LOADER,
       ...(context.env.BROWSER ? { browser: context.env.BROWSER } : {}),
       outbound: () => exports.HttpGateway({}),
-      telemetryConsole: context.env.TELEMETRY_CONSOLE === "1",
     };
   });
 }

package/src/adapter/cloudflare/workspace/scoped-workspace.ts

@@ -27,12 +27,8 @@ function normalizePath(path: string): string {
   return `/${parts.join("/")}`;
 }
 
-function isReservedMemoryPath(path: string): boolean {
-  return path === "/shared/memories" || path.startsWith("/shared/memories/");
-}
-
 /**
- * A Session sees the user's shared mount plus its own directory. All other
+ * A Session sees the user's UserSpace mount plus its own directory. All other
  * paths are interpreted relative to the current Session directory; another
  * Session can never be named through this port. The Inbox Host also uses this
  * object to create and remove the Session tree, so callers never need to build
@@ -45,6 +41,8 @@ export class ScopedWorkspace implements WorkspacePort, WorkspaceAdminPort {
     private readonly parent: WorkspacePort,
     readonly sessionId: string,
     private readonly quota: WorkspaceQuota = UNCONFIGURED_QUOTA,
+    /** Physical storage root; the runtime mount remains `/userspace`. */
+    private readonly userSpaceRoot: "/userspace" | "/shared" = "/userspace",
   ) {
     if (!sessionId || sessionId.includes("/") || sessionId === "." || sessionId === "..") {
       throw new Error("invalid session id");
@@ -53,12 +51,12 @@ export class ScopedWorkspace implements WorkspacePort, WorkspaceAdminPort {
   }
 
   async ensure(): Promise<void> {
-    await this.parent.mkdir("/shared", { recursive: true });
+    await this.parent.mkdir(this.userSpaceRoot, { recursive: true });
     await this.parent.mkdir(this.sessionRoot, { recursive: true });
   }
 
   /**
-   * Count only this Session's private tree. User-level `/shared` belongs to the
+   * Count only this Session's private tree. `/userspace` belongs to the user and
    * Inbox and must not be charged once per Chat.
    */
   async getUsage(): Promise<WorkspaceUsage> {
@@ -100,7 +98,7 @@ export class ScopedWorkspace implements WorkspacePort, WorkspaceAdminPort {
     return { ...this.quota };
   }
 
-  /** Host-only lifecycle operation. It never removes the user-level `/shared` tree. */
+  /** Host-only lifecycle operation. It never removes the UserSpace tree. */
   async removeAll(): Promise<void> {
     await this.parent.rm(this.sessionRoot, {
       recursive: true,
@@ -110,8 +108,8 @@ export class ScopedWorkspace implements WorkspacePort, WorkspaceAdminPort {
 
   private physical(path: string): string {
     const normalized = normalizePath(path);
-    if (normalized === "/shared" || normalized.startsWith("/shared/")) {
-      return normalized;
+    if (normalized === "/userspace" || normalized.startsWith("/userspace/")) {
+      return `${this.userSpaceRoot}${normalized.slice("/userspace".length)}`;
     }
     if (normalized === this.sessionRoot || normalized.startsWith(`${this.sessionRoot}/`)) {
       return normalized;
@@ -126,16 +124,19 @@ export class ScopedWorkspace implements WorkspacePort, WorkspaceAdminPort {
 
   private writablePhysical(path: string): string {
     const physical = this.physical(path);
-    if (isReservedMemoryPath(physical)) {
-      throw new Error("/shared/memories is read-only in Session workspaces");
+    if (
+      physical === `${this.userSpaceRoot}/memories` ||
+      physical.startsWith(`${this.userSpaceRoot}/memories/`)
+    ) {
+      throw new Error("/userspace/memories is read-only in Session workspaces");
     }
     return physical;
   }
 
   private async assertNoSymlinkComponents(path: string): Promise<void> {
     let root: string;
-    if (path === "/shared" || path.startsWith("/shared/")) {
-      root = "/shared";
+    if (path === this.userSpaceRoot || path.startsWith(`${this.userSpaceRoot}/`)) {
+      root = this.userSpaceRoot;
     } else if (
       path === this.sessionRoot ||
       path.startsWith(`${this.sessionRoot}/`)
@@ -172,6 +173,10 @@ export class ScopedWorkspace implements WorkspacePort, WorkspaceAdminPort {
   }
 
   private virtual(path: string): string {
+    if (path === this.userSpaceRoot) return "/userspace";
+    if (path.startsWith(`${this.userSpaceRoot}/`)) {
+      return `/userspace${path.slice(this.userSpaceRoot.length)}`;
+    }
     if (path === this.sessionRoot) return "/";
     if (path.startsWith(`${this.sessionRoot}/`)) {
       return path.slice(this.sessionRoot.length);
@@ -218,8 +223,8 @@ export class ScopedWorkspace implements WorkspacePort, WorkspaceAdminPort {
     expected: WorkspaceFileVersion | null,
   ): Promise<WorkspaceConditionalWriteResult> {
     const physical = await this.guardedPhysical(path, true);
-    if (physical === "/shared" || physical.startsWith("/shared/")) {
-      throw new Error("/shared is read-only for Sandbox publishing");
+    if (physical === this.userSpaceRoot || physical.startsWith(`${this.userSpaceRoot}/`)) {
+      throw new Error("/userspace is read-only for Sandbox publishing");
     }
     const current = await this.parent.stat(physical);
     const currentVersion =
@@ -291,7 +296,7 @@ export class ScopedWorkspace implements WorkspacePort, WorkspaceAdminPort {
 
   async rm(path: string, opts?: { recursive?: boolean; force?: boolean }) {
     const physical = await this.guardedPhysical(path, true);
-    if (physical === "/shared" || physical === this.sessionRoot) {
+    if (physical === this.userSpaceRoot || physical === this.sessionRoot) {
       throw new Error("workspace mount roots cannot be removed");
     }
     return this.parent.rm(physical, opts);
@@ -315,7 +320,7 @@ export class ScopedWorkspace implements WorkspacePort, WorkspaceAdminPort {
 
   async symlink(target: string, linkPath: string) {
     /*
-     * A symlink stored under `/shared` could target this Session's physical
+     * A symlink stored under `/userspace` could target this Session's physical
      * directory and then be followed by another Session. Path normalization
      * cannot guard a later filesystem dereference, so scoped runtimes do not
      * create symlinks at all.

package/src/db/index.ts

@@ -10,6 +10,7 @@ import { ExtContextRepository } from "./ext-context.repo";
 import { MessageUiRepository } from "./message-ui.repo";
 import { SteerRepository } from "./steer.repo";
 import { RuntimeEventOutboxRepository } from "./runtime-event-outbox.repo";
+import { TelemetryOutboxRepository } from "./telemetry-outbox.repo";
 import { AgentToolRepository } from "./agent-tool.repo";
 import { SubmissionAdmissionRepository } from "./submission-admission.repo";
 
@@ -37,6 +38,7 @@ export * from "./ext-context.repo";
 export * from "./message-ui.repo";
 export * from "./steer.repo";
 export * from "./runtime-event-outbox.repo";
+export * from "./telemetry-outbox.repo";
 export * from "./agent-tool.repo";
 export * from "./submission-admission.repo";
 
@@ -50,6 +52,7 @@ export class RuntimeDatabase {
   readonly messageUi: MessageUiRepository;
   readonly steers: SteerRepository;
   readonly runtimeEvents: RuntimeEventOutboxRepository;
+  readonly telemetry: TelemetryOutboxRepository;
   readonly agentTools: AgentToolRepository;
   readonly submissionAdmissions: SubmissionAdmissionRepository;
 
@@ -69,6 +72,7 @@ export class RuntimeDatabase {
     this.messageUi = new MessageUiRepository(sql);
     this.steers = new SteerRepository(sql);
     this.runtimeEvents = new RuntimeEventOutboxRepository(sql);
+    this.telemetry = new TelemetryOutboxRepository(sql);
     this.agentTools = new AgentToolRepository(sql);
     this.submissionAdmissions = new SubmissionAdmissionRepository(sql);
   }
@@ -116,5 +120,6 @@ export class RuntimeDatabase {
     this.sql`DELETE FROM pi_tool_interactions`;
     this.sql`DELETE FROM pi_tool_settlements`;
     this.sql`DELETE FROM pi_recovery_milestones`;
+    this.sql`DELETE FROM pi_telemetry_outbox`;
   }
 }

package/src/db/schema.ts

@@ -94,6 +94,21 @@ export function initializeSchema(sql: SqlTaggedTemplate): void {
     created_at INTEGER NOT NULL,
     delivered_at INTEGER
   )`;
+  sql`CREATE TABLE IF NOT EXISTS pi_telemetry_outbox (
+    event_id TEXT PRIMARY KEY,
+    body TEXT NOT NULL,
+    created_at INTEGER NOT NULL,
+    delivered_at INTEGER,
+    attempt_count INTEGER NOT NULL DEFAULT 0,
+    quarantined_at INTEGER,
+    last_error TEXT
+  )`;
+  sql`CREATE INDEX IF NOT EXISTS pi_telemetry_outbox_pending
+      ON pi_telemetry_outbox(created_at, event_id)
+      WHERE delivered_at IS NULL AND quarantined_at IS NULL`;
+  sql`CREATE INDEX IF NOT EXISTS pi_telemetry_outbox_delivered
+      ON pi_telemetry_outbox(delivered_at)
+      WHERE delivered_at IS NOT NULL`;
   sql`CREATE TABLE IF NOT EXISTS pi_submission_admissions (
     request_id TEXT PRIMARY KEY,
     idempotency_key TEXT UNIQUE,

package/src/db/telemetry-outbox.repo.ts

@@ -0,0 +1,151 @@
+import type { SqlTaggedTemplate } from "agents/chat";
+
+export const TELEMETRY_OUTBOX_PENDING_LIMIT = 10_000;
+export const TELEMETRY_OUTBOX_BATCH_SIZE = 50;
+
+export interface NewTelemetryOutboxEvent {
+  readonly eventId: string;
+  readonly body: string;
+  readonly createdAt: number;
+}
+
+export interface StoredTelemetryOutboxEvent extends NewTelemetryOutboxEvent {
+  readonly deliveredAt: number | null;
+  readonly attemptCount: number;
+  readonly quarantinedAt: number | null;
+  readonly lastError: string | null;
+}
+
+export type TelemetryOutboxInsertResult =
+  | "inserted"
+  | "duplicate"
+  | "full";
+
+type TelemetryOutboxRow = {
+  event_id: string;
+  body: string;
+  created_at: number;
+  delivered_at: number | null;
+  attempt_count: number;
+  quarantined_at: number | null;
+  last_error: string | null;
+};
+
+function mapRow(row: TelemetryOutboxRow): StoredTelemetryOutboxEvent {
+  return {
+    eventId: row.event_id,
+    body: row.body,
+    createdAt: row.created_at,
+    deliveredAt: row.delivered_at,
+    attemptCount: row.attempt_count,
+    quarantinedAt: row.quarantined_at,
+    lastError: row.last_error,
+  };
+}
+
+export class TelemetryOutboxRepository {
+  constructor(private readonly sql: SqlTaggedTemplate) {}
+
+  insert(
+    event: NewTelemetryOutboxEvent,
+    pendingLimit = TELEMETRY_OUTBOX_PENDING_LIMIT,
+  ): TelemetryOutboxInsertResult {
+    const existing = this.find(event.eventId);
+    if (existing) {
+      if (existing.body !== event.body) {
+        throw new Error(`Conflicting telemetry event: ${event.eventId}`);
+      }
+      return "duplicate";
+    }
+    if (this.pendingCount() >= pendingLimit) return "full";
+    this.sql`
+      INSERT INTO pi_telemetry_outbox (
+        event_id, body, created_at, delivered_at,
+        attempt_count, quarantined_at, last_error
+      ) VALUES (
+        ${event.eventId}, ${event.body}, ${event.createdAt}, NULL,
+        0, NULL, NULL
+      )
+    `;
+    return "inserted";
+  }
+
+  find(eventId: string): StoredTelemetryOutboxEvent | null {
+    const row = this.sql<TelemetryOutboxRow>`
+      SELECT event_id, body, created_at, delivered_at,
+             attempt_count, quarantined_at, last_error
+      FROM pi_telemetry_outbox
+      WHERE event_id = ${eventId}
+    `[0];
+    return row ? mapRow(row) : null;
+  }
+
+  listPending(
+    limit = TELEMETRY_OUTBOX_BATCH_SIZE,
+  ): StoredTelemetryOutboxEvent[] {
+    return this.sql<TelemetryOutboxRow>`
+      SELECT event_id, body, created_at, delivered_at,
+             attempt_count, quarantined_at, last_error
+      FROM pi_telemetry_outbox
+      WHERE delivered_at IS NULL AND quarantined_at IS NULL
+      ORDER BY created_at, event_id
+      LIMIT ${limit}
+    `.map(mapRow);
+  }
+
+  pendingCount(): number {
+    return this.sql<{ count: number }>`
+      SELECT COUNT(*) AS count
+      FROM pi_telemetry_outbox
+      WHERE delivered_at IS NULL AND quarantined_at IS NULL
+    `[0]?.count ?? 0;
+  }
+
+  hasPending(): boolean {
+    return Boolean(
+      this.sql<{ pending: number }>`
+        SELECT 1 AS pending
+        FROM pi_telemetry_outbox
+        WHERE delivered_at IS NULL AND quarantined_at IS NULL
+        LIMIT 1
+      `[0],
+    );
+  }
+
+  markDelivered(eventIds: readonly string[], deliveredAt: number): void {
+    for (const eventId of eventIds) {
+      this.sql`
+        UPDATE pi_telemetry_outbox
+        SET delivered_at = ${deliveredAt}, last_error = NULL
+        WHERE event_id = ${eventId}
+          AND delivered_at IS NULL AND quarantined_at IS NULL
+      `;
+    }
+  }
+
+  markFailed(eventIds: readonly string[], error: string): void {
+    for (const eventId of eventIds) {
+      this.sql`
+        UPDATE pi_telemetry_outbox
+        SET attempt_count = attempt_count + 1, last_error = ${error}
+        WHERE event_id = ${eventId}
+          AND delivered_at IS NULL AND quarantined_at IS NULL
+      `;
+    }
+  }
+
+  quarantine(eventId: string, quarantinedAt: number, error: string): void {
+    this.sql`
+      UPDATE pi_telemetry_outbox
+      SET quarantined_at = ${quarantinedAt}, last_error = ${error}
+      WHERE event_id = ${eventId} AND delivered_at IS NULL
+    `;
+  }
+
+  deleteDeliveredBefore(cutoff: number): void {
+    this.sql`
+      DELETE FROM pi_telemetry_outbox
+      WHERE delivered_at IS NOT NULL AND delivered_at < ${cutoff}
+    `;
+  }
+}

package/src/index.ts

@@ -47,6 +47,7 @@ export * from "./kernel/extensions";
 export * from "./kernel/profile";
 export * from "./kernel/receipts";
 export * from "./kernel/runtime-config";
+export * from "./telemetry";
 export type { RuntimeAssemblyView } from "./kernel/runtime-assembly-view";
 export * from "./runtime-agent";
 export * from "./kernel/state";

package/src/kernel/approval-lifecycle.ts

@@ -83,6 +83,11 @@ interface ApprovalLifecycleOptions<
     data: ApprovalContinuationData,
   ) => Promise<void>;
   readonly onApprovalsChanged: () => Promise<void>;
+  readonly onTelemetryRequested?: (approval: ApprovalRecord) => void;
+  readonly onTelemetryDecided?: (
+    approval: ApprovalRecord,
+    decision: "approved" | "rejected" | "cancelled",
+  ) => void;
 }
 
 // #endregion
@@ -210,9 +215,17 @@ export class ApprovalLifecycle<
       approval: ApprovalRecord,
     ) => void | Promise<void>,
   ): Promise<void> {
-    const pending = this.options.db.transaction(() =>
-      this.ensurePending(submission, approval)
-    );
+    const pending = this.options.db.transaction(() => {
+      const value = this.ensurePending(submission, approval);
+      if (value.created) {
+        try {
+          this.options.onTelemetryRequested?.(value.approval);
+        } catch {
+          // Observability must not change approval durability.
+        }
+      }
+      return value;
+    });
     if (pending.created) {
       await this.options.onApprovalsChanged();
       await onApproval?.(pending.approval);
@@ -313,6 +326,14 @@ export class ApprovalLifecycle<
         submission,
         decision.mutations,
       );
+      const decided = this.read(stored.executionId);
+      if (decided) {
+        try {
+          this.options.onTelemetryDecided?.(decided, "cancelled");
+        } catch {
+          // Observability must not change terminal cleanup.
+        }
+      }
     }
     return true;
   }
@@ -376,6 +397,17 @@ export class ApprovalLifecycle<
         submission,
         [...pending.mutations, ...decision.mutations],
       );
+      const decided = this.read(stored.executionId);
+      if (decided && decided.status !== "pending") {
+        try {
+          this.options.onTelemetryDecided?.(
+            decided,
+            decided.status === "approved" ? "approved" : "rejected",
+          );
+        } catch {
+          // Observability must not change approval decisions.
+        }
+      }
     });
     const persisted = this.read(stored.executionId);
     if (!persisted || persisted.status === "pending") {

package/src/kernel/bindings.ts

@@ -953,7 +953,6 @@ export interface RuntimePlatformPort {
    * 出口由 Host 通过 Service Binding 等平台边界控制，不使用无约束的 Runtime 全局网络能力。
    */
   outbound: () => Fetcher;
-  telemetryConsole?: boolean;
   /**
    * 在 Pi 工具真正执行前请 Host 审查本次调用。
    *