zk-credits 0.2.5 → 0.2.7

package/README.md

@@ -2,12 +2,14 @@
 
 Loopback sidecar that attaches a hash-pinned BN254 Groth16 proof to each
 coding-agent LLM request through the experimental x402 `zk-prepaid` scheme.
-Built for the invite-only, unpaid, experimental Base Sepolia pilot; credits
-are founder-provisioned test credits, and the circuit is not independently
-audited.
+Built for the invite-only experimental Base Sepolia pilot. Product calls use
+founder-provisioned test credits and have no product payment step; the circuit
+is not independently audited. External research participants in slots A and C
+receive $25 for a 30-minute session regardless of setup success. That payment
+is not product revenue or willingness-to-pay evidence.
 
 ```bash
-npm install --global zk-credits@0.2.5
+npm install --global zk-credits@0.2.7
 ```
 
 ## Pinned pilot versions
@@ -17,17 +19,17 @@ not mix versions between the sidecar, the adapter package, and the gateway:
 
 | Package | Version |
 | --- | --- |
-| `zk-credits` (this sidecar) | `0.2.5` |
+| `zk-credits` (this sidecar) | `0.2.7` |
 | `@zk-credits/x402-zk-prepaid` (adapter) | `0.1.0` |
 | `@zk-credits/shared` | `0.1.0` |
 
-The pinned Base Sepolia trial version is `0.2.5`. It uses the non-streaming
-`POST /v1/chat/completions` path below, includes the loopback Responses bridge
-for Codex, and acquires the pinned private proving bundle through the local
-GitHub CLI session. It also synchronizes V2 Base events and checks the gateway
-known root before local setup completes. Neither this version nor the adapter
-supports a Stellar or evaluation path. The proving artifacts are available
-only from the private immutable release pinned by `circuits/manifest.json`.
+The pinned Base Sepolia trial version is `0.2.7`. It uses the non-streaming
+`POST /v1/chat/completions` path below, includes the narrow loopback Responses
+bridge for supported Codex text and function-tool requests, and acquires the
+pinned private proving bundle through the local GitHub CLI session. It also
+synchronizes V2 Base events and checks the gateway known root before local
+setup completes. The proving artifacts are available only from the private
+immutable release pinned by `circuits/manifest.json`.
 
 Verify the shipped artifacts before your first prove. The package's
 `circuits/manifest.json` fixes the SHA-256 of the frozen
@@ -57,14 +59,19 @@ still receives the class. A rejected request consumes no credit.
 
 ## First run
 
-1. Redeem an invite and download the encrypted V2 credential export. Credits
-   are founder-provisioned test credits; there is no payment step.
-2. Ask the pilot contact for read access to the private bundle repository
-   `mangekyou-labs/zk-credits-base-sepolia-v2-bundle`, then authenticate the
-   GitHub CLI on this machine with `gh auth login`. The sidecar uses that local
-   GitHub CLI session to read the immutable release identified in
-   `circuits/manifest.json`; it never receives or stores your GitHub token.
-   Set the credential, gateway, and Base Sepolia RPC endpoint:
+1. Redeem the founder-prepared invite and download the encrypted V2 credential
+   export. The founder grants access to the private bundle repository
+   `mangekyou-labs/zk-credits-base-sepolia-v2-bundle` before the session.
+2. Give Codex the single setup instruction in the
+   [first-use guide](../../docs/onboarding/base-zk-credits-codex-first-use.md).
+   Codex checks local GitHub CLI authentication and repository access, installs
+   this pinned release, downloads and verifies the bundle, and runs setup.
+   The human signs in if needed, enters the recovery password at the hidden
+   prompt, gives consent, and chooses their own task. No product payment is
+   involved. The sidecar uses the local GitHub CLI session and never receives
+   or stores the GitHub token.
+3. The setup command sets the credential, gateway, and Base Sepolia RPC
+   endpoint:
 
    ```bash
    export ZK_CREDITS_CREDENTIAL_PATH="$HOME/Downloads/zk-credits-credential.json"
@@ -99,7 +106,7 @@ still receives the class. A rejected request consumes no credit.
    leaves, and the local slot stays reusable. The gateway never serves a path
    for a named leaf or commitment.
 
-3. Start setup. It verifies the credential, pinned artifact hashes, and
+4. Start setup. It verifies the credential, pinned artifact hashes, and
    witness locally, then prompts for the backup password without echo:
 
    ```bash
