@weaccelerateinc/agent-sdk 0.10.3 → 0.12.0

package/managed-mcp.js

@@ -1,6 +1,7 @@
 import { AccelerateClient, AccelerateError } from './index.js';
+import { browserUseRunProvenance } from './browser-provenance.js';
 import { browserOperationJsonSchema, parseBrowserOperation, normalizeBrowserOperation } from './browser-operations.js';
-import { checkoutDiagnosticsJsonSchema, validateCheckoutDiagnostics } from './checkout-diagnostics.js';
+import { checkoutDiagnosticsJsonSchema, validateCheckoutDiagnostics, validateCheckoutReconciliation } from './checkout-diagnostics.js';
 import { createHash } from 'node:crypto';
 
 const ID = /^mcs_[A-Za-z0-9_-]{43}$/;
@@ -8,9 +9,12 @@ const OWNER = /^[A-Za-z0-9_.:-]{1,500}$/;
 const PHONE = /^\+[1-9]\d{6,14}$/;
 const CONTEXT_KEYS = ['customer_id', 'workspace_id', 'conversation_id', 'phone_number'];
 const STATUSES = ['wallet_required', 'selection_ready', 'details_ready', 'approval_required', 'approved',
-  'ready_for_submit', 'cancelled', 'expired', 'failed', 'submit_attempted', 'outcome_unknown'];
+  'ready_for_submit', 'final_click_armed', 'cancelled', 'expired', 'failed', 'submit_attempted', 'outcome_unknown'];
 const NEXT_ACTIONS = ['check_configuration', 'check_request', 'check_status', 'complete_wallet',
   'complete_verification', 'refresh_quote', 'refresh_revision', 'reconcile_order', 'stop'];
+// Errors that prove the final-click arm was not created. Everything else after an arm request is an unknown outcome.
+const PRE_ARM_REFUSALS = new Set(['approval_required', 'revision_conflict', 'checkout_expired', 'checkout_closed', 'customer_click_required',
+  'permission_denied', 'submit_unavailable', 'capability_disabled']);
 const object = value => value !== null && typeof value === 'object' && !Array.isArray(value) &&
   [Object.prototype, null].includes(Object.getPrototypeOf(value));
 const check = (value, code = 'invalid_input') => { if (!value) throw new AccelerateError(code); };
