@ziggs-ai/agent-sdk 0.22.0 → 0.24.0

package/dist/Agent.d.ts

@@ -230,9 +230,13 @@ export declare class Agent {
     options: Required<Pick<AgentOptions, 'agentId' | 'operatorKey' | 'openaiKey'>> & AgentOptions;
     toolManager: ToolManager;
     llm?: OpenAIAdapter | LlmAdapter;
-    brain: ZiggsBrain | ClaudeBrain;
+    brain: ZiggsBrain | ClaudeBrain | {
+        workflow: ZiggsBrain['workflow'];
+        tick: import('./brain/index.js').HandlerBrainConfig['tick'];
+    };
     private eff;
     private eventQueue;
+    private activeTaskRuns;
     private sessions;
     private sessionResolver;
     private tickTimeoutMs;
@@ -265,6 +269,9 @@ export declare class Agent {
     constructor(options?: AgentOptions);
     private _validate;
     private _setup;
+    /** Runtime control is a task fact, never model-interpreted message text. */
+    private taskExecutionControl;
+    private acknowledgeExecutionControl;
     /**
      * Handler for a resource change (artifact created, task state transition,
      * agreement updated) surfaced by the inbox loop. The agent decides which
@@ -305,7 +312,6 @@ export declare class Agent {
      * wake keys on the live room / hire.
      */
     private dropStaleCancelledAgreementSession;
-    private formedByForHireActivation;
     private laneAgreementIsTerminal;
     /**
      * Whether the host answers this wake without spending a model turn.

package/dist/Agent.js

@@ -1,8 +1,9 @@
+import { withAgreementContext } from './runtime/agreementContext.js';
 import { agreementLaneId, agreementIdFromLane } from '@ziggs-ai/api-client';
 import { createDeclaredPollRunner } from './platform/polls/declaredPollRunner.js';
 import { randomUUID } from 'node:crypto';
 import { AsyncLocalStorage } from 'node:async_hooks';
-import { WakeEffects } from './runtime/wakeEffects.js';
+import { contextScopesFromWake, WakeEffects, workScopeFromWake } from './runtime/wakeEffects.js';
 export { workScopeFromWake } from './runtime/wakeEffects.js';
 import { ZiggsBrain } from './brain/ZiggsBrain.js';
 import { ClaudeBrain } from './brain/ClaudeBrain.js';
@@ -17,6 +18,7 @@ import { WAKE_TOOLS } from './platform/tools/tier1/wakeTools.js';
 import { createZiggsEffectHandler } from './platform/ZiggsEffectHandler.js';
 import { normalizeIncomingEvent } from './ingress/normalizeIncoming.js';
 import { PromptBuilder } from './runtime/PromptBuilder.js';
+import { removeTaskBook } from './runtime/taskBookkeeping.js';
 import { InMemoryStore, hireIdsFromEvent, memorySectionForWake, partitionMemoryStore, uniqueHireIds, } from './memory/MemoryStore.js';
 import { ToolManager } from './tools/ToolManager.js';
 import { toolName } from './tools/defineTool.js';
@@ -133,7 +135,7 @@ function createBackendServices(options) {
     // the provider client throws at construction on a missing key, so a claude-sdk
     // agent left on the default (OpenAI) model with no openaiKey would fail to
     // start over an adapter it never uses. Skip it.
-    const llm = isClaudeCognition(options.cognition)
+    const llm = options.brain?.kind === 'handler' || isClaudeCognition(options.cognition)
         ? undefined
         : isLlmAdapter(options.services?.llm)
             ? options.services.llm
@@ -179,6 +181,8 @@ export class Agent {
     brain;
     eff;
     eventQueue;
+    // In-process ticks only; durable intent remains on the existing task row.
+    activeTaskRuns = new Map();
     sessions = new Map();
     sessionResolver;
     tickTimeoutMs;
@@ -269,7 +273,10 @@ export class Agent {
         this._setup();
     }
     _validate() {
-        if (isClaudeCognition(this.options.cognition)) {
+        if (this.options.brain?.kind === 'handler') {
+            // Deterministic handlers use no model adapter or credentials.
+        }
+        else if (isClaudeCognition(this.options.cognition)) {
             if (!this.options.anthropicKey) {
                 throw new Error('anthropicKey is required for the Claude brain — pass claudeBrain({ anthropicKey }) or set ANTHROPIC_API_KEY');
             }
@@ -301,7 +308,7 @@ export class Agent {
             operatorKey: this.options.operatorKey,
             agentId: this.options.agentId,
         };
-        const messageSender = async (message, receiverId, sessionId, messageId) => {
+        const messageSender = async (message, receiverId, sessionId, messageId, conversationAgreementId) => {
             const sentId = messageId ?? `sdk_${randomUUID()}`;
             const result = await sendChatMessage({
                 chatId: sessionId,
@@ -314,6 +321,7 @@ export class Agent {
                 // 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,
             }, 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.');
@@ -340,7 +348,7 @@ export class Agent {
             // The Claude brain has no FSM — it drives query() per wake and parks. It
             // still plugs into the agent's lane/timer machinery via a trivial parked
             // workflow, synthesized here so callers don't hand-write a dummy one.
-            if (isClaudeCognition(this.options.cognition)) {
+            if (this.options.brain?.kind === 'handler' || isClaudeCognition(this.options.cognition)) {
                 workflow = {
                     id: this.options.agentId,
                     description: this.options.description,
@@ -378,29 +386,31 @@ export class Agent {
                 armWakeAt: (sessionId, at, reason) => this.stateTimers.armWakeAt(laneKeyFor(this.options.agentId, sessionId), at, reason, this.wakeEffects.getStore()?.scope),
             },
         });
-        this.brain = isClaudeCognition(this.options.cognition)
-            ? new ClaudeBrain({
-                workflow,
-                toolManager: services.toolManager,
-                description: this.options.description,
-                systemPrompt: this.options.systemPrompt,
-                specialization: this.options.specialization,
-                model: resolveClaudeModel(this.options.model, this.options.services?.llm?.model),
-                anthropicKey: this.options.anthropicKey,
-                operatorKey: this.options.operatorKey,
-                agentId: this.options.agentId,
-                // No taskService/agreementService: Claude-brain tools execute through
-                // eff({ kind: 'tool-call' }) → the shared executor, which sources those
-                // services from the effect handler's deps like the FSM path.
-                maxTurns: this.options.claudeMaxTurns,
-                statelessPerWake: this.options.claudeStatelessPerWake,
-                actsOnHireActivation: this.options.actsOnHireActivation === true,
-            })
-            : new ZiggsBrain({
-                workflow,
-                toolManager: services.toolManager,
-                promptBuilder: services.promptBuilder,
-            });
+        this.brain = this.options.brain?.kind === 'handler'
+            ? { workflow, tick: this.options.brain.config.tick }
+            : isClaudeCognition(this.options.cognition)
+                ? new ClaudeBrain({
+                    workflow,
+                    toolManager: services.toolManager,
+                    description: this.options.description,
+                    systemPrompt: this.options.systemPrompt,
+                    specialization: this.options.specialization,
+                    model: resolveClaudeModel(this.options.model, this.options.services?.llm?.model),
+                    anthropicKey: this.options.anthropicKey,
+                    operatorKey: this.options.operatorKey,
+                    agentId: this.options.agentId,
+                    // No taskService/agreementService: Claude-brain tools execute through
+                    // eff({ kind: 'tool-call' }) → the shared executor, which sources those
+                    // services from the effect handler's deps like the FSM path.
+                    maxTurns: this.options.claudeMaxTurns,
+                    statelessPerWake: this.options.claudeStatelessPerWake,
+                    actsOnHireActivation: this.options.actsOnHireActivation === true,
+                })
+                : new ZiggsBrain({
+                    workflow,
+                    toolManager: services.toolManager,
+                    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
@@ -411,6 +421,49 @@ export class Agent {
             });
         });
     }
+    /** Runtime control is a task fact, never model-interpreted message text. */
+    async taskExecutionControl(taskId) {
+        if (!this.taskService)
+            return null;
+        let task;
+        try {
+            task = await this.taskService.getTask(taskId);
+        }
+        catch (error) {
+            if ([403, 404].includes(error.status ?? 0))
+                return { blocked: true };
+            throw error;
+        }
+        // A coordinator sees its children's task events too; those do not pause it.
+        if (task.executorIsYou !== true && task.assigneeId !== this.options.agentId)
+            return null;
+        return { blocked: task.state === 'cancelled' || (task.state === 'active' && task.control?.action === 'pause'), closed: task.state === 'cancelled', control: task.control };
+    }
+    async acknowledgeExecutionControl(taskId, control) {
+        if (control?.status !== 'requested')
+            return;
+        try {
+            if (control.action !== 'resume') {
+                // Custom session resolvers may run the same task in different lanes.
+                // Acknowledgement covers all of this runtime's task executions.
+                const active = [...(this.activeTaskRuns.get(taskId) ?? [])];
+                for (const run of active) {
+                    run.control = control;
+                    run.abort.abort(Object.assign(new Error('Task execution held'), { code: 'TASK_CONTROL', taskId, control }));
+                }
+                // The finishing run acknowledges after its actual operations settle.
+                // A tool that ignores cancellation must not hold up this inbox lane.
+                if (active.length)
+                    return;
+            }
+            await this.taskService?.acknowledgeControl(taskId, control.requestId);
+        }
+        catch (error) {
+            // A newer user request wins. Its durable inbox event will be handled next.
+            if (error.status !== 409)
+                runtimeLog.warn('Agent', `control acknowledgement failed for ${taskId}: ${error.message}`);
+        }
+    }
     /**
      * Handler for a resource change (artifact created, task state transition,
      * agreement updated) surfaced by the inbox loop. The agent decides which
@@ -612,24 +665,6 @@ export class Agent {
             // Fail open: a lookup error must not drop a live hire's session.
         }
     }
-    async formedByForHireActivation(event) {
-        const fromWake = formedByFromWake(event);
-        if (fromWake)
-            return fromWake;
-        const agreementId = agreementIdFromWake(event);
-        if (!agreementId || !this.agreementService)
-            return undefined;
-        try {
-            const agreement = await this.agreementService.get(agreementId);
-            const formedBy = agreement?.formedBy;
-            if (formedBy === 'agent' || formedBy === 'principal')
-                return formedBy;
-        }
-        catch {
-            // Fail open: a lookup error must not drop a person's store-claim wake.
-        }
-        return undefined;
-    }
     async laneAgreementIsTerminal(sessionId) {
         const agreementId = agreementIdFromLane(sessionId);
         if (!agreementId || !this.agreementService)
@@ -666,7 +701,13 @@ export class Agent {
             };
         }
         if (isHireActivationNotice(event)) {
-            const formedBy = await this.formedByForHireActivation(event);
+            const id = agreementIdFromWake(event);
+            const agreement = id && this.options.actsOnHireActivation !== true
+                ? await this.agreementService.get(id).catch(() => null)
+                : null;
+            if (agreement?.terms?.interactionMode === 'tasks')
+                return { reason: 'task_only_activation', because: 'task-only service waits for assigned work' };
+            const formedBy = formedByFromWake(event) ?? agreement?.formedBy;
             if (shouldSkipAgentFormedHireActivation({
                 event,
                 formedBy,
@@ -894,9 +935,10 @@ export class Agent {
             return;
         // Stale timer frames (superseded epoch) are dropped BEFORE touching the
         // live timer — a pure-stale frame must not reset a freshly armed countdown.
-        const frame = this.stateTimers.stripStale(event, laneKey);
+        let frame = this.stateTimers.stripStale(event, laneKey);
         if (frame === null)
             return;
+        frame = await withAgreementContext(frame, id => this.agreementService.get(id));
         // Traffic resets inactivity timers, but must not cancel an appointment
         // the agent explicitly requested. Only its own fresh timer frame consumes
         // that wake; a notice-only tick cannot ask the model to restore it.
@@ -921,7 +963,48 @@ export class Agent {
             sessionId: session.sessionId,
             laneKey,
         };
+        // Cache only within this wake. Long turns refresh at action boundaries at
+        // most once per second, without a read per tool or a fallible final read.
+        const controls = new Map();
+        const readControl = async (taskId) => {
+            const cached = controls.get(taskId);
+            if (cached && Date.now() - cached.at < 1000)
+                return cached.value;
+            const value = await this.taskExecutionControl(taskId);
+            controls.set(taskId, { at: Date.now(), value });
+            return value;
+        };
+        const frames = frame?.type === 'batch'
+            ? frame.events : [frame];
+        const runnable = [];
+        for (const item of frames) {
+            const taskId = workScopeFromWake(item, session.sessionId).taskId;
+            const execution = taskId ? await readControl(taskId) : null;
+            if (taskId && execution?.blocked) {
+                // The brain never sees this frame, so close the books here the way a
+                // task-closed outcome would; a paused task is still open work.
+                if (session.ctx && execution.closed)
+                    removeTaskBook(session.ctx, taskId);
+                if (session.ctx?.activeTaskId === taskId)
+                    session.ctx = { ...session.ctx, activeTaskId: null };
+                if (this.sessionStore)
+                    await this.sessionStore.save(laneKey, { ctx: session.ctx, state: session.state });
+                await this.acknowledgeExecutionControl(taskId, execution.control);
+            }
+            else {
+                if (taskId && execution?.control?.action === 'resume')
+                    await this.acknowledgeExecutionControl(taskId, execution.control);
+                runnable.push(item);
+            }
+        }
+        if (!runnable.length) {
+            this.recordWakeOutcome(session, { kind: 'no-op', reason: 'task_control' });
+            return;
+        }
+        if (runnable.length !== frames.length)
+            frame = runnable.length === 1 ? runnable[0] : { type: 'batch', events: runnable };
         const memory = this.memoryForWake(session, frame);
+        const wakeTaskId = workScopeFromWake(frame, session.sessionId).taskId;
         // Recorded here rather than after the tick: this is the last point where the
         // input is still exactly what the brain will see, and a wake that goes on to
         // throw is the one most worth replaying.
@@ -950,16 +1033,81 @@ export class Agent {
         // event (duplicate sends, runaway per-wake input).
         const tickAbort = new AbortController();
         const marks = WakeEffects.forWake(frame, session.sessionId);
+        let heldTask;
+        const pendingEffects = new Set();
+        let savedSession;
+        let tickWork;
+        const taskRuns = new Map();
+        const registerTaskRun = (taskId) => {
+            if (taskRuns.has(taskId))
+                return;
+            const run = { abort: tickAbort };
+            const active = this.activeTaskRuns.get(taskId) ?? new Set();
+            active.add(run);
+            this.activeTaskRuns.set(taskId, active);
+            taskRuns.set(taskId, { run, release: () => {
+                    active.delete(run);
+                    if (!active.size)
+                        this.activeTaskRuns.delete(taskId);
+                } });
+        };
+        const releaseTaskRuns = () => {
+            for (const { release } of taskRuns.values())
+                release();
+            taskRuns.clear();
+        };
+        const checkpoint = async (effectTaskId) => {
+            if (tickAbort.signal.aborted) {
+                if (tickAbort.signal.reason?.code === 'TASK_CONTROL')
+                    heldTask = tickAbort.signal.reason;
+                throw tickAbort.signal.reason;
+            }
+            if (heldTask)
+                throw new Error('Task execution held');
+            const taskId = effectTaskId ?? marks.scope.taskId ?? wakeTaskId;
+            if (!taskId)
+                return;
+            registerTaskRun(taskId);
+            const execution = await readControl(taskId);
+            if (heldTask)
+                throw new Error('Task execution held');
+            if (execution?.blocked) {
+                heldTask = { taskId, control: execution.control };
+                taskRuns.get(taskId).run.control = execution.control;
+                tickAbort.abort(Object.assign(new Error('Task execution held'), { code: 'TASK_CONTROL', taskId, control: execution.control }));
+                throw new Error('Task execution held');
+            }
+        };
         const eff = async (effect) => {
-            const response = await this.eff(effect);
+            // Record-only telemetry can finish after interruption. Every action and
+            // model call checks the current task before starting another operation.
+            if (effect.kind !== 'record-event') {
+                const args = effect.args;
+                const taskId = effect.kind === 'tool-call' && typeof args?.taskId === 'string' ? args.taskId : undefined;
+                await checkpoint(taskId);
+            }
+            const agreementId = marks.scope.agreementId;
+            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) } }
+                : sameRoom && agreementId && effect.kind === 'send-message'
+                    ? { ...effect, conversationAgreementId: effect.conversationAgreementId ?? agreementId }
+                    : sameRoom && 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); });
             marks.observe(effect, response);
             for (const key of marks.sentMessageKeys)
                 this.outboundMessages.mark(key);
             return response;
         };
         try {
+            await checkpoint();
+            tickWork = 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 }));
             const result = await Promise.race([
-                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 })),
+                tickWork,
                 new Promise((_, reject) => {
                     tickWatchdog = setTimeout(() => {
                         tickAbort.abort(new Error('tick timeout'));
@@ -1006,12 +1154,19 @@ export class Agent {
                 }
             }
             if (this.sessionStore) {
-                this.sessionStore.save(laneKey, { ctx: session.ctx, state: session.state }).catch((err) => {
+                savedSession = this.sessionStore.save(laneKey, { ctx: session.ctx, state: session.state });
+                void savedSession.catch((err) => {
                     runtimeLog.warn('Agent', `sessionStore.save failed laneKey=${laneKey}: ${err?.message || err}`);
                 });
             }
             // Arm only when the timeout was handled: an unhandled state-timeout must
             // not re-arm, or the lane would runtimeLog.error every timeoutMs forever.
+            if (tickAbort.signal.reason?.code === 'TASK_CONTROL')
+                heldTask = tickAbort.signal.reason;
+            if (heldTask) {
+                this.recordWakeOutcome(session, { kind: 'no-op', reason: 'task_control' });
+                return;
+            }
             if (!result.stateTimeoutUnhandled)
                 this._armIfTimedParked(laneKey, result.state);
             /**
@@ -1040,6 +1195,12 @@ export class Agent {
             }
         }
         catch (err) {
+            if (tickAbort.signal.reason?.code === 'TASK_CONTROL')
+                heldTask = tickAbort.signal.reason;
+            if (heldTask) {
+                this.recordWakeOutcome(session, { kind: 'no-op', reason: 'task_control' });
+                return;
+            }
             this.recordWakeOutcome(session, {
                 kind: 'no-op',
                 reason: 'tick_failed',
@@ -1069,9 +1230,27 @@ export class Agent {
         }
         finally {
             clearTimeout(tickWatchdog);
+            // Do not extend the tick watchdog with unbounded cleanup. Keep the
+            // run registered until its actual work settles; only then can we attest.
+            const finish = async () => {
+                await Promise.allSettled([tickWork, ...pendingEffects]);
+                try {
+                    await savedSession;
+                }
+                catch {
+                    releaseTaskRuns();
+                    return;
+                }
+                const controlsToAck = [...taskRuns].map(([taskId, { run }]) => ({ taskId, control: run.control }));
+                releaseTaskRuns();
+                for (const { taskId, control } of controlsToAck)
+                    await this.acknowledgeExecutionControl(taskId, control);
+            };
+            void finish().catch(error => runtimeLog.warn('Agent', `task control cleanup failed: ${String(error)}`));
             // Also on the failure path: a tick that threw still must not leave the
             // work it was refused for sitting active.
-            await this.settleUnmetAfterAsk(laneKey).catch(() => { });
+            if (!heldTask)
+                await this.settleUnmetAfterAsk(laneKey).catch(() => { });
         }
     }
     /**
@@ -1250,7 +1429,7 @@ export class Agent {
         const full = (await this.taskService.getTask(taskId));
         const state = String(full.state ?? '');
         if (state !== 'active' && state !== 'in-progress') {
-            throw new Error(`wakeTaskAssignment: task ${taskId} is ${state}, not active`);
+            return;
         }
         const sessionId = laneSessionIdForTask(full);
         const laneKey = laneKeyFor(agentId, sessionId);

package/dist/brain/ClaudeBrain.d.ts

@@ -4,6 +4,7 @@ import type { Workflow } from '../types.js';
 import type { ToolManager } from '../tools/ToolManager.js';
 import { type RawEvent } from '../runtime/buildOutcome.js';
 import type { TickInput, TickOutput } from './ZiggsBrain.js';
+export { isPublishProbeChat, isCapabilityProbeSession } from '../probeChat.js';
 /**
  * status notices must not spend a Claude turn answering
  * nobody. Real work wakes arrive as chat `message`, synthetic `task_result`
@@ -22,12 +23,6 @@ import type { TickInput, TickOutput } from './ZiggsBrain.js';
  * message still lands in chat history and arrives as context on the next
  * real wake — skipped here is the LLM turn, not the information.
  */
-/**
- * Store publish chats the agent in a room named `probe_<agentId>_<ts>`.
- * That check is "are you connected and can you reply", not a hired job —
- * spending a model turn on it is how a long skill prompt 504s the gate.
- */
-export declare function isCapabilityProbeSession(sessionId: string | undefined | null): boolean;
 export declare function isNoticeOnlyWake(event: RawEvent | undefined, ownAgentId?: string | null): boolean;
 export type CognitionKind = 'fsm' | 'claude-sdk';
 export interface ClaudeBrainOptions {
@@ -88,8 +83,6 @@ export declare class ClaudeBrain implements Brain {
     workflow: Workflow;
     toolManager: ToolManager;
     private rolePrompt;
-    /** Store one-liner — used when the publish probe asks who we are. */
-    private listingBlurb;
     private specialization;
     private model;
     private anthropicKey;

package/dist/brain/ClaudeBrain.js

@@ -1,4 +1,5 @@
 import { getAgreement } from '@ziggs-ai/api-client';
+import { permitsAutomaticMandate } from '../runtime/agreementContext.js';
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { isMessageAddressedElsewhere, outcomeFromEvent } from '../runtime/buildOutcome.js';
 import { getBatchEvents } from '../context/batch.js';
@@ -12,6 +13,8 @@ import { runtimeLog } from '../shared/runtimeLog.js';
 import { resolveOnBehalfAgreementId, } from './onBehalfAgreement.js';
 import { filterStandingOfferNotices, isReadableAgreementNoticeLane } from './standingOfferNotice.js';
 import { formedByFromWake, shouldSkipAgentFormedHireActivation, } from './hireActivationNotice.js';
+import { isPublishProbeChat } from '../probeChat.js';
+export { isPublishProbeChat, isCapabilityProbeSession } from '../probeChat.js';
 /**
  * status notices must not spend a Claude turn answering
  * nobody. Real work wakes arrive as chat `message`, synthetic `task_result`
@@ -30,14 +33,6 @@ import { formedByFromWake, shouldSkipAgentFormedHireActivation, } from './hireAc
  * message still lands in chat history and arrives as context on the next
  * real wake — skipped here is the LLM turn, not the information.
  */
-/**
- * Store publish chats the agent in a room named `probe_<agentId>_<ts>`.
- * That check is "are you connected and can you reply", not a hired job —
- * spending a model turn on it is how a long skill prompt 504s the gate.
- */
-export function isCapabilityProbeSession(sessionId) {
-    return typeof sessionId === 'string' && sessionId.startsWith('probe_');
-}
 export function isNoticeOnlyWake(event, ownAgentId) {
     const events = getBatchEvents(event);
     if (events.length === 0)
@@ -186,8 +181,6 @@ export class ClaudeBrain {
     workflow;
     toolManager;
     rolePrompt;
-    /** Store one-liner — used when the publish probe asks who we are. */
-    listingBlurb;
     specialization;
     model;
     anthropicKey;
@@ -220,7 +213,6 @@ export class ClaudeBrain {
         // 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.listingBlurb = opts.description;
         this.specialization = opts.specialization ?? null;
         this.model = opts.model;
         this.anthropicKey = opts.anthropicKey;
@@ -279,36 +271,6 @@ export class ClaudeBrain {
                 metrics: { llmCalls: 0, tokens: { total: 0, input: 0, output: 0 } },
             };
         }
-        // Store publish must hear a reply even when leftover mail already tripped
-        // the wake-rate breaker. The breaker used to sit above this and park the
-        // probe with no send-message — Register then died on ALB 504.
-        if (nextCtx.lastOutcome?.kind === 'message-received' &&
-            isCapabilityProbeSession(identity.sessionId)) {
-            const text = `I received your message. ${this.listingBlurb.trim().split(/\r?\n/)[0]?.trim() || 'I am online.'}`;
-            const writeKeys = createDeliveryWriteKeys(identity.laneKey, rawEvent);
-            const senderId = rawEvent?.senderId != null && String(rawEvent.senderId).trim() !== ''
-                ? String(rawEvent.senderId)
-                : undefined;
-            await eff({
-                kind: 'send-message',
-                sessionId: identity.sessionId,
-                ...(senderId ? { receiverId: senderId } : {}),
-                text,
-                messageId: writeKeys.messageKey({
-                    text,
-                    sessionId: identity.sessionId,
-                    receiverId: senderId,
-                }),
-            });
-            runtimeLog.info('ClaudeBrain', `capability-probe reply — skipping LLM session=${identity.sessionId} agent=${this.agentId}`);
-            return {
-                ctx: nextCtx,
-                state: state ?? DEFAULT_STATE,
-                parked: true,
-                stateTimeoutUnhandled: false,
-                metrics: { llmCalls: 0, tokens: { total: 0, input: 0, output: 0 } },
-            };
-        }
         const listingCheck = await filterStandingOfferNotices(rawEvent, this.agentId, readAgreement);
         if (listingCheck.ignoredAgreementIds.length > 0) {
             rawEvent = listingCheck.event;
@@ -328,7 +290,11 @@ export class ClaudeBrain {
         }
         const now = Date.now();
         const recentDeliveries = (nextCtx.recentDeliveries ?? []).filter((t) => now - t < WAKE_WINDOW_MS);
-        if (recentDeliveries.length >= MAX_WAKES_PER_WINDOW) {
+        // Store publish still has to hear a model reply when leftover mail already
+        // tripped the breaker. The prefix only skips the park — it does not write
+        // a canned answer.
+        if (recentDeliveries.length >= MAX_WAKES_PER_WINDOW &&
+            !isPublishProbeChat(identity.sessionId)) {
             runtimeLog.warn('ClaudeBrain', `wake-rate breaker tripped: ${recentDeliveries.length} wakes in ${WAKE_WINDOW_MS / 60_000}min ` +
                 `session=${identity.sessionId} agent=${this.agentId} — skipping LLM for this wake`);
             nextCtx.recentDeliveries = recentDeliveries;
@@ -409,6 +375,7 @@ export class ClaudeBrain {
             // not just task_result events — see resolveOnBehalfAgreementId.
             // Skip payer-only subs named on the worker result; bind to the
             // provider hire (see onBehalfAgreement.ts).
+            allowAutomaticMandate: permitsAutomaticMandate(rawEvent),
             onBehalfOfAgreementId: resolveOnBehalfAgreementId(rawEvent, Array.isArray(contextSnap?.agreements)
                 ? contextSnap.agreements
                 : null, this.agentId, identity.sessionId),
@@ -602,6 +569,10 @@ export class ClaudeBrain {
             await consumeQuery(resumeId);
         }
         catch (err) {
+            if (signal?.aborted && signal.reason?.code === 'TASK_CONTROL') {
+                nextCtx.claudeSessionId = this.statelessPerWake ? undefined : sessionId;
+                return { ctx: nextCtx, state: state ?? DEFAULT_STATE, parked: true, stateTimeoutUnhandled: false, metrics };
+            }
             // Turn exhaustion arrives as a thrown error result, not a break, so it
             // needs its own note before the throw propagates.
             if (isMaxTurnsError(err)) {

package/dist/brain/ZiggsBrain.d.ts

@@ -88,5 +88,5 @@ export declare class ZiggsBrain implements Brain {
     toolManager: ToolManager;
     promptBuilder: PromptBuilder;
     constructor({ workflow, toolManager, promptBuilder }: ZiggsBrainOptions);
-    tick({ event, ctx, state, identity, eff, memory, transitionTap }: TickInput): Promise<TickOutput>;
+    tick({ event, ctx, state, identity, eff, memory, transitionTap, signal }: TickInput): Promise<TickOutput>;
 }

package/dist/brain/ZiggsBrain.js

@@ -31,7 +31,7 @@ export class ZiggsBrain {
         this.toolManager = toolManager;
         this.promptBuilder = promptBuilder || new PromptBuilder();
     }
-    async tick({ event, ctx, state, identity, eff, memory, transitionTap }) {
+    async tick({ event, ctx, state, identity, eff, memory, transitionTap, signal }) {
         if (!identity?.sessionId)
             throw new Error('ZiggsBrain.tick: identity.sessionId is required');
         if (!eff)
@@ -51,7 +51,14 @@ export class ZiggsBrain {
         });
         // `send` awaits the recursive _step until the machine settles at a
         // parked state (or stops). When it returns, we have the final state.
-        await machine.send({ event: event, identity });
+        try {
+            await machine.send({ event: event, identity });
+        }
+        catch (error) {
+            if (!signal?.aborted || signal.reason?.code !== 'TASK_CONTROL')
+                throw error;
+            // Preserve completed FSM progress so Resume does not restart the task.
+        }
         return {
             ctx: machine.ctx,
             state: machine.state,