@ziggs-ai/api-client 0.8.0 → 0.9.1

package/dist/http/ChatClient.js

@@ -7,6 +7,9 @@ function buildHeaders(creds) {
         'content-type': 'application/json',
         Authorization: `Bearer ${creds.operatorKey}`,
         'X-Agent-Id': creds.agentId,
+        // ZIG-1092 — the wake's lane, so the backend can fence this call to the
+        // engagement it belongs to rather than the agent's whole authority.
+        ...(creds.laneId ? { 'X-Ziggs-Lane': creds.laneId } : {}),
     };
 }
 function assertCreds(creds, op) {
@@ -101,7 +104,7 @@ export async function listMyChats(creds) {
     assertCreds(creds, 'list my chats');
     // ZIG-699 — empty array only for a genuine empty 200; any failure (non-2xx /
     // network) throws so ziggs_chat_list reports a real error instead of "you
-    // have no chats". Status stays whitespace-delimited for toolError classification.
+    // have no chats". ZIG-1124 — HTTP failures are ApiError (status/body/code).
     let res;
     try {
         res = await fetch(`${getBackendUrl()}/chats/mine`, {
@@ -116,7 +119,7 @@ export async function listMyChats(creds) {
     if (!res.ok) {
         const body = await res.text().catch(() => '');
         runtimeLog.warn('ChatClient', `⚠️ listMyChats failed: ${res.status} ${res.statusText} ${body?.slice(0, 200)}`);
-        throw new Error(`GET /chats/mine ${res.status} ${body?.slice(0, 200)}`);
+        throwApiError(res, body, `GET /chats/mine failed: ${res.status}`);
     }
     const data = await res.json().catch(() => null);
     return Array.isArray(data?.['chats']) ? data['chats'] : [];

package/dist/http/ConnectionsClient.js

@@ -1,5 +1,6 @@
 import 'dotenv/config';
 import { getBackendUrl } from '../utils/urlUtils.js';
+import { throwApiError } from '../shared/apiError.js';
 import { buildOperatorHeaders } from './operatorHeaders.js';
 import { GrantsClient } from './GrantsClient.js';
 // ZIG-569 — defense-in-depth mirror of the backend leak-guard
@@ -169,10 +170,9 @@ export class ConnectionsClient {
         const response = await fetch(`${this.baseUrl}${path}`, init);
         const text = await response.text().catch(() => '');
         if (!response.ok) {
-            const err = new Error(`${method} ${path} ${response.status} ${text.slice(0, 200)}`);
-            err.status = response.status;
-            err.body = text;
-            throw err;
+            // ZIG-1124 — ApiError (status/body/code); ConnectionsError remains the
+            // documented duck type for callers that branch on `.status`.
+            throwApiError(response, text, `${method} ${path} failed: ${response.status}`);
         }
         return text;
     }

package/dist/http/ContextDiscoveryClient.js

@@ -1,5 +1,6 @@
 import 'dotenv/config';
 import { getBackendUrl } from '../utils/urlUtils.js';
+import { throwApiError } from '../shared/apiError.js';
 import { buildOperatorHeaders } from './operatorHeaders.js';
 /**
  * P4 discovery — labels-only pointers to context the agent could REQUEST but
@@ -34,7 +35,7 @@ export class ContextDiscoveryClient {
         });
         const body = await res.text().catch(() => '');
         if (!res.ok) {
-            throw new Error(`ContextDiscoveryClient.discoverGrantable ${res.status} ${body.slice(0, 200)}`);
+            throwApiError(res, body, `ContextDiscoveryClient.discoverGrantable failed: ${res.status}`);
         }
         const parsed = JSON.parse(body);
         return (parsed.items ?? []).map((i) => ({

package/dist/http/ContextReadClient.d.ts

@@ -1,5 +1,28 @@
 import 'dotenv/config';
-export type ContextReadType = 'messages' | 'artifacts' | 'agreements' | 'tasks';
+export declare const CONTEXT_READ_TYPES: readonly ["messages", "artifacts", "agreements", "tasks"];
+export type ContextReadType = (typeof CONTEXT_READ_TYPES)[number];
+/**
+ * Entry points a read can name as `via=<kind>:<id>` — the server's `parseVia`
+ * grammar. `counterparty` parses but reads nothing: it resolves a scope graph,
+ * not content, which is why {@link CONTEXT_READ_VIA} admits it for no type.
+ */
+export declare const VIA_KINDS: readonly ["chat", "agreement", "task", "counterparty", "artifact"];
+export type ViaKind = (typeof VIA_KINDS)[number];
+/**
+ * Which entry points each read type actually accepts, mirroring the server's
+ * `CONTEXT_READ_VIA`. Stated once here so the tool descriptions, the argument
+ * check, and this type all read off the same list instead of three prose
+ * copies that drift — and so a wrong pairing is refused with the reason rather
+ * than as a bare 400 from a round-trip away.
+ */
+export declare const CONTEXT_READ_VIA: Record<ContextReadType, readonly ViaKind[]>;
+/** `chat:<id>, agreement:<id>` — the accepted entries for one read type, for humans. */
+export declare function viaHint(type: ContextReadType): string;
+/** Split `chat:abc` into its parts, or null when it is not a `via` at all. */
+export declare function parseVia(via: string): {
+    kind: ViaKind;
+    id: string;
+} | null;
 export interface ContextReadQuery {
     via: string;
     cursor?: string;
@@ -12,7 +35,7 @@ export interface ContextReadQuery {
 export interface ContextReadEnvelope<T = unknown> {
     type: ContextReadType;
     via: {
-        kind: string;
+        kind: ViaKind;
         id: string;
     };
     items: T[];
@@ -44,11 +67,15 @@ export declare class ContextReadClient {
     private readonly operatorKey;
     private readonly agentId?;
     private readonly baseUrl;
+    private readonly laneId?;
     /**
      * @param operatorKey Agent-scoped or fleet operator key.
      * @param agentId Required for fleet keys (sent as X-Agent-Id). Omit for agent-scoped keys.
+     * @param laneId ZIG-1092 — the wake's lane, sent as X-Ziggs-Lane. This is the
+     *   path the dogfood leak ran through: `via=artifact:<other customer's spec>`
+     *   was authorised purely because the same agent had authored it.
      */
-    constructor(operatorKey: string, agentId?: string, baseUrl?: string);
+    constructor(operatorKey: string, agentId?: string, baseUrl?: string, laneId?: string);
     read<T = unknown>(type: ContextReadType, query: ContextReadQuery): Promise<ContextReadEnvelope<T>>;
     /**
      * Aggregated chat snapshot — `GET /context/snapshot?via=chat:<id>`. The

package/dist/http/ContextReadClient.js

@@ -1,6 +1,54 @@
 import 'dotenv/config';
 import { getBackendUrl } from '../utils/urlUtils.js';
 import { pollSurfaceError } from '../shared/rateLimit.js';
+export const CONTEXT_READ_TYPES = [
+    'messages',
+    'artifacts',
+    'agreements',
+    'tasks',
+];
+/**
+ * Entry points a read can name as `via=<kind>:<id>` — the server's `parseVia`
+ * grammar. `counterparty` parses but reads nothing: it resolves a scope graph,
+ * not content, which is why {@link CONTEXT_READ_VIA} admits it for no type.
+ */
+export const VIA_KINDS = [
+    'chat',
+    'agreement',
+    'task',
+    'counterparty',
+    'artifact',
+];
+/**
+ * Which entry points each read type actually accepts, mirroring the server's
+ * `CONTEXT_READ_VIA`. Stated once here so the tool descriptions, the argument
+ * check, and this type all read off the same list instead of three prose
+ * copies that drift — and so a wrong pairing is refused with the reason rather
+ * than as a bare 400 from a round-trip away.
+ */
+export const CONTEXT_READ_VIA = {
+    messages: ['chat'],
+    artifacts: ['chat', 'agreement', 'task', 'artifact'],
+    agreements: ['chat', 'agreement'],
+    tasks: ['agreement', 'task'],
+};
+/** `chat:<id>, agreement:<id>` — the accepted entries for one read type, for humans. */
+export function viaHint(type) {
+    return CONTEXT_READ_VIA[type].map((k) => `${k}:<id>`).join(', ');
+}
+/** Split `chat:abc` into its parts, or null when it is not a `via` at all. */
+export function parseVia(via) {
+    const at = via.indexOf(':');
+    if (at <= 0)
+        return null;
+    const kind = via.slice(0, at);
+    const id = via.slice(at + 1);
+    if (!id)
+        return null;
+    return VIA_KINDS.includes(kind)
+        ? { kind: kind, id }
+        : null;
+}
 /**
  * Protocol-first uniform context reads (ZIG-427).
  * Wraps `GET /context/read/:type` — one client, one envelope, four types.
@@ -9,16 +57,21 @@ export class ContextReadClient {
     operatorKey;
     agentId;
     baseUrl;
+    laneId;
     /**
      * @param operatorKey Agent-scoped or fleet operator key.
      * @param agentId Required for fleet keys (sent as X-Agent-Id). Omit for agent-scoped keys.
+     * @param laneId ZIG-1092 — the wake's lane, sent as X-Ziggs-Lane. This is the
+     *   path the dogfood leak ran through: `via=artifact:<other customer's spec>`
+     *   was authorised purely because the same agent had authored it.
      */
-    constructor(operatorKey, agentId, baseUrl) {
+    constructor(operatorKey, agentId, baseUrl, laneId) {
         if (!operatorKey)
             throw new Error('ContextReadClient: operatorKey is required');
         this.operatorKey = operatorKey;
         this.agentId = agentId;
         this.baseUrl = baseUrl || getBackendUrl();
+        this.laneId = laneId;
     }
     async read(type, query) {
         if (!query.via?.trim()) {
@@ -44,24 +97,19 @@ export class ContextReadClient {
         };
         if (this.agentId)
             headers['X-Agent-Id'] = this.agentId;
+        if (this.laneId)
+            headers['X-Ziggs-Lane'] = this.laneId;
         if (query.contextGrantId) {
             headers['X-Context-Grant-Id'] = query.contextGrantId;
         }
         const res = await fetch(url.toString(), { headers });
         const body = await res.text().catch(() => '');
         if (!res.ok) {
-            // Carry the status like `snapshot()` does, so callers can branch on it.
             // A 403 here is a legitimate outcome, not a transport failure: addressing
             // and authorisation are separate, so an agent can be told about mail it
-            // is not (or is no longer) allowed to open.
-            // ZIG-1019: a 429 carries the server's own wait; everything else keeps
-            // the plain status-tagged error callers already branch on.
-            if (res.status === 429) {
-                throw pollSurfaceError(`ContextReadClient.read ${type}`, res, body);
-            }
-            const err = new Error(`ContextReadClient.read ${type} ${res.status} ${body.slice(0, 200)}`);
-            err.status = res.status;
-            throw err;
+            // is not (or is no longer) allowed to open. ZIG-1124 — one ApiError shape
+            // (429 → RateLimitedError with Retry-After).
+            throw pollSurfaceError(`ContextReadClient.read ${type}`, res, body);
         }
         return JSON.parse(body);
     }
@@ -88,18 +136,16 @@ export class ContextReadClient {
         };
         if (this.agentId)
             headers['X-Agent-Id'] = this.agentId;
+        if (this.laneId)
+            headers['X-Ziggs-Lane'] = this.laneId;
         if (opts.contextGrantId) {
             headers['X-Context-Grant-Id'] = opts.contextGrantId;
         }
         const res = await fetch(url.toString(), { headers });
         const body = await res.text().catch(() => '');
         if (!res.ok) {
-            if (res.status === 429) {
-                throw pollSurfaceError('ContextReadClient.snapshot', res, body);
-            }
-            const err = new Error(`ContextReadClient.snapshot ${res.status} ${body.slice(0, 200)}`);
-            err.status = res.status;
-            throw err;
+            // ZIG-1124 — ApiError for every non-OK (429 → RateLimitedError).
+            throw pollSurfaceError('ContextReadClient.snapshot', res, body);
         }
         return JSON.parse(body);
     }

package/dist/http/GrantsClient.js

@@ -1,5 +1,6 @@
 import 'dotenv/config';
 import { getBackendUrl } from '../utils/urlUtils.js';
+import { throwApiError } from '../shared/apiError.js';
 import { buildOperatorHeaders } from './operatorHeaders.js';
 /**
  * ZIG-648 — unified grant listing across every rail. `GET /grants` returns the
@@ -41,7 +42,7 @@ export class GrantsClient {
         });
         const body = await res.text().catch(() => '');
         if (!res.ok) {
-            throw new Error(`GrantsClient.listGrants ${res.status} ${body.slice(0, 200)}`);
+            throwApiError(res, body, `GrantsClient.listGrants failed: ${res.status}`);
         }
         const parsed = JSON.parse(body);
         return {

package/dist/http/InboxClient.d.ts

@@ -1,11 +1,21 @@
 import 'dotenv/config';
+/**
+ * What a delivery can be about. A closed union, not a comment: a consumer that
+ * dispatches on `kind` (the MCP read plan) is only safe if the compiler can tell
+ * it a case is missing. The task-only deliverable that was acked unread got
+ * through precisely because this was `string`.
+ *
+ * A type and not a value list, unlike the backend's `RESOURCE_KINDS` — nothing
+ * on this side validates a delivery kind at runtime (the server does that on the
+ * way in), and exhaustiveness checking is purely type-level.
+ */
+export type InboxDeliveryKind = 'message' | 'artifact' | 'task-state' | 'agreement';
 /**
  * One thing addressed to this agent. A reference, never content — following it
  * (a chat read, a task read) is where this agent's grants are enforced.
  */
 export interface InboxDeliveryRef {
-    /** 'message' | 'artifact' | 'task-state' | 'agreement'. */
-    kind: string;
+    kind: InboxDeliveryKind;
     resourceId: string;
     chatId: string | null;
     agreementId: string | null;
@@ -24,16 +34,35 @@ export interface InboxProposalRef {
     agreementId: string;
     title: string;
     proposedAt: string | null;
+    /**
+     * ZIG-1087 — party ids still owing a decision, and the named responder slot.
+     * The inbox lists proposals awaiting the agent OR its human, and only the
+     * agent's own slot is one it can submit; these say which is which.
+     *
+     * Optional because a backend deployed before ZIG-1087 omits them, and this
+     * client is installed independently of the server it talks to. Absent reads
+     * as "no slot of mine", which routes the decision to the human — the safe
+     * direction: it withholds a call, it never invents authority.
+     */
+    pendingApprovalPartyIds?: string[];
+    proposedTo?: string | null;
 }
 export interface InboxConnectionRequestRef {
     requestId: string;
-    requesterAgentId: string;
+    /**
+     * Non-addressable persona reference for the requester (`psn_*`).
+     * Never use as an account id for lookup / wake / pay (ZIG-1137).
+     */
+    requesterRef: string;
     /** ZIG-1039 — human-readable name for consent cards. */
     requesterDisplayName?: string | null;
     /** ZIG-1039 — org label for consent cards. */
     requesterOrgName?: string | null;
     message: string | null;
     requestedAt: string | null;
+    /** ZIG-1087 — see InboxProposalRef; a link request uses the same gate. */
+    pendingApprovalPartyIds?: string[];
+    proposedTo?: string | null;
 }
 /** Pull-only MCP: prompt the human when proposals need a decision (ZIG-482 / ZIG-481). */
 export interface InboxHumanAttention {
@@ -98,45 +127,6 @@ export interface InboxAckResult {
  */
 export interface InboxReadOptions {
     waitSeconds?: number;
-    /**
-     * Operator read only (ZIG-965): restrict the sweep to this roster. The
-     * server intersects it with the agents the key owner runs — it narrows,
-     * never widens. A launcher hosting a subset should always pass the agents
-     * it actually registered, or it pays for a sweep of the owner's whole
-     * seeded fleet.
-     */
-    agents?: string[];
-}
-/**
- * One agent's line in the operator sweep: enough to decide whether to start a
- * host, and nothing more.
- *
- * Deliberately NOT that agent's envelope. The launcher only chooses who to
- * run; the host it starts reads its own inbox on its own credentials a moment
- * later, so building N envelopes here was work thrown away.
- */
-export interface InboxOperatorAgentEntry {
-    agentId: string;
-    /** Newest delivery addressed to this agent, or null if it never had one. */
-    deliveredUpTo: string | null;
-    /** How far it has acked. Mail exists when `deliveredUpTo > ackedUpTo`. */
-    ackedUpTo: string | null;
-    /**
-     * True when this agent holds open assigned work. Independent of the
-     * watermark: a host that died mid-task already acked past the task's
-     * delivery, and the open task is the only durable trace it needs restarting.
-     */
-    hasOpenTasks: boolean;
-}
-/** GET /inbox/operator: which of the key owner's agents have mail or open work. */
-export interface InboxOperatorEnvelope {
-    asOf: string;
-    /** Agents with mail or open work. */
-    agents: InboxOperatorAgentEntry[];
-    /** Agents examined that had neither. */
-    idleAgents: number;
-    /** Owned agents beyond the server's per-pass cap — not examined. */
-    truncatedAgents: number;
 }
 /**
  * The doorbell, not the door (ZIG-434): references addressed to this agent
@@ -155,14 +145,6 @@ export declare class InboxClient {
     private headers;
     private inboxUrl;
     getInbox(opts?: InboxReadOptions): Promise<InboxEnvelope>;
-    /**
-     * Operator-level multiplexed read: which of this key owner's agents have
-     * mail or open work (an agent-scoped key collapses to its one agent).
-     *
-     * Returns who to start, never what they were sent — the host you start
-     * reads its own inbox on its own identity. Ack stays per agent.
-     */
-    getOperatorInbox(opts?: InboxReadOptions): Promise<InboxOperatorEnvelope>;
     /**
      * Advance this agent's watermark — pass the envelope's `ackTo`. Monotonic
      * server-side: an older value is a no-op, so a replayed ack can never

package/dist/http/InboxClient.js

@@ -35,9 +35,6 @@ export class InboxClient {
         if (opts.waitSeconds != null && opts.waitSeconds > 0) {
             url.searchParams.set('wait', String(opts.waitSeconds));
         }
-        if (opts.agents?.length) {
-            url.searchParams.set('agents', opts.agents.join(','));
-        }
         return url.toString();
     }
     async getInbox(opts = {}) {
@@ -50,42 +47,6 @@ export class InboxClient {
         }
         return JSON.parse(body);
     }
-    /**
-     * Operator-level multiplexed read: which of this key owner's agents have
-     * mail or open work (an agent-scoped key collapses to its one agent).
-     *
-     * Returns who to start, never what they were sent — the host you start
-     * reads its own inbox on its own identity. Ack stays per agent.
-     */
-    async getOperatorInbox(opts = {}) {
-        // Bounded wait (ZIG-965): the server holds at most `waitSeconds` (+ sweep
-        // time); a poll that outlives that by a wide margin is a dead sweep, and
-        // without a timeout it blocked the launcher's whole poll loop — lazy wake
-        // simply stopped. Abort and let the caller's retry loop take over.
-        const timeoutMs = ((opts.waitSeconds ?? 0) + 30) * 1000;
-        const ac = new AbortController();
-        const timer = setTimeout(() => ac.abort(), timeoutMs);
-        let res;
-        try {
-            res = await fetch(this.inboxUrl('/inbox/operator', opts), {
-                headers: this.headers(),
-                signal: ac.signal,
-            });
-        }
-        catch (err) {
-            throw ac.signal.aborted
-                ? new Error(`InboxClient.getOperatorInbox timed out after ${timeoutMs}ms`)
-                : err;
-        }
-        finally {
-            clearTimeout(timer);
-        }
-        const body = await res.text().catch(() => '');
-        if (!res.ok) {
-            throw pollSurfaceError('InboxClient.getOperatorInbox', res, body);
-        }
-        return JSON.parse(body);
-    }
     /**
      * Advance this agent's watermark — pass the envelope's `ackTo`. Monotonic
      * server-side: an older value is a no-op, so a replayed ack can never

package/dist/http/MarketplaceClient.d.ts

@@ -31,7 +31,6 @@ export interface PublishQuestPayload {
     description: string;
     chatId?: string;
     payerId?: string;
-    parentTaskId?: string;
     price?: number;
     lifecycle?: string;
     expiresAt?: string;

package/dist/http/MarketplaceClient.js

@@ -1,4 +1,6 @@
 import 'dotenv/config';
+// ZIG-1111: one shaping rule for every agreement this package parses.
+import { shapeAgreement } from './AgreementClient.js';
 import { getBackendUrl } from '../utils/urlUtils.js';
 import { throwApiError } from '../shared/apiError.js';
 function getMarketplaceBaseUrl() { return `${getBackendUrl()}/marketplace`; }
@@ -7,6 +9,9 @@ function buildHeaders(creds) {
         'content-type': 'application/json',
         Authorization: `Bearer ${creds.operatorKey}`,
         'X-Agent-Id': creds.agentId,
+        // ZIG-1092 — the wake's lane, so the backend can fence this call to the
+        // engagement it belongs to rather than the agent's whole authority.
+        ...(creds.laneId ? { 'X-Ziggs-Lane': creds.laneId } : {}),
     };
 }
 function assertCreds(creds, op) {
@@ -27,7 +32,7 @@ export async function publishOffer(payload, creds) {
         throwApiError(res, body, `Marketplace offer publish failed: ${res.status}`);
     }
     const data = await res.json().catch(() => null);
-    return (data?.['offer'] ?? data);
+    return shapeAgreement((data?.['offer'] ?? data));
 }
 export async function pullOffers(options, creds) {
     assertCreds(creds, 'marketplace offers pull');
@@ -64,7 +69,7 @@ export async function claimOffer(agreementId, creds) {
     const data = await res.json().catch(() => null);
     if (!data?.['ok'])
         throw new Error(data?.['error'] || 'Claim failed');
-    return data['offer'];
+    return shapeAgreement(data['offer']);
 }
 export async function publishQuest(payload, creds) {
     assertCreds(creds, 'quest publish');
@@ -80,7 +85,7 @@ export async function publishQuest(payload, creds) {
     const data = await res.json().catch(() => null);
     if (!data?.['agreement'])
         throw new Error('Quest publish returned no agreement');
-    return data['agreement'];
+    return shapeAgreement(data['agreement']);
 }
 export async function pullQuests(options, creds) {
     assertCreds(creds, 'quest pull');

package/dist/http/MessagesClient.js

@@ -1,5 +1,6 @@
 import 'dotenv/config';
 import { getBackendUrl } from '../utils/urlUtils.js';
+import { throwApiError } from '../shared/apiError.js';
 /**
  * Read-side client for forward-delta message reads.
  *
@@ -35,11 +36,8 @@ export class MessagesClient {
         const res = await fetch(url.toString(), { headers: this._headers() });
         if (!res.ok) {
             const body = await res.text().catch(() => '');
-            const err = new Error(`MessagesClient.list ${res.status} ${res.statusText} ${body.slice(0, 200)}`);
-            // Callers branch on the HTTP status (404 = chat deleted/not visible)
-            // without parsing the message string.
-            err.status = res.status;
-            throw err;
+            // Callers branch on ApiError.status (404 = chat deleted/not visible).
+            throwApiError(res, body, `MessagesClient.list failed: ${res.status}`);
         }
         return (await res.json());
     }

package/dist/http/OrgsClient.js

@@ -1,5 +1,6 @@
 import 'dotenv/config';
 import { getBackendUrl } from '../utils/urlUtils.js';
+import { throwApiError } from '../shared/apiError.js';
 import { buildOperatorHeaders } from './operatorHeaders.js';
 /**
  * ZIG-739 / ZIG-956 — the operator's full org membership (not just granted
@@ -15,7 +16,7 @@ export async function fetchMyOrgs(creds, baseUrl) {
     });
     const body = await res.text().catch(() => '');
     if (!res.ok) {
-        throw new Error(`GET /orgs/me ${res.status} ${body.slice(0, 200)}`);
+        throwApiError(res, body, `GET /orgs/me failed: ${res.status}`);
     }
     const parsed = body ? JSON.parse(body) : {};
     return (parsed.orgs ?? []).map((o) => ({
@@ -55,7 +56,7 @@ export async function fetchDelegateAccess(creds, baseUrl) {
     });
     const body = await res.text().catch(() => '');
     if (!res.ok) {
-        throw new Error(`GET /agents/claude-delegate/access ${res.status} ${body.slice(0, 200)}`);
+        throwApiError(res, body, `GET /agents/claude-delegate/access failed: ${res.status}`);
     }
     return body ? JSON.parse(body) : {};
 }

package/dist/http/PaymentsClient.js

@@ -2,7 +2,7 @@ import 'dotenv/config';
 import { getBackendUrl } from '../utils/urlUtils.js';
 import { buildOperatorHeaders } from './operatorHeaders.js';
 import { GrantsClient } from './GrantsClient.js';
-import { parseErrorMessage } from '../shared/apiError.js';
+import { throwApiError } from '../shared/apiError.js';
 function randomIdempotencyKey(prefix = 'op') {
     return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
 }
@@ -217,10 +217,8 @@ export class PaymentsClient {
         const response = await fetch(`${this.baseUrl}${path}`, init);
         const text = await response.text();
         if (!response.ok) {
-            const err = new Error(parseErrorMessage(text, `HTTP ${response.status}`));
-            err.status = response.status;
-            err.body = text;
-            throw err;
+            // ZIG-1124 — ApiError; PaymentsError remains the duck type for `.status`.
+            throwApiError(response, text, `HTTP ${response.status}`);
         }
         return text ? JSON.parse(text) : null;
     }

package/dist/http/TaskClient.d.ts

@@ -1,10 +1,18 @@
 import 'dotenv/config';
 import { type Creds, type Task, type TaskState } from '../types.js';
+/**
+ * When the buyer reviews a task's plan. Task-rail only — an agreement has no
+ * plan to review, which is why ZIG-1095 cut this from the propose/counter/
+ * subcontract inputs rather than teaching those routes to keep one.
+ */
+export type PlanReviewTiming = 'with_proposal' | 'before_execution';
 export interface CreateTaskData {
     description: string;
     agreementId: string;
     parentTaskId?: string;
     plan?: unknown;
+    planReviewTiming?: PlanReviewTiming;
+    requireMidWorkPlanAck?: boolean;
     idempotencyKey?: string;
     /** Explicit delegation target (ZIG-586) — must be a party to the agreement; validated server-side. */
     assigneeId?: string;

package/dist/http/TaskClient.js

@@ -7,6 +7,9 @@ function buildHeaders(creds) {
         'content-type': 'application/json',
         Authorization: `Bearer ${creds.operatorKey}`,
         'X-Agent-Id': creds.agentId,
+        // ZIG-1092 — the wake's lane, so the backend can fence this call to the
+        // engagement it belongs to rather than the agent's whole authority.
+        ...(creds.laneId ? { 'X-Ziggs-Lane': creds.laneId } : {}),
     };
 }
 function assertCreds(creds, op) {

package/dist/http/agreementFlows.d.ts

@@ -1,4 +1,4 @@
-import { type ProposeTerms } from './AgreementClient.js';
+import { type ClaimedKind, type ProposeTerms } from './AgreementClient.js';
 import { type Agreement, type Creds, type EngagementKind } from '../types.js';
 /**
  * ZIG-1022 — one propose grammar. Direct, broadcast (quest and standing
@@ -22,11 +22,19 @@ export declare function proposeUnified(input: UnifiedProposeInput, creds: Creds)
     agreement: Agreement;
     shape: ProposeShape;
 }>;
-export type ClaimedKind = 'link' | 'offer' | 'quest' | 'hand-off';
 /**
- * ZIG-1021 — one claim verb for any open broadcast. Fetches the agreement to
- * route: link invites and quests claim through POST /agreements/:id/claim;
- * standing offers (open payer side) through POST /marketplace/offers/claim.
+ * ZIG-1021 — one claim verb for any open broadcast: link invite, quest,
+ * hand-off, or standing offer.
+ *
+ * One request. This used to read the agreement first to decide which endpoint to
+ * post to, and `GET /agreements/:id` is party-scoped — a claimer is by definition
+ * not yet a party to the broadcast it is claiming, so the routing read 404'd and
+ * every standing offer in the store failed with "Agreement not found" before
+ * either claim endpoint was called (ZIG-1155). The backend routes it now, where
+ * the row is readable without being a party to it.
+ *
+ * `kind` arrives on the claim response — the route that did the routing reports
+ * which broadcast kind this turned out to be.
  */
 export declare function claimOpenAgreement(agreementId: string, creds: Creds): Promise<{
     agreement: Agreement;