@envarai/envarpay 2026.1029.1 → 2026.1108.1

package/README.md

@@ -1,6 +1,35 @@
-# `@envarai/envarpay`
+# @envarai/envarpay
 
-This package runs an A2A seller gate for free services and Envar account-balance purchases. Buyers use their Envar Wallet; this package does not sign buyer payments.
+The current TypeScript package serves free A2A capabilities and verifies Envar
+account-balance claims for paid services. It does not sign buyer payments.
+The Python distribution named envarpay is
+[a separate legacy MCP/x402 implementation](https://github.com/EnvarAI/EnvarPay/blob/main/docs/legacy/python.md).
+
+## Try a local free service
+
+From a directory where this package is installed:
+
+~~~sh
+node "$(npm root)/@envarai/envarpay/examples/local-free-service/demo.mjs"
+~~~
+
+From this source directory:
+
+~~~sh
+npm ci --ignore-scripts
+npm run build
+node examples/local-free-service/demo.mjs
+~~~
+
+The demo needs no Envar account, integration credential or payment. It creates
+two loopback A2A services and private SQLite state, then verifies one original
+Task/result across replay and restart. Expect capability_executions: 1,
+paid_operations: 0 and matching task_id, replay_task_id, restarted_get_task_id
+and restarted_replay_task_id. This is a deterministic contract example, not AI
+inference or in-flight native execution recovery.
+
+[Full local guide](https://github.com/EnvarAI/EnvarPay/blob/main/docs/local-free-service.md) ·
+[Cloud commerce guide](https://envar.ai/guide/commerce)
 
 ## Native Agent connection
 

package/examples/local-free-service/README.md

@@ -0,0 +1,17 @@
+# Free local A2A service
+
+Run this example with Node.js 22.14+ (24 recommended):
+
+```sh
+node "$(npm root)/@envarai/envarpay/examples/local-free-service/demo.mjs"
+```
+
+From a built source checkout, use `node examples/local-free-service/demo.mjs` in `packages/typescript`.
+
+It runs two authenticated loopback A2A services using the real CommerceServer, native A2A executor and SQLite stores. A private deterministic capability uppercases a fixed input; there is no model, Envar account or payment. The driver checks one actual capability execution, identical Task IDs on replay, and the same completed result after a new server process opens the original stores.
+
+Use `--state-dir /private/demo-state` to choose an empty/private state directory. Otherwise a private temporary directory is created and retained. The result includes its path, but never bearer tokens. Repeating the command with that same directory reads the original result.
+
+This is completed-result persistence, not a claim that unfinished external model tasks recover after a restart. Paid services retain their normal payment gate.
+
+[Full walkthrough](https://github.com/EnvarAI/EnvarPay/blob/main/docs/local-free-service.md) · [Contributing](https://github.com/EnvarAI/EnvarPay/blob/main/CONTRIBUTING.md)

package/examples/local-free-service/demo.mjs

@@ -0,0 +1,178 @@
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { once } from 'node:events';
+import { createInterface } from 'node:readline';
+import { existsSync, mkdtempSync, readFileSync, writeFileSync, realpathSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { parseArgs } from 'node:util';
+import { fileURLToPath } from 'node:url';
+import { DatabaseSync } from 'node:sqlite';
+import { setTimeout as sleep } from 'node:timers/promises';
+import { EXPECTED_TEXT, INPUT, MESSAGE_ID, SERVICE_PATH, prepareState } from './shared.mjs';
+
+export async function launchServer(stateDirectory) {
+  const child = spawn(process.execPath, [
+    fileURLToPath(new URL('./server.mjs', import.meta.url)), '--state-dir', stateDirectory,
+  ], { stdio: ['ignore', 'pipe', 'pipe'] });
+  const closed = once(child, 'close');
+  let stderr = '';
+  child.stderr.setEncoding('utf8');
+  child.stderr.on('data', chunk => { stderr = (stderr + chunk).slice(-4096); });
+  const lines = createInterface({ input: child.stdout });
+  let timer;
+  try {
+    const ready = await Promise.race([
+      new Promise((resolve, reject) => {
+        lines.on('line', line => {
+          try { const row = JSON.parse(line); if (row.event === 'ready') resolve(row); }
+          catch { reject(new Error('Example server emitted an invalid readiness record.')); }
+        });
+        child.once('error', reject);
+        child.once('exit', code => reject(new Error('Example server exited before ready (' + code + '): ' + stderr)));
+      }),
+      new Promise((_, reject) => { timer = setTimeout(() => reject(new Error('Example server readiness timed out.')), 15000); }),
+    ]);
+    return {
+      ...ready,
+      async stop() {
+        child.kill('SIGTERM');
+        const force = setTimeout(() => child.kill('SIGKILL'), 5000);
+        try {
+          const [code, signal] = await closed;
+          assert.equal(code, 0, 'Example shutdown failed: ' + signal + ' ' + stderr);
+        } finally { clearTimeout(force); lines.close(); }
+      },
+    };
+  } catch (error) {
+    child.kill('SIGKILL');
+    await closed;
+    lines.close();
+    throw error;
+  } finally { clearTimeout(timer); }
+}
+
+export async function rpc(origin, token, method, params) {
+  assert.equal(new URL(origin).hostname, '127.0.0.1');
+  const response = await fetch(origin + SERVICE_PATH + '/a2a', {
+    method: 'POST', redirect: 'error', signal: AbortSignal.timeout(10000),
+    headers: {
+      Authorization: 'Bearer ' + token, 'Content-Type': 'application/json', 'A2A-Version': '1.0',
+    },
+    body: JSON.stringify({ jsonrpc: '2.0', id: method + '-local-demo', method, params }),
+  });
+  assert.equal(response.status, 200);
+  return response.json();
+}
+export const message = (input = INPUT) => ({
+  message: { messageId: MESSAGE_ID, role: 'ROLE_USER', parts: [{ data: input }] },
+  configuration: { returnImmediately: true },
+});
+export function resultText(task) {
+  return (task.artifacts ?? []).flatMap(a => a.parts ?? []).map(p => p.text ?? '').join('\n');
+}
+async function completed(origin, token, taskId) {
+  const deadline = Date.now() + 10000;
+  while (Date.now() < deadline) {
+    const response = await rpc(origin, token, 'GetTask', { id: taskId });
+    assert.ok(!response.error, JSON.stringify(response.error));
+    if (response.result.status.state === 'TASK_STATE_COMPLETED') return response.result;
+    if (response.result.status.state === 'TASK_STATE_FAILED' || response.result.metadata?.recoveryRequired) {
+      throw new Error('Inspect the original demo Task; no replacement was submitted.');
+    }
+    await sleep(50);
+  }
+  throw new Error('The original demo Task is still unresolved; keep this state directory.');
+}
+function executionCount(directory) {
+  const path = join(directory, 'executions.jsonl');
+  return existsSync(path) ? readFileSync(path, 'utf8').trim().split('\n').filter(Boolean).length : 0;
+}
+function inspectLedger(directory, name) {
+  const db = new DatabaseSync(join(directory, name + '.sqlite3'), { readOnly: true });
+  try {
+    return {
+      orders: db.prepare('SELECT message_id, payment_state, execution_state FROM commerce_orders').all(),
+      payment_attempts: db.prepare('SELECT COUNT(*) AS count FROM commerce_payment_attempts').get().count,
+      tasks: db.prepare('SELECT COUNT(*) AS count FROM commerce_tasks').get().count,
+    };
+  } finally { db.close(); }
+}
+
+/** Real HTTP + process restart demonstration; completed-result replay, not an in-flight recovery claim. */
+export async function runDemo(directory) {
+  const state = await prepareState(directory);
+  let server;
+  try {
+    server = await launchServer(state.stateDirectory);
+    const firstPid = server.pid;
+    const cardResponse = await fetch(server.origin + SERVICE_PATH + '/agent-card.json', { signal: AbortSignal.timeout(10000) });
+    assert.equal(cardResponse.status, 200);
+    const card = await cardResponse.json();
+    assert.equal(card.supportedInterfaces[0].protocolVersion, '1.0');
+    const unauthorized = await fetch(server.origin + SERVICE_PATH + '/a2a', { method: 'POST', signal: AbortSignal.timeout(10000) });
+    assert.equal(unauthorized.status, 401);
+    const first = await rpc(server.origin, state.tokens.buyer, 'SendMessage', message());
+    assert.ok(first.result?.task?.id, JSON.stringify(first.error));
+    const taskId = first.result.task.id;
+    const delivered = await completed(server.origin, state.tokens.buyer, taskId);
+    assert.equal(resultText(delivered), EXPECTED_TEXT);
+    const replay = await rpc(server.origin, state.tokens.buyer, 'SendMessage', message());
+    assert.equal(replay.result.task.id, taskId);
+    const conflict = await rpc(server.origin, state.tokens.buyer, 'SendMessage', message({ text: 'Changed input must not run' }));
+    assert.ok(conflict.error, 'Changed input using the original message ID must be rejected.');
+    assert.equal(executionCount(state.stateDirectory), 1);
+    await server.stop();
+    server = undefined;
+
+    // A different OS process reopens the original SQLite stores and original auth files.
+    server = await launchServer(state.stateDirectory);
+    const secondPid = server.pid;
+    const restored = await rpc(server.origin, state.tokens.buyer, 'GetTask', { id: taskId });
+    assert.equal(restored.result.id, taskId);
+    assert.equal(restored.result.status.state, 'TASK_STATE_COMPLETED');
+    assert.equal(resultText(restored.result), EXPECTED_TEXT);
+    const replayAfterRestart = await rpc(server.origin, state.tokens.buyer, 'SendMessage', message());
+    assert.equal(replayAfterRestart.result.task.id, taskId);
+    assert.equal(resultText(replayAfterRestart.result.task), EXPECTED_TEXT);
+    assert.equal(executionCount(state.stateDirectory), 1);
+    await server.stop();
+    server = undefined;
+
+    const seller = inspectLedger(state.stateDirectory, 'seller');
+    const runtime = inspectLedger(state.stateDirectory, 'runtime');
+    for (const ledger of [seller, runtime]) {
+      assert.equal(ledger.orders.length, 1);
+      assert.equal(ledger.orders[0].message_id, MESSAGE_ID);
+      assert.equal(ledger.orders[0].payment_state, 'not_required');
+      assert.equal(ledger.orders[0].execution_state, 'completed');
+      assert.equal(ledger.payment_attempts, 0);
+      assert.equal(ledger.tasks, 1);
+    }
+    const proof = {
+      example: 'local-free-service', capability: 'deterministic uppercase, not AI inference',
+      message_id: MESSAGE_ID, task_id: taskId,
+      replay_task_id: replay.result.task.id,
+      restarted_get_task_id: restored.result.id,
+      restarted_replay_task_id: replayAfterRestart.result.task.id,
+      server_processes: [firstPid, secondPid],
+      result: EXPECTED_TEXT, capability_executions: executionCount(state.stateDirectory),
+      seller, runtime, paid_operations: 0, state_directory: state.stateDirectory,
+      scope: 'Completed result survives process restart. No in-flight runtime recovery, model quality, payment or production acceptance claim.',
+    };
+    writeFileSync(join(state.stateDirectory, 'result.json'), JSON.stringify(proof, null, 2) + '\n', { mode: 0o600, flush: true });
+    return proof;
+  } finally { await server?.stop(); }
+}
+
+if (process.argv[1] && realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url))) {
+  try {
+    const { values } = parseArgs({ options: { 'state-dir': { type: 'string' } } });
+    const directory = values['state-dir'] ?? mkdtempSync(join(tmpdir(), 'envarpay-local-free-'));
+    const proof = await runDemo(directory);
+    console.log(JSON.stringify(proof, null, 2));
+  } catch (error) {
+    console.error('Local free example failed: ' + error.message);
+    process.exitCode = 1;
+  }
+}

package/examples/local-free-service/server.mjs

@@ -0,0 +1,94 @@
+import { appendFileSync, realpathSync } from 'node:fs';
+import { join } from 'node:path';
+import { once } from 'node:events';
+import { fileURLToPath } from 'node:url';
+import { parseArgs } from 'node:util';
+import { setTimeout as sleep } from 'node:timers/promises';
+import { Task } from '@a2a-js/sdk';
+import { CommerceServer, CommerceStore, bearerAuthenticator, listenCommerce, nativeA2AExecutor } from '@envarai/envarpay/server';
+import { HOST, SERVICE_PATH, prepareState, sellerConfig } from './shared.mjs';
+
+/**
+ * Both A2A endpoints and both SQLite stores are real SDK components.
+ * The only example-specific capability is deterministic string transformation.
+ * There is no Envar claim, wallet, model credential or paid offer.
+ */
+export async function startDemoServer(directory) {
+  const state = await prepareState(directory);
+  const privateOrigin = 'http://' + HOST + ':' + state.privatePort;
+  const origin = 'http://' + HOST + ':' + state.publicPort;
+  const cardUrl = privateOrigin + SERVICE_PATH + '/agent-card.json';
+  const upstreamStore = new CommerceStore(join(state.stateDirectory, 'runtime.sqlite3'));
+  let sellerStore, upstream, seller, upstreamHttp, sellerHttp;
+  const controller = new AbortController();
+  const closeHttp = async http => {
+    if (!http) return;
+    http.closeIdleConnections();
+    await new Promise(resolve => http.close(resolve));
+  };
+  const stop = async () => {
+    seller?.stop();
+    upstream?.stop();
+    controller.abort();
+    await Promise.all([closeHttp(sellerHttp), closeHttp(upstreamHttp)]);
+    while (seller?.isRunning || upstream?.isRunning) await sleep(5);
+    sellerStore?.close();
+    upstreamStore.close();
+  };
+  try {
+    upstream = new CommerceServer({
+      config: sellerConfig('local-private-demo', cardUrl),
+      origin: privateOrigin, store: upstreamStore,
+      authenticate: bearerAuthenticator({ [state.tokens.runtime]: 'local-seller' }),
+      execute: async function* (order) {
+        appendFileSync(join(state.stateDirectory, 'executions.jsonl'),
+          JSON.stringify({ message_id: order.messageId, order_id: order.id }) + '\n',
+          { mode: 0o600, flush: true });
+        yield Task.fromJSON({
+          id: 'deterministic-' + order.id, contextId: 'demo-' + order.id,
+          status: { state: 'TASK_STATE_COMPLETED' },
+          artifacts: [{ artifactId: 'uppercase-result', name: 'Deterministic demo result',
+            parts: [{ text: 'DEMO ONLY: ' + order.input.text.toUpperCase() }] }],
+        });
+      },
+    });
+    upstreamHttp = listenCommerce(upstream, privateOrigin, HOST, state.privatePort);
+    await once(upstreamHttp, 'listening');
+    sellerStore = new CommerceStore(join(state.stateDirectory, 'seller.sqlite3'));
+    seller = new CommerceServer({
+      config: sellerConfig('local-free-demo', cardUrl), origin, store: sellerStore,
+      authenticate: bearerAuthenticator({ [state.tokens.buyer]: 'local-buyer' }),
+      execute: nativeA2AExecutor({ uppercase: state.tokens.runtime }, fetch, controller.signal),
+    });
+    sellerHttp = listenCommerce(seller, origin, HOST, state.publicPort);
+    await once(sellerHttp, 'listening');
+    return { origin, privateOrigin, stateDirectory: state.stateDirectory, stop };
+  } catch (error) {
+    await stop();
+    throw error;
+  }
+}
+
+if (process.argv[1] && realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url))) {
+  const { values } = parseArgs({ options: { 'state-dir': { type: 'string' } } });
+  if (!values['state-dir']) throw new Error('Usage: node server.mjs --state-dir /private/demo-state');
+  let server;
+  try {
+    server = await startDemoServer(values['state-dir']);
+    let stopping = false;
+    const shutdown = async () => {
+      if (stopping) return;
+      stopping = true;
+      await server.stop();
+    };
+    process.once('SIGINT', shutdown);
+    process.once('SIGTERM', shutdown);
+    process.stdout.write(JSON.stringify({
+      event: 'ready', pid: process.pid, origin: server.origin,
+      private_origin: server.privateOrigin, state_directory: server.stateDirectory,
+    }) + '\n');
+  } catch (error) {
+    console.error('Local free example could not start: ' + error.message);
+    process.exitCode = 1;
+  }
+}

package/examples/local-free-service/shared.mjs

@@ -0,0 +1,86 @@
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { randomBytes } from 'node:crypto';
+import { createServer } from 'node:http';
+import { once } from 'node:events';
+import { join, resolve } from 'node:path';
+
+export const MESSAGE_ID = 'local-free-service-original-v1';
+export const INPUT = Object.freeze({ text: 'Hello from the local free service' });
+export const EXPECTED_TEXT = 'DEMO ONLY: HELLO FROM THE LOCAL FREE SERVICE';
+export const SERVICE_PATH = '/services/uppercase/v1/offers/free';
+export const HOST = '127.0.0.1';
+
+export function privateFile(path) {
+  const stat = lstatSync(path);
+  if (!stat.isFile() || stat.isSymbolicLink() || (stat.mode & 0o077)) {
+    throw new Error('Use an owner-only regular demo state file: ' + path);
+  }
+  return readFileSync(path, 'utf8');
+}
+export function readJson(path) { return JSON.parse(privateFile(path)); }
+
+async function reservePorts() {
+  const servers = [createServer(), createServer()];
+  try {
+    for (const server of servers) {
+      server.listen(0, HOST);
+      await once(server, 'listening');
+    }
+    return servers.map(server => server.address().port);
+  } finally {
+    await Promise.all(servers.map(server => new Promise(resolve => server.close(resolve))));
+  }
+}
+
+/** Example state is private and deliberately kept after the demonstration. */
+export async function prepareState(directory) {
+  const stateDirectory = resolve(directory);
+  mkdirSync(stateDirectory, { recursive: true, mode: 0o700 });
+  const stat = lstatSync(stateDirectory);
+  if (!stat.isDirectory() || stat.isSymbolicLink() || (stat.mode & 0o077)) {
+    throw new Error('Choose a private demo directory (mode 700), not a symlink.');
+  }
+  const metadataPath = join(stateDirectory, 'demo.json');
+  if (!existsSync(metadataPath)) {
+    if (readdirSync(stateDirectory).length) throw new Error('Choose an empty directory or this example’s original state directory.');
+    const [privatePort, publicPort] = await reservePorts();
+    writeFileSync(join(stateDirectory, 'tokens.json'), JSON.stringify({
+      buyer: randomBytes(32).toString('hex'),
+      runtime: randomBytes(32).toString('hex'),
+    }), { mode: 0o600, flag: 'wx', flush: true });
+    writeFileSync(metadataPath, JSON.stringify({
+      example: 'envarpay-local-free-service', version: 1, privatePort, publicPort,
+    }), { mode: 0o600, flag: 'wx', flush: true });
+  }
+  const metadata = readJson(metadataPath);
+  const tokens = readJson(join(stateDirectory, 'tokens.json'));
+  if (metadata.example !== 'envarpay-local-free-service' || metadata.version !== 1 ||
+      ![metadata.privatePort, metadata.publicPort].every(p => Number.isInteger(p) && p > 0 && p < 65536) ||
+      metadata.privatePort === metadata.publicPort ||
+      ![tokens.buyer, tokens.runtime].every(t => typeof t === 'string' && /^[a-f0-9]{64}$/.test(t))) {
+    throw new Error('Preserve the original demo state; its identity or local credentials are invalid.');
+  }
+  return { stateDirectory, ...metadata, tokens };
+}
+
+export function sellerConfig(agentId, cardUrl) {
+  return {
+    configVersion: 1,
+    agent: { id: agentId, name: 'Local deterministic demonstration — no model' },
+    paymentProfiles: {},
+    services: [{
+      id: 'uppercase', name: 'Deterministic uppercase demo', revision: 1,
+      execution: { type: 'a2a', cardUrl },
+      contract: {
+        inputSchema: {
+          type: 'object', additionalProperties: false,
+          properties: { text: { type: 'string', minLength: 1, maxLength: 500 } },
+          required: ['text'],
+        },
+        deliverables: ['Uppercase text prefixed with DEMO ONLY'],
+        targetDurationSeconds: 30, includedRevisions: 0,
+      },
+      offers: [{ id: 'free', pricing: { kind: 'free' }, collection: { kind: 'none' } }],
+    }],
+  };
+}

package/node_modules/@envarai/connect/CONTRIBUTING.md

@@ -0,0 +1,9 @@
+# Contributing
+
+Use Node.js 22.14+ (24 recommended). Run `npm ci --ignore-scripts`, `npm test`, and verify a packed tarball with `node scripts/verify-package.mjs ARTIFACT_DIRECTORY`.
+
+Keep task identities, durable recovery, owner-scoped authorization and local credentials intact. Native models/tools remain owned by the native runtime. Add adapter and recovery tests with isolated profiles; never use real user credentials in fixtures. Describe the reproduced behavior and tests in your PR. Changes are MIT licensed; preserve upstream notices.
+
+Start with the [code map and adapter contract](docs/adapter-development.md), then pick a [scoped contribution brief](docs/contribution-tasks.md). Include a reproduction, file locations, expected original-task behavior and acceptance commands. Public tests use isolated fixtures and need no production account.
+
+Package and website versions have separate release owners; see [compatibility](docs/compatibility.md). The normal test suite checks current install examples against package.json.

package/node_modules/@envarai/connect/README.md

@@ -2,10 +2,33 @@
 
 Connect an Agent you run to [Envar](https://envar.ai). Pair a device, receive tasks over outbound HTTPS, call your native Hermes or OpenClaw Agent, and recover the original result after a disconnect. Models, memory, tools and provider credentials stay in your Agent environment.
 
+## What is open source
+
+| Project | Public scope | License |
+| --- | --- | --- |
+| [EnvarConnect](https://github.com/EnvarAI/EnvarConnect) | Native connectors, task SDK, Agent Work v1 contracts | MIT |
+| [EnvarPay](https://github.com/EnvarAI/EnvarPay) | Seller quotes, account-balance claim verification, paid execution gate | MIT |
+
+The hosted Envar website, account service and ledger are maintained separately.
+This repository does not include a self-hosted copy of that platform. Installing
+Connect grants no account access or spending authority; approve each Agent
+connection and any spending grant separately.
+
+## Choose your starting point
+
+| Goal | Start |
+| --- | --- |
+| Connect an existing Hermes/OpenClaw to Envar | [Native setup](docs/native-connector.md) |
+| Develop or inspect the Connector without cloud credentials | [Adapter development and local contract tests](docs/adapter-development.md) |
+| Understand package, website and bundled Pay versions | [Compatibility](docs/compatibility.md) |
+| Make a first contribution | [Concrete task briefs](docs/contribution-tasks.md) |
+
+For the independent seller-side developer path, start with [EnvarPay](https://github.com/EnvarAI/EnvarPay). Connect itself is the client and native adapter; a compatible enrollment/WorkService server is still required for a live connection.
+
 ## Install
 
 ```sh
-npm install --global @envarai/connect
+npm install --global --ignore-scripts @envarai/connect@2026.1107.2
 envar-connect --version
 ```
 
@@ -22,6 +45,13 @@ Use `--framework openclaw` for OpenClaw. Restart the existing native gateway whe
 
 The default state remains `~/.envarpay/connectors/AGENT_UUID` for compatibility. Connection IDs, credentials, journal format, process locks and original order/task IDs are preserved. Run only one receiver for a journal. Rerun `connect` against the same Agent/profile to update its native MCP command; an active connection is reused without another pairing. Keep the original directory when reinstalling or rolling back.
 
+Linux receivers require `flock` from util-linux and a filesystem that supports
+file locks. The kernel releases the receiver lock when its process exits, so
+container restarts and reused PIDs cannot strand the connection. When upgrading
+an orphaned legacy PID lock, first stop the old receiver and verify no other
+receiver uses that journal, then move only `receiver.lock` aside once. Preserve
+the SQLite journal, credentials and native binding. Never remove an active lock.
+
 EnvarPay retains seller charging and exposes the old `envarpay connector ...` command as a compatibility entry. EnvarConnect does not depend on EnvarPay. Free tasks need no payment setup. Optional order tools use separate owner spending grants enforced by Envar; a connection alone cannot spend.
 
 ## API and development
@@ -34,4 +64,14 @@ npm test
 npm run version:date
 ```
 
+If your npm registry is a corporate mirror, check `npm config get registry`.
+The connection command on your Envar Agent page also offers a fixed official
+bundled package with integrity verification; it installs without fetching npm
+dependencies. A mirror returning 404 does not establish that the public package
+is missing.
+
 See [native setup](docs/native-connector.md), [migration](docs/migration.md), [release automation](docs/releasing.md), and [contributing](CONTRIBUTING.md). The non-root container is `ghcr.io/envarai/connect`; it contains the Connector, not a native Agent runtime.
+GHCR package access is separate from repository visibility. Anonymous image pulls
+are not currently part of the verified public installation path. Use the npm
+package, the official bundled download, or build the checked-out `Dockerfile`
+locally; a managed image may require an authorized GHCR login.

package/node_modules/@envarai/connect/SECURITY.md

@@ -0,0 +1,9 @@
+# Security policy
+
+EnvarConnect runs beside a user-owned Agent and holds its scoped Envar credential, A2A access tokens, model-key references, encrypted balance claims, and local Task ledger. Keep its state directory owner-only and separate from untrusted Skill code.
+
+Paid execution must wait for a captured claim that matches the original Envar order, seller, service revision, quote, amount, input digest, and Task ID. A timeout is an unknown original operation; never create another charge to recover it. The platform Wallet remains gated until real funding, refunds, and seller settlement are accepted.
+
+Report a vulnerability using [GitHub private vulnerability reporting](https://github.com/EnvarAI/EnvarConnect/security/advisories/new). Include the affected version and a synthetic reproduction. Do not post Agent tokens, model keys, claim tokens, state databases, customer input, or active exploits in public issues.
+
+The latest stable calendar release is the maintenance target. There is no promised response SLA or production security certification.

package/node_modules/@envarai/connect/dist/connector/state.d.ts

@@ -35,8 +35,9 @@ export declare class ConnectorJournal {
     private readonly db;
     private lock?;
     constructor(path: string, binding: ConnectorBinding);
-    /** A stale process can be replaced only after proving that PID no longer exists. */
+    /** One receiver per journal; Linux kernel locks survive PID reuse safely. */
     acquireProcessLock(path: string): void;
+    private acquireKernelLock;
     ingest(delivery: Delivery): void;
     save(record: LocalWork): void;
     get(id: string): LocalWork | undefined;

package/node_modules/@envarai/connect/dist/connector/state.js

@@ -1,5 +1,6 @@
 /** Owner-only durable journal. Transport receipts never imply a second execution. */
-import { chmodSync, closeSync, existsSync, lstatSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { chmodSync, closeSync, constants, existsSync, lstatSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
 import { dirname } from 'node:path';
 import { randomUUID, createHash } from 'node:crypto';
 import { DatabaseSync } from 'node:sqlite';
@@ -49,10 +50,14 @@ export class ConnectorJournal {
         }
         this.db.prepare("INSERT OR IGNORE INTO connector_meta VALUES ('binding',?)").run(JSON.stringify(binding));
     }
-    /** A stale process can be replaced only after proving that PID no longer exists. */
+    /** One receiver per journal; Linux kernel locks survive PID reuse safely. */
     acquireProcessLock(path) {
         if (this.lock)
             throw new Error('Connector already owns a process lock');
+        if (process.platform === 'linux') {
+            this.acquireKernelLock(path);
+            return;
+        }
         if (existsSync(path)) {
             privateFile(path);
             const value = parseStored(readFileSync(path, 'utf8'));
@@ -77,6 +82,55 @@ export class ConnectorJournal {
         }
         this.lock = { path, nonce };
     }
+    acquireKernelLock(path) {
+        const guard = `${path}.flock`;
+        if (existsSync(guard))
+            privateFile(guard);
+        const fd = openSync(guard, constants.O_CREAT | constants.O_RDWR | constants.O_NOFOLLOW, 0o600);
+        try {
+            // The child inherits this open file description. Its exit keeps the lock
+            // held by our descriptor; process death releases it even after SIGKILL.
+            const result = spawnSync('flock', ['--nonblock', '3'], { stdio: ['ignore', 'ignore', 'ignore', fd] });
+            if (result.status === 1)
+                throw new Error('Another Connector process is using this journal');
+            if (result.error || result.status !== 0)
+                throw new Error('Linux Connector locking requires util-linux flock and filesystem lock support');
+            if (existsSync(path)) {
+                privateFile(path);
+                const stored = readFileSync(path, 'utf8');
+                const value = parseStored(stored);
+                if (value.locking !== 'flock') {
+                    // Do not steal a legacy PID lock during an upgrade. An operator must
+                    // confirm an orphaned container lock before moving it aside once.
+                    if (!Number.isSafeInteger(value.pid) || value.pid < 1)
+                        throw new Error('Inspect the original Connector lock');
+                    try {
+                        process.kill(value.pid, 0);
+                        throw new Error('Another Connector process is using this journal (legacy PID lock)');
+                    }
+                    catch (error) {
+                        if (error.code !== 'ESRCH')
+                            throw error;
+                    }
+                }
+                unlinkSync(path);
+            }
+            const nonce = randomUUID();
+            // Exclusive creation also excludes a legacy receiver racing this upgrade.
+            const metadata = openSync(path, 'wx', 0o600);
+            try {
+                writeFileSync(metadata, JSON.stringify({ pid: process.pid, nonce, locking: 'flock' }), { flush: true });
+            }
+            finally {
+                closeSync(metadata);
+            }
+            this.lock = { path, nonce, fd };
+        }
+        catch (error) {
+            closeSync(fd);
+            throw error;
+        }
+    }
     ingest(delivery) {
         const work = delivery.work;
         const incoming = ['work', 'input', 'cancel'].includes(delivery.kind);
@@ -176,12 +230,19 @@ export class ConnectorJournal {
     sameObservation(record, observation) { return record.lastObservation === digest(observation); }
     close() {
         this.db.close();
-        if (this.lock && existsSync(this.lock.path)) {
-            privateFile(this.lock.path);
-            const value = parseStored(readFileSync(this.lock.path, 'utf8'));
-            if (value.nonce === this.lock.nonce)
-                unlinkSync(this.lock.path);
+        try {
+            if (this.lock && existsSync(this.lock.path)) {
+                privateFile(this.lock.path);
+                const value = parseStored(readFileSync(this.lock.path, 'utf8'));
+                if (value.nonce === this.lock.nonce)
+                    unlinkSync(this.lock.path);
+            }
+        }
+        finally {
+            // The guard inode stays in place while the kernel releases its lock.
+            if (this.lock?.fd !== undefined)
+                closeSync(this.lock.fd);
+            this.lock = undefined;
         }
-        this.lock = undefined;
     }
 }

package/node_modules/@envarai/connect/docs/adapter-development.md

@@ -0,0 +1,60 @@
+# Build and verify a runtime adapter
+
+Start with the existing interfaces, rather than inventing another task protocol:
+
+| Code | Responsibility |
+| --- | --- |
+| `src/adapters/types.ts` | RuntimeAdapter, capabilities, observation and original execution reference |
+| `src/adapters/a2a-runtime.ts` | Existing Hermes/OpenClaw A2A implementation |
+| `src/adapters/native-a2a.ts` | Native Card and endpoint validation, SendMessage/GetTask transport |
+| `src/connector/loop.ts` | Claim, admission, heartbeat, dispatch, pending reports and recovery |
+| `src/connector/state.ts` | Durable journal and original runtime binding |
+| `contracts/agent-work/v1/schema.json` | Public work/report contract |
+
+## Adapter contract
+
+- `probe()` reports the runtime and capabilities it can actually demonstrate.
+- `start(work, executionKey)` receives the original work ID after durable admission.
+  Call the native operation once. Do not retry an uncertain POST.
+- `observe(reference)` only reads the original Task/session handle. The reference
+  must bind the original runtime and must contain no credential.
+- `provideInput` and `cancel` must distinguish a request from a confirmed native
+  action. An unsupported capability is not a successful cancellation.
+- `close()` releases the adapter's client resources; the runtime lifecycle belongs
+  to its operator.
+
+Do not reuse display names as authorization, move model/provider credentials
+into the platform, or create a substitute execution when the original is unknown.
+
+## Work locally without a production account
+
+```sh
+npm ci --ignore-scripts
+npm test
+# Focused iteration:
+node --test test/connector-adapters.test.mjs test/connector-loop.test.mjs
+```
+
+These tests run actual local transports and journals against isolated fixtures.
+They require no Envar account or model payment. They are protocol tests, not a
+claim that a public WorkService server or a real model ran.
+
+Use the current fixtures in those files as the reference for a new adapter.
+An implementation should show:
+
+1. One native dispatch for an admitted original task.
+2. Restart reads the same saved handle and replays the same pending event.
+3. A lost send response remains unknown, without another SendMessage.
+4. A changed Card/origin/reference cannot redirect the native credential.
+5. Result delivery persists before acknowledgement.
+6. Unsupported input/cancel is reported honestly.
+
+For a real native integration, use an isolated profile you own and document its
+exact version. Keep keys, prompts, private files and personal profiles out of the
+PR. Include sanitized original IDs and observed state transitions, not secrets.
+
+## First contributions
+
+The maintained task briefs are in [contribution tasks](contribution-tasks.md).
+Discuss a new runtime or incompatible schema change before building it. Contract
+tests can be reviewed publicly; access to production credentials is not needed.

package/node_modules/@envarai/connect/docs/compatibility.md

@@ -0,0 +1,61 @@
+# Versions and compatibility
+
+Install the release documented by this checkout:
+
+```sh
+npm install --global --ignore-scripts @envarai/connect@2026.1107.2
+envar-connect --version
+```
+
+The version above comes from package.json. `npm run version:date` updates it and
+the other current installation examples; the normal test suite rejects stale
+commands. Historical migration examples keep their original versions.
+
+## Which version controls what?
+
+| Component | Source of truth | Upgrade behavior |
+| --- | --- | --- |
+| Standalone Connector | This package's package.json / npm release | Upgrade the package, preserve the original directory, and restart its receiver and native MCP process as instructed. |
+| Envar's browser-generated command | The deployed server/web release's fixed package and SHA-512 manifest | The website may deliberately pin a reviewed version. It is not automatically npm latest. |
+| Legacy `envarpay connector` | The Connect dependency bundled in that installed Pay package | Updating standalone Connect does not replace the version inside Pay. Use standalone Connect for a new native connection. |
+| Agent Work protocol | [v1 schema](../contracts/agent-work/v1/schema.json) | Package calendar versions do not change the protocol version. Incompatible changes require a new protocol version. |
+| Native runtime | The existing Hermes/OpenClaw installation | Installing Connect does not upgrade the runtime, change its model, or grant tool permissions. |
+
+Keep only one receiver for a journal. The website and Pay dependency should be
+promoted only after that consumer's contract and installation checks pass.
+A newer package release alone does not establish that an existing receiver was
+upgraded or that every supported runtime was retested.
+
+## Runtime scope
+
+Node.js 22.14+ is required; Node 24 is recommended. CI runs the minimum 22.14.0
+and current Node 22/24 lines. Linux process locks require util-linux `flock`;
+the managed container includes it. Preserve the journal on a filesystem that
+supports the locks.
+
+The last recorded native setup baseline is Hermes 2026.9.24 and OpenClaw
+2026.10.4. The local adapter tests cover the protocol and recovery boundaries;
+they do not call a model or prove acceptance on every later native version.
+Report your exact native version with any compatibility issue.
+
+Both native adapters currently observe original Tasks, but do not advertise
+input continuation or confirmed cancellation. A gateway restart may lose its
+in-memory Task. Keep that operation unknown and inspect it; never create a
+replacement simply because observation timed out.
+
+## Another Envar origin
+
+The Connector accepts an explicitly selected HTTPS origin:
+
+```sh
+envar-connect connect --origin https://your-envar.example --agent AGENT_UUID --framework hermes
+```
+
+The origin must implement the same enrollment and Agent Work contract. This
+package does not contain that server. Loopback HTTP is a deliberate development
+option, not a way to send credentials to arbitrary HTTP hosts. The original
+journal binds the origin, connection, Agent and native adapter; do not edit those
+fields to reuse another connection's task or spending authority.
+
+Read [native setup](native-connector.md), [migration](migration.md), and
+[adapter development](adapter-development.md) before changing an installation.

package/node_modules/@envarai/connect/docs/contribution-tasks.md

@@ -0,0 +1,34 @@
+# Contribution tasks
+
+These are scoped contribution briefs, not promises that every runtime is
+supported. Open an issue describing the brief and your proposed work before
+starting a large change; maintainers can confirm whether someone is already
+working on it.
+
+| Brief | Reproduce / inspect | Files | Acceptance |
+| --- | --- | --- | --- |
+| C1 — Document one additional native version | Use an isolated profile with the [native guide](native-connector.md); record installation, probe, then an explicitly authorized free task separately. | `docs/native-connector.md`, `docs/compatibility.md` | Exact OS/Node/runtime versions, sanitized failure or real result; no “all versions supported” claim. A model call is optional and its own operator's responsibility. |
+| C2 — Multi-byte result boundary coverage | The adapter limits text by UTF-8 bytes and rejects empty completion. Add a case straddling that limit with multi-byte text. | `src/adapters/a2a-runtime.ts`, `test/connector-adapters.test.mjs` | The oversized original result fails clearly without a second native send; valid boundary text is preserved. |
+| C3 — Actionable missing-runtime diagnostics | Reproduce missing executable, ambiguous OpenClaw profile or missing Linux flock in an isolated setup. Improve only a demonstrated unclear error. | `src/adapters/configure-native.ts`, `src/connector/state.ts`, `test/connector-setup.test.mjs` | The error identifies the operator action; it does not select another profile, remove an active lock, or print a credential. |
+| C4 — Consumer compatibility recipe | Build a small consumer using the public EnvarWorkClient/RuntimeAdapter contracts against a local test fixture. | `src/index.ts`, `src/adapters/types.ts`, `contracts/agent-work/v1/` | Document inputs, exact IDs and replay behavior; distinguish fixture execution from native acceptance, and use no cloud secret. |
+
+Every PR should state the problem, before/after behavior, tests, and compatibility
+impact. Run `npm test`; focused file tests help iteration but do not replace the
+normal CI discovery command.
+
+## Maintenance and feedback
+
+GitHub Issues is the public support and design entry. Maintainers aim to give
+an initial response within two business days and a substantive review or an
+explicit next step within five business days. This is a best-effort maintenance
+target, not a service-level agreement; availability and scope should be stated
+on the issue when a response takes longer.
+
+Issues are triaged as reproducible bug, documentation, compatible enhancement,
+design discussion, or outside current scope. A decision to defer is useful when
+it includes the reason and the supported alternative. Security reports follow
+[SECURITY.md](../SECURITY.md), not a public issue with credentials.
+
+Current focus: reproducible setup, compatibility, original-operation recovery,
+and useful adapters. Hosted models, implicit spending permissions and automatic
+resubmission of unknown work are outside this Connector's responsibility.

package/node_modules/@envarai/connect/docs/migration.md

@@ -0,0 +1,10 @@
+# Moving from EnvarPay Connector
+
+EnvarConnect is extracted from the MIT EnvarPay Connector at `2a9e03ebfd0beb9a167ad57473ead56ec5dd9bf5`. It retains the v1 protocol and SQLite journal layout.
+
+1. Keep the original state directory and its owner-only permissions. Stop the old receiver before starting the new one; do not remove its journal or binding files.
+2. Install the reviewed `@envarai/connect` version. `envar-connect run --agent ID` reads the existing `~/.envarpay/connectors/ID` binding. A custom installation uses the original `--directory PATH`.
+3. Run `envar-connect connect` with the same Agent/framework/profile to update the native MCP entry. It preserves the active connection and native peer credential. Restart the existing native gateway when requested, then start one receiver.
+4. Read the original task/order after restart. Reuse persisted request IDs; never buy again to recover a delayed result.
+
+Rollback uses the prior EnvarPay package against the same state directory, after stopping the new receiver. Both implementations understand the same journal. Rerun its original connect command if its native MCP command needs restoring. Connection permissions and spending grants are unchanged.

package/node_modules/@envarai/connect/docs/native-connector.md

@@ -0,0 +1,79 @@
+# Native Agent Connector
+
+Requires the matching Envar native enrollment/WorkService deployment. A package install or authenticated Agent Card is not a real task acceptance test.
+
+## 1. Open the correct terminal
+
+Use the same OS user and profile as the native Agent. It must already have a working model and Node.js 22.14+ (24 recommended).
+
+| Runtime | Terminal in an official container |
+| --- | --- |
+| Hermes | `docker exec --user hermes -e HOME=/opt/data -it CONTAINER sh` |
+| OpenClaw | `docker exec --user node -e HOME=/home/node -it CONTAINER sh` |
+
+Replace `CONTAINER` with your container name. Run `node --version` there. On a local install, use the terminal where the native Agent normally runs. Do not install the Connector under root while the gateway runs as another user.
+
+## 2. Connect and approve
+
+Create a private Envar Agent and copy its connection command. The command installs a fixed, bundled package through Envar and selects that exact Agent ID. The official npm package is also available:
+
+```sh
+npm install --prefix "$HOME/.envarpay/cli" --ignore-scripts --no-audit --no-fund @envarai/connect@2026.1107.2
+"$HOME/.envarpay/cli/node_modules/.bin/envar-connect" connect --agent AGENT_UUID --framework hermes
+```
+
+For OpenClaw choose `--framework openclaw`. The command prints a short code and an Envar approval link. Sign in as the owner, verify the Agent and code, and approve. A private polling secret is stored locally and never included in the URL. The request expires in ten minutes. The connection credential lasts up to 30 days and is limited to one Agent.
+
+Optional free outgoing permission does not permit spending. The receiving owner must also permit each caller under **Free task permissions**.
+
+For multiple OpenClaw Agents, select `--native-agent ID`. Use `--home PATH` for a secondary profile. Hermes honors `HERMES_HOME`; OpenClaw honors `OPENCLAW_STATE_DIR` and `OPENCLAW_CONFIG_PATH`. Setup changes only the managed peer, routing and MCP entry, preserving existing credentials, tools and private configuration backups.
+
+### Managed Ace Data Cloud instances
+
+Reuse an existing instance when its subscription and model configuration are
+valid. Keep the existing EnvarPay seller profile and ledger; a new private Envar
+Agent must have its own Connector directory. A seller Agent Card is not a native
+Connector pairing.
+
+If Hermes reports that A2A peers are supplied by the deployment environment,
+finish the setup through that deployment's peer configuration. Editing `.env`
+alone cannot override those values. Preserve existing peers, use the generated
+private `native.token` for this Connector only, and never paste it into Envar or
+logs. Have the deployment supervisor run the receiver against its durable
+original directory; an interactive terminal alone does not survive replacement
+of the container.
+
+## 3. Start receiving
+
+When setup says a restart is needed, restart the existing native gateway using its normal service/container controls. In Docker, restart the container from the host, then reopen the same user shell. Do not start a second gateway alongside an already supervised one.
+
+```sh
+"$HOME/.envarpay/cli/node_modules/.bin/envar-connect" run --agent AGENT_UUID
+```
+
+Keep this process and the gateway running. For persistent deployment, have your existing supervisor launch this command with the same user, HOME and durable state volume. It uses outbound HTTPS; no public A2A tunnel is required.
+
+## 4. Verify the actual result
+
+Send the free connection test from the Agent page. Wait for the exact returned result. `doctor` checks authenticated native A2A and connection status without invoking the model; it cannot establish model/task success.
+
+After enabling free outgoing tasks and the recipient's permission, ask the native Agent to use `list_peers`, `send_message`, then `wait_work`/`get_work`. Preserve the same request ID after any lost response. Native MCP also exposes original input/cancel requests and received results. Incoming claims and reports belong to the Connector, not a second model loop.
+
+## Recovery and disconnection
+
+- Restart the Connector using its original directory. Its private SQLite journal restores pending reports and original native handles before taking new work.
+- Both currently tested native A2A servers hold Tasks in memory. A native gateway restart may lose the original Task. That state stays **unknown** and is never resubmitted automatically.
+- A lost response after a native send also stays unknown when no original handle can be recovered. Do not replace it with a new paid order.
+- Native input continuation and cancellation are not advertised in this release. A cancellation request after execution starts must wait for the original outcome.
+- `envar-connect disconnect --agent AGENT_UUID` revokes this credential and preserves journals. To reconnect after a website disconnection, stop the old receiver, rerun the original connection command with `--new-pairing`, then approve the new code. A fresh connection cannot recover another connection's admitted work.
+- Expired credentials need owner reauthorization. Inspect unresolved work before disconnecting; do not delete its journal to silence an error.
+
+## Verified versions and remaining acceptance
+
+Fresh-container preflight uses OpenClaw `2026.10.4` and the Hermes `2026.9.24` CLI. It verifies installation, dedicated native A2A authorization and native MCP tool discovery. Real inference, six directed Agent exchanges and balance orders are separate release acceptance gates. Unsupported native versions should fail with a concrete setup/protocol error rather than trigger a different runtime.
+
+## Service discovery and budgeted purchases
+
+With the companion Envar commerce release, the native Agent can use `list_services`, `quote_service`, `confirm_order`, `get_order`, `wait_order`, `list_orders` and `recover_order`. The owner separately creates a spending grant for one Agent and one immutable service revision, with per-order/total limits and expiry. The connection's optional sending permission is not a spending grant. Without an eligible grant, the confirmation response points to the same original Envar order for owner approval.
+
+The Connector persists quote request identities before its network call. Retries preserve the request and original quote; financial POSTs are never retried invisibly. A package upgrade prompts a reload of the native MCP process, preserving the existing journals and runtime credentials.

package/node_modules/@envarai/connect/docs/releasing.md

@@ -0,0 +1,19 @@
+# Stable releases
+
+Versions use `YEAR.MONTHDAY.SEQUENCE` in Asia/Shanghai, matching EnvarPay. Run `npm run version:date` when package or image contents change; commit package.json, package-lock.json and the updated current install examples together. The version command synchronizes README/native/compatibility commands; `node scripts/sync-doc-versions.mjs --check` is also covered by `npm test`.
+
+Pushes to main that change runtime/package/container files run `publish-npm.yml`. The workflow tests Node 22 and 24, packs once per Node version, installs the actual tarball offline with an empty cache, and builds/runs containers on amd64 and arm64. After those checks it publishes `ghcr.io/envarai/connect:VERSION`, verifies its source/version labels, publishes the tested Node 24 tarball to npm with provenance, verifies version and integrity, updates image latest, and attaches the tarball to GitHub release `vVERSION`.
+
+A retry reuses the same npm artifact and source commit. Changed tarballs cannot overwrite published versions; latest cannot move backwards. Rerun failed jobs on the original run. Workflow-only changes do not publish automatically.
+
+## One-time npm setup
+
+Configure the npm Trusted Publisher for `@envarai/connect`: GitHub owner `EnvarAI`, repository `EnvarConnect`, workflow `publish-npm.yml`, environment `npm`. The GitHub environment is restricted to main. npm must grant the initial package publication/Trusted Publisher binding to an authorized maintainer; the workflow has no long-lived npm token. Package publication is complete only after the public registry readback succeeds.
+
+## Contracts
+
+`contracts/agent-work/v1/schema.json` is the source. Run `node scripts/generate-work-contract.mjs` after editing it. Commit generated types. Publish compatible contracts before updating EnvarAI's pinned copy; incompatible v1 changes require a new contract version. Runtime code never downloads a schema.
+
+## Promote consumers after publication
+
+Read the public npm version and SHA-512 integrity before updating the website download manifest or Pay's pinned/bundled Connect dependency. Test each consumer and preserve the original state directory. A website pin may lag a package release deliberately; record that reason in its release/compatibility notes. No receiver is upgraded merely by publishing npm latest.

package/node_modules/@envarai/connect/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@envarai/connect",
-  "version": "2026.1029.1",
+  "version": "2026.1107.2",
   "description": "Connect your own Agent to Envar: tasks, native adapters and recovery",
   "type": "module",
   "license": "MIT",
@@ -31,7 +31,10 @@
     "dist",
     "contracts",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "docs",
+    "CONTRIBUTING.md",
+    "SECURITY.md"
   ],
   "repository": {
     "type": "git",
@@ -73,5 +76,15 @@
     "json5",
     "yaml",
     "zod"
+  ],
+  "homepage": "https://github.com/EnvarAI/EnvarConnect#readme",
+  "keywords": [
+    "ai-agents",
+    "a2a",
+    "mcp",
+    "agent-work",
+    "hermes",
+    "openclaw",
+    "typescript"
   ]
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@envarai/envarpay",
-  "version": "2026.1029.1",
-  "description": "A2A services with Envar account-balance payments",
+  "version": "2026.1108.1",
+  "description": "Free A2A services and Envar account-balance seller gates",
   "type": "module",
   "license": "MIT",
   "engines": {
@@ -58,7 +58,7 @@
   },
   "dependencies": {
     "@a2a-js/sdk": "1.2.1",
-    "@envarai/connect": "2026.1029.1",
+    "@envarai/connect": "2026.1107.2",
     "@modelcontextprotocol/sdk": "1.31.0",
     "ajv": "8.20.0",
     "ajv-formats": "3.0.1",
@@ -84,5 +84,16 @@
     "yaml",
     "zod",
     "@envarai/connect"
+  ],
+  "homepage": "https://github.com/EnvarAI/EnvarPay#readme",
+  "keywords": [
+    "ai-agents",
+    "agent-services",
+    "agent-payments",
+    "a2a",
+    "mcp",
+    "typescript",
+    "hermes",
+    "openclaw"
   ]
 }