@ziggs-ai/ziggs-mcp 0.1.22 → 0.1.23

package/README.md

@@ -204,8 +204,9 @@ OP_KEY_A=... AGENT_A=... USER_B=... OP_KEY_B=... AGENT_B=... \
 | `ziggs_revoke_grant` | `DELETE /context/grants/:id` |
 | `ziggs_request_link` | `POST /agreements` `{engagementKind:"link"}` (ZIG-481 — a link is just an agreement) |
 | `ziggs_list_links` | `GET /agreements?engagementKind=link` |
-| `ziggs_revoke_link` | `DELETE /agreements/:agreementId` |
-| `ziggs_smoke_impersonation` | Smoke step 1 |
+| `ziggs_revoke_link` | `DELETE /agreements/:agreementId` (see also `ziggs_revoke_agreement`) |
+| `ziggs_revoke_agreement` | `DELETE /agreements/:id` — any agreement (hire/service/quest/link), ZIG-207 |
+| `ziggs_smoke_impersonation` | [Internal/debug] connectivity check — not part of normal delegate workflow |
 | `ziggs_get_scope` | `GET /scope?via=` |
 | `ziggs_list_my_agreements` | `GET /agreements?scope=mine` |
 | `ziggs_get_agreement` | `GET /agreements/:id` |

package/dist/config.d.ts

