@datalayer/agent-runtimes 1.5.8 → 1.5.9

package/lib/apps/apps/appspec.js

@@ -304,12 +304,47 @@ function parsePap(data) {
             operations: records(company.operations).map(operation => ({
                 action: text(operation.action),
                 tool: text(operation.tool),
+                ...(isData(operation.allows)
+                    ? { allows: parsePapStanding(operation.allows) }
+                    : {}),
                 summary: text(operation.summary),
                 userApprovalRequired: flag(operation.user_approval_required, true),
             })),
         },
     };
 }
+/** A standing permission an operation gives (PAP_DATALAYER R-07), as agentspecs reads it. */
+function parsePapStanding(data) {
+    return {
+        connection: text(data.connection),
+        action: oneOf(data.action, ['write', 'buy'], 'buy'),
+        limits: records(data.limits).map(limit => ({
+            path: text(limit.path),
+            ...(typeof limit.maximum === 'string'
+                ? { maximum: text(limit.maximum) }
+                : {}),
+            ...(typeof limit.allowed === 'string'
+                ? { allowed: text(limit.allowed) }
+                : {}),
+        })),
+        uses: text(data.uses),
+        days: text(data.days),
+    };
+}
+/** A standing permission as its document says it: every field, none has a default. */
+function dumpPapStanding(standing) {
+    return {
+        connection: standing.connection,
+        action: standing.action,
+        limits: standing.limits.map(limit => ({
+            path: limit.path,
+            ...(limit.maximum !== undefined ? { maximum: limit.maximum } : {}),
+            ...(limit.allowed !== undefined ? { allowed: limit.allowed } : {}),
+        })),
+        uses: standing.uses,
+        days: standing.days,
+    };
+}
 /** Personal Agent Protocol as its document says it, nothing at its default. */
 function dumpPap(pap) {
     if (!pap)
@@ -337,7 +372,11 @@ function dumpPap(pap) {
         .list('registered_agents', pap.company.registeredAgents)
         .list('operations', pap.company.operations.map(operation => new Writer()
         .text('action', operation.action, '\u0000')
-        .text('tool', operation.tool, '\u0000')
+        // An operation that allows a standing permission calls no tool (R-07).
+        .text('tool', operation.tool, operation.allows ? '' : '\u0000')
+        .present('allows', operation.allows
+        ? dumpPapStanding(operation.allows)
+        : undefined)
         .text('summary', operation.summary, '\u0000')
         .value('user_approval_required', operation.userApprovalRequired, true).data)).data).data;
 }

package/lib/protocols/mcp/client.d.ts

@@ -0,0 +1,73 @@
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import type { CallToolResult, GetPromptResult, ReadResourceResult, Tool } from '@modelcontextprotocol/sdk/types.js';
+/** A listed tool as a client reads it. */
+export interface McpToolReading {
+    name: string;
+    title: string | null;
+    description: string | null;
+    /** Its parameters' names, sorted. */
+    parameters: string[];
+    /** Those it requires, sorted. */
+    required: string[];
+    /** Whether it says an output schema (answers structured content). */
+    structured: boolean;
+    readOnly: boolean;
+    destructive: boolean;
+    idempotent: boolean;
+    openWorld: boolean;
+}
+/** A tool's answer as a client reads it. */
+export interface McpCallReading {
+    isError: boolean;
+    /** Its text parts, joined by a newline. */
+    text: string;
+    structured: Record<string, unknown> | null;
+}
+/** A text resource's contents as a client reads them. */
+export interface McpResourceReading {
+    uri: string;
+    mimeType: string | null;
+    text: string;
+}
+/** A prompt's message as a client reads it. */
+export interface McpPromptReading {
+    role: 'user' | 'assistant';
+    text: string;
+}
+/** A listed tool: its parameters, whether it answers structured, its hints. */
+export declare function toolReading(tool: Tool): McpToolReading;
+/** A tool's answer: refused or not, its text parts joined, its structured content. */
+export declare function callReading(result: CallToolResult): McpCallReading;
+/** A resource's text contents; a binary one is refused, never decoded here. */
+export declare function resourceReading(result: ReadResourceResult): McpResourceReading[];
+/** A prompt's messages as text; a message of another kind is refused. */
+export declare function promptReading(result: GetPromptResult): McpPromptReading[];
+/** Where an `McpClient` connects: a Streamable HTTP endpoint, or any transport. */
+export type McpServerAddress = {
+    url: string;
+    /** Headers sent with every request (a bearer, for one). */
+    headers?: Record<string, string>;
+} | {
+    transport: Transport;
+};
+/**
+ * An MCP client: connects, lists and calls tools, reads resources, gets
+ * prompts, and answers each as the readings above. The SDK's `Client` does
+ * the protocol (the initialize handshake, the version negotiated, a
+ * structured answer checked against the tool's output schema).
+ */
+export declare class McpClient {
+    private readonly client;
+    private readonly agreed;
+    private constructor();
+    /** Connected to `server`, said to it as `name` at `version`. */
+    static connect(server: McpServerAddress, name?: string, version?: string): Promise<McpClient>;
+    /** The protocol version agreed with the server. */
+    get protocolVersion(): string;
+    /** Every tool the server lists, through its pages. */
+    listTools(): Promise<McpToolReading[]>;
+    callTool(name: string, args: Record<string, unknown>): Promise<McpCallReading>;
+    readResource(uri: string): Promise<McpResourceReading[]>;
+    getPrompt(name: string, args: Record<string, string>): Promise<McpPromptReading[]>;
+    close(): Promise<void>;
+}

