proteum 2.2.8 → 2.3.0

package/server/services/router/http/cache.ts

@@ -0,0 +1,116 @@
+import path from 'path';
+
+export type THttpCacheHeadersConfig = {
+    cacheControl?: string;
+    surrogateControl?: string | false;
+};
+
+export type TPublicAssetsCacheConfig = {
+    dev?: string;
+    versioned?: string;
+    unversioned?: string;
+    etag?: boolean;
+    lastModified?: boolean;
+};
+
+export type THttpCacheConfig = {
+    html?: {
+        dynamic?: THttpCacheHeadersConfig;
+        static?: THttpCacheHeadersConfig;
+    };
+    publicAssets?: TPublicAssetsCacheConfig;
+};
+
+export type TResolvedHttpCacheHeadersConfig = {
+    cacheControl: string;
+    surrogateControl: string | false;
+};
+
+export type TResolvedPublicAssetsCacheConfig = {
+    dev: string;
+    versioned: string;
+    unversioned: string;
+    etag?: boolean;
+    lastModified?: boolean;
+};
+
+export type TResolvedHttpCacheConfig = {
+    html: {
+        dynamic: TResolvedHttpCacheHeadersConfig;
+        static: TResolvedHttpCacheHeadersConfig;
+    };
+    publicAssets: TResolvedPublicAssetsCacheConfig;
+};
+
+export const defaultHttpCacheConfig = {
+    html: {
+        dynamic: {
+            cacheControl: 'no-store, no-cache, must-revalidate, proxy-revalidate',
+            surrogateControl: 'no-store',
+        },
+        static: {
+            cacheControl: 'public, max-age=0, must-revalidate',
+            surrogateControl: false,
+        },
+    },
+    publicAssets: {
+        dev: 'no-store',
+        versioned: 'public, max-age=31536000, immutable',
+        unversioned: 'public, max-age=0, must-revalidate',
+    },
+} satisfies TResolvedHttpCacheConfig;
+
+type TPublicAssetRequest = {
+    originalUrl?: string;
+    url?: string;
+};
+
+type TPublicAssetResponse = {
+    req?: TPublicAssetRequest;
+};
+
+const hashedPublicAssetPattern = /(^|[-_.])[a-f0-9]{6,}(?=(\.[^.]+)+$)/i;
+
+export const resolveHttpCacheConfig = (config?: THttpCacheConfig): TResolvedHttpCacheConfig => ({
+    html: {
+        dynamic: {
+            ...defaultHttpCacheConfig.html.dynamic,
+            ...(config?.html?.dynamic || {}),
+        },
+        static: {
+            ...defaultHttpCacheConfig.html.static,
+            ...(config?.html?.static || {}),
+        },
+    },
+    publicAssets: {
+        ...defaultHttpCacheConfig.publicAssets,
+        ...(config?.publicAssets || {}),
+    },
+});
+
+export const isVersionedPublicAssetRequest = (
+    res: undefined | TPublicAssetResponse,
+    filePath: string,
+) => {
+    const requestUrl = res?.req?.originalUrl || res?.req?.url || '';
+    const searchParams = new URL(requestUrl, 'http://proteum.local').searchParams;
+    if (searchParams.has('v')) return true;
+
+    return hashedPublicAssetPattern.test(path.basename(filePath));
+};
+
+export const resolvePublicAssetCacheControl = ({
+    res,
+    filePath,
+    profile,
+    cache,
+}: {
+    res: undefined | TPublicAssetResponse;
+    filePath: string;
+    profile: string;
+    cache: TResolvedPublicAssetsCacheConfig;
+}) => {
+    if (profile === 'dev') return cache.dev;
+
+    return isVersionedPublicAssetRequest(res, filePath) ? cache.versioned : cache.unversioned;
+};

package/server/services/router/http/index.ts

@@ -8,7 +8,10 @@ import express from 'express';
 import http from 'http';
 import https from 'https';
 import path from 'path';
+import { randomUUID } from 'crypto';
 import cors, { CorsOptions } from 'cors';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
 
 // Middlewares (npm)
 import morgan from 'morgan';
@@ -37,9 +40,16 @@ import {
     parseConnectedProjectProxyPath,
 } from '@common/connectedProjects';
 import { profilerTraceRequestIdHeader } from '@common/dev/profiler';