@@ -107,7 +114,9 @@ still receives the class. A rejected request consumes no credit.
    ```
 
    No gateway admin token is required. Then run `zk-credits codex` to open
-   Codex with the local sidecar.
+   Codex with the local sidecar. A/C first-use measurement targets five
+   minutes of active human work; unattended download, proving, and provider
+   waits are measured separately. More than five minutes is a friction finding.
 
 The sidecar binds `127.0.0.1:3210` only. It does not modify `~/.cline` or
 `~/.codex`.
@@ -198,11 +207,20 @@ zk-credits cline [cline arguments...]
 zk-credits setup codex [--model <model>]
 zk-credits codex [codex arguments...]
 zk-credits status
-zk-credits serve [--port <port>]
+zk-credits serve [--port <port>] [--internal-trial-one-proof]
+zk-credits x402-agent
+zk-credits founder-demo-agent
 zk-credits trial-registered-adapter
 eval "$(zk-credits env)"
 ```
 
+`serve --internal-trial-one-proof` is an opt-in maintainer mode for the
+internal Base Sepolia trial. During that process lifetime, one authenticated,
+valid spend request may reach the prepaid transport and the proof factory may
+attempt one proof. A later valid request receives HTTP 409 with
+`internal_trial_limit_reached`; ordinary `serve` behavior is unchanged without
+the flag.
+
 `trial-registered-adapter` is a maintainer-only internal trial command. It
 requires the locally recovered credential and pinned proving bundle, prompts
 for the credential password and gateway admin token without echo when they are
