@weaccelerateinc/agent-sdk 0.10.3 → 0.11.0

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'], 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/private-chat.js

@@ -1,4 +1,5 @@
 import { AccelerateClient, AccelerateError } from './index.js';
+import { validateCheckoutReconciliation } from './checkout-diagnostics.js';
 import { createHash } from 'node:crypto';
 
 const idPattern = /^mcs_[A-Za-z0-9_-]{43}$/;
@@ -7,7 +8,7 @@ const identityPattern = /^[A-Za-z0-9_.:-]{1,500}$/;
 // This limit applies only to the private review image, not JSON responses.
 const maximumReviewImageBytes = 8 * 1024 * 1024;
 const stages = new Set(['not_started', 'identity_required', 'otp_required', 'selection_required', 'preparing_checkout', 'approval_required', 'cvv_required', 'verified', 'review_delivery_required', 'review_delivered', 'approved_for_submit', 'closed']);
-const statuses = new Set(['wallet_required', 'selection_ready', 'details_ready', 'approval_required', 'approved', 'ready_for_submit', 'cancelled', 'expired', 'failed', 'submit_attempted', 'outcome_unknown']);
+const statuses = new Set(['wallet_required', 'selection_ready', 'details_ready', 'approval_required', 'approved', 'ready_for_submit', 'final_click_armed', 'cancelled', 'expired', 'failed', 'submit_attempted', 'outcome_unknown']);
 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); };
 function keys(value, allowed, required = allowed, code = 'invalid_input') {
@@ -37,14 +38,20 @@ function quote(value, revision = false, afterFill = false) {
 }
 function state(value, expectedId) {
   keys(value, ['checkout', 'stage', 'handled', 'duplicate', 'cards', 'addresses', 'identity_field', 'approval', 'selection_error', 'review'], ['checkout', 'stage', 'handled', 'duplicate', 'cards', 'addresses'], 'invalid_response');
-  keys(value.checkout, ['id', 'status', 'revision', 'expires_at', 'card', 'address', 'quote', 'submit_expires_at', 'purpose', 'submit_allowed', 'approval_policy', 'purchase_approved', 'fill_after_verification', 'retry_safe', 'payment_confirmed'],
+  keys(value.checkout, ['id', 'status', 'revision', 'expires_at', 'card', 'address', 'quote', 'submit_expires_at', 'purpose', 'submit_allowed', 'approval_policy', 'purchase_approved', 'fill_after_verification', 'reconciliation', 'final_click_actor', 'submit_actor', 'retry_safe', 'payment_confirmed'],
     ['id', 'status', 'revision', 'expires_at', 'retry_safe', 'payment_confirmed'], 'invalid_response');
   const checkout = value.checkout;
+  if (checkout.reconciliation !== undefined) {
+    try { validateCheckoutReconciliation(checkout.reconciliation, checkout.status); } catch { check(false, 'invalid_response'); }
+  }
   if (checkout.purpose !== undefined || checkout.submit_allowed !== undefined) check(
     ['purchase', 'sandbox_source_comparison', 'sandbox_fill_only'].includes(checkout.purpose) &&
     checkout.submit_allowed === (checkout.purpose === 'purchase'), 'invalid_response');
   check(checkout.id === expectedId && statuses.has(checkout.status) && checkout.retry_safe === false && checkout.payment_confirmed === false, 'invalid_response');
-  if (checkout.approval_policy !== undefined || checkout.purchase_approved !== undefined) check(checkout.approval_policy === 'after_fill' && typeof checkout.purchase_approved === 'boolean' && (!checkout.purchase_approved || checkout.status === 'ready_for_submit' && checkout.purpose === 'purchase'), 'invalid_response');
+  if (checkout.approval_policy !== undefined || checkout.purchase_approved !== undefined) check(checkout.approval_policy === 'after_fill' && typeof checkout.purchase_approved === 'boolean' && (!checkout.purchase_approved || ['ready_for_submit', 'final_click_armed'].includes(checkout.status) && checkout.purpose === 'purchase'), 'invalid_response');
+  if (checkout.final_click_actor !== undefined) check(checkout.final_click_actor === 'customer' && checkout.purpose === 'purchase', 'invalid_response');
+  if (checkout.submit_actor !== undefined) check(checkout.submit_actor === 'customer' && checkout.final_click_actor === 'customer' && ['submit_attempted', 'outcome_unknown'].includes(checkout.status), 'invalid_response');
+  if (checkout.status === 'submit_attempted' && checkout.purpose === 'purchase') check(checkout.submit_actor === 'customer', 'invalid_response');
   if (checkout.fill_after_verification !== undefined) check(checkout.fill_after_verification === true && checkout.approval_policy === 'after_fill' &&
     ['purchase', 'sandbox_fill_only'].includes(checkout.purpose), 'invalid_response');
   integer(checkout.revision, 0); date(checkout.expires_at); if (checkout.submit_expires_at !== undefined) date(checkout.submit_expires_at);

package/starter/README.md

@@ -72,14 +72,8 @@ The current safe capture is qualified only for the configured sandbox merchant's
 5. Fill the verified revision once. The private handler delivers the actual safe form image and exact total: PAN stars plus last four, visible expiry and CVV stars.
 6. For the default fill-only checkout, require successful informational image delivery, then cancel the same checkout. Submit is absent and forbidden. Do not inspect the populated browser.
 
-For an explicitly enabled purchase integration, the same private image asks for simple approve/decline and grants a full five-minute decision window from the actual provider receipt. `ready_for_submit` is insufficient: wait for `purchase_approved:true`, then use a separate explicit owner-authorized submit operation before the returned deadline. After qualification, purchase mode requires both of these backend settings:
+This managed-browser starter is fill-only. Accelerate never sends the final payment click, and its private Kernel browser cannot hand control to the customer without breaking custody, so `purpose:purchase` and the submit flag are rejected. For purchases use the existing-browser partner starter: the customer's own backend browser performs the single physical click.
 
-```dotenv
-ACCELERATE_STARTER_PURPOSE=purchase
-ACCELERATE_ENABLE_PURCHASE_SUBMIT=true
-```
-
-The model cannot enable these settings. `purpose:purchase` without the submit flag still exposes no submit tool.
 
 ## Explicit legacy compatibility
 

package/starter/package.json

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

package/starter/runtime.mjs

@@ -9,10 +9,15 @@ const requiredHooks = ['resolveContext', 'withOwnedCheckout', 'withCheckoutCreat
 export async function configureStarter(server, env = process.env) {
   const mode = env.ACCELERATE_STARTER_MODE ?? 'synthetic';
   const purpose = env.ACCELERATE_STARTER_PURPOSE ?? 'sandbox_fill_only';
-  const enableSubmit = 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.');
+    env.ACCELERATE_ENABLE_PURCHASE_SUBMIT === 'true' && purpose !== 'purchase') throw Error('Unsupported server purchase policy.');
+  // Accelerate never sends the final payment click, and its private managed browser cannot hand control to the
+  // customer without breaking custody. This starter is therefore fill-only; purchases use the existing-browser partner starter.
+  if (purpose !== 'sandbox_fill_only' || env.ACCELERATE_ENABLE_PURCHASE_SUBMIT === 'true') {
+    throw Error('The managed-browser starter is fill-only. Use the existing-browser partner starter for purchases.');
+  }
+  const enableSubmit = false;
   let host, privateChat;
   const matches = (state, event) => state.checkout.id === event.checkout.id && state.checkout.revision === event.checkout.revision &&
     state.checkout.purpose === purpose && state.checkout.approval_policy === 'after_fill' &&

package/starter/synthetic.mjs

@@ -13,7 +13,7 @@ const png = () => Buffer.from([137, 80, 78, 71, 13, 10, 26, 10, 1, 2, 3]);
 /** In-process fixtures only: no network, source, browser, raw OTP or security code.
  * Private verification is simulated; safe image delivery uses the real SDK. */
 export function createSyntheticHost({ purpose = 'sandbox_fill_only', deliverReview } = {}) {
-  if (!['sandbox_fill_only', 'purchase'].includes(purpose)) invalid();
+  if (purpose !== 'sandbox_fill_only') invalid();
   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,

package/starter/tests/starter.test.mjs

@@ -74,41 +74,6 @@ test('review delivery failure retains the same event and retries image delivery
   assert.equal(host.counters().submit, 0);
 });
 
-test('purchase profile waits the full five-minute receipt-bound window and requires a distinct final submit', async t => {
-  const originalNow = Date.now; let now = originalNow(); Date.now = () => now;
-  t.after(() => { Date.now = originalNow; });
-  const { host, checkout, dispatch, binding, reachFill } = await prepared('purchase');
-  const filled = await reachFill();
-  await assert.rejects(host.privateChat.chat.reply(checkout.id, { ...binding, message_id: 'too-early', text: 'approve', sent_at: new Date(now).toISOString() }));
-  await assert.rejects(host.client.checkouts.submit(checkout.id, { revision: filled.revision }), { code: 'submit_unavailable' });
-  now += 45000; await dispatch('review_ready', filled);
-  const reviewed = await host.privateChat.chat.get(checkout.id, binding);
-  assert.equal(reviewed.stage, 'approval_required'); assert.equal(Date.parse(reviewed.review.expires_at), now + 300000);
-  now += 299999;
-  const approved = await host.privateChat.chat.reply(checkout.id, { ...binding, message_id: 'private-decision', text: 'approve', sent_at: new Date(now).toISOString() });
-  assert.equal(approved.stage, 'approved_for_submit'); assert.equal(approved.checkout.purchase_approved, true);
-  assert.equal(host.counters().submit, 1); // Only the deliberately denied early request.
-  assert.equal((await host.client.checkouts.get(checkout.id)).status, 'ready_for_submit');
-  const submitted = await host.client.checkouts.submit(checkout.id, { revision: filled.revision });
-  assert.equal(submitted.status, 'submit_attempted'); assert.equal(submitted.payment_confirmed, false);
-  await assert.rejects(host.client.checkouts.submit(checkout.id, { revision: filled.revision }), { code: 'submit_unavailable' });
-});
-
-test('purchase decision at five minutes is expired, and a private decline cancels without submission', async t => {
-  const originalNow = Date.now; let now = originalNow(); Date.now = () => now;
-  t.after(() => { Date.now = originalNow; });
-  const expired = await prepared('purchase'), filled = await expired.reachFill();
-  await expired.dispatch('review_ready', filled); now += 300000;
-  await assert.rejects(expired.host.privateChat.chat.reply(expired.checkout.id, { ...expired.binding,
-    message_id: 'late-decision', text: 'approve', sent_at: new Date(now).toISOString() }));
-  assert.equal(expired.host.counters().purchase_decision, 0); assert.equal(expired.host.counters().submit, 0);
-  const declined = await prepared('purchase'), next = await declined.reachFill();
-  await declined.dispatch('review_ready', next); now++;
-  const closed = await declined.host.privateChat.chat.reply(declined.checkout.id, { ...declined.binding,
-    message_id: 'private-decline', text: 'decline', sent_at: new Date(now).toISOString() });
-  assert.equal(closed.checkout.status, 'cancelled'); assert.equal(declined.host.counters().submit, 0);
-});
-
 test('starter registers the supported managed review profile and never accepts model purchase policy', async () => {
   const tools = new Map();
   const configured = await configureStarter({ registerTool(name, config, callback) { tools.set(name, { config, callback }); } }, {});
@@ -118,10 +83,13 @@ test('starter registers the supported managed review profile and never accepts m
   assert.equal(created.ok, true); assert.equal(created.checkout.approval_policy, 'after_fill');
   const rejected = await call('accelerate_checkout_start', { start_url: syntheticCheckoutUrl, purpose: 'purchase' });
   assert.equal(rejected.ok, false); assert.equal(rejected.error.code, 'invalid_input');
-  const purchaseTools = new Map();
-  await configureStarter({ registerTool(name, _config, callback) { purchaseTools.set(name, callback); } },
-    { ACCELERATE_STARTER_PURPOSE: 'purchase', ACCELERATE_ENABLE_PURCHASE_SUBMIT: 'true' });
-  assert.equal(purchaseTools.has('accelerate_checkout_submit'), true);
+  // Kernel custody is fill-only: Accelerate never clicks and cannot hand its private browser to the customer.
+  for (const env of [{ ACCELERATE_STARTER_PURPOSE: 'purchase', ACCELERATE_ENABLE_PURCHASE_SUBMIT: 'true' }, { ACCELERATE_STARTER_PURPOSE: 'purchase' },
+    { ACCELERATE_STARTER_PURPOSE: 'purchase', ACCELERATE_ENABLE_PURCHASE_SUBMIT: 'false' }]) {
+    await assert.rejects(configureStarter({ registerTool() { assert.fail('Kernel purchase exposed tools.'); } }, env), /fill-only/);
+    await assert.rejects(configureStarter({ registerTool() { assert.fail('Kernel purchase exposed tools.'); } }, { ...env, ACCELERATE_STARTER_MODE: 'live' }), /fill-only/);
+  }
+  assert.throws(() => createSyntheticHost({ purpose: 'purchase' }));
   for (const env of [{ ACCELERATE_STARTER_PURPOSE: 'unknown' }, { ACCELERATE_ENABLE_PURCHASE_SUBMIT: 'true' },
     { ACCELERATE_ENABLE_PURCHASE_SUBMIT: '1' }]) await assert.rejects(configureStarter({ registerTool() { assert.fail('Invalid policy exposed tools.'); } }, env));
 });