@ziggs-ai/agent-sdk 0.6.0 → 0.7.1

package/dist/runtime/runTurn.js

@@ -377,10 +377,18 @@ export async function runTurn(input) {
                     lastActionDef = actionDef;
                 }
                 catch (err) {
-                    // Both the streaming path AND the non-streaming fallback failed —
-                    // the user got nothing. End the turn with a loud send-failed error.
-                    runtimeLog.error('runTurn', `respond send failed after stream fallback: ${err.message}`);
-                    turnError = { source: 'protocol', cause: 'send-failed' };
+                    if (isReplySlotTaken(err)) {
+                        runtimeLog.warn('runTurn', `reply already persisted under ${streamMessageId} (idempotency 409) — a replay or second host answered this wake first; dropping duplicate`);
+                        allEmittedEvents.push({ type: 'message_duplicate_skipped', receiverId: decision.receiverId, chatId: sessionId, senderId: 'system' });
+                        lastAction = chosenAction;
+                        lastActionDef = actionDef;
+                    }
+                    else {
+                        // Both the streaming path AND the non-streaming fallback failed —
+                        // the user got nothing. End the turn with a loud send-failed error.
+                        runtimeLog.error('runTurn', `respond send failed after stream fallback: ${err.message}`);
+                        turnError = { source: 'protocol', cause: 'send-failed' };
+                    }
                 }
                 break;
             }
@@ -560,7 +568,7 @@ function annotateToolCallDedup(toolCalls, toolManager, initialSawCreate = false)
             sawCreate = true;
             return { tc, skipExecute: false };
         }