package/lib/protocols/mcp/client.js

@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * An MCP client in TypeScript, on the official `@modelcontextprotocol/sdk`
+ * (AGENT_PROTOCOLS PR-51, decided 2026-10-13), and what it reads from a
+ * server's answers — the twin of `agent_runtimes.protocols.mcp.reading`.
+ *
+ * The readings are the plain shape both languages agree on, held to
+ * `agent_runtimes/protocols/mcp/fixtures/session.json` by the pytest and the
+ * vitest. A tool's missing annotations are read with the specification's
+ * defaults (`readOnlyHint` false, `destructiveHint` true, `idempotentHint`
+ * false, `openWorldHint` true), so a server that says nothing is never read
+ * as harmless; `destructiveHint` means something only when the tool is not
+ * read-only, so a read-only tool is never destructive.
+ *
+ * @module protocols/mcp/client
+ */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+const sorted = (values) => [...values].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+/** A listed tool: its parameters, whether it answers structured, its hints. */
+export function toolReading(tool) {
+    const hints = tool.annotations;
+    const readOnly = hints?.readOnlyHint === true;
+    return {
+        name: tool.name,
+        title: tool.title ?? null,
+        description: tool.description ?? null,
+        parameters: sorted(Object.keys(tool.inputSchema.properties ?? {})),
+        required: sorted(tool.inputSchema.required ?? []),
+        structured: tool.outputSchema !== undefined,
+        readOnly,
+        destructive: !readOnly && hints?.destructiveHint !== false,
+        idempotent: hints?.idempotentHint === true,
+        openWorld: hints?.openWorldHint !== false,
+    };
+}
+/** A tool's answer: refused or not, its text parts joined, its structured content. */
+export function callReading(result) {
+    return {
+        isError: result.isError === true,
+        text: result.content
+            .flatMap(part => (part.type === 'text' ? [part.text] : []))
+            .join('\n'),
+        structured: result.structuredContent ?? null,
+    };
+}
+/** A resource's text contents; a binary one is refused, never decoded here. */
+export function resourceReading(result) {
+    return result.contents.map(part => {
+        if (!('text' in part) || typeof part.text !== 'string') {
+            throw new Error(`${part.uri} is not text.`);
+        }
+        return { uri: part.uri, mimeType: part.mimeType ?? null, text: part.text };
+    });
+}
+/** A prompt's messages as text; a message of another kind is refused. */
+export function promptReading(result) {
+    return result.messages.map(message => {
+        if (message.content.type !== 'text') {
+            throw new Error(`A ${message.role} message is not text.`);
+        }
+        return { role: message.role, text: message.content.text };
+    });
+}
+/**
+ * An MCP client: connects, lists and calls tools, reads resources, gets
+ * prompts, and answers each as the readings above. The SDK's `Client` does
+ * the protocol (the initialize handshake, the version negotiated, a
+ * structured answer checked against the tool's output schema).
+ */
+export class McpClient {
+    client;
+    agreed;
+    constructor(client, agreed) {
+        this.client = client;
+        this.agreed = agreed;
+    }
+    /** Connected to `server`, said to it as `name` at `version`. */
+    static async connect(server, name = 'agent-runtimes', version = '1.0.0') {
+        const transport = 'transport' in server
+            ? server.transport
+            : new StreamableHTTPClientTransport(new URL(server.url), {
+                requestInit: server.headers
+                    ? { headers: server.headers }
+                    : undefined,
+            });
+        // The SDK hands the version agreed at initialize to the transport alone.
+        let agreed;
+        const setProtocolVersion = transport.setProtocolVersion?.bind(transport);
+        transport.setProtocolVersion = (protocolVersion) => {
+            agreed = protocolVersion;
+            setProtocolVersion?.(protocolVersion);
+        };
+        const client = new Client({ name, version });
+        await client.connect(transport);
+        return new McpClient(client, () => agreed);
+    }
+    /** The protocol version agreed with the server. */
+    get protocolVersion() {
+        const version = this.agreed();
+        if (!version) {
+            throw new Error('The MCP client is not connected.');
+        }
+        return version;
+    }
+    /** Every tool the server lists, through its pages. */
+    async listTools() {
+        const tools = [];
+        let cursor;
+        do {
+            const page = await this.client.listTools(cursor ? { cursor } : {});
+            tools.push(...page.tools.map(toolReading));
+            cursor = page.nextCursor;
+        } while (cursor);
+        return tools;
+    }
+    async callTool(name, args) {
+        const result = await this.client.callTool({ name, arguments: args });
+        if (!Array.isArray(result.content)) {
+            throw new Error(`${name} answered in the form before MCP 2024-11-05.`);
+        }
+        return callReading(result);
+    }
+    async readResource(uri) {
+        return resourceReading(await this.client.readResource({ uri }));
+    }
+    async getPrompt(name, args) {
+        return promptReading(await this.client.getPrompt({ name, arguments: args }));
+    }
+    async close() {
+        await this.client.close();
+    }
+}

