@ziggs-ai/agent-sdk 0.10.0 → 0.10.1

package/dist/agent/ClaudeSdkAgent.js

@@ -1,5 +1,5 @@
 import { query } from '@anthropic-ai/claude-agent-sdk';
-import { outcomeFromEvent } from '../runtime/buildOutcome.js';
+import { isMessageAddressedElsewhere, outcomeFromEvent } from '../runtime/buildOutcome.js';
 import { getBatchEvents } from '../context/batch.js';
 import { bootstrapCtx } from '../runtime/bootstrapCtx.js';
 import { createWakeWriteKeys } from '../runtime/wakeWriteKeys.js';
@@ -20,12 +20,18 @@ import { runtimeLog } from '../shared/runtimeLog.js';
  * `notification` only.
  *
  * Empty / missing batch → notice-only (do not burn a turn on a malformed wake).
+ *
+ * A message addressed to a DIFFERENT party is notice-only too (attention
+ * gate): the sender named who should act, and it wasn't this agent. The
+ * message still lands in chat history and arrives as context on the next
+ * real wake — skipped here is the LLM turn, not the information.
  */
-export function isNoticeOnlyWake(event) {
+export function isNoticeOnlyWake(event, ownAgentId) {
     const events = getBatchEvents(event);
     if (events.length === 0)
         return true;
-    return events.every((ev) => ev?.type === 'notification');
+    return events.every((ev) => ev?.type === 'notification' ||
+        isMessageAddressedElsewhere(ev, ownAgentId));
 }
 const DEFAULT_STATE = 'ready';
 /**
@@ -62,6 +68,20 @@ const MAX_WAKES_PER_WINDOW = Number(process.env.CLAUDE_SDK_MAX_WAKES_PER_WINDOW
  * discard. Env-overridable. Kept below MAX_TASK_INPUT_TOKENS so a lane resets
  * before it can approach the per-wake abort. */
 const MAX_SESSION_RESUME_INPUT_TOKENS = Number(process.env.CLAUDE_SDK_MAX_SESSION_INPUT_TOKENS ?? 200_000);
+/**
+ * ZIG-1191 — "the transcript you asked me to resume is not here".
+ *
+ * Claude Code answers a `resume` of an unknown id with this, and it is the only
+ * failure that a fresh session reliably fixes: the id is valid-looking but its
+ * transcript lived on a container that is gone. Matched on the message because
+ * that is all the CLI gives us — no code, no typed error — so keep it narrow
+ * enough that a different failure never claims the retry.
+ */
+export function isMissingSessionError(err) {
+    const message = err?.message;
+    return (typeof message === 'string' &&
+        /no conversation found with session id/i.test(message));
+}
 /** Total billable input for one API response (base + cache read + cache write). */
 function billableInput(usage) {
     if (!usage)
@@ -164,6 +184,13 @@ export class ClaudeSdkAgent {
     maxTurns;
     statelessPerWake;
     queryFn;
+    /**
+     * ZIG-1120 #7 — tool set is fixed at host construction; rebuilding the
+     * in-process MCP server (+ zod schema tree) every wake was pure waste.
+     * A mutable holder supplies per-wake context without closing over `tick`.
+     */
+    toolContextHolder = { current: null };
+    sdkMcpServer = null;
     constructor(opts) {
         if (!opts.workflow?.states)
             throw new Error('ClaudeSdkAgent: workflow with states is required');
@@ -209,7 +236,7 @@ export class ClaudeSdkAgent {
             };
         }
         nextCtx.recentWakes = [...recentWakes, now];
-        if (isNoticeOnlyWake(rawEvent)) {
+        if (isNoticeOnlyWake(rawEvent, identity.agentId)) {
             runtimeLog.info('ClaudeSdkAgent', `notice-only wake — skipping LLM session=${identity.sessionId} agent=${this.agentId} ` +
                 `type=${rawEvent?.type ?? 'unknown'}`);
             return {
@@ -222,9 +249,13 @@ export class ClaudeSdkAgent {
         }
         let contextSnap = null;
         try {
+            // ZIG-1120 #5: pre-read is for wake gating + summarizeContext (a count) +
+            // onBehalf agreement resolution — same 12-message cap as the tool path.
+            // Uncapped pulls burned 35–47k input tokens/wake on long chats.
             contextSnap = await eff({
                 kind: 'read-context',
                 sessionId: identity.sessionId,
+                opts: { maxMessages: 12 },
             });
         }
         catch (err) {
@@ -287,13 +318,22 @@ export class ClaudeSdkAgent {
             runId,
             wakeKeys,
         };
-        const availableTools = await this.toolManager.getAvailableTools();
-        const mcpServer = buildZiggsSdkMcpServer(availableTools, () => toolContext, {
-            name: 'ziggs',
-            instructions: 'In-process Ziggs tools backed by api-client. No external MCP process.',
-        });
+        this.toolContextHolder.current = toolContext;
+        if (!this.sdkMcpServer) {
+            const availableTools = await this.toolManager.getAvailableTools();
+            this.sdkMcpServer = buildZiggsSdkMcpServer(availableTools, () => {
+                const ctx = this.toolContextHolder.current;
+                if (!ctx) {
+                    throw new Error('ClaudeSdkAgent: tool context missing for in-process MCP call');
+                }
+                return ctx;
+            }, {
+                name: 'ziggs',
+                instructions: 'In-process Ziggs tools backed by api-client. No external MCP process.',
+            });
+        }
         const prompt = buildClaudeEventPrompt(rawEvent, summarizeContext(contextSnap));
-        const mcpServers = { ziggs: mcpServer };
+        const mcpServers = { ziggs: this.sdkMcpServer };
         assertHostedAgentZiggsTools(mcpServers);
         const queryOptions = claudeQueryOptions({
             systemPrompt,
@@ -306,80 +346,110 @@ export class ClaudeSdkAgent {
                 if (line)
                     runtimeLog.warn('ClaudeSdkAgent', `stderr session=${identity.sessionId}: ${line}`);
             },
-            // ZIG-860: stateless-per-wake never resumes — each wake is a fresh
-            // transcript, so per-wake input stays flat instead of replaying the
-            // whole lane history every turn.
-            resume: this.statelessPerWake ? undefined : nextCtx.claudeSessionId,
         });
         let metrics = { llmCalls: 0, tokens: { total: 0, input: 0, output: 0, cacheRead: 0, cacheCreation: 0 } };
         let sessionId = nextCtx.claudeSessionId;
         let spentInput = 0;
-        // Host watchdog abort (see TickInput.signal): stop consuming AND interrupt
-        // the query, so a timed-out wake never lingers as a token-burning zombie
-        // racing its own redelivered retry. Breaking the for-await returns the
-        // generator; interrupt() additionally stops a query blocked mid-turn.
-        const query = this.queryFn({ prompt, options: queryOptions });
-        const onAbort = () => {
-            void query.interrupt?.()?.catch(() => { });
-        };
-        if (signal?.aborted)
-            onAbort();
-        else
-            signal?.addEventListener('abort', onAbort, { once: true });
-        try {
-            for await (const message of query) {
-                if (signal?.aborted) {
-                    runtimeLog.warn('ClaudeSdkAgent', `host watchdog aborted wake session=${identity.sessionId} agent=${this.agentId} — stopping query`);
-                    break;
-                }
-                if ('session_id' in message && typeof message.session_id === 'string') {
-                    sessionId = message.session_id;
-                }
-                // Surface the model's own prose so a hired Claude agent is as legible as
-                // an FSM agent (ZIG-787). Each completed assistant turn's text is recorded
-                // as a `thought` — the SAME agent-private channel the FSM uses for its
-                // reasoning (runTurn `emitThought` → record-event → recordThought), so it
-                // shows in the hired-agent view without cluttering the counterparty chat.
-                // Pure tool-use turns carry no text and record nothing.
-                //
-                // Fire-and-forget on purpose: this runs inside `for await (query())`, so
-                // awaiting an artifacts round-trip per turn would couple model-stream
-                // consumption to the artifacts backend — a slow/wedged backend would stall
-                // the whole wake, not just fail a breadcrumb. Recording is best-effort and
-                // thought ordering is not load-bearing, so we let it run in the background
-                // and swallow failures with a warn.
-                if (message.type === 'assistant') {
-                    const text = extractAssistantText(message).trim();
-                    if (text) {
-                        // Ordinal drawn synchronously so the fire-and-forget below can't
-                        // reorder key assignment against other writes of this wake.
-                        const idempotencyKey = wakeKeys.artifactKey({ kind: 'thought', text });
-                        void eff({ kind: 'record-event', sessionId: identity.sessionId, entry: { kind: 'thought', text }, idempotencyKey })
-                            .catch((err) => runtimeLog.warn('ClaudeSdkAgent', `record thought failed session=${identity.sessionId}: ${err.message}`));
+        // ZIG-860: stateless-per-wake never resumes — each wake is a fresh
+        // transcript, so per-wake input stays flat instead of replaying the whole
+        // lane history every turn.
+        const resumeId = this.statelessPerWake ? undefined : nextCtx.claudeSessionId;
+        const consumeQuery = async (resume) => {
+            // Host watchdog abort (see TickInput.signal): stop consuming AND interrupt
+            // the query, so a timed-out wake never lingers as a token-burning zombie
+            // racing its own redelivered retry. Breaking the for-await returns the
+            // generator; interrupt() additionally stops a query blocked mid-turn.
+            const query = this.queryFn({ prompt, options: { ...queryOptions, resume } });
+            const onAbort = () => {
+                void query.interrupt?.()?.catch(() => { });
+            };
+            if (signal?.aborted)
+                onAbort();
+            else
+                signal?.addEventListener('abort', onAbort, { once: true });
+            try {
+                for await (const message of query) {
+                    if (signal?.aborted) {
+                        runtimeLog.warn('ClaudeSdkAgent', `host watchdog aborted wake session=${identity.sessionId} agent=${this.agentId} — stopping query`);
+                        break;
+                    }
+                    if ('session_id' in message && typeof message.session_id === 'string') {
+                        sessionId = message.session_id;
+                    }
+                    // Surface the model's own prose so a hired Claude agent is as legible as
+                    // an FSM agent (ZIG-787). Each completed assistant turn's text is recorded
+                    // as a `thought` — the SAME agent-private channel the FSM uses for its
+                    // reasoning (runTurn `emitThought` → record-event → recordThought), so it
+                    // shows in the hired-agent view without cluttering the counterparty chat.
+                    // Pure tool-use turns carry no text and record nothing.
+                    //
+                    // Fire-and-forget on purpose: this runs inside `for await (query())`, so
+                    // awaiting an artifacts round-trip per turn would couple model-stream
+                    // consumption to the artifacts backend — a slow/wedged backend would stall
+                    // the whole wake, not just fail a breadcrumb. Recording is best-effort and
+                    // thought ordering is not load-bearing, so we let it run in the background
+                    // and swallow failures with a warn.
+                    if (message.type === 'assistant') {
+                        const text = extractAssistantText(message).trim();
+                        if (text) {
+                            // Ordinal drawn synchronously so the fire-and-forget below can't
+                            // reorder key assignment against other writes of this wake.
+                            const idempotencyKey = wakeKeys.artifactKey({ kind: 'thought', text });
+                            void eff({ kind: 'record-event', sessionId: identity.sessionId, entry: { kind: 'thought', text }, idempotencyKey })
+                                .catch((err) => runtimeLog.warn('ClaudeSdkAgent', `record thought failed session=${identity.sessionId}: ${err.message}`));
+                        }
+                    }
+                    const m = extractMetrics(message);
+                    if (m)
+                        metrics = m;
+                    if (message.type === 'result' && message.subtype !== 'success') {
+                        runtimeLog.warn('ClaudeSdkAgent', `query ended without success subtype=${message.subtype} session=${identity.sessionId}`);
+                    }
+                    // Runaway guard (ZIG-759): abort before an unbounded loop drains the
+                    // shared fleet key. Breaking the for-await calls the generator's return(),
+                    // which terminates the underlying query.
+                    spentInput += billableInput(usageOf(message));
+                    if (spentInput > MAX_TASK_INPUT_TOKENS) {
+                        runtimeLog.warn('ClaudeSdkAgent', `input-token budget exceeded (~${spentInput} > ${MAX_TASK_INPUT_TOKENS}) session=${identity.sessionId} agent=${this.agentId} — aborting query to cap spend (ZIG-759)`);
+                        break;
                     }
                 }
-                const m = extractMetrics(message);
-                if (m)
-                    metrics = m;
-                if (message.type === 'result' && message.subtype !== 'success') {
-                    runtimeLog.warn('ClaudeSdkAgent', `query ended without success subtype=${message.subtype} session=${identity.sessionId}`);
-                }
-                // Runaway guard (ZIG-759): abort before an unbounded loop drains the
-                // shared fleet key. Breaking the for-await calls the generator's return(),
-                // which terminates the underlying query.
-                spentInput += billableInput(usageOf(message));
-                if (spentInput > MAX_TASK_INPUT_TOKENS) {
-                    runtimeLog.warn('ClaudeSdkAgent', `input-token budget exceeded (~${spentInput} > ${MAX_TASK_INPUT_TOKENS}) session=${identity.sessionId} agent=${this.agentId} — aborting query to cap spend (ZIG-759)`);
-                    break;
-                }
             }
+            finally {
+                signal?.removeEventListener('abort', onAbort);
+            }
+        };
+        try {
+            await consumeQuery(resumeId);
         }
         catch (err) {
-            runtimeLog.warn('ClaudeSdkAgent', `query failed session=${identity.sessionId}: ${err.message}`);
-            throw err;
-        }
-        finally {
-            signal?.removeEventListener('abort', onAbort);
+            // ZIG-1191: the resumed transcript is gone. Claude Code stores transcripts
+            // on the container's own disk while the session id outlives it — persisted
+            // per lane in the session store with a 24h TTL — so a redeployed agents
+            // task inherits an id pointing at a file that no longer exists. Every wake
+            // on that lane then failed identically for as long as the TTL held, and the
+            // human saw one "Something went wrong. Please try again." per attempt.
+            //
+            // Retrying here is safe precisely because this failure happens BEFORE any
+            // turn runs: nothing was emitted, no tool ran, no idempotency ordinal was
+            // spent. That is why the retry is scoped to this one error and to one
+            // attempt — a mid-wake failure must keep propagating, since its partial
+            // writes are already out.
+            if (!isMissingSessionError(err) || !resumeId) {
+                runtimeLog.warn('ClaudeSdkAgent', `query failed session=${identity.sessionId}: ${err.message}`);
+                throw err;
+            }
+            runtimeLog.info('ClaudeSdkAgent', `resumed Claude session ${resumeId} no longer exists (container replaced?) ` +
+                `session=${identity.sessionId} agent=${this.agentId} — retrying once on a fresh session (ZIG-1191)`);
+            nextCtx.claudeSessionId = undefined;
+            sessionId = undefined;
+            try {
+                await consumeQuery(undefined);
+            }
+            catch (retryErr) {
+                runtimeLog.warn('ClaudeSdkAgent', `query failed session=${identity.sessionId}: ${retryErr.message}`);
+                throw retryErr;
+            }
         }
         // Stateless-per-wake keeps no session id — clear any carried over from the
         // prior ctx so the next wake starts fresh too (ZIG-860). Otherwise remember

package/dist/context/applyEffects.js

@@ -21,10 +21,11 @@ function applyTaskOperationResultToContext(updates, operation, result) {
         }
     }
     if (operation === 'task-update') {
-        const status = (task?.['state'] || r['state'] || r['status']);
-        if (status === 'completed')
+        // `state` only — ZIG-1057 cut `status` from the wire (ZIG-1128).
+        const state = (task?.['state'] || r['state']);
+        if (state === 'completed')
             updates['taskCompleted'] = true;
-        if (status === 'failed')
+        if (state === 'failed')
             updates['taskFailed'] = true;
     }
     if (operation === 'agreement-respond')

package/dist/index.d.ts

@@ -41,7 +41,6 @@ export { default } from './AgentHost.js';
 export { validateContext, ContextWarning } from './cognition/validateContext.js';
 export { runLauncher } from './server/runLauncher.js';
 export { ConnectionPool } from './server/ConnectionPool.js';
-export { createStaleBacklogGate, resolveReplayPolicy, newestActionableAt, parseReplayMaxAge, } from './server/staleBacklogGate.js';
 export { decodeOperatorKeyClaims, boundKeyFleetWarning } from './shared/operatorKeyClaims.js';
 export { createHealthServer } from './server/createHealthServer.js';
 export { TaskService } from './server/tasks/TaskService.js';
@@ -55,6 +54,8 @@ export { OpenAIAdapter } from './adapters/OpenAIAdapter.js';
 export { extractJSON, safeParseJSON } from './utils/jsonExtractor.js';
 export { HistoryFormatter, historyFormatter, AgreementFormatter, agreementFormatter } from './formatters/index.js';
 export { ProactiveTrigger } from './server/proactive/ProactiveTrigger.js';
+export { PollRegistry, declaredPolls, type PollBinding, type PollContext, type PollKind, type PollResult, } from './server/polls/PollKind.js';
+export { PollRunner, type PollRunnerOptions, type WakeTarget } from './server/polls/PollRunner.js';
 export { PROTOCOL_TOOLS, agreementProposeTool, agreementSubcontractTool, agreementRespondTool, agreementClaimTool, agreementCounterTool, agreementGetTool, agreementRevokeTool, agreementFulfillTool, taskCreateTool, taskSetResultTool, taskUpdatePlanStepTool, dispatchProtocolOp, PAYMENT_TOOLS, paymentBalanceTool, paymentTransferTool, paymentHoldTool, paymentReleaseTool, paymentResolveWalletTool, CONNECTION_TOOLS, connectionProxyTool, connectionListGrantsTool, requestConnectionTool, DISCOVERY_TOOLS, agentSearchTool, agentGetTool, MARKETPLACE_TOOLS, marketplaceViewTool, CONTEXT_TOOLS, contextReadTool, contextDelegateTool, contextExpandReachTool, contextDiscoverGrantableTool, GRANTS_TOOLS, listGrantsTool, LINK_TOOLS, linkCreateInviteTool, linkListTool, ARTIFACT_TOOLS, recordArtifactTool, CHAT_TOOLS, openConversationTool, } from './server/tools/index.js';
 export { CLAUDE_SDK_TOOLS } from './agent/claudeSdkTools.js';
 export { PROTOCOL_TOOL_NAMES, PROTOCOL_TOOL_TO_OPERATION, mapProtocolToolToOperation, isProtocolToolName } from './tasks/protocolRegistry.js';
@@ -65,7 +66,7 @@ export { classifyIncomingEvent } from './context/classifyEnvelope.js';
 export { buildContextUpdates, CONTEXT_RESET } from './context/applyEffects.js';
 export { getBatchEvents, isTaskResultRelevantToAgent } from './context/batch.js';
 export { classifyWorkflowEvent, findTaskResult, unwrapBatchEvent, findIncomingTaskResult } from './context/routingLabels.js';
-export { MessagesClient, ArtifactsClient, AgentSearchClient, getBackendUrl, getWebSocketUrl, } from '@ziggs-ai/api-client';
+export { MessagesClient, ArtifactsClient, AgentSearchClient, getBackendUrl, } from '@ziggs-ai/api-client';
 export { SeenMessages } from './server/SeenMessages.js';
 export { runtimeLog, resetRuntimeLogLevelCache } from './shared/runtimeLog.js';
 export type { RuntimeLogLevel } from './shared/runtimeLog.js';

package/dist/index.js

@@ -35,7 +35,6 @@ export { default } from './AgentHost.js';
 export { validateContext, ContextWarning } from './cognition/validateContext.js';
 export { runLauncher } from './server/runLauncher.js';
 export { ConnectionPool } from './server/ConnectionPool.js';
-export { createStaleBacklogGate, resolveReplayPolicy, newestActionableAt, parseReplayMaxAge, } from './server/staleBacklogGate.js';
 export { decodeOperatorKeyClaims, boundKeyFleetWarning } from './shared/operatorKeyClaims.js';
 export { createHealthServer } from './server/createHealthServer.js';
 export { TaskService } from './server/tasks/TaskService.js';
@@ -48,6 +47,8 @@ export { OpenAIAdapter } from './adapters/OpenAIAdapter.js';
 export { extractJSON, safeParseJSON } from './utils/jsonExtractor.js';
 export { HistoryFormatter, historyFormatter, AgreementFormatter, agreementFormatter } from './formatters/index.js';
 export { ProactiveTrigger } from './server/proactive/ProactiveTrigger.js';
+export { PollRegistry, declaredPolls, } from './server/polls/PollKind.js';
+export { PollRunner } from './server/polls/PollRunner.js';
 // ZIG-894 — the hand-rolled ZiggsPayClient / ZiggsConnectClient were deleted;
 // payment and connection tools now use @ziggs-ai/api-client's PaymentsClient /
 // ConnectionsClient, the same clients ziggs-mcp uses.
@@ -70,6 +71,6 @@ export { classifyIncomingEvent } from './context/classifyEnvelope.js';
 export { buildContextUpdates, CONTEXT_RESET } from './context/applyEffects.js';
 export { getBatchEvents, isTaskResultRelevantToAgent } from './context/batch.js';
 export { classifyWorkflowEvent, findTaskResult, unwrapBatchEvent, findIncomingTaskResult } from './context/routingLabels.js';
-export { MessagesClient, ArtifactsClient, AgentSearchClient, getBackendUrl, getWebSocketUrl, } from '@ziggs-ai/api-client';
+export { MessagesClient, ArtifactsClient, AgentSearchClient, getBackendUrl, } from '@ziggs-ai/api-client';
 export { SeenMessages } from './server/SeenMessages.js';
 export { runtimeLog, resetRuntimeLogLevelCache } from './shared/runtimeLog.js';

package/dist/runtime/bootstrapCtx.js

@@ -18,14 +18,15 @@ import { migrateLegacyTaskFields } from './taskBookkeeping.js';
 export function bootstrapCtx(identity, existing) {
     if (existing) {
         const legacy = existing;
+        // ZIG-1128: the lane-level mirrors are destructured OFF, not carried through.
+        // `migrateLegacyTaskFields` has already folded whatever they held into
+        // `tasks`; keeping the empty husks on the restored Ctx is what let a live FSM
+        // guard read one and see "nothing delegated" forever.
+        const { pendingSubtasks: _pendingSubtasks, collectedResults: _collectedResults, delegatedAgreementIds: _delegatedAgreementIds, ...rest } = existing;
         return {
-            ...existing,
+            ...rest,
             identity,
             tasks: migrateLegacyTaskFields(legacy),
-            // ZIG-1057: deprecated mirrors stay empty; use all*() readers.
-            pendingSubtasks: {},
-            collectedResults: [],
-            delegatedAgreementIds: [],
         };
     }
     return {
@@ -34,9 +35,6 @@ export function bootstrapCtx(identity, existing) {
         activeAgreementId: null,
         activeTaskId: null,
         pendingProposalAgreementId: null,
-        pendingSubtasks: {},
-        collectedResults: [],
-        delegatedAgreementIds: [],
         toolResults: [],
         lastOutcome: { kind: 'enter' },
     };

package/dist/runtime/buildOutcome.d.ts

@@ -3,7 +3,6 @@ import type { Action, AgreementRef, Ctx, Outcome, TaskRef, ToolResultEntry } fro
 export interface WireResult {
     taskId?: string;
     state?: string;
-    status?: string;
     agreement?: AgreementRef;
     agreementId?: string;
     proposal?: {
@@ -37,6 +36,15 @@ export interface EmittedEvent {
     senderId?: string;
     [key: string]: unknown;
 }
+/**
+ * A chat message whose stated receiver is a DIFFERENT party. `receiverId` is
+ * the sender's addressing decision, carried on every wire frame; the
+ * human-broadcast sentinel counts as "elsewhere" for an agent (a broadcast is
+ * addressed to the room's humans). A frame with NO receiver keeps the turn —
+ * we cannot know it is not ours, and skipping on absence would deafen agents
+ * to malformed or legacy frames.
+ */
+export declare function isMessageAddressedElsewhere(ev: RawEvent | null | undefined, ownAgentId: string | null | undefined): boolean;
 /**
  * Converts a raw incoming event into the single Outcome that re-enters the
  * machine.

package/dist/runtime/buildOutcome.js

@@ -1,6 +1,21 @@
 import { isProtocolToolName, mapProtocolToolToOperation } from '../tasks/protocolRegistry.js';
 import { getBatchEvents, isTaskResultRelevantToAgent } from '../context/batch.js';
 import { bookForDelegation, ensureTaskBook, findBookHoldingPending, removeTaskBook, } from './taskBookkeeping.js';
+/**
+ * A chat message whose stated receiver is a DIFFERENT party. `receiverId` is
+ * the sender's addressing decision, carried on every wire frame; the
+ * human-broadcast sentinel counts as "elsewhere" for an agent (a broadcast is
+ * addressed to the room's humans). A frame with NO receiver keeps the turn —
+ * we cannot know it is not ours, and skipping on absence would deafen agents
+ * to malformed or legacy frames.
+ */
+export function isMessageAddressedElsewhere(ev, ownAgentId) {
+    return Boolean(ev &&
+        ev.type === 'message' &&
+        ownAgentId &&
+        ev.receiverId &&
+        ev.receiverId !== ownAgentId);
+}
 // ── outcomeFromEvent: incoming wire event → Outcome ──────────────────────────
 /**
  * Converts a raw incoming event into the single Outcome that re-enters the
@@ -139,6 +154,14 @@ function singleEventToOutcome(ev, ownAgentId) {
     // Suppress our own messages echoed back through the chat fanout.
     if (ownAgentId && ev.senderId && ev.senderId === ownAgentId)
         return null;
+    // Attention gate: a message addressed to someone else is room context, not
+    // a turn. Delivery is audience-based on purpose (everyone in the chat hears
+    // everything), so in a multi-agent room every agent used to burn an LLM turn
+    // per utterance just to decide it wasn't theirs — the sender already decided
+    // that by naming a receiver. The message still lands in chat history and
+    // rides in on the next wake's read-back; nothing is lost but the interrupt.
+    if (isMessageAddressedElsewhere(ev, ownAgentId))
+        return null;
     const text = typeof ev.text === 'string' ? ev.text : undefined;
     const senderType = typeof ev.senderType === 'string' ? ev.senderType : undefined;
     return { kind: 'message-received', text, senderId: ev.senderId, senderType };
@@ -286,8 +309,9 @@ function inferKindFromProtocolOp(op, result) {
         return 'task-delegated';
     }
     if (op === 'task-update') {
-        const status = task?.state || r.state || r.status;
-        if (status === 'completed' || status === 'failed')
+        // Same resolution as `isStateChangingProtocolEvent` above — `state` only.
+        const state = task?.state || r.state;
+        if (state === 'completed' || state === 'failed')
             return 'task-closed';
         return 'tool-result';
     }
@@ -462,10 +486,9 @@ export function applyOutcomeToCtx(ctx, outcome) {
         }
         case 'task-closed': {
             // Clear only this task's entry — sibling open tasks keep their books (ZIG-977).
-            const closedId = outcome.taskId ||
-                outcome.result?.task?.taskId ||
-                outcome.result?.taskId ||
-                ctx.activeTaskId;
+            // ZIG-1171: buildOutcomeOfKind already collapses result.task.taskId /
+            // result.taskId into outcome.taskId — do not re-walk the raw result here.
+            const closedId = outcome.taskId || ctx.activeTaskId;
             if (closedId)
                 removeTaskBook(ctx, closedId);
             else {

package/dist/runtime/taskIntake.js

@@ -49,9 +49,10 @@ export function buildTaskIntakeState(initial) {
                 // Function form so a failed task_set_result surfaces as an error outcome
                 // (→ dflt error transition) instead of a phantom task-closed.
                 produces: (result) => {
+                    // `state` only — ZIG-1057 cut `status` from the wire (ZIG-1128).
                     const r = result;
-                    const status = r?.task?.state ?? r?.state ?? r?.status;
-                    return status === 'completed' || status === 'failed' ? 'task-closed' : 'error';
+                    const state = r?.task?.state ?? r?.state;
+                    return state === 'completed' || state === 'failed' ? 'task-closed' : 'error';
                 },
                 terminatesLoop: true,
             },
@@ -63,9 +64,10 @@ export function buildTaskIntakeState(initial) {
                 },
                 tool: 'task_set_result',
                 produces: (result) => {
+                    // `state` only — ZIG-1057 cut `status` from the wire (ZIG-1128).
                     const r = result;
-                    const status = r?.task?.state ?? r?.state ?? r?.status;
-                    return status === 'completed' || status === 'failed' ? 'task-closed' : 'error';
+                    const state = r?.task?.state ?? r?.state;
+                    return state === 'completed' || state === 'failed' ? 'task-closed' : 'error';
                 },
                 terminatesLoop: true,
             },

package/dist/runtime/wakeWriteKeys.js

@@ -97,6 +97,13 @@ export function createWakeWriteKeys(laneKey, event) {
     const identity = eventIdentity(event);
     const wakeHash = identity === null ? null : sha(`${laneKey}\n${identity}`).slice(0, 40);
     let ordinal = 0;
+    // ZIG-1171: one content-hash builder; tags differ, the shape does not.
+    const keyed = (tag, material, opts) => {
+        if (wakeHash === null)
+            return undefined;
+        const body = `wk_${wakeHash}_${tag}_${sha(material).slice(0, 16)}`;
+        return opts?.asMessageId ? `sdk_idem_${body}` : body;
+    };
     return {
         wakeKey: wakeHash === null ? null : `wk_${wakeHash}`,
         artifactKey(content) {
@@ -110,37 +117,23 @@ export function createWakeWriteKeys(laneKey, event) {
             // agent like agent-definer. Callers without content keep the ordinal.
             if (content === undefined)
                 return `wk_${wakeHash}_a${ordinal++}`;
-            const contentHash = sha(typeof content === 'string' ? content : JSON.stringify(content) ?? '').slice(0, 16);
-            return `wk_${wakeHash}_a_${contentHash}`;
+            const material = typeof content === 'string' ? content : JSON.stringify(content) ?? '';
+            return keyed('a', material);
         },
         taskStateKey(taskId, state) {
-            if (wakeHash === null)
-                return undefined;
-            return `wk_${wakeHash}_t_${sha(`${taskId}\n${state}`).slice(0, 16)}`;
+            return keyed('t', `${taskId}\n${state}`);
         },
         messageKey(fields) {
-            if (wakeHash === null)
-                return undefined;
-            const msgHash = sha(`${fields.sessionId ?? ''}\n${fields.receiverId ?? ''}\n${fields.text}`).slice(0, 16);
-            return `sdk_idem_wk_${wakeHash}_m_${msgHash}`;
+            return keyed('m', `${fields.sessionId ?? ''}\n${fields.receiverId ?? ''}\n${fields.text}`, { asMessageId: true });
         },
         taskSpawnKey(fields) {
-            if (wakeHash === null)
-                return undefined;
-            const spawnHash = sha(`${fields.agreementId}\n${fields.description}\n${fields.assigneeId ?? ''}\n${fields.parentTaskId ?? ''}`).slice(0, 16);
-            return `wk_${wakeHash}_s_${spawnHash}`;
+            return keyed('s', `${fields.agreementId}\n${fields.description}\n${fields.assigneeId ?? ''}\n${fields.parentTaskId ?? ''}`);
         },
         agreementProposeKey(fields) {
-            if (wakeHash === null)
-                return undefined;
-            const proposeHash = sha(`${fields.proposedTo}\n${fields.providerId ?? ''}\n${fields.description}\n${fields.parentAgreementId ?? ''}`).slice(0, 16);
-            return `wk_${wakeHash}_ap_${proposeHash}`;
+            return keyed('ap', `${fields.proposedTo}\n${fields.providerId ?? ''}\n${fields.description}\n${fields.parentAgreementId ?? ''}`);
         },
         agreementSubcontractKey(fields) {
-            if (wakeHash === null)
-                return undefined;
-            const subHash = sha(`${fields.executorId}\n${fields.description}\n${fields.parentAgreementId}`).slice(0, 16);
-            return `wk_${wakeHash}_asc_${subHash}`;
+            return keyed('asc', `${fields.executorId}\n${fields.description}\n${fields.parentAgreementId}`);
         },
     };
 }