@ziggs-ai/agent-sdk 0.20.0 → 0.22.0

package/dist/platform/inboxLoop.js

@@ -5,6 +5,17 @@ const READ_PAGE = 100;
 function log(label, msg) {
     runtimeLog.info(label, msg);
 }
+function inboxClient(deps) {
+    return new InboxClient(deps.creds.operatorKey, deps.creds.agentId, deps.baseUrl, deps.creds.instanceId);
+}
+async function releaseInboxHostBestEffort(deps) {
+    try {
+        await inboxClient(deps).releaseHost();
+    }
+    catch (err) {
+        warn(deps.label ?? 'inboxLoop', `inbox host release failed: ${err?.message ?? err}`);
+    }
+}
 function warn(label, msg) {
     runtimeLog.warn(label, msg);
 }
@@ -25,45 +36,6 @@ export function chatsInWakeOrder(chats) {
 function isPublishProbeChat(chatId) {
     return chatId.startsWith('probe_');
 }
-/**
- * Store publish waits on a chat reply, not inbox ack. The ordinary pass can
- * already be inside leftover mail when that room appears, so a side read
- * answers `probe_*` chats without waiting for the current pass to finish.
- * It never acks — the main pass still owns the watermark.
- */
-export async function answerPublishProbes(deps) {
-    const inbox = new InboxClient(deps.creds.operatorKey, deps.creds.agentId, deps.baseUrl);
-    const reader = new ContextReadClient(deps.creds.operatorKey, deps.creds.agentId, deps.baseUrl);
-    const envelope = await inbox.getInbox({});
-    const probes = (envelope.chats ?? []).filter((c) => isPublishProbeChat(c.chatId));
-    if (probes.length === 0)
-        return 0;
-    const mine = (d) => d.assigneeId === deps.ownAgentId;
-    const earliestByChat = new Map();
-    for (const d of envelope.deliveries) {
-        if (!d.chatId || !mine(d) || !isPublishProbeChat(d.chatId))
-            continue;
-        const seen = earliestByChat.get(d.chatId);
-        if (!seen || d.ts < seen)
-            earliestByChat.set(d.chatId, d.ts);
-    }
-    const attempt = async (what, handover) => {
-        try {
-            await handover();
-            return true;
-        }
-        catch (err) {
-            warn(deps.label ?? 'inboxLoop', `publish-probe ${what} was not handled: ${err?.message ?? err}`);
-            return false;
-        }
-    };
-    let delivered = 0;
-    for (const news of probes) {
-        const earliest = earliestByChat.get(news.chatId) ?? news.latestAt;
-        delivered += await deliverMessagesForChat(deps, news, earliest, reader, attempt);
-    }
-    return delivered;
-}
 /**
  * Standing proposals share the merged inbox visibility model with deliveries,
  * but older envelopes predate an explicit assignee stamp. Prefer the server's
@@ -78,6 +50,22 @@ function proposalIsMine(proposal, ownAgentId) {
     return (proposal.pendingApprovalPartyIds?.includes(ownAgentId) === true ||
         proposal.proposedTo === ownAgentId);
 }
+/**
+ * The one hire a chat's assigned deliveries name, or null when the room
+ * has none or more than one. Memory (and acting-for) treat "several
+ * customers in one room" as the shared section.
+ */
+export function soleHireAgreementIdForChat(deliveries, chatId, ownAgentId) {
+    const ids = new Set();
+    for (const d of deliveries) {
+        if (d.chatId !== chatId || !d.agreementId)
+            continue;
+        if (d.assigneeId && d.assigneeId !== ownAgentId)
+            continue;
+        ids.add(d.agreementId);
+    }
+    return ids.size === 1 ? [...ids][0] : null;
+}
 /**
  * Read the messages behind one chat's deliveries and hand them to the host.
  *
@@ -85,7 +73,7 @@ function proposalIsMine(proposal, ownAgentId) {
  * reads through `/context/read`, where the agent's own grants fence what it is
  * allowed to see. A delivery reference is an address, never an authorisation.
  */
-async function deliverMessagesForChat(deps, news, earliestTs, reader, attempt) {
+async function deliverMessagesForChat(deps, news, earliestTs, reader, attempt, hireAgreementId) {
     let delivered = 0;
     let remaining = news.count;
     // `after` is exclusive, so step back a millisecond to include the oldest
@@ -135,6 +123,7 @@ async function deliverMessagesForChat(deps, news, earliestTs, reader, attempt) {
                 // leaving it made ClaudeBrain treat the wake as notice-only.
                 receiverId: deps.ownAgentId,
                 receiver: { id: deps.ownAgentId },
+                ...(hireAgreementId ? { agreementId: hireAgreementId } : {}),
             }));
             if (handled)
                 delivered++;
@@ -155,7 +144,7 @@ async function deliverMessagesForChat(deps, news, earliestTs, reader, attempt) {
  */
 export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
     const label = deps.label ?? 'inboxLoop';
-    const inbox = new InboxClient(deps.creds.operatorKey, deps.creds.agentId, deps.baseUrl);
+    const inbox = inboxClient(deps);
     const reader = new ContextReadClient(deps.creds.operatorKey, deps.creds.agentId, deps.baseUrl);
     const envelope = await inbox.getInbox(waitSeconds > 0 ? { waitSeconds } : {});
     let messagesDelivered = 0;
@@ -244,7 +233,7 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
     for (const news of chatsInWakeOrder(envelope.chats ?? [])) {
         const earliest = earliestByChat.get(news.chatId) ?? news.latestAt;
         const failuresBefore = failures;
-        const n = await deliverMessagesForChat(deps, news, earliest, reader, attempt);
+        const n = await deliverMessagesForChat(deps, news, earliest, reader, attempt, soleHireAgreementIdForChat(envelope.deliveries, news.chatId, deps.ownAgentId));
         messagesDelivered += n;
         if (n > 0)
             log(label, `chat ${news.chatId} delivered ${n} message(s)`);
@@ -409,16 +398,6 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
  * some defaults ship with. Lower it if your deployment sits behind a shorter one.
  */
 const DEFAULT_WAIT_SECONDS = 110;
-/**
- * Side-poll interval for store-publish `probe_*` rooms.
- *
- * Default **off**. A second GET /inbox beside the main long-poll burned the
- * shared poll ceiling: every hosted agent side-polled, probes got 429s, and
- * Register saw ALB HTML 504s. Main pass + probe-first ordering + pinned
- * `probe_*` deliveries are enough; set `probePollMs` only when you knowingly
- * need the extra loop.
- */
-const DEFAULT_PROBE_POLL_MS = 0;
 const ERROR_BACKOFF_BASE_MS = 1_000;
 const ERROR_BACKOFF_MAX_MS = 30_000;
 /**
@@ -455,7 +434,6 @@ function sleep(ms) {
 export function runInboxLoop(deps, opts = {}) {
     const label = deps.label ?? 'inboxLoop';
     const waitSeconds = opts.waitSeconds ?? DEFAULT_WAIT_SECONDS;
-    const probePollMs = opts.probePollMs ?? DEFAULT_PROBE_POLL_MS;
     let running = true;
     let consecutiveErrors = 0;
     let heldPasses = 0;
@@ -501,32 +479,7 @@ export function runInboxLoop(deps, opts = {}) {
             }
         }
     })();
-    const probes = (async () => {
-        if (probePollMs <= 0)
-            return;
-        while (running) {
-            const slice = 50;
-            let left = probePollMs;
-            while (left > 0 && running) {
-                const step = Math.min(slice, left);
-                await sleep(step);
-                left -= step;
-            }
-            if (!running)
-                break;
-            try {
-                const n = await answerPublishProbes(deps);
-                if (n > 0)
-                    log(label, `publish-probe side poll delivered ${n} message(s)`);
-            }
-            catch (err) {
-                if (!running)
-                    break;
-                warn(label, `publish-probe side poll failed: ${err?.message ?? err}`);
-            }
-        }
-    })();
-    const done = Promise.all([main, probes]);
+    const done = main;
     return {
         get running() {
             return running;
@@ -539,7 +492,10 @@ export function runInboxLoop(deps, opts = {}) {
         },
         async stop() {
             running = false;
-            await done.catch(() => { });
+            // Drop the lease immediately. Do not wait out a held poll — SIGTERM
+            // then process.exit cannot sit on the 110s wait.
+            await releaseInboxHostBestEffort(deps);
+            void done.catch(() => { });
         },
     };
 }

package/dist/platform/polls/declaredPollRunner.d.ts

@@ -1,4 +1,10 @@
 import type { AgentOptions } from '../../Agent.js';
 import { PollRunner, type WakeTarget } from './PollRunner.js';
-/** Validate before starting any work, so a declared wake source cannot vanish. */
+/**
+ * Build the runner that executes this agent's declared wakes.
+ *
+ * A malformed `polls` value is a programming error and still throws. A
+ * binding that names an unknown kind or has no chatId is not: PollRunner
+ * warns and skips it, so one agent's invalid poll cannot refuse the host.
+ */
 export declare function createDeclaredPollRunner(options: AgentOptions, target: WakeTarget): PollRunner | null;

package/dist/platform/polls/declaredPollRunner.js

@@ -1,6 +1,12 @@
 import { PollRegistry } from './PollKind.js';
 import { PollRunner } from './PollRunner.js';
-/** Validate before starting any work, so a declared wake source cannot vanish. */
+/**
+ * Build the runner that executes this agent's declared wakes.
+ *
+ * A malformed `polls` value is a programming error and still throws. A
+ * binding that names an unknown kind or has no chatId is not: PollRunner
+ * warns and skips it, so one agent's invalid poll cannot refuse the host.
+ */
 export function createDeclaredPollRunner(options, target) {
     const registry = new PollRegistry();
     for (const kind of options.pollKinds ?? [])
@@ -9,14 +15,6 @@ export function createDeclaredPollRunner(options, target) {
         return null;
     if (!Array.isArray(options.polls))
         throw new Error('Agent: polls must be an array');
-    for (const binding of options.polls) {
-        if (!binding || !registry.get(binding.kind)) {
-            throw new Error(`Agent ${options.agentId}: unknown poll kind "${binding?.kind}"; declare its implementation in pollKinds`);
-        }
-        if (typeof binding.chatId !== 'string' || !binding.chatId.trim()) {
-            throw new Error(`Agent ${options.agentId}: poll "${binding.kind}" requires a chatId`);
-        }
-    }
     if (!options.polls.length)
         return null;
     return new PollRunner({

package/dist/platform/tasks/TaskService.d.ts

@@ -8,7 +8,29 @@ export declare class TaskService {
     getActiveTasksForChat(chatId: string): Promise<Task[]>;
     getSubtasks(parentTaskId: string): Promise<Task[]>;
     spawnUnderAgreement(agreementId: string, taskData: Omit<CreateTaskData, 'agreementId'>): Promise<Task>;
-    updateState(taskId: string, state: TaskState, result?: unknown, idempotencyKey?: string): Promise<import("@ziggs-ai/api-client").TaskWriteConfirm>;
+    updateState(taskId: string, state: TaskState, result?: unknown, idempotencyKey?: string): Promise<{
+        ok: true;
+        taskId: string;
+        state: string;
+        outcome: import("@ziggs-ai/api-client").NextCallOutcome;
+        recorded: string;
+        handoff?: string;
+        delivery?: string;
+        metering?: string;
+        agreement?: string;
+        next: import("@ziggs-ai/api-client").NextCall[];
+        workContext?: import("@ziggs-ai/api-client").WorkContext;
+        agreementId?: string;
+        updatedAt?: string;
+        status?: string;
+        stepCount?: number;
+        structureChanged?: boolean;
+        stepId?: string;
+        stepStatus?: string;
+        patchedCount?: number;
+        resultRecorded?: boolean;
+        terminalState?: string;
+    }>;
     updatePlanStep(taskId: string, stepId: string, status: string, result?: unknown): Promise<import("@ziggs-ai/api-client").TaskWriteConfirm>;
     cancel(taskId: string): Promise<import("@ziggs-ai/api-client").TaskWriteConfirm>;
     report(taskId: string, message?: string): Promise<import("@ziggs-ai/api-client").TaskWriteConfirm>;

package/dist/platform/tasks/TaskService.js

@@ -1,4 +1,4 @@
-import { createTask, getTask, getActiveTasksForAgent, getActiveTasksForChat, getSubtasks, updateTaskState, updateTaskPlanStep, cancelTask, reportTask, setTaskSatisfaction, countTasks, } from '@ziggs-ai/api-client';
+import { createTask, getTask, getActiveTasksForAgent, getActiveTasksForChat, getSubtasks, updateTaskState, updateTaskPlanStep, cancelTask, reportTask, setTaskSatisfaction, countTasks, presentTaskOutcome, } from '@ziggs-ai/api-client';
 import { runtimeLog } from '../../shared/runtimeLog.js';
 function safeJsonStringify(value) {
     if (value === null || value === undefined)
@@ -65,7 +65,13 @@ export class TaskService {
             };
             const updated = await updateTaskState(taskId, state, data, this.creds);
             runtimeLog.info('TaskService', `Task state: ${taskId} → ${state}`);
-            return updated;
+            // The same four facts the MCP surface reports, from the same
+            // presenter: what was stored, who was woken, what metering did, what the
+            // agreement is now. Both surfaces say it once, and say it the same way.
+            return {
+                ...updated,
+                ...presentTaskOutcome(updated, { creds: this.creds, surface: 'sdk' }),
+            };
         }
         catch (error) {
             runtimeLog.error('TaskService', `Task state update failed: ${error.message}`);

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

@@ -21,9 +21,10 @@ export { DISCOVERY_TOOLS, agentSearchTool, agentGetTool } from './tier2/discover
 export { MARKETPLACE_TOOLS, marketplaceViewTool } from './tier2/marketplaceTools.js';
 export { PAYMENT_TOOLS, paymentBalanceTool } from './tier2/paymentTools.js';
 export { CONNECTION_TOOLS, connectionProxyTool, connectionListGrantsTool, requestConnectionTool, } from './tier2/connectionTools.js';
-export { CONTEXT_TOOLS, contextReadTool, contextDelegateTool, contextExpandReachTool, contextDiscoverGrantableTool, } from './tier2/contextTools.js';
+export { CONTEXT_TOOLS, contextReadTool, contextRequestTool, contextDelegateTool, contextExpandReachTool, contextDiscoverGrantableTool, } from './tier2/contextTools.js';
 export { GRANTS_TOOLS, listGrantsTool } from './tier2/grantsTools.js';
-export { TASK_TOOLS, listTasksTool } from './tier2/taskTools.js';
+export { TASK_TOOLS, listTasksTool, cancelTaskTool } from './tier2/taskTools.js';
+export { PLAN_TOOLS, taskReplacePlanTool } from './tier2/planTools.js';
 export { LINK_TOOLS, linkProposeTool, linkListTool, } from './tier2/linkTools.js';
 export { INTRODUCTION_TOOLS, introductionMintTool, introductionRedeemTool, introductionListTool, introductionRevokeTool, } from './tier2/introductionTools.js';
 export { ARTIFACT_TOOLS, recordArtifactTool } from './tier2/artifactTools.js';

package/dist/platform/tools/index.js

@@ -23,11 +23,12 @@ export { DISCOVERY_TOOLS, agentSearchTool, agentGetTool } from './tier2/discover
 export { MARKETPLACE_TOOLS, marketplaceViewTool } from './tier2/marketplaceTools.js';
 export { PAYMENT_TOOLS, paymentBalanceTool } from './tier2/paymentTools.js';
 export { CONNECTION_TOOLS, connectionProxyTool, connectionListGrantsTool, requestConnectionTool, } from './tier2/connectionTools.js';
-export { CONTEXT_TOOLS, contextReadTool, contextDelegateTool, contextExpandReachTool, contextDiscoverGrantableTool, } from './tier2/contextTools.js';
+export { CONTEXT_TOOLS, contextReadTool, contextRequestTool, contextDelegateTool, contextExpandReachTool, contextDiscoverGrantableTool, } from './tier2/contextTools.js';
 // one grant lister across every rail (retires context_discover +
 // payment_list_grants). Always-available on the hosted agent — see CLAUDE_SDK_TOOLS.
 export { GRANTS_TOOLS, listGrantsTool } from './tier2/grantsTools.js';
-export { TASK_TOOLS, listTasksTool } from './tier2/taskTools.js';
+export { TASK_TOOLS, listTasksTool, cancelTaskTool } from './tier2/taskTools.js';
+export { PLAN_TOOLS, taskReplacePlanTool } from './tier2/planTools.js';
 // links (agreements with engagementKind 'link') — cross-org reach.
 ///1022: the rail is two tools; propose/claim/revoke ride the
 // agreement grammar.

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

@@ -57,7 +57,7 @@ cachedAgreements) {
         case 'agreement-propose':
             return proposeAgreement(services, payload, chatId, agents, actorId, writeKeys);
         case 'agreement-subcontract':
-            return subcontractAgreement(services, payload, chatId, agents, actorId, writeKeys, cachedAgreements);
+            return subcontractAgreement(services, payload, namedSubcontractChat(payload, chatId), agents, actorId, writeKeys, cachedAgreements);
         case 'agreement-respond':
             if (!payload.agreementId || !payload.action)
                 return null;
@@ -323,6 +323,13 @@ function agActive(a) {
 function agIsActiveStatus(a) {
     return String(a.status ?? '') === 'active';
 }
+/** A named room on the call wins; otherwise the wake's chat. Empty is omit. */
+function namedSubcontractChat(payload, wakeChatId) {
+    const named = payload.chatId;
+    if (typeof named === 'string' && named.trim())
+        return named.trim();
+    return wakeChatId;
+}
 async function subcontractAgreement(services, payload, chatId, _agents, actingAgentId, writeKeys = null, cachedAgreements) {
     if (!payload.description || !payload.executorId)
         return null;

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

@@ -1,7 +1,7 @@
 import { defineTool } from '../../../tools/defineTool.js';
 import { requireProtocolOperation } from '../../../tasks/protocolRegistry.js';
 import { dispatchProtocolOp } from './protocolRunner.js';
-import { AGREEMENT_PROPOSE_PROVIDER_ID_DESCRIPTION, agreementClaimCapability, } from '@ziggs-ai/api-client';
+import { AGREEMENT_PROPOSE_PROVIDER_ID_DESCRIPTION, agreementClaimCapability, agreementSubcontractCapability, } from '@ziggs-ai/api-client';
 /** keep these enums in lockstep with MCP ziggs_agreement_* / ziggs_task_create. */
 const LIFECYCLE_ENUM = ['open', 'time-bound', 'count-bound'];
 const PLAN_REVIEW_TIMING_ENUM = ['with_proposal', 'before_execution'];
@@ -61,7 +61,7 @@ function handlerFor(toolName) {
     };
 }
 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 agreementSubcontractTool = defineTool('agreement_subcontract', agreementSubcontractCapability.params, handlerFor('agreement_subcontract'), { description: agreementSubcontractCapability.descriptions.sdk, 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', agreementClaimCapability.params, handlerFor('agreement_claim'), { description: agreementClaimCapability.descriptions.sdk });
 export const taskSetResultTool = defineTool('task_set_result', {
@@ -73,7 +73,7 @@ export const taskSetResultTool = defineTool('task_set_result', {
         type: 'object',
         description: 'Outcome payload (summary, status, links, …). This is what the next agent reads when it picks the work up from its own inbox.',
     },
-}, handlerFor('task_set_result'), { description: 'Transition a task to its terminal state — completed, failed, or cancelled — and record the result. Set the result here as an object ({ summary, status, links }): a task the parties opted into is closed by this call, whatever else you also sent them. Pass state (not status).' });
+}, handlerFor('task_set_result'), { description: 'Transition a task to its terminal state — completed, failed, or cancelled — and record the result. Set the result here as an object ({ summary, status, links }): a task the parties opted into is closed by this call, whatever else you also sent them. Pass state (not status). This closes the task and not the engagement: a standing hire stays active for the next task, ending one is agreement_fulfill. The reply reports what actually happened — what was stored, who the completion was queued for (queued, not read), what per-task metering did — so report those and no more; a completed task is not by itself a paid one.' });
 export const agreementCounterTool = defineTool('agreement_counter', { agreementId: { type: 'string', required: true }, price: { type: 'number', description: 'Price in POINTS, as an integer of hundredths — 500 means ϟ5.00. Convert both ways: a human asking for "ϟ2 per task" means 200, not 2. ϟ is the points symbol, not a hundredth.' }, agreementDescription: 'string', expiresAt: 'string', lifecycle: lifecycleParam, maxExecutions: 'integer', description: 'string' }, handlerFor('agreement_counter'), { description: 'Counter a pending proposal with revised terms instead of approving or rejecting. Check status first with agreement_get.' });
 export const agreementGetTool = defineTool('agreement_get', { agreementId: { type: 'string', required: true } }, handlerFor('agreement_get'), { description: 'Read the current proposal status for an agreement (pending, approved, rejected, countered, expired).' });
 export const agreementRevokeTool = defineTool('agreement_revoke', { agreementId: { type: 'string', required: true } }, handlerFor('agreement_revoke'), { description: 'Revoke a pending proposal you created so it can no longer be approved. Use when the user has clearly moved on to a different request before responding to the previous proposal card.' });

package/dist/platform/tools/tier2/contextTools.d.ts

@@ -1,5 +1,8 @@
 import type { ToolDefinition } from '../../../tools/defineTool.js';
 export declare const contextReadTool: ToolDefinition;
+export declare const openTool: ToolDefinition;
+export declare const accessExplainTool: ToolDefinition;
+export declare const contextRequestTool: ToolDefinition;
 export declare const contextDelegateTool: ToolDefinition;
 export declare const contextExpandReachTool: ToolDefinition;
 export declare const contextDiscoverGrantableTool: ToolDefinition;

package/dist/platform/tools/tier2/contextTools.js

@@ -1,9 +1,12 @@
-import { CONTEXT_CAPABILITIES, contextReadCapability, contextDelegateCapability, contextExpandReachCapability, contextDiscoverGrantableCapability, } from '@ziggs-ai/api-client';
+import { CONTEXT_CAPABILITIES, contextReadCapability, openCapability, accessExplainCapability, contextDelegateCapability, contextExpandReachCapability, contextDiscoverGrantableCapability, contextRequestCapability, } from '@ziggs-ai/api-client';
 import { toolFromCapability, toolsFromCapabilities } from '../../../tools/capabilityAdapter.js';
 // context grant tools ride the same api-client
 // clients as ziggs-mcp; the whole definition (schema + handler) is now shared
 // via the capability layer, so the two surfaces cannot fork.
 export const contextReadTool = toolFromCapability(contextReadCapability);
+export const openTool = toolFromCapability(openCapability);
+export const accessExplainTool = toolFromCapability(accessExplainCapability);
+export const contextRequestTool = toolFromCapability(contextRequestCapability);
 export const contextDelegateTool = toolFromCapability(contextDelegateCapability);
 export const contextExpandReachTool = toolFromCapability(contextExpandReachCapability);
 export const contextDiscoverGrantableTool = toolFromCapability(contextDiscoverGrantableCapability);

package/dist/platform/tools/tier2/planTools.d.ts

@@ -0,0 +1,20 @@
+import { type ToolDefinition } from '../../../tools/defineTool.js';
+/**
+ * `task_replace_plan` — write the checklist of a task you hold.
+ *
+ * The hosted tool set could only UPDATE a step that already existed
+ * (`task_update_plan_step` takes a stepId), and a task created without a plan
+ * has none, so an agent had no way to record anything about its own work on
+ * the task row. That mattered the moment one agent served two customers: from
+ * the second customer's room it could not find the approval request it had
+ * sent under the first customer's hire, and told them it had never been sent
+ * (store-opening lab, 2026-09-15). The MCP surface has had
+ * `ziggs_task_replace_plan` all along; this is the same client call for the
+ * hosted brain.
+ *
+ * The plan is the agent's own notebook on the task: step results can carry
+ * ids (an approval agreement, an artifact), and `task_list` reads the plan back
+ * from any room the agent is woken in.
+ */
+export declare const taskReplacePlanTool: ToolDefinition;
+export declare const PLAN_TOOLS: ToolDefinition[];

package/dist/platform/tools/tier2/planTools.js

@@ -0,0 +1,64 @@
+import { replaceTaskPlan } from '@ziggs-ai/api-client';
+import { defineTool } from '../../../tools/defineTool.js';
+import { credsFromToolContext } from '../../../tools/toolCreds.js';
+/**
+ * `task_replace_plan` — write the checklist of a task you hold.
+ *
+ * The hosted tool set could only UPDATE a step that already existed
+ * (`task_update_plan_step` takes a stepId), and a task created without a plan
+ * has none, so an agent had no way to record anything about its own work on
+ * the task row. That mattered the moment one agent served two customers: from
+ * the second customer's room it could not find the approval request it had
+ * sent under the first customer's hire, and told them it had never been sent
+ * (store-opening lab, 2026-09-15). The MCP surface has had
+ * `ziggs_task_replace_plan` all along; this is the same client call for the
+ * hosted brain.
+ *
+ * The plan is the agent's own notebook on the task: step results can carry
+ * ids (an approval agreement, an artifact), and `task_list` reads the plan back
+ * from any room the agent is woken in.
+ */
+export const taskReplacePlanTool = defineTool('task_replace_plan', {
+    taskId: { type: 'string', required: true, minLength: 1, pattern: '\\S' },
+    steps: {
+        type: 'array',
+        required: true,
+        items: {
+            type: 'object',
+            properties: {
+                stepId: {
+                    type: 'string',
+                    description: 'Stable id for this step. Omit to let the server assign step-<n>.',
+                },
+                description: { type: 'string', minLength: 1, pattern: '\\S' },
+                order: {
+                    type: 'integer',
+                    description: 'Position in the plan. Omit to use the array index.',
+                },
+                status: {
+                    type: 'string',
+                    enum: ['pending', 'in_progress', 'completed', 'skipped'],
+                    description: 'Step progress. Omit for pending.',
+                },
+                result: {
+                    type: 'object',
+                    description: 'What this step produced, as an object — e.g. { "agreementId": "agr_…" } for an approval you requested, or { "artifactId": "art_…" } for a pack you recorded. Stored with the step and read back by task_list.',
+                },
+            },
+            required: ['description'],
+        },
+        description: 'The FULL ordered step list. Existing steps are replaced wholesale, not appended to — read the current plan with task_list first and send it back with your changes.',
+    },
+}, async (args, ctx) => {
+    const creds = credsFromToolContext(ctx, 'task_replace_plan');
+    const taskId = typeof args.taskId === 'string' ? args.taskId.trim() : '';
+    if (!taskId)
+        throw new Error('task_replace_plan: taskId is required');
+    const steps = args.steps;
+    if (!Array.isArray(steps))
+        throw new Error('task_replace_plan: steps must be an array');
+    return replaceTaskPlan(taskId, steps, creds);
+}, {
+    description: 'Replace the plan of a task you hold with the full ordered step list. Use it to write your own checklist on a task that arrived without one, and to record what a step produced (an approval agreement id, an artifact id) so a later wake — in any room — can find it with task_list. Steps you do not send are removed; mark finished steps completed so closing the task does not rewrite them as skipped.',
+});
+export const PLAN_TOOLS = [taskReplacePlanTool];

package/dist/platform/tools/tier2/taskTools.d.ts

@@ -1,3 +1,4 @@
 import type { ToolDefinition } from '../../../tools/defineTool.js';
 export declare const listTasksTool: ToolDefinition;
+export declare const cancelTaskTool: ToolDefinition;
 export declare const TASK_TOOLS: ToolDefinition[];

package/dist/platform/tools/tier2/taskTools.js

@@ -1,6 +1,7 @@
-import { listTasksCapability, TASK_CAPABILITIES } from '@ziggs-ai/api-client';
+import { cancelTaskCapability, listTasksCapability, TASK_CAPABILITIES } from '@ziggs-ai/api-client';
 import { toolFromCapability, toolsFromCapabilities } from '../../../tools/capabilityAdapter.js';
 // GET /tasks, defined once in api-client. MCP ziggs_task_list and this
 // hosted-Claude tool used to re-declare the same filters.
 export const listTasksTool = toolFromCapability(listTasksCapability);
+export const cancelTaskTool = toolFromCapability(cancelTaskCapability);
 export const TASK_TOOLS = toolsFromCapabilities(TASK_CAPABILITIES);

package/dist/pricing/fleetDefaults.js

@@ -3,7 +3,6 @@
  * Prices are in wallet cents (1 ZIG = 100 cents).
  */
 import { FLEET_TIER_BY_AGENT_ID } from './fleetTierByAgentId.gen.js';
-import { FREE_TIER_A_AGENT_IDS } from './fleetFreeTierA.gen.js';
 import { isEvalFreeExecutor } from './fleetEvalFree.js';
 export const ZIGGS_OPERATOR_CUT_BPS = 1000; // 10%
 export const TIER_PRICE_CENTS = {
@@ -13,7 +12,6 @@ export const TIER_PRICE_CENTS = {
     D: 100, // 1 ZIG / call (hand-written demo agents)
 };
 const PING_DESCRIPTION_PATTERN = /\b(ping|health\s*check|healthcheck|liveness|readiness|heartbeat)\b/i;
-const TRIVIAL_LOOKUP_DESCRIPTION_PATTERN = /\b(what\s+time|current\s+time|local\s+time|world\s+clock|timezone|time\s+zone|weather|forecast|temperature|uv\s+index)\b/i;
 export function resolveFleetTier(agentId) {
     if (!agentId || typeof agentId !== 'string')
         return null;
@@ -30,15 +28,12 @@ export function isFreeAllowlistedExecutor(executorId, description) {
         return false;
     if (isEvalFreeExecutor(executorId))
         return true;
-    if (FREE_TIER_A_AGENT_IDS.has(executorId))
-        return true;
+    // A health check does not bill, whatever tier the executor is in. This is
+    // the only description-based exemption left: an agent whose work should cost
+    // nothing says so with a posted price of 0 on its own listing, where the
+    // buyer can see it, rather than through a rule inferred here.
     if (description && PING_DESCRIPTION_PATTERN.test(description))
         return true;
-    if (description &&
-        TRIVIAL_LOOKUP_DESCRIPTION_PATTERN.test(description) &&
-        FREE_TIER_A_AGENT_IDS.has(executorId)) {
-        return true;
-    }
     return false;
 }
 export function resolveDefaultPriceCentsForExecutor(executorId, description) {

package/dist/pricing/fleetTierByAgentId.gen.d.ts

@@ -4,4 +4,4 @@
  */
 export type FleetPricingTier = 'A' | 'B' | 'C' | 'D';
 export declare const FLEET_TIER_BY_AGENT_ID: Record<string, FleetPricingTier>;
-export declare const FLEET_TIER_MAP_SIZE = 767;
+export declare const FLEET_TIER_MAP_SIZE = 17;