@ziggs-ai/agent-sdk 0.11.0 → 0.12.0

package/dist/runtime/PromptBuilder.js

@@ -281,7 +281,19 @@ ${this._renderDecisionSchemaFromActions(actions, senderMeta, ctxObj, omitMessage
             const name = a.name && a.name !== id ? `${a.name} (${id})` : id;
             agentLabels.set(id, `${name}${desc}`);
         }
-        const kindOf = (id) => userIds.has(id) ? 'user' : agentIds.has(id) ? 'agent' : 'unknown';
+        // The server declares what each participant is (`kind` on the snapshot row),
+        // so read that. Which array a row arrived in is a projection detail, and
+        // guessing from it mislabels the first participant that is neither a person
+        // nor an agent. A backend too old to send `kind` still resolves by array.
+        const declaredKinds = new Map();
+        for (const row of [...users, ...otherAgents]) {
+            const id = (row?.['userId'] ?? row?.['agentId']);
+            const kind = row?.['kind'];
+            if (id && typeof kind === 'string')
+                declaredKinds.set(id, kind);
+        }
+        const kindOf = (id) => declaredKinds.get(id) ??
+            (userIds.has(id) ? 'user' : agentIds.has(id) ? 'agent' : 'unknown');
         const labelOf = (id) => userLabels.get(id) ?? agentLabels.get(id) ?? id;
         const tagged = (id) => `${labelOf(id)} [${kindOf(id)}]`;
         const agreementParties = new Map();

package/dist/server/ConnectionPool.d.ts

@@ -16,6 +16,7 @@ export interface SendToOptions {
 export declare class ConnectionPool {
     private readonly manager;
     private readonly configs;
+    private readonly hosts;
     private readonly responseListeners;
     /**
      * Register N agent configs. Nothing connects until `connectAll()`; a config
@@ -29,6 +30,24 @@ export declare class ConnectionPool {
     startAgent(agentId: string): Promise<AgentHost>;
     stopAgent(agentId: string): Promise<void>;
     disconnectAll(): Promise<void>;
+    /**
+     * Shut the fleet down without abandoning work: stop taking new deliveries
+     * everywhere, THEN wait for in-flight turns to finish.
+     *
+     * The order is the whole point. Draining one agent while the others still
+     * long-poll leaves a window — as long as the drain — in which a host that is
+     * on its way out keeps accepting new work. On a rolling deploy the replacement
+     * is already live and polling the same inboxes, so that window is where one
+     * delivery gets handled twice: two hosts, one request, two answers.
+     *
+     * `disconnect()` only stops the inbox loop and timers; in-flight ticks live in
+     * each host's event queue, which is what `drain()` waits on. So stopping
+     * intake first costs nothing that is already running.
+     *
+     * A host that cannot finish inside `timeoutMs` is left behind rather than
+     * holding up the rest — the caller is on a shutdown clock of its own.
+     */
+    shutdown(timeoutMs?: number): Promise<void>;
     /**
      * 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.

package/dist/server/ConnectionPool.js

@@ -19,6 +19,10 @@ import { runtimeLog } from '../shared/runtimeLog.js';
 export class ConnectionPool {
     manager = new ConnectionManager();
     configs = new Map();
+    // Live hosts, so shutdown can drain them. The manager hands its handles to
+    // open/close callbacks and does not expose them, and re-reading one through
+    // `startAgent` after a stop would reconnect the agent we are shutting down.
+    hosts = new Map();
     // Listeners enqueued by requestFrom — drained on outbound send-message effects.
     responseListeners = new Map();
     /**
@@ -56,10 +60,12 @@ export class ConnectionPool {
                     },
                 });
                 await host.connectAsync();
+                this.hosts.set(agentId, host);
                 runtimeLog.debug('ConnectionPool', `connected "${agentId}"`);
                 return host;
             }, async (host) => {
                 host.disconnect();
+                this.hosts.delete(agentId);
                 runtimeLog.debug('ConnectionPool', `disconnected "${agentId}"`);
             }, metaByAgentId.get(agentId));
         }
@@ -78,6 +84,30 @@ export class ConnectionPool {
     async disconnectAll() {
         return this.manager.stopAll();
     }
+    /**
+     * Shut the fleet down without abandoning work: stop taking new deliveries
+     * everywhere, THEN wait for in-flight turns to finish.
+     *
+     * The order is the whole point. Draining one agent while the others still
+     * long-poll leaves a window — as long as the drain — in which a host that is
+     * on its way out keeps accepting new work. On a rolling deploy the replacement
+     * is already live and polling the same inboxes, so that window is where one
+     * delivery gets handled twice: two hosts, one request, two answers.
+     *
+     * `disconnect()` only stops the inbox loop and timers; in-flight ticks live in
+     * each host's event queue, which is what `drain()` waits on. So stopping
+     * intake first costs nothing that is already running.
+     *
+     * A host that cannot finish inside `timeoutMs` is left behind rather than
+     * holding up the rest — the caller is on a shutdown clock of its own.
+     */
+    async shutdown(timeoutMs = 30_000) {
+        const hosts = [...this.hosts.values()];
+        await this.manager.stopAll();
+        await Promise.all(hosts.map((host) => host.drain(timeoutMs).catch((err) => {
+            runtimeLog.warn('ConnectionPool', `drain did not finish: ${err.message}`);
+        })));
+    }
     /**
      * 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.

package/dist/server/OutboxBuffer.d.ts

@@ -24,7 +24,7 @@ export declare class OutboxBuffer {
     constructor(options?: OutboxBufferOptions);
     track(chatId: string, msg: {
         text: string;
-        receiverId: string;
+        receiverId?: string;
     }): void;
     merge(chatId: string, history: HistoryEntryShape[], agentId: string | null): void;
     gc(): void;

package/dist/server/ZiggsEffectHandler.d.ts

@@ -35,7 +35,7 @@ export interface ZiggsEffectDeps {
     contextReadClient: ContextReadClient;
     taskService: TaskService;
     agreementService: AgreementService;
-    messageSender: (text: string, receiverId: string, sessionId: string, messageId?: string) => Promise<unknown>;
+    messageSender: (text: string, receiverId: string | undefined, sessionId: string, messageId?: string) => Promise<unknown>;
     /** Sends a streaming chunk to a client. Called per-token during stream-text effects. */
     chunkSender?: (sessionId: string, receiverId: string, text: string, messageId: string) => void;
     toolManager: ToolManager;

package/dist/server/ZiggsEffectHandler.js

@@ -15,7 +15,7 @@ const emptySnapshot = (agentId, chatMissing = false) => ({
     history: [],
     agreements: [],
     users: [],
-    agents: [{ agentId, role: 'self', isYou: true }],
+    agents: [{ agentId, role: 'self', isYou: true, kind: 'agent' }],
     latestSequence: null,
     ...(chatMissing ? { chatMissing: true } : {}),
 });
@@ -26,7 +26,11 @@ async function buildSnapshot(deps, chatId, agentId, opts = {}) {
         const snap = await deps.contextReadClient.snapshot(chatId, {
             maxMessages: opts.limit,
         });
-        return snap;
+        // Built rather than cast: the roster rows are typed on both sides now (they
+        // carry the declared participant kind), and only `history` is loose on the
+        // wire, so a whole-object cast would be asserting past the one field that
+        // actually needs it.
+        return { ...snap, history: snap.history };
     }
     catch (err) {
         // Defensive: server normally signals a dead chat as 200 + chatMissing, but
@@ -331,7 +335,16 @@ export function createZiggsEffectHandler(deps) {
     };
     const handler = async (effect) => {
         const response = await dispatch(effect);
-        deps.effectTap?.(effect, response);
+        // A tap observes; it must never decide the effect's fate. This call was bare,
+        // so a tap that threw took the effect down with it — and taps stringify
+        // arbitrary tool results, which throws on a circular value or a BigInt. The
+        // other two taps (metrics, wake) are already guarded; this is the last one.
+        try {
+            deps.effectTap?.(effect, response);
+        }
+        catch (err) {
+            runtimeLog.warn('ZiggsEffectHandler', `effectTap failed: ${err?.message || err}`);
+        }
         return response;
     };
     return handler;

package/dist/server/agreements/AgreementService.d.ts

@@ -1,4 +1,4 @@
-import { type Agreement, type ClaimedKind, type ProposeAgreementData, type ProposeDirectInput, type ProposeBroadcastInput, type PublishOfferPayload, type DelegateAgreementData, type CounterAgreementData, type CreateAgreementBody, type ListAgreementsFilters, type GetMyAgreementsFilters, type ChatLinkType, type ArtifactLinkType, type UserRole } from '@ziggs-ai/api-client';
+import { type Agreement, type ClaimedKind, type ProposeAgreementData, type ProposeDirectInput, type ProposeBroadcastInput, type PublishOfferPayload, type DelegateAgreementData, type CounterAgreementData, type CreateLinkBody, type ListAgreementsFilters, type GetMyAgreementsFilters, type ChatLinkType, type ArtifactLinkType, type UserRole } from '@ziggs-ai/api-client';
 export declare class AgreementService {
     private creds;
     constructor(operatorKey: string, agentId: string);
@@ -20,7 +20,7 @@ export declare class AgreementService {
     delegate(payload: DelegateAgreementData): Promise<Agreement>;
     respond(agreementId: string, action: 'approve' | 'reject'): Promise<Agreement>;
     /**
-     * claim any open broadcast (quest, standing offer, hand-off,
+     * claim any open broadcast (request, standing offer, hand-off,
      * link invite). Routing (offer vs agreement claim endpoint) is decided in
      * the shared flow; `kind` is the api-client ClaimedKind so this signature
      * can't drift from the flow again (a 'hand-off' addition broke the build).
@@ -45,7 +45,12 @@ export declare class AgreementService {
      */
     mine(filters?: GetMyAgreementsFilters): Promise<Agreement[]>;
     get(agreementId: string): Promise<Agreement | null>;
-    create(body: CreateAgreementBody): Promise<{
+    /**
+     * Create a trust link — direct to one agent, or an open invite. Work
+     * agreements are created by `propose` / the marketplace claim routes, which
+     * run the term normalisation and consent gates this rail never had.
+     */
+    createLink(body: CreateLinkBody): Promise<{
         ok: boolean;
         agreement: Agreement;
     }>;

package/dist/server/agreements/AgreementService.js

@@ -1,4 +1,4 @@
-import { proposeAgreement, proposeBroadcast as proposeBroadcastApi, delegateAgreement, respondToAgreement, counterAgreement, claimOpenAgreement, getAgreementStatus, listAgreements, getMyAgreements, getAgreement, publishOffer as publishOfferApi, createAgreement, revokeAgreement, fulfillAgreement, linkAgreementToChat, getChatsForAgreement, linkArtifactToAgreement, getArtifactsForAgreement, linkUserToAgreement, getUsersForAgreement, } from '@ziggs-ai/api-client';
+import { proposeAgreement, proposeBroadcast as proposeBroadcastApi, delegateAgreement, respondToAgreement, counterAgreement, claimOpenAgreement, getAgreementStatus, listAgreements, getMyAgreements, getAgreement, publishOffer as publishOfferApi, createLink, revokeAgreement, fulfillAgreement, linkAgreementToChat, getChatsForAgreement, linkArtifactToAgreement, getArtifactsForAgreement, linkUserToAgreement, getUsersForAgreement, } from '@ziggs-ai/api-client';
 export class AgreementService {
     creds;
     constructor(operatorKey, agentId) {
@@ -38,7 +38,7 @@ export class AgreementService {
         return respondToAgreement(agreementId, action, this.creds);
     }
     /**
-     * claim any open broadcast (quest, standing offer, hand-off,
+     * claim any open broadcast (request, standing offer, hand-off,
      * link invite). Routing (offer vs agreement claim endpoint) is decided in
      * the shared flow; `kind` is the api-client ClaimedKind so this signature
      * can't drift from the flow again (a 'hand-off' addition broke the build).
@@ -51,7 +51,7 @@ export class AgreementService {
      * agent; the target owner approves. Folds the old request_link tool.
      */
     async requestLink(providerId, description) {
-        const { agreement } = await createAgreement({ engagementKind: 'link', providerId, ...(description ? { description } : {}) }, this.creds);
+        const { agreement } = await createLink({ targetAgentId: providerId, ...(description ? { description } : {}) }, this.creds);
         return agreement;
     }
     counter(agreementId, counter) {
@@ -75,8 +75,13 @@ export class AgreementService {
     get(agreementId) {
         return getAgreement(agreementId, this.creds);
     }
-    create(body) {
-        return createAgreement(body, this.creds);
+    /**
+     * Create a trust link — direct to one agent, or an open invite. Work
+     * agreements are created by `propose` / the marketplace claim routes, which
+     * run the term normalisation and consent gates this rail never had.
+     */
+    createLink(body) {
+        return createLink(body, this.creds);
     }
     revoke(agreementId) {
         return revokeAgreement(agreementId, this.creds);

package/dist/server/inboxLoop.d.ts

@@ -1,4 +1,4 @@
-import { type InboxQuestRef, type InboxTaskRef, type Creds } from '@ziggs-ai/api-client';
+import { 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
@@ -27,11 +27,11 @@ export interface InboxLoopDeps {
      */
     onTask?: (task: InboxTaskRef) => Promise<void>;
     /**
-     * A marketplace quest doorbell. The host MUST triage with a plain
+     * A marketplace request doorbell. The host MUST triage with a plain
      * string compare and return without an LLM wake on miss — otherwise every
-     * public quest burns a full Claude turn per published supplier.
+     * public request burns a full Claude turn per published supplier.
      */
-    onQuest?: (quest: InboxQuestRef) => Promise<void>;
+    onRequest?: (request: InboxRequestRef) => Promise<void>;
     label?: string;
 }
 export interface InboxPassResult {
@@ -41,8 +41,8 @@ export interface InboxPassResult {
     resourceEvents: number;
     /** Assigned open tasks delivered this pass. */
     tasksDelivered: number;
-    /** Quest refs triaged this pass — includes misses that only ack. */
-    questsTriaged: number;
+    /** Request refs triaged this pass — includes misses that only ack. */
+    requestsTriaged: number;
     /** True when the watermark advanced this pass. */
     acked: boolean;
     /** True when there was more mail than one envelope carries. */

package/dist/server/inboxLoop.js

@@ -83,7 +83,7 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
     let messagesDelivered = 0;
     let resourceEvents = 0;
     let tasksDelivered = 0;
-    let questsTriaged = 0;
+    let requestsTriaged = 0;
     let failures = 0;
     // a handover that failed must not be acked, and must not be
     // remembered as seen — otherwise the redelivery the held watermark buys is
@@ -107,10 +107,16 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
         // make a badly backed-up agent replay its whole backlog forever.
         warn(label, 'inbox deliveriesCapped (more mail than one envelope carries — the tail follows on the next pass)');
     }
-    // Oldest delivery per chat: where to start reading that chat's messages.
+    // The single-assign law: a row is MINE to act on iff it carries my stamp.
+    // Everything else in the merged view (a sibling carrier's mail, the owner's
+    // needs-human rows, granted ambient lanes) is context the host may read on
+    // demand — never a wake, never mine to ack as handled.
+    const mine = (d) => d.assigneeId === deps.ownAgentId;
+    // Oldest ASSIGNED delivery per chat: where to start reading that chat's
+    // messages. Ambient chat rows must not drag the read window earlier.
     const earliestByChat = new Map();
     for (const d of envelope.deliveries) {
-        if (!d.chatId)
+        if (!d.chatId || !mine(d))
             continue;
         const seen = earliestByChat.get(d.chatId);
         if (!seen || d.ts < seen)
@@ -126,10 +132,14 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
     // Everything that is not chat text is handed over as a resource event, from
     // the delivery itself — the reference already carries the ids the host needs,
     // so nothing has to be re-derived to name what changed.
-    // Quests must never take this path — even if a pre-cut server
+    // Requests must never take this path — even if a pre-cut server
     // left them in `deliveries`, skip so they cannot wake the LLM before triage.
+    // Unassigned rows never take it either: waking the brain on a sibling's
+    // mail is the N-wakes-per-event cost the party-owned inbox exists to kill.
     for (const d of envelope.deliveries) {
-        if (d.kind === 'message' || d.kind === 'quest')
+        if (d.kind === 'message' || d.kind === 'request')
+            continue;
+        if (!mine(d))
             continue;
         const key = `delivery:${d.kind}:${d.resourceId}:${d.ts}`;
         if (deps.seen.has(key))
@@ -169,26 +179,26 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
     if (envelope.truncatedTasks) {
         warn(label, `inbox truncatedTasks=${envelope.truncatedTasks} (more assigned tasks than one pass surfaces — they appear as earlier ones close)`);
     }
-    // quest channel. Triage is the host's job (exact string compare);
+    // request channel. Triage is the host's job (exact string compare);
     // a miss must still count as handled so the watermark can advance with 0 tokens.
-    for (const quest of envelope.questsAwaitingMe ?? []) {
-        const key = `quest:${quest.agreementId}:${quest.ts}`;
+    for (const request of envelope.requestsAwaitingMe ?? []) {
+        const key = `request:${request.agreementId}:${request.ts}`;
         if (deps.seen.has(key))
             continue;
         deps.seen.mark(key);
-        if (deps.onQuest) {
-            const handled = await attempt(`quest ${quest.agreementId}`, () => deps.onQuest(quest), () => deps.seen.unmark(key));
+        if (deps.onRequest) {
+            const handled = await attempt(`request ${request.agreementId}`, () => deps.onRequest(request), () => deps.seen.unmark(key));
             if (handled)
-                questsTriaged++;
+                requestsTriaged++;
         }
         else {
             // No handler → still count as handled (ack) so an old host cannot wedge
-            // forever on quest mail it does not understand.
-            questsTriaged++;
+            // forever on request mail it does not understand.
+            requestsTriaged++;
         }
     }
-    if (envelope.truncatedQuests) {
-        warn(label, `inbox truncatedQuests=${envelope.truncatedQuests} (more quests than one pass surfaces — the tail follows on the next pass)`);
+    if (envelope.truncatedRequests) {
+        warn(label, `inbox truncatedRequests=${envelope.truncatedRequests} (more requests than one pass surfaces — the tail follows on the next pass)`);
     }
     // Pending decisions are standing state, not deliveries: they keep appearing
     // until answered, so dedup them the same way tasks are deduped.
@@ -216,20 +226,23 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
     // this window has failed too many times in a row and is now poison, in which
     // case it is dropped loudly rather than wedging the agent forever.
     let acked = false;
-    // ZIG-1305 — a capped envelope has unlisted older deliveries behind ackTo;
+    // A capped envelope has unlisted older deliveries behind ackTo;
     // acking would refuse or bury them. Hold until a later uncapped pass.
     if (envelope.deliveriesCapped && envelope.ackTo) {
-        warn(label, `holding the watermark at ${envelope.ackTo} — deliveriesCapped; ack would not cover the unlisted tail (ZIG-1305)`);
+        warn(label, `holding the watermark at ${envelope.ackTo} — deliveriesCapped; ack would not cover the unlisted tail`);
     }
     else if (envelope.ackTo && (failures === 0 || opts.forceAck)) {
         if (failures > 0) {
             runtimeLog.error(label, `acking a window that failed ${failures} handover(s) — giving up on redelivery to keep the ` +
                 `agent alive; this mail is lost (ackTo=${envelope.ackTo})`);
         }
+        // Assigned rows only: the server's bury-guard checks what was MINE to
+        // handle. Ambient rows slide past the cursor unlisted — they were never
+        // this agent's to act on, and the owner's seen mark tracks them.
         const handledResourceIds = [
             ...new Set([
-                ...envelope.deliveries.map((d) => d.resourceId),
-                ...(envelope.questsAwaitingMe ?? []).map((q) => q.agreementId),
+                ...envelope.deliveries.filter(mine).map((d) => d.resourceId),
+                ...(envelope.requestsAwaitingMe ?? []).map((q) => q.agreementId),
             ]),
         ].filter((id) => typeof id === 'string' && id.length > 0);
         await inbox.ack(envelope.ackTo, { handledResourceIds });
@@ -245,13 +258,18 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
         messagesDelivered,
         resourceEvents,
         tasksDelivered,
-        questsTriaged,
+        requestsTriaged,
         acked,
         truncated: envelope.deliveriesCapped,
         failures,
     };
 }
-const DEFAULT_WAIT_SECONDS = 25;
+/**
+ * Default long-poll hold for hosted agents. Matches the server's own ceiling,
+ * and assumes a proxy idle timeout comfortably above it rather than the 25s
+ * some defaults ship with. Lower it if your deployment sits behind a shorter one.
+ */
+const DEFAULT_WAIT_SECONDS = 110;
 const ERROR_BACKOFF_BASE_MS = 1_000;
 const ERROR_BACKOFF_MAX_MS = 30_000;
 /**

package/dist/server/polls/PollRunner.d.ts

@@ -41,6 +41,26 @@ export interface PollRunnerOptions {
      * through every single time.
      */
     wakeTimeoutMs?: number;
+    /**
+     * Most actionable wakes one binding may cause per {@link wakeWindowMs}.
+     * Default 20.
+     *
+     * A poll wakes its agent whenever the source says `actionable`, and each wake
+     * is a real model run. Nothing else bounds that: the agent polls the outside
+     * world and triggers itself, so the backend never sees it and the agreement
+     * wake ceiling never gets a chance to fire. A mailbox that stops being
+     * archived keeps answering "yes, there is unhandled mail" forever, at one wake
+     * per interval, indefinitely.
+     *
+     * 20 an hour is far above any healthy agent and roughly 20 minutes of a
+     * runaway at the 60s default interval.
+     *
+     * Deliberately a runner option and NOT read from the PollKind or the binding:
+     * a bound that the bounded thing can raise is not a bound.
+     */
+    maxWakesPerWindow?: number;
+    /** Window the wake cap is measured over. Default 1 hour. */
+    wakeWindowMs?: number;
     label?: string;
 }
 export declare class PollRunner {
@@ -49,9 +69,11 @@ export declare class PollRunner {
     private readonly label;
     private readonly maxBackoffMs;
     private readonly wakeTimeoutMs;
+    private readonly maxWakesPerWindow;
+    private readonly wakeWindowMs;
     private readonly loops;
     private running;
-    constructor({ pool, registry, agents, operatorKey, defaultIntervalMs, maxBackoffMs, wakeTimeoutMs, label, }: PollRunnerOptions);
+    constructor({ pool, registry, agents, operatorKey, defaultIntervalMs, maxBackoffMs, wakeTimeoutMs, maxWakesPerWindow, wakeWindowMs, label, }: PollRunnerOptions);
     get size(): number;
     start(): void;
     stop(): void;
@@ -59,4 +81,17 @@ export declare class PollRunner {
     /** Interval while healthy; doubling up to the ceiling while failing. */
     private nextDelay;
     private tick;
+    /**
+     * Take one wake from this binding's budget, or refuse.
+     *
+     * Refusing is announced once per window, at error level, and resuming is
+     * announced too. A poll that simply goes quiet is worse than one that wakes
+     * too much: from the outside it is indistinguishable from a mailbox that is
+     * genuinely empty, so nobody looks.
+     *
+     * The source keeps being polled while capped. Stopping the poll as well would
+     * mean the first tick after the window rolls is the one that discovers the
+     * backlog, and a source that recovered would go unnoticed for a whole window.
+     */
+    private claimWake;
 }

package/dist/server/polls/PollRunner.js

@@ -26,14 +26,18 @@ export class PollRunner {
     label;
     maxBackoffMs;
     wakeTimeoutMs;
+    maxWakesPerWindow;
+    wakeWindowMs;
     loops = [];
     running = false;
-    constructor({ pool, registry, agents, operatorKey, defaultIntervalMs = 60_000, maxBackoffMs = 15 * 60_000, wakeTimeoutMs = Number(process.env.CLAUDE_SDK_TICK_TIMEOUT_MS ?? 300_000), label = 'PollRunner', }) {
+    constructor({ pool, registry, agents, operatorKey, defaultIntervalMs = 60_000, maxBackoffMs = 15 * 60_000, wakeTimeoutMs = Number(process.env.CLAUDE_SDK_TICK_TIMEOUT_MS ?? 300_000), maxWakesPerWindow = 20, wakeWindowMs = 60 * 60_000, label = 'PollRunner', }) {
         this.pool = pool;
         this.operatorKey = operatorKey;
         this.label = label;
         this.maxBackoffMs = maxBackoffMs;
         this.wakeTimeoutMs = wakeTimeoutMs;
+        this.maxWakesPerWindow = maxWakesPerWindow;
+        this.wakeWindowMs = wakeWindowMs;
         for (const config of agents) {
             const agentId = config['agentId'];
             if (typeof agentId !== 'string' || !agentId)
@@ -61,6 +65,9 @@ export class PollRunner {
                     chatId: binding.chatId,
                     timer: null,
                     failures: 0,
+                    wakes: 0,
+                    windowStartedAt: Date.now(),
+                    capped: false,
                 });
             }
         }
@@ -115,7 +122,7 @@ export class PollRunner {
             this.schedule(loop);
             return;
         }
-        if (result?.actionable) {
+        if (result?.actionable && this.claimWake(loop)) {
             const hint = result.hint ?? `New work from ${loop.kind.id}. Check it.`;
             try {
                 // Awaited on purpose — see the header. The next tick waits for the
@@ -135,4 +142,37 @@ export class PollRunner {
         }
         this.schedule(loop);
     }
+    /**
+     * Take one wake from this binding's budget, or refuse.
+     *
+     * Refusing is announced once per window, at error level, and resuming is
+     * announced too. A poll that simply goes quiet is worse than one that wakes
+     * too much: from the outside it is indistinguishable from a mailbox that is
+     * genuinely empty, so nobody looks.
+     *
+     * The source keeps being polled while capped. Stopping the poll as well would
+     * mean the first tick after the window rolls is the one that discovers the
+     * backlog, and a source that recovered would go unnoticed for a whole window.
+     */
+    claimWake(loop) {
+        const now = Date.now();
+        if (now - loop.windowStartedAt >= this.wakeWindowMs) {
+            if (loop.capped) {
+                runtimeLog.info(this.label, `${loop.agentId}:${loop.kind.id} wake budget reset — waking again (cap ${this.maxWakesPerWindow}/${this.wakeWindowMs}ms)`);
+            }
+            loop.windowStartedAt = now;
+            loop.wakes = 0;
+            loop.capped = false;
+        }
+        if (loop.wakes >= this.maxWakesPerWindow) {
+            if (!loop.capped) {
+                loop.capped = true;
+                runtimeLog.error(this.label, `${loop.agentId}:${loop.kind.id} hit the wake cap (${this.maxWakesPerWindow} in ${this.wakeWindowMs}ms) and will NOT be woken again until the window rolls. ` +
+                    `The source keeps reporting actionable, so either it is genuinely that busy or something downstream stopped clearing it.`);
+            }
+            return false;
+        }
+        loop.wakes += 1;
+        return true;
+    }
 }

package/dist/server/requestMatch.d.ts

@@ -0,0 +1,5 @@
+/**
+ * exact-match triage for marketplace requests.
+ * Empty match never hits (token-safe default). Comparison is exact after trim.
+ */
+export declare function requestExactMatch(match: string, tags: ReadonlyArray<string | null | undefined>): boolean;

package/dist/server/{questMatch.js → requestMatch.js}

@@ -1,8 +1,8 @@
 /**
- * exact-match triage for marketplace quests.
+ * exact-match triage for marketplace requests.
  * Empty match never hits (token-safe default). Comparison is exact after trim.
  */
-export function questExactMatch(match, tags) {
+export function requestExactMatch(match, tags) {
     const needle = typeof match === 'string' ? match.trim() : '';
     if (!needle)
         return false;

package/dist/server/runLauncher.js

@@ -5,6 +5,14 @@ import { boundKeyFleetWarning } from '../shared/operatorKeyClaims.js';
 import { runtimeLog } from '../shared/runtimeLog.js';
 import { PollRegistry } from './polls/PollKind.js';
 import { PollRunner } from './polls/PollRunner.js';
+/**
+ * How long a shutdown waits for in-flight turns after it has stopped taking new
+ * work. An agent turn is an LLM call, so the old 30s was under the length of the
+ * work it was meant to protect; the container's stop timeout is what has to be
+ * larger still, or the drain is cut short by SIGKILL regardless (ECS
+ * `stopTimeout`, 120s on the fleet task definitions).
+ */
+const DRAIN_TIMEOUT_MS = Number(process.env.FLEET_DRAIN_TIMEOUT_MS) || 90_000;
 /**
  * Collect the poll kinds the agents themselves ship and start a runner for
  * whatever they declared. This lives in the launcher, not in a caller's
@@ -57,7 +65,7 @@ async function runSingle(config, { operatorKey, label = 'agent', port = process.
         runtimeLog.info(label, 'SIGTERM — shutting down');
         pollRunner?.stop();
         agent.disconnect();
-        await agent.drain(30_000);
+        await agent.drain(DRAIN_TIMEOUT_MS);
         try {
             await onShutdown?.();
         }
@@ -122,10 +130,23 @@ async function runFleet(configs, { operatorKey, port = process.env.PORT || 8080,
     });
     process.on('SIGTERM', async () => {
         runtimeLog.info(label, 'SIGTERM — shutting down');
+        // Stop taking new work everywhere first, then wait for what is running.
+        //
+        // This used to disconnect and drain only `primary` — which `run.ts` never
+        // sets, so in the deployed fleet the drain was a no-op on null and the
+        // process exited straight through `disconnectAll`, killing every in-flight
+        // turn. A buyer whose request landed mid-rollout got a host that stopped
+        // mid-sentence and never reported.
+        //
+        // Draining before stopping intake is the other half of the same bug: the
+        // wait is exactly the window in which a host on its way out keeps accepting
+        // deliveries the incoming host is also being handed.
         pollRunner?.stop();
         primary?.disconnect?.();
-        await primary?.drain?.(30_000);
-        await pool.disconnectAll();
+        await Promise.all([
+            pool.shutdown(DRAIN_TIMEOUT_MS),
+            primary?.drain?.(DRAIN_TIMEOUT_MS) ?? Promise.resolve(),
+        ]);
         try {
             await onShutdown?.();
         }

package/dist/server/tasks/TaskService.d.ts

@@ -8,10 +8,10 @@ export declare class TaskService {
     getActiveTasksForChat(chatId: string): Promise<Task[]>;
     getSubtasks(parentTaskId: string): Promise<Task[]>;
     spawnUnderAgreement(agreementId: string, taskData: Omit<CreateTaskData, 'agreementId'>): Promise<Task>;
-    updateState(taskId: string, state: TaskState, result?: unknown, idempotencyKey?: string): Promise<Task>;
-    updatePlanStep(taskId: string, stepId: string, status: string, result?: unknown): Promise<Task>;
-    cancel(taskId: string): Promise<Task>;
-    report(taskId: string, message?: string): Promise<Task>;
-    setSatisfaction(taskId: string, satisfaction: 'positive' | 'negative'): Promise<Task>;
+    updateState(taskId: string, state: TaskState, result?: unknown, idempotencyKey?: string): Promise<import("@ziggs-ai/api-client").TaskWriteConfirm>;
+    updatePlanStep(taskId: string, stepId: string, status: string, result?: unknown): Promise<import("@ziggs-ai/api-client").TaskWriteConfirm>;
+    cancel(taskId: string): Promise<import("@ziggs-ai/api-client").TaskWriteConfirm>;
+    report(taskId: string, message?: string): Promise<import("@ziggs-ai/api-client").TaskWriteConfirm>;
+    setSatisfaction(taskId: string, satisfaction: 'positive' | 'negative'): Promise<import("@ziggs-ai/api-client").TaskWriteConfirm>;
     count(filters?: CountTasksFilters): Promise<number>;
 }

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

@@ -19,7 +19,7 @@ export { PROTOCOL_TOOLS, agreementProposeTool, agreementSubcontractTool, agreeme
 export { dispatchProtocolOp } from './tier1/protocolRunner.js';
 export { DISCOVERY_TOOLS, agentSearchTool, agentGetTool } from './tier2/discoveryTools.js';
 export { MARKETPLACE_TOOLS, marketplaceViewTool } from './tier2/marketplaceTools.js';
-export { PAYMENT_TOOLS, paymentBalanceTool, paymentTransferTool, paymentWaitForApprovalTool, paymentHoldTool, paymentReleaseTool, paymentResolveWalletTool, paymentIssueGrantTool, paymentAttenuateGrantTool, paymentRevokeGrantTool, } from './tier2/paymentTools.js';
+export { PAYMENT_TOOLS, paymentBalanceTool } from './tier2/paymentTools.js';
 export { CONNECTION_TOOLS, connectionProxyTool, connectionListGrantsTool, requestConnectionTool, } from './tier2/connectionTools.js';
 export { CONTEXT_TOOLS, contextReadTool, contextDelegateTool, contextExpandReachTool, contextDiscoverGrantableTool, } from './tier2/contextTools.js';
 export { GRANTS_TOOLS, listGrantsTool } from './tier2/grantsTools.js';

package/dist/server/tools/index.js

@@ -21,7 +21,7 @@ export { dispatchProtocolOp } from './tier1/protocolRunner.js';
 // ── Tier 2: capability bundles ──────────────────────────────────────────────
 export { DISCOVERY_TOOLS, agentSearchTool, agentGetTool } from './tier2/discoveryTools.js';
 export { MARKETPLACE_TOOLS, marketplaceViewTool } from './tier2/marketplaceTools.js';
-export { PAYMENT_TOOLS, paymentBalanceTool, paymentTransferTool, paymentWaitForApprovalTool, paymentHoldTool, paymentReleaseTool, paymentResolveWalletTool, paymentIssueGrantTool, paymentAttenuateGrantTool, paymentRevokeGrantTool, } from './tier2/paymentTools.js';
+export { PAYMENT_TOOLS, paymentBalanceTool } from './tier2/paymentTools.js';
 export { CONNECTION_TOOLS, connectionProxyTool, connectionListGrantsTool, requestConnectionTool, } from './tier2/connectionTools.js';
 export { CONTEXT_TOOLS, contextReadTool, contextDelegateTool, contextExpandReachTool, contextDiscoverGrantableTool, } from './tier2/contextTools.js';
 // one grant lister across every rail (retires context_discover +