+import { createProteumMcpServer } from '@common/dev/mcpServer';
+import { createRuntimeProteumMcpProvider } from '@server/app/devMcp';
 
 // Middlewaees (core)
 import { isMutipart, MiddlewareFormData } from './multipart';
+import {
+    resolveHttpCacheConfig,
+    resolvePublicAssetCacheControl,
+    type THttpCacheConfig,
+} from './cache';
 
 /*----------------------------------
 - CONFIG
@@ -58,12 +68,15 @@ export type Config = {
         maxSize: string; // Expression package bytes
     };
     csp: { default?: string[]; styles?: string[]; images?: string[]; scripts: string[] };
+    cache?: THttpCacheConfig;
     cors?: CorsOptions;
     helmet?: Parameters<typeof helmet>[0];
 };
 
 export type Hooks = {};
 
+export { resolveHttpCacheConfig, type THttpCacheConfig } from './cache';
+
 type TContentSecurityPolicyOptions = NonNullable<Parameters<typeof helmet.contentSecurityPolicy>[0]>;
 type TContentSecurityPolicyDirectives = NonNullable<TContentSecurityPolicyOptions['directives']>;
 type TDevSessionAuthService = {
@@ -94,37 +107,9 @@ const createContentSecurityPolicy = (config: Config['csp']): TContentSecurityPol
     };
 };
 
-const immutablePublicAssetCacheControl = 'public, max-age=31536000, immutable';
-const devPublicAssetCacheControl = 'no-store';
-const revalidatedPublicAssetCacheControl = 'public, max-age=0, must-revalidate';
-const hashedPublicAssetPattern = /(^|[-_.])[a-f0-9]{6,}(?=(\.[^.]+)+$)/i;
 const connectedProjectBootRetryCount = 10;
 const connectedProjectBootRetryDelayMs = 5_000;
 
-const isVersionedPublicAssetRequest = (res: undefined | express.Response | http.ServerResponse, filePath: string) => {
-    const request =
-        res && typeof res === 'object' && 'req' in res
-            ? ((res as express.Response | (http.ServerResponse & { req?: express.Request })).req ?? undefined)
-            : undefined;
-    const requestUrl = request?.originalUrl || request?.url || '';
-    const searchParams = new URL(requestUrl, 'http://proteum.local').searchParams;
-    if (searchParams.has('v')) return true;
-
-    return hashedPublicAssetPattern.test(path.basename(filePath));
-};
-
-const resolvePublicAssetCacheControl = ({
-    res,
-    filePath,
-    profile,
-}: {
-    res: undefined | express.Response | http.ServerResponse;
-    filePath: string;
-    profile: string;
-}) => {
-    if (profile === 'dev') return devPublicAssetCacheControl;
-    return isVersionedPublicAssetRequest(res, filePath) ? immutablePublicAssetCacheControl : revalidatedPublicAssetCacheControl;
-};
 const wait = async (durationMs: number) =>
     await new Promise<void>((resolve) => {
         setTimeout(resolve, durationMs);
@@ -406,20 +391,22 @@ export default class HttpServer<TRouter extends TServerRouter = TServerRouter> {
         // Normalement, seulement utile pour le mode production,
         // Quand mode debug, les ressources client semblent servies par le dev middlewae
         // Sauf que les ressources serveur ne semblent pas trouvées par le dev-middleware
-        const disablePublicAssetCaching = this.app.env.profile === 'dev';
+        const publicAssetCache = resolveHttpCacheConfig(this.config.cache).publicAssets;
+        const defaultPublicAssetValidators = this.app.env.profile !== 'dev';
+        const publicAssetEtag = publicAssetCache.etag ?? defaultPublicAssetValidators;
+        const publicAssetLastModified = publicAssetCache.lastModified ?? defaultPublicAssetValidators;
+
         routes.use(compression());
         routes.use('/public', cors());
         routes.use(
             '/public',
             express.static(path.join(Container.path.root, APP_OUTPUT_DIR, 'public'), {
                 dotfiles: 'deny',
-                etag: !disablePublicAssetCaching,
-                lastModified: !disablePublicAssetCaching,
+                etag: publicAssetEtag,
+                lastModified: publicAssetLastModified,
                 setHeaders: (res, filePath) => {
-                    if (disablePublicAssetCaching) {
-                        res.removeHeader('ETag');
-                        res.removeHeader('Last-Modified');
-                    }
+                    if (!publicAssetEtag) res.removeHeader('ETag');
+                    if (!publicAssetLastModified) res.removeHeader('Last-Modified');
 
                     res.setHeader(
                         'Cache-Control',
@@ -427,6 +414,7 @@ export default class HttpServer<TRouter extends TServerRouter = TServerRouter> {
                             res,
                             filePath,
                             profile: this.app.env.profile,
+                            cache: publicAssetCache,
                         }),
                     );
                 },
@@ -510,6 +498,8 @@ export default class HttpServer<TRouter extends TServerRouter = TServerRouter> {
     private registerDevTraceRoutes(routes: express.Express) {
         if (!__DEV__ || this.app.env.profile !== 'dev') return;
 
+        this.registerDevMcpRoute(routes);
+
         if (this.app.container.Trace.isDevTraceEnabled()) {
             routes.get('/__proteum/trace/requests', (req, res) => {
                 const rawLimit = Array.isArray(req.query.limit) ? req.query.limit[0] : req.query.limit;
@@ -836,4 +826,73 @@ export default class HttpServer<TRouter extends TServerRouter = TServerRouter> {
     private getCronManager() {
         return (this.app as typeof this.app & { Cron?: CronManager }).Cron;
     }
+
+    private registerDevMcpRoute(routes: express.Express) {
+        type TMcpTransportEntry = {
+            server: ReturnType<typeof createProteumMcpServer>;
+            transport: StreamableHTTPServerTransport;
+        };
+        const transports = new Map<string, TMcpTransportEntry>();
+        const readSessionId = (req: express.Request) => {
+            const value = req.headers['mcp-session-id'];
+            if (Array.isArray(value)) return value[0];
+            return typeof value === 'string' && value.trim() ? value : undefined;
+        };
+        const writeJsonRpcError = (res: express.Response, statusCode: number, message: string) => {
+            res.status(statusCode).json({
+                jsonrpc: '2.0',
+                error: {
+                    code: -32000,
+                    message,
+                },
+                id: null,
+            });
+        };
+
+        routes.all('/__proteum/mcp', async (req, res) => {
+            const sessionId = readSessionId(req);
+            let entry = sessionId ? transports.get(sessionId) : undefined;
+
+            try {
+                if (!entry && !sessionId && req.method === 'POST' && isInitializeRequest(req.body)) {
+                    const provider = createRuntimeProteumMcpProvider({
+                        app: this.app,
+                        publicUrl: this.publicUrl,
+                        routerPort: this.config.port,
+                    });
+                    const server = createProteumMcpServer({
+                        provider,
+                        version: String(process.env.npm_package_version || 'runtime'),
+                    });
+                    const transport = new StreamableHTTPServerTransport({
+                        sessionIdGenerator: () => randomUUID(),
+                        onsessioninitialized: (initializedSessionId) => {
+                            transports.set(initializedSessionId, { server, transport });
+                        },
+                    });
+
+                    transport.onclose = () => {
+                        const transportSessionId = transport.sessionId;
+                        if (transportSessionId) transports.delete(transportSessionId);
+                        void server.close().catch(() => undefined);
+                    };
+
+                    await server.connect(transport);
+                    entry = { server, transport };
+                }
+
+                if (!entry) {
+                    writeJsonRpcError(res, 400, 'Bad Request: initialize the Proteum MCP session before sending tool or resource requests.');
+                    return;
+                }
+
+                await entry.transport.handleRequest(req, res, req.body);
+            } catch (error) {
+                console.error('Error handling Proteum MCP request:', error);
+                if (!res.headersSent) {
+                    writeJsonRpcError(res, 500, 'Internal Proteum MCP server error.');
+                }
+            }
+        });
+    }
 }

package/server/services/router/index.ts

@@ -52,7 +52,7 @@ import { AnyRouterService } from './service';
 import ServerRequest from './request';
 import ServerResponse, { TRouterContext, TRouterContextServices } from './response';
 import Page from './response/page';
-import HTTP, { Config as HttpServiceConfig } from './http';
+import HTTP, { Config as HttpServiceConfig, resolveHttpCacheConfig } from './http';
 import DocumentRenderer from './response/page/document';
 import { loadGeneratedRuntimeBundle } from './generatedRuntime';
 
@@ -97,9 +97,6 @@ export type TApiResponseData = { data: any; triggers?: { [cle: string]: any } };
 
 export type HttpHeaders = { [cle: string]: string };
 
-const dynamicHtmlCacheControl = 'no-store, no-cache, must-revalidate, proxy-revalidate';
-const staticHtmlCacheControl = 'public, max-age=0, must-revalidate';
-
 /*----------------------------------
 - SERVICE CONFIG
 ----------------------------------*/
