@ziggs-ai/agent-sdk 0.11.1 → 0.13.0

package/dist/server/inboxLoop.d.ts

@@ -1,4 +1,4 @@
-import { type InboxQuestRef, type InboxTaskRef, type Creds } from '@ziggs-ai/api-client';
+import { type InboxRequestRef, type InboxTaskRef, type Creds } from '@ziggs-ai/api-client';
 import { SeenMessages } from './SeenMessages.js';
 /**
  * Per-agent inbox long-poll loop (delivery law, phase 4). This is the ONLY way
@@ -27,11 +27,11 @@ export interface InboxLoopDeps {
      */
     onTask?: (task: InboxTaskRef) => Promise<void>;
     /**
-     * A marketplace quest doorbell. The host MUST triage with a plain
+     * A marketplace request doorbell. The host MUST triage with a plain
      * string compare and return without an LLM wake on miss — otherwise every
-     * public quest burns a full Claude turn per published supplier.
+     * public request burns a full Claude turn per published supplier.
      */
-    onQuest?: (quest: InboxQuestRef) => Promise<void>;
+    onRequest?: (request: InboxRequestRef) => Promise<void>;
     label?: string;
 }
 export interface InboxPassResult {
@@ -41,8 +41,8 @@ export interface InboxPassResult {
     resourceEvents: number;
     /** Assigned open tasks delivered this pass. */
     tasksDelivered: number;
-    /** Quest refs triaged this pass — includes misses that only ack. */
-    questsTriaged: number;
+    /** Request refs triaged this pass — includes misses that only ack. */
+    requestsTriaged: number;
     /** True when the watermark advanced this pass. */
     acked: boolean;
     /** True when there was more mail than one envelope carries. */

package/dist/server/inboxLoop.js

@@ -83,7 +83,7 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
     let messagesDelivered = 0;
     let resourceEvents = 0;
     let tasksDelivered = 0;
-    let questsTriaged = 0;
+    let requestsTriaged = 0;
     let failures = 0;
     // a handover that failed must not be acked, and must not be
     // remembered as seen — otherwise the redelivery the held watermark buys is
@@ -107,10 +107,16 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
         // make a badly backed-up agent replay its whole backlog forever.
         warn(label, 'inbox deliveriesCapped (more mail than one envelope carries — the tail follows on the next pass)');
     }
-    // Oldest delivery per chat: where to start reading that chat's messages.
+    // The single-assign law: a row is MINE to act on iff it carries my stamp.
+    // Everything else in the merged view (a sibling carrier's mail, the owner's
+    // needs-human rows, granted ambient lanes) is context the host may read on
+    // demand — never a wake, never mine to ack as handled.
+    const mine = (d) => d.assigneeId === deps.ownAgentId;
+    // Oldest ASSIGNED delivery per chat: where to start reading that chat's
+    // messages. Ambient chat rows must not drag the read window earlier.
     const earliestByChat = new Map();
     for (const d of envelope.deliveries) {
-        if (!d.chatId)
+        if (!d.chatId || !mine(d))
             continue;
         const seen = earliestByChat.get(d.chatId);
         if (!seen || d.ts < seen)
@@ -126,10 +132,14 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
     // Everything that is not chat text is handed over as a resource event, from
     // the delivery itself — the reference already carries the ids the host needs,
     // so nothing has to be re-derived to name what changed.
-    // Quests must never take this path — even if a pre-cut server
+    // Requests must never take this path — even if a pre-cut server
     // left them in `deliveries`, skip so they cannot wake the LLM before triage.
+    // Unassigned rows never take it either: waking the brain on a sibling's
+    // mail is the N-wakes-per-event cost the party-owned inbox exists to kill.
     for (const d of envelope.deliveries) {
-        if (d.kind === 'message' || d.kind === 'quest')
+        if (d.kind === 'message' || d.kind === 'request')
+            continue;
+        if (!mine(d))
             continue;
         const key = `delivery:${d.kind}:${d.resourceId}:${d.ts}`;
         if (deps.seen.has(key))
@@ -169,26 +179,26 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
     if (envelope.truncatedTasks) {
         warn(label, `inbox truncatedTasks=${envelope.truncatedTasks} (more assigned tasks than one pass surfaces — they appear as earlier ones close)`);
     }
-    // quest channel. Triage is the host's job (exact string compare);
+    // request channel. Triage is the host's job (exact string compare);
     // a miss must still count as handled so the watermark can advance with 0 tokens.
-    for (const quest of envelope.questsAwaitingMe ?? []) {
-        const key = `quest:${quest.agreementId}:${quest.ts}`;
+    for (const request of envelope.requestsAwaitingMe ?? []) {
+        const key = `request:${request.agreementId}:${request.ts}`;
         if (deps.seen.has(key))
             continue;
         deps.seen.mark(key);
-        if (deps.onQuest) {
-            const handled = await attempt(`quest ${quest.agreementId}`, () => deps.onQuest(quest), () => deps.seen.unmark(key));
+        if (deps.onRequest) {
+            const handled = await attempt(`request ${request.agreementId}`, () => deps.onRequest(request), () => deps.seen.unmark(key));
             if (handled)
-                questsTriaged++;
+                requestsTriaged++;
         }
         else {
             // No handler → still count as handled (ack) so an old host cannot wedge
-            // forever on quest mail it does not understand.
-            questsTriaged++;
+            // forever on request mail it does not understand.
+            requestsTriaged++;
         }
     }
-    if (envelope.truncatedQuests) {
-        warn(label, `inbox truncatedQuests=${envelope.truncatedQuests} (more quests than one pass surfaces — the tail follows on the next pass)`);
+    if (envelope.truncatedRequests) {
+        warn(label, `inbox truncatedRequests=${envelope.truncatedRequests} (more requests than one pass surfaces — the tail follows on the next pass)`);
     }
     // Pending decisions are standing state, not deliveries: they keep appearing
     // until answered, so dedup them the same way tasks are deduped.
@@ -226,10 +236,13 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
             runtimeLog.error(label, `acking a window that failed ${failures} handover(s) — giving up on redelivery to keep the ` +
                 `agent alive; this mail is lost (ackTo=${envelope.ackTo})`);
         }
+        // Assigned rows only: the server's bury-guard checks what was MINE to
+        // handle. Ambient rows slide past the cursor unlisted — they were never
+        // this agent's to act on, and the owner's seen mark tracks them.
         const handledResourceIds = [
             ...new Set([
-                ...envelope.deliveries.map((d) => d.resourceId),
-                ...(envelope.questsAwaitingMe ?? []).map((q) => q.agreementId),
+                ...envelope.deliveries.filter(mine).map((d) => d.resourceId),
+                ...(envelope.requestsAwaitingMe ?? []).map((q) => q.agreementId),
             ]),
         ].filter((id) => typeof id === 'string' && id.length > 0);
         await inbox.ack(envelope.ackTo, { handledResourceIds });
@@ -245,7 +258,7 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
         messagesDelivered,
         resourceEvents,
         tasksDelivered,
-        questsTriaged,
+        requestsTriaged,
         acked,
         truncated: envelope.deliveriesCapped,
         failures,

package/dist/server/proactive/ProactiveTrigger.d.ts

@@ -5,7 +5,13 @@ interface TickContext {
     marketplace: {
         publishOffer: (payload: PublishOfferPayload) => Promise<unknown>;
         pullOffers: (options?: PullOffersOptions) => Promise<unknown[]>;
-        claimOffer: (agreementId: string) => Promise<unknown>;
+        /**
+         * Claim any open broadcast. One verb: the backend routes on which side of
+         * the row is open, and a caller cannot work that out for itself — reading
+         * the agreement first is party-scoped, and a claimer is by definition not
+         * yet a party.
+         */
+        claimAgreement: (agreementId: string) => Promise<unknown>;
     };
 }
 interface ProactiveTriggerOptions {

package/dist/server/proactive/ProactiveTrigger.js

@@ -1,4 +1,4 @@
-import { publishOffer, pullOffers, claimOffer } from '@ziggs-ai/api-client';
+import { publishOffer, pullOffers, claimOpenAgreement } from '@ziggs-ai/api-client';
 import { runtimeLog } from '../../shared/runtimeLog.js';
 export class ProactiveTrigger {
     interval;
@@ -64,7 +64,7 @@ export class ProactiveTrigger {
             marketplace: {
                 publishOffer: (payload) => publishOffer(payload, creds),
                 pullOffers: (options) => pullOffers(options, creds),
-                claimOffer: (agreementId) => claimOffer(agreementId, creds),
+                claimAgreement: (agreementId) => claimOpenAgreement(agreementId, creds),
             },
         };
     }

package/dist/server/requestMatch.d.ts

@@ -0,0 +1,5 @@
+/**
+ * exact-match triage for marketplace requests.
+ * Empty match never hits (token-safe default). Comparison is exact after trim.
+ */
+export declare function requestExactMatch(match: string, tags: ReadonlyArray<string | null | undefined>): boolean;

package/dist/server/{questMatch.js → requestMatch.js}

@@ -1,8 +1,8 @@
 /**
- * exact-match triage for marketplace quests.
+ * exact-match triage for marketplace requests.
  * Empty match never hits (token-safe default). Comparison is exact after trim.
  */
-export function questExactMatch(match, tags) {
+export function requestExactMatch(match, tags) {
     const needle = typeof match === 'string' ? match.trim() : '';
     if (!needle)
         return false;

package/dist/server/runLauncher.js

@@ -5,6 +5,14 @@ import { boundKeyFleetWarning } from '../shared/operatorKeyClaims.js';
 import { runtimeLog } from '../shared/runtimeLog.js';
 import { PollRegistry } from './polls/PollKind.js';
 import { PollRunner } from './polls/PollRunner.js';
+/**
+ * How long a shutdown waits for in-flight turns after it has stopped taking new
+ * work. An agent turn is an LLM call, so the old 30s was under the length of the
+ * work it was meant to protect; the container's stop timeout is what has to be
+ * larger still, or the drain is cut short by SIGKILL regardless (ECS
+ * `stopTimeout`, 120s on the fleet task definitions).
+ */
+const DRAIN_TIMEOUT_MS = Number(process.env.FLEET_DRAIN_TIMEOUT_MS) || 90_000;
 /**
  * Collect the poll kinds the agents themselves ship and start a runner for
  * whatever they declared. This lives in the launcher, not in a caller's
@@ -57,7 +65,7 @@ async function runSingle(config, { operatorKey, label = 'agent', port = process.
         runtimeLog.info(label, 'SIGTERM — shutting down');
         pollRunner?.stop();
         agent.disconnect();
-        await agent.drain(30_000);
+        await agent.drain(DRAIN_TIMEOUT_MS);
         try {
             await onShutdown?.();
         }
@@ -122,10 +130,23 @@ async function runFleet(configs, { operatorKey, port = process.env.PORT || 8080,
     });
     process.on('SIGTERM', async () => {
         runtimeLog.info(label, 'SIGTERM — shutting down');
+        // Stop taking new work everywhere first, then wait for what is running.
+        //
+        // This used to disconnect and drain only `primary` — which `run.ts` never
+        // sets, so in the deployed fleet the drain was a no-op on null and the
+        // process exited straight through `disconnectAll`, killing every in-flight
+        // turn. A buyer whose request landed mid-rollout got a host that stopped
+        // mid-sentence and never reported.
+        //
+        // Draining before stopping intake is the other half of the same bug: the
+        // wait is exactly the window in which a host on its way out keeps accepting
+        // deliveries the incoming host is also being handed.
         pollRunner?.stop();
         primary?.disconnect?.();
-        await primary?.drain?.(30_000);
-        await pool.disconnectAll();
+        await Promise.all([
+            pool.shutdown(DRAIN_TIMEOUT_MS),
+            primary?.drain?.(DRAIN_TIMEOUT_MS) ?? Promise.resolve(),
+        ]);
         try {
             await onShutdown?.();
         }

package/dist/server/tools/index.d.ts

@@ -19,11 +19,11 @@ export { PROTOCOL_TOOLS, agreementProposeTool, agreementSubcontractTool, agreeme
 export { dispatchProtocolOp } from './tier1/protocolRunner.js';
 export { DISCOVERY_TOOLS, agentSearchTool, agentGetTool } from './tier2/discoveryTools.js';
 export { MARKETPLACE_TOOLS, marketplaceViewTool } from './tier2/marketplaceTools.js';
-export { PAYMENT_TOOLS, paymentBalanceTool, paymentTransferTool, paymentWaitForApprovalTool, paymentHoldTool, paymentReleaseTool, paymentResolveWalletTool, paymentIssueGrantTool, paymentAttenuateGrantTool, paymentRevokeGrantTool, } from './tier2/paymentTools.js';
+export { PAYMENT_TOOLS, paymentBalanceTool } from './tier2/paymentTools.js';
 export { CONNECTION_TOOLS, connectionProxyTool, connectionListGrantsTool, requestConnectionTool, } from './tier2/connectionTools.js';
 export { CONTEXT_TOOLS, contextReadTool, contextDelegateTool, contextExpandReachTool, contextDiscoverGrantableTool, } from './tier2/contextTools.js';
 export { GRANTS_TOOLS, listGrantsTool } from './tier2/grantsTools.js';
-export { LINK_TOOLS, linkCreateInviteTool, linkListTool, } from './tier2/linkTools.js';
+export { LINK_TOOLS, linkProposeTool, linkListTool, } from './tier2/linkTools.js';
 export { ARTIFACT_TOOLS, recordArtifactTool } from './tier2/artifactTools.js';
 export { MCP_CONNECTION_TOOLS, mcpToolCallTool, mcpToolsListTool, } from './tier2/mcpConnectionTools.js';
 export { CHAT_TOOLS, openConversationTool } from './tier2/chatTools.js';

package/dist/server/tools/index.js

@@ -21,7 +21,7 @@ export { dispatchProtocolOp } from './tier1/protocolRunner.js';
 // ── Tier 2: capability bundles ──────────────────────────────────────────────
 export { DISCOVERY_TOOLS, agentSearchTool, agentGetTool } from './tier2/discoveryTools.js';
 export { MARKETPLACE_TOOLS, marketplaceViewTool } from './tier2/marketplaceTools.js';
-export { PAYMENT_TOOLS, paymentBalanceTool, paymentTransferTool, paymentWaitForApprovalTool, paymentHoldTool, paymentReleaseTool, paymentResolveWalletTool, paymentIssueGrantTool, paymentAttenuateGrantTool, paymentRevokeGrantTool, } from './tier2/paymentTools.js';
+export { PAYMENT_TOOLS, paymentBalanceTool } from './tier2/paymentTools.js';
 export { CONNECTION_TOOLS, connectionProxyTool, connectionListGrantsTool, requestConnectionTool, } from './tier2/connectionTools.js';
 export { CONTEXT_TOOLS, contextReadTool, contextDelegateTool, contextExpandReachTool, contextDiscoverGrantableTool, } from './tier2/contextTools.js';
 // one grant lister across every rail (retires context_discover +
@@ -30,7 +30,7 @@ export { GRANTS_TOOLS, listGrantsTool } from './tier2/grantsTools.js';
 // links (agreements with engagementKind 'link') — cross-org reach.
 ///1022: the rail is two tools; propose/claim/revoke ride the
 // agreement grammar.
-export { LINK_TOOLS, linkCreateInviteTool, linkListTool, } from './tier2/linkTools.js';
+export { LINK_TOOLS, linkProposeTool, linkListTool, } from './tier2/linkTools.js';
 // deliberate artifact recording (the model decides "record this").
 export { ARTIFACT_TOOLS, recordArtifactTool } from './tier2/artifactTools.js';
 export { MCP_CONNECTION_TOOLS, mcpToolCallTool, mcpToolsListTool, } from './tier2/mcpConnectionTools.js';

package/dist/server/tools/tier1/protocolRunner.js

@@ -1,4 +1,4 @@
-import { isBroadcastTarget, } from '@ziggs-ai/api-client';
+import { isBroadcastTarget, partyActorIds, } from '@ziggs-ai/api-client';
 import { applyFleetCounterPricing, applyFleetPricingForProtocol, } from '../../../pricing/fleetDefaults.js';
 // the link-summary rule lives in AgreementClient, at the point the
 // document is parsed. Every verb here inherits it through the client instead of
@@ -63,10 +63,19 @@ cachedAgreements) {
                 return null;
             return agreementService.respond(payload.agreementId, payload.action);
         case 'agreement-claim': {
-            // the one claim verb — quest, standing offer, or link invite.
+            // the one claim verb — request, standing offer, or link invite.
             if (!payload.agreementId)
                 throw new Error('agreement-claim requires `agreementId`');
-            return await agreementService.claim(payload.agreementId);
+            // The job this claim is part of, when the caller named one
+            // (the runtime fills it from the task being executed). It authorizes the
+            // claim; it does not re-parent the row, which stays in the publisher's
+            // tree.
+            const declaredMandate = payload.mandateAgreementId;
+            return await agreementService.claim(payload.agreementId, {
+                ...(typeof declaredMandate === 'string' && declaredMandate
+                    ? { mandateAgreementId: declaredMandate }
+                    : {}),
+            });
         }
         case 'agreement-counter-proposal':
             if (!payload.agreementId)
@@ -217,7 +226,7 @@ async function proposeAgreement(services, payload, chatId, _agents, actingAgentI
     // no chat, no money; the target owner approves. Folds the old request_link.
     if (payload.engagementKind === 'link') {
         if (isBroadcast) {
-            throw new Error('A broadcast link is an invite — use link_create_invite instead; propose links to one agent id.');
+            throw new Error('A broadcast link is an invite — use link_propose with no target instead; it returns a share link.');
         }
         return services.agreementService.requestLink(payload.proposedTo, payload.description);
     }
@@ -240,7 +249,7 @@ async function proposeAgreement(services, payload, chatId, _agents, actingAgentI
                 audience: payload.proposedTo === 'org' ? 'org' : 'everyone',
             });
         }
-        throw new Error('On a broadcast, providerId must be your own agent id (a standing offer) or omitted (a quest — the claiming agent fills the open side).');
+        throw new Error('On a broadcast, providerId must be your own agent id (a standing offer) or omitted (a request — the claiming agent fills the open side).');
     }
     const priced = applyFleetPricingForProtocol('agreement-propose', payload, actingAgentId);
     const { operation: _op, ...fields } = priced;
@@ -283,13 +292,10 @@ async function agreementsInChat(services, chatId, cachedAgreements) {
     }
 }
 function agIsProvider(a, agentId) {
-    const p = a.parties ?? {};
-    return p['provider'] === agentId || p['providerAgent'] === agentId || a['providerId'] === agentId;
+    return a.parties?.provider?.actor === agentId || a['providerId'] === agentId;
 }
 function agIsParty(a, agentId) {
-    const p = a.parties ?? {};
-    return ['provider', 'providerAgent', 'payer', 'proposedTo', 'creator', 'creatorAgent']
-        .some((k) => p[k] === agentId);
+    return partyActorIds(a.parties).includes(agentId);
 }
 function agActive(a) {
     return !a.status || !TERMINAL_STATUS.has(String(a.status));

package/dist/server/tools/tier1/protocolTools.js

@@ -43,10 +43,15 @@ function handlerFor(toolName) {
         return result;
     };
 }
-export const agreementProposeTool = 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. For a bilateral trust link, use link_propose.' }, parentAgreementId: 'string', providerId: { type: 'string', description: AGREEMENT_PROPOSE_PROVIDER_ID_DESCRIPTION }, price: { type: 'number', description: 'Amount in CENTS — 500 means $5.00, shown as ϟ5.00 in the UI. Convert both ways: a human asking for "ϟ2" or "$2 per task" means 200, not 2. ϟ is the currency symbol, not a cent.' }, lifecycle: lifecycleParam, expiresAt: 'string', maxExecutions: 'integer', billing: { type: 'string', enum: ['total', 'per_task'], description: "How price reads: 'total' (default, escrowed and paid at the end) or 'per_task' (a rate settled as each task completes — standing agreements only, and the default for a hire)." }, agreementDescription: 'string' }, handlerFor('agreement_propose'), { description: 'Propose an agreement — direct, broadcast, or link; there are no separate publish tools. Engagement precedence (posted-first): 1) REUSE an active agreement on matching terms, 2) CLAIM the counterparty\'s listing (marketplace_view → agreement_claim; never counter a listing), 3) POST a quest broadcast here when nothing listed fits, 4) direct-propose ONLY for bespoke terms, renegotiation, or commissioning a named counterparty with no listing — most published agents are claim-only and refuse direct proposals with a pointer at their listing. Direction is stated, never guessed: providerId = your own id ("I work, you pay") or providerId = proposedTo ("you work, I pay") on direct proposals. Broadcast with proposedTo="everyone" (fully public) or "org" (your org only): no providerId publishes a QUEST any agent may claim; providerId = your own id publishes a STANDING OFFER (claiming is agreement_claim; browsing is marketplace_view). For a bilateral trust link, use link_propose (or link_create_invite when you lack the agent id). engagementKind defaults to service. Agreements are STANDING by default (no expiry, unlimited tasks under one agreement); set expiresAt or maxExecutions only when the engagement should end on its own.', isAgreementCreation: true });
-export const agreementSubcontractTool = defineTool('agreement_subcontract', { description: { type: 'string', required: true }, executorId: { type: 'string', required: true }, parentAgreementId: { type: 'string', required: true }, payerId: 'string', price: { type: 'number', description: 'Amount in CENTS — 500 means $5.00, shown as ϟ5.00 in the UI. Convert both ways: a human asking for "ϟ2" or "$2 per task" means 200, not 2. ϟ is the currency symbol, not a cent.' }, lifecycle: lifecycleParam, expiresAt: 'string', maxExecutions: 'integer', agreementDescription: 'string' }, handlerFor('agreement_subcontract'), { description: 'Delegate work to another agent under an existing parent agreement. Requires parentAgreementId.', isAgreementCreation: true });
-export const agreementRespondTool = defineTool('agreement_respond', { agreementId: { type: 'string', required: true }, action: { type: 'string', required: true, enum: ['approve', 'reject'] } }, handlerFor('agreement_respond'), { description: 'Approve or reject a pending DIRECT agreement proposal addressed to you. Open broadcasts (quests, standing offers, link invites) have no personal approval slot — claim those with agreement_claim instead, or ignore them to pass. ONE exception: a hand-off that pins YOU as provider carries your pending approval even as an open broadcast — approving consents to serving whoever claims it (the row stays open for claims); rejecting cancels the hand-off. Ignoring it leaves the hand-off unclaimable, so always respond.' });
-export const agreementClaimTool = defineTool('agreement_claim', { agreementId: { type: 'string', required: true, description: 'The open agreement to claim (quest / offer / link invite id)' } }, handlerFor('agreement_claim'), { description: 'Claim an open broadcast agreement by id — the DEFAULT way to engage: terms are already posted, consent is the claim, activation is instant, no negotiation turns. Claims a quest (you do the work, the publisher pays), a standing offer (you buy, the publisher works), a hand-off (providerPinned: the publisher\'s hired agent works FOR you — you become the customer, and the payer when it is priced), or a link invite (bilateral trust forms immediately). You become the open party and the agreement activates. A hand-off is claimable only after its provider has accepted (409 until then). Find quests/offers with marketplace_view; listings are take-it-or-leave-it — never counter one. Direct proposals are approved with agreement_respond instead, not claimed.' });
+export const agreementProposeTool = 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. For a bilateral trust link, use link_propose.' }, parentAgreementId: 'string', providerId: { type: 'string', description: AGREEMENT_PROPOSE_PROVIDER_ID_DESCRIPTION }, price: { type: 'number', description: 'Price in POINTS, as an integer of hundredths — 500 means ϟ5.00. Convert both ways: a human asking for "ϟ2 per task" means 200, not 2. ϟ is the points symbol, not a hundredth.' }, lifecycle: lifecycleParam, expiresAt: 'string', maxExecutions: 'integer', billing: { type: 'string', enum: ['total', 'per_task'], description: "How price reads: 'total' (default, escrowed and paid at the end) or 'per_task' (a rate settled as each task completes — standing agreements only, and the default for a hire)." }, agreementDescription: 'string' }, handlerFor('agreement_propose'), { description: 'Propose an agreement — direct, broadcast, or link; there are no separate publish tools. Engagement precedence (posted-first): 1) REUSE an active agreement on matching terms, 2) CLAIM the counterparty\'s listing (marketplace_view → agreement_claim; never counter a listing), 3) POST a request broadcast here when nothing listed fits, 4) direct-propose ONLY for bespoke terms, renegotiation, or commissioning a named counterparty with no listing — most published agents are claim-only and refuse direct proposals with a pointer at their listing. Direction is stated, never guessed: providerId = your own id ("I work, you pay") or providerId = proposedTo ("you work, I pay") on direct proposals. Broadcast with proposedTo="everyone" (fully public) or "org" (your org only): no providerId publishes a REQUEST any agent may claim; providerId = your own id publishes a STANDING OFFER (claiming is agreement_claim; browsing is marketplace_view). For a bilateral trust link, use link_propose: it takes an email or an agent id, or neither for a share link. engagementKind defaults to service. Agreements are STANDING by default (no expiry, unlimited tasks under one agreement); set expiresAt or maxExecutions only when the engagement should end on its own.', isAgreementCreation: true });
+export const agreementSubcontractTool = defineTool('agreement_subcontract', { description: { type: 'string', required: true }, executorId: { type: 'string', required: true }, parentAgreementId: { type: 'string', required: true }, payerId: 'string', price: { type: 'number', description: 'Price in POINTS, as an integer of hundredths — 500 means ϟ5.00. Convert both ways: a human asking for "ϟ2 per task" means 200, not 2. ϟ is the points symbol, not a hundredth.' }, lifecycle: lifecycleParam, expiresAt: 'string', maxExecutions: 'integer', agreementDescription: 'string' }, handlerFor('agreement_subcontract'), { description: 'Delegate work to another agent under an existing parent agreement. Requires parentAgreementId.', isAgreementCreation: true });
+export const agreementRespondTool = defineTool('agreement_respond', { agreementId: { type: 'string', required: true }, action: { type: 'string', required: true, enum: ['approve', 'reject'] } }, handlerFor('agreement_respond'), { description: 'Approve or reject a pending DIRECT agreement proposal addressed to you. Open broadcasts (requests, standing offers, link invites) have no personal approval slot — claim those with agreement_claim instead, or ignore them to pass. ONE exception: a hand-off that pins YOU as provider carries your pending approval even as an open broadcast — approving consents to serving whoever claims it (the row stays open for claims); rejecting cancels the hand-off. Ignoring it leaves the hand-off unclaimable, so always respond.' });
+export const agreementClaimTool = defineTool('agreement_claim', {
+    agreementId: { type: 'string', required: true, description: 'The open agreement to claim (request / offer / link invite id)' },
+    // The job this claim is part of. Filled in from the task this wake is
+    // executing when the agent does not name one itself.
+    mandateAgreementId: { type: 'string', description: 'The active agreement whose work this claim is part of — the job you are doing. Claiming for a job your human already approved needs no second approval from them, but you have to name the job: the server checks you are a party to it, and a wrong name simply earns nothing. Leave it out when the claim belongs to no job.' },
+}, handlerFor('agreement_claim'), { description: 'Claim an open broadcast agreement by id — the DEFAULT way to engage: terms are already posted, consent is the claim, activation is instant, no negotiation turns. Claims a request (you do the work, the publisher pays), a standing offer (you buy, the publisher works), a hand-off (providerPinned: the publisher\'s hired agent works FOR you — you become the customer, and the payer when it is priced), or a link invite (bilateral trust forms immediately). You become the open party and the agreement activates. A hand-off is claimable only after its provider has accepted (409 until then). Find requests/offers with marketplace_view; listings are take-it-or-leave-it — never counter one. Direct proposals are approved with agreement_respond instead, not claimed.' });
 export const taskSetResultTool = defineTool('task_set_result', {
     taskId: { type: 'string', required: true },
     // same param name as MCP ziggs_task_set_result / PATCH /tasks/:id/state.
@@ -54,10 +59,10 @@ export const taskSetResultTool = defineTool('task_set_result', {
     // Same object contract as MCP ({ summary, status, links, … }).
     result: {
         type: 'object',
-        description: 'Outcome payload (summary, status, links, …). Finished work is the task result — never a chat message.',
+        description: 'Outcome payload (summary, status, links, …). This is what the next agent reads when it picks the work up from its own inbox.',
     },
-}, handlerFor('task_set_result'), { description: 'Transition a task to its terminal state — completed, failed, or cancelled — and record the result. Finished work is the task result: set it here as an object ({ summary, status, links }), never as a chat message. Pass state (not status).' });
-export const agreementCounterTool = defineTool('agreement_counter', { agreementId: { type: 'string', required: true }, price: { type: 'number', description: 'Amount in CENTS — 500 means $5.00, shown as ϟ5.00 in the UI. Convert both ways: a human asking for "ϟ2" or "$2 per task" means 200, not 2. ϟ is the currency symbol, not a cent.' }, agreementDescription: 'string', expiresAt: 'string', lifecycle: lifecycleParam, maxExecutions: 'integer', description: 'string' }, handlerFor('agreement_counter'), { description: 'Counter a pending proposal with revised terms instead of approving or rejecting. Check status first with agreement_get.' });
+}, handlerFor('task_set_result'), { description: 'Transition a task to its terminal state — completed, failed, or cancelled — and record the result. Set the result here as an object ({ summary, status, links }): a task the parties opted into is closed by this call, whatever else you also sent them. Pass state (not status).' });
+export const agreementCounterTool = defineTool('agreement_counter', { agreementId: { type: 'string', required: true }, price: { type: 'number', description: 'Price in POINTS, as an integer of hundredths — 500 means ϟ5.00. Convert both ways: a human asking for "ϟ2 per task" means 200, not 2. ϟ is the points symbol, not a hundredth.' }, agreementDescription: 'string', expiresAt: 'string', lifecycle: lifecycleParam, maxExecutions: 'integer', description: 'string' }, handlerFor('agreement_counter'), { description: 'Counter a pending proposal with revised terms instead of approving or rejecting. Check status first with agreement_get.' });
 export const agreementGetTool = defineTool('agreement_get', { agreementId: { type: 'string', required: true } }, handlerFor('agreement_get'), { description: 'Read the current proposal status for an agreement (pending, approved, rejected, countered, expired).' });
 export const agreementRevokeTool = defineTool('agreement_revoke', { agreementId: { type: 'string', required: true } }, handlerFor('agreement_revoke'), { description: 'Revoke a pending proposal you created so it can no longer be approved. Use when the user has clearly moved on to a different request before responding to the previous proposal card.' });
 export const agreementFulfillTool = defineTool('agreement_fulfill', { agreementId: { type: 'string', required: true } }, handlerFor('agreement_fulfill'), { description: 'END an agreement you provide — permanently. Fulfilling terminates the whole relationship, not one deliverable: every grant it conferred is revoked, its shared space is torn down, and it cannot be reopened. Finished WORK is reported via task_set_result (the task closes; the agreement stays standing for the next task). Only fulfill when the engagement\'s full scope is delivered and nothing more is expected — never a standing hire that just finished a task.' });

package/dist/server/tools/tier2/linkTools.d.ts

@@ -1,4 +1,4 @@
 import type { ToolDefinition } from '../../../tools/defineTool.js';
-export declare const linkCreateInviteTool: ToolDefinition;
+export declare const linkProposeTool: ToolDefinition;
 export declare const linkListTool: ToolDefinition;
 export declare const LINK_TOOLS: ToolDefinition[];

package/dist/server/tools/tier2/linkTools.js

@@ -1,13 +1,15 @@
-import { LINK_CAPABILITIES, createLinkInviteCapability, listLinksCapability, } from '@ziggs-ai/api-client';
+import { LINK_CAPABILITIES, listLinksCapability, proposeLinkCapability, } from '@ziggs-ai/api-client';
 import { toolFromCapability, toolsFromCapabilities } from '../../../tools/capabilityAdapter.js';
-// links are agreements with engagementKind 'link':
-// bilateral agent-to-agent trust that gives any unpublished agent cross-org
-// reach. Defined once in api-client's shared capability layer (including the
-// linkSummary shaping); this file only adapts them onto the SDK.
+// links are agreements with engagementKind 'link': bilateral trust between two
+// PEOPLE that gives either side reach to the other. Defined once in api-client's
+// shared capability layer (including the linkSummary shaping); this file only
+// adapts them onto the SDK.
 //
-///1022 shrank the rail to two tools. The agreement verbs carry the
-// rest: request a direct link with agreement_propose (engagementKind 'link'),
-// claim an invite with agreement_claim, end a link with agreement_revoke.
-export const linkCreateInviteTool = toolFromCapability(createLinkInviteCapability);
+// Two tools. There were three: `link_create_invite` was `link_propose` with a
+// different way of naming the other side, so a caller had to choose between them
+// before knowing which applied. One verb takes an email, an agent id, or
+// nothing. The agreement verbs carry the rest: claim an invite with
+// agreement_claim, end a link with agreement_revoke.
+export const linkProposeTool = toolFromCapability(proposeLinkCapability);
 export const linkListTool = toolFromCapability(listLinksCapability);
 export const LINK_TOOLS = toolsFromCapabilities(LINK_CAPABILITIES);

package/dist/server/tools/tier2/marketplaceTools.js

@@ -1,9 +1,9 @@
 import { MARKETPLACE_CAPABILITIES, marketplaceViewCapability } from '@ziggs-ai/api-client';
 import { toolFromCapability, toolsFromCapabilities } from '../../../tools/capabilityAdapter.js';
-// the marketplace read (quests AND standing offers),
+// the marketplace read (requests AND standing offers),
 // defined once in api-client's shared capability layer. Publishing is NOT
 // here: it is the tier-1 verb agreement_propose with proposedTo
-// "everyone" | "org" (providerId = own id for an offer, omitted for a quest);
+// "everyone" | "org" (providerId = own id for an offer, omitted for a request);
 // claiming is agreement_claim.
 export const marketplaceViewTool = toolFromCapability(marketplaceViewCapability);
 export const MARKETPLACE_TOOLS = toolsFromCapabilities(MARKETPLACE_CAPABILITIES);

package/dist/server/tools/tier2/mcpConnectionTools.d.ts

@@ -1,4 +1,37 @@
 import { type ToolDefinition } from '../../../tools/defineTool.js';
 export declare const mcpToolsListTool: ToolDefinition;
+/**
+ * How much of one MCP tool result a wake will carry.
+ *
+ * A remote MCP server hands back the upstream API's payload verbatim, and those
+ * are sized for programs, not for a context window: GitHub's `list_pull_requests`
+ * with no paging argument answered ~150,000 characters. Past the runtime's limit
+ * the result stops being a result — the Claude SDK spills an oversized tool
+ * result to a file, and a hosted agent has no filesystem tool to read it with, so
+ * the wake ends in "the answer was too big and I cannot see it". Same class of
+ * problem as an MCP server that ships a 30K-character tool description, one layer
+ * later.
+ *
+ * A bounded answer with a marker beats an unreadable one: the model can act on
+ * "truncated, narrow the call", and it cannot act on a file path.
+ */
+export declare const MAX_MCP_RESULT_CHARS = 24000;
+/**
+ * Tool schemas are bigger than tool results and are read once per wake, so they
+ * get their own, larger ceiling — a schema cut in half is worse than useless,
+ * because the half that survives looks complete.
+ */
+export declare const MAX_MCP_TOOLS_LIST_CHARS = 60000;
+/**
+ * Bound one MCP result, telling the model plainly what was cut.
+ *
+ * Text blocks are cut individually rather than the JSON being sliced, because a
+ * sliced JSON string is invalid and a model handed invalid JSON reports the
+ * server as broken.
+ */
+export declare function boundMcpResult(result: unknown, max?: number): {
+    result: unknown;
+    truncated?: Record<string, unknown>;
+};
 export declare const mcpToolCallTool: ToolDefinition;
 export declare const MCP_CONNECTION_TOOLS: ToolDefinition[];