@ziggs-ai/ziggs-mcp 0.9.0 → 0.9.2

package/dist/inboxToolResult.js

@@ -253,9 +253,10 @@ self = { agentId: '' }) {
     // ZIG-659: the inbox reports session-start counts and points to
     // ziggs_pending_decisions for the sessionChatCard — it no longer re-emits the
     // cards, so a session start doesn't ship the same card ~6× across tools.
+    // ZIG-1120: omit `activeTasks` so counts come from inbox.tasksAwaitingMe —
+    // callers that still pass an array (or []) keep the listTasks-derived path.
     const pending = formatPendingDecisionsPayload(inbox, origin, self, {
-        activeTasks,
-        activeTasksError,
+        ...(activeTasks !== undefined ? { activeTasks, activeTasksError } : {}),
         withSessionCard: false,
     });
     const pendingTail = pending.hasActionable === true

package/dist/pendingDecisions.d.ts

@@ -1,4 +1,4 @@
-import { type InboxEnvelope, type Task } from '@ziggs-ai/api-client';
+import { type InboxEnvelope, type InboxTaskRef, type Task } from '@ziggs-ai/api-client';
 /**
  * The two ids this delegate answers for, in the order authority is checked:
  * its own agent id (what the credential impersonates, and the only slot it can
@@ -26,17 +26,23 @@ export interface PendingDecisionItem {
     proposedAt: string | null;
     proposedAtLabel: string | null;
     appUrl: string;
-    respondableBy: DecisionResponder;
     /**
-     * The MCP tool call the agent runs on approval — null when the decision is
-     * the human's, because offering a tool that always 403s is what sent agents
-     * into retry loops.
+     * ZIG-1171 / ZIG-1087 — the one bit that used to be five parallel fields
+     * (`respondableBy` + four null/non-null tool/say strings). Card and next-
+     * action copy derive the agent cues from this alone.
+     *
+     * `agent` — the pending slot is this delegate's own; ziggs_agreement_respond works.
+     * `human` — the slot belongs to the principal; no tool on this surface can give it.
      */
-    respondApprove: string | null;
-    respondReject: string | null;
-    sayApprove: string | null;
-    sayReject: string | null;
+    respondableBy: DecisionResponder;
 }