@@ -1136,15 +1133,15 @@ export default class ServerRouter<
     }
 
     private applyHtmlCacheHeaders(res: express.Response, isStaticHtml: boolean) {
-        if (isStaticHtml) {
+        const cache = resolveHttpCacheConfig(this.config.http.cache);
+        const htmlCache = isStaticHtml ? cache.html.static : cache.html.dynamic;
+
+        if (htmlCache.surrogateControl === false) {
             res.removeHeader('Surrogate-Control');
-            res.setHeader('Cache-Control', staticHtmlCacheControl);
-            return;
+        } else {
+            res.setHeader('Surrogate-Control', htmlCache.surrogateControl);
         }
 
-        // Don't cache dynamic HTML, because updated releases can change asset hashes.
-        // https://github.com/helmetjs/nocache/blob/main/index.ts
-        res.setHeader('Surrogate-Control', 'no-store');
-        res.setHeader('Cache-Control', dynamicHtmlCacheControl);
+        res.setHeader('Cache-Control', htmlCache.cacheControl);
     }
 }

package/tests/agents-utils.test.cjs

@@ -24,7 +24,17 @@ const createCoreFixture = () => {
 
     writeFile(path.join(agentsRoot, 'AGENTS.md'), '# Root Contract\n\n- Root rule\n');
     writeFile(path.join(agentsRoot, 'CODING_STYLE.md'), '# Coding Style\n\n- Style rule\n');
+    writeFile(path.join(agentsRoot, 'diagnostics.md'), '# Diagnostics\n\n- Diagnostics rule\n');
+    writeFile(path.join(agentsRoot, 'optimizations.md'), '# Optimizations\n\n- Optimization rule\n');
     writeFile(path.join(agentsRoot, 'client', 'AGENTS.md'), '# Client Rules\n\n- Client rule\n');
+    writeFile(path.join(agentsRoot, 'client', 'pages', 'AGENTS.md'), '# Page Rules\n\n- Page rule\n');
+    writeFile(path.join(agentsRoot, 'server', 'routes', 'AGENTS.md'), '# Route Rules\n\n- Route rule\n');
+    writeFile(path.join(agentsRoot, 'server', 'services', 'AGENTS.md'), '# Service Rules\n\n- Service rule\n');
+    writeFile(path.join(agentsRoot, 'tests', 'e2e', 'AGENTS.md'), '# E2E Rules\n\n- E2E rule\n');
+    writeFile(
+        path.join(agentsRoot, 'tests', 'e2e', 'REAL_WORLD_JOURNEY_TESTS.md'),
+        '# Real World Journey Tests\n\n- Journey rule\n',
+    );
 
     return root;
 };