package/lib/protocols/mcp/index.d.ts

@@ -2,3 +2,4 @@ export declare const MCP_PLUGIN = "agent-runtimes.protocols.mcp";
 /** The MCP specification version of the `@modelcontextprotocol/sdk` installed (1.32: `LATEST_PROTOCOL_VERSION`); Python's `mcp` 2.1 speaks 2026-07-28. */
 export declare const MCP_SPECIFICATION_VERSION = "2025-11-25";
 export declare const McpPlugin: import("@datalayer/reactor").ReactorPlugin<Record<string, never>, unknown, unknown>;
+export * from './client';

package/lib/protocols/mcp/index.js

@@ -7,7 +7,8 @@
  * declares no point yet: MCP's optional capabilities and extensions become
  * `mcp.extension.<name>` points when the MCP client and server read them
  * from contributions (AGENT_PROTOCOLS PR-01). The twin of
- * `agent_runtimes.protocols.mcp`.
+ * `agent_runtimes.protocols.mcp`. Its client, on the official
+ * `@modelcontextprotocol/sdk`, is `./client` (PR-51).
  *
  * @module protocols/mcp
  */
@@ -36,3 +37,4 @@ export const McpPlugin = definePlugin({
         }, { id: 'mcp', order: DEFAULT_ORDER }),
     ],
 });
+export * from './client';

package/lib/protocols/web-bot-auth/tap.d.ts

