@ziggs-ai/agent-sdk 0.10.0 → 0.10.2

package/dist/runtime/AgentMachine.js

@@ -30,7 +30,7 @@ export class AgentMachine {
     toolManager;
     promptBuilder;
     memory;
-    wakeKeys;
+    writeKeys;
     state;
     status = 'active';
     ctx;
@@ -50,14 +50,14 @@ export class AgentMachine {
     get llmCalls() { return this._llmCalls; }
     get tokens() { return this._tokens; }
     get stateTimeoutUnhandled() { return this._stateTimeoutUnhandled; }
-    constructor({ workflow, executionCore, eff, toolManager, promptBuilder, memory, input, transitionTap, maxTurnsWithoutUserInput, wakeKeys }) {
+    constructor({ workflow, executionCore, eff, toolManager, promptBuilder, memory, input, transitionTap, maxTurnsWithoutUserInput, writeKeys }) {
         this.workflow = workflow;
         this.executionCore = executionCore;
         this.eff = eff;
         this.toolManager = toolManager;
         this.promptBuilder = promptBuilder;
         this.memory = memory;
-        this.wakeKeys = wakeKeys;
+        this.writeKeys = writeKeys;
         this._transitionTap = transitionTap;
         this._maxTurnsWithoutUserInput = maxTurnsWithoutUserInput ?? DEFAULT_MAX_TURNS_WITHOUT_USER_INPUT;
         this.state = input.state || workflow.initial;
@@ -202,7 +202,7 @@ export class AgentMachine {
                     eff: this.eff,
                     memory: this.memory,
                     incomingEvent: this._lastIncomingEvent,
-                    wakeKeys: this.wakeKeys,
+                    writeKeys: this.writeKeys,
                 });
                 this.ctx.toolResults = toolResults;
                 this._llmCalls += llmCalls;
@@ -296,7 +296,7 @@ export class AgentMachine {
                 promptBuilder: this.promptBuilder,
                 memory: this.memory,
                 definition: this.workflow,
-                wakeKeys: this.wakeKeys,
+                writeKeys: this.writeKeys,
             });
             this.ctx.toolResults = toolResults;
             this._llmCalls += llmCalls;
@@ -365,7 +365,7 @@ export class AgentMachine {
                 sessionId,
                 receiverId: userId,
                 text,
-                messageId: this.wakeKeys?.messageKey({ text, sessionId, receiverId: userId }),
+                messageId: this.writeKeys?.messageKey({ text, sessionId, receiverId: userId }),
             });
         }
         catch { /* best-effort */ }

package/dist/runtime/bootstrapCtx.js

