@ziggs-ai/agent-sdk 0.42.0 → 0.43.0

package/dist/Agent.js

@@ -1,9 +1,11 @@
+import { runWorkExecution } from '@ziggs-ai/api-client';
+import { MessageRecordsClient } from '@ziggs-ai/api-client/http';
+import { responseCommand } from './runtime/messageCommand.js';
 import { validateWorkExecution, withWorkExecution, currentWorkExecution } from '@ziggs-ai/api-client';
 import { SERVER_EVENTS } from '@ziggs-ai/contracts';
 import { withAgreementContext } from './runtime/agreementContext.js';
-import { agreementLaneId, agreementIdFromLane, isContextAccessRequest } from '@ziggs-ai/api-client';
+import { agreementLaneId, isContextAccessRequest } from '@ziggs-ai/api-client';
 import { createDeclaredPollRunner } from './platform/polls/declaredPollRunner.js';
-import { randomUUID } from 'node:crypto';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { contextScopesFromWake, WakeEffects, workScopeFromWake } from './runtime/wakeEffects.js';
 import { ExecutionController, asWorkTool, executionControllers } from './runtime/executionController.js';
@@ -16,7 +18,6 @@ import { CLAUDE_SDK_TOOLS } from './brain/claudeSdkTools.js';
 import { resolveClaudeModel } from './brain/claudeCognition.js';
 import { resolveFleetModel } from './shared/fleetModel.js';
 export { DEFAULT_MODEL, resolveFleetModel } from './shared/fleetModel.js';
-import { CHAT_TOOLS } from './platform/tools/tier2/chatTools.js';
 import { contextReadTool, openTool, accessExplainTool } from './platform/tools/tier2/contextTools.js';
 import { EventQueue } from './platform/EventQueue.js';
 import { StateTimers } from './platform/StateTimers.js';
@@ -35,7 +36,7 @@ import { PROTOCOL_TOOLS } from './platform/tools/tier1/protocolTools.js';
 import { marketplaceViewTool } from './platform/tools/tier2/marketplaceTools.js';
 import { OpenAIAdapter } from './adapters/OpenAIAdapter.js';
 import { AnthropicAdapter } from './adapters/AnthropicAdapter.js';
-import { ArtifactsClient, ConnectionsClient, ContextReadClient, TelemetryClient, sendChatMessage, presentSendResult, getAgreement, getTask, annotationForSdkTool, } from '@ziggs-ai/api-client';
+import { ArtifactsClient, ConnectionsClient, ContextReadClient, TelemetryClient, getAgreement, getTask, annotationForSdkTool, } from '@ziggs-ai/api-client';
 import { isCheckoutNeed, normalizeNeeds, unmetNeeds, unmetNeedsMessage, } from './tools/needs.js';
 import { openCheckout, closeCheckout } from './checkout/open.js';
 import { resolveBackendUrl } from './shared/backendUrl.js';
@@ -56,20 +57,16 @@ async function loadConnectionPool() {
     const mod = await import(/* @vite-ignore */ modPath);
     return mod.ConnectionPool;
 }
