@ziggs-ai/agent-sdk 0.19.0 → 0.21.0

package/dist/platform/inboxLoop.js

@@ -1,10 +1,21 @@
-import { ContextReadClient, InboxClient, } from '@ziggs-ai/api-client';
+import { ContextReadClient, InboxClient, planInboxAck, planPartialInboxAck, } 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);
 }
+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;
@@ -190,22 +179,72 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
     // needs-human rows, granted ambient lanes) is context the host may read on
     // demand — never a wake, never mine to ack as handled.
     const mine = (d) => d.assigneeId === deps.ownAgentId;
+    // Give the mark back in steps instead of once at the end of the pass.
+    //
+    // A pass that acks only when it finishes freezes the watermark for its whole
+    // length, and the server hands an unanswered row to the person's stand-in
+    // after 90s. Measured, a single turn is ~19s but an uninterrupted stretch is
+    // ~86s median, so the pass — not the turn — is what crosses the window. Each
+    // row now carries a token for its own position; `planPartialInboxAck` says
+    // how far those tokens can safely be taken given what is finished.
+    //
+    // A mark is global, so it can only be released in timestamp order, while
+    // chats are worked newest-first. One chat in the pass — the ordinary case,
+    // and the one the window actually bites — releases as soon as it is done.
+    // Several, and the oldest is worked last, so the release waits for it: no
+    // worse than acking at the end, which is what this replaced.
+    const handledSoFar = new Set();
+    let lastAckedTo = null;
+    const ackWhatIsFinished = async () => {
+        const step = planPartialInboxAck(envelope, handledSoFar, {
+            ownAgentId: deps.ownAgentId,
+            failures,
+        });
+        if (!step || step.ackTo === lastAckedTo)
+            return;
+        try {
+            await inbox.ack(step.ackTo, { handledResourceIds: step.handledResourceIds });
+            lastAckedTo = step.ackTo;
+            log(label, `acked up to ${step.ackTo} (mid-pass)`);
+        }
+        catch (err) {
+            // Never fatal: the end-of-pass ack is still coming, and the watermark is
+            // monotonic, so a lost step costs nothing but the exposure it would have
+            // closed.
+            warn(label, `mid-pass ack did not land: ${err?.message ?? err}`);
+        }
+    };
     // Oldest ASSIGNED delivery per chat: where to start reading that chat's
     // messages. Ambient chat rows must not drag the read window earlier.
     const earliestByChat = new Map();
