@ziggs-ai/ziggs-mcp 0.1.28 → 0.1.30

package/dist/tools.js

@@ -171,6 +171,49 @@ 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_discover_context 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 — cross-connection discovery: every connection this agent holds a
  * grant for, joined with provider + health, so ziggs_connection_proxy's
@@ -345,19 +388,40 @@ export function registerZiggsTools(server, creds, cfg) {
                 : 'Next: ziggs_inbox or ziggs_pending_decisions at session start.',
         });
     });
-    server.tool('ziggs_switch_org', 'Switch which org this MCP OAuth session acts in without reconnecting. Existing Bearer unchanged; runtime org flips server-side. Requires confirm=true (party-identity change). Target org must be one you belong to. Call ziggs_auth_status after to verify actingOrgId.', {
-        orgId: z.string().describe('Organization id to act in'),
+    server.tool('ziggs_list_my_orgs', 'List every org you (the operator) belong to — { orgId, name, kind, role }. Unlike ziggs_discover_context (granted scopes only), this is your full membership, so you can resolve an org name to an id and offer the human a pick-list before ziggs_switch_org.', {}, READ_ONLY, async () => {
+        try {
+            const orgs = await fetchMyOrgs(creds);
+            return textResult({ count: orgs.length, orgs });
+        }
+        catch (e) {
+            return toolError(e.message);
+        }
+    });
+    server.tool('ziggs_switch_org', 'Switch which org this MCP OAuth session acts in without reconnecting. Existing Bearer unchanged; runtime org flips server-side. Requires confirm=true (party-identity change). Accepts an org id (org_...) OR an org name — names resolve against your memberships (see ziggs_list_my_orgs); an ambiguous name returns the candidates. Call ziggs_auth_status after to verify actingOrgId.', {
+        org: z
+            .string()
+            .describe('Org id (org_...) or org name to act in — must be one you belong to'),
         confirm: z
             .literal(true)
             .describe('Must be true — confirms the human approved switching acting org'),
-    }, WRITE, async ({ orgId, confirm }) => {
+    }, WRITE, async ({ org, confirm }) => {
         if (confirm !== true) {
             return toolError('confirm must be true — org switch changes which workspace you act in');
         }
+        const selector = org.trim();
         try {
-            const result = await rebindDelegateOrg(creds, orgId.trim());
+            const orgs = await fetchMyOrgs(creds);
+            const resolved = resolveOrgSelector(orgs, selector);
+            if (resolved.status === 'ambiguous') {
+                return toolError(`"${selector}" matches ${resolved.matches.length} orgs — switch by exact orgId. Candidates: ${JSON.stringify(resolved.matches)}`);
+            }
+            if (resolved.status === 'not-found') {
+                return toolError(`No org matches "${selector}". You belong to: ${JSON.stringify(orgs)}`);
+            }
+            const result = await rebindDelegateOrg(creds, resolved.orgId);
             return textResult({
                 ok: true,
+                resolvedOrgId: resolved.orgId,
                 ...result,
                 note: result.unchanged
                     ? 'Already acting in this org — no changes made.'
@@ -475,13 +539,22 @@ export function registerZiggsTools(server, creds, cfg) {
             .string()
             .optional()
             .describe('Usually "message" for user-visible chat'),
-    }, WRITE, async ({ chatId, receiverId, text, entryType }) => {
+        idempotencyKey: z
+            .string()
+            .optional()
+            .describe('Retry-safe key. Reuse the SAME key when re-sending the SAME logical message (e.g. after a network error/timeout) so it is stored and delivered exactly once — the backend dedupes on chatId + messageId. Use a fresh key (or omit) for a genuinely new message.'),
+    }, WRITE, async ({ chatId, receiverId, text, entryType, idempotencyKey }) => {
         try {
             const result = await sendChatMessage({
                 chatId,
                 receiverId,
                 text,
-                messageId: `mcp_${randomUUID()}`,
+                // A stable idempotencyKey maps to a stable messageId so a retried
+                // logical send collapses to one row/one delivery (ZIG-718 backend
+                // dedupe); otherwise each call is a distinct message.
+                messageId: idempotencyKey
+                    ? `mcp_idem_${idempotencyKey}`
+                    : `mcp_${randomUUID()}`,
                 entryType: entryType ?? 'message',
                 contentType: 'text',
             }, creds);
@@ -656,6 +729,16 @@ export function registerZiggsTools(server, creds, cfg) {
             return toolError(e.message);
         }
     });
+    server.tool('ziggs_discover_grantable', 'See what context EXISTS in your orgs that you CANNOT read yet — so you can ask for it instead of failing blind. Returns labels only: { type, label, scopeRef, orgId } per item, never content, member names, tokens, or money. Bounded to orgs you have an active agreement in. To act on one, ask your human to grant it, or (if you hold a broader grant of your own) delegate via ziggs_delegate_grant using the scopeRef. Use ziggs_discover_context for what you already hold; this is what you lack.', {}, READ_ONLY, async () => {
+        try {
+            const client = new ContextDiscoveryClient(creds.operatorKey, creds.agentId);
+            const items = await client.discoverGrantable();
+            return textResult({ count: items.length, items });
+        }
+        catch (e) {
+            return toolError(e.message);
+        }
+    });
     server.tool('ziggs_read_context', 'Read the contents of a scope you already hold: messages | artifacts | agreements | tasks (the type param), under via=chat:<id>, agreement:<id>, or task:<id>. Forward-delta with after+direction=forward; cursor pagination; contextGrantId pins a grant. The response carries a `readPlan` with the next page and/or forward-delta call pre-filled (after=this page\'s latestSequence), so you can keep reading without rebuilding args. This is the single read path for all four types — to discover which scopes exist (your chats / tasks / agreements / grants / links), use the ziggs_list_* tools.', {
         type: contextReadTypeSchema.describe('Resource type to read'),
         via: z
@@ -746,9 +829,13 @@ export function registerZiggsTools(server, creds, cfg) {
             .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 }) => {
+        inputArtifactIds: z
+            .array(z.string())
+            .optional()
+            .describe('Artifact ids this task consumes as structured inputs (ZIG-734) — pass prior-step output handles without embedding them in description'),
+    }, WRITE, async ({ agreementId, description, parentTaskId, assigneeId, inputArtifactIds }) => {
         try {
-            const task = await createTask({ agreementId, description, parentTaskId, assigneeId }, creds);
+            const task = await createTask({ agreementId, description, parentTaskId, assigneeId, inputArtifactIds }, creds);
             return textResult({ ok: true, task });
         }
         catch (e) {

package/dist/trustTools.js

@@ -110,7 +110,7 @@ export function registerTrustTools(server, creds, cfg) {
             return toolError(e.message);
         }
     });
-    server.tool('ziggs_delegate_grant', 'Delegate a narrower child grant from one you hold (POST /context/grants/:id/delegate). Delegation only narrows scope/expiry/temporal — never broadens.', {
+    server.tool('ziggs_delegate_grant', 'Delegate a narrower child grant from one you hold (POST /context/grants/:id/delegate). Delegation only narrows scope/expiry/temporal — never broadens. If the grant\'s original owner is a different party, this does NOT grant — it opens a request that owner must approve, and returns { status: "pending_approval", agreementId }; surface that to the human and do not treat it as done.', {
         parentGrantId: z.string(),
         holderId: z.string().describe('Agent receiving the delegated grant'),
         scopeKind: grantScopeKindSchema,
@@ -124,13 +124,23 @@ export function registerTrustTools(server, creds, cfg) {
     }, WRITE, async ({ parentGrantId, holderId, scopeKind, scopeId, temporal, expiresAt, watermarkAt, }) => {
         try {
             const client = new ContextGrantsClient(creds.operatorKey, creds.agentId);
-            const grant = await client.delegateGrant(parentGrantId, {
+            const result = await client.delegateGrant(parentGrantId, {
                 holderId,
                 scope: { kind: scopeKind, id: scopeId },
                 temporal,
                 expiresAt,
                 watermarkAt,
             });
+            if (result.status === 'pending_approval') {
+                return textResult({
+                    status: 'pending_approval',
+                    message: "This grant's original owner must approve sharing it. A request was opened for them — surface it to the human; nothing is granted yet.",
+                    parentGrantId,
+                    agreementId: result.agreementId,
+                    ownerId: result.ownerId,
+                });
+            }
+            const grant = result.grant;
             return textResult({
                 status: 'delegated',
                 parentGrantId,
@@ -265,7 +275,7 @@ export function registerTrustTools(server, creds, cfg) {
             return toolError(e.message);
         }
     });
-    server.tool('ziggs_revoke_grant', 'Revoke a context grant and its descendants (DELETE /context/grants/:id). Requires context:admin on the operator key.', {
+    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 issued or whose scope you own, but do not hold, requires context:admin.', {
         grantId: z.string(),
     }, DESTRUCTIVE, async ({ grantId }) => {
         try {

package/package.json

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

package/skills/ziggs/SKILL.md

@@ -39,7 +39,7 @@ The sections below elaborate this protocol with tools, examples, and edge cases.
 ## Session start — pending decisions + inbox
 
 1. Call **`ziggs_auth_status`** after OAuth connect — check **`actingOrgId`** / **`actingOrgName`** (runtime org, not JWT).
-2. To switch org without reconnecting: **`ziggs_switch_org`** with `confirm: true`, then re-check **`ziggs_auth_status`**.
+2. To switch org without reconnecting: **`ziggs_switch_org`** (`org` = an org id **or** a name, `confirm: true`), then re-check **`ziggs_auth_status`**. Don't make the human paste an `org_...` id — call **`ziggs_list_my_orgs`** to resolve a name and offer a pick-list; an ambiguous name returns the candidates.
 3. Call **`ziggs_pending_decisions`** — if `pendingCount > 0`, **paste `decisionChatCard` for the human** before anything else. 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.