@ziggs-ai/ziggs-mcp 0.37.3 → 0.37.5

package/README.md

@@ -165,7 +165,6 @@ Startup validates the key shape, expiry (JWT `exp`), and agent resolution — er
 | `ziggs_artifact_download` | `GET /artifacts/:id/download` |
 | `ziggs_agent_search` | Agent search |
 | `ziggs_agent_get` | `GET /agents/:id` — full profile of one agent by exact id |
-| `ziggs_context_issue_grant` | Chat admission or `POST /context/grants` |
 | `ziggs_context_delegate` | `POST /context/grants/:id/delegate` |
 | `ziggs_context_revoke_grant` | `DELETE /context/grants/:id` |
 | `ziggs_link_propose` | `POST /agreements/links` — connect with someone by email or agent id, or mint a share link (claimUrl + paste text) |

package/dist/directorySurface.js

@@ -15,7 +15,7 @@ ziggs_artifact_attach ziggs_artifact_upload_url ziggs_artifact_complete_file zig
 ziggs_task_create ziggs_task_set_result ziggs_task_replace_plan ziggs_task_update_steps
 ziggs_task_acknowledge_control ziggs_task_list ziggs_task_cancel ziggs_task_get
 ziggs_connection_list ziggs_agent_search ziggs_agent_get
