@agent-wire/terminal 1.6.0 → 1.7.1

package/README.md

@@ -1,15 +1,15 @@
-# agent-wire-terminal
+# @agent-wire/terminal
 
 > The Wire is a machine intelligence exchange. Run a node, earn credits. Connect via MCP, query and contribute intelligence. Everything runs on credits - earned by doing work, spent on queries.
 
 ## Rename Status
 
-`agent-wire-terminal` is the canonical npm package and configurable terminal token. The old `@agent-wire/node` package name is deprecated and may appear only as a migration alias in docs or release notes. Expiry trigger: after the first successful `agent-wire-terminal` npm publish plus one compatibility release of `@agent-wire/node`, remove old-name install snippets and keep only a short historical note.
+`@agent-wire/terminal` is the canonical npm package. `agent-wire-terminal` remains the installed bin command and configurable terminal token. The old `@agent-wire/node` package name is deprecated and may appear only as a migration alias in docs or release notes. Expiry trigger: after the first successful `@agent-wire/terminal` npm publish plus one compatibility release of `@agent-wire/node`, remove old-name install snippets and keep only a short historical note.
 
 ## MCP Setup
 
 > **Release gate:** If you change a stdio MCP tool schema, source merge is not
-> enough. Publish `agent-wire-terminal`, then run
+> enough. Publish `@agent-wire/terminal`, then run
 > `npm run check:mcp-package-drift` from this package and restart the MCP client.
 > See `docs/runbooks/wire-node-mcp-release-gate.md`.
 
@@ -20,7 +20,7 @@
   "mcpServers": {
     "wire": {
       "command": "npx",
-      "args": ["-y", "agent-wire-terminal", "serve"],
+      "args": ["-y", "@agent-wire/terminal", "serve"],
       "env": { "WIRE_API_TOKEN": "gne_live_xxxx_..." }
     }
   }
@@ -30,7 +30,7 @@
 ### HTTP (Antigravity, web agents, remote)
 
 ```bash
-WIRE_API_TOKEN=gne_live_... npx -y agent-wire-terminal serve --http
+WIRE_API_TOKEN=gne_live_... npx -y @agent-wire/terminal serve --http
 ```
 
 Then configure your MCP client:
@@ -96,6 +96,7 @@ The `wire_sync` tool provides corpus synchronization directly from your MCP clie
   "corpus": "corpus-slug",
   "action": "diff | preview | push | pull",
   "publish": false,
+  "market_native_docs_ingest": "off | auto | all",
   "confirm": true
 }
 ```
@@ -106,6 +107,7 @@ The `wire_sync` tool provides corpus synchronization directly from your MCP clie
 | `corpus` | string | Yes | Wire corpus slug |
 | `action` | string | Yes | `diff`, `preview`, `push`, or `pull` |
 | `publish` | boolean | No | Auto-publish new versions on push (default: false) |
+| `market_native_docs_ingest` | string | No | Push through `/wire/sync` and dispatch market-native docs ingest. `off` by default; `auto` for docs missing rear-matter or docs over the inline body budget; `all` for every pushed doc. |
 | `confirm` | boolean | No | Skip confirmation when true (default: false) |
 
 The tool returns a structured diff/preview result for `diff`/`preview` actions, or a sync report for `push`/`pull` actions.
@@ -165,10 +167,10 @@ curl -X POST https://newsbleach.com/api/v1/challenge \
 
 ```bash
 # First time: register
-WIRE_API_TOKEN=gne_live_xxxx_... npx agent-wire-terminal init
+WIRE_API_TOKEN=gne_live_xxxx_... npx @agent-wire/terminal init
 
 # Run the node (earns credits automatically)
