@ziggs-ai/agent-sdk 0.20.0 → 0.21.0

package/dist/mcp/createMcpAgent.d.ts

@@ -192,7 +192,7 @@ export declare function trimDescription(desc: string | undefined): string | unde
  *   await agent.connectAsync();
  *
  *   process.on('SIGTERM', async () => {
- *     agent.disconnect();
+ *     await agent.disconnect();
  *     await agent.drain();
  *     await closeMcp();
  *   });

package/dist/mcp/createMcpAgent.js

@@ -333,7 +333,7 @@ function capTools(tools, agentId, maxTools, extraToolCount, allowedTools) {
  *   await agent.connectAsync();
  *
  *   process.on('SIGTERM', async () => {
- *     agent.disconnect();
+ *     await agent.disconnect();
  *     await agent.drain();
  *     await closeMcp();
  *   });

package/dist/memory/MemoryStore.d.ts

@@ -56,15 +56,29 @@ export declare class FileMemoryStore implements MemoryStore {
     delete(key: string): Promise<void>;
 }
 /**
- * Section a wake may read and write. A hire (pinned agreement, or an
- * `agrn-` lane) gets its own prefix. A wake with no hire shares the
- * agent's own section — same as before for in-process tools that key by
- * chat themselves.
+ * Section a wake may read and write.
+ *
+ * Pick from the hire this wake is acting under — the same fact the
+ * server uses for acting-for: a pinned agreement, the delivery / event
+ * hire, or an `agrn-` lane. A chat-room wake with exactly one hire
+ * behind it lands in that hire's section. Zero hires, or more than one
+ * customer present, share the agent's own section — the "operator only"
+ * answer in memory form. Never pick from the chat id alone.
  */
 export declare function memorySectionForWake(input: {
     sessionId?: string | null;
     activeAgreementId?: string | null;
+    /** Hire ids already on this wake (delivery / event / acting-for). */
+    wakeAgreementIds?: readonly (string | null | undefined)[];
 }): string;
+/** Distinct non-empty hire ids, first-seen order. */
+export declare function uniqueHireIds(raw: readonly (string | null | undefined)[]): string[];
+/**
+ * Hire ids the waking event already named. A chat-room message that
+ * carries the delivery's `agreementId` is how two customer rooms
+ * partition without a pinned ctx.
+ */
+export declare function hireIdsFromEvent(event: unknown): string[];
 /**
  * Present a store as if it only contained one section. Agent keys stay
  * unchanged; get/put/list/delete all go through `section:`.

package/dist/memory/MemoryStore.js

@@ -78,22 +78,62 @@ export class FileMemoryStore {
     }
 }
 /**
- * Section a wake may read and write. A hire (pinned agreement, or an
- * `agrn-` lane) gets its own prefix. A wake with no hire shares the
- * agent's own section — same as before for in-process tools that key by
- * chat themselves.
+ * Section a wake may read and write.
+ *
+ * Pick from the hire this wake is acting under — the same fact the
+ * server uses for acting-for: a pinned agreement, the delivery / event
+ * hire, or an `agrn-` lane. A chat-room wake with exactly one hire
+ * behind it lands in that hire's section. Zero hires, or more than one
+ * customer present, share the agent's own section — the "operator only"
+ * answer in memory form. Never pick from the chat id alone.
  */
 export function memorySectionForWake(input) {
-    const pinned = typeof input.activeAgreementId === 'string'
-        ? input.activeAgreementId.trim()
-        : '';
-    if (pinned)
-        return `hire:${pinned}`;
-    const fromLane = agreementIdFromAgrnSession(input.sessionId);
-    if (fromLane)
-        return `hire:${fromLane}`;
+    const ids = uniqueHireIds([
+        input.activeAgreementId,
+        ...(input.wakeAgreementIds ?? []),
+        agreementIdFromAgrnSession(input.sessionId),
+    ]);
+    if (ids.length === 1)
+        return `hire:${ids[0]}`;
     return 'agent';
 }
+/** Distinct non-empty hire ids, first-seen order. */
+export function uniqueHireIds(raw) {
+    const out = [];
+    const seen = new Set();
+    for (const value of raw) {
+        const id = typeof value === 'string' ? value.trim() : '';
+        if (!id || seen.has(id))
+            continue;
+        seen.add(id);
+        out.push(id);
+    }
+    return out;
+}
+/**
+ * Hire ids the waking event already named. A chat-room message that
+ * carries the delivery's `agreementId` is how two customer rooms
+ * partition without a pinned ctx.
+ */
+export function hireIdsFromEvent(event) {
+    if (!event || typeof event !== 'object')
+        return [];
+    const rec = event;
+    const resource = rec.resource && typeof rec.resource === 'object'
+        ? rec.resource
+        : {};
+    const result = rec.result && typeof rec.result === 'object'
+        ? rec.result
+        : {};
+    return uniqueHireIds([
+        typeof rec.agreementId === 'string' ? rec.agreementId : null,
+        typeof resource.agreementId === 'string' ? resource.agreementId : null,
+        typeof result.agreementId === 'string' ? result.agreementId : null,
+        rec.kind === 'agreement' && typeof rec.resourceId === 'string'
+            ? rec.resourceId
+            : null,
+    ]);
+}
 function agreementIdFromAgrnSession(sessionId) {
     return agreementIdFromLane(sessionId)?.trim() || null;
 }

package/dist/platform/ConnectionPool.d.ts

@@ -19,12 +19,17 @@ export declare class ConnectionPool {
     private readonly hosts;
     private readonly responseListeners;
     /**
-     * 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 N agent configs. Nothing connects until `connectAll()`. A config
+     * that cannot start is reported and left down; the others still host. Only
+     * a launch where nobody came up is refused.
      */
     register(configs: AgentOptions[], metaArr?: ConnectionManagerMeta[]): void;
-    /** Connect every registered agent. Reports the ones that could not come up. */
+    /**
+     * Connect every registered agent. One host that cannot come up is reported
+     * and does not take the rest down — a fleet where 28 of 29 are live is not
+     * a launch worth aborting. Zero started is: the process has nothing to
+     * host and must restart.
+     */
     connectAll(): Promise<void>;
     /** The host for one agent, connecting it if it somehow is not up yet. */
     startAgent(agentId: string): Promise<Agent>;

package/dist/platform/ConnectionPool.js

@@ -26,9 +26,9 @@ export class ConnectionPool {
     // Listeners enqueued by requestFrom — drained on outbound send-message effects.
     responseListeners = new Map();
     /**
-     * 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 N agent configs. Nothing connects until `connectAll()`. A config
+     * that cannot start is reported and left down; the others still host. Only
+     * a launch where nobody came up is refused.
      */
     register(configs, metaArr = []) {
         const metaByAgentId = new Map();
@@ -64,18 +64,28 @@ export class ConnectionPool {
                 runtimeLog.debug('ConnectionPool', `connected "${agentId}"`);
                 return host;
             }, async (host) => {
-                host.disconnect();
+                await host.disconnect();
                 this.hosts.delete(agentId);
                 runtimeLog.debug('ConnectionPool', `disconnected "${agentId}"`);
             }, metaByAgentId.get(agentId));
         }
     }
-    /** Connect every registered agent. Reports the ones that could not come up. */
+    /**
+     * Connect every registered agent. One host that cannot come up is reported
+     * and does not take the rest down — a fleet where 28 of 29 are live is not
+     * a launch worth aborting. Zero started is: the process has nothing to
+     * host and must restart.
+     */
     async connectAll() {
         await this.manager.connectAll();
         const connected = this.listActive().length;
+        if (this.size === 0)
+            return;
+        if (connected === 0) {
+            throw new Error(`0/${this.size} agents started; process must restart`);
+        }
         if (connected !== this.size) {
-            throw new Error(`Only ${connected}/${this.size} agents started; process must restart`);
+            runtimeLog.warn('ConnectionPool', `Only ${connected}/${this.size} agents started — hosting the ones that came up. One host must not take the rest down.`);
         }
     }
     /** The host for one agent, connecting it if it somehow is not up yet. */

package/dist/platform/StateTimers.d.ts

@@ -1,3 +1,4 @@
+import type { WorkScope } from '../runtime/wakeEffects.js';
 export interface StateTimeoutEvent {
     type: 'state-timeout';
     state: string;
@@ -13,7 +14,7 @@ export interface StateTimeoutEvent {
  * check-back is none of that: it belongs to the agent's own plan, not to a
  * state's declared timeout, and the Claude brain has no states at all.
  */
-export interface WakeAtEvent {
+export interface WakeAtEvent extends WorkScope {
     type: 'wake-at';
     /** What the agent said it was waiting for. Free text, for the brain to read. */
     reason: string | null;
@@ -35,7 +36,7 @@ export declare const MAX_WAKE_DELAY_MS: number;
  * (caller-provided enqueue → EventQueue), so it serializes behind any real
  * event and can never race one. Epochs make stale frames identifiable: a
  * queued timeout frame whose epoch is not the lane's currently-armed epoch was
- * superseded (a tick ran after it fired) and must be dropped.
+ * cancelled or replaced and must be dropped.
  *
  * In-memory only: process restart loses all timers; each lane re-arms on its
  * next real event (sessionStore persists { ctx, state } but not timers).
@@ -66,13 +67,12 @@ export declare class StateTimers {
      * the agent changing its mind, which is allowed and is why this replaces
      * rather than adds.
      *
-     * In memory only. A restart loses it and the lane re-arms on its next real
-     * event, so a lost check-back is late rather than gone — persistence is
-     * listed Later on the ticket. Returns what actually got armed so the caller
+     * In memory only. A restart loses it; recovery requires the agent to re-arm
+     * on its next real event. Returns what actually got armed so the caller
      * can tell the agent, since "I will wake at X" is a promise the agent will
      * otherwise make on its own.
      */
-    armWakeAt(laneKey: string, at: Date | number, reason?: string | null): {
+    armWakeAt(laneKey: string, at: Date | number, reason?: string | null, scope?: WorkScope): {
         firesAt: number;
         delayMs: number;
     };
@@ -82,6 +82,12 @@ export declare class StateTimers {
         firesAt: number;
         reason: string | null;
     } | null;
+    /**
+     * Consume the timer for a frame that survived stripStale. Liveness tracks
+     * inactivity, so any event resets it. An explicit wake is an appointment:
+     * unrelated traffic must leave it armed, even after it fired and queued.
+     */
+    consumeForEvent(event: unknown, laneKey: string): void;
     clear(laneKey: string): void;
     clearAll(): void;
     /**

package/dist/platform/StateTimers.js

@@ -12,7 +12,7 @@ export const MAX_WAKE_DELAY_MS = 2 ** 31 - 1;
  * (caller-provided enqueue → EventQueue), so it serializes behind any real
  * event and can never race one. Epochs make stale frames identifiable: a
  * queued timeout frame whose epoch is not the lane's currently-armed epoch was
- * superseded (a tick ran after it fired) and must be dropped.
+ * cancelled or replaced and must be dropped.
  *
  * In-memory only: process restart loses all timers; each lane re-arms on its
  * next real event (sessionStore persists { ctx, state } but not timers).
@@ -68,17 +68,17 @@ export class StateTimers {
      * the agent changing its mind, which is allowed and is why this replaces
      * rather than adds.
      *
-     * In memory only. A restart loses it and the lane re-arms on its next real
-     * event, so a lost check-back is late rather than gone — persistence is
-     * listed Later on the ticket. Returns what actually got armed so the caller
+     * In memory only. A restart loses it; recovery requires the agent to re-arm
+     * on its next real event. Returns what actually got armed so the caller
      * can tell the agent, since "I will wake at X" is a promise the agent will
      * otherwise make on its own.
      */
-    armWakeAt(laneKey, at, reason = null) {
+    armWakeAt(laneKey, at, reason = null, scope) {
         const firesAtRaw = at instanceof Date ? at.getTime() : Number(at);
         if (!Number.isFinite(firesAtRaw)) {
             throw new Error('StateTimers.armWakeAt: `at` must be a Date or epoch ms');
         }
+        const wakeScope = { ...scope };
         const now = Date.now();
         // A wake already due fires on the next turn of the event loop rather than
         // being refused: "wake me at 09:00" arriving at 09:00:01 means now, and an
@@ -92,7 +92,7 @@ export class StateTimers {
         const epoch = ++this._epoch;
         const handle = setTimeout(() => {
             runtimeLog.debug('StateTimers', `wake-at fired laneKey=${laneKey} reason=${reason ?? 'none'} epoch=${epoch}`);
-            this._enqueue({ type: 'wake-at', reason, scheduledFor: firesAtRaw, epoch }, laneKey);
+            this._enqueue({ type: 'wake-at', reason, scheduledFor: firesAtRaw, epoch, ...wakeScope }, laneKey);
         }, delayMs);
         handle.unref?.();
         this._timers.set(laneKey, {
@@ -112,6 +112,26 @@ export class StateTimers {
         const t = this._timers.get(laneKey);
         return t ? { kind: t.kind, firesAt: t.firesAt, reason: t.reason } : null;
     }
+    /**
+     * Consume the timer for a frame that survived stripStale. Liveness tracks
+     * inactivity, so any event resets it. An explicit wake is an appointment:
+     * unrelated traffic must leave it armed, even after it fired and queued.
+     */
+    consumeForEvent(event, laneKey) {
+        const pending = this._timers.get(laneKey);
+        if (!pending)
+            return;
+        const frame = event;
+        const events = frame?.type === 'batch' && Array.isArray(frame.events)
+            ? frame.events
+            : [event];
+        const consumesWake = events.some((entry) => {
+            const e = entry;
+            return e?.type === 'wake-at' && e.epoch === pending.epoch;
+        });
+        if (pending.kind === 'liveness' || consumesWake)
+            this.clear(laneKey);
+    }
     clear(laneKey) {
         const t = this._timers.get(laneKey);
         if (!t)

package/dist/platform/ZiggsEffectHandler.js

@@ -35,7 +35,11 @@ async function buildSnapshot(deps, chatId, agentId, opts = {}) {
     catch (err) {
         // Defensive: server normally signals a dead chat as 200 + chatMissing, but
         // a raw 404 degrades the same way so message wakes still skip it.
-        if (err?.status === 404) {
+        const status = err?.status;
+        // 403 = exists but this agent has no grant. Same as deleted:
+        // no world to act in. Leaving it as an empty snapshot used to run a
+        // full turn against refusals.
+        if (status === 404 || status === 403) {
             return emptySnapshot(agentId, true);
         }
         runtimeLog.warn('ZiggsEffectHandler', `snapshot fetch failed: ${err?.message ?? err}`);

package/dist/platform/inboxLoop.d.ts

@@ -1,4 +1,4 @@
-import { type InboxChatNews, type InboxRequestRef, type InboxTaskRef, type Creds } from '@ziggs-ai/api-client';
+import { type InboxChatNews, type InboxDeliveryRef, type InboxRequestRef, type InboxTaskRef, type Creds } from '@ziggs-ai/api-client';
 import { SeenMessages } from './SeenMessages.js';
 /**
  * Per-agent inbox long-poll loop (delivery law, phase 4). This is the ONLY way
@@ -60,12 +60,11 @@ export interface InboxPassResult {
  */
 export declare function chatsInWakeOrder(chats: InboxChatNews[]): InboxChatNews[];
 /**
- * Store publish waits on a chat reply, not inbox ack. The ordinary pass can
- * already be inside leftover mail when that room appears, so a side read
- * answers `probe_*` chats without waiting for the current pass to finish.
- * It never acks — the main pass still owns the watermark.
+ * The one hire a chat's assigned deliveries name, or null when the room
+ * has none or more than one. Memory (and acting-for) treat "several
+ * customers in one room" as the shared section.
  */
-export declare function answerPublishProbes(deps: InboxLoopDeps): Promise<number>;
+export declare function soleHireAgreementIdForChat(deliveries: readonly Pick<InboxDeliveryRef, 'chatId' | 'agreementId' | 'assigneeId'>[], chatId: string, ownAgentId: string): string | null;
 /**
  * One long-poll pass: hold up to `waitSeconds` for new inbox content, then read
  * the deltas, deliver them into the host, and ack. Returns what it delivered.
@@ -114,5 +113,4 @@ export declare function heldPassAfter(prev: number, pass: Pick<InboxPassResult,
  */
 export declare function runInboxLoop(deps: InboxLoopDeps, opts?: {
     waitSeconds?: number;
-    probePollMs?: number;
 }): InboxLoopHandle;

package/dist/platform/inboxLoop.js

@@ -5,6 +5,17 @@ const READ_PAGE = 100;
 function log(label, msg) {
     runtimeLog.info(label, msg);
 }
+function inboxClient(deps) {
+    return new InboxClient(deps.creds.operatorKey, deps.creds.agentId, deps.baseUrl, deps.creds.instanceId);
+}
+async function releaseInboxHostBestEffort(deps) {
+    try {
+        await inboxClient(deps).releaseHost();
+    }
+    catch (err) {
+        warn(deps.label ?? 'inboxLoop', `inbox host release failed: ${err?.message ?? err}`);
+    }
+}
 function warn(label, msg) {
     runtimeLog.warn(label, msg);
 }
@@ -25,45 +36,6 @@ export function chatsInWakeOrder(chats) {
 function isPublishProbeChat(chatId) {
     return chatId.startsWith('probe_');
 }
-/**
- * Store publish waits on a chat reply, not inbox ack. The ordinary pass can
- * already be inside leftover mail when that room appears, so a side read
- * answers `probe_*` chats without waiting for the current pass to finish.
- * It never acks — the main pass still owns the watermark.
- */
-export async function answerPublishProbes(deps) {
-    const inbox = new InboxClient(deps.creds.operatorKey, deps.creds.agentId, deps.baseUrl);
-    const reader = new ContextReadClient(deps.creds.operatorKey, deps.creds.agentId, deps.baseUrl);
-    const envelope = await inbox.getInbox({});
-    const probes = (envelope.chats ?? []).filter((c) => isPublishProbeChat(c.chatId));
-    if (probes.length === 0)
-        return 0;
-    const mine = (d) => d.assigneeId === deps.ownAgentId;
-    const earliestByChat = new Map();
-    for (const d of envelope.deliveries) {
-        if (!d.chatId || !mine(d) || !isPublishProbeChat(d.chatId))
-            continue;
-        const seen = earliestByChat.get(d.chatId);
-        if (!seen || d.ts < seen)
-            earliestByChat.set(d.chatId, d.ts);
-    }
-    const attempt = async (what, handover) => {
-        try {
-            await handover();
-            return true;
-        }
-        catch (err) {
-            warn(deps.label ?? 'inboxLoop', `publish-probe ${what} was not handled: ${err?.message ?? err}`);
-            return false;
-        }
-    };
-    let delivered = 0;
-    for (const news of probes) {
-        const earliest = earliestByChat.get(news.chatId) ?? news.latestAt;
-        delivered += await deliverMessagesForChat(deps, news, earliest, reader, attempt);
-    }
-    return delivered;
-}
 /**
  * Standing proposals share the merged inbox visibility model with deliveries,
  * but older envelopes predate an explicit assignee stamp. Prefer the server's
@@ -78,6 +50,22 @@ function proposalIsMine(proposal, ownAgentId) {
     return (proposal.pendingApprovalPartyIds?.includes(ownAgentId) === true ||
         proposal.proposedTo === ownAgentId);
 }
+/**
+ * The one hire a chat's assigned deliveries name, or null when the room
+ * has none or more than one. Memory (and acting-for) treat "several
+ * customers in one room" as the shared section.
+ */
+export function soleHireAgreementIdForChat(deliveries, chatId, ownAgentId) {
+    const ids = new Set();
+    for (const d of deliveries) {
+        if (d.chatId !== chatId || !d.agreementId)
+            continue;
+        if (d.assigneeId && d.assigneeId !== ownAgentId)
+            continue;
+        ids.add(d.agreementId);
+    }
+    return ids.size === 1 ? [...ids][0] : null;
+}
 /**
  * Read the messages behind one chat's deliveries and hand them to the host.
  *
@@ -85,7 +73,7 @@ function proposalIsMine(proposal, ownAgentId) {
  * reads through `/context/read`, where the agent's own grants fence what it is
  * allowed to see. A delivery reference is an address, never an authorisation.
  */
-async function deliverMessagesForChat(deps, news, earliestTs, reader, attempt) {
+async function deliverMessagesForChat(deps, news, earliestTs, reader, attempt, hireAgreementId) {
     let delivered = 0;
     let remaining = news.count;
     // `after` is exclusive, so step back a millisecond to include the oldest
@@ -135,6 +123,7 @@ async function deliverMessagesForChat(deps, news, earliestTs, reader, attempt) {
                 // leaving it made ClaudeBrain treat the wake as notice-only.
                 receiverId: deps.ownAgentId,
                 receiver: { id: deps.ownAgentId },
+                ...(hireAgreementId ? { agreementId: hireAgreementId } : {}),
             }));
             if (handled)
                 delivered++;
@@ -155,7 +144,7 @@ async function deliverMessagesForChat(deps, news, earliestTs, reader, attempt) {
  */
 export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
     const label = deps.label ?? 'inboxLoop';
-    const inbox = new InboxClient(deps.creds.operatorKey, deps.creds.agentId, deps.baseUrl);
+    const inbox = inboxClient(deps);
     const reader = new ContextReadClient(deps.creds.operatorKey, deps.creds.agentId, deps.baseUrl);
     const envelope = await inbox.getInbox(waitSeconds > 0 ? { waitSeconds } : {});
     let messagesDelivered = 0;
@@ -244,7 +233,7 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
     for (const news of chatsInWakeOrder(envelope.chats ?? [])) {
         const earliest = earliestByChat.get(news.chatId) ?? news.latestAt;
         const failuresBefore = failures;
-        const n = await deliverMessagesForChat(deps, news, earliest, reader, attempt);
+        const n = await deliverMessagesForChat(deps, news, earliest, reader, attempt, soleHireAgreementIdForChat(envelope.deliveries, news.chatId, deps.ownAgentId));
         messagesDelivered += n;
         if (n > 0)
             log(label, `chat ${news.chatId} delivered ${n} message(s)`);
@@ -409,16 +398,6 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
  * some defaults ship with. Lower it if your deployment sits behind a shorter one.
  */
 const DEFAULT_WAIT_SECONDS = 110;
-/**
- * Side-poll interval for store-publish `probe_*` rooms.
- *
- * Default **off**. A second GET /inbox beside the main long-poll burned the
- * shared poll ceiling: every hosted agent side-polled, probes got 429s, and
- * Register saw ALB HTML 504s. Main pass + probe-first ordering + pinned
- * `probe_*` deliveries are enough; set `probePollMs` only when you knowingly
- * need the extra loop.
- */
-const DEFAULT_PROBE_POLL_MS = 0;
 const ERROR_BACKOFF_BASE_MS = 1_000;
 const ERROR_BACKOFF_MAX_MS = 30_000;
 /**
@@ -455,7 +434,6 @@ function sleep(ms) {
 export function runInboxLoop(deps, opts = {}) {
     const label = deps.label ?? 'inboxLoop';
     const waitSeconds = opts.waitSeconds ?? DEFAULT_WAIT_SECONDS;
-    const probePollMs = opts.probePollMs ?? DEFAULT_PROBE_POLL_MS;
     let running = true;
     let consecutiveErrors = 0;
     let heldPasses = 0;
@@ -501,32 +479,7 @@ export function runInboxLoop(deps, opts = {}) {
             }
         }
     })();
-    const probes = (async () => {
-        if (probePollMs <= 0)
-            return;
-        while (running) {
-            const slice = 50;
-            let left = probePollMs;
-            while (left > 0 && running) {
-                const step = Math.min(slice, left);
-                await sleep(step);
-                left -= step;
-            }
-            if (!running)
-                break;
-            try {
-                const n = await answerPublishProbes(deps);
-                if (n > 0)
-                    log(label, `publish-probe side poll delivered ${n} message(s)`);
-            }
-            catch (err) {
-                if (!running)
-                    break;
-                warn(label, `publish-probe side poll failed: ${err?.message ?? err}`);
-            }
-        }
-    })();
-    const done = Promise.all([main, probes]);
+    const done = main;
     return {
         get running() {
             return running;
@@ -539,7 +492,10 @@ export function runInboxLoop(deps, opts = {}) {
         },
         async stop() {
             running = false;
-            await done.catch(() => { });
+            // Drop the lease immediately. Do not wait out a held poll — SIGTERM
+            // then process.exit cannot sit on the 110s wait.
+            await releaseInboxHostBestEffort(deps);
+            void done.catch(() => { });
         },
     };
 }

package/dist/platform/polls/declaredPollRunner.d.ts

@@ -1,4 +1,10 @@
 import type { AgentOptions } from '../../Agent.js';
 import { PollRunner, type WakeTarget } from './PollRunner.js';
-/** Validate before starting any work, so a declared wake source cannot vanish. */
+/**
+ * Build the runner that executes this agent's declared wakes.
+ *
+ * A malformed `polls` value is a programming error and still throws. A
+ * binding that names an unknown kind or has no chatId is not: PollRunner
+ * warns and skips it, so one agent's invalid poll cannot refuse the host.
+ */
 export declare function createDeclaredPollRunner(options: AgentOptions, target: WakeTarget): PollRunner | null;

package/dist/platform/polls/declaredPollRunner.js

@@ -1,6 +1,12 @@
 import { PollRegistry } from './PollKind.js';
 import { PollRunner } from './PollRunner.js';
-/** Validate before starting any work, so a declared wake source cannot vanish. */
+/**
+ * Build the runner that executes this agent's declared wakes.
+ *
+ * A malformed `polls` value is a programming error and still throws. A
+ * binding that names an unknown kind or has no chatId is not: PollRunner
+ * warns and skips it, so one agent's invalid poll cannot refuse the host.
+ */
 export function createDeclaredPollRunner(options, target) {
     const registry = new PollRegistry();
     for (const kind of options.pollKinds ?? [])
@@ -9,14 +15,6 @@ export function createDeclaredPollRunner(options, target) {
         return null;
     if (!Array.isArray(options.polls))
         throw new Error('Agent: polls must be an array');
-    for (const binding of options.polls) {
-        if (!binding || !registry.get(binding.kind)) {
-            throw new Error(`Agent ${options.agentId}: unknown poll kind "${binding?.kind}"; declare its implementation in pollKinds`);
-        }
-        if (typeof binding.chatId !== 'string' || !binding.chatId.trim()) {
-            throw new Error(`Agent ${options.agentId}: poll "${binding.kind}" requires a chatId`);
-        }
-    }
     if (!options.polls.length)
         return null;
     return new PollRunner({

package/dist/platform/tools/index.d.ts

@@ -24,6 +24,7 @@ export { CONNECTION_TOOLS, connectionProxyTool, connectionListGrantsTool, reques
 export { CONTEXT_TOOLS, contextReadTool, contextDelegateTool, contextExpandReachTool, contextDiscoverGrantableTool, } from './tier2/contextTools.js';
 export { GRANTS_TOOLS, listGrantsTool } from './tier2/grantsTools.js';
 export { TASK_TOOLS, listTasksTool } from './tier2/taskTools.js';
+export { PLAN_TOOLS, taskReplacePlanTool } from './tier2/planTools.js';
 export { LINK_TOOLS, linkProposeTool, linkListTool, } from './tier2/linkTools.js';
 export { INTRODUCTION_TOOLS, introductionMintTool, introductionRedeemTool, introductionListTool, introductionRevokeTool, } from './tier2/introductionTools.js';
 export { ARTIFACT_TOOLS, recordArtifactTool } from './tier2/artifactTools.js';

package/dist/platform/tools/index.js

@@ -28,6 +28,7 @@ export { CONTEXT_TOOLS, contextReadTool, contextDelegateTool, contextExpandReach
 // payment_list_grants). Always-available on the hosted agent — see CLAUDE_SDK_TOOLS.
 export { GRANTS_TOOLS, listGrantsTool } from './tier2/grantsTools.js';
 export { TASK_TOOLS, listTasksTool } from './tier2/taskTools.js';
+export { PLAN_TOOLS, taskReplacePlanTool } from './tier2/planTools.js';
 // links (agreements with engagementKind 'link') — cross-org reach.
 ///1022: the rail is two tools; propose/claim/revoke ride the
 // agreement grammar.

package/dist/platform/tools/tier2/contextTools.d.ts

@@ -1,5 +1,7 @@
 import type { ToolDefinition } from '../../../tools/defineTool.js';
 export declare const contextReadTool: ToolDefinition;
+export declare const openTool: ToolDefinition;
+export declare const accessExplainTool: ToolDefinition;
 export declare const contextDelegateTool: ToolDefinition;
 export declare const contextExpandReachTool: ToolDefinition;
 export declare const contextDiscoverGrantableTool: ToolDefinition;

package/dist/platform/tools/tier2/contextTools.js

@@ -1,9 +1,11 @@
-import { CONTEXT_CAPABILITIES, contextReadCapability, contextDelegateCapability, contextExpandReachCapability, contextDiscoverGrantableCapability, } from '@ziggs-ai/api-client';
+import { CONTEXT_CAPABILITIES, contextReadCapability, openCapability, accessExplainCapability, contextDelegateCapability, contextExpandReachCapability, contextDiscoverGrantableCapability, } from '@ziggs-ai/api-client';
 import { toolFromCapability, toolsFromCapabilities } from '../../../tools/capabilityAdapter.js';
 // context grant tools ride the same api-client
 // clients as ziggs-mcp; the whole definition (schema + handler) is now shared
 // via the capability layer, so the two surfaces cannot fork.
 export const contextReadTool = toolFromCapability(contextReadCapability);
+export const openTool = toolFromCapability(openCapability);
+export const accessExplainTool = toolFromCapability(accessExplainCapability);
 export const contextDelegateTool = toolFromCapability(contextDelegateCapability);
 export const contextExpandReachTool = toolFromCapability(contextExpandReachCapability);
 export const contextDiscoverGrantableTool = toolFromCapability(contextDiscoverGrantableCapability);