@@ -0,0 +1,56 @@
+import { type HttpSigner, type NonceStore } from './index';
+/** Draft until Visa confirms it. */
+export declare const TAP_STATUS = "draft";
+/** Where the profile was read, 2026-10-13. */
+export declare const TAP_SOURCES: readonly ["https://developer.visa.com/capabilities/trusted-agent-protocol/trusted-agent-protocol-specifications", "https://developer.visa.com/capabilities/trusted-agent-protocol/overview", "https://github.com/visa/trusted-agent-protocol"];
+/** Visa's key directory, as its page says it. */
+export declare const VISA_JWKS = "https://mcp.visa.com/.well-known/jwks";
+export declare const TAP_BROWSE_TAG = "agent-browser-auth";
+export declare const TAP_PAY_TAG = "agent-payer-auth";
+export type TapIntent = 'browse' | 'pay';
+export declare const TAP_TAGS: Record<TapIntent, string>;
+export declare const TAP_REQUIRED_COMPONENTS: readonly ["@authority", "@path"];
+export declare const TAP_REQUIRED_PARAMS: readonly ["created", "keyid", "alg", "expires", "nonce", "tag"];
+/** `alg` as Visa writes it. */
+export declare const TAP_ALG = "Ed25519";
+/** The longest window, and how long a nonce is remembered. */
+export declare const TAP_MAX_WINDOW_SECONDS: number;
+export interface TapSignOptions {
+    intent: TapIntent;
+    label?: string;
+    /** Covered: at least `@authority` and `@path` (the default). */
+    components?: string[];
+    /** Unix seconds; now by default. */
+    created?: number;
+    /** Seconds, at most 8 minutes (the default). */
+    lifetime?: number;
+    nonce?: string;
+}
+export interface TapSignedHeaders {
+    'Signature-Input': string;
+    Signature: string;
+}
+/** What verifying a TAP signature found; `reason` when it does not hold. */
+export interface TapVerification {
+    verified: boolean;
+    reason?: string;
+    intent?: TapIntent;
+    keyid?: string;
+    nonce?: string;
+}
+/** Sign one request as a TAP agent browsing or paying, under an Ed25519 key. */
+export declare function signTapRequest(request: {
+    method: string;
+    url: string;
+}, signer: HttpSigner, options: TapSignOptions): Promise<TapSignedHeaders>;
+/**
+ * Verify the TAP signature of one request against Ed25519 keys known by
+ * `keyid` (Visa's directory, or a registry's). A request with no TAP tag is
+ * no trusted agent's; the merchant decides what to do with it.
+ */
+export declare function verifyTapRequest(request: Request, keys: Map<string, JsonWebKey>, options: {
+    nonceStore: NonceStore;
+    now?: number;
+}): Promise<TapVerification>;
+/** The `keyid` of an Ed25519 public JWK, as a TAP key list is indexed when it says none. */
+export declare function tapKeys(jwks: JsonWebKey[]): Promise<Map<string, JsonWebKey>>;

package/lib/protocols/web-bot-auth/tap.js

