@ziggs-ai/agent-sdk 0.15.0 → 0.17.0

package/dist/index.d.ts

@@ -8,28 +8,29 @@
  *   • Validation at load — defineAgent throws on hard problems, warns on soft
  */
 export { defineAgent } from './defineAgent.js';
-export { createMcpAgent, resolveZiggsGatewayTarget, wrapGatewayFetch, ZiggsGatewayError } from './adapters/McpAdapter.js';
-export type { CreateMcpAgentOptions, McpAgentHandle, McpTransportConfig } from './adapters/McpAdapter.js';
-export { parseSkill, skillHash, skillRolePrompt, splitFrontmatter, SkillValidationError, SKILL_MAX_CHARS, } from './skills/parseSkill.js';
+export { createMcpAgent, resolveZiggsGatewayTarget, wrapGatewayFetch, ZiggsGatewayError } from './mcp/createMcpAgent.js';
+export type { CreateMcpAgentOptions, McpAgentHandle, McpTransportConfig } from './mcp/createMcpAgent.js';
+export { parseSkill, skillHash, skillRolePrompt, skillReferenceName, skillReferenceOneLine, splitFrontmatter, SkillValidationError, SKILL_MAX_CHARS, } from './skills/parseSkill.js';
 export type { ParsedSkill, SkillFile, SkillReference } from './skills/parseSkill.js';
 export { loadSkill, readSkillFiles, assertSkillHash } from './skills/loadSkill.js';
-export { AgentHost, createAgent, createAgentPool, DEFAULT_MODEL } from './AgentHost.js';
-export { Agent } from './agent/Agent.js';
-export { ClaudeSdkAgent } from './agent/ClaudeSdkAgent.js';
-export type { CognitionKind } from './agent/ClaudeSdkAgent.js';
-export { CLAUDE_SDK_PROTOCOL } from './agent/claudeSdkProtocol.js';
-export { buildClaudeEventPrompt, summarizeContext } from './agent/claudeCognition.js';
+export { skillReadReferenceTool } from './skills/skillReadReference.js';
+export { Agent, createAgent, createAgentPool, DEFAULT_MODEL } from './Agent.js';
+export { ZiggsBrain } from './brain/ZiggsBrain.js';
+export { ClaudeBrain } from './brain/ClaudeBrain.js';
+export type { CognitionKind, ClaudeBrainOptions } from './brain/ClaudeBrain.js';
+export { CLAUDE_SDK_PROTOCOL } from './brain/claudeSdkProtocol.js';
+export { buildClaudeEventPrompt, summarizeContext } from './brain/claudeCognition.js';
 export { ziggsBrain, claudeBrain, isBrainSelection, isClaudeCognition } from './brain/index.js';
 export type { Brain, BrainSelection, ZiggsBrainConfig, ClaudeBrainConfig, } from './brain/index.js';
-export type { TickInput, TickOutput, AgentOptions } from './agent/Agent.js';
-export type { SessionResolver, AgentHostOptions, WakeRecord } from './AgentHost.js';
-export { createZiggsEffectHandler } from './server/ZiggsEffectHandler.js';
-export type { ZiggsEffectDeps } from './server/ZiggsEffectHandler.js';
-export { EventQueue } from './server/EventQueue.js';
-export type { EventQueueBusyLane, WaitForIdleResult } from './server/EventQueue.js';
-export { StateTimers } from './server/StateTimers.js';
-export type { StateTimeoutEvent } from './server/StateTimers.js';
-export { OutboxBuffer } from './server/OutboxBuffer.js';
+export type { TickInput, TickOutput, ZiggsBrainOptions } from './brain/ZiggsBrain.js';
+export type { SessionResolver, AgentOptions, WakeRecord } from './Agent.js';
+export { createZiggsEffectHandler } from './platform/ZiggsEffectHandler.js';
+export type { ZiggsEffectDeps } from './platform/ZiggsEffectHandler.js';
+export { EventQueue } from './platform/EventQueue.js';
+export type { EventQueueBusyLane, WaitForIdleResult } from './platform/EventQueue.js';
+export { StateTimers } from './platform/StateTimers.js';
+export type { StateTimeoutEvent } from './platform/StateTimers.js';
+export { OutboxBuffer } from './platform/OutboxBuffer.js';
 export { normalizeIncomingEvent } from './ingress/normalizeIncoming.js';
 export { AgentMachine, type TransitionEvent } from './runtime/AgentMachine.js';
 export { runTurn } from './runtime/runTurn.js';
