@ziggs-ai/agent-sdk 0.7.1 → 0.7.2

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,21 @@ 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: lifecycle / status notices must not spend a Claude turn answering
+ * nobody. Real work wakes arrive as chat `message` or as synthetic `task_result`
+ * from `wakeTaskAssignment` (task channel). Terminal task_result notices still
+ * run so orchestrators can consume completions.
+ */
+function isNoticeOnlyWake(event) {
+    const events = getBatchEvents(event);
+    if (events.length === 0)
+        return false;
+    return events.every((ev) => {
+        const t = ev?.type;
+        return t === 'notification' || t === 'agreement_lifecycle';
+    });
+}
 const DEFAULT_STATE = 'ready';
 /**
  * Per-task turn cap. A wake drives one `query()` that may loop up to this many
@@ -186,6 +202,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,8 +72,13 @@ 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: lifecycle notices are events, not counterparty speech.
+    if (event?.text) {
+        const notice = event.type === 'notification' ||
+            event.type === 'agreement_lifecycle' ||
+            event.entryType === 'notification';
+        lines.push(`${notice ? 'Notification' : 'Message'}: ${event.text}`);
+    }
     if (event?.senderId)
         lines.push(`Sender: ${event.senderId}`);
     if (event?.operation)

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;
@@ -72,9 +79,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

@@ -26,14 +26,17 @@ function isAgreementLifecycleNotification(metadata) {
         typeof operation === 'string' &&
         PROPOSAL_RESOLVED_OPERATIONS.has(operation));
 }
+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,12 +45,16 @@ 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;
@@ -65,11 +72,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/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.7.2",
   "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.6.3",
     "ajv": "^8.17.1",
     "dotenv": "^17.2.3",
     "openai": "^4.0.0",