@ziggs-ai/agent-sdk 0.15.0 → 0.17.0

package/dist/adapters/AnthropicAdapter.d.ts

@@ -7,7 +7,7 @@ interface AdapterOptions {
 /**
  * Anthropic adapter satisfying the same LlmAdapter contract as OpenAIAdapter:
  * OpenAI-wire-shaped LlmMessage[] in, { content, tool_calls, usage } out.
- * Selected by AgentHost when the configured model id starts with "claude".
+ * Selected by Agent when the configured model id starts with "claude".
  */
 export declare class AnthropicAdapter {
     private client;

package/dist/adapters/AnthropicAdapter.js

@@ -8,7 +8,7 @@ const MAX_COMPLETION_TOKENS = 16000;
 /**
  * Anthropic adapter satisfying the same LlmAdapter contract as OpenAIAdapter:
  * OpenAI-wire-shaped LlmMessage[] in, { content, tool_calls, usage } out.
- * Selected by AgentHost when the configured model id starts with "claude".
+ * Selected by Agent when the configured model id starts with "claude".
  */
 export class AnthropicAdapter {
     client;

package/dist/{agent/ClaudeSdkAgent.d.ts → brain/ClaudeBrain.d.ts}

@@ -1,8 +1,9 @@
+import type { Brain } from './index.js';
 import { query } from '@anthropic-ai/claude-agent-sdk';
 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 './Agent.js';
+import type { TickInput, TickOutput } from './ZiggsBrain.js';
 /**
  * status notices must not spend a Claude turn answering
  * nobody. Real work wakes arrive as chat `message`, synthetic `task_result`
@@ -21,9 +22,15 @@ import type { TickInput, TickOutput } from './Agent.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 ClaudeSdkAgentOptions {
+export interface ClaudeBrainOptions {
     workflow: Workflow;
     toolManager: ToolManager;
     /** Store-facing one-liner. Used as the role block only when `systemPrompt` is absent. */
@@ -63,15 +70,18 @@ export interface ClaudeSdkAgentOptions {
 export declare function isMaxTurnsError(err: unknown): boolean;
 export declare function isMissingSessionError(err: unknown): boolean;
 /**
- * A Ziggs agent whose brain is the Claude Agent SDK. Same host, same `eff`
- * side channel, same tool surface as the FSM `Agent` — the ONLY difference is
+ * A brain driven by the Claude Agent SDK. Same body, same `eff`
+ * side channel, same tool surface as `ZiggsBrain` — the ONLY difference is
  * the loop: instead of the FSM + `runTurn`, a wake drives a headless Claude
  * `query()` (see "host is the product; the brain is how it decides").
  */
-export declare class ClaudeSdkAgent {
+export declare class ClaudeBrain implements Brain {
+    readonly kind: "claude";
     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;
@@ -81,12 +91,14 @@ export declare class ClaudeSdkAgent {
     private statelessPerWake;
     private queryFn;
     /**
-     * #7 — tool set is fixed at host construction; rebuilding the
-     * in-process MCP server (+ zod schema tree) every wake was pure waste.
-     * A mutable holder supplies per-wake context without closing over `tick`.
+     * Per-lane tool context. One agent object serves every room, and a
+     * wake's query can still be running when another lane starts. A single
+     * `current` field meant B's room/sender/write keys overwrote A's
+     * mid-query. Wakes on one lane stay serialized; one server per lane is
+     * enough, and getContext closes over that lane's key.
      */
-    private toolContextHolder;
-    private sdkMcpServer;
-    constructor(opts: ClaudeSdkAgentOptions);
+    private toolContextByLane;
+    private sdkMcpByLane;
+    constructor(opts: ClaudeBrainOptions);
     tick({ event, ctx, state, identity, eff, signal }: TickInput): Promise<TickOutput>;
 }

package/dist/{agent/ClaudeSdkAgent.js → brain/ClaudeBrain.js}

@@ -1,3 +1,4 @@
+import { isAgreementId } from '@ziggs-ai/api-client';
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { isMessageAddressedElsewhere, outcomeFromEvent } from '../runtime/buildOutcome.js';
 import { getBatchEvents } from '../context/batch.js';
@@ -8,6 +9,7 @@ import { buildZiggsSdkMcpServer } from './toolManagerToSdkMcp.js';
 import { claudeQueryOptions, buildClaudeEventPrompt, summarizeContext, extractAssistantText, } from './claudeCognition.js';
 import { assertHostedAgentZiggsTools } from './hostedAgentConnection.js';
 import { runtimeLog } from '../shared/runtimeLog.js';
+import { resolveOnBehalfAgreementId, } from './onBehalfAgreement.js';
 /**
  * status notices must not spend a Claude turn answering
  * nobody. Real work wakes arrive as chat `message`, synthetic `task_result`
@@ -26,6 +28,14 @@ import { runtimeLog } from '../shared/runtimeLog.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 function isCapabilityProbeSession(sessionId) {
+    return typeof sessionId === 'string' && sessionId.startsWith('probe_');
+}
 export function isNoticeOnlyWake(event, ownAgentId) {
     const events = getBatchEvents(event);
     if (events.length === 0)
@@ -164,61 +174,18 @@ function extractMetrics(message) {
     };
 }
 /**
- * Resolve the agreement this wake acts under, for a delegated per-user MCP
- * call. Without it the gateway resolves the connection owner from
- * `senderId` — which, under a delegation, is the delegating agent (who owns no
- * connection) → a spurious NO_USER_CONNECTION even though the payer IS connected.
- *
- * The id must be found on ANY wake the worker might fetch on, not just
- * `task_result` events. In practice the worker often fetches while reacting to
- * the proposal-approved / agreement-active lifecycle events, which carry the id
- * at the event top level rather than under `result`. Reading only
- * `result.agreementId` (the original wiring) left those wakes with no
- * agreement → the false "authorize your connection" prompt. Resolve from every
- * reliable source instead:
- *   1. task_result events → `result.agreementId`
- *   2. agreement-lifecycle events → top-level `agreementId`
- *   3. task lanes → `sessionId` IS the agreement id
- *   4. fallback → the single active agreement in context this agent provides
- */
-function resolveOnBehalfAgreementId(rawEvent, contextSnap, agentId, sessionId) {
-    const str = (v) => typeof v === 'string' && v ? v : undefined;
-    const fromResult = str(rawEvent?.result?.agreementId);
-    if (fromResult)
-        return fromResult;
-    const fromEvent = str(rawEvent?.agreementId);
-    if (fromEvent)
-        return fromEvent;
-    if (typeof sessionId === 'string' && sessionId.startsWith('agr_'))
-        return sessionId;
-    // Fallback: exactly one active agreement in context where this agent is the
-    // provider. Guarded to a single match so we never send the wrong agreement.
-    const ags = Array.isArray(contextSnap?.agreements)
-        ? contextSnap.agreements
-        : [];
-    const provides = ags.filter((a) => {
-        const provider = a?.parties?.provider;
-        const providerIds = [provider?.actor, a?.providerId, a?.providerAgentId, a?.executorId];
-        const isProvider = providerIds.some((x) => x === agentId);
-        const status = a?.status != null ? String(a.status).toLowerCase() : '';
-        const active = !status || status === 'active' || status === 'approved';
-        return isProvider && active;
-    });
-    if (provides.length === 1) {
-        return str(provides[0].agreementId) ?? str(provides[0].id) ?? str(provides[0]._id);
-    }
-    return undefined;
-}
-/**
- * A Ziggs agent whose brain is the Claude Agent SDK. Same host, same `eff`
- * side channel, same tool surface as the FSM `Agent` — the ONLY difference is
+ * A brain driven by the Claude Agent SDK. Same body, same `eff`
+ * side channel, same tool surface as `ZiggsBrain` — the ONLY difference is
  * the loop: instead of the FSM + `runTurn`, a wake drives a headless Claude
  * `query()` (see "host is the product; the brain is how it decides").
  */
-export class ClaudeSdkAgent {
+export class ClaudeBrain {
+    kind = 'claude';
     workflow;
     toolManager;
     rolePrompt;
+    /** Store one-liner — used when the publish probe asks who we are. */
+    listingBlurb;
     specialization;
     model;
     anthropicKey;
@@ -228,25 +195,28 @@ export class ClaudeSdkAgent {
     statelessPerWake;
     queryFn;
     /**
-     * #7 — tool set is fixed at host construction; rebuilding the
-     * in-process MCP server (+ zod schema tree) every wake was pure waste.
-     * A mutable holder supplies per-wake context without closing over `tick`.
+     * Per-lane tool context. One agent object serves every room, and a
+     * wake's query can still be running when another lane starts. A single
+     * `current` field meant B's room/sender/write keys overwrote A's
+     * mid-query. Wakes on one lane stay serialized; one server per lane is
+     * enough, and getContext closes over that lane's key.
      */
-    toolContextHolder = { current: null };
-    sdkMcpServer = null;
+    toolContextByLane = new Map();
+    sdkMcpByLane = new Map();
     constructor(opts) {
         if (!opts.workflow?.states)
-            throw new Error('ClaudeSdkAgent: workflow with states is required');
+            throw new Error('ClaudeBrain: workflow with states is required');
         if (!opts.toolManager)
-            throw new Error('ClaudeSdkAgent: toolManager is required');
+            throw new Error('ClaudeBrain: toolManager is required');
         if (!opts.anthropicKey)
-            throw new Error('ClaudeSdkAgent: anthropicKey is required');
+            throw new Error('ClaudeBrain: anthropicKey is required');
         this.workflow = opts.workflow;
         this.toolManager = opts.toolManager;
         // the prompt and the store blurb are two different strings. Agents
         // written before the split still carry the prompt in `description`, so fall
         // back to it rather than silently dropping their role.
         this.rolePrompt = opts.systemPrompt || opts.description;
+        this.listingBlurb = opts.description;
         this.specialization = opts.specialization ?? null;
         this.model = opts.model;
         this.anthropicKey = opts.anthropicKey;
@@ -258,18 +228,15 @@ export class ClaudeSdkAgent {
     }
     async tick({ event, ctx, state, identity, eff, signal }) {
         if (!identity?.sessionId)
-            throw new Error('ClaudeSdkAgent.tick: identity.sessionId is required');
+            throw new Error('ClaudeBrain.tick: identity.sessionId is required');
         if (!eff)
-            throw new Error('ClaudeSdkAgent.tick: eff is required');
+            throw new Error('ClaudeBrain.tick: eff is required');
         const rawEvent = event;
         const nextCtx = bootstrapCtx(identity, ctx);
         nextCtx.lastOutcome = outcomeFromEvent(rawEvent ?? null, identity.agentId);
-        const now = Date.now();
-        const recentDeliveries = (nextCtx.recentDeliveries ?? []).filter((t) => now - t < WAKE_WINDOW_MS);
-        if (recentDeliveries.length >= MAX_WAKES_PER_WINDOW) {
-            runtimeLog.warn('ClaudeSdkAgent', `wake-rate breaker tripped: ${recentDeliveries.length} wakes in ${WAKE_WINDOW_MS / 60_000}min ` +
-                `session=${identity.sessionId} agent=${this.agentId} — skipping LLM for this wake`);
-            nextCtx.recentDeliveries = recentDeliveries;
+        if (isNoticeOnlyWake(rawEvent, identity.agentId)) {
+            runtimeLog.info('ClaudeBrain', `notice-only wake — skipping LLM session=${identity.sessionId} agent=${this.agentId} ` +
+                `type=${rawEvent?.type ?? 'unknown'}`);
             return {
                 ctx: nextCtx,
                 state: state ?? DEFAULT_STATE,
@@ -278,10 +245,42 @@ export class ClaudeSdkAgent {
                 metrics: { llmCalls: 0, tokens: { total: 0, input: 0, output: 0 } },
             };
         }
-        nextCtx.recentDeliveries = [...recentDeliveries, now];
-        if (isNoticeOnlyWake(rawEvent, identity.agentId)) {
-            runtimeLog.info('ClaudeSdkAgent', `notice-only wake — skipping LLM session=${identity.sessionId} agent=${this.agentId} ` +
-                `type=${rawEvent?.type ?? 'unknown'}`);
+        // 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 now = Date.now();
+        const recentDeliveries = (nextCtx.recentDeliveries ?? []).filter((t) => now - t < WAKE_WINDOW_MS);
+        if (recentDeliveries.length >= MAX_WAKES_PER_WINDOW) {
+            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;
             return {
                 ctx: nextCtx,
                 state: state ?? DEFAULT_STATE,
@@ -290,6 +289,7 @@ export class ClaudeSdkAgent {
                 metrics: { llmCalls: 0, tokens: { total: 0, input: 0, output: 0 } },
             };
         }
+        nextCtx.recentDeliveries = [...recentDeliveries, now];
         let contextSnap = null;
         try {
             // #5: pre-read is for wake gating + summarizeContext (a count) +
@@ -302,7 +302,7 @@ export class ClaudeSdkAgent {
             });
         }
         catch (err) {
-            runtimeLog.warn('ClaudeSdkAgent', `read-context failed session=${identity.sessionId}: ${err.message}`);
+            runtimeLog.warn('ClaudeBrain', `read-context failed session=${identity.sessionId}: ${err.message}`);
         }
         // Same guard as the FSM's runTurn: a message wake for a chat the backend
         // no longer resolves (deleted / not visible) has no world to act in —
@@ -314,17 +314,15 @@ export class ClaudeSdkAgent {
         // signal. Loud-log that mis-key; message wakes still skip below.
         if (contextSnap?.chatMissing === true) {
             const sessionId = identity.sessionId;
-            const looksLikeBareAgreement = typeof sessionId === 'string' &&
-                sessionId.startsWith('agr_') &&
-                !sessionId.startsWith('agrn-');
+            const looksLikeBareAgreement = isAgreementId(sessionId);
             if (looksLikeBareAgreement) {
-                runtimeLog.warn('ClaudeSdkAgent', `chatMissing on non-chat sessionId=${sessionId} agent=${this.agentId} ` +
+                runtimeLog.warn('ClaudeBrain', `chatMissing on non-chat sessionId=${sessionId} agent=${this.agentId} ` +
                     `outcome=${nextCtx.lastOutcome?.kind ?? 'none'} — lane was keyed by ` +
                     `agreementId instead of the agreement's origin/notification chat; ` +
                     `wake continues with an empty snapshot`);
             }
             if (nextCtx.lastOutcome?.kind === 'message-received') {
-                runtimeLog.warn('ClaudeSdkAgent', `chat ${sessionId} not found on backend — skipping message wake agent=${this.agentId}`);
+                runtimeLog.warn('ClaudeBrain', `chat ${sessionId} not found on backend — skipping message wake agent=${this.agentId}`);
                 return {
                     ctx: nextCtx,
                     state: state ?? DEFAULT_STATE,
@@ -359,26 +357,33 @@ export class ClaudeSdkAgent {
             // MCP call resolve the originating end-user (payer) rather than the
             // delegating agent (senderId). Resolved from every reliable wire source,
             // not just task_result events — see resolveOnBehalfAgreementId.
-            onBehalfOfAgreementId: resolveOnBehalfAgreementId(rawEvent, contextSnap, this.agentId, identity.sessionId),
+            // Skip payer-only subs named on the worker result; bind to the
+            // provider hire (see onBehalfAgreement.ts).
+            onBehalfOfAgreementId: resolveOnBehalfAgreementId(rawEvent, Array.isArray(contextSnap?.agreements)
+                ? contextSnap.agreements
+                : null, this.agentId, identity.sessionId),
             runId,
             writeKeys,
         };
-        this.toolContextHolder.current = toolContext;
-        if (!this.sdkMcpServer) {
+        const lane = identity.laneKey;
+        this.toolContextByLane.set(lane, toolContext);
+        let sdkMcpServer = this.sdkMcpByLane.get(lane);
+        if (!sdkMcpServer) {
             const availableTools = await this.toolManager.getAvailableTools();
-            this.sdkMcpServer = buildZiggsSdkMcpServer(availableTools, () => {
-                const ctx = this.toolContextHolder.current;
+            sdkMcpServer = buildZiggsSdkMcpServer(availableTools, () => {
+                const ctx = this.toolContextByLane.get(lane);
                 if (!ctx) {
-                    throw new Error('ClaudeSdkAgent: tool context missing for in-process MCP call');
+                    throw new Error(`ClaudeBrain: tool context missing for lane ${lane}`);
                 }
                 return ctx;
             }, {
                 name: 'ziggs',
                 instructions: 'In-process Ziggs tools backed by api-client. No external MCP process.',
             });
+            this.sdkMcpByLane.set(lane, sdkMcpServer);
         }
         const prompt = buildClaudeEventPrompt(rawEvent, summarizeContext(contextSnap));
-        const mcpServers = { ziggs: this.sdkMcpServer };
+        const mcpServers = { ziggs: sdkMcpServer };
         assertHostedAgentZiggsTools(mcpServers);
         const queryOptions = claudeQueryOptions({
             systemPrompt,
@@ -389,7 +394,7 @@ export class ClaudeSdkAgent {
             stderr: (data) => {
                 const line = data.trim();
                 if (line)
-                    runtimeLog.warn('ClaudeSdkAgent', `stderr session=${identity.sessionId}: ${line}`);
+                    runtimeLog.warn('ClaudeBrain', `stderr session=${identity.sessionId}: ${line}`);
             },
         });
         let metrics = { llmCalls: 0, tokens: { total: 0, input: 0, output: 0, cacheRead: 0, cacheCreation: 0 } };
@@ -424,7 +429,7 @@ export class ClaudeSdkAgent {
             try {
                 for await (const message of query) {
                     if (signal?.aborted) {
-                        runtimeLog.warn('ClaudeSdkAgent', `host watchdog aborted wake session=${identity.sessionId} agent=${this.agentId} — stopping query`);
+                        runtimeLog.warn('ClaudeBrain', `host watchdog aborted wake session=${identity.sessionId} agent=${this.agentId} — stopping query`);
                         break;
                     }
                     if ('session_id' in message && typeof message.session_id === 'string') {
@@ -450,14 +455,14 @@ export class ClaudeSdkAgent {
                             // reorder key assignment against other writes of this wake.
                             const idempotencyKey = writeKeys.artifactKey({ kind: 'thought', text });
                             void eff({ kind: 'record-event', sessionId: identity.sessionId, entry: { kind: 'thought', text }, idempotencyKey })
-                                .catch((err) => runtimeLog.warn('ClaudeSdkAgent', `record thought failed session=${identity.sessionId}: ${err.message}`));
+                                .catch((err) => runtimeLog.warn('ClaudeBrain', `record thought failed session=${identity.sessionId}: ${err.message}`));
                         }
                     }
                     const m = extractMetrics(message);
                     if (m)
                         metrics = m;
                     if (message.type === 'result' && message.subtype !== 'success') {
-                        runtimeLog.warn('ClaudeSdkAgent', `query ended without success subtype=${message.subtype} session=${identity.sessionId}`);
+                        runtimeLog.warn('ClaudeBrain', `query ended without success subtype=${message.subtype} session=${identity.sessionId}`);
                     }
                     // Runaway guard: abort before an unbounded loop drains the
                     // key. Breaking the for-await calls the generator's return(),
@@ -475,7 +480,7 @@ export class ClaudeSdkAgent {
                     }
                     if (spentInput > MAX_TASK_INPUT_TOKENS) {
                         abortedBy = 'input-budget';
-                        runtimeLog.warn('ClaudeSdkAgent', `input-token budget exceeded (~${Math.round(spentInput)} cost-weighted > ${MAX_TASK_INPUT_TOKENS}) session=${identity.sessionId} agent=${this.agentId} — aborting query to cap spend`);
+                        runtimeLog.warn('ClaudeBrain', `input-token budget exceeded (~${Math.round(spentInput)} cost-weighted > ${MAX_TASK_INPUT_TOKENS}) session=${identity.sessionId} agent=${this.agentId} — aborting query to cap spend`);
                         break;
                     }
                 }
@@ -492,6 +497,44 @@ export class ClaudeSdkAgent {
          * why. The lane's history carries the reason instead, so a wedged-task
          * detector has something to read.
          */
+        /**
+         * Close the task this wake was woken for, when a guard stopped the wake
+         * before the agent could close it itself.
+         *
+         * The note above records the reason where a detector could read it. Nothing
+         * reads it, and the hirer reads none of it: the task stays `active` with no
+         * result, the wake returns parked like any other, its inbox item is acked,
+         * and the engagement looks alive forever. Measured on production — a
+         * connector agent whose tool schema costs ~20-45k input per wake spent the
+         * session budget across four wakes on one lane and its task sat untouched
+         * for as long as anyone cared to watch. The buyer had a greeting, a hire,
+         * and silence.
+         *
+         * So the guard now says the same thing the prompt tells every agent to say
+         * when it cannot do the work: fail the task, with the reason, because a
+         * visible failure the counterparty can re-route beats a silent drop.
+         * Best-effort — a wake already cut short must not throw on the way out.
+         */
+        const failTaskCutShort = async (reason) => {
+            const taskId = nextCtx.activeTaskId;
+            if (!taskId)
+                return;
+            await eff({
+                kind: 'tool-call',
+                sessionId: identity.sessionId,
+                name: 'task_set_result',
+                args: {
+                    taskId,
+                    state: 'failed',
+                    result: {
+                        summary: `Stopped before finishing: ${reason}. Nothing was filed for this task.`,
+                        status: 'failed',
+                    },
+                },
+            }).catch((err) => runtimeLog.warn('ClaudeBrain', `could not fail task ${taskId} after a cut-short wake ` +
+                `session=${identity.sessionId}: ${err.message}`));
+            runtimeLog.warn('ClaudeBrain', `failed task ${taskId} because the wake was cut short session=${identity.sessionId} agent=${this.agentId}`);
+        };
         const noteWakeCutShort = async (reason) => {
             const text = `Wake stopped early: ${reason}. Work in progress was NOT filed — no ` +
                 `artifact was recorded and no task was closed by this wake.`;
@@ -500,7 +543,7 @@ export class ClaudeSdkAgent {
                 sessionId: identity.sessionId,
                 entry: { kind: 'thought', text },
                 idempotencyKey: writeKeys.artifactKey({ kind: 'thought', text }),
-            }).catch((err) => runtimeLog.warn('ClaudeSdkAgent', `record abort note failed session=${identity.sessionId}: ${err.message}`));
+            }).catch((err) => runtimeLog.warn('ClaudeBrain', `record abort note failed session=${identity.sessionId}: ${err.message}`));
         };
         try {
             await consumeQuery(resumeId);
@@ -510,7 +553,12 @@ export class ClaudeSdkAgent {
             // needs its own note before the throw propagates.
             if (isMaxTurnsError(err)) {
                 abortedBy = 'max-turns';
-                await noteWakeCutShort(`the turn cap (${this.maxTurns}) was reached`);
+                // Same reasoning as the spend guard below: a cap that stops the work
+                // has to close the work, or the hirer is left watching an active task
+                // nobody is on.
+                const reason = `the turn cap (${this.maxTurns}) was reached`;
+                await noteWakeCutShort(reason);
+                await failTaskCutShort(reason);
             }
             // the resumed transcript is gone. Claude Code stores transcripts
             // on the container's own disk while the session id outlives it — persisted
@@ -525,10 +573,10 @@ export class ClaudeSdkAgent {
             // attempt — a mid-wake failure must keep propagating, since its partial
             // writes are already out.
             if (!isMissingSessionError(err) || !resumeId) {
-                runtimeLog.warn('ClaudeSdkAgent', `query failed session=${identity.sessionId}: ${err.message}`);
+                runtimeLog.warn('ClaudeBrain', `query failed session=${identity.sessionId}: ${err.message}`);
                 throw err;
             }
-            runtimeLog.info('ClaudeSdkAgent', `resumed Claude session ${resumeId} no longer exists (container replaced?) ` +
+            runtimeLog.info('ClaudeBrain', `resumed Claude session ${resumeId} no longer exists (container replaced?) ` +
                 `session=${identity.sessionId} agent=${this.agentId} — retrying once on a fresh session`);
             nextCtx.claudeSessionId = undefined;
             sessionId = undefined;
@@ -542,7 +590,7 @@ export class ClaudeSdkAgent {
                 await consumeQuery(undefined);
             }
             catch (retryErr) {
-                runtimeLog.warn('ClaudeSdkAgent', `query failed session=${identity.sessionId}: ${retryErr.message}`);
+                runtimeLog.warn('ClaudeBrain', `query failed session=${identity.sessionId}: ${retryErr.message}`);
                 throw retryErr;
             }
         }
@@ -564,13 +612,15 @@ export class ClaudeSdkAgent {
         // re-reads the world from scratch and runs out of budget at the same step,
         // and a standing job cannot advance.
         if (nextCtx.claudeSessionId && peakTurnInput > MAX_SESSION_RESUME_INPUT_TOKENS) {
-            runtimeLog.info('ClaudeSdkAgent', `resetting Claude session (transcript ~${peakTurnInput} > ${MAX_SESSION_RESUME_INPUT_TOKENS}) ` +
+            runtimeLog.info('ClaudeBrain', `resetting Claude session (transcript ~${peakTurnInput} > ${MAX_SESSION_RESUME_INPUT_TOKENS}) ` +
                 `session=${identity.sessionId} agent=${this.agentId} — next wake starts fresh`);
             nextCtx.claudeSessionId = undefined;
         }
         if (abortedBy === 'input-budget') {
-            await noteWakeCutShort(`the per-wake spend guard cut this run off (~${Math.round(spentInput)} ` +
-                `cost-weighted input tokens > ${MAX_TASK_INPUT_TOKENS})`);
+            const reason = `the per-wake spend guard cut this run off (~${Math.round(spentInput)} ` +
+                `cost-weighted input tokens > ${MAX_TASK_INPUT_TOKENS})`;
+            await noteWakeCutShort(reason);
+            await failTaskCutShort(reason);
         }
         return {
             ctx: nextCtx,

package/dist/{agent/Agent.d.ts → brain/ZiggsBrain.d.ts}

@@ -1,9 +1,10 @@
+import type { Brain } from './index.js';
 import type { Ctx, Identity, Workflow, EffectHandler } from '../types.js';
 import { type TransitionEvent } from '../runtime/AgentMachine.js';
 import { PromptBuilder } from '../runtime/PromptBuilder.js';
 import type { MemoryStore } from '../memory/MemoryStore.js';
 import type { ToolManager } from '../tools/ToolManager.js';
-export interface AgentOptions {
+export interface ZiggsBrainOptions {
     workflow: Workflow;
     toolManager: ToolManager;
     promptBuilder?: PromptBuilder;
@@ -11,26 +12,27 @@ export interface AgentOptions {
 export interface TickInput {
     /** Wire event (already normalized: a `message` or `task_result`-style envelope). */
     event: unknown;
-    /** Server-provided per-session state. Omit on the first tick — a fresh ctx is constructed. */
+    /** Agent-provided per-session state. Omit on the first tick — a fresh ctx is constructed. */
     ctx?: Ctx;
-    /** Server-provided workflow state name. Omit on the first tick — defaults to `workflow.initial`. */
+    /** Agent-provided workflow state name. Omit on the first tick — defaults to `workflow.initial`. */
     state?: string;
-    /** Who am I and what session am I running in. The Agent carries this through Ctx. */
+    /** Who am I and what session am I running in. The ZiggsBrain carries this through Ctx. */
     identity: Identity;
     /** The single side channel for I/O — LLM, context, tools, send, record. */
     eff: EffectHandler;
     /**
      * Agent-private long-term memory. Operator-provided (default
-     * `InMemoryStore` when omitted by `AgentHost`). Key shape is the agent's
-     * choice — `counterparty:<id>`, `agreement:<id>:notes`, etc.
+     * `InMemoryStore` when omitted by `Agent`). The agent already scopes
+     * this to the hire the wake is inside; key shape inside that section is
+     * the agent's choice — `counterparty:<id>`, `agreement:<id>:notes`, etc.
      */
     memory?: MemoryStore;
     /** Optional tap for FSM transition events. */
     transitionTap?: (event: TransitionEvent) => void;
     /**
-     * Aborted by the host when the tick watchdog fires. A brain driving an
-     * external loop (the Claude Agent SDK query) MUST stop consuming it on
-     * abort — the host's Promise.race only abandons the tick promise, so
+     * Aborted by the agent when the tick watchdog fires. A brain driving an
+     * external loop (the Claude ZiggsBrain SDK query) MUST stop consuming it on
+     * abort — the agent's Promise.race only abandons the tick promise, so
      * without this the query keeps running as a zombie: burning tokens and
      * racing its own redelivered retry (observed as duplicate kickoffs and a
      * 363k-token wake, 2026-07-26).
@@ -38,13 +40,13 @@ export interface TickInput {
     signal?: AbortSignal;
 }
 export interface TickOutput {
-    /** Updated ctx — Server persists this against the session. */
+    /** Updated ctx — Agent persists this against the session. */
     ctx: Ctx;
-    /** Workflow state name after the tick — Server persists this against the session. */
+    /** Workflow state name after the tick — Agent persists this against the session. */
     state: string;
     /** Whether the machine settled at a parked state. */
     parked: boolean;
-    /** True when a state-timeout outcome matched no transition this tick — the host must NOT re-arm. */
+    /** True when a state-timeout outcome matched no transition this tick — the agent must NOT re-arm. */
     stateTimeoutUnhandled: boolean;
     /**
      * Accumulated LLM call count and token usage for this tick.
@@ -64,10 +66,10 @@ export interface TickOutput {
     };
 }
 /**
- * Pure agent: workflow definition + cognition machinery. No I/O, no transport,
- * no services. The Agent's only side channel is the `eff` handler it receives
- * on each `tick`. Server-side state (sessions, lanes, queue, outbox) lives in
- * `AgentHost` — not here.
+ * Workflow brain: workflow definition + cognition machinery. No I/O, no transport,
+ * no services. The brain's only side channel is the `eff` handler it receives
+ * on each `tick`. Body state (sessions, lanes, queue, outbox) lives in
+ * `Agent` — not here.
  *
  * The contract:
  *
@@ -75,13 +77,14 @@ export interface TickOutput {
  *   `{ ctx, state, parked }`
  *
  * Reads top-to-bottom like a synchronous function. Every `await eff(...)`
- * inside the cognition core is a yield to the Server, which performs the
- * impure operation and resumes the Agent with the result.
+ * inside the cognition core is a yield to the body, which performs the
+ * impure operation and resumes the ZiggsBrain with the result.
  */
-export declare class Agent {
+export declare class ZiggsBrain implements Brain {
+    readonly kind: "ziggs";
     workflow: Workflow;
     toolManager: ToolManager;
     promptBuilder: PromptBuilder;
-    constructor({ workflow, toolManager, promptBuilder }: AgentOptions);
+    constructor({ workflow, toolManager, promptBuilder }: ZiggsBrainOptions);
     tick({ event, ctx, state, identity, eff, memory, transitionTap }: TickInput): Promise<TickOutput>;
 }