@@ -59,6 +63,7 @@ const checkoutSchema = schemaObject({
   expires_at: timestampSchema, purpose: { type: 'string', enum: ['purchase', 'sandbox_source_comparison', 'sandbox_fill_only'] },
   approval_policy: { const: 'after_fill' }, purchase_approved: { type: 'boolean' },
   fill_after_verification: { const: true },
+  final_click_actor: { const: 'customer' }, submit_actor: { const: 'customer' },
   submit_allowed: { type: 'boolean' }, retry_safe: { const: false }, payment_confirmed: { const: false },
   card: schemaObject({ last4: { anyOf: [{ type: 'string', pattern: '^\\d{4}$' }, { type: 'null' }] }, brand: nullableText(40) }),
   address: schemaObject({ label: nullableText(400), city: nullableText(128), state: nullableText(128), postal_code_mask: nullableText(128) }, ['label']),
@@ -107,7 +112,7 @@ export const managedCheckoutToolDefinitions = freeze([
     description: 'Cancel this exact owned checkout and request private browser cleanup. Cancellation does not reverse an attempted order or prove that no purchase occurred. Keep uncertain-payment fences until independently reconciled.',
     inputSchema: idInput, outputSchema: outputSchema('checkout'), destructive: true },
   { name: 'accelerate_checkout_submit', title: 'Explicitly submit approved purchase',
-    description: 'Explicit final purchase decision for this exact owned revision while its returned ready claim remains valid. Calls the one-use private final-submit operation once. Never automatically invoke after fill or retry after uncertainty. The default review profile requires the customer’s private post-fill approval first. submit_attempted is not order or payment confirmation. Available only when the server explicitly enables purchase submission.',
+    description: 'Explicit final purchase decision for this exact owned revision while its returned ready claim remains valid. Accelerate never clicks: this arms one short-lived click, your own backend performs the single physical final click in the customer’s existing browser, then Accelerate observes the outcome once. Never automatically invoke after fill or retry after uncertainty. The default review profile requires the customer’s private post-fill approval first. submit_attempted is not order or payment confirmation. Available only when the server explicitly enables purchase submission.',
     inputSchema: revisionInput, outputSchema: outputSchema('checkout'), destructive: true, submitOnly: true },
 ].map(value => ({ ...value, annotations: { readOnlyHint: value.readOnly === true, idempotentHint: value.readOnly === true,
   destructiveHint: value.destructive === true, openWorldHint: true } })));
@@ -126,7 +131,7 @@ function safeText(value, max = 1000, multiline = false) {
 function timestamp(value) { check(typeof value === 'string' && /^\d{4}-\d{2}-\d{2}T[\d:.]+Z$/u.test(value) && Number.isFinite(Date.parse(value)), 'invalid_response'); return value; }
 function projectCheckout(value) {
   shape(value, ['id', 'status', 'revision', 'expires_at', 'retry_safe', 'payment_confirmed'],
-    ['purpose', 'submit_allowed', 'approval_policy', 'purchase_approved', 'fill_after_verification', 'card', 'address', 'quote', 'submit_expires_at', 'diagnostics'], 'invalid_response');
+    ['purpose', 'submit_allowed', 'approval_policy', 'purchase_approved', 'fill_after_verification', 'card', 'address', 'quote', 'submit_expires_at', 'diagnostics', 'reconciliation', 'final_click_actor', 'submit_actor'], 'invalid_response');
   check(typeof value.id === 'string' && ID.test(value.id) && STATUSES.includes(value.status) && Number.isSafeInteger(value.revision) &&
     value.revision >= 0 && value.revision <= 2147483647 && value.retry_safe === false && value.payment_confirmed === false, 'invalid_response');
   const result = { id: value.id, status: value.status, revision: value.revision, expires_at: timestamp(value.expires_at), retry_safe: false, payment_confirmed: false };
@@ -135,7 +140,7 @@ function projectCheckout(value) {
     result.purpose = value.purpose; result.submit_allowed = value.submit_allowed;
   }
   if (value.approval_policy !== undefined || value.purchase_approved !== undefined) {
-    check(value.approval_policy === 'after_fill' && typeof value.purchase_approved === 'boolean' && (!value.purchase_approved || value.status === 'ready_for_submit' && value.purpose === 'purchase'), 'invalid_response');
+    check(value.approval_policy === 'after_fill' && typeof value.purchase_approved === 'boolean' && (!value.purchase_approved || ['ready_for_submit', 'final_click_armed'].includes(value.status) && value.purpose === 'purchase'), 'invalid_response');
     result.approval_policy = value.approval_policy; result.purchase_approved = value.purchase_approved;
   }
   if (value.fill_after_verification !== undefined) {
@@ -143,6 +148,17 @@ function projectCheckout(value) {
       ['purchase', 'sandbox_fill_only'].includes(value.purpose), 'invalid_response');
     result.fill_after_verification = true;
   }
+  // The customer's own backend/browser performs any final click; Accelerate never does.
+  if (value.final_click_actor !== undefined) {
+    check(value.final_click_actor === 'customer' && value.purpose === 'purchase', 'invalid_response');
+    result.final_click_actor = 'customer';
+  }
+  if (value.submit_actor !== undefined) {
+    check(value.submit_actor === 'customer' && value.final_click_actor === 'customer' && ['submit_attempted', 'outcome_unknown'].includes(value.status), 'invalid_response');
+    result.submit_actor = 'customer';
+  }
+  // An attested attempt names the customer; an unknown outcome cannot assert that a click happened.
+  if (value.status === 'submit_attempted' && value.purpose === 'purchase') check(value.submit_actor === 'customer', 'invalid_response');
   if (value.card !== undefined) {
     shape(value.card, ['last4', 'brand'], [], 'invalid_response');
     check(value.card.last4 === null || typeof value.card.last4 === 'string' && /^\d{4}$/u.test(value.card.last4), 'invalid_response');
@@ -164,6 +180,8 @@ function projectCheckout(value) {
     result.quote = { checkout_origin: value.quote.checkout_origin, amount_cents: value.quote.amount_cents, currency: 'USD' };
   }
   if (value.submit_expires_at !== undefined) result.submit_expires_at = timestamp(value.submit_expires_at);
+  // A backend record: checked here so a reconciled checkout stays readable, and never projected to the agent.
+  if (value.reconciliation !== undefined) { try { validateCheckoutReconciliation(value.reconciliation, value.status); } catch { check(false, 'invalid_response'); } }
   if (value.diagnostics !== undefined) result.diagnostics = JSON.parse(JSON.stringify(validateCheckoutDiagnostics(value.diagnostics, result)));
   return result;
 }
@@ -243,6 +261,9 @@ export function registerManagedCheckoutTools(server, { client = AccelerateClient
   const { verificationTiming, approvalPolicy, fillAfterVerification = false } = flowProfile({ profile, verificationTiming: requestedTiming, approvalPolicy: requestedApproval });
   check(server && typeof server.registerTool === 'function' && client?.checkouts &&
     ['create', 'get', 'browser', 'applyDetails', 'requestApproval', 'fill', 'submit', 'cancel'].every(key => typeof client.checkouts[key] === 'function') &&
+    (!enableSubmit || ['armFinalClick', 'completeFinalClick'].every(key => typeof client.checkouts[key] === 'function')) &&
+    // Purchases are never clicked by Accelerate or by Accelerate's private Kernel browser: only the customer's own browser host can click.
+    (purpose !== 'purchase' || browserMode === 'customer_backend_trusted' && ['prepareFinalClick', 'performFinalClick'].every(key => typeof browserConnector?.[key] === 'function')) &&
     [resolveContext, withOwnedCheckout, withCheckoutCreation, dispatchCheckoutEvent].every(value => typeof value === 'function') &&
     ['purchase', 'sandbox_fill_only'].includes(purpose) && typeof enableSubmit === 'boolean' && (!enableSubmit || purpose === 'purchase') &&
     ['on_start', 'on_payment'].includes(verificationTiming) && ['before_fill', 'after_fill'].includes(approvalPolicy) &&
@@ -251,6 +272,7 @@ export function registerManagedCheckoutTools(server, { client = AccelerateClient
     (browserConnector === undefined || browserMode === 'customer_backend_trusted' && browserConnector?.contract === 'accelerate_existing_browser_v1' &&
       ['prepareAttachment', 'commitAttachment', 'assertPaymentReady', 'confirmCleanup'].every(key => typeof browserConnector[key] === 'function')));
   const requirePolicy = checkout => {
+    check(purpose !== 'purchase' || checkout.final_click_actor === 'customer', 'invalid_response');
     check(approvalPolicy === 'after_fill' ? checkout.approval_policy === 'after_fill' && typeof checkout.purchase_approved === 'boolean'
       : checkout.approval_policy === undefined && checkout.purchase_approved === undefined, 'invalid_response');
     return checkout;
@@ -312,7 +334,10 @@ export function registerManagedCheckoutTools(server, { client = AccelerateClient
             requireAdmission();
             const browser = attachment ? attachment.browser : scope.browser;
             if (browserMode === 'customer_backend_trusted') {
-              shape(browser, ['provider', 'browser_id', 'custody_mode'], browser?.provider === 'connector' ? ['connector_id'] : [], 'permission_denied');
+              shape(browser, ['provider', 'browser_id', 'custody_mode'], browser?.provider === 'connector' ? ['connector_id'] : ['provenance'], 'permission_denied');
+              if (browser.provenance !== undefined) {
+                try { browserUseRunProvenance(browser.provenance); } catch { check(false, 'permission_denied'); }
+              }
               const valid = browser.provider === 'browser_use'
                 ? typeof browser.browser_id === 'string' && /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/u.test(browser.browser_id)
                 : browser.provider === 'connector' && typeof browser.connector_id === 'string' && /^[a-z][a-z0-9_-]{0,63}$/u.test(browser.connector_id) &&
@@ -322,6 +347,7 @@ export function registerManagedCheckoutTools(server, { client = AccelerateClient
             creationStarted = true;
             const created = await client.checkouts.create({ ...context, start_url: input.start_url,
               idempotency_key: scope.idempotency_key, interaction_mode: 'chat', purpose,
+              ...(purpose === 'purchase' ? { final_click_actor: 'customer' } : {}),
               ...(browserMode === 'customer_backend_trusted' ? { browser: { ...browser } } : {}),
               ...(attachment?.browser_resource ?? scope.browser_resource ? { browser_resource: attachment?.browser_resource ?? scope.browser_resource } : {}),
               ...(approvalPolicy === 'after_fill' ? { approval_policy: approvalPolicy } : {}),
@@ -350,7 +376,30 @@ export function registerManagedCheckoutTools(server, { client = AccelerateClient
               value = await client.checkouts.requestApproval(id, { ...approval, ...(fillAfterVerification ? { fill_after_verification: true } : {}) }, options);
               check(!fillAfterVerification || value.fill_after_verification === true, 'invalid_response');
             } else if (definition.name === 'accelerate_checkout_fill') value = await client.checkouts.fill(id, { revision: input.revision }, options);
-            else if (definition.name === 'accelerate_checkout_submit') { check(enableSubmit && purpose === 'purchase', 'permission_denied'); value = await client.checkouts.submit(id, { revision: input.revision }, options); }
+            else if (definition.name === 'accelerate_checkout_submit') {
+              check(enableSubmit && purpose === 'purchase' && typeof browserConnector?.performFinalClick === 'function' && typeof browserConnector.prepareFinalClick === 'function', 'permission_denied');
+              // prepare -> arm -> customer-owned host click -> complete, exactly once. The arm token and target stay in this scope.
+              // Slow provider/extension readiness runs BEFORE the arm so it cannot consume the short click window.
+              const preparation = await browserConnector.prepareFinalClick(context, { checkout_id: id }, options); requireAdmission();
+              let armed;
+              try { armed = await client.checkouts.armFinalClick(id, { revision: input.revision }, options); }
+              catch (error) {
+                // Only an explicit refusal proves nothing was armed. Transport, schema, timeout and upstream failures may have burned the arm.
+                if (error instanceof AccelerateError && PRE_ARM_REFUSALS.has(error.code)) throw error;
+                throw new AccelerateError('outcome_unknown');
+              }
+              try {
+                await browserConnector.performFinalClick(context, { checkout_id: id, preparation,
+                  checkout_url: armed.target.checkout_url, submit_selector: armed.target.submit_selector,
+                  armed_expires_at: armed.armed_expires_at }, options);
+              } catch { /* Host failure is not retried; the service observation below is the only truth. */ }
+              try { value = await client.checkouts.completeFinalClick(id, { revision: input.revision, arm_id: armed.arm_id }, options); }
+              catch { throw new AccelerateError('outcome_unknown'); }
+              // After a click attempt any unusable observation is an uncertain outcome, never a retryable failure.
+              try { requirePolicy(projectCheckout(value)); } catch { throw new AccelerateError('outcome_unknown'); }
+              check(['submit_attempted', 'outcome_unknown'].includes(value?.status) && value.final_click_actor === 'customer' &&
+                (value.status === 'outcome_unknown' || value.submit_actor === 'customer'), 'outcome_unknown');
+            }
             else value = await client.checkouts.cancel(id, options);
             requireAdmission();
             const projected = kind === 'browser' ? projectBrowser(value) : requirePolicy(projectCheckout(value));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weaccelerateinc/agent-sdk",
-  "version": "0.10.3",
+  "version": "0.12.0",
   "description": "Server-only payment SDK, existing-browser connectors and private host adapters for agent platforms",
   "type": "module",
   "main": "./index.js",
@@ -57,6 +57,18 @@
     "./browser-use-host": {
       "types": "./browser-use-host.d.ts",
       "import": "./browser-use-host.js"
+    },
+    "./whatsapp-messaging": {
+      "types": "./whatsapp-messaging.d.ts",
+      "import": "./whatsapp-messaging.js"
+    },
+    "./whatsapp-journal": {
+      "types": "./whatsapp-journal.d.ts",
+      "import": "./whatsapp-journal.js"
+    },
+    "./postgres-whatsapp-journal": {
+      "types": "./postgres-whatsapp-journal.d.ts",
+      "import": "./postgres-whatsapp-journal.js"
     }
   },
   "files": [
@@ -91,7 +103,14 @@
     "approved-extension-releases",
     "partner-starter",
     "browser-use-host.js",
-    "browser-use-host.d.ts"
+    "browser-use-host.d.ts",
+    "whatsapp-messaging.js",
+    "whatsapp-messaging.d.ts",
+    "whatsapp-journal.js",
+    "whatsapp-journal.d.ts",
+    "browser-provenance.js",
+    "postgres-whatsapp-journal.js",
+    "postgres-whatsapp-journal.d.ts"
   ],
   "engines": {
     "node": ">=22"

package/partner-starter/.env.example

@@ -2,8 +2,10 @@
 ACCELERATE_STARTER_MODE=synthetic
 # Explicit new profile: private CVV continues the armed fill in the backend.
 ACCELERATE_CHECKOUT_PROFILE=managed_review_v2
-ACCELERATE_STARTER_PURPOSE=sandbox_fill_only
-ACCELERATE_ENABLE_PURCHASE_SUBMIT=false
+ACCELERATE_STARTER_PURPOSE=purchase
+ACCELERATE_ENABLE_PURCHASE_SUBMIT=true
+# For a fill-only test, set purpose to sandbox_fill_only and submit to false.
+# This file is a template; export values or load it with your server environment.
 # Live: operator-controlled absolute file exporting createPartnerDependencies().
 # ACCELERATE_CONTEXT_MODULE=/absolute/protected/partner-host.mjs
 # ACCELERATE_API_KEY=<tenant server key>

package/partner-starter/README.md

@@ -1,20 +1,20 @@
 # Existing-browser payment starter
 
-SDK source 0.10.3, explicit `managed_review_v2`, `customer_backend_trusted`. The matching service must support this profile; source changes do not establish an archive publication or live deployment. Your platform creates its browser and installs the approved extension. This starter attaches that same browser at payment; it never creates a replacement. The older `accelerate-agent init <dir>` starter still selects Accelerate-managed Kernel custody.
+SDK 0.12.0, explicit `managed_review_v2`, `customer_backend_trusted`. Newly generated existing-browser apps default to `purpose:'purchase'` with the submit tool enabled. The matching service must support this profile; publishing the SDK does not deploy the service or qualify a merchant layout. Your platform creates its browser and installs the approved extension. This starter attaches that same browser at payment; it never creates a replacement. The older `accelerate-agent init <dir>` starter still selects Accelerate-managed Kernel custody and its fill-only default.
 
 ## Run without credentials
 
-Once Accelerate supplies the matching verified 0.10.3 archive, install it, then:
+Once Accelerate supplies the matching verified 0.12.0 archive, install it, then:
 
 ```sh
 npx --no-install accelerate-agent init ./partner-demo --browser existing
 cd partner-demo
-npm install /secure/downloads/weaccelerateinc-agent-sdk-0.10.3.tgz
+npm install /secure/downloads/weaccelerateinc-agent-sdk-0.12.0.tgz
 npm test
 npm run smoke
 ```
 
-The synthetic fixture uses the actual connector, durable-host interface, private ingress/outbox and MCP registration. It simulates verification/provider operations; no real browser, message, credential or order is created. Its in-memory persistence and fake extension metadata are test fixtures only.
+The synthetic fixture uses the actual connector, durable-host interface, private ingress/outbox and MCP registration. It simulates verification/provider operations; no real browser, message, credential or order is created. The smoke exercises default purchase mode, confirms submission is rejected before private approval, then cancels without approving or submitting. Its in-memory persistence and fake extension metadata are test fixtures only.
 
 ## Connect your platform
 
@@ -41,8 +41,21 @@ At create, v2 declares `fill_after_verification:true` and requires the service t
 
 Before attachment, use ordinary customer details for required non-secret fields or ask for missing details. Leave card number/PAN, expiry and CVV empty; never obtain them through ordinary browser tools.
 
-PAN displays stars + last four, CVV stars, expiry visible. Filled-page inspection is blocked for the agent. Provider-owner backend access remains trusted. The published release baseline qualifies `https://demos.weaccelerate.com/normal/payment`. The new universal-card source path probes compatible public HTTPS card forms instead of keeping a merchant hostname allowlist. It requires private `universal_card_v1` admission bound to the exact existing document and immutable purpose before OTP/CVV; ambiguous/unsupported forms fail without a replacement browser. That capability requires coordinated service/executor deployment and does not promise every checkout works. A candidate artifact or generic interface alone does not qualify a browser.
+PAN displays stars + last four, CVV stars, expiry visible. Filled-page inspection is blocked for the agent. Provider-owner backend access remains trusted. `universal_card_v1` is private runtime admission for the exact HTTPS checkout document and requested purpose, including both purchase and fill-only. It detects compatible payment fields and safe review support across merchants; unsupported or ambiguous forms fail before OTP/CVV without a replacement browser. It requires a matching service/executor deployment. The approved extension's original manifest records demo fill/review/cancel evidence; the [2 November sandbox report](https://github.com/weaccelerateinc/accelerate/blob/main/products/agent-sdk/qualification/REPORT.md) includes additional real merchant fill/review runs, with no real-store order submission or production qualification. The universal path reuses the approved 0.0.0.1 extension; it does not require candidate 0.0.0.2.
 
-The default is `sandbox_fill_only`, with no submit tool. After its informational image, call cancel and verify cleanup. Enable purchase only through explicit backend `purpose:'purchase'` and `enableSubmit:true` after qualification. Customer approval never automatically submits. Uncertain outcomes retain fences and require reconciliation; status/cleanup never authorize a replacement by themselves.
+## Purchase and fill-only configuration
+
+The new starter defaults are:
+
+```dotenv
+ACCELERATE_STARTER_PURPOSE=purchase
+ACCELERATE_ENABLE_PURCHASE_SUBMIT=true
+```
+
+Purchase mode exposes `accelerate_checkout_submit`. Accelerate never sends the final click: that tool arms one short click, your `createPartnerDependencies` browser connector host must implement `performFinalClick` to click once in the customer's existing browser, then Accelerate observes the outcome. Registration fails without that host. The synthetic fixture simulates the arm, host click and completion; its smoke still cancels without a purchase decision, and the starter tests run the approved path. Private CVV, a delivered masked review, a fresh customer decision and a separate explicit submit for the matching revision are still required. A ready form or customer approval never submits automatically. The default `ACCELERATE_STARTER_MODE=synthetic` makes no external requests. `live` selects real backend dependencies, not the production wallet environment; the approved key, Merchant ID and service configuration select that environment.
+
+For a no-order test, set `ACCELERATE_STARTER_PURPOSE=sandbox_fill_only` and remove the submit override or set `ACCELERATE_ENABLE_PURCHASE_SUBMIT=false`. If you copied `.env.example`, change both lines. An explicit true submit setting with fill-only purpose is rejected. After its informational review, cancel and verify cleanup. Purchase purpose with explicit submit false is also supported.
+
+The starter does not load `.env` automatically; export the settings or load them through your server's environment configuration. The purchase default introduced in 0.11.0 applies to newly generated `init --browser existing` projects. Published 0.10.3 and already generated apps retain their old files; configure their existing switches explicitly to enable purchase. Reusable SDK registration defaults remain fill-only. Existing checkout purpose is immutable, so an existing fill-only checkout cannot become a purchase. Uncertain outcomes retain fences and require reconciliation; status/cleanup never authorize a replacement by themselves.
 
 Before live testing, confirm the session is executing the deployed v2 tool bundle. Updating a durable agent app does not necessarily replace an active session’s tools; settle its old work and use the framework’s supported idle deployment handoff or create a new authenticated session. Verify the quote response acknowledges `fill_after_verification:true`; a successful deployment alone is insufficient.

package/partner-starter/package.json

@@ -12,7 +12,7 @@
     "test": "node --test tests/*.test.mjs"
   },
   "dependencies": {
-    "@weaccelerateinc/agent-sdk": "0.10.3",
+    "@weaccelerateinc/agent-sdk": "0.12.0",
     "@modelcontextprotocol/server": "2.3.1"
   },
   "devDependencies": {

package/partner-starter/runtime.mjs

@@ -9,8 +9,9 @@ export async function configureStarter(server, env = process.env) {
   const mode = env.ACCELERATE_STARTER_MODE ?? 'synthetic';
   const profile = env.ACCELERATE_CHECKOUT_PROFILE ?? 'managed_review_v2';
   if (!['managed_review_v1', 'managed_review_v2'].includes(profile)) throw Error('Unsupported partner checkout profile.');
-  const purpose = env.ACCELERATE_STARTER_PURPOSE ?? 'sandbox_fill_only';
-  const enableSubmit = env.ACCELERATE_ENABLE_PURCHASE_SUBMIT === 'true';
+  const purpose = env.ACCELERATE_STARTER_PURPOSE ?? 'purchase';
+  const enableSubmit = env.ACCELERATE_ENABLE_PURCHASE_SUBMIT === undefined
+    ? purpose === 'purchase' : env.ACCELERATE_ENABLE_PURCHASE_SUBMIT === 'true';
   if (!['sandbox_fill_only', 'purchase'].includes(purpose) ||
     env.ACCELERATE_ENABLE_PURCHASE_SUBMIT !== undefined && !['true', 'false'].includes(env.ACCELERATE_ENABLE_PURCHASE_SUBMIT) ||
     enableSubmit && purpose !== 'purchase') throw Error('Unsupported server purchase policy.');

package/partner-starter/smoke.mjs

@@ -12,9 +12,9 @@ const timer = setTimeout(() => { void transport.close(); }, 15000);
 try {
   await client.connect(transport);
   const tools = await client.listTools();
-  assert.equal(tools.tools.length, 7);
+  assert.equal(tools.tools.length, 8);
   assert.equal(tools.tools.some(tool => tool.name === 'accelerate_checkout_request_payment'), true);
-  assert.equal(tools.tools.some(tool => tool.name === 'accelerate_checkout_submit'), false);
+  assert.equal(tools.tools.some(tool => tool.name === 'accelerate_checkout_submit'), true);
   assert.equal(tools.tools.some(tool => tool.name === 'accelerate_checkout_fill'), false);
   const call = async (name, args) => {
     const result = await client.callTool({ name, arguments: args });
@@ -23,8 +23,9 @@ try {
   };
   const checkoutUrl = 'https://demos.weaccelerate.com/normal/payment';
   const checkout = (await call('accelerate_checkout_start', { start_url: checkoutUrl })).checkout;
-  assert.equal(checkout.purpose, 'sandbox_fill_only'); assert.equal(checkout.submit_allowed, false);
+  assert.equal(checkout.purpose, 'purchase'); assert.equal(checkout.submit_allowed, true);
   assert.equal(checkout.approval_policy, 'after_fill'); assert.equal(checkout.purchase_approved, false);
+  assert.equal(checkout.final_click_actor, 'customer');
   assert.equal(checkout.status, 'wallet_required'); assert.equal(checkout.card, undefined);
   const id = checkout.id;
   assert.equal((await call('accelerate_checkout_status', { checkout_id: id })).checkout.status, 'wallet_required');
@@ -42,12 +43,16 @@ try {
   assert.equal(reviewed.purchase_approved, false);
   const remaining = Date.parse(reviewed.submit_expires_at) - Date.now();
   assert.ok(remaining > 290000 && remaining <= 300000);
+  const rejected = await client.callTool({ name: 'accelerate_checkout_submit', arguments: { checkout_id: id, revision: reviewed.revision } });
+  const rejection = rejected.structuredContent ?? JSON.parse(rejected.content.find(part => part.type === 'text').text);
+  assert.equal(rejection.ok, false); assert.equal(rejection.error.code, 'submit_unavailable');
   assert.equal((await call('accelerate_checkout_cancel', { checkout_id: id })).checkout.status, 'cancelled');
   complete = true;
   process.stdout.write(JSON.stringify({ ok: true, synthetic_only: true, mcp_protocol: true,
     profile: 'managed_review_v2', existing_browser_connector: true, browser_mode: 'customer_backend_trusted', verification_deferred: true, private_verification_before_fill: true,
-    private_review_receipt_acknowledged: true, approval_window_ms: 300000, purchase_approval_requested: false,
-    submit_tool_absent: true, manual_fill_tool_absent: true, fill_ready: true, cancelled: true, live_checkout_requests: 0 }) + '\n');
+    private_review_receipt_acknowledged: true, approval_window_ms: 300000, purchase_approval_requested: true,
+    purpose: 'purchase', submit_tool_present: true, unapproved_submit_blocked: true, purchase_decision_received: false,
+    submit_attempted: false, final_click_actor: 'customer', manual_fill_tool_absent: true, fill_ready: true, cancelled: true, live_checkout_requests: 0 }) + '\n');
 } catch {
   process.stderr.write(JSON.stringify({ ok: false, code: 'synthetic_smoke_failed' }) + '\n');
 } finally {

package/partner-starter/synthetic.mjs

@@ -1,4 +1,4 @@
-import { createHash } from 'node:crypto';
+import { createHash, randomBytes } from 'node:crypto';
 import { createExistingBrowserConnector } from '@weaccelerateinc/agent-sdk/browser-connector';
 import { AccelerateClient } from '@weaccelerateinc/agent-sdk';
 import { AcceleratePrivateChatClient, deliverPrivateCheckoutReview } from '@weaccelerateinc/agent-sdk/private-chat';
@@ -18,7 +18,7 @@ function createSyntheticHost({ purpose = 'sandbox_fill_only', profile = 'managed
   const records = new Map(), owners = new Map(), events = new Set(), messages = new Map();
   const calls = { create: 0, browser: 0, payment_requested: 0, approval_requested: 0,
     private_verification: 0, fill: 0, review: 0, review_sent: 0, review_acknowledged: 0,
-    purchase_decision: 0, submit: 0, cancel: 0, external: 0 };
+    purchase_decision: 0, submit: 0, final_click_arm: 0, final_click_host: 0, final_click_complete: 0, cancel: 0, external: 0 };
   let tail = Promise.resolve();
   const locked = async work => {
     const previous = tail; let release;
@@ -29,6 +29,8 @@ function createSyntheticHost({ purpose = 'sandbox_fill_only', profile = 'managed
     expires_at: record.expires_at, purpose, submit_allowed: purpose === 'purchase',
     approval_policy: 'after_fill', purchase_approved: record.purchaseApproved === true,
     retry_safe: false, payment_confirmed: false,
+    ...(purpose === 'purchase' ? { final_click_actor: 'customer' } : {}),
+    ...(record.submitActor ? { submit_actor: 'customer' } : {}),
     ...(record.fillAfterVerificationProfile ? { fill_after_verification: true } : {}),
     ...(record.selected ? { card: { brand: 'Visa', last4: '4242' }, address: { label: 'Saved address ***23' } } : {}),
     ...(record.quote ? { quote: record.quote } : {}),
@@ -55,6 +57,7 @@ function createSyntheticHost({ purpose = 'sandbox_fill_only', profile = 'managed
     const body = request.body ? JSON.parse(request.body) : undefined;
     if (parsed.pathname === '/v1/checkouts' && request.method === 'POST') {
       if (body.interaction_mode !== 'chat' || body.purpose !== purpose || body.approval_policy !== 'after_fill' ||
+        (purpose === 'purchase') !== (body.final_click_actor === 'customer') || body.final_click_actor !== undefined && purpose !== 'purchase' ||
         Object.keys(context).some(key => body[key] !== context[key]) || body.start_url !== syntheticCheckoutUrl ||
         JSON.stringify(body.browser) !== JSON.stringify({ provider: 'connector', connector_id: 'synthetic_cdp', browser_id: 'existing:browser:1', custody_mode: 'customer_backend_trusted' })) invalid();
       if ((profile === 'managed_review_v2') !== (body.fill_after_verification === true)) invalid();
@@ -63,7 +66,7 @@ function createSyntheticHost({ purpose = 'sandbox_fill_only', profile = 'managed
         expires_at: new Date(Date.now() + 900000).toISOString(), selected: false, fillAfterVerificationProfile: body.fill_after_verification === true }); }
       return Response.json(view(records.get(id)), { status: 201 });
     }
-    const match = /^\/v1\/checkouts\/(mcs_[A-Za-z0-9_-]{43})(?:\/(browser|details|approval|fill|submit|cancel|private-chat\/(?:start|state|review|review-delivered|reply)))?$/.exec(parsed.pathname);
+    const match = /^\/v1\/checkouts\/(mcs_[A-Za-z0-9_-]{43})(?:\/(browser|details|approval|fill|submit|cancel|final-click\/(?:arm|complete)|private-chat\/(?:start|state|review|review-delivered|reply)))?$/.exec(parsed.pathname);
     if (!match || !records.has(match[1])) invalid();
     const record = records.get(match[1]), action = match[2];
     if (!action && request.method === 'GET') return Response.json(view(record));
@@ -116,6 +119,7 @@ function createSyntheticHost({ purpose = 'sandbox_fill_only', profile = 'managed
       body.amount_cents === 100 && body.currency === 'USD') {
       if ((profile === 'managed_review_v2') !== (body.fill_after_verification === true)) invalid();
       record.fillAfterVerification = body.fill_after_verification === true;
+      record.submitSelector = body.submit_selector;
       record.status = 'approval_required'; record.stage = 'cvv_required'; record.revision++;
       record.quote = { checkout_origin: 'https://demos.weaccelerate.com', amount_cents: 100, currency: 'USD' };
     } else if (action === 'fill' && record.status === 'approved' && body.revision === record.revision) {
@@ -123,10 +127,24 @@ function createSyntheticHost({ purpose = 'sandbox_fill_only', profile = 'managed
       fill(record);
     } else if (action === 'cancel') { calls.cancel++; record.status = 'cancelled'; record.stage = 'closed'; record.purchaseApproved = false; delete record.review; }
     else if (action === 'submit') {
+      // The executor click path is closed for every purchase. Counting it proves the fixture never uses it.
       calls.submit++;
-      if (purpose !== 'purchase' || !record.purchaseApproved || record.stage !== 'approved_for_submit' ||
-        body.revision !== record.revision || Date.now() >= Date.parse(record.review.expires_at)) return Response.json({ error: { code: 'submit_unavailable' } }, { status: 409 });
-      record.status = 'submit_attempted'; record.stage = 'closed'; record.purchaseApproved = false; delete record.review;
+      return Response.json({ error: { code: 'customer_click_required' } }, { status: 403 });
+    } else if (action === 'final-click/arm') {
+      if (purpose !== 'purchase' || !record.purchaseApproved || record.stage !== 'approved_for_submit' || record.status !== 'ready_for_submit' ||
+        body.revision !== record.revision || Date.now() >= Date.parse(record.review.expires_at) || record.arm) return Response.json({ error: { code: 'submit_unavailable' } }, { status: 409 });
+      calls.final_click_arm++;
+      record.arm = { id: 'sealed.' + randomBytes(48).toString('base64url'), expires_at: new Date(Date.now() + 10000).toISOString() };
+      record.status = 'final_click_armed';
+      return Response.json({ arm_id: record.arm.id, armed_expires_at: record.arm.expires_at,
+        target: { checkout_url: syntheticCheckoutUrl, submit_selector: record.submitSelector }, retry_safe: false, payment_confirmed: false });
+    } else if (action === 'final-click/complete') {
+      if (record.status !== 'final_click_armed' || body.revision !== record.revision || body.arm_id !== record.arm?.id || Object.keys(body).length !== 2)
+        return Response.json({ error: { code: 'submit_unavailable' } }, { status: 409 });
+      calls.final_click_complete++;
+      // Observation only: the fixture saw a click only when the customer host performed one.
+      record.status = record.clicked ? 'submit_attempted' : 'outcome_unknown'; record.submitActor = record.clicked === true;
+      record.stage = 'closed'; record.purchaseApproved = false; delete record.review; delete record.arm;
     } else invalid();
     return Response.json(view(record));
   };
@@ -180,6 +198,13 @@ function createSyntheticHost({ purpose = 'sandbox_fill_only', profile = 'managed
       // this exact event for redelivery, without replaying private filling.
       events.add(event.idempotency_key);
     },
+    /** The customer's browser host: the only place a physical click is ever simulated. */
+    hostClick: request => {
+      const record = records.get(request.checkout_id);
+      if (!record?.arm || Date.now() >= Date.parse(record.arm.expires_at) || Date.parse(request.armed_expires_at) !== Date.parse(record.arm.expires_at) || record.clicked ||
+        request.submit_selector !== record.submitSelector || request.checkout_url !== syntheticCheckoutUrl) invalid();
+      calls.final_click_host++; record.clicked = true; return { dispatched: true };
+    },
     counters: () => ({ ...calls }),
   };
   return host;
@@ -200,7 +225,7 @@ export function createSyntheticDependencies({ purpose = 'sandbox_fill_only', pro
     artifact: { format: 'zip', sha256: 'a'.repeat(64), bytes: 1234 },
     bridge: { protocol: 'accelerate_extension_bridge_v1', sha256: 'b'.repeat(64) },
     capabilities: { manual_card_fill: true, document_bound_single_use: true, autosave_disabled: true, automatic_submit: false, maximum_retention_ms: 480000 },
-    compatibility: { sdk_versions: ['0.10.1', '0.10.2', '0.10.3'], executor_contract: 'accelerate_manual_checkout_v1' },
+    compatibility: { sdk_versions: ['0.10.1', '0.10.2', '0.10.3', '0.10.4', '0.11.0', '0.12.0'], executor_contract: 'accelerate_manual_checkout_v1' },
     qualifications: [{ provider: 'connector', scope: 'synthetic_only', evidence: 'docs/evidence/synthetic-starter.json' }],
   }; // Fake metadata for this in-process fixture only; never load it in live mode.
   const browser = { owner: context, browser: { provider: 'connector', connector_id: 'synthetic_cdp', browser_id: 'existing:browser:1', custody_mode: 'customer_backend_trusted' },
@@ -215,6 +240,11 @@ export function createSyntheticDependencies({ purpose = 'sandbox_fill_only', pro
     bindCheckout: async (_context, value) => { saved.set(value.checkout_id, value); },
     resolveCheckoutBrowser: async (_context, { checkout_id }) => { const { checkout_id: _id, attempt_key: _key, ...value } = saved.get(checkout_id); return value; },
     confirmCleanup: async () => ({ provider_browser_stopped: true, credentials_cleared: true, fence_retained: true }),
+    // Purchase only. The synthetic page is clicked by this customer-side host, never by Accelerate.
+    ...(purpose === 'purchase' ? { performFinalClick: async (_context, request) => {
+      if (request.fence_id !== 'synthetic:fence:1' || request.browser.browser_id !== 'existing:browser:1') throw Error('Synthetic click rejected.');
+      return fixture.hostClick(request);
+    } } : {}),
   } });
   return { client: fixture.client, privateChat: fixture.privateChat, resolveContext: fixture.resolveContext,
     persistence, browserConnector,

package/partner-starter/tests/starter.test.mjs

@@ -1,16 +1,18 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import { configureStarter } from '../runtime.mjs';
-import { syntheticCheckoutUrl } from '../synthetic.mjs';
+import { createSyntheticDependencies, syntheticCheckoutUrl } from '../synthetic.mjs';
+import { registerPartnerCheckoutTools } from '@weaccelerateinc/agent-sdk/partner';
 async function fixture(env = {}) {
   const tools = new Map(); const integration = await configureStarter({ registerTool(name, _config, callback) { tools.set(name, callback); } }, env);
   const call = async (name, args) => { const result = (await tools.get(name)(args, {})).structuredContent; assert.equal(result.ok, true, JSON.stringify(result)); return result; };
   return { ...integration, tools, call };
 }
-test('explicit v2 starter verifies privately then fills and acknowledges review without a model fill tool', async t => {
+test('explicit fill-only v2 verifies privately then fills and acknowledges review without a submit tool', async t => {
   const old = globalThis.fetch; globalThis.fetch = () => assert.fail('No network in synthetic starter'); t.after(() => { globalThis.fetch = old; });
-  const f = await fixture(), checkout = (await f.call('accelerate_checkout_start', { start_url: syntheticCheckoutUrl })).checkout;
+  const f = await fixture({ ACCELERATE_STARTER_PURPOSE: 'sandbox_fill_only' }), checkout = (await f.call('accelerate_checkout_start', { start_url: syntheticCheckoutUrl })).checkout;
   const id = checkout.id; assert.equal(checkout.fill_after_verification, true); assert.equal(f.counters().fill, 0); assert.equal(checkout.status, 'wallet_required'); assert.equal(f.counters().payment_requested, 0);
+  assert.equal(checkout.purpose, 'sandbox_fill_only'); assert.equal(checkout.submit_allowed, false);
   assert.equal(f.tools.has('accelerate_checkout_submit'), false); assert.equal(f.tools.size, 7); assert.equal(f.tools.has('accelerate_checkout_fill'), false);
   assert.equal(f.profile, 'managed_review_v2');
   await f.call('accelerate_checkout_request_payment', { checkout_id: id });
@@ -28,7 +30,7 @@ test('explicit v2 starter verifies privately then fills and acknowledges review
   assert.equal(f.counters().submit, 0); assert.equal(f.counters().cancel, 1); assert.equal(f.counters().external, 0);
 });
 test('legacy v1 remains an explicit starter profile with one manual fill and no silent upgrade', async () => {
-  const f = await fixture({ ACCELERATE_CHECKOUT_PROFILE: 'managed_review_v1' });
+  const f = await fixture({ ACCELERATE_CHECKOUT_PROFILE: 'managed_review_v1', ACCELERATE_STARTER_PURPOSE: 'sandbox_fill_only' });
   assert.equal(f.tools.has('accelerate_checkout_fill'), true); assert.equal(f.tools.size, 8);
   const id = (await f.call('accelerate_checkout_start', { start_url: syntheticCheckoutUrl })).checkout.id;
   await f.call('accelerate_checkout_request_payment', { checkout_id: id });
@@ -43,10 +45,15 @@ test('legacy v1 remains an explicit starter profile with one manual fill and no
   assert.equal(f.counters().review_acknowledged, 1); assert.equal(f.counters().submit, 0);
   await f.call('accelerate_checkout_cancel', { checkout_id: id });
 });
-test('v2 purchase still requires a fresh private decision and explicit submit after automatic fill', async () => {
-  const f = await fixture({ ACCELERATE_STARTER_PURPOSE: 'purchase', ACCELERATE_ENABLE_PURCHASE_SUBMIT: 'true' });
+test('default v2 purchase still requires a fresh private decision and explicit submit after automatic fill', async t => {
+  const old = globalThis.fetch; globalThis.fetch = () => assert.fail('No network in synthetic starter'); t.after(() => { globalThis.fetch = old; });
+  const f = await fixture();
   assert.equal(f.tools.has('accelerate_checkout_fill'), false); assert.equal(f.tools.has('accelerate_checkout_submit'), true);
-  const id = (await f.call('accelerate_checkout_start', { start_url: syntheticCheckoutUrl })).checkout.id;
+  assert.equal(f.tools.size, 8);
+  const created = (await f.call('accelerate_checkout_start', { start_url: syntheticCheckoutUrl })).checkout;
+  assert.equal(created.purpose, 'purchase'); assert.equal(created.submit_allowed, true);
+  assert.equal(f.counters().payment_requested, 0);
+  const id = created.id;
   await f.call('accelerate_checkout_request_payment', { checkout_id: id });
   assert.equal(f.counters().fill, 0);
   await f.call('accelerate_checkout_apply_details', { checkout_id: id, checkout_url: syntheticCheckoutUrl });
@@ -60,10 +67,53 @@ test('v2 purchase still requires a fresh private decision and explicit submit af
   const rejected = (await f.tools.get('accelerate_checkout_submit')({ checkout_id: id, revision: quote.revision }, {})).structuredContent;
   assert.equal(rejected.ok, false); assert.equal(f.counters().submit, 0);
   await f.call('accelerate_checkout_cancel', { checkout_id: id });
+  assert.equal(f.counters().external, 0);
+});
+test('purchase submission can be explicitly disabled without changing purchase purpose', async () => {
+  const f = await fixture({ ACCELERATE_ENABLE_PURCHASE_SUBMIT: 'false' });
+  const created = (await f.call('accelerate_checkout_start', { start_url: syntheticCheckoutUrl })).checkout;
+  assert.equal(created.purpose, 'purchase'); assert.equal(created.submit_allowed, true);
+  assert.equal(f.tools.has('accelerate_checkout_submit'), false);
+  await f.call('accelerate_checkout_cancel', { checkout_id: created.id });
+  assert.equal(f.counters().submit, 0);
 });
 test('live setup requires a trusted backend module and preserves explicit custody selection', async () => {
   await assert.rejects(configureStarter({ registerTool() {} }, { ACCELERATE_STARTER_MODE: 'live' }), /trusted absolute/);
   await assert.rejects(configureStarter({ registerTool() {} }, { ACCELERATE_STARTER_MODE: 'unknown' }), /Unsupported/);
   await assert.rejects(configureStarter({ registerTool() {} }, { ACCELERATE_CHECKOUT_PROFILE: 'unknown' }), /profile/);
-  await assert.rejects(configureStarter({ registerTool() {} }, { ACCELERATE_ENABLE_PURCHASE_SUBMIT: 'true' }), /purchase policy/);
+  await assert.rejects(configureStarter({ registerTool() {} }, { ACCELERATE_STARTER_PURPOSE: 'sandbox_fill_only', ACCELERATE_ENABLE_PURCHASE_SUBMIT: 'true' }), /purchase policy/);
+  for (const value of ['', 'TRUE', '1'])
+    await assert.rejects(configureStarter({ registerTool() {} }, { ACCELERATE_ENABLE_PURCHASE_SUBMIT: value }), /purchase policy/);
+});
+
+test('approved synthetic purchase: arm, one customer-host click, complete; the old executor submit is never used', async t => {
+  const clock = Date.now; let now = clock(); Date.now = () => now; t.after(() => { Date.now = clock; });
+  const tools = new Map(), deps = createSyntheticDependencies({ purpose: 'purchase', profile: 'managed_review_v2' });
+  const context = await deps.resolveContext(); let reply;
+  deps.authenticate = async () => ({ authenticated: true, direct: true, context, ...reply });
+  const integration = registerPartnerCheckoutTools({ registerTool(name, _config, callback) { tools.set(name, callback); } },
+    { ...deps, purpose: 'purchase', enableSubmit: true, profile: 'managed_review_v2' });
+  const invoke = async (name, args) => (await tools.get(name)(args, {})).structuredContent;
+  const call = async (name, args) => { const result = await invoke(name, args); assert.equal(result.ok, true, JSON.stringify(result)); return result; };
+  const created = (await call('accelerate_checkout_start', { start_url: syntheticCheckoutUrl })).checkout, id = created.id;
+  assert.equal(created.final_click_actor, 'customer');
+  await call('accelerate_checkout_request_payment', { checkout_id: id });
+  await call('accelerate_checkout_apply_details', { checkout_id: id, checkout_url: syntheticCheckoutUrl });
+  const quote = (await call('accelerate_checkout_request_approval', { checkout_id: id, checkout_url: syntheticCheckoutUrl, amount_cents: 100, currency: 'USD',
+    checkout_total_selector: '#checkout-total', submit_selector: '#place-order' })).checkout;
+  await call('accelerate_checkout_status', { checkout_id: id });
+  assert.equal((await invoke('accelerate_checkout_submit', { checkout_id: id, revision: quote.revision })).error.code, 'submit_unavailable');
+  assert.equal(deps.counters().final_click_arm, 0);
+  now++; // The decision must follow the delivered review receipt.
+  reply = { message_id: 'synthetic-private-decision', text: 'approve', sent_at: new Date(now).toISOString() };
+  assert.deepEqual(await integration.privateIngress.handle({}, Buffer.from('synthetic provider envelope')), { handled: true });
+  const done = (await call('accelerate_checkout_submit', { checkout_id: id, revision: quote.revision })).checkout;
+  assert.equal(done.status, 'submit_attempted'); assert.equal(done.submit_actor, 'customer'); assert.equal(done.payment_confirmed, false);
+  const counters = deps.counters();
+  assert.deepEqual([counters.final_click_arm, counters.final_click_host, counters.final_click_complete, counters.submit, counters.external], [1, 1, 1, 0, 0]);
+});
+test('purchase registration needs a host that performs the customer click; fill-only does not', () => {
+  const fillOnly = createSyntheticDependencies({ purpose: 'sandbox_fill_only' });
+  assert.throws(() => registerPartnerCheckoutTools({ registerTool() {} }, { ...fillOnly, purpose: 'purchase', enableSubmit: true }), /performFinalClick/);
+  registerPartnerCheckoutTools({ registerTool() {} }, { ...fillOnly, purpose: 'sandbox_fill_only', enableSubmit: false });
 });

package/partner-starter/trusted-context.example.mjs

@@ -11,6 +11,9 @@ export async function createPartnerDependencies({ client, privateChat }) {
   // browserConnector: createBrowserUseConnector({ extensionRelease,
   //   host: createBrowserUseHost({apiKey,merchantId,extensionId,extensionRelease,host}) }) OR
   //   createExistingBrowserConnector({ connectorId, extensionRelease, host });
+  //   For purchase, host.performFinalClick(context, request, options) must perform exactly ONE trusted pointer
+  //   click on request.submit_selector in the exact fenced browser/document/URL (no retry, no lifting the fence)
+  //   and return { dispatched }. Accelerate never sends the final click.
   // authenticate(request, rawBody): verify webhook + established direct identity;
   // messaging: createLinqMessagingAdapter({ client: linq, sendingPhone, resolveDestination });
   // admitOrdinaryMessage(event), dispatchSafeProgress(event): durable dedupe + AI queue.

package/partner.js

@@ -12,6 +12,10 @@ export function registerPartnerCheckoutTools(server, options = {}) {
   if (browserConnector?.contract !== 'accelerate_existing_browser_v1' || !privateChat?.chat) {
     throw Error('An existing-browser connector and private chat client are required.');
   }
+  // Accelerate never sends the final click. A purchase needs the customer's own browser host to do it once.
+  if (purpose === 'purchase' && (typeof browserConnector.performFinalClick !== 'function' || typeof browserConnector.prepareFinalClick !== 'function')) {
+    throw Error('Purchase requires a connector whose host implements performFinalClick: the customer\u2019s own browser performs the final click.');
+  }
   const host = createDurableCheckoutHost({ persistence, resolveContext });
   // Keep the filled browser until explicit cancel or separately authorized
   // submit. Review delivery can be recovered without repeating the fill.

package/postgres-host.d.ts

@@ -1,4 +1,4 @@
-import type { HostPersistence } from './host-adapter.js';
+import type { HostCheckoutRecord } from './host-adapter.js';
 export const checkoutHostMigrationSql: string;
 export interface CheckoutHostPostgresClient {
   query(sql: string, values?: unknown[]): Promise<{ rows: Record<string, unknown>[]; rowCount?: number | null }>;
@@ -6,9 +6,13 @@ export interface CheckoutHostPostgresClient {
   on?(event: 'error', listener: () => void): unknown;
   removeListener?(event: 'error', listener: () => void): unknown;
 }
-export function createPostgresCheckoutPersistence(options: {
+/** Use a separate namespace for each private record type, including WhatsApp journals. */
+export function createPostgresCheckoutPersistence<Record = HostCheckoutRecord>(options: {
   pool: { connect(): Promise<CheckoutHostPostgresClient> };
   encryptionKey: Buffer | string;
   namespace?: string;
   lockTimeoutMs?: number;
-}): Readonly<HostPersistence & { initialize(): Promise<void> }>;
+}): Readonly<{
+  withLock<T>(ownerKey: string, work: (access: { load(): Promise<Record | undefined>; commit(record: Record): Promise<void> }) => Promise<T>): Promise<T>;
+  initialize(): Promise<void>;
+}>;