@@ -220,6 +238,17 @@ Codex SDK:
 import { buildCodexSdkOptions, buildCodexThreadOptions } from 'zk-credits/codex';
 ```
 
+`zk-credits/x402` exports `createLocalX402Agent` for an operator who is
+integrating the adapter into their own x402 agent. It loads the same local
+credential, pinned proof artifacts, public witness, proof engine, and slot
+ledger used by the sidecar. The request-aware client binds the actual method,
+URL, and body into each spend; its metrics endpoint exposes authenticated
+aggregate counters on loopback. See
+[`docs/onboarding/base-zk-credits-x402-agent.md`](../../docs/onboarding/base-zk-credits-x402-agent.md)
+for integration and measured-call steps. The included `zk-credits x402-agent`
+command is a small task-running starter for the founder demo and local
+rehearsal; external slot C uses their own agent.
+
 The credential secret is decrypted only in local memory. The sidecar cache
 contains public Base event leaves and never stores the secret, prompt, response,
 proof, account, or wallet.

package/dist/base-registered-trial.d.ts

@@ -1,11 +1,11 @@
 /**
- * One-shot local transport for exercising the official @x402/core adapter.
+ * One-shot local transport for the founder's task-running x402 demo agent.
  *
  * @x402/core creates scheme payloads from PaymentRequired and does not pass
  * HTTP method/body context to a scheme client. This harness captures that
  * request context locally, then binds it into the same Base proof factory
  * before invoking the registered `zk-prepaid` scheme. It is intended only for
- * the internal Base Sepolia trial, not as a general HTTP client.
+ * the internal Base Sepolia founder demo, not as a general HTTP client.
  *
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
@@ -28,6 +28,10 @@ export interface BaseRegisteredTrialOptions extends BasePrepaidClientOptions {
     body: string;
     headers?: HeadersInit;
     fetch?: typeof fetch;
+    /** The response can be shown locally to the operator; it is never retained by metrics. */
+    onResponse?: (response: Response) => void | Promise<void>;
 }
+/** A bounded, single-task request for the founder's internal x402 demo. */
+export declare function buildBaseRegisteredTrialRequestBody(task?: string): string;
 /** Runs one POST to the pilot chat route through a directly registered adapter. */
 export declare function runBaseRegisteredTrialExchange(options: BaseRegisteredTrialOptions): Promise<BaseRegisteredTrialResult>;

package/dist/base-registered-trial.js

@@ -1,17 +1,27 @@
 /**
- * One-shot local transport for exercising the official @x402/core adapter.
+ * One-shot local transport for the founder's task-running x402 demo agent.
  *
  * @x402/core creates scheme payloads from PaymentRequired and does not pass
  * HTTP method/body context to a scheme client. This harness captures that
  * request context locally, then binds it into the same Base proof factory
  * before invoking the registered `zk-prepaid` scheme. It is intended only for
- * the internal Base Sepolia trial, not as a general HTTP client.
+ * the internal Base Sepolia founder demo, not as a general HTTP client.
  *
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 import { x402Client } from '@x402/core/client';
 import { BASE_SEPOLIA_NETWORK, decodeHeader, encodeHeader, lifecycleFailure, lifecycleStage, PAYMENT_REQUIRED_HEADER, PAYMENT_RESPONSE_HEADER, PAYMENT_SIGNATURE_HEADER, registerZkPrepaidClient, ZK_PREPAID_SCHEME, } from '@zk-credits/x402-zk-prepaid';
 import { createBasePaymentFactory } from './base-sidecar.js';
+/** A bounded, single-task request for the founder's internal x402 demo. */
+export function buildBaseRegisteredTrialRequestBody(task = 'Reply with exactly: internal trial complete.') {
+    if (typeof task !== 'string' || task.trim().length === 0 || task.length > 4_000) {
+        throw new Error('Task must contain between 1 and 4000 characters');
+    }
+    return JSON.stringify({
+        model: 'deepseek/deepseek-v4-flash',
+        messages: [{ role: 'user', content: task }],
+    });
+}
 function observe(options, event) {
     try {
         options.lifecycle?.(event);
@@ -163,6 +173,12 @@ export async function runBaseRegisteredTrialExchange(options) {
     }
     result.responseSucceeded = true;
     observe(options, lifecycleStage('exchange_succeeded'));
+    try {
+        await options.onResponse?.(paidResponse.clone());
+    }
+    catch {
+        // Displaying a completed response is local convenience, not settlement.
+    }
     result.committedSlotDelta = ledger.snapshot().committed - startingCommittedSlots;
     return result;
 }

package/dist/base-sidecar.d.ts

@@ -50,6 +50,8 @@ export interface BasePrepaidClientOptions {
     credential: CreditCredential;
     witnessProvider: BaseWitnessProvider;
     prove: BaseProofGenerator;
+    /** Limits this local client to one proof attempt for a single internal trial. */
+    internalTrialOneProof?: boolean;
     fetch?: typeof fetch;
     /**
      * Durable local slot ledger. A slot is provisional until the proof passes

package/dist/base-sidecar.js

@@ -16,6 +16,12 @@ const TREE_DEPTH = 20;
 const FIELD_ORDER = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
 const REPLAY_TTL_MS = 24 * 60 * 60 * 1000;
 const MAX_PENDING_PAYMENTS = 64;
+const PAYMENT_PROOF_FIELDS = ['pi_a', 'pi_b', 'pi_c'];
+function proofForPayment(proof) {
+    return Object.fromEntries(PAYMENT_PROOF_FIELDS
+        .filter((field) => Object.prototype.hasOwnProperty.call(proof, field))
+        .map((field) => [field, proof[field]]));
+}
 function field(value, label) {
     if (!/^\d+$/u.test(value))
         throw new Error(`Invalid ${label}`);
@@ -63,6 +69,7 @@ function requestBodyBytes(body) {
 /** Creates the shared local proof factory used by both client transports. */
 export function createBasePaymentFactory(options) {
     const secret = secretFromBase64Url(options.credential.secret);
+    let internalTrialProofAttempted = false;
     return async ({ method, url, body, requirements }) => {
         if (requirements.extra.deploymentDomain !== options.credential.deploymentDomain) {
             throw new Error('Credential deployment domain does not match the gateway challenge');
@@ -98,6 +105,11 @@ export function createBasePaymentFactory(options) {
                 nullifier,
                 share,
             ];
+            if (options.internalTrialOneProof) {
+                if (internalTrialProofAttempted)
+                    throw new Error('internal_trial_limit_reached');
+                internalTrialProofAttempted = true;
+            }
             const proof = await options.prove({
                 secret: secretToField(secret),
                 tier_id: String(options.credential.tierId),
@@ -118,7 +130,7 @@ export function createBasePaymentFactory(options) {
             await slotLedger.commit(selectedSlot);
             const payment = buildPaymentPayload({
                 requirements,
-                proof: proof.proof,
+                proof: proofForPayment(proof.proof),
                 publicSignals: [...proof.publicSignals],
                 nonce,
                 responseKey: responseKeys.publicKey,

package/dist/cli.js

@@ -7,6 +7,7 @@ import { launchCodexProcess } from './codex-launcher.js';
 import { launchClineProcess } from './cline-launcher.js';
 import { isCodexProfileInstalled, resolveCodexHome, writeCodexProfile, } from './codex-profile.js';
 import { createBasePrepaidClient, createFileWitnessProvider, validateBaseCreditWitness } from './base-sidecar.js';
+import { createLocalX402Agent } from './local-x402-agent.js';
 import { createBaseEventWitnessProvider } from './base-event-sync.js';
 import { createPinnedBaseProofGenerator } from './proof-coordinator.js';
 import { createBaseProofMetrics } from './proof-metrics.js';
@@ -21,10 +22,11 @@ import { applySetupConfig, readSetupConfig, resolveSetupInputs, writeSetupConfig
 import { ensureSidecarReady } from './sidecar-lifecycle.js';
 import { readLoopbackToken, writeLoopbackToken } from './sidecar-state.js';
 import { createSidecarServer } from './sidecar.js';
-import { runBaseRegisteredTrialExchange } from './base-registered-trial.js';
+import { buildBaseRegisteredTrialRequestBody, runBaseRegisteredTrialExchange } from './base-registered-trial.js';
 import { loadCircuitManifest } from './artifact-bundle.js';
 import { BASE_SEPOLIA_NETWORK } from '@zk-credits/x402-zk-prepaid';
 import { requireGatewayKnownRoot as checkGatewayKnownRoot } from './gateway-root-check.js';
+import { evaluateGatewayReadiness, isGatewayStatusFresh } from './gateway-trial-status.js';
 const DEFAULT_GATEWAY_URL = 'https://zk-credits-gateway.onrender.com';
 const DEFAULT_PORT = 3210;
 function stateDirectory() {
@@ -164,16 +166,25 @@ function printHelp() {
   zk-credits setup codex [--model <model>]
   zk-credits codex [codex arguments...]
   zk-credits status
-  zk-credits serve [--port <port>]
-  zk-credits trial-registered-adapter
+  zk-credits serve [--port <port>] [--internal-trial-one-proof]
+  zk-credits x402-agent
+  zk-credits founder-demo-agent
   eval "$(zk-credits env)"
 
 "zk-credits cline" and the Codex companion configure and launch coding agents
 against the x402 zk-prepaid loopback sidecar. The gateway spend path is
 non-streaming POST /v1/chat/completions; Codex Responses requests pass through
 the sidecar's bounded local compatibility bridge.
-"zk-credits trial-registered-adapter" runs one confirmed, billable internal
-trial request through the directly registered official x402 client adapter.
+"zk-credits founder-demo-agent" asks for one local task and runs it through
+the request-aware x402 adapter and local proof engine. It requires explicit
+confirmation before one billable internal exchange; the task and response are
+displayed locally and never added to activation evidence.
+"zk-credits x402-agent" is a small task-running starter for the participant's
+own x402 agent loop. It asks for tasks locally and sends each through the same
+request-aware adapter and local proof engine; aggregate metrics stay on the
+loopback-only authenticated endpoint.
+"zk-credits serve --internal-trial-one-proof" limits this sidecar process to
+one authenticated, valid spend request and one local proof attempt.
 Set ZK_CREDITS_CREDENTIAL_PATH and BASE_RPC_URL before setup. For Base Sepolia
 V2, setup can download the immutable bundle pinned by the package manifest by
 using this machine's authenticated GitHub CLI session, then synchronizes the
@@ -193,16 +204,22 @@ async function loadBaseClientRuntime(passwordInput) {
     if (!artifactDirectory) {
         throw new Error('Set ZK_CREDITS_ARTIFACT_DIR to the directory holding the installed pinned proving bundle');
     }
+    const baseRpcUrl = process.env.BASE_RPC_URL;
+    const baseContractAddress = process.env.BASE_PRIVATE_CREDIT_BOND_ADDRESS;
     const witnessProvider = witnessPath
         ? createFileWitnessProvider(JSON.parse(await readFile(witnessPath, 'utf8')))
-        : process.env.BASE_RPC_URL && process.env.BASE_PRIVATE_CREDIT_BOND_ADDRESS
-            ? createBaseEventWitnessProvider({
-                rpcUrl: process.env.BASE_RPC_URL,
-                contractAddress: process.env.BASE_PRIVATE_CREDIT_BOND_ADDRESS,
-                deploymentBlock: process.env.BASE_DEPLOYMENT_BLOCK && /^\d+$/u.test(process.env.BASE_DEPLOYMENT_BLOCK) ? BigInt(process.env.BASE_DEPLOYMENT_BLOCK) : undefined,
-                confirmations: process.env.BASE_CONFIRMATIONS && /^\d+$/u.test(process.env.BASE_CONFIRMATIONS) ? BigInt(process.env.BASE_CONFIRMATIONS) : undefined,
-                cachePath: join(stateDirectory(), 'base-event-sync.json'),
-            })
+        : baseRpcUrl && baseContractAddress
+            ? await witnessProviderForSource({
+                kind: 'base-events',
+                rpcUrl: baseRpcUrl,
+                contractAddress: baseContractAddress,
+                ...(process.env.BASE_DEPLOYMENT_BLOCK && /^\d+$/u.test(process.env.BASE_DEPLOYMENT_BLOCK)
+                    ? { deploymentBlock: process.env.BASE_DEPLOYMENT_BLOCK }
+                    : {}),
+                ...(process.env.BASE_CONFIRMATIONS && /^\d+$/u.test(process.env.BASE_CONFIRMATIONS)
+                    ? { confirmations: process.env.BASE_CONFIRMATIONS }
+                    : {}),
+            }, join(stateDirectory(), 'base-event-sync.json'))
             : (() => { throw new Error('Set ZK_CREDITS_WITNESS_PATH or configure BASE_RPC_URL and BASE_PRIVATE_CREDIT_BOND_ADDRESS'); })();
     const proofMetrics = createBaseProofMetrics();
     const exchangeMetrics = createZkPrepaidLifecycleMetrics();
@@ -230,7 +247,6 @@ const GATEWAY_COUNTER_NAMES = [
     'request_rejected',
 ];
 const GATEWAY_CLAIM_COUNT_NAMES = ['reserved', 'ready', 'committed', 'cancelled'];
-const GATEWAY_READINESS_CHECK_NAMES = new Set(['launchControl', 'database', 'baseRoot', 'baseRpc', 'verifierAssets', 'provider']);
 function isRecord(value) {
     return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }
@@ -265,16 +281,10 @@ async function requireGatewayKnownRoot(root) {
 }
 async function gatewayReadiness(origin) {
     const response = await readGatewayJson(new URL('/ready', origin), { accept: 'application/json' });
-    const report = isRecord(response.body) ? response.body : undefined;
-    const checks = Array.isArray(report?.checks) ? report.checks : [];
-    const failedChecks = checks.flatMap((check) => (isRecord(check) && check.ok === true
-        ? []
-        : [isRecord(check) && typeof check.name === 'string' && GATEWAY_READINESS_CHECK_NAMES.has(check.name) ? check.name : 'unknown']));
-    const hasLaunchCheck = checks.some((check) => isRecord(check) && check.name === 'launchControl' && check.ok === true);
+    const gate = evaluateGatewayReadiness(response.status, response.body);
     return {
         status: response.status,
-        passed: response.status === 200 && report?.ready === true && failedChecks.length === 0 && hasLaunchCheck,
-        failedChecks,
+        ...gate,
     };
 }
 async function gatewayTrialSnapshot(origin, token) {
@@ -314,6 +324,7 @@ async function gatewayTrialSnapshot(origin, token) {
         status: response.status,
         ...(snapshot ? { snapshot } : {}),
         gatePassed: response.status === 200
+            && isGatewayStatusFresh(body?.generatedAt)
             && body?.network === BASE_SEPOLIA_NETWORK
             && launch?.state === 'enabled'
             && knownRoot
@@ -338,15 +349,107 @@ async function confirmDirectTrial() {
         input.close();
     }
 }
+async function readFounderDemoTask() {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new Error('the founder demo requires a local interactive terminal');
+    }
+    const input = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const task = (await input.question('Task for the founder x402 demo agent (up to 4000 characters): ')).trim();
+        if (task.length === 0 || task.length > 4_000) {
+            throw new Error('Task must contain between 1 and 4000 characters');
+        }
+        return task;
+    }
+    finally {
+        input.close();
+    }
+}
+async function readX402AgentTask() {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new Error('the x402 starter agent requires a local interactive terminal');
+    }
+    const input = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const task = (await input.question('Task for your x402 agent (or :quit): ')).trim();
+        if (task === ':quit')
+            return null;
+        if (task.length === 0 || task.length > 4_000) {
+            throw new Error('Task must contain between 1 and 4000 characters');
+        }
+        return task;
+    }
+    finally {
+        input.close();
+    }
+}
+async function runX402Agent() {
+    const gateway = gatewayOrigin();
+    const runtime = await createLocalX402Agent({
+        credentialPassword: await readHiddenValue('Credential backup password: '),
+    });
+    const url = new URL('/v1/chat/completions', gateway).toString();
+    console.log(`Local aggregate metrics: ${runtime.metricsUrl}`);
+    console.log('Enter one task at a time. Each task can spend one founder-provisioned test credit.');
+    try {
+        while (true) {
+            const task = await readX402AgentTask();
+            if (task === null)
+                break;
+            const response = await runtime.client.fetch(url, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: buildBaseRegisteredTrialRequestBody(task),
+            });
+            await displayAgentResponse(response);
+            if (!response.ok)
+                console.log(`Request ended with HTTP ${response.status}.`);
+        }
+    }
+    finally {
+        await runtime.close();
+    }
+}
+async function displayAgentResponse(response) {
+    let content;
+    try {
+        const body = await response.json();
+        if (isRecord(body) && Array.isArray(body.choices) && isRecord(body.choices[0])) {
+            const message = body.choices[0].message;
+            if (isRecord(message))
+                content = message.content;
+        }
+    }
+    catch {
+        // The response is a local display convenience; activation recording uses
+        // only the closed exchange and counter summaries below.
+    }
+    console.log('\nAgent response (shown locally only):');
+    if (typeof content === 'string') {
+        console.log(content);
+        return;
+    }
+    if (Array.isArray(content)) {
+        const textParts = content
+            .filter((part) => isRecord(part))
+            .filter((part) => part.type === 'text' && typeof part.text === 'string')
+            .map((part) => part.text);
+        if (textParts.length > 0) {
+            console.log(textParts.join('\n'));
+            return;
+        }
+    }
+    console.log('[The response completed, but its text content was not available for local display.]');
+}
 function gatewayCounterDelta(before, after) {
     return {
         metrics: Object.fromEntries(GATEWAY_COUNTER_NAMES.map((name) => [name, after.metrics[name] - before.metrics[name]])),
         claims: Object.fromEntries(GATEWAY_CLAIM_COUNT_NAMES.map((name) => [name, after.claims[name] - before.claims[name]])),
     };
 }
-async function trialRegisteredAdapter() {
+async function trialRegisteredAdapter(task) {
     if (!await confirmDirectTrial()) {
-        console.log(JSON.stringify({ path: 'registered-adapter', status: 'not_run' }));
+        console.log(JSON.stringify({ path: 'founder-demo-agent', status: 'not_run' }));
         return;
     }
     try {
@@ -354,13 +457,13 @@ async function trialRegisteredAdapter() {
         if (runtime.credential.tierId !== 0
             || runtime.credential.deploymentDomain !== '84532'
             || runtime.credential.expiry <= Math.floor(Date.now() / 1000)) {
-            console.log(JSON.stringify({ path: 'registered-adapter', status: 'stopped', failurePhase: 'credential_gate' }));
+            console.log(JSON.stringify({ path: 'founder-demo-agent', status: 'stopped', failurePhase: 'credential_gate' }));
             return;
         }
         const startingSlots = runtime.slotLedger.snapshot();
         if (startingSlots.committed >= startingSlots.capacity) {
             console.log(JSON.stringify({
-                path: 'registered-adapter',
+                path: 'founder-demo-agent',
                 status: 'stopped',
                 failurePhase: 'local_credit_gate',
                 localCredits: { capacity: startingSlots.capacity, committed: startingSlots.committed, available: 0 },
@@ -370,7 +473,7 @@ async function trialRegisteredAdapter() {
         const gateway = gatewayOrigin();
         const adminToken = process.env.BILLING_INTERNAL_TOKEN || await readHiddenValue('Gateway admin token: ');
         if (!adminToken.trim()) {
-            console.log(JSON.stringify({ path: 'registered-adapter', status: 'stopped', failurePhase: 'admin_auth' }));
+            console.log(JSON.stringify({ path: 'founder-demo-agent', status: 'stopped', failurePhase: 'admin_auth' }));
             return;
         }
         const lifecycle = createNodeSidecarLifecycle({
@@ -387,33 +490,29 @@ async function trialRegisteredAdapter() {
         ]);
         const launcherStatus = { codexProfileInstalled, sidecarRunning };
         if (sidecarRunning) {
-            console.log(JSON.stringify({ path: 'registered-adapter', status: 'stopped', failurePhase: 'sidecar_running', launcherStatus }));
+            console.log(JSON.stringify({ path: 'founder-demo-agent', status: 'stopped', failurePhase: 'sidecar_running', launcherStatus }));
             return;
         }
         const witness = await runtime.witnessProvider.witnessForCredential(runtime.credential);
         const readiness = await gatewayReadiness(gateway);
         if (!readiness.passed) {
-            console.log(JSON.stringify({ path: 'registered-adapter', status: 'stopped', failurePhase: 'readiness', launcherStatus, readiness }));
+            console.log(JSON.stringify({ path: 'founder-demo-agent', status: 'stopped', failurePhase: 'readiness', launcherStatus, readiness }));
             return;
         }
         const adminBefore = await gatewayTrialSnapshot(gateway, adminToken);
         if (!adminBefore.gatePassed || !adminBefore.snapshot) {
-            console.log(JSON.stringify({ path: 'registered-adapter', status: 'stopped', failurePhase: 'admin_status', launcherStatus, readiness, adminStatus: adminBefore.status }));
+            console.log(JSON.stringify({ path: 'founder-demo-agent', status: 'stopped', failurePhase: 'admin_status', launcherStatus, readiness, adminStatus: adminBefore.status }));
             return;
         }
         if (witness.root !== adminBefore.snapshot.currentRoot) {
-            console.log(JSON.stringify({ path: 'registered-adapter', status: 'stopped', failurePhase: 'root_mismatch', launcherStatus, readiness, adminStatus: adminBefore.status }));
+            console.log(JSON.stringify({ path: 'founder-demo-agent', status: 'stopped', failurePhase: 'root_mismatch', launcherStatus, readiness, adminStatus: adminBefore.status }));
             return;
         }
         const baselineSlots = runtime.slotLedger.snapshot();
         const baselineProof = runtime.proofMetrics.snapshot();
         const baselineLifecycle = runtime.exchangeMetrics.snapshot();
         const requestUrl = new URL('/v1/chat/completions', gateway).toString();
-        const requestBody = JSON.stringify({
-            model: 'deepseek/deepseek-v4-flash',
-            messages: [{ role: 'user', content: 'Reply with exactly: internal trial complete.' }],
-            stream: false,
-        });
+        const requestBody = buildBaseRegisteredTrialRequestBody(task);
         const exchange = await runBaseRegisteredTrialExchange({
             url: requestUrl,
             body: requestBody,
@@ -423,6 +522,7 @@ async function trialRegisteredAdapter() {
             prove: runtime.prove,
             slotLedger: runtime.slotLedger,
             lifecycle: runtime.exchangeMetrics.observe,
+            onResponse: displayAgentResponse,
         });
         const adminAfter = await gatewayTrialSnapshot(gateway, adminToken);
         const proofAfter = runtime.proofMetrics.snapshot();
@@ -451,7 +551,7 @@ async function trialRegisteredAdapter() {
             ?? (adminAfter.status !== 200 || !adminAfter.snapshot ? 'postflight_admin_status' : undefined)
             ?? (!gatewayCountersMatch ? 'gateway_counter_delta' : undefined);
         console.log(JSON.stringify({
-            path: 'registered-adapter',
+            path: 'founder-demo-agent',
             readiness: { status: readiness.status, passed: readiness.passed, failedChecks: readiness.failedChecks },
             launcherStatus,
             adminStatus: { before: adminBefore.status, after: adminAfter.status },
@@ -479,11 +579,12 @@ async function trialRegisteredAdapter() {
         }));
     }
     catch {
-        console.log(JSON.stringify({ path: 'registered-adapter', status: 'stopped', failurePhase: 'local_setup' }));
+        console.log(JSON.stringify({ path: 'founder-demo-agent', status: 'stopped', failurePhase: 'local_setup' }));
     }
 }
 async function serve(args, passwordInput) {
     const port = readPort(args);
+    const internalTrialOneProof = args.includes('--internal-trial-one-proof');
     const statePaths = sidecarStatePaths(stateDirectory());
     const localToken = createLoopbackToken();
     const { credential, witnessProvider, proofMetrics, exchangeMetrics, slotLedger, prove } = await loadBaseClientRuntime(passwordInput);
@@ -492,6 +593,7 @@ async function serve(args, passwordInput) {
         witnessProvider,
         prove,
         slotLedger,
+        internalTrialOneProof,
         lifecycle: exchangeMetrics.observe,
     });
     const gatewayBaseUrl = process.env.ZK_CREDITS_GATEWAY_URL || DEFAULT_GATEWAY_URL;
@@ -499,6 +601,7 @@ async function serve(args, passwordInput) {
         localToken,
         gatewayBaseUrl,
         prepaidClient: prepaid.client,
+        internalTrialOneProof,
         metrics: () => ({ ...proofMetrics.snapshot(), exchange: exchangeMetrics.snapshot() }),
     });
     let address;
@@ -538,8 +641,17 @@ async function main() {
         await serve(args.slice(1).filter((argument) => argument !== '--credential-password-stdin'), passwordFromStdin);
         return;
     }
-    if (args[0] === 'trial-registered-adapter') {
-        await trialRegisteredAdapter();
+    if (args[0] === 'founder-demo-agent') {
+        if (args.length !== 1)
+            throw new Error('founder-demo-agent does not accept arguments; it reads the task locally');
+        const task = await readFounderDemoTask();
+        await trialRegisteredAdapter(task);
+        return;
+    }
+    if (args[0] === 'x402-agent') {
+        if (args.length !== 1)
+            throw new Error('x402-agent does not accept arguments; it reads tasks locally');
+        await runX402Agent();
         return;
     }
     const statePaths = sidecarStatePaths(sidecarHome);

package/dist/codex-profile.js

@@ -70,7 +70,7 @@ export function codexModelsResponse() {
                 apply_patch_tool_type: 'freeform',
                 web_search_tool_type: 'text',
                 truncation_policy: { mode: 'tokens', limit: 10_000 },
-                supports_parallel_tool_calls: true,
+                supports_parallel_tool_calls: false,
                 supports_image_detail_original: false,
                 context_window: 128_000,
                 max_context_window: 128_000,

package/dist/gateway-trial-status.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Freshness and readiness checks used by the separately registered adapter
+ * trial. Keep this gate fail-closed when a gateway omits a named check.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export declare const GATEWAY_READINESS_CHECK_NAMES: readonly ["launchControl", "database", "baseRoot", "baseRpc", "verifierAssets", "provider"];
+export declare function isGatewayStatusFresh(value: unknown, now?: number): boolean;
+export declare function evaluateGatewayReadiness(status: number | null, body: unknown, now?: number): {
+    passed: boolean;
+    failedChecks: string[];
+    timestampFresh: boolean;
+};