@ziggs-ai/agent-sdk 0.20.0 → 0.22.0

package/dist/brain/standingOfferNotice.js

@@ -0,0 +1,89 @@
+import { isAgreementId, isBroadcastTarget } from '@ziggs-ai/api-client';
+import { getBatchEvents } from '../context/batch.js';
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value : null;
+}
+function agreementEventIds(event) {
+    const resource = record(event?.resource);
+    const result = record(event?.result);
+    const candidates = [
+        resource?.agreementId,
+        resource?.kind === 'agreement' ? resource.resourceId : undefined,
+        event?.agreementId,
+        result?.agreementId,
+    ];
+    return [...new Set(candidates.filter((value) => typeof value === 'string' && value.length > 0))];
+}
+export function agreementEventId(event) {
+    const ids = agreementEventIds(event);
+    return ids.length === 1 ? ids[0] : undefined;
+}
+/**
+ * Provider acceptance leaves a standing listing OPEN with its buyer slot still
+ * a broadcast. It is not a customer hire. Check the full authoritative row;
+ * /status, event actor ids and the word "approved" cannot prove this shape.
+ */
+export function isOwnUnclaimedStandingOffer(value, agreementId, agentId) {
+    const row = record(value);
+    const parties = record(row?.parties);
+    const payer = record(parties?.payer);
+    const provider = record(parties?.provider);
+    return row?.agreementId === agreementId &&
+        row.status === 'open' &&
+        row.providerPinned === true &&
+        provider?.actor === agentId &&
+        typeof payer?.principal === 'string' &&
+        isBroadcastTarget(payer.principal);
+}
+/** Remove only proven listing-acceptance notices; mixed batches keep all real work. */
+export async function filterStandingOfferNotices(event, agentId, readAgreement) {
+    const events = getBatchEvents(event);
+    const retained = [];
+    const ignoredAgreementIds = [];
+    const reads = new Map();
+    for (const item of events) {
+        const resource = record(item?.resource);
+        const reason = resource?.reason ?? item?.reason;
+        const id = agreementEventId(item);
+        if (item?.type === 'resource_changed' && resource?.kind === 'agreement' &&
+            (reason === 'approval:approved' || reason === 'proposal_approved') && id) {
+            // Inconclusive reads preserve the wake. An unavailable read must not eat
+            // a legitimate customer hire or the answer to an agent's own request.
+            if (!reads.has(id))
+                reads.set(id, Promise.resolve().then(() => readAgreement(id)).catch(() => null));
+            if (isOwnUnclaimedStandingOffer(await reads.get(id), id, agentId)) {
+                ignoredAgreementIds.push(id);
+                continue;
+            }
+        }
+        retained.push(item);
+    }
+    if (ignoredAgreementIds.length === 0)
+        return { event, ignoredAgreementIds };
+    return {
+        event: retained.length === 0 ? undefined
+            : retained.length === 1 ? retained[0] : { ...event, events: retained },
+        ignoredAgreementIds,
+    };
+}
+/** A synthetic mailbox has no chat row; access to its agreement must still be proven. */
+export async function isReadableAgreementNoticeLane(sessionId, event, readAgreement) {
+    const id = sessionId.startsWith('agrn-') ? sessionId.slice('agrn-'.length) : sessionId;
+    if (!isAgreementId(id))
+        return false;
+    const events = getBatchEvents(event);
+    if (events.length === 0 || events.some((item) => {
+        const eventIds = agreementEventIds(item);
+        // Old in-memory timers do not carry scope. They may resume only a readable
+        // agreement mailbox. Never derive authority from the model-written reason.
+        return eventIds.length ? eventIds.some((eventId) => eventId !== id) : item?.type !== 'wake-at';
+    }))
+        return false;
+    try {
+        return record(await readAgreement(id))?.agreementId === id;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/index.d.ts

@@ -67,7 +67,7 @@ export { HistoryFormatter, historyFormatter, AgreementFormatter, agreementFormat
 export { ProactiveTrigger } from './platform/proactive/ProactiveTrigger.js';
 export { PollRegistry, declaredPolls, type PollBinding, type PollContext, type PollKind, type PollResult, } from './platform/polls/PollKind.js';
 export { PollRunner, type PollRunnerOptions, type WakeTarget } from './platform/polls/PollRunner.js';
-export { PROTOCOL_TOOLS, agreementProposeTool, agreementSubcontractTool, agreementRespondTool, agreementClaimTool, agreementCounterTool, agreementGetTool, agreementRevokeTool, agreementFulfillTool, taskCreateTool, taskSetResultTool, taskUpdatePlanStepTool, dispatchProtocolOp, PAYMENT_TOOLS, paymentBalanceTool, CONNECTION_TOOLS, connectionProxyTool, connectionListGrantsTool, requestConnectionTool, MCP_CONNECTION_TOOLS, mcpToolCallTool, mcpToolsListTool, DISCOVERY_TOOLS, agentSearchTool, agentGetTool, MARKETPLACE_TOOLS, marketplaceViewTool, CONTEXT_TOOLS, contextReadTool, contextDelegateTool, contextExpandReachTool, contextDiscoverGrantableTool, GRANTS_TOOLS, listGrantsTool, LINK_TOOLS, linkProposeTool, linkListTool, INTRODUCTION_TOOLS, introductionMintTool, introductionRedeemTool, introductionListTool, introductionRevokeTool, ARTIFACT_TOOLS, recordArtifactTool, CHAT_TOOLS, openConversationTool, } from './platform/tools/index.js';
+export { PROTOCOL_TOOLS, agreementProposeTool, agreementSubcontractTool, agreementRespondTool, agreementClaimTool, agreementCounterTool, agreementGetTool, agreementRevokeTool, agreementFulfillTool, taskCreateTool, taskSetResultTool, taskUpdatePlanStepTool, dispatchProtocolOp, PAYMENT_TOOLS, paymentBalanceTool, CONNECTION_TOOLS, connectionProxyTool, connectionListGrantsTool, requestConnectionTool, MCP_CONNECTION_TOOLS, mcpToolCallTool, mcpToolsListTool, DISCOVERY_TOOLS, agentSearchTool, agentGetTool, MARKETPLACE_TOOLS, marketplaceViewTool, CONTEXT_TOOLS, contextReadTool, contextRequestTool, contextDelegateTool, contextExpandReachTool, contextDiscoverGrantableTool, GRANTS_TOOLS, listGrantsTool, PLAN_TOOLS, taskReplacePlanTool, LINK_TOOLS, linkProposeTool, linkListTool, INTRODUCTION_TOOLS, introductionMintTool, introductionRedeemTool, introductionListTool, introductionRevokeTool, ARTIFACT_TOOLS, recordArtifactTool, CHAT_TOOLS, openConversationTool, } from './platform/tools/index.js';
 export { CLAUDE_SDK_TOOLS } from './brain/claudeSdkTools.js';
 export { PROTOCOL_TOOL_NAMES, PROTOCOL_TOOL_TO_OPERATION, mapProtocolToolToOperation, isProtocolToolName } from './tasks/protocolRegistry.js';
 export { InMemoryStore, FileMemoryStore } from './memory/MemoryStore.js';

package/dist/index.js

@@ -79,7 +79,7 @@ export {
 // Tier 1 — protocol grammar (framework-managed via taskTools).
 PROTOCOL_TOOLS, agreementProposeTool, agreementSubcontractTool, agreementRespondTool, agreementClaimTool, agreementCounterTool, agreementGetTool, agreementRevokeTool, agreementFulfillTool, taskCreateTool, taskSetResultTool, taskUpdatePlanStepTool, dispatchProtocolOp, 
 // Tier 2 — opt-in capability bundles (spread into `tools:`).
-PAYMENT_TOOLS, paymentBalanceTool, CONNECTION_TOOLS, connectionProxyTool, connectionListGrantsTool, requestConnectionTool, MCP_CONNECTION_TOOLS, mcpToolCallTool, mcpToolsListTool, DISCOVERY_TOOLS, agentSearchTool, agentGetTool, MARKETPLACE_TOOLS, marketplaceViewTool, CONTEXT_TOOLS, contextReadTool, contextDelegateTool, contextExpandReachTool, contextDiscoverGrantableTool, GRANTS_TOOLS, listGrantsTool, LINK_TOOLS, linkProposeTool, linkListTool, INTRODUCTION_TOOLS, introductionMintTool, introductionRedeemTool, introductionListTool, introductionRevokeTool, ARTIFACT_TOOLS, recordArtifactTool, CHAT_TOOLS, openConversationTool, } from './platform/tools/index.js';
+PAYMENT_TOOLS, paymentBalanceTool, CONNECTION_TOOLS, connectionProxyTool, connectionListGrantsTool, requestConnectionTool, MCP_CONNECTION_TOOLS, mcpToolCallTool, mcpToolsListTool, DISCOVERY_TOOLS, agentSearchTool, agentGetTool, MARKETPLACE_TOOLS, marketplaceViewTool, CONTEXT_TOOLS, contextReadTool, contextRequestTool, contextDelegateTool, contextExpandReachTool, contextDiscoverGrantableTool, GRANTS_TOOLS, listGrantsTool, PLAN_TOOLS, taskReplacePlanTool, LINK_TOOLS, linkProposeTool, linkListTool, INTRODUCTION_TOOLS, introductionMintTool, introductionRedeemTool, introductionListTool, introductionRevokeTool, ARTIFACT_TOOLS, recordArtifactTool, CHAT_TOOLS, openConversationTool, } from './platform/tools/index.js';
 // The always-on toolset for the hosted Claude cognition (parity guard
 // reads this as part of the real SDK registry).
 export { CLAUDE_SDK_TOOLS } from './brain/claudeSdkTools.js';

package/dist/ingress/normalizeIncoming.d.ts

@@ -22,6 +22,8 @@ export interface NormalizedEvent {
         entryType?: string;
         operation?: string;
         agreementId?: string;
+        /** Agreement row stamp — host skip for agent-formed activation reads this. */
+        formedBy?: 'principal' | 'agent';
         result?: unknown;
         text?: string;
     };
@@ -63,6 +65,7 @@ interface WireMetadata {
         agreement?: {
             agreementId?: string;
             status?: string;
+            formedBy?: string;
             proposal?: {
                 status?: string;
             };

package/dist/ingress/normalizeIncoming.js

@@ -32,6 +32,10 @@ function wireAgreementId(metadata) {
         metadata.agreementId;
     return typeof raw === 'string' ? raw : '';
 }
+function wireFormedBy(metadata) {
+    const raw = metadata.service?.agreement?.formedBy;
+    return raw === 'principal' || raw === 'agent' ? raw : undefined;
+}
 /**
  * Self-hire / fully-consented create activates before the chat fan-out lands.
  * The wire still says `proposal_created`, but the embedded agreement is already
@@ -102,6 +106,8 @@ export function normalizeIncomingEvent({ text, metadata = {} }) {
     const entryType = typeof metadata.entryType === 'string' && metadata.entryType
         ? metadata.entryType
         : undefined;
+    const wakeAgreementId = wireAgreementId(metadata);
+    const formedBy = wireFormedBy(metadata);
     const base = {
         senderId: metadata.sender?.id,
         senderType,
@@ -109,6 +115,8 @@ export function normalizeIncomingEvent({ text, metadata = {} }) {
         messageId: typeof metadata.messageId === 'string' && metadata.messageId ? metadata.messageId : undefined,
         timestamp: Date.now(),
         ...(entryType ? { entryType } : {}),
+        ...(wakeAgreementId ? { agreementId: wakeAgreementId } : {}),
+        ...(formedBy ? { formedBy } : {}),
     };
     if (isAgreementLifecycleNotification(metadata)) {
         const operation = isAlreadyActivatedProposalCreated(metadata)

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}`);
@@ -301,9 +305,19 @@ export function createZiggsEffectHandler(deps) {
                 });
             }
             case 'send-message': {
-                await deps.messageSender(effect.text, effect.receiverId, effect.sessionId, effect.messageId);
+                const sent = await deps.messageSender(effect.text, effect.receiverId, effect.sessionId, effect.messageId);
                 outbox.track(effect.sessionId, { text: effect.text, receiverId: effect.receiverId });
-                return { ok: true };
+                // Carry the send's own report back to whoever asked for the send. A
+                // sender that cannot see where its message went cannot tell a delivered
+                // answer from a dropped one, which is the whole failure here.
+                const report = (sent ?? {});
+                return {
+                    ok: true,
+                    ...(report.chatId ? { chatId: report.chatId } : {}),
+                    ...(report.messageId ? { messageId: report.messageId } : {}),
+                    ...(report.delivered ? { delivered: report.delivered } : {}),
+                    ...(report.to ? { to: report.to } : {}),
+                };
             }
             case 'record-event': {
                 // Routes through ArtifactsClient as an agent-private artifact —

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;