@ziggs-ai/ziggs-mcp 0.3.1 → 0.3.2

package/README.md

@@ -208,7 +208,7 @@ OP_KEY_A=... AGENT_A=... USER_B=... OP_KEY_B=... AGENT_B=... \
 | `ziggs_revoke_agreement` | `DELETE /agreements/:id` — any agreement (hire/service/quest/link) |
 | `ziggs_smoke_impersonation` | [Internal/debug] connectivity check — only when `ZIGGS_MCP_DEBUG=1`; not part of normal delegate workflow |
 | `ziggs_context_snapshot` | `GET /context/snapshot?via=chat:` — one-shot chat orientation (history + agreements + roster), grant-fenced |
-| `ziggs_list_my_agreements` | `GET /agreements?scope=mine` |
+| `ziggs_list_my_agreements` | `GET /agreements?scope=mine&partyOnly=true` — agreements you are a party to; `scope: "reachable"` drops `partyOnly` for every agreement your grant can read |
 | `ziggs_get_agreement` | `GET /agreements/:id` |
 | `ziggs_list_chats` | `GET /chats/mine` |
 | `ziggs_open_conversation` | `POST /chats` |

package/dist/config.d.ts

@@ -12,6 +12,12 @@ declare const envSchema: z.ZodObject<{
     ZIGGS_OWNER_USER_ID: z.ZodOptional<z.ZodString>;
     /** Set to 1/true/yes to register internal/debug-only MCP tools (ZIG-672). */
     ZIGGS_MCP_DEBUG: z.ZodOptional<z.ZodString>;
+    /**
+     * Set to 1/true/yes to register only the core everyday/session-start tools,
+     * skipping the heavy groups (payments, links, marketplace, connections) to
+     * cut cold-start deferred-loading (ZIG-941 #7). Unset = all tools register.
+     */
+    ZIGGS_MCP_CORE_ONLY: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     ZIGGS_OPERATOR_KEY: string;
     ZIGGS_API_URL?: string | undefined;
@@ -20,6 +26,7 @@ declare const envSchema: z.ZodObject<{
     ZIGGS_AGENT_ID?: string | undefined;
     ZIGGS_OWNER_USER_ID?: string | undefined;
     ZIGGS_MCP_DEBUG?: string | undefined;
+    ZIGGS_MCP_CORE_ONLY?: string | undefined;
 }, {
     ZIGGS_OPERATOR_KEY: string;
     ZIGGS_API_URL?: string | undefined;
@@ -28,6 +35,7 @@ declare const envSchema: z.ZodObject<{
     ZIGGS_AGENT_ID?: string | undefined;
     ZIGGS_OWNER_USER_ID?: string | undefined;
     ZIGGS_MCP_DEBUG?: string | undefined;
+    ZIGGS_MCP_CORE_ONLY?: string | undefined;
 }>;
 type EnvConfig = z.infer<typeof envSchema>;
 export interface ZiggsMcpConfig extends EnvConfig {
@@ -35,6 +43,11 @@ export interface ZiggsMcpConfig extends EnvConfig {
     resolvedAgentId: string;
     /** When true, register internal/debug-only tools such as ziggs_smoke_impersonation. */
     debugTools: boolean;
+    /**
+     * When true, register only the core everyday/session-start tool tier and skip
+     * the heavy groups (payments, links, marketplace, connections) — ZIG-941 #7.
+     */
+    coreOnly: boolean;
 }
 /** Load delegate credentials from the environment (ZIG-222 / ZIG-430). */
 export declare function loadConfig(): ZiggsMcpConfig;

package/dist/config.js

@@ -13,8 +13,15 @@ const envSchema = z.object({
     ZIGGS_OWNER_USER_ID: z.string().optional(),
     /** Set to 1/true/yes to register internal/debug-only MCP tools (ZIG-672). */
     ZIGGS_MCP_DEBUG: z.string().optional(),
+    /**
+     * Set to 1/true/yes to register only the core everyday/session-start tools,
+     * skipping the heavy groups (payments, links, marketplace, connections) to
+     * cut cold-start deferred-loading (ZIG-941 #7). Unset = all tools register.
+     */
+    ZIGGS_MCP_CORE_ONLY: z.string().optional(),
 });
-function parseDebugToolsFlag(raw) {
+/** Parse a truthy env flag (1/true/yes) — shared by ZIGGS_MCP_DEBUG and ZIGGS_MCP_CORE_ONLY. */
+function parseBoolFlag(raw) {
     if (!raw)
         return false;
     const v = raw.trim().toLowerCase();
@@ -30,6 +37,7 @@ export function loadConfig() {
         ZIGGS_AGENT_ID: process.env.ZIGGS_AGENT_ID,
         ZIGGS_OWNER_USER_ID: process.env.ZIGGS_OWNER_USER_ID,
         ZIGGS_MCP_DEBUG: process.env.ZIGGS_MCP_DEBUG,
+        ZIGGS_MCP_CORE_ONLY: process.env.ZIGGS_MCP_CORE_ONLY,
     };
     const parsed = envSchema.safeParse(raw);
     if (!parsed.success) {
@@ -49,6 +57,7 @@ export function loadConfig() {
     return {
         ...parsed.data,
         resolvedAgentId,
-        debugTools: parseDebugToolsFlag(parsed.data.ZIGGS_MCP_DEBUG),
+        debugTools: parseBoolFlag(parsed.data.ZIGGS_MCP_DEBUG),
+        coreOnly: parseBoolFlag(parsed.data.ZIGGS_MCP_CORE_ONLY),
     };
 }

package/dist/connectionCreds.js

@@ -24,6 +24,7 @@ export function connectionFromBearer(bearer, httpBaseUrl, ownerUserId) {
         ZIGGS_OWNER_USER_ID: ownerUserId,
         resolvedAgentId,
         debugTools: false,
+        coreOnly: false,
     };
     return {
         creds: { operatorKey: bearer, agentId: resolvedAgentId },

package/dist/orgs.d.ts

@@ -0,0 +1,28 @@
+import { type Creds } from '@ziggs-ai/api-client';
+export interface MyOrg {
+    orgId: string;
+    name: string;
+    kind: string;
+    role?: string;
+}
+/**
+ * ZIG-739 — the operator's full org membership (not just granted scopes, which
+ * is all ziggs_list_grants sees). Lets the delegate resolve an org name to
+ * an id and offer a pick-list instead of demanding a pasted org_... id.
+ */
+export declare function fetchMyOrgs(creds: Creds): Promise<MyOrg[]>;
+export type OrgResolution = {
+    status: 'ok';
+    orgId: string;
+} | {
+    status: 'ambiguous';
+    matches: MyOrg[];
+} | {
+    status: 'not-found';
+};
+/**
+ * ZIG-739 — resolve an org selector (exact org_... id OR a name/handle) against
+ * the operator's memberships. Exact id wins; otherwise case-insensitive name
+ * match. Ambiguous names return the candidates rather than guessing.
+ */
+export declare function resolveOrgSelector(orgs: MyOrg[], selector: string): OrgResolution;

package/dist/orgs.js

@@ -0,0 +1,44 @@
+import { getBackendUrl } from '@ziggs-ai/api-client';
+/**
+ * ZIG-739 — the operator's full org membership (not just granted scopes, which
+ * is all ziggs_list_grants sees). Lets the delegate resolve an org name to
+ * an id and offer a pick-list instead of demanding a pasted org_... id.
+ */
+export async function fetchMyOrgs(creds) {
+    const url = `${getBackendUrl()}/orgs/me`;
+    const res = await fetch(url, {
+        method: 'GET',
+        headers: {
+            Authorization: `Bearer ${creds.operatorKey}`,
+            'X-Agent-Id': creds.agentId,
+        },
+    });
+    const body = await res.text().catch(() => '');
+    if (!res.ok) {
+        throw new Error(`GET /orgs/me ${res.status} ${body.slice(0, 200)}`);
+    }
+    const parsed = body ? JSON.parse(body) : {};
+    return (parsed.orgs ?? []).map((o) => ({
+        orgId: o.orgId,
+        name: o.name,
+        kind: o.kind,
+        role: o.role,
+    }));
+}
+/**
+ * ZIG-739 — resolve an org selector (exact org_... id OR a name/handle) against
+ * the operator's memberships. Exact id wins; otherwise case-insensitive name
+ * match. Ambiguous names return the candidates rather than guessing.
+ */
+export function resolveOrgSelector(orgs, selector) {
+    const byId = orgs.find((o) => o.orgId === selector);
+    if (byId)
+        return { status: 'ok', orgId: byId.orgId };
+    const needle = selector.toLowerCase();
+    const byName = orgs.filter((o) => o.name.toLowerCase() === needle);
+    if (byName.length === 1)
+        return { status: 'ok', orgId: byName[0].orgId };
+    if (byName.length > 1)
+        return { status: 'ambiguous', matches: byName };
+    return { status: 'not-found' };
+}

package/dist/tools.js

@@ -2,6 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { z } from 'zod';
 import { getAgreement, getMyAgreements, listMyChats, openConversation, proposeDirectTo, proposeBroadcast, publishOffer, claimOffer, provisionRelayWorkers, respondToAgreement, revokeAgreement, counterAgreement, fulfillAgreement, sendChatMessage, ConnectionsClient, PaymentsClient, assertNoLeakedConnectionSecret, ContextDiscoveryClient, ContextReadClient, ContextGrantsClient, GrantsClient, unreadableGrantRails, InboxClient, createTask, updateTaskState, replaceTaskPlan, listTasks, getTask, getBackendUrl, ArtifactsClient, } from '@ziggs-ai/api-client';
 import { decodeOperatorKeyClaims } from './operatorKey.js';
+import { fetchMyOrgs } from './orgs.js';
 import { registerTrustTools } from './trustTools.js';
 import { registerPaymentTools } from './paymentTools.js';
 import { formatInboxToolResult, buildReadContextReadPlan, } from './inboxToolResult.js';
@@ -87,49 +88,6 @@ async function fetchDelegateAccess(creds) {
     }
     return body ? JSON.parse(body) : {};
 }
-/**
- * ZIG-739 — the operator's full org membership (not just granted scopes, which
- * is all ziggs_list_grants sees). Lets the delegate resolve an org name to
- * an id and offer a pick-list instead of demanding a pasted org_... id.
- */
-async function fetchMyOrgs(creds) {
-    const url = `${getBackendUrl()}/orgs/me`;
-    const res = await fetch(url, {
-        method: 'GET',
-        headers: {
-            Authorization: `Bearer ${creds.operatorKey}`,
-            'X-Agent-Id': creds.agentId,
-        },
-    });
-    const body = await res.text().catch(() => '');
-    if (!res.ok) {
-        throw new Error(`GET /orgs/me ${res.status} ${body.slice(0, 200)}`);
-    }
-    const parsed = body ? JSON.parse(body) : {};
-    return (parsed.orgs ?? []).map((o) => ({
-        orgId: o.orgId,
-        name: o.name,
-        kind: o.kind,
-        role: o.role,
-    }));
-}
-/**
- * ZIG-739 — resolve an org selector (exact org_... id OR a name/handle) against
- * the operator's memberships. Exact id wins; otherwise case-insensitive name
- * match. Ambiguous names return the candidates rather than guessing.
- */
-function resolveOrgSelector(orgs, selector) {
-    const byId = orgs.find((o) => o.orgId === selector);
-    if (byId)
-        return { status: 'ok', orgId: byId.orgId };
-    const needle = selector.toLowerCase();
-    const byName = orgs.filter((o) => o.name.toLowerCase() === needle);
-    if (byName.length === 1)
-        return { status: 'ok', orgId: byName[0].orgId };
-    if (byName.length > 1)
-        return { status: 'ambiguous', matches: byName };
-    return { status: 'not-found' };
-}
 /**
  * ZIG-641 / ZIG-648 — cross-connection discovery over the unified GET /grants:
  * every connection grant this agent holds, grouped by connection so
@@ -205,6 +163,188 @@ async function loadSessionActionsPayload(creds, cfg, opts) {
         withSessionCard: opts?.withSessionCard,
     });
 }
+// ZIG-941 #7 — heavy tool groups pulled out of registerZiggsTools so the
+// lean session-start tier (ZIGGS_MCP_CORE_ONLY) can skip registering them.
+// Registration is otherwise identical to the previous inline definitions.
+function registerMarketplaceTools(server, creds) {
+    server.tool('ziggs_publish_quest', 'Publish an open quest any agent can claim (buyer-broadcast): you are the buyer, and whoever claims it does the work. audience="everyone" (default) is fully public across all orgs; audience="org" scopes it to your active org — only agents in your org see it in marketplace feeds and may claim it. The payer is derived server-side as your side (the publisher); there is no payer input.', {
+        description: z.string(),
+        chatId: z.string().optional(),
+        price: z.number().optional(),
+        audience: z
+            .enum(['everyone', 'org'])
+            .optional()
+            .describe("'everyone' (default, public) or 'org' (visible/claimable only within your org)"),
+    }, WRITE, async ({ description, chatId, price, audience }) => {
+        try {
+            // Buyer-broadcast: the payer is derived server-side as the creating
+            // principal (your side), and providerId is forbidden on broadcasts —
+            // the claiming agent fills the open provider side. So we send neither.
+            // audience flows straight through; the api-client + backend map it to
+            // the proposedTo sentinel and scope on the publisher's org.
+            const agreement = await proposeBroadcast({
+                description,
+                chatId: chatId ?? '',
+                price,
+                engagementKind: 'service',
+                audience: audience ?? 'everyone',
+            }, creds);
+            return textResult({ agreement });
+        }
+        catch (e) {
+            return toolError(e.message);
+        }
+    });
+    server.tool('ziggs_publish_offer', 'Publish a standing offer buyers can claim (seller-broadcast). audience="everyone" (default) is public; audience="org" scopes it to your active org. Requires an active org when audience="org".', {
+        description: z.string(),
+        price: z.number().optional(),
+        engagementKind: z.enum(['hire', 'service']).optional(),
+        audience: z
+            .enum(['everyone', 'org'])
+            .optional()
+            .describe("'everyone' (default, public) or 'org' (visible/claimable only within your org)"),
+    }, WRITE, async ({ description, price, engagementKind, audience }) => {
+        try {
+            const agreement = await publishOffer({
+                description,
+                price,
+                engagementKind,
+                audience: audience ?? 'everyone',
+            }, creds);
+            return textResult({ offer: agreement });
+        }
+        catch (e) {
+            return toolError(e.message);
+        }
+    });
+    server.tool('ziggs_claim_offer', 'Claim a published standing offer (POST /marketplace/offers/claim). Use for relay worker provisioning when the worker has a marketplace offer — no worker-side approval needed.', {
+        agreementId: z.string().describe('Open offer agreementId to claim'),
+    }, WRITE, async ({ agreementId }) => {
+        try {
+            const offer = await claimOffer(agreementId, creds);
+            return textResult({ offer });
+        }
+        catch (e) {
+            return toolError(e.message);
+        }
+    });
+    server.tool('ziggs_provision_relay_workers', 'Initiator path: provision per-step worker agreements before relay kickoff. Reuses active delegations under the hire, claims standing offers when available, otherwise proposes delegations (worker must approve — never impersonated). Returns relay:v1 payload and POST /tasks body when all steps are active.', {
+        hireAgreementId: z.string(),
+        chatId: z
+            .string()
+            .optional()
+            .describe('Required when a step has no standing offer and needs delegation under the hire'),
+        inputArtifactIds: z.array(z.string()).optional(),
+        steps: z.array(z.object({
+            stepId: z.string(),
+            order: z.number(),
+            assigneeId: z.string(),
+            description: z.string(),
+            offerAgreementId: z
+                .string()
+                .optional()
+                .describe('Explicit open offer to claim for this worker'),
+        })),
+        kickoff: z
+            .boolean()
+            .optional()
+            .describe('When true and readyForKickoff, also POST /tasks on the hire for relay-coordinator'),
+    }, WRITE, async ({ hireAgreementId, chatId, inputArtifactIds, steps, kickoff }) => {
+        try {
+            const result = await provisionRelayWorkers({
+                creds,
+                hireAgreementId,
+                chatId,
+                inputArtifactIds,
+                steps,
+            });
+            const relayTaskBody = buildRelayCoordinatorTaskBody({
+                hireAgreementId,
+                payload: result.payload,
+            });
+            let task;
+            if (kickoff && result.readyForKickoff) {
+                task = await createTask(relayTaskBody, creds);
+            }
+            return textResult({
+                ...result,
+                relayTaskBody,
+                task,
+                nextSteps: result.readyForKickoff
+                    ? kickoff && task
+                        ? 'Relay coordinator task created — watch Execution for step progress.'
+                        : 'All worker agreements active — POST relayTaskBody via createTask or set kickoff=true.'
+                    : `Worker approval pending on: ${result.pendingApprovals.join(', ')}. Call ziggs_respond_to_agreement after workers approve, then re-run with kickoff=true.`,
+            });
+        }
+        catch (e) {
+            return toolError(e.message);
+        }
+    });
+}
+function registerConnectionTools(server, creds) {
+    server.tool('ziggs_connection_proxy', "Use a stored connection (a third-party credential, e.g. the owner's GitHub/Jira — NOT an agent-to-agent Link, see ziggs_list_links for that) without ever seeing the credential. " +
+        'Calls the backend connections proxy with a grant the owner issued to this agent: the proxy enforces the grant, decrypts the token server-side, makes the upstream provider call, and returns the result (token-leak guarded on both sides). ' +
+        'Provide connectionId, grantId, the provider action (e.g. repo:read), and an optional action-specific payload. ' +
+        "Don't know connectionId/grantId yet? Call ziggs_list_my_connections first.", {
+        connectionId: z.string().describe('Connection to act on'),
+        grantId: z
+            .string()
+            .describe('Grant the owner issued to this agent for the connection'),
+        action: z.string().describe('Provider action, e.g. repo:read'),
+        payload: z
+            .record(z.unknown())
+            .optional()
+            .describe('Action-specific arguments (provider-defined)'),
+    }, WRITE, async ({ connectionId, grantId, action, payload }) => {
+        try {
+            const result = await new ConnectionsClient(creds.operatorKey, creds.agentId).proxy({ connectionId, grantId, action, payload });
+            return textResult({ ok: true, action, result });
+        }
+        catch (e) {
+            return toolError(e.message);
+        }
+    });
+    server.tool('ziggs_list_my_connections', 'Discover the third-party connections (credentials like GitHub/Jira, NOT agent-to-agent Links — see ziggs_list_links for that) you hold grants for (e.g. "is GitHub connected?") without the owner sharing connectionId/grantId out of band. ' +
+        'Returns, per connection: connectionId, provider, and the grant(s) you hold — each as the canonical grant shape (grantId, scope, caveats, and grant health active/expired/revoked). ' +
+        'Read-only — never returns credential material. Feed the connectionId + a grantId with health "active" into ziggs_connection_proxy to actually use it.', {}, READ_ONLY, async () => {
+        try {
+            const connections = await listConnectionsForHolder(creds);
+            return textResult({ connections });
+        }
+        catch (e) {
+            return toolError(e.message);
+        }
+    });
+    server.tool('ziggs_request_connection', 'Ask your principal (the human) to connect a remote MCP server and grant you the listed tools. ' +
+        'Opens a connection-consent agreement as an approvable card in the chat you pass — the human approves it there like any other agreement (there is no MCP tool to approve it, so tell them to approve it in the chat). ' +
+        'On approval the server is connected (browser OAuth if needed) and you are granted the tools; the result shows up in ziggs_list_my_connections for use with ziggs_connection_proxy.', {
+        chatId: z
+            .string()
+            .describe('The chat you are working in — the consent card is opened there'),
+        serverUrl: z.string().describe('Remote MCP server URL (https)'),
+        tools: z
+            .array(z.string())
+            .describe("Tool names you want — become the grant's allowed_actions caveats"),
+        reason: z
+            .string()
+            .optional()
+            .describe('Plain-language reason shown to the human deciding'),
+    }, WRITE, async ({ chatId, serverUrl, tools, reason }) => {
+        try {
+            const result = await new ConnectionsClient(creds.operatorKey, creds.agentId).requestMcpConnection({ chatId, serverUrl, tools, reason });
+            return textResult({
+                ok: true,
+                ...result,
+                note: 'A connection-consent card is now in the chat awaiting your principal. Tell the human now (pull-only MCP has no push) — they approve it right in the chat. ' +
+                    'Once approved, the connection + grant appear in ziggs_list_my_connections for ziggs_connection_proxy.',
+            });
+        }
+        catch (e) {
+            return toolError(e.message);
+        }
+    });
+}
 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. (Renamed from ziggs_connection_status — "connection" now refers only to third-party credential connections, see ziggs_connection_proxy.)', {}, READ_ONLY, async () => {
         const claims = decodeOperatorKeyClaims(creds.operatorKey);
@@ -346,15 +486,22 @@ export function registerZiggsTools(server, creds, cfg) {
             return toolError(e.message);
         }
     });
-    server.tool('ziggs_list_my_agreements', 'List agreements visible to the impersonated delegate agent (scope=mine).', {
+    server.tool('ziggs_list_my_agreements', 'List agreements you are a party to — your hires, proposals, and work (default scope "mine"). Pass scope "reachable" to list every agreement your grant can read in the org, including ones you are not a party to; the isYou flags on each row mark which party (if any) is you.', {
+        scope: z
+            .enum(['mine', 'reachable'])
+            .optional()
+            .describe('mine (default): only agreements where you are a party. reachable: all agreements your grant can read in the org.'),
         proposalStatus: z
             .string()
             .optional()
             .describe('Optional filter: pending, approved, rejected, …'),
-    }, READ_ONLY, async ({ proposalStatus }) => {
+    }, READ_ONLY, async ({ scope, proposalStatus }) => {
         try {
-            const agreements = await getMyAgreements(proposalStatus ? { proposalStatus } : {}, creds);
-            return textResult({ count: agreements.length, agreements });
+            const agreements = await getMyAgreements({
+                ...(proposalStatus ? { proposalStatus } : {}),
+                partyOnly: scope !== 'reachable',
+            }, creds);
+            return textResult({ count: agreements.length, scope: scope ?? 'mine', agreements });
         }
         catch (e) {
             return toolError(e.message);
@@ -396,7 +543,7 @@ export function registerZiggsTools(server, creds, cfg) {
         receiverId: z
             .string()
             .optional()
-            .describe('User or agent id receiving the message. Optional when the chat has exactly one other member (the recipient is inferred server-side); required when multiple members could receive it.'),
+            .describe("User or agent id receiving the message. Optional: with exactly one other member the recipient is inferred server-side; in a room with several members an omitted receiver becomes a broadcast to the room's HUMAN members (agents are not woken by it). Pass 'human' to broadcast explicitly, or a specific agent id to address (and wake) that agent."),
         text: z.string(),
         entryType: z
             .string()
@@ -456,120 +603,9 @@ export function registerZiggsTools(server, creds, cfg) {
             return toolError(e.message);
         }
     });
-    server.tool('ziggs_publish_quest', 'Publish an open quest any agent can claim (buyer-broadcast): you are the buyer, and whoever claims it does the work. audience="everyone" (default) is fully public across all orgs; audience="org" scopes it to your active org — only agents in your org see it in marketplace feeds and may claim it. The payer is derived server-side as your side (the publisher); there is no payer input.', {
-        description: z.string(),
-        chatId: z.string().optional(),
-        price: z.number().optional(),
-        audience: z
-            .enum(['everyone', 'org'])
-            .optional()
-            .describe("'everyone' (default, public) or 'org' (visible/claimable only within your org)"),
-    }, WRITE, async ({ description, chatId, price, audience }) => {
-        try {
-            // Buyer-broadcast: the payer is derived server-side as the creating
-            // principal (your side), and providerId is forbidden on broadcasts —
-            // the claiming agent fills the open provider side. So we send neither.
-            // audience flows straight through; the api-client + backend map it to
-            // the proposedTo sentinel and scope on the publisher's org.
-            const agreement = await proposeBroadcast({
-                description,
-                chatId: chatId ?? '',
-                price,
-                engagementKind: 'service',
-                audience: audience ?? 'everyone',
-            }, creds);
-            return textResult({ agreement });
-        }
-        catch (e) {
-            return toolError(e.message);
-        }
-    });
-    server.tool('ziggs_publish_offer', 'Publish a standing offer buyers can claim (seller-broadcast). audience="everyone" (default) is public; audience="org" scopes it to your active org. Requires an active org when audience="org".', {
-        description: z.string(),
-        price: z.number().optional(),
-        engagementKind: z.enum(['hire', 'service']).optional(),
-        audience: z
-            .enum(['everyone', 'org'])
-            .optional()
-            .describe("'everyone' (default, public) or 'org' (visible/claimable only within your org)"),
-    }, WRITE, async ({ description, price, engagementKind, audience }) => {
-        try {
-            const agreement = await publishOffer({
-                description,
-                price,
-                engagementKind,
-                audience: audience ?? 'everyone',
-            }, creds);
-            return textResult({ offer: agreement });
-        }
-        catch (e) {
-            return toolError(e.message);
-        }
-    });
-    server.tool('ziggs_claim_offer', 'Claim a published standing offer (POST /marketplace/offers/claim). Use for relay worker provisioning when the worker has a marketplace offer — no worker-side approval needed.', {
-        agreementId: z.string().describe('Open offer agreementId to claim'),
-    }, WRITE, async ({ agreementId }) => {
-        try {
-            const offer = await claimOffer(agreementId, creds);
-            return textResult({ offer });
-        }
-        catch (e) {
-            return toolError(e.message);
-        }
-    });
-    server.tool('ziggs_provision_relay_workers', 'Initiator path: provision per-step worker agreements before relay kickoff. Reuses active delegations under the hire, claims standing offers when available, otherwise proposes delegations (worker must approve — never impersonated). Returns relay:v1 payload and POST /tasks body when all steps are active.', {
-        hireAgreementId: z.string(),
-        chatId: z
-            .string()
-            .optional()
-            .describe('Required when a step has no standing offer and needs delegation under the hire'),
-        inputArtifactIds: z.array(z.string()).optional(),
-        steps: z.array(z.object({
-            stepId: z.string(),
-            order: z.number(),
-            assigneeId: z.string(),
-            description: z.string(),
-            offerAgreementId: z
-                .string()
-                .optional()
-                .describe('Explicit open offer to claim for this worker'),
-        })),
-        kickoff: z
-            .boolean()
-            .optional()
-            .describe('When true and readyForKickoff, also POST /tasks on the hire for relay-coordinator'),
-    }, WRITE, async ({ hireAgreementId, chatId, inputArtifactIds, steps, kickoff }) => {
-        try {
-            const result = await provisionRelayWorkers({
-                creds,
-                hireAgreementId,
-                chatId,
-                inputArtifactIds,
-                steps,
-            });
-            const relayTaskBody = buildRelayCoordinatorTaskBody({
-                hireAgreementId,
-                payload: result.payload,
-            });
-            let task;
-            if (kickoff && result.readyForKickoff) {
-                task = await createTask(relayTaskBody, creds);
-            }
-            return textResult({
-                ...result,
-                relayTaskBody,
-                task,
-                nextSteps: result.readyForKickoff
-                    ? kickoff && task
-                        ? 'Relay coordinator task created — watch Execution for step progress.'
-                        : 'All worker agreements active — POST relayTaskBody via createTask or set kickoff=true.'
-                    : `Worker approval pending on: ${result.pendingApprovals.join(', ')}. Call ziggs_respond_to_agreement after workers approve, then re-run with kickoff=true.`,
-            });
-        }
-        catch (e) {
-            return toolError(e.message);
-        }
-    });
+    if (!cfg.coreOnly) {
+        registerMarketplaceTools(server, creds);
+    }
     server.tool('ziggs_respond_to_agreement', 'Approve or reject a pending agreement. Uses PUT /approvals/:partyId or POST /claim for an open broadcast (public or org-scoped; org-scoped quests are claimable only by members of the agreement\'s org).', {
         agreementId: z.string(),
         action: z.enum(['approve', 'reject']),
@@ -935,67 +971,11 @@ export function registerZiggsTools(server, creds, cfg) {
     // ---------------------------------------------------------------------------
     // Connection proxy (ZIG-569)
     // ---------------------------------------------------------------------------
-    server.tool('ziggs_connection_proxy', "Use a stored connection (a third-party credential, e.g. the owner's GitHub/Jira — NOT an agent-to-agent Link, see ziggs_list_links for that) without ever seeing the credential. " +
-        'Calls the backend connections proxy with a grant the owner issued to this agent: the proxy enforces the grant, decrypts the token server-side, makes the upstream provider call, and returns the result (token-leak guarded on both sides). ' +
-        'Provide connectionId, grantId, the provider action (e.g. repo:read), and an optional action-specific payload. ' +
-        "Don't know connectionId/grantId yet? Call ziggs_list_my_connections first.", {
-        connectionId: z.string().describe('Connection to act on'),
-        grantId: z
-            .string()
-            .describe('Grant the owner issued to this agent for the connection'),
-        action: z.string().describe('Provider action, e.g. repo:read'),
-        payload: z
-            .record(z.unknown())
-            .optional()
-            .describe('Action-specific arguments (provider-defined)'),
-    }, WRITE, async ({ connectionId, grantId, action, payload }) => {
-        try {
-            const result = await new ConnectionsClient(creds.operatorKey, creds.agentId).proxy({ connectionId, grantId, action, payload });
-            return textResult({ ok: true, action, result });
-        }
-        catch (e) {
-            return toolError(e.message);
-        }
-    });
-    server.tool('ziggs_list_my_connections', 'Discover the third-party connections (credentials like GitHub/Jira, NOT agent-to-agent Links — see ziggs_list_links for that) you hold grants for (e.g. "is GitHub connected?") without the owner sharing connectionId/grantId out of band. ' +
-        'Returns, per connection: connectionId, provider, and the grant(s) you hold — each as the canonical grant shape (grantId, scope, caveats, and grant health active/expired/revoked). ' +
-        'Read-only — never returns credential material. Feed the connectionId + a grantId with health "active" into ziggs_connection_proxy to actually use it.', {}, READ_ONLY, async () => {
-        try {
-            const connections = await listConnectionsForHolder(creds);
-            return textResult({ connections });
-        }
-        catch (e) {
-            return toolError(e.message);
-        }
-    });
-    server.tool('ziggs_request_connection', 'Ask your principal (the human) to connect a remote MCP server and grant you the listed tools. ' +
-        'Opens a connection-consent agreement as an approvable card in the chat you pass — the human approves it there like any other agreement (there is no MCP tool to approve it, so tell them to approve it in the chat). ' +
-        'On approval the server is connected (browser OAuth if needed) and you are granted the tools; the result shows up in ziggs_list_my_connections for use with ziggs_connection_proxy.', {
-        chatId: z
-            .string()
-            .describe('The chat you are working in — the consent card is opened there'),
-        serverUrl: z.string().describe('Remote MCP server URL (https)'),
-        tools: z
-            .array(z.string())
-            .describe("Tool names you want — become the grant's allowed_actions caveats"),
-        reason: z
-            .string()
-            .optional()
-            .describe('Plain-language reason shown to the human deciding'),
-    }, WRITE, async ({ chatId, serverUrl, tools, reason }) => {
-        try {
-            const result = await new ConnectionsClient(creds.operatorKey, creds.agentId).requestMcpConnection({ chatId, serverUrl, tools, reason });
-            return textResult({
-                ok: true,
-                ...result,
-                note: 'A connection-consent card is now in the chat awaiting your principal. Tell the human now (pull-only MCP has no push) — they approve it right in the chat. ' +
-                    'Once approved, the connection + grant appear in ziggs_list_my_connections for ziggs_connection_proxy.',
-            });
-        }
-        catch (e) {
-            return toolError(e.message);
-        }
-    });
+    if (!cfg.coreOnly) {
+        registerConnectionTools(server, creds);
+    }
     registerTrustTools(server, creds, cfg);
-    registerPaymentTools(server, creds);
+    if (!cfg.coreOnly) {
+        registerPaymentTools(server, creds);
+    }
 }

package/dist/trustTools.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { AgentSearchClient, ContextGrantsClient, createAgreement, listAgreements, revokeAgreement, claimAgreement, addChatMember, grantCaveat, } from '@ziggs-ai/api-client';
+import { fetchMyOrgs, resolveOrgSelector } from './orgs.js';
 import { READ_ONLY, WRITE, DESTRUCTIVE } from './toolAnnotations.js';
 import { toolError } from './toolError.js';
 function textResult(data) {
@@ -22,6 +23,154 @@ function contextBounds(grant) {
 const grantScopeKindSchema = z.enum(['chat', 'agreement', 'org']);
 const contextTemporalSchema = z.enum(['from-now', 'from-start']);
 const DEFAULT_WEB_URL = 'https://ziggsai.com';
+/**
+ * ZIG-941 #6 — org-scoped grants may name the org instead of pasting its opaque
+ * org_... id. Resolve the selector against the operator's memberships via the
+ * (previously unused) resolveOrgSelector: exact id or case-insensitive name.
+ * Ambiguous names return the candidate list rather than guessing; a name that
+ * matched nothing errors with a pointer to ziggs_list_my_orgs. An org_... id
+ * that is not a membership passes through unchanged — you may hold a grant on
+ * an org you do not belong to, so the server stays the authority on the id.
+ */
+async function resolveOrgScope(creds, scopeId) {
+    const resolution = resolveOrgSelector(await fetchMyOrgs(creds), scopeId);
+    if (resolution.status === 'ok')
+        return { scopeId: resolution.orgId };
+    if (resolution.status === 'ambiguous') {
+        return {
+            error: toolError(`Org name "${scopeId}" matches ${resolution.matches.length} of your orgs — pass the org id: ` +
+                resolution.matches.map((m) => `${m.name} (${m.orgId})`).join(', ')),
+        };
+    }
+    if (scopeId.startsWith('org_'))
+        return { scopeId };
+    return {
+        error: toolError(`No org named "${scopeId}" in your memberships — use ziggs_list_my_orgs to see them, or pass the org id.`),
+    };
+}
+// ZIG-941 #7 — the link tool group, pulled out so the lean session-start
+// tier (ZIGGS_MCP_CORE_ONLY) can skip it. Registration is unchanged.
+function registerLinkTools(server, creds, webUrl) {
+    server.tool('ziggs_request_link', 'Request a bilateral trust link with another agent before cross-org reach (party-to-party, NOT a third-party service connection — see ziggs_list_my_connections for that). A link is just an agreement (POST /agreements {engagementKind:"link"}). The target OWNER must approve it (via ziggs_respond_to_agreement) before unpublished delegates can message each other.', {
+        providerId: z
+            .string()
+            .describe('Bare agent id to link with (the target delegate). Use ziggs_search_agents or a known delegate id — do not guess.'),
+        message: z
+            .string()
+            .optional()
+            .describe('Optional note shown to the counterparty human on approval (agreement description)'),
+    }, WRITE, async ({ providerId, message }) => {
+        try {
+            const { agreement } = await createAgreement({ engagementKind: 'link', providerId, description: message }, creds);
+            return textResult({
+                status: 'pending',
+                message: 'Link agreement created — the counterparty owner must approve (ziggs_respond_to_agreement) before cross-org reach. Surface pending state to the human.',
+                agreement,
+            });
+        }
+        catch (e) {
+            return toolError(e.message);
+        }
+    });
+    server.tool('ziggs_create_link_invite', 'Create a shareable OPEN link invite (bilateral agent-to-agent trust, NOT a third-party service connection — see ziggs_list_my_connections for that) when you do NOT have the counterparty\'s agent id (e.g. connecting across orgs). Creates an open link agreement (POST /agreements {engagementKind:"link"}, proposedTo:"everyone"). Share the returned inviteId (agreementId) out-of-band; the recipient forms the link by calling ziggs_claim_link_invite — neither side pastes an agent id. Revoke via ziggs_revoke_link to disable.', {
+        message: z
+            .string()
+            .optional()
+            .describe('Optional note shown to whoever opens the invite (agreement description)'),
+    }, WRITE, async ({ message }) => {
+        try {
+            const { agreement } = await createAgreement({ engagementKind: 'link', description: message }, creds);
+            return textResult({
+                status: 'open',
+                inviteId: agreement.agreementId,
+                claimUrl: `${webUrl}/app/link-invites/${agreement.agreementId}`,
+                message: 'Open link invite created. Share claimUrl with the counterparty — they open it in the Ziggs web app to claim and activate the link. No agent id needed on either side.',
+                agreement,
+            });
+        }
+        catch (e) {
+            return toolError(e.message);
+        }
+    });
+    server.tool('ziggs_claim_link_invite', 'Claim an open link invite by its id to form a bilateral link (agent-to-agent trust, NOT a third-party service connection — see ziggs_list_my_connections for that) (POST /agreements/:id/claim). You become the counterparty and the link activates immediately (cross-org reach + bilateral context grants). You cannot claim your own invite.', {
+        agreementId: z
+            .string()
+            .describe('The invite id (agreementId) shared by the issuer'),
+    }, WRITE, async ({ agreementId }) => {
+        try {
+            const { agreement } = await claimAgreement(agreementId, creds);
+            return textResult({
+                status: 'linked',
+                message: 'Link invite claimed — you are now linked. A link is reach-only: open a chat with the peer (ziggs_open_conversation) and grant it chat access with ziggs_issue_grant, or share a slice of a grant you already hold with ziggs_delegate_grant, before reading context.',
+                agreement,
+            });
+        }
+        catch (e) {
+            return toolError(e.message);
+        }
+    });
+    server.tool('ziggs_list_links', 'List link agreements for this delegate — bilateral agent-to-agent trust relationships, NOT third-party service connections (see ziggs_list_my_connections for those) (GET /agreements?engagementKind=link). Defaults to ACTIVE links only; pass status to see pending proposals ("open") or revoked ones ("cancelled"). Each item is a link summary: agreementId, status, proposalStatus, parties.creatorAgent (requester), parties.providerAgent (target), parties.proposedTo (target owner). Approve pending links via ziggs_respond_to_agreement.', {
+        status: z
+            .enum(['active', 'open', 'cancelled', 'all'])
+            .optional()
+            .describe('active (default) = established links; open = pending proposals/invites awaiting approval or claim; cancelled = revoked; all = every link regardless of status'),
+    }, READ_ONLY, async ({ status }) => {
+        try {
+            const resolvedStatus = status ?? 'active';
+            const links = await listAgreements({
+                engagementKind: 'link',
+                ...(resolvedStatus === 'all' ? {} : { status: resolvedStatus }),
+            }, creds);
+            // ZIG-670: link-shaped summaries, not raw agreement documents — the
+            // money block, approvals array, and Mongo internals are noise here.
+            const summaries = links.map((a) => ({
+                agreementId: a.agreementId,
+                status: a.status,
+                proposalStatus: a.proposalStatus,
+                parties: {
+                    creatorAgent: a.parties?.creatorAgent ?? null,
+                    providerAgent: a.parties?.providerAgent ?? null,
+                    creator: a.parties?.creator ?? null,
+                    proposedTo: a.parties?.proposedTo ?? null,
+                },
+                ...(a.description ? { description: a.description } : {}),
+                createdAt: a.createdAt,
+            }));
+            const hasActive = links.some((a) => a.status === 'active');
+            return textResult({
+                count: summaries.length,
+                status: resolvedStatus,
+                links: summaries,
+                ...(hasActive
+                    ? {
+                        nextSteps: 'A link is reach-only. Open a chat with the peer (ziggs_open_conversation, participantId = peer agent id) and grant it chat access with ziggs_issue_grant, or share a slice of a grant you hold with ziggs_delegate_grant, before reading context.',
+                    }
+                    : {}),
+            });
+        }
+        catch (e) {
+            return toolError(e.message);
+        }
+    });
+    server.tool('ziggs_revoke_link', 'Revoke a bilateral link agreement — agent-to-agent trust, NOT a third-party service connection (DELETE /agreements/:agreementId). Either party may revoke; cross-org reach ends immediately. For non-link agreements (hire/service/quest), use ziggs_revoke_agreement — same endpoint, different messaging.', {
+        agreementId: z
+            .string()
+            .describe('agreementId of the link agreement (from ziggs_list_links)'),
+    }, DESTRUCTIVE, async ({ agreementId }) => {
+        try {
+            const result = await revokeAgreement(agreementId, creds);
+            return textResult({
+                status: 'revoked',
+                message: 'Link revoked — unpublished cross-org reach to this peer is blocked again.',
+                agreementId,
+                agreement: result.agreement,
+            });
+        }
+        catch (e) {
+            return toolError(e.message);
+        }
+    });
+}
 /** ZIG-433 — agent search + context grant management through MCP. */
 export function registerTrustTools(server, creds, cfg) {
     const webUrl = cfg?.ZIGGS_WEB_URL?.replace(/\/$/, '') ?? DEFAULT_WEB_URL;
@@ -117,10 +266,18 @@ export function registerTrustTools(server, creds, cfg) {
                     chat: 'chat' in result ? result.chat : undefined,
                 });
             }
+            // ZIG-941 #6 — an org scope may be named rather than pasted as org_… id.
+            let resolvedScopeId = scopeId;
+            if (scopeKind === 'org') {
+                const resolved = await resolveOrgScope(creds, scopeId);
+                if ('error' in resolved)
+                    return resolved.error;
+                resolvedScopeId = resolved.scopeId;
+            }
             const client = new ContextGrantsClient(creds.operatorKey, creds.agentId);
             const grant = await client.issueGrant({
                 holderId,
-                scope: { kind: scopeKind, id: scopeId },
+                scope: { kind: scopeKind, id: resolvedScopeId },
                 temporal: resolvedTemporal,
                 expiresAt,
             });
@@ -147,10 +304,18 @@ export function registerTrustTools(server, creds, cfg) {
             .describe('from-now watermark ISO-8601 (optional; server may default)'),
     }, WRITE, async ({ parentGrantId, holderId, scopeKind, scopeId, temporal, expiresAt, watermarkAt, }) => {
         try {
+            // ZIG-941 #6 — an org scope may be named rather than pasted as org_… id.
+            let resolvedScopeId = scopeId;
+            if (scopeKind === 'org') {
+                const resolved = await resolveOrgScope(creds, scopeId);
+                if ('error' in resolved)
+                    return resolved.error;
+                resolvedScopeId = resolved.scopeId;
+            }
             const client = new ContextGrantsClient(creds.operatorKey, creds.agentId);
             const result = await client.delegateGrant(parentGrantId, {
                 holderId,
-                scope: { kind: scopeKind, id: scopeId },
+                scope: { kind: scopeKind, id: resolvedScopeId },
                 temporal,
                 expiresAt,
                 watermarkAt,
@@ -176,125 +341,9 @@ export function registerTrustTools(server, creds, cfg) {
             return toolError(e.message);
         }
     });
-    server.tool('ziggs_request_link', 'Request a bilateral trust link with another agent before cross-org reach (party-to-party, NOT a third-party service connection — see ziggs_list_my_connections for that). A link is just an agreement (POST /agreements {engagementKind:"link"}). The target OWNER must approve it (via ziggs_respond_to_agreement) before unpublished delegates can message each other.', {
-        providerId: z
-            .string()
-            .describe('Bare agent id to link with (the target delegate). Use ziggs_search_agents or a known delegate id — do not guess.'),
-        message: z
-            .string()
-            .optional()
-            .describe('Optional note shown to the counterparty human on approval (agreement description)'),
-    }, WRITE, async ({ providerId, message }) => {
-        try {
-            const { agreement } = await createAgreement({ engagementKind: 'link', providerId, description: message }, creds);
-            return textResult({
-                status: 'pending',
-                message: 'Link agreement created — the counterparty owner must approve (ziggs_respond_to_agreement) before cross-org reach. Surface pending state to the human.',
-                agreement,
-            });
-        }
-        catch (e) {
-            return toolError(e.message);
-        }
-    });
-    server.tool('ziggs_create_link_invite', 'Create a shareable OPEN link invite (bilateral agent-to-agent trust, NOT a third-party service connection — see ziggs_list_my_connections for that) when you do NOT have the counterparty\'s agent id (e.g. connecting across orgs). Creates an open link agreement (POST /agreements {engagementKind:"link"}, proposedTo:"everyone"). Share the returned inviteId (agreementId) out-of-band; the recipient forms the link by calling ziggs_claim_link_invite — neither side pastes an agent id. Revoke via ziggs_revoke_link to disable.', {
-        message: z
-            .string()
-            .optional()
-            .describe('Optional note shown to whoever opens the invite (agreement description)'),
-    }, WRITE, async ({ message }) => {
-        try {
-            const { agreement } = await createAgreement({ engagementKind: 'link', description: message }, creds);
-            return textResult({
-                status: 'open',
-                inviteId: agreement.agreementId,
-                claimUrl: `${webUrl}/app/link-invites/${agreement.agreementId}`,
-                message: 'Open link invite created. Share claimUrl with the counterparty — they open it in the Ziggs web app to claim and activate the link. No agent id needed on either side.',
-                agreement,
-            });
-        }
-        catch (e) {
-            return toolError(e.message);
-        }
-    });
-    server.tool('ziggs_claim_link_invite', 'Claim an open link invite by its id to form a bilateral link (agent-to-agent trust, NOT a third-party service connection — see ziggs_list_my_connections for that) (POST /agreements/:id/claim). You become the counterparty and the link activates immediately (cross-org reach + bilateral context grants). You cannot claim your own invite.', {
-        agreementId: z
-            .string()
-            .describe('The invite id (agreementId) shared by the issuer'),
-    }, WRITE, async ({ agreementId }) => {
-        try {
-            const { agreement } = await claimAgreement(agreementId, creds);
-            return textResult({
-                status: 'linked',
-                message: 'Link invite claimed — you are now linked. A link is reach-only: open a chat with the peer (ziggs_open_conversation) and grant it chat access with ziggs_issue_grant, or share a slice of a grant you already hold with ziggs_delegate_grant, before reading context.',
-                agreement,
-            });
-        }
-        catch (e) {
-            return toolError(e.message);
-        }
-    });
-    server.tool('ziggs_list_links', 'List link agreements for this delegate — bilateral agent-to-agent trust relationships, NOT third-party service connections (see ziggs_list_my_connections for those) (GET /agreements?engagementKind=link). Defaults to ACTIVE links only; pass status to see pending proposals ("open") or revoked ones ("cancelled"). Each item is a link summary: agreementId, status, proposalStatus, parties.creatorAgent (requester), parties.providerAgent (target), parties.proposedTo (target owner). Approve pending links via ziggs_respond_to_agreement.', {
-        status: z
-            .enum(['active', 'open', 'cancelled', 'all'])
-            .optional()
-            .describe('active (default) = established links; open = pending proposals/invites awaiting approval or claim; cancelled = revoked; all = every link regardless of status'),
-    }, READ_ONLY, async ({ status }) => {
-        try {
-            const resolvedStatus = status ?? 'active';
-            const links = await listAgreements({
-                engagementKind: 'link',
-                ...(resolvedStatus === 'all' ? {} : { status: resolvedStatus }),
-            }, creds);
-            // ZIG-670: link-shaped summaries, not raw agreement documents — the
-            // money block, approvals array, and Mongo internals are noise here.
-            const summaries = links.map((a) => ({
-                agreementId: a.agreementId,
-                status: a.status,
-                proposalStatus: a.proposalStatus,
-                parties: {
-                    creatorAgent: a.parties?.creatorAgent ?? null,
-                    providerAgent: a.parties?.providerAgent ?? null,
-                    creator: a.parties?.creator ?? null,
-                    proposedTo: a.parties?.proposedTo ?? null,
-                },
-                ...(a.description ? { description: a.description } : {}),
-                createdAt: a.createdAt,
-            }));
-            const hasActive = links.some((a) => a.status === 'active');
-            return textResult({
-                count: summaries.length,
-                status: resolvedStatus,
-                links: summaries,
-                ...(hasActive
-                    ? {
-                        nextSteps: 'A link is reach-only. Open a chat with the peer (ziggs_open_conversation, participantId = peer agent id) and grant it chat access with ziggs_issue_grant, or share a slice of a grant you hold with ziggs_delegate_grant, before reading context.',
-                    }
-                    : {}),
-            });
-        }
-        catch (e) {
-            return toolError(e.message);
-        }
-    });
-    server.tool('ziggs_revoke_link', 'Revoke a bilateral link agreement — agent-to-agent trust, NOT a third-party service connection (DELETE /agreements/:agreementId). Either party may revoke; cross-org reach ends immediately. For non-link agreements (hire/service/quest), use ziggs_revoke_agreement — same endpoint, different messaging.', {
-        agreementId: z
-            .string()
-            .describe('agreementId of the link agreement (from ziggs_list_links)'),
-    }, DESTRUCTIVE, async ({ agreementId }) => {
-        try {
-            const result = await revokeAgreement(agreementId, creds);
-            return textResult({
-                status: 'revoked',
-                message: 'Link revoked — unpublished cross-org reach to this peer is blocked again.',
-                agreementId,
-                agreement: result.agreement,
-            });
-        }
-        catch (e) {
-            return toolError(e.message);
-        }
-    });
+    if (!cfg?.coreOnly) {
+        registerLinkTools(server, creds, webUrl);
+    }
     server.tool('ziggs_revoke_grant', 'Revoke a context grant and its descendants (DELETE /context/grants/:id). You can revoke (narrow) any grant you hold — this needs no special scope. Revoking a grant you do NOT hold (one you issued, or on a scope you own) is a human-authority action: as a delegate you are limited to grants you hold; the human/owner does the rest.', {
         grantId: z.string(),
     }, DESTRUCTIVE, async ({ grantId }) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ziggs-ai/ziggs-mcp",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "MCP server for Claude Code, Cursor, and other MCP hosts — act as your Ziggs delegate agent",
   "type": "module",
   "bin": {
@@ -36,12 +36,12 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@ziggs-ai/api-client": "^0.3.0",
+    "@ziggs-ai/api-client": "^0.3.1",
     "dotenv": "^16.6.1",
     "zod": "^3.24.2"
   },
   "devDependencies": {
-    "@ziggs-ai/agent-sdk": "^0.4.0"
+    "@ziggs-ai/agent-sdk": "^0.4.1"
   },
   "engines": {
     "node": ">=20"