@@ -18,14 +18,15 @@ import { migrateLegacyTaskFields } from './taskBookkeeping.js';
 export function bootstrapCtx(identity, existing) {
     if (existing) {
         const legacy = existing;
+        // ZIG-1128: the lane-level mirrors are destructured OFF, not carried through.
+        // `migrateLegacyTaskFields` has already folded whatever they held into
+        // `tasks`; keeping the empty husks on the restored Ctx is what let a live FSM
+        // guard read one and see "nothing delegated" forever.
+        const { pendingSubtasks: _pendingSubtasks, collectedResults: _collectedResults, delegatedAgreementIds: _delegatedAgreementIds, ...rest } = existing;
         return {
-            ...existing,
+            ...rest,
             identity,
             tasks: migrateLegacyTaskFields(legacy),
-            // ZIG-1057: deprecated mirrors stay empty; use all*() readers.
-            pendingSubtasks: {},
-            collectedResults: [],
-            delegatedAgreementIds: [],
         };
     }
     return {
@@ -34,9 +35,6 @@ export function bootstrapCtx(identity, existing) {
         activeAgreementId: null,
         activeTaskId: null,
         pendingProposalAgreementId: null,
-        pendingSubtasks: {},
-        collectedResults: [],
-        delegatedAgreementIds: [],
         toolResults: [],
         lastOutcome: { kind: 'enter' },
     };

package/dist/runtime/buildOutcome.d.ts

@@ -3,7 +3,6 @@ import type { Action, AgreementRef, Ctx, Outcome, TaskRef, ToolResultEntry } fro
 export interface WireResult {
     taskId?: string;
     state?: string;
-    status?: string;
     agreement?: AgreementRef;
     agreementId?: string;
     proposal?: {
@@ -37,6 +36,15 @@ export interface EmittedEvent {
     senderId?: string;
     [key: string]: unknown;
 }
+/**
+ * A chat message whose stated receiver is a DIFFERENT party. `receiverId` is
+ * the sender's addressing decision, carried on every wire frame; the
+ * human-broadcast sentinel counts as "elsewhere" for an agent (a broadcast is
+ * addressed to the room's humans). A frame with NO receiver keeps the turn —
+ * we cannot know it is not ours, and skipping on absence would deafen agents
+ * to malformed or legacy frames.
+ */
+export declare function isMessageAddressedElsewhere(ev: RawEvent | null | undefined, ownAgentId: string | null | undefined): boolean;
 /**
  * Converts a raw incoming event into the single Outcome that re-enters the
  * machine.

package/dist/runtime/buildOutcome.js

@@ -1,6 +1,21 @@
 import { isProtocolToolName, mapProtocolToolToOperation } from '../tasks/protocolRegistry.js';
 import { getBatchEvents, isTaskResultRelevantToAgent } from '../context/batch.js';
 import { bookForDelegation, ensureTaskBook, findBookHoldingPending, removeTaskBook, } from './taskBookkeeping.js';
+/**
+ * A chat message whose stated receiver is a DIFFERENT party. `receiverId` is
+ * the sender's addressing decision, carried on every wire frame; the
+ * human-broadcast sentinel counts as "elsewhere" for an agent (a broadcast is
+ * addressed to the room's humans). A frame with NO receiver keeps the turn —
+ * we cannot know it is not ours, and skipping on absence would deafen agents
+ * to malformed or legacy frames.
+ */
+export function isMessageAddressedElsewhere(ev, ownAgentId) {
+    return Boolean(ev &&
+        ev.type === 'message' &&
+        ownAgentId &&
+        ev.receiverId &&
+        ev.receiverId !== ownAgentId);
+}
 // ── outcomeFromEvent: incoming wire event → Outcome ──────────────────────────
 /**
  * Converts a raw incoming event into the single Outcome that re-enters the
@@ -139,6 +154,14 @@ function singleEventToOutcome(ev, ownAgentId) {
     // Suppress our own messages echoed back through the chat fanout.
     if (ownAgentId && ev.senderId && ev.senderId === ownAgentId)
         return null;
+    // Attention gate: a message addressed to someone else is room context, not
+    // a turn. Delivery is audience-based on purpose (everyone in the chat hears
+    // everything), so in a multi-agent room every agent used to burn an LLM turn
+    // per utterance just to decide it wasn't theirs — the sender already decided
+    // that by naming a receiver. The message still lands in chat history and
+    // rides in on the next wake's read-back; nothing is lost but the interrupt.
+    if (isMessageAddressedElsewhere(ev, ownAgentId))
+        return null;
     const text = typeof ev.text === 'string' ? ev.text : undefined;
     const senderType = typeof ev.senderType === 'string' ? ev.senderType : undefined;
     return { kind: 'message-received', text, senderId: ev.senderId, senderType };
@@ -286,8 +309,9 @@ function inferKindFromProtocolOp(op, result) {
         return 'task-delegated';
     }
     if (op === 'task-update') {
-        const status = task?.state || r.state || r.status;
-        if (status === 'completed' || status === 'failed')
+        // Same resolution as `isStateChangingProtocolEvent` above — `state` only.
+        const state = task?.state || r.state;
+        if (state === 'completed' || state === 'failed')
             return 'task-closed';
         return 'tool-result';
     }
@@ -462,10 +486,9 @@ export function applyOutcomeToCtx(ctx, outcome) {
         }
         case 'task-closed': {
             // Clear only this task's entry — sibling open tasks keep their books (ZIG-977).
-            const closedId = outcome.taskId ||
-                outcome.result?.task?.taskId ||
-                outcome.result?.taskId ||
-                ctx.activeTaskId;
+            // ZIG-1171: buildOutcomeOfKind already collapses result.task.taskId /
+            // result.taskId into outcome.taskId — do not re-walk the raw result here.
+            const closedId = outcome.taskId || ctx.activeTaskId;
             if (closedId)
                 removeTaskBook(ctx, closedId);
             else {

package/dist/runtime/{wakeWriteKeys.d.ts → deliveryWriteKeys.d.ts}

@@ -1,4 +1,4 @@
-import type { WakeWriteKeys } from '../types.js';
+import type { DeliveryWriteKeys } from '../types.js';
 /**
  * Build the per-wake key derivation. Call once per tick with the lane and the
  * raw triggering event, then thread the instance to every write of the wake.
@@ -24,4 +24,4 @@ import type { WakeWriteKeys } from '../types.js';
  *   as task spawns; the backend dedups on (creator, key) so a replayed
  *   propose/subcontract resolves to the original agreement.
  */
-export declare function createWakeWriteKeys(laneKey: string, event: unknown): WakeWriteKeys;
+export declare function createDeliveryWriteKeys(laneKey: string, event: unknown): DeliveryWriteKeys;

package/dist/runtime/{wakeWriteKeys.js → deliveryWriteKeys.js}

@@ -93,10 +93,17 @@ function sha(input) {
  *   as task spawns; the backend dedups on (creator, key) so a replayed
  *   propose/subcontract resolves to the original agreement.
  */
-export function createWakeWriteKeys(laneKey, event) {
+export function createDeliveryWriteKeys(laneKey, event) {
     const identity = eventIdentity(event);
     const wakeHash = identity === null ? null : sha(`${laneKey}\n${identity}`).slice(0, 40);
     let ordinal = 0;
+    // ZIG-1171: one content-hash builder; tags differ, the shape does not.
+    const keyed = (tag, material, opts) => {
+        if (wakeHash === null)
+            return undefined;
+        const body = `wk_${wakeHash}_${tag}_${sha(material).slice(0, 16)}`;
+        return opts?.asMessageId ? `sdk_idem_${body}` : body;
+    };
     return {
         wakeKey: wakeHash === null ? null : `wk_${wakeHash}`,
         artifactKey(content) {
@@ -110,37 +117,23 @@ export function createWakeWriteKeys(laneKey, event) {
             // agent like agent-definer. Callers without content keep the ordinal.
             if (content === undefined)
                 return `wk_${wakeHash}_a${ordinal++}`;
-            const contentHash = sha(typeof content === 'string' ? content : JSON.stringify(content) ?? '').slice(0, 16);
-            return `wk_${wakeHash}_a_${contentHash}`;
+            const material = typeof content === 'string' ? content : JSON.stringify(content) ?? '';
+            return keyed('a', material);
         },
         taskStateKey(taskId, state) {
-            if (wakeHash === null)
-                return undefined;
-            return `wk_${wakeHash}_t_${sha(`${taskId}\n${state}`).slice(0, 16)}`;
+            return keyed('t', `${taskId}\n${state}`);
         },
         messageKey(fields) {
-            if (wakeHash === null)
-                return undefined;
-            const msgHash = sha(`${fields.sessionId ?? ''}\n${fields.receiverId ?? ''}\n${fields.text}`).slice(0, 16);
-            return `sdk_idem_wk_${wakeHash}_m_${msgHash}`;
+            return keyed('m', `${fields.sessionId ?? ''}\n${fields.receiverId ?? ''}\n${fields.text}`, { asMessageId: true });
         },
         taskSpawnKey(fields) {
-            if (wakeHash === null)
-                return undefined;
-            const spawnHash = sha(`${fields.agreementId}\n${fields.description}\n${fields.assigneeId ?? ''}\n${fields.parentTaskId ?? ''}`).slice(0, 16);
-            return `wk_${wakeHash}_s_${spawnHash}`;
+            return keyed('s', `${fields.agreementId}\n${fields.description}\n${fields.assigneeId ?? ''}\n${fields.parentTaskId ?? ''}`);
         },
         agreementProposeKey(fields) {
-            if (wakeHash === null)
-                return undefined;
-            const proposeHash = sha(`${fields.proposedTo}\n${fields.providerId ?? ''}\n${fields.description}\n${fields.parentAgreementId ?? ''}`).slice(0, 16);
-            return `wk_${wakeHash}_ap_${proposeHash}`;
+            return keyed('ap', `${fields.proposedTo}\n${fields.providerId ?? ''}\n${fields.description}\n${fields.parentAgreementId ?? ''}`);
         },
         agreementSubcontractKey(fields) {
-            if (wakeHash === null)
-                return undefined;
-            const subHash = sha(`${fields.executorId}\n${fields.description}\n${fields.parentAgreementId}`).slice(0, 16);
-            return `wk_${wakeHash}_asc_${subHash}`;
+            return keyed('asc', `${fields.executorId}\n${fields.description}\n${fields.parentAgreementId}`);
         },
     };
 }

package/dist/runtime/runMechanical.d.ts

@@ -1,4 +1,4 @@
-import type { Ctx, EffectHandler, MechanicalState, Outcome, ToolResultEntry, WakeWriteKeys } from '../types.js';
+import type { Ctx, EffectHandler, MechanicalState, Outcome, ToolResultEntry, DeliveryWriteKeys } from '../types.js';
 import type { MemoryStore } from '../memory/MemoryStore.js';
 import { type RawEvent } from './buildOutcome.js';
 export interface RunMechanicalResult {
@@ -23,5 +23,5 @@ export declare function runMechanical(input: {
     memory?: MemoryStore;
     incomingEvent: RawEvent | null;
     /** This wake's replay-stable write keys (shared across every turn of the tick — see AgentMachine). */
-    wakeKeys?: WakeWriteKeys;
+    writeKeys?: DeliveryWriteKeys;
 }): Promise<RunMechanicalResult>;

package/dist/runtime/runMechanical.js

@@ -5,12 +5,12 @@ import { runtimeLog } from '../shared/runtimeLog.js';
  * Used by dumb coordinators whose only job is a fixed tool call on task-assigned.
  */
 export async function runMechanical(input) {
-    const { stateId, state, ctx, eff, memory, incomingEvent, wakeKeys } = input;
+    const { stateId, state, ctx, eff, memory, incomingEvent, writeKeys } = input;
     const sessionId = ctx.identity.sessionId;
     const runId = crypto.randomUUID();
     const effWithTrace = (effect) => {
         if (effect.kind === 'tool-call') {
-            return eff({ ...effect, runId, stateId, wakeKeys });
+            return eff({ ...effect, runId, stateId, writeKeys });
         }
         return eff(effect);
     };

package/dist/runtime/runTurn.d.ts

@@ -1,4 +1,4 @@
-import type { Action, Ctx, Outcome, ToolResultEntry, EffectHandler, WakeWriteKeys } from '../types.js';
+import type { Action, Ctx, Outcome, ToolResultEntry, EffectHandler, DeliveryWriteKeys } from '../types.js';
 import type { MemoryStore } from '../memory/MemoryStore.js';
 import { type RawEvent } from './buildOutcome.js';
 import { PromptBuilder } from './PromptBuilder.js';
@@ -33,7 +33,7 @@ interface RunTurnInput {
      */
     streamRespondActions?: boolean;
     /** This wake's replay-stable write keys (shared across every turn of the tick — see AgentMachine). */
-    wakeKeys?: WakeWriteKeys;
+    writeKeys?: DeliveryWriteKeys;
 }
 interface RunTurnResult {
     outcome: Outcome;

package/dist/runtime/runTurn.js

@@ -45,7 +45,7 @@ function isGenericFallbackTool(name, toolManager) {
  * call and (optionally) wrapping it in telemetry / dedup / retries.
  */
 export async function runTurn(input) {
-    const { stateId, statePrompt, actions, incomingEvent, ctx, eff, toolManager, promptBuilder, memory, definition, wakeKeys } = input;
+    const { stateId, statePrompt, actions, incomingEvent, ctx, eff, toolManager, promptBuilder, memory, definition, writeKeys } = input;
     // Default on (ZIG-838); ENABLE_LLM_STREAMING=false is the deployment
     // kill-switch. Any other value (unset, 'true', …) streams.
     const streamRespondActions = input.streamRespondActions ?? process.env.ENABLE_LLM_STREAMING !== 'false';
@@ -62,13 +62,13 @@ export async function runTurn(input) {
             return eff({ ...effect, runId, stateId });
         }
         if (effect.kind === 'tool-call') {
-            return eff({ ...effect, runId, stateId, wakeKeys });
+            return eff({ ...effect, runId, stateId, writeKeys });
         }
         if (effect.kind === 'send-message' && !effect.messageId) {
             const send = effect;
             return eff({
                 ...effect,
-                messageId: wakeKeys?.messageKey({
+                messageId: writeKeys?.messageKey({
                     text: send.text,
                     sessionId: send.sessionId,
                     receiverId: send.receiverId,
@@ -84,7 +84,7 @@ export async function runTurn(input) {
         if (s.length === 0)
             return;
         try {
-            await eff({ kind: 'record-event', sessionId, entry: { kind: 'thought', text: s }, idempotencyKey: wakeKeys?.artifactKey({ kind: 'thought', text: s }) });
+            await eff({ kind: 'record-event', sessionId, entry: { kind: 'thought', text: s }, idempotencyKey: writeKeys?.artifactKey({ kind: 'thought', text: s }) });
         }
         catch (err) {
             runtimeLog.warn('runTurn', `record-event:thought failed: ${err.message}`);
@@ -380,7 +380,7 @@ export async function runTurn(input) {
                     }
                     const safeText = truncateMsg(replyText);
                     persistMessageId =
-                        wakeKeys?.messageKey({
+                        writeKeys?.messageKey({
                             text: safeText,
                             sessionId,
                             receiverId: decision.receiverId,

package/dist/runtime/taskIntake.js

@@ -49,9 +49,10 @@ export function buildTaskIntakeState(initial) {
                 // Function form so a failed task_set_result surfaces as an error outcome
                 // (→ dflt error transition) instead of a phantom task-closed.
                 produces: (result) => {
+                    // `state` only — ZIG-1057 cut `status` from the wire (ZIG-1128).
                     const r = result;
-                    const status = r?.task?.state ?? r?.state ?? r?.status;
-                    return status === 'completed' || status === 'failed' ? 'task-closed' : 'error';
+                    const state = r?.task?.state ?? r?.state;
+                    return state === 'completed' || state === 'failed' ? 'task-closed' : 'error';
                 },
                 terminatesLoop: true,
             },
@@ -63,9 +64,10 @@ export function buildTaskIntakeState(initial) {
                 },
                 tool: 'task_set_result',
                 produces: (result) => {
+                    // `state` only — ZIG-1057 cut `status` from the wire (ZIG-1128).
                     const r = result;
-                    const status = r?.task?.state ?? r?.state ?? r?.status;
-                    return status === 'completed' || status === 'failed' ? 'task-closed' : 'error';
+                    const state = r?.task?.state ?? r?.state;
+                    return state === 'completed' || state === 'failed' ? 'task-closed' : 'error';
                 },
                 terminatesLoop: true,
             },

package/dist/server/ConnectionPool.d.ts

@@ -1,17 +1,3 @@
-/**
- * ConnectionPool — multi-agent fleet manager.
- *
- * Holds N `AgentHostOptions` configs but only constructs/wakes an
- * `AgentHost` (one WS connection) when needed. Idle hosts are slept after
- * `idleTimeoutMs`. At most `maxActive` hosts are connected at a time; LRU
- * eviction drops the oldest if the cap is reached. With `startControl`, a
- * separate "launcher" socket receives backend-driven wake hints so the pool
- * spins up the right host on demand.
- *
- * This is how a single Node process serves a fleet of agents without
- * holding 1000 open sockets — typical config: 1000+ registered, ~50 live.
- */
-import { type InboxOperatorAgentEntry, type StartAgentOptions } from '@ziggs-ai/api-client';
 import { AgentHost, type AgentHostOptions } from '../AgentHost.js';
 interface ConnectionManagerMeta {
     domain?: string;
@@ -24,44 +10,27 @@ interface QueryFilter {
     expertise?: string[];
     tags?: string[];
 }
-export interface PoolOptions {
-    maxActive?: number;
-    idleTimeoutMs?: number;
-    /**
-     * Gate on the operator-poll lazy start (ZIG-910): return false to leave an
-     * actionable agent's host down this pass. Explicit startAgent()s are not gated.
-     */
-    shouldLazyStart?: (entry: InboxOperatorAgentEntry) => boolean;
-}
 export interface SendToOptions {
     timeoutMs?: number;
 }
-export interface ControlOptions {
-    wsUrl?: string;
-    operatorKey?: string;
-}
 export declare class ConnectionPool {
     private readonly manager;
     private readonly configs;
     private readonly responseListeners;
-    constructor({ maxActive, idleTimeoutMs, shouldLazyStart }?: PoolOptions);
     /**
-     * Register N agent configs. Each will be lazily started (a fresh
-     * `AgentHost` constructed + connected) the first time it's referenced.
+     * Register N agent configs. Nothing connects until `connectAll()`; a config
+     * registered and never connected is an agent nobody hosts, which is the
+     * failure this pool exists to make impossible.
      */
     register(configs: AgentHostOptions[], metaArr?: ConnectionManagerMeta[]): void;
-    /**
-     * Start (or return) an agent's host. `pinned` keeps it up for the process's
-     * lifetime — no idle sweep, last to be evicted; use it for hosts the operator
-     * named rather than ones work happened to reach.
-     */
-    startAgent(agentId: string, opts?: StartAgentOptions): Promise<AgentHost>;
-    /** Agents kept up explicitly (launcher `preStart`), not by demand. */
-    listPinned(): string[];
-    sleep(agentId: string): Promise<void>;
+    /** Connect every registered agent. Reports the ones that could not come up. */
+    connectAll(): Promise<void>;
+    /** The host for one agent, connecting it if it somehow is not up yet. */
+    startAgent(agentId: string): Promise<AgentHost>;
+    stopAgent(agentId: string): Promise<void>;
     disconnectAll(): Promise<void>;
     /**
-     * Start the named agent, deliver a message, and wait for its first outbound
+     * Deliver a message to the named agent and wait for its first outbound
      * `send-message` effect — i.e. the agent's reply. Returns the reply text.
      *
      * The effectTap injected in `register` drains a per-agent listener queue;
@@ -70,28 +39,17 @@ export declare class ConnectionPool {
      */
     requestFrom(agentId: string, text: string, metadata?: Record<string, unknown>, { timeoutMs }?: SendToOptions): Promise<string>;
     /**
-     * Start the named agent and deliver one wire frame to it. Returns once the
-     * host has finished processing.
+     * Deliver one wire frame to the named agent. Returns once the host has
+     * finished processing.
      *
      * Note: does not return the agent's response. For request/response
      * semantics use `requestFrom`.
      */
     sendTo(agentId: string, text: string, metadata?: Record<string, unknown>, { timeoutMs }?: SendToOptions): Promise<null>;
-    /**
-     * Start the fleet lazy-start loop (delivery law, phase 4): the manager
-     * long-polls `GET /inbox/operator` with this operator key and starts the host
-     * for any owned agent whose slice has actionable content. Each started host
-     * then consumes via its own per-agent inbox loop — this is ordinary lazy
-     * process management, not a pushed signal. `wsUrl` is accepted for
-     * back-compat but unused (the poll is HTTP).
-     */
-    startControl({ operatorKey }?: ControlOptions): void;
-    stopControl(): void;
     query(filter: QueryFilter): string[];
     list(): string[];
     listActive(): string[];
     get size(): number;
-    get maxActive(): number;
     getMeta(id: string): ConnectionManagerMeta | undefined;
 }
 export {};

package/dist/server/ConnectionPool.js

@@ -1,30 +1,30 @@
 /**
- * ConnectionPool — multi-agent fleet manager.
+ * ConnectionPool — the agents this launcher process hosts.
  *
- * Holds N `AgentHostOptions` configs but only constructs/wakes an
- * `AgentHost` (one WS connection) when needed. Idle hosts are slept after
- * `idleTimeoutMs`. At most `maxActive` hosts are connected at a time; LRU
- * eviction drops the oldest if the cap is reached. With `startControl`, a
- * separate "launcher" socket receives backend-driven wake hints so the pool
- * spins up the right host on demand.
+ * Holds N `AgentHostOptions` configs and connects every one of them at boot
+ * (ZIG-1108). Each host long-polls its own inbox for the life of the process —
+ * there is no agent socket. There is no subset, no cap and no lifecycle policy:
+ * a write releasing that poll is the only signal anything needs.
  *
- * This is how a single Node process serves a fleet of agents without
- * holding 1000 open sockets — typical config: 1000+ registered, ~50 live.
+ * What this replaced: a launcher that registered 1000+ configs and connected
+ * ~50, deciding which by long-polling `GET /inbox/operator` for a fleet-wide
+ * sweep, sleeping quiet hosts on an idle timer, evicting past `maxActive` by
+ * LRU, and exempting operator-named agents with a `pinned` flag. Whether an
+ * agent was alive came down to a Terraform string, and nothing noticed when the
+ * answer was "none of them".
  */
 import { ConnectionManager } from '@ziggs-ai/api-client';
 import { AgentHost } from '../AgentHost.js';
 import { runtimeLog } from '../shared/runtimeLog.js';
 export class ConnectionPool {
-    manager;
+    manager = new ConnectionManager();
     configs = new Map();
     // Listeners enqueued by requestFrom — drained on outbound send-message effects.
     responseListeners = new Map();
-    constructor({ maxActive = 50, idleTimeoutMs = 60_000, shouldLazyStart } = {}) {
-        this.manager = new ConnectionManager({ maxActive, idleTimeoutMs, shouldLazyStart });
-    }
     /**
-     * Register N agent configs. Each will be lazily started (a fresh
-     * `AgentHost` constructed + connected) the first time it's referenced.
+     * Register N agent configs. Nothing connects until `connectAll()`; a config
+     * registered and never connected is an agent nobody hosts, which is the
+     * failure this pool exists to make impossible.
      */
     register(configs, metaArr = []) {
         const metaByAgentId = new Map();
@@ -46,14 +46,7 @@ export class ConnectionPool {
                 const pool = this;
                 const host = new AgentHost({
                     ...cfg,
-                    // Inbox activity and in-flight effects both reset the idle timer:
-                    // previously only pool.sendTo() touched it, so a host woken by its
-                    // own inbox loop was torn down every idleTimeoutMs (default 60s)
-                    // regardless of the work it was doing — losing lane ctx, Claude
-                    // session ids, and armed timers each time.
-                    onActivity: () => pool.manager.touch(agentId),
                     effectTap(effect, response) {
-                        pool.manager.touch(agentId);
                         if (effect.kind === 'send-message') {
                             const listeners = pool.responseListeners.get(agentId);
                             if (listeners?.length)
@@ -63,34 +56,30 @@ export class ConnectionPool {
                     },
                 });
                 await host.connectAsync();
-                runtimeLog.debug('ConnectionPool', `started "${agentId}" (active: ${this.manager.listActive().length}/${this.maxActive})`);
+                runtimeLog.debug('ConnectionPool', `connected "${agentId}"`);
                 return host;
             }, async (host) => {
                 host.disconnect();
-                runtimeLog.debug('ConnectionPool', `slept "${agentId}"`);
+                runtimeLog.debug('ConnectionPool', `disconnected "${agentId}"`);
             }, metaByAgentId.get(agentId));
         }
     }
-    /**
-     * Start (or return) an agent's host. `pinned` keeps it up for the process's
-     * lifetime — no idle sweep, last to be evicted; use it for hosts the operator
-     * named rather than ones work happened to reach.
-     */
-    async startAgent(agentId, opts = {}) {
-        return await this.manager.startAgent(agentId, opts);
+    /** Connect every registered agent. Reports the ones that could not come up. */
+    async connectAll() {
+        return this.manager.connectAll();
     }
-    /** Agents kept up explicitly (launcher `preStart`), not by demand. */
-    listPinned() {
-        return this.manager.listPinned();
+    /** The host for one agent, connecting it if it somehow is not up yet. */
+    async startAgent(agentId) {
+        return await this.manager.startAgent(agentId);
     }
-    async sleep(agentId) {
-        return this.manager.sleep(agentId);
+    async stopAgent(agentId) {
+        return this.manager.stopAgent(agentId);
     }
     async disconnectAll() {
-        return this.manager.sleepAll();
+        return this.manager.stopAll();
     }
     /**
-     * Start the named agent, deliver a message, and wait for its first outbound
+     * Deliver a message to the named agent and wait for its first outbound
      * `send-message` effect — i.e. the agent's reply. Returns the reply text.
      *
      * The effectTap injected in `register` drains a per-agent listener queue;
@@ -139,8 +128,8 @@ export class ConnectionPool {
         });
     }
     /**
-     * Start the named agent and deliver one wire frame to it. Returns once the
-     * host has finished processing.
+     * Deliver one wire frame to the named agent. Returns once the host has
+     * finished processing.
      *
      * Note: does not return the agent's response. For request/response
      * semantics use `requestFrom`.
@@ -149,31 +138,11 @@ export class ConnectionPool {
         const host = await this.startAgent(agentId);
         const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`sendTo timeout for "${agentId}" after ${timeoutMs}ms`)), timeoutMs));
         await Promise.race([host.handleMessage(text, metadata), timeoutPromise]);
-        this.manager.touch(agentId);
         return null;
     }
-    /**
-     * Start the fleet lazy-start loop (delivery law, phase 4): the manager
-     * long-polls `GET /inbox/operator` with this operator key and starts the host
-     * for any owned agent whose slice has actionable content. Each started host
-     * then consumes via its own per-agent inbox loop — this is ordinary lazy
-     * process management, not a pushed signal. `wsUrl` is accepted for
-     * back-compat but unused (the poll is HTTP).
-     */
-    startControl({ operatorKey } = {}) {
-        if (!operatorKey) {
-            runtimeLog.warn('ConnectionPool', 'startControl: operatorKey is required — skipping');
-            return;
-        }
-        this.manager.start(operatorKey);
-    }
-    stopControl() {
-        void this.manager.stop();
-    }
     query(filter) { return this.manager.query(filter); }
     list() { return this.manager.list(); }
     listActive() { return this.manager.listActive(); }
     get size() { return this.manager.size; }
-    get maxActive() { return this.manager.maxActive; }
     getMeta(id) { return this.manager.getMeta(id); }
 }

package/dist/server/EventQueue.d.ts

@@ -7,6 +7,12 @@ export interface EventQueueOptions {
  * batch dispatch. The runtime sees at most one in-flight processEvent call
  * per laneKey at a time; multiple events arriving while busy are merged
  * into a single { type: 'batch', events: [...] } frame on the next pass.
+ *
+ * ZIG-1191: `enqueue` REJECTS when the dispatch failed. It used to log the error
+ * and resolve, which made every caller — including the inbox loop, whose next
+ * statement is the ack — unable to tell a handled event from a lost one. A
+ * caller that has nothing to do with a failure should say so with `.catch()`;
+ * the one holding a delivery must not have that decision made for it.
  */
 export declare class EventQueue {
     private _processEvent;