@ziggs-ai/api-client 0.38.2 → 0.39.1

package/dist/capabilities/mcpBriefs.js

@@ -53,16 +53,16 @@ const BRIEFS = {
         changes: 'nothing is approved or rejected. The decision stays pending.',
     },
     ziggs_session_list: {
-        does: 'Lists your open windows: name, app, awake or not, and the chats each holds. Sibling windows of the same assistant key.',
+        does: 'Lists your open windows: name, app, awake or not, and the executions each holds. Sibling windows of the same assistant key.',
         returns: 'sessions[] for this assistant',
-        next: 'ziggs_session_hold to take a chat in this window',
+        next: 'ziggs_session_hold to route an execution to this window',
     },
     ziggs_session_hold: {
-        does: 'Holds a chat in this window (the X-Ziggs-Session host). Pulls it off any sibling that held it.',
-        changes: 'moves which window holds the chat; does not send a message',
+        does: 'Routes an authorized execution to this window (the X-Ziggs-Session host). Removes its routing hint from siblings.',
+        changes: 'changes session routing, not authority or responsibility',
     },
     ziggs_context_snapshot: {
-        does: 'Reads the context of a task, agreement or chat: workBrief (who acts, for whom, with which authority and actions), its ancestors, dependencies, history and artifacts.',
+        does: 'Reads authorized context for an explicit message, artifact, task or agreement.',
         returns: 'a cursor for more messages',
     },
     // Agreements
@@ -120,32 +120,19 @@ const BRIEFS = {
         does: 'Ends an agreement you provide, for good, once its whole scope is delivered. A finished task closes with ziggs_task_set_result instead.',
         changes: 'revokes every grant it conferred; it cannot be reopened',
     },
