@ziggs-ai/agent-sdk 0.16.1 → 0.18.0

package/dist/{adapters/McpAdapter.d.ts → mcp/createMcpAgent.d.ts}

@@ -1,6 +1,6 @@
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
-import { AgentHost, type AgentHostOptions } from '../AgentHost.js';
+import { type Agent, type AgentOptions } from '../Agent.js';
 import type { ToolDefinition } from '../tools/defineTool.js';
 import type { Workflow } from '../types.js';
 export type McpTransportConfig = {
@@ -34,7 +34,7 @@ export type McpTransportConfig = {
     operatorKey?: string;
     /** Ziggs backend base URL — defaults to BACKEND_URL / ZIGGS_BACKEND_URL. */
     baseUrl?: string;
-    /** Agent to impersonate (X-Agent-Id) — defaults to the host agentId. */
+    /** Agent to impersonate (X-Agent-Id) — defaults to the agent agentId. */
     agentId?: string;
 } | {
     /**
@@ -51,7 +51,7 @@ export type McpTransportConfig = {
     operatorKey?: string;
     /** Ziggs backend base URL — defaults to BACKEND_URL / ZIGGS_BACKEND_URL. */
     baseUrl?: string;
-    /** Agent to impersonate (X-Agent-Id) — defaults to the host agentId. */
+    /** Agent to impersonate (X-Agent-Id) — defaults to the agent agentId. */
     agentId?: string;
     /**
      * The MCP server URL this agent fronts. Not used for gateway calls (the
@@ -84,6 +84,7 @@ export declare function resolveZiggsGatewayTarget(config: Extract<McpTransportCo
     type: 'ziggs';
 }>, defaults?: {
     agentId?: string;
+    laneId?: string;
 }): {
     url: URL;
     headers: Record<string, string>;
@@ -95,11 +96,11 @@ export declare function resolveZiggsGatewayTarget(config: Extract<McpTransportCo
  */
 export declare function resolvePerUserGatewayTarget(config: Extract<McpTransportConfig, {
     type: 'ziggs-per-user';
-}>, agentId: string, userId: string, onBehalfOfAgreementId?: string): {
+}>, agentId: string, userId: string, onBehalfOfAgreementId?: string, laneId?: string): {
     url: URL;
     headers: Record<string, string>;
 };
-export interface CreateMcpAgentOptions extends Omit<AgentHostOptions, 'tools' | 'workflow' | 'states' | 'initial'> {
+export interface CreateMcpAgentOptions extends Omit<AgentOptions, 'tools' | 'workflow' | 'states' | 'initial'> {
     /** MCP server connection — stdio (local process) or HTTP (remote). */
     transport: McpTransportConfig;
     /** Additional Ziggs tools to register alongside the MCP-derived ones. */
@@ -142,8 +143,8 @@ export interface CreateMcpAgentOptions extends Omit<AgentHostOptions, 'tools' |
  */
 export declare function mcpToolBudget(maxTools: number, extraToolCount: number): number;
 export interface McpAgentHandle {
-    host: AgentHost;
-    /** Disconnect the MCP client (call on shutdown alongside host.disconnect()). */
+    agent: Agent;
+    /** Disconnect the MCP client (call on shutdown alongside agent.disconnect()). */
     closeMcp: () => Promise<void>;
     /** Names of MCP tools that were mapped to Ziggs tools on startup. */
     toolNames: string[];
@@ -164,35 +165,35 @@ export declare const MAX_TOOL_DESC_CHARS = 2000;
 /** Truncate one description at a sentence/newline boundary near the cap. */
 export declare function trimDescription(desc: string | undefined): string | undefined;
 /**
- * Wraps any MCP server as a Ziggs AgentHost.
+ * Wraps any MCP server as a Ziggs Agent.
  *
  * 1. Opens a connection to the MCP server (stdio, HTTP, or the Ziggs gateway).
  * 2. Calls tools/list and maps each tool to a Ziggs ToolDefinition.
- * 3. Returns an AgentHost pre-loaded with those tools, ready to connectAsync().
+ * 3. Returns an Agent pre-loaded with those tools, ready to connectAsync().
  *
  * Usage (local stdio server):
- *   const { host, closeMcp } = await createMcpAgent({
+ *   const { agent, closeMcp } = await createMcpAgent({
  *     transport: { type: 'stdio', command: 'npx', args: ['-y', '@modelcontextprotocol/server-github'] },
  *     agentId: 'my-github-agent',
  *     name: 'GitHub Agent',
  *     description: 'Wraps the GitHub MCP server',
  *   });
- *   await host.connectAsync();
+ *   await agent.connectAsync();
  *
  * Usage (OAuth-protected remote server, brokered through Ziggs — the user
  * connected the server and issued this agent a grant; the agent never sees
  * the user's token):
- *   const { host, closeMcp } = await createMcpAgent({
+ *   const { agent, closeMcp } = await createMcpAgent({
  *     transport: { type: 'ziggs', connectionId: 'con_abc', grantId: 'cgr_xyz' },
  *     agentId: 'my-notion-agent',
  *     name: 'Notion Agent',
  *     description: 'Works in the owner\'s Notion via their MCP connection',
  *   });
- *   await host.connectAsync();
+ *   await agent.connectAsync();
  *
  *   process.on('SIGTERM', async () => {
- *     host.disconnect();
- *     await host.drain();
+ *     agent.disconnect();
+ *     await agent.drain();
  *     await closeMcp();
  *   });
  */

package/dist/{adapters/McpAdapter.js → mcp/createMcpAgent.js}

@@ -1,8 +1,10 @@
+import { resolveWebAppOrigin, connectionsSettingsAppUrl, laneHeader } from '@ziggs-ai/api-client';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { ConnectionsClient, getBackendUrl } from '@ziggs-ai/api-client';
-import { AgentHost } from '../AgentHost.js';
+import { createAgent } from '../Agent.js';
+import { laneFromToolContext } from '../tools/toolCreds.js';
 import { thinkingDefaults } from '../runtime/defaults.js';
 /**
  * Typed failure from the Ziggs MCP gateway. `code` is the stable
@@ -71,6 +73,12 @@ export function resolveZiggsGatewayTarget(config, defaults = {}) {
             authorization: `Bearer ${operatorKey}`,
             'x-agent-id': agentId,
             'x-grant-id': config.grantId,
+            // The lane, so the broker can tell who this wake acts for. Until it was
+            // sent, this door was the unfenced one: the named-connector proxy states
+            // its lane, so the same account and the same grant got two different
+            // answers depending on which door the agent used. Built by the shared
+            // helper, because a copy of this header going missing is invisible.
+            ...laneHeader(defaults.laneId),
         },
     };
 }
@@ -79,7 +87,7 @@ export function resolveZiggsGatewayTarget(config, defaults = {}) {
  * the gateway resolves the invoking user's own connection + grant from
  * `x-on-behalf-of-user` + the impersonated agent.
  */
-export function resolvePerUserGatewayTarget(config, agentId, userId, onBehalfOfAgreementId) {
+export function resolvePerUserGatewayTarget(config, agentId, userId, onBehalfOfAgreementId, laneId) {
     const operatorKey = config.operatorKey || process.env.ZIGGS_OPERATOR_KEY;
     if (!operatorKey) {
         throw new Error('ziggs-per-user MCP transport requires an operatorKey (or ZIGGS_OPERATOR_KEY)');
@@ -103,6 +111,8 @@ export function resolvePerUserGatewayTarget(config, agentId, userId, onBehalfOfA
             // agent (senderId), not the end-user who owns the connection. The gateway
             // uses this agreement to resolve the delegation root's user.
             ...(onBehalfOfAgreementId ? { 'x-on-behalf-of-agreement': onBehalfOfAgreementId } : {}),
+            // The lane, for the same reason as the path-id door above.
+            ...laneHeader(laneId),
         },
     };
 }
@@ -127,6 +137,15 @@ export function buildTransport(config, defaults = {}) {
         });
     }
     if (config.type === 'ziggs') {
+        /**
+         * No lane, and there cannot be one: this client is built ONCE at boot and
+         * shared by every wake, so any lane baked into its headers would be the
+         * wrong one for all but the first. The `ziggs` transport is the legacy
+         * fleet entry (`scripts/run-mcp-fleet.ts`) — a fixed connection + grant the
+         * operator configured for itself, so the lane-less fence (its own estate)
+         * is the right answer for it. A per-lane client belongs to `ziggs-per-user`,
+         * which builds one per wake and states the lane there.
+         */
         const target = resolveZiggsGatewayTarget(config, defaults);
         return new StreamableHTTPClientTransport(target.url, {
             requestInit: { headers: target.headers },
@@ -253,7 +272,7 @@ function trimToolDescriptions(tools, agentId) {
         return { ...t, description: nextDesc };
     });
     if (trimmedCount > 0) {
-        console.warn(`[McpAdapter] ${agentId}: trimmed ${trimmedCount} oversized tool description(s) to ${MAX_TOOL_DESC_CHARS} chars, saving ~${Math.round(savedChars / 4 / 1000)}K tokens/turn.`);
+        console.warn(`[createMcpAgent] ${agentId}: trimmed ${trimmedCount} oversized tool description(s) to ${MAX_TOOL_DESC_CHARS} chars, saving ~${Math.round(savedChars / 4 / 1000)}K tokens/turn.`);
     }
     return out;
 }
@@ -267,7 +286,7 @@ function filterToolsByAllowlist(tools, allowedTools, agentId) {
         return tools;
     const patterns = allowedTools.map((p) => p.toLowerCase());
     const kept = tools.filter((t) => patterns.some((p) => t.name.toLowerCase().includes(p)));
-    console.warn(`[McpAdapter] ${agentId}: tool allowlist active — bound ${kept.length}/${tools.length} tools matching [${allowedTools.join(', ')}]${kept.length === 0 ? ' ⚠️ NONE MATCHED — check patterns against the server\'s tool names' : ': ' + kept.map((t) => t.name).join(', ')}.`);
+    console.warn(`[createMcpAgent] ${agentId}: tool allowlist active — bound ${kept.length}/${tools.length} tools matching [${allowedTools.join(', ')}]${kept.length === 0 ? ' ⚠️ NONE MATCHED — check patterns against the server\'s tool names' : ': ' + kept.map((t) => t.name).join(', ')}.`);
     return kept;
 }
 /**
@@ -283,48 +302,48 @@ function capTools(tools, agentId, maxTools, extraToolCount, allowedTools) {
     const budget = mcpToolBudget(maxTools, extraToolCount);
     if (trimmed.length <= budget)
         return trimmed;
-    console.warn(`[McpAdapter] ${agentId}: MCP server exposes ${trimmed.length} tools, over the ${maxTools}-tool LLM cap; binding the first ${budget}, dropping ${trimmed.length - budget}.`);
+    console.warn(`[createMcpAgent] ${agentId}: MCP server exposes ${trimmed.length} tools, over the ${maxTools}-tool LLM cap; binding the first ${budget}, dropping ${trimmed.length - budget}.`);
     return trimmed.slice(0, budget);
 }
 /**
- * Wraps any MCP server as a Ziggs AgentHost.
+ * Wraps any MCP server as a Ziggs Agent.
  *
  * 1. Opens a connection to the MCP server (stdio, HTTP, or the Ziggs gateway).
  * 2. Calls tools/list and maps each tool to a Ziggs ToolDefinition.
- * 3. Returns an AgentHost pre-loaded with those tools, ready to connectAsync().
+ * 3. Returns an Agent pre-loaded with those tools, ready to connectAsync().
  *
  * Usage (local stdio server):
- *   const { host, closeMcp } = await createMcpAgent({
+ *   const { agent, closeMcp } = await createMcpAgent({
  *     transport: { type: 'stdio', command: 'npx', args: ['-y', '@modelcontextprotocol/server-github'] },
  *     agentId: 'my-github-agent',
  *     name: 'GitHub Agent',
  *     description: 'Wraps the GitHub MCP server',
  *   });
- *   await host.connectAsync();
+ *   await agent.connectAsync();
  *
  * Usage (OAuth-protected remote server, brokered through Ziggs — the user
  * connected the server and issued this agent a grant; the agent never sees
  * the user's token):
- *   const { host, closeMcp } = await createMcpAgent({
+ *   const { agent, closeMcp } = await createMcpAgent({
  *     transport: { type: 'ziggs', connectionId: 'con_abc', grantId: 'cgr_xyz' },
  *     agentId: 'my-notion-agent',
  *     name: 'Notion Agent',
  *     description: 'Works in the owner\'s Notion via their MCP connection',
  *   });
- *   await host.connectAsync();
+ *   await agent.connectAsync();
  *
  *   process.on('SIGTERM', async () => {
- *     host.disconnect();
- *     await host.drain();
+ *     agent.disconnect();
+ *     await agent.drain();
  *     await closeMcp();
  *   });
  */
 export async function createMcpAgent(options) {
-    const { transport: transportConfig, extraTools = [], workflow, maxTools = DEFAULT_MAX_TOOLS, allowedTools, toolSchema, ...hostOptions } = options;
+    const { transport: transportConfig, extraTools = [], workflow, maxTools = DEFAULT_MAX_TOOLS, allowedTools, toolSchema, ...agentOptions } = options;
     // ── Per-user path: no boot connection; one MCP client per invoking
     // user, each carrying that user's on-behalf-of header for an isolated session.
     if (transportConfig.type === 'ziggs-per-user') {
-        const agentId = transportConfig.agentId || hostOptions.agentId;
+        const agentId = transportConfig.agentId || agentOptions.agentId;
         if (!agentId) {
             throw new Error('ziggs-per-user MCP transport requires an agentId to impersonate');
         }
@@ -333,14 +352,17 @@ export async function createMcpAgent(options) {
         }
         const tools = capTools(toolSchema, agentId, maxTools, extraTools.length, allowedTools);
         const clients = new Map();
-        const clientFor = (userId, onBehalfOfAgreementId) => {
-            // Key by user + agreement: the gateway may resolve a different end-user
-            // per agreement (delegation), so sessions must not be shared across them.
-            const cacheKey = `${userId}|${onBehalfOfAgreementId ?? ''}`;
+        const clientFor = (userId, onBehalfOfAgreementId, laneId) => {
+            // Key by user + agreement + lane: the gateway may resolve a different
+            // end-user per agreement (delegation), and the lane decides which party's
+            // grants this session may spend, so sessions must not be shared across
+            // any of the three. The headers are fixed when the transport is built,
+            // so a session reused across lanes would carry the first lane's fence.
+            const cacheKey = `${userId}|${onBehalfOfAgreementId ?? ''}|${laneId ?? ''}`;
             let p = clients.get(cacheKey);
             if (!p) {
                 p = (async () => {
-                    const target = resolvePerUserGatewayTarget(transportConfig, agentId, userId, onBehalfOfAgreementId);
+                    const target = resolvePerUserGatewayTarget(transportConfig, agentId, userId, onBehalfOfAgreementId, laneId);
                     const transport = new StreamableHTTPClientTransport(target.url, {
                         requestInit: { headers: target.headers },
                         fetch: wrapGatewayFetch(),
@@ -367,9 +389,7 @@ export async function createMcpAgent(options) {
             process.env.ZIGGS_BACKEND_URL ||
             'http://localhost:3000').replace(/\/$/, '');
         // App URL for the user-facing connect link: api.ziggsai.com → ziggsai.com.
-        const appUrl = backendBase.includes('localhost')
-            ? 'http://localhost:1234'
-            : backendBase.replace(/\/\/api\./, '//');
+        const appUrl = resolveWebAppOrigin(undefined, backendBase);
         const serverLabel = transportConfig.serverUrl
             ? new URL(transportConfig.serverUrl).host
             : 'the external service';
@@ -404,6 +424,14 @@ export async function createMcpAgent(options) {
             // connection-owning end-user; pass the agreement so the gateway resolves
             // the delegation root's user.
             const onBehalfOfAgreementId = typeof context.onBehalfOfAgreementId === 'string' ? context.onBehalfOfAgreementId : undefined;
+            /**
+             * The lane this wake runs in, read the same way every tool reads it.
+             * Without it the relay states no lane, the gateway resolves the wake to
+             * the agent's own operator, and any grant the CUSTOMER gave is refused —
+             * on the door built for exactly that case. Omitting a lane can only
+             * narrow reach, never widen it, so the miss never raises.
+             */
+            const laneId = laneFromToolContext(context);
             // (B): per-user resolution is intermittently flaky even when the
             // connection is valid and resolvable — the same on-behalf call fails with
             // NO_USER_CONNECTION on one wake and succeeds on the next. clientFor never
@@ -414,7 +442,7 @@ export async function createMcpAgent(options) {
             let lastErr;
             for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
                 try {
-                    const c = await clientFor(userId, onBehalfOfAgreementId);
+                    const c = await clientFor(userId, onBehalfOfAgreementId, laneId);
                     return (await c.callTool({ name, arguments: args }));
                 }
                 catch (err) {
@@ -422,7 +450,7 @@ export async function createMcpAgent(options) {
                     const resolutionMiss = err instanceof ZiggsGatewayError && err.code === 'NO_USER_CONNECTION';
                     const transient = resolutionMiss || !(err instanceof ZiggsGatewayError);
                     if (attempt < MAX_ATTEMPTS && transient) {
-                        console.warn(`[McpAdapter] per-user ${name} attempt ${attempt}/${MAX_ATTEMPTS} failed (${err.message}); retrying with a fresh connection`);
+                        console.warn(`[createMcpAgent] per-user ${name} attempt ${attempt}/${MAX_ATTEMPTS} failed (${err.message}); retrying with a fresh connection`);
                         await new Promise((r) => setTimeout(r, 500 * attempt));
                         continue;
                     }
@@ -433,7 +461,7 @@ export async function createMcpAgent(options) {
                 lastErr.code === 'NO_USER_CONNECTION' &&
                 transportConfig.serverUrl) {
                 const requestId = await triggerConnectionRequest(userId).catch(() => null);
-                const link = `${appUrl}/app/access${requestId ? `?request=${encodeURIComponent(requestId)}` : ''}`;
+                const link = connectionsSettingsAppUrl(appUrl, requestId);
                 return {
                     content: [
                         {
@@ -445,13 +473,13 @@ export async function createMcpAgent(options) {
             }
             throw lastErr;
         };
-        const host = new AgentHost({
-            ...hostOptions,
-            workflow: workflow ?? buildDefaultWorkflow(hostOptions.description ?? '', tools),
+        const agent = createAgent({
+            ...agentOptions,
+            workflow: workflow ?? buildDefaultWorkflow(agentOptions.description ?? '', tools),
             tools: [...mapMcpTools(caller, tools), ...extraTools],
         });
         return {
-            host,
+            agent,
             closeMcp: async () => {
                 await Promise.all([...clients.values()].map(p => p.then(c => c.close()).catch(() => { })));
             },
@@ -459,21 +487,29 @@ export async function createMcpAgent(options) {
         };
     }
     // ── Single-client path (stdio / http / brokered ziggs): discover tools at boot.
-    const transport = buildTransport(transportConfig, { agentId: hostOptions.agentId });
+    const transport = buildTransport(transportConfig, { agentId: agentOptions.agentId });
     const client = new Client({ name: 'ziggs-mcp-agent', version: '1.0.0' });
-    await client.connect(transport);
-    const rawTools = capTools((await client.listTools()).tools, hostOptions.agentId, maxTools, extraTools.length, allowedTools);
-    const caller = (name, args) => client.callTool({ name, arguments: args });
-    const mcpTools = mapMcpTools(caller, rawTools);
-    const resolvedWorkflow = workflow ?? buildDefaultWorkflow(hostOptions.description ?? '', rawTools);
-    const host = new AgentHost({
-        ...hostOptions,
-        workflow: resolvedWorkflow,
-        tools: [...mcpTools, ...extraTools],
-    });
-    return {
-        host,
-        closeMcp: () => client.close(),
-        toolNames: rawTools.map((t) => t.name),
-    };
+    try {
+        await client.connect(transport);
+        const rawTools = capTools((await client.listTools()).tools, agentOptions.agentId, maxTools, extraTools.length, allowedTools);
+        const caller = (name, args) => client.callTool({ name, arguments: args });
+        const mcpTools = mapMcpTools(caller, rawTools);
+        const resolvedWorkflow = workflow ?? buildDefaultWorkflow(agentOptions.description ?? '', rawTools);
+        const agent = createAgent({
+            ...agentOptions,
+            workflow: resolvedWorkflow,
+            tools: [...mcpTools, ...extraTools],
+        });
+        return {
+            agent,
+            closeMcp: () => client.close(),
+            toolNames: rawTools.map((t) => t.name),
+        };
+    }
+    catch (err) {
+        // Validation and tool discovery can fail after stdio has spawned a child.
+        // A rejected factory must release the transport it already acquired.
+        await client.close().catch(() => { });
+        throw err;
+    }
 }

package/dist/memory/MemoryStore.d.ts

@@ -3,7 +3,9 @@
  *
  * This is the SDK's contract; the *storage* is operator-provided. The agent
  * picks the key shape (often `counterparty:<id>`, sometimes `agreement:<id>:notes`,
- * etc.) — the SDK does not enforce one.
+ * etc.) — the SDK does not enforce one. The host prefixes every key with
+ * the hire the wake is inside (or the agent's own section when there is
+ * no hire), so one customer's notes cannot be read in another's wake.
  *
  * Reference implementations: `InMemoryStore` (default; non-durable) and
  * `FileMemoryStore` (single JSON file; useful for local dev). Anything
@@ -53,3 +55,18 @@ export declare class FileMemoryStore implements MemoryStore {
     }[]>;
     delete(key: string): Promise<void>;
 }
+/**
+ * Section a wake may read and write. A hire (pinned agreement, or an
+ * `agrn-` lane) gets its own prefix. A wake with no hire shares the
+ * agent's own section — same as before for in-process tools that key by
+ * chat themselves.
+ */
+export declare function memorySectionForWake(input: {
+    sessionId?: string | null;
+    activeAgreementId?: string | null;
+}): string;
+/**
+ * Present a store as if it only contained one section. Agent keys stay
+ * unchanged; get/put/list/delete all go through `section:`.
+ */
+export declare function partitionMemoryStore(store: MemoryStore, section: string): MemoryStore;

package/dist/memory/MemoryStore.js

@@ -1,3 +1,4 @@
+import { agreementIdFromLane } from '@ziggs-ai/api-client';
 /** Non-durable reference impl. Per-process; lost on restart. */
 export class InMemoryStore {
     store = new Map();
@@ -76,3 +77,45 @@ export class FileMemoryStore {
         await this._flush();
     }
 }
+/**
+ * Section a wake may read and write. A hire (pinned agreement, or an
+ * `agrn-` lane) gets its own prefix. A wake with no hire shares the
+ * agent's own section — same as before for in-process tools that key by
+ * chat themselves.
+ */
+export function memorySectionForWake(input) {
+    const pinned = typeof input.activeAgreementId === 'string'
+        ? input.activeAgreementId.trim()
+        : '';
+    if (pinned)
+        return `hire:${pinned}`;
+    const fromLane = agreementIdFromAgrnSession(input.sessionId);
+    if (fromLane)
+        return `hire:${fromLane}`;
+    return 'agent';
+}
+function agreementIdFromAgrnSession(sessionId) {
+    return agreementIdFromLane(sessionId)?.trim() || null;
+}
+/**
+ * Present a store as if it only contained one section. Agent keys stay
+ * unchanged; get/put/list/delete all go through `section:`.
+ */
+export function partitionMemoryStore(store, section) {
+    const prefix = `${section}:`;
+    const partitioned = {
+        get: (key) => store.get(prefix + key),
+        put: (key, value) => store.put(prefix + key, value),
+        list: async (keyPrefix) => {
+            const rows = await store.list(prefix + keyPrefix);
+            return rows.map(({ key, value }) => ({
+                key: key.startsWith(prefix) ? key.slice(prefix.length) : key,
+                value,
+            }));
+        },
+    };
+    if (store.delete) {
+        partitioned.delete = (key) => store.delete(prefix + key);
+    }
+    return partitioned;
+}

package/dist/{server → platform}/ConnectionPool.d.ts

@@ -1,4 +1,4 @@
-import { AgentHost, type AgentHostOptions } from '../AgentHost.js';
+import { type Agent, type AgentOptions } from '../Agent.js';
 interface ConnectionManagerMeta {
     domain?: string;
     expertise?: string[];
@@ -23,11 +23,11 @@ export declare class ConnectionPool {
      * registered and never connected is an agent nobody hosts, which is the
      * failure this pool exists to make impossible.
      */
-    register(configs: AgentHostOptions[], metaArr?: ConnectionManagerMeta[]): void;
+    register(configs: AgentOptions[], metaArr?: ConnectionManagerMeta[]): void;
     /** Connect every registered agent. Reports the ones that could not come up. */
     connectAll(): Promise<void>;
     /** The host for one agent, connecting it if it somehow is not up yet. */
-    startAgent(agentId: string): Promise<AgentHost>;
+    startAgent(agentId: string): Promise<Agent>;
     stopAgent(agentId: string): Promise<void>;
     disconnectAll(): Promise<void>;
     /**
@@ -68,6 +68,12 @@ export declare class ConnectionPool {
     query(filter: QueryFilter): string[];
     list(): string[];
     listActive(): string[];
+    /**
+     * Inbox liveness for every live agent in this process. The runner's health
+     * route answers from this rather than from "the HTTP server replied", which
+     * a wedged process does happily while none of its agents read anything.
+     */
+    liveness(): ReturnType<Agent['inboxLiveness']>[];
     get size(): number;
     getMeta(id: string): ConnectionManagerMeta | undefined;
 }

package/dist/{server → platform}/ConnectionPool.js

@@ -1,7 +1,7 @@
 /**
  * ConnectionPool — the agents this launcher process hosts.
  *
- * Holds N `AgentHostOptions` configs and connects every one of them at boot
+ * Holds N `AgentOptions` configs and connects every one of them at boot
  *. Each host long-polls its own inbox for the life of the process —
  * there is no agent socket. There is no subset, no cap and no lifecycle policy:
  * a write releasing that poll is the only signal anything needs.
@@ -14,7 +14,7 @@
  * answer was "none of them".
  */
 import { ConnectionManager } from '@ziggs-ai/api-client';
-import { AgentHost } from '../AgentHost.js';
+import { createAgent } from '../Agent.js';
 import { runtimeLog } from '../shared/runtimeLog.js';
 export class ConnectionPool {
     manager = new ConnectionManager();
@@ -48,7 +48,7 @@ export class ConnectionPool {
                 const cfg = this.configs.get(agentId);
                 const originalTap = cfg.effectTap;
                 const pool = this;
-                const host = new AgentHost({
+                const host = createAgent({
                     ...cfg,
                     effectTap(effect, response) {
                         if (effect.kind === 'send-message') {
@@ -72,7 +72,11 @@ export class ConnectionPool {
     }
     /** Connect every registered agent. Reports the ones that could not come up. */
     async connectAll() {
-        return this.manager.connectAll();
+        await this.manager.connectAll();
+        const connected = this.listActive().length;
+        if (connected !== this.size) {
+            throw new Error(`Only ${connected}/${this.size} agents started; process must restart`);
+        }
     }
     /** The host for one agent, connecting it if it somehow is not up yet. */
     async startAgent(agentId) {
@@ -181,6 +185,14 @@ export class ConnectionPool {
     query(filter) { return this.manager.query(filter); }
     list() { return this.manager.list(); }
     listActive() { return this.manager.listActive(); }
+    /**
+     * Inbox liveness for every live agent in this process. The runner's health
+     * route answers from this rather than from "the HTTP server replied", which
+     * a wedged process does happily while none of its agents read anything.
+     */
+    liveness() {
+        return [...this.hosts.values()].map((host) => host.inboxLiveness());
+    }
     get size() { return this.manager.size; }
     getMeta(id) { return this.manager.getMeta(id); }
 }

package/dist/{server → platform}/EventQueue.d.ts

@@ -7,7 +7,7 @@ export interface EventQueueBusyLane {
     queued: number;
     processing: boolean;
 }
-/** Outcome of `waitForIdle` / `AgentHost.drain`. Timeout is data, not a throw. */
+/** Outcome of `waitForIdle` / `Agent.drain`. Timeout is data, not a throw. */
 export interface WaitForIdleResult {
     idle: boolean;
     timedOut: boolean;

package/dist/{server → platform}/StateTimers.d.ts

@@ -6,7 +6,7 @@ export interface StateTimeoutEvent {
 }
 /**
  * Per-lane liveness timers for parked states declaring timeoutMs. Owned by
- * AgentHost. A firing timer enqueues a state-timeout frame on the SAME lane
+ * Agent. A firing timer enqueues a state-timeout frame on the SAME lane
  * (caller-provided enqueue → EventQueue), so it serializes behind any real
  * event and can never race one. Epochs make stale frames identifiable: a
  * queued timeout frame whose epoch is not the lane's currently-armed epoch was

package/dist/{server → platform}/StateTimers.js

@@ -1,7 +1,7 @@
 import { runtimeLog } from '../shared/runtimeLog.js';
 /**
  * Per-lane liveness timers for parked states declaring timeoutMs. Owned by
- * AgentHost. A firing timer enqueues a state-timeout frame on the SAME lane
+ * Agent. A firing timer enqueues a state-timeout frame on the SAME lane
  * (caller-provided enqueue → EventQueue), so it serializes behind any real
  * event and can never race one. Epochs make stale frames identifiable: a
  * queued timeout frame whose epoch is not the lane's currently-armed epoch was

package/dist/{server → platform}/ZiggsEffectHandler.d.ts

@@ -1,14 +1,14 @@
 /**
  * Ziggs-flavored EffectHandler.
  *
- * Translates the Agent's pure Effect requests into concrete backend calls:
+ * Translates the brain's Effect requests into concrete backend calls:
  * reads go through the grant-fenced ContextReadClient snapshot, writes through
  * artifactsClient / taskService / agreementService / messageSender, and LLM
- * turns through the adapter. This is the only place where Agent intent meets
+ * turns through the adapter. This is the only place where brain intent meets
  * backend reality.
  *
- * Lives in agent-sdk for now alongside `Agent`; destined for a separate
- * `@ziggs-ai/agent-server` package once the SDK split is complete.
+ * Belongs to the SDK body. The operator runner owns process startup and
+ * health serving; it does not perform the brain’s effects.
  */
 import type { Effect, EffectHandler, LlmMessage, LlmResponse, LlmToolSchema, ToolCallResult } from '../types.js';
 /** Minimal LLM adapter contract — OpenAIAdapter satisfies this. */

package/dist/{server → platform}/ZiggsEffectHandler.js

@@ -115,7 +115,7 @@ export async function executeToolWithSideEffects(deps, eff, effect, roster) {
     const argsPreview = previewToolArgs(args);
     // #6 — breadcrumbs are best-effort. Awaiting them bracketed every
     // tool call; a slow/wedged artifacts backend stalled the whole wake. Match
-    // ClaudeSdkAgent thought writes (fire-and-forget).
+    // ClaudeBrain thought writes (fire-and-forget).
     void emitToolOperationArtifact(deps.artifactsClient, effect.sessionId, 'started', {
         state: 'started',
         tool: effect.name,
@@ -230,7 +230,7 @@ export function createZiggsEffectHandler(deps) {
             case 'read-context': {
                 // Grant-fenced aggregate read: the backend composes the ContextSnapshot
                 // (GET /context/snapshot) through the same access + temporal fence as
-                // the per-type reads. Every producer — ClaudeSdkAgent.tick, runTurn,
+                // the per-type reads. Every producer — ClaudeBrain.tick, runTurn,
                 // and the on-demand context_snapshot tool — routes through here.
                 const snap = await buildSnapshot(deps, effect.sessionId, deps.agentId, {
                     limit: effect.opts?.maxMessages,