@ziggs-ai/agent-sdk 0.42.2 → 0.43.1

package/dist/index.js

@@ -42,7 +42,7 @@ export { runTurn } from './runtime/runTurn.js';
 export { runMechanical } from './runtime/runMechanical.js';
 export { PromptBuilder } from './runtime/PromptBuilder.js';
 export { thinkingDefaults, defineThinkingState, defineMechanicalState, DEFAULT_WAIT_PROMPT } from './runtime/defaults.js';
-export { KICKOFF_STATE, CLAIM_KICKOFF_STATE, injectKickoffDefault, buildKickoffState, buildClaimKickoffState, handlesClaimWake, } from './runtime/kickoff.js';
+export { KICKOFF_STATE, injectKickoffDefault, buildKickoffState, handlesClaimWake, } from './runtime/kickoff.js';
 export { validateWorkflow, WorkflowValidationError, PROBE_CTX } from './runtime/validateWorkflow.js';
 export { outcomeFromEvent, outcomeFromActionResult, applyOutcomeToCtx } from './runtime/buildOutcome.js';
 export { LANE_BOOK_KEY, allCollectedResults, allDelegatedAgreementIds, allPendingSubtasks, } from './runtime/taskBookkeeping.js';
@@ -82,7 +82,7 @@ export {
 // Tier 1 — protocol grammar (framework-managed via taskTools).
 PROTOCOL_TOOLS, agreementProposeTool, agreementSubcontractTool, agreementRespondTool, agreementClaimTool, agreementCounterTool, agreementGetTool, agreementRevokeTool, agreementFulfillTool, taskCreateTool, taskSetResultTool, taskUpdatePlanStepTool, dispatchProtocolOp, 
 // Tier 2 — opt-in capability bundles (spread into `tools:`).
-PAYMENT_TOOLS, paymentBalanceTool, CONNECTION_TOOLS, connectionProxyTool, connectionListGrantsTool, requestConnectionTool, MCP_CONNECTION_TOOLS, mcpToolCallTool, mcpToolsListTool, DISCOVERY_TOOLS, agentSearchTool, agentGetTool, MARKETPLACE_TOOLS, marketplaceViewTool, CONTEXT_TOOLS, contextReadTool, accessRequestTool, contextDelegateTool, contextExpandReachTool, contextDiscoverGrantableTool, GRANTS_TOOLS, listGrantsTool, PLAN_TOOLS, taskReplacePlanTool, LINK_TOOLS, linkProposeTool, linkListTool, INTRODUCTION_TOOLS, introductionMintTool, introductionRedeemTool, introductionListTool, introductionRevokeTool, PARTY_TOOLS, partyNoteTool, ARTIFACT_TOOLS, recordArtifactTool, CHAT_TOOLS, openConversationTool, LISTING_TOOLS, } from './platform/tools/index.js';
+PAYMENT_TOOLS, paymentBalanceTool, CONNECTION_TOOLS, connectionProxyTool, connectionListGrantsTool, requestConnectionTool, MCP_CONNECTION_TOOLS, mcpToolCallTool, mcpToolsListTool, DISCOVERY_TOOLS, agentSearchTool, agentGetTool, MARKETPLACE_TOOLS, marketplaceViewTool, CONTEXT_TOOLS, contextReadTool, accessRequestTool, contextDelegateTool, contextExpandReachTool, contextDiscoverGrantableTool, GRANTS_TOOLS, listGrantsTool, PLAN_TOOLS, taskReplacePlanTool, LINK_TOOLS, linkProposeTool, linkListTool, INTRODUCTION_TOOLS, introductionMintTool, introductionRedeemTool, introductionListTool, introductionRevokeTool, PARTY_TOOLS, partyNoteTool, ARTIFACT_TOOLS, recordArtifactTool, LISTING_TOOLS, } from './platform/tools/index.js';
 // The always-on toolset for the hosted Claude cognition (parity guard
 // reads this as part of the real SDK registry).
 export { CLAUDE_SDK_TOOLS } from './brain/claudeSdkTools.js';
