@borgee/agents-host 0.2.62 → 0.2.68

package/dist/agents-host.d.ts

@@ -1,6 +1,6 @@
 import type { ChatControlPlane } from './chat/chat-control-plane.js';
 import { type AgentsHostRuntimeOptions } from './debug.js';
-import type { ProviderAdapter } from './providers/provider-adapter.js';
+import { type ProviderAdapter } from './providers/provider-adapter.js';
 import type { AgentsHostConfig } from './types.js';
 /**
  * Minimal single-agent agents host: connects one local Claude/Copilot CLI
@@ -160,6 +160,8 @@ export declare class AgentsHost {
     private readCollaborationDraft;
     private supersedeActiveTurn;
     private invalidateChannelTurn;
+    private stopTurn;
+    private responseStateForExecuted;
     private rememberRecentTurn;
     private resolveAuthorizedCollaborationTurn;
     private updateAwaitingUserState;

package/dist/agents-host.js

@@ -12,6 +12,7 @@ import { createLocalhostGatewayController, LOCALHOST_GATEWAY_COLLABORATION_TARGE
 import { extractTaskIdFromTaskAssignmentContent, resolveTaskAssignmentStatePath, } from './context/injection.js';
 import { AuthorizationAuditSink, } from './policy/authorization-audit.js';
 import { createProvider } from './providers/create-provider.js';
+import { ProviderTurnCancelledError } from './providers/provider-adapter.js';
 import { resolveAttentionStatePath, resolveCompactionStatePath, resolveSharedProtocolKickoffDecisionPath, resolveSharedProtocolStatusPath, } from './state-paths.js';
 import { appendVisibleMention as appendVisibleBodyMention, extractVisibleMentionIds as extractCanonicalMentionIds, } from './visible-mentions.js';
 import { buildHostedIncomingContentText, buildHostedTurnContentParts, extractHostedMessageAttachments, normalizeHostedMessageAttachment, } from './hosted-turn-content.js';
@@ -24,6 +25,9 @@ const PROTOCOL_KICKOFF_DECISION_POLL_INTERVAL_MS = 50;
 const PROTOCOL_KICKOFF_ROUND_LIMIT = 20;
 const COLLABORATION_LATE_SEND_GRACE_MS = 5_000;
 const ORDINARY_HUMAN_EVENT_KINDS = new Set(['', 'message']);
+const TASK_EXECUTION_LOCAL_DIRECTORY_PROPERTY_KEY = 'execution.local_directory';
+const TASK_EXECUTION_LOCAL_DIRECTORY_REMINDER = 'This task has no Execution Local Directory yet. Set it before asking me to work in a real local project directory.';
+const TASK_EXECUTION_LOCAL_DIRECTORY_IN_USE_PREFIX = 'Using Execution Local Directory:';
 async function ensurePrivateStateRoot(path) {
     await mkdir(path, { recursive: true, mode: PRIVATE_STATE_ROOT_MODE });
     await chmod(path, PRIVATE_STATE_ROOT_MODE);
@@ -145,13 +149,15 @@ class DefaultHostRuntime {
                 });
         this.ensureStateRoot = deps.ensureStateRoot ?? ensurePrivateStateRoot;
     }
-    async start(onMessage) {
+    async start(onMessage, onStopTurn) {
         await this.ensureStateRoot(this.config.stateRootDir);
         await this.gateway.start();
         try {
+            this.controlPlane.onStopTurn?.(onStopTurn);
             await this.controlPlane.connect(onMessage);
         }
         catch (error) {
+            this.controlPlane.onStopTurn?.(undefined);
             await this.gateway.stop().catch(() => { });
             throw error;
         }
@@ -159,6 +165,7 @@ class DefaultHostRuntime {
     async stop() {
         let thrown;
         try {
+            this.controlPlane.onStopTurn?.(undefined);
             await this.controlPlane.close();
         }
         catch (error) {
@@ -366,7 +373,7 @@ export class AgentsHost {
                     return;
                 }
                 this.dispatchMessage(message);
-            });
+            }, async (channelId) => this.stopTurn(channelId));
             const agentId = await this.ensureSelfAgentId();
             bufferingMessages = false;
             while (bufferedMessages.length > 0) {
@@ -675,7 +682,7 @@ export class AgentsHost {
             return null;
         }
         this.recordCollaborationOutcome(msg.channel_id, {
-            responseState: executed.completed ? 'responded' : 'failed',
+            responseState: this.responseStateForExecuted(executed),
             deliveryState: executed.deliveryState ?? 'not-delivered',
         });
         this.updateMissedCollaborationDiagnostic(msg.channel_id, priorMissedCollaborationDiagnostic);
@@ -1110,7 +1117,7 @@ export class AgentsHost {
         channelState.blocked = undefined;
         this.awaitingUserByChannel.delete(channelId);
         this.recordCollaborationOutcome(channelId, {
-            responseState: executed.completed ? 'responded' : 'failed',
+            responseState: this.responseStateForExecuted(executed),
             deliveryState: executed.deliveryState ?? 'not-delivered',
             ...(message.wakeBlockedState ? { wakeState: 'resumed-human' } : {}),
             turnExecutionId: activeTurn.turnExecutionId ?? undefined,
@@ -1174,7 +1181,7 @@ export class AgentsHost {
         const visibleMessageId = deliveredMessageId ?? protocolState.lastProtocolMessageId;
         if (executed.reply?.controlMalformed) {
             this.recordCollaborationOutcome(channelId, {
-                responseState: executed.completed ? 'responded' : 'failed',
+                responseState: this.responseStateForExecuted(executed),
                 deliveryState: executed.deliveryState ?? 'not-delivered',
                 ...(message.wakeBlockedState ? { wakeState: 'resumed-human' } : {}),
                 turnExecutionId: activeTurn.turnExecutionId ?? undefined,
@@ -1184,7 +1191,7 @@ export class AgentsHost {
         }
         if (!executed.reply?.control) {
             this.recordCollaborationOutcome(channelId, {
-                responseState: executed.completed ? 'responded' : 'failed',
+                responseState: this.responseStateForExecuted(executed),
                 deliveryState: executed.deliveryState ?? 'not-delivered',
                 ...(message.wakeBlockedState ? { wakeState: 'resumed-human' } : {}),
                 turnExecutionId: activeTurn.turnExecutionId ?? undefined,
@@ -1218,7 +1225,7 @@ export class AgentsHost {
         }
         if (executed.reply.control.kind === 'start-protocol') {
             this.recordCollaborationOutcome(channelId, {
-                responseState: executed.completed ? 'responded' : 'failed',
+                responseState: this.responseStateForExecuted(executed),
                 deliveryState: executed.deliveryState ?? 'not-delivered',
                 ...(message.wakeBlockedState ? { wakeState: 'resumed-human' } : {}),
                 turnExecutionId: activeTurn.turnExecutionId ?? undefined,
@@ -1229,7 +1236,7 @@ export class AgentsHost {
         }
         if (executed.reply.control.kind === 'attention-only') {
             this.recordCollaborationOutcome(channelId, {
-                responseState: executed.completed ? 'responded' : 'failed',
+                responseState: this.responseStateForExecuted(executed),
                 deliveryState: executed.deliveryState ?? 'not-delivered',
                 ...(message.wakeBlockedState ? { wakeState: 'resumed-human' } : {}),
                 turnExecutionId: activeTurn.turnExecutionId ?? undefined,
@@ -2188,9 +2195,7 @@ export class AgentsHost {
         this.recordCollaborationOutcome(msg.channel_id, {
             responseState: executed.completed && executed.reply?.awaitingUser
                 ? 'blocked'
-                : executed.completed
-                    ? 'responded'
-                    : 'failed',
+                : this.responseStateForExecuted(executed),
             deliveryState: executed.deliveryState ?? 'not-delivered',
             ...(executed.completed && executed.reply?.awaitingUser
                 ? {
@@ -2444,6 +2449,65 @@ export class AgentsHost {
                     turnExecutionId: activeTurn.turnExecutionId,
                 });
             }
+            if (error instanceof ProviderTurnCancelledError) {
+                const cancelledReplyText = error.publicReplyText?.trim();
+                if (!silentTurn &&
+                    !deferDelivery &&
+                    typeof cancelledReplyText === 'string' &&
+                    cancelledReplyText.length > 0 &&
+                    this.started &&
+                    !this.controlPlaneClosed) {
+                    reply = { text: cancelledReplyText };
+                    publicReplyText = cancelledReplyText;
+                    visibleReplyBody = this.resolveVisibleTurnBody(activeTurn, reply, publicReplyText);
+                    try {
+                        const posted = await this.borgee.postMessage({
+                            channelId,
+                            body: visibleReplyBody,
+                            replyToId: activeTurn?.delivery?.replyToId,
+                        });
+                        this.logger.debug('posted cancelled turn feedback', {
+                            ...turnContext,
+                            durationMs: Date.now() - turnStartedAt,
+                            replyLength: publicReplyText.length,
+                            delivery: 'post',
+                        });
+                        return {
+                            reply,
+                            deliveredMessageId: posted.messageId,
+                            publicReplyText,
+                            visibleReplyBody,
+                            deliveryState: 'posted',
+                            stale: activeTurn?.superseded === true,
+                            completed: false,
+                            cancelled: true,
+                        };
+                    }
+                    catch (postError) {
+                        this.logger.debugError('failed to post cancelled turn feedback', {
+                            ...turnContext,
+                            error: postError,
+                        });
+                        this.logger.error('failed to post cancelled turn feedback', {
+                            ...turnContext,
+                            error: summarizeError(postError),
+                        });
+                    }
+                }
+                this.logger.debug('cancelled turn', {
+                    ...turnContext,
+                    durationMs: Date.now() - turnStartedAt,
+                });
+                return {
+                    reply,
+                    publicReplyText,
+                    visibleReplyBody,
+                    deliveryState: 'not-delivered',
+                    stale: activeTurn?.superseded === true,
+                    completed: false,
+                    cancelled: true,
+                };
+            }
             this.logger.debugError('failed to generate or send reply', {
                 ...turnContext,
                 error,
@@ -2655,6 +2719,29 @@ export class AgentsHost {
             activeTurn.turnExecutionId = null;
         }
     }
+    async stopTurn(channelId) {
+        const activeTurn = this.collaborationChannels.get(channelId)?.activeTurn;
+        const aborted = await this.provider.cancelTurn?.(channelId) ?? false;
+        if (!aborted) {
+            return { aborted: false };
+        }
+        if (activeTurn) {
+            this.supersedeActiveTurn(channelId, activeTurn);
+        }
+        else {
+            this.recordCollaborationOutcome(channelId, {
+                responseState: 'superseded',
+                deliveryState: 'not-delivered',
+            });
+        }
+        return { aborted: true };
+    }
+    responseStateForExecuted(executed) {
+        if (executed.cancelled) {
+            return 'superseded';
+        }
+        return executed.completed ? 'responded' : 'failed';
+    }
     rememberRecentTurn(channelState, activeTurn) {
         if (!activeTurn.turnExecutionId) {
             channelState.recentTurn = undefined;
@@ -2853,6 +2940,34 @@ export class AgentsHost {
             task = null;
         }
         if (task && task.assigneeId === selfAgentId) {
+            const executionLocalDirectory = task.properties?.[TASK_EXECUTION_LOCAL_DIRECTORY_PROPERTY_KEY];
+            if (typeof executionLocalDirectory !== 'string' || executionLocalDirectory.trim().length === 0) {
+                try {
+                    await this.borgee.postMessage({
+                        channelId: msg.channel_id,
+                        body: TASK_EXECUTION_LOCAL_DIRECTORY_REMINDER,
+                    });
+                }
+                catch (error) {
+                    this.logger.debugError('task local directory reminder post failed', {
+                        channelId: msg.channel_id,
+                        error,
+                    });
+                }
+                return null;
+            }
+            try {
+                await this.borgee.postMessage({
+                    channelId: msg.channel_id,
+                    body: `${TASK_EXECUTION_LOCAL_DIRECTORY_IN_USE_PREFIX} ${executionLocalDirectory}`,
+                });
+            }
+            catch (error) {
+                this.logger.debugError('task local directory notice post failed', {
+                    channelId: msg.channel_id,
+                    error,
+                });
+            }
             if (task.status === 'open') {
                 try {
                     await this.borgee.updateTask({

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

@@ -1,6 +1,7 @@
-import type { ReportTurnActivityInput, TurnActivityReporter } from '../plugin-sdk.js';
+import type { ReportTurnActivityInput, 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;
     connect(onMessage: (message: ChannelMessageEvent) => void): Promise<void>;
     close(): Promise<void>;
     postMessage(input: PostMessageInput): Promise<PostedMessage>;

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

@@ -1,7 +1,7 @@
-import { type BorgeePluginClient, type BorgeePluginOptions, type InboundMessageEvent, type ReportTurnActivityInput, type TurnActivityReporter } from '../plugin-sdk.js';
+import { type BorgeePluginClient, type BorgeePluginOptions, type InboundMessageEvent, type ReportTurnActivityInput, type StopTurnHandler, 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' | 'readHistory' | 'reportTurnActivity' | 'sendMessage' | 'startTyping' | 'updateTask' | 'setTaskProperty' | 'deleteTaskProperty'>;
+type PluginClientLike = Pick<BorgeePluginClient, 'agentId' | 'close' | 'connect' | 'createTask' | 'deleteMessage' | 'editMessage' | 'getMe' | 'getTask' | 'listChannels' | 'listTasks' | 'listUsers' | 'on' | 'onStopTurn' | 'readHistory' | 'reportTurnActivity' | 'sendMessage' | 'startTyping' | 'updateTask' | 'setTaskProperty' | 'deleteTaskProperty'>;
 type PluginClientFactory = (options: BorgeePluginOptions) => PluginClientLike;
 type SdkChatControlPlaneOptions = Pick<BorgeePluginOptions, 'pluginId'>;
 /**
@@ -16,6 +16,7 @@ export declare class SdkChatControlPlane implements ChatControlPlane {
     private connected;
     private me;
     constructor(baseUrl: string, apiKey: string, createClient?: PluginClientFactory, options?: SdkChatControlPlaneOptions);
+    onStopTurn(handler: StopTurnHandler | undefined): void;
     connect(onMessage: (message: ChannelMessageEvent) => void): Promise<void>;
     close(): Promise<void>;
     postMessage(input: PostMessageInput): Promise<PostedMessage>;

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

@@ -14,6 +14,9 @@ export class SdkChatControlPlane {
     constructor(baseUrl, apiKey, createClient = createBorgeePlugin, options = {}) {
         this.client = createClient({ baseUrl, apiKey, ...options });
     }
+    onStopTurn(handler) {
+        this.client.onStopTurn(handler);
+    }
     async connect(onMessage) {
         this.unsubscribe = this.client.on('message', (event) => {
             const message = mapInboundToChannelMessage(event);
@@ -46,6 +49,7 @@ export class SdkChatControlPlane {
         this.pendingMessages = [];
         this.unsubscribe?.();
         this.unsubscribe = null;
+        this.client.onStopTurn(undefined);
         await this.client.close();
     }
     async postMessage(input) {

package/dist/compatibility-gates.d.ts

@@ -25,12 +25,14 @@ export type InternalPolicyMode = 'audit-only' | 'enforce';
 export type InternalProviderImplementationPath = 'v1' | 'v2';
 export type InternalProviderImplementationKey = 'claude' | 'copilot';
 export type InternalProviderImplementationOverrides = Partial<Record<InternalProviderImplementationKey, InternalProviderImplementationPath>>;
+export declare const CURRENT_AGENTS_HOST_PACKAGE_VERSION: string;
 export interface ManagedRuntimeSettingsSnapshot {
     schemaVersion: number;
     compatibilityGates: string[];
     providerImplementationOverrides: string[];
     internalPolicyMode: InternalPolicyMode;
     projectionStrategy: ProjectionStrategy;
+    packageVersion: string;
 }
 export declare const DEFAULT_INTERNAL_COMPATIBILITY_GATES: readonly string[];
 export declare function resolveInternalProjectionStrategy(env?: NodeJS.ProcessEnv): ProjectionStrategy;

package/dist/compatibility-gates.js

@@ -1,4 +1,7 @@
 import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { DEFAULT_PROJECTION_STRATEGY, normalizeProjectionStrategy, } from './projection-strategy-values.js';
 export const CLAUDE_PROVIDER_V2_COMPATIBILITY_GATE = 'claude-provider-v2';
 export const COPILOT_PROVIDER_V2_COMPATIBILITY_GATE = 'copilot-provider-v2';
@@ -22,6 +25,15 @@ export const INTERNAL_POLICY_MODE_ENV = 'AGENTS_HOST_INTERNAL_POLICY_MODE';
 export const INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV = 'AGENTS_HOST_INTERNAL_PROVIDER_IMPLEMENTATIONS';
 export const INTERNAL_CLAUDE_PROMPT_STRATEGY_ENV = 'AGENTS_HOST_INTERNAL_CLAUDE_PROMPT_STRATEGY';
 export const MANAGED_RUNTIME_SETTINGS_SCHEMA_VERSION = 1;
+function readCurrentAgentsHostPackageVersion() {
+    const packageManifestPath = join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json');
+    const manifest = JSON.parse(readFileSync(packageManifestPath, 'utf8'));
+    if (typeof manifest.version !== 'string' || manifest.version.length === 0) {
+        throw new Error(`Unable to resolve agents-host package version from ${packageManifestPath}`);
+    }
+    return manifest.version;
+}
+export const CURRENT_AGENTS_HOST_PACKAGE_VERSION = readCurrentAgentsHostPackageVersion();
 const VALID_PROVIDER_IMPLEMENTATION_ENTRIES = '"claude:v1", "claude:v2", "copilot:v1", or "copilot:v2"';
 export const DEFAULT_INTERNAL_COMPATIBILITY_GATES = Object.freeze([
     ATTENTION_FOLLOW_SEMANTICS_COMPATIBILITY_GATE,
@@ -176,6 +188,7 @@ export function resolveManagedRuntimeSettingsSnapshot(env = process.env) {
         providerImplementationOverrides: resolveManagedRuntimeProviderImplementationOverrides(env, compatibilityGates),
         internalPolicyMode: resolveInternalPolicyMode(compatibilityGates.includes(POLICY_AUDIT_ENFORCEMENT_COMPATIBILITY_GATE), env),
         projectionStrategy: resolveInternalProjectionStrategy(env),
+        packageVersion: CURRENT_AGENTS_HOST_PACKAGE_VERSION,
     };
 }
 export function serializeManagedRuntimeSettingsSnapshot(snapshot) {

package/dist/context/prompt.js

@@ -565,9 +565,7 @@ function buildClaudeZeroTurnPrompt(params) {
     }
     const gatewayTaskLines = buildClaudeOrdinaryGatewayTaskLines(params.promptContext);
     return [
-        'Do not claim to have performed actions you did not actually perform.',
         ...(gatewayTaskLines.length > 0 ? [...gatewayTaskLines, ''] : []),
-        `New message from ${params.incomingAuthorId}:`,
         params.incomingContent,
     ].join('\n');
 }

package/dist/managed-daemon.js

@@ -7,7 +7,7 @@ import { fileURLToPath } from 'node:url';
 import { AgentsHostSupervisor } from './agents-host-supervisor.js';
 import { DEFAULT_PROJECTION_STRATEGY, normalizeProjectionStrategy, } from './projection-strategy-values.js';
 import { resolveChannelWorkspaceDirectory, resolveChannelWorkspaceRootDirectory, resolveManagedWorkspaceCollectionRoot, resolveTaskThreadScratchWorkspaceDirectory, } from './context/injection.js';
-import { CLAUDE_PROVIDER_V2_COMPATIBILITY_GATE, COMPATIBILITY_GATES_ENV, createManagedRuntimeSettingsFingerprint, INTERNAL_CLAUDE_PROMPT_STRATEGY_ENV, INTERNAL_DISABLED_COMPATIBILITY_GATES_ENV, INTERNAL_POLICY_MODE_ENV, INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV, MANAGED_RUNTIME_CONVERGENCE_COMPATIBILITY_GATE, MANAGED_RUNTIME_SETTINGS_SCHEMA_VERSION, resolveDisabledDefaultCompatibilityGates, resolveManagedRuntimeSettingsSnapshot, serializeManagedRuntimeSettingsSnapshot, normalizeInternalProviderImplementationOverrides, } from './compatibility-gates.js';
+import { CLAUDE_PROVIDER_V2_COMPATIBILITY_GATE, COMPATIBILITY_GATES_ENV, CURRENT_AGENTS_HOST_PACKAGE_VERSION, createManagedRuntimeSettingsFingerprint, INTERNAL_CLAUDE_PROMPT_STRATEGY_ENV, INTERNAL_DISABLED_COMPATIBILITY_GATES_ENV, INTERNAL_POLICY_MODE_ENV, INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV, MANAGED_RUNTIME_CONVERGENCE_COMPATIBILITY_GATE, MANAGED_RUNTIME_SETTINGS_SCHEMA_VERSION, resolveDisabledDefaultCompatibilityGates, resolveManagedRuntimeSettingsSnapshot, serializeManagedRuntimeSettingsSnapshot, normalizeInternalProviderImplementationOverrides, } from './compatibility-gates.js';
 import { DEFAULT_PROVIDER_COMMAND_CONFIG, hasLegacyClaudeOneShotArgs, loadConfigFromEnv, } from './config.js';
 import { loadLocalConfigGenerateSpec, materializeLocalConfig, parseGenerateConfigSpec, resolveLocalConfigLayout, } from './local-config.js';
 import { normalizeManagedRuntimeKey, resolveManagedBootstrapLockPath, resolveManagedDaemonEndpoint, resolveManagedDaemonLogPath, resolveManagedRuntimeRoot, resolveManagedStateRoot, resolveManagedRuntimeSettingsPath, } from './state-paths.js';
@@ -163,6 +163,7 @@ function normalizeManagedRuntimeSettingsSnapshot(snapshot) {
         providerImplementationOverrides,
         internalPolicyMode: snapshot.internalPolicyMode,
         projectionStrategy: snapshot.projectionStrategy ?? DEFAULT_PROJECTION_STRATEGY,
+        packageVersion: CURRENT_AGENTS_HOST_PACKAGE_VERSION,
     };
 }
 function parseManagedRuntimeSettingsSnapshotRecord(value, sourceLabel) {
@@ -197,6 +198,9 @@ function parseManagedRuntimeSettingsSnapshotRecord(value, sourceLabel) {
         providerImplementationOverrides: [...record.providerImplementationOverrides],
         internalPolicyMode: record.internalPolicyMode,
         projectionStrategy: projectionStrategy ?? DEFAULT_PROJECTION_STRATEGY,
+        packageVersion: typeof record.packageVersion === 'string' && record.packageVersion.trim().length > 0
+            ? record.packageVersion
+            : CURRENT_AGENTS_HOST_PACKAGE_VERSION,
     });
 }
 async function loadManagedRuntimeSettingsSnapshot(rootPath) {

package/dist/plugin-sdk.js

@@ -3777,7 +3777,6 @@ var BppTransport = class {
   // send issued during a reconnect never races ahead of the handshake.
   online = false;
   terminal = false;
-  inboundFailed = false;
   inboundChain = Promise.resolve();
   configChain = Promise.resolve();
   configAcks = /* @__PURE__ */ new Map();
