@noodleseed/one 0.149.0 → 0.151.0

package/node_modules/@noodle-borg/assistant-gateway/dist/embed-operator-view.d.ts

@@ -15,10 +15,18 @@ export interface AssistantEmbedOperatorView {
     readonly capabilities: readonly string[];
     readonly turnsPerDay: number;
     readonly mintsPerDay: number;
+    /**
+     * What a browser agent may spend on this surface through the WebMCP bridge. Reported beside the
+     * turn caps because "is my budget about to run out" is the same question, and a bridge call spends
+     * neither a turn nor a mint — an operator reading only those two would see a quiet day.
+     */
+    readonly bridgeCallsPerSession: number;
+    readonly bridgeCallsPerDay: number;
     /** True when the caps are the deployment defaults rather than something an operator chose. */
     readonly budgetIsDefault: boolean;
     readonly turnsToday: number;
     readonly mintsToday: number;
+    readonly bridgeCallsToday: number;
     readonly createdAt: string;
     /**
      * Present only when Noodle is funding this surface's model. It exists so an operator can tell

package/node_modules/@noodle-borg/assistant-gateway/dist/embed-operator-view.js

@@ -42,9 +42,17 @@ export async function assistantEmbedOperatorView(input) {
         capabilities: surface?.capabilities.map((entry) => entry.name) ?? [],
         turnsPerDay: envelope.turnsPerDay,
         mintsPerDay: envelope.mintsPerDay,
-        budgetIsDefault: record.turnsPerDay === undefined && record.mintsPerDay === undefined,
+        bridgeCallsPerSession: envelope.bridgeToolCallsPerSession,
+        bridgeCallsPerDay: envelope.bridgeToolCallsPerDay,
+        budgetIsDefault: record.turnsPerDay === undefined &&
+            record.mintsPerDay === undefined &&
+            record.bridgeToolCallsPerSession === undefined &&
+            record.bridgeToolCallsPerDay === undefined,
         turnsToday: await input.peek(`turns:${record.embedId}`),
         mintsToday: await input.peek(`mints:${record.embedId}`),
+        // Keyed as `admitBridgeToolCall` writes it, so the number an operator reads is the one the
+        // gate consumed rather than a parallel count that can drift from it.
+        bridgeCallsToday: await input.peek(`bridge:${record.embedId}`),
         createdAt: record.createdAt.toISOString(),
         ...(spend === undefined
             ? {}

package/node_modules/@noodle-borg/assistant-gateway/dist/embed-store.d.ts

@@ -38,6 +38,14 @@ export interface PublicEmbedRecord {
      */
     readonly mintsPerAddressHour?: number;
     readonly turnsPerAddressHour?: number;
+    /**
+     * Operator overrides for this surface's WebMCP bridge budgets. The shipped defaults are
+     * proportionate rather than measured (ADR 0220), so an operator who can see their own agent
+     * traffic needs to move them without waiting for a release. `0` is the kill switch here too,
+     * though zeroing `turnsPerDay` already stops bridge calls with it.
+     */
+    readonly bridgeToolCallsPerSession?: number;
+    readonly bridgeToolCallsPerDay?: number;
 }
 /** Project the non-secret embed coordinate onto the shared assistant tenant shape. */
 export declare function publicEmbedTenant(embed: PublicEmbedRecord): TenantRef;
