@reclaimprotocol/agent 0.1.26 → 0.1.28

package/src/old/login-cdp.ts

@@ -92,13 +92,39 @@ export interface CdpLoginResult {
 	closedBrowser: boolean
 }
 
+export interface LocalDashboardBrowser {
+	mode: 'dedicated' | 'attach'
+	port: number
+}
+
+/**
+ * Accept only the two loopback Chrome modes used for legacy dashboard login.
+ * Config files are user-editable, so validate at runtime rather than trusting
+ * the TypeScript shape. Remote Builder, container, custom-CDP, and URL inputs
+ * are deliberately unsupported here.
+ */
+export function localDashboardBrowser(value: unknown): LocalDashboardBrowser {
+	if(!value || typeof value !== 'object') {
+		return { mode: 'dedicated', port: 9222 }
+	}
+
+	const mode = Reflect.get(value, 'attachMode')
+	const port = Reflect.get(value, 'port')
+	if((mode === 'dedicated' || mode === 'attach')
+		&& Number.isInteger(port) && Number(port) > 0 && Number(port) <= 65_535) {
+		return { mode, port: Number(port) }
+	}
+
+	return { mode: 'dedicated', port: 9222 }
+}
+
 /**
- * Open the dashboard login page in Chrome via CDP, wait for the developer to
- * finish signing in, read the resulting Firebase ID token from page storage,
- * then clean up. If we had to launch a dedicated Chrome for this, we close the
- * whole browser afterwards; if we attached to a Chrome that was already up
- * (for example, the capture flow's), we only close the tab we opened so we
- * don't disrupt it.
+ * Open the dashboard login page in a local Chrome via loopback CDP, wait for
+ * the developer to finish signing in, read the resulting Firebase ID token
+ * from page storage, then clean up. This never uses a Builder, container,
+ * custom-CDP, or shared browser. If we launch a dedicated Chrome, we close the
+ * whole browser afterward; if we attach to an existing local Chrome, we close
+ * only the tab we opened.
  */
 export async function captureFirebaseTokenViaCdp(opts: {
 	loginUrl?: string
@@ -116,9 +142,9 @@ export async function captureFirebaseTokenViaCdp(opts: {
 	const timeoutMs = opts.timeoutMs ?? 360_000
 	const pollMs = opts.pollMs ?? 1000
 
-	const cfg = new ConfigStore().read()?.browser_agent
-	const mode = cfg?.attachMode ?? 'dedicated'
-	const port = cfg?.port ?? 9222
+	const { mode, port } = localDashboardBrowser(
+		new ConfigStore().read()?.browser_agent,
+	)
 
 	// Ensure something is answering CDP. In dedicated mode we may launch it.
 	let launchedByUs = false
@@ -127,9 +153,10 @@ export async function captureFirebaseTokenViaCdp(opts: {
 	} catch{
 		if(mode !== 'dedicated') {
 			throw new Error(
-				`attach mode: nothing answering CDP on port ${port}. Launch Chrome ` +
+				`local attach mode: nothing answering CDP on port ${port}. ` +
+				'Launch Chrome ' +
 				`with --remote-debugging-port=${port} AND a non-default ` +
-				'--user-data-dir, or switch to dedicated mode (attach_browser).',
+				'--user-data-dir, or use the dedicated local login mode.',
 			)
 		}
 

package/src/old/to-register.ts

@@ -1,3 +1,4 @@
+import { badRequest, conflict } from '@hapi/boom'
 import assert from 'node:assert'
 import type { ReclaimProvider } from '../provider/schema.ts'
 import type { AllowedJsRequest, DraftRequest } from '../provider/to-version.ts'
@@ -353,6 +354,8 @@ export interface SemverTriplet {
 	patch: number
 }
 
+export type SemverBump = 'major' | 'minor' | 'patch'
+
 /**
  * Pull `{major,minor,patch}` triplets out of a `/versions` response, tolerant
  * of the exact envelope (array, `{ providerVersions: [...] }`, `{ items }`,
@@ -384,22 +387,68 @@ export function extractVersions(resp: unknown): SemverTriplet[] {
  * rather than collide with the guaranteed 1.0.0).
  */
 export function bumpPatchString(versions: SemverTriplet[]): string {
-	if(versions.length === 0) {
+	return resolveNewVersionString(versions)
+}
+
+/** Resolve a strictly newer immutable version for old-devtools publishing. */
+export function resolveNewVersionString(
+	versions: SemverTriplet[],
+	input: { version?: SemverTriplet, bump?: SemverBump } = {},
+): string {
+	assert(
+		!(input.version && input.bump),
+		badRequest('Pass either `version` or `bump`, not both.'),
+	)
+	const highest = highestVersion(versions)
+	if(input.version) {
+		assert(
+			!highest || compareVersions(input.version, highest) > 0,
+			conflict(
+				`Version ${formatVersion(input.version)} must be higher than the ` +
+				`current highest version ${highest ? formatVersion(highest) : 'none'}.`,
+			),
+		)
+		return formatVersion(input.version)
+	}
+
+	if(!highest) {
 		return '1.0.1'
 	}
 
+	const bump = input.bump ?? 'patch'
+	switch (bump) {
+		case 'major':
+			return `${highest.major + 1}.0.0`
+		case 'minor':
+			return `${highest.major}.${highest.minor + 1}.0`
+		case 'patch':
+			return `${highest.major}.${highest.minor}.${highest.patch + 1}`
+	}
+}
+
+function highestVersion(
+	versions: SemverTriplet[],
+): SemverTriplet | undefined {
+	if(versions.length === 0) {
+		return undefined
+	}
+
 	let hi = versions[0]
 	for(const v of versions) {
-		if(
-			v.major > hi.major ||
-			(v.major === hi.major && v.minor > hi.minor) ||
-			(v.major === hi.major && v.minor === hi.minor && v.patch > hi.patch)
-		) {
+		if(compareVersions(v, hi) > 0) {
 			hi = v
 		}
 	}
 
-	return `${hi.major}.${hi.minor}.${hi.patch + 1}`
+	return hi
+}
+
+function compareVersions(a: SemverTriplet, b: SemverTriplet) {
+	return a.major - b.major || a.minor - b.minor || a.patch - b.patch
+}
+
+function formatVersion(version: SemverTriplet) {
+	return `${version.major}.${version.minor}.${version.patch}`
 }
 
 function pickArray(resp: unknown): unknown[] {

package/src/old/tools/authenticate.ts

@@ -5,10 +5,11 @@ import { persistIdentity, toEthUid } from '../identity.ts'
 import { captureFirebaseTokenViaCdp } from '../login-cdp.ts'
 
 /**
- * OLD-devtools authenticate. The default, zero-arg flow drives Chrome via CDP:
- * it opens the devtools dashboard, waits for the developer to sign in, reads
- * the Firebase ID token straight from page storage, then closes the tab (or
- * the browser, if it launched one just for this). Two manual overrides remain:
+ * OLD-devtools authenticate. The default, zero-arg flow drives only a local
+ * Chrome through loopback CDP. It never uses a Builder, container, custom-CDP,
+ * or shared browser. It opens the devtools dashboard, waits for the developer
+ * to sign in, reads the Firebase ID token from page storage, then closes the
+ * tab or the dedicated browser it launched. Two manual overrides remain:
  *
  *   - `token`: paste a Firebase ID token yourself (skips the browser).
  *   - `ethAddress`: an `eth:<addr>`/`0x…` uid for an already-provisioned eth
@@ -41,7 +42,9 @@ export function authenticateTool(client: ReclaimOldClient): RegisteredTool {
 			name: 'reclaim_authenticate',
 			description:
 				'Authenticate against the OLD Reclaim devtools backend. \n\n' +
-				'Default (no args): opens the devtools dashboard in Chrome via CDP, ' +
+				'Default (no args): opens the devtools dashboard in a LOCAL Chrome ' +
+				'over loopback CDP. It never uses a Builder, container, custom-CDP, ' +
+				'or shared browser. It ' +
 				'waits for you to sign in, grabs the Firebase token automatically, ' +
 				'and closes the tab. A previously stored identity that is still ' +
 				'valid is reused first (pass `useBrowser: true` to force a fresh ' +
@@ -151,6 +154,7 @@ export function authenticateTool(client: ReclaimOldClient): RegisteredTool {
 			return {
 				authenticated: true,
 				method: 'browser',
+				browser: 'local-chrome',
 				closedBrowser: result.closedBrowser,
 				note:
 					'Signed in via the dashboard; Firebase token captured and cached. ' +

package/src/old/tools/publish.ts

@@ -1,24 +1,29 @@
-import { Boom, isBoom } from '@hapi/boom'
+import { badRequest, Boom, isBoom } from '@hapi/boom'
+import assert from 'node:assert'
 import { defineTool, type RegisteredTool } from '../../mcp/server.ts'
 import type { AttachState } from '../../mcp/tools/agent/attach.ts'
 import {
 	ALLOWED_REQUESTS_HINT,
+	COOKIE_ATTACHMENT_HINT,
 	USER_SCRIPT_HINT,
 } from '../../provider/injection-doc.ts'
 import {
 	countsFor,
 	matchRedactionWarnings,
 } from '../../provider/match-redaction-warning.ts'
+import { postPublishBrowserNotes } from '../../provider/post-publish-browser.ts'
 import type { ReclaimProvider } from '../../provider/schema.ts'
 import type { AllowedJsRequest } from '../../provider/to-version.ts'
 import type { ReclaimOldClient } from '../client.ts'
 import {
-	bumpPatchString,
 	extractVersions,
 	injectedRequestDataFrom,
 	type OldProviderOpts,
 	providerToConfigBody,
 	providerToRegisterBody,
+	resolveNewVersionString,
+	type SemverBump,
+	type SemverTriplet,
 } from '../to-register.ts'
 
 const DEFAULT_VERSION_INFO = 'Updated from MCP browser capture'
@@ -70,8 +75,8 @@ function rethrowOwnershipError(err: unknown, providerId: string): never {
  *   - WITHOUT `providerId` → `POST /api/providers/register`: creates a
  *     brand-new provider + version 1.0.0. Re-running creates a DUPLICATE.
  *   - WITH `providerId` → `POST /api/providers/:providerId/config`: adds a
- *     new version to an existing provider (auto-bumps the patch above the
- *     highest existing version).
+ *     new immutable version to an existing provider (patch by default;
+ *     major/minor/patch or an exact higher version when requested).
  *
  * Get a `providerId` from `get_me_providers`.
  *
@@ -90,6 +95,8 @@ export function createVersionFromCaptureTool(
 		providers?: ReclaimProvider[]
 		initialUrl: string
 		providerId?: string
+		version?: SemverTriplet
+		bump?: SemverBump
 		description?: string
 		geoLocation?: string
 		useProxy?: boolean
@@ -119,8 +126,11 @@ export function createVersionFromCaptureTool(
 				+ 'redactions are supported.\n\n'
 				+ 'Omit `providerId` to REGISTER A NEW provider (creates it + '
 				+ 'version 1.0.0 — re-running creates a DUPLICATE). Pass '
-				+ '`providerId` (from get_me_providers) to add a NEW VERSION to it; '
-				+ 'the patch auto-bumps. You can only version a provider YOU own — '
+				+ '`providerId` (from get_me_providers) to add a NEW IMMUTABLE VERSION '
+				+ 'to it. Omit `version` and `bump` for a patch bump, pass `bump` for '
+				+ 'a major/minor/patch bump, or pass an exact higher `version` when '
+				+ 'the user directs it. Never edit an existing version. You can only '
+				+ 'version a provider YOU own — '
 				+ 'to publish your own take on one you don\'t own, omit '
 				+ '`providerId` to register your own copy.\n\n'
 				+ 'THIS BACKEND ONLY EVER CREATES A NEW VERSION — there is no '
@@ -225,6 +235,27 @@ export function createVersionFromCaptureTool(
 							'Existing provider to add a new version to. Omit to register ' +
 							'a brand-new provider.',
 					},
+					version: {
+						type: 'object',
+						description:
+							'Exact new semver requested by the user. Existing-provider ' +
+							'publishing only; it must be higher than the current highest ' +
+							'version. Do not pass with `bump`.',
+						properties: {
+							major: { type: 'integer', minimum: 0 },
+							minor: { type: 'integer', minimum: 0 },
+							patch: { type: 'integer', minimum: 0 },
+						},
+						required: ['major', 'minor', 'patch'],
+					},
+					bump: {
+						type: 'string',
+						enum: ['major', 'minor', 'patch'],
+						description:
+							'Semantic increment from the highest version. Defaults to ' +
+							'`patch`. Existing-provider publishing only; do not pass with ' +
+							'an exact `version`.',
+					},
 					description: {
 						type: 'string',
 						description: 'Provider description (new-provider register only).',
@@ -435,7 +466,8 @@ export function createVersionFromCaptureTool(
 							'certain none is configured. Builder calls the equivalent ' +
 							'concept `interceptorType` (no `NONE` there — omitting the ' +
 							'whole `interceptorOptions` object is its no-interception ' +
-							'signal instead). What each value actually does: ' +
+							'signal instead). ' + COOKIE_ATTACHMENT_HINT +
+							'What each value actually does: ' +
 							'how_it_works({ topic: "interception" }).',
 					},
 					disableRequestReplay: {
@@ -456,6 +488,17 @@ export function createVersionFromCaptureTool(
 			},
 		},
 		async(args) => {
+			assert(
+				!(args.version && args.bump),
+				badRequest('Pass either `version` or `bump`, not both.'),
+			)
+			assert(
+				args.providerId || (!args.version && !args.bump),
+				badRequest(
+					'`version` and `bump` require `providerId`; new-provider ' +
+					'registration starts at the backend-defined version.',
+				),
+			)
 			// `provider` / `providers` are just two spellings of the same input —
 			// fold them into one array. Zero drafts is allowed ONLY when adding a
 			// version to an EXISTING provider (`providerId` set): that publishes
@@ -514,17 +557,12 @@ export function createVersionFromCaptureTool(
 			// developer before closing it (a builder-mode session is
 			// quota-accounted and otherwise just sits until its TTL expires).
 			const attached = attachRef?.current
-			if(attached) {
-				notes.push(
-					`A "${attached.mode}" browser session is still attached` +
-					(attached.browserSessionId
-						? ` (browserSessionId: ${attached.browserSessionId})`
-						: '') +
-					'. Ask the developer whether they want to keep it open for ' +
-					'further edits — only call dispose_browser once they confirm ' +
-					'they\'re done with it.',
-				)
-			}
+			notes.push(...postPublishBrowserNotes(attached, {
+				initialUrl: args.initialUrl,
+				hasUserScript: !!args.customInjection?.trim(),
+				hasInterceptor: args.injectionType !== 'NONE'
+					&& !!args.customInjection?.trim(),
+			}))
 
 			const withNotes = (result: unknown) => {
 				if(notes.length && result && typeof result === 'object') {
@@ -585,7 +623,7 @@ export function createVersionFromCaptureTool(
 					// providerId.
 					try {
 						const versionsResp = await client.listVersions(newProviderId)
-						const followVersion = bumpPatchString(
+						const followVersion = resolveNewVersionString(
 							extractVersions(versionsResp),
 						)
 						const configBody = providerToConfigBody(
@@ -631,8 +669,9 @@ export function createVersionFromCaptureTool(
 				return withNotes(registered)
 			}
 
-			// New version of an existing provider — pick the next patch above
-			// the highest existing version. A provider you don't own (for example, a
+			// New version of an existing provider — resolve the requested semantic
+			// increment above the highest existing version. A provider you don't own
+			// (for example, a
 			// public one) fails here with 401/403/404; surface the register-a-copy
 			// workaround instead of a bare permission error.
 			const providerId = args.providerId
@@ -661,7 +700,10 @@ export function createVersionFromCaptureTool(
 				)
 
 				const versionsResp = await client.listVersions(providerId)
-				const version = bumpPatchString(extractVersions(versionsResp))
+				const version = resolveNewVersionString(
+					extractVersions(versionsResp),
+					{ version: args.version, bump: args.bump },
+				)
 				const versionInfo =
 					args.notes && args.notes.trim().length >= 10
 						? args.notes.trim()

package/src/proof/attestor-auth.ts

@@ -0,0 +1,33 @@
+import { createAuthRequest, type proto } from '@reclaimprotocol/attestor-core'
+
+/** Session-bound authorization in both forms used by Reclaim proof clients. */
+export interface AttestorAuthentication {
+	/** Native object consumed by the JavaScript attestor client. */
+	request: proto.AuthenticationRequest
+	/** Legacy base64 JSON token consumed by native TEE clients. */
+	token: string
+}
+
+/**
+ * Create legacy-compatible attestor authorization when the deployment has an
+ * auth private key. An absent key intentionally means authentication is off.
+ */
+export async function createAttestorAuthentication(
+	sessionId: string,
+	privateKey: string | undefined,
+): Promise<AttestorAuthentication | undefined> {
+	if(!privateKey?.trim()) {
+		return undefined
+	}
+
+	const request = await createAuthRequest({ id: sessionId }, privateKey)
+	const token = Buffer.from(
+		JSON.stringify({
+			...request,
+			signature: Buffer.from(request.signature).toString('base64'),
+		}),
+		'utf8',
+	).toString('base64')
+
+	return { request, token }
+}

package/src/proof/attestor.ts

@@ -9,7 +9,8 @@
 import { bytesToHex } from '@noble/hashes/utils.js'
 import {
 	createClaimOnAttestor,
-	type Logger
+	type Logger,
+	type proto,
 } from '@reclaimprotocol/attestor-core'
 // Side-effect: make external domhandler nodes DOM-like so attestor-core's
 // bundled `xpath` accepts them (see patch-domhandler.ts). Must load before any
@@ -33,8 +34,8 @@ export interface AttestorLogEntry {
 	ctx?: Record<string, unknown>
 }
 
-/** The attestor's signed claim data + signature, for building the nested proof
- *  JWS a Consumer verifies against the attestor's key. Populated when
+/** The attestor's signed claim data + signature, for building the exact legacy
+ *  Proof a Consumer verifies against the attestor's key. Populated when
  *  `includeAttestorClaim` is set (the app's verification runner needs it; the
  *  MCP `run_proof` tool ignores it). */
 export interface AttestorClaim {
@@ -50,6 +51,8 @@ export interface AttestorClaim {
 /** Options for {@link runAttestorProof}. */
 export interface RunAttestorProofOptions {
 	attestorUrl?: string
+	/** Optional session-bound authorization generated by the trusted backend. */
+	authRequest?: proto.AuthenticationRequest
 	/** When resolving the key from env/.env/file, the address the caller expects
 	 *  to sign with (sanity check). Ignored when `ownerPrivateKey` is given. */
 	ownerAddress?: string
@@ -62,7 +65,7 @@ export interface RunAttestorProofOptions {
 	 *  want gnark's speed pin it explicitly (for example, the verify runner). */
 	zkEngine?: 'gnark' | 'snarkjs' | 'stwo'
 	/** Extract the structured {@link AttestorClaim} (claim + attestor signature)
-	 *  onto the result for nested-proof construction. */
+	 *  onto the result for legacy Proof construction. */
 	includeAttestorClaim?: boolean
 }
 
@@ -74,7 +77,7 @@ export interface ProofResult {
 	owner?: string
 	verified: boolean
 	error?: string
-	/** Structured claim + signature for nested-proof verification. Set only when
+	/** Structured claim + signature for legacy Proof verification. Set only when
 	 *  `includeAttestorClaim` was requested and the claim carries signatures. */
 	attestorClaim?: AttestorClaim
 	/** Set to `'missing-owner-key'` when no credential was available to
@@ -274,7 +277,10 @@ export async function runAttestorProof(
 					headers: secrets,
 				},
 				ownerPrivateKey,
-				client: { url: resolveAttestorUrl(opts.attestorUrl) },
+				client: {
+					url: resolveAttestorUrl(opts.attestorUrl),
+					...(opts.authRequest ? { authRequest: opts.authRequest } : {}),
+				},
 				zkEngine: opts.zkEngine ?? 'stwo',
 				...(capture !== undefined && { logger: capture.logger as Logger }),
 			})
@@ -311,8 +317,8 @@ export async function runAttestorProof(
 			result.owner = owner
 		}
 
-		// Structured claim + signature so the result JWS can carry a nested,
-		// attestor-signed proof the Consumer verifies independently.
+		// Structured claim + signature so the result JWS can carry the exact
+		// legacy Proof the Consumer verifies independently.
 		if(opts.includeAttestorClaim) {
 			const sigs = (claim as {
 				signatures?: { attestorAddress?: unknown, claimSignature?: unknown }

package/src/proof/index.ts

@@ -8,6 +8,10 @@ export type {
 	RunAttestorProofOptions,
 } from './attestor.ts'
 export { runAttestorProof, tailLogs, warnsAndErrors } from './attestor.ts'
+export {
+	createAttestorAuthentication,
+	type AttestorAuthentication,
+} from './attestor-auth.ts'
 export {
 	buildHttpParams,
 	ensureAttestorCrypto,

package/src/proof/pod-prover.ts

@@ -26,10 +26,9 @@
  *
  * The pod API is unauthenticated (gateway/session is the trust boundary); call
  * it over the same internal host used for CDP. Consumers verify
- * `claim_signature` only (see `@reclaimprotocol/client`'s `verifyNestedProof`),
- * so this hands back a {@link AttestorClaim} whose hex `claimSignature` the
- * shared `wrapProofAsJws` (app-side) turns into the nested result proof.
- * `result_signature` is unused by any consumer.
+ * `claim_signature` with the legacy SDK's `verifyProof`, so this hands back an
+ * {@link AttestorClaim} that the app places in the exact legacy `Proof` shape.
+ * `result_signature` is unused by consumers.
  */
 import { bytesToHex } from '@noble/hashes/utils.js'
 import type { ProviderParams } from '@reclaimprotocol/attestor-core'
@@ -77,6 +76,8 @@ export interface PopcornProveOptions {
 	secretParams: HttpSecretParams
 	/** Session context, stringified into the claim context if given. */
 	context?: Record<string, unknown>
+	/** Base64 JSON authorization forwarded by reclaim-tee to the attestor. */
+	authRequest?: string
 	fetchImpl?: typeof fetch
 }
 
@@ -142,7 +143,7 @@ function b64ToBytes(b64: string): Uint8Array {
 export async function popcornProve(
 	opts: PopcornProveOptions,
 ): Promise<ProofResult> {
-	const { apiUrl, params, secretParams, context } = opts
+	const { apiUrl, params, secretParams, context, authRequest } = opts
 	const doFetch = opts.fetchImpl ?? fetch
 	const base = apiUrl.replace(/\/$/, '')
 
@@ -151,6 +152,7 @@ export async function popcornProve(
 		params,
 		secretParams,
 		...(context ? { context: JSON.stringify(context) } : {}),
+		...(authRequest ? { authRequest } : {}),
 	})
 	const fail = (error: string): ProofResult => ({
 		proof: undefined,

package/src/provider/injection-doc.ts

@@ -15,13 +15,21 @@
  * Shared by both publish tools so the two can't drift apart.
  */
 
+/** Auth behavior shared by intercepted and script-requested claims. */
+export const COOKIE_ATTACHMENT_HINT =
+	'For an intercepted request or window.Reclaim.requestClaim, the verification '
+	+ 'client automatically attaches cookies applicable to the request URL to '
+	+ 'the claim sent to the attestor. Do not read, hardcode, or copy Cookie '
+	+ 'values into the script or public params. '
+
 /** What the script is and where the real guidance lives. */
 export const USER_SCRIPT_HINT =
 	'Plain JavaScript injected into the provider page before every page load. '
 	+ 'Use standard browser APIs (window.location, element.click(), forms) to '
 	+ 'drive login/navigation so the target request fires — the client already '
 	+ 'intercepts page requests, and window.Reclaim is only for rare edge cases, '
-	+ 'not navigation. Full guide: how_it_works({ topic: "user-script" }).'
+	+ 'not navigation. ' + COOKIE_ATTACHMENT_HINT
+	+ 'Full guide: how_it_works({ topic: "user-script" }).'
 
 /** Prefixes the `allowedJsRequests` / `allowedInjectedRequestData` field. The
  *  trap it describes is silent and total — a mis-declared entry makes

package/src/provider/post-publish-browser.ts

@@ -0,0 +1,56 @@
+interface AttachedBrowser {
+	mode: string
+	browserSessionId?: string
+}
+
+interface BrowserRetestOptions {
+	initialUrl: string
+	hasUserScript: boolean
+	hasInterceptor: boolean
+}
+
+/** Advisory follow-up when a browser remains after provider creation. */
+export function postPublishBrowserNotes(
+	attached: AttachedBrowser | undefined,
+	options: BrowserRetestOptions,
+): string[] {
+	if(!attached) {
+		return []
+	}
+
+	const identity = `A "${attached.mode}" browser session is still attached`
+		+ (attached.browserSessionId
+			? ` (browserSessionId: ${attached.browserSessionId})`
+			: '')
+	const retest = 'Before disposing it, best-effort test the '
+		+ 'already-authenticated path only when this profile is still signed in: '
+		+ `navigate to initialUrl (${options.initialUrl}) without clearing cookies `
+		+ 'or forcing another login. '
+		+ (options.hasUserScript
+			? 'Use test_user_script with this version\'s script and initialUrl; '
+			: 'Navigate to initialUrl normally; ')
+		+ 'confirm every required target request still fires, then replay and '
+		+ 'prove each one when the existing capture has enough data. Check that '
+		+ 'the flow handles '
+		+ 'both a fresh sign-in and an already-signed-in landing from current page '
+		+ 'state, not only a login transition. This is advisory: skip it when no '
+		+ 'authenticated state is available. An inconclusive result must not block '
+		+ 'disposal or trigger a republish.'
+	const interceptor = options.hasInterceptor
+		? 'The attached authoring browser validates page behavior and the user '
+			+ 'script, but it does not prove compatibility with an in-page '
+			+ 'production interceptor. '
+			+ 'For the InApp SDK, verifier app, or browser extension, keep any '
+			+ 'client-specific interceptor verification as a separate follow-up.'
+		: undefined
+	const dispose = 'Ask the developer whether they want to keep the browser '
+		+ 'open '
+		+ 'for this retest or further edits. Only call dispose_browser after they '
+		+ 'confirm they are done.'
+
+	return [
+		identity + '. ' + retest,
+		...(interceptor ? [interceptor] : []),
+		dispose,
+	]
+}