-        if (name === 'task_update') {
+        if (name === 'task_set_result') {
             let taskId = null;
             try {
                 const a = JSON.parse(tc.function.arguments || '{}');
@@ -569,7 +577,7 @@ function annotateToolCallDedup(toolCalls, toolManager, initialSawCreate = false)
             catch { }
             const key = taskId || tc.id || '_';
             if (seenUpdateTaskIds.has(key))
-                return { tc, skipExecute: true, skipReason: 'duplicate task_update for same taskId' };
+                return { tc, skipExecute: true, skipReason: 'duplicate task_set_result for same taskId' };
             seenUpdateTaskIds.add(key);
             return { tc, skipExecute: false };
         }
@@ -652,6 +660,20 @@ function truncateMsg(msg) {
         return msg;
     return msg.slice(0, MAX_MSG_CHARS) + `\n\n[truncated to ${MAX_MSG_CHARS} of ${msg.length} chars]`;
 }
+/**
+ * A send rejected with 409 hit the backend's (chatId, messageId) idempotency
+ * gate on a wake-derived id: this wake's reply already exists. Two legal ways
+ * that happens — a crash-replay re-ran the wake, or a second host raced the
+ * same at-least-once delivery — and in both the re-run LLM produced different
+ * text, so the backend rejects instead of no-op'ing (ZIG-932 treats
+ * same-key-same-content as replay, same-key-different-content as conflict).
+ * The user already has the winner's reply. Re-sending under a fresh id would
+ * double-message; failing the turn marks an answered wake as an error. Treat
+ * it as delivered-by-the-other-attempt and move on.
+ */
+function isReplySlotTaken(err) {
+    return err?.status === 409;
+}
 async function executeSendMessage(decision, eff, sessionId) {
     // Callers (executeDecision) guarantee message + receiverId, and sessionId is
     // always ctx.identity.sessionId. A send failure throws to the turn loop,
@@ -662,7 +684,15 @@ async function executeSendMessage(decision, eff, sessionId) {
     // to the current session otherwise.
     const targetSessionId = decision.chatId || sessionId;
     const safeMessage = truncateMsg(decision.message);
-    await eff({ kind: 'send-message', sessionId: targetSessionId, receiverId: decision.receiverId, text: safeMessage });
+    try {
+        await eff({ kind: 'send-message', sessionId: targetSessionId, receiverId: decision.receiverId, text: safeMessage });
+    }
+    catch (err) {
+        if (!isReplySlotTaken(err))
+            throw err;
+        runtimeLog.warn('runTurn', `reply already persisted for this wake (idempotency 409) — a replay or second host answered first; dropping duplicate to ${decision.receiverId}`);
+        return [{ type: 'message_duplicate_skipped', receiverId: decision.receiverId, chatId: targetSessionId, senderId: 'system' }];
+    }
     const events = [{ type: 'message_sent', receiverId: decision.receiverId, chatId: targetSessionId, message: safeMessage, senderId: 'system' }];
     if (targetSessionId !== sessionId)
         events.push({ type: 'report_sent', message: 'Reported to owner.', senderId: 'system' });
@@ -693,6 +723,11 @@ async function executeSendMessages(decision, eff, sessionId) {
             await eff({ kind: 'send-message', sessionId: targetSessionId, receiverId: msg.receiverId, text: safeMessage });
         }
         catch (err) {
+            if (isReplySlotTaken(err)) {
+                runtimeLog.warn('runTurn', `reply already persisted for this wake (idempotency 409) — dropping duplicate to ${msg.receiverId}`);
+                events.push({ type: 'message_duplicate_skipped', receiverId: msg.receiverId, chatId: targetSessionId, senderId: 'system' });
+                continue;
+            }
             // Scenario: backend rejected or transport dropped this one send. Record
             // it and keep going — remaining recipients must still get their message.
             failures.push({ receiverId: msg.receiverId, error: err.message });

package/dist/runtime/taskBookkeeping.d.ts

@@ -0,0 +1,35 @@
+import type { Ctx, TaskBookkeeping } from '../types.js';
+/**
+ * Reserved key for coordinator-side pending/collected state when the lane has
+ * an active agreement but no assigned parent task yet (kickoff → spawn).
+ * Never deleted by task-closed of a real taskId (ZIG-977).
+ */
+export declare const LANE_BOOK_KEY = "__lane__";
+export declare function emptyTaskBook(agreementId?: string | null): TaskBookkeeping;
+export declare function ensureTaskBook(ctx: Ctx, taskId: string, agreementId?: string | null): TaskBookkeeping;
+/** Focus task's book, or null when nothing is focused / missing. */
+export declare function focusTaskBook(ctx: Ctx): TaskBookkeeping | null;
+/**
+ * Book that receives task-delegated / subtask-finished when we know the parent
+ * engagement: focus task if assigned, else the coordinator lane bucket.
+ */
+export declare function bookForDelegation(ctx: Ctx): TaskBookkeeping;
+/** Find which engagement is awaiting this child taskId. */
+export declare function findBookHoldingPending(ctx: Ctx, childTaskId: string): TaskBookkeeping | null;
+export declare function allCollectedResults(ctx: Ctx): TaskBookkeeping['collectedResults'];
+export declare function allPendingSubtasks(ctx: Ctx): Record<string, TaskBookkeeping['pendingSubtasks'][string]>;
+export declare function allDelegatedAgreementIds(ctx: Ctx): string[];
+export declare function hasOpenTaskForAgreement(ctx: Ctx, agreementId: string): boolean;
+export declare function hasDelegatedAgreement(ctx: Ctx, agreementId: string): boolean;
+/**
+ * Remove one task's bookkeeping and retarget focus if we just closed the
+ * focused task. Leaves sibling entries (and the coordinator lane bucket) alone.
+ */
+export declare function removeTaskBook(ctx: Ctx, taskId: string): void;
+/** Refresh deprecated aggregate views from the per-task map. */
+export declare function syncAggregateTaskViews(ctx: Ctx): void;
+/**
+ * Migrate a pre-ZIG-977 persisted ctx (lane-level pendingSubtasks /
+ * collectedResults / delegatedAgreementIds) into the tasks map.
+ */
+export declare function migrateLegacyTaskFields(existing: Record<string, unknown>): Record<string, TaskBookkeeping>;

package/dist/runtime/taskBookkeeping.js

@@ -0,0 +1,149 @@
+/**
+ * Reserved key for coordinator-side pending/collected state when the lane has
+ * an active agreement but no assigned parent task yet (kickoff → spawn).
+ * Never deleted by task-closed of a real taskId (ZIG-977).
+ */
+export const LANE_BOOK_KEY = '__lane__';
+export function emptyTaskBook(agreementId = null) {
+    return {
+        agreementId,
+        pendingSubtasks: {},
+        collectedResults: [],
+        delegatedAgreementIds: [],
+    };
+}
+export function ensureTaskBook(ctx, taskId, agreementId) {
+    if (!ctx.tasks)
+        ctx.tasks = {};
+    let book = ctx.tasks[taskId];
+    if (!book) {
+        book = emptyTaskBook(agreementId ?? null);
+        ctx.tasks[taskId] = book;
+    }
+    else if (agreementId && !book.agreementId) {
+        book.agreementId = agreementId;
+    }
+    return book;
+}
+/** Focus task's book, or null when nothing is focused / missing. */
+export function focusTaskBook(ctx) {
+    if (!ctx.activeTaskId)
+        return null;
+    return ctx.tasks?.[ctx.activeTaskId] ?? null;
+}
+/**
+ * Book that receives task-delegated / subtask-finished when we know the parent
+ * engagement: focus task if assigned, else the coordinator lane bucket.
+ */
+export function bookForDelegation(ctx) {
+    if (ctx.activeTaskId) {
+        return ensureTaskBook(ctx, ctx.activeTaskId, ctx.activeAgreementId);
+    }
+    const book = ensureTaskBook(ctx, LANE_BOOK_KEY, ctx.activeAgreementId);
+    if (ctx.activeAgreementId && !book.agreementId)
+        book.agreementId = ctx.activeAgreementId;
+    return book;
+}
+/** Find which engagement is awaiting this child taskId. */
+export function findBookHoldingPending(ctx, childTaskId) {
+    if (!ctx.tasks)
+        return null;
+    for (const book of Object.values(ctx.tasks)) {
+        if (childTaskId in book.pendingSubtasks)
+            return book;
+    }
+    return null;
+}
+export function allCollectedResults(ctx) {
+    if (!ctx.tasks)
+        return [];
+    const out = [];
+    for (const book of Object.values(ctx.tasks)) {
+        out.push(...book.collectedResults);
+    }
+    return out;
+}
+export function allPendingSubtasks(ctx) {
+    if (!ctx.tasks)
+        return {};
+    const out = {};
+    for (const book of Object.values(ctx.tasks)) {
+        Object.assign(out, book.pendingSubtasks);
+    }
+    return out;
+}
+export function allDelegatedAgreementIds(ctx) {
+    if (!ctx.tasks)
+        return [];
+    const ids = [];
+    for (const book of Object.values(ctx.tasks)) {
+        for (const id of book.delegatedAgreementIds) {
+            if (!ids.includes(id))
+                ids.push(id);
+        }
+    }
+    return ids;
+}
+export function hasOpenTaskForAgreement(ctx, agreementId) {
+    if (!agreementId || !ctx.tasks)
+        return false;
+    return Object.entries(ctx.tasks).some(([key, book]) => key !== LANE_BOOK_KEY && book.agreementId === agreementId);
+}
+export function hasDelegatedAgreement(ctx, agreementId) {
+    return allDelegatedAgreementIds(ctx).includes(agreementId);
+}
+/**
+ * Remove one task's bookkeeping and retarget focus if we just closed the
+ * focused task. Leaves sibling entries (and the coordinator lane bucket) alone.
+ */
+export function removeTaskBook(ctx, taskId) {
+    if (!taskId || !ctx.tasks)
+        return;
+    delete ctx.tasks[taskId];
+    if (ctx.activeTaskId === taskId) {
+        const nextId = Object.keys(ctx.tasks).find((id) => id !== LANE_BOOK_KEY) ?? null;
+        ctx.activeTaskId = nextId;
+        ctx.activeAgreementId = nextId ? (ctx.tasks[nextId]?.agreementId ?? null) : null;
+    }
+}
+/** Refresh deprecated aggregate views from the per-task map. */
+export function syncAggregateTaskViews(ctx) {
+    ctx.pendingSubtasks = allPendingSubtasks(ctx);
+    ctx.collectedResults = allCollectedResults(ctx);
+    ctx.delegatedAgreementIds = allDelegatedAgreementIds(ctx);
+}
+/**
+ * Migrate a pre-ZIG-977 persisted ctx (lane-level pendingSubtasks /
+ * collectedResults / delegatedAgreementIds) into the tasks map.
+ */
+export function migrateLegacyTaskFields(existing) {
+    if (existing.tasks && typeof existing.tasks === 'object') {
+        return existing.tasks;
+    }
+    const tasks = {};
+    const activeTaskId = existing.activeTaskId ?? null;
+    const activeAgreementId = existing.activeAgreementId ?? null;
+    const pendingSubtasks = existing.pendingSubtasks ?? {};
+    const collectedResults = existing.collectedResults ?? [];
+    const delegatedAgreementIds = existing.delegatedAgreementIds ?? [];
+    const hasLegacy = Object.keys(pendingSubtasks).length > 0 ||
+        collectedResults.length > 0 ||
+        delegatedAgreementIds.length > 0;
+    if (activeTaskId) {
+        tasks[activeTaskId] = {
+            agreementId: activeAgreementId,
+            pendingSubtasks,
+            collectedResults,
+            delegatedAgreementIds: [...delegatedAgreementIds],
+        };
+    }
+    else if (hasLegacy) {
+        tasks[LANE_BOOK_KEY] = {
+            agreementId: activeAgreementId,
+            pendingSubtasks,
+            collectedResults,
+            delegatedAgreementIds: [...delegatedAgreementIds],
+        };
+    }
+    return tasks;
+}

package/dist/runtime/taskIntake.js

@@ -35,7 +35,7 @@ export function buildTaskIntakeState(initial) {
         prompt: {
             role: 'A task was just assigned to you under one of your active agreements, and your workflow has no explicit route for it. This injected default exists so an assigned task is NEVER silently dropped — under a standing hire, new tasks keep arriving for the lifetime of the agreement.',
             goal: 'Resolve the assigned task this turn: deliver the result if you can produce it, otherwise fail it with a reason.',
-            constraints: 'The task is in <event> (and as activeTaskId / activeAgreementId in <machine_context>). If the deliverable can be produced in this turn (an answer, summary, plan, draft — most representation work), call task_update with status "completed" and the deliverable as result — the result is what the counterparty consumes, so make it the actual deliverable, not a status note. If the task genuinely needs abilities or tools you do not have, call task_update with status "failed" and a one-line reason — a visible failure the counterparty can re-route beats a silent drop. Never leave the task dangling or answer with a chat message alone.',
+            constraints: 'The task is in <event> (and as activeTaskId / activeAgreementId in <machine_context>). If the deliverable can be produced in this turn (an answer, summary, plan, draft — most representation work), call task_set_result with state "completed" and the deliverable as result — the result is what the counterparty consumes, so make it the actual deliverable, not a status note. If the task genuinely needs abilities or tools you do not have, call task_set_result with state "failed" and a one-line reason — a visible failure the counterparty can re-route beats a silent drop. Never leave the task dangling or answer with a chat message alone.',
         },
         actions: {
             ...dflt.actions,
@@ -43,10 +43,10 @@ export function buildTaskIntakeState(initial) {
                 prompt: {
                     when: 'You can produce the deliverable for the assigned task in this turn.',
                     instruction: 'Complete the assigned task, with the deliverable itself as the result.',
-                    format: '{"taskId": "<assigned task id from <event>>", "status": "completed", "result": "<the full deliverable>"}',
+                    format: '{"taskId": "<assigned task id from <event>>", "state": "completed", "result": "<the full deliverable>"}',
                 },
-                tool: 'task_update',
-                // Function form so a failed task_update surfaces as an error outcome
+                tool: 'task_set_result',
+                // Function form so a failed task_set_result surfaces as an error outcome
                 // (→ dflt error transition) instead of a phantom task-closed.
                 produces: (result) => {
                     const r = result;
@@ -59,9 +59,9 @@ export function buildTaskIntakeState(initial) {
                 prompt: {
                     when: 'The task needs abilities, tools, or information you cannot obtain this turn.',
                     instruction: 'Fail the assigned task with a one-line reason so the counterparty can re-route it.',
-                    format: '{"taskId": "<assigned task id from <event>>", "status": "failed", "result": "<one-line reason>"}',
+                    format: '{"taskId": "<assigned task id from <event>>", "state": "failed", "result": "<one-line reason>"}',
                 },
-                tool: 'task_update',
+                tool: 'task_set_result',
                 produces: (result) => {
                     const r = result;
                     const status = r?.task?.state ?? r?.state ?? r?.status;

package/dist/server/ZiggsEffectHandler.d.ts

@@ -59,7 +59,7 @@ export interface ZiggsEffectDeps {
  * side effects — that is the whole point of funneling both paths here.
  *
  * `eff` is threaded into the tool context so eff-backed tools
- * (`ziggs_context_snapshot`, `ziggs_send_message`) resolve through this same path
+ * (`context_snapshot`, `chat_send`) resolve through this same path
  * regardless of which cognition invoked them.
  */
 export declare function executeToolWithSideEffects(deps: Pick<ZiggsEffectDeps, 'toolManager' | 'artifactsClient' | 'telemetryClient' | 'telemetryIngest' | 'operatorKey' | 'agentId' | 'taskService' | 'agreementService' | 'contextReadClient' | 'messageSender'>, eff: EffectHandler, effect: Extract<Effect, {

package/dist/server/ZiggsEffectHandler.js

@@ -1,5 +1,6 @@
 import { OutboxBuffer } from './OutboxBuffer.js';
 import { runtimeLog } from '../shared/runtimeLog.js';
+import { artifactScopeForSession } from '@ziggs-ai/api-client';
 import { buildLlmIngestPayload, buildToolIngestPayload, isTelemetryIngestEnabled, sendTelemetry, } from './telemetryIngest.js';
 const CONTEXT_CACHE_MAX = 256;
 /**
@@ -69,12 +70,15 @@ function previewToolArgs(args) {
  * Chat timeline: `Message.tsx` parses `entryType: artifact`, `content_type: operation` with
  * `operation_*:{json}` where json includes `state` and `tool`.
  */
-async function emitToolOperationArtifact(client, chatId, phase, payload, idempotencyKey) {
+async function emitToolOperationArtifact(client, sessionId, phase, payload, idempotencyKey) {
     const prefix = phase === 'started' ? 'operation_started' : phase === 'completed' ? 'operation_completed' : 'operation_error';
     const text = `${prefix}:${JSON.stringify(payload)}`;
     try {
         await client.write({
-            chatId,
+            // ZIG-1032: an agreement lane (`agrn-…`) is a routing key, not a chat —
+            // passing it as chatId asked the backend to write into a chat that does
+            // not exist and 403'd every breadcrumb on agreement-lane work.
+            ...artifactScopeForSession(sessionId),
             text,
             content_type: 'operation',
             visibility: 'agent-private',
@@ -98,7 +102,7 @@ async function emitToolOperationArtifact(client, chatId, phase, payload, idempot
  * side effects — that is the whole point of funneling both paths here.
  *
  * `eff` is threaded into the tool context so eff-backed tools
- * (`ziggs_context_snapshot`, `ziggs_send_message`) resolve through this same path
+ * (`context_snapshot`, `chat_send`) resolve through this same path
  * regardless of which cognition invoked them.
  */
 export async function executeToolWithSideEffects(deps, eff, effect, roster) {
@@ -214,7 +218,7 @@ export function createZiggsEffectHandler(deps) {
                 // Grant-fenced aggregate read: the backend composes the ContextSnapshot
                 // (GET /context/snapshot) through the same access + temporal fence as
                 // the per-type reads. Every producer — ClaudeSdkAgent.tick, runTurn,
-                // and the on-demand ziggs_context_snapshot tool — routes through here.
+                // and the on-demand context_snapshot tool — routes through here.
                 const snap = await buildSnapshot(deps, effect.sessionId, deps.agentId, {
                     limit: effect.opts?.maxMessages,
                 });
@@ -296,7 +300,7 @@ export function createZiggsEffectHandler(deps) {
                     }
                     else {
                         await deps.artifactsClient.write({
-                            chatId: effect.sessionId,
+                            ...artifactScopeForSession(effect.sessionId),
                             text: JSON.stringify(effect.entry),
                             content_type: String(effect.entry.kind ?? 'event'),
                             visibility: 'agent-private',

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

@@ -19,6 +19,19 @@ export declare class AgreementService {
     publishOffer(payload: PublishOfferPayload): Promise<Agreement>;
     delegate(payload: DelegateAgreementData): Promise<Agreement>;
     respond(agreementId: string, action: 'approve' | 'reject'): Promise<Agreement>;
+    /**
+     * ZIG-1021 — claim any open broadcast (quest, standing offer, link invite).
+     * Routing (offer vs agreement claim endpoint) is decided in the shared flow.
+     */
+    claim(agreementId: string): Promise<{
+        agreement: Agreement;
+        kind: 'link' | 'offer' | 'quest';
+    }>;
+    /**
+     * ZIG-1022 — a link proposal is an agreement (engagementKind 'link') to one
+     * agent; the target owner approves. Folds the old request_link tool.
+     */
+    requestLink(providerId: string, description?: string): Promise<Agreement>;
     counter(agreementId: string, counter: CounterAgreementData): Promise<Agreement>;
     getStatus(agreementId: string): Promise<unknown | null>;
     list(filters?: ListAgreementsFilters): Promise<Agreement[]>;

package/dist/server/agreements/AgreementService.js

@@ -1,4 +1,4 @@
-import { proposeAgreement, proposeBroadcast as proposeBroadcastApi, delegateAgreement, respondToAgreement, counterAgreement, getAgreementStatus, listAgreements, getMyAgreements, getAgreement, publishOffer as publishOfferApi, createAgreement, revokeAgreement, fulfillAgreement, linkAgreementToChat, getChatsForAgreement, joinAgreement, linkArtifactToAgreement, getArtifactsForAgreement, linkUserToAgreement, getUsersForAgreement, } from '@ziggs-ai/api-client';
+import { proposeAgreement, proposeBroadcast as proposeBroadcastApi, delegateAgreement, respondToAgreement, counterAgreement, claimOpenAgreement, getAgreementStatus, listAgreements, getMyAgreements, getAgreement, publishOffer as publishOfferApi, createAgreement, revokeAgreement, fulfillAgreement, linkAgreementToChat, getChatsForAgreement, joinAgreement, linkArtifactToAgreement, getArtifactsForAgreement, linkUserToAgreement, getUsersForAgreement, } from '@ziggs-ai/api-client';
 export class AgreementService {
     creds;
     constructor(operatorKey, agentId) {
@@ -37,6 +37,21 @@ export class AgreementService {
     respond(agreementId, action) {
         return respondToAgreement(agreementId, action, this.creds);
     }
+    /**
+     * ZIG-1021 — claim any open broadcast (quest, standing offer, link invite).
+     * Routing (offer vs agreement claim endpoint) is decided in the shared flow.
+     */
+    claim(agreementId) {
+        return claimOpenAgreement(agreementId, this.creds);
+    }
+    /**
+     * ZIG-1022 — a link proposal is an agreement (engagementKind 'link') to one
+     * agent; the target owner approves. Folds the old request_link tool.
+     */
+    async requestLink(providerId, description) {
+        const { agreement } = await createAgreement({ engagementKind: 'link', providerId, ...(description ? { description } : {}) }, this.creds);
+        return agreement;
+    }
     counter(agreementId, counter) {
         return counterAgreement(agreementId, counter || {}, this.creds);
     }

package/dist/server/inboxLoop.js

@@ -1,5 +1,6 @@
 import { ContextReadClient, InboxClient, } from '@ziggs-ai/api-client';
 import { runtimeLog } from '../shared/runtimeLog.js';
+import { isRateLimited } from '@ziggs-ai/api-client';
 const READ_PAGE = 100;
 function log(label, msg) {
     runtimeLog.info(label, msg);
@@ -208,6 +209,18 @@ export function runInboxLoop(deps, opts = {}) {
                 if (!running)
                     break;
                 consecutiveErrors++;
+                // ZIG-1019: a 429 already told us how long to wait, and every refused
+                // call still counts against the cap — so the exponential ladder digs
+                // the hole deeper (1s, 2s, 4s… of pure refusals). Wait the server's
+                // number instead, and do not let a throttle inflate the ladder for the
+                // real errors that come after it.
+                const throttleMs = isRateLimited(err) ? (err.retryAfterMs ?? 30_000) : null;
+                if (throttleMs !== null) {
+                    consecutiveErrors = 0;
+                    warn(label, `inbox loop throttled: ${err?.message ?? err} — waiting ${Math.round(throttleMs)}ms as instructed`);
+                    await sleep(throttleMs);
+                    continue;
+                }
                 const backoff = Math.min(ERROR_BACKOFF_MAX_MS, ERROR_BACKOFF_BASE_MS * 2 ** (consecutiveErrors - 1));
                 const jitter = backoff * (0.5 + (consecutiveErrors % 7) / 14); // deterministic-ish, no Math.random
                 warn(label, `inbox loop pass failed (#${consecutiveErrors}): ${err?.message ?? err} — retrying in ~${Math.round(jitter)}ms`);

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

@@ -15,7 +15,7 @@
  * its `tools:` array. Each tool reads operatorKey/agentId from tool context and
  * wraps a backend HTTP client — no per-agent plumbing.
  */
-export { PROTOCOL_TOOLS, agreementProposeTool, agreementSubcontractTool, agreementRespondTool, agreementCounterProposalTool, agreementCheckProposalTool, agreementRevokeTool, taskSpawnTool, taskUpdateTool, taskUpdatePlanStepTool, } from './tier1/protocolTools.js';
+export { PROTOCOL_TOOLS, agreementProposeTool, agreementSubcontractTool, agreementRespondTool, agreementClaimTool, agreementCounterTool, agreementGetTool, agreementRevokeTool, agreementFulfillTool, taskCreateTool, taskSetResultTool, taskUpdatePlanStepTool, } from './tier1/protocolTools.js';
 export { dispatchProtocolOp } from './tier1/protocolRunner.js';
 export { DISCOVERY_TOOLS, agentSearchTool, agentGetTool } from './tier2/discoveryTools.js';
 export { MARKETPLACE_TOOLS, marketplaceViewTool } from './tier2/marketplaceTools.js';
@@ -23,6 +23,6 @@ export { PAYMENT_TOOLS, paymentBalanceTool, paymentTransferTool, paymentWaitForA
 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, requestLinkTool, createLinkInviteTool, claimLinkInviteTool, listLinksTool, revokeLinkTool, } from './tier2/linkTools.js';
+export { LINK_TOOLS, linkCreateInviteTool, linkListTool, } from './tier2/linkTools.js';
 export { ARTIFACT_TOOLS, recordArtifactTool } from './tier2/artifactTools.js';
 export { CHAT_TOOLS, openConversationTool } from './tier2/chatTools.js';

package/dist/server/tools/index.js

@@ -16,7 +16,7 @@
  * wraps a backend HTTP client — no per-agent plumbing.
  */
 // ── Tier 1: protocol grammar ────────────────────────────────────────────────
-export { PROTOCOL_TOOLS, agreementProposeTool, agreementSubcontractTool, agreementRespondTool, agreementCounterProposalTool, agreementCheckProposalTool, agreementRevokeTool, taskSpawnTool, taskUpdateTool, taskUpdatePlanStepTool, } from './tier1/protocolTools.js';
+export { PROTOCOL_TOOLS, agreementProposeTool, agreementSubcontractTool, agreementRespondTool, agreementClaimTool, agreementCounterTool, agreementGetTool, agreementRevokeTool, agreementFulfillTool, taskCreateTool, taskSetResultTool, taskUpdatePlanStepTool, } from './tier1/protocolTools.js';
 export { dispatchProtocolOp } from './tier1/protocolRunner.js';
 // ── Tier 2: capability bundles ──────────────────────────────────────────────
 export { DISCOVERY_TOOLS, agentSearchTool, agentGetTool } from './tier2/discoveryTools.js';
@@ -28,9 +28,11 @@ export { CONTEXT_TOOLS, contextReadTool, contextDelegateTool, contextExpandReach
 // payment_list_grants). Always-available on the hosted agent — see CLAUDE_SDK_TOOLS.
 export { GRANTS_TOOLS, listGrantsTool } from './tier2/grantsTools.js';
 // ZIG-898: links (agreements with engagementKind 'link') — cross-org reach.
-export { LINK_TOOLS, requestLinkTool, createLinkInviteTool, claimLinkInviteTool, listLinksTool, revokeLinkTool, } from './tier2/linkTools.js';
+// ZIG-1021/1022: the rail is two tools; propose/claim/revoke ride the
+// agreement grammar.
+export { LINK_TOOLS, linkCreateInviteTool, linkListTool, } from './tier2/linkTools.js';
 // ZIG-899: deliberate artifact recording (the model decides "record this").
 export { ARTIFACT_TOOLS, recordArtifactTool } from './tier2/artifactTools.js';
-// ZIG-900 decision: open_conversation only — chat listing stays a context-rail
-// read (list_grants scopeKind=chat), no duplicate lister (ZIG-626 rule).
+// ZIG-900 decision: chat_open only — chat listing stays a context-rail
+// read (grant_list scopeKind=chat), no duplicate lister (ZIG-626 rule).
 export { CHAT_TOOLS, openConversationTool } from './tier2/chatTools.js';

package/dist/server/tools/tier1/protocolRunner.d.ts

@@ -1,7 +1,7 @@
 import type { AgreementService } from '../../agreements/AgreementService.js';
 import type { TaskService } from '../../tasks/TaskService.js';
 import type { WakeWriteKeys } from '../../../types.js';
-import type { ContextReadClient } from '@ziggs-ai/api-client';
+import { type ContextReadClient } from '@ziggs-ai/api-client';
 interface Services {
     agreementService: AgreementService;
     taskService: TaskService;
@@ -30,7 +30,7 @@ interface ProtocolPayload {
     plan?: unknown;
     planReviewTiming?: string;
     requireMidWorkPlanAck?: boolean;
-    engagementKind?: 'hire' | 'service';
+    engagementKind?: 'hire' | 'service' | 'link';
     subtasks?: (string | {
         description?: string;
     })[];

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

@@ -1,4 +1,17 @@
+import { linkSummary, } from '@ziggs-ai/api-client';
 import { applyFleetCounterPricing, applyFleetPricingForProtocol, } from '../../../pricing/fleetDefaults.js';
+/**
+ * ZIG-957 — same summary shape as MCP link mutations / link_* tools.
+ * Raw Mongo money/approvals noise must not reach the LLM on a trust link.
+ */
+function shapeAgreementResult(agreement) {
+    if (!agreement)
+        return agreement;
+    return agreement.engagementKind === 'link' ? linkSummary(agreement) : agreement;
+}
+function shapeRevokeResult(result) {
+    return { ...result, agreement: shapeAgreementResult(result.agreement) };
+}
 // Map legacy task-state aliases onto the canonical set.
 function normalizeState(state) {
     if (state === 'done')
@@ -49,7 +62,17 @@ export async function dispatchProtocolOp(services, payload, chatId, agents = [],
         case 'agreement-respond':
             if (!payload.agreementId || !payload.action)
                 return null;
-            return agreementService.respond(payload.agreementId, payload.action);
+            return shapeAgreementResult(await agreementService.respond(payload.agreementId, payload.action));
+        case 'agreement-claim': {
+            // ZIG-1021: the one claim verb — quest, standing offer, or link invite.
+            if (!payload.agreementId)
+                throw new Error('agreement-claim requires `agreementId`');
+            const claimed = await agreementService.claim(payload.agreementId);
+            return {
+                ...claimed,
+                agreement: shapeAgreementResult(claimed.agreement),
+            };
+        }
         case 'agreement-counter-proposal':
             if (!payload.agreementId)
                 return null;
@@ -76,11 +99,11 @@ export async function dispatchProtocolOp(services, payload, chatId, agents = [],
         case 'agreement-revoke':
             if (!payload.agreementId)
                 return null;
-            return agreementService.revoke(payload.agreementId);
+            return shapeRevokeResult(await agreementService.revoke(payload.agreementId));
         case 'agreement-fulfill':
             if (!payload.agreementId)
                 return null;
-            return agreementService.fulfill(payload.agreementId);
+            return shapeRevokeResult(await agreementService.fulfill(payload.agreementId));
         case 'task-spawn': {
             if (!payload.agreementId || !payload.description)
                 return null;
@@ -160,9 +183,14 @@ export async function dispatchProtocolOp(services, payload, chatId, agents = [],
             });
         }
         case 'task-update': {
-            if (!payload.taskId || !payload.status)
+            // ZIG-957: canonical tool param is `state` (MCP + REST). Accept legacy
+            // `status` so fleet prompts that still emit it keep working.
+            const terminalRaw = (typeof payload.state === 'string' && payload.state) ||
+                (typeof payload.status === 'string' && payload.status) ||
+                '';
+            if (!payload.taskId || !terminalRaw)
                 return null;
-            const state = normalizeState(payload.status);
+            const state = normalizeState(terminalRaw);
             // Wake-derived idempotency key: a crash-replay re-issuing this transition
             // no-ops server-side instead of erroring on the already-terminal task.
             return taskService.updateState(payload.taskId, state, payload.result, wakeKeys?.taskStateKey(payload.taskId, state));
@@ -192,13 +220,36 @@ async function proposeAgreement(services, payload, chatId, _agents, actingAgentI
     if (!payload.description)
         throw new Error('agreement-propose requires `description`');
     if (!payload.proposedTo)
-        throw new Error('agreement-propose requires `proposedTo` (userId or agentId). To spawn a task under an existing agreement, use `task_spawn` instead.');
+        throw new Error('agreement-propose requires `proposedTo` (userId or agentId). To create a task under an existing agreement, use `task_create` instead.');
     const isBroadcast = payload.proposedTo === 'everyone' || payload.proposedTo === 'org';
+    // ZIG-1022: a link proposal is an agreement with engagementKind 'link' —
+    // 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.');
+        }
+        return shapeAgreementResult(await services.agreementService.requestLink(payload.proposedTo, payload.description));
+    }
     if (!isBroadcast && !payload.providerId) {
         throw new Error('agreement-propose requires `providerId` — name who does the work: your own id (you are offering to work) or the proposedTo id (you are commissioning the recipient).');
     }
     if (isBroadcast && payload.providerId) {
-        throw new Error('agreement-propose forbids `providerId` on a broadcast — the claiming agent fills the open side.');
+        // ZIG-1022: providerId = self on a broadcast publishes a STANDING OFFER
+        // (seller side open to any claimer). Any other providerId stays an error.
+        if (actingAgentId && payload.providerId === actingAgentId) {
+            const priced = applyFleetPricingForProtocol('agreement-propose', payload, actingAgentId);
+            return services.agreementService.publishOffer({
+                description: String(priced.description ?? ''),
+                price: typeof priced.price === 'number' ? priced.price : undefined,
+                lifecycle: typeof priced.lifecycle === 'string' ? priced.lifecycle : undefined,
+                expiresAt: typeof priced.expiresAt === 'string' ? priced.expiresAt : undefined,
+                maxExecutions: typeof priced.maxExecutions === 'number' ? priced.maxExecutions : undefined,
+                engagementKind: priced.engagementKind === 'hire' ? 'hire' : priced.engagementKind === 'service' ? 'service' : undefined,
+                billing: priced['billing'] === 'per_task' ? 'per_task' : priced['billing'] === 'total' ? 'total' : undefined,
+                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).');
     }
     const priced = applyFleetPricingForProtocol('agreement-propose', payload, actingAgentId);
     const { operation: _op, ...fields } = priced;

package/dist/server/tools/tier1/protocolTools.d.ts

@@ -2,11 +2,12 @@ import { type ToolDefinition } from '../../../tools/defineTool.js';
 export declare const agreementProposeTool: ToolDefinition;
 export declare const agreementSubcontractTool: ToolDefinition;
 export declare const agreementRespondTool: ToolDefinition;
-export declare const taskUpdateTool: ToolDefinition;
-export declare const agreementCounterProposalTool: ToolDefinition;
-export declare const agreementCheckProposalTool: ToolDefinition;
+export declare const agreementClaimTool: ToolDefinition;
+export declare const taskSetResultTool: ToolDefinition;
+export declare const agreementCounterTool: ToolDefinition;
+export declare const agreementGetTool: ToolDefinition;
 export declare const agreementRevokeTool: ToolDefinition;
 export declare const agreementFulfillTool: ToolDefinition;
 export declare const taskUpdatePlanStepTool: ToolDefinition;
-export declare const taskSpawnTool: ToolDefinition;
+export declare const taskCreateTool: ToolDefinition;
 export declare const PROTOCOL_TOOLS: ToolDefinition[];