@noodleseed/one 0.166.0 → 0.168.0

package/node_modules/@noodle-borg/service/dist/routes/control-plane.js

@@ -195,6 +195,7 @@ export async function handleDeploy(req, res, registry, options, maxBody, tenant,
         deploymentId: result.deploymentId,
         serverVersion: result.serverVersion,
         accessMode: result.accessMode,
+        ...(result.authentication !== undefined ? { authentication: result.authentication } : {}),
         ...(result.ownerSubject !== undefined ? { ownerSubject: result.ownerSubject } : {}),
         url: tenantMcpUrl(base, tenant, result.serverVersion, endpointOptions),
         defaultUrl: tenantMcpUrl(base, tenant, undefined, endpointOptions),

package/node_modules/@noodle-borg/service/dist/routes/deploy-preflight.js

@@ -2,8 +2,8 @@ import { randomUUID } from 'node:crypto';
 import { cspFaultsInManifest } from '@noodle-borg/compiler';
 import { readDeployBody, sendJson } from '@noodle-borg/transport-http';
 import { DEPLOY_PREFLIGHT_CHECK_TIMEOUT_MS, deployPreflightRequestSchema, formatWireError, } from '@noodle-borg/wire-contracts';
+import { isIdentityAccessMode } from '../deployment-access-mode.js';
 import { manifestUsesUserRoot } from '../registry-access.js';
-import { isIdentityAccessMode } from './access-mode.js';
 import { authorizeDeploymentOwnerSelection, authorizeTenantControl, developerGrantRouteAccess, } from './control-plane.js';
 // Per-process resource admission, not a tenant quota or distributed state authority.
 const activePreflights = new WeakSet();
@@ -91,7 +91,7 @@ export async function handleDeployPreflight(req, res, registry, options, maxBody
             });
         }
         const accessMode = parsed.accessMode ?? 'owner-only';
