@borgee/agents-host 0.2.84 → 0.2.97

package/README.md

@@ -479,7 +479,7 @@ successfully applied snapshot running.
 Each Borgee channel is mapped 1:1 to a provider-native session while it stays
 active:
 
-- **Claude**: one persistent `@agentclientprotocol/claude-agent-acp` subprocess is shared by a single `AgentsHost`, with one ACP session per Borgee channel. Same-channel turns are serialized; different channels keep isolated ACP sessions. The real ACP session cwd now comes from the resolved channel working folder `~/.borgee/channels/<encoded-channel-id>/workspace`. Task threads only switch execution onto an explicit existing `execution.local_directory`; otherwise they stay discussion-only on `~/.borgee/channels/<encoded-thread-id>/scratch/workspace`, and ACP permission requests are denied so filesystem and shell tools stay unavailable. The host persists the channel→ACP-session map in its state root, restores same-host continuity with ACP `session/resume` when available, retries stale restores with a fresh session immediately, and injects the per-channel local context paths through Claude ACP `_meta.systemPrompt.append`.
+- **Claude**: one persistent `@agentclientprotocol/claude-agent-acp` subprocess is shared by a single `AgentsHost`, with one ACP session per Borgee channel. Same-channel turns are serialized; different channels keep isolated ACP sessions. The real ACP session cwd now comes from the resolved channel working folder `~/.borgee/channels/<encoded-channel-id>/workspace`. Task threads only switch execution onto an explicit existing `execution.local_directory`; otherwise they stay discussion-only on `~/.borgee/channels/<encoded-thread-id>/scratch/workspace`, and ACP permission requests are denied so filesystem and shell tools stay unavailable. The host persists the channel→ACP-session map in its state root, restores same-host continuity with ACP `session/resume` when available, retries stale restores with a fresh session immediately, and injects the per-channel local context paths through Claude ACP `_meta.systemPrompt.append`. The bundled adapter advertises a versioned targeted task-stop extension backed by the Agent SDK's `Query.stopTask(taskId)`: accepting that request moves only the selected background run to `stopping`, while its provider lifecycle event decides the terminal state and the parent turn plus sibling workers continue unchanged. Custom ACP commands do not receive this capability and remain fail-closed.
 - **Codex**: one persistent `@agentclientprotocol/codex-acp` subprocess is
   shared by a single `AgentsHost`, with one ACP session per Borgee channel. When
   the current turn has a materialized channel context payload, Codex refreshes a

package/dist/agents-host.js

@@ -150,17 +150,19 @@ class DefaultHostRuntime {
                 });
         this.ensureStateRoot = deps.ensureStateRoot ?? ensurePrivateStateRoot;
     }