@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Visa's Trusted Agent Protocol as a profile over Web Bot Auth
+ * (AGENT_PROTOCOLS PR-24) — the twin of
+ * `agent_runtimes.protocols.web_bot_auth.tap`.
+ *
+ * **Draft.** Built on 2026-10-13 from Visa's public *Merchant
+ * Specifications* and its reference repository (`TAP_SOURCES`), not
+ * confirmed by Visa: the product says it *arriving* until it is. Visa
+ * publishes no test vector; `fixtures/tap.json` is one computed in Python
+ * and reproduced here byte for byte.
+ *
+ * The agent-recognition signature: `Signature-Input` and `Signature` alone
+ * (Visa names no `Signature-Agent`, so keys are handed in by `keyid`),
+ * covering at least `@authority` and `@path`, with `created`, `keyid`,
+ * `alg="Ed25519"`, `expires`, `nonce` and `tag` — `agent-browser-auth` to
+ * browse, `agent-payer-auth` to pay —, `created` and `expires` at most 8
+ * minutes apart, a nonce seen in the last 8 minutes a replay. Signed and
+ * verified with Cloudflare's `http-message-sig`, the RFC 9421 library under
+ * `web-bot-auth`.
+ *
+ * @module protocols/web-bot-auth/tap
+ */
+import { createSignature, verifySignature, webcrypto } from 'http-message-sig';
+import { generateNonce, jwkThumbprint, } from './index';
+/** Draft until Visa confirms it. */
+export const TAP_STATUS = 'draft';
+/** Where the profile was read, 2026-10-13. */
+export const TAP_SOURCES = [
+    'https://developer.visa.com/capabilities/trusted-agent-protocol/trusted-agent-protocol-specifications',
+    'https://developer.visa.com/capabilities/trusted-agent-protocol/overview',
+    'https://github.com/visa/trusted-agent-protocol',
+];
+/** Visa's key directory, as its page says it. */
+export const VISA_JWKS = 'https://mcp.visa.com/.well-known/jwks';
+export const TAP_BROWSE_TAG = 'agent-browser-auth';
+export const TAP_PAY_TAG = 'agent-payer-auth';
+export const TAP_TAGS = {
+    browse: TAP_BROWSE_TAG,
+    pay: TAP_PAY_TAG,
+};
+export const TAP_REQUIRED_COMPONENTS = ['@authority', '@path'];
+export const TAP_REQUIRED_PARAMS = [
+    'created',
+    'keyid',
+    'alg',
+    'expires',
+    'nonce',
+    'tag',
+];
+/** `alg` as Visa writes it. */
+export const TAP_ALG = 'Ed25519';
+/** The longest window, and how long a nonce is remembered. */
+export const TAP_MAX_WINDOW_SECONDS = 8 * 60;
+/** Sign one request as a TAP agent browsing or paying, under an Ed25519 key. */
+export async function signTapRequest(request, signer, options) {
+    if (signer.algorithm !== 'ed25519') {
+        throw new Error('a TAP signature is Ed25519');
+    }
+    const components = options.components ?? [...TAP_REQUIRED_COMPONENTS];
+    const missing = TAP_REQUIRED_COMPONENTS.filter(name => !components.includes(name));
+    if (missing.length) {
+        throw new Error(`a TAP signature covers ${missing.join(', ')}`);
+    }
+    const lifetime = options.lifetime ?? TAP_MAX_WINDOW_SECONDS;
+    if (!(lifetime > 0 && lifetime <= TAP_MAX_WINDOW_SECONDS)) {
+        throw new Error(`a TAP signature lives at most ${TAP_MAX_WINDOW_SECONDS}s (8 minutes)`);
+    }
+    const created = options.created ?? Math.floor(Date.now() / 1000);
+    const fields = await createSignature({
+        kind: 'request',
+        method: request.method,
+        targetUri: request.url,
+        fields: [],
+    }, {
+        label: options.label ?? 'sig2',
+        components,
+        parameters: {
+            created,
+            keyid: signer.keyid,
+            alg: TAP_ALG,
+            expires: created + lifetime,
+            nonce: options.nonce ?? generateNonce(),
+            tag: TAP_TAGS[options.intent],
+        },
+        signer: { algorithm: TAP_ALG, sign: data => signer.sign(data) },
+    });
+    return {
+        'Signature-Input': fields.signatureInput,
+        Signature: fields.signature,
+    };
+}
+const TAP_LABEL = /(?:^|,)\s*([a-z*][a-z0-9_.*-]*)=\([^)]*\)[^,]*;tag="(?:agent-browser-auth|agent-payer-auth)"/g;
+/**
+ * Verify the TAP signature of one request against Ed25519 keys known by
+ * `keyid` (Visa's directory, or a registry's). A request with no TAP tag is
+ * no trusted agent's; the merchant decides what to do with it.
+ */
+export async function verifyTapRequest(request, keys, options) {
+    const input = request.headers.get('signature-input');
+    if (!input || !request.headers.get('signature')) {
+        return { verified: false, reason: 'the request is not signed' };
+    }
+    const labels = [...input.matchAll(TAP_LABEL)].map(match => match[1]);
+    if (labels.length === 0) {
+        return { verified: false, reason: 'no signature carries a TAP tag' };
+    }
+    if (labels.length > 1) {
+        return {
+            verified: false,
+            reason: 'more than one signature carries a TAP tag',
+        };
+    }
+    const now = options.now ?? Math.floor(Date.now() / 1000);
+    let keyid;
+    let unknownKey = false;
+    try {
+        const verified = await verifySignature(request, {
+            label: labels[0],
+            policy: {
+                algorithms: [TAP_ALG],
+                requiredComponents: [...TAP_REQUIRED_COMPONENTS],
+                requiredParameters: [...TAP_REQUIRED_PARAMS],
+                now,
+                validate: signature => {
+                    const { created, expires, tag } = signature.parameters;
+                    return ((tag === TAP_BROWSE_TAG || tag === TAP_PAY_TAG) &&
+                        created !== undefined &&
+                        expires !== undefined &&
+                        expires - created <= TAP_MAX_WINDOW_SECONDS &&
+                        now < expires);
+                },
+            },
+            resolveVerifier: async (candidate) => {
+                keyid = candidate.parameters.keyid;
+                const jwk = keyid === undefined ? undefined : keys.get(keyid);
+                if (!jwk || jwk.kty !== 'OKP' || jwk.crv !== 'Ed25519') {
+                    unknownKey = true;
+                    throw new Error('the key is not a known Ed25519 key');
+                }
+                const key = await crypto.subtle.importKey('jwk', jwk, { name: 'Ed25519' }, false, ['verify']);
+                const verifier = webcrypto.verifier(key);
+                return {
+                    algorithm: TAP_ALG,
+                    verify: (data, signature) => verifier.verify(data, signature),
+                };
+            },
+        });
+        const { tag, nonce } = verified.parameters;
+        if (nonce === undefined || keyid === undefined) {
+            return { verified: false, reason: 'the signature has no nonce', keyid };
+        }
+        const fresh = await options.nonceStore.checkAndRecord(`tap ${keyid}`, nonce, new Date((now + TAP_MAX_WINDOW_SECONDS) * 1000));
+        if (!fresh) {
+            return { verified: false, reason: 'the nonce was seen before', keyid };
+        }
+        return {
+            verified: true,
+            intent: tag === TAP_PAY_TAG ? 'pay' : 'browse',
+            keyid,
+            nonce,
+        };
+    }
+    catch (error) {
+        return {
+            verified: false,
+            reason: unknownKey
+                ? 'the key is not a known Ed25519 key'
+                : error.message,
+            keyid,
+        };
+    }
+}
+/** The `keyid` of an Ed25519 public JWK, as a TAP key list is indexed when it says none. */
+export async function tapKeys(jwks) {
+    const keys = new Map();
+    for (const jwk of jwks) {
+        const kid = jwk.kid;
+        keys.set(kid ?? (await jwkThumbprint(jwk)), jwk);
+    }
+    return keys;
+}

