@ziggs-ai/agent-sdk 0.10.0 → 0.10.2

package/dist/agent/ClaudeSdkAgent.js

@@ -1,8 +1,8 @@
 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';
+import { createDeliveryWriteKeys } from '../runtime/deliveryWriteKeys.js';
 import { CLAUDE_SDK_PROTOCOL } from './claudeSdkProtocol.js';
 import { buildZiggsSdkMcpServer } from './toolManagerToSdkMcp.js';
 import { claudeQueryOptions, buildClaudeEventPrompt, summarizeContext, extractAssistantText, } from './claudeCognition.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');
@@ -195,11 +222,11 @@ export class ClaudeSdkAgent {
         const nextCtx = bootstrapCtx(identity, ctx);
         nextCtx.lastOutcome = outcomeFromEvent(rawEvent ?? null, identity.agentId);
         const now = Date.now();
-        const recentWakes = (nextCtx.recentWakes ?? []).filter((t) => now - t < WAKE_WINDOW_MS);
-        if (recentWakes.length >= MAX_WAKES_PER_WINDOW) {
-            runtimeLog.warn('ClaudeSdkAgent', `wake-rate breaker tripped: ${recentWakes.length} wakes in ${WAKE_WINDOW_MS / 60_000}min ` +
+        const recentDeliveries = (nextCtx.recentDeliveries ?? []).filter((t) => now - t < WAKE_WINDOW_MS);
+        if (recentDeliveries.length >= MAX_WAKES_PER_WINDOW) {
+            runtimeLog.warn('ClaudeSdkAgent', `wake-rate breaker tripped: ${recentDeliveries.length} wakes in ${WAKE_WINDOW_MS / 60_000}min ` +
                 `session=${identity.sessionId} agent=${this.agentId} — skipping LLM for this wake`);
-            nextCtx.recentWakes = recentWakes;
+            nextCtx.recentDeliveries = recentDeliveries;
             return {
                 ctx: nextCtx,
                 state: state ?? DEFAULT_STATE,
@@ -208,8 +235,8 @@ export class ClaudeSdkAgent {
                 metrics: { llmCalls: 0, tokens: { total: 0, input: 0, output: 0 } },
             };
         }
-        nextCtx.recentWakes = [...recentWakes, now];
-        if (isNoticeOnlyWake(rawEvent)) {
+        nextCtx.recentDeliveries = [...recentDeliveries, now];
+        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) {
@@ -265,12 +296,14 @@ export class ClaudeSdkAgent {
             this.rolePrompt,
             this.specialization ? `Specialization: ${this.specialization}` : '',
         ].filter(Boolean).join('\n');
-        const systemPrompt = `${CLAUDE_SDK_PROTOCOL}\n\n${roleBlock}`;
+        // Two blocks, not one string: the shared protocol first so its cache prefix
+        // is reachable by every hosted agent, this agent's role second (ZIG-788).
+        const systemPrompt = [CLAUDE_SDK_PROTOCOL, roleBlock];
         const runId = crypto.randomUUID();
         // Replay-stable write keys for this wake (runId is random and can't serve):
         // a crash-replay of the same event derives the same keys, so the backend
         // drops the duplicate artifacts / no-ops the repeated task transitions.
-        const wakeKeys = createWakeWriteKeys(identity.laneKey, rawEvent);
+        const writeKeys = createDeliveryWriteKeys(identity.laneKey, rawEvent);
         const toolContext = {
             operatorKey: this.operatorKey,
             agentId: this.agentId,
@@ -285,15 +318,24 @@ export class ClaudeSdkAgent {
             // not just task_result events — see resolveOnBehalfAgreementId.
             onBehalfOfAgreementId: resolveOnBehalfAgreementId(rawEvent, contextSnap, this.agentId, identity.sessionId),
             runId,
-            wakeKeys,
+            writeKeys,
         };
-        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 +348,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 = writeKeys.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/agent/claudeCognition.d.ts

@@ -11,11 +11,15 @@
  * it MUST be applied on every Claude-brain wake. Centralizing it here means a
  * caller cannot silently drift from it.
  */
-import type { Options, SDKAssistantMessage } from '@anthropic-ai/claude-agent-sdk';
+import { type Options, type SDKAssistantMessage } from '@anthropic-ai/claude-agent-sdk';
 import type { RawEvent } from '../runtime/buildOutcome.js';
 export interface ClaudeQueryOptionsParams {
-    /** Protocol + role system prompt. */
-    systemPrompt: string;
+    /**
+     * The system prompt in cache-ordered blocks: the shared protocol first, then
+     * this agent's role. Both are stable across wakes — see
+     * {@link claudeQueryOptions} for why that matters.
+     */
+    systemPrompt: string[];
     /** Claude model id for the brain. */
     model: string;
     /** In-process MCP servers exposing the agent's tools (e.g. `{ ziggs }`). */
@@ -47,6 +51,24 @@ export declare function resolveClaudeModel(preferred?: string, servicesModel?: s
  * Build the `query()` options for a Claude-brain wake. The lockdown fields are
  * fixed here; callers only supply the per-wake variables (prompt, model, tools,
  * turn budget, resume). Returns `Options` so it drops straight into `query()`.
+ *
+ * ZIG-788 — prompt caching. The system prompt is handed over as blocks with a
+ * trailing `SYSTEM_PROMPT_DYNAMIC_BOUNDARY`: everything before the marker is
+ * eligible for cross-session caching, and there is nothing after it because
+ * nothing in this prompt varies per wake. Every per-wake input — the event, the
+ * context digest — is in the user prompt (`buildClaudeEventPrompt`), which sits
+ * after the cached prefix and cannot invalidate it.
+ *
+ * Cross-SESSION is the point, not cross-turn: `statelessPerWake` starts a fresh
+ * transcript on every wake, so without this the identical prefix was re-read at
+ * full price on each one.
+ *
+ * Caching is a prefix match, so block ORDER decides how far the hit reaches:
+ * the protocol block is byte-identical for every hosted agent and goes first,
+ * the role block is per-agent and goes second. An agent whose combined prompt
+ * lands under the model's minimum cacheable prefix (~1k tokens on Sonnet, more
+ * on Haiku) simply writes no entry — that is a silent no-op, not an error, so
+ * read `cacheRead`/`cacheCreation` in the wake metrics rather than assuming.
  */
 export declare function claudeQueryOptions(params: ClaudeQueryOptionsParams): Options;
 /**

package/dist/agent/claudeCognition.js

@@ -1,3 +1,17 @@
+/**
+ * Shared Claude-Agent-SDK cognition pieces.
+ *
+ * Everything a Claude-brain agent needs to turn a Ziggs wake into a `query()`
+ * call, EXCEPT the loop itself. `ClaudeSdkAgent` owns the loop (drive `query()`,
+ * collect metrics); this module owns the periphery so it lives in one place and
+ * is unit-testable without spinning up the SDK.
+ *
+ * The lockdown option set (`tools: []`, `strictMcpConfig`, `settingSources: []`,
+ * bypass permissions, no local settings) is a security boundary, not a default —
+ * it MUST be applied on every Claude-brain wake. Centralizing it here means a
+ * caller cannot silently drift from it.
+ */
+import { SYSTEM_PROMPT_DYNAMIC_BOUNDARY, } from '@anthropic-ai/claude-agent-sdk';
 import { getBatchEvents } from '../context/batch.js';
 const DEFAULT_CLAUDE_MODEL = 'claude-sonnet-4-6';
 /**
@@ -17,10 +31,28 @@ export function resolveClaudeModel(preferred, servicesModel) {
  * Build the `query()` options for a Claude-brain wake. The lockdown fields are
  * fixed here; callers only supply the per-wake variables (prompt, model, tools,
  * turn budget, resume). Returns `Options` so it drops straight into `query()`.
+ *
+ * ZIG-788 — prompt caching. The system prompt is handed over as blocks with a
+ * trailing `SYSTEM_PROMPT_DYNAMIC_BOUNDARY`: everything before the marker is
+ * eligible for cross-session caching, and there is nothing after it because
+ * nothing in this prompt varies per wake. Every per-wake input — the event, the
+ * context digest — is in the user prompt (`buildClaudeEventPrompt`), which sits
+ * after the cached prefix and cannot invalidate it.
+ *
+ * Cross-SESSION is the point, not cross-turn: `statelessPerWake` starts a fresh
+ * transcript on every wake, so without this the identical prefix was re-read at
+ * full price on each one.
+ *
+ * Caching is a prefix match, so block ORDER decides how far the hit reaches:
+ * the protocol block is byte-identical for every hosted agent and goes first,
+ * the role block is per-agent and goes second. An agent whose combined prompt
+ * lands under the model's minimum cacheable prefix (~1k tokens on Sonnet, more
+ * on Haiku) simply writes no entry — that is a silent no-op, not an error, so
+ * read `cacheRead`/`cacheCreation` in the wake metrics rather than assuming.
  */
 export function claudeQueryOptions(params) {
     return {
-        systemPrompt: params.systemPrompt,
+        systemPrompt: [...params.systemPrompt, SYSTEM_PROMPT_DYNAMIC_BOUNDARY],
         model: params.model,
         mcpServers: params.mcpServers,
         // The agent's ONLY capabilities are its MCP tools — no built-in file/bash/web

package/dist/agent/claudeSdkTools.d.ts

@@ -1,5 +1,5 @@
 import { type ToolDefinition } from '../tools/defineTool.js';
-import type { EffectHandler, WakeWriteKeys } from '../types.js';
+import type { EffectHandler, DeliveryWriteKeys } from '../types.js';
 export interface ClaudeSdkToolContext extends Record<string, unknown> {
     operatorKey: string;
     agentId: string;
@@ -14,7 +14,7 @@ export interface ClaudeSdkToolContext extends Record<string, unknown> {
     /** Per-wake id grouping this tick's tool calls in telemetry (ZIG-775). Random — never use for idempotency. */
     runId?: string;
     /** Replay-stable write keys for this wake — write tools derive idempotency keys from here, never from the LLM. */
-    wakeKeys?: WakeWriteKeys;
+    writeKeys?: DeliveryWriteKeys;
 }
 export declare const contextSnapshotTool: ToolDefinition;
 export declare const chatSendTool: ToolDefinition;

package/dist/agent/claudeSdkTools.js

@@ -77,7 +77,7 @@ export const chatSendTool = defineTool('chat_send', {
     const text = String(args.text);
     const messageId = args.idempotencyKey
         ? `sdk_idem_${String(args.idempotencyKey)}`
-        : c.wakeKeys?.messageKey({ text, sessionId, receiverId }) ?? `sdk_${randomUUID()}`;
+        : c.writeKeys?.messageKey({ text, sessionId, receiverId }) ?? `sdk_${randomUUID()}`;
     return c.eff({
         kind: 'send-message',
         sessionId,

package/dist/agent/toolManagerToSdkMcp.js

@@ -100,7 +100,7 @@ export function buildSdkToolDefs(toolDefs, getContext) {
                         senderType: ctx.senderType,
                         onBehalfOfAgreementId: ctx.onBehalfOfAgreementId,
                         runId: ctx.runId,
-                        wakeKeys: ctx.wakeKeys,
+                        writeKeys: ctx.writeKeys,
                     });
                     if (r.ok)
                         return toCallToolResult(r.result);

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

@@ -35,13 +35,12 @@ export { validateWorkflow, WorkflowValidationError } from './runtime/validateWor
 export { deriveRespondsToProposals, statesRespondToProposals, } from './runtime/deriveRespondsToProposals.js';
 export { outcomeFromEvent, outcomeFromActionResult, applyOutcomeToCtx } from './runtime/buildOutcome.js';
 export { LANE_BOOK_KEY, allCollectedResults, allDelegatedAgreementIds, allPendingSubtasks, } from './runtime/taskBookkeeping.js';
-export { createWakeWriteKeys } from './runtime/wakeWriteKeys.js';
-export type { Outcome, OutcomeKind, Ctx, Identity, HistoryEntry, ToolResultEntry, PendingSubtask, CollectedSubtaskResult, TaskBookkeeping, Workflow, State, ParkedState, ThinkingState, MechanicalState, Action, Transition, PromptDef, ActionPrompt, Produces, ProducesFn, AgreementRef, TaskRef, ProposalRef, AgentConfig, DefineAgentInput, ServicesConfig, Effect, EffectKind, EffectResult, EffectResultMap, EffectHandler, LlmMessage, LlmToolCall, LlmToolSchema, LlmResponse, ContextSnapshot, ReadContextOpts, ToolCallResult, RecordedEntry, WakeWriteKeys, } from './types.js';
+export { createDeliveryWriteKeys } from './runtime/deliveryWriteKeys.js';
+export type { Outcome, OutcomeKind, Ctx, Identity, HistoryEntry, ToolResultEntry, PendingSubtask, CollectedSubtaskResult, TaskBookkeeping, Workflow, State, ParkedState, ThinkingState, MechanicalState, Action, Transition, PromptDef, ActionPrompt, Produces, ProducesFn, AgreementRef, TaskRef, ProposalRef, AgentConfig, DefineAgentInput, ServicesConfig, Effect, EffectKind, EffectResult, EffectResultMap, EffectHandler, LlmMessage, LlmToolCall, LlmToolSchema, LlmResponse, ContextSnapshot, ReadContextOpts, ToolCallResult, RecordedEntry, DeliveryWriteKeys, } from './types.js';
 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,8 @@ 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, configureApiClient, } from '@ziggs-ai/api-client';
+export type { ApiClientConfig } 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

@@ -29,13 +29,12 @@ export { validateWorkflow, WorkflowValidationError } from './runtime/validateWor
 export { deriveRespondsToProposals, statesRespondToProposals, } from './runtime/deriveRespondsToProposals.js';
 export { outcomeFromEvent, outcomeFromActionResult, applyOutcomeToCtx } from './runtime/buildOutcome.js';
 export { LANE_BOOK_KEY, allCollectedResults, allDelegatedAgreementIds, allPendingSubtasks, } from './runtime/taskBookkeeping.js';
-export { createWakeWriteKeys } from './runtime/wakeWriteKeys.js';
+export { createDeliveryWriteKeys } from './runtime/deliveryWriteKeys.js';
 export { default } from './AgentHost.js';
 // ── Supporting modules ──────────────────────────────────────────────────────
 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,9 @@ 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, 
+// ZIG-1204 — self-hosted / non-default backend: consumers of agent-sdk alone
+// must be able to point the shared HTTP client without a direct api-client dep.
+configureApiClient, } from '@ziggs-ai/api-client';
 export { SeenMessages } from './server/SeenMessages.js';
 export { runtimeLog, resetRuntimeLogLevelCache } from './shared/runtimeLog.js';

package/dist/ingress/normalizeIncoming.d.ts

@@ -7,7 +7,7 @@ export interface NormalizedEvent {
         /**
          * Backend per-delivery id of the chat row this event came from. The one
          * field of the event that is identical on live push and on catch-up
-         * redelivery, so it anchors the wake's idempotency keys (wakeWriteKeys).
+         * redelivery, so it anchors the wake's idempotency keys (deliveryWriteKeys).
          */
         messageId?: string;
         timestamp: number;
@@ -92,7 +92,7 @@ interface NormalizeArgs {
  * 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 vs notification) and the fields the FSM / SessionResolver /
- * wakeWriteKeys depend on, nothing more. `ownAgentId` is accepted for call-site
+ * deliveryWriteKeys depend on, nothing more. `ownAgentId` is accepted for call-site
  * compatibility but no longer gates anything.
  */
 export declare function normalizeIncomingEvent({ text, metadata }: NormalizeArgs): NormalizedEvent;

package/dist/ingress/normalizeIncoming.js

@@ -86,7 +86,7 @@ function isTerminalTaskState(state) {
  * 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 vs notification) and the fields the FSM / SessionResolver /
- * wakeWriteKeys depend on, nothing more. `ownAgentId` is accepted for call-site
+ * deliveryWriteKeys depend on, nothing more. `ownAgentId` is accepted for call-site
  * compatibility but no longer gates anything.
  */
 export function normalizeIncomingEvent({ text, metadata = {} }) {

package/dist/runtime/AgentMachine.d.ts

@@ -1,4 +1,4 @@
-import type { Ctx, Outcome, Workflow, Identity, EffectHandler, WakeWriteKeys } from '../types.js';
+import type { Ctx, Outcome, Workflow, Identity, EffectHandler, DeliveryWriteKeys } from '../types.js';
 import { type RawEvent } from './buildOutcome.js';
 import type { runTurn as RunTurnFn } from './runTurn.js';
 import { PromptBuilder } from './PromptBuilder.js';
@@ -60,7 +60,7 @@ interface MachineOptions {
     /** Runaway-loop backstop: max thinking turns without human input before parking. Default 100. */
     maxTurnsWithoutUserInput?: number;
     /** This wake's replay-stable write keys — one stream shared by every turn of the tick. */
-    wakeKeys?: WakeWriteKeys;
+    writeKeys?: DeliveryWriteKeys;
 }
 interface IncomingFrame {
     event?: RawEvent;
@@ -86,7 +86,7 @@ export declare class AgentMachine {
     toolManager: ToolManager;
     promptBuilder: PromptBuilder;
     memory?: MemoryStore;
-    wakeKeys?: WakeWriteKeys;
+    writeKeys?: DeliveryWriteKeys;
     state: string;
     status: 'active' | 'stopped';
     ctx: Ctx;
@@ -114,7 +114,7 @@ export declare class AgentMachine {
         output: number;
     };
     get stateTimeoutUnhandled(): boolean;
-    constructor({ workflow, executionCore, eff, toolManager, promptBuilder, memory, input, transitionTap, maxTurnsWithoutUserInput, wakeKeys }: MachineOptions);
+    constructor({ workflow, executionCore, eff, toolManager, promptBuilder, memory, input, transitionTap, maxTurnsWithoutUserInput, writeKeys }: MachineOptions);
     getSnapshot(): MachineSnapshot;
     /** Parked = currently in a parked state and not executing a turn. */
     get isParked(): boolean;