@agent-wire/terminal 1.7.5 → 1.7.7

package/dist/api.d.ts

@@ -1,5 +1,10 @@
+import type { CreditAmount } from './contracts/credit-amount.js';
 import type { WireNodeConfig } from './config.js';
 import type { MarketNativeDocsIngestMode, RemoteDocument } from './sync/types.js';
+export declare class RegistrationError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
 type LegacyActionInvokeParams = {
     action_id: string;
     mode: string;
@@ -11,8 +16,18 @@ type LegacyActionInvokeParams = {
 type LegacyActionChainParams = LegacyActionInvokeParams & {
     chain_id?: string;
 };
+export interface MeshScopeParams {
+    scope?: 'agent' | 'fleet' | 'circle';
+    circle_id?: string;
+}
 export interface QueryParams {
-    text: string;
+    text?: string;
+    types?: string | string[];
+    type?: string;
+    exclude_types?: string | string[];
+    exclude_type?: string;
+    creator?: string;
+    agent?: string;
     domain?: string;
     limit?: number;
     offset?: number;
@@ -46,14 +61,14 @@ export interface ContributeParams {
         claim: string;
         trackable: boolean;
     }>;
-    price?: number;
+    price?: CreditAmount;
     pricing_curve?: Array<{
         credits: number;
         after_hours: number;
     }>;
     curve_power?: number;
     bid?: {
-        amount: number;
+        amount: CreditAmount;
         duration_hours: number;
     };
     embargo_until?: string;
@@ -111,7 +126,7 @@ export interface StakeResult {
     position: {
         id: string;
         side: string;
-        amount: number;
+        amount: CreditAmount;
         created_at: string;
     };
     market: {
@@ -133,7 +148,7 @@ export interface MarketStatus {
     your_positions: Array<{
         id: string;
         side: string;
-        amount: number;
+        amount: CreditAmount;
         created_at: string;
     }>;
     resolution: {
@@ -165,8 +180,8 @@ export interface PinPreview {
 export interface RetractionResult {
     retracted: boolean;
     contribution_id: string;
-    deposit_refund: number;
-    deposit_forfeit: number;
+    deposit_refund: CreditAmount;
+    deposit_forfeit: CreditAmount;
     bounty_clawback: number;
 }
 export interface RateParams {
@@ -271,13 +286,15 @@ export type WireEventStreamMessage = {
     event: string;
     data: unknown;
 };
-declare function normalizeHelpTopic(topic: string | undefined): string;
+export declare function normalizeWaitTimeoutSeconds(timeoutSeconds: number | undefined): number;
+export declare function normalizeHelpTopic(topic: string | undefined): string;
 export declare const __wireApiTestInternals: {
     normalizeHelpTopic: typeof normalizeHelpTopic;
     parseSseBlock: typeof parseSseBlock;
 };
 declare function parseSseBlock(block: string): WireEventStreamMessage | null;
 export declare class WireAPI {
+    claims(params: Record<string, unknown>): Promise<unknown>;
     private baseUrl;
     private token;
     private nodeId;
@@ -327,7 +344,7 @@ export declare class WireAPI {
     }>;
     submitResult(workId: string, result: Record<string, unknown>): Promise<{
         credits_awarded: number;
-        balance_after: number;
+        balance_after: CreditAmount;
     }>;
     heartbeat(nodeId: string): Promise<{
         status: string;
@@ -359,7 +376,32 @@ export declare class WireAPI {
     accessContribution(contributionId: string): Promise<Record<string, unknown>>;
     private verifyLocalContributionReadRoute;
     private localHeaders;
+    private localAuthToken;
     private tryLocalContributionRead;
+    /**
+     * Generic local-node fetch for the pyramid consume-head proxies. Returns the
+     * parsed JSON body on success, throws a descriptive error on non-2xx.
+     */
+    private localNodeFetch;
+    /**
+     * pyramid_map — GET /pyramid/{slug}/map.
+     * Apex synthesis + freshness counts + nav skeleton + unresolved gaps.
+     * Orient first at boot, then drill via pyramid_hydrate using nav node ids.
+     */
+    getPyramidMap(slug: string): Promise<Record<string, unknown>>;
+    /**
+     * pyramid_hydrate — GET /pyramid/{slug}/drill/{node_id}.
+     * Returns the DrillResult: full node content (headline/distilled/narrative
+     * via the node payload) plus children, evidence, gaps, web_edges, and
+     * question context. Pull one node/region after orienting via pyramid_map.
+     */
+    getPyramidDrill(slug: string, nodeId: string): Promise<Record<string, unknown>>;
+    /**
+     * pyramid_ask — POST /pyramid/{slug}/question  body { question }.
+     * Cheap (<5s, no-LLM) mechanical retrieval over the existing pyramid;
+     * returns a markdown answer plus node-id citations / sources.
+     */
+    askPyramid(slug: string, question: string): Promise<Record<string, unknown>>;
     /**
      * Rate a Wire item. Free. Must have accessed it first.
      */
@@ -416,31 +458,31 @@ export declare class WireAPI {
     /**
      * Get full mesh status: active threads, intents, blackboard.
      */
-    meshStatus(): Promise<Record<string, unknown>>;
+    meshStatus(scope?: MeshScopeParams): Promise<Record<string, unknown>>;
     /**
      * Read the shared blackboard.
      */
-    meshBoardRead(): Promise<Record<string, unknown>>;
+    meshBoardRead(scope?: MeshScopeParams): Promise<Record<string, unknown>>;
     /**
      * Write a key-value entry to the shared blackboard.
      */
-    meshBoardWrite(key: string, value: unknown, ttl?: number): Promise<Record<string, unknown>>;
+    meshBoardWrite(key: string, value: unknown, ttl?: number, scope?: MeshScopeParams): Promise<Record<string, unknown>>;
     /**
      * Delete a key from the shared blackboard.
      */
-    meshBoardDelete(key: string): Promise<Record<string, unknown>>;
+    meshBoardDelete(key: string, scope?: MeshScopeParams): Promise<Record<string, unknown>>;
     /**
      * Declare an intent (what this thread is about to do).
      */
-    meshDeclareIntent(action: string, domain?: string, meta?: Record<string, unknown>, ttl?: number): Promise<Record<string, unknown>>;
+    meshDeclareIntent(action: string, domain?: string, meta?: Record<string, unknown>, ttl?: number, scope?: MeshScopeParams): Promise<Record<string, unknown>>;
     /**
      * Release (delete) an intent.
      */
-    meshReleaseIntent(intentId: string): Promise<Record<string, unknown>>;
+    meshReleaseIntent(intentId: string, scope?: MeshScopeParams): Promise<Record<string, unknown>>;
     /**
      * Get active intents for this agent.
      */
-    meshGetIntents(): Promise<Record<string, unknown>>;
+    meshGetIntents(scope?: MeshScopeParams): Promise<Record<string, unknown>>;
     /**
      * Stake credits on a prediction market attached to a contribution.
      * The contribution must have a claim with `market.enabled: true`.
@@ -450,7 +492,7 @@ export declare class WireAPI {
      * @param side - 'agree' or 'disagree'
      * @param amount - Number of credits to stake (must be >= market's min_stake)
      */
-    stakeMarket(contributionId: string, side: 'agree' | 'disagree', amount: number): Promise<StakeResult>;
+    stakeMarket(contributionId: string, side: 'agree' | 'disagree', amount: CreditAmount, requestId?: string): Promise<StakeResult>;
     /**
      * Get the current status of a prediction market, including pool sizes,
      * your positions, and resolution status if resolved.
@@ -616,9 +658,10 @@ export declare class WireAPI {
     proposeSupersession(targetId: string, contributionId: string): Promise<Record<string, unknown>>;
     acceptSupersession(proposalId: string): Promise<Record<string, unknown>>;
     rejectSupersession(proposalId: string): Promise<Record<string, unknown>>;
-    executeSupersession(targetId: string, newContributionId: string): Promise<Record<string, unknown>>;
-    submitCorrection(targetId: string, correctionContributionId: string, depositAmount: number): Promise<Record<string, unknown>>;
-    endorseCorrection(correctionId: string, depositAmount: number): Promise<Record<string, unknown>>;
+    executeSupersession(targetId: string, newContributionId: string, allowTypeChange?: boolean): Promise<Record<string, unknown>>;
+    submitCorrection(targetId: string, correctionContributionId: string, depositAmount: CreditAmount): Promise<Record<string, unknown>>;
+    withdrawCorrection(correctionId: string): Promise<Record<string, unknown>>;
+    endorseCorrection(correctionId: string, depositAmount: CreditAmount): Promise<Record<string, unknown>>;
     listCircles(): Promise<Record<string, unknown>>;
     createCircle(name: string, partnerEmail: string, description?: string): Promise<Record<string, unknown>>;
     joinCircle(circleId: string): Promise<Record<string, unknown>>;
@@ -727,4 +770,13 @@ export declare class WireAPI {
     getRosterWithDeviceSecret(deviceSecret: string, harness?: string, hintName?: string): Promise<Record<string, unknown>>;
     resumeAgent(agentName: string, deviceSecret: string, nonce: string): Promise<Record<string, unknown>>;
 }
+/**
+ * Paginate through all results from a fetch function.
+ * Concatenates pages until a page returns fewer than pageSize items.
+ *
+ * @param fetchPage - Function that fetches a page (1-indexed page number, pageSize)
+ * @param pageSize - Number of items per page (default 100)
+ * @returns All items concatenated
+ */
+export declare function paginateAll<T>(fetchPage: (page: number, pageSize: number) => Promise<T[]>, pageSize?: number): Promise<T[]>;
 export {};

package/dist/api.js

@@ -1,8 +1,15 @@
-import { paginateAll } from './sync/paginate.js';
 const DEFAULT_TRUSTED_CHAIN_TIMEOUT_MS = 600_000;
 const TRUSTED_CHAIN_CLIENT_GRACE_MS = 5_000;
 const DEFAULT_WIRE_SYNC_TIMEOUT_MS = DEFAULT_TRUSTED_CHAIN_TIMEOUT_MS + TRUSTED_CHAIN_CLIENT_GRACE_MS;
 const DEFAULT_ACTION_QUOTE_TIMEOUT_MS = 30_000;
+export class RegistrationError extends Error {
+    status;
+    constructor(status, message) {
+        super(`Registration failed (${status}): ${message}`);
+        this.status = status;
+        this.name = 'RegistrationError';
+    }
+}
 function legacyActionRequestOptions(params) {
     if (params.mode === 'quote') {
         return { body: params, timeoutMs: DEFAULT_ACTION_QUOTE_TIMEOUT_MS };
@@ -13,15 +20,32 @@ function legacyActionRequestOptions(params) {
         timeoutMs: timeoutMs + TRUSTED_CHAIN_CLIENT_GRACE_MS,
     };
 }
+function meshQuery(params, extra = {}) {
+    const query = new URLSearchParams(extra);
+    if (params.scope)
+        query.set('scope', params.scope);
+    if (params.circle_id)
+        query.set('circle_id', params.circle_id);
+    return query.size ? `?${query}` : '';
+}
 const DEFAULT_WAIT_TIMEOUT_SECONDS = 30;
-const MAX_WAIT_TIMEOUT_SECONDS = 1800;
+// Raised from 1800 (30m): the SSE event stream is server-side UNCAPPED + 30s-keepalived, so a long
+// client park is just a client-side deadline, not an infra limit. 86400 = 24h finite ceiling.
+const MAX_WAIT_TIMEOUT_SECONDS = 86_400;
+// Sentinel: timeout_seconds < 0 parks INDEFINITELY (until an event) — no client deadline, so the
+// SSE + reconnect loop runs until a match arrives = ZERO re-arm cycles. The hair-trigger is
+// preserved (SSE delivers instantly). 0 keeps its "immediate poll" meaning.
+const INDEFINITE_WAIT_TIMEOUT_SECONDS = -1;
 const DEFAULT_WAIT_LIMIT = 50;
 const MAX_WAIT_LIMIT = 200;
 const WAIT_RECONNECT_DELAY_MS = 1_000;
-function normalizeWaitTimeoutSeconds(timeoutSeconds) {
+export function normalizeWaitTimeoutSeconds(timeoutSeconds) {
     if (timeoutSeconds === undefined)
         return DEFAULT_WAIT_TIMEOUT_SECONDS;
-    return Math.min(Math.max(Math.floor(timeoutSeconds), 0), MAX_WAIT_TIMEOUT_SECONDS);
+    const floored = Math.floor(timeoutSeconds);
+    if (floored < 0)
+        return INDEFINITE_WAIT_TIMEOUT_SECONDS;
+    return Math.min(floored, MAX_WAIT_TIMEOUT_SECONDS);
 }
 function normalizeWaitLimit(limit) {
     if (limit === undefined)
@@ -60,7 +84,7 @@ function appendWaitParams(url, params) {
             url.searchParams.set(key, String(value));
     }
 }
-function normalizeHelpTopic(topic) {
+export function normalizeHelpTopic(topic) {
     return (topic || '')
         .trim()
         .replace(/^https?:\/\/[^/]+\/api\/v1\/help\/?/i, '')
@@ -88,7 +112,7 @@ function isLocalRouteServedStatus(status) {
     return status === 200 || status === 401 || status === 403 || status === 404;
 }
 function isLocalReadFallbackStatus(status) {
-    return status === 404 || status === 409 || status === 410 || status === 412 || status === 428 || status === 503 || status === 504;
+    return status === 401 || status === 403 || status === 404 || status === 409 || status === 410 || status === 412 || status === 428 || status === 503 || status === 504;
 }
 function parseSseBlock(block) {
     let event = 'message';
@@ -122,6 +146,13 @@ function parseSseBlock(block) {
     }
 }
 export class WireAPI {
+    async claims(params) {
+        const { action, claim_id } = params;
+        if (action === 'get' || action === 'list') {
+            return this.request('GET', '/wire/claims' + (claim_id ? `?claim_id=${encodeURIComponent(String(claim_id))}` : ''));
+        }
+        return this.request('POST', '/wire/claims', params, 120_000);
+    }
     baseUrl;
     token;
     nodeId;
@@ -213,7 +244,7 @@ export class WireAPI {
         return response;
     }
     async getMe() {
-        return this.request('GET', '/me');
+        return this.unwrapEnvelopeOrPlain(await this.request('GET', '/me'));
     }
     async registerNode(name, capabilities) {
         return this.request('POST', '/node/register', { name, capabilities });
@@ -233,7 +264,7 @@ export class WireAPI {
         });
         if (!res.ok) {
             const err = await res.json().catch(() => ({ error: res.statusText }));
-            throw new Error(`Registration failed (${res.status}): ${err.error || res.statusText}`);
+            throw new RegistrationError(res.status, err.error || res.statusText);
         }
         // Server wraps response in wireEnvelope: { data: { ... }, mesh, fleet, ... }
         const envelope = await res.json();
@@ -254,21 +285,10 @@ export class WireAPI {
     }
     async query(params) {
         const qs = new URLSearchParams();
-        qs.set('text', params.text);
-        qs.set('domain', params.domain || 'all');
-        if (params.limit !== undefined)
-            qs.set('limit', String(params.limit));
-        if (params.offset !== undefined)
-            qs.set('offset', String(params.offset));
-        qs.set('sort', params.sort || 'recency');
-        if (params.watchlist)
-            qs.set('watchlist', 'true');
-        if (params.list)
-            qs.set('list', params.list);
-        if (params.changed_only)
-            qs.set('changed_only', 'true');
-        if (params.price_below !== undefined)
-            qs.set('price_below', String(params.price_below));
+        for (const [key, value] of Object.entries({ domain: 'all', sort: 'recency', ...params })) {
+            if (value !== undefined && value !== null)
+                qs.set(key, String(value));
+        }
         return this.request('GET', `/wire/query?${qs.toString()}`);
     }
     async help(params = {}) {
@@ -397,7 +417,7 @@ export class WireAPI {
     async verifyLocalContributionReadRoute() {
         if (!this.localNodeEnabled)
             return 'unavailable';
-        if (!this.localNodeToken)
+        if (!this.localAuthToken())
             return 'unavailable';
         if (this.localContributionRouteStatus)
             return this.localContributionRouteStatus;
@@ -425,7 +445,7 @@ export class WireAPI {
     }
     localHeaders() {
         const headers = {
-            'Authorization': `Bearer ${this.localNodeToken}`,
+            'Authorization': `Bearer ${this.localAuthToken()}`,
             'Content-Type': 'application/json',
         };
         if (this.threadId) {
@@ -433,6 +453,9 @@ export class WireAPI {
         }
         return headers;
     }
+    localAuthToken() {
+        return this.localNodeToken || this.token || '';
+    }
     async tryLocalContributionRead(identifier) {
         if (!this.localNodeEnabled)
             return null;
@@ -464,6 +487,55 @@ export class WireAPI {
             return null;
         }
     }
+    // ── Pyramid consume-head proxies (spec green playful/176/24) ───────────
+    // Thin HTTP proxies to the LOCAL AWN node's read-time pyramid routes
+    // (pyramid_routes mounted at /pyramid/*). They forward (slug, args) to the
+    // route and return the parsed JSON as-is. Auth: pass the local Bearer token
+    // (this.localHeaders()); the AWN routes enforce dual-auth + access-tier +
+    // nano-payment. Same local-node fetch pattern as tryLocalContributionRead.
+    /**
+     * Generic local-node fetch for the pyramid consume-head proxies. Returns the
+     * parsed JSON body on success, throws a descriptive error on non-2xx.
+     */
+    async localNodeFetch(method, path, body, timeoutMs = 15_000) {
+        const res = await fetch(`${this.localNodeUrl}${path}`, {
+            method,
+            headers: this.localHeaders(),
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({ error: res.statusText }));
+            const message = err.error || res.statusText;
+            throw new Error(`Local node ${method} ${path} failed (${res.status}): ${message}`);
+        }
+        return await res.json();
+    }
+    /**
+     * pyramid_map — GET /pyramid/{slug}/map.
+     * Apex synthesis + freshness counts + nav skeleton + unresolved gaps.
+     * Orient first at boot, then drill via pyramid_hydrate using nav node ids.
+     */
+    async getPyramidMap(slug) {
+        return this.localNodeFetch('GET', `/pyramid/${encodeURIComponent(slug)}/map`);
+    }
+    /**
+     * pyramid_hydrate — GET /pyramid/{slug}/drill/{node_id}.
+     * Returns the DrillResult: full node content (headline/distilled/narrative
+     * via the node payload) plus children, evidence, gaps, web_edges, and
+     * question context. Pull one node/region after orienting via pyramid_map.
+     */
+    async getPyramidDrill(slug, nodeId) {
+        return this.localNodeFetch('GET', `/pyramid/${encodeURIComponent(slug)}/drill/${encodeURIComponent(nodeId)}`);
+    }
+    /**
+     * pyramid_ask — POST /pyramid/{slug}/question  body { question }.
+     * Cheap (<5s, no-LLM) mechanical retrieval over the existing pyramid;
+     * returns a markdown answer plus node-id citations / sources.
+     */
+    async askPyramid(slug, question) {
+        return this.localNodeFetch('POST', `/pyramid/${encodeURIComponent(slug)}/question`, { question });
+    }
     /**
      * Rate a Wire item. Free. Must have accessed it first.
      */
@@ -511,7 +583,8 @@ export class WireAPI {
      * Read a source document by ID.
      */
     async readDocument(documentId) {
-        return this.request('GET', `/wire/documents/${documentId}?include_body=true`, undefined, 30_000);
+        const quote = await this.request('GET', `/wire/documents/${documentId}`, undefined, 30_000);
+        return this.request('POST', `/wire/documents/${quote.id ?? quote.data?.id ?? documentId}`, { max_price: quote.current_price ?? quote.data?.current_price ?? 0 }, 30_000);
     }
     /**
      * Find unscouted documents — unclaimed bounties.
@@ -554,7 +627,7 @@ export class WireAPI {
         return paginateAll(async (page, pageSize) => {
             const offset = (page - 1) * pageSize;
             const result = await this.request('GET', `/wire/corpora/${encodeURIComponent(slug)}/documents?limit=${pageSize}&offset=${offset}`);
-            return result.documents || [];
+            return result.documents || result.items || [];
         }, 100);
     }
     /**
@@ -584,44 +657,44 @@ export class WireAPI {
     /**
      * Get full mesh status: active threads, intents, blackboard.
      */
-    async meshStatus() {
-        return this.request('GET', '/mesh/status');
+    async meshStatus(scope = {}) {
+        return this.request('GET', `/mesh/status${meshQuery(scope)}`);
     }
     /**
      * Read the shared blackboard.
      */
-    async meshBoardRead() {
-        return this.request('GET', '/mesh/board');
+    async meshBoardRead(scope = {}) {
+        return this.request('GET', `/mesh/board${meshQuery(scope)}`);
     }
     /**
      * Write a key-value entry to the shared blackboard.
      */
-    async meshBoardWrite(key, value, ttl) {
-        return this.request('POST', '/mesh/board', { key, value, ttl });
+    async meshBoardWrite(key, value, ttl, scope = {}) {
+        return this.request('POST', '/mesh/board', { key, value, ttl, ...scope });
     }
     /**
      * Delete a key from the shared blackboard.
      */
-    async meshBoardDelete(key) {
-        return this.request('DELETE', `/mesh/board?key=${encodeURIComponent(key)}`);
+    async meshBoardDelete(key, scope = {}) {
+        return this.request('DELETE', `/mesh/board${meshQuery(scope, { key })}`);
     }
     /**
      * Declare an intent (what this thread is about to do).
      */
-    async meshDeclareIntent(action, domain, meta, ttl) {
-        return this.request('POST', '/mesh/intent', { action, domain, meta, ttl });
+    async meshDeclareIntent(action, domain, meta, ttl, scope = {}) {
+        return this.request('POST', '/mesh/intent', { action, domain, meta, ttl, ...scope });
     }
     /**
      * Release (delete) an intent.
      */
-    async meshReleaseIntent(intentId) {
-        return this.request('DELETE', `/mesh/intent?intent_id=${encodeURIComponent(intentId)}`);
+    async meshReleaseIntent(intentId, scope = {}) {
+        return this.request('DELETE', `/mesh/intent${meshQuery(scope, { intent_id: intentId })}`);
     }
     /**
      * Get active intents for this agent.
      */
-    async meshGetIntents() {
-        return this.request('GET', '/mesh/intent');
+    async meshGetIntents(scope = {}) {
+        return this.request('GET', `/mesh/intent${meshQuery(scope)}`);
     }
     // ── Prediction Markets ─────────────────────────────────────
     /**
@@ -633,8 +706,8 @@ export class WireAPI {
      * @param side - 'agree' or 'disagree'
      * @param amount - Number of credits to stake (must be >= market's min_stake)
      */
-    async stakeMarket(contributionId, side, amount) {
-        return this.request('POST', `/wire/market/${contributionId}/stake`, { side, amount });
+    async stakeMarket(contributionId, side, amount, requestId = crypto.randomUUID()) {
+        return this.request('POST', `/wire/market/${contributionId}/stake`, { side, amount, request_id: requestId });
     }
     /**
      * Get the current status of a prediction market, including pool sizes,
@@ -858,11 +931,14 @@ export class WireAPI {
         if (timeoutSeconds === 0) {
             return this.requestUnwrap('POST', '/wire/wait', params, 15_000);
         }
+        // timeoutSeconds < 0 ⇒ park INDEFINITELY: no deadline timer, so the SSE + reconnect loop runs
+        // until a matching event arrives (or the process aborts). Zero re-arm cycles.
+        const indefinite = timeoutSeconds < 0;
         const limit = normalizeWaitLimit(params.limit);
         const events = [];
         let nextCursor = params.cursor;
         const controller = new AbortController();
-        const deadlineTimer = setTimeout(() => controller.abort(), timeoutSeconds * 1000);
+        const deadlineTimer = indefinite ? null : setTimeout(() => controller.abort(), timeoutSeconds * 1000);
         try {
             while (!controller.signal.aborted) {
                 try {
@@ -905,7 +981,8 @@ export class WireAPI {
             }
         }
         finally {
-            clearTimeout(deadlineTimer);
+            if (deadlineTimer)
+                clearTimeout(deadlineTimer);
             controller.abort();
         }
         return {
@@ -992,13 +1069,21 @@ export class WireAPI {
     async rejectSupersession(proposalId) {
         return this.request('POST', `/wire/contributions/${encodeURIComponent(proposalId)}/reject-supersession`);
     }
-    async executeSupersession(targetId, newContributionId) {
-        return this.request('POST', `/wire/contributions/${encodeURIComponent(targetId)}/supersede`, { new_contribution_id: newContributionId });
+    async executeSupersession(targetId, newContributionId, allowTypeChange) {
+        // allow_type_change forwards to the REST endpoint (which already honors it) so a CROSS-TYPE
+        // supersession is reachable via the CLI/MCP, not only via raw REST (WI playful/170/177).
+        const body = { new_contribution_id: newContributionId };
+        if (allowTypeChange)
+            body.allow_type_change = true;
+        return this.request('POST', `/wire/contributions/${encodeURIComponent(targetId)}/supersede`, body);
     }
     // ── Corrections ───────────────────────────────────────────
     async submitCorrection(targetId, correctionContributionId, depositAmount) {
         return this.request('POST', `/wire/contributions/${encodeURIComponent(targetId)}/correct`, { correction_contribution_id: correctionContributionId, deposit_amount: depositAmount });
     }
+    async withdrawCorrection(correctionId) {
+        return this.request('DELETE', `/wire/contributions/${encodeURIComponent(correctionId)}/endorse-correction`);
+    }
     async endorseCorrection(correctionId, depositAmount) {
         return this.request('POST', `/wire/contributions/${encodeURIComponent(correctionId)}/endorse-correction`, { deposit_amount: depositAmount });
     }
@@ -1292,4 +1377,30 @@ export class WireAPI {
         return json.data || json;
     }
 }
+/**
+ * Paginate through all results from a fetch function.
+ * Concatenates pages until a page returns fewer than pageSize items.
+ *
+ * @param fetchPage - Function that fetches a page (1-indexed page number, pageSize)
+ * @param pageSize - Number of items per page (default 100)
+ * @returns All items concatenated
+ */
+export async function paginateAll(fetchPage, pageSize = 100) {
+    const allItems = [];
+    let page = 1;
+    const MAX_PAGES = 500; // 500 pages * 100 per page = 50k docs max
+    while (true) {
+        if (page > MAX_PAGES) {
+            console.error(`[wire-sync] Pagination stopped at ${MAX_PAGES} pages (${allItems.length} items). If your corpus has more documents, contact support.`);
+            break;
+        }
+        const items = await fetchPage(page, pageSize);
+        allItems.push(...items);
+        if (items.length < pageSize) {
+            break;
+        }
+        page++;
+    }
+    return allItems;
+}
 //# sourceMappingURL=api.js.map