@@ -42,14 +43,12 @@ export { outcomeFromEvent, outcomeFromActionResult, applyOutcomeToCtx } from './
 export { LANE_BOOK_KEY, allCollectedResults, allDelegatedAgreementIds, allPendingSubtasks, } from './runtime/taskBookkeeping.js';
 export { createDeliveryWriteKeys } from './runtime/deliveryWriteKeys.js';
 export type { Outcome, OutcomeKind, Ctx, Identity, HistoryEntry, ToolResultEntry, PendingSubtask, CollectedSubtaskResult, TaskBookkeeping, Workflow, State, ParkedState, ThinkingState, MechanicalState, Action, Transition, PromptDef, ActionPrompt, Produces, ProducesFn, AgreementRef, TaskRef, ProposalRef, AgentConfig, DefineAgentInput, ServicesConfig, Effect, EffectKind, EffectResult, EffectResultMap, EffectHandler, LlmMessage, LlmToolCall, LlmToolSchema, LlmResponse, ContextSnapshot, SnapshotParticipant, ReadContextOpts, ToolCallResult, RecordedEntry, DeliveryWriteKeys, } from './types.js';
-export { default } from './AgentHost.js';
+export { default } from './Agent.js';
 export { validateContext, ContextWarning } from './cognition/validateContext.js';
-export { runLauncher } from './server/runLauncher.js';
-export { ConnectionPool } from './server/ConnectionPool.js';
+export { ConnectionPool } from './platform/ConnectionPool.js';
 export { decodeOperatorKeyClaims, boundKeyFleetWarning } from './shared/operatorKeyClaims.js';
-export { createHealthServer } from './server/createHealthServer.js';
-export { TaskService } from './server/tasks/TaskService.js';
-export { AgreementService } from './server/agreements/AgreementService.js';
+export { TaskService } from './platform/tasks/TaskService.js';
+export { AgreementService } from './platform/agreements/AgreementService.js';
 export { ToolManager } from './tools/ToolManager.js';
 export { ToolProvider } from './tools/ToolProvider.js';
 export { defineTool } from './tools/defineTool.js';
@@ -61,21 +60,21 @@ export type { AgentNeed, ConnectionNeed } from './tools/needs.js';
 export { OpenAIAdapter } from './adapters/OpenAIAdapter.js';
 export { extractJSON, safeParseJSON } from './utils/jsonExtractor.js';
 export { HistoryFormatter, historyFormatter, AgreementFormatter, agreementFormatter } from './formatters/index.js';
-export { ProactiveTrigger } from './server/proactive/ProactiveTrigger.js';
-export { PollRegistry, declaredPolls, type PollBinding, type PollContext, type PollKind, type PollResult, } from './server/polls/PollKind.js';
-export { PollRunner, type PollRunnerOptions, type WakeTarget } from './server/polls/PollRunner.js';
-export { PROTOCOL_TOOLS, agreementProposeTool, agreementSubcontractTool, agreementRespondTool, agreementClaimTool, agreementCounterTool, agreementGetTool, agreementRevokeTool, agreementFulfillTool, taskCreateTool, taskSetResultTool, taskUpdatePlanStepTool, dispatchProtocolOp, PAYMENT_TOOLS, paymentBalanceTool, CONNECTION_TOOLS, connectionProxyTool, connectionListGrantsTool, requestConnectionTool, MCP_CONNECTION_TOOLS, mcpToolCallTool, mcpToolsListTool, DISCOVERY_TOOLS, agentSearchTool, agentGetTool, MARKETPLACE_TOOLS, marketplaceViewTool, CONTEXT_TOOLS, contextReadTool, contextDelegateTool, contextExpandReachTool, contextDiscoverGrantableTool, GRANTS_TOOLS, listGrantsTool, LINK_TOOLS, linkProposeTool, linkListTool, INTRODUCTION_TOOLS, introductionMintTool, introductionRedeemTool, introductionListTool, introductionRevokeTool, ARTIFACT_TOOLS, recordArtifactTool, CHAT_TOOLS, openConversationTool, } from './server/tools/index.js';
-export { CLAUDE_SDK_TOOLS } from './agent/claudeSdkTools.js';
+export { ProactiveTrigger } from './platform/proactive/ProactiveTrigger.js';
+export { PollRegistry, declaredPolls, type PollBinding, type PollContext, type PollKind, type PollResult, } from './platform/polls/PollKind.js';
+export { PollRunner, type PollRunnerOptions, type WakeTarget } from './platform/polls/PollRunner.js';
+export { PROTOCOL_TOOLS, agreementProposeTool, agreementSubcontractTool, agreementRespondTool, agreementClaimTool, agreementCounterTool, agreementGetTool, agreementRevokeTool, agreementFulfillTool, taskCreateTool, taskSetResultTool, taskUpdatePlanStepTool, dispatchProtocolOp, PAYMENT_TOOLS, paymentBalanceTool, CONNECTION_TOOLS, connectionProxyTool, connectionListGrantsTool, requestConnectionTool, MCP_CONNECTION_TOOLS, mcpToolCallTool, mcpToolsListTool, DISCOVERY_TOOLS, agentSearchTool, agentGetTool, MARKETPLACE_TOOLS, marketplaceViewTool, CONTEXT_TOOLS, contextReadTool, contextDelegateTool, contextExpandReachTool, contextDiscoverGrantableTool, GRANTS_TOOLS, listGrantsTool, LINK_TOOLS, linkProposeTool, linkListTool, INTRODUCTION_TOOLS, introductionMintTool, introductionRedeemTool, introductionListTool, introductionRevokeTool, ARTIFACT_TOOLS, recordArtifactTool, CHAT_TOOLS, openConversationTool, } from './platform/tools/index.js';
+export { CLAUDE_SDK_TOOLS } from './brain/claudeSdkTools.js';
 export { PROTOCOL_TOOL_NAMES, PROTOCOL_TOOL_TO_OPERATION, mapProtocolToolToOperation, isProtocolToolName } from './tasks/protocolRegistry.js';
 export { InMemoryStore, FileMemoryStore } from './memory/MemoryStore.js';
 export type { MemoryStore } from './memory/MemoryStore.js';