@@ -47,6 +55,8 @@ export interface PublicEmbedBudget {
     readonly mintsPerDay?: number;
     readonly mintsPerAddressHour?: number;
     readonly turnsPerAddressHour?: number;
+    readonly bridgeToolCallsPerSession?: number;
+    readonly bridgeToolCallsPerDay?: number;
 }
 export interface PublicEmbedStore {
     /**
@@ -89,7 +99,7 @@ import type { TenantRef } from './tenant-ref.js';
  * cap may be, not about HTTP, and a second caller must not be able to reach the store with a shape
  * this would have rejected.
  */
-export type BudgetField = 'turnsPerDay' | 'mintsPerDay' | 'mintsPerAddressHour' | 'turnsPerAddressHour';
+export type BudgetField = 'turnsPerDay' | 'mintsPerDay' | 'mintsPerAddressHour' | 'turnsPerAddressHour' | 'bridgeToolCallsPerSession' | 'bridgeToolCallsPerDay';
 type BudgetValue = Partial<Record<BudgetField, number>>;
 type ParsedBudget = {
     readonly ok: true;

package/node_modules/@noodle-borg/assistant-gateway/dist/embed-store.js

@@ -28,6 +28,8 @@ const BUDGET_FIELDS = [
     'mintsPerDay',
     'mintsPerAddressHour',
     'turnsPerAddressHour',
+    'bridgeToolCallsPerSession',
+    'bridgeToolCallsPerDay',
 ];
 export function parsePublicEmbedBudget(body) {
     // A JSON body of `null` is an object to `typeof` and reads as a crash to a property access, so it

package/node_modules/@noodle-borg/assistant-gateway/dist/in-memory-embed-store.js

@@ -45,6 +45,12 @@ export class InMemoryPublicEmbedStore {
             ...(budget.turnsPerAddressHour !== undefined
                 ? { turnsPerAddressHour: budget.turnsPerAddressHour }
                 : {}),
+            ...(budget.bridgeToolCallsPerSession !== undefined
+                ? { bridgeToolCallsPerSession: budget.bridgeToolCallsPerSession }
+                : {}),
+            ...(budget.bridgeToolCallsPerDay !== undefined
+                ? { bridgeToolCallsPerDay: budget.bridgeToolCallsPerDay }
+                : {}),
         };
         this.#byId.set(embedId, updated);
         return updated;

package/node_modules/@noodle-borg/assistant-gateway/dist/model-error.js

@@ -52,6 +52,12 @@ export function modelFetchError(cause) {
 export function modelResponseError(cause) {
     return new AssistantModelError('model_response_invalid', { retryable: false, cause });
 }
+export function managedSponsorshipExhausted() {
+    return new AssistantModelError('daily_turn_budget_exhausted', { retryable: false });
+}
+export function managedSponsorshipUnavailable(cause) {
+    return new AssistantModelError('model_unavailable', { retryable: true, cause });
+}
 function isTimeoutError(error) {
     return error instanceof Error && error.name === 'TimeoutError';
 }

package/node_modules/@noodle-borg/assistant-gateway/dist/model-request.d.ts

@@ -22,6 +22,17 @@ interface ResolvedAssistantModelBase {
     readonly baseUrl: string;
     readonly model: string;
     readonly requestPolicy?: AssistantModelRequestPolicy;
+    /**
+     * Private hosted sponsorship admission. It is deliberately attached to the resolved binding so
+     * every path that reaches provider I/O passes the same gate, including suggestions, interaction
+     * narration, authenticated assistants, and doctor probes.
+     */
+    readonly sponsorship?: {
+        readonly accountKey: string;
+        readonly allowance: number;
+        readonly units: number;
+        admit(): Promise<boolean>;
+    };
     readonly publicAdmission?: {
         readonly defaults: {
             readonly turnsPerSession: number;

package/node_modules/@noodle-borg/assistant-gateway/dist/model-request.js

@@ -1,4 +1,4 @@
-import { AssistantModelError, modelFetchError, modelHttpError, modelRequestError, modelResponseError, } from './model-error.js';
+import { AssistantModelError, managedSponsorshipExhausted, managedSponsorshipUnavailable, modelFetchError, modelHttpError, modelRequestError, modelResponseError, } from './model-error.js';
 import { readResponsesCompletion, responsesInput, responsesTools } from './model-responses.js';
 import { readModelCompletion } from './model-stream.js';
 export async function requestModelCompletion(input) {
@@ -34,6 +34,7 @@ export async function requestModelCompletion(input) {
     if (maxRequestBytes !== undefined && requestBytes > maxRequestBytes) {
         throw modelRequestError('model request too large');
     }
+    await admitSponsorship(binding);
     const bearerToken = binding.apiKey ?? (await binding.bearerToken());
     if (!/^[^\s]{1,8192}$/.test(bearerToken)) {
         throw modelRequestError('invalid model bearer token');
@@ -63,4 +64,24 @@ export async function requestModelCompletion(input) {
         throw modelResponseError(error);
     }
 }
+/** One resolved binding represents one bounded model operation, even when its agent loop has steps. */
+const sponsorshipAdmissions = new WeakMap();
+async function admitSponsorship(binding) {
+    if (binding.source !== 'noodle-managed' || binding.sponsorship === undefined)
+        return;
+    let admission = sponsorshipAdmissions.get(binding);
+    if (admission === undefined) {
+        admission = binding.sponsorship.admit();
+        sponsorshipAdmissions.set(binding, admission);
+    }
+    let allowed;
+    try {
+        allowed = await admission;
+    }
+    catch (error) {
+        throw managedSponsorshipUnavailable(error);
+    }
+    if (!allowed)
+        throw managedSponsorshipExhausted();
+}
 //# sourceMappingURL=model-request.js.map

package/node_modules/@noodle-borg/assistant-gateway/dist/portable.d.ts

@@ -1,4 +1,5 @@
 /** Assistant gateway contracts and in-memory adapters safe for the published CLI runtime. */
+export * from './app-tool-call.js';
 export * from './artifact-projection.js';
 export * from './assistant-appearance.js';
 export * from './assistant-appearance-store.js';

package/node_modules/@noodle-borg/assistant-gateway/dist/portable.js

@@ -1,4 +1,5 @@
 /** Assistant gateway contracts and in-memory adapters safe for the published CLI runtime. */
+export * from './app-tool-call.js';
 export * from './artifact-projection.js';
 export * from './assistant-appearance.js';
 export * from './assistant-appearance-store.js';

package/node_modules/@noodle-borg/assistant-gateway/dist/surface-budget.d.ts

@@ -31,5 +31,5 @@ export interface SurfaceBudgetBounds {
  * operator any more than by app code, so an over-eager `--turns-per-day 999999999` degrades to the
  * ceiling instead of becoming the ceiling. Zero survives clamping and is the kill switch.
  */
-export declare function surfaceEnvelope(base: AdmissionEnvelope, embed: Pick<PublicEmbedRecord, 'turnsPerDay' | 'mintsPerDay' | 'mintsPerAddressHour' | 'turnsPerAddressHour'>, bounds?: SurfaceBudgetBounds): AdmissionEnvelope;
+export declare function surfaceEnvelope(base: AdmissionEnvelope, embed: Pick<PublicEmbedRecord, 'turnsPerDay' | 'mintsPerDay' | 'mintsPerAddressHour' | 'turnsPerAddressHour' | 'bridgeToolCallsPerSession' | 'bridgeToolCallsPerDay'>, bounds?: SurfaceBudgetBounds): AdmissionEnvelope;
 //# sourceMappingURL=surface-budget.d.ts.map

package/node_modules/@noodle-borg/assistant-gateway/dist/surface-budget.js

@@ -31,6 +31,16 @@ export function surfaceEnvelope(base, embed, bounds) {
                 turnsPerAddressHour: Math.min(embed.turnsPerAddressHour, effectiveBase.turnsPerAddressHour),
             }
             : {}),
+        // The bridge bounds are the operator's to spend in either direction, like the daily caps and
+        // unlike the per-address ones: they govern this surface's own agent traffic against its own
+        // connectors, not a bound shared with everyone behind one address. `clamp` still holds them
+        // under the structural maximum.
+        ...(embed.bridgeToolCallsPerSession !== undefined
+            ? { bridgeToolCallsPerSession: embed.bridgeToolCallsPerSession }
+            : {}),
+        ...(embed.bridgeToolCallsPerDay !== undefined
+            ? { bridgeToolCallsPerDay: embed.bridgeToolCallsPerDay }
+            : {}),
     });
     if (bounds === undefined)
         return requested;

package/node_modules/@noodle-borg/assistant-gateway/package.json

@@ -41,7 +41,7 @@
     "@noodle-borg/module": "0.0.0",
     "@noodle-borg/protocol": "0.0.0",
     "@noodle-borg/runtime": "0.0.0",
-    "@noodleseed/assistant": "1.29.0",
+    "@noodleseed/assistant": "1.31.0",
     "zod": "^4.4.3"
   },
   "devDependencies": {

package/node_modules/@noodle-borg/authoring/dist/assistant.d.ts

@@ -168,12 +168,20 @@ export interface AuthenticatedWebsiteAccess {
     /** Allowlist of verified session claims; undeclared claims are dropped at session exchange. */
     readonly sessionClaims?: Readonly<Record<string, SessionClaimDeclaration>>;
     readonly capabilities?: readonly CapabilityRef[];
+    /** @see AuthenticatedWebsiteInput.webmcp */
+    readonly webmcp?: {
+        readonly enabled?: boolean;
+    };
 }
 export interface PublicWebsiteAccess {
     readonly mode: 'public' | 'mixed';
     readonly origins: readonly string[];
     readonly capabilities: readonly CapabilityRef[];
     readonly instructions?: string;
+    /** @see AuthenticatedWebsiteInput.webmcp */
+    readonly webmcp?: {
+        readonly enabled?: boolean;
+    };
 }
 export type AssistantAccess = AuthenticatedWebsiteAccess | PublicWebsiteAccess;
 export interface AuthenticatedWebsiteInput {
@@ -183,6 +191,19 @@ export interface AuthenticatedWebsiteInput {
     readonly sessionClaims?: Readonly<Record<string, SessionClaimDeclaration>>;
     /** Optional narrowing; omitted means the signed-in surface projects the whole server. */
     readonly capabilities?: readonly CapabilityRef[];
+    /**
+     * Override this assistant's WebMCP opt-in for sessions minted on this surface, in either
+     * direction (ADR 0220, amended). Omitted inherits the assistant's value.
+     *
+     * It governs **discovery**: whether the embed registers this session's tools with
+     * `document.modelContext`, and so whether a browser agent learns they exist. It is not a second
+     * authorization boundary — every call the bridge makes already carries exactly this session's
+     * authority. A deployment serving a marketing page and a signed-in app usually has two honest
+     * answers, which one switch cannot express.
+     */
+    readonly webmcp?: {
+        readonly enabled?: boolean;
+    };
 }
 export interface PublicWebsiteInput {
     readonly origins: readonly (string | ConfigRef)[];
@@ -201,6 +222,10 @@ export interface PublicWebsiteInput {
      * never operates one — and its backend completes the exchange.
      */
     readonly signIn?: boolean;
+    /** @see AuthenticatedWebsiteInput.webmcp */
+    readonly webmcp?: {
+        readonly enabled?: boolean;
+    };
 }
 export declare function authenticatedWebsite(input: AuthenticatedWebsiteInput): AuthenticatedWebsiteAccess;
 export declare function publicWebsite(input: PublicWebsiteInput): PublicWebsiteAccess;
@@ -213,8 +238,7 @@ export interface EmbeddedAssistantOptions extends AssistantUiOptions {
      * page's WebMCP API. Off unless set. Calls carry exactly the embed session's authority and take the
      * same authorization, limits, confirmation, and audit path as the assistant's own — see ADR 0220.
      *
-     * Deployment-wide on purpose: it decides which callers may reach the server's tools, which is
-     * surface authority rather than presentation, so it is not refinable per surface.
+     * The default for every surface, which any surface may override in either direction.
      */
     readonly webmcp?: {
         readonly enabled?: boolean;
@@ -227,6 +251,10 @@ export interface AssistantSurfaceConfig {
     readonly instructions?: string;
     readonly capabilities?: readonly AssistantCapability[];
     readonly sessionClaims?: Readonly<Record<string, SessionClaimDeclaration>>;
+    /** @see AuthenticatedWebsiteInput.webmcp */
+    readonly webmcp?: {
+        readonly enabled?: boolean;
+    };
 }
 export interface EmbeddedAssistantConfig extends AssistantUiOptions {
     readonly model: AssistantModel;
@@ -238,7 +266,7 @@ export interface EmbeddedAssistantConfig extends AssistantUiOptions {
     readonly allowedOrigins: readonly string[];
     /** Mirrored from the authenticated surface, for the same reason. */
     readonly sessionClaims?: Readonly<Record<string, SessionClaimDeclaration>>;
-    /** @see EmbeddedAssistantOptions.webmcp — deployment-wide, never per surface. */
+    /** @see EmbeddedAssistantOptions.webmcp — the default each surface may override. */
     readonly webmcp?: {
         readonly enabled?: boolean;
     };

package/node_modules/@noodle-borg/authoring/dist/assistant.js

@@ -6,6 +6,7 @@ export function authenticatedWebsite(input) {
         ...(input.instructions === undefined ? {} : { instructions: input.instructions }),
         ...(input.sessionClaims ? { sessionClaims: structuredClone(input.sessionClaims) } : {}),
         ...(input.capabilities ? { capabilities: [...input.capabilities] } : {}),
+        ...(input.webmcp === undefined ? {} : { webmcp: { ...input.webmcp } }),
     };
 }
 export function publicWebsite(input) {
@@ -14,6 +15,7 @@ export function publicWebsite(input) {
         origins: serializeOrigins(input.origins, 'assistant.access.origins'),
         capabilities: [...input.capabilities],
         ...(input.instructions === undefined ? {} : { instructions: input.instructions }),
+        ...(input.webmcp === undefined ? {} : { webmcp: { ...input.webmcp } }),
     };
 }
 function serializeOrigins(origins, path) {
@@ -56,6 +58,7 @@ export function embeddedAssistant(input) {
             ...(surface.mode === 'authenticated' && surface.sessionClaims
                 ? { sessionClaims: structuredClone(surface.sessionClaims) }
                 : {}),
+            ...(surface.webmcp === undefined ? {} : { webmcp: { ...surface.webmcp } }),
         })),
         allowedOrigins: surfaces.flatMap((surface) => [...surface.origins]),
         ...structuredClone(ui),

package/node_modules/@noodle-borg/cli-catalog/dist/catalog-data-assistant.js

@@ -129,6 +129,20 @@ const BUDGET_SUBCOMMAND = subcommand({
                     value: '<count>',
                     summary: 'Model turns one source address may run per hour. The abuse bound, not fairness.',
                 }),
+                flag({
+                    ...FLAG_FIELDS,
+                    name: 'bridge-calls-per-session',
+                    type: 'string',
+                    value: '<count>',
+                    summary: 'Tool calls a browser agent may make in one session over the WebMCP bridge.',
+                }),
+                flag({
+                    ...FLAG_FIELDS,
+                    name: 'bridge-calls-per-day',
+                    type: 'string',
+                    value: '<count>',
+                    summary: 'Bridge tool calls this surface may serve per UTC day. 0 closes the bridge.',
+                }),
                 flag({
                     ...FLAG_FIELDS,
                     name: 'surface',
@@ -140,6 +154,99 @@ const BUDGET_SUBCOMMAND = subcommand({
         }),
     ],
 });
+const SPONSORSHIP_ACCOUNT_ARGUMENT = argument({
+    ...ARGUMENT_FIELDS,
+    name: 'billing-account-id',
+    type: 'string',
+    summary: 'Billing account receiving the sponsored allowance.',
+    required: true,
+});
+const SPONSORSHIP_FLAGS = [SERVICE_FLAG, AUTH_TOKEN_FLAG, JSON_FLAG];
+const SPONSORSHIP_REASON_FLAG = flag({
+    ...FLAG_FIELDS,
+    name: 'reason',
+    type: 'string',
+    value: '<text>',
+    summary: 'Auditable reason for granting or revoking sponsored usage.',
+    required: true,
+});
+const SPONSORSHIP_IDEMPOTENCY_FLAG = flag({
+    ...FLAG_FIELDS,
+    name: 'idempotency-key',
+    type: 'string',
+    value: '<key>',
+    summary: 'Stable retry key for exactly-once mutation semantics.',
+    required: true,
+});
+const SPONSORSHIP_SUBCOMMAND = subcommand({
+    ...SUBCOMMAND_FIELDS,
+    name: 'sponsorship',
+    summary: 'Inspect sponsored managed-assistant usage or operate expiring bonus grants.',
+    subcommands: [
+        subcommand({
+            ...SUBCOMMAND_FIELDS,
+            name: 'inspect',
+            summary: 'Show one billing account’s allowance, usage, reset, and grants.',
+            arguments: [SPONSORSHIP_ACCOUNT_ARGUMENT],
+            flags: [...SPONSORSHIP_FLAGS],
+            jsonOutput: { mode: 'single' },
+        }),
+        subcommand({
+            ...SUBCOMMAND_FIELDS,
+            name: 'grant',
+            summary: 'Add a bounded daily allowance until an explicit expiry.',
+            arguments: [SPONSORSHIP_ACCOUNT_ARGUMENT],
+            flags: [
+                flag({
+                    ...FLAG_FIELDS,
+                    name: 'turns-per-day',
+                    type: 'integer',
+                    value: '<count>',
+                    summary: 'Additional sponsored turns per UTC day.',
+                    required: true,
+                    constraints: { minimum: 1, maximum: 100_000 },
+                }),
+                flag({
+                    ...FLAG_FIELDS,
+                    name: 'starts-at',
+                    type: 'string',
+                    value: '<timestamp>',
+                    summary: 'Optional ISO timestamp; defaults to now.',
+                    constraints: { default: 'now' },
+                }),
+                flag({
+                    ...FLAG_FIELDS,
+                    name: 'expires-at',
+                    type: 'string',
+                    value: '<timestamp>',
+                    summary: 'Required ISO timestamp after which the grant stops applying.',
+                    required: true,
+                }),
+                SPONSORSHIP_REASON_FLAG,
+                SPONSORSHIP_IDEMPOTENCY_FLAG,
+                ...SPONSORSHIP_FLAGS,
+            ],
+            jsonOutput: { mode: 'single' },
+        }),
+        subcommand({
+            ...SUBCOMMAND_FIELDS,
+            name: 'revoke',
+            summary: 'Revoke one bonus grant without deleting its audit history.',
+            arguments: [
+                SPONSORSHIP_ACCOUNT_ARGUMENT,
+                argument({
+                    ...ARGUMENT_FIELDS,
+                    name: 'grant-id',
+                    type: 'string',
+                    summary: 'Managed-assistant sponsorship grant identifier.',
+                    required: true,
+                }),
+            ],
+            flags: [SPONSORSHIP_REASON_FLAG, SPONSORSHIP_IDEMPOTENCY_FLAG, ...SPONSORSHIP_FLAGS],
+            jsonOutput: { mode: 'single' },
+        }),
+    ],
+});
 const CLIENTS_SUBCOMMAND = subcommand({
     ...SUBCOMMAND_FIELDS,
     name: 'clients',
@@ -255,6 +362,7 @@ export const ASSISTANT_COMMAND = {
         CLIENTS_SUBCOMMAND,
         EMBEDS_SUBCOMMAND,
         BUDGET_SUBCOMMAND,
+        SPONSORSHIP_SUBCOMMAND,
         subcommand({
             ...SUBCOMMAND_FIELDS,
             name: 'usage',

package/node_modules/@noodle-borg/compiler/dist/manifest/schema.d.ts

@@ -377,6 +377,9 @@ export declare const manifestV1Schema: z.ZodObject<{
                 sessionClaims: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
                     exposeToModel: z.ZodOptional<z.ZodBoolean>;
                 }, z.core.$strict>>>;
+                webmcp: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>>;
             }, z.core.$strict>>>;
             sessionClaims: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
                 exposeToModel: z.ZodOptional<z.ZodBoolean>;
@@ -856,6 +859,9 @@ export declare const manifestV2Schema: z.ZodObject<{
                 sessionClaims: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
                     exposeToModel: z.ZodOptional<z.ZodBoolean>;
                 }, z.core.$strict>>>;
+                webmcp: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>>;
             }, z.core.$strict>>>;
             sessionClaims: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
                 exposeToModel: z.ZodOptional<z.ZodBoolean>;
@@ -1545,6 +1551,9 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 sessionClaims: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
                     exposeToModel: z.ZodOptional<z.ZodBoolean>;
                 }, z.core.$strict>>>;
+                webmcp: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>>;
             }, z.core.$strict>>>;
             sessionClaims: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
                 exposeToModel: z.ZodOptional<z.ZodBoolean>;
@@ -2023,6 +2032,9 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 sessionClaims: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
                     exposeToModel: z.ZodOptional<z.ZodBoolean>;
                 }, z.core.$strict>>>;
+                webmcp: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>>;
             }, z.core.$strict>>>;
             sessionClaims: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
                 exposeToModel: z.ZodOptional<z.ZodBoolean>;

package/node_modules/@noodle-borg/compiler/dist/manifest/schema.js

@@ -352,6 +352,11 @@ const embeddedAssistantSchema = z
         instructions: z.string().trim().min(1).max(MAX_SERVER_INSTRUCTIONS).optional(),
         capabilities: z.array(assistantCapabilitySchema).optional(),
         sessionClaims: sessionClaimsSchema.optional(),
+        // Overrides the assistant's own opt-in for sessions minted on this surface, in either
+        // direction (ADR 0220, amended). Declared explicitly rather than inherited from
+        // `assistantUiSchema.shape` — this is not renderer presentation, and a surface that
+        // acquired it by a spread would be an accident rather than a decision.
+        webmcp: optionalStrictObject({ enabled: z.boolean().optional() }),
     })
         .strict())
         .min(1)
@@ -360,9 +365,9 @@ const embeddedAssistantSchema = z
     // 2026-07-14). Keys become `${user.claims.<key>}`; `exposeToModel` adds it to the identity line.
     sessionClaims: sessionClaimsSchema.optional(),
     // Additive optional field: a v1.x minor under ADR 0150, so no existing manifest can observe it.
-    // Declared here rather than in `assistantUiSchema` deliberately — that shape is also spread into
-    // every surface, and which callers may reach the server's tools is surface authority, not
-    // renderer-owned presentation a surface may refine.
+    // The deployment's default, which any surface may override. Declared here rather than in
+    // `assistantUiSchema` because that shape is spread into every surface as renderer-owned
+    // presentation, and this is not presentation — the surface carries its own copy on purpose.
     webmcp: optionalStrictObject({ enabled: z.boolean().optional() }),
     ...assistantUiSchema.shape,
 })

package/node_modules/@noodle-borg/module/dist/index.d.ts

@@ -4,6 +4,7 @@ export * from './deployment-activation.js';
 export * from './deployment-automation.js';
 export * from './endpoint-url.js';
 export * from './intent.js';
+export * from './logger.js';
 export * from './organization-provisioning.js';
 export * from './platform-human-identity.js';
 export * from './request-analytics.js';

package/node_modules/@noodle-borg/module/dist/index.js

@@ -4,6 +4,7 @@ export * from './deployment-activation.js';
 export * from './deployment-automation.js';
 export * from './endpoint-url.js';
 export * from './intent.js';
+export * from './logger.js';
 export * from './organization-provisioning.js';
 export * from './platform-human-identity.js';
 export * from './request-analytics.js';

package/node_modules/@noodle-borg/module/dist/logger.d.ts

@@ -0,0 +1,15 @@
+import type { ModuleLogger } from './contract.js';
+export type ModuleLogLevel = 'debug' | 'info' | 'warn' | 'error';
+export type ModuleLogFields = Readonly<Record<string, unknown>>;
+/** Adapt a module host logger to the child-capable shape used by service integrations. */
+export interface AdaptedModuleLogger {
+    readonly level: ModuleLogLevel;
+    log(level: ModuleLogLevel, event: string, fields?: ModuleLogFields): void;
+    debug(event: string, fields?: ModuleLogFields): void;
+    info(event: string, fields?: ModuleLogFields): void;
+    warn(event: string, fields?: ModuleLogFields): void;
+    error(event: string, fields?: ModuleLogFields): void;
+    child(fields: ModuleLogFields): AdaptedModuleLogger;
+}
+export declare function adaptModuleLogger(logger: ModuleLogger, base?: ModuleLogFields): AdaptedModuleLogger;
+//# sourceMappingURL=logger.d.ts.map

package/node_modules/@noodle-borg/module/dist/logger.js

@@ -0,0 +1,16 @@
+export function adaptModuleLogger(logger, base = {}) {
+    const fields = (extra) => ({ ...base, ...extra });
+    const log = (level, event, extra) => {
+        logger[level](event, fields(extra));
+    };
+    return {
+        level: 'debug',
+        log,
+        debug: (event, extra) => log('debug', event, extra),
+        info: (event, extra) => log('info', event, extra),
+        warn: (event, extra) => log('warn', event, extra),
+        error: (event, extra) => log('error', event, extra),
+        child: (extra) => adaptModuleLogger(logger, fields(extra)),
+    };
+}
+//# sourceMappingURL=logger.js.map

package/node_modules/@noodle-borg/observability/dist/assistant-app-tool-usage.js

@@ -0,0 +1,47 @@
+import { randomUUID } from 'node:crypto';
+import { captureAssistantUsage } from './assistant-usage.js';
+/** Project one apps-bridge tool call onto the shared tenant request stream. */
+export function assistantAppToolCallRequestEvent(session, input) {
+    const isPublic = session.publicEmbedId !== undefined;
+    return {
+        ...session.tenant,
+        deploymentId: session.deploymentId,
+        requestId: randomUUID(),
+        sessionId: session.id,
+        sessionSource: 'synthetic',
+        subjectKind: isPublic ? 'anonymous' : 'authenticated',
+        accessMode: isPublic ? 'public' : 'authenticated',
+        surface: input.bridged ? 'webmcp' : isPublic ? 'assistant-public' : 'assistant-authenticated',
+        method: 'tools/call',
+        kind: 'usage',
+        ...(input.toolName === undefined ? {} : { toolName: input.toolName }),
+        outcome: input.outcome === 'ok' ? 'ok' : input.outcome === 'refused' ? 'tool_error' : 'mcp_error',
+        ...(input.errorKind === undefined ? {} : { errorKind: input.errorKind }),
+        durationMs: Number.isFinite(input.durationMs) && input.durationMs > 0 ? input.durationMs : 0,
+        // Scalar-only, like every other assistant event: tool arguments, results, page context, and
+        // credentials have no field to enter through.
+        details: { eventKind: 'appToolCall', bridged: input.bridged },
+    };
+}
+/**
+ * Bind one apps-bridge tool call's fixed facts, leaving the caller a recorder it can run at any
+ * exit. The route reaches several of them -- a budget refusal before any resolution work, an
+ * unprojected tool, bad arguments, a raised confirmation, a result -- and assembling the event at
+ * each one is how one of them ends up forgotten, which is what happened to the budget refusal.
+ */
+export function assistantAppToolCallRecorder(input) {
+    const startedAt = input.clock();
+    return (outcome, errorKind) => {
+        captureAssistantUsage(input.capture, assistantAppToolCallRequestEvent(input.session, {
+            // Absent when the caller named no tool. That row still matters: a nameless call that
+            // exhausts a budget is the shape abusive traffic takes, and it is the row an operator
+            // watching a browser agent would miss if a missing name suppressed the event.
+            ...(input.toolName === undefined ? {} : { toolName: input.toolName }),
+            bridged: input.bridged,
+            outcome,
+            ...(errorKind === undefined ? {} : { errorKind }),
+            durationMs: input.clock() - startedAt,
+        }));
+    };
+}
+//# sourceMappingURL=assistant-app-tool-usage.js.map

package/node_modules/@noodle-borg/observability/dist/index.js

@@ -1,3 +1,4 @@
+export * from './assistant-app-tool-usage.js';
 export * from './assistant-usage.js';
 export * from './intent-capture.js';
 export * from './request-event-buffer.js';