@ziggs-ai/agent-sdk 0.9.0 → 0.10.1

package/dist/runtime/PromptBuilder.js

@@ -1,6 +1,6 @@
 import { HistoryFormatter, AgreementFormatter } from '../formatters/index.js';
 import { validateContext } from '../cognition/validateContext.js';
-import { isBroadcastTarget } from '@ziggs-ai/api-client';
+import { isBroadcastTarget, isOpaquePresentationRef } from '@ziggs-ai/api-client';
 import { LANE_BOOK_KEY, allCollectedResults, allDelegatedAgreementIds, allPendingSubtasks, } from './taskBookkeeping.js';
 /** Rough chars-per-token ratio for budgeting (English/JSON averages ~4). */
 const CHARS_PER_TOKEN = 4;
@@ -298,16 +298,20 @@ ${this._renderDecisionSchemaFromActions(actions, senderMeta, ctxObj, omitMessage
                 const pid = parties[field];
                 if (!pid || pid === myAgentId)
                     continue;
+                // Opaque presentation refs are not principal slots (ZIG-1137).
+                if (isOpaquePresentationRef(pid))
+                    continue;
                 if (!agreementParties.has(pid))
                     agreementParties.set(pid, []);
                 agreementParties.get(pid).push({ agreementId: agId ?? '', role });
             }
         }
-        // Chat and transfer surfaces default to the full directory: every chat
-        // counterparty can receive a chat message; every id can receive a transfer
-        // by their principal id until per-wallet routing is wired through.
+        // Chat keeps the full directory — including opaque `rpb_*` / `psn_*` refs
+        // the persona layer may surface. Echo those as chat_send receiverId; the
+        // backend resolves them in-room. Transfer (and any account-id action) must
+        // never list opaque refs — lookup / wake / pay against them 400s (ZIG-1137).
         const chatIds = new Set([...userIds, ...agentIds]);
-        const transferIds = new Set([...userIds, ...agentIds]);
+        const transferIds = new Set([...userIds, ...agentIds].filter((id) => !isOpaquePresentationRef(id)));
         const lines = ['<recipients>'];
         lines.push('<users>');
         if (userIds.size === 0)

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/runTurn.js