package/lib/specs/apps.js

@@ -4444,13 +4444,15 @@ export const SHOPPING_DESK_APP_0_0_1 = {
             },
         ],
         verified: {
-            live: [],
+            live: [
+                "Drilled on r1 on 13 October 2026 against the hosted test merchants, as its Preview's runtime reaches the gateway's ucp and acp toolsets: at Example Store (store.examples.datalayer.run) a search, a checkout filled, the exact purchase asked of the person, approved on Waiting for you, bought once and refused a second time, its order read; at Example Outfitters (outfitters.examples.datalayer.run) the same checkout over ACP. Test merchants only: paid with a test instrument.",
+            ],
             recorded: [
                 "The purchase is the developers' UCP example (examples/protocols/ucp/shopping.py) against its local test store, Example Store, run in its own tests.",
                 "The checkout at Example Outfitters is the developers' ACP example (examples/protocols/agentic_commerce/checkout.py), run in its own tests.",
             ],
             unverified: [
-                'It has not run in the Studio against the hosted Example Store and Example Outfitters (store.examples.datalayer.run, outfitters.examples.datalayer.run) from this example yet.',
+                "A model's turns in the Studio's Preview were not watched in that drill (no dev server ran).",
             ],
         },
     },
@@ -4480,8 +4482,8 @@ export const SHOPPING_DESK_APP_0_0_1 = {
         documents: [],
         alternatives: [],
     },
-    enabled: false,
-    unavailable_because: 'It buys at shops for you over UCP and ACP, and the services that reach a shop for you are not shipped yet.',
+    enabled: true,
+    unavailable_because: '',
     tags: ['example', 'companies'],
     icon: 'apps',
     emoji: '🛍️',