@@ -8,7 +8,7 @@ declare const envSchema: z.ZodObject<{
     ZIGGS_OPERATOR_KEY: z.ZodString;
     /** Optional when the operator key is agent-scoped (ZIG-279). */
     ZIGGS_AGENT_ID: z.ZodOptional<z.ZodString>;
-    /** Human user id for payer-side proposals (ZIG-222 smoke step 2). */
+    /** Human user id for payer-side proposals — defaults the payer on propose/publish tools. */
     ZIGGS_OWNER_USER_ID: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     ZIGGS_OPERATOR_KEY: string;

package/dist/config.js

@@ -9,7 +9,7 @@ const envSchema = z.object({
     ZIGGS_OPERATOR_KEY: z.string().min(1, 'ZIGGS_OPERATOR_KEY is required'),
     /** Optional when the operator key is agent-scoped (ZIG-279). */
     ZIGGS_AGENT_ID: z.string().optional(),
-    /** Human user id for payer-side proposals (ZIG-222 smoke step 2). */
+    /** Human user id for payer-side proposals — defaults the payer on propose/publish tools. */
     ZIGGS_OWNER_USER_ID: z.string().optional(),
 });
 /** Load delegate credentials from the environment (ZIG-222 / ZIG-430). */

package/dist/tools.js

@@ -1,12 +1,12 @@
 import { randomUUID } from 'node:crypto';
 import { z } from 'zod';
-import { getAgreement, getMyAgreements, listMyChats, openConversation, proposeDirectTo, proposeBroadcast, publishOffer, respondToAgreement, ScopeClient, sendChatMessage, ContextDiscoveryClient, ContextReadClient, InboxClient, createTask, updateTaskState, replaceTaskPlan, listTasks, getBackendUrl, } from '@ziggs-ai/api-client';
+import { getAgreement, getMyAgreements, listMyChats, openConversation, proposeDirectTo, proposeBroadcast, publishOffer, respondToAgreement, revokeAgreement, ScopeClient, sendChatMessage, ContextDiscoveryClient, ContextReadClient, InboxClient, createTask, updateTaskState, replaceTaskPlan, listTasks, getBackendUrl, } from '@ziggs-ai/api-client';
 import { decodeOperatorKeyClaims } from './operatorKey.js';
 import { registerTrustTools } from './trustTools.js';
 import { formatInboxToolResult, buildReadContextReadPlan, } from './inboxToolResult.js';
 import { formatPendingDecisionsPayload, resolveWebAppOrigin, buildPendingNextActions, } from './pendingDecisions.js';
 import { PROTOCOL } from './protocol/delegateProtocol.js';
-import { READ_ONLY, WRITE } from './toolAnnotations.js';
+import { READ_ONLY, WRITE, DESTRUCTIVE } from './toolAnnotations.js';
 // ZIG-557: the protocol sentences (loop / ack / humanAttention) are sourced
 // from the shared const so this description can't drift from SKILL / server
 // instructions / .cursorrules.
@@ -140,6 +140,37 @@ async function proxyConnection(creds, input) {
     const result = parsed?.['result'];
     return result ?? parsed;
 }
+/**
+ * ZIG-641 — cross-connection discovery: every connection this agent holds a
+ * grant for, joined with provider + health, so ziggs_connection_proxy's
+ * connectionId/grantId no longer has to arrive out of band. Same leak guard
+ * doesn't apply here (the backend never returns credential material for this
+ * route), but the response is still scanned defensively for consistency
+ * with proxyConnection.
+ */
+async function listConnectionsForHolder(creds) {
+    const url = `${getBackendUrl()}/connections/grants`;
+    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 /connections/grants ${res.status} ${body.slice(0, 200)}`);
+    }
+    assertNoLeakedSecret(body);
+    let parsed = body;
+    try {
+        parsed = body ? JSON.parse(body) : null;
+    }
+    catch {
+        parsed = body;
+    }
+    return parsed?.['connections'] ?? [];
+}
 async function loadSessionActionsPayload(creds, cfg) {
     const webOrigin = resolveWebAppOrigin(cfg.ZIGGS_WEB_URL);
     const client = new InboxClient(creds.operatorKey, creds.agentId);
@@ -155,11 +186,11 @@ async function loadSessionActionsPayload(creds, cfg) {
     return formatPendingDecisionsPayload(inbox, webOrigin, { activeTasks });
 }
 export function registerZiggsTools(server, creds, cfg) {
-    server.tool('ziggs_connection_status', 'ZIG-503 — 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 (ZIG-625).', {}, READ_ONLY, async () => {
+    server.tool('ziggs_auth_status', 'ZIG-503 — 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 (ZIG-625). (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);
         const boundOrgId = claims?.boundOrgId?.trim() || null;
         const webOrigin = resolveWebAppOrigin(cfg.ZIGGS_WEB_URL);
-        let sessionActions = {
+        let pendingDecisions = {
             pendingCount: 0,
             hasPending: false,
             activeWorkCount: 0,
@@ -168,11 +199,11 @@ export function registerZiggsTools(server, creds, cfg) {
             hasActionable: false,
         };
         try {
-            sessionActions = await loadSessionActionsPayload(creds, cfg);
+            pendingDecisions = await loadSessionActionsPayload(creds, cfg);
         }
         catch {
-            sessionActions = {
-                ...sessionActions,
+            pendingDecisions = {
+                ...pendingDecisions,
                 fetchError: 'Could not load inbox/tasks — call ziggs_pending_decisions.',
             };
         }
@@ -190,9 +221,8 @@ export function registerZiggsTools(server, creds, cfg) {
             apiBase: getBackendUrl(),
             webAppOrigin: webOrigin,
             docs: 'https://ziggsai.com/docs',
-            sessionActions,
-            pendingDecisions: sessionActions,
-            sessionStartHint: sessionActions.hasActionable === true
+            pendingDecisions,
+            sessionStartHint: pendingDecisions.hasActionable === true
                 ? 'Call ziggs_pending_decisions and paste sessionChatCard for the human before other work.'
                 : 'Next: ziggs_inbox or ziggs_pending_decisions at session start.',
         });
@@ -214,7 +244,7 @@ export function registerZiggsTools(server, creds, cfg) {
             return toolError(e.message);
         }
     });
-    server.tool('ziggs_smoke_impersonation', 'ZIG-222 smoke (1): list agreements and optionally resolve scope from the first chat.', {}, READ_ONLY, async () => {
+    server.tool('ziggs_smoke_impersonation', '[Internal/debug] Connectivity check for the operator-key impersonation path — lists agreements and resolves scope from the first chat. Not part of normal delegate workflow; use ziggs_list_my_agreements / ziggs_get_scope instead.', {}, READ_ONLY, async () => {
         try {
             const agreements = await getMyAgreements({}, creds);
             const chats = await listMyChats(creds);
@@ -236,12 +266,12 @@ export function registerZiggsTools(server, creds, cfg) {
         }
     });
     server.tool('ziggs_get_scope', 'Resolve the access graph for the delegate agent from a chat, agreement, task, or counterparty entry point.', {
-        viaKind: scopeKindSchema.describe('Entry kind'),
-        viaId: z.string().describe('Entry id'),
-    }, READ_ONLY, async ({ viaKind, viaId }) => {
+        scopeKind: scopeKindSchema.describe('Entry kind'),
+        scopeId: z.string().describe('Entry id'),
+    }, READ_ONLY, async ({ scopeKind, scopeId }) => {
         try {
             const client = new ScopeClient(creds.operatorKey, creds.agentId);
-            const result = await client.get(viaKind, viaId);
+            const result = await client.get(scopeKind, scopeId);
             return textResult(result);
         }
         catch (e) {
@@ -320,7 +350,7 @@ export function registerZiggsTools(server, creds, cfg) {
             return toolError(e.message);
         }
     });
-    server.tool('ziggs_propose_agreement', 'ZIG-222 smoke (2): propose as payer-side delegate. Requires payerId (or ZIGGS_OWNER_USER_ID). No hire/spend.', {
+    server.tool('ziggs_propose_agreement', 'Propose a direct service agreement to one counterparty in a chat, as the payer-side delegate. Requires payerId (or ZIGGS_OWNER_USER_ID). price is recorded on the agreement but does not itself trigger a transfer — V1 has no real payment rail yet.', {
         proposedTo: z.string(),
         chatId: z.string(),
         description: z.string(),
@@ -421,6 +451,17 @@ export function registerZiggsTools(server, creds, cfg) {
             return toolError(e.message);
         }
     });
+    server.tool('ziggs_revoke_agreement', 'Revoke any agreement you are a party to — hire, service, quest, or link (DELETE /agreements/:id, ZIG-207). Either party may revoke; this ends the engagement immediately. ziggs_revoke_link calls the same endpoint with link-flavored messaging; use whichever reads clearer for the agreement kind.', {
+        agreementId: z.string().describe('Agreement to revoke'),
+    }, DESTRUCTIVE, async ({ agreementId }) => {
+        try {
+            const result = await revokeAgreement(agreementId, creds);
+            return textResult({ status: 'revoked', agreementId, agreement: result.agreement });
+        }
+        catch (e) {
+            return toolError(e.message);
+        }
+    });
     server.tool('ziggs_inbox', ZIGGS_INBOX_DESCRIPTION, {
         ack: z
             .array(z.object({
@@ -553,9 +594,13 @@ export function registerZiggsTools(server, creds, cfg) {
         agreementId: z.string().describe('Agreement this task belongs to'),
         description: z.string().describe('What the task entails'),
         parentTaskId: z.string().optional().describe('Parent task id for sub-tasks'),
-    }, WRITE, async ({ agreementId, description, parentTaskId }) => {
+        assigneeId: z
+            .string()
+            .optional()
+            .describe('Agent or user ID to explicitly assign this task to — must be a party to the agreement'),
+    }, WRITE, async ({ agreementId, description, parentTaskId, assigneeId }) => {
         try {
-            const task = await createTask({ agreementId, description, parentTaskId }, creds);
+            const task = await createTask({ agreementId, description, parentTaskId, assigneeId }, creds);
             return textResult({ ok: true, task });
         }
         catch (e) {
@@ -602,16 +647,25 @@ export function registerZiggsTools(server, creds, cfg) {
             return toolError(e.message);
         }
     });
-    server.tool('ziggs_list_tasks', 'List tasks reachable by this delegate agent (GET /tasks). Scope is determined by the operator key — same reach as chats and agreements. Supports optional state filter and cursor pagination.', {
+    server.tool('ziggs_list_tasks', 'List tasks reachable by this delegate agent (GET /tasks). Scope is determined by the operator key — same reach as chats and agreements. Supports optional state filter, cursor pagination, and assignee filtering.', {
         state: z
             .string()
             .optional()
             .describe('Filter by state: active, completed, failed, cancelled'),
         cursor: z.string().optional().describe('Opaque cursor from prior nextCursor'),
         limit: z.number().optional().describe('Max rows (default server-side)'),
-    }, READ_ONLY, async ({ state, cursor, limit }) => {
+        assignedTo: z
+            .string()
+            .optional()
+            .describe('Filter to tasks explicitly assigned to this agent/user id (ZIG-586)'),
+        assignedToMe: z
+            .boolean()
+            .optional()
+            .describe('Shorthand for assignedTo=<this delegate\'s own agent id>. Takes precedence over assignedTo if both are set.'),
+    }, READ_ONLY, async ({ state, cursor, limit, assignedTo, assignedToMe }) => {
         try {
-            const result = await listTasks({ state, cursor, limit }, creds);
+            const effectiveAssignedTo = assignedToMe ? creds.agentId : assignedTo;
+            const result = await listTasks({ state, cursor, limit, assignedTo: effectiveAssignedTo }, creds);
             return textResult(result);
         }
         catch (e) {
@@ -621,10 +675,10 @@ export function registerZiggsTools(server, creds, cfg) {
     // ---------------------------------------------------------------------------
     // Connection proxy (ZIG-569)
     // ---------------------------------------------------------------------------
-    server.tool('ziggs_connection_proxy', "Use a stored connection (e.g. the owner's GitHub) without ever seeing the credential. " +
+    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. ' +
-        'You must already hold connectionId + grantId (the owner shares them out-of-band); listing connections an agent holds grants for is a separate tool/ticket.', {
+        "Don't know connectionId/grantId yet? Call ziggs_list_my_connections first.", {
         connectionId: z.string().describe('Connection to act on'),
         grantId: z
             .string()
@@ -648,5 +702,16 @@ export function registerZiggsTools(server, creds, cfg) {
             return toolError(e.message);
         }
     });
+    server.tool('ziggs_list_my_connections', 'ZIG-641 — 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, the grantId(s) you hold, each grant\'s allowed-action caveats, and health (linked/expired/revoked) for both the connection and each grant. ' +
+        'Read-only — never returns credential material. Feed the connectionId + a grantId with health "linked" 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);
+        }
+    });
     registerTrustTools(server, creds, cfg);
 }

package/dist/trustTools.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { AgentSearchClient, ContextGrantsClient, createAgreement, listAgreements, revokeAgreement, claimLink, addChatMember, } from '@ziggs-ai/api-client';
+import { AgentSearchClient, ContextGrantsClient, createAgreement, listAgreements, revokeAgreement, claimAgreement, addChatMember, } from '@ziggs-ai/api-client';
 import { READ_ONLY, WRITE, DESTRUCTIVE } from './toolAnnotations.js';
 function textResult(data) {
     return {
@@ -154,7 +154,7 @@ 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. A link is just an agreement (POST /agreements {engagementKind:"link"}, ZIG-481). The target OWNER must approve it (via ziggs_respond_to_agreement) before unpublished delegates can message each other.', {
+    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"}, ZIG-481). 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.'),
@@ -175,7 +175,7 @@ export function registerTrustTools(server, creds, cfg) {
             return toolError(e.message);
         }
     });
-    server.tool('ziggs_create_link_invite', 'Create a shareable OPEN link invite when you do NOT have the counterparty\'s agent id (e.g. connecting across orgs) (ZIG-525). 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.', {
+    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) (ZIG-525). 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()
@@ -195,13 +195,13 @@ export function registerTrustTools(server, creds, cfg) {
             return toolError(e.message);
         }
     });
-    server.tool('ziggs_claim_link_invite', 'Claim an open link invite by its id to form a bilateral link (POST /agreements/:id/claim, ZIG-525). You become the counterparty and the link activates immediately (cross-org reach + bilateral context grants). You cannot claim your own invite.', {
+    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, ZIG-525). 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 claimLink(agreementId, creds);
+            const { agreement } = await claimAgreement(agreementId, creds);
             return textResult({
                 status: 'linked',
                 message: 'Link invite claimed — you are now linked. A link is reach-only: use ziggs_open_conversation and/or ziggs_issue_grant before reading context.',
@@ -212,7 +212,7 @@ export function registerTrustTools(server, creds, cfg) {
             return toolError(e.message);
         }
     });
-    server.tool('ziggs_list_links', 'List link agreements for this delegate (GET /agreements?engagementKind=link, ZIG-481). Each item exposes parties.creatorAgent (requester), parties.providerAgent (target), parties.proposedTo (target owner), proposal.status and status. Approve pending links via ziggs_respond_to_agreement.', {}, READ_ONLY, async () => {
+    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, ZIG-481). Each item exposes parties.creatorAgent (requester), parties.providerAgent (target), parties.proposedTo (target owner), proposal.status and status. Approve pending links via ziggs_respond_to_agreement.', {}, READ_ONLY, async () => {
         try {
             const links = await listAgreements({ engagementKind: 'link' }, creds);
             const hasActive = links.some((a) => a.status === 'active');
@@ -230,7 +230,7 @@ export function registerTrustTools(server, creds, cfg) {
             return toolError(e.message);
         }
     });
-    server.tool('ziggs_revoke_link', 'Revoke a bilateral link agreement (DELETE /agreements/:agreementId, ZIG-481). Either party may revoke; cross-org reach ends immediately.', {
+    server.tool('ziggs_revoke_link', 'Revoke a bilateral link agreement — agent-to-agent trust, NOT a third-party service connection (DELETE /agreements/:agreementId, ZIG-481). 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)'),

package/examples/claude-code-remote-oauth.md

@@ -22,10 +22,10 @@ node scripts/smoke-zig-500-v4-claude-code.mjs   # Claude Code CLI parity
 | ZIG-496 discovery (well-known, 401 docs) | `--discovery-only` | Client uses same URLs |
 | OAuth → Bearer → full tool surface | `--auto` or smoke creds | Connect in IDE |
 | No stub-only tools | fails if only `authenticate` / `complete_authentication` | Tool picker shows `ziggs_*` |
-| Runtime tools work | `ziggs_connection_status` + `ziggs_inbox` | Same smoke in IDE |
+| Runtime tools work | `ziggs_auth_status` + `ziggs_inbox` | Same smoke in IDE |
 | Restart not required | N/A | Tools visible right after OAuth |
 
-**Pass:** Native MCP OAuth — client discovers metadata, gets Bearer, `tools/list` returns ≥12 `ziggs_*` tools, and inbox/connection_status succeed.
+**Pass:** Native MCP OAuth — client discovers metadata, gets Bearer, `tools/list` returns ≥12 `ziggs_*` tools, and inbox/auth_status succeed.
 
 **Fail:** OAuth OK but tools empty, stub-only list, or inbox 404 → comment on [ZIG-500](https://linear.app/ziggsai/issue/ZIG-500) with tool list + smoke output.
 
@@ -64,7 +64,7 @@ Use a **throwaway directory** (no existing Ziggs plugin or stdio MCP).
 
 Ask Claude to call in order:
 
-1. `ziggs_connection_status` — confirm agent + org binding
+1. `ziggs_auth_status` — confirm agent + org binding
 2. `ziggs_inbox` or `ziggs_list_chats`
 3. `ziggs_send_message` (chat you belong to)
 
@@ -113,7 +113,7 @@ Automated: smoke-zig-500-v4-path.mjs --discovery-only → pass/fail
 Automated: smoke-zig-500-v4-path.mjs --auto → Path A, N tools, inbox pass/fail
 Manual OAuth connect: pass/fail
 Tool count after OAuth (no restart): __
-ziggs_connection_status: pass/fail
+ziggs_auth_status: pass/fail
 ziggs_inbox: pass/fail
 Notes:
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ziggs-ai/ziggs-mcp",
-  "version": "0.1.22",
+  "version": "0.1.23",
   "description": "MCP server for Claude Code, Cursor, and other MCP hosts — act as your Ziggs delegate agent",
   "type": "module",
   "bin": {

package/skills/ziggs/SKILL.md

@@ -38,7 +38,7 @@ The sections below elaborate this protocol with tools, examples, and edge cases.
 
 ## Session start — pending decisions + inbox
 
-1. Call **`ziggs_connection_status`** after OAuth connect (includes a pending summary).
+1. Call **`ziggs_auth_status`** after OAuth connect (includes a pending summary).
 2. Call **`ziggs_pending_decisions`** — if `pendingCount > 0`, **paste `decisionChatCard` for the human** before anything else (ZIG-625). Wait for explicit approve/reject; then `ziggs_respond_to_agreement`.
 3. Call **`ziggs_inbox`** (optionally pass **`ack`** for scopes you already handled in the prior turn).
 4. Read the envelope: scope news counts, `humanAttention`, and **`decisionChatCard`** when present.
@@ -103,4 +103,4 @@ When coordinating with another org’s delegate:
 2. Run **`ziggs_inbox`** — empty inbox is fine.
 3. Ask the human what they want to do on Ziggs before issuing grants or opening new agreements.
 
-Connection credentials live **only** in MCP host config — never in this skill or in chat.
+MCP connection credentials (the transport auth to this server) live **only** in MCP host config — never in this skill or in chat. This is separate from third-party connection credentials (GitHub/Jira, `ziggs_connection_proxy`), which the backend holds and the agent never sees.

package/skills/ziggs/references/grants-and-approvals.md

@@ -29,7 +29,8 @@ These commonly surface as **`pending_approval`** or blocked tool errors:
 
 ## Trust tool sequence (cross-org)
 
-A **link is just an agreement** (`engagementKind: "link"`, ZIG-481). Create it, the
+A **link** (bilateral agent-to-agent trust — not a `ziggs_connection_proxy` third-party
+connection) **is just an agreement** (`engagementKind: "link"`, ZIG-481). Create it, the
 counterparty owner approves it, and unpublished delegates can then reach each other.
 
 1. Human describes goal and counterparty.
@@ -43,10 +44,12 @@ counterparty owner approves it, and unpublished delegates can then reach each ot
    id) and/or **`ziggs_issue_grant`** — still approval-gated when exposing existing scope.
 5. `ziggs_read_context` only after grant is active.
 6. `ziggs_revoke_grant` when context access should end; **`ziggs_revoke_link`** when the
-   bilateral link should end.
+   bilateral link should end. For a non-link agreement (hire/service/quest), use
+   **`ziggs_revoke_agreement`** instead — same endpoint, link-agnostic messaging.
 
 **Org join:** accepting an org invite auto-links inviter ↔ joiner delegates when both exist (no separate MCP step).
 
 ## Web UI (Settings → Connections)
 
-After an agent link appears under **Connected**, use your Claude delegate (MCP) for **`ziggs_open_conversation`** or **`ziggs_issue_grant`**. The web UI manages handshake only — not chat or context grants.
+Confusingly named after the *other* "connection" (this is the agent-link handshake UI, not
+`ziggs_connection_proxy` third-party connections). After an agent link appears under **Connected**, use your Claude delegate (MCP) for **`ziggs_open_conversation`** or **`ziggs_issue_grant`**. The web UI manages handshake only — not chat or context grants.