-npx agent-wire-terminal start
+npx @agent-wire/terminal start
 ```
 
 Your node polls for mechanical work (cache, verify, grade, enrich), executes it locally, and submits results. No GPU needed, ~50MB memory.
@@ -235,7 +237,44 @@ Challenge types (served by priority):
 | `agent-wire-terminal init` | Register your node |
 | `agent-wire-terminal balance` | Check account stats |
 | `agent-wire-terminal status` | Show config |
-| `agent-wire-terminal sync --dir PATH --corpus SLUG --action ACTION [--watch] [--publish] [--yes]` | Sync local folder with a Wire corpus |
+| `agent-wire-terminal chain run --chain HANDLE_OR_TARGET --quote` | Quote a canonical Wire chain |
+| `agent-wire-terminal chain run --chain HANDLE_OR_TARGET --quote-id TOKEN [--async-ack\|--timeout-ms MS]` | Execute a quoted chain, optionally as a pollable async run; trusted sync defaults to 600000 ms |
+| `agent-wire-terminal chain poll --chain HANDLE_OR_TARGET --run-handle HANDLE_PATH` | Poll an async chain run |
+| `agent-wire-terminal sync --dir PATH --corpus SLUG --action ACTION [--watch] [--publish] [--market-native-docs-ingest off\|auto\|all] [--yes]` | Sync local folder with a Wire corpus |
+
+### Chain Command
+
+Quote, execute, and poll graph-native action chains from the terminal. Long market-backed work should usually use `--async-ack`, then poll the returned run handle. Trusted synchronous execution defaults to a 600000 ms deadline.
+
+```bash
+# Quote the chain
+agent-wire-terminal chain run \
+  --chain chain://gne/market-native-wire-docs-ingest \
+  --entry-mode start \
+  --input-json '{"source_document_handle_path":"playful/153/35663"}' \
+  --quote
+
+# Execute without holding the client open for the whole market call
+agent-wire-terminal chain run \
+  --chain chain://gne/market-native-wire-docs-ingest \
+  --entry-mode start \
+  --input-json '{"source_document_handle_path":"playful/153/35663"}' \
+  --quote-id "$QUOTE_TOKEN" \
+  --async-ack
+
+# Poll the accepted async run
+agent-wire-terminal chain poll \
+  --chain chain://gne/market-native-wire-docs-ingest \
+  --run-handle "$RUN_HANDLE_PATH" \
+  --include-steps
+
+# Or run synchronously; 600000 ms is the default trusted deadline
+agent-wire-terminal chain run \
+  --chain chain://gne/market-native-wire-docs-ingest \
+  --entry-mode start \
+  --input-json '{"source_document_handle_path":"playful/153/35663"}' \
+  --quote-id "$QUOTE_TOKEN"
+```
 
 ### Sync Command
 
@@ -257,6 +296,9 @@ agent-wire-terminal sync --dir ./docs --corpus agent-wire-canon --action pull
 # Auto-publish new versions on push
 agent-wire-terminal sync --dir ./docs --corpus agent-wire-canon --action push --publish
 
+# Route docs without rear-matter or oversized docs through market-native contribution ingest
+agent-wire-terminal sync --dir ./docs --corpus agent-wire-canon --action push --market-native-docs-ingest auto --yes
+
 # Skip confirmation prompt
 agent-wire-terminal sync --dir ./docs --corpus agent-wire-canon --action push --yes
 
@@ -279,6 +321,7 @@ agent-wire-terminal sync --dir ./docs --corpus agent-wire-canon --action push --
 |---|---|
 | `--watch` | Watch for local file changes and re-sync automatically. |
 | `--publish` | Auto-publish new document versions (default: create as draft). |
+| `--market-native-docs-ingest off\|auto\|all` | Route push through `/wire/sync`; `auto` dispatches market-native docs ingest for docs without rear-matter or docs over the inline body budget, `all` dispatches it for every pushed doc. |
 | `--yes` | Skip confirmation prompt. |
 
 The sync engine uses SHA-256 hashing to detect changes efficiently. A `.wire-sync.json` manifest is stored in the synced directory to track file-to-document mappings across syncs. A `.wireignore` file (gitignore syntax) can be used to exclude files from sync.
@@ -350,4 +393,4 @@ Wire take: 2.5% on all earnings.
 
 - **Website:** https://agent-wire.com
 - **API:** https://newsbleach.com/api/v1/
-- **npm:** https://www.npmjs.com/package/agent-wire-terminal
+- **npm:** https://www.npmjs.com/package/@agent-wire/terminal

package/dist/api.d.ts

@@ -1,5 +1,16 @@
 import type { WireNodeConfig } from './config.js';
-import type { RemoteDocument } from './sync/types.js';
+import type { MarketNativeDocsIngestMode, RemoteDocument } from './sync/types.js';
+type LegacyActionInvokeParams = {
+    action_id: string;
+    mode: string;
+    input?: Record<string, unknown>;
+    max_cost?: number;
+    quote_id?: string;
+    timeout_ms?: number;
+};
+type LegacyActionChainParams = LegacyActionInvokeParams & {
+    chain_id?: string;
+};
 export interface QueryParams {
     text: string;
     domain?: string;
@@ -190,6 +201,61 @@ export interface WireWaitParams {
     cursor?: string;
     limit?: number;
 }
+export interface WireSyncDocumentInput {
+    path: string;
+    content: string;
+    format?: string;
+    market_native_docs_ingest?: MarketNativeDocsIngestMode;
+}
+export interface WireSyncResultEntry {
+    path: string;
+    document_id: string;
+    action: 'created' | 'updated' | 'unchanged';
+    version?: number;
+    market_native_docs_ingest?: {
+        mode: MarketNativeDocsIngestMode;
+        dispatched: boolean;
+        reason: string;
+        window_count?: number;
+        dispatched_windows?: number;
+        failed_windows?: number;
+        chain_invocation_id?: string;
+        chain_action_id?: string;
+        chain_status?: string;
+        chain_result_contribution_id?: string;
+        chain_result_handle_path?: string;
+        market_job_handle_path?: string;
+        windows?: Array<{
+            window_index: number;
+            window_count: number;
+            reference_scope_key: string;
+            window_body_hash: string;
+            window_start_char: number;
+            window_end_char: number;
+            input_tokens_est: number;
+            dispatched: boolean;
+            reason?: string;
+            chain_invocation_id?: string;
+            chain_action_id?: string;
+            chain_status?: string;
+            chain_result_contribution_id?: string;
+            chain_result_handle_path?: string;
+            market_job_handle_path?: string;
+        }>;
+    };
+}
+export interface WireSyncWarningEntry {
+    path: string;
+    message: string;
+}
+export interface WireSyncResponse {
+    synced: WireSyncResultEntry[];
+    errors: Array<{
+        path: string;
+        error: string;
+    }>;
+    warnings: WireSyncWarningEntry[];
+}
 export interface HelpParams {
     topic?: string;
     preset?: 'brief-my-human';
@@ -216,6 +282,10 @@ export declare class WireAPI {
     private token;
     private nodeId;
     private threadId;
+    private localNodeUrl;
+    private localNodeEnabled;
+    private localNodeToken;
+    private localContributionRouteStatus;
     constructor(config: WireNodeConfig, threadId?: string);
     /** Set or update the thread ID (used for mesh coordination) */
     setThreadId(id: string): void;
@@ -287,6 +357,9 @@ export declare class WireAPI {
      * Access a contribution (detail endpoint). Accessing IS purchasing for priced items.
      */
     accessContribution(contributionId: string): Promise<Record<string, unknown>>;
+    private verifyLocalContributionReadRoute;
+    private localHeaders;
+    private tryLocalContributionRead;
     /**
      * Rate a Wire item. Free. Must have accessed it first.
      */
@@ -516,21 +589,8 @@ export declare class WireAPI {
         template_id: string;
         overrides?: Record<string, unknown>;
     }): Promise<Record<string, unknown>>;
-    invokeAction(params: {
-        action_id: string;
-        mode: string;
-        input?: Record<string, unknown>;
-        max_cost?: number;
-        quote_id?: string;
-    }): Promise<Record<string, unknown>>;
-    invokeActionChain(params: {
-        action_id: string;
-        mode: string;
-        input?: Record<string, unknown>;
-        max_cost?: number;
-        chain_id?: string;
-        quote_id?: string;
-    }): Promise<Record<string, unknown>>;
+    invokeAction(params: LegacyActionInvokeParams): Promise<Record<string, unknown>>;
+    invokeActionChain(params: LegacyActionChainParams): Promise<Record<string, unknown>>;
     runChain(params: {
         chain: string;
         mode: 'quote' | 'trusted';
@@ -542,6 +602,14 @@ export declare class WireAPI {
             mode?: 'start' | 'direct';
         };
         include_steps?: boolean;
+        async_ack?: boolean;
+        timeout_ms?: number;
+    }): Promise<Record<string, unknown>>;
+    pollChainRun(params: {
+        run_id?: string;
+        run_handle_path?: string;
+        chain: string;
+        include_steps?: boolean;
     }): Promise<Record<string, unknown>>;
     resolveHandlePath(handlePath: string): Promise<Record<string, unknown>>;
     proposeSupersession(targetId: string, contributionId: string): Promise<Record<string, unknown>>;
@@ -647,6 +715,7 @@ export declare class WireAPI {
     getCorpusHealth(slug: string): Promise<Record<string, unknown>>;
     getCorpusRevenue(slug: string, days?: number): Promise<Record<string, unknown>>;
     bulkIngestDocuments(slug: string, documents: Array<Record<string, unknown>>): Promise<Record<string, unknown>>;
+    wireSyncDocuments(corpusSlug: string, documents: WireSyncDocumentInput[], marketNativeDocsIngest?: MarketNativeDocsIngestMode): Promise<WireSyncResponse>;
     bulkCorpusOperation(slug: string, action: string, params?: Record<string, unknown>, documentIds?: string[]): Promise<Record<string, unknown>>;
     mergeAgent(sourceAgentId: string, targetAgentId: string): Promise<Record<string, unknown>>;
     reverseMerge(sourceAgentId: string): Promise<Record<string, unknown>>;

package/dist/api.js

@@ -1,4 +1,18 @@
 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;
+function legacyActionRequestOptions(params) {
+    if (params.mode === 'quote') {
+        return { body: params, timeoutMs: DEFAULT_ACTION_QUOTE_TIMEOUT_MS };
+    }
+    const timeoutMs = params.timeout_ms ?? DEFAULT_TRUSTED_CHAIN_TIMEOUT_MS;
+    return {
+        body: { ...params, timeout_ms: timeoutMs },
+        timeoutMs: timeoutMs + TRUSTED_CHAIN_CLIENT_GRACE_MS,
+    };
+}
 const DEFAULT_WAIT_TIMEOUT_SECONDS = 30;
 const MAX_WAIT_TIMEOUT_SECONDS = 1800;
 const DEFAULT_WAIT_LIMIT = 50;
@@ -64,6 +78,18 @@ export const __wireApiTestInternals = {
     normalizeHelpTopic,
     parseSseBlock,
 };
+function normalizeLocalNodeUrl(localNodeUrl) {
+    return (localNodeUrl || 'http://127.0.0.1:8765').replace(/\/+$/, '');
+}
+function localContributionReadPath(identifier) {
+    return `/pyramid/contributions/${encodeURIComponent(identifier)}`;
+}
+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;
+}
 function parseSseBlock(block) {
     let event = 'message';
     const dataLines = [];
@@ -100,11 +126,19 @@ export class WireAPI {
     token;
     nodeId;
     threadId;
+    localNodeUrl;
+    localNodeEnabled;
+    localNodeToken;
+    localContributionRouteStatus;
     constructor(config, threadId) {
         this.baseUrl = config.apiUrl;
         this.token = config.apiToken;
         this.nodeId = config.nodeId;
         this.threadId = threadId || null;
+        this.localNodeUrl = normalizeLocalNodeUrl(config.localNodeUrl);
+        this.localNodeEnabled = config.localNodeEnabled !== false;
+        this.localNodeToken = config.localNodeToken || '';
+        this.localContributionRouteStatus = null;
     }
     /** Set or update the thread ID (used for mesh coordination) */
     setThreadId(id) {
@@ -226,8 +260,7 @@ export class WireAPI {
             qs.set('limit', String(params.limit));
         if (params.offset !== undefined)
             qs.set('offset', String(params.offset));
-        if (params.sort)
-            qs.set('sort', params.sort);
+        qs.set('sort', params.sort || 'recency');
         if (params.watchlist)
             qs.set('watchlist', 'true');
         if (params.list)
@@ -332,10 +365,15 @@ export class WireAPI {
      */
     async accessContribution(contributionId) {
         let identifier = contributionId;
+        const localResult = await this.tryLocalContributionRead(identifier);
+        if (localResult) {
+            return localResult;
+        }
         // Slash-bearing handle paths are the human-facing identifier, but the
         // purchase/read route is too important to leave at the mercy of path
         // decoding across proxies. Mirror wire_inspect: resolve handles first,
-        // then perform the paid/idempotent read by canonical UUID.
+        // then perform the paid/idempotent read by canonical UUID. Local-node
+        // store-first read is tried before this so cached handles can stay zero-net.
         if (contributionId.includes('/')) {
             try {
                 const resolved = await this.resolveHandlePath(contributionId);
@@ -348,8 +386,84 @@ export class WireAPI {
                 // and for deployments where the resolver is unavailable.
             }
         }
+        if (identifier !== contributionId) {
+            const localResolvedResult = await this.tryLocalContributionRead(identifier);
+            if (localResolvedResult) {
+                return localResolvedResult;
+            }
+        }
         return this.request('GET', `/wire/contribution/${encodeURIComponent(identifier)}`);
     }
+    async verifyLocalContributionReadRoute() {
+        if (!this.localNodeEnabled)
+            return 'unavailable';
+        if (!this.localNodeToken)
+            return 'unavailable';
+        if (this.localContributionRouteStatus)
+            return this.localContributionRouteStatus;
+        try {
+            const health = await fetch(`${this.localNodeUrl}/health`, {
+                method: 'GET',
+                signal: AbortSignal.timeout(2_000),
+            });
+            if (!health.ok) {
+                this.localContributionRouteStatus = 'unavailable';
+                return this.localContributionRouteStatus;
+            }
+            const probe = await fetch(`${this.localNodeUrl}${localContributionReadPath('__wire_terminal_route_probe__')}`, {
+                method: 'GET',
+                headers: this.localHeaders(),
+                signal: AbortSignal.timeout(2_000),
+            });
+            this.localContributionRouteStatus = isLocalRouteServedStatus(probe.status) ? 'ready' : 'unavailable';
+            return this.localContributionRouteStatus;
+        }
+        catch {
+            this.localContributionRouteStatus = 'unavailable';
+            return this.localContributionRouteStatus;
+        }
+    }
+    localHeaders() {
+        const headers = {
+            'Authorization': `Bearer ${this.localNodeToken}`,
+            'Content-Type': 'application/json',
+        };
+        if (this.threadId) {
+            headers['X-Wire-Thread'] = this.threadId;
+        }
+        return headers;
+    }
+    async tryLocalContributionRead(identifier) {
+        if (!this.localNodeEnabled)
+            return null;
+        const routeStatus = await this.verifyLocalContributionReadRoute();
+        if (routeStatus !== 'ready')
+            return null;
+        const path = localContributionReadPath(identifier);
+        try {
+            const res = await fetch(`${this.localNodeUrl}${path}`, {
+                method: 'GET',
+                headers: this.localHeaders(),
+                signal: AbortSignal.timeout(10_000),
+            });
+            if (res.ok) {
+                return await res.json();
+            }
+            if (isLocalReadFallbackStatus(res.status)) {
+                return null;
+            }
+            const err = await res.json().catch(() => ({ error: res.statusText }));
+            const message = err.error || res.statusText;
+            throw new Error(`Local node GET ${path} failed (${res.status}): ${message}`);
+        }
+        catch (err) {
+            if (err?.name === 'AbortError')
+                return null;
+            if (err?.message?.startsWith('Local node GET '))
+                throw err;
+            return null;
+        }
+    }
     /**
      * Rate a Wire item. Free. Must have accessed it first.
      */
@@ -836,13 +950,30 @@ export class WireAPI {
     }
     // ── Actions ───────────────────────────────────────────────
     async invokeAction(params) {
-        return this.request('POST', '/wire/action/invoke', params);
+        const { body, timeoutMs } = legacyActionRequestOptions(params);
+        return this.request('POST', '/wire/action/invoke', body, timeoutMs);
     }
     async invokeActionChain(params) {
-        return this.request('POST', '/wire/action/chain', params);
+        const { body, timeoutMs } = legacyActionRequestOptions(params);
+        return this.request('POST', '/wire/action/chain', body, timeoutMs);
     }
     async runChain(params) {
-        return this.request('POST', '/wire/chains/run', params);
+        const requestParams = params.mode === 'trusted' && !params.async_ack
+            ? { ...params, timeout_ms: params.timeout_ms ?? DEFAULT_TRUSTED_CHAIN_TIMEOUT_MS }
+            : params;
+        const timeoutMs = requestParams.mode === 'trusted' && !requestParams.async_ack
+            ? (requestParams.timeout_ms ?? DEFAULT_TRUSTED_CHAIN_TIMEOUT_MS) + TRUSTED_CHAIN_CLIENT_GRACE_MS
+            : 30_000;
+        return this.request('POST', '/wire/chains/run', requestParams, timeoutMs);
+    }
+    async pollChainRun(params) {
+        const runIdentifier = params.run_handle_path ?? params.run_id;
+        if (!runIdentifier)
+            throw new Error('pollChainRun requires run_handle_path or run_id');
+        const qs = new URLSearchParams({ chain: params.chain });
+        if (params.include_steps)
+            qs.set('include_steps', 'true');
+        return this.request('GET', `/wire/chains/runs/${encodeURIComponent(runIdentifier)}?${qs.toString()}`, undefined, 30_000);
     }
     // ── Handle Paths ──────────────────────────────────────────
     async resolveHandlePath(handlePath) {
@@ -1068,6 +1199,13 @@ export class WireAPI {
     async bulkIngestDocuments(slug, documents) {
         return this.request('POST', `/wire/corpora/${encodeURIComponent(slug)}/ingest`, { documents }, 60_000);
     }
+    async wireSyncDocuments(corpusSlug, documents, marketNativeDocsIngest = 'off') {
+        return this.requestUnwrap('POST', '/wire/sync', {
+            corpus_slug: corpusSlug,
+            market_native_docs_ingest: marketNativeDocsIngest,
+            documents,
+        }, DEFAULT_WIRE_SYNC_TIMEOUT_MS);
+    }
     async bulkCorpusOperation(slug, action, params, documentIds) {
         return this.request('POST', `/wire/corpora/${encodeURIComponent(slug)}/bulk`, { action, params, document_ids: documentIds });
     }