-    // Rooms
-    ziggs_chat_list: {
-        does: 'Lists rooms you hold a grant on, with last message and unread count, plus the rooms a person let you list, marked readable: false with no message and the read request to file. fields adds members or rosterSummary.',
-    },
-    ziggs_chat_open: {
-        does: 'Opens or reuses a conversation with a person or agent (participantId), starts a group (participantIds), or invites people into a room (chatId).',
-        changes: 'creates the room or invitation; sends no message',
-        next: 'ziggs_chat_send',
-    },
-    ziggs_chat_send: {
-        does: 'Sends a message as you into a room where you hold an active write grant; a refusal names what is missing. First contact goes through ziggs_chat_open.',
-        changes: 'delivers the message; it cannot be unsent',
-    },
-    // Reading context
+    // Resource context
     ziggs_open: {
-        does: 'Reads one task, agreement, chat or artifact by ref: a handle like T7K2QXD, a Ziggs URL or an id. Returns the actions you may take. Hidden and unknown look the same. Messages under one agreement: ziggs_context_read.',
+        does: 'Reads an authorized resource by handle, URL or id, with available actions. Hidden and unknown look the same. For agreement messages use ziggs_message_list.',
     },
     ziggs_access_explain: {
-        does: 'Explains what you may do with one artifact, chat, task or agreement, and the recovery calls; runs none of them.',
+        does: 'Explains what you may do with one resource, and the recovery calls; runs none of them.',
     },
     ziggs_context_read: {
-        does: 'Reads messages, artifacts, agreements or tasks in a scope you hold, via chat:, agreement:, task: or artifact:<id>.',
+        does: 'Reads artifacts, agreements or tasks via agreement:, task: or artifact:<id>. Use ziggs_message_read for exact messages. Preserves selected work and resource scope.',
         returns: 'a readPlan with the next call pre-filled',
     },
     ziggs_context_expand_reach: {
-        does: 'Lists the chat and agreement ids a grant you hold covers, as labels only.',
+        does: 'Lists resource references covered by a grant you hold, as labels only.',
     },
     ziggs_context_discover_grantable: {
         does: 'Lists context in workspaces you work in that you cannot read yet, as labels only.',
@@ -156,7 +143,7 @@ const BRIEFS = {
         does: 'Lists grants you hold, or with role issuer the grants you caused. An empty list means no grants of your own, not no access.',
     },
     ziggs_access_request: {
-        does: 'Asks for access to an artifact, chat, agreement or task for this agent. recipientId names who decides (a refusal lists who you can ask); an artifact needs chatId.',
+        does: 'Requests access to a specific resource. recipientId names the approver; refusals list eligible approvers. No conversation is needed.',
         changes: 'creates a pending approval; grants nothing until approved',
     },
     ziggs_context_delegate: {
@@ -182,6 +169,13 @@ const BRIEFS = {
         does: 'Shares one artifact you authored with another agent.',
         changes: 'grants it at once to a connected agent; otherwise asks your owner to approve (pending_approval)',
     },
+    ziggs_message_send: { does: 'Sends a canonical command with independent readers, recipients, answer effect and optional mandate.', changes: 'delivers a message and grants its readers access' },
+    ziggs_message_replies: { does: 'Reads authorized causal replies by messageId; a reference grants no access and receipt expiry does not erase history.' },
+    ziggs_message_read: { does: 'Reads an exact message by messageId under current access and execution policy. Does not acknowledge its receipt.' },
+    ziggs_message_list: { does: 'Queries authorized messages by participants, agreement or task. Filters select history, not authority.' },
+    ziggs_message_controls: { does: 'Inspects recipients and authority for an explicit agreement or task without reading history.' },
+    ziggs_message_answers: { does: 'Reads durable answer requests and their outcomes independently of inbox acknowledgment.' },
+    ziggs_message_answer_cancel: { does: 'Cancels one exact pending answer request as its author.', changes: 'closes the request without deleting history or cancelling tasks' },
     ziggs_task_delegate: {
         does: 'Delegates work, returns a child output, or rechecks readiness.',
         changes: 'creates or returns isolated work',
@@ -196,8 +190,8 @@ const BRIEFS = {
         changes: 'attaches that output once',
     },
     ziggs_artifact_attach: {
-        does: 'Attaches an artifact you can read to a chat, task or agreement you belong to.',
-        changes: 'everyone in it can read the artifact',
+        does: 'Links an authorized artifact to an explicit task or agreement, subject to work and source-disclosure checks.',
+        changes: 'records the permitted task or agreement artifact link',
     },
     ziggs_artifact_upload_url: {
         does: 'Gives a presigned upload URL for a file too large to pass to ziggs_artifact_record.',
@@ -255,7 +249,7 @@ const BRIEFS = {
     },
     ziggs_link_list: {
         does: 'Lists your links. peer.id is the person on the other side.',
-        next: 'ziggs_chat_open with peer.id',
+        next: 'ziggs_message_send with an explicit command naming peer.id',
     },
     ziggs_introduction_mint: {
         does: 'Mints an introduction string, optionally about a chat, task or agreement you hold. Anyone holding it can redeem it.',
@@ -285,7 +279,7 @@ const BRIEFS = {
     },
     ziggs_connection_request: {
         does: 'Asks a person to connect an MCP server and grant you its tools.',
-        changes: 'posts a consent card in the chat you pass',
+        changes: 'requests consent in the recipient’s inbox for explicit message/work context',
     },
     ziggs_connection_proxy: {
         does: 'Calls a named connector (GitHub, Jira) under a grant, without seeing the credential. MCP servers are refused (Unknown provider: mcp).',

package/dist/capabilities/messaging.d.ts

@@ -0,0 +1,9 @@
+import { type CapabilityDefinition } from './types.js';
+export declare const readMessageCapability: CapabilityDefinition;
+export declare const sendMessageCapability: CapabilityDefinition;
+export declare const readRepliesCapability: CapabilityDefinition;
+export declare const queryMessagesCapability: CapabilityDefinition;
+export declare const messageControlsCapability: CapabilityDefinition;
+export declare const messageAnswersCapability: CapabilityDefinition;
+export declare const cancelAnswerCapability: CapabilityDefinition;
+export declare const MESSAGING_CAPABILITIES: CapabilityDefinition[];

package/dist/capabilities/messaging.js

@@ -0,0 +1,11 @@
+import { MessageRecordsClient } from '../http/MessageRecordsClient.js';
+import { fullCreds } from './types.js';
+const client = (env) => { const creds = fullCreds(env); return new MessageRecordsClient(creds.operatorKey, creds.agentId, env.baseUrl); };
+export const readMessageCapability = { key: 'message_read', names: { sdk: 'message_read', mcp: 'ziggs_message_read' }, title: 'Read exact message', descriptions: { sdk: 'Read one authorized message. Returns content, independent readers/recipients, requested-answer action slots and authorized relationships. Does not acknowledge delivery.' }, annotation: 'read-only', needsAgentId: true, params: { messageId: { type: 'string', required: true } }, handler: (args, env) => client(env).get(String(args.messageId)) };
+export const sendMessageCapability = { key: 'message_send', names: { sdk: 'message_send', mcp: 'ziggs_message_send' }, title: 'Send message', descriptions: { sdk: 'Send the canonical command: operationId; content:{text}; audience:{kind:"explicit",principalIds:[...]}; deliveries:{kind:"explicit",principalIds:[...]}; effect:{kind:"none"} or request-answers:{requests:[{requestId,responsiblePrincipalId}]} or answer:{action:{kind:"message",id,slot:"answer",requestId},artifacts:[]} or provide-input:{action}. Optional mandate:{agreementId,taskId}, relationships:{replyToMessageId,taskIds,artifacts}, exact sources. Reuse operationId unchanged on retry. A causal reply alone never resolves an answer. No room required.' }, annotation: 'destructive', needsAgentId: true, params: { command: { type: 'object', required: true, description: 'MessageCommand with explicit independent audience, deliveries, action effect and optional mandate.' } }, handler: (args, env) => client(env).send(args.command) };
+export const readRepliesCapability = { key: 'message_replies', names: { sdk: 'message_replies', mcp: 'ziggs_message_replies' }, title: 'Read replies', descriptions: { sdk: 'Read currently authorized causal replies; links never grant access. Continue using nextCursor as before.' }, annotation: 'read-only', needsAgentId: true, params: { messageId: { type: 'string', required: true }, before: { type: 'string' }, limit: { type: 'number' } }, handler: (args, env) => client(env).replies(String(args.messageId), { before: args.before, limit: args.limit }) };
+export const queryMessagesCapability = { key: 'message_list', names: { sdk: 'message_list', mcp: 'ziggs_message_list' }, title: 'Query messages', descriptions: { sdk: 'Query the same authorized message records by agreementId, taskId or participantIds. These filters select history, never authority. No address or conversation required.' }, annotation: 'read-only', needsAgentId: true, params: { q: { type: 'string' }, senderId: { type: 'string' }, recipientIds: { type: 'array', items: { type: 'string' } }, agreementId: { type: 'string' }, taskId: { type: 'string' }, participantIds: { type: 'array', items: { type: 'string' } }, before: { type: 'string' }, limit: { type: 'number' } }, handler: (args, env) => client(env).list(args) };
+export const messageControlsCapability = { key: 'message_controls', names: { sdk: 'message_controls', mcp: 'ziggs_message_controls' }, title: 'Inspect message mandate', descriptions: { sdk: 'Discover recipients and current authority under an explicitly selected agreement/task without reading message history.' }, annotation: 'read-only', needsAgentId: true, params: { q: { type: 'string' }, senderId: { type: 'string' }, recipientIds: { type: 'array', items: { type: 'string' } }, agreementId: { type: 'string', required: true }, taskId: { type: 'string' } }, handler: (args, env) => client(env).controls(String(args.agreementId), args.taskId) };
+export const messageAnswersCapability = { key: 'message_answers', names: { sdk: 'message_answers', mcp: 'ziggs_message_answers' }, title: 'Read answer requests', descriptions: { sdk: 'Read durable requested-answer outcomes independently of inbox ACK state.' }, annotation: 'read-only', needsAgentId: true, params: { messageId: { type: 'string', required: true } }, handler: (args, env) => client(env).answers(String(args.messageId)) };
+export const cancelAnswerCapability = { key: 'message_answer_cancel', names: { sdk: 'message_answer_cancel', mcp: 'ziggs_message_answer_cancel' }, title: 'Cancel answer request', descriptions: { sdk: 'As the request author, cancel one exact pending answer slot. Does not delete history or cancel tasks.' }, annotation: 'destructive', needsAgentId: true, params: { messageId: { type: 'string', required: true }, requestId: { type: 'string', required: true } }, handler: (args, env) => client(env).cancelAnswer(String(args.messageId), String(args.requestId)) };
+export const MESSAGING_CAPABILITIES = [readMessageCapability, sendMessageCapability, readRepliesCapability, queryMessagesCapability, messageControlsCapability, messageAnswersCapability, cancelAnswerCapability];

package/dist/capabilities/nextCall.js

@@ -1,6 +1,6 @@
 /**
  * Fields that name a party to reach. A `psn_` persona face is display state
- * and must never be offered here — chat_open / chat_send refuse it, and the
+ * and must never be offered here — chat_open / message_send refuse it, and the
  * baseline's provider learned that only by being refused.
  */
 const ADDRESS_FIELDS = [
@@ -9,6 +9,7 @@ const ADDRESS_FIELDS = [
     'receiverId',
     'counterparty',
     'executorId',
+    'holderId',
 ];
 /**
  * Required arguments for the capability keys this helper is asked to emit.
@@ -18,8 +19,9 @@ const ADDRESS_FIELDS = [
  * these against live `CapabilityDefinition.params` for keys that have one.
  */
 const REQUIRED_ARGS = {
-    chat_open: ['participantId'],
-    chat_send: ['chatId'],
+    message_read: ['messageId'],
+    message_replies: ['messageId'],
+    message_send: ['command'],
     agreement_claim: ['agreementId'],
     agreement_get: ['agreementId'],
     agreement_buy: ['counterparty', 'description'],
@@ -39,8 +41,9 @@ const REQUIRED_ARGS = {
  * until a ready arg fills them — an incomplete call must not invent an id.
  */
 const HTTP_BINDINGS = {
-    chat_open: { method: 'POST', path: '/chats' },
-    chat_send: { method: 'POST', path: '/chats/:chatId/messages' },
+    message_send: { method: 'POST', path: '/messaging/messages' },
+    message_replies: { method: 'GET', path: '/messaging/messages/:messageId/replies' },
+    message_read: { method: 'GET', path: '/messaging/messages/:messageId' },
     introduction_list: { method: 'GET', path: '/introductions' },
     introduction_mint: { method: 'POST', path: '/introductions' },
     introduction_redeem: { method: 'POST', path: '/introductions/:token/redeem' },
@@ -99,9 +102,6 @@ const MATERIAL_EFFECTS = {
     link_propose: {
         relationship: 'proposes a reach-only link; nothing is shared until they accept',
     },
-    chat_open: {
-        disclosure: 'opening a room issues the other side a grant on it',
-    },
     task_create: {
         commitment: 'creates a task under the named agreement',
     },
@@ -225,20 +225,11 @@ export function nextCall(env, capabilityKey, args, why, opts) {
         filled[key] = value;
     }
     for (const name of requiredArgNames(capabilityKey, opts?.definition)) {
-        if (capabilityKey === 'chat_open' && name === 'participantId' && Array.isArray(filled.participantIds) && filled.participantIds.length > 0)
-            continue;
         if (!isFilled(filled[name])) {
             if (!missing.includes(name))
                 missing.push(name);
         }
     }
-    if (capabilityKey === 'chat_open' && (!opts?.definition || 'participantIds' in opts.definition.params)) {
-        if (!filled.participantId && !(Array.isArray(filled.participantIds) && filled.participantIds.length > 0) && !missing.includes('participantId')) {
-            missing.push('participantId');
-        }
-        if (Array.isArray(filled.participantIds) && !filled.chatId && !filled.idempotencyKey)
-            missing.push('idempotencyKey');
-    }
     const hold = opts?.hold;
     const ready = missing.length === 0 && !hold;
     const outcome = opts?.outcome ??

package/dist/capabilities/sources.d.ts

@@ -7,7 +7,7 @@ import type { CapabilityParam } from './types.js';
 export declare const WRITE_SOURCE_KINDS: readonly ["message", "artifact", "task_result", "task_plan_step", "url"];
 export type WriteSourceKind = (typeof WRITE_SOURCE_KINDS)[number];
 /**
- * - `message`: `id` is the messageId, `chatId` its room.
+ * - `message`: `id` is the globally unique messageId.
  * - `artifact`: `id` is the artifactId.
  * - `task_result`: `id` is the taskId.
  * - `task_plan_step`: `id` is the stepId, `taskId` its task.
@@ -16,12 +16,11 @@ export type WriteSourceKind = (typeof WRITE_SOURCE_KINDS)[number];
 export interface WriteSource {
     kind: WriteSourceKind;
     id?: string;
-    chatId?: string;
     taskId?: string;
     value?: string;
 }
 /** One line, shared by every tool that takes `sources`: it is repeated per tool. */
-export declare const SOURCES_DESCRIPTION = "What this text drew on: {kind,id} for a message (+chatId), artifact, task_result or task_plan_step (+taskId); {kind:\"url\",value} outside. [] = nothing more.";
+export declare const SOURCES_DESCRIPTION = "Sources: {kind,id}; task_plan_step adds taskId. External: {kind:\"url\",value}. [] adds none.";
 export declare const SOURCES_PARAM: CapabilityParam;
 /** The `sources` a tool call carried, ready for the request body. */
 export declare function sourcesArg(args: Record<string, unknown>): {

package/dist/capabilities/sources.js

@@ -11,7 +11,7 @@ export const WRITE_SOURCE_KINDS = [
     'url',
 ];
 /** One line, shared by every tool that takes `sources`: it is repeated per tool. */
-export const SOURCES_DESCRIPTION = 'What this text drew on: {kind,id} for a message (+chatId), artifact, task_result or task_plan_step (+taskId); {kind:"url",value} outside. [] = nothing more.';
+export const SOURCES_DESCRIPTION = 'Sources: {kind,id}; task_plan_step adds taskId. External: {kind:"url",value}. [] adds none.';
 export const SOURCES_PARAM = {
     type: 'array',
     description: SOURCES_DESCRIPTION,
@@ -20,7 +20,6 @@ export const SOURCES_PARAM = {
         properties: {
             kind: { type: 'string', enum: WRITE_SOURCE_KINDS },
             id: { type: 'string' },
-            chatId: { type: 'string' },
             taskId: { type: 'string' },
             value: { type: 'string' },
         },

package/dist/capabilities/tasks.js

@@ -35,7 +35,7 @@ export const listTasksCapability = {
         },
         createdByMe: {
             type: 'boolean',
-            description: 'Tasks YOU created — the work you handed out to others. This is the check before delegating: assignedToMe lists only what was handed TO you, so a job you already assigned does not appear there and you would assign it twice.',
+            description: 'Work you delegated. Check before assigning again; assignedToMe only lists work assigned to you.',
         },
         assignedToMe: {
             type: 'boolean',

package/dist/capabilities/toolLane.js

@@ -1,7 +1,7 @@
+import { MESSAGING_CAPABILITIES } from './messaging.js';
 import { AGREEMENT_CAPABILITIES } from './agreements.js';
 import { AGREEMENT_VERB_CAPABILITIES, LISTING_DOOR_CAPABILITIES, agreementSubcontractCapability, } from './agreementVerbs.js';
 import { ARTIFACT_CAPABILITIES } from './artifacts.js';
-import { CHAT_CAPABILITIES } from './chat.js';
 import { CONNECTION_CAPABILITIES } from './connections.js';
 import { CONTEXT_CAPABILITIES } from './context.js';
 import { DISCOVERY_CAPABILITIES } from './discovery.js';
@@ -13,12 +13,12 @@ import { PARTY_CAPABILITIES } from './parties.js';
 import { PAYMENT_CAPABILITIES } from './payments.js';
 import { TASK_CAPABILITIES } from './tasks.js';
 const CAPABILITIES = [
+    ...MESSAGING_CAPABILITIES,
     ...AGREEMENT_CAPABILITIES,
     ...AGREEMENT_VERB_CAPABILITIES,
     agreementSubcontractCapability,
     ...LISTING_DOOR_CAPABILITIES,
     ...ARTIFACT_CAPABILITIES,
-    ...CHAT_CAPABILITIES,
     ...CONNECTION_CAPABILITIES,
     ...CONTEXT_CAPABILITIES,
     ...DISCOVERY_CAPABILITIES,

package/dist/engagementGuide.d.ts

@@ -33,7 +33,7 @@ export interface EngagementGuide {
     outcome: EngagementOutcome;
     summary: string;
     /** Room the brief arrived in — never a substitute for agreementId. */
-    chatId?: string | null;
+    addressId?: string | null;
     agreementId?: string | null;
     taskId?: string | null;
     waitingOn?: WaitingOn | null;
@@ -138,7 +138,7 @@ export declare function marketplaceFormation(env: CapabilityEnv, input: {
  */
 export declare function contactPath(env: CapabilityEnv, input: ContactPathInput): EngagementGuide;
 export declare function hireWorkOrderGuide(env: CapabilityEnv, delivery: InboxDeliveryRef): EngagementGuide;
-export declare function strangerBriefGuide(env: CapabilityEnv, chatId: string | null): EngagementGuide;
+export declare function strangerBriefGuide(env: CapabilityEnv, addressId: string | null): EngagementGuide;
 export declare function duplicateGuide(): EngagementGuide;
 /**
  * First engagement that matters on this envelope. Empty mail with no held

package/dist/engagementGuide.js

@@ -226,8 +226,8 @@ export function contactPath(env, input) {
             outcome: 'ok',
             summary: sameOrg && !linked
                 ? 'Same-org person: reach them under this scoped identity.'
-                : 'Linked person: open or continue the working room. A link does not reveal their org roster.',
-            next: nextCall(env, 'chat_open', { participantId: partyId }, 'reach this person in a working room'),
+                : 'Linked person: choose an explicit message audience and delivery. A link does not reveal their org roster.',
+            next: nextCall(env, 'message_send', undefined, `send an explicit message command to ${partyId}; choose readers, delivery and answer responsibility separately`),
         };
     }
     if (partyKind === 'person' && !linked) {
@@ -258,7 +258,7 @@ export function hireWorkOrderGuide(env, delivery) {
     return {
         kind: 'work_order',
         outcome: 'ok',
-        chatId: delivery.chatId,
+        addressId: delivery.addressId,
         agreementId,
         summary: 'A brief from the principal in this hire is a work order. Create a task on yourself under that agreement. Fill the description from the brief after you read it. When you need helpers, declare a graph — do not invent worker_next.',
         next: nextCall(env, 'task_create', {
@@ -267,11 +267,11 @@ export function hireWorkOrderGuide(env, delivery) {
         }, 'create the work order on yourself under this hire'),
     };
 }
-export function strangerBriefGuide(env, chatId) {
+export function strangerBriefGuide(env, addressId) {
     return {
         kind: 'stranger_brief',
         outcome: 'pending',
-        chatId,
+        addressId,
         summary: "A stranger's brief is not a work order. They hire you through your store listing, or through an agreement you draft when you have none; do not create a task under a hire you do not have.",
         next: nextCall(env, 'agreement_request', undefined, 'draft the agreement this brief would ride', { definition: agreementRequestCapability }),
     };
@@ -311,7 +311,7 @@ export function inboxEngagement(input) {
     }
     const stranger = mine.find((d) => d.kind === 'message' && !d.agreementId);
     if (stranger) {
-        return strangerBriefGuide(env, stranger.chatId);
+        return strangerBriefGuide(env, stranger.addressId);
     }
     const held = tasks.find((t) => t.heldByDeps);
     if (held) {

package/dist/handles.d.ts

@@ -7,7 +7,7 @@
  * call. The server stays the judge of what the handle opens.
  */
 export declare const HANDLE_ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-export type HandleKind = 'task' | 'agreement' | 'chat' | 'artifact';
+export type HandleKind = 'task' | 'agreement' | 'address' | 'artifact';
 /** The handle's kind and its upper-case form, or null when it is not one. */
 export declare function parseHandle(raw: string): {
     kind: HandleKind;

package/dist/handles.js

@@ -7,7 +7,7 @@
  * call. The server stays the judge of what the handle opens.
  */
 export const HANDLE_ALPHABET = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
-const LETTER_KIND = { T: 'task', A: 'agreement', C: 'chat', F: 'artifact' };
+const LETTER_KIND = { T: 'task', A: 'agreement', C: 'address', F: 'artifact' };
 const N = HANDLE_ALPHABET.length;
 function checkHolds(handle) {
     let factor = 1;
@@ -36,7 +36,7 @@ const OLD_SHAPES = [
     [/^task_[0-9a-f-]{36}$/, 'task'],
     [/^agr_[A-Za-z0-9_]+$/, 'agreement'],
     [/^(art_|org-state-)[A-Za-z0-9_-]+$/, 'artifact'],
-    [/^[a-z]{24}$/, 'chat'],
+    [/^[a-z]{24}$/, 'address'],
 ];
 /** The shape of a handle, whether or not its check letter holds. */
 export function looksLikeHandle(raw) {

package/dist/http/AgreementClient.d.ts

@@ -43,17 +43,8 @@ export interface ProposeTerms {
 /** 1:1 proposal to a specific user or agent (`proposedTo` = their id). */
 export interface ProposeDirectInput extends ProposeTerms {
     proposedTo: string;
-    /**
-     * The room the terms are discussed in, when there is one.
-     *
-     * Optional, matching the server, which has always accepted a proposal
-     * without one. Delivery does not depend on it: the create-time agreement
-     * event targets the party slots, so the counterparty is told either way; a
-     * room only gives them somewhere to talk about it. Required here was what
-     * forced a bookkeeping agreement between parties with no conversation to
-     * invent a chat id in order to exist.
-     */
-    chatId?: string;
+    /** Optional display-reference context for resolving a masked party; does not publish or share. */
+    addressId?: string;
 }
 /**
  * Open buyer-broadcast. `audience` selects who may see/claim it:
@@ -133,8 +124,6 @@ export interface DelegateAgreementData {
     /** What this text drew on. See {@link WriteSource}. */
     sources?: WriteSource[];
     executorId: string;
-    /** Omit it and the server uses the parent agreement's own chat. */
-    chatId?: string;
     parentAgreementId: string;
     price?: number;
     lifecycle?: string;
@@ -264,10 +253,15 @@ export interface CreateLinkBody {
      * Needs `to`.
      */
     about?: {
-        kind: 'agreement' | 'task' | 'chat';
+        kind: 'agreement' | 'task' | 'address';
         id: string;
     };
 }
+export interface WriteSuccess {
+    success: boolean;
+    /** @deprecated Use success. */
+    ok: boolean;
+}
 /**
  * The route's answer.
  *
@@ -287,8 +281,7 @@ export interface CreateLinkBody {
  * Without it a caller could not reference what it had just created, check on it
  * later, or tell a repeat from a first attempt.
  */
-export interface CreateLinkResult {
-    ok: boolean;
+export interface CreateLinkResult extends WriteSuccess {
     status: 'sent';
     /** The link row, for a named agent id or an open invite. Null for an email. */
     agreementId: string | null;
@@ -304,14 +297,12 @@ export interface CreateLinkResult {
  * carries links and nothing else.
  */
 export declare function createLink(body: CreateLinkBody, creds: Creds): Promise<CreateLinkResult>;
-export declare function revokeAgreement(agreementId: string, creds: Creds): Promise<{
-    ok: boolean;
+export declare function revokeAgreement(agreementId: string, creds: Creds): Promise<WriteSuccess & {
     agreement: Agreement;
 }>;
 /** mark an agreement fulfilled (complete). A provider closing its own
  * delivered work — party-gated server-side. */
-export declare function fulfillAgreement(agreementId: string, creds: Creds): Promise<{
-    ok: boolean;
+export declare function fulfillAgreement(agreementId: string, creds: Creds): Promise<WriteSuccess & {
     agreement: Agreement;
 }>;
 /** What an open-broadcast claim resolved to. ⚠️ Mirrors the server; it is authoritative. */
@@ -344,11 +335,6 @@ export interface ClaimOptions {
      * verifies the claim against the acting agent and never guesses one.
      */
     mandateAgreementId?: string;
-    /**
-     * The room a hire of a listing is made in. On activation its
-     * agent joins that room; the claimer must take part in it.
-     */
-    chatId?: string;
     /**
      * Your connection for each kind of access the listing asks for,
      * `{ <kind>: <connectionId> }`. The hire is granted exactly that connection. A claim made inside a job (mandateAgreementId)
@@ -356,42 +342,15 @@ export interface ClaimOptions {
      */
     connections?: Record<string, string>;
     /**
-     * Who a hire of a listing is for. `me` (the default) keeps its room to the
-     * person; `workspace` makes the workspace the payer and shows the room to
-     * every member.
+     * Who a hire is for. `me` keeps the agreement private; `workspace` makes
+     * the workspace the payer and shares work with its members.
      */
     hireFor?: 'me' | 'workspace';
 }
-/**
- * Where a hire made in a room stands on getting its agent in.
- * `ready` only once the agent is in; `admission_failed` names the action that
- * resumes it without hiring or charging again.
- */
-export interface ClaimRoom {
-    chatId?: string;
-    status: 'awaiting_approval' | 'ready' | 'admission_failed' | 'preparation_failed' | 'unavailable';
-    message?: string;
-    recovery?: {
-        method: string;
-        path: string;
-        tool?: string;
-        args?: Record<string, unknown>;
-    };
-}
-export declare function claimAgreement(agreementId: string, creds: Creds, opts?: ClaimOptions): Promise<{
-    ok: boolean;
+export declare function claimAgreement(agreementId: string, creds: Creds, opts?: ClaimOptions): Promise<WriteSuccess & {
     agreement: Agreement;
     kind?: ClaimedKind;
-    room?: ClaimRoom;
 }>;
-/**
- * Link types a caller may ask for. `origin` and `delegation` are workflow-owned;
- * callers may only pin an agreement into a chat as a reference (`mention`).
- */
-export declare const CHAT_LINK_TYPES: readonly ["mention"];
-export type ChatLinkType = (typeof CHAT_LINK_TYPES)[number];
-export declare function linkAgreementToChat(agreementId: string, chatId: string, linkType: ChatLinkType | undefined, creds: Creds): Promise<unknown | null>;
-export declare function getChatsForAgreement(agreementId: string, creds: Creds): Promise<unknown[]>;
 export declare const ARTIFACT_LINK_TYPES: readonly ["produced", "referenced"];
 export type ArtifactLinkType = (typeof ARTIFACT_LINK_TYPES)[number];
 export declare function linkArtifactToAgreement(agreementId: string, artifactId: string, linkType: ArtifactLinkType | undefined, creds: Creds): Promise<unknown | null>;
@@ -417,22 +376,16 @@ export declare class AgreementClient {
     listMine(filters?: GetMyAgreementsFilters): Promise<Agreement[]>;
     get(id: string): Promise<Agreement | null>;
     createLink(data: CreateLinkBody): Promise<CreateLinkResult>;
-    revoke(id: string): Promise<{
-        ok: boolean;
+    revoke(id: string): Promise<WriteSuccess & {
         agreement: Agreement;
     }>;
-    fulfill(id: string): Promise<{
-        ok: boolean;
+    fulfill(id: string): Promise<WriteSuccess & {
         agreement: Agreement;
     }>;
-    claimAgreement(id: string): Promise<{
-        ok: boolean;
+    claimAgreement(id: string): Promise<WriteSuccess & {
         agreement: Agreement;
         kind?: ClaimedKind;
-        room?: ClaimRoom;
     }>;
-    linkToChat(id: string, chatId: string, linkType?: ChatLinkType): Promise<unknown>;
-    listChats(id: string): Promise<unknown[]>;
     linkArtifact(id: string, artifactId: string, linkType?: ArtifactLinkType): Promise<unknown>;
     listArtifacts(id: string): Promise<unknown[]>;
 }