@@ -3941,8 +3940,15 @@ var BppTransport = class {
         }
       });
       ws.on("close", (code, reason) => {
+        const closeReason = reason?.toString("utf8") ?? "";
         connectionAbort.abort();
         const wasCurrent = this.ws === ws;
+        const closeSummary = `code=${code} reason=${closeReason || "<none>"} current=${wasCurrent}`;
+        if (code === 1e3 || this.closed) {
+          this.logger?.info("bpp.ws_closed", closeSummary);
+        } else {
+          this.logger?.warn("bpp.ws_closed", closeSummary);
+        }
         if (wasCurrent) {
           this.online = false;
           this.stopHeartbeat();
@@ -3952,7 +3958,7 @@ var BppTransport = class {
         if (authFailed && wasCurrent) {
           this.closed = true;
           this.terminal = true;
-          this.logger?.error("bpp.auth_failed", `server closed with ${WS_CLOSE_AUTH_FAILED} (authentication failed); not reconnecting. reason=${reason?.toString("utf8") ?? ""}`);
+          this.logger?.error("bpp.auth_failed", `server closed with ${WS_CLOSE_AUTH_FAILED} (authentication failed); not reconnecting. reason=${closeReason}`);
           this.handlers?.onStateChange({ status: "error", reason: "api_key_invalid" });
         }
         if (wasCurrent) {
@@ -3998,6 +4004,7 @@ var BppTransport = class {
       }
       this.startHeartbeat();
       this.goOnline(ws);
+      this.logger?.info("bpp.connected");
       resolve();
     } catch (error) {
       const failure = error instanceof BorgeeError ? error : new BorgeeError(`agent identity handshake failed: ${String(error)}`, "bpp.identity_unresolved");
@@ -4011,6 +4018,7 @@ var BppTransport = class {
     this.reconnectAttempt += 1;
     const delay = Math.min(this.reconnectBaseMs * 2 ** (this.reconnectAttempt - 1), this.reconnectMaxMs);
     this.handlers?.onStateChange({ status: "reconnecting", attempt: this.reconnectAttempt });
+    this.logger?.info("bpp.reconnect_scheduled", `attempt=${this.reconnectAttempt} delay_ms=${delay}`);
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = void 0;
       if (this.closed)
@@ -4080,12 +4088,11 @@ var BppTransport = class {
   }
   handleInbound(frame) {
     this.inboundChain = this.inboundChain.then(() => {
-      if (this.inboundFailed)
-        return;
-      this.handlers?.onInbound(mapInbound(frame));
-    }).catch((error) => {
-      this.inboundFailed = true;
-      this.failTerminal(this.inboundFailure(error), this.ws);
+      try {
+        this.handlers?.onInbound(mapInbound(frame));
+      } catch (error) {
+        this.logger?.error("bpp.inbound_dispatch_failed", this.inboundFailure(error));
+      }
     });
   }
   handleActionResult(frame) {
@@ -4380,6 +4387,7 @@ var BppTransport = class {
   failTerminal(error, ws) {
     if (this.terminal)
       return;
+    this.logger?.error("bpp.terminal_failure", error);
     this.terminal = true;
     this.online = false;
     this.handlers?.onStateChange({ status: "error", reason: "unknown", code: error.code });
@@ -5051,8 +5059,13 @@ var Client = class {
     this.t.setStopTurnHandler?.(handler);
   }
   emit(event, payload) {
-    for (const h of this.listeners[event])
-      h(payload);
+    for (const h of this.listeners[event]) {
+      try {
+        h(payload);
+      } catch (error) {
+        this.logger.error("client.observer_failed", { event, error });
+      }
+    }
   }
   handlers() {
     return {