@ziggs-ai/agent-sdk 0.7.1 → 0.8.1

package/dist/agent/ClaudeSdkAgent.d.ts

@@ -1,7 +1,22 @@
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import type { Workflow } from '../types.js';
 import type { ToolManager } from '../tools/ToolManager.js';
+import { type RawEvent } from '../runtime/buildOutcome.js';
 import type { TickInput, TickOutput } from './Agent.js';
+/**
+ * ZIG-1035 / ZIG-1052: status notices must not spend a Claude turn answering
+ * nobody. Real work wakes arrive as chat `message`, synthetic `task_result`
+ * from `wakeTaskAssignment`, or `agreement_lifecycle` (hire / proposal
+ * resolution — the FSM kickoffs on the same event; Claude must act too).
+ *
+ * Intentionally not mirrored as an FSM "notice skip": the FSM already no-ops
+ * enter-only outcomes in AgentMachine; `agreement_lifecycle` never produces
+ * `enter`, so hire wakes always step. Claude's filter is narrower — pure
+ * `notification` only.
+ *
+ * Empty / missing batch → notice-only (do not burn a turn on a malformed wake).
+ */
+export declare function isNoticeOnlyWake(event: RawEvent | undefined): boolean;
 export type CognitionKind = 'fsm' | 'claude-sdk';
 export interface ClaudeSdkAgentOptions {
     workflow: Workflow;

package/dist/agent/ClaudeSdkAgent.js

@@ -1,5 +1,6 @@
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { outcomeFromEvent } from '../runtime/buildOutcome.js';
+import { getBatchEvents } from '../context/batch.js';
 import { bootstrapCtx } from '../runtime/bootstrapCtx.js';
 import { createWakeWriteKeys } from '../runtime/wakeWriteKeys.js';
 import { CLAUDE_SDK_PROTOCOL } from './claudeSdkProtocol.js';
@@ -7,6 +8,25 @@ import { buildZiggsSdkMcpServer } from './toolManagerToSdkMcp.js';
 import { claudeQueryOptions, buildClaudeEventPrompt, summarizeContext, extractAssistantText, } from './claudeCognition.js';
 import { assertHostedAgentZiggsTools } from './hostedAgentConnection.js';
 import { runtimeLog } from '../shared/runtimeLog.js';
+/**
+ * ZIG-1035 / ZIG-1052: status notices must not spend a Claude turn answering
+ * nobody. Real work wakes arrive as chat `message`, synthetic `task_result`
+ * from `wakeTaskAssignment`, or `agreement_lifecycle` (hire / proposal
+ * resolution — the FSM kickoffs on the same event; Claude must act too).
+ *
+ * Intentionally not mirrored as an FSM "notice skip": the FSM already no-ops
+ * enter-only outcomes in AgentMachine; `agreement_lifecycle` never produces
+ * `enter`, so hire wakes always step. Claude's filter is narrower — pure
+ * `notification` only.
+ *
+ * Empty / missing batch → notice-only (do not burn a turn on a malformed wake).
+ */
+export function isNoticeOnlyWake(event) {
+    const events = getBatchEvents(event);
+    if (events.length === 0)
+        return true;
+    return events.every((ev) => ev?.type === 'notification');
+}
 const DEFAULT_STATE = 'ready';
 /**
  * Per-task turn cap. A wake drives one `query()` that may loop up to this many
@@ -186,6 +206,17 @@ export class ClaudeSdkAgent {
             };
         }
         nextCtx.recentWakes = [...recentWakes, now];
+        if (isNoticeOnlyWake(rawEvent)) {
+            runtimeLog.info('ClaudeSdkAgent', `notice-only wake — skipping LLM session=${identity.sessionId} agent=${this.agentId} ` +
+                `type=${rawEvent?.type ?? 'unknown'}`);
+            return {
+                ctx: nextCtx,
+                state: state ?? DEFAULT_STATE,
+                parked: true,
+                stateTimeoutUnhandled: false,
+                metrics: { llmCalls: 0, tokens: { total: 0, input: 0, output: 0 } },
+            };
+        }
         let contextSnap = null;
         try {
             contextSnap = await eff({

package/dist/agent/claudeCognition.js

@@ -72,12 +72,27 @@ export function summarizeContext(snap) {
 function renderEventLines(event, lines) {
     if (event?.type)
         lines.push(`Event type: ${event.type}`);
-    if (event?.text)
-        lines.push(`Message: ${event.text}`);
+    // ZIG-1035 / ZIG-1052: notifications are not counterparty speech.
+    // agreement_lifecycle is a work signal (hire approval) — label it as such.
+    if (event?.text) {
+        const label = event.type === 'agreement_lifecycle'
+            ? 'Agreement lifecycle'
+            : event.type === 'notification' || event.entryType === 'notification'
+                ? 'Notification'
+                : 'Message';
+        lines.push(`${label}: ${event.text}`);
+    }
     if (event?.senderId)
         lines.push(`Sender: ${event.senderId}`);
     if (event?.operation)
         lines.push(`Operation: ${event.operation}`);
+    if (event?.type === 'agreement_lifecycle' &&
+        (event.operation === 'proposal_approved' || event.operation === 'proposal_approved_execute')) {
+        lines.push('Work signal: proposal approved. If you proposed this agreement, spawn the first task (task_create) under it now. If you are the hired provider, begin fulfilling per the agreement — do not ignore this wake.');
+    }
+    if (typeof event?.agreementId === 'string' && event.agreementId) {
+        lines.push(`Agreement: ${event.agreementId}`);
+    }
     // ZIG-832: surface the task/agreement this event carries. Without it the brain
     // can't tell WHICH task to update/complete (workers otherwise stall asking for
     // their own taskId) and can't see whether the referenced step already ran or

package/dist/agent/claudeSdkTools.js

@@ -47,19 +47,21 @@ export const chatSendTool = defineTool('chat_send', {
     const receiverId = args.receiverId ?? c.senderId;
     if (!receiverId)
         throw new Error('chat_send: receiverId is required (this wake has no sender to default to)');
-    // Default to the wake's replay-stable key: a crash-replay of this wake
-    // re-derives the same messageId and the backend drops the duplicate
-    // (ZIG-718). An explicit LLM idempotencyKey still wins (retry-safe resend
-    // of the same logical message across wakes); random only when the wake has
-    // no durable identity.
+    // Default to the wake's content-derived key (ZIG-1045): a crash-replay that
+    // re-sends the same text re-derives the same messageId and the backend drops
+    // the duplicate (ZIG-718); a re-think with different text gets a new key
+    // instead of colliding on a per-wake ordinal. An explicit LLM idempotencyKey
+    // still wins (retry-safe resend of the same logical message across wakes);
+    // random only when the wake has no durable identity.
+    const text = String(args.text);
     const messageId = args.idempotencyKey
         ? `sdk_idem_${String(args.idempotencyKey)}`
-        : c.wakeKeys?.messageKey() ?? `sdk_${randomUUID()}`;
+        : c.wakeKeys?.messageKey({ text, sessionId, receiverId }) ?? `sdk_${randomUUID()}`;
     return c.eff({
         kind: 'send-message',
         sessionId,
         receiverId,
-        text: String(args.text),
+        text,
         messageId,
     });
 }, { description: 'Send a user-visible chat message. Conversation only — never use for finished-work reporting.' });

package/dist/formatters/HistoryFormatter.js

@@ -24,6 +24,11 @@ export class HistoryFormatter {
             const label = labelTypes ? '[CHAT] ' : '';
             return `${label}${this.formatMessage(entry, agentId, timePrefix)}`;
         }
+        // ZIG-1035: notices are not counterparty turns — no "from → to:" speech framing.
+        if (entryType === 'notification') {
+            const label = labelTypes ? '[NOTICE] ' : '';
+            return `${label}${timePrefix}[notice] ${entry['text'] || ''}`;
+        }
         if (entryType === 'task_history') {
             const label = labelTypes ? '[TASK] ' : '';
             return `${label}${this.formatTaskHistory(entry, agentId, timePrefix)}`;

package/dist/ingress/normalizeIncoming.d.ts

@@ -11,7 +11,14 @@ export interface NormalizedEvent {
          */
         messageId?: string;
         timestamp: number;
-        type: 'task_result' | 'message' | 'agreement_lifecycle';
+        /**
+         * `notification` = lifecycle / status notice (ZIG-1035). Not counterparty
+         * speech; Claude parks without a model turn. Terminal task notices still
+         * use `task_result` so orchestrators see completions.
+         */
+        type: 'task_result' | 'message' | 'agreement_lifecycle' | 'notification';
+        /** Wire `entryType` when present (kept so brains can tell notice vs speech). */
+        entryType?: string;
         operation?: string;
         agreementId?: string;
         result?: unknown;
@@ -57,7 +64,14 @@ interface WireMetadata {
     service?: {
         task?: WireTask;
         operation?: string;
-        agreement?: unknown;
+        agreement?: {
+            agreementId?: string;
+            status?: string;
+            proposal?: {
+                status?: string;
+            };
+            parties?: WireParties;
+        };
         agreementId?: string;
     };
     [key: string]: unknown;
@@ -72,9 +86,9 @@ interface NormalizeArgs {
  * backend policy now (delivery law, phase 4): the inbox loop only ever delivers
  * what is fenced to this agent, so there is no client-side "is this for me"
  * relevance gate — this function decides SHAPE (message vs task_result vs
- * agreement_lifecycle) and the fields the FSM / SessionResolver / wakeWriteKeys
- * depend on, nothing more. `ownAgentId` is accepted for call-site compatibility
- * but no longer gates anything.
+ * agreement_lifecycle vs notification) and the fields the FSM / SessionResolver /
+ * wakeWriteKeys depend on, nothing more. `ownAgentId` is accepted for call-site
+ * compatibility but no longer gates anything.
  */
 export declare function normalizeIncomingEvent({ text, metadata }: NormalizeArgs): NormalizedEvent;
 export {};

package/dist/ingress/normalizeIncoming.js

@@ -19,21 +19,53 @@ function isTaskRelated(metadata, taskData) {
         || contentType === 'task' || contentType === 'task_update'
         || Boolean(taskData.state || taskData.proposal || taskData.parentTaskId || taskData.executorId || taskData.agentId || taskData.payerId || taskData.createdBy));
 }
+function wireOperation(metadata) {
+    const op = metadata.service?.operation ?? metadata.operation;
+    return typeof op === 'string' ? op : undefined;
+}
+function wireAgreementId(metadata) {
+    const raw = metadata.service?.agreementId ??
+        metadata.service?.agreement?.agreementId ??
+        metadata.agreementId;
+    return typeof raw === 'string' ? raw : '';
+}
+/**
+ * Self-hire / fully-consented create activates before the chat fan-out lands.
+ * The wire still says `proposal_created`, but the embedded agreement is already
+ * `active` / proposal `approved`. That is the hire work signal (same as
+ * `proposal_approved_execute`) — Claude must not park it as a notice (ZIG-1052).
+ */
+function isAlreadyActivatedProposalCreated(metadata) {
+    if (wireOperation(metadata) !== 'proposal_created')
+        return false;
+    const agr = metadata.service?.agreement;
+    if (!agr || typeof agr !== 'object')
+        return false;
+    const status = agr.status;
+    const proposalStatus = agr.proposal?.status;
+    return status === 'active' || proposalStatus === 'approved';
+}
 function isAgreementLifecycleNotification(metadata) {
     const entryType = metadata.entryType || 'message';
-    const operation = metadata.service?.operation ?? metadata.operation;
-    return (entryType === 'notification' &&
-        typeof operation === 'string' &&
-        PROPOSAL_RESOLVED_OPERATIONS.has(operation));
+    if (entryType !== 'notification')
+        return false;
+    const operation = wireOperation(metadata);
+    if (typeof operation === 'string' && PROPOSAL_RESOLVED_OPERATIONS.has(operation)) {
+        return true;
+    }
+    return isAlreadyActivatedProposalCreated(metadata);
+}
+function isTerminalTaskState(state) {
+    return state === 'completed' || state === 'failed' || state === 'cancelled';
 }
 /**
  * Classify + shape a wire delivery into a lane-routable event. Targeting is
  * backend policy now (delivery law, phase 4): the inbox loop only ever delivers
  * what is fenced to this agent, so there is no client-side "is this for me"
  * relevance gate — this function decides SHAPE (message vs task_result vs
- * agreement_lifecycle) and the fields the FSM / SessionResolver / wakeWriteKeys
- * depend on, nothing more. `ownAgentId` is accepted for call-site compatibility
- * but no longer gates anything.
+ * agreement_lifecycle vs notification) and the fields the FSM / SessionResolver /
+ * wakeWriteKeys depend on, nothing more. `ownAgentId` is accepted for call-site
+ * compatibility but no longer gates anything.
  */
 export function normalizeIncomingEvent({ text, metadata = {} }) {
     // ZIG-936: classifier data lives under `service` on the inbox-pull wire;
@@ -42,17 +74,22 @@ export function normalizeIncomingEvent({ text, metadata = {} }) {
     const chatId = normalizeChatId(metadata);
     const receiverId = normalizeReceiverId(metadata, taskData);
     const senderType = metadata.sender?.type ? String(metadata.sender.type).toUpperCase() : undefined;
+    const entryType = typeof metadata.entryType === 'string' && metadata.entryType
+        ? metadata.entryType
+        : undefined;
     const base = {
         senderId: metadata.sender?.id,
         senderType,
         receiverId: receiverId || undefined,
         messageId: typeof metadata.messageId === 'string' && metadata.messageId ? metadata.messageId : undefined,
         timestamp: Date.now(),
+        ...(entryType ? { entryType } : {}),
     };
     if (isAgreementLifecycleNotification(metadata)) {
-        const operation = metadata.service?.operation ?? metadata.operation;
-        const rawAgreementId = metadata.service?.agreementId ?? metadata.agreementId;
-        const agreementId = typeof rawAgreementId === 'string' ? rawAgreementId : '';
+        const operation = isAlreadyActivatedProposalCreated(metadata)
+            ? 'proposal_approved_execute'
+            : wireOperation(metadata);
+        const agreementId = wireAgreementId(metadata);
         return {
             chatId,
             event: {
@@ -65,11 +102,42 @@ export function normalizeIncomingEvent({ text, metadata = {} }) {
         };
     }
     if (isTaskRelated(metadata, taskData)) {
+        // ZIG-1035: active/spawn chat notices are not work — real assignment arrives
+        // on the task channel (`tasksAwaitingMe` → wakeTaskAssignment). Keep terminal
+        // task notices as `task_result` so orchestrators still see completions.
+        if (entryType === 'notification' && !isTerminalTaskState(taskData?.state)) {
+            return {
+                chatId,
+                event: {
+                    ...base,
+                    type: 'notification',
+                    result: taskData,
+                    text,
+                    operation: metadata.service?.operation ?? metadata.operation,
+                },
+            };
+        }
         return {
             chatId,
             event: { ...base, type: 'task_result', result: taskData, text },
         };
     }
+    // ZIG-1035: residual lifecycle notices (proposal_created, agreement active, …)
+    // must not fall through as counterparty `message` speech.
+    if (entryType === 'notification') {
+        const operation = metadata.service?.operation ?? metadata.operation;
+        const rawAgreementId = metadata.service?.agreementId ?? metadata.agreementId;
+        return {
+            chatId,
+            event: {
+                ...base,
+                type: 'notification',
+                text,
+                ...(typeof operation === 'string' ? { operation } : {}),
+                ...(typeof rawAgreementId === 'string' ? { agreementId: rawAgreementId } : {}),
+            },
+        };
+    }
     return {
         chatId,
         event: { ...base, type: 'message', text },

package/dist/runtime/AgentMachine.js

@@ -356,9 +356,17 @@ export class AgentMachine {
         if (!userId)
             return;
         try {
-            // Wake-derived messageId: a crash-replay that errors the same way parks
-            // again and re-sends this apology — same key, backend drops the dupe.
-            await this.eff({ kind: 'send-message', sessionId: this.ctx.identity.sessionId, receiverId: userId, text, messageId: this.wakeKeys?.messageKey() });
+            // Content-derived wake messageId (ZIG-1045): a crash-replay that errors
+            // the same way parks again and re-sends this apology — same key, backend
+            // drops the dupe.
+            const sessionId = this.ctx.identity.sessionId;
+            await this.eff({
+                kind: 'send-message',
+                sessionId,
+                receiverId: userId,
+                text,
+                messageId: this.wakeKeys?.messageKey({ text, sessionId, receiverId: userId }),
+            });
         }
         catch { /* best-effort */ }
     }

package/dist/runtime/runTurn.js

@@ -65,7 +65,15 @@ export async function runTurn(input) {
             return eff({ ...effect, runId, stateId, wakeKeys });
         }
         if (effect.kind === 'send-message' && !effect.messageId) {
-            return eff({ ...effect, messageId: wakeKeys?.messageKey() });
+            const send = effect;
+            return eff({
+                ...effect,
+                messageId: wakeKeys?.messageKey({
+                    text: send.text,
+                    sessionId: send.sessionId,
+                    receiverId: send.receiverId,
+                }),
+            });
         }
         return eff(effect);
     };
@@ -316,11 +324,12 @@ export async function runTurn(input) {
             const inboundFromAgent = String(incomingEvent?.senderType || '').toUpperCase() === 'AGENT';
             runtimeLog.info('runTurn', `streaming check: enabled=${streamRespondActions} receiverId=${decision.receiverId ?? 'none'} tool=${actionDef?.tool ?? 'none'} action=${chosenAction} inboundFromAgent=${inboundFromAgent}`);
             if (streamRespondActions && !inboundFromAgent && decision.receiverId && !actionDef?.tool && chosenAction !== 'wait') {
-                // Wake-derived when the wake has a durable identity: a crash-replay
-                // streams and persists under the SAME id, so the backend's
-                // (chatId, messageId) dedup drops the duplicate reply (ZIG-718).
-                const streamMessageId = wakeKeys?.messageKey() ?? crypto.randomUUID();
-                runtimeLog.info('runTurn', `stream-text start action=${chosenAction} receiverId=${decision.receiverId} msgId=${streamMessageId}`);
+                // Live chunks use a provisional id (text not known yet). The persisted
+                // send below switches to a content-derived wake key (ZIG-1045) once the
+                // reply text exists — a crash-replay of the same text reuses that key
+                // (ZIG-718), and a re-think with different text does not collide.
+                const chunkMessageId = crypto.randomUUID();
+                runtimeLog.info('runTurn', `stream-text start action=${chosenAction} receiverId=${decision.receiverId} msgId=${chunkMessageId}`);
                 const streamMessages = [
                     ...messages,
                     {
@@ -334,7 +343,7 @@ export async function runTurn(input) {
                 ];
                 let replyText = '';
                 try {
-                    const streamResult = await eff({ kind: 'stream-text', sessionId, receiverId: decision.receiverId, messageId: streamMessageId, messages: streamMessages });
+                    const streamResult = await eff({ kind: 'stream-text', sessionId, receiverId: decision.receiverId, messageId: chunkMessageId, messages: streamMessages });
                     replyText = streamResult.text ?? '';
                     // Count the streamed reply only when it actually produced the text we
                     // send (an empty resolve falls through to the llm-call fallback below,
@@ -356,6 +365,7 @@ export async function runTurn(input) {
                     // llm-call + send-message below so the user still gets a reply.
                     runtimeLog.error('runTurn', `stream-text failed: ${err.message} — falling back to non-streaming send`);
                 }
+                let persistMessageId = chunkMessageId;
                 try {
                     if (!replyText) {
                         const fallbackResponse = await effWithTrace({ kind: 'llm-call', messages: streamMessages, tools: [], sessionId });
@@ -369,16 +379,20 @@ export async function runTurn(input) {
                             throw new Error('fallback llm-call returned empty reply text');
                     }
                     const safeText = truncateMsg(replyText);
-                    // Reuse streamMessageId so any partial chunks already streamed to
-                    // the client reconcile against the final persisted message.
-                    await eff({ kind: 'send-message', sessionId, receiverId: decision.receiverId, text: safeText, messageId: streamMessageId });
+                    persistMessageId =
+                        wakeKeys?.messageKey({
+                            text: safeText,
+                            sessionId,
+                            receiverId: decision.receiverId,
+                        }) ?? chunkMessageId;
+                    await eff({ kind: 'send-message', sessionId, receiverId: decision.receiverId, text: safeText, messageId: persistMessageId });
                     allEmittedEvents.push({ type: 'message_sent', receiverId: decision.receiverId, chatId: sessionId, message: safeText, senderId: 'system' });
                     lastAction = chosenAction;
                     lastActionDef = actionDef;
                 }
                 catch (err) {
                     if (isReplySlotTaken(err)) {
-                        runtimeLog.warn('runTurn', `reply already persisted under ${streamMessageId} (idempotency 409) — a replay or second host answered this wake first; dropping duplicate`);
+                        runtimeLog.warn('runTurn', `reply already persisted under ${persistMessageId} (idempotency 409) — a replay or second host answered this wake first; dropping duplicate`);
                         allEmittedEvents.push({ type: 'message_duplicate_skipped', receiverId: decision.receiverId, chatId: sessionId, senderId: 'system' });
                         lastAction = chosenAction;
                         lastActionDef = actionDef;

package/dist/runtime/wakeWriteKeys.d.ts

@@ -9,11 +9,13 @@ import type { WakeWriteKeys } from '../types.js';
  * - task transitions: `wk_<wake-hash>_t_<hash(taskId, state)>` — derived from
  *   the transition itself, so it dedups regardless of the order in which the
  *   replayed wake happens to re-issue its tool calls.
- * - chat messages:    `sdk_idem_wk_<wake-hash>_m<ordinal>` — used directly as
- *   the messageId (the backend dedups on (chatId, messageId), ZIG-718), drawn
- *   from the same ordinal stream as artifacts so one counter keys the wake's
- *   whole write sequence. The prefix matches the tool-layer convention for
- *   deterministic ids (`sdk_idem_<llm-key>`).
+ * - chat messages:    `sdk_idem_wk_<wake-hash>_m_<hash(chat, receiver, text)>`
+ *   — used directly as the messageId (the backend dedups on (chatId, messageId),
+ *   ZIG-718). Content-derived (ZIG-1045), not ordinal: a wake may emit several
+ *   distinct messages without colliding, and a crash-replay that re-sends the
+ *   same text reuses the key; a re-think with different text gets a new key
+ *   instead of 409-dropping on the old ordinal slot. The prefix matches the
+ *   tool-layer convention for deterministic ids (`sdk_idem_<llm-key>`).
  * - task spawns:      `wk_<wake-hash>_s_<hash(agreement, description, …)>` —
  *   derived from what the spawn writes, so it dedups regardless of re-issue
  *   order while still distinguishing multiple spawns in one wake.

package/dist/runtime/wakeWriteKeys.js

@@ -78,11 +78,13 @@ function sha(input) {
  * - task transitions: `wk_<wake-hash>_t_<hash(taskId, state)>` — derived from
  *   the transition itself, so it dedups regardless of the order in which the
  *   replayed wake happens to re-issue its tool calls.
- * - chat messages:    `sdk_idem_wk_<wake-hash>_m<ordinal>` — used directly as
- *   the messageId (the backend dedups on (chatId, messageId), ZIG-718), drawn
- *   from the same ordinal stream as artifacts so one counter keys the wake's
- *   whole write sequence. The prefix matches the tool-layer convention for
- *   deterministic ids (`sdk_idem_<llm-key>`).
+ * - chat messages:    `sdk_idem_wk_<wake-hash>_m_<hash(chat, receiver, text)>`
+ *   — used directly as the messageId (the backend dedups on (chatId, messageId),
+ *   ZIG-718). Content-derived (ZIG-1045), not ordinal: a wake may emit several
+ *   distinct messages without colliding, and a crash-replay that re-sends the
+ *   same text reuses the key; a re-think with different text gets a new key
+ *   instead of 409-dropping on the old ordinal slot. The prefix matches the
+ *   tool-layer convention for deterministic ids (`sdk_idem_<llm-key>`).
  * - task spawns:      `wk_<wake-hash>_s_<hash(agreement, description, …)>` —
  *   derived from what the spawn writes, so it dedups regardless of re-issue
  *   order while still distinguishing multiple spawns in one wake.
@@ -107,10 +109,11 @@ export function createWakeWriteKeys(laneKey, event) {
                 return undefined;
             return `wk_${wakeHash}_t_${sha(`${taskId}\n${state}`).slice(0, 16)}`;
         },
-        messageKey() {
+        messageKey(fields) {
             if (wakeHash === null)
                 return undefined;
-            return `sdk_idem_wk_${wakeHash}_m${ordinal++}`;
+            const msgHash = sha(`${fields.sessionId ?? ''}\n${fields.receiverId ?? ''}\n${fields.text}`).slice(0, 16);
+            return `sdk_idem_wk_${wakeHash}_m_${msgHash}`;
         },
         taskSpawnKey(fields) {
             if (wakeHash === null)

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

@@ -1,4 +1,4 @@
-import { type Agreement, 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 CreateAgreementBody, 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,12 +20,14 @@ export declare class AgreementService {
     delegate(payload: DelegateAgreementData): Promise<Agreement>;
     respond(agreementId: string, action: 'approve' | 'reject'): Promise<Agreement>;
     /**
-     * ZIG-1021 — claim any open broadcast (quest, standing offer, link invite).
-     * Routing (offer vs agreement claim endpoint) is decided in the shared flow.
+     * ZIG-1021 — claim any open broadcast (quest, 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).
      */
     claim(agreementId: string): Promise<{
         agreement: Agreement;
-        kind: 'link' | 'offer' | 'quest';
+        kind: ClaimedKind;
     }>;
     /**
      * ZIG-1022 — a link proposal is an agreement (engagementKind 'link') to one

package/dist/server/agreements/AgreementService.js

@@ -38,8 +38,10 @@ export class AgreementService {
         return respondToAgreement(agreementId, action, this.creds);
     }
     /**
-     * ZIG-1021 — claim any open broadcast (quest, standing offer, link invite).
-     * Routing (offer vs agreement claim endpoint) is decided in the shared flow.
+     * ZIG-1021 — claim any open broadcast (quest, 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).
      */
     claim(agreementId) {
         return claimOpenAgreement(agreementId, this.creds);

package/dist/types.d.ts

@@ -389,8 +389,18 @@ export interface WakeWriteKeys {
     artifactKey(): string | undefined;
     /** Key for a task state transition. Derived from (taskId, state), so it is stable regardless of tool-call order within the wake. */
     taskStateKey(taskId: string, state: string): string | undefined;
-    /** Default messageId for the next chat-message send of this wake — the backend dedups on (chatId, messageId). Draws the same per-wake ordinal as artifactKey — call exactly once per send, at the call site. */
-    messageKey(): string | undefined;
+    /**
+     * Default messageId for a chat-message send of this wake — the backend dedups
+     * on (chatId, messageId). Derived from the emission's content (text + chat +
+     * receiver), not a per-wake ordinal (ZIG-1045): a wake that says two things
+     * gets two keys, and a redelivered wake that re-says the same text reuses the
+     * same key, while a re-think with different text does not collide and drop.
+     */
+    messageKey(fields: {
+        text: string;
+        sessionId?: string;
+        receiverId?: string;
+    }): string | undefined;
     /** Key for a task spawn. Derived from what the spawn writes (agreement, description, assignee, parent), so it is stable regardless of tool-call order within the wake. */
     taskSpawnKey(fields: {
         agreementId: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ziggs-ai/agent-sdk",
-  "version": "0.7.1",
+  "version": "0.8.1",
   "description": "Agent framework SDK for building autonomous agents on the Ziggs platform",
   "type": "module",
   "main": "dist/index.js",
@@ -26,7 +26,7 @@
     "@anthropic-ai/claude-agent-sdk": "^0.3.204",
     "@anthropic-ai/sdk": "^0.110.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@ziggs-ai/api-client": "^0.6.1",
+    "@ziggs-ai/api-client": "^0.7.1",
     "ajv": "^8.17.1",
     "dotenv": "^17.2.3",
     "openai": "^4.0.0",