@ziggs-ai/agent-sdk 0.1.6 → 0.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ziggs-ai/agent-sdk",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Agent framework SDK for building autonomous agents on the Ziggs platform",
   "type": "module",
   "main": "src/index.ts",
@@ -16,14 +16,24 @@
     "test:watch": "node --experimental-test-module-mocks --import tsx/esm --test --watch test/*.test.ts"
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "@ziggs-ai/api-client": "^0.1.9",
     "ajv": "^8.17.1",
     "dotenv": "^17.2.3",
     "openai": "^4.0.0"
   },
-  "keywords": ["ziggs", "agent", "sdk", "ai", "autonomous"],
+  "keywords": [
+    "ziggs",
+    "agent",
+    "sdk",
+    "ai",
+    "autonomous"
+  ],
   "license": "MIT",
-  "files": ["src", "README.md"],
+  "files": [
+    "src",
+    "README.md"
+  ],
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"

package/src/adapters/McpAdapter.ts

@@ -0,0 +1,173 @@
+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 { AgentHost, type AgentHostOptions } from '../AgentHost.js';
+import type { ToolDefinition } from '../tools/defineTool.js';
+import { thinkingDefaults } from '../runtime/defaults.js';
+import type { Workflow } from '../types.js';
+
+export type McpTransportConfig =
+  | { type: 'stdio'; command: string; args?: string[]; env?: Record<string, string> }
+  | { type: 'http'; url: string };
+
+export interface CreateMcpAgentOptions extends Omit<AgentHostOptions, '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. */
+  extraTools?: ToolDefinition[];
+  /** Override the default single-state thinking workflow. */
+  workflow?: Workflow;
+}
+
+export interface McpAgentHandle {
+  host: AgentHost;
+  /** Disconnect the MCP client (call on shutdown alongside host.disconnect()). */
+  closeMcp: () => Promise<void>;
+  /** Names of MCP tools that were mapped to Ziggs tools on startup. */
+  toolNames: string[];
+}
+
+function buildTransport(config: McpTransportConfig) {
+  if (config.type === 'stdio') {
+    return new StdioClientTransport({
+      command: config.command,
+      args: config.args ?? [],
+      env: config.env,
+    });
+  }
+  return new StreamableHTTPClientTransport(new URL(config.url));
+}
+
+type McpTool = {
+  name: string;
+  description?: string;
+  inputSchema?: Record<string, unknown>;
+};
+
+type McpContent = { type: string; text?: string };
+
+function mcpContentToResult(content: McpContent[]): unknown {
+  const text = content
+    .map(c => (c.type === 'text' ? c.text ?? '' : JSON.stringify(c)))
+    .join('\n');
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+function mapMcpTools(client: Client, tools: McpTool[]): ToolDefinition[] {
+  return tools.map(tool => ({
+    schema: {
+      type: 'function' as const,
+      function: {
+        name: tool.name,
+        description: tool.description ?? '',
+        parameters: tool.inputSchema ?? { type: 'object', properties: {} },
+      },
+    },
+    handler: async (args: Record<string, unknown>) => {
+      const result = await client.callTool({ name: tool.name, arguments: args }) as {
+        isError?: boolean;
+        content: McpContent[];
+      };
+      if (result.isError) {
+        throw new Error(mcpContentToResult(result.content) as string);
+      }
+      return mcpContentToResult(result.content);
+    },
+    isGenericFallback: true,
+  }));
+}
+
+/**
+ * Wraps any MCP server as a Ziggs AgentHost.
+ *
+ * 1. Opens a connection to the MCP server (stdio or HTTP).
+ * 2. Calls tools/list and maps each tool to a Ziggs ToolDefinition.
+ * 3. Returns an AgentHost pre-loaded with those tools, ready to connectAsync().
+ *
+ * Usage:
+ *   const { host, 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();
+ *
+ *   process.on('SIGTERM', async () => {
+ *     host.disconnect();
+ *     await host.drain();
+ *     await closeMcp();
+ *   });
+ */
+function buildDefaultWorkflow(description: string): Workflow {
+  const dflt = thinkingDefaults({ initial: 'idle' });
+  return {
+    id: 'mcp-agent',
+    description: description || 'MCP-backed agent',
+    initial: 'idle',
+    states: {
+      idle: {
+        kind: 'thinking',
+        prompt: {
+          role: 'You are a helpful agent powered by an MCP server.',
+          goal: description || 'Help the user by calling the available tools.',
+          constraints: 'Use your tools to answer requests. When no action is needed, wait.',
+        },
+        actions: { ...dflt.actions },
+        transitions: [...dflt.transitions],
+      },
+    },
+  };
+}
+
+/**
+ * Wraps any MCP server as a Ziggs AgentHost.
+ *
+ * 1. Opens a connection to the MCP server (stdio or HTTP).
+ * 2. Calls tools/list and maps each tool to a Ziggs ToolDefinition.
+ * 3. Returns an AgentHost pre-loaded with those tools, ready to connectAsync().
+ *
+ * Usage:
+ *   const { host, 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();
+ *
+ *   process.on('SIGTERM', async () => {
+ *     host.disconnect();
+ *     await host.drain();
+ *     await closeMcp();
+ *   });
+ */
+export async function createMcpAgent(options: CreateMcpAgentOptions): Promise<McpAgentHandle> {
+  const { transport: transportConfig, extraTools = [], workflow, ...hostOptions } = options;
+
+  const transport = buildTransport(transportConfig);
+  const client = new Client({ name: 'ziggs-mcp-agent', version: '1.0.0' });
+
+  await client.connect(transport);
+
+  const { tools: rawTools } = await client.listTools();
+  const mcpTools = mapMcpTools(client, rawTools as McpTool[]);
+
+  const resolvedWorkflow = workflow ?? buildDefaultWorkflow(hostOptions.description ?? '');
+
+  const host = new AgentHost({
+    ...hostOptions,
+    workflow: resolvedWorkflow,
+    tools: [...mcpTools, ...extraTools],
+  });
+
+  return {
+    host,
+    closeMcp: () => client.close(),
+    toolNames: rawTools.map((t: McpTool) => t.name),
+  };
+}

package/src/adapters/OpenAIAdapter.ts

@@ -62,49 +62,85 @@ export class OpenAIAdapter {
       : undefined;
 
     try {
-      const { usage: _u, ...restOptions } = options as Record<string, unknown>;
-      // Verbose LLM request/response logging — commented out to reduce log noise.
-      // Re-enable by uncommenting to see full prompt/output blocks per LLM call.
-      // const divider = '─'.repeat(80);
-      // console.log(`\n${divider}`);
-      // console.log(`📤 LLM REQUEST → ${this.model}  (${messages.length} msg${messages.length === 1 ? '' : 's'})`);
-      // console.log(divider);
-      // for (const m of messages) {
-      //   const content = typeof m.content === 'string' ? m.content : JSON.stringify(m.content);
-      //   const len = content?.length ?? 0;
-      //   console.log(`\n[${m.role.toUpperCase()}]  ${len} chars`);
-      //   console.log(content ?? '');
-      // }
-      // console.log(`${divider}\n`);
+      const { usage: _u, response_format: _explicitResponseFormat, ...restOptions } = options as Record<string, unknown>;
+      const responseFormat = openAITools
+        ? undefined
+        : ((_explicitResponseFormat as OpenAI.ResponseFormatJSONObject) ?? { type: 'json_object' });
+
+      // OpenAI 400s response_format:{type:'json_object'} unless the word "json"
+      // appears somewhere in the messages. Callers are expected to mention it
+      // in their system prompt, but that's an implicit cross-file contract —
+      // guarantee it here instead of trusting every call site to remember.
+      let finalMessages = messages;
+      if (
+        responseFormat?.type === 'json_object' &&
+        !messages.some(m => {
+          const c = typeof m.content === 'string' ? m.content : JSON.stringify(m.content ?? '');
+          return /json/i.test(c);
+        })
+      ) {
+        finalMessages = [...messages, { role: 'system', content: 'Respond with valid JSON.' }];
+      }
+
+      // Verbose LLM request/response logging — enabled for debugging.
+      // Comment out again to reduce log noise.
+      const divider = '─'.repeat(80);
+      console.log(`\n${divider}`);
+      console.log(`📤 LLM REQUEST → ${this.model}  (${finalMessages.length} msg${finalMessages.length === 1 ? '' : 's'})`);
+      console.log(divider);
+      for (const m of finalMessages) {
+        const content = typeof m.content === 'string' ? m.content : JSON.stringify(m.content);
+        const len = content?.length ?? 0;
+        console.log(`\n[${m.role.toUpperCase()}]  ${len} chars`);
+        console.log(content ?? '');
+      }
+      console.log(`${divider}\n`);
       const res = await this.client.chat.completions.create({
         model: this.model,
-        messages,
+        messages: finalMessages,
         stream: false,
-        max_completion_tokens: 3000,
-        response_format: openAITools ? undefined : ((restOptions['response_format'] as OpenAI.ResponseFormatJSONObject) ?? { type: 'json_object' }),
+        // 25000 reserves room for hidden reasoning tokens on reasoning models
+        // (gpt-5.x/o-series) — they're billed against this cap before any
+        // visible content, so a low cap can exhaust the budget and return
+        // empty content with finish_reason "length".
+        max_completion_tokens: 25000,
+        response_format: responseFormat,
         ...(openAITools && { tools: openAITools }),
         ...restOptions,
       } as OpenAI.Chat.ChatCompletionCreateParamsNonStreaming);
 
       const msg = res.choices[0].message;
+      const finishReason = res.choices[0].finish_reason;
       const content = msg.content?.trim() ?? null;
       const toolCalls = msg.tool_calls?.length ? msg.tool_calls : null;
-      // Verbose LLM response logging — commented out to reduce log noise.
-      // console.log(`\n${divider}`);
-      // console.log(`📥 LLM RESPONSE ← ${this.model}`);
-      // console.log(divider);
-      // if (content) {
-      //   console.log(`\n[CONTENT]  ${content.length} chars`);
-      //   console.log(content);
-      // }
-      // if (toolCalls) {
-      //   console.log(`\n[TOOL CALLS]  ${toolCalls.length}`);
-      //   for (const tc of toolCalls) {
-      //     console.log(`  → ${tc.function.name}(${tc.function.arguments})`);
-      //   }
-      // }
-      // if (!content && !toolCalls) console.log('\n(no content, no tool calls)');
-      // console.log(`${divider}\n`);
+      // Verbose LLM response logging — enabled for debugging.
+      // Comment out again to reduce log noise.
+      console.log(`\n${divider}`);
+      console.log(`📥 LLM RESPONSE ← ${this.model}  finish=${finishReason}`);
+      console.log(divider);
+      if (content) {
+        console.log(`\n[CONTENT]  ${content.length} chars`);
+        console.log(content);
+      }
+      if (toolCalls) {
+        console.log(`\n[TOOL CALLS]  ${toolCalls.length}`);
+        for (const tc of toolCalls) {
+          console.log(`  → ${tc.function.name}(${tc.function.arguments})`);
+        }
+      }
+      if (!content && !toolCalls) console.log('\n(no content, no tool calls)');
+      if (res.usage) {
+        const u = res.usage as OpenAI.CompletionUsage & { completion_tokens_details?: { reasoning_tokens?: number } };
+        console.log(`\n[USAGE]  prompt=${u.prompt_tokens} completion=${u.completion_tokens}${u.completion_tokens_details?.reasoning_tokens != null ? ` (reasoning=${u.completion_tokens_details.reasoning_tokens})` : ''} total=${u.total_tokens}`);
+      }
+      console.log(`${divider}\n`);
+      if (!content && !toolCalls && finishReason === 'length') {
+        const u = res.usage as (OpenAI.CompletionUsage & { completion_tokens_details?: { reasoning_tokens?: number } }) | undefined;
+        throw new Error(
+          `LLM returned no usable output — completion token budget exhausted before any content ` +
+          `(finish_reason=length, reasoning_tokens=${u?.completion_tokens_details?.reasoning_tokens ?? 'unknown'})`,
+        );
+      }
       return {
         content,
         tool_calls: toolCalls,
@@ -131,7 +167,7 @@ export class OpenAIAdapter {
       model: this.model,
       messages,
       stream: true,
-      max_completion_tokens: 3000,
+      max_completion_tokens: 25000,
     });
     let text = '';
     for await (const chunk of stream) {

package/src/context/batch.ts

@@ -1,3 +1,5 @@
+import { isBroadcastTarget } from '@ziggs-ai/api-client';
+
 export function getBatchEvents(rawEvent: unknown): unknown[] {
   if (!rawEvent) return [];
   const e = rawEvent as Record<string, unknown>;
@@ -12,6 +14,6 @@ export function isTaskResultRelevantToAgent(result: Record<string, unknown>, own
     result['creatorIsYou'] || result['providerIsYou'] || result['payerIsYou'] || result['proposedToIsYou'] ||
     parties['creator'] === ownAgentId || parties['provider'] === ownAgentId ||
     parties['payer'] === ownAgentId || parties['proposedTo'] === ownAgentId ||
-    parties['proposedTo'] === 'everyone'
+    isBroadcastTarget(parties['proposedTo'] as string | undefined)
   );
 }

package/src/formatters/HistoryFormatter.ts

@@ -116,7 +116,13 @@ export class HistoryFormatter {
 
   formatParticipant(participant: AnyObj | null | undefined, agentId: string): string {
     if (!participant) return 'unknown';
-    const id = (participant['id'] as string) || 'unknown';
+    // Message.sender is stored as {agentId, underAgreementId} (no `id`, no
+    // `type`) while Message.receiver is {id, type} — two different shapes on
+    // the same document (see backend Message schema). Without this fallback,
+    // every sender renders as "unknown (unknown)" and self-sent history rows
+    // never match `id === agentId`, so the agent can't recognize its own
+    // past messages in <history>.
+    const id = (participant['id'] as string) || (participant['agentId'] as string) || 'unknown';
     if (participant['type'] === 'system') return 'System';
     if (id === agentId) return 'You';
     return `${id} (${participant['type'] || 'unknown'})`;

package/src/index.ts

@@ -9,6 +9,8 @@
  */
 
 export { defineAgent } from './defineAgent.js';
+export { createMcpAgent } from './adapters/McpAdapter.js';
+export type { CreateMcpAgentOptions, McpAgentHandle, McpTransportConfig } from './adapters/McpAdapter.js';
 export { AgentHost, createAgent, createAgentPool } from './AgentHost.js';
 export { Agent } from './agent/Agent.js';
 export type { TickInput, TickOutput, AgentOptions } from './agent/Agent.js';

package/src/pricing/fleetDefaults.ts

@@ -12,7 +12,7 @@ export const TIER_PRICE_CENTS: Record<FleetPricingTier, number> = {
   A: 200, // 2 ZIG / call
   B: 500, // 5 ZIG / call
   C: 1500, // 15 ZIG / job (orchestrator, charged once at top)
-  D: 100, // 1 ZIG / call (simulated)
+  D: 100, // 1 ZIG / call (hand-written demo agents)
 };
 
 const ZIGGS_ORCHESTRATOR_IDS = new Set(['ziggs-agent']);
@@ -144,11 +144,18 @@ export function applyFleetAgreementPricing(
   return next;
 }
 
-/** Default tier price when a fleet agent counters without an explicit `price`. */
-export function applyFleetCounterPricing(
-  payload: ProtocolPricingPayload,
+/**
+ * Default tier price when a fleet agent counters without an explicit `price`.
+ *
+ * Generic over the payload shape so the precise field types of the caller's
+ * payload survive the round-trip — this helper only ever sets `price`, so a
+ * richer input type (e.g. protocolRunner's `ProtocolPayload`) must come back
+ * out unwidened by `ProtocolPricingPayload`'s `[key: string]: unknown` index.
+ */
+export function applyFleetCounterPricing<T extends ProtocolPricingPayload>(
+  payload: T,
   actingAgentId: string,
-): ProtocolPricingPayload {
+): T {
   if (payload.price != null && payload.price !== undefined) {
     return payload;
   }
@@ -157,7 +164,7 @@ export function applyFleetCounterPricing(
     payload.description ?? payload.agreementDescription,
   );
   if (cents == null) return payload;
-  return { ...payload, price: cents };
+  return { ...payload, price: cents } as T;
 }
 
 /** User or agent direct-create / marketplace: default from provider specialist. */

package/src/pricing/fleetTierByAgentId.gen.ts

@@ -270,305 +270,6 @@ export const FLEET_TIER_BY_AGENT_ID: Record<string, FleetPricingTier> = {
   "feature-prioritizer": "C",
   "threat-model-committee": "C",
   "negotiation-simulator": "C",
-  "pizza-ordering-agent": "D",
-  "sushi-ordering-agent": "D",
-  "burger-ordering-agent": "D",
-  "salad-ordering-agent": "D",
-  "coffee-ordering-agent": "D",
-  "restaurant-finder": "D",
-  "reservation-maker": "D",
-  "menu-browser": "D",
-  "dietary-filter": "D",
-  "review-aggregator": "D",
-  "meal-planner": "D",
-  "recipe-finder": "D",
-  "grocery-list-builder": "D",
-  "calorie-counter": "D",
-  "wine-pairer": "D",
-  "food-delivery-tracker": "D",
-  "tip-calculator": "D",
-  "split-bill-calculator": "D",
-  "allergen-checker": "D",
-  "catering-coordinator": "D",
-  "party-food-planner": "D",
-  "food-truck-finder": "D",
-  "brunch-recommender": "D",
-  "dessert-advisor": "D",
-  "happy-hour-finder": "D",
-  "breakfast-planner": "D",
-  "late-night-eats-finder": "D",
-  "food-allergy-restaurant-finder": "D",
-  "kids-menu-finder": "D",
-  "flight-searcher": "D",
-  "hotel-booker": "D",
-  "car-rental": "D",
-  "airport-transfer": "D",
-  "visa-checker": "D",
-  "trip-planner": "D",
-  "itinerary-builder": "D",
-  "packing-list-maker": "D",
-  "currency-advisor": "D",
-  "travel-insurance": "D",
-  "train-booker": "D",
-  "bus-route-finder": "D",
-  "ferry-scheduler": "D",
-  "road-trip-planner": "D",
-  "toll-calculator": "D",
-  "rideshare-booker": "D",
-  "bike-share": "D",
-  "scooter-rental": "D",
-  "parking-finder": "D",
-  "traffic-checker": "D",
-  "travel-photo-finder": "D",
-  "local-guide": "D",
-  "phrase-book": "D",
-  "embassy-locator": "D",
-  "timezone-advisor": "D",
-  "cruise-finder": "D",
-  "camping-booker": "D",
-  "hostel-searcher": "D",
-  "vacation-rental": "D",
-  "loyalty-tracker": "D",
-  "electronics-shopper": "D",
-  "fashion-advisor": "D",
-  "book-recommender": "D",
-  "gift-finder": "D",
-  "price-comparator": "D",
-  "grocery-shopper": "D",
-  "furniture-browser": "D",
-  "auto-parts-finder": "D",
-  "pet-supplies": "D",
-  "sports-gear": "D",
-  "deal-hunter": "D",
-  "coupon-finder": "D",
-  "wishlist-manager": "D",
-  "return-tracker": "D",
-  "warranty-checker": "D",
-  "subscription-manager": "D",
-  "auction-bidder": "D",
-  "local-store-finder": "D",
-  "size-converter": "D",
-  "product-reviewer": "D",
-  "comparison-builder": "D",
-  "inventory-checker": "D",
-  "price-drop-monitor": "D",
-  "flash-sale-alerter": "D",
-  "barcode-scanner": "D",
-  "doctor-appointment-booker": "D",
-  "dentist-scheduler": "D",
-  "optometrist-finder": "D",
-  "symptom-checker": "D",
-  "medication-reminder": "D",
-  "prescription-tracker": "D",
-  "pharmacy-finder": "D",
-  "fitness-trainer": "D",
-  "workout-planner": "D",
-  "yoga-instructor": "D",
-  "meditation-guide": "D",
-  "step-counter": "D",
-  "nutrition-advisor": "D",
-  "diet-planner": "D",
-  "water-tracker": "D",
-  "sleep-tracker": "D",
-  "mood-logger": "D",
-  "mental-health-checkin": "D",
-  "stress-advisor": "D",
-  "breathing-guide": "D",
-  "first-aid-advisor": "D",
-  "vaccine-tracker": "D",
-  "insurance-claim-helper": "D",
-  "lab-result-explainer": "D",
-  "pet-vet-booker": "D",
-  "smart-light-controller": "D",
-  "thermostat-manager": "D",
-  "smart-lock-controller": "D",
-  "camera-monitor": "D",
-  "smart-speaker": "D",
-  "plumber-finder": "D",
-  "electrician-booker": "D",
-  "cleaner-scheduler": "D",
-  "gardener-finder": "D",
-  "pest-control": "D",
-  "interior-designer": "D",
-  "paint-matcher": "D",
-  "furniture-arranger": "D",
-  "lighting-planner": "D",
-  "utility-tracker": "D",
-  "energy-monitor": "D",
-  "water-advisor": "D",
-  "moving-coordinator": "D",
-  "storage-finder": "D",
-  "furniture-assembly-helper": "D",
-  "home-warranty-manager": "D",
-  "renovation-planner": "D",
-  "contractor-reviewer": "D",
-  "package-tracker": "D",
-  "handyman-finder": "D",
-  "bank-account-viewer": "D",
-  "transaction-categorizer": "D",
-  "budget-planner": "D",
-  "savings-tracker": "D",
-  "credit-card-advisor": "D",
-  "loan-calculator": "D",
-  "mortgage-estimator": "D",
-  "refinance-checker": "D",
-  "portfolio-tracker": "D",
-  "stock-trader-sim": "D",
-  "crypto-trader-sim": "D",
-  "robo-advisor": "D",
-  "tax-estimator": "D",
-  "deduction-finder": "D",
-  "tax-filing-assistant": "D",
-  "receipt-organizer": "D",
-  "auto-insurance-quoter": "D",
-  "home-insurance-quoter": "D",
-  "life-insurance-quoter": "D",
-  "health-insurance-quoter": "D",
-  "claim-filer": "D",
-  "bill-pay-scheduler": "D",
-  "subscription-auditor": "D",
-  "retirement-calculator": "D",
-  "college-savings-planner": "D",
-  "uber-sim": "D",
-  "lyft-sim": "D",
-  "taxi-booker": "D",
-  "shuttle-service": "D",
-  "limo-booker": "D",
-  "subway-navigator": "D",
-  "bus-tracker": "D",
-  "commuter-rail": "D",
-  "light-rail": "D",
-  "ferry-booker": "D",
-  "bike-rental": "D",
-  "scooter-rental-sim": "D",
-  "e-bike-finder": "D",
-  "skateboard-rental": "D",
-  "segway-tour": "D",
-  "parking-meter": "D",
-  "garage-finder": "D",
-  "valet-service": "D",
-  "airport-parking": "D",
-  "street-parking": "D",
-  "car-wash-finder": "D",
-  "oil-change-scheduler": "D",
-  "tire-shop": "D",
-  "mechanic-finder": "D",
-  "roadside-assistance": "D",
-  "course-finder": "D",
-  "university-searcher": "D",
-  "scholarship-finder": "D",
-  "admission-advisor": "D",
-  "resume-reviewer": "D",
-  "job-searcher": "D",
-  "interview-prepper": "D",
-  "salary-negotiator": "D",
-  "career-coach": "D",
-  "online-class-enrollor": "D",
-  "certificate-tracker": "D",
-  "skill-assessor": "D",
-  "mentor-matcher": "D",
-  "language-lesson-booker": "D",
-  "music-lesson-scheduler": "D",
-  "tutoring-booker": "D",
-  "internship-finder": "D",
-  "networking-advisor": "D",
-  "linkedin-optimizer": "D",
-  "conference-finder": "D",
-  "workshop-registrar": "D",
-  "webinar-scheduler": "D",
-  "library-manager": "D",
-  "study-group-coordinator": "D",
-  "campus-navigator": "D",
-  "concert-ticket-buyer": "D",
-  "movie-ticket-booker": "D",
-  "theater-booker": "D",
-  "party-organizer": "D",
-  "wedding-planner": "D",
-  "birthday-coordinator": "D",
-  "sports-ticket-buyer": "D",
-  "gym-membership-manager": "D",
-  "spa-booker": "D",
-  "streaming-manager": "D",
-  "playlist-curator": "D",
-  "podcast-recommender": "D",
-  "board-game-organizer": "D",
-  "trivia-host": "D",
-  "karaoke-picker": "D",
-  "museum-ticket-buyer": "D",
-  "zoo-pass-manager": "D",
-  "amusement-park-planner": "D",
-  "festival-finder": "D",
-  "book-club-organizer": "D",
-  "art-class-booker": "D",
-  "cooking-class-finder": "D",
-  "photography-booker": "D",
-  "escape-room-booker": "D",
-  "dmv-appointment": "D",
-  "passport-renewal": "D",
-  "visa-tracker": "D",
-  "voter-registration": "D",
-  "polling-finder": "D",
-  "official-lookup": "D",
-  "building-permit-tracker": "D",
-  "zoning-info": "D",
-  "noise-complaint-filer": "D",
-  "jury-duty-manager": "D",
-  "court-date-tracker": "D",
-  "public-record-searcher": "D",
-  "tax-authority-contact": "D",
-  "benefits-checker": "D",
-  "park-permit": "D",
-  "recycling-guide": "D",
-  "carbon-calculator": "D",
-  "eco-product-finder": "D",
-  "volunteer-finder": "D",
-  "donation-tracker": "D",
-  "charity-evaluator": "D",
-  "community-board": "D",
-  "neighborhood-alert": "D",
-  "lost-and-found": "D",
-  "carpool-matcher": "D",
-  "bike-route-planner": "D",
-  "transit-optimizer": "D",
-  "solar-estimator": "D",
-  "ev-charger-finder": "D",
-  "green-energy-advisor": "D",
-  "pet-adoption": "D",
-  "breeder-finder": "D",
-  "pet-sitter-booker": "D",
-  "dog-walker": "D",
-  "pet-groomer": "D",
-  "pet-boarding": "D",
-  "pet-food-delivery": "D",
-  "pet-toy-recommender": "D",
-  "pet-training-class": "D",
-  "pet-insurance-comparer": "D",
-  "dry-cleaner": "D",
-  "tailor-finder": "D",
-  "shoe-repair": "D",
-  "watch-repair": "D",
-  "phone-repair": "D",
-  "car-detailer": "D",
-  "car-wash-booker": "D",
-  "auto-detailing": "D",
-  "mechanic-scheduler": "D",
-  "tire-rotator": "D",
-  "photo-printer": "D",
-  "custom-framer": "D",
-  "engraver": "D",
-  "embroiderer": "D",
-  "storage-unit-finder": "D",
-  "junk-removal": "D",
-  "donation-pickup": "D",
-  "hauler": "D",
-  "painter-finder": "D",
-  "roofer-finder": "D",
-  "window-washer": "D",
-  "chimney-sweep": "D",
-  "snow-remover": "D",
-  "lawn-care": "D",
-  "tree-trimmer": "D",
-  "power-washer": "D",
   "aristotle": "B",
   "plato": "B",
   "confucius": "B",
@@ -1019,4 +720,4 @@ export const FLEET_TIER_BY_AGENT_ID: Record<string, FleetPricingTier> = {
   "death-studies-scholar": "B"
 } as Record<string, FleetPricingTier>;
 
-export const FLEET_TIER_MAP_SIZE = 1012;
+export const FLEET_TIER_MAP_SIZE = 713;

package/src/runtime/PromptBuilder.ts

@@ -2,6 +2,7 @@ import type { Action, Ctx, PromptDef } from '../types.js';
 import { HistoryFormatter, AgreementFormatter } from '../formatters/index.js';
 import { validateContext } from '../cognition/validateContext.js';
 import type { RawEvent } from './buildOutcome.js';
+import { isBroadcastTarget } from '@ziggs-ai/api-client';
 
 type AnyObj = Record<string, unknown>;
 
@@ -207,7 +208,9 @@ ${this._renderDecisionSchemaFromActions(actions, senderMeta, ctxObj, omitMessage
     const content = event.text || event.result || event.content;
     if (!content) return `<event type="${eventType}" from="${from}">(Empty)</event>`;
     const str = typeof content === 'object' ? JSON.stringify(content) : String(content);
-    const display = str.length > 1000 ? str.slice(0, 1000) + '...' : str;
+    // Matches MAX_MSG_CHARS in runTurn.ts — the incoming instruction shouldn't
+    // be truncated tighter than what the agent itself is allowed to send back.
+    const display = str.length > 3500 ? str.slice(0, 3500) + '...' : str;
     return `<event type="${eventType}" from="${from}">\n${display}\n</event>`;
   }
 
@@ -370,7 +373,7 @@ ${this._renderDecisionSchemaFromActions(actions, senderMeta, ctxObj, omitMessage
 
     const replyTo = (senderMeta.defaultReplyReceiverId as string) || '<receiverId>';
     const pendingProposals = (ctxObj.agreements || []).filter(
-      (a) => (a.proposal as Record<string, unknown> | undefined)?.status === 'pending' && (a.proposedToIsYou || (a.parties as Record<string, unknown> | undefined)?.proposedTo === 'everyone'),
+      (a) => (a.proposal as Record<string, unknown> | undefined)?.status === 'pending' && (a.proposedToIsYou || isBroadcastTarget((a.parties as Record<string, unknown> | undefined)?.proposedTo as string | undefined)),
     );
 
     if (pendingProposals.length > 0) {

package/src/runtime/runTurn.ts

@@ -424,9 +424,13 @@ function eventsAreTerminal(events: EmittedEvent[]): boolean {
       // (api-client now returns Agreement directly, not wrapped in { agreement }).
       const ag = (r.agreement ?? (r.agreementId ? r : null)) as Record<string, unknown> | null | undefined;
       const task = (r.task || (r.taskId ? r : null)) as Record<string, unknown> | null | undefined;
+      // Agreement's own status lives flat as `proposalStatus` (see api-client
+      // Agreement type) — not nested under `.proposal.status`. Check both so
+      // a successful agreement_propose is recognized as terminal instead of
+      // being re-issued by the LLM on the next loop iteration.
       const agProposal = ag?.proposal as Record<string, unknown> | undefined;
       const taskProposal = task?.proposal as Record<string, unknown> | undefined;
-      const proposalStatus = agProposal?.status || taskProposal?.status;
+      const proposalStatus = ag?.proposalStatus ?? agProposal?.status ?? taskProposal?.status;
       if (proposalStatus === 'pending' || proposalStatus === 'approved') return true;
       const state = task?.state || r.state;
       if (state === 'active' || state === 'in-progress' ||
@@ -445,10 +449,11 @@ function eventsContainAgreementCreation(events: EmittedEvent[]): boolean {
     if (r.success === false || r.error) return false;
     // Support both nested { agreement: {...} } and flat Agreement objects.
     const ag = (r.agreement ?? (r.agreementId ? r : null)) as Record<string, unknown> | undefined;
+    // See eventsAreTerminal above: proposalStatus is flat on Agreement, not nested.
     const agProposal = ag?.proposal as Record<string, unknown> | undefined;
     const task = r.task as Record<string, unknown> | undefined;
     const taskProposal = task?.proposal as Record<string, unknown> | undefined;
-    const proposalStatus = agProposal?.status || taskProposal?.status;
+    const proposalStatus = ag?.proposalStatus ?? agProposal?.status ?? taskProposal?.status;
     return proposalStatus === 'pending' || proposalStatus === 'approved';
   });
 }

package/src/server/InboxCatchUp.ts

@@ -171,7 +171,14 @@ export async function runInboxCatchUp(deps: InboxCatchUpDeps): Promise<InboxCatc
   const toAck: InboxAck[] = [];
 
   if (envelope.truncatedScopes > 0) {
-    warn(label, `inbox truncatedScopes=${envelope.truncatedScopes} — skipping ack until narrowed`);
+    // Informational only — does NOT block acking the scopes actually
+    // returned below. truncatedScopes just means the caller's total reach
+    // exceeded the server's per-call scope cap (backend/src/inbox/inbox.service.ts,
+    // INBOX_MAX_SCOPES); each entry in envelope.scopes is still an
+    // independently accurate, safe-to-ack unit of news for that scope. Never
+    // acking here meant a busy long-lived agent (reach > cap) would never ack
+    // anything and re-deliver its entire backlog on every reconnect forever.
+    warn(label, `inbox truncatedScopes=${envelope.truncatedScopes} (reach exceeds per-call cap — examined scopes are still acked normally)`);
   }
 
   for (const scope of envelope.scopes) {
@@ -202,11 +209,7 @@ export async function runInboxCatchUp(deps: InboxCatchUpDeps): Promise<InboxCatc
       }
     }
 
-    if (
-      envelope.truncatedScopes === 0 &&
-      scope.latestAt &&
-      (scope.newMessages > 0 || scope.newArtifacts > 0)
-    ) {
+    if (scope.latestAt && (scope.newMessages > 0 || scope.newArtifacts > 0)) {
       toAck.push({
         kind: scope.scope.kind,
         id: scope.scope.id,

package/src/server/agreements/AgreementService.ts

@@ -1,16 +1,15 @@
 import {
-  proposeAgreement, delegateAgreement, respondToAgreement, counterAgreement,
+  proposeAgreement, proposeBroadcast as proposeBroadcastApi, delegateAgreement, respondToAgreement, counterAgreement,
   getAgreementStatus, listAgreements, getMyAgreements, getAgreement,
   publishOffer as publishOfferApi, createAgreement, revokeAgreement, getAgreementsByChat, linkAgreementToChat,
   getChatsForAgreement, joinAgreement, linkArtifactToAgreement, getArtifactsForAgreement,
-  linkUserToAgreement, getUsersForAgreement, createContract,
-  OPEN_AGREEMENT_TARGET,
+  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, type CreateContractInput,
+  type ChatLinkType, type ArtifactLinkType, type UserRole,
 } from '@ziggs-ai/api-client';
 
 export class AgreementService {
@@ -22,19 +21,18 @@ export class AgreementService {
     this.creds = { operatorKey, agentId };
   }
 
-  /** @deprecated Prefer {@link proposeDirect} or {@link proposeBroadcast}. */
-  contract(input: CreateContractInput): Promise<Agreement> {
-    return createContract(input, this.creds);
-  }
-
   /** 1:1 proposal. Server defaults engagementKind to `service` when omitted. */
   proposeDirect(payload: ProposeDirectInput): Promise<Agreement> {
     return proposeAgreement(payload, this.creds);
   }
 
-  /** Open buyer-broadcast (`proposedTo: "everyone"`). Server defaults engagementKind to `service`. */
+  /**
+   * 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 proposeAgreement({ ...payload, proposedTo: OPEN_AGREEMENT_TARGET }, this.creds);
+    return proposeBroadcastApi(payload, this.creds);
   }
 
   /** @deprecated Alias for {@link proposeDirect}. */
@@ -42,7 +40,10 @@ export class AgreementService {
     return proposeAgreement(payload, this.creds);
   }
 
-  /** Seller-broadcast marketplace offer (`parties.payer = everyone`). */
+  /**
+   * 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);
   }

package/src/server/tasks/TaskService.ts

@@ -1,7 +1,7 @@
 import {
   createTask, getTask, getActiveTasksForAgent, getActiveTasksForChat, getSubtasks,
   updateTaskState, cancelTask,
-  claimLedgerTask, reportTask, setTaskSatisfaction, countTasks,
+  reportTask, setTaskSatisfaction, countTasks,
   type Creds, type Task, type TaskState,
 } from '@ziggs-ai/api-client';
 import type { CountTasksFilters } from '@ziggs-ai/api-client';
@@ -50,7 +50,7 @@ export class TaskService {
     return getSubtasks(parentTaskId, this.creds);
   }
 
-  async spawnUnderAgreement(agreementId: string, taskData: { description: string; parentTaskId?: string; plan?: unknown; planReviewTiming?: string; requireMidWorkPlanAck?: boolean }): Promise<Task> {
+  async spawnUnderAgreement(agreementId: string, taskData: { description: string; parentTaskId?: string; plan?: unknown; planReviewTiming?: string; requireMidWorkPlanAck?: boolean; assigneeId?: string }): Promise<Task> {
     if (!agreementId) throw new Error('TaskService.spawnUnderAgreement: agreementId is required');
     try {
       const result = await createTask({ ...taskData, agreementId } as Parameters<typeof createTask>[0], this.creds);
@@ -85,17 +85,6 @@ export class TaskService {
     }
   }
 
-  async claimLedgerTask(taskId: string): Promise<Task> {
-    try {
-      const task = await claimLedgerTask(taskId, this.creds);
-      runtimeLog.info('TaskService', `[ledger] Claimed task ${taskId}`);
-      return task as unknown as Task;
-    } catch (error) {
-      runtimeLog.warn('TaskService', `[ledger] Claim failed for ${taskId}: ${(error as Error).message}`);
-      throw error;
-    }
-  }
-
   async report(taskId: string, message = ''): Promise<Task> {
     return reportTask(taskId, message, this.creds);
   }

package/src/server/tools/index.ts

@@ -7,7 +7,8 @@
  * config (default 'all'), dispatched to in-process services (taskService /
  * agreementService) injected into tool context — NOT passed in the user `tools:`
  * array. Publishing open work is part of this grammar:
- * agreement_propose({ proposedTo: "everyone" }) — there is no separate publish tool.
+ * agreement_propose({ proposedTo: "everyone" }) for a public broadcast, or
+ * proposedTo: "org" to scope it to your org — there is no separate publish tool.
  *
  * Tier 2 — capability bundles (tier2/). Opt-in, HTTP-backed tool bundles an agent
  * chooses to have. Off by default; an agent gains a bundle by spreading it into

package/src/server/tools/tier1/protocolTools.ts

@@ -33,7 +33,7 @@ export const agreementProposeTool: ToolDefinition = defineTool(
   'agreement_propose',
   { description: { type: 'string', required: true }, proposedTo: { type: 'string', required: true }, engagementKind: { type: 'string', enum: ['hire', 'service'], description: 'Contract type. Defaults to service when omitted.' }, parentAgreementId: 'string', parentTaskId: 'string', payerId: 'string', providerId: 'string', price: 'number', lifecycle: 'string', expiresAt: 'string', maxExecutions: 'number', agreementDescription: 'string', plan: { type: 'object' }, planReviewTiming: 'string', requireMidWorkPlanAck: 'boolean' },
   handlerFor('agreement-propose'),
-  { description: 'Propose a contract to a user, agent, or everyone (proposedTo="everyone" for open broadcast). engagementKind defaults to service.', isAgreementCreation: true },
+  { description: 'Propose a contract to a user, agent, or as an open broadcast. For a broadcast set proposedTo="everyone" (fully public — any agent may claim) or proposedTo="org" (scoped to your org — only members of your org see and claim it). engagementKind defaults to service.', isAgreementCreation: true },
 );
 
 export const agreementSubcontractTool: ToolDefinition = defineTool(

package/src/server/tools/tier2/marketplaceTools.ts

@@ -1,10 +1,12 @@
 import { defineTool, type ToolDefinition } from '../../../tools/defineTool.js';
-import { pullFromLedger } from '@ziggs-ai/api-client';
+import { pullQuests } from '@ziggs-ai/api-client';
 
 type Ctx = Record<string, unknown>;
 
 // Read-only marketplace access. Publishing an open quest is NOT here: it is the
-// tier-1 protocol verb agreement_propose({ proposedTo: "everyone" }).
+// tier-1 protocol verb agreement_propose({ proposedTo: "everyone" | "org" }).
+// This feed already returns only quests the caller may see — org-scoped quests
+// appear here only for members of the quest's org (filtered server-side).
 export const marketplaceViewTool: ToolDefinition = defineTool('marketplace_view',
   { limit: 'number', since: 'string' },
   async (args, ctx) => {
@@ -16,10 +18,10 @@ export const marketplaceViewTool: ToolDefinition = defineTool('marketplace_view'
       limit: typeof args['limit'] === 'number' ? args['limit'] as number : 20,
     };
     if (args['since']) options.since = args['since'] as string;
-    const quests = await pullFromLedger(options, { operatorKey, agentId });
+    const quests = await pullQuests(options, { operatorKey, agentId });
     return { quests, count: quests.length };
   },
-  { description: 'Browse open quests on the marketplace — work that buyers have broadcast to any willing agent. Use to find available jobs. To claim a quest, use agreement_respond on the returned agreementId. To publish your own quest, use agreement_propose({ proposedTo: "everyone" }).' },
+  { description: 'Browse open quests on the marketplace — work buyers have broadcast to willing agents. Returns public quests plus any org-scoped quests in your org. To claim a quest, use agreement_respond on the returned agreementId. To publish your own, use agreement_propose({ proposedTo: "everyone" }) for a public quest or proposedTo: "org" to keep it inside your org.' },
 );
 
 export const MARKETPLACE_TOOLS: ToolDefinition[] = [marketplaceViewTool];