-    async start(onMessage, onStopTurn, onStopBackgroundRun) {
+    async start(onMessage, onStopTurn, onStopBackgroundRun, onActivityTransportReady) {
         await this.ensureStateRoot(this.config.stateRootDir);
         await this.gateway.start();
         try {
             this.controlPlane.onStopTurn?.(onStopTurn);
             this.controlPlane.onStopBackgroundRun?.(onStopBackgroundRun);
+            this.controlPlane.onActivityTransportReady?.(onActivityTransportReady);
             await this.controlPlane.connect(onMessage);
         }
         catch (error) {
             this.controlPlane.onStopTurn?.(undefined);
             this.controlPlane.onStopBackgroundRun?.(undefined);
+            this.controlPlane.onActivityTransportReady?.(undefined);
             await this.gateway.stop().catch(() => { });
             throw error;
         }
@@ -170,6 +172,7 @@ class DefaultHostRuntime {
         try {
             this.controlPlane.onStopTurn?.(undefined);
             this.controlPlane.onStopBackgroundRun?.(undefined);
+            this.controlPlane.onActivityTransportReady?.(undefined);
             await this.controlPlane.close();
         }
         catch (error) {
@@ -365,6 +368,14 @@ export class AgentsHost {
             cancel: this.provider.cancelBackgroundRun
                 ? (channelId, providerRunId) => (this.provider.cancelBackgroundRun(channelId, providerRunId))
                 : undefined,
+            onFinished: (channelId, run) => {
+                this.borgee.reportTaskFinished?.({
+                    channelId,
+                    taskId: run.runId,
+                    outcome: run.state,
+                    ...(run.state === 'failed' ? { reason: 'unknown' } : {}),
+                });
+            },
         });
     }
     async start() {
@@ -391,7 +402,7 @@ export class AgentsHost {
                     return;
                 }
                 this.dispatchMessage(message);
-            }, async (channelId) => this.stopTurn(channelId), async (channelId, runId) => this.backgroundRuns.stop(channelId, runId));
+            }, async (channelId) => this.stopTurn(channelId), async (channelId, runId) => this.backgroundRuns.stop(channelId, runId), () => this.backgroundRuns.replay());
             const agentId = await this.ensureSelfAgentId();
             bufferingMessages = false;
             while (bufferedMessages.length > 0) {
@@ -642,10 +653,10 @@ export class AgentsHost {
         if (this.isHumanWakeFiltered(msg, authorKind, attentionSnapshot)) {
             return;
         }
-        let foregroundInterrupt;
+        let foregroundTransition;
         if (authorKind !== 'agent' && channelState.activeTurn) {
             this.supersedeActiveTurn(msg.channel_id, channelState.activeTurn);
-            foregroundInterrupt = (async () => {
+            foregroundTransition = (async () => {
                 try {
                     await this.provider.interruptTurn?.(msg.channel_id);
                 }
@@ -669,7 +680,7 @@ export class AgentsHost {
             attentionSnapshot,
             taskThreadContext,
         });
-        await foregroundInterrupt;
+        await foregroundTransition;
         await this.ensureCollaborationProcessor(msg.channel_id, channelState);
     }
     detectProtocolKickoffCandidate(anchorMessageId, content, selfAgentId) {
@@ -2399,6 +2410,13 @@ export class AgentsHost {
                     onProgress: (update) => {
                         if (supportsBackgroundRunLifecycle) {
                             this.backgroundRuns.observe(channelId, update);
+                            if (update.type === 'activity' && update.activity.background === true) {
+                                this.borgee.reportActivity?.({
+                                    channelId,
+                                    activity: { shape: 'activity', ...update.activity },
+                                });
+                                return;
+                            }
                         }
                         if (!this.canAcceptTurnOutput(channelId, activeTurn?.generation)) {
                             return;

package/dist/background-runs.d.ts

@@ -4,6 +4,10 @@ interface BackgroundRunTrackerOptions {
     lifecycleSupported: boolean;
     targetedCancellationSupported: boolean;
     cancel?: (channelId: string, providerRunId: string) => Promise<boolean>;
+    onFinished?: (channelId: string, run: {
+        runId: string;
+        state: 'completed' | 'failed' | 'cancelled';
+    }) => void;
 }
 export declare class BackgroundRunTracker {
     private readonly report;
@@ -12,8 +16,9 @@ export declare class BackgroundRunTracker {
     private readonly mintRunId;
     private readonly runs;
     private readonly runsById;
-    constructor(report: (channelId: string, activity: AgentActivity) => void, options: BackgroundRunTrackerOptions, now?: () => number, mintRunId?: (channelId: string, providerRunId: string, startedAt: number) => string);
+    constructor(report: (channelId: string, activity: AgentActivity) => void, options: BackgroundRunTrackerOptions, now?: () => number, mintRunId?: (channelId: string, providerRunId: string, startedAt: number, executionId?: string) => string);
     observe(channelId: string, update: ProviderProgressUpdate): void;
+    replay(): void;
     stop(channelId: string, runId: string): Promise<{
         outcome: 'stopped' | 'not_found' | 'unsupported';
         reason?: string;

package/dist/background-runs.js

@@ -20,15 +20,26 @@ export class BackgroundRunTracker {
         const key = `${channelId}\0${update.run.providerRunId}`;
         const held = this.runs.get(key);
         const state = runState(update.run.state);
+        const refinesUnknown = held?.state === 'unknown' && state !== 'unknown';
         const stopSupported = update.run.stopSupported &&
             this.options.targetedCancellationSupported &&
             this.options.cancel !== undefined;
         const executionChanged = held !== undefined &&
-            update.run.startedAt !== undefined &&
-            update.run.startedAt !== held.startedAt;
-        const startsNewExecution = !held || executionChanged || (isTerminal(held.state) && !isTerminal(state));
-        if (held && isTerminal(held.state) && isTerminal(state) && !startsNewExecution)
+            ((update.run.executionId !== undefined &&
+                update.run.executionId !== held.executionId) ||
+                (update.run.startedAt !== undefined &&
+                    update.run.startedAt !== held.startedAt));
+        const startsNewExecution = !held ||
+            executionChanged ||
+            (held.state !== 'unknown' && isTerminal(held.state) && !isTerminal(state));
+        if (held &&
+            isTerminal(held.state) &&
+            isTerminal(state) &&
+            !startsNewExecution &&
+            held.state !== state &&
+            held.state !== 'unknown') {
             return;
+        }
         const startedAt = startsNewExecution
             ? (update.run.startedAt ?? this.now())
             : (update.run.startedAt ?? held.startedAt);
@@ -36,9 +47,11 @@ export class BackgroundRunTracker {
             ? {
                 channelId,
                 providerRunId: update.run.providerRunId,
-                runId: this.mintRunId(channelId, update.run.providerRunId, startedAt),
+                runId: this.mintRunId(channelId, update.run.providerRunId, startedAt, update.run.executionId),
+                executionId: update.run.executionId,
                 label: update.run.label,
                 state,
+                parentActivityId: update.run.parentActivityId,
                 startedAt,
                 finishedAt: update.run.finishedAt,
                 reason: update.run.reason,
@@ -48,32 +61,53 @@ export class BackgroundRunTracker {
                 ...held,
                 label: update.run.label,
                 state,
+                parentActivityId: update.run.parentActivityId ?? held.parentActivityId,
                 startedAt,
-                finishedAt: update.run.finishedAt,
-                reason: update.run.reason,
+                finishedAt: refinesUnknown
+                    ? update.run.finishedAt
+                    : (update.run.finishedAt ?? held.finishedAt),
+                reason: refinesUnknown ? update.run.reason : (update.run.reason ?? held.reason),
                 stopSupported,
             };
         if (isTerminal(state) && run.finishedAt === undefined) {
             run.finishedAt = this.now();
         }
+        if (held &&
+            held.runId === run.runId &&
+            held.label === run.label &&
+            held.state === run.state &&
+            held.parentActivityId === run.parentActivityId &&
+            held.finishedAt === run.finishedAt &&
+            held.reason === run.reason &&
+            held.stopSupported === run.stopSupported) {
+            return;
+        }
         if (held && held.runId !== run.runId) {
             this.runsById.delete(held.runId);
         }
         this.runs.delete(key);
         this.runs.set(key, run);
         this.runsById.set(run.runId, run);
-        while (this.runs.size > MAX_TRACKED_RUNS) {
-            const oldestKey = this.runs.keys().next().value;
-            if (typeof oldestKey !== 'string') {
+        let historySize = [...this.runs.values()].filter((candidate) => isTerminal(candidate.state)).length;
+        while (historySize > MAX_TRACKED_RUNS) {
+            const oldest = [...this.runs].find(([, candidate]) => isTerminal(candidate.state));
+            if (!oldest) {
                 break;
             }
-            const oldest = this.runs.get(oldestKey);
-            this.runs.delete(oldestKey);
-            if (oldest) {
-                this.runsById.delete(oldest.runId);
-            }
+            this.runs.delete(oldest[0]);
+            this.runsById.delete(oldest[1].runId);
+            historySize -= 1;
         }
         this.publish(run);
+        if (isConcreteTerminal(state) &&
+            (startsNewExecution || !held || !isConcreteTerminal(held.state))) {
+            this.options.onFinished?.(channelId, { runId: run.runId, state });
+        }
+    }
+    replay() {
+        for (const run of this.runs.values()) {
+            this.publish(run);
+        }
     }
     async stop(channelId, runId) {
         if (!this.options.lifecycleSupported ||
@@ -110,6 +144,7 @@ export class BackgroundRunTracker {
             runId: run.runId,
             label: run.label,
             state: run.state,
+            ...(run.parentActivityId ? { parentId: run.parentActivityId } : {}),
             startedAt: run.startedAt,
             ...(run.finishedAt !== undefined ? { finishedAt: run.finishedAt } : {}),
             ...(run.reason ? { reason: run.reason } : {}),
@@ -135,18 +170,18 @@ function runState(status) {
     }
 }
 function isTerminal(state) {
-    return (state === 'completed' ||
-        state === 'failed' ||
-        state === 'cancelled' ||
-        state === 'unknown');
+    return (isConcreteTerminal(state) || state === 'unknown');
+}
+function isConcreteTerminal(state) {
+    return state === 'completed' || state === 'failed' || state === 'cancelled';
 }
-function stableRunId(channelId, providerRunId, startedAt) {
+function stableRunId(channelId, providerRunId, startedAt, executionId) {
     const digest = createHash('sha256')
         .update(channelId)
         .update('\0')
         .update(providerRunId)
         .update('\0')
-        .update(String(startedAt))
+        .update(executionId ?? String(startedAt))
         .digest('hex')
         .slice(0, 32);
     return `run_${digest}`;

package/dist/chat/chat-control-plane.d.ts

@@ -1,8 +1,9 @@
-import type { AgentActivity, ReportTurnActivityInput, StopBackgroundRunHandler, StopTurnHandler, TurnActivityReporter } from '../plugin-sdk.js';
+import type { AgentActivity, ReportTaskFinishedInput, ReportTurnActivityInput, StopBackgroundRunHandler, StopTurnHandler, TurnActivityReporter } from '../plugin-sdk.js';
 import type { ChannelSummary, ChannelHistoryEntry, ChannelMessageEvent, CreateTaskInput, DirectoryUser, MeResponseUser, PostMessageInput, PostedMessage, ReadChannelHistoryInput, Task, UpdateTaskInput } from '../types.js';
 export interface ChatControlPlane {
     onStopTurn?(handler: StopTurnHandler | undefined): void;
     onStopBackgroundRun?(handler: StopBackgroundRunHandler | undefined): void;
+    onActivityTransportReady?(handler: (() => void) | undefined): void;
     connect(onMessage: (message: ChannelMessageEvent) => void): Promise<void>;
     close(): Promise<void>;
     postMessage(input: PostMessageInput): Promise<PostedMessage>;
@@ -11,6 +12,7 @@ export interface ChatControlPlane {
     startTyping(channelId: string): () => void;
     /** Opens one turn's report on the activity rail. Fire-and-forget: nothing recovers what it sends. */
     reportTurnActivity(input: ReportTurnActivityInput): TurnActivityReporter;
+    reportTaskFinished?(input: ReportTaskFinishedInput): void;
     reportActivity?(input: {
         channelId: string;
         activity: AgentActivity;

package/dist/chat/sdk-chat-control-plane.d.ts

@@ -1,7 +1,7 @@
-import { type BorgeePluginClient, type BorgeePluginOptions, type InboundMessageEvent, type ReportTurnActivityInput, type StopTurnHandler, type StopBackgroundRunHandler, type TurnActivityReporter } from '../plugin-sdk.js';
+import { type BorgeePluginClient, type BorgeePluginOptions, type InboundMessageEvent, type ReportTaskFinishedInput, type ReportTurnActivityInput, type StopTurnHandler, type StopBackgroundRunHandler, type TurnActivityReporter } from '../plugin-sdk.js';
 import type { ChannelSummary, ChannelHistoryEntry, ChannelMessageEvent, CreateTaskInput, DirectoryUser, MeResponseUser, PostMessageInput, PostedMessage, ReadChannelHistoryInput, Task, UpdateTaskInput } from '../types.js';
 import type { ChatControlPlane } from './chat-control-plane.js';
-type PluginClientLike = Pick<BorgeePluginClient, 'agentId' | 'close' | 'connect' | 'createTask' | 'deleteMessage' | 'editMessage' | 'getMe' | 'getTask' | 'listChannels' | 'listTasks' | 'listUsers' | 'on' | 'onStopTurn' | 'onStopBackgroundRun' | 'reportActivity' | 'readHistory' | 'reportTurnActivity' | 'sendMessage' | 'startTyping' | 'updateTask' | 'setTaskProperty' | 'deleteTaskProperty'>;
+type PluginClientLike = Pick<BorgeePluginClient, 'agentId' | 'close' | 'connect' | 'createTask' | 'deleteMessage' | 'editMessage' | 'getMe' | 'getTask' | 'listChannels' | 'listTasks' | 'listUsers' | 'on' | 'onStopTurn' | 'onStopBackgroundRun' | 'reportActivity' | 'readHistory' | 'reportTurnActivity' | 'sendMessage' | 'startTyping' | 'updateTask' | 'setTaskProperty' | 'deleteTaskProperty'> & Partial<Pick<BorgeePluginClient, 'reportTaskFinished'>>;
 type PluginClientFactory = (options: BorgeePluginOptions) => PluginClientLike;
 type SdkChatControlPlaneOptions = Pick<BorgeePluginOptions, 'pluginId'>;
 /**
@@ -13,15 +13,19 @@ export declare class SdkChatControlPlane implements ChatControlPlane {
     private readonly client;
     private pendingMessages;
     private unsubscribe;
+    private stateUnsubscribe;
+    private activityTransportReady;
     private connected;
     private me;
     constructor(baseUrl: string, apiKey: string, createClient?: PluginClientFactory, options?: SdkChatControlPlaneOptions);
     onStopTurn(handler: StopTurnHandler | undefined): void;
     onStopBackgroundRun(handler: StopBackgroundRunHandler | undefined): void;
+    onActivityTransportReady(handler: (() => void) | undefined): void;
     connect(onMessage: (message: ChannelMessageEvent) => void): Promise<void>;
     close(): Promise<void>;
     postMessage(input: PostMessageInput): Promise<PostedMessage>;
     reportActivity(input: Parameters<BorgeePluginClient['reportActivity']>[0]): void;
+    reportTaskFinished(input: ReportTaskFinishedInput): void;
     editMessage(messageId: string, content: string): Promise<void>;
     deleteMessage(messageId: string): Promise<void>;
     startTyping(channelId: string): () => void;

package/dist/chat/sdk-chat-control-plane.js

@@ -9,6 +9,8 @@ export class SdkChatControlPlane {
     client;
     pendingMessages = [];
     unsubscribe = null;
+    stateUnsubscribe = null;
+    activityTransportReady;
     connected = false;
     me = null;
     constructor(baseUrl, apiKey, createClient = createBorgeePlugin, options = {}) {
@@ -20,6 +22,9 @@ export class SdkChatControlPlane {
     onStopBackgroundRun(handler) {
         this.client.onStopBackgroundRun?.(handler);
     }
+    onActivityTransportReady(handler) {
+        this.activityTransportReady = handler;
+    }
     async connect(onMessage) {
         this.unsubscribe = this.client.on('message', (event) => {
             const message = mapInboundToChannelMessage(event);
@@ -29,6 +34,11 @@ export class SdkChatControlPlane {
             }
             onMessage(message);
         });
+        this.stateUnsubscribe = this.client.on('connectionState', (state) => {
+            if (state.status === 'online') {
+                this.activityTransportReady?.();
+            }
+        });
         try {
             await this.client.connect();
             this.connected = true;
@@ -43,6 +53,8 @@ export class SdkChatControlPlane {
         catch (error) {
             this.unsubscribe?.();
             this.unsubscribe = null;
+            this.stateUnsubscribe?.();
+            this.stateUnsubscribe = null;
             this.pendingMessages = [];
             throw error;
         }
@@ -52,6 +64,9 @@ export class SdkChatControlPlane {
         this.pendingMessages = [];
         this.unsubscribe?.();
         this.unsubscribe = null;
+        this.stateUnsubscribe?.();
+        this.stateUnsubscribe = null;
+        this.activityTransportReady = undefined;
         this.client.onStopTurn(undefined);
         this.client.onStopBackgroundRun?.(undefined);
         await this.client.close();
@@ -67,6 +82,9 @@ export class SdkChatControlPlane {
     reportActivity(input) {
         this.client.reportActivity(input);
     }
+    reportTaskFinished(input) {
+        this.client.reportTaskFinished?.(input);
+    }
     async editMessage(messageId, content) {
         await this.client.editMessage({ messageId, body: content });
     }

package/dist/plugin-sdk.js

@@ -3722,8 +3722,8 @@ var import_websocket_server = __toESM(require_websocket_server(), 1);
 // ../sdk/plugin-ts/dist/errors.js
 var BorgeeError = class extends Error {
   code;
-  constructor(message, code) {
-    super(message);
+  constructor(message, code, options) {
+    super(message, options);
     this.name = "BorgeeError";
     this.code = code;
   }
@@ -3743,6 +3743,95 @@ var PermissionDeniedError = class extends BorgeeError {
   }
 };
 
+// ../sdk/plugin-ts/dist/channel-contracts.js
+var isZoneId = (value) => typeof value === "string" && /^[A-Za-z0-9_-]{1,128}$/.test(value);
+var validateChannelPlacement = (parentId) => {
+  if (parentId !== null && (!isZoneId(parentId) || parentId === "null")) {
+    throw new BorgeeError("parentId is required: pass null for Default or a Zone ID", "channel.placement_invalid");
+  }
+};
+var rejectChannelPlacementUpdate = (input) => {
+  for (const field of ["parentId", "parent_id", "channelType", "channel_type", "kind"]) {
+    if (Object.hasOwn(input, field)) {
+      throw new BorgeeError(`${field} cannot be changed after channel creation`, "channel.field_immutable");
+    }
+  }
+};
+var validateListZonesInput = (input) => {
+  if (!isZoneId(input.guildId)) {
+    throw new BorgeeError("guildId must be a nonempty opaque ID", "zone.input_invalid");
+  }
+  if (input.limit !== void 0 && (!Number.isInteger(input.limit) || input.limit < 1 || input.limit > 50)) {
+    throw new BorgeeError("limit must be an integer between 1 and 50", "zone.input_invalid");
+  }
+  if (input.after !== void 0 && !isZoneId(input.after)) {
+    throw new BorgeeError("after must be a nonempty opaque Zone ID", "zone.input_invalid");
+  }
+};
+
+// ../sdk/plugin-ts/dist/bpp/channel-results.js
+var invalidResult = (field) => new BorgeeError(`Invalid channel result: ${field}`, "bpp.invalid_result");
+var record = (value, field) => {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw invalidResult(field);
+  return value;
+};
+var requiredString = (value, field) => {
+  if (typeof value !== "string")
+    throw invalidResult(field);
+  return value;
+};
+var decodeChannel = (value) => {
+  const channel = record(value, "channel");
+  if (!isZoneId(channel.id))
+    throw invalidResult("id");
+  if (channel.parent_id !== null && !isZoneId(channel.parent_id))
+    throw invalidResult("parent_id");
+  return {
+    id: channel.id,
+    name: requiredString(channel.name, "name"),
+    kind: requiredString(channel.kind, "kind"),
+    parentId: channel.parent_id
+  };
+};
+var decodeChannels = (value) => {
+  if (!Array.isArray(value))
+    throw invalidResult("channels");
+  return value.map(decodeChannel);
+};
+var decodeZone = (value) => {
+  const zone = record(value, "zone");
+  if (!isZoneId(zone.id))
+    throw invalidResult("zone.id");
+  const name = requiredString(zone.name, "zone.name");
+  if (new RegExp("^\\p{White_Space}|\\p{White_Space}$", "u").test(name) || [...name].length < 1 || [...name].length > 100 || /[\p{Cc}\p{Cs}]/u.test(name)) {
+    throw invalidResult("zone.name");
+  }
+  return { id: zone.id, name };
+};
+var decodeZonePage = (value, input) => {
+  const page = record(value, "Zone page");
+  if (!Array.isArray(page.zones))
+    throw invalidResult("zones");
+  const limit = input?.limit ?? 20;
+  if (page.zones.length > limit)
+    throw invalidResult("zones exceed the requested limit");
+  const zones = page.zones.map(decodeZone);
+  let previous = input?.after;
+  for (const zone of zones) {
+    if (previous !== void 0 && zone.id <= previous)
+      throw invalidResult("Zone IDs must follow the cursor in ascending order");
+    previous = zone.id;
+  }
+  const nextAfter = page.next_after;
+  if (nextAfter !== null) {
+    if (!isZoneId(nextAfter) || zones.length !== limit || nextAfter !== zones.at(-1)?.id) {
+      throw invalidResult("next_after must be null or the final ID of a full page");
+    }
+  }
+  return { zones, nextAfter };
+};
+
 // ../sdk/plugin-ts/dist/bpp/bpp-transport.js
 var PROTOCOL_VERSION = "bpp-1";
 var CONFIG_ACK_REASONS = /* @__PURE__ */ new Set([
@@ -3929,7 +4018,13 @@ var BppTransport = class {
         this.pending.delete(nonce);
         reject(new BorgeeError(`semantic_action ${action.op} timed out`, "bpp.action_timeout"));
       }, remaining);
-      this.pending.set(nonce, { op: action.op, resolve, reject, timer });
+      this.pending.set(nonce, {
+        op: action.op,
+        ...action.op === "list_zones" ? { zoneInput: { guildId: action.guildId, limit: action.limit, after: action.after } } : {},
+        resolve,
+        reject,
+        timer
+      });
       this.send(frame);
     });
   }
@@ -4159,7 +4254,13 @@ var BppTransport = class {
     this.pending.delete(frame.nonce);
     clearTimeout(p.timer);
     if (frame.status === RESULT_STATUS_OK) {
-      const result = decodeActionResult(p.op, frame.payload);
+      let result;
+      try {
+        result = decodeActionResult(p.op, frame.payload, p.zoneInput);
+      } catch (error) {
+        p.reject(error);
+        return;
+      }
       if (p.op === "get_me" && result && typeof result === "object") {
         const id = result.id;
         if (id)
@@ -4401,7 +4502,7 @@ var BppTransport = class {
     };
     this.send(frame);
   }
-  // sendActivity flattens the four-shape union onto one frame. The union is
+  // sendActivity flattens the activity union onto one frame. The union is
   // how a producer says which shape it is reporting; the wire puts the
   // discriminator beside its payload with no wrapper object, matching both the
   // protocol this relays and inbound_message's own `kind`.
@@ -4443,6 +4544,9 @@ var BppTransport = class {
         frame.detail = action.activity.detail ?? "";
         frame.parent_id = action.activity.parentId ?? "";
         frame.subagent = action.activity.subagent ?? false;
+        frame.background = action.activity.background;
+        frame.background_state = action.activity.backgroundState;
+        frame.follow_up_control = action.activity.followUpControl;
         frame.reason = action.activity.reason ?? "";
         if (action.activity.paths)
           frame.paths = action.activity.paths;
@@ -4464,12 +4568,25 @@ var BppTransport = class {
         frame.run_id = action.activity.runId;
         frame.label = action.activity.label;
         frame.run_state = action.activity.state;
+        frame.parent_id = action.activity.parentId ?? "";
         frame.started_at = action.activity.startedAt;
         frame.finished_at = action.activity.finishedAt ?? 0;
         frame.reason = action.activity.reason ?? "";
         frame.stop_supported = action.activity.stopSupported;
         frame.stop_unsupported_reason = action.activity.stopUnsupportedReason ?? "";
         break;
+      case "normalized":
+        frame.protocol_version = action.activity.protocolVersion;
+        frame.task_id = action.activity.taskId;
+        frame.event = action.activity.event;
+        break;
+    }
+    if (action.activity.shape === "normalized") {
+      const ids = [frame.channel_id, frame.task_id];
+      if (ids.some((value) => new TextEncoder().encode(value).byteLength > 256))
+        return;
+      if (new TextEncoder().encode(JSON.stringify(frame)).byteLength > 32768)
+        return;
     }
     this.send(frame);
   }
@@ -4603,15 +4720,21 @@ function encodeActionPayload(action) {
     case "list_users":
     case "list_channels":
       return {};
+    case "list_zones":
+      validateListZonesInput(action);
+      return { guild_id: action.guildId, limit: action.limit, after: action.after };
     case "create_channel":
+      validateChannelPlacement(action.parentId);
       return {
         guild_id: action.guildId,
         name: action.name,
+        parent_id: action.parentId,
         topic: action.topic,
         visibility: action.visibility,
         member_ids: action.memberIds
       };
     case "update_channel":
+      rejectChannelPlacementUpdate(action);
       return {
         channel_id: action.channelId,
         name: action.name,
@@ -4655,7 +4778,20 @@ function encodeActionPayload(action) {
       return {};
   }
 }
-function decodeActionResult(op, payloadJSON) {
+function decodeActionResult(op, payloadJSON, zoneInput) {
+  if (op === "list_zones" || op === "list_channels" || op === "create_channel" || op === "update_channel") {
+    let value;
+    try {
+      value = JSON.parse(payloadJSON);
+    } catch (cause) {
+      throw new BorgeeError("Invalid JSON in channel result", "bpp.invalid_result", { cause });
+    }
+    if (op === "list_zones")
+      return decodeZonePage(value, zoneInput);
+    if (op === "list_channels")
+      return decodeChannels(value);
+    return decodeChannel(value);
+  }
   const p = safeParseJSON(payloadJSON);
   switch (op) {
     case "send_message":
@@ -4695,21 +4831,6 @@ function decodeActionResult(op, payloadJSON) {
         kind: u.kind === "agent" ? "agent" : "user"
       }));
     }
-    case "list_channels": {
-      const arr = Array.isArray(p) ? p : [];
-      return arr.map((c) => ({
-        id: String(c.id ?? ""),
-        name: String(c.name ?? ""),
-        kind: String(c.kind ?? "")
-      }));
-    }
-    case "create_channel":
-    case "update_channel":
-      return {
-        id: String(p.id ?? ""),
-        name: String(p.name ?? ""),
-        kind: String(p.kind ?? "")
-      };
     case "set_topic":
     case "delete_channel":
       return void 0;
@@ -5050,16 +5171,19 @@ var Client = class {
     return await this.t.perform({ op: "list_channels" });
   }
   async createChannel(input) {
+    validateChannelPlacement(input.parentId);
     return await this.t.perform({
       op: "create_channel",
       guildId: input.guildId,
       name: input.name,
+      parentId: input.parentId,
       topic: input.topic,
       visibility: input.visibility,
       memberIds: input.memberIds
     });
   }
   async updateChannel(input) {
+    rejectChannelPlacementUpdate(input);
     return await this.t.perform({
       op: "update_channel",
       channelId: input.channelId,
@@ -5068,6 +5192,10 @@ var Client = class {
       archived: input.archived
     });
   }
+  async listZones(input) {
+    validateListZonesInput(input);
+    return await this.t.perform({ op: "list_zones", ...input });
+  }
   async setTopic(input) {
     await this.t.perform({ op: "set_topic", channelId: input.channelId, topic: input.topic });
   }