+    const assignedRowsByChat = new Map();
     for (const d of envelope.deliveries) {
         if (!d.chatId || !mine(d))
             continue;
         const seen = earliestByChat.get(d.chatId);
         if (!seen || d.ts < seen)
             earliestByChat.set(d.chatId, d.ts);
+        const rows = assignedRowsByChat.get(d.chatId);
+        if (rows)
+            rows.push(d.resourceId);
+        else
+            assignedRowsByChat.set(d.chatId, [d.resourceId]);
     }
     for (const news of chatsInWakeOrder(envelope.chats ?? [])) {
         const earliest = earliestByChat.get(news.chatId) ?? news.latestAt;
-        const n = await deliverMessagesForChat(deps, news, earliest, reader, attempt);
+        const failuresBefore = failures;
+        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)`);
+        // A fold that dropped a handover has not finished its rows, and the
+        // watermark must wait for the redelivery it is holding open.
+        if (failures === failuresBefore) {
+            for (const id of assignedRowsByChat.get(news.chatId) ?? []) {
+                handledSoFar.add(id);
+            }
+            await ackWhatIsFinished();
+        }
     }
     // Everything that is not chat text is handed over as a resource event, from
     // the delivery itself — the reference already carries the ids the host needs,
@@ -220,8 +259,12 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
         if (!mine(d))
             continue;
         const key = `delivery:${d.kind}:${d.resourceId}:${d.ts}`;
-        if (deps.seen.has(key))
+        // Handled on an earlier pass — it still settles this instant, exactly as
+        // it does in the end-of-pass list.
+        if (deps.seen.has(key)) {
+            handledSoFar.add(d.resourceId);
             continue;
+        }
         deps.seen.mark(key);
         const handled = await attempt(`${d.kind} ${d.resourceId}`, () => deps.onResourceEvent({
             kind: d.kind,
@@ -236,9 +279,13 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
             ...(d.actorId ? { actorId: d.actorId } : {}),
             change: 'created',
         }), () => deps.seen.unmark(key));
-        if (handled)
+        if (handled) {
             resourceEvents++;
+            handledSoFar.add(d.resourceId);
+        }
     }
+    // An older row here may have been holding the mark back behind the chats.
+    await ackWhatIsFinished();
     // the work channel. An open assigned task is redelivered on every
     // pass until it closes (that IS the durable-wait contract), so dedup on
     // taskId+updatedAt — a genuinely touched task wakes again, an untouched one
@@ -261,18 +308,23 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
     // a miss must still count as handled so the watermark can advance with 0 tokens.
     for (const request of envelope.openRequestsAwaitingMe ?? []) {
         const key = `request:${request.agreementId}:${request.ts}`;
-        if (deps.seen.has(key))
+        if (deps.seen.has(key)) {
+            handledSoFar.add(request.agreementId);
             continue;
+        }
         deps.seen.mark(key);
         if (deps.onRequest) {
             const handled = await attempt(`request ${request.agreementId}`, () => deps.onRequest(request), () => deps.seen.unmark(key));
-            if (handled)
+            if (handled) {
                 requestsTriaged++;
+                handledSoFar.add(request.agreementId);
+            }
         }
         else {
             // No handler → still count as handled (ack) so an old host cannot wedge
             // forever on request mail it does not understand.
             requestsTriaged++;
+            handledSoFar.add(request.agreementId);
         }
     }
     if (envelope.truncatedRequests) {
@@ -308,22 +360,20 @@ export async function pollInboxOnce(deps, waitSeconds = 0, opts = {}) {
     // the watermark so the server redelivers the window — unless `forceAck` says
     // this window has failed too many times in a row and is now poison, in which
     // case it is dropped loudly rather than wedging the agent forever.
+    // One function, shared with the MCP inbox tool — do not restate the list
+    // or the allow-gate here.
     let acked = false;
-    if (envelope.ackTo && (failures === 0 || opts.forceAck)) {
+    const ack = planInboxAck(envelope, {
+        ownAgentId: deps.ownAgentId,
+        failures,
+        forceAck: opts.forceAck,
+    });
+    if (ack.allowed) {
         if (failures > 0) {
             runtimeLog.error(label, `acking a window that failed ${failures} handover(s) — giving up on redelivery to keep the ` +
                 `agent alive; this mail is lost (ackTo=${envelope.ackTo})`);
         }
-        // Assigned rows only: the server's bury-guard checks what was MINE to
-        // handle. Ambient rows slide past the cursor unlisted — they were never
-        // this agent's to act on, and the owner's seen mark tracks them.
-        const handledResourceIds = [
-            ...new Set([
-                ...envelope.deliveries.filter(mine).map((d) => d.resourceId),
-                ...(envelope.openRequestsAwaitingMe ?? []).map((q) => q.agreementId),
-            ]),
-        ].filter((id) => typeof id === 'string' && id.length > 0);
-        await inbox.ack(envelope.ackTo, { handledResourceIds });
+        await inbox.ack(envelope.ackTo, { handledResourceIds: ack.handledResourceIds });
         acked = true;
         log(label, `acked up to ${envelope.ackTo}`);
     }
@@ -348,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;
 /**
@@ -394,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;
@@ -440,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;
@@ -478,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/tools/index.d.ts

@@ -24,6 +24,7 @@ export { CONNECTION_TOOLS, connectionProxyTool, connectionListGrantsTool, reques
 export { CONTEXT_TOOLS, contextReadTool, contextDelegateTool, contextExpandReachTool, contextDiscoverGrantableTool, } from './tier2/contextTools.js';
 export { GRANTS_TOOLS, listGrantsTool } from './tier2/grantsTools.js';
 export { TASK_TOOLS, listTasksTool } 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

@@ -28,6 +28,7 @@ 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';
 export { TASK_TOOLS, listTasksTool } 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/tier2/contextTools.d.ts

@@ -1,5 +1,7 @@
 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 contextDelegateTool: ToolDefinition;
 export declare const contextExpandReachTool: ToolDefinition;
 export declare const contextDiscoverGrantableTool: ToolDefinition;

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

@@ -1,9 +1,11 @@
-import { CONTEXT_CAPABILITIES, contextReadCapability, contextDelegateCapability, contextExpandReachCapability, contextDiscoverGrantableCapability, } from '@ziggs-ai/api-client';
+import { CONTEXT_CAPABILITIES, contextReadCapability, openCapability, accessExplainCapability, contextDelegateCapability, contextExpandReachCapability, contextDiscoverGrantableCapability, } 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 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/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;