@noodleseed/one 0.165.0 → 0.167.0

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

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 type ToolAuthorizationManifest = {
+    readonly discovery?: 'authorized' | 'public' | undefined;
     readonly requiredScopes?: readonly string[] | undefined;
     readonly allowedRoles?: readonly string[] | undefined;
 };
@@ -504,6 +505,7 @@ export declare const manifestV1Schema: z.ZodObject<{
         title: z.ZodOptional<z.ZodString>;
         description: z.ZodString;
         authorization: z.ZodOptional<z.ZodType<ToolAuthorizationManifest, unknown, z.core.$ZodTypeInternals<ToolAuthorizationManifest, unknown>>>;
+        securitySchemes: z.ZodOptional<z.ZodNever>;
         inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         annotations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -1164,6 +1166,7 @@ export declare const manifestV2Schema: z.ZodObject<{
         title: z.ZodOptional<z.ZodString>;
         description: z.ZodString;
         authorization: z.ZodOptional<z.ZodType<ToolAuthorizationManifest, unknown, z.core.$ZodTypeInternals<ToolAuthorizationManifest, unknown>>>;
+        securitySchemes: z.ZodOptional<z.ZodNever>;
         inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         annotations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -1729,6 +1732,7 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         title: z.ZodOptional<z.ZodString>;
         description: z.ZodString;
         authorization: z.ZodOptional<z.ZodType<ToolAuthorizationManifest, unknown, z.core.$ZodTypeInternals<ToolAuthorizationManifest, unknown>>>;
+        securitySchemes: z.ZodOptional<z.ZodNever>;
         inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         annotations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -2388,6 +2392,7 @@ export declare const manifestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         title: z.ZodOptional<z.ZodString>;
         description: z.ZodString;
         authorization: z.ZodOptional<z.ZodType<ToolAuthorizationManifest, unknown, z.core.$ZodTypeInternals<ToolAuthorizationManifest, unknown>>>;
+        securitySchemes: z.ZodOptional<z.ZodNever>;
         inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         annotations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;

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

@@ -70,25 +70,35 @@ const roleSchema = z
 const authorizationListSchema = (item) => z.array(item).min(1).max(MAX_TOOL_AUTHORIZATION_VALUES);
 const requiredScopesSchema = authorizationListSchema(scopeTokenSchema);
 const allowedRolesSchema = authorizationListSchema(roleSchema);
-const toolAuthorizationSchema = z.union([
+const toolAuthorizationSchema = z
+    .union([
     z
         .object({
+        discovery: z.enum(['authorized', 'public']).optional(),
         requiredScopes: requiredScopesSchema,
         allowedRoles: allowedRolesSchema.optional(),
     })
         .strict(),
     z
         .object({
+        discovery: z.enum(['authorized', 'public']).optional(),
         requiredScopes: requiredScopesSchema.optional(),
         allowedRoles: allowedRolesSchema,
     })
         .strict(),
-]);
+])
+    .overwrite((authorization) => {
+    if (authorization.discovery !== 'authorized')
+        return authorization;
+    const { discovery: _discovery, ...normalized } = authorization;
+    return normalized;
+});
 const toolSchema = z.object({
     name: nameSchema,
     title: z.string().trim().min(1).optional(),
     description: z.string().min(1),
     authorization: toolAuthorizationSchema.optional(),
+    securitySchemes: z.never().optional(),
     inputSchema: jsonSchemaSchema,
     outputSchema: jsonSchemaSchema.optional(),
     annotations: z.record(z.string(), z.unknown()).optional(),

package/node_modules/@noodle-borg/module/dist/customer-auth-access.d.ts

@@ -0,0 +1,7 @@
+import type { AccessMode } from './contract.js';
+export declare function usesCustomerAuthentication(input: {
+    readonly schemaVersion: number;
+    readonly accessMode: AccessMode | undefined;
+    readonly hasServerAuth: boolean;
+}): boolean;
+//# sourceMappingURL=customer-auth-access.d.ts.map

package/node_modules/@noodle-borg/module/dist/customer-auth-access.js

@@ -0,0 +1,6 @@
+export function usesCustomerAuthentication(input) {
+    if (input.accessMode === 'customers')
+        return true;
+    return input.accessMode === 'mixed' && input.schemaVersion === 2 && input.hasServerAuth;
+}
+//# sourceMappingURL=customer-auth-access.js.map

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

@@ -1,5 +1,6 @@
 export * from './asset-store.js';
 export * from './contract.js';
+export * from './customer-auth-access.js';
 export * from './deployment-activation.js';
 export * from './deployment-automation.js';
 export * from './endpoint-url.js';

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

@@ -1,5 +1,6 @@
 export * from './asset-store.js';
 export * from './contract.js';
+export * from './customer-auth-access.js';
 export * from './deployment-activation.js';
 export * from './deployment-automation.js';
 export * from './endpoint-url.js';

package/node_modules/@noodle-borg/protocol/dist/handlers/tools.js

@@ -15,6 +15,9 @@ export function registerTools(server, artifact, deps, context) {
     server.setRequestHandler(ListToolsRequestSchema, async () => mapToolsList(artifact, context.caller, {
         knowledgeTools: await knowledgeToolsEnabled(artifact, deps),
         intentCapture: context.intentCapture?.enabled === true,
+        ...(context.toolAuthentication === undefined
+            ? {}
+            : { authentication: context.toolAuthentication }),
     }));
     server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
         const toolName = request.params.name;

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

@@ -8,6 +8,7 @@ export { buildMcpServer, type ProtocolRequestContext, type ProtocolToolDispatchC
 export { handleStatelessHttp } from './stateless.js';
 export { evaluateToolAuthorization, filterAuthorizedTools, TOOL_AUTHORIZATION_DENIED, type ToolAuthorizationCaller, type ToolAuthorizationDecision, type ToolAuthorizationRuleClass, toolAuthorizationRuleClass, toolAuthorizationRuleFingerprint, } from './tool-authorization.js';
 export { toolRequiresConfirmation } from './tool-confirmation.js';
+export { filterDiscoverableTools, type ToolAuthenticationPolicy } from './tool-discovery.js';
 export { createDualEraMcpHandler, createPlatformDualEraMcpHandler, } from './v2/handler.js';
 export { LEGACY_MCP_PROTOCOL_VERSION, type McpProtocolEra, type McpProtocolMode, MODERN_MCP_PROTOCOL_VERSION, SERVED_MCP_PROTOCOL_VERSIONS, type ServedMcpProtocolVersion, } from './v2/versions.js';
 export { injectWidgetBridge } from './widget/inject.js';

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

@@ -7,6 +7,7 @@ export { buildMcpServer, } from './sdk-server.js';
 export { handleStatelessHttp } from './stateless.js';
 export { evaluateToolAuthorization, filterAuthorizedTools, TOOL_AUTHORIZATION_DENIED, toolAuthorizationRuleClass, toolAuthorizationRuleFingerprint, } from './tool-authorization.js';
 export { toolRequiresConfirmation } from './tool-confirmation.js';
+export { filterDiscoverableTools } from './tool-discovery.js';
 export { createDualEraMcpHandler, createPlatformDualEraMcpHandler, } from './v2/handler.js';
 export { LEGACY_MCP_PROTOCOL_VERSION, MODERN_MCP_PROTOCOL_VERSION, SERVED_MCP_PROTOCOL_VERSIONS, } from './v2/versions.js';
 export { injectWidgetBridge } from './widget/inject.js';

package/node_modules/@noodle-borg/protocol/dist/mapping.d.ts

@@ -1,6 +1,7 @@
 import type { ArtifactTool, RuntimeArtifact } from '@noodle-borg/compiler';
 import type { JsonRpcErrorObject } from './jsonrpc.js';
-import { type ToolAuthorizationCaller } from './tool-authorization.js';
+import type { ToolAuthorizationCaller } from './tool-authorization.js';
+import { type ToolAuthenticationPolicy, type ToolSecurityScheme } from './tool-discovery.js';
 import { type WidgetDomainProjection } from './widget/domain-projection.js';
 /**
  * Artifact → MCP wire mapping. The official `@modelcontextprotocol/sdk` owns JSON-RPC framing and
@@ -16,6 +17,7 @@ export interface ToolDescriptor {
     readonly inputSchema: Record<string, unknown>;
     readonly outputSchema?: Record<string, unknown>;
     readonly annotations?: Record<string, unknown>;
+    readonly securitySchemes?: readonly ToolSecurityScheme[];
     /** MCP `_meta` extension bag (e.g. MCP Apps `{ ui: { resourceUri } }` linking the tool to its widget). */
     readonly _meta?: Record<string, unknown>;
 }
@@ -44,6 +46,7 @@ export { mapExecutionError } from './execution-error-mapping.js';
 /** Map a resolved artifact tool to an MCP tool descriptor (carrying its `_meta` extension bag, if any). */
 export declare function mapTool(tool: ArtifactTool, options?: {
     readonly intentCapture?: boolean;
+    readonly authentication?: ToolAuthenticationPolicy;
 }): ToolDescriptor;
 /**
  * Map the artifact's tools to a `tools/list` result. App-only widget helpers remain discoverable here with
@@ -53,6 +56,7 @@ export declare function mapTool(tool: ArtifactTool, options?: {
 export declare function mapToolsList(artifact: RuntimeArtifact, caller?: ToolAuthorizationCaller, options?: {
     readonly knowledgeTools?: boolean;
     readonly intentCapture?: boolean;
+    readonly authentication?: ToolAuthenticationPolicy;
 }): ToolsListResult;
 /**
  * Map a successful tool output to a `tools/call` result. Structured (object) output is returned as

package/node_modules/@noodle-borg/protocol/dist/mapping.js

@@ -1,21 +1,27 @@
 import { splitResultMeta } from '@noodle-borg/runtime';
 import { artifactDeclaresContext, assertNoContextToolCollision, CONTEXT_TOOL_DESCRIPTOR, } from './context-tool.js';
 import { projectIntentCaptureInput } from './intent-capture.js';
-import { filterAuthorizedTools } from './tool-authorization.js';
+import { filterDiscoverableTools, toolSecuritySchemes, } from './tool-discovery.js';
 import { projectWidgetResourceMeta, } from './widget/domain-projection.js';
 import { injectWidgetBridge } from './widget/inject.js';
 export { mapExecutionError } from './execution-error-mapping.js';
 /** Map a resolved artifact tool to an MCP tool descriptor (carrying its `_meta` extension bag, if any). */
 export function mapTool(tool, options) {
-    return {
+    return withToolAuthentication({
         name: tool.name,
         ...(tool.title !== undefined ? { title: tool.title } : {}),
         description: tool.description,
         inputSchema: projectIntentCaptureInput(withPortableInteractionInput(tool), options?.intentCapture === true),
         ...(tool.outputSchema !== undefined ? { outputSchema: tool.outputSchema } : {}),
         ...(tool.annotations !== undefined ? { annotations: tool.annotations } : {}),
-        ...(tool._meta !== undefined ? { _meta: tool._meta } : {}),
-    };
+        ...(tool._meta === undefined ? {} : { _meta: tool._meta }),
+    }, tool, options?.authentication);
+}
+function withToolAuthentication(descriptor, tool, policy) {
+    if (policy !== 'mixed-customer')
+        return descriptor;
+    const securitySchemes = toolSecuritySchemes(tool);
+    return { ...descriptor, securitySchemes, _meta: { ...descriptor._meta, securitySchemes } };
 }
 const PORTABLE_INTERACTION_INPUT_SCHEMA = {
     type: 'object',
@@ -65,10 +71,12 @@ export function mapToolsList(artifact, caller, options) {
     assertNoContextToolCollision(artifact);
     return {
         tools: [
-            ...filterAuthorizedTools(artifact.tools, caller).map((tool) => mapTool(tool, options)),
-            ...(artifactDeclaresContext(artifact) ? [CONTEXT_TOOL_DESCRIPTOR] : []),
+            ...filterDiscoverableTools(artifact.tools, caller).map((tool) => mapTool(tool, options)),
+            ...(artifactDeclaresContext(artifact)
+                ? [withToolAuthentication(CONTEXT_TOOL_DESCRIPTOR, {}, options?.authentication)]
+                : []),
             ...(options?.knowledgeTools === true
-                ? knowledgeToolDescriptors(artifact, options?.intentCapture === true)
+                ? knowledgeToolDescriptors(artifact, options?.intentCapture === true).map((descriptor) => withToolAuthentication(descriptor, {}, options?.authentication))
                 : []),
         ],
     };

package/node_modules/@noodle-borg/protocol/dist/sdk-server.d.ts

@@ -18,6 +18,8 @@ export interface ServedArtifact {
     readonly appPackageSnapshot?: AppPackageSnapshotV1;
 }
 export interface ProtocolRequestContext {
+    /** Resolved endpoint policy used only to derive MCP discovery metadata. */
+    readonly toolAuthentication?: import('./tool-discovery.js').ToolAuthenticationPolicy;
     readonly caller?: CallerIdentity;
     /** Internal hosting attribution, never MCP payload metadata or caller-visible context. */
     readonly publicAdmission?: NonNullable<ExecuteDeps['publicAdmission']>;

package/node_modules/@noodle-borg/protocol/dist/tool-discovery.d.ts

@@ -0,0 +1,14 @@
+import type { ArtifactTool } from '@noodle-borg/compiler';
+import { type ToolAuthorizationCaller } from './tool-authorization.js';
+/** The hosting plane opts into schemes only for the resolved mixed customer policy. */
+export type ToolAuthenticationPolicy = 'mixed-customer';
+export type ToolSecurityScheme = {
+    readonly type: 'noauth';
+} | {
+    readonly type: 'oauth2';
+    readonly scopes: readonly string[];
+};
+/** Descriptor publication only; execution and non-MCP capability filters remain authorization-only. */
+export declare function filterDiscoverableTools(tools: readonly ArtifactTool[], caller: ToolAuthorizationCaller | undefined): readonly ArtifactTool[];
+export declare function toolSecuritySchemes(tool: Pick<ArtifactTool, 'authorization'>): readonly ToolSecurityScheme[];
+//# sourceMappingURL=tool-discovery.d.ts.map

package/node_modules/@noodle-borg/protocol/dist/tool-discovery.js

@@ -0,0 +1,12 @@
+import { evaluateToolAuthorization } from './tool-authorization.js';
+/** Descriptor publication only; execution and non-MCP capability filters remain authorization-only. */
+export function filterDiscoverableTools(tools, caller) {
+    return tools.filter((tool) => tool.authorization?.discovery === 'public' ||
+        evaluateToolAuthorization(tool.authorization, caller).allow);
+}
+export function toolSecuritySchemes(tool) {
+    return tool.authorization === undefined
+        ? [{ type: 'noauth' }]
+        : [{ type: 'oauth2', scopes: tool.authorization.requiredScopes ?? [] }];
+}
+//# sourceMappingURL=tool-discovery.js.map

package/node_modules/@noodle-borg/protocol/dist/v2/server.js

@@ -93,6 +93,9 @@ function registerV2Tools(server, artifact, deps, context, era) {
         const mapped = mapToolsList(artifact, context.caller, {
             knowledgeTools: await knowledgeToolsEnabled(artifact, deps),
             intentCapture: context.intentCapture?.enabled === true,
+            ...(context.toolAuthentication === undefined
+                ? {}
+                : { authentication: context.toolAuthentication }),
         });
         return (era === 'modern' ? shapeModernToolsList(mapped) : mapped);
     });

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

@@ -1,12 +1,14 @@
+import { MIXED_CUSTOMER_AUTH_FEATURE_VERSION, serviceInfoResponseSchema, } from '@noodle-borg/wire-contracts';
 export function serviceInfoPayload(buildInfo, developerMcp) {
-    return {
+    return serviceInfoResponseSchema.parse({
         ok: true,
         status: 'ok',
         ...buildInfo,
+        features: { mixedCustomerAuth: MIXED_CUSTOMER_AUTH_FEATURE_VERSION },
         ...(developerMcp
             ? { developerPlugin: { mcpCapabilityVersion: DEVELOPER_MCP_CAPABILITY_VERSION } }
             : {}),
-    };
+    });
 }
 export function cliCompatibilityError(buildInfo, cliVersion) {
     const supported = buildInfo.compatiblePackageVersions?.['@noodleseed/one'];

package/node_modules/@noodle-borg/service/dist/customer-auth-audience-binding.js

@@ -1,3 +1,12 @@
+import { usesCustomerAuthentication } from '@noodle-borg/module';
+/** Match durable ownership, including an omitted stored projection when compilation declares auth. */
+export function requiresCustomerAuthProjection(record, compiledAuth) {
+    return usesCustomerAuthentication({
+        schemaVersion: record.schemaVersion,
+        accessMode: record.accessMode,
+        hasServerAuth: record.serverAuth != null || compiledAuth !== undefined,
+    });
+}
 /** Safe lifecycle error; tenant identities and configured values never enter its public message. */
 export class CustomerAuthAudienceConflictError extends Error {
     code = 'customer_auth_audience_conflict';
@@ -51,7 +60,7 @@ export function isTenantAuthConfig(value) {
 }
 /** Customer-serving records must exactly project the compiler-authoritative auth declaration. */
 export function hasExactCustomerAuthProjection(record, compiledAuth) {
-    if (record.accessMode !== 'customers')
+    if (!requiresCustomerAuthProjection(record, compiledAuth))
         return true;
     if (compiledAuth === undefined || !isTenantAuthConfig(record.serverAuth))
         return false;
@@ -65,7 +74,7 @@ export function hasExactCustomerAuthProjection(record, compiledAuth) {
 }
 /** Require an exact compiler-authenticated snapshot before clearing customer app archive stamps. */
 export function assertCustomerAuthRestorePrecondition(records, precondition) {
-    const candidates = records.filter((record) => record.active && record.accessMode === 'customers');
+    const candidates = records.filter((record) => record.active && requiresCustomerAuthProjection(record));
     const projections = precondition?.customerAuthProjections ?? [];
     if (candidates.length !== projections.length) {
         throw new CustomerAuthAudienceProjectionError();
@@ -107,7 +116,7 @@ export function findActiveCustomerAuthAudienceConflict(records, tenant, auth) {
     for (const record of records) {
         if (!record.active ||
             record.archivedAt !== undefined ||
-            record.accessMode !== 'customers' ||
+            !requiresCustomerAuthProjection(record) ||
             sameTenant(record, tenant)) {
             continue;
         }
@@ -124,7 +133,9 @@ export function findActiveCustomerAuthAudienceConflict(records, tenant, auth) {
 export function assertUniqueActiveCustomerAuthAudienceBindings(records) {
     const owners = new Map();
     for (const record of records) {
-        if (!record.active || record.archivedAt !== undefined || record.accessMode !== 'customers') {
+        if (!record.active ||
+            record.archivedAt !== undefined ||
+            !requiresCustomerAuthProjection(record)) {
             continue;
         }
         if (!isTenantAuthConfig(record.serverAuth)) {
@@ -143,7 +154,7 @@ export function assertUniqueActiveCustomerAuthAudienceBindings(records) {
 }
 /** Shared registry guard with an optimized durable-store path and an in-memory fallback. */
 export async function hasActiveCustomerAuthAudienceConflict(store, records, record, auth) {
-    if (record.accessMode !== 'customers' || auth === undefined || auth.kind === 'bridge')
+    if (!requiresCustomerAuthProjection(record, auth) || auth === undefined || auth.kind === 'bridge')
         return false;
     const tenant = { org: record.orgSlug, app: record.appSlug, env: record.environment };
     const conflict = store?.findActiveCustomerAuthAudienceConflict !== undefined

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

@@ -0,0 +1,24 @@
+import { parse as parseYaml } from 'yaml';
+export function isIdentityAccessMode(accessMode, manifest) {
+    if (accessMode === 'mixed' && manifest !== undefined) {
+        try {
+            const parsed = parseYaml(manifest);
+            if (typeof parsed === 'object' && parsed !== null && 'server' in parsed) {
+                const server = parsed.server;
+                if (typeof server === 'object' &&
+                    server !== null &&
+                    'auth' in server &&
+                    server.auth != null)
+                    return true;
+            }
+        }
+        catch {
+            /* Compilation owns malformed manifest diagnostics. */
+        }
+    }
+    return (accessMode === 'owner-only' ||
+        accessMode === 'org-members' ||
+        accessMode === 'customers' ||
+        accessMode === 'authenticated');
+}
+//# sourceMappingURL=deployment-access-mode.js.map

package/node_modules/@noodle-borg/service/dist/deployment-activation-precondition.js

@@ -0,0 +1,27 @@
+import { isDeepStrictEqual } from 'node:util';
+/** Compare inside the lifecycle lock/transaction, before any projection or active-pointer writes. */
+export function matchesDeploymentActivation(target, precondition) {
+    if (target.schemaVersion !== (precondition?.expectedSchemaVersion ?? 1))
+        return false;
+    if (precondition === undefined)
+        return true;
+    if (target.accessMode !== precondition.expectedAccessMode)
+        return false;
+    const expected = precondition.expectedRevision;
+    if (expected === undefined)
+        return true;
+    // These are all persisted compile inputs plus the authority and lifecycle state used by the target.
+    // Active status may legitimately change on repeated activation; it is not an executable input.
+    return [
+        'manifest',
+        'connectors',
+        'hostedAssets',
+        'serverAuth',
+        'serverVersion',
+        'ownerSubject',
+        'createdBySubject',
+        'orgMembershipSources',
+        'archivedAt',
+    ].every((key) => isDeepStrictEqual(target[key], expected[key]));
+}
+//# sourceMappingURL=deployment-activation-precondition.js.map

package/node_modules/@noodle-borg/service/dist/deployment-authentication.js

@@ -0,0 +1,19 @@
+import { usesCustomerAuthentication } from '@noodle-borg/module';
+import { deploymentRecordVersionError } from './deployment-record-version.js';
+/** Read the effective authentication authority only when this runtime understands the record. */
+export function deploymentAuthenticationFor(record, compiledAuth) {
+    if (deploymentRecordVersionError(record) !== undefined || record.accessMode === undefined) {
+        return undefined;
+    }
+    if (record.accessMode === 'public')
+        return 'none';
+    if (usesCustomerAuthentication({
+        schemaVersion: record.schemaVersion,
+        accessMode: record.accessMode,
+        hasServerAuth: record.serverAuth !== undefined || compiledAuth !== undefined,
+    })) {
+        return 'customer';
+    }
+    return 'platform';
+}
+//# sourceMappingURL=deployment-authentication.js.map

package/node_modules/@noodle-borg/service/dist/deployment-execution.js

@@ -1,8 +1,8 @@
 import { cspFaultsInManifest } from '@noodle-borg/compiler';
 import { noopLogger } from '@noodle-borg/transport-http';
 import { BUSINESS_SETUP_MESSAGE, BusinessOnboarding } from './business-onboarding.js';
+import { isIdentityAccessMode } from './deployment-access-mode.js';
 import { manifestUsesUserRoot } from './registry-access.js';
-import { isIdentityAccessMode } from './routes/access-mode.js';
 import { provisionPublicEmbed } from './routes/deploy-public-embed.js';
 import { deploymentActivationRejection } from './routes/deployment-activation-response.js';
 /** Shared post-authorization deploy flow. Both API deploys and installations retain registry activation hooks. */
@@ -42,7 +42,7 @@ export async function executeAuthorizedDeployment(input, dependencies) {
     }
     // Identity access modes bind the data plane to verified identity, so the deployer must be authenticated.
     // (Localhost dev runs the gate open; such deploys are rejected for lack of an owner/audit actor.)
-    if (isIdentityAccessMode(accessMode) && !identity) {
+    if (isIdentityAccessMode(accessMode, manifest) && !identity) {
         return reject(401, {
             error: `${accessMode} deployments require an authenticated deployer`,
         });

package/node_modules/@noodle-borg/service/dist/deployment-record-version.js

@@ -0,0 +1,55 @@
+import { sameDeploymentScope } from './deployment-versioning.js';
+const VERSION_ERROR = {
+    code: 'unsupported_deployment_record_version',
+    path: 'schemaVersion',
+    message: 'Deployment record version is not supported by this runtime.',
+};
+export class UnsupportedDeploymentRecordVersionError extends Error {
+    code = VERSION_ERROR.code;
+    constructor() {
+        super(VERSION_ERROR.message);
+        this.name = 'UnsupportedDeploymentRecordVersionError';
+    }
+}
+/** R1 serves the two understood policy versions; future policy remains unavailable. */
+export function deploymentRecordVersionError(record) {
+    return record.schemaVersion === 1 || record.schemaVersion === 2 ? undefined : VERSION_ERROR;
+}
+/** A stale writer cannot replace or deactivate a newer policy, even after registry preflight. */
+export function assertDeploymentAppendVersion(records, candidate) {
+    if (records.some((record) => record.schemaVersion > candidate.schemaVersion &&
+        (record.deploymentId === candidate.deploymentId ||
+            (candidate.active &&
+                record.active &&
+                record.archivedAt === undefined &&
+                sameDeploymentScope(record, candidate)))))
+        throw new UnsupportedDeploymentRecordVersionError();
+}
+export function unsupportedDeploymentRecordFailure() {
+    return { ok: false, errors: [VERSION_ERROR] };
+}
+/** Reject a deployment compiled against an operator policy that has since changed. */
+export class DeploymentPolicyChangedError extends Error {
+    code = 'deployment_policy_changed';
+    constructor() {
+        super('The active deployment policy changed. Retry the deployment.');
+    }
+}
+export function assertDeploymentAppendPolicy(records, candidate, precondition) {
+    if (precondition === undefined)
+        return;
+    const current = records.find((record) => record.active && record.archivedAt === undefined && sameDeploymentScope(record, candidate));
+    const expected = precondition.active;
+    if (expected === null
+        ? current !== undefined
+        : current === undefined ||
+            current.deploymentId !== expected.deploymentId ||
+            current.schemaVersion !== expected.schemaVersion ||
+            current.accessMode !== expected.accessMode ||
+            current.ownerSubject !== expected.ownerSubject ||
+            current.manifest !== expected.manifest ||
+            JSON.stringify(current.serverAuth) !== JSON.stringify(expected.serverAuth)) {
+        throw new DeploymentPolicyChangedError();
+    }
+}
+//# sourceMappingURL=deployment-record-version.js.map

package/node_modules/@noodle-borg/service/dist/developer-mcp/inspection.js

@@ -8,7 +8,21 @@ export async function inspectServiceDeployment(registry, tenant, baseUrl, endpoi
     return {
         ok: true,
         target: status.target,
-        deployment: status.deployment,
+        // Keep the Developer MCP port projection explicit as status gains additive operator fields.
+        deployment: {
+            deploymentId: status.deployment.deploymentId,
+            endpointUrl: status.deployment.endpointUrl,
+            active: status.deployment.active,
+            serverName: status.deployment.serverName,
+            createdAt: status.deployment.createdAt,
+            ...(status.deployment.createdByEmail === undefined
+                ? {}
+                : { createdByEmail: status.deployment.createdByEmail }),
+            accessMode: status.deployment.accessMode,
+            ...(status.deployment.ownerSubject === undefined
+                ? {}
+                : { ownerSubject: status.deployment.ownerSubject }),
+        },
         health: {
             state: status.health.state,
             missingSecrets: status.config.missingSecrets,