-        if (isIdentityAccessMode(accessMode) && identity === undefined) {
+        if (isIdentityAccessMode(accessMode, parsed.manifest) && identity === undefined) {
             return sendJson(res, 401, {
                 code: 'deployer_identity_required',
                 error: `${accessMode} deployments require an authenticated deployer`,

package/node_modules/@noodle-borg/service/dist/serve-resource-auth.js

@@ -44,7 +44,7 @@ export async function bridgeAuthForResource(registry, resource, allowedBaseDomai
         ? await registry.getActiveByTenant(tenant)
         : await registry.getActiveByTenantVersion(tenant, tenant.serverVersion);
     const auth = target?.served.artifact.server.auth;
-    if (auth?.kind !== 'bridge')
+    if (target?.authentication?.kind !== 'customer' || auth?.kind !== 'bridge')
         return undefined;
     const variables = await registry.configStore.resolveConfigValues('variable', resolveConfigScope(tenant));
     return resolveTenantBridgeAuthVariables(auth, variables);

package/node_modules/@noodle-borg/service/dist/store/in-memory.d.ts

@@ -1,20 +1,15 @@
-import type { AccessMode } from '@noodle-borg/transport-http';
-import type { ActiveAccessUpdateInput, AppArchiveResult, AppRestorePrecondition, AppRestoreResult, AppSummary, ArtifactStore, DeploymentActivationResult, DeploymentListFilter, DeploymentLock, DeploymentLockUpdateResult, DeploymentSummary, DeployRecord, EnvSummary, ProductionEnvironmentChange, TenantAuthConfig, TenantRef } from '../store.js';
+import type { ActiveAccessUpdateInput, AppArchiveResult, AppRestorePrecondition, AppRestoreResult, AppSummary, ArtifactStore, DeploymentActivationPrecondition, DeploymentActivationResult, DeploymentListFilter, DeploymentLock, DeploymentLockUpdateResult, DeploymentPolicyPrecondition, DeploymentSummary, DeployRecord, EnvSummary, ProductionEnvironmentChange, TenantAuthConfig, TenantRef } from '../store.js';
 /** In-memory store: keeps records in a Map. Used by tests and as an explicit, non-persistent option. */
 export declare class InMemoryArtifactStore implements ArtifactStore {
     #private;
-    append(record: DeployRecord): Promise<void>;
+    append(record: DeployRecord, precondition?: DeploymentPolicyPrecondition): Promise<void>;
     loadAll(): Promise<readonly DeployRecord[]>;
     get(deploymentId: string): Promise<DeployRecord | undefined>;
     getActiveByTenant(ref: TenantRef): Promise<DeployRecord | undefined>;
     getActiveByTenantVersion(ref: TenantRef, serverVersion: string): Promise<DeployRecord | undefined>;
     setDeploymentLock(ref: TenantRef, serverVersion: string, expectedDeploymentId: string, deploymentLock: DeploymentLock | undefined): Promise<DeploymentLockUpdateResult>;
     findActiveCustomerAuthAudienceConflict(ref: TenantRef, auth: TenantAuthConfig): Promise<TenantRef | undefined>;
-    activateDeployment(ref: TenantRef, deploymentId: string, precondition?: {
-        readonly expectedAccessMode: AccessMode | undefined;
-        readonly expectedSchemaVersion?: number;
-        readonly serverAuth?: TenantAuthConfig;
-    }, _options?: {
+    activateDeployment(ref: TenantRef, deploymentId: string, precondition?: DeploymentActivationPrecondition, _options?: {
         readonly automationId?: string;
     }): Promise<DeploymentActivationResult | undefined>;
     updateActiveAccess(ref: TenantRef, deploymentId: string, input: ActiveAccessUpdateInput): Promise<DeployRecord | undefined>;

package/node_modules/@noodle-borg/service/dist/store/in-memory.js

@@ -1,8 +1,9 @@
 import { normalizeServerVersion } from '@noodle-borg/module';
 import { assertSameAppPackageSnapshot, sanitizeDeployRecordAppPackageSnapshot, } from '../app-package-snapshot.js';
 import { assertCustomerAuthRestorePrecondition, assertUniqueActiveCustomerAuthAudienceBindings, findActiveCustomerAuthAudienceConflict, requiresCustomerAuthProjection, } from '../customer-auth-audience-binding.js';
+import { matchesDeploymentActivation } from '../deployment-activation-precondition.js';
 import { assertDeploymentActivationUnlocked, assertDeploymentAppendUnlocked, } from '../deployment-lock.js';
-import { assertDeploymentAppendVersion } from '../deployment-record-version.js';
+import { assertDeploymentAppendPolicy, assertDeploymentAppendVersion, } from '../deployment-record-version.js';
 import { defaultActiveRecord, sameDeploymentScope, sameTenantRecord, } from '../deployment-versioning.js';
 import { appArchivedAt, deploymentSummary, matchesDeploymentFilter, paginateAppSummaries, planAppArchive, planAppRestore, planArchivedAppSweep, preserveDeploymentOwnerState, resolveActiveAccessUpdate, resolveProductionEnvironment, summarizeApps, summarizeEnvs, validateDeploymentListFilter, withoutArchiveStamp, } from './records.js';
 import { validateSlug, validateTenantRef } from './validate.js';
@@ -10,8 +11,9 @@ import { validateSlug, validateTenantRef } from './validate.js';
 export class InMemoryArtifactStore {
     #records = new Map();
     #productionEnvironments = new Map();
-    async append(record) {
+    async append(record, precondition) {
         assertDeploymentAppendVersion([...this.#records.values()], record);
+        assertDeploymentAppendPolicy([...this.#records.values()], record, precondition);
         const existing = this.#records.get(record.deploymentId);
         if (existing !== undefined)
             assertSameAppPackageSnapshot(existing, record);
@@ -85,8 +87,7 @@ export class InMemoryArtifactStore {
         if (target === undefined || !sameTenantRecord(target, safe))
             return Promise.resolve(undefined);
         assertDeploymentActivationUnlocked([...this.#records.values()], target);
-        if (target.schemaVersion !== (precondition?.expectedSchemaVersion ?? 1) ||
-            (precondition !== undefined && target.accessMode !== precondition.expectedAccessMode)) {
+        if (!matchesDeploymentActivation(target, precondition)) {
             return Promise.resolve(undefined);
         }
         const previousActive = [...this.#records.values()]
@@ -95,6 +96,7 @@ export class InMemoryArtifactStore {
         if (precondition === undefined && previousActive !== undefined) {
             assertDeploymentAppendVersion([previousActive], { ...target, active: true });
         }
+        assertDeploymentAppendPolicy([...this.#records.values()], { ...target, active: true }, precondition?.expectedActivePolicy);
         const alreadyActive = previousActive?.deploymentId === target.deploymentId;
         const activated = {
             ...target,

package/node_modules/@noodle-borg/service/dist/store/json-file.d.ts

@@ -1,5 +1,4 @@
-import type { AccessMode } from '@noodle-borg/transport-http';
-import type { ActiveAccessUpdateInput, AppArchiveResult, AppRestorePrecondition, AppRestoreResult, AppSummary, ArtifactStore, DeploymentActivationResult, DeploymentListFilter, DeploymentLock, DeploymentLockUpdateResult, DeploymentSummary, DeployRecord, EnvSummary, ProductionEnvironmentChange, TenantAuthConfig, TenantRef } from '../store.js';
+import type { ActiveAccessUpdateInput, AppArchiveResult, AppRestorePrecondition, AppRestoreResult, AppSummary, ArtifactStore, DeploymentActivationPrecondition, DeploymentActivationResult, DeploymentListFilter, DeploymentLock, DeploymentLockUpdateResult, DeploymentPolicyPrecondition, DeploymentSummary, DeployRecord, EnvSummary, ProductionEnvironmentChange, TenantAuthConfig, TenantRef } from '../store.js';
 /**
  * JSON-file store: one file per deployment at `<dataDir>/deployments/<deploymentId>.json`, written atomically
  * (write a temp file, then `rename` over the target — no partial file is ever read). `deploymentId` is a
@@ -9,18 +8,14 @@ import type { ActiveAccessUpdateInput, AppArchiveResult, AppRestorePrecondition,
 export declare class JsonFileArtifactStore implements ArtifactStore {
     #private;
     constructor(dataDir: string);
-    append(record: DeployRecord): Promise<void>;
+    append(record: DeployRecord, precondition?: DeploymentPolicyPrecondition): Promise<void>;
     get(deploymentId: string): Promise<DeployRecord | undefined>;
     getActiveByTenant(ref: TenantRef): Promise<DeployRecord | undefined>;
     getActiveByTenantVersion(ref: TenantRef, serverVersion: string): Promise<DeployRecord | undefined>;
     setDeploymentLock(ref: TenantRef, serverVersion: string, expectedDeploymentId: string, deploymentLock: DeploymentLock | undefined): Promise<DeploymentLockUpdateResult>;
     findActiveCustomerAuthAudienceConflict(ref: TenantRef, auth: TenantAuthConfig): Promise<TenantRef | undefined>;
     updateActiveAccess(ref: TenantRef, deploymentId: string, input: ActiveAccessUpdateInput): Promise<DeployRecord | undefined>;
-    activateDeployment(ref: TenantRef, deploymentId: string, precondition?: {
-        readonly expectedAccessMode: AccessMode | undefined;
-        readonly expectedSchemaVersion?: number;
-        readonly serverAuth?: TenantAuthConfig;
-    }): Promise<DeploymentActivationResult | undefined>;
+    activateDeployment(ref: TenantRef, deploymentId: string, precondition?: DeploymentActivationPrecondition): Promise<DeploymentActivationResult | undefined>;
     loadAll(): Promise<readonly DeployRecord[]>;
     listDeployments(filter: DeploymentListFilter): Promise<readonly DeploymentSummary[]>;
     getAppArchivedAt(org: string, app: string): Promise<string | undefined>;

package/node_modules/@noodle-borg/service/dist/store/json-file.js

@@ -4,8 +4,9 @@ import { join } from 'node:path';
 import { normalizeServerVersion } from '@noodle-borg/module';
 import { assertSameAppPackageSnapshot, sanitizeDeployRecordAppPackageSnapshot, } from '../app-package-snapshot.js';
 import { assertCustomerAuthRestorePrecondition, assertUniqueActiveCustomerAuthAudienceBindings, findActiveCustomerAuthAudienceConflict, requiresCustomerAuthProjection, } from '../customer-auth-audience-binding.js';
+import { matchesDeploymentActivation } from '../deployment-activation-precondition.js';
 import { assertDeploymentActivationUnlocked, assertDeploymentAppendUnlocked, } from '../deployment-lock.js';
-import { assertDeploymentAppendVersion } from '../deployment-record-version.js';
+import { assertDeploymentAppendPolicy, assertDeploymentAppendVersion, } from '../deployment-record-version.js';
 import { defaultActiveRecord, sameDeploymentScope, sameTenantRecord, } from '../deployment-versioning.js';
 import { appArchivedAt, deploymentSummary, matchesDeploymentFilter, paginateAppSummaries, planAppArchive, planAppRestore, planArchivedAppSweep, preserveDeploymentOwnerState, resolveActiveAccessUpdate, resolveProductionEnvironment, summarizeApps, summarizeEnvs, validateDeploymentListFilter, withoutArchiveStamp, } from './records.js';
 import { DEPLOYMENT_ID_PATTERN, validateSlug, validateTenantRef } from './validate.js';
@@ -23,10 +24,10 @@ export class JsonFileArtifactStore {
         this.#dir = join(dataDir, 'deployments');
         this.#environmentMetadataDir = join(dataDir, 'environment-metadata');
     }
-    append(record) {
-        return this.#serializeLifecycle(() => this.#appendUnlocked(record));
+    append(record, precondition) {
+        return this.#serializeLifecycle(() => this.#appendUnlocked(record, precondition));
     }
-    async #appendUnlocked(record) {
+    async #appendUnlocked(record, precondition) {
         // Defence in depth: `deploymentId` becomes a filename, so reject anything outside the minted shape
         // (`mintDeploymentId` only ever produces `[a-z0-9-]`). Guards this public class against a caller that
         // passes an untrusted id (no path traversal, no escaping the data dir).
@@ -36,6 +37,7 @@ export class JsonFileArtifactStore {
         }
         const records = await this.loadAll();
         assertDeploymentAppendVersion(records, record);
+        assertDeploymentAppendPolicy(records, record, precondition);
         const existing = records.find((candidate) => candidate.deploymentId === record.deploymentId);
         if (existing !== undefined)
             assertSameAppPackageSnapshot(existing, record);
@@ -129,8 +131,7 @@ export class JsonFileArtifactStore {
             const target = await this.get(deploymentId);
             if (target === undefined || !sameTenantRecord(target, safe))
                 return undefined;
-            if (target.schemaVersion !== (precondition?.expectedSchemaVersion ?? 1) ||
-                (precondition !== undefined && target.accessMode !== precondition.expectedAccessMode)) {
+            if (!matchesDeploymentActivation(target, precondition)) {
                 return undefined;
             }
             const records = await this.loadAll();
@@ -141,6 +142,7 @@ export class JsonFileArtifactStore {
             if (precondition === undefined && previousActive !== undefined) {
                 assertDeploymentAppendVersion([previousActive], { ...target, active: true });
             }
+            assertDeploymentAppendPolicy(records, { ...target, active: true }, precondition?.expectedActivePolicy);
             const alreadyActive = previousActive?.deploymentId === target.deploymentId;
             const activated = {
                 ...target,

package/node_modules/@noodle-borg/service/dist/store/records.js

@@ -141,17 +141,28 @@ export function resolveActiveAccessUpdate(record, ref, input) {
         !sameTenantRecord(record, ref) ||
         record.accessMode !== input.expectedAccessMode ||
         record.schemaVersion !== (input.expectedSchemaVersion ?? 1) ||
+        (input.expectedManifest !== undefined && record.manifest !== input.expectedManifest) ||
         deploymentOwnerSubject(record) !== input.expectedOwnerSubject)
         return undefined;
     if ((record.accessMode ?? 'owner-only') === input.accessMode &&
+        (input.schemaVersion === undefined || record.schemaVersion === input.schemaVersion) &&
         (input.ownerSubject === undefined || deploymentOwnerSubject(record) === input.ownerSubject) &&
-        !requiresCustomerAuthProjection({ ...record, accessMode: input.accessMode }, input.serverAuth))
+        !requiresCustomerAuthProjection({
+            ...record,
+            accessMode: input.accessMode,
+            schemaVersion: input.schemaVersion ?? record.schemaVersion,
+        }, input.serverAuth))
         return record;
     return {
         ...record,
         accessMode: input.accessMode,
+        schemaVersion: input.schemaVersion ?? record.schemaVersion,
         ...(input.ownerSubject !== undefined ? { ownerSubject: input.ownerSubject } : {}),
-        ...(requiresCustomerAuthProjection({ ...record, accessMode: input.accessMode }, input.serverAuth) && input.serverAuth !== undefined
+        ...(requiresCustomerAuthProjection({
+            ...record,
+            accessMode: input.accessMode,
+            schemaVersion: input.schemaVersion ?? record.schemaVersion,
+        }, input.serverAuth) && input.serverAuth !== undefined
             ? { serverAuth: input.serverAuth }
             : {}),
     };

package/node_modules/@noodle-borg/service/dist/store.d.ts

@@ -33,7 +33,7 @@ export type SecretEnvelope = {
  * of the source strings, so the inputs + identity are a faithful, reproducible record.
  */
 export interface DeployRecord {
-    /** Record format version, for forward migration of the persisted shape. Current writers emit `1`. */
+    /** Record format version; customer mixed adoption writes 2, which remains sticky on new records. */
     readonly schemaVersion: number;
     readonly deploymentId: string;
     readonly orgSlug: string;
@@ -258,13 +258,29 @@ export interface DeploymentActivationResult {
     readonly alreadyActive: boolean;
 }
 /** One atomic access/owner compare-and-set over the active deployment's observed state. */
+export interface DeploymentPolicyPrecondition {
+    readonly active: Pick<DeployRecord, 'deploymentId' | 'schemaVersion' | 'accessMode' | 'ownerSubject' | 'manifest' | 'serverAuth'> | null;
+}
+/** The source and authority validated before atomically activating this exact target revision. */
+export interface DeploymentActivationPrecondition {
+    readonly expectedAccessMode: AccessMode | undefined;
+    /** Older callers are restricted to schema-1 targets. */
+    readonly expectedSchemaVersion?: number;
+    readonly expectedRevision?: Pick<DeployRecord, 'manifest' | 'connectors' | 'hostedAssets' | 'serverAuth' | 'serverVersion' | 'ownerSubject' | 'createdBySubject' | 'orgMembershipSources' | 'archivedAt'>;
+    readonly expectedActivePolicy?: DeploymentPolicyPrecondition;
+    /** Compiler-authoritative projection, applied only after revision validation. */
+    readonly serverAuth?: TenantAuthConfig;
+}
 export interface ActiveAccessUpdateInput {
+    /** Internal policy adoption; callers cannot author a deployment schema version. */
+    readonly schemaVersion?: 2;
     readonly accessMode: AccessMode;
     /** Desired owner mutation. Omission preserves the current effective owner; clearing is unsupported. */
     readonly ownerSubject?: string;
     readonly expectedAccessMode: AccessMode | undefined;
     /** Older callers omit this and are restricted to version-1 records. */
     readonly expectedSchemaVersion?: number;
+    readonly expectedManifest?: string;
     readonly expectedOwnerSubject: string | undefined;
     /** Compiler-authoritative projection persisted atomically when enabling customer access. */
     readonly serverAuth?: TenantAuthConfig;
@@ -286,7 +302,7 @@ export interface ControlPlaneStore extends OrganizationStore {
  * an earlier deployment without changing the tenant-facing URL.
  */
 export interface ArtifactStore {
-    append(record: DeployRecord): Promise<void>;
+    append(record: DeployRecord, precondition?: DeploymentPolicyPrecondition): Promise<void>;
     loadAll(): Promise<readonly DeployRecord[]>;
     /**
      * Fetch one server's record by id, or `undefined` if absent. A point read used by lazy
@@ -304,12 +320,7 @@ export interface ArtifactStore {
      * bindings. Implementations may optimize this security lookup; registries fall back to `loadAll`.
      */
     findActiveCustomerAuthAudienceConflict?(ref: TenantRef, auth: TenantAuthConfig): Promise<TenantRef | undefined>;
-    activateDeployment(ref: TenantRef, deploymentId: string, precondition?: {
-        readonly expectedAccessMode: AccessMode | undefined;
-        readonly expectedSchemaVersion?: number;
-        /** Compiler-authoritative projection persisted atomically when activating customer access. */
-        readonly serverAuth?: TenantAuthConfig;
-    }, options?: {
+    activateDeployment(ref: TenantRef, deploymentId: string, precondition?: DeploymentActivationPrecondition, options?: {
         readonly automationId?: string;
     }): Promise<DeploymentActivationResult | undefined>;
     /**

package/node_modules/@noodle-borg/service/package.json

@@ -39,7 +39,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@noodle-borg/admission-limits": "0.0.0",
-    "@noodle-borg/agent-kit": "0.102.0",
+    "@noodle-borg/agent-kit": "0.104.0",
     "@noodle-borg/app-package": "0.0.0",
     "@noodle-borg/assistant-gateway": "0.0.0",
     "@noodle-borg/auth": "0.0.0",

package/node_modules/@noodle-borg/transport-http/dist/handler.d.ts

@@ -5,6 +5,7 @@ import { type TlsPosture } from './front-door.js';
 import { type Logger } from './logging.js';
 import { type PublicTenantRouting } from './routing.js';
 import type { HostedToolAuthorizationObserver } from './service-principal-authorization.js';
+import { type TargetAuthentication } from './target-authentication.js';
 import type { HostedToolDispatchHook } from './tool-dispatch.js';
 export type { AccessMode, AdmissionCategory, AdmissionContext, AdmissionDecision, AdmissionGate, DataPlaneAuthorizationResult, DataPlaneIdentityAuthorizer, OwnerTokenVerifier, TenantRouteRef, } from '@noodle-borg/module';
 export type { PublicTenantRouting } from './routing.js';
@@ -78,9 +79,7 @@ export interface ServedTarget {
     readonly app?: string;
     readonly environment?: string;
     readonly orgMembershipSources?: readonly OrgMembershipSource[];
-    readonly verifyToken?: OwnerTokenVerifier;
-    readonly authServerIssuer?: string;
-    readonly authServerIssuers?: readonly string[];
+    readonly authentication?: TargetAuthentication;
     readonly intentCaptureMode?: IntentCaptureMode;
 }
 export type ServerLookup = (deploymentId: string) => Promise<ServedTarget | undefined>;

package/node_modules/@noodle-borg/transport-http/dist/handler.js

@@ -4,6 +4,7 @@ import { noopLogger } from './logging.js';
 import { guard, logRequest, rpcError, sendJson } from './responses.js';
 import { resolveRoute } from './routing.js';
 import { serveRequest } from './serve-request.js';
+import { resolveTargetAuthentication } from './target-authentication.js';
 const DEFAULT_ENDPOINT = '/mcp';
 const DEFAULT_MAX_BODY = 1 << 20;
 /** Build the single-artifact raw-Node security front door. */
@@ -33,7 +34,7 @@ export function createMcpHttpHandler(target, options = {}) {
             app: undefined,
             environment: undefined,
             orgMembershipSources: undefined,
-            verifyOwnerToken: options.verifyOwnerToken,
+            authentication: resolveTargetAuthentication({}, options.verifyOwnerToken),
             authorizeDataPlaneIdentity: options.authorizeDataPlaneIdentity,
             admissionGate: options.admissionGate,
             captureRequestEvent: options.captureRequestEvent,
@@ -101,9 +102,7 @@ export function createMcpRouter(lookup, options = {}) {
                 ownerSubject: resolvedTarget.ownerSubject,
                 org: resolvedTarget.org,
                 orgMembershipSources: resolvedTarget.orgMembershipSources,
-                verifyOwnerToken: resolvedTarget.accessMode === 'customers'
-                    ? resolvedTarget.verifyToken
-                    : (resolvedTarget.verifyToken ?? options.verifyOwnerToken),
+                authentication: resolveTargetAuthentication(resolvedTarget, options.verifyOwnerToken),
                 authorizeDataPlaneIdentity: options.authorizeDataPlaneIdentity,
                 admissionGate: options.admissionGate,
                 captureRequestEvent: options.captureRequestEvent,

package/node_modules/@noodle-borg/transport-http/dist/identity-authorization.d.ts

@@ -1,12 +1,13 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { AccessMode, DataPlaneIdentityAuthorizer, OrgMembershipSource, OwnerTokenVerifier } from '@noodle-borg/module';
+import type { AccessMode, DataPlaneIdentityAuthorizer, OrgMembershipSource } from '@noodle-borg/module';
 import { type ProtocolRequestContext } from '@noodle-borg/protocol';
+import type { TargetAuthentication } from './target-authentication.js';
 export interface IdentityAuthorizationOptions {
     readonly accessMode: AccessMode | undefined;
     readonly ownerSubject: string | undefined;
     readonly org: string | undefined;
     readonly orgMembershipSources: readonly OrgMembershipSource[] | undefined;
-    readonly verifyOwnerToken: OwnerTokenVerifier | undefined;
+    readonly authentication: TargetAuthentication;
     readonly authorizeDataPlaneIdentity: DataPlaneIdentityAuthorizer | undefined;
     /** Whether to trust forwarded-proto when reconstructing the public resource/PRM URLs. */
     readonly trustProxy: boolean;

package/node_modules/@noodle-borg/transport-http/dist/identity-authorization.js

@@ -9,13 +9,13 @@ import { header } from './request-capture.js';
 export async function authorizeIdentityMode(req, res, auth) {
     const challenge = protectedResourceMetadataUrl(req, auth);
     const token = bearerToken(header(req, 'authorization'));
-    if (token === null || auth.verifyOwnerToken === undefined) {
+    if (token === null || auth.authentication.verifyToken === undefined) {
         sendUnauthorized(res, challenge);
         return { allow: false, reason: token === null ? 'missing_token' : 'verifier_unavailable' };
     }
-    const verification = await auth.verifyOwnerToken(token, canonicalResourceUrl(req, auth));
+    const verification = await auth.authentication.verifyToken(token, canonicalResourceUrl(req, auth));
     if (verification === null) {
-        sendUnauthorized(res, challenge);
+        sendUnauthorized(res, challenge, 'invalid_token');
         return { allow: false, reason: 'token_rejected' };
     }
     const { caller: identity } = verification;
@@ -76,27 +76,38 @@ export async function authorizeIdentityMode(req, res, auth) {
  */
 export async function authorizePublicServiceMode(req, auth) {
     const token = bearerToken(header(req, 'authorization'));
-    if (token === null || auth.verifyOwnerToken === undefined)
+    if (token === null || auth.authentication.verifyToken === undefined)
         return { allow: true };
-    const verification = await auth.verifyOwnerToken(token, canonicalResourceUrl(req, auth));
+    const verification = await auth.authentication.verifyToken(token, canonicalResourceUrl(req, auth));
     return verification?.caller.identityKind === 'service'
         ? { allow: true, caller: verification.caller }
         : { allow: true };
 }
 export async function authorizeMixedMode(req, res, auth) {
-    const token = bearerToken(header(req, 'authorization'));
-    if (token === null)
+    const authorization = header(req, 'authorization');
+    if (authorization === undefined)
         return { allow: true };
+    const token = bearerToken(authorization);
     const challenge = protectedResourceMetadataUrl(req, auth);
-    if (auth.verifyOwnerToken === undefined) {
+    if (token === null) {
+        sendUnauthorized(res, challenge, 'invalid_token');
+        return { allow: false, reason: 'token_rejected' };
+    }
+    if (auth.authentication.verifyToken === undefined) {
         sendUnauthorized(res, challenge);
         return { allow: false, reason: 'verifier_unavailable' };
     }
-    const verification = await auth.verifyOwnerToken(token, canonicalResourceUrl(req, auth));
+    const verification = await auth.authentication.verifyToken(token, canonicalResourceUrl(req, auth));
     if (verification === null) {
-        sendUnauthorized(res, challenge);
+        sendUnauthorized(res, challenge, 'invalid_token');
         return { allow: false, reason: 'token_rejected' };
     }
+    if (auth.authentication.kind === 'customer' &&
+        verification.caller.identityKind !== 'customer' &&
+        verification.caller.identityKind !== 'service') {
+        sendUnauthorized(res, challenge, 'invalid_token');
+        return { allow: false, reason: 'identity_not_customer' };
+    }
     return {
         allow: true,
         caller: verification.caller,
@@ -126,13 +137,13 @@ export function bearerToken(headerValue) {
  * `resourceMetadataUrl` is included so an MCP client can discover the authorization server (RFC 9728 /
  * the MCP authorization spec).
  */
-function sendUnauthorized(res, resourceMetadataUrl) {
+function sendUnauthorized(res, resourceMetadataUrl, error) {
     const challenge = resourceMetadataUrl !== undefined
         ? `Bearer realm="noodle", resource_metadata="${resourceMetadataUrl}"`
         : 'Bearer realm="noodle"';
     res.writeHead(401, {
         'content-type': 'application/json; charset=utf-8',
-        'www-authenticate': challenge,
+        'www-authenticate': error === undefined ? challenge : `${challenge}, error="${error}"`,
     });
     res.end(JSON.stringify(rpcError(JSON_RPC.INVALID_REQUEST, 'unauthorized')));
 }

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

@@ -8,6 +8,7 @@ export { sendJson } from './responses.js';
 export { type RunningServer, type ServeOptions, serveHttp } from './serve.js';
 export type { HostedToolAuthorizationObservation, HostedToolAuthorizationObserver, ServicePrincipalToolAuthorizationObservation, } from './service-principal-authorization.js';
 export { preflightServicePrincipalToolCall, sendServicePrincipalToolDenial, } from './service-principal-authorization.js';
+export type { TargetAuthentication } from './target-authentication.js';
 export type { HostedToolDispatchContext, HostedToolDispatchHook, } from './tool-dispatch.js';
 export { toWebRequest, writeWebResponse } from './web-bridge.js';
 //# sourceMappingURL=index.d.ts.map

package/node_modules/@noodle-borg/transport-http/dist/serve-request.js

@@ -49,6 +49,9 @@ export async function serveRequest(req, res, target, auth, routeId, maxBody, all
     // and the SDK transport is never constructed for it. A missing accessMode is reserved for loopback/local
     // dev targets and remains open.
     let protocolContext = {
+        ...(auth.accessMode === 'mixed' && auth.authentication.kind === 'customer'
+            ? { toolAuthentication: 'mixed-customer' }
+            : {}),
         ...(auth.oauthClientCredentialsReady ? { oauthClientCredentialsReady: true } : {}),
     };
     let subject;

package/node_modules/@noodle-borg/transport-http/dist/target-authentication.d.ts

@@ -0,0 +1,15 @@
+import type { AccessMode, OwnerTokenVerifier } from '@noodle-borg/module';
+/** Resolved identity authority. A missing customer verifier must never select platform defaults. */
+export type TargetAuthentication = {
+    readonly kind: 'platform';
+    readonly verifyToken?: OwnerTokenVerifier;
+} | {
+    readonly kind: 'customer';
+    readonly verifyToken?: OwnerTokenVerifier;
+    readonly authorizationServers?: readonly string[];
+};
+export declare function resolveTargetAuthentication(target: {
+    readonly accessMode?: AccessMode;
+    readonly authentication?: TargetAuthentication;
+}, platformVerifier?: OwnerTokenVerifier): TargetAuthentication;
+//# sourceMappingURL=target-authentication.d.ts.map

package/node_modules/@noodle-borg/transport-http/dist/target-authentication.js

@@ -0,0 +1,9 @@
+export function resolveTargetAuthentication(target, platformVerifier) {
+    if (target.authentication?.kind === 'customer')
+        return target.authentication;
+    if (target.accessMode === 'customers')
+        return { kind: 'customer' };
+    const verifyToken = target.authentication?.verifyToken ?? platformVerifier;
+    return { kind: 'platform', ...(verifyToken === undefined ? {} : { verifyToken }) };
+}
+//# sourceMappingURL=target-authentication.js.map

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

@@ -124,6 +124,11 @@ export declare const deploySuccessResponseSchema: z.ZodObject<{
         mixed: "mixed";
         customers: "customers";
     }>;
+    authentication: z.ZodOptional<z.ZodEnum<{
+        customer: "customer";
+        none: "none";
+        platform: "platform";
+    }>>;
     ownerSubject: z.ZodOptional<z.ZodString>;
     url: z.ZodString;
     defaultUrl: z.ZodString;
@@ -385,4 +390,5 @@ export * from './application-connections.js';
 export * from './application-onboarding.js';
 export * from './billing-catalog.js';
 export * from './operation-coordination.js';
+export { MIXED_CUSTOMER_AUTH_FEATURE_VERSION, type ServiceInfoClientResponse, type ServiceInfoResponse, serviceInfoClientResponseSchema, serviceInfoResponseSchema, } from './service-info.js';
 //# sourceMappingURL=index.d.ts.map

package/node_modules/@noodle-borg/wire-contracts/dist/index.js

@@ -9,7 +9,7 @@
  */
 import { z } from 'zod';
 import { accessModeSchema } from './access-mode.js';
-import { deploymentOwnerSubjectSchema } from './control-plane.js';
+import { deploymentAuthenticationSchema, deploymentOwnerSubjectSchema } from './control-plane.js';
 export * from './access-mode.js';
 export * from './app-purge-reconciliation.js';
 export * from './application-channels.js';
@@ -92,6 +92,8 @@ export const deploySuccessResponseSchema = z.object({
     deploymentId: z.string().min(1),
     serverVersion: z.string().min(1),
     accessMode: accessModeSchema,
+    /** Effective authority reported by capable services; absence means unknown on older services. */
+    authentication: deploymentAuthenticationSchema.optional(),
     ownerSubject: deploymentOwnerSubjectSchema.optional(),
     url: z.string().min(1),
     defaultUrl: z.string().min(1),
@@ -227,4 +229,5 @@ export * from './application-connections.js';
 export * from './application-onboarding.js';
 export * from './billing-catalog.js';
 export * from './operation-coordination.js';
+export { MIXED_CUSTOMER_AUTH_FEATURE_VERSION, serviceInfoClientResponseSchema, serviceInfoResponseSchema, } from './service-info.js';
 //# sourceMappingURL=index.js.map

package/node_modules/@noodle-borg/wire-contracts/dist/service-info.d.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+export declare const MIXED_CUSTOMER_AUTH_FEATURE_VERSION = 1;
+/** Strict producer contract for the enabled R1 service; no configured tenant data belongs here. */
+export declare const serviceInfoResponseSchema: z.ZodObject<{
+    developerPlugin: z.ZodOptional<z.ZodObject<{
+        mcpCapabilityVersion: z.ZodString;
+    }, z.core.$strict>>;
+    features: z.ZodObject<{
+        mixedCustomerAuth: z.ZodLiteral<1>;
+    }, z.core.$strict>;
+    ok: z.ZodLiteral<true>;
+    status: z.ZodLiteral<"ok">;
+    version: z.ZodString;
+    gitSha: z.ZodString;
+    buildTime: z.ZodString;
+    systemRelease: z.ZodOptional<z.ZodString>;
+    manifestChecksum: z.ZodOptional<z.ZodString>;
+    packageVersions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    compatiblePackageVersions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+}, z.core.$strict>;
+/** Older services may omit features; future fields are stripped at each structured metadata layer. */
+export declare const serviceInfoClientResponseSchema: z.ZodObject<{
+    developerPlugin: z.ZodOptional<z.ZodObject<{
+        mcpCapabilityVersion: z.ZodString;
+    }, z.core.$strip>>;
+    features: z.ZodOptional<z.ZodObject<{
+        mixedCustomerAuth: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    ok: z.ZodLiteral<true>;
+    status: z.ZodLiteral<"ok">;
+    version: z.ZodString;
+    gitSha: z.ZodString;
+    buildTime: z.ZodString;
+    systemRelease: z.ZodOptional<z.ZodString>;
+    manifestChecksum: z.ZodOptional<z.ZodString>;
+    packageVersions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    compatiblePackageVersions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+export type ServiceInfoResponse = z.infer<typeof serviceInfoResponseSchema>;
+export type ServiceInfoClientResponse = z.infer<typeof serviceInfoClientResponseSchema>;
+//# sourceMappingURL=service-info.d.ts.map

package/node_modules/@noodle-borg/wire-contracts/dist/service-info.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+export const MIXED_CUSTOMER_AUTH_FEATURE_VERSION = 1;
+const buildInfoShape = {
+    ok: z.literal(true),
+    status: z.literal('ok'),
+    version: z.string(),
+    gitSha: z.string(),
+    buildTime: z.string(),
+    systemRelease: z.string().optional(),
+    manifestChecksum: z.string().optional(),
+    packageVersions: z.record(z.string(), z.string()).optional(),
+    compatiblePackageVersions: z.record(z.string(), z.array(z.string())).optional(),
+};
+/** Strict producer contract for the enabled R1 service; no configured tenant data belongs here. */
+export const serviceInfoResponseSchema = z.strictObject({
+    ...buildInfoShape,
+    developerPlugin: z.strictObject({ mcpCapabilityVersion: z.string().min(1) }).optional(),
+    features: z.strictObject({ mixedCustomerAuth: z.literal(MIXED_CUSTOMER_AUTH_FEATURE_VERSION) }),
+});
+/** Older services may omit features; future fields are stripped at each structured metadata layer. */
+export const serviceInfoClientResponseSchema = z.object({
+    ...buildInfoShape,
+    developerPlugin: z.object({ mcpCapabilityVersion: z.string().min(1) }).optional(),
+    features: z.object({ mixedCustomerAuth: z.number().int().positive().optional() }).optional(),
+});
+//# sourceMappingURL=service-info.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noodleseed/one",
-  "version": "0.166.0",
+  "version": "0.168.0",
   "private": false,
   "description": "Noodle CLI by Noodle Seed — author, run, and deploy declarative MCP servers. Embedding the assistant in your own web app is @noodleseed/assistant.",
   "license": "Apache-2.0",
@@ -235,7 +235,7 @@
     "@modelcontextprotocol/client": "2.0.0",
     "@modelcontextprotocol/server": "2.0.0",
     "@noodle-borg/admission-limits": "0.0.0",
-    "@noodle-borg/agent-kit": "0.102.0",
+    "@noodle-borg/agent-kit": "0.104.0",
     "@noodle-borg/app-audit": "0.0.0",
     "@noodle-borg/app-package": "0.0.0",
     "@noodle-borg/assistant-gateway": "0.0.0",

package/node_modules/@noodle-borg/service/dist/routes/access-mode.js

@@ -1,7 +0,0 @@
-export function isIdentityAccessMode(accessMode) {
-    return (accessMode === 'owner-only' ||
-        accessMode === 'org-members' ||
-        accessMode === 'customers' ||
-        accessMode === 'authenticated');
-}
-//# sourceMappingURL=access-mode.js.map