@@ -5281,12 +5283,15 @@ export const TRAVEL_DESK_APP_0_0_1 = {
             },
         ],
         verified: {
-            live: [],
+            live: [
+                "Drilled on r1 on 13 October 2026 against the hosted Example Air (air.examples.datalayer.run), as its Preview's runtime reaches the gateway's pact toolset: its card read, asked as the application alone, the person's sign-in by device code approved at the Brand, then asked for the person and answered from the booking (bookings:read used, its receipt verified).",
+            ],
             recorded: [
                 "The journey is the developers' PACT example (examples/protocols/pact/personal_agent.py) against its local Provider, Example Air, run in its own tests (version 1.3.112).",
             ],
             unverified: [
-                'It has not run in the Studio against the hosted Example Air (air.examples.datalayer.run) from this example yet; the hosted Example Air keeps registrations in memory, so an application is registered there again after each restart.',
+                'The hosted Example Air keeps registrations in memory: an application is registered there (POST /example/register, its issuer and keys) again after each restart.',
+                "A model's turns in the Studio's Preview were not watched in that drill (no dev server ran); the step-up to bookings:change was not drilled live.",
             ],
         },
     },
@@ -5316,8 +5321,8 @@ export const TRAVEL_DESK_APP_0_0_1 = {
         documents: [],
         alternatives: [],
     },
-    enabled: false,
-    unavailable_because: 'It asks an airline for you over PACT, and the services that reach a business for you are not shipped yet.',
+    enabled: true,
+    unavailable_because: '',
     tags: ['example', 'companies'],
     icon: 'apps',
     emoji: '✈️',
@@ -8338,12 +8343,15 @@ export const APP_SOURCES = {
                 },
             ],
             verified: {
+                live: [
+                    "Drilled on r1 on 13 October 2026 against the hosted test merchants, as its Preview's runtime reaches the gateway's ucp and acp toolsets: at Example Store (store.examples.datalayer.run) a search, a checkout filled, the exact purchase asked of the person, approved on Waiting for you, bought once and refused a second time, its order read; at Example Outfitters (outfitters.examples.datalayer.run) the same checkout over ACP. Test merchants only: paid with a test instrument.",
+                ],
                 recorded: [
                     "The purchase is the developers' UCP example (examples/protocols/ucp/shopping.py) against its local test store, Example Store, run in its own tests.",
                     "The checkout at Example Outfitters is the developers' ACP example (examples/protocols/agentic_commerce/checkout.py), run in its own tests.",
                 ],
                 unverified: [
-                    'It has not run in the Studio against the hosted Example Store and Example Outfitters (store.examples.datalayer.run, outfitters.examples.datalayer.run) from this example yet.',
+                    "A model's turns in the Studio's Preview were not watched in that drill (no dev server ran).",
                 ],
             },
         },
@@ -8354,8 +8362,6 @@ export const APP_SOURCES = {
         deployment: {
             hosted: {},
         },
-        enabled: false,
-        unavailable_because: 'It buys at shops for you over UCP and ACP, and the services that reach a shop for you are not shipped yet.',
         tags: ['example', 'companies'],
         emoji: '🛍️',
     },
@@ -8883,11 +8889,15 @@ export const APP_SOURCES = {
                 },
             ],
             verified: {
+                live: [
+                    "Drilled on r1 on 13 October 2026 against the hosted Example Air (air.examples.datalayer.run), as its Preview's runtime reaches the gateway's pact toolset: its card read, asked as the application alone, the person's sign-in by device code approved at the Brand, then asked for the person and answered from the booking (bookings:read used, its receipt verified).",
+                ],
                 recorded: [
                     "The journey is the developers' PACT example (examples/protocols/pact/personal_agent.py) against its local Provider, Example Air, run in its own tests (version 1.3.112).",
                 ],
                 unverified: [
-                    'It has not run in the Studio against the hosted Example Air (air.examples.datalayer.run) from this example yet; the hosted Example Air keeps registrations in memory, so an application is registered there again after each restart.',
+                    'The hosted Example Air keeps registrations in memory: an application is registered there (POST /example/register, its issuer and keys) again after each restart.',
+                    "A model's turns in the Studio's Preview were not watched in that drill (no dev server ran); the step-up to bookings:change was not drilled live.",
                 ],
             },
         },
@@ -8898,8 +8908,6 @@ export const APP_SOURCES = {
         deployment: {
             hosted: {},
         },
-        enabled: false,
-        unavailable_because: 'It asks an airline for you over PACT, and the services that reach a business for you are not shipped yet.',
         tags: ['example', 'companies'],
         emoji: '✈️',
     },