+/** Chat/tool cues when {@link PendingDecisionItem.respondableBy} is `agent`. */
+export declare function decisionRespondCues(item: PendingDecisionItem): {
+    sayApprove: string;
+    sayReject: string;
+    toolApprove: string;
+    toolReject: string;
+} | null;
 export interface ActiveWorkItem {
     taskId: string;
     agreementId: string | null;
@@ -99,6 +105,13 @@ export declare function buildPaymentApprovalItems(approvals: Array<Record<string
  */
 export declare function filterTasksForDelegate(tasks: Task[], selfIds: ReadonlySet<string>): Task[];
 export declare function buildActiveWorkItems(tasks: Task[], webOrigin: string): ActiveWorkItem[];
+/**
+ * ZIG-1120: inbox already carries `tasksAwaitingMe` — the open-task work
+ * channel. Use that for counts/cards when the caller did not round-trip
+ * `listTasks` (ziggs_inbox). Plan progress is absent on the ref; pending_decisions
+ * still fetches full Task rows when it needs the richer card.
+ */
+export declare function buildActiveWorkItemsFromInbox(refs: InboxTaskRef[], webOrigin: string): ActiveWorkItem[];
 /**
  * Combined card: approve/reject + active tasks (what humans actually need at
  * session start). ZIG-659: this is the ONE card shipped per session start —
@@ -113,6 +126,11 @@ export declare function buildSessionChatCard(decisions: PendingDecisionItem[], w
 }): string;
 /** Structured session payload for MCP tools (ZIG-625 + active work). */
 export declare function formatPendingDecisionsPayload(inbox: InboxEnvelope, webOrigin: string, self: DecisionSelfIds, opts?: {
+    /**
+     * Full Task rows from `listTasks`. Omit (undefined) to derive active work
+     * from `inbox.tasksAwaitingMe` instead (ZIG-1120 — ziggs_inbox). Pass `[]`
+     * when the list fetch ran and returned nothing.
+     */
     activeTasks?: Task[];
     activeTasksError?: string;
     /**

package/dist/pendingDecisions.js

@@ -1,4 +1,17 @@
 import { resolvePendingApprovalPartyId, } from '@ziggs-ai/api-client';
+/** Chat/tool cues when {@link PendingDecisionItem.respondableBy} is `agent`. */
+export function decisionRespondCues(item) {
+    if (item.respondableBy !== 'agent')
+        return null;
+    const id = item.agreementId;
+    const link = item.kind === 'link_request';
+    return {
+        sayApprove: link ? `approve link ${id}` : `approve ${id}`,
+        sayReject: link ? `reject link ${id}` : `reject ${id}`,
+        toolApprove: `ziggs_agreement_respond agreementId=${id} action=approve`,
+        toolReject: `ziggs_agreement_respond agreementId=${id} action=reject`,
+    };
+}
 const TITLE_MAX = 72;
 const ACTIVE_TASK_LIMIT = 20;
 /**
@@ -58,26 +71,15 @@ function planProgress(plan) {
     const done = steps.filter((s) => s.status === 'completed' || s.status === 'skipped').length;
     return { done, total };
 }
-function proposalToItem(p, origin, self) {
-    const id = p.agreementId;
-    // The inbox lists proposals awaiting EITHER of our ids, so ask which one.
+/** Whose pending slot is this — agent may answer only when the slot is its own. */
+function respondableByFor(facts, self) {
+    // The inbox lists decisions awaiting EITHER of our ids, so ask which one.
     // Agent id first: when both owe a decision, ours is the one we can act on.
-    const slot = resolvePendingApprovalPartyId({ pendingPartyIds: p.pendingApprovalPartyIds ?? [], proposedTo: p.proposedTo }, [self.agentId, self.ownerUserId]);
-    const mine = slot != null && slot === self.agentId;
-    return {
-        kind: 'proposal',
-        agreementId: id,
-        title: displayTitle(p.title?.trim() || '(untitled proposal)'),
-        subtitle: null,
-        proposedAt: p.proposedAt,
-        proposedAtLabel: formatWhen(p.proposedAt),
-        appUrl: agreementAppUrl(origin, id),
-        respondableBy: mine ? 'agent' : 'human',
-        respondApprove: mine ? `ziggs_agreement_respond agreementId=${id} action=approve` : null,
-        respondReject: mine ? `ziggs_agreement_respond agreementId=${id} action=reject` : null,
-        sayApprove: mine ? `approve ${id}` : null,
-        sayReject: mine ? `reject ${id}` : null,
-    };
+    const slot = resolvePendingApprovalPartyId({
+        pendingPartyIds: facts.pendingApprovalPartyIds ?? [],
+        proposedTo: facts.proposedTo,
+    }, [self.agentId, self.ownerUserId]);
+    return slot != null && slot === self.agentId ? 'agent' : 'human';
 }
 function linkRequesterHeadline(c) {
     // ZIG-1039: consent cards lead with a readable name + org; ZIG-1137: ref is
@@ -90,15 +92,34 @@ function linkRequesterHeadline(c) {
         return name;
     return c.requesterRef;
 }
+/** ZIG-1171 — one builder for proposal / link_request decision items. */
+function decisionToItem(kind, id, fields, origin, self) {
+    return {
+        kind,
+        agreementId: id,
+        title: fields.title,
+        subtitle: fields.subtitle,
+        proposedAt: fields.proposedAt,
+        proposedAtLabel: formatWhen(fields.proposedAt),
+        appUrl: agreementAppUrl(origin, id),
+        respondableBy: respondableByFor(fields.facts, self),
+    };
+}
+function proposalToItem(p, origin, self) {
+    return decisionToItem('proposal', p.agreementId, {
+        title: displayTitle(p.title?.trim() || '(untitled proposal)'),
+        subtitle: null,
+        proposedAt: p.proposedAt,
+        facts: {
+            pendingApprovalPartyIds: p.pendingApprovalPartyIds,
+            proposedTo: p.proposedTo,
+        },
+    }, origin, self);
+}
 function linkToItem(c, origin, self) {
-    const id = c.requestId;
     const note = c.message?.trim() || null;
     const headline = linkRequesterHeadline(c);
-    const slot = resolvePendingApprovalPartyId({ pendingPartyIds: c.pendingApprovalPartyIds ?? [], proposedTo: c.proposedTo }, [self.agentId, self.ownerUserId]);
-    const mine = slot != null && slot === self.agentId;
-    return {
-        kind: 'link_request',
-        agreementId: id,
+    return decisionToItem('link_request', c.requestId, {
         title: truncateText(`Agent link · ${headline}`),
         subtitle: note
             ? truncateText(note, 96)
@@ -106,14 +127,11 @@ function linkToItem(c, origin, self) {
                 ? truncateText(`ref: ${c.requesterRef}`, 96)
                 : null,
         proposedAt: c.requestedAt,
-        proposedAtLabel: formatWhen(c.requestedAt),
-        appUrl: agreementAppUrl(origin, id),
-        respondableBy: mine ? 'agent' : 'human',
-        respondApprove: mine ? `ziggs_agreement_respond agreementId=${id} action=approve` : null,
-        respondReject: mine ? `ziggs_agreement_respond agreementId=${id} action=reject` : null,
-        sayApprove: mine ? `approve link ${id}` : null,
-        sayReject: mine ? `reject link ${id}` : null,
-    };
+        facts: {
+            pendingApprovalPartyIds: c.pendingApprovalPartyIds,
+            proposedTo: c.proposedTo,
+        },
+    }, origin, self);
 }
 export function buildPendingDecisionItems(inbox, webOrigin, self) {
     const items = [];
@@ -191,6 +209,30 @@ export function buildActiveWorkItems(tasks, webOrigin) {
         };
     });
 }
+/**
+ * ZIG-1120: inbox already carries `tasksAwaitingMe` — the open-task work
+ * channel. Use that for counts/cards when the caller did not round-trip
+ * `listTasks` (ziggs_inbox). Plan progress is absent on the ref; pending_decisions
+ * still fetches full Task rows when it needs the richer card.
+ */
+export function buildActiveWorkItemsFromInbox(refs, webOrigin) {
+    return refs
+        .filter((t) => !t.state || t.state === 'active')
+        .slice(0, ACTIVE_TASK_LIMIT)
+        .map((t) => {
+        const agreementId = t.agreementId?.trim() || null;
+        return {
+            taskId: t.taskId,
+            agreementId,
+            title: displayTitle(t.title?.trim() || '(untitled task)'),
+            state: t.state || 'active',
+            planDone: 0,
+            planTotal: 0,
+            appUrl: agreementId ? agreementAppUrl(webOrigin, agreementId) : null,
+            sayWork: `work on ${t.taskId}`,
+        };
+    });
+}
 function kindLabel(kind) {
     if (kind === 'proposal')
         return 'Agreement proposal';
@@ -228,11 +270,12 @@ function buildDecisionSection(items, opts) {
         lines.push('');
         lines.push(`[Review in Ziggs →](${item.appUrl})`);
         lines.push('');
-        if (item.sayApprove && item.respondApprove && item.sayReject && item.respondReject) {
+        const cues = decisionRespondCues(item);
+        if (cues) {
             lines.push('| You say in chat | What the agent runs |');
             lines.push('|:----------------|:--------------------|');
-            lines.push(`| \`${item.sayApprove}\` | \`${item.respondApprove}\` |`);
-            lines.push(`| \`${item.sayReject}\` | \`${item.respondReject}\` |`);
+            lines.push(`| \`${cues.sayApprove}\` | \`${cues.toolApprove}\` |`);
+            lines.push(`| \`${cues.sayReject}\` | \`${cues.toolReject}\` |`);
         }
         else {
             // ZIG-1087 — this one is bound to the human's own party slot. Saying so
@@ -374,7 +417,9 @@ export function buildSessionChatCard(decisions, work, opts) {
 export function formatPendingDecisionsPayload(inbox, webOrigin, self, opts) {
     const withSessionCard = opts?.withSessionCard !== false;
     const decisions = buildPendingDecisionItems(inbox, webOrigin, self);
-    const activeWork = buildActiveWorkItems(opts?.activeTasks ?? [], webOrigin);
+    const activeWork = opts?.activeTasks !== undefined
+        ? buildActiveWorkItems(opts.activeTasks, webOrigin)
+        : buildActiveWorkItemsFromInbox(inbox.tasksAwaitingMe ?? [], webOrigin);
     const paymentApprovals = buildPaymentApprovalItems(opts?.paymentApprovals ?? [], webOrigin);
     const truncatedProposals = inbox.truncatedProposals ?? 0;
     const truncatedConnectionRequests = inbox.truncatedConnectionRequests ?? 0;
@@ -470,8 +515,9 @@ export function buildPendingNextActions(decisions, work = []) {
         actions.push('Wait for the human to say approve/reject (e.g. `approve agr-…`) — do not auto-respond.');
     }
     for (const d of decisions.slice(0, 4)) {
-        if (d.sayApprove && d.sayReject) {
-            actions.push(`${kindLabel(d.kind)} ${d.agreementId}: \`${d.sayApprove}\` or \`${d.sayReject}\``);
+        const cues = decisionRespondCues(d);
+        if (cues) {
+            actions.push(`${kindLabel(d.kind)} ${d.agreementId}: \`${cues.sayApprove}\` or \`${cues.sayReject}\``);
         }
         else {
             actions.push(`${kindLabel(d.kind)} ${d.agreementId}: waiting on the human's own approval — they decide it at ${d.appUrl}; ziggs_agreement_respond cannot.`);

package/dist/toolError.d.ts

@@ -1,26 +1,26 @@
 /**
  * ZIG-667 — one error surface for every MCP tool.
  *
- * Raw client exceptions read like
- *   `ContextReadClient.read messages 403 {"error":"not authorized for this scope"}`
- * — an internal class.method name, a raw HTTP status, and a raw backend body.
- * LLM callers stall on stack-trace prose; they recover from errors they can
- * parse. This module strips the internals, keeps a stable machine-readable
- * code, and for authorization denials says what to do next.
+ * ZIG-1124 — classify from the thrown {@link ApiError} fields (`status`,
+ * `code`, `body` / `message`). No client-prefix strip, no HTTP-status regex,
+ * no re-parsing a JSON body that was concatenated into the message string.
  */
 export interface ToolErrorShape {
     code: string;
     message: string;
     hint?: string;
 }
-/** Classify a raw client error message into a stable shape. */
-export declare function classifyToolError(rawMessage: string, knownStatus?: number | null): ToolErrorShape;
+/**
+ * Classify a thrown client error (or a plain string this layer raised) into a
+ * stable MCP shape.
+ */
+export declare function classifyToolError(input: unknown): ToolErrorShape;
 /**
  * MCP tool error result: machine-readable code + cleaned message (+ hint).
  *
  * Pass the caught error itself, not `err.message` — an `ApiError` carries the
- * HTTP status that decides the code and the hint (ZIG-1086). A plain string is
- * still accepted for refusals this layer raises on its own.
+ * HTTP status and server `code` that decide the hint (ZIG-1086 / ZIG-1124).
+ * A plain string is still accepted for refusals this layer raises on its own.
  */
 export declare function toolError(input: unknown): {
     content: {

package/dist/toolError.js

@@ -1,15 +1,10 @@
 /**
  * ZIG-667 — one error surface for every MCP tool.
  *
- * Raw client exceptions read like
- *   `ContextReadClient.read messages 403 {"error":"not authorized for this scope"}`
- * — an internal class.method name, a raw HTTP status, and a raw backend body.
- * LLM callers stall on stack-trace prose; they recover from errors they can
- * parse. This module strips the internals, keeps a stable machine-readable
- * code, and for authorization denials says what to do next.
+ * ZIG-1124 — classify from the thrown {@link ApiError} fields (`status`,
+ * `code`, `body` / `message`). No client-prefix strip, no HTTP-status regex,
+ * no re-parsing a JSON body that was concatenated into the message string.
  */
-const CLIENT_PREFIX = /^[A-Z][A-Za-z0-9]*Client\.[A-Za-z0-9_]+\s+/;
-const HTTP_STATUS = /(?:^|\s)([1-5]\d{2})(?=\s|$)/;
 const SCOPE_DENIED_HINT = 'You are not authorized for this scope. To get access: ask the counterparty ' +
     'to issue you a context grant (they run ziggs_context_issue_grant), or propose a ' +
     'bilateral link first (ziggs_agreement_propose with engagementKind "link"). Check what you can already ' +
@@ -39,51 +34,52 @@ function codeForStatus(status) {
         return 'BAD_REQUEST';
     return 'TOOL_ERROR';
 }
-/** Pull a human reason out of an embedded backend JSON body, if any. */
-function extractBodyReason(raw) {
-    const start = raw.indexOf('{');
-    if (start === -1)
-        return null;
-    try {
-        const parsed = JSON.parse(raw.slice(start));
-        const reason = parsed['error'] ?? parsed['message'];
-        return typeof reason === 'string' && reason.trim() ? reason.trim() : null;
-    }
-    catch {
-        return null;
-    }
-}
 /**
  * An `ApiError` from api-client, recognised by shape rather than `instanceof`:
  * a bundled or duplicated copy of the class would fail an identity check while
  * carrying exactly the fields we need.
  */
-function thrownStatus(err) {
-    if (typeof err !== 'object' || err === null)
-        return null;
-    const status = err.status;
-    return typeof status === 'number' && status >= 100 && status < 600 ? status : null;
+function thrownFields(err) {
+    if (typeof err === 'string') {
+        return { message: err, status: null, code: null };
+    }
+    if (typeof err !== 'object' || err === null) {
+        return { message: String(err), status: null, code: null };
+    }
+    const o = err;
+    const status = typeof o.status === 'number' && o.status >= 100 && o.status < 600
+        ? o.status
+        : null;
+    const code = typeof o.code === 'string' && o.code ? o.code : null;
+    const message = typeof o.message === 'string' && o.message ? o.message : String(err);
+    return { message, status, code };
 }
-/** Classify a raw client error message into a stable shape. */
-export function classifyToolError(rawMessage, knownStatus) {
-    const cleaned = rawMessage.replace(CLIENT_PREFIX, '').trim();
-    // ZIG-1086: the status is scraped from the message only as a LAST resort.
-    // `ApiError` carries it as a real field, and every caller that dropped it
-    // (passing `err.message` instead of `err`) landed here with nothing to match:
-    // "missing scope: context:admin" has no digits, so it fell through to a bare
-    // TOOL_ERROR and the agent never saw the recovery hint it needed.
-    const statusMatch = HTTP_STATUS.exec(cleaned);
-    const status = knownStatus ?? (statusMatch ? Number(statusMatch[1]) : null);
-    const bodyReason = extractBodyReason(cleaned);
+/**
+ * Classify a thrown client error (or a plain string this layer raised) into a
+ * stable MCP shape.
+ */
+export function classifyToolError(input) {
+    const { message, status, code: machineCode } = thrownFields(input);
+    if (machineCode === 'AGENT_LACKS_HUMAN_AUTHORITY') {
+        return {
+            code: 'AGENT_LACKS_HUMAN_AUTHORITY',
+            message,
+            hint: HUMAN_AUTHORITY_HINT,
+        };
+    }
+    if (machineCode === 'NOT_AUTHORIZED_FOR_SCOPE') {
+        return {
+            code: 'NOT_AUTHORIZED_FOR_SCOPE',
+            message,
+            hint: SCOPE_DENIED_HINT,
+        };
+    }
     if (status === null) {
-        return { code: 'TOOL_ERROR', message: cleaned || rawMessage };
+        return { code: 'TOOL_ERROR', message };
     }
     const code = codeForStatus(status);
-    // Prefer the backend's own reason over the transport framing.
-    const message = bodyReason ?? cleaned;
-    // The human-authority guard refuses every impersonated agent, whatever it
-    // asked for. Checked before the scope branch below: its message also mentions
-    // scopes, and "ask for a grant on this scope" is the wrong advice here.
+    // Backend human-authority already sends AGENT_LACKS_HUMAN_AUTHORITY; keep a
+    // message fallback for older bodies / tests that omit `code`.
     if (code === 'NOT_AUTHORIZED' && /impersonated agent cannot perform/i.test(message)) {
         return {
             code: 'AGENT_LACKS_HUMAN_AUTHORITY',
@@ -91,9 +87,8 @@ export function classifyToolError(rawMessage, knownStatus) {
             hint: HUMAN_AUTHORITY_HINT,
         };
     }
-    // Context-scope denials (the backend says "…for this scope") get the scope
-    // code and a recovery path. Other 403s (connection grants, party checks)
-    // keep the generic code — their fixes live in other domains.
+    // Many scope denials still throw a bare ForbiddenException string with no
+    // machine code — classify those by the word "scope" in the message.
     if (code === 'NOT_AUTHORIZED' && /\bscope\b/i.test(message)) {
         return {
             code: 'NOT_AUTHORIZED_FOR_SCOPE',
@@ -107,14 +102,11 @@ export function classifyToolError(rawMessage, knownStatus) {
  * MCP tool error result: machine-readable code + cleaned message (+ hint).
  *
  * Pass the caught error itself, not `err.message` — an `ApiError` carries the
- * HTTP status that decides the code and the hint (ZIG-1086). A plain string is
- * still accepted for refusals this layer raises on its own.
+ * HTTP status and server `code` that decide the hint (ZIG-1086 / ZIG-1124).
+ * A plain string is still accepted for refusals this layer raises on its own.
  */
 export function toolError(input) {
-    const message = typeof input === 'string'
-        ? input
-        : (input?.message ?? String(input));
-    const shape = classifyToolError(String(message), thrownStatus(input));
+    const shape = classifyToolError(input);
     return {
         content: [
             { type: 'text', text: JSON.stringify({ error: shape }, null, 2) },

package/dist/tools.js

@@ -1,6 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { z } from 'zod';
-import { getAgreement, getMyAgreements, listMyChats, proposeUnified, delegateAgreement, provisionRelayWorkers, respondToAgreement, revokeAgreement, counterAgreement, fulfillAgreement, sendChatMessage, ConnectionsClient, PaymentsClient, ContextReadClient, GrantsClient, InboxClient, createTask, updateTaskState, replaceTaskPlan, listTasks, getTask, getBackendUrl, fetchMyOrgs, fetchDelegateAccess, GRANTS_CAPABILITIES, CONTEXT_GRANT_SCOPE_KINDS, contextReadCapability, contextExpandReachCapability, contextDiscoverGrantableCapability, recordArtifactCapability, listArtifactsCapability, shareArtifactCapability, attachArtifactCapability, openConversationCapability, connectionProxyCapability, requestConnectionCapability, agreementClaimCapability, marketplaceViewCapability, linkSummary, } from '@ziggs-ai/api-client';
+import { getAgreement, getMyAgreements, listMyChats, proposeUnified, delegateAgreement, provisionRelayWorkers, respondToAgreement, revokeAgreement, counterAgreement, fulfillAgreement, sendChatMessage, ConnectionsClient, PaymentsClient, ContextReadClient, GrantsClient, InboxClient, createTask, updateTaskState, replaceTaskPlan, listTasks, getTask, getBackendUrl, fetchMyOrgs, fetchDelegateAccess, GRANTS_CAPABILITIES, CONTEXT_GRANT_SCOPE_KINDS, contextReadCapability, contextExpandReachCapability, contextDiscoverGrantableCapability, recordArtifactCapability, listArtifactsCapability, shareArtifactCapability, attachArtifactCapability, openConversationCapability, connectionProxyCapability, requestConnectionCapability, agreementClaimCapability, marketplaceViewCapability, } from '@ziggs-ai/api-client';
 import { decodeOperatorKeyClaims } from './operatorKey.js';
 import { registerTrustTools } from './trustTools.js';
 import { registerPaymentTools } from './paymentTools.js';
@@ -81,27 +81,37 @@ function delegateSelfIds(creds, cfg) {
 async function loadSessionActionsPayload(creds, cfg, opts) {
     const webOrigin = resolveWebAppOrigin(cfg.ZIGGS_WEB_URL);
     const client = new InboxClient(creds.operatorKey, creds.agentId);
-    const inbox = await client.getInbox();
+    // ZIG-1120 #4 — inbox / tasks / payments are independent; overlap them.
+    const [inboxSettled, tasksSettled, paymentsSettled] = await Promise.allSettled([
+        client.getInbox(),
+        listTasks({ state: 'active', limit: 20 }, creds),
+        new PaymentsClient(creds.operatorKey, creds.agentId).approvals({
+            status: 'pending',
+        }),
+    ]);
+    if (inboxSettled.status === 'rejected') {
+        throw inboxSettled.reason;
+    }
+    const inbox = inboxSettled.value;
     let activeTasks = [];
     let activeTasksError;
-    try {
-        const listed = await listTasks({ state: 'active', limit: 20 }, creds);
-        activeTasks = filterTasksForDelegate(listed.tasks ?? [], delegateSelfIds(creds, cfg));
+    if (tasksSettled.status === 'fulfilled') {
+        activeTasks = filterTasksForDelegate(tasksSettled.value.tasks ?? [], delegateSelfIds(creds, cfg));
     }
-    catch (e) {
+    else {
         // ZIG-700 — inbox is still useful when task listing fails, but surface the
         // failure so hasActiveWork:false is not mistaken for "no tasks".
-        activeTasksError = e.message;
+        activeTasksError = tasksSettled.reason.message;
     }
     // ZIG-896 — paused transfers awaiting the wallet owner. Same failure rule as
     // tasks: a failed fetch is surfaced, not silently rendered as "none pending".
     let paymentApprovals = [];
     let paymentApprovalsError;
-    try {
-        paymentApprovals = (await new PaymentsClient(creds.operatorKey, creds.agentId).approvals({ status: 'pending' }));
+    if (paymentsSettled.status === 'fulfilled') {
+        paymentApprovals = paymentsSettled.value;
     }
-    catch (e) {
-        paymentApprovalsError = e.message;
+    else {
+        paymentApprovalsError = paymentsSettled.reason.message;
     }
     return formatPendingDecisionsPayload(inbox, webOrigin, {
         agentId: creds.agentId,
@@ -195,13 +205,20 @@ export function registerZiggsTools(server, creds, cfg) {
     server.tool('ziggs_auth_status', 'Verify MCP OAuth binding: delegate agent id, owner user id, and org scope. Call after connect before inbox/chats. Includes pendingDecisions summary when approve/reject is waiting. ("Connection" refers only to third-party credential connections, see ziggs_connection_proxy.)', {}, READ_ONLY, async () => {
         const claims = decodeOperatorKeyClaims(creds.operatorKey);
         const webOrigin = resolveWebAppOrigin(cfg.ZIGGS_WEB_URL);
+        // ZIG-1120 #4 — delegate access and session actions are independent.
+        const [accessSettled, pendingSettled] = await Promise.allSettled([
+            fetchDelegateAccess(creds),
+            // ZIG-659: counts + a pointer only — the full sessionChatCard is owned
+            // by ziggs_pending_decisions, not duplicated here.
+            loadSessionActionsPayload(creds, cfg, { withSessionCard: false }),
+        ]);
         let actingOrgId = null;
         let actingOrgName = null;
         let actingOrgKind = null;
         let connected = false;
         let switchOrgHint = null;
-        try {
-            const access = await fetchDelegateAccess(creds);
+        if (accessSettled.status === 'fulfilled') {
+            const access = accessSettled.value;
             actingOrgId = typeof access.orgId === 'string' ? access.orgId : null;
             actingOrgName = typeof access.orgName === 'string' ? access.orgName : null;
             actingOrgKind = typeof access.orgKind === 'string' ? access.orgKind : null;
@@ -209,8 +226,8 @@ export function registerZiggsTools(server, creds, cfg) {
             switchOrgHint =
                 typeof access.switchOrgHint === 'string' ? access.switchOrgHint : null;
         }
-        catch (e) {
-            switchOrgHint = `Could not load runtime org: ${e.message}`;
+        else {
+            switchOrgHint = `Could not load runtime org: ${accessSettled.reason.message}`;
         }
         let pendingDecisions = {
             pendingCount: 0,
@@ -220,14 +237,10 @@ export function registerZiggsTools(server, creds, cfg) {
             actionCount: 0,
             hasActionable: false,
         };
-        try {
-            // ZIG-659: counts + a pointer only — the full sessionChatCard is owned
-            // by ziggs_pending_decisions, not duplicated here.
-            pendingDecisions = await loadSessionActionsPayload(creds, cfg, {
-                withSessionCard: false,
-            });
+        if (pendingSettled.status === 'fulfilled') {
+            pendingDecisions = pendingSettled.value;
         }
-        catch {
+        else {
             pendingDecisions = {
                 ...pendingDecisions,
                 fetchError: 'Could not load inbox/tasks — call ziggs_pending_decisions.',
@@ -466,8 +479,6 @@ export function registerZiggsTools(server, creds, cfg) {
                 lifecycle,
                 billing,
             }, creds);
-            // ZIG-957: link mutations return linkSummary, not the raw Mongo doc.
-            const agreementOut = shape === 'link' && agreement ? linkSummary(agreement) : agreement;
             // ZIG-1039: surface the owner-routing rewrite so agents do not think
             // the id they passed was ignored silently.
             const routedProposedTo = shape === 'link' &&
@@ -478,7 +489,7 @@ export function registerZiggsTools(server, creds, cfg) {
                 : undefined;
             return textResult({
                 shape,
-                agreement: agreementOut,
+                agreement,
                 ...(routedProposedTo ? { note: routedProposedTo } : {}),
                 ...(shape === 'quest' || shape === 'offer'
                     ? {
@@ -542,9 +553,7 @@ export function registerZiggsTools(server, creds, cfg) {
                 // So a refusal can name where the human goes, not just why.
                 appUrl: agreementAppUrl(resolveWebAppOrigin(cfg.ZIGGS_WEB_URL), agreementId),
             });
-            // ZIG-957: link approvals/rejects share the same summary shape as claim/revoke.
-            const agreement = updated?.engagementKind === 'link' ? linkSummary(updated) : updated;
-            return textResult({ agreement });
+            return textResult({ agreement: updated });
         }
         catch (e) {
             return toolError(e);
@@ -556,17 +565,13 @@ export function registerZiggsTools(server, creds, cfg) {
         try {
             const result = await revokeAgreement(agreementId, creds);
             const isLink = result.agreement?.engagementKind === 'link';
-            // ZIG-957: same summary shape as create/list/claim link tools (not the raw Mongo doc).
-            const agreement = result.agreement
-                ? (isLink ? linkSummary(result.agreement) : result.agreement)
-                : undefined;
             return textResult({
                 status: 'revoked',
                 agreementId,
                 ...(isLink
                     ? { note: 'Link revoked — unpublished cross-org reach to this peer is blocked again.' }
                     : {}),
-                agreement,
+                agreement: result.agreement,
             });
         }
         catch (e) {
@@ -625,35 +630,33 @@ export function registerZiggsTools(server, creds, cfg) {
     }, READ_ONLY, async ({ ack, waitSeconds }) => {
         try {
             const client = new InboxClient(creds.operatorKey, creds.agentId);
+            // Ack-before-fetch is load-bearing; everything else is independent of
+            // the envelope until we know whether there are deliveries to tag.
             const acked = ack ? await client.ack(ack) : null;
             const inbox = await client.getInbox(waitSeconds != null ? { waitSeconds } : {});
-            let activeTasks = [];
-            let activeTasksError;
-            try {
-                const listed = await listTasks({ state: 'active', limit: 20 }, creds);
-                activeTasks = filterTasksForDelegate(listed.tasks ?? [], delegateSelfIds(creds, cfg));
-            }
-            catch (e) {
-                // ZIG-700 — surface the failure instead of silently omitting the work card.
-                activeTasksError = e.message;
-            }
-            // ZIG-635: tag each scope with the covering grant from the caller's own
-            // held context grants. Best-effort — the inbox still works untagged.
-            // All pages of live grants only (GET /grants also returns expired/revoked
-            // and paginates), so a scope isn't left untagged behind the first page.
+            // ZIG-1120 #2+#3: activeWorkCount comes from inbox.tasksAwaitingMe
+            // (formatInboxToolResult omits listTasks). Grant walk is only for
+            // readPlan pinning and is unused when deliveries is empty — the idle
+            // long-poll outcome — so skip it there (artifact grants grow unbounded).
             let reach = [];
-            try {
-                reach = await new GrantsClient(creds.operatorKey, creds.agentId).listAllGrants({
-                    // Every context scope kind — a literal subset here is how the CLI
-                    // silently dropped a whole kind when `artifact` was added.
-                    scopeKind: [...CONTEXT_GRANT_SCOPE_KINDS],
-                    health: 'active',
-                });
-            }
-            catch {
-                // omit grant tags when the grants read fails
+            if ((inbox.deliveries?.length ?? 0) > 0) {
+                try {
+                    // ZIG-635: tag each scope with the covering grant from the caller's
+                    // own held context grants. Best-effort — the inbox still works
+                    // untagged. All pages of live grants only (GET /grants also returns
+                    // expired/revoked and paginates).
+                    reach = await new GrantsClient(creds.operatorKey, creds.agentId).listAllGrants({
+                        // Every context scope kind — a literal subset here is how the CLI
+                        // silently dropped a whole kind when `artifact` was added.
+                        scopeKind: [...CONTEXT_GRANT_SCOPE_KINDS],
+                        health: 'active',
+                    });
+                }
+                catch {
+                    // omit grant tags when the grants read fails
+                }
             }
-            return textResult(formatInboxToolResult(inbox, acked, cfg.ZIGGS_WEB_URL, activeTasks, reach, activeTasksError, { agentId: creds.agentId, ownerUserId: ownerPrincipalId(creds, cfg) }));
+            return textResult(formatInboxToolResult(inbox, acked, cfg.ZIGGS_WEB_URL, undefined, reach, undefined, { agentId: creds.agentId, ownerUserId: ownerPrincipalId(creds, cfg) }));
         }
         catch (e) {
             return toolError(e);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ziggs-ai/ziggs-mcp",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "MCP server for Claude Code, Cursor, and other MCP hosts \u2014 act as your Ziggs delegate agent",
   "type": "module",
   "bin": {
@@ -36,7 +36,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@ziggs-ai/api-client": "^0.9.0",
+    "@ziggs-ai/api-client": "^0.9.1",
     "dotenv": "^16.6.1",
     "zod": "^3.24.2"
   },