@@ -52,7 +62,7 @@ const createAppFixture = () => {
     return appRoot;
 };
 
-test('standalone configure creates tracked instruction files with embedded corpus', () => {
+test('standalone configure creates tracked instruction files with routing contract and split docs', () => {
     const coreRoot = createCoreFixture();
     const appRoot = createAppFixture();
     const result = configureProjectAgentInstructions({ appRoot, coreRoot });
@@ -63,10 +73,16 @@ test('standalone configure creates tracked instruction files with embedded corpu
     assert.equal(result.blocked.length, 0);
     assert.match(agentsContent, /^# Proteum Instructions/m);
     assert.match(agentsContent, /<!-- proteum-instructions:start -->/);
-    assert.match(agentsContent, /## Source: AGENTS\.md/);
-    assert.match(agentsContent, /## Root Contract/);
-    assert.match(agentsContent, /## Source: CODING_STYLE\.md/);
-    assert.match(codingStyleContent, /## Source: client\/AGENTS\.md/);
+    assert.match(agentsContent, /## Agent Routing Contract/);
+    assert.match(agentsContent, /npx proteum orient <query>/);
+    assert.doesNotMatch(agentsContent, /## Source: CODING_STYLE\.md/);
+    assert.match(codingStyleContent, /## Source: CODING_STYLE\.md/);
+    assert.match(codingStyleContent, /## Coding Style/);
+    assert.doesNotMatch(codingStyleContent, /## Source: client\/AGENTS\.md/);
+    assert.equal(fs.existsSync(path.join(appRoot, 'tests', 'e2e', 'AGENTS.md')), true);
+    assert.equal(fs.existsSync(path.join(appRoot, 'tests', 'e2e', 'REAL_WORLD_JOURNEY_TESTS.md')), true);
+    assert.match(fs.readFileSync(path.join(appRoot, 'tests', 'e2e', 'REAL_WORLD_JOURNEY_TESTS.md'), 'utf8'), /Journey rule/);
+    assert.doesNotMatch(fs.readFileSync(path.join(appRoot, 'tests', 'e2e', 'REAL_WORLD_JOURNEY_TESTS.md'), 'utf8'), /## Source: CODING_STYLE\.md/);
     assert.doesNotMatch(agentsContent, /Before reading or applying instructions from this file/);
     assert.doesNotMatch(gitignoreContent, /Proteum-managed instruction files/);
     assert.doesNotMatch(gitignoreContent, /^\/AGENTS\.md$/m);
@@ -102,7 +118,8 @@ test('configure preserves project content outside the managed section', () => {
     const content = fs.readFileSync(path.join(appRoot, 'AGENTS.md'), 'utf8');
     assert.match(content, /# Product Notes/);
     assert.match(content, /Keep this product note\./);
-    assert.match(content, /## Source: CODING_STYLE\.md/);
+    assert.match(content, /## Agent Routing Contract/);
+    assert.doesNotMatch(content, /## Source: CODING_STYLE\.md/);
     assert.doesNotMatch(content, /Old managed content/);
     assert.match(content, /# Local Footer/);
     assert.match(content, /Keep this footer\./);
@@ -144,7 +161,8 @@ test('configure preserves project content around legacy managed stubs', () => {
     assert.match(content, /## Product Bootstrap/);
     assert.match(content, /Keep these local bootstrap notes\./);
     assert.match(content, /# Proteum Instructions/);
-    assert.match(content, /## Source: CODING_STYLE\.md/);
+    assert.match(content, /## Agent Routing Contract/);
+    assert.doesNotMatch(content, /## Source: CODING_STYLE\.md/);
     assert.doesNotMatch(content, /# Proteum Managed Instructions/);
     assert.doesNotMatch(content, /Before reading or applying instructions from this file/);
     assert.match(content, /## Local Footer/);
@@ -159,15 +177,75 @@ test('monorepo configure writes root and app instruction files', () => {
     fs.mkdirSync(path.join(monorepoRoot, '.git'));
     fs.mkdirSync(path.join(appRoot, 'client'), { recursive: true });
 
+    configureProjectAgentInstructions({ appRoot, coreRoot });
+
     const result = configureProjectAgentInstructions({ appRoot, coreRoot, monorepoRoot });
 
     assert.equal(result.mode, 'monorepo');
     assert.equal(resolveProjectAgentMonorepoRoot(appRoot), fs.realpathSync(monorepoRoot));
-    assert.match(fs.readFileSync(path.join(monorepoRoot, 'AGENTS.md'), 'utf8'), /## Source: AGENTS\.md/);
-    assert.match(fs.readFileSync(path.join(appRoot, 'AGENTS.md'), 'utf8'), /## Source: client\/AGENTS\.md/);
+    assert.match(fs.readFileSync(path.join(monorepoRoot, 'AGENTS.md'), 'utf8'), /## Agent Routing Contract/);
+    assert.match(fs.readFileSync(path.join(monorepoRoot, 'CODING_STYLE.md'), 'utf8'), /## Source: CODING_STYLE\.md/);
+    assert.match(fs.readFileSync(path.join(monorepoRoot, 'diagnostics.md'), 'utf8'), /## Source: diagnostics\.md/);
+    assert.match(fs.readFileSync(path.join(monorepoRoot, 'optimizations.md'), 'utf8'), /## Source: optimizations\.md/);
+    assert.match(fs.readFileSync(path.join(monorepoRoot, 'tests', 'e2e', 'AGENTS.md'), 'utf8'), /## Source: tests\/e2e\/AGENTS\.md/);
+    assert.match(fs.readFileSync(path.join(monorepoRoot, 'tests', 'e2e', 'REAL_WORLD_JOURNEY_TESTS.md'), 'utf8'), /## Source: tests\/e2e\/REAL_WORLD_JOURNEY_TESTS\.md/);
+    assert.doesNotMatch(fs.readFileSync(path.join(monorepoRoot, 'tests', 'e2e', 'REAL_WORLD_JOURNEY_TESTS.md'), 'utf8'), /## Source: CODING_STYLE\.md/);
+    assert.equal(fs.existsSync(path.join(appRoot, 'tests', 'e2e', 'AGENTS.md')), false);
+    assert.match(fs.readFileSync(path.join(appRoot, 'AGENTS.md'), 'utf8'), /## Agent Routing Contract/);
+    assert.match(fs.readFileSync(path.join(appRoot, 'client', 'AGENTS.md'), 'utf8'), /## Source: client\/AGENTS\.md/);
+    assert.equal(fs.existsSync(path.join(appRoot, 'CODING_STYLE.md')), false);
+    assert.equal(fs.existsSync(path.join(appRoot, 'diagnostics.md')), false);
+    assert.equal(fs.existsSync(path.join(appRoot, 'optimizations.md')), false);
+    assert.equal(result.removed.some((entry) => entry.endsWith('/apps/product/CODING_STYLE.md')), true);
+});
+
+test('monorepo configure preserves local app-root documents', () => {
+    const coreRoot = createCoreFixture();
+    const monorepoRoot = makeTempRoot();
+    const appRoot = path.join(monorepoRoot, 'apps', 'product');
+    const localCodingStylePath = path.join(appRoot, 'CODING_STYLE.md');
+
+    fs.mkdirSync(path.join(monorepoRoot, '.git'));
+    writeFile(localCodingStylePath, '# Local Coding Style\n\n- Keep this app-local override.\n');
+
+    const result = configureProjectAgentInstructions({ appRoot, coreRoot, monorepoRoot });
+
+    assert.match(fs.readFileSync(path.join(monorepoRoot, 'CODING_STYLE.md'), 'utf8'), /## Source: CODING_STYLE\.md/);
+    assert.match(fs.readFileSync(localCodingStylePath, 'utf8'), /Keep this app-local override/);
+    assert.equal(result.removed.some((entry) => entry.endsWith('/apps/product/CODING_STYLE.md')), false);
+});
+
+test('monorepo configure strips retired managed sections from local app-root documents', () => {
+    const coreRoot = createCoreFixture();
+    const monorepoRoot = makeTempRoot();
+    const appRoot = path.join(monorepoRoot, 'apps', 'product');
+    const localCodingStylePath = path.join(appRoot, 'CODING_STYLE.md');
+
+    fs.mkdirSync(path.join(monorepoRoot, '.git'));
+    fs.mkdirSync(appRoot, { recursive: true });
+    configureProjectAgentInstructions({ appRoot, coreRoot });
+
+    const managedContent = fs.readFileSync(localCodingStylePath, 'utf8');
+    writeFile(
+        localCodingStylePath,
+        [
+            '# Local Coding Style',
+            '',
+            '- Keep this app-local override.',
+            '',
+            managedContent,
+        ].join('\n'),
+    );
+
+    const result = configureProjectAgentInstructions({ appRoot, coreRoot, monorepoRoot });
+    const retainedContent = fs.readFileSync(localCodingStylePath, 'utf8');
+
+    assert.match(retainedContent, /Keep this app-local override/);
+    assert.doesNotMatch(retainedContent, /proteum-instructions:start/);
+    assert.equal(result.updated.some((entry) => entry.endsWith('/apps/product/CODING_STYLE.md')), true);
 });
 
-test('configure migrates legacy managed symlinks to embedded files', () => {
+test('configure migrates legacy managed symlinks to tracked files', () => {
     const coreRoot = createCoreFixture();
     const appRoot = createAppFixture();
     const installedCoreRoot = createCoreFixture();
@@ -203,5 +281,5 @@ test('configure reports blocked paths unless overwrite is allowed', () => {
 
     assert.equal(result.overwritten.some((entry) => entry.endsWith('/CODING_STYLE.md')), true);
     assert.equal(fs.lstatSync(blockedPath).isFile(), true);
-    assert.match(fs.readFileSync(blockedPath, 'utf8'), /## Source: AGENTS\.md/);
+    assert.match(fs.readFileSync(blockedPath, 'utf8'), /## Source: CODING_STYLE\.md/);
 });