@ziggs-ai/agent-sdk 0.12.0 → 0.13.0

package/dist/AgentHost.js

@@ -201,11 +201,13 @@ export class AgentHost {
             description: resolved.description || 'A helpful assistant',
             systemPrompt: resolved.systemPrompt,
             specialization: resolved.specialization ?? null,
+            requestMatchTags: resolved.requestMatchTags,
             tools: resolved.tools || [],
             // Copied deliberately: this object is an allow-list, so a field left out
             // here is silently dropped between the manifest and the runtime. That is
             // exactly how `respondsToProposals` reached the store as null for 133
-            // agents — the declaration existed and nothing carried it.
+            // agents — the declaration existed and nothing carried it. Same for
+            // `requestMatchTags` (always undefined at triage) and `telemetryIngest`.
             needs: resolved.needs,
             taskTools: resolved.taskTools,
             states: resolved.states,
@@ -219,6 +221,7 @@ export class AgentHost {
             metricsTap: resolved.metricsTap,
             wakeTap: resolved.wakeTap,
             inboxCatchUp: resolved.inboxCatchUp,
+            telemetryIngest: resolved.telemetryIngest,
             brain: resolved.brain,
             cognition: resolved.cognition ?? 'fsm',
             claudeMaxTurns: resolved.claudeMaxTurns,

package/dist/agent/ClaudeSdkAgent.js

@@ -197,8 +197,8 @@ function resolveOnBehalfAgreementId(rawEvent, contextSnap, agentId, sessionId) {
         ? contextSnap.agreements
         : [];
     const provides = ags.filter((a) => {
-        const p = a?.parties ?? a;
-        const providerIds = [p?.provider, p?.providerAgent, a?.providerId, a?.providerAgentId, a?.executorId];
+        const provider = a?.parties?.provider;
+        const providerIds = [provider?.actor, a?.providerId, a?.providerAgentId, a?.executorId];
         const isProvider = providerIds.some((x) => x === agentId);
         const status = a?.status != null ? String(a.status).toLowerCase() : '';
         const active = !status || status === 'active' || status === 'approved';

package/dist/cognition/validateContext.js

@@ -41,8 +41,11 @@ function validateAgreements(agreements, warn) {
         }
         if (ag['parties'] && typeof ag['parties'] === 'object') {
             const parties = ag['parties'];
+            // Each side is occupied when either column names somebody; a side with a
+            // principal and no actor is a party acting through its own credential.
             for (const key of ['creator', 'provider']) {
-                if (!parties[key])
+                const side = parties[key];
+                if (!side?.principal && !side?.actor)
                     warn(`${path}.parties.${key}`, 'missing');
             }
         }

package/dist/context/batch.d.ts

@@ -1,2 +1,5 @@
+import { type AgreementParties } from '@ziggs-ai/api-client';
 export declare function getBatchEvents(rawEvent: unknown): unknown[];
 export declare function isTaskResultRelevantToAgent(result: Record<string, unknown>, ownAgentId: string | null): boolean;
+/** The agreement's party slots on a task_result payload, when it carries one. */
+export declare function partiesOf(result: Record<string, unknown>): AgreementParties | undefined;

package/dist/context/batch.js

@@ -1,4 +1,4 @@
-import { isBroadcastTarget } from '@ziggs-ai/api-client';
+import { isBroadcastTarget, partyActorIds } from '@ziggs-ai/api-client';
 export function getBatchEvents(rawEvent) {
     if (!rawEvent)
         return [];
@@ -10,9 +10,12 @@ export function getBatchEvents(rawEvent) {
 export function isTaskResultRelevantToAgent(result, ownAgentId) {
     if (!ownAgentId)
         return true;
-    const parties = result['agreement']?.['parties'] ?? {};
+    const parties = partiesOf(result);
     return !!(result['creatorIsYou'] || result['providerIsYou'] || result['payerIsYou'] || result['proposedToIsYou'] ||
-        parties['creator'] === ownAgentId || parties['provider'] === ownAgentId ||
-        parties['payer'] === ownAgentId || parties['proposedTo'] === ownAgentId ||
-        isBroadcastTarget(parties['proposedTo']));
+        partyActorIds(parties).includes(ownAgentId) ||
+        isBroadcastTarget(parties?.proposedTo?.principal));
+}
+/** The agreement's party slots on a task_result payload, when it carries one. */
+export function partiesOf(result) {
+    return result['agreement']?.parties;
 }

package/dist/context/classifyEnvelope.js

@@ -1,8 +1,7 @@
 import { CONTEXT_RESET } from './applyEffects.js';
-import { getBatchEvents, isTaskResultRelevantToAgent } from './batch.js';
+import { getBatchEvents, isTaskResultRelevantToAgent, partiesOf } from './batch.js';
 function isTaskAssignment(result, ownAgentId) {
-    const parties = result['agreement']?.['parties'] ?? {};
-    const isProvider = result['providerIsYou'] || parties['provider'] === ownAgentId;
+    const isProvider = result['providerIsYou'] || partiesOf(result)?.provider?.actor === ownAgentId;
     return !!(isProvider && (result['state'] === 'active' || result['state'] === 'in-progress'));
 }
 export function classifyIncomingEvent(rawEvent, ownAgentId) {
@@ -22,9 +21,9 @@ export function classifyIncomingEvent(rawEvent, ownAgentId) {
             continue;
         const state = result['state'];
         const ag = result['agreement'];
-        const parties = ag?.['parties'] || {};
+        const parties = partiesOf(result);
         const proposalStatus = ag?.['proposal']?.['status'];
-        if (state === 'active' && proposalStatus === 'approved' && ownAgentId && parties['creator'] === ownAgentId) {
+        if (state === 'active' && proposalStatus === 'approved' && ownAgentId && parties?.creator?.actor === ownAgentId) {
             flags['approval'] = true;
             flags['taskAssignment'] = result;
             continue;

package/dist/context/routingLabels.js

@@ -1,5 +1,5 @@
 import { isProtocolToolName } from '../tasks/protocolRegistry.js';
-import { getBatchEvents, isTaskResultRelevantToAgent } from './batch.js';
+import { getBatchEvents, isTaskResultRelevantToAgent, partiesOf } from './batch.js';
 export function unwrapBatchEvent(event) {
     const e = event;
     if (e?.['type'] === 'batch' && Array.isArray(e['events']) && e['events'][0])
@@ -22,9 +22,8 @@ export function classifyWorkflowEvent(event, ownAgentId = null) {
         sawOwnTaskResult = true;
         const state = result['state'];
         const ag = result['agreement'];
-        const parties = ag?.['parties'] || {};
         const proposalStatus = ag?.['proposal'] ? ag['proposal']['status'] : undefined;
-        const isProvider = result['providerIsYou'] || parties['provider'] === ownAgentId;
+        const isProvider = result['providerIsYou'] || partiesOf(result)?.provider?.actor === ownAgentId;
         if (isProvider && (state === 'active' || state === 'in-progress'))
             return 'task_assignment';
         if (proposalStatus === 'approved' || (state === 'active' && proposalStatus === 'pending'))

package/dist/formatters/AgreementFormatter.d.ts

@@ -1,3 +1,4 @@
+import { type AgreementPartySide } from '@ziggs-ai/api-client';
 interface AgreementFormatterOptions {
     shortIds?: boolean;
     indentSize?: number;
@@ -10,7 +11,12 @@ export declare class AgreementFormatter {
     format(agreements: AnyObj[] | null | undefined): string;
     formatAgreement(ag: AnyObj, indent?: string): string;
     _renderTaskExecution(task: AnyObj, indent?: string): string;
-    _labelParty(id: string | null | undefined, isYou: boolean | undefined): string;
+    /**
+     * A side names up to two ids — the accountable principal and the agent that
+     * acted for it. Both are rendered: the agent has to recognize itself here,
+     * and the principal is who the deal is actually with.
+     */
+    _labelParty(side: AgreementPartySide | null | undefined, isYou: boolean | undefined): string;
     shortId(id: string | null | undefined): string;
     private _indent;
 }

package/dist/formatters/AgreementFormatter.js

@@ -1,3 +1,4 @@
+import { partySideIds } from '@ziggs-ai/api-client';
 export class AgreementFormatter {
     shortIds;
     indentSize;
@@ -37,14 +38,16 @@ export class AgreementFormatter {
         const status = (ag['status'] || 'unknown').toUpperCase();
         const agId = this.shortId(ag['agreementId']);
         const parties = ag['parties'] || {};
+        const side = (name) => parties[name];
         const lines = [
             `${indent}[${status}] Agreement ${agId}`,
-            `${indent}  Creator: ${this._labelParty(parties['creator'], ag['creatorIsYou'])}`,
-            `${indent}  Provider: ${this._labelParty(parties['provider'], ag['providerIsYou'])}`,
-            `${indent}  Payer: ${this._labelParty(parties['payer'], ag['payerIsYou'])}`,
+            `${indent}  Creator: ${this._labelParty(side('creator'), ag['creatorIsYou'])}`,
+            `${indent}  Provider: ${this._labelParty(side('provider'), ag['providerIsYou'])}`,
+            `${indent}  Payer: ${this._labelParty(side('payer'), ag['payerIsYou'])}`,
         ];
-        if (parties['proposedTo'])
-            lines.push(`${indent}  Proposed to: ${this._labelParty(parties['proposedTo'], ag['proposedToIsYou'])}`);
+        if (partySideIds(side('proposedTo')).length > 0) {
+            lines.push(`${indent}  Proposed to: ${this._labelParty(side('proposedTo'), ag['proposedToIsYou'])}`);
+        }
         const proposal = ag['proposal'];
         if (proposal?.['status'])
             lines.push(`${indent}  Proposal: ${proposal['status']}${proposal['respondedBy'] ? ` (by ${proposal['respondedBy']})` : ''}`);
@@ -111,10 +114,16 @@ export class AgreementFormatter {
         }
         return lines.join('\n');
     }
-    _labelParty(id, isYou) {
-        if (!id)
+    /**
+     * A side names up to two ids — the accountable principal and the agent that
+     * acted for it. Both are rendered: the agent has to recognize itself here,
+     * and the principal is who the deal is actually with.
+     */
+    _labelParty(side, isYou) {
+        const shown = partySideIds(side).join(' via ');
+        if (!shown)
             return 'N/A';
-        return isYou ? `You (${id})` : id;
+        return isYou ? `You (${shown})` : shown;
     }
     shortId(id) {
         if (!id)

package/dist/formatters/HistoryFormatter.d.ts

@@ -17,6 +17,11 @@ export declare class HistoryFormatter {
     formatParticipant(participant: AnyObj | null | undefined, agentId: string): string;
     formatOwner(task: AnyObj, agentId: string): string;
     formatExecutor(task: AnyObj, agentId: string): string;
+    /**
+     * One side of the task's agreement, or `fallback` when the frame carries no
+     * parties — a bare resource_changed skeleton has the task ids and nothing else.
+     */
+    private _formatSide;
     shortId(id: string | null | undefined): string;
     formatTime(timestamp: string | null | undefined): string;
     formatArgs(args: AnyObj | null | undefined): string;

package/dist/formatters/HistoryFormatter.js

@@ -1,3 +1,4 @@
+import { partySideIds } from '@ziggs-ai/api-client';
 export class HistoryFormatter {
     showTimestamps;
     shortIds;
@@ -67,7 +68,8 @@ export class HistoryFormatter {
             case 'created': {
                 const ag = task['agreement'];
                 const parties = ag?.['parties'] || {};
-                return `${timePrefix}Task created under agreement: "${desc}" (${ids})\n    Owner: ${this.formatOwner(task, agentId)}\n    Executor: ${this.formatExecutor(task, agentId)}\n    Proposed to: ${parties['proposedTo'] || 'N/A'}`;
+                const proposedTo = partySideIds(parties['proposedTo']).join(' via ');
+                return `${timePrefix}Task created under agreement: "${desc}" (${ids})\n    Owner: ${this.formatOwner(task, agentId)}\n    Executor: ${this.formatExecutor(task, agentId)}\n    Proposed to: ${proposedTo || 'N/A'}`;
             }
             case 'state_changed': {
                 const prev = service?.['previousState']?.['state'] || '?';
@@ -140,14 +142,21 @@ export class HistoryFormatter {
         return `${id} (${participant['type'] || 'unknown'})`;
     }
     formatOwner(task, agentId) {
-        const ag = task['agreement'];
-        const creatorId = ag?.['parties']?.['creator'] ?? task['agentId'];
-        return creatorId === agentId ? 'You' : String(creatorId ?? 'N/A');
+        return this._formatSide(task, 'creator', task['agentId'], agentId);
     }
     formatExecutor(task, agentId) {
-        const ag = task['agreement'];
-        const providerId = ag?.['parties']?.['provider'] ?? task['executorId'];
-        return providerId === agentId ? 'You' : String(providerId ?? 'N/A');
+        return this._formatSide(task, 'provider', task['executorId'], agentId);
+    }
+    /**
+     * One side of the task's agreement, or `fallback` when the frame carries no
+     * parties — a bare resource_changed skeleton has the task ids and nothing else.
+     */
+    _formatSide(task, role, fallback, agentId) {
+        const parties = task['agreement']?.['parties'];
+        const ids = partySideIds(parties?.[role]);
+        if (ids.length === 0)
+            return fallback === agentId ? 'You' : String(fallback ?? 'N/A');
+        return ids.includes(agentId) ? 'You' : ids.join(' via ');
     }
     shortId(id) {
         if (!id)

package/dist/index.d.ts

@@ -62,7 +62,7 @@ export { HistoryFormatter, historyFormatter, AgreementFormatter, agreementFormat
 export { ProactiveTrigger } from './server/proactive/ProactiveTrigger.js';
 export { PollRegistry, declaredPolls, type PollBinding, type PollContext, type PollKind, type PollResult, } from './server/polls/PollKind.js';
 export { PollRunner, type PollRunnerOptions, type WakeTarget } from './server/polls/PollRunner.js';
-export { PROTOCOL_TOOLS, agreementProposeTool, agreementSubcontractTool, agreementRespondTool, agreementClaimTool, agreementCounterTool, agreementGetTool, agreementRevokeTool, agreementFulfillTool, taskCreateTool, taskSetResultTool, taskUpdatePlanStepTool, dispatchProtocolOp, PAYMENT_TOOLS, paymentBalanceTool, CONNECTION_TOOLS, connectionProxyTool, connectionListGrantsTool, requestConnectionTool, MCP_CONNECTION_TOOLS, mcpToolCallTool, mcpToolsListTool, DISCOVERY_TOOLS, agentSearchTool, agentGetTool, MARKETPLACE_TOOLS, marketplaceViewTool, CONTEXT_TOOLS, contextReadTool, contextDelegateTool, contextExpandReachTool, contextDiscoverGrantableTool, GRANTS_TOOLS, listGrantsTool, LINK_TOOLS, linkCreateInviteTool, linkListTool, ARTIFACT_TOOLS, recordArtifactTool, CHAT_TOOLS, openConversationTool, } from './server/tools/index.js';
+export { PROTOCOL_TOOLS, agreementProposeTool, agreementSubcontractTool, agreementRespondTool, agreementClaimTool, agreementCounterTool, agreementGetTool, agreementRevokeTool, agreementFulfillTool, taskCreateTool, taskSetResultTool, taskUpdatePlanStepTool, dispatchProtocolOp, PAYMENT_TOOLS, paymentBalanceTool, CONNECTION_TOOLS, connectionProxyTool, connectionListGrantsTool, requestConnectionTool, MCP_CONNECTION_TOOLS, mcpToolCallTool, mcpToolsListTool, DISCOVERY_TOOLS, agentSearchTool, agentGetTool, MARKETPLACE_TOOLS, marketplaceViewTool, CONTEXT_TOOLS, contextReadTool, contextDelegateTool, contextExpandReachTool, contextDiscoverGrantableTool, GRANTS_TOOLS, listGrantsTool, LINK_TOOLS, linkProposeTool, linkListTool, ARTIFACT_TOOLS, recordArtifactTool, CHAT_TOOLS, openConversationTool, } from './server/tools/index.js';
 export { CLAUDE_SDK_TOOLS } from './agent/claudeSdkTools.js';
 export { PROTOCOL_TOOL_NAMES, PROTOCOL_TOOL_TO_OPERATION, mapProtocolToolToOperation, isProtocolToolName } from './tasks/protocolRegistry.js';
 export { InMemoryStore, FileMemoryStore } from './memory/MemoryStore.js';

package/dist/index.js

@@ -76,7 +76,7 @@ export {
 // Tier 1 — protocol grammar (framework-managed via taskTools).
 PROTOCOL_TOOLS, agreementProposeTool, agreementSubcontractTool, agreementRespondTool, agreementClaimTool, agreementCounterTool, agreementGetTool, agreementRevokeTool, agreementFulfillTool, taskCreateTool, taskSetResultTool, taskUpdatePlanStepTool, dispatchProtocolOp, 
 // Tier 2 — opt-in capability bundles (spread into `tools:`).
-PAYMENT_TOOLS, paymentBalanceTool, CONNECTION_TOOLS, connectionProxyTool, connectionListGrantsTool, requestConnectionTool, MCP_CONNECTION_TOOLS, mcpToolCallTool, mcpToolsListTool, DISCOVERY_TOOLS, agentSearchTool, agentGetTool, MARKETPLACE_TOOLS, marketplaceViewTool, CONTEXT_TOOLS, contextReadTool, contextDelegateTool, contextExpandReachTool, contextDiscoverGrantableTool, GRANTS_TOOLS, listGrantsTool, LINK_TOOLS, linkCreateInviteTool, linkListTool, ARTIFACT_TOOLS, recordArtifactTool, CHAT_TOOLS, openConversationTool, } from './server/tools/index.js';
+PAYMENT_TOOLS, paymentBalanceTool, CONNECTION_TOOLS, connectionProxyTool, connectionListGrantsTool, requestConnectionTool, MCP_CONNECTION_TOOLS, mcpToolCallTool, mcpToolsListTool, DISCOVERY_TOOLS, agentSearchTool, agentGetTool, MARKETPLACE_TOOLS, marketplaceViewTool, CONTEXT_TOOLS, contextReadTool, contextDelegateTool, contextExpandReachTool, contextDiscoverGrantableTool, GRANTS_TOOLS, listGrantsTool, LINK_TOOLS, linkProposeTool, linkListTool, ARTIFACT_TOOLS, recordArtifactTool, CHAT_TOOLS, openConversationTool, } from './server/tools/index.js';
 // The always-on toolset for the hosted Claude cognition (parity guard
 // reads this as part of the real SDK registry).
 export { CLAUDE_SDK_TOOLS } from './agent/claudeSdkTools.js';

package/dist/ingress/normalizeIncoming.d.ts

@@ -1,3 +1,4 @@
+import type { AgreementParties } from '@ziggs-ai/api-client';
 export interface NormalizedEvent {
     chatId: string | null;
     event: {
@@ -25,12 +26,6 @@ export interface NormalizedEvent {
         text?: string;
     };
 }
-interface WireParties {
-    creator?: string;
-    provider?: string;
-    payer?: string;
-    proposedTo?: string;
-}
 interface WireTask {
     taskId?: string;
     agentId?: string;
@@ -42,7 +37,7 @@ interface WireTask {
     state?: string;
     proposal?: unknown;
     agreement?: {
-        parties?: WireParties;
+        parties?: AgreementParties;
     };
 }
 interface WireMetadata {
@@ -69,7 +64,7 @@ interface WireMetadata {
             proposal?: {
                 status?: string;
             };
-            parties?: WireParties;
+            parties?: AgreementParties;
             approvals?: Array<{
                 partyId?: string;
                 status?: string;

package/dist/runtime/PromptBuilder.js

@@ -1,6 +1,6 @@
 import { HistoryFormatter, AgreementFormatter } from '../formatters/index.js';
 import { validateContext } from '../cognition/validateContext.js';
-import { isBroadcastTarget, isOpaquePresentationRef } from '@ziggs-ai/api-client';
+import { isBroadcastTarget, isOpaquePresentationRef, partySideIds } from '@ziggs-ai/api-client';
 import { LANE_BOOK_KEY, allCollectedResults, allDelegatedAgreementIds, allPendingSubtasks, } from './taskBookkeeping.js';
 /** Rough chars-per-token ratio for budgeting (English/JSON averages ~4). */
 const CHARS_PER_TOKEN = 4;
@@ -191,12 +191,13 @@ ${this._renderDecisionSchemaFromActions(actions, senderMeta, ctxObj, omitMessage
         const creatorIsYou = task.creatorIsYou;
         const providerIsYou = task.providerIsYou;
         if (ag?.agreementId) {
+            const named = (name) => partySideIds(parties[name]).join(' via ');
             lines.push(`Agreement: ${ag.agreementId}${creatorIsYou ? ' (yours)' : ''}`);
-            lines.push(`  Creator: ${parties.creator ?? 'N/A'}${creatorIsYou ? ' (You)' : ''}`);
-            lines.push(`  Provider: ${parties.provider ?? 'N/A'}${providerIsYou ? ' (You)' : ''}`);
+            lines.push(`  Creator: ${named('creator') || 'N/A'}${creatorIsYou ? ' (You)' : ''}`);
+            lines.push(`  Provider: ${named('provider') || 'N/A'}${providerIsYou ? ' (You)' : ''}`);
             const proposal = ag.proposal;
             if (proposal?.status) {
-                lines.push(`  Proposal: ${proposal.status} (to ${parties.proposedTo}${task.proposedToIsYou ? ' - You' : ''})`);
+                lines.push(`  Proposal: ${proposal.status} (to ${named('proposedTo')}${task.proposedToIsYou ? ' - You' : ''})`);
             }
             const money = ag.money;
             if (typeof money?.price === 'number' && money.price > 0) {
@@ -300,22 +301,19 @@ ${this._renderDecisionSchemaFromActions(actions, senderMeta, ctxObj, omitMessage
         for (const ag of agreements || []) {
             const agId = ag?.agreementId;
             const parties = ag?.parties || {};
-            const roles = [
-                ['creator', 'creator'],
-                ['provider', 'provider'],
-                ['payer', 'payer'],
-                ['proposedTo', 'proposedTo'],
-            ];
-            for (const [field, role] of roles) {
-                const pid = parties[field];
-                if (!pid || pid === myAgentId)
-                    continue;
-                // Opaque presentation refs are not principal slots.
-                if (isOpaquePresentationRef(pid))
-                    continue;
-                if (!agreementParties.has(pid))
-                    agreementParties.set(pid, []);
-                agreementParties.get(pid).push({ agreementId: agId ?? '', role });
+            for (const role of ['creator', 'provider', 'payer', 'proposedTo']) {
+                // Both columns of a side are addressable and carry the same role: the
+                // principal is who the deal is with, the actor is who acts on it.
+                for (const pid of partySideIds(parties[role])) {
+                    if (pid === myAgentId)
+                        continue;
+                    // Opaque presentation refs are not principal slots.
+                    if (isOpaquePresentationRef(pid))
+                        continue;
+                    if (!agreementParties.has(pid))
+                        agreementParties.set(pid, []);
+                    agreementParties.get(pid).push({ agreementId: agId ?? '', role });
+                }
             }
         }
         // Chat keeps the full directory — including opaque `rpb_*` / `psn_*` refs
@@ -380,7 +378,7 @@ ${this._renderDecisionSchemaFromActions(actions, senderMeta, ctxObj, omitMessage
         lines.push('Set "action" to exactly one of the action names below.');
         lines.push('Message text is rendered as markdown (CommonMark + GFM). You MAY use **bold**, *italic*, `code`, fenced code blocks, lists, links, and tables when they improve clarity — plain text is also fine.\n');
         const replyTo = senderMeta.defaultReplyReceiverId || '<receiverId>';
-        const pendingProposals = (ctxObj.agreements || []).filter((a) => a.proposal?.status === 'pending' && (a.proposedToIsYou || isBroadcastTarget(a.parties?.proposedTo)));
+        const pendingProposals = (ctxObj.agreements || []).filter((a) => a.proposal?.status === 'pending' && (a.proposedToIsYou || isBroadcastTarget(a.parties?.proposedTo?.principal)));
         if (pendingProposals.length > 0) {
             lines.push(`PRIORITY: You have ${pendingProposals.length} pending proposal(s) directed at you. Respond BEFORE other actions.`);
             lines.push(`{"thought": "...", "action": "<action_bound_to_agreement_respond>", "args": {"agreementId": "<id>", "action": "approve|reject"}}\n`);

package/dist/runtime/buildOutcome.js

@@ -92,7 +92,7 @@ function singleEventToOutcome(ev, ownAgentId) {
         const parties = ag?.parties || {};
         const state = result.state;
         // Direct assignment to me (provider) — task spawned, citing an active agreement.
-        const isAssignedToMe = (result.providerIsYou || parties.provider === ownAgentId) &&
+        const isAssignedToMe = (result.providerIsYou || parties.provider?.actor === ownAgentId) &&
             (state === 'active' || state === 'in-progress');
         if (isAssignedToMe) {
             return { kind: 'task-assigned', task };
@@ -421,7 +421,7 @@ export function applyOutcomeToCtx(ctx, outcome) {
             const book = bookForDelegation(ctx);
             if (tid && !(tid in book.pendingSubtasks)) {
                 book.pendingSubtasks[tid] = {
-                    agentId: t.assigneeId ?? t.executorId ?? t.agreement?.parties?.provider ?? null,
+                    agentId: t.assigneeId ?? t.executorId ?? t.agreement?.parties?.provider?.actor ?? null,
                     spawnedAt: Date.now(),
                 };
             }
@@ -465,7 +465,7 @@ export function applyOutcomeToCtx(ctx, outcome) {
                 if (!existing) {
                     book.collectedResults.push({
                         taskId,
-                        agentId: pending?.agentId ?? t?.assigneeId ?? t?.executorId ?? t?.agreement?.parties?.provider ?? null,
+                        agentId: pending?.agentId ?? t?.assigneeId ?? t?.executorId ?? t?.agreement?.parties?.provider?.actor ?? null,
                         status: outcome.status,
                         result: payload,
                     });
@@ -479,7 +479,7 @@ export function applyOutcomeToCtx(ctx, outcome) {
                     existing.status = outcome.status;
                     existing.result = payload;
                     if (existing.agentId == null) {
-                        existing.agentId = t?.assigneeId ?? t?.executorId ?? t?.agreement?.parties?.provider ?? null;
+                        existing.agentId = t?.assigneeId ?? t?.executorId ?? t?.agreement?.parties?.provider?.actor ?? null;
                     }
                 }
                 if (agId) {

package/dist/runtime/mandateDeclaration.d.ts

@@ -0,0 +1,9 @@
+import type { ToolManager } from '../tools/ToolManager.js';
+/**
+ * Add the wake's own mandate to a tool call that declares one and left it blank.
+ *
+ * Returns the args unchanged whenever there is nothing to say: the tool takes no
+ * declaration, the model already made one, or this wake is not running inside a
+ * job at all.
+ */
+export declare function withDeclaredMandate(args: Record<string, unknown>, toolName: string | null | undefined, toolManager: ToolManager | undefined, activeAgreementId: string | null | undefined): Record<string, unknown>;

package/dist/runtime/mandateDeclaration.js

@@ -0,0 +1,62 @@
+/**
+ * Fill in the job an agent is working inside, so it does not have to.
+ *
+ * The consent gate excuses an agreement an agent forms INSIDE a job its human
+ * already approved, and it verifies the claim server-side. What was missing was
+ * the claim itself: nothing on the agent surface said "I am doing this as part
+ * of job X", so every engagement an agent formed arrived as an outsider and
+ * waited on a human — including buying the help the job it was hired for needs.
+ *
+ * The declaration is made at the CALLER, never resolved on the server: the
+ * agreements module must not read the tasks module, and a guessed mandate is a
+ * false claim the termination cascade would act on destructively. Here the fact
+ * is free — the runtime already knows which task this wake is executing and
+ * which agreement that task runs under, which is exactly the answer.
+ *
+ * The model can still name a job itself (and does, when it is working on
+ * something other than its assigned task). An explicit value is never
+ * overwritten, including an explicit empty string, which reads as "this belongs
+ * to no job" — the difference between saying nothing and saying none.
+ */
+/**
+ * The parameter a tool uses to carry the declaration.
+ *
+ * Two names, because the doors differ and each name is true at its own door: on
+ * a tool that CREATES an agreement the job becomes that row's parent, so the
+ * field is the parent id; on a tool that claims a row somebody else posted
+ * nothing is re-parented — the lineage stays with the publisher — and the job is
+ * only an authority. Listed together here so the runtime has one place that
+ * knows both, rather than a name test at each call site.
+ */
+const MANDATE_PARAM_NAMES = ['mandateAgreementId', 'parentAgreementId'];
+/** The mandate parameter this tool declares, if it declares one. */
+function mandateParamOf(toolName, toolManager) {
+    if (!toolName)
+        return null;
+    const schema = toolManager?.getTool?.(toolName)?.schema;
+    const properties = schema?.function?.parameters?.properties;
+    if (!properties)
+        return null;
+    for (const name of MANDATE_PARAM_NAMES) {
+        if (Object.prototype.hasOwnProperty.call(properties, name))
+            return name;
+    }
+    return null;
+}
+/**
+ * Add the wake's own mandate to a tool call that declares one and left it blank.
+ *
+ * Returns the args unchanged whenever there is nothing to say: the tool takes no
+ * declaration, the model already made one, or this wake is not running inside a
+ * job at all.
+ */
+export function withDeclaredMandate(args, toolName, toolManager, activeAgreementId) {
+    if (!activeAgreementId)
+        return args;
+    const param = mandateParamOf(toolName, toolManager);
+    if (!param)
+        return args;
+    if (args[param] !== undefined)
+        return args;
+    return { ...args, [param]: activeAgreementId };
+}

package/dist/runtime/runTurn.js

@@ -1,6 +1,7 @@
 import { outcomeFromActionResult } from './buildOutcome.js';
 import { runtimeLog } from '../shared/runtimeLog.js';
 import { safeParseJSON } from '../utils/jsonExtractor.js';
+import { withDeclaredMandate } from './mandateDeclaration.js';
 const MAX_TOOL_LOOP_ITERS = 20;
 const MAX_MSG_CHARS = 3500;
 /**
@@ -260,6 +261,9 @@ export async function runTurn(input) {
                     args = JSON.parse(tc.function.arguments || '{}');
                 }
                 catch { }
+                // Say which job this is part of, when the tool asks and the model did
+                // not. The runtime knows; the model would have to be told.
+                args = withDeclaredMandate(args, toolName, toolManager, ctx.activeAgreementId);
                 const decision = { action: matchingAction, tool: toolName, args };
                 const result = await executeDecision(decision, actionDef, effWithTrace, sessionId, memory, null, addToolUsage);
                 toolCallResults.push({ tc, matchingAction, result, args, actionDef });
@@ -311,6 +315,10 @@ export async function runTurn(input) {
             const decision = parsed.decision;
             const chosenAction = decision.action;
             const actionDef = actions[chosenAction];
+            // Same mandate declaration as the tool-call path above. Both routes reach
+            // the same tools, so filling it on only one would make the excuse depend on
+            // which shape the model happened to answer in.
+            decision.args = withDeclaredMandate((decision.args ?? {}), actionDef?.tool, toolManager, ctx.activeAgreementId);
             if (decision.thought)
                 await emitThought(decision.thought);
             // 2-call streaming: if this is a respond action (has receiverId, no bound tool),

package/dist/server/agreements/AgreementService.d.ts

@@ -1,4 +1,4 @@
-import { type Agreement, type ClaimedKind, type ProposeAgreementData, type ProposeDirectInput, type ProposeBroadcastInput, type PublishOfferPayload, type DelegateAgreementData, type CounterAgreementData, type CreateLinkBody, type ListAgreementsFilters, type GetMyAgreementsFilters, type ChatLinkType, type ArtifactLinkType, type UserRole } from '@ziggs-ai/api-client';
+import { type Agreement, type ClaimedKind, type ClaimOptions, type ProposeAgreementData, type ProposeDirectInput, type ProposeBroadcastInput, type PublishOfferPayload, type DelegateAgreementData, type CounterAgreementData, type CreateLinkBody, type CreateLinkResult, type ListAgreementsFilters, type GetMyAgreementsFilters, type ChatLinkType, type ArtifactLinkType, type UserRole } from '@ziggs-ai/api-client';
 export declare class AgreementService {
     private creds;
     constructor(operatorKey: string, agentId: string);
@@ -25,15 +25,22 @@ export declare class AgreementService {
      * the shared flow; `kind` is the api-client ClaimedKind so this signature
      * can't drift from the flow again (a 'hand-off' addition broke the build).
      */
-    claim(agreementId: string): Promise<{
+    claim(agreementId: string, opts?: ClaimOptions): Promise<{
         agreement: Agreement;
         kind: ClaimedKind;
     }>;
     /**
-     * a link proposal is an agreement (engagementKind 'link') to one
-     * agent; the target owner approves. Folds the old request_link tool.
+     * Connect with the person an agent answers for.
+     *
+     * `to` is an email or an agent id. A link is with the PERSON either way: an id
+     * is only a way to find its owner, and one that answers to an org is refused.
+     *
+     * The reply says only that the invitation went. Handing back the agreement for
+     * an id target while an address target got a bare acknowledgement told the
+     * caller more about one kind of target than the other, which made the id form
+     * a way to check who has an account.
      */
-    requestLink(providerId: string, description?: string): Promise<Agreement>;
+    requestLink(to: string, description?: string): Promise<CreateLinkResult>;
     counter(agreementId: string, counter: CounterAgreementData): Promise<Agreement>;
     getStatus(agreementId: string): Promise<unknown | null>;
     list(filters?: ListAgreementsFilters): Promise<Agreement[]>;
@@ -46,14 +53,11 @@ export declare class AgreementService {
     mine(filters?: GetMyAgreementsFilters): Promise<Agreement[]>;
     get(agreementId: string): Promise<Agreement | null>;
     /**
-     * Create a trust link — direct to one agent, or an open invite. Work
+     * Connect with someone — by email, by agent id, or with a share link. Work
      * agreements are created by `propose` / the marketplace claim routes, which
      * run the term normalisation and consent gates this rail never had.
      */
-    createLink(body: CreateLinkBody): Promise<{
-        ok: boolean;
-        agreement: Agreement;
-    }>;
+    createLink(body: CreateLinkBody): Promise<CreateLinkResult>;
     revoke(agreementId: string): Promise<{
         ok: boolean;
         agreement: Agreement;

package/dist/server/agreements/AgreementService.js

@@ -43,16 +43,22 @@ export class AgreementService {
      * the shared flow; `kind` is the api-client ClaimedKind so this signature
      * can't drift from the flow again (a 'hand-off' addition broke the build).
      */
-    claim(agreementId) {
-        return claimOpenAgreement(agreementId, this.creds);
+    claim(agreementId, opts = {}) {
+        return claimOpenAgreement(agreementId, this.creds, opts);
     }
     /**
-     * a link proposal is an agreement (engagementKind 'link') to one
-     * agent; the target owner approves. Folds the old request_link tool.
+     * Connect with the person an agent answers for.
+     *
+     * `to` is an email or an agent id. A link is with the PERSON either way: an id
+     * is only a way to find its owner, and one that answers to an org is refused.
+     *
+     * The reply says only that the invitation went. Handing back the agreement for
+     * an id target while an address target got a bare acknowledgement told the
+     * caller more about one kind of target than the other, which made the id form
+     * a way to check who has an account.
      */
-    async requestLink(providerId, description) {
-        const { agreement } = await createLink({ targetAgentId: providerId, ...(description ? { description } : {}) }, this.creds);
-        return agreement;
+    async requestLink(to, description) {
+        return createLink({ to, ...(description ? { description } : {}) }, this.creds);
     }
     counter(agreementId, counter) {
         return counterAgreement(agreementId, counter || {}, this.creds);
@@ -76,7 +82,7 @@ export class AgreementService {
         return getAgreement(agreementId, this.creds);
     }
     /**
-     * Create a trust link — direct to one agent, or an open invite. Work
+     * Connect with someone — by email, by agent id, or with a share link. Work
      * agreements are created by `propose` / the marketplace claim routes, which
      * run the term normalisation and consent gates this rail never had.
      */

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/tools/index.d.ts

@@ -23,7 +23,7 @@ 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

@@ -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
@@ -66,7 +66,16 @@ cachedAgreements) {
             // 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);
     }
@@ -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: '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 (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 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)' } }, 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 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.

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/types.d.ts

@@ -4,15 +4,11 @@
  * One outcome vocabulary, one ctx shape, one transition signature.
  * Every state — parked or thinking — re-enters with exactly one Outcome.
  */
+import type { AgreementParties } from '@ziggs-ai/api-client';
 import type { AgentNeed } from './tools/needs.js';
 export interface AgreementRef {
     agreementId: string;
-    parties?: {
-        creator?: string;
-        provider?: string;
-        payer?: string;
-        proposedTo?: string;
-    };
+    parties?: AgreementParties;
     proposal?: {
         status?: 'pending' | 'approved' | 'rejected' | 'cancelled';
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ziggs-ai/agent-sdk",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Agent framework SDK for building autonomous agents on the Ziggs platform",
   "type": "module",
   "main": "dist/index.js",
@@ -26,7 +26,7 @@
     "@anthropic-ai/claude-agent-sdk": "^0.3.204",
     "@anthropic-ai/sdk": "^0.110.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@ziggs-ai/api-client": "0.11.0",
+    "@ziggs-ai/api-client": "0.12.0",
     "ajv": "^8.17.1",
     "dotenv": "^17.2.3",
     "openai": "^4.0.0",