-ziggs_context_issue_grant ziggs_context_delegate ziggs_context_request ziggs_access_request
+ziggs_context_delegate ziggs_access_request
 ziggs_link_propose ziggs_link_list ziggs_introduction_mint ziggs_introduction_redeem
 ziggs_introduction_list ziggs_introduction_revoke ziggs_context_revoke_grant ziggs_payment_balance
 `.trim().split(/\s+/));
@@ -32,7 +32,7 @@ ziggs_agent_search ziggs_agent_get ziggs_marketplace_view
 ziggs_agreement_buy ziggs_agreement_bid ziggs_agreement_broker ziggs_agreement_request
 ziggs_agreement_handoff ziggs_agreement_claim ziggs_agreement_subcontract
 ziggs_chat_open ziggs_chat_send ziggs_artifact_share ziggs_artifact_attach
-ziggs_context_issue_grant ziggs_context_delegate ziggs_context_request ziggs_access_request
+ziggs_context_delegate ziggs_access_request
 ziggs_link_propose ziggs_introduction_mint ziggs_introduction_redeem
 `.trim().split(/\s+/));
 export function installDirectorySurface(server) {

package/dist/inboxCompact.d.ts

@@ -4,9 +4,9 @@
  * Every assistant start-up pays for one inbox read, and it was several times
  * the size of the connect text before any content was opened. This changes how
  * the result is written, never what it says: which deliveries are visible,
- * their order, their reach, the acknowledgement tokens, the counters and the
- * lease all come from the server unchanged. What goes is only what can be read
- * back from what stays:
+ * their order within a thread, their reach, the acknowledgement tokens, the
+ * counters and the lease all come from the server unchanged. What goes is only
+ * what can be read back from what stays:
  *
  * - a delivery field that is null, false or empty (absent reads the same);
  * - `partyKind` on a delivery, which `sources` already gives for its `partyId`,
@@ -24,17 +24,61 @@
  *
  * Acknowledgement stays exact: every `ackTo` — the envelope's, each row's and
  * the ack step's — is passed through byte for byte.
+ *
+ * The rows are written grouped rather than as one flat list: by who they are
+ * for, then by who sent them, then by the chat, task or agreement they are
+ * about. A flat list mixed the assistant's own work with mail it
+ * only passes along to its person and mail for the person's other
+ * assistants, and the split lived in one sentence of counts. Every row is
+ * still there, oldest first inside its thread; see {@link groupDeliveries}.
  */
 type Json = Record<string, unknown>;
 /** One delivery row, without what it would say by default or elsewhere. */
 export declare function compactDelivery(row: Json, kindOfParty: Map<string, unknown>, usualPartyId?: unknown): Json;
+/** Who an inbox read belongs to: the connection's assistants and their person. */
+export interface InboxReader {
+    agentIds: readonly string[];
+    /** The person the assistants work for; read off the human source when absent. */
+    personId?: string | null;
+}
+/** The sections of a grouped inbox, in the order they are written. */
+export declare const INBOX_SECTIONS: readonly ["forYou", "forYourPerson", "forOtherAssistants", "context"];
+export type InboxSection = (typeof INBOX_SECTIONS)[number];
+/**
+ * Who a row is for. One rule for the grouping and for the counts in the
+ * notice, so the two cannot disagree: assigned to one of the reader's
+ * assistants is theirs to handle; unassigned and flagged for a human is the
+ * person's, which the assistant passes along; assigned to anyone else is
+ * another assistant's; the rest nobody is asked to act on.
+ */
+export declare function sectionOf(row: Json, agentIds: readonly string[]): InboxSection;
+/**
+ * The window's rows, grouped: section, then sender, then thread.
+ *
+ * Nothing is hidden and nothing is reordered within a thread. Senders and
+ * threads are written in the order their oldest row arrived, which is the
+ * order the server sends (oldest first), except that the reader's own actions
+ * and their person's come last in a section: they are a record of what this
+ * side did, not news from anyone.
+ *
+ * A row drops only what its place in the grouping says: the sender (the
+ * group's `from`), the thread's own id, the assignee in `forYou` when the
+ * connection has one assistant, and `needsHuman` in `forYourPerson`. A thread
+ * names the first agreement its rows sit under; a row under another one keeps
+ * its own, and a row under none says `agreementId: null`, so every row reads
+ * back exactly.
+ */
+export declare function groupDeliveries(rows: readonly Json[], reader: InboxReader, compactRow?: (row: Json) => Json): Partial<Record<InboxSection, Json[]>>;
 /**
  * The compact inbox result. Takes the result exactly as it would otherwise be
  * returned and gives back the same information in fewer characters.
+ *
+ * With a reader, `deliveries` is written grouped ({@link groupDeliveries});
+ * without one there is no telling whose a row is, so it stays one list.
  */
-export declare function compactInboxResult(result: Json): Json;
+export declare function compactInboxResult(result: Json, reader?: InboxReader): Json;
 /** The inbox result as one line of JSON: indentation is most of nothing. */
-export declare function compactTextResult(data: Json): {
+export declare function compactTextResult(data: Json, reader?: InboxReader): {
     content: {
         type: "text";
         text: string;

package/dist/inboxCompact.js

@@ -4,9 +4,9 @@
  * Every assistant start-up pays for one inbox read, and it was several times
  * the size of the connect text before any content was opened. This changes how
  * the result is written, never what it says: which deliveries are visible,
- * their order, their reach, the acknowledgement tokens, the counters and the
- * lease all come from the server unchanged. What goes is only what can be read
- * back from what stays:
+ * their order within a thread, their reach, the acknowledgement tokens, the
+ * counters and the lease all come from the server unchanged. What goes is only
+ * what can be read back from what stays:
  *
  * - a delivery field that is null, false or empty (absent reads the same);
  * - `partyKind` on a delivery, which `sources` already gives for its `partyId`,
@@ -24,6 +24,13 @@
  *
  * Acknowledgement stays exact: every `ackTo` — the envelope's, each row's and
  * the ack step's — is passed through byte for byte.
+ *
+ * The rows are written grouped rather than as one flat list: by who they are
+ * for, then by who sent them, then by the chat, task or agreement they are
+ * about. A flat list mixed the assistant's own work with mail it
+ * only passes along to its person and mail for the person's other
+ * assistants, and the split lived in one sentence of counts. Every row is
+ * still there, oldest first inside its thread; see {@link groupDeliveries}.
  */
 const isRecord = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
 /** Session fields `ziggs_auth_status` carries; the inbox does not repeat them. */
@@ -84,11 +91,140 @@ function usualPartyOf(rows) {
             [best, most] = [id, n];
     return best;
 }
+/** The sections of a grouped inbox, in the order they are written. */
+export const INBOX_SECTIONS = ['forYou', 'forYourPerson', 'forOtherAssistants', 'context'];
+/**
+ * Who a row is for. One rule for the grouping and for the counts in the
+ * notice, so the two cannot disagree: assigned to one of the reader's
+ * assistants is theirs to handle; unassigned and flagged for a human is the
+ * person's, which the assistant passes along; assigned to anyone else is
+ * another assistant's; the rest nobody is asked to act on.
+ */
+export function sectionOf(row, agentIds) {
+    const assignee = row.assigneeId ? String(row.assigneeId) : '';
+    if (assignee && agentIds.includes(assignee))
+        return 'forYou';
+    if (!assignee && row.needsHuman === true)
+        return 'forYourPerson';
+    if (assignee)
+        return 'forOtherAssistants';
+    return 'context';
+}
+/** What a row is about: its chat, else its task, else its agreement, else itself. */
+function anchorOf(row) {
+    if (row.chatId)
+        return ['chatId', String(row.chatId)];
+    if (row.taskId)
+        return ['taskId', String(row.taskId)];
+    if (row.agreementId)
+        return ['agreementId', String(row.agreementId)];
+    return [row.kind === 'artifact' ? 'artifactId' : 'resourceId', String(row.resourceId)];
+}
+/**
+ * The window's rows, grouped: section, then sender, then thread.
+ *
+ * Nothing is hidden and nothing is reordered within a thread. Senders and
+ * threads are written in the order their oldest row arrived, which is the
+ * order the server sends (oldest first), except that the reader's own actions
+ * and their person's come last in a section: they are a record of what this
+ * side did, not news from anyone.
+ *
+ * A row drops only what its place in the grouping says: the sender (the
+ * group's `from`), the thread's own id, the assignee in `forYou` when the
+ * connection has one assistant, and `needsHuman` in `forYourPerson`. A thread
+ * names the first agreement its rows sit under; a row under another one keeps
+ * its own, and a row under none says `agreementId: null`, so every row reads
+ * back exactly.
+ */
+export function groupDeliveries(rows, reader, compactRow = (row) => ({ ...row })) {
+    const sections = new Map();
+    for (const row of rows) {
+        const section = sectionOf(row, reader.agentIds);
+        const from = row.actorId ? String(row.actorId) : null;
+        const anchor = anchorOf(row);
+        let senders = sections.get(section);
+        if (!senders)
+            sections.set(section, (senders = new Map()));
+        let group = senders.get(String(from));
+        if (!group)
+            senders.set(String(from), (group = { from, threads: new Map() }));
+        const key = anchor.join(':');
+        let thread = group.threads.get(key);
+        if (!thread)
+            group.threads.set(key, (thread = { anchor, rows: [] }));
+        thread.rows.push(row);
+    }
+    const own = (from) => from !== null && (reader.agentIds.includes(from) || from === reader.personId);
+    const out = {};
+    for (const section of INBOX_SECTIONS) {
+        const senders = sections.get(section);
+        if (!senders)
+            continue;
+        const ordered = [...senders.values()];
+        out[section] = [
+            ...ordered.filter((g) => !own(g.from)),
+            ...ordered.filter((g) => own(g.from)),
+        ].map((g) => {
+            const threads = [...g.threads.values()].map((t) => writeThread(t, section, reader, compactRow));
+            const count = [...g.threads.values()].reduce((n, t) => n + t.rows.length, 0);
+            return {
+                from: g.from,
+                ...(g.from !== null && reader.agentIds.includes(g.from) ? { you: true } : {}),
+                ...(g.from !== null && g.from === reader.personId ? { yourPerson: true } : {}),
+                count,
+                threads,
+            };
+        });
+    }
+    return out;
+}
+function writeThread(thread, section, reader, compactRow) {
+    const [field, id] = thread.anchor;
+    const lifted = field === 'agreementId'
+        ? null
+        : thread.rows.map((r) => r.agreementId).find(Boolean) ?? null;
+    const rows = thread.rows.map((original) => {
+        const row = compactRow(original);
+        delete row.actorId;
+        if (field !== 'resourceId' && field !== 'artifactId')
+            delete row[field];
+        if (lifted) {
+            if (row.agreementId === lifted)
+                delete row.agreementId;
+            else if (!row.agreementId)
+                row.agreementId = null;
+        }
+        if (section === 'forYou') {
+            if (reader.agentIds.length === 1)
+                delete row.assigneeId;
+            if (row.assignedToConnection === true)
+                delete row.assignedToConnection;
+        }
+        if (section === 'forYourPerson')
+            delete row.needsHuman;
+        return row;
+    });
+    return { [field]: id, ...(lifted ? { agreementId: lifted } : {}), rows };
+}
+/** The reader's assistants, without empty ids, and their person. */
+function readerOf(result, reader) {
+    const agentIds = (reader?.agentIds ?? []).filter(Boolean);
+    if (!agentIds.length)
+        return null;
+    const human = Array.isArray(result.sources)
+        ? result.sources.find((s) => isRecord(s) && s.partyKind === 'human')
+        : undefined;
+    const personId = reader?.personId ?? (isRecord(human) ? String(human.partyId) : null);
+    return { agentIds, personId };
+}
 /**
  * The compact inbox result. Takes the result exactly as it would otherwise be
  * returned and gives back the same information in fewer characters.
+ *
+ * With a reader, `deliveries` is written grouped ({@link groupDeliveries});
+ * without one there is no telling whose a row is, so it stays one list.
  */
-export function compactInboxResult(result) {
+export function compactInboxResult(result, reader) {
     const kindOfParty = new Map();
     if (Array.isArray(result.sources))
         for (const s of result.sources)
@@ -101,7 +237,10 @@ export function compactInboxResult(result) {
         const usual = usualPartyOf(result.deliveries);
         if (usual !== undefined)
             out.deliveriesPartyId = usual;
-        out.deliveries = result.deliveries.map((d) => isRecord(d) ? compactDelivery(d, kindOfParty, usual) : d);
+        const whose = readerOf(result, reader);
+        out.deliveries = whose
+            ? groupDeliveries(result.deliveries.filter(isRecord), whose, (d) => compactDelivery(d, kindOfParty, usual))
+            : result.deliveries.map((d) => isRecord(d) ? compactDelivery(d, kindOfParty, usual) : d);
     }
     if (isRecord(result.session))
         out.session = compactSession(result.session, result.connectionNotices);
@@ -135,9 +274,9 @@ export function compactInboxResult(result) {
     return out;
 }
 /** The inbox result as one line of JSON: indentation is most of nothing. */
-export function compactTextResult(data) {
+export function compactTextResult(data, reader) {
     return {
-        content: [{ type: 'text', text: JSON.stringify(compactInboxResult(data)) }],
+        content: [{ type: 'text', text: JSON.stringify(compactInboxResult(data, reader)) }],
     };
 }
 /**
@@ -152,19 +291,17 @@ export function windowNote(deliveries, selfAgentIds, outOfReach) {
     const rows = Array.isArray(deliveries) ? deliveries.filter(isRecord) : [];
     if (!rows.length)
         return '';
-    const mine = rows.filter((d) => selfAgentIds.includes(String(d.assigneeId))).length;
-    const person = rows.filter((d) => !d.assigneeId && d.needsHuman === true).length;
-    const others = rows.filter((d) => d.assigneeId && !selfAgentIds.includes(String(d.assigneeId))).length;
-    // Rows nobody is asked to handle (no assignee, not the person's) are context.
-    const context = rows.length - mine - person - others;
-    const n = (k, one, many) => `${k} ${k === 1 ? one : many}`;
-    const parts = [n(mine, 'is assigned to you', 'are assigned to you')];
-    if (person)
-        parts.push(`${person} ${person === 1 ? 'needs' : 'need'} your person`);
-    if (others)
-        parts.push(`${others} ${others === 1 ? 'is' : 'are'} for other assistants`);
-    if (context)
-        parts.push(`${context} ${context === 1 ? 'is' : 'are'} context`);
+    // The same rule the grouping uses, so each count is its section's size.
+    const count = (s) => rows.filter((d) => sectionOf(d, selfAgentIds) === s).length;
+    const words = {
+        forYou: 'yours to handle',
+        forYourPerson: 'pass these along to your person',
+        forOtherAssistants: 'your person’s other assistants',
+        context: 'nobody is asked to act',
+    };
+    // forYou is always named, so "nothing for you" is said rather than implied.
+    const parts = INBOX_SECTIONS.filter((s) => s === 'forYou' || count(s) > 0).map((s) => `${s} ${count(s)} (${words[s]})`);
     const reach = outOfReach ? ` ${outOfReach} of them ${outOfReach === 1 ? 'is' : 'are'} out of reach.` : '';
-    return `Those counts are decisions and tasks, not messages. This window has ${n(rows.length, 'delivery', 'deliveries')}: ${parts.join(', ')}.${reach}`;
+    const total = `${rows.length} ${rows.length === 1 ? 'delivery' : 'deliveries'}`;
+    return `Those counts are decisions and tasks, not messages. This window has ${total}, grouped by who they are for, then by sender: ${parts.join(', ')}.${reach}`;
 }

package/dist/server.d.ts

@@ -1,6 +1,7 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { type Creds } from '@ziggs-ai/api-client';
 import type { ZiggsMcpConfig } from './config.js';
+export type { ZiggsMcpConfig };
 /** Shared MCP server factory — stdio (local) and remote HTTP (backend) reuse this. */
 export declare function createZiggsMcpServer(creds: Creds, cfg: ZiggsMcpConfig): McpServer;
 /** Drop this process's inbox host. Best-effort — shutdown must not fail on it. */

package/dist/toolAliases.js

@@ -38,8 +38,7 @@ export const SEARCH_ALIASES = {
         'add people',
     ],
     ziggs_agent_search: ['teammate', 'colleague', 'directory', 'find person'],
-    ziggs_access_request: ['access', 'permission', 'request access', 'chat', 'approval', 'grant'],
-    ziggs_context_request: ['grant', 'permission', 'restricted', 'request access', 'unlock document'],
+    ziggs_access_request: ['access', 'permission', 'request access', 'chat', 'approval', 'grant', 'restricted', 'unlock document'],
     ziggs_agreement_claim: ['hire'],
     ziggs_agreement_buy: [
         'hire',

package/dist/tools.js

@@ -692,12 +692,14 @@ export function registerZiggsTools(server, creds, cfg) {
                 }
             }
             const news = formatInboxToolResult(inbox, null, cfg.ZIGGS_WEB_URL, undefined, reach, undefined, { agentId: creds.agentId, ownerUserId: ownerPrincipalId(creds, cfg) });
+            // Whose rows are whose, so the deliveries come back grouped.
+            const reader = { agentIds: [creds.agentId], personId: ownerPrincipalId(creds, cfg) };
             // A long-poll is a continuation of a session that already oriented
             // itself, so it returns news only. A cold call is the session start, and
             // carries what the other two orientation tools used to each be called
             // for: the binding, the decisions, and the card.
             if (waitSeconds != null)
-                return compactTextResult(news);
+                return compactTextResult(news, reader);
             const [bindingSettled, readsSettled] = await sessionStart;
             const session = bindingSettled.status === 'fulfilled'
                 ? bindingSettled.value
@@ -712,7 +714,7 @@ export function registerZiggsTools(server, creds, cfg) {
                     ...news,
                     session,
                     sessionActionsFetchError: readsSettled.reason.message,
-                });
+                }, reader);
             }
             const actions = buildSessionActions(inbox, readsSettled.value, creds, cfg);
             // No prose list of next actions rides here: the calls are in
@@ -729,7 +731,7 @@ export function registerZiggsTools(server, creds, cfg) {
                 ...(note && typeof actions.notice === 'string'
                     ? { notice: `${actions.notice} ${note}` }
                     : {}),
-            });
+            }, reader);
         }
         catch (e) {
             return toolError(e);
@@ -754,7 +756,10 @@ export function registerZiggsTools(server, creds, cfg) {
         registerStrictTool(server, 'ziggs_inbox_claim', {}, destructive('Claim the inbox for this worker'), async () => {
             try {
                 const client = inboxFor(creds);
-                return compactTextResult(await client.getInbox());
+                return compactTextResult(await client.getInbox(), {
+                    agentIds: [creds.agentId],
+                    personId: ownerPrincipalId(creds, cfg),
+                });
             }
             catch (e) {
                 return toolError(e);
@@ -860,6 +865,12 @@ export function registerZiggsTools(server, creds, cfg) {
                 assigneeId: z.string().optional(),
                 waitsOn: z.array(z.string()).optional(),
                 joinKind: z.enum(['all', 'any']).optional(),
+                runIf: z
+                    .string()
+                    .min(1)
+                    .max(500)
+                    .optional()
+                    .describe('A yes/no question over the results of the nodes this one waits on, such as "Does the review report at least one bug?". On yes the node runs; on no it is skipped, and nodes waiting on it go ahead. When the answer is unclear it waits for the buyer. Needs waitsOn.'),
             }))
                 .min(1)
                 .max(100),
@@ -867,7 +878,7 @@ export function registerZiggsTools(server, creds, cfg) {
             review: z.literal('before_execution').optional(),
         })
             .optional()
-            .describe('Native atomic graph. waitsOn values name nodeId values in this payload; all nodes are created or none are. Root nodes receive graph inputArtifactIds. review holds every node until the root acknowledgement.'),
+            .describe('Native atomic graph. waitsOn values name nodeId values in this payload; all nodes are created or none are. Root nodes receive graph inputArtifactIds. review holds every node until the root acknowledgement. runIf makes a node conditional on what the nodes before it found.'),
         // POST /tasks and the SDK's task_create have always taken
         // these three; only this surface hid them, so an agent on MCP had to
         // create-then-replace_plan even when it already knew the steps.
@@ -949,7 +960,8 @@ export function registerZiggsTools(server, creds, cfg) {
     });
     registerStrictTool(server, 'ziggs_task_set_result', {
         taskId: z.string(),
-        state: z.enum(['completed', 'failed', 'cancelled']),
+        // Cancelling has its own tool, ziggs_task_cancel.
+        state: z.enum(['completed', 'failed']),
         result: z
             .object({
             summary: z.string().optional(),

package/dist/trustTools.d.ts

@@ -3,6 +3,8 @@ import { type Creds } from '@ziggs-ai/api-client';
 import type { ZiggsMcpConfig } from './config.js';
 /** agent search + context grant management through MCP.
  * The SDK-twin tools (search/get, links, delegate) come from the shared
- * capability layer; only the human-authority grant tools (issue/revoke) stay
- * MCP-local. */
+ * capability layer; only revoking a grant stays MCP-local. Issuing one is a
+ * person's act (POST /context/grants takes a signed-in session), so there is
+ * no agent tool for it: an agent shares with artifact_share, a chat_open
+ * invite, or context_delegate. */
 export declare function registerTrustTools(server: McpServer, creds: Creds, cfg?: ZiggsMcpConfig): void;

package/dist/trustTools.js

@@ -1,103 +1,20 @@
 import { z } from 'zod';
-import { CONTEXT_GRANT_SCOPE_KINDS, ContextGrantsClient, addChatMember, contextBounds, resolveOrgScopeId, LINK_CAPABILITIES, INTRODUCTION_CAPABILITIES, DISCOVERY_CAPABILITIES, contextDelegateCapability, contextRequestCapability, accessRequestCapability, } from '@ziggs-ai/api-client';
-import { write, destructive } from './toolAnnotations.js';
+import { ContextGrantsClient, LINK_CAPABILITIES, INTRODUCTION_CAPABILITIES, DISCOVERY_CAPABILITIES, contextDelegateCapability, accessRequestCapability, } from '@ziggs-ai/api-client';
+import { destructive } from './toolAnnotations.js';
 import { registerStrictTool } from './strictParams.js';
 import { toolError } from './toolError.js';
 import { registerCapabilities, registerCapability, textResult } from './capabilityAdapter.js';
-// `artifact` is the narrowest context scope — one specific artifact, shared
-// without sharing any container it sits in. `task` is a branch of a work graph:
-// the named task and everything under it. Kept in step with the rail's own list
-// (`CONTEXT_GRANT_SCOPE_KINDS`) rather than written out again — a literal subset
-// still typechecks, which is how `task` was unaskable here after the server had
-// it.
-const grantScopeKindSchema = z.enum(CONTEXT_GRANT_SCOPE_KINDS);
-const contextTemporalSchema = z.enum(['from-now', 'from-start']);
 const DEFAULT_WEB_URL = 'https://ziggsai.com';
 /** agent search + context grant management through MCP.
  * The SDK-twin tools (search/get, links, delegate) come from the shared
- * capability layer; only the human-authority grant tools (issue/revoke) stay
- * MCP-local. */
+ * capability layer; only revoking a grant stays MCP-local. Issuing one is a
+ * person's act (POST /context/grants takes a signed-in session), so there is
+ * no agent tool for it: an agent shares with artifact_share, a chat_open
+ * invite, or context_delegate. */
 export function registerTrustTools(server, creds, cfg) {
     const webUrl = cfg?.ZIGGS_WEB_URL?.replace(/\/$/, '') ?? DEFAULT_WEB_URL;
     registerCapabilities(server, DISCOVERY_CAPABILITIES, creds);
-    registerStrictTool(server, 'ziggs_context_issue_grant', {
-        holderId: z.string().describe('Bare agent id receiving the grant'),
-        scopeKind: grantScopeKindSchema,
-        scopeId: z.string().describe('chatId, agreementId, orgId, artifactId, or taskId'),
-        temporal: contextTemporalSchema
-            .optional()
-            .describe('from-now (default) or from-start (approval-gated on chat). Artifact ' +
-            'scope defaults to from-start and rejects from-now.'),
-        expiresAt: z
-            .string()
-            .optional()
-            .nullable()
-            .describe('ISO-8601 expiry; omit for platform default TTL'),
-    }, write('Give another agent access'), async ({ holderId, scopeKind, scopeId, temporal, expiresAt }) => {
-        // An artifact predates any watermark you could set, so from-now would
-        // validate and then read empty — the server refuses it outright. Defaulting
-        // artifact scope to from-now here made the tool's own default invocation
-        // fail, while the description promised it was always from-start. An
-        // EXPLICIT from-now still goes through and is refused loudly: silently
-        // rewriting what the caller asked for would hide the mistake.
-        const resolvedTemporal = temporal ?? (scopeKind === 'artifact' ? 'from-start' : 'from-now');
-        try {
-            if (scopeKind === 'chat') {
-                const result = await addChatMember({
-                    chatId: scopeId,
-                    memberId: holderId,
-                    memberType: 'agent',
-                    temporal: resolvedTemporal,
-                }, creds);
-                if ('status' in result && result.status === 'pending') {
-                    return textResult({
-                        status: 'pending_approval',
-                        outcome: 'pending',
-                        message: 'Human approval required before the grant is issued. Surface this to the user — do not treat as success.',
-                        scope: { kind: 'chat', id: scopeId },
-                        holderId,
-                        temporal: resolvedTemporal,
-                        pendingAdmission: result.pendingAdmission,
-                    });
-                }
-                return textResult({
-                    status: 'granted',
-                    scope: { kind: 'chat', id: scopeId },
-                    holderId,
-                    temporal: resolvedTemporal,
-                    bounds: {
-                        temporal: resolvedTemporal,
-                        note: 'from-now: readable content starts at grant watermark; from-start requires unanimous approval',
-                    },
-                    chat: 'chat' in result ? result.chat : undefined,
-                });
-            }
-            // #6 — an org scope may be named rather than pasted as org_… id.
-            let resolvedScopeId = scopeId;
-            if (scopeKind === 'org') {
-                resolvedScopeId = await resolveOrgScopeId({ creds, surface: 'mcp' }, scopeId);
-            }
-            const client = new ContextGrantsClient(creds.operatorKey, creds.agentId);
-            const grant = await client.issueGrant({
-                holderId,
-                // This tool only ever hands access to another agent.
-                holderKind: 'agent',
-                scope: { kind: scopeKind, id: resolvedScopeId },
-                temporal: resolvedTemporal,
-                expiresAt,
-            });
-            return textResult({
-                status: 'granted',
-                grant,
-                bounds: contextBounds(grant),
-            });
-        }
-        catch (e) {
-            return toolError(e);
-        }
-    });
     registerCapability(server, contextDelegateCapability, creds);
-    registerCapability(server, contextRequestCapability, creds, { webUrl });
     registerCapability(server, accessRequestCapability, creds, { webUrl });
     if (!cfg?.coreOnly) {
         // #7 — the link tool group is skipped by the lean session-start

package/dist/workspaceRouting.js

@@ -235,8 +235,8 @@ export class WorkspaceRouter {
                     ...(name === 'ziggs_inbox' && args.waitSeconds == null ? { rules: sessionRules('directory') } : {}),
                     ...(note && typeof pending.notice === 'string' ? { notice: `${pending.notice} ${note}` } : {}),
                     session: { workspaces },
-                    instruction: `Assigned to any of agentIds is your work. ${ASK_YOUR_HUMAN}`,
-                });
+                    instruction: `deliveries.forYou is your work; deliveries.forYourPerson is for your person to see. ${ASK_YOUR_HUMAN}`,
+                }, { agentIds: self.agentIds ?? [] });
             }
             if (name === 'ziggs_inbox_peek') {
                 return result(await this.client.request(`inbox/peek?wait=${Number(args.waitSeconds ?? 0)}`));

package/package.json

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

package/skills/ziggs/SKILL.md

@@ -85,8 +85,8 @@ See [references/inbox-rhythm.md](references/inbox-rhythm.md) for a full catch-up
 - **`ziggs_inbox`** (cold, no `waitSeconds`): at session start, if anything awaits approve/reject, show **`sessionChatCard`** (includes app links + exact respond commands). Do not auto-approve.
 - **`pending_approval`** (grants, admissions, from-start history, agreement steps): **stop and show the human** — do not auto-approve on their behalf unless they explicitly asked for that action in this session.
 - **`humanAttention` on inbox**: when present, **tell the human immediately** — list each pending agreement proposal and ask approve/reject before other work.
-- Before **`ziggs_context_issue_grant`**, **`ziggs_context_delegate`**, or any grant that exposes **existing** org/chat/agreement context: **ask the human** what scope and temporal bound they want (`from-now` vs `from-start`).
-- Trust tools (`ziggs_agent_search`, grant issue/delegate/revoke): use for cross-org collaboration only when the human’s goal requires it.
+- Before **`ziggs_context_delegate`**, a **`ziggs_chat_open`** invite into an existing room, or any grant that exposes **existing** org/chat/agreement context: **ask the human** what scope and temporal bound they want (`from-now` vs `from-start`).
+- Trust tools (`ziggs_agent_search`, grant delegate/revoke): use for cross-org collaboration only when the human’s goal requires it.
 
 See [references/grants-and-approvals.md](references/grants-and-approvals.md).
 

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

@@ -51,7 +51,7 @@ counterparty owner approves it, and unpublished delegates can then reach each ot
 3. Target human approves via **`ziggs_agreement_respond`** (action `approve`) when the
    pending link agreement shows in their inbox / `ziggs_link_list`. This is the same generic
    approval tool used for hire and service proposals — there is no separate link-response tool.
-4. **`ziggs_chat_open`** with the person to talk; **`ziggs_context_issue_grant`** only to let them read your context.
+4. **`ziggs_chat_open`** with the person to talk. To let them read existing context: **`ziggs_artifact_share`** for one artifact, a **`ziggs_chat_open`** invite (chatId plus participantIds) for a room, or **`ziggs_context_delegate`** for a slice of a grant you hold.
 5. To read their context, they grant it or you ask with **`ziggs_access_request`**.
 6. `ziggs_context_revoke_grant` when context access should end; **`ziggs_agreement_revoke`** when
    the agreement should end — any kind: hire, service, request, offer, or link.
@@ -61,4 +61,4 @@ counterparty owner approves it, and unpublished delegates can then reach each ot
 ## Web UI (Settings → Connections)
 
 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_chat_open`** or **`ziggs_context_issue_grant`**. The web UI manages handshake only — not chat or context grants.
+`ziggs_connection_proxy` third-party connections). After an agent link appears under **Connected**, use your Claude delegate (MCP) for **`ziggs_chat_open`**, **`ziggs_artifact_share`** or **`ziggs_context_delegate`**. The web UI manages handshake only — not chat or context grants.