@ziggs-ai/agent-sdk 0.1.12 → 0.2.1

package/src/server/ZiggsEffectHandler.ts

@@ -1,427 +0,0 @@
-/**
- * Ziggs-flavored EffectHandler.
- *
- * Translates the Agent's pure 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
- * 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.
- */
-import type {
-  Effect, EffectHandler,
-  ContextSnapshot, LlmMessage, LlmResponse, LlmToolSchema, ToolCallResult,
-} from '../types.js';
-import { OutboxBuffer } from './OutboxBuffer.js';
-import { runtimeLog } from '../shared/runtimeLog.js';
-/** Minimal LLM adapter contract — OpenAIAdapter satisfies this. */
-interface LlmAdapter {
-  chatMessages(messages: LlmMessage[], tools?: LlmToolSchema[], options?: Record<string, unknown>): Promise<LlmResponse>;
-  chatMessagesStream?(messages: LlmMessage[], onChunk: (text: string) => void): Promise<{ text: string; usage?: LlmResponse['usage'] }>;
-}
-import type { TaskService } from './tasks/TaskService.js';
-import type { AgreementService } from './agreements/AgreementService.js';
-import type { ToolManager } from '../tools/ToolManager.js';
-import type {
-  ArtifactsClient,
-  ContextReadClient,
-  TelemetryClient,
-} from '@ziggs-ai/api-client';
-import {
-  buildLlmIngestPayload,
-  buildToolIngestPayload,
-  isTelemetryIngestEnabled,
-  sendTelemetry,
-} from './telemetryIngest.js';
-
-export interface ZiggsEffectDeps {
-  /**
-   * LLM adapter for `llm-call` / `stream-text`. Optional: the Claude brain
-   * drives its own model via `query()` and emits neither effect, so it wires
-   * no adapter. Those two cases throw if reached without one.
-   */
-  llm?: LlmAdapter;
-  artifactsClient: ArtifactsClient;
-  /** Grant-fenced aggregate read backbone — sources the read-context snapshot. */
-  contextReadClient: ContextReadClient;
-  taskService: TaskService;
-  agreementService: AgreementService;
-  messageSender: (text: string, receiverId: string, sessionId: string, messageId?: string) => Promise<unknown>;
-  /** Sends a streaming chunk to a client. Called per-token during stream-text effects. */
-  chunkSender?: (sessionId: string, receiverId: string, text: string, messageId: string) => void;
-  toolManager: ToolManager;
-  operatorKey: string;
-  agentId: string;
-  telemetryClient?: TelemetryClient;
-  /** When false, skips POST /agents/monitoring/ingest (default: env on). */
-  telemetryIngest?: boolean;
-  effectTap?: (effect: Effect, response: unknown) => void;
-}
-
-const CONTEXT_CACHE_MAX = 256;
-
-/**
- * Compose a `ContextSnapshot` for a chatId via the grant-fenced aggregate read
- * (`GET /context/snapshot`, ZIG-775 follow-up). The backend assembles history +
- * agreements + roster through the same `assertScopeAccess` + temporal fence as
- * the per-type context reads, and annotates `*IsYou` / self server-side against
- * the acting agent. This function only preserves the never-throw/degrade
- * contract that the cognition code depends on — the shape is unchanged.
- */
-const emptySnapshot = (agentId: string, chatMissing = false): ContextSnapshot => ({
-  history: [],
-  agreements: [],
-  users: [],
-  agents: [{ agentId, role: 'self', isYou: true }],
-  latestSequence: null,
-  ...(chatMissing ? { chatMissing: true } : {}),
-});
-
-async function buildSnapshot(
-  deps: ZiggsEffectDeps,
-  chatId: string,
-  agentId: string,
-  opts: { limit?: number } = {},
-): Promise<ContextSnapshot> {
-  try {
-    // Server returns 200 + chatMissing:true for a deleted chat, so its
-    // annotations (roster, *IsYou, self) are already applied — pass through.
-    const snap = await deps.contextReadClient.snapshot(chatId, {
-      maxMessages: opts.limit,
-    });
-    return snap as ContextSnapshot;
-  } catch (err: unknown) {
-    // Defensive: server normally signals a dead chat as 200 + chatMissing, but
-    // a raw 404 degrades the same way so message wakes still skip it.
-    if ((err as { status?: number })?.status === 404) {
-      return emptySnapshot(agentId, true);
-    }
-    runtimeLog.warn(
-      'ZiggsEffectHandler',
-      `snapshot fetch failed: ${(err as Error)?.message ?? err}`,
-    );
-    return emptySnapshot(agentId);
-  }
-}
-
-const OP_ARTIFACT_MAX_CHARS = 900;
-
-function clipForOperationArtifact(value: unknown): unknown {
-  if (value == null) return value;
-  if (typeof value === 'string') {
-    return value.length > OP_ARTIFACT_MAX_CHARS ? `${value.slice(0, OP_ARTIFACT_MAX_CHARS - 1)}…` : value;
-  }
-  try {
-    const s = JSON.stringify(value);
-    if (s.length <= OP_ARTIFACT_MAX_CHARS) return value;
-    return `${s.slice(0, OP_ARTIFACT_MAX_CHARS - 1)}…`;
-  } catch {
-    return String(value).slice(0, OP_ARTIFACT_MAX_CHARS);
-  }
-}
-
-function previewToolArgs(args: Record<string, unknown>): Record<string, unknown> | undefined {
-  const keys = Object.keys(args);
-  if (keys.length === 0) return undefined;
-  const out: Record<string, unknown> = {};
-  for (let i = 0; i < keys.length && i < 16; i++) {
-    const k = keys[i];
-    out[k] = clipForOperationArtifact(args[k]);
-  }
-  return out;
-}
-
-/**
- * Chat timeline: `Message.tsx` parses `entryType: artifact`, `content_type: operation` with
- * `operation_*:{json}` where json includes `state` and `tool`.
- */
-async function emitToolOperationArtifact(
-  client: ArtifactsClient,
-  chatId: string,
-  phase: 'started' | 'completed' | 'error',
-  payload: Record<string, unknown>,
-): Promise<void> {
-  const prefix =
-    phase === 'started' ? 'operation_started' : phase === 'completed' ? 'operation_completed' : 'operation_error';
-  const text = `${prefix}:${JSON.stringify(payload)}`;
-  try {
-    await client.write({
-      chatId,
-      text,
-      content_type: 'operation',
-      visibility: 'agent-private',
-    });
-  } catch (e: unknown) {
-    runtimeLog.warn(
-      'ZiggsEffectHandler',
-      `tool operation artifact (${phase}): ${(e as Error)?.message ?? String(e)}`,
-    );
-  }
-}
-
-/**
- * The single tool-execution path for BOTH cognitions (ZIG-775).
- *
- * Executing a tool is more than calling its handler: it emits the operation
- * timeline artifacts (started / completed / error) and tool telemetry, and
- * resolves the invoking user + roster. The FSM reaches this via
- * `eff({ kind: 'tool-call' })` inside `runTurn`; the Claude Agent SDK bridge
- * (`toolManagerToSdkMcp`) emits the SAME effect — so a hosted Claude-brain
- * agent's tool activity is as observable as an FSM agent's (needed for
- * hired-agent visibility, ZIG-535). A caller cannot run a tool and skip these
- * side effects — that is the whole point of funneling both paths here.
- *
- * `eff` is threaded into the tool context so eff-backed tools
- * (`ziggs_context_snapshot`, `ziggs_send_message`) resolve through this same path
- * regardless of which cognition invoked them.
- */
-export async function executeToolWithSideEffects(
-  deps: Pick<
-    ZiggsEffectDeps,
-    | 'toolManager'
-    | 'artifactsClient'
-    | 'telemetryClient'
-    | 'telemetryIngest'
-    | 'operatorKey'
-    | 'agentId'
-    | 'taskService'
-    | 'agreementService'
-    | 'contextReadClient'
-    | 'messageSender'
-  >,
-  eff: EffectHandler,
-  effect: Extract<Effect, { kind: 'tool-call' }>,
-  roster: { agents: unknown[]; users: unknown[] },
-): Promise<ToolCallResult> {
-  const toolT0 = Date.now();
-  const args = (effect.args as Record<string, unknown>) || {};
-  const argsPreview = previewToolArgs(args);
-  await emitToolOperationArtifact(deps.artifactsClient, effect.sessionId, 'started', {
-    state: 'started',
-    tool: effect.name,
-    ...(argsPreview ? { args: argsPreview } : {}),
-  });
-  try {
-    const lastUser = (roster.users as Array<{ userId?: string; id?: string }>).find(
-      (u) => u.userId || u.id,
-    );
-    // Accumulate token usage from any nested LLM call the tool makes (llmTool),
-    // so it can be folded into the turn's authoritative token count (ZIG-813).
-    let nestedUsage: { prompt_tokens: number; completion_tokens: number; total_tokens: number } | undefined;
-    const reportUsage = (u: LlmResponse['usage']): void => {
-      if (!u) return;
-      const p = u.prompt_tokens ?? u.promptTokens ?? 0;
-      const c = u.completion_tokens ?? u.completionTokens ?? 0;
-      const t = u.total_tokens ?? u.totalTokens ?? p + c;
-      nestedUsage = {
-        prompt_tokens: (nestedUsage?.prompt_tokens ?? 0) + p,
-        completion_tokens: (nestedUsage?.completion_tokens ?? 0) + c,
-        total_tokens: (nestedUsage?.total_tokens ?? 0) + t,
-      };
-    };
-    const result = await deps.toolManager.executeTool(effect.name, args, {
-      operatorKey: deps.operatorKey,
-      agentId: deps.agentId,
-      chatId: effect.sessionId,
-      taskService: deps.taskService,
-      agreementService: deps.agreementService,
-      contextReadClient: deps.contextReadClient,
-      sendMessage: deps.messageSender,
-      eff,
-      agents: roster.agents,
-      users: roster.users,
-      senderId: effect.senderId ?? lastUser?.userId ?? lastUser?.id,
-      senderType: effect.senderType ?? (lastUser ? 'USER' : undefined),
-      onBehalfOfAgreementId: effect.onBehalfOfAgreementId,
-      memory: effect.memory,
-      reportUsage,
-      turnScratch: {},
-    });
-    await emitToolOperationArtifact(deps.artifactsClient, effect.sessionId, 'completed', {
-      state: 'completed',
-      tool: effect.name,
-      result: clipForOperationArtifact(result),
-    });
-    sendTelemetry(
-      deps.telemetryClient,
-      buildToolIngestPayload({
-        sessionId: effect.sessionId,
-        tool: effect.name,
-        durationMs: Date.now() - toolT0,
-        ok: true,
-        runId: effect.runId,
-        stateId: effect.stateId,
-      }),
-      isTelemetryIngestEnabled(deps.telemetryIngest),
-    );
-    return { ok: true, result, ...(nestedUsage ? { usage: nestedUsage } : {}) } satisfies ToolCallResult;
-  } catch (error: unknown) {
-    const errMsg = (error as Error)?.message ?? String(error);
-    runtimeLog.warn('ZiggsEffectHandler', `tool-call "${effect.name}" failed: ${errMsg}`);
-    await emitToolOperationArtifact(deps.artifactsClient, effect.sessionId, 'error', {
-      state: 'failed',
-      tool: effect.name,
-      error: errMsg,
-    });
-    sendTelemetry(
-      deps.telemetryClient,
-      buildToolIngestPayload({
-        sessionId: effect.sessionId,
-        tool: effect.name,
-        durationMs: Date.now() - toolT0,
-        ok: false,
-        runId: effect.runId,
-        stateId: effect.stateId,
-      }),
-      isTelemetryIngestEnabled(deps.telemetryIngest),
-    );
-    return { ok: false, error: errMsg } satisfies ToolCallResult;
-  }
-}
-
-/**
- * Build a single shared EffectHandler. The handler is stateful — it caches
- * the latest ContextSnapshot per sessionId so tool-call effects can resolve
- * session-coupled deps (the `agents` roster) without forcing the Agent to
- * pass them through. Cache is bounded with simple LRU eviction (re-set on
- * read promotes the entry; oldest entry drops when size exceeds the cap).
- */
-export function createZiggsEffectHandler(deps: ZiggsEffectDeps): EffectHandler {
-  const contextCache = new Map<string, ContextSnapshot>();
-  const outbox = new OutboxBuffer();
-
-  const cachePut = (sessionId: string, snap: ContextSnapshot): void => {
-    if (contextCache.has(sessionId)) contextCache.delete(sessionId);
-    contextCache.set(sessionId, snap);
-    if (contextCache.size > CONTEXT_CACHE_MAX) {
-      const oldest = contextCache.keys().next().value;
-      if (oldest !== undefined) contextCache.delete(oldest);
-    }
-  };
-  const cacheGet = (sessionId: string): ContextSnapshot | undefined => {
-    const snap = contextCache.get(sessionId);
-    if (snap !== undefined) {
-      contextCache.delete(sessionId);
-      contextCache.set(sessionId, snap);
-    }
-    return snap;
-  };
-
-  const dispatch = async (effect: Effect): Promise<unknown> => {
-    switch (effect.kind) {
-      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,
-        // and the on-demand ziggs_context_snapshot tool — routes through here.
-        const snap = await buildSnapshot(deps, effect.sessionId, deps.agentId, {
-          limit: effect.opts?.maxMessages,
-        });
-        const me = (snap.agents as Array<{ isYou?: boolean; agentId?: string }>).find((a) => a?.isYou)?.agentId || null;
-        outbox.merge(effect.sessionId, snap.history as Record<string, unknown>[], me);
-        cachePut(effect.sessionId, snap);
-        return snap;
-      }
-
-
-      case 'llm-call': {
-        if (!deps.llm) throw new Error('llm-call effect requires an LLM adapter — none configured for this cognition');
-        const t0 = Date.now();
-        const r: LlmResponse = await deps.llm.chatMessages(effect.messages, effect.tools);
-        sendTelemetry(
-          deps.telemetryClient,
-          buildLlmIngestPayload(r, {
-            sessionId: effect.sessionId,
-            durationMs: Date.now() - t0,
-            runId: effect.runId,
-            stateId: effect.stateId,
-          }),
-          isTelemetryIngestEnabled(deps.telemetryIngest),
-        );
-        return r;
-      }
-
-      case 'stream-text': {
-        if (!deps.llm) throw new Error('stream-text effect requires an LLM adapter — none configured for this cognition');
-        const { sessionId, receiverId, messageId, messages } = effect;
-        let text = '';
-        let usage: LlmResponse['usage'];
-        if (deps.llm.chatMessagesStream) {
-          const streamed = await deps.llm.chatMessagesStream(messages as LlmMessage[], (chunk) => {
-            // Live-stream display is best-effort. The transport's send rejects
-            // empty/whitespace-only content (WebSocketClient: content.trim() === ''),
-            // and a whitespace-only chunk (e.g. a leading newline) is truthy yet
-            // still throws — which, uncaught, aborts the whole stream and loses the
-            // entire reply (e.g. a composer's final synthesis). Swallow chunk-send
-            // failures; `text` accumulates independently and the final send-message
-            // (below, in runTurn) carries the full reply regardless.
-            try {
-              if (chunk && chunk.trim()) deps.chunkSender?.(sessionId, receiverId, chunk, messageId);
-            } catch { /* ignore — streaming display only */ }
-          });
-          text = streamed.text;
-          usage = streamed.usage;
-        } else {
-          const r = await deps.llm.chatMessages(messages as LlmMessage[]);
-          text = r.content ?? '';
-          usage = r.usage;
-          if (text) deps.chunkSender?.(sessionId, receiverId, text, messageId);
-        }
-        return { text, usage };
-      }
-
-      case 'tool-call': {
-        // Roster comes from the cached snapshot (populated by read-context). Both
-        // cognitions land here — the FSM via runTurn's executeTool, the Claude
-        // Agent SDK via the toolManagerToSdkMcp bridge — so tool side effects are
-        // emitted exactly once, in one place (ZIG-775).
-        const cached = cacheGet(effect.sessionId);
-        return executeToolWithSideEffects(deps, handler as EffectHandler, effect, {
-          agents: (cached?.agents as unknown[]) || [],
-          users: (cached?.users as unknown[]) || [],
-        });
-      }
-
-      case 'send-message': {
-        await deps.messageSender(effect.text, effect.receiverId, effect.sessionId, effect.messageId);
-        outbox.track(effect.sessionId, { text: effect.text, receiverId: effect.receiverId });
-        return { ok: true };
-      }
-
-      case 'record-event': {
-        // Routes through ArtifactsClient as an agent-private artifact —
-        // visible to this agent across turns, not to other chat parties.
-        try {
-          if (effect.entry.kind === 'thought' && typeof effect.entry.text === 'string') {
-            await deps.artifactsClient.recordThought(effect.sessionId, effect.entry.text);
-          } else {
-            await deps.artifactsClient.write({
-              chatId: effect.sessionId,
-              text: JSON.stringify(effect.entry),
-              content_type: String(effect.entry.kind ?? 'event'),
-              visibility: 'agent-private',
-            });
-          }
-        } catch (err: unknown) {
-          runtimeLog.warn('ZiggsEffectHandler', `record-event failed: ${(err as Error)?.message ?? String(err)}`);
-        }
-        return { ok: true };
-      }
-
-      default: {
-        const exhaustive: never = effect;
-        throw new Error(`ZiggsEffectHandler: unknown effect kind ${(exhaustive as Record<string, unknown>).kind}`);
-      }
-    }
-  };
-
-  const handler = async (effect: Effect): Promise<unknown> => {
-    const response = await dispatch(effect);
-    deps.effectTap?.(effect, response);
-    return response;
-  };
-
-  return handler as EffectHandler;
-}