@@ -94,7 +94,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, 
+export { ArtifactsClient, AgentSearchClient, getBackendUrl, 
 // 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';
@@ -102,3 +102,4 @@ export { SeenMessages } from './platform/SeenMessages.js';
 export { runtimeLog, resetRuntimeLogLevelCache } from './shared/runtimeLog.js';
 export { runAgents } from './launcher/runAgents.js';
 export { createHealthServer, inboxHealth } from './launcher/createHealthServer.js';
+export { responseCommand } from './runtime/messageCommand.js';

package/dist/ingress/normalizeIncoming.d.ts

@@ -1,6 +1,6 @@
 import type { AgreementParties } from '@ziggs-ai/api-client';
 export interface NormalizedEvent {
-    chatId: string | null;
+    addressId: string | null;
     event: {
         senderId?: string;
         senderType?: string;
@@ -23,6 +23,7 @@ export interface NormalizedEvent {
         entryType?: string;
         operation?: string;
         agreementId?: string;
+        taskId?: string;
         /** Agreement row stamp — host skip for agent-formed activation reads this. */
         formedBy?: 'principal' | 'agent';
         result?: unknown;
@@ -44,7 +45,8 @@ interface WireTask {
     };
 }
 interface WireMetadata {
-    chatId?: string;
+    taskId?: string;
+    addressId?: string;
     messageId?: string;
     entryType?: string;
     contentType?: string;
@@ -62,7 +64,7 @@ interface WireMetadata {
     assigneeId?: string;
     task?: WireTask;
     service?: {
-        conversationAgreementId?: string;
+        workAgreementId?: string;
         task?: WireTask;
         operation?: string;
         agreement?: {

package/dist/ingress/normalizeIncoming.js

@@ -5,7 +5,7 @@ const PROPOSAL_RESOLVED_OPERATIONS = new Set([
     'proposal_approved_execute',
 ]);
 function normalizeChatId(metadata) {
-    return metadata.chatId || null;
+    return metadata.addressId || null;
 }
 function normalizeReceiverId(metadata, taskData) {
     const rewritten = typeof metadata.receiverId === 'string' && metadata.receiverId
@@ -27,7 +27,7 @@ function wireOperation(metadata) {
     return typeof op === 'string' ? op : undefined;
 }
 function wireAgreementId(metadata) {
-    const raw = metadata.service?.conversationAgreementId ??
+    const raw = metadata.service?.workAgreementId ??
         metadata.service?.agreementId ??
         metadata.service?.agreement?.agreementId ??
         metadata.agreementId;
@@ -101,7 +101,7 @@ export function normalizeIncomingEvent({ text, metadata = {} }) {
     // classifier data lives under `service` on the inbox-pull wire;
     // fall back to top-level for hand-built (direct-injection) metadata.
     const taskData = (metadata.service?.task ?? metadata.task) || null;
-    const chatId = normalizeChatId(metadata);
+    const addressId = normalizeChatId(metadata);
     const receiverId = normalizeReceiverId(metadata, taskData);
     const senderType = metadata.sender?.type ? String(metadata.sender.type).toUpperCase() : undefined;
     const entryType = typeof metadata.entryType === 'string' && metadata.entryType
@@ -117,6 +117,7 @@ export function normalizeIncomingEvent({ text, metadata = {} }) {
         messageId: typeof metadata.messageId === 'string' && metadata.messageId ? metadata.messageId : undefined,
         timestamp: Date.now(),
         ...(entryType ? { entryType } : {}),
+        ...(metadata.taskId ? { taskId: metadata.taskId } : {}),
         ...(wakeAgreementId ? { agreementId: wakeAgreementId } : {}),
         ...(formedBy ? { formedBy } : {}),
     };
@@ -126,7 +127,7 @@ export function normalizeIncomingEvent({ text, metadata = {} }) {
             : wireOperation(metadata);
         const agreementId = wireAgreementId(metadata);
         return {
-            chatId,
+            addressId,
             event: {
                 ...base,
                 type: 'agreement_lifecycle',
@@ -142,7 +143,7 @@ export function normalizeIncomingEvent({ text, metadata = {} }) {
         // task notices as `task_result` so orchestrators still see completions.
         if (entryType === 'notification' && !isTerminalTaskState(taskData?.state)) {
             return {
-                chatId,
+                addressId,
                 event: {
                     ...base,
                     type: 'notification',
@@ -153,7 +154,7 @@ export function normalizeIncomingEvent({ text, metadata = {} }) {
             };
         }
         return {
-            chatId,
+            addressId,
             event: { ...base, type: 'task_result', result: taskData, text },
         };
     }
@@ -163,7 +164,7 @@ export function normalizeIncomingEvent({ text, metadata = {} }) {
         const operation = metadata.service?.operation ?? metadata.operation;
         const rawAgreementId = metadata.service?.agreementId ?? metadata.agreementId;
         return {
-            chatId,
+            addressId,
             event: {
                 ...base,
                 type: 'notification',
@@ -174,7 +175,7 @@ export function normalizeIncomingEvent({ text, metadata = {} }) {
         };
     }
     return {
-        chatId,
+        addressId,
         event: { ...base, type: 'message', text },
     };
 }

package/dist/mcp/createMcpAgent.d.ts

@@ -152,6 +152,20 @@ export interface McpAgentHandle {
 export declare function buildTransport(config: McpTransportConfig, defaults?: {
     agentId?: string;
 }): StdioClientTransport | StreamableHTTPClientTransport;
+type McpTool = {
+    name: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+};
+/**
+ * The workflow an MCP agent runs, with the same assigned-task intake
+ * `defineAgent` gives every other agent. Without it a task wake reached the
+ * `idle` state, whose only way to deliver is `respond`: a reply needs an exact
+ * message or a named recipient, a task carries neither, so every task ended in
+ * a refused send and a tick timeout and the result was never written. The
+ * intake routes the wake to `task_set_result` instead.
+ */
+export declare function mcpAgentWorkflow(workflow: Workflow | undefined, description: string, mcpTools: McpTool[]): Workflow;
 /**
  * Max chars for a single tool description bound to the LLM. Verbose MCP servers
  * embed whole manuals in their descriptions (PostHog's `execute-sql` alone is
@@ -198,3 +212,4 @@ export declare function trimDescription(desc: string | undefined): string | unde
  *   });
  */
 export declare function createMcpAgent(options: CreateMcpAgentOptions): Promise<McpAgentHandle>;
+export {};

package/dist/mcp/createMcpAgent.js

@@ -7,6 +7,7 @@ import { resolveBackendUrl } from '../shared/backendUrl.js';
 import { createAgent } from '../Agent.js';
 import { laneFromToolContext } from '../tools/toolCreds.js';
 import { thinkingDefaults } from '../runtime/defaults.js';
+import { injectTaskIntakeDefault, TASK_INTAKE_STATE } from '../runtime/taskIntake.js';
 /**
  * Typed failure from the Ziggs MCP gateway. `code` is the stable
  * machine-readable reason — e.g. `GRANT_REVOKED`, `GRANT_EXPIRED`,
@@ -34,6 +35,7 @@ export function wrapGatewayFetch(baseFetch = fetch) {
     return (async (input, init) => {
         const headers = new Headers(init?.headers);
         headers.delete('X-Ziggs-Execution');
+        headers.delete('X-Ziggs-Attempt');
         for (const [key, value] of Object.entries(assistantRequestHeaders()))
             headers.set(key, value);
         const response = await baseFetch(input, { ...init, headers });
@@ -183,15 +185,42 @@ function mapMcpTools(callTool, tools) {
         isGenericFallback: true,
     }));
 }
+/**
+ * The workflow an MCP agent runs, with the same assigned-task intake
+ * `defineAgent` gives every other agent. Without it a task wake reached the
+ * `idle` state, whose only way to deliver is `respond`: a reply needs an exact
+ * message or a named recipient, a task carries neither, so every task ended in
+ * a refused send and a tick timeout and the result was never written. The
+ * intake routes the wake to `task_set_result` instead.
+ */
+export function mcpAgentWorkflow(workflow, description, mcpTools) {
+    const wf = injectTaskIntakeDefault(workflow ?? buildDefaultWorkflow(description, mcpTools));
+    const intake = wf.states[TASK_INTAKE_STATE];
+    if (intake?.kind !== 'thinking')
+        return wf;
+    // The intake is where an assigned task is worked, so it needs the MCP tools
+    // too. With task_set_result alone the agent could only close the task
+    // without doing it.
+    return {
+        ...wf,
+        states: { ...wf.states, [TASK_INTAKE_STATE]: { ...intake, actions: { ...mcpToolActions(mcpTools), ...intake.actions } } },
+    };
+}
+/** Each MCP tool as an explicit action, so runTurn offers it to the model. */
+function mcpToolActions(mcpTools) {
+    // A tool action has no outcome of its own: the turn's tool loop continues on
+    // its result, exactly as in the default idle state.
+    return Object.fromEntries(mcpTools.map(t => [t.name, {
+            tool: t.name,
+            prompt: { when: t.description || `Use ${t.name}` },
+        }]));
+}
 function buildDefaultWorkflow(description, mcpTools) {
     const dflt = thinkingDefaults({ initial: 'idle' });
     // Bind each MCP tool as an explicit action so runTurn includes them in the
     // LLM API call and the decision schema. Without this, allowedToolNames is
     // empty and the tools array passed to the LLM is also empty.
-    const toolActions = Object.fromEntries(mcpTools.map(t => [t.name, {
-            tool: t.name,
-            prompt: { when: t.description || `Use ${t.name}` },
-        }]));
+    const toolActions = mcpToolActions(mcpTools);
     return {
         id: 'mcp-agent',
         description: description || 'MCP-backed agent',
@@ -386,19 +415,26 @@ export async function createMcpAgent(options) {
         // The server holds the invoking user to the people this wake may ask, so
         // the request carries the same lane as the call that missed: in the hire's
         // room that user is its customer.
-        const triggerConnectionRequest = async (userId, laneId) => {
+        const triggerConnectionRequest = async (userId) => {
             if (!transportConfig.serverUrl)
                 return null;
             const operatorKey = transportConfig.operatorKey || process.env.ZIGGS_OPERATOR_KEY;
             if (!operatorKey)
                 return null;
+            const work = currentWorkExecution();
+            const context = work?.taskId ? { kind: 'task', id: work.taskId }
+                : work?.agreementId ? { kind: 'agreement', id: work.agreementId }
+                    : work?.action?.kind === 'message' ? { kind: 'message', id: work.action.id } : null;
+            if (!context)
+                return null;
             try {
                 const body = await new ConnectionsClient(operatorKey, agentId, backendBase).requestMcpConnection({
                     serverUrl: transportConfig.serverUrl,
                     tools: tools.map(t => t.name),
-                    onBehalfOfUserId: userId,
+                    recipientId: userId,
+                    context,
                 });
-                return (body?.request?.requestId) ?? null;
+                return typeof body.agreementId === 'string' ? body.agreementId : null;
             }
             catch {
                 // Best-effort: the backend dedups pending requests and the caller falls
@@ -451,8 +487,8 @@ export async function createMcpAgent(options) {
             if (lastErr instanceof ZiggsGatewayError &&
                 lastErr.code === 'NO_USER_CONNECTION' &&
                 transportConfig.serverUrl) {
-                const requestId = await triggerConnectionRequest(userId, laneId).catch(() => null);
-                const link = connectionsSettingsAppUrl(appUrl, requestId);
+                const requestId = await triggerConnectionRequest(userId).catch(() => null);
+                const link = requestId ? new URL(`/app/inbox?kind=agreement&id=${encodeURIComponent(requestId)}`, appUrl).toString() : connectionsSettingsAppUrl(appUrl);
                 return {
                     content: [
                         {
@@ -466,7 +502,7 @@ export async function createMcpAgent(options) {
         };
         const agent = createAgent({
             ...agentOptions,
-            workflow: workflow ?? buildDefaultWorkflow(agentOptions.description ?? '', tools),
+            workflow: mcpAgentWorkflow(workflow, agentOptions.description ?? '', tools),
             tools: [...mapMcpTools(caller, tools), ...extraTools],
         });
         return {
@@ -509,7 +545,7 @@ export async function createMcpAgent(options) {
         };
         const caller = async (name, args) => (await clientFor()).callTool({ name, arguments: args });
         const mcpTools = mapMcpTools(caller, rawTools);
-        const resolvedWorkflow = workflow ?? buildDefaultWorkflow(agentOptions.description ?? '', rawTools);
+        const resolvedWorkflow = mcpAgentWorkflow(workflow, agentOptions.description ?? '', rawTools);
         const agent = createAgent({
             ...agentOptions,
             workflow: resolvedWorkflow,

package/dist/memory/MemoryStore.d.ts

@@ -61,7 +61,7 @@ export declare class FileMemoryStore implements MemoryStore {
  *
  * Pick from the hire this wake is acting under — the same fact the
  * server uses for acting-for: a pinned agreement, the delivery / event
- * hire, or an `agrn-` lane. Exactly one agreement gives that agreement's
+ * hire. Processing lane names do not grant a memory partition. Exactly one agreement gives that agreement's
  * section. None, or several, gives null: notes are bound to an agreement,
  * so such a wake has nowhere to keep them, and says so on a write rather
  * than landing in a room's or the agent's shared drawer.

package/dist/memory/MemoryStore.js

@@ -1,4 +1,3 @@
-import { agreementIdFromLane } from '@ziggs-ai/api-client';
 /** Non-durable reference impl. Per-process; lost on restart. */
 export class InMemoryStore {
     store = new Map();
@@ -82,7 +81,7 @@ export class FileMemoryStore {
  *
  * Pick from the hire this wake is acting under — the same fact the
  * server uses for acting-for: a pinned agreement, the delivery / event
- * hire, or an `agrn-` lane. Exactly one agreement gives that agreement's
+ * hire. Processing lane names do not grant a memory partition. Exactly one agreement gives that agreement's
  * section. None, or several, gives null: notes are bound to an agreement,
  * so such a wake has nowhere to keep them, and says so on a write rather
  * than landing in a room's or the agent's shared drawer.
@@ -91,7 +90,6 @@ export function memorySectionForWake(input) {
     const ids = uniqueHireIds([
         input.activeAgreementId,
         ...(input.wakeAgreementIds ?? []),
-        agreementIdFromAgrnSession(input.sessionId),
     ]);
     return ids.length === 1 ? `hire:${ids[0]}` : null;
 }
@@ -146,9 +144,6 @@ export function hireIdsFromEvent(event) {
             : null,
     ]);
 }
-function agreementIdFromAgrnSession(sessionId) {
-    return agreementIdFromLane(sessionId)?.trim() || null;
-}
 /**
  * Present a store as if it only contained one section. Agent keys stay
  * unchanged; get/put/list/delete all go through `section:`.

package/dist/platform/ConnectionPool.js

@@ -58,7 +58,7 @@ export class ConnectionPool {
                         if (effect.kind === 'send-message') {
                             const listeners = pool.responseListeners.get(agentId);
                             if (listeners?.length)
-                                listeners.shift()(effect.text ?? '');
+                                listeners.shift()(effect.command.content.text);
                         }
                         originalTap?.(effect, response);
                     },

package/dist/platform/OutboxBuffer.d.ts

@@ -22,11 +22,11 @@ export declare class OutboxBuffer {
     private _pending;
     private _ttlMs;
     constructor(options?: OutboxBufferOptions);
-    track(chatId: string, msg: {
+    track(addressId: string, msg: {
         text: string;
         receiverId?: string;
     }): void;
-    merge(chatId: string, history: HistoryEntryShape[], agentId: string | null): void;
+    merge(addressId: string, history: HistoryEntryShape[], agentId: string | null): void;
     gc(): void;
     private _gcChat;
 }

package/dist/platform/OutboxBuffer.js

@@ -10,15 +10,15 @@ export class OutboxBuffer {
     constructor(options = {}) {
         this._ttlMs = Number.isFinite(options.ttlMs) ? Math.max(1_000, options.ttlMs) : 10 * 60 * 1000;
     }
-    track(chatId, msg) {
-        this._gcChat(chatId);
-        if (!this._pending.has(chatId))
-            this._pending.set(chatId, []);
-        this._pending.get(chatId).push({ text: msg.text, receiverId: msg.receiverId, timestamp: Date.now() });
+    track(addressId, msg) {
+        this._gcChat(addressId);
+        if (!this._pending.has(addressId))
+            this._pending.set(addressId, []);
+        this._pending.get(addressId).push({ text: msg.text, receiverId: msg.receiverId, timestamp: Date.now() });
     }
-    merge(chatId, history, agentId) {
-        this._gcChat(chatId);
-        const pending = this._pending.get(chatId);
+    merge(addressId, history, agentId) {
+        this._gcChat(addressId);
+        const pending = this._pending.get(addressId);
         if (!pending || pending.length === 0)
             return;
         const matchedIndices = new Set();
@@ -42,27 +42,27 @@ export class OutboxBuffer {
             });
         }
         if (remaining.length === 0)
-            this._pending.delete(chatId);
+            this._pending.delete(addressId);
         else
-            this._pending.set(chatId, remaining);
+            this._pending.set(addressId, remaining);
     }
     gc() {
-        for (const chatId of this._pending.keys())
-            this._gcChat(chatId);
+        for (const addressId of this._pending.keys())
+            this._gcChat(addressId);
     }
-    _gcChat(chatId) {
-        const pending = this._pending.get(chatId);
+    _gcChat(addressId) {
+        const pending = this._pending.get(addressId);
         if (!pending?.length)
             return;
         const cutoff = Date.now() - this._ttlMs;
         const fresh = pending.filter(msg => msg.timestamp >= cutoff);
         if (fresh.length === 0) {
-            this._pending.delete(chatId);
-            runtimeLog.warn('OutboxBuffer', `expired all pending messages chatId=${chatId}`);
+            this._pending.delete(addressId);
+            runtimeLog.warn('OutboxBuffer', `expired all pending messages addressId=${addressId}`);
             return;
         }
         if (fresh.length !== pending.length) {
-            this._pending.set(chatId, fresh);
+            this._pending.set(addressId, fresh);
         }
     }
 }

package/dist/platform/StateTimers.d.ts

@@ -15,6 +15,7 @@ export interface StateTimeoutEvent {
  * state's declared timeout, and the Claude brain has no states at all.
  */
 export interface WakeAtEvent extends WorkScope {
+    wakeId: string;
     type: 'wake-at';
     /** What the agent said it was waiting for. Free text, for the brain to read. */
     reason: string | null;
@@ -74,9 +75,10 @@ export declare class StateTimers {
      * the agent, since "I will wake at X" is a promise the agent will otherwise
      * make on its own.
      */
-    armWakeAt(laneKey: string, at: Date | number, reason?: string | null, scope?: WorkScope): {
+    armWakeAt(laneKey: string, at: Date | number, reason?: string | null, scope?: WorkScope, wakeId?: string): {
         firesAt: number;
         delayMs: number;
+        wakeId: string;
     };
     /** What is armed on this lane, if anything. Read by the specs and by `wake_at`. */
     peek(laneKey: string): {

package/dist/platform/StateTimers.js

@@ -1,3 +1,4 @@
+import { randomUUID } from 'node:crypto';
 import { runtimeLog } from '../shared/runtimeLog.js';
 /**
  * `setTimeout` stores its delay in a signed 32-bit int. A longer delay does
@@ -75,7 +76,7 @@ export class StateTimers {
      * the agent, since "I will wake at X" is a promise the agent will otherwise
      * make on its own.
      */
-    armWakeAt(laneKey, at, reason = null, scope) {
+    armWakeAt(laneKey, at, reason = null, scope, wakeId = randomUUID()) {
         const firesAtRaw = at instanceof Date ? at.getTime() : Number(at);
         if (!Number.isFinite(firesAtRaw)) {
             throw new Error('StateTimers.armWakeAt: `at` must be a Date or epoch ms');
@@ -94,7 +95,7 @@ export class StateTimers {
         const epoch = ++this._epoch;
         const handle = setTimeout(() => {
             runtimeLog.debug('StateTimers', `wake-at fired laneKey=${laneKey} reason=${reason ?? 'none'} epoch=${epoch}`);
-            this._enqueue({ type: 'wake-at', reason, scheduledFor: firesAtRaw, epoch, ...wakeScope }, laneKey);
+            this._enqueue({ type: 'wake-at', wakeId, reason, scheduledFor: firesAtRaw, epoch, ...wakeScope }, laneKey);
         }, delayMs);
         handle.unref?.();
         this._timers.set(laneKey, {
@@ -107,7 +108,7 @@ export class StateTimers {
             armedAt: now,
             handle,
         });
-        return { firesAt: now + delayMs, delayMs };
+        return { firesAt: now + delayMs, delayMs, wakeId };
     }
     /** What is armed on this lane, if anything. Read by the specs and by `wake_at`. */
     peek(laneKey) {

package/dist/platform/WakeLedger.d.ts

@@ -3,11 +3,14 @@ import { type MemoryStore } from '../memory/MemoryStore.js';
 import type { WorkScope } from '../runtime/wakeEffects.js';
 /** One check-back an agent asked for, as it is kept across a restart. */
 export interface SavedWake {
+    wakeId: string;
     laneKey: string;
     sessionId: string;
     firesAt: number;
     reason: string | null;
     scope?: WorkScope;
+    /** The conversation the lane's own messages came from, when it has one. */
+    addressId?: string;
     executionContext?: WorkExecutionContext;
 }
 /**
@@ -15,30 +18,31 @@ export interface SavedWake {
  *
  * The timer itself stays in memory (`StateTimers`). This keeps the facts
  * needed to arm it again: which lane, when, why, and under which work. A wake
- * is written when it is armed and marked done when it fires, so on start the
+ * is written when armed and marked done after successful handover, so on start the
  * host re-arms exactly the ones still waiting, and one that passed while the
- * host was down fires once.
+ * host was down remains eligible. A failed handover remains pending.
  *
  * The notes live in the agent's own memory store under a prefix no memory
  * section uses (sections are `hire:<id>`), so the agent's memory tools never
  * see them. Writes are chained so a mark can never land before the arm it
  * follows.
  *
- * Two hosts of the same agent running at once, as during a rolling deploy,
- * can both re-arm a wake and both fire it. That costs one extra wake, and the
- * agent checks for an answer before it chases anyone.
+ * Concurrent hosts may both discover a pending wake. Exact action claims fence
+ * simultaneous execution; the domain owner still decides whether work is due.
  */
 export declare class WakeLedger {
     private readonly store;
+    private inFlight;
     private writes;
     constructor(store: MemoryStore);
     /** False when the store is in memory: then a restart loses wakes anyway. */
     get durable(): boolean;
     arm(wake: SavedWake): void;
-    done(laneKey: string): void;
+    done(laneKey: string, wakeId: string): void;
     /** The wakes still waiting to fire, for the host to arm again on start. */
     pending(): Promise<SavedWake[]>;
     /** Resolves when every write so far has landed. For tests and shutdown. */
+    track(work: Promise<unknown>): void;
     flushed(): Promise<void>;
     private write;
     private warn;

package/dist/platform/WakeLedger.js

@@ -6,21 +6,21 @@ const PREFIX = 'host:wake-at:';
  *
  * The timer itself stays in memory (`StateTimers`). This keeps the facts
  * needed to arm it again: which lane, when, why, and under which work. A wake
- * is written when it is armed and marked done when it fires, so on start the
+ * is written when armed and marked done after successful handover, so on start the
  * host re-arms exactly the ones still waiting, and one that passed while the
- * host was down fires once.
+ * host was down remains eligible. A failed handover remains pending.
  *
  * The notes live in the agent's own memory store under a prefix no memory
  * section uses (sections are `hire:<id>`), so the agent's memory tools never
  * see them. Writes are chained so a mark can never land before the arm it
  * follows.
  *
- * Two hosts of the same agent running at once, as during a rolling deploy,
- * can both re-arm a wake and both fire it. That costs one extra wake, and the
- * agent checks for an answer before it chases anyone.
+ * Concurrent hosts may both discover a pending wake. Exact action claims fence
+ * simultaneous execution; the domain owner still decides whether work is due.
  */
 export class WakeLedger {
     store;
+    inFlight = new Set();
     writes = Promise.resolve();
     constructor(store) {
         this.store = store;
@@ -33,11 +33,11 @@ export class WakeLedger {
         const { laneKey, ...rest } = wake;
         this.write(laneKey, { ...rest, state: 'armed' });
     }
-    done(laneKey) {
+    done(laneKey, wakeId) {
         this.writes = this.writes
             .then(async () => {
             const saved = (await this.store.get(PREFIX + laneKey));
-            if (saved?.state === 'armed') {
+            if (saved?.state === 'armed' && saved.wakeId === wakeId) {
                 await this.store.put(PREFIX + laneKey, { ...saved, state: 'done' });
             }
         })
@@ -56,18 +56,25 @@ export class WakeLedger {
                 continue;
             out.push({
                 laneKey: key.slice(PREFIX.length),
+                wakeId: saved.wakeId,
                 sessionId: saved.sessionId,
                 firesAt: saved.firesAt,
                 reason: saved.reason ?? null,
                 ...(saved.scope ? { scope: saved.scope } : {}),
+                ...(typeof saved.addressId === 'string' && saved.addressId ? { addressId: saved.addressId } : {}),
                 ...(saved.executionContext ? { executionContext: saved.executionContext } : {}),
             });
         }
         return out;
     }
     /** Resolves when every write so far has landed. For tests and shutdown. */
-    flushed() {
-        return this.writes;
+    track(work) {
+        this.inFlight.add(work);
+        void work.finally(() => this.inFlight.delete(work)).catch(() => { });
+    }
+    async flushed() {
+        await Promise.allSettled([...this.inFlight]);
+        await this.writes;
     }
     write(laneKey, value) {
         this.writes = this.writes

package/dist/platform/ZiggsEffectHandler.d.ts

@@ -1,4 +1,4 @@
-import type { WriteSource } from '@ziggs-ai/api-client';
+import type { MessageCommand, MessageCommandResult } from '@ziggs-ai/contracts';
 /**
  * Ziggs-flavored EffectHandler.
  *
@@ -37,7 +37,21 @@ export interface ZiggsEffectDeps {
     contextReadClient: ContextReadClient;
     taskService: TaskService;
     agreementService: AgreementService;
-    messageSender: (text: string, receiverId: string | undefined, sessionId: string, messageId?: string, conversationAgreementId?: string, underAgreementId?: string, taskId?: string, sources?: WriteSource[]) => Promise<unknown>;
+    messageSender: (command: MessageCommand) => Promise<MessageCommandResult>;
+    /**
+     * The explicit conversation and work selected for this wake. A processing
+     * lane alone cannot select a destination; task-first and restored wakes
+     * use their execution context without waiting for a message.
+     */
+    conversationFor?: (sessionId: string) => {
+        agreementId?: string;
+        addressId?: string;
+        taskId?: string;
+        message?: {
+            messageId: string;
+            senderId?: string;
+        };
+    } | undefined;
     /** Sends a streaming chunk to a client. Called per-token during stream-text effects. */
     chunkSender?: (sessionId: string, receiverId: string, text: string, messageId: string) => void;
     toolManager: ToolManager;
@@ -67,10 +81,10 @@ export interface ZiggsEffectDeps {
  * side effects — that is the whole point of funneling both paths here.
  *
  * `eff` is threaded into the tool context so eff-backed tools
- * (`context_snapshot`, `chat_send`) resolve through this same path
+ * (`context_snapshot`, `message_send`) resolve through this same path
  * regardless of which cognition invoked them.
  */
-export declare function executeToolWithSideEffects(deps: Pick<ZiggsEffectDeps, 'toolManager' | 'artifactsClient' | 'telemetryClient' | 'telemetryIngest' | 'operatorKey' | 'agentId' | 'taskService' | 'agreementService' | 'contextReadClient' | 'messageSender' | 'wakeScheduler'>, eff: EffectHandler, effect: Extract<Effect, {
+export declare function executeToolWithSideEffects(deps: Pick<ZiggsEffectDeps, 'toolManager' | 'artifactsClient' | 'telemetryClient' | 'telemetryIngest' | 'operatorKey' | 'agentId' | 'taskService' | 'agreementService' | 'contextReadClient' | 'messageSender' | 'wakeScheduler' | 'conversationFor'>, eff: EffectHandler, effect: Extract<Effect, {
     kind: 'tool-call';
 }>, roster: {
     agents: unknown[];