@@ -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() });
+            await eff({ kind: 'record-event', sessionId, entry: { kind: 'thought', text: s }, idempotencyKey: wakeKeys?.artifactKey({ kind: 'thought', text: s }) });
         }
         catch (err) {
             runtimeLog.warn('runTurn', `record-event:thought failed: ${err.message}`);

package/dist/runtime/taskBookkeeping.d.ts

@@ -7,8 +7,6 @@ import type { Ctx, TaskBookkeeping } from '../types.js';
 export declare const LANE_BOOK_KEY = "__lane__";
 export declare function emptyTaskBook(agreementId?: string | null): TaskBookkeeping;
 export declare function ensureTaskBook(ctx: Ctx, taskId: string, agreementId?: string | null): TaskBookkeeping;
-/** Focus task's book, or null when nothing is focused / missing. */
-export declare function focusTaskBook(ctx: Ctx): TaskBookkeeping | null;
 /**
  * Book that receives task-delegated / subtask-finished when we know the parent
  * engagement: focus task if assigned, else the coordinator lane bucket.

package/dist/runtime/taskBookkeeping.js

@@ -25,12 +25,6 @@ export function ensureTaskBook(ctx, taskId, agreementId) {
     }
     return book;
 }
-/** Focus task's book, or null when nothing is focused / missing. */
-export function focusTaskBook(ctx) {
-    if (!ctx.activeTaskId)
-        return null;
-    return ctx.tasks?.[ctx.activeTaskId] ?? null;
-}
 /**
  * Book that receives task-delegated / subtask-finished when we know the parent
  * engagement: focus task if assigned, else the coordinator lane bucket.

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/runtime/wakeWriteKeys.js

@@ -97,41 +97,43 @@ export function createWakeWriteKeys(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() {
+        artifactKey(content) {
             if (wakeHash === null)
                 return undefined;
-            return `wk_${wakeHash}_a${ordinal++}`;
+            // Content-derived for the same reason messageKey is (ZIG-1045): the
+            // ordinal restarts at a0 on every wake, so a redelivered event whose
+            // re-think writes different artifacts collided with the first wake's
+            // and the backend discarded the new write. Harmless for a breadcrumb,
+            // not for a result artifact — which is the whole deliverable of an
+            // agent like agent-definer. Callers without content keep the ordinal.
+            if (content === undefined)
+                return `wk_${wakeHash}_a${ordinal++}`;
+            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/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[];
+    /** 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>;
     sleep(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,25 +56,21 @@ 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);
@@ -90,7 +79,7 @@ export class ConnectionPool {
         return this.manager.sleepAll();
     }
     /**
-     * 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;

package/dist/server/EventQueue.js

@@ -4,6 +4,12 @@ import { runtimeLog } from '../shared/runtimeLog.js';
  * 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 class EventQueue {
     _processEvent;
@@ -28,9 +34,12 @@ export class EventQueue {
             state = { events: [], processing: false };
             this._state.set(laneKey, state);
         }
-        return new Promise((resolve) => {
+        return new Promise((resolve, reject) => {
             this._metrics.enqueued += 1;
-            state.events.push({ event, resolve });
+            state.events.push({
+                event,
+                settle: (err) => (err === undefined ? resolve() : reject(err)),
+            });
             this._trimQueueIfNeeded(state, laneKey);
             this._processIfNeeded(laneKey);
         });
@@ -49,21 +58,25 @@ export class EventQueue {
         while (state.events.length > 0) {
             const batch = state.events.splice(0, state.events.length);
             const events = batch.map(e => e.event);
-            const resolvers = batch.map(e => e.resolve);
+            const settlers = batch.map(e => e.settle);
             const coalesced = events.length === 1
                 ? events[0]
                 : { type: 'batch', events };
+            // Coalescing makes the batch the unit of success: the lane ran one tick
+            // for all of it, so a failure belongs to every event that was merged in.
+            let failure;
             try {
                 await this._processEvent(coalesced, laneKey);
             }
             catch (error) {
+                failure = error ?? new Error('processEvent failed');
                 this._metrics.errors += 1;
                 runtimeLog.error('EventQueue', `processEvent error for laneKey=${laneKey}: ${error?.message || error}`);
             }
             this._metrics.processedBatches += 1;
             this._metrics.processedEvents += events.length;
-            for (const r of resolvers)
-                r();
+            for (const settle of settlers)
+                settle(failure);
         }
         state.processing = false;
     }
@@ -71,7 +84,9 @@ export class EventQueue {
         while (state.events.length > this._maxQueueLengthPerLane) {
             const dropped = state.events.shift();
             this._metrics.dropped += 1;
-            dropped?.resolve();
+            // A dropped event was never handled, so its caller hears about it — the
+            // inbox loop holds the ack instead of acking work that fell off the queue.
+            dropped?.settle(new Error(`EventQueue dropped an event on laneKey=${laneKey} (queue over ${this._maxQueueLengthPerLane})`));
             runtimeLog.warn('EventQueue', `dropped oldest event laneKey=${laneKey} max=${this._maxQueueLengthPerLane}`);
         }
     }

package/dist/server/SeenMessages.d.ts

@@ -10,4 +10,11 @@ export declare class SeenMessages {
     constructor(maxSize?: number);
     has(messageId: string | null | undefined): boolean;
     mark(messageId: string | null | undefined): void;
+    /**
+     * Forget a mark, so the next delivery of the same id is processed rather than
+     * skipped. ZIG-1191: marking happens BEFORE the work, to hold the door against
+     * a concurrent duplicate — which means a failure has to take the mark back, or
+     * the redelivery that a held ack buys is silently dropped as a duplicate.
+     */
+    unmark(messageId: string | null | undefined): void;
 }

package/dist/server/SeenMessages.js

@@ -28,4 +28,19 @@ export class SeenMessages {
                 this.seen.delete(oldest);
         }
     }
+    /**
+     * Forget a mark, so the next delivery of the same id is processed rather than
+     * skipped. ZIG-1191: marking happens BEFORE the work, to hold the door against
+     * a concurrent duplicate — which means a failure has to take the mark back, or
+     * the redelivery that a held ack buys is silently dropped as a duplicate.
+     */
+    unmark(messageId) {
+        if (!messageId || typeof messageId !== 'string')
+            return;
+        if (!this.seen.delete(messageId))
+            return;
+        const at = this.order.indexOf(messageId);
+        if (at !== -1)
+            this.order.splice(at, 1);
+    }
 }