package/src/server/agreements/AgreementService.ts

@@ -1,118 +0,0 @@
-import {
-  proposeAgreement, proposeBroadcast as proposeBroadcastApi, delegateAgreement, respondToAgreement, counterAgreement,
-  getAgreementStatus, listAgreements, getMyAgreements, getAgreement,
-  publishOffer as publishOfferApi, createAgreement, revokeAgreement, fulfillAgreement, linkAgreementToChat,
-  getChatsForAgreement, joinAgreement, linkArtifactToAgreement, getArtifactsForAgreement,
-  linkUserToAgreement, getUsersForAgreement,
-  type Creds, type Agreement,
-  type ProposeAgreementData, type ProposeDirectInput, type ProposeBroadcastInput,
-  type PublishOfferPayload,
-  type DelegateAgreementData, type CounterAgreementData,
-  type CreateAgreementBody, type ListAgreementsFilters, type GetMyAgreementsFilters,
-  type ChatLinkType, type ArtifactLinkType, type UserRole,
-} from '@ziggs-ai/api-client';
-
-export class AgreementService {
-  private creds: Creds;
-
-  constructor(operatorKey: string, agentId: string) {
-    if (!operatorKey) throw new Error('AgreementService: operatorKey is required');
-    if (!agentId) throw new Error('AgreementService: agentId is required (operator-token impersonation)');
-    this.creds = { operatorKey, agentId };
-  }
-
-  /** 1:1 proposal. Server defaults engagementKind to `service` when omitted. */
-  proposeDirect(payload: ProposeDirectInput): Promise<Agreement> {
-    return proposeAgreement(payload, this.creds);
-  }
-
-  /**
-   * Open buyer-broadcast. `payload.audience` selects who may see/claim it:
-   * 'everyone' (default, fully public) or 'org' (members of your active org).
-   * Server defaults engagementKind to `service`.
-   */
-  proposeBroadcast(payload: ProposeBroadcastInput): Promise<Agreement> {
-    return proposeBroadcastApi(payload, this.creds);
-  }
-
-  /** @deprecated Alias for {@link proposeDirect}. */
-  propose(payload: ProposeAgreementData): Promise<Agreement> {
-    return proposeAgreement(payload, this.creds);
-  }
-
-  /**
-   * Seller-broadcast marketplace offer. `payload.audience` sets the `payer`
-   * sentinel: 'everyone' (default, public) or 'org' (your active org only).
-   */
-  publishOffer(payload: PublishOfferPayload): Promise<Agreement> {
-    return publishOfferApi(payload, this.creds);
-  }
-
-  delegate(payload: DelegateAgreementData): Promise<Agreement> {
-    return delegateAgreement(payload, this.creds);
-  }
-
-  respond(agreementId: string, action: 'approve' | 'reject'): Promise<Agreement> {
-    return respondToAgreement(agreementId, action, this.creds);
-  }
-
-  counter(agreementId: string, counter: CounterAgreementData): Promise<Agreement> {
-    return counterAgreement(agreementId, counter || {}, this.creds);
-  }
-
-  getStatus(agreementId: string): Promise<unknown | null> {
-    return getAgreementStatus(agreementId, this.creds);
-  }
-
-  list(filters: ListAgreementsFilters = {}): Promise<Agreement[]> {
-    return listAgreements(filters, this.creds);
-  }
-
-  mine(filters: GetMyAgreementsFilters = {}): Promise<Agreement[]> {
-    return getMyAgreements(filters, this.creds);
-  }
-
-  get(agreementId: string): Promise<Agreement | null> {
-    return getAgreement(agreementId, this.creds);
-  }
-
-  create(body: CreateAgreementBody): Promise<{ ok: boolean; agreement: Agreement }> {
-    return createAgreement(body, this.creds);
-  }
-
-  revoke(agreementId: string): Promise<{ ok: boolean; agreement: Agreement }> {
-    return revokeAgreement(agreementId, this.creds);
-  }
-
-  fulfill(agreementId: string): Promise<{ ok: boolean; agreement: Agreement }> {
-    return fulfillAgreement(agreementId, this.creds);
-  }
-
-  linkToChat(agreementId: string, chatId: string, linkType: ChatLinkType = 'mention'): Promise<unknown | null> {
-    return linkAgreementToChat(agreementId, chatId, linkType, this.creds);
-  }
-
-  getChats(agreementId: string): Promise<unknown[]> {
-    return getChatsForAgreement(agreementId, this.creds);
-  }
-
-  join(agreementId: string): Promise<{ chatId: string; agentId: string | null; isNew: boolean }> {
-    return joinAgreement(agreementId, this.creds);
-  }
-
-  linkArtifact(agreementId: string, artifactId: string, linkType: ArtifactLinkType = 'produced'): Promise<unknown | null> {
-    return linkArtifactToAgreement(agreementId, artifactId, linkType, this.creds);
-  }
-
-  getArtifacts(agreementId: string): Promise<unknown[]> {
-    return getArtifactsForAgreement(agreementId, this.creds);
-  }
-
-  linkUser(agreementId: string, userId: string, role: UserRole): Promise<unknown | null> {
-    return linkUserToAgreement(agreementId, userId, role, this.creds);
-  }
-
-  getUsers(agreementId: string): Promise<unknown[]> {
-    return getUsersForAgreement(agreementId, this.creds);
-  }
-}

