@ziggs-ai/agent-sdk 0.9.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)
@@ -155,7 +175,7 @@ function resolveOnBehalfAgreementId(rawEvent, contextSnap, agentId, sessionId) {
 export class ClaudeSdkAgent {
     workflow;
     toolManager;
-    description;
+    rolePrompt;
     specialization;
     model;
     anthropicKey;
@@ -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');
@@ -173,7 +200,10 @@ export class ClaudeSdkAgent {
             throw new Error('ClaudeSdkAgent: anthropicKey is required');
         this.workflow = opts.workflow;
         this.toolManager = opts.toolManager;
-        this.description = opts.description;
+        // ZIG-1080: the prompt and the store blurb are two different strings. Agents
+        // written before the split still carry the prompt in `description`, so fall
+        // back to it rather than silently dropping their role.
+        this.rolePrompt = opts.systemPrompt || opts.description;
         this.specialization = opts.specialization ?? null;
         this.model = opts.model;
         this.anthropicKey = opts.anthropicKey;
@@ -206,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 {
@@ -219,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) {
@@ -259,7 +293,7 @@ export class ClaudeSdkAgent {
         }
         const roleBlock = [
             `## Your role`,
-            this.description,
+            this.rolePrompt,
             this.specialization ? `Specialization: ${this.specialization}` : '',
         ].filter(Boolean).join('\n');
         const systemPrompt = `${CLAUDE_SDK_PROTOCOL}\n\n${roleBlock}`;
@@ -284,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,
@@ -303,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();
-                        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/agent/claudeSdkTools.js

@@ -8,18 +8,37 @@ import { listGrantsTool } from '../server/tools/tier2/grantsTools.js';
 // messages cover "what woke me and what was just said"; the model can pass a
 // larger maxMessages explicitly when it genuinely needs deeper history.
 const DEFAULT_SNAPSHOT_MAX_MESSAGES = 12;
+/**
+ * First usable string among the candidates, treating blank as absent.
+ *
+ * ZIG-1081: a model that does not know a value fills the field with `""` rather
+ * than omitting it — the schema shows `chatId`, the agent has no way to know it,
+ * so it sends an empty string. Plain `??` let that blank win over the lane
+ * default, and the very next line rejected it as missing. Every wake opened with
+ * a failed `context_snapshot` and a recovery turn.
+ */
+function firstFilled(...candidates) {
+    for (const candidate of candidates) {
+        if (typeof candidate === 'string' && candidate.trim() !== '')
+            return candidate;
+    }
+    return undefined;
+}
 // Named distinctly from ziggs-mcp's per-type `ziggs_context_read`: this is the
 // one-shot aggregate snapshot (grant-fenced server-side), not a cursored read.
 export const contextSnapshotTool = defineTool('context_snapshot', {
-    chatId: { type: 'string', description: 'Chat/session id. Defaults to the current lane session.' },
+    chatId: { type: 'string', description: 'Omit this to snapshot the chat you were woken in — that is the usual case, and you do not need to know its id. Only pass a chatId to snapshot a DIFFERENT chat.' },
     maxMessages: { type: 'number', description: `Message history cap (default ${DEFAULT_SNAPSHOT_MAX_MESSAGES}). Pass a larger value when you need deeper history.` },
 }, async (args, ctx) => {
     const c = ctx;
     if (!c.eff)
         throw new Error('context_snapshot requires eff in tool context');
-    const sessionId = args.chatId ?? c.chatId ?? c.sessionId;
-    if (!sessionId)
-        throw new Error('context_snapshot: chatId is required');
+    const sessionId = firstFilled(args.chatId, c.chatId, c.sessionId);
+    if (!sessionId) {
+        throw new Error('context_snapshot: this wake carries no chat to snapshot. Call it with no arguments ' +
+            'to read the chat you were woken in; if this wake is on an agreement lane with no ' +
+            'single chat, read the agreement instead and pass a chatId from one of its chats.');
+    }
     return c.eff({
         kind: 'read-context',
         sessionId,
@@ -29,22 +48,24 @@ export const contextSnapshotTool = defineTool('context_snapshot', {
     });
 }, { description: 'Read the chat snapshot: the NEWEST maxMessages of history (chronological order), plus agreements, agents, and users for a session.' });
 export const chatSendTool = defineTool('chat_send', {
-    chatId: { type: 'string', description: 'Chat id. Defaults to current session.' },
-    receiverId: { type: 'string', description: 'Recipient user or agent id. Defaults to the sender of the event that woke you — omit when replying to them.' },
+    chatId: { type: 'string', description: 'Omit this to send in the chat you were woken in — that is the usual case. Only pass a chatId to send in a DIFFERENT chat.' },
+    receiverId: { type: 'string', description: 'Recipient user or agent id. Omit when replying to whoever woke you — that is the default.' },
     text: { type: 'string', required: true },
     idempotencyKey: { type: 'string', description: 'Reuse for retry-safe resend of the same logical message.' },
 }, async (args, ctx) => {
     const c = ctx;
     if (!c.eff)
         throw new Error('chat_send requires eff in tool context');
-    const sessionId = args.chatId ?? c.chatId ?? c.sessionId;
-    if (!sessionId)
-        throw new Error('chat_send: chatId is required');
+    const sessionId = firstFilled(args.chatId, c.chatId, c.sessionId);
+    if (!sessionId) {
+        throw new Error('chat_send: this wake carries no chat to send in. Call it with no chatId to reply in ' +
+            'the chat you were woken in, or pass the chatId of the chat you mean.');
+    }
     // Replying to whoever woke you is the overwhelmingly common case; making
     // the model spell it out cost a failed tool call + a full extra LLM turn
     // per reply. Batch/timer wakes carry no sender — those still require an
     // explicit receiverId.
-    const receiverId = args.receiverId ?? c.senderId;
+    const receiverId = firstFilled(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 content-derived key (ZIG-1045): a crash-replay that
@@ -99,12 +120,19 @@ export const listTasksTool = defineTool('task_list', {
     if (!c.agentId)
         throw new Error('task_list: agentId missing from tool context');
     const assignedTo = args.assignedToMe ? c.agentId : args.assignedTo;
+    // ZIG-1092: the lane fences this to the engagement's tasks. Without it the
+    // list is every task the agent's key can reach, across all its customers.
+    const laneId = c.chatId || c.sessionId || undefined;
     return listTasks({
         state: args.state,
         cursor: args.cursor,
         limit: typeof args.limit === 'number' ? args.limit : undefined,
         assignedTo,
-    }, { operatorKey: c.operatorKey, agentId: c.agentId });
+    }, {
+        operatorKey: c.operatorKey,
+        agentId: c.agentId,
+        ...(laneId ? { laneId } : {}),
+    });
 }, {
     description: 'List tasks reachable by this agent (GET /tasks). Scope follows the operator key — same reach as chats and agreements. Optional state / assignee filters and cursor pagination. Use assignedToMe to list your own open work.',
 });

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/defineAgent.js

@@ -35,7 +35,10 @@ export function defineAgent(input) {
     // states/transitions are validated too.
     const workflow = injectTaskIntakeDefault(injectKickoffDefault({
         id: input.agentId,
-        description: input.description,
+        // The workflow description is the agent's role text, which PromptBuilder
+        // renders into <self>. ZIG-1080 split that from the store-facing
+        // `description`: prefer the prompt when the author supplied one.
+        description: input.systemPrompt || input.description,
         initial: input.initial,
         states: input.states,
     }));

package/dist/formatters/HistoryFormatter.js

@@ -126,6 +126,17 @@ export class HistoryFormatter {
             return 'System';
         if (id === agentId)
             return 'You';
+        // ZIG-1137: prefer presentation face when the wire masks the principal.
+        const presentation = participant['presentation'];
+        const faceName = (typeof presentation?.['name'] === 'string' && presentation['name']) ||
+            (typeof presentation?.['persona']?.['name'] === 'string'
+                ? presentation['persona']['name']
+                : null);
+        if (faceName)
+            return `${faceName} (${id})`;
+        if (id.startsWith('rpb_') || id.startsWith('psn_')) {
+            return `${id} (presentation)`;
+        }
         return `${id} (${participant['type'] || 'unknown'})`;
     }
     formatOwner(task, agentId) {

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/ingress/normalizeIncoming.d.ts

@@ -71,6 +71,11 @@ interface WireMetadata {
                 status?: string;
             };
             parties?: WireParties;
+            approvals?: Array<{
+                partyId?: string;
+                status?: string;
+                role?: string;
+            }>;
         };
         agreementId?: string;
     };

package/dist/ingress/normalizeIncoming.js

@@ -45,6 +45,27 @@ function isAlreadyActivatedProposalCreated(metadata) {
     const proposalStatus = agr.proposal?.status;
     return status === 'active' || proposalStatus === 'approved';
 }
+/**
+ * ZIG-1078 — a `proposal_created` notification addressed to a party whose
+ * approval is PENDING is a consent REQUEST, not a status notice. The backend
+ * fans `proposal_created` out specifically to the pending approvers
+ * (ZIG-244), and parking it meant the hand-off provider (ZIG-1059) — or any
+ * agent whose consent a proposal awaits — was alerted and then never looked:
+ * the approval sat pending until a human nudged the chat. Same technique as
+ * isAlreadyActivatedProposalCreated (ZIG-1052): reclassify by what the
+ * embedded agreement SAYS rather than adding a new wake word.
+ */
+function isPendingApprovalRequestNotification(metadata) {
+    if (wireOperation(metadata) !== 'proposal_created')
+        return false;
+    const receiverId = metadata.receiver?.id;
+    if (!receiverId)
+        return false;
+    const approvals = metadata.service?.agreement?.approvals;
+    if (!Array.isArray(approvals))
+        return false;
+    return approvals.some((a) => a && a.partyId === receiverId && a.status === 'pending');
+}
 function isAgreementLifecycleNotification(metadata) {
     const entryType = metadata.entryType || 'message';
     if (entryType !== 'notification')
@@ -53,7 +74,8 @@ function isAgreementLifecycleNotification(metadata) {
     if (typeof operation === 'string' && PROPOSAL_RESOLVED_OPERATIONS.has(operation)) {
         return true;
     }
-    return isAlreadyActivatedProposalCreated(metadata);
+    return (isAlreadyActivatedProposalCreated(metadata) ||
+        isPendingApprovalRequestNotification(metadata));
 }
 function isTerminalTaskState(state) {
     return state === 'completed' || state === 'failed' || state === 'cancelled';

package/dist/pricing/fleetDefaults.d.ts

@@ -19,7 +19,6 @@ export interface ProtocolPricingPayload {
     providerId?: string;
     executorId?: string;
     parentAgreementId?: string;
-    parentTaskId?: string;
     [key: string]: unknown;
 }
 /**
@@ -36,8 +35,6 @@ export declare function applyFleetAgreementPricing(operation: 'agreement-propose
  * out unwidened by `ProtocolPricingPayload`'s `[key: string]: unknown` index.
  */
 export declare function applyFleetCounterPricing<T extends ProtocolPricingPayload>(payload: T, actingAgentId: string): T;
-/** User or agent direct-create / marketplace: default from provider specialist. */
-export declare function resolveDefaultPriceForProvider(providerId: string, description?: string | null, explicitPrice?: number | null): number | null;
 /**
  * Infer fleet actor when tool context omits agentId (ZIG-368 safety net).
  */

package/dist/pricing/fleetDefaults.js

@@ -121,12 +121,6 @@ export function applyFleetCounterPricing(payload, actingAgentId) {
         return payload;
     return { ...payload, price: cents };
 }
-/** User or agent direct-create / marketplace: default from provider specialist. */
-export function resolveDefaultPriceForProvider(providerId, description, explicitPrice) {
-    if (typeof explicitPrice === 'number')
-        return explicitPrice;
-    return resolveDefaultPriceCentsForExecutor(providerId, description);
-}
 /**
  * Infer fleet actor when tool context omits agentId (ZIG-368 safety net).
  */