-const DEFAULT_SESSION_RESOLVER = (normalized) => normalized.chatId;
+const DEFAULT_SESSION_RESOLVER = (normalized) => normalized.addressId ?? (normalized.event.agreementId ? `agrn-${normalized.event.agreementId}` : normalized.event.messageId ? `msgn-${normalized.event.messageId}` : null);
 /**
  * one lane key per unit of work, derived the same way as inbox wakes.
  *
- * Inbox deliveries key on `chatId` (DEFAULT_SESSION_RESOLVER). Bootstrap used to
+ * Inbox deliveries use their room when present. Bootstrap used to
  * prefer bare `agreementId`, which opened a second lane for the same task and
- * made the snapshot read treat the agreement id as a chat (`chatMissing: true`,
- * empty context). Prefer the origin chat when present; otherwise the agreement's
- * notification chat (`agrn-<agreementId>`), which is always linked after.
+ * misdirected the snapshot read. Use the agreement's local processing key. An origin link is
+ * navigation, not a delivery destination. This key creates no chat or grant.
  */
 export function laneSessionIdForTask(task) {
-    if (typeof task.originChatId === 'string' && task.originChatId) {
-        return task.originChatId;
-    }
     if (typeof task.agreementId === 'string' && task.agreementId) {
         return agreementLaneId(task.agreementId);
     }
@@ -86,7 +83,7 @@ const CHECKOUT_TICK_TIMEOUT_MS = Number(process.env.CLAUDE_SDK_CHECKOUT_TICK_TIM
  * Anything else is a custom tool, and under execution control a custom tool
  * does work: it gets a `taskId` the model fills (see asWorkTool).
  */
-const HAND_DEFINED_PLATFORM_TOOLS = new Set([...PROTOCOL_TOOLS, ...CHAT_TOOLS, ...CLAUDE_SDK_TOOLS, ...WAKE_TOOLS, marketplaceViewTool, contextReadTool, openTool, accessExplainTool]
+const HAND_DEFINED_PLATFORM_TOOLS = new Set([...PROTOCOL_TOOLS, ...CLAUDE_SDK_TOOLS, ...WAKE_TOOLS, marketplaceViewTool, contextReadTool, openTool, accessExplainTool]
     .map((tool) => toolName(tool)));
 function customToolAsWork(tool) {
     const name = toolName(tool);
@@ -111,9 +108,6 @@ function createToolManager(options) {
     // Both directions: shedding claim (taskTools array without it) sheds browse.
     const canClaim = taskTools.some((t) => t.schema.function.name === 'agreement_claim');
     const browseTools = canClaim ? [marketplaceViewTool] : [];
-    // chat_open is always-on so claim/provider kickoff (FSM) and the
-    // Claude always-on set can open the buyer chat after a store claim. CHAT_TOOLS
-    // is also folded into CLAUDE_SDK_TOOLS; Map registration makes duplicates a no-op.
     // wake_at stays registered for the FSM and for the hosted model, where it is
     // deferred behind tool search; an agent that can be handed a task
     // with a check-back rule but cannot arm a wake would have to busy-wait, and
@@ -126,7 +120,7 @@ function createToolManager(options) {
     const everydayContext = isClaudeCognition(options.cognition)
         ? [contextReadTool, openTool, accessExplainTool].filter((t) => !ownNames.has(toolName(t)))
         : [];
-    const platformTools = [...taskTools, ...CHAT_TOOLS, ...browseTools, ...claudeSdkTools, ...everydayContext, ...WAKE_TOOLS];
+    const platformTools = [...taskTools, ...browseTools, ...claudeSdkTools, ...everydayContext, ...WAKE_TOOLS];
     warnOnShadowedPlatformTools(platformTools, ownTools, options.agentId);
     const controlOn = options.executionControl ?? isClaudeCognition(options.cognition);
     toolManager.registerAll([...platformTools, ...(controlOn ? ownTools.map(customToolAsWork) : ownTools)]);
@@ -241,6 +235,11 @@ export class Agent {
     /** Tasks left active by the asking turn, failed right after it (per lane). */
     unmetTasksPendingAsk = new Map();
     wakeEffects = new AsyncLocalStorage();
+    /**
+     * The roomless lane a live wake runs on. A tool's send or read reaches the
+     * host without the wake's effect wrapper, so both look the lane up here.
+     */
+    wakeDestination = new AsyncLocalStorage();
     outboundMessages = new SeenMessages();
     confirmedPlanVersions = new SeenMessages();
     grantProviderCache = null;
@@ -312,7 +311,7 @@ export class Agent {
         this.sessionStore = options.sessionStore ?? null;
         this._validate();
         this.pollRunner = createDeclaredPollRunner(this.options, {
-            sendTo: (_agentId, text, metadata) => this.handleMessage(text, metadata ?? {}),
+            wakeTask: (_agentId, taskId) => this.wakeTaskAssignment(taskId),
         });
         this._setup();
     }
@@ -344,7 +343,7 @@ export class Agent {
         this.toolManager = services.toolManager;
         this.llm = services.llm;
         // Outbound send is HTTP (delivery law, phase 4): the agent no longer holds a
-        // socket. `POST /chats/:id/messages` persists the whole message — the same
+        // socket. `POST /messaging/messages` persists the whole message — the same
         // row the WS path persisted. Live-token streaming had no HTTP path, so
         // `chunkSender` is intentionally dropped: partials degrade, the full reply
         // is never lost (runTurn always follows a stream with a whole send-message).
@@ -352,32 +351,7 @@ export class Agent {
             operatorKey: this.options.operatorKey,
             agentId: this.options.agentId,
         };
-        const messageSender = async (message, receiverId, sessionId, messageId, conversationAgreementId, underAgreementId, taskId, sources) => {
-            const sentId = messageId ?? `sdk_${randomUUID()}`;
-            const result = await sendChatMessage({
-                chatId: sessionId,
-                // Omitted on purpose when the caller has no valid address for THIS
-                // room: the backend infers the recipient from the room's own
-                // participants.
-                receiverId,
-                text: message,
-                // messageId is the backend's (chatId, messageId) dedup key. Callers
-                // pass a wake-derived id for replay-stability; fall back to a fresh id
-                // only when absent (matches the old WS path letting the server assign).
-                messageId: sentId,
-                conversationAgreementId,
-                underAgreementId,
-                taskId,
-                ...(sources ? { sources } : {}),
-            }, creds);
-            if (!result.success)
-                throw new Error('sendChatMessage: the server did not accept this message — nothing was delivered and nobody was woken. Retry with the same messageId, which the backend dedups on.');
-            this.outboundMessages.mark(JSON.stringify([result.chatId, result.messageId]));
-            // Presented once, here, so every hosted send — FSM reply, brain tool,
-            // stream follow-up — reports the destination the same way the MCP
-            // surface does.
-            return { ...result, ...presentSendResult(result, { creds, surface: 'sdk' }) };
-        };
+        const messageSender = (command) => new MessageRecordsClient(creds.operatorKey, creds.agentId, resolveBackendUrl()).send(command);
         this.taskService = services.taskService;
         this.agreementService = services.agreementService;
         this.telemetryClient = services.telemetryClient;
@@ -413,6 +387,10 @@ export class Agent {
             taskService: services.taskService,
             agreementService: services.agreementService,
             messageSender,
+            conversationFor: (sessionId) => {
+                const lane = this.wakeDestination.getStore();
+                return lane?.sessionId === sessionId ? lane : undefined;
+            },
             toolManager: services.toolManager,
             operatorKey: this.options.operatorKey,
             agentId: this.options.agentId,
@@ -467,17 +445,17 @@ export class Agent {
                     promptBuilder: services.promptBuilder,
                 });
         this.eventQueue = new EventQueue((event, laneKey) => this._processEvent(event, laneKey));
-        // A timer frame is not a delivery: there is no watermark waiting on it and
-        // nothing to redeliver, so its failure is logged and dropped here rather
-        // than left as an unhandled rejection (made enqueue reject).
+        // Timer dispatch is at-least-once. Only successful work checkpoints this
+        // exact wake; a crash/failure leaves it durable, and an older completion
+        // cannot consume a timer armed while that work was running.
         this.stateTimers = new StateTimers((ev, laneKey) => {
-            // A check-back that fired is no longer waiting: a restart from here on
-            // must not fire it again.
-            if (ev.type === 'wake-at')
-                this.wakeLedger.done(laneKey);
-            void this.eventQueue.enqueue(ev, laneKey).catch((err) => {
+            const work = this.eventQueue.enqueue(ev, laneKey).then(() => {
+                if (ev.type === 'wake-at')
+                    this.wakeLedger.done(laneKey, ev.wakeId);
+            }).catch((err) => {
                 runtimeLog.warn('Agent', `state-timer frame failed laneKey=${laneKey}: ${err?.message || err}`);
             });
+            this.wakeLedger.track(work);
         });
     }
     executionControlOn() {
@@ -522,8 +500,10 @@ export class Agent {
         if (!this.taskService)
             return null;
         let task;
+        // Host control observation is separate from task work. Only execution state
+        // leaves this method; a stopped work context cannot observe its own stop.
         try {
-            task = await this.taskService.getTask(taskId);
+            task = await withWorkExecution(undefined, () => this.taskService.getTask(taskId));
         }
         catch (error) {
             // Unreadable is not a hold. The wake filter still drops a frame whose
@@ -537,6 +517,17 @@ export class Agent {
             return null;
         return { blocked: task.state === 'cancelled' || (task.state === 'active' && task.control?.action === 'pause'), closed: task.state === 'cancelled', control: task.control };
     }
+    /**
+     * Control on an assignment the inbox will not run yet. No wake follows, so a
+     * resume is acknowledged here too once no run of the task is live; the wake
+     * path that would otherwise answer it never comes while the delivery is blocked.
+     */
+    async observeBlockedTaskControl(taskId) {
+        const execution = await this.taskExecutionControl(taskId);
+        const idleResume = execution?.control?.action === 'resume' && !this.activeTaskRuns.get(taskId)?.size;
+        if (execution?.blocked || idleResume)
+            await this.acknowledgeExecutionControl(taskId, execution?.control);
+    }
     async acknowledgeExecutionControl(taskId, control) {
         if (control?.status !== 'requested')
             return;
@@ -605,15 +596,15 @@ export class Agent {
         }
         // Map the event to a candidate session key using the configured resolver
         // on a synthetic normalized-event shape. Default resolver buckets by
-        // chatId; agents using a different sessionResolver (agreementId, taskId,
+        // addressId; agents using a different sessionResolver (agreementId, taskId,
         // counterpartyId) will get the right lane here as long as the wire
         // event carries the corresponding id.
         const fakeNormalized = {
-            chatId: event.chatId,
+            addressId: event.addressId,
             event: { type: 'message', timestamp: Date.now(), text: '' },
         };
         let sessionId = this.sessionResolver(fakeNormalized, ownAgentId);
-        // store claims deliver agreement wakes with no chatId. Do not
+        // store claims deliver agreement wakes with no addressId. Do not
         // drop them; lane by agreement the same way task bootstrap does
         // (`agrn-<agreementId>`), never a bare agreement id.
         if (!sessionId) {
@@ -641,10 +632,10 @@ export class Agent {
         return this.eventQueue.enqueue({
             type: SERVER_EVENTS.resourceChanged,
             resource: event,
-            chatId: event.chatId,
+            addressId: event.addressId,
             taskId: event.taskId,
             agreementId,
-            // Claimer/buyer — chat_send defaults receiverId from senderId.
+            // Claimer/buyer — the canonical reply command explicitly names the requester.
             ...(actorId ? { senderId: actorId } : {}),
         }, laneKey);
     }
@@ -658,15 +649,27 @@ export class Agent {
             ['proposal_approved', 'proposal_rejected'].includes(notice?.operation ?? '') &&
             isContextAccessRequest(notice?.agreement?.grantRequest))
             return;
-        const messageId = (metadata.responsibilityId ?? metadata.messageId);
+        const messageId = (metadata.receiptId ?? metadata.messageId);
         if (messageId && this.seenMessages.has(messageId)) {
             runtimeLog.debug('Agent', `skip duplicate messageId=${messageId}`);
             return;
         }
         if (messageId)
             this.seenMessages.mark(messageId);
+        // The inbox marks a message that has no room. It has no other way back to
+        // the agent, so one that cannot be routed here stays pending, never dropped.
+        const roomless = metadata.roomless === true && !metadata.addressId;
+        const roomlessAgreementId = metadata.roomless === true && !metadata.addressId
+            && typeof metadata.agreementId === 'string' && metadata.agreementId ? metadata.agreementId : undefined;
+        const unroutable = (why) => {
+            if (messageId)
+                this.seenMessages.unmark(messageId);
+            return new Error(`handleMessage: message ${messageId ?? '(no id)'} ${roomlessAgreementId ? `under agreement ${roomlessAgreementId}` : 'with an exact action'} has no address and ${why}. Left pending.`);
+        };
         const ownAgentId = this._resolveOwnAgentId();
         if (!ownAgentId) {
+            if (roomless)
+                throw unroutable('ownAgentId is missing');
             runtimeLog.warn('Agent', 'handleMessage: ownAgentId missing — dropping event');
             return;
         }
@@ -687,7 +690,9 @@ export class Agent {
         const normalized = normalizeIncomingEvent({ text: enrichedText, metadata, ownAgentId });
         const sessionId = this.sessionResolver(normalized, ownAgentId);
         if (!sessionId) {
-            runtimeLog.warn('Agent', `session resolver returned null ownAgentId=${ownAgentId} chatId=${normalized.chatId ?? 'null'}`);
+            if (roomless)
+                throw unroutable('the session resolver returned no lane for it');
+            runtimeLog.warn('Agent', `session resolver returned null ownAgentId=${ownAgentId} addressId=${normalized.addressId ?? 'null'}`);
             return;
         }
         const executionContext = metadata.executionContext;
@@ -695,6 +700,8 @@ export class Agent {
         if (!this.sessions.has(laneKey)) {
             this.sessions.set(laneKey, { sessionId, ownAgentId, executionContext });
         }
+        if (roomlessAgreementId)
+            this.sessions.get(laneKey).roomlessAgreementId = roomlessAgreementId;
         // The inbox loop owns ack (act-before-ack, delivery law); the agent only
         // routes the event onto its lane. No live-path watermark ack — there is no
         // separate live/push channel to reconcile against anymore.
@@ -703,7 +710,7 @@ export class Agent {
         // the same message being processed twice; leaving it set on a failed wake
         // would make the redelivery this rejection buys us a no-op.
         try {
-            await this.eventQueue.enqueue({ ...normalized.event, chatId: normalized.chatId }, laneKey);
+            await this.eventQueue.enqueue({ ...normalized.event, addressId: normalized.addressId }, laneKey);
         }
         catch (err) {
             if (messageId)
@@ -797,8 +804,7 @@ export class Agent {
             // Fail open: a lookup error must not drop a live hire's session.
         }
     }
-    async laneAgreementIsTerminal(sessionId) {
-        const agreementId = agreementIdFromLane(sessionId);
+    async agreementIsTerminal(agreementId) {
         if (!agreementId || !this.agreementService)
             return false;
         try {
@@ -822,8 +828,10 @@ export class Agent {
      * Every rule here reads a row or the frame itself. None of them reads a lane,
      * an agent kind, a name or an id shape.
      */
-    async wakeSuppression(event, sessionId) {
-        if (await this.laneAgreementIsTerminal(sessionId)) {
+    async wakeSuppression(event, _sessionId) {
+        const execution = currentWorkExecution();
+        const agreementId = execution ? execution.agreementId : workScopeFromWake(event).agreementId;
+        if (await this.agreementIsTerminal(agreementId)) {
             return { reason: 'agreement_terminal', because: 'its agreement is terminal' };
         }
         if (this.isSettledTaskEcho(event)) {
@@ -864,7 +872,7 @@ export class Agent {
      *
      * A task frame that carries a terminal state AND a result is an echo of work
      * this agent has already finished: there is no decision left in it. Dropping it
-     * is not the same suppression as {@link laneAgreementIsTerminal}, which waits
+     * is not the same suppression as {@link agreementIsTerminal}, which waits
      * for the agreement to end — this fires while the engagement is still live,
      * which is where the cost actually was.
      *
@@ -1033,17 +1041,74 @@ export class Agent {
         const tools = this.options.tools ?? this.options.services?.tools ?? [];
         return tools.some((t) => toolName(t) === 'connection_request');
     }
+    /**
+     * The work destination comes from the selected execution first, then the
+     * structured wake. It does not depend on an earlier message being delivered
+     * to this host, so task-first and restarted/scheduled runs work identically.
+     * A reply defaults to the message that woke it, and to the wake's task.
+     * A lane name is never an address: a conversation comes from a message.
+     */
+    wakeDestinationFor(session, frame, marks) {
+        const asFrame = (value) => value && typeof value === 'object' ? value : {};
+        const text = (value) => typeof value === 'string' && value ? value : undefined;
+        const execution = session.executionContext;
+        const wake = asFrame(frame);
+        const events = wake.type === 'batch' && Array.isArray(wake.events) ? wake.events.map(asFrame) : undefined;
+        // The shared conversations this wake's own messages arrived in.
+        const rooms = [...new Set((events ?? [wake]).filter(e => e.type === 'message').map(e => text(e.addressId)).filter((id) => !!id))];
+        const room = rooms.length === 1 ? rooms[0] : undefined;
+        // A direct execution exists to answer one exact message.
+        const actionMessageId = execution && !execution.agreementId && execution.action?.kind === 'message' ? text(execution.action.id) : undefined;
+        // Agreement work answers in its own conversation; only a lane without work
+        // execution, or a direct execution, keeps the room its messages came from.
+        const remembers = !execution || !!actionMessageId;
+        if (remembers && rooms.length)
+            session.addressId = room && (session.addressId === undefined || session.addressId === room) ? room : null;
+        const remembered = remembers ? session.addressId ?? undefined : undefined;
+        const explicitAgreement = text(wake.agreementId) ?? text(wake.resource?.agreementId) ?? text(wake.result?.agreementId)
+            ?? (events ? marks.scope.agreementId : undefined);
+        const explicitChat = text(wake.addressId) ?? text(wake.resource?.addressId);
+        // An exact incoming message supplies its reply address, and a batch of
+        // messages from one room keeps that room; from several rooms the agent
+        // names one. Work execution supplies authority, never a transport
+        // default: under it, other events' navigation hints select no chat.
+        const addressId = wake.type === 'message' ? explicitChat
+            : events ? room ?? (rooms.length ? undefined : remembered)
+                : execution ? remembered
+                    : explicitChat ?? remembered;
+        // An unscoped batch cannot borrow a previous customer's agreement.
+        const agreementId = execution ? execution.agreementId ?? undefined
+            : explicitAgreement ?? (events ? undefined : session.roomlessAgreementId);
+        const message = wake.type === 'message' && text(wake.messageId)
+            ? { messageId: wake.messageId, ...(text(wake.senderId) ? { senderId: wake.senderId } : {}), ...(text(wake.taskId) ? { taskId: wake.taskId } : {}) }
+            : actionMessageId ? { messageId: actionMessageId } : undefined;
+        const inputRooms = rooms.length > 1 ? rooms : undefined;
+        if (!agreementId && !addressId && !message && !inputRooms)
+            return undefined;
+        const taskId = execution ? execution.taskId ?? undefined : marks.scope.taskId;
+        return {
+            sessionId: session.sessionId,
+            agreementId,
+            addressId,
+            ...(message ? { message } : {}),
+            ...(taskId ? { taskId } : {}),
+            ...(inputRooms ? { inputRooms } : {}),
+        };
+    }
     async _processEvent(event, laneKey) {
-        return withWorkExecution(this.sessions.get(laneKey)?.executionContext, () => this._processEventInContext(event, laneKey));
+        const context = this.sessions.get(laneKey)?.executionContext;
+        if (!context)
+            return this._processEventInContext(event, laneKey);
+        return runWorkExecution(context, this.options.operatorKey, () => this._processEventInContext(event, laneKey), resolveBackendUrl());
     }
     async _processEventInContext(event, laneKey) {
         const session = this.sessions.get(laneKey);
         if (!session?.sessionId)
             return;
         if (session.executionContext)
-            await validateWorkExecution(session.executionContext, this.options.operatorKey, resolveBackendUrl());
+            await validateWorkExecution(currentWorkExecution() ?? session.executionContext, this.options.operatorKey, resolveBackendUrl());
         // Presentation may call our sender an rpb-* room binding or the person we
-        // stand in for. Only an exact (chat, messageId) we successfully sent proves
+        // stand in for. Only an exact canonical messageId we successfully sent proves
         // an echo; another message from the same binding still gets a full wake.
         const incoming = event;
         const events = incoming?.type === 'batch' && Array.isArray(incoming.events) ? incoming.events : [event];
@@ -1054,7 +1119,7 @@ export class Agent {
                 && e?.source === 'active-task-snapshot' && (task?.state === 'active' || task?.state === 'in-progress')
                 && task?.assigneeId === this.options.agentId && task.taskId && task.updatedAt && this.confirmedPlanVersions.has(JSON.stringify([laneKey, JSON.stringify([task.taskId, task.updatedAt])])))
                 return false;
-            return e?.type !== 'message' || !e.messageId || !this.outboundMessages.has(JSON.stringify([e.chatId ?? session.sessionId, e.messageId]));
+            return e?.type !== 'message' || !e.messageId || !this.outboundMessages.has(e.messageId);
         });
         if (remaining.length === 0) {
             this.recordWakeOutcome(session, { kind: 'no-op', reason: events.some(e => e?.type === 'task_result') ? 'own_plan_snapshot' : 'own_message_echo' });
@@ -1179,7 +1244,9 @@ export class Agent {
         // a zombie — burning tokens and racing the redelivered retry of the same
         // event (duplicate sends, runaway per-wake input).
         const tickAbort = new AbortController();
-        const marks = WakeEffects.forWake(frame, session.sessionId);
+        const marks = session.executionContext
+            ? new WakeEffects({ agreementId: session.executionContext.agreementId ?? undefined, taskId: session.executionContext.taskId ?? undefined }, false)
+            : WakeEffects.forWake(frame, session.sessionId);
         const executionController = this.executionController(identity, tickAbort.signal, taskId => registerTaskRun(taskId));
         let heldTask;
         const pendingEffects = new Set();
@@ -1205,6 +1272,8 @@ export class Agent {
             taskRuns.clear();
         };
         const checkpoint = async (namedTaskId) => {
+            if (session.executionContext)
+                await validateWorkExecution(currentWorkExecution() ?? session.executionContext, this.options.operatorKey, resolveBackendUrl());
             if (tickAbort.signal.aborted) {
                 if (tickAbort.signal.reason?.code === 'TASK_CONTROL')
                     heldTask = tickAbort.signal.reason;
@@ -1263,11 +1332,9 @@ export class Agent {
             const sameRoom = 'sessionId' in effect && effect.sessionId === session.sessionId;
             const scopedEffect = sameRoom && effect.kind === 'read-context'
                 ? { ...effect, opts: { ...effect.opts, workScopes: contextScopesFromWake(frame, session.sessionId) } }
-                : agreementId && effect.kind === 'send-message'
-                    ? { ...effect, underAgreementId: effect.underAgreementId ?? agreementId }
-                    : agreementId && (effect.kind === 'tool-call' || effect.kind === 'record-event')
-                        ? { ...effect, serviceAgreementId: effect.serviceAgreementId ?? agreementId }
-                        : effect;
+                : agreementId && (effect.kind === 'tool-call' || effect.kind === 'record-event')
+                    ? { ...effect, serviceAgreementId: effect.serviceAgreementId ?? agreementId }
+                    : effect;
             const operation = this.eff(scopedEffect);
             pendingEffects.add(operation);
             const response = await operation.finally(() => { pendingEffects.delete(operation); });
@@ -1278,7 +1345,8 @@ export class Agent {
         };
         try {
             await checkpoint();
-            const tick = () => this.wakeEffects.run(marks, () => this.brain.tick({ event: frame, ctx: session.ctx, state: session.state, identity, eff, memory, transitionTap: this.options.transitionTap, signal: tickAbort.signal, ...(checkout ? { checkout: checkout.session } : {}) }));
+            const roomless = this.wakeDestinationFor(session, frame, marks);
+            const tick = () => this.wakeDestination.run(roomless, () => this.wakeEffects.run(marks, () => this.brain.tick({ event: frame, ctx: session.ctx, state: session.state, identity, eff, memory, transitionTap: this.options.transitionTap, signal: tickAbort.signal, ...(checkout ? { checkout: checkout.session } : {}) })));
             tickWork = executionController ? executionControllers.run(executionController, tick) : tick();
             const result = await Promise.race([
                 tickWork,
@@ -1289,6 +1357,9 @@ export class Agent {
                     }, checkout ? Math.max(this.tickTimeoutMs, CHECKOUT_TICK_TIMEOUT_MS) : this.tickTimeoutMs);
                 }),
             ]);
+            // Protected writes validate at their owner. A successful turn may have
+            // completed its own task/answer, so post-turn admission would reject success.
+            // Retained state is validated again before the next turn.
             session.ctx = result.ctx;
             this.carryExecutionState(session.ctx, executionController);
             session.state = result.state;
@@ -1397,8 +1468,8 @@ export class Agent {
             const ev = event;
             const senderType = String(ev?.senderType ?? '').toUpperCase();
             const senderId = ev?.senderId;
-            if (senderId && senderType === 'USER') {
-                this.eff({ kind: 'send-message', sessionId: session.sessionId, receiverId: senderId, text: 'Something went wrong. Please try again.' }).catch(() => { });
+            if (senderId && senderType === 'USER' && err?.code !== 'REQUIRED_CONTEXT_UNAVAILABLE') {
+                responseCommand(this.eff, session.sessionId, 'Something went wrong. Please try again.', { recipientId: senderId }).then(command => this.eff({ kind: 'send-message', sessionId: session.sessionId, command })).catch(() => { });
             }
             // and then say so. Everything above is recovery for the lane —
             // it does not mean the event was handled, and the caller is about to
@@ -1495,13 +1566,15 @@ export class Agent {
      * Borrowing that path would make a dev tool able to disturb a live one.
      */
     async replayWake(record) {
-        return withWorkExecution(record.executionContext, () => this.replayWakeInContext(record));
+        if (!record.executionContext)
+            return this.replayWakeInContext(record);
+        return runWorkExecution(record.executionContext, this.options.operatorKey, () => this.replayWakeInContext(record), resolveBackendUrl());
     }
     async replayWakeInContext(record) {
         if (!record?.sessionId)
             throw new Error('replayWake: record.sessionId is required');
         if (record.executionContext)
-            await validateWorkExecution(record.executionContext, this.options.operatorKey, resolveBackendUrl());
+            await validateWorkExecution(currentWorkExecution() ?? record.executionContext, this.options.operatorKey, resolveBackendUrl());
         const identity = {
             agentId: record.agentId || this.options.agentId,
             sessionId: record.sessionId,
@@ -1522,11 +1595,14 @@ export class Agent {
         // Same watchdog as a live wake, for the same reason: an unaborted Claude
         // query outlives the promise that abandoned it and keeps spending.
         const abort = new AbortController();
-        const marks = WakeEffects.forWake(record.event, identity.sessionId);
+        const marks = record.executionContext
+            ? new WakeEffects({ agreementId: record.executionContext.agreementId ?? undefined, taskId: record.executionContext.taskId ?? undefined }, false)
+            : WakeEffects.forWake(record.event, identity.sessionId);
+        const destination = this.wakeDestinationFor({ sessionId: record.sessionId, ownAgentId: identity.agentId, executionContext: record.executionContext }, record.event, marks);
         const controller = this.executionController(identity, abort.signal);
         let watchdog;
         try {
-            const tick = () => this.wakeEffects.run(marks, () => this.brain.tick({
+            const tick = () => this.wakeDestination.run(destination, () => this.wakeEffects.run(marks, () => this.brain.tick({
                 event: record.event,
                 ctx: record.ctx,
                 state: record.state,
@@ -1535,7 +1611,7 @@ export class Agent {
                 memory,
                 transitionTap: this.options.transitionTap,
                 signal: abort.signal,
-            }));
+            })));
             const result = await Promise.race([
                 controller ? executionControllers.run(controller, tick) : tick(),
                 new Promise((_, reject) => {
@@ -1612,12 +1688,13 @@ export class Agent {
                 onResourceEvent: (event) => {
                     return this.handleResourceEvent(event);
                 },
+                onTaskControlCheck: (taskId) => this.observeBlockedTaskControl(taskId),
                 // work delivered by the inbox's task channel, not by a chat
                 // row — this is what reaches a task under a chat-less agreement or one
                 // the agent assigned to itself.
-                onTask: async (task) => {
+                onTask: async (task, inputs) => {
                     try {
-                        await this.wakeTaskAssignment(task.taskId, { fromInbox: true });
+                        await this.wakeTaskAssignment(task.taskId, { fromInbox: true, inputs });
                     }
                     catch (err) {
                         runtimeLog.warn(this.options.name || 'agent', `inbox task ${task.taskId} could not be woken: ${err.message}`);
@@ -1645,13 +1722,18 @@ export class Agent {
         const laneKey = laneKeyFor(this.options.agentId, sessionId);
         const scope = this.wakeEffects.getStore()?.scope;
         const armed = this.stateTimers.armWakeAt(laneKey, at, reason, scope);
+        // The conversation the lane's messages came from, so a restarted host
+        // answers there too instead of reading the lane name as an address.
+        const addressId = this.sessions.get(laneKey)?.addressId;
         this.wakeLedger.arm({
             laneKey,
             sessionId,
             firesAt: armed.firesAt,
+            wakeId: armed.wakeId,
             reason,
             ...(scope ? { scope } : {}),
-            executionContext: currentWorkExecution(),
+            ...(addressId ? { addressId } : {}),
+            executionContext: currentWorkExecution() ? { ...currentWorkExecution(), attemptId: undefined } : undefined,
         });
         return { ...armed, durable: this.wakeLedger.durable };
     }
@@ -1679,10 +1761,10 @@ export class Agent {
             if (this.stateTimers.peek(wake.laneKey))
                 continue;
             if (!this.sessions.has(wake.laneKey)) {
-                this.sessions.set(wake.laneKey, { sessionId: wake.sessionId, ownAgentId: agentId, executionContext: wake.executionContext });
+                this.sessions.set(wake.laneKey, { sessionId: wake.sessionId, ownAgentId: agentId, executionContext: wake.executionContext, ...(wake.addressId ? { addressId: wake.addressId } : {}) });
             }
             try {
-                this.stateTimers.armWakeAt(wake.laneKey, wake.firesAt, wake.reason, wake.scope);
+                this.stateTimers.armWakeAt(wake.laneKey, wake.firesAt, wake.reason, wake.scope, wake.wakeId);
                 runtimeLog.info(this.options.name || 'agent', `re-armed a saved wake laneKey=${wake.laneKey} at=${new Date(wake.firesAt).toISOString()}`);
             }
             catch (err) {
@@ -1705,11 +1787,17 @@ export class Agent {
         }
         const needle = request.match.trim();
         const title = request.title?.trim() || needle;
-        await this.handleMessage(`New marketplace request matching your tags (${needle}): ${title}. Claim with agreement_claim if you will take it.`, {
-            messageId: `request-wake:${request.agreementId}:${request.ts}`,
-            chatId: `marketplace:${request.agreementId}`,
-            agreementId: request.agreementId,
-        });
+        // The request is read by its agreement. It has no message and no
+        // conversation, so the wake names neither.
+        try {
+            await this.handleMessage(`New marketplace request matching your tags (${needle}): ${title}. Claim with agreement_claim if you will take it.`, { agreementId: request.agreementId });
+        }
+        catch (err) {
+            // An open request is an offer to look, not assigned work, and it stays
+            // open in the marketplace. A wake that could not read it must not hold
+            // every other delivery in the pass behind it.
+            runtimeLog.warn(this.options.name || 'agent', `request ${request.agreementId}: wake failed, left open in the marketplace: ${err?.message || err}`);
+        }
     }
     /** replay task-assigned for an existing active task (demo recovery). */
     async wakeTaskAssignment(taskId, options) {
@@ -1722,21 +1810,23 @@ export class Agent {
         if (state !== 'active' && state !== 'in-progress') {
             return;
         }
+        const selected = currentWorkExecution();
         const sessionId = laneSessionIdForTask(full);
-        const laneKey = laneKeyFor(agentId, sessionId);
+        const laneKey = laneKeyFor(agentId, sessionId, selected?.contextId);
         if (!this.sessions.has(laneKey)) {
             this.sessions.set(laneKey, { sessionId, ownAgentId: agentId, executionContext: currentWorkExecution() });
         }
         await this.eventQueue.enqueue({
             type: 'task_result',
-            ...(options?.fromInbox ? { source: 'active-task-snapshot' } : {}),
+            // New facts must not disappear behind an unchanged task snapshot version.
+            ...(options?.fromInbox && !options.inputs?.length ? { source: 'active-task-snapshot' } : {}),
             result: {
                 ...full,
+                ...(options?.inputs?.length ? { inputs: options.inputs } : {}),
                 taskId: full.taskId ?? taskId,
                 state,
                 providerIsYou: true,
             },
-            chatId: sessionId,
         }, laneKey);
     }
     /**

package/dist/brain/ClaudeBrain.d.ts

@@ -5,7 +5,6 @@ import type { ToolManager } from '../tools/ToolManager.js';
 import { type RawEvent } from '../runtime/buildOutcome.js';
 import type { TickInput, TickOutput } from './ZiggsBrain.js';
 import { type AskWakeGate } from './wakeGate.js';
-export { isPublishProbeChat } from '../probeChat.js';
 /**
  * status notices must not spend a Claude turn answering
  * nobody. Real work wakes arrive as chat `message`, synthetic `task_result`