package/src/server/createHealthServer.ts

@@ -1,85 +0,0 @@
-import { createServer, type Server } from 'http';
-import type { ConnectionPool } from './ConnectionPool.js';
-import type { AgentHost } from '../AgentHost.js';
-import { runtimeLog } from '../shared/runtimeLog.js';
-
-function readJsonBody(req: import('http').IncomingMessage): Promise<Record<string, unknown>> {
-  return new Promise((resolve, reject) => {
-    const chunks: Buffer[] = [];
-    req.on('data', (c) => chunks.push(c));
-    req.on('end', () => {
-      try {
-        const raw = Buffer.concat(chunks).toString('utf8');
-        resolve(raw ? (JSON.parse(raw) as Record<string, unknown>) : {});
-      } catch (err) {
-        reject(err);
-      }
-    });
-    req.on('error', reject);
-  });
-}
-
-export function createHealthServer({
-  port = Number(process.env.PORT) || 8080,
-  label = 'agents',
-  pool,
-}: {
-  port?: number;
-  label?: string;
-  pool?: ConnectionPool;
-} = {}): Server {
-  const server = createServer(async (req, res) => {
-    const url = req.url ?? '/';
-    const wakeMatch = url.match(/^\/fleet-wake\/([^/?]+)/);
-    if (req.method === 'POST' && wakeMatch && pool) {
-      const agentId = decodeURIComponent(wakeMatch[1]);
-      try {
-        await pool.wake(agentId);
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ ok: true, agentId, active: pool.listActive().includes(agentId) }));
-      } catch (err) {
-        res.writeHead(500, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ ok: false, error: (err as Error).message }));
-      }
-      return;
-    }
-
-    if (req.method === 'POST' && url === '/fleet-deliver' && pool) {
-      try {
-        const body = await readJsonBody(req);
-        const agentId = String(body.agentId ?? '');
-        const chatId = String(body.chatId ?? '');
-        const text = String(body.text ?? '');
-        const senderId = String(body.senderId ?? '');
-        if (!agentId || !chatId || !text || !senderId) {
-          res.writeHead(400, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ ok: false, error: 'agentId, chatId, text, senderId required' }));
-          return;
-        }
-        const host = (await pool.wake(agentId)) as AgentHost;
-        await host.handleMessage(text, {
-          chatId,
-          entryType: 'message',
-          content_type: 'text',
-          sender: { id: senderId, type: 'USER' },
-          receiver: { id: agentId, type: 'AGENT' },
-        });
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ ok: true, agentId }));
-      } catch (err) {
-        res.writeHead(500, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ ok: false, error: (err as Error).message }));
-      }
-      return;
-    }
-    if (url === '/health' || url === '/') {
-      res.writeHead(200);
-      res.end('ok');
-      return;
-    }
-    res.writeHead(404);
-    res.end();
-  });
-  server.listen(port, () => runtimeLog.info(label, `health server on port ${port}`));
-  return server;
-}