-export type { SessionStore } from './AgentHost.js';
+export type { SessionStore } from './Agent.js';
 export { classifyIncomingEvent } from './context/classifyEnvelope.js';
 export { buildContextUpdates, CONTEXT_RESET } from './context/applyEffects.js';
 export { getBatchEvents, isTaskResultRelevantToAgent } from './context/batch.js';
 export { classifyWorkflowEvent, findTaskResult, unwrapBatchEvent, findIncomingTaskResult } from './context/routingLabels.js';
 export { MessagesClient, ArtifactsClient, AgentSearchClient, getBackendUrl, configureApiClient, } from '@ziggs-ai/api-client';
 export type { ApiClientConfig } from '@ziggs-ai/api-client';
-export { SeenMessages } from './server/SeenMessages.js';
+export { SeenMessages } from './platform/SeenMessages.js';
 export { runtimeLog, resetRuntimeLogLevelCache } from './shared/runtimeLog.js';
 export type { RuntimeLogLevel } from './shared/runtimeLog.js';

package/dist/index.js

@@ -8,28 +8,29 @@
  *   • Validation at load — defineAgent throws on hard problems, warns on soft
  */
 export { defineAgent } from './defineAgent.js';
-export { createMcpAgent, resolveZiggsGatewayTarget, wrapGatewayFetch, ZiggsGatewayError } from './adapters/McpAdapter.js';
+export { createMcpAgent, resolveZiggsGatewayTarget, wrapGatewayFetch, ZiggsGatewayError } from './mcp/createMcpAgent.js';
 // Skills: packaged instructions (SKILL.md + optional references/*.md) that
 // become an agent's systemPrompt. Parse-validate-pin is the whole machinery;
 // wiring one into an agent is a spread into claudeSdkAgentBase/createMcpAgent.
 // Prompt-baked — never the SDK's native skill loader.
-export { parseSkill, skillHash, skillRolePrompt, splitFrontmatter, SkillValidationError, SKILL_MAX_CHARS, } from './skills/parseSkill.js';
+export { parseSkill, skillHash, skillRolePrompt, skillReferenceName, skillReferenceOneLine, splitFrontmatter, SkillValidationError, SKILL_MAX_CHARS, } from './skills/parseSkill.js';
 export { loadSkill, readSkillFiles, assertSkillHash } from './skills/loadSkill.js';
-export { AgentHost, createAgent, createAgentPool, DEFAULT_MODEL } from './AgentHost.js';
-export { Agent } from './agent/Agent.js';
-export { ClaudeSdkAgent } from './agent/ClaudeSdkAgent.js';
+export { skillReadReferenceTool } from './skills/skillReadReference.js';
+export { Agent, createAgent, createAgentPool, DEFAULT_MODEL } from './Agent.js';
+export { ZiggsBrain } from './brain/ZiggsBrain.js';
+export { ClaudeBrain } from './brain/ClaudeBrain.js';
 // The exact strings a Claude-brain wake sends: the shared protocol block, the
 // role-independent event prompt, and the one-line context digest. Exported so a
 // caller can answer "what does this agent actually put in front of the model,
 // and what does it cost?" without re-deriving it — a second copy of the prompt
 // is a second answer to that question, and only one of them would be true.
-export { CLAUDE_SDK_PROTOCOL } from './agent/claudeSdkProtocol.js';
-export { buildClaudeEventPrompt, summarizeContext } from './agent/claudeCognition.js';
+export { CLAUDE_SDK_PROTOCOL } from './brain/claudeSdkProtocol.js';
+export { buildClaudeEventPrompt, summarizeContext } from './brain/claudeCognition.js';
 export { ziggsBrain, claudeBrain, isBrainSelection, isClaudeCognition } from './brain/index.js';
-export { createZiggsEffectHandler } from './server/ZiggsEffectHandler.js';
-export { EventQueue } from './server/EventQueue.js';
-export { StateTimers } from './server/StateTimers.js';
-export { OutboxBuffer } from './server/OutboxBuffer.js';
+export { createZiggsEffectHandler } from './platform/ZiggsEffectHandler.js';
+export { EventQueue } from './platform/EventQueue.js';
+export { StateTimers } from './platform/StateTimers.js';
+export { OutboxBuffer } from './platform/OutboxBuffer.js';
 export { normalizeIncomingEvent } from './ingress/normalizeIncoming.js';
 // Runtime primitives
 export { AgentMachine } from './runtime/AgentMachine.js';
@@ -42,15 +43,13 @@ export { validateWorkflow, WorkflowValidationError } from './runtime/validateWor
 export { outcomeFromEvent, outcomeFromActionResult, applyOutcomeToCtx } from './runtime/buildOutcome.js';
 export { LANE_BOOK_KEY, allCollectedResults, allDelegatedAgreementIds, allPendingSubtasks, } from './runtime/taskBookkeeping.js';
 export { createDeliveryWriteKeys } from './runtime/deliveryWriteKeys.js';
-export { default } from './AgentHost.js';
+export { default } from './Agent.js';
 // ── Supporting modules ──────────────────────────────────────────────────────
 export { validateContext, ContextWarning } from './cognition/validateContext.js';
-export { runLauncher } from './server/runLauncher.js';
-export { ConnectionPool } from './server/ConnectionPool.js';
+export { ConnectionPool } from './platform/ConnectionPool.js';
 export { decodeOperatorKeyClaims, boundKeyFleetWarning } from './shared/operatorKeyClaims.js';
-export { createHealthServer } from './server/createHealthServer.js';
-export { TaskService } from './server/tasks/TaskService.js';
-export { AgreementService } from './server/agreements/AgreementService.js';
+export { TaskService } from './platform/tasks/TaskService.js';
+export { AgreementService } from './platform/agreements/AgreementService.js';
 export { ToolManager } from './tools/ToolManager.js';
 export { ToolProvider } from './tools/ToolProvider.js';
 export { defineTool } from './tools/defineTool.js';
@@ -62,25 +61,25 @@ export { MCP_PROVIDER, describeNeed, normalizeNeeds, toolsForNeed, toolsForNeeds
 export { OpenAIAdapter } from './adapters/OpenAIAdapter.js';
 export { extractJSON, safeParseJSON } from './utils/jsonExtractor.js';
 export { HistoryFormatter, historyFormatter, AgreementFormatter, agreementFormatter } from './formatters/index.js';
-export { ProactiveTrigger } from './server/proactive/ProactiveTrigger.js';
-export { PollRegistry, declaredPolls, } from './server/polls/PollKind.js';
-export { PollRunner } from './server/polls/PollRunner.js';
+export { ProactiveTrigger } from './platform/proactive/ProactiveTrigger.js';
+export { PollRegistry, declaredPolls, } from './platform/polls/PollKind.js';
+export { PollRunner } from './platform/polls/PollRunner.js';
 // the hand-rolled ZiggsPayClient / ZiggsConnectClient were deleted;
 // payment and connection tools now use @ziggs-ai/api-client's PaymentsClient /
 // ConnectionsClient, the same clients ziggs-mcp uses.
 // the hand-rolled ZiggsContextClient was deleted; context tools now
 // use the same @ziggs-ai/api-client clients as ziggs-mcp (GrantsClient /
 // ContextGrantsClient / ContextReadClient). Grant/reach types live there.
-// All agent tool bundles live under server/tools/ (tier1 = protocol grammar,
-// tier2 = opt-in HTTP capability bundles). Single home: server/tools/index.ts.
+// All agent tool bundles live under platform/tools/ (tier1 = protocol grammar,
+// tier2 = opt-in HTTP capability bundles). Single home: platform/tools/index.ts.
 export { 
 // Tier 1 — protocol grammar (framework-managed via taskTools).
 PROTOCOL_TOOLS, agreementProposeTool, agreementSubcontractTool, agreementRespondTool, agreementClaimTool, agreementCounterTool, agreementGetTool, agreementRevokeTool, agreementFulfillTool, taskCreateTool, taskSetResultTool, taskUpdatePlanStepTool, dispatchProtocolOp, 
 // Tier 2 — opt-in capability bundles (spread into `tools:`).
-PAYMENT_TOOLS, paymentBalanceTool, CONNECTION_TOOLS, connectionProxyTool, connectionListGrantsTool, requestConnectionTool, MCP_CONNECTION_TOOLS, mcpToolCallTool, mcpToolsListTool, DISCOVERY_TOOLS, agentSearchTool, agentGetTool, MARKETPLACE_TOOLS, marketplaceViewTool, CONTEXT_TOOLS, contextReadTool, contextDelegateTool, contextExpandReachTool, contextDiscoverGrantableTool, GRANTS_TOOLS, listGrantsTool, LINK_TOOLS, linkProposeTool, linkListTool, INTRODUCTION_TOOLS, introductionMintTool, introductionRedeemTool, introductionListTool, introductionRevokeTool, ARTIFACT_TOOLS, recordArtifactTool, CHAT_TOOLS, openConversationTool, } from './server/tools/index.js';
+PAYMENT_TOOLS, paymentBalanceTool, CONNECTION_TOOLS, connectionProxyTool, connectionListGrantsTool, requestConnectionTool, MCP_CONNECTION_TOOLS, mcpToolCallTool, mcpToolsListTool, DISCOVERY_TOOLS, agentSearchTool, agentGetTool, MARKETPLACE_TOOLS, marketplaceViewTool, CONTEXT_TOOLS, contextReadTool, contextDelegateTool, contextExpandReachTool, contextDiscoverGrantableTool, GRANTS_TOOLS, listGrantsTool, LINK_TOOLS, linkProposeTool, linkListTool, INTRODUCTION_TOOLS, introductionMintTool, introductionRedeemTool, introductionListTool, introductionRevokeTool, ARTIFACT_TOOLS, recordArtifactTool, CHAT_TOOLS, openConversationTool, } from './platform/tools/index.js';
 // The always-on toolset for the hosted Claude cognition (parity guard
 // reads this as part of the real SDK registry).
-export { CLAUDE_SDK_TOOLS } from './agent/claudeSdkTools.js';
+export { CLAUDE_SDK_TOOLS } from './brain/claudeSdkTools.js';
 export { PROTOCOL_TOOL_NAMES, PROTOCOL_TOOL_TO_OPERATION, mapProtocolToolToOperation, isProtocolToolName } from './tasks/protocolRegistry.js';
 export { InMemoryStore, FileMemoryStore } from './memory/MemoryStore.js';
 export { classifyIncomingEvent } from './context/classifyEnvelope.js';
@@ -91,5 +90,5 @@ export { MessagesClient, ArtifactsClient, AgentSearchClient, getBackendUrl,
 // self-hosted / non-default backend: consumers of agent-sdk alone
 // must be able to point the shared HTTP client without a direct api-client dep.
 configureApiClient, } from '@ziggs-ai/api-client';
-export { SeenMessages } from './server/SeenMessages.js';
+export { SeenMessages } from './platform/SeenMessages.js';
 export { runtimeLog, resetRuntimeLogLevelCache } from './shared/runtimeLog.js';

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,9 @@
+import { resolveWebAppOrigin, connectionsSettingsAppUrl } 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 { thinkingDefaults } from '../runtime/defaults.js';
 /**
  * Typed failure from the Ziggs MCP gateway. `code` is the stable
@@ -71,6 +72,11 @@ 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.
+            ...(defaults.laneId ? { 'x-ziggs-lane': defaults.laneId } : {}),
         },
     };
 }
@@ -79,7 +85,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 +109,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.
+            ...(laneId ? { 'x-ziggs-lane': laneId } : {}),
         },
     };
 }
@@ -253,7 +261,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 +275,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 +291,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');
         }
@@ -367,9 +375,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';
@@ -422,7 +428,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 +439,7 @@ export async function createMcpAgent(options) {
                 lastErr.code === 'NO_USER_CONNECTION' &&
                 transportConfig.serverUrl) {
                 const requestId = await triggerConnectionRequest(userId).catch(() => null);
-                const link = `${appUrl}/app/settings/connections${requestId ? `?request=${encodeURIComponent(requestId)}` : ''}`;
+                const link = connectionsSettingsAppUrl(appUrl, requestId);
                 return {
                     content: [
                         {
@@ -445,13 +451,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 +465,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;
 }