proteum 2.2.6 → 2.2.8

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

@@ -11,32 +11,30 @@ import {
     TAnyRoute,
     RouterService,
     TAnyRouter,
+    TServerRouter,
 } from '@server/services/router';
 
 import type { Application } from '@server/app/index';
+import AppContainer from '@server/app/container';
 
 import type { TRouterServiceArgs } from '@server/services/router/service';
 
 // Specific
 import type { default as UsersService, TAuthCheckConditions, TBasicUser } from '..';
-import UsersRequestService from './request';
-
-/*----------------------------------
-- TYPES
-----------------------------------*/
+import { createUsersRequestService, type TUsersRequestContext } from './request';
 
 /*----------------------------------
 - SERVICE
 ----------------------------------*/
 export default class AuthenticationRouterService<
-    TApplication extends Application = Application,
-    TUser extends TBasicUser = TApplication['app']['userType'],
-    TRouter extends TAnyRouter = TAnyRouter,
+    TApplication extends Application,
+    TUser extends TBasicUser,
+    TRouter extends TAnyRouter = TServerRouter,
     TRequest extends ServerRequest<TRouter> = ServerRequest<TRouter>,
 > extends RouterService<
     { users: UsersService<TUser, TApplication> },
     TRouter,
-    UsersRequestService<TRouter, TUser, TRequest>
+    TUsersRequestContext<TUser>
 > {
     /*----------------------------------
     - LIFECYCLE
@@ -45,7 +43,7 @@ export default class AuthenticationRouterService<
     public users: UsersService<TUser, TApplication>;
 
     public constructor(
-        getConfig: TRouterServiceArgs<{ users: UsersService<TUser, TApplication> }, TRouter>[0],
+        getConfig: TRouterServiceArgs<{ users: UsersService<TUser, TApplication> }>[0],
         app: TApplication,
     ) {
         super(getConfig, app);
@@ -59,11 +57,11 @@ export default class AuthenticationRouterService<
         details: Record<string, any>,
         minimumCapture: 'summary' | 'resolve' | 'deep' = 'resolve',
     ) {
-        this.app.container.Trace.record(
+        AppContainer.Trace.record(
             request.id,
             'auth.route',
             {
-                routePath: route.path || '',
+                routePath: 'path' in route ? route.path || '' : '',
                 routeId: route.options.id || '',
                 authInput: route.options.auth ?? null,
                 tracking: route.options.authTracking ?? null,
@@ -219,7 +217,7 @@ export default class AuthenticationRouterService<
     - ROUTER SERVICE LIFECYCLE
     ----------------------------------*/
 
-    public requestService(request: TRequest): UsersRequestService<TRouter, TUser, TRequest> {
-        return new UsersRequestService(request, this);
+    public requestService(request: TRequest): TUsersRequestContext<TUser> {
+        return createUsersRequestService(request, this.users);
     }
 }

package/server/services/auth/router/request.ts

@@ -2,13 +2,11 @@
 - DEPENDANCES
 ----------------------------------*/
 
-// Core
-import type { Request as ServerRequest, TAnyRouter } from '@server/services/router';
-import RequestService from '@server/services/router/request/service';
+import type { Application } from '@server/app/index';
 
 // Specific
-import type AuthenticationRouterService from '.';
-import type { TAuthCheckConditions, TAuthTrackingContext, TUserRole } from '..';
+import type UsersService from '..';
+import type { TAuthCheckConditions, TAuthRequest, TAuthTrackingContext, TUserRole } from '..';
 
 // Types
 import type { TBasicUser } from '@server/services/auth';
@@ -17,21 +15,36 @@ import type { TBasicUser } from '@server/services/auth';
 - TYPES
 ----------------------------------*/
 
+type TUsersRouterService<TUser extends TBasicUser> = {
+    users: UsersService<TUser, Application>;
+};
+
+export interface TUsersRequestContext<TUser extends TBasicUser> {
+    login(email: string): Promise<unknown>;
+    logout(): void;
+
+    check(): TUser;
+    check(conditions: null, tracking?: TAuthTrackingContext): TUser;
+    check(conditions: TAuthCheckConditions, tracking?: TAuthTrackingContext): TUser;
+    check(conditions: false, tracking?: TAuthTrackingContext): null;
+    check(role: TUserRole, feature: null): TUser;
+    check(role: false): null;
+    check(role: TUserRole | true, feature: FeatureKeys, action?: string): TUser;
+    check(role: false, feature: FeatureKeys, action?: string): null;
+}
+
 /*----------------------------------
 - MODULE
 ----------------------------------*/
 export default class UsersRequestService<
-    TRouter extends TAnyRouter,
     TUser extends TBasicUser,
-    TRequest extends ServerRequest<TRouter> = ServerRequest<TRouter>,
-> extends RequestService<TRequest> {
+    TRequest extends TAuthRequest,
+> implements TUsersRequestContext<TUser> {
     public constructor(
-        request: TRequest,
-        public auth: AuthenticationRouterService<TRouter['app'], TUser, TRouter, TRequest>,
+        public request: TRequest,
+        public auth: TUsersRouterService<TUser>,
         public users = auth.users,
-    ) {
-        super(request);
-    }
+    ) {}
 
     public login(email: string) {
         if (!this.users.login) throw new Error('The current auth service does not implement login().');
@@ -93,3 +106,11 @@ export default class UsersRequestService<
         return this.users.check(this.request, roleOrConditions, featureOrTracking, action);
     }
 }
+
+export const createUsersRequestService = <
+    TUser extends TBasicUser,
+    TRequest extends TAuthRequest,
+>(
+    request: TRequest,
+    users: UsersService<TUser, Application>,
+): TUsersRequestContext<TUser> => new UsersRequestService<TUser, TRequest>(request, { users });

package/server/services/disks/driver.ts

@@ -27,7 +27,7 @@ export type TDrivercnfig = {
 
 export type SourceFile = { name: string; path: string; modified: number; parentFolder: string; source: string };
 
-export type TOutputFileOptions = { encoding: string };
+export type TOutputFileOptions = { encoding: BufferEncoding };
 
 export type TReadFileOptions = { encoding?: 'string' | 'buffer'; withMetas?: boolean };
 

package/server/services/disks/index.ts

@@ -32,8 +32,6 @@ export default class DisksManager<
     TConfig extends Config & { default: keyof MountpointList & string; drivers: MountpointList },
     TApplication extends Application,
 > extends Service<TConfig, Hooks, TApplication, TApplication> {
-    public default!: MountpointList[keyof MountpointList & string];
-
     /*----------------------------------
     - LIFECYCLE
     ----------------------------------*/
@@ -50,10 +48,14 @@ export default class DisksManager<
             drivers[driverId].parent = this;
         }*/
 
-        const defaultDisk = drivers[this.config.default];
-        if (defaultDisk === undefined) console.log(`Default disk "${this.config.default as string}" not mounted.`);
+        this.default;
+    }
 
-        this.default = defaultDisk;
+    public get default(): Driver {
+        const drivers: Services = this.config.drivers;
+        const defaultDisk = drivers[this.config.default];
+        if (defaultDisk === undefined) throw new Error(`Default disk "${String(this.config.default)}" not mounted.`);
+        return defaultDisk;
     }
 
     public async shutdown() {}
@@ -62,13 +64,14 @@ export default class DisksManager<
     - LIFECYCLE
     ----------------------------------*/
 
-    public get(diskName?: 'default' | keyof MountpointList) {
+    public get(diskName?: 'default' | keyof MountpointList): Driver {
+        const drivers: Services = this.config.drivers;
         const disk =
             diskName === 'default' || diskName === undefined
                 ? this.default
-                : this.config.drivers[diskName as keyof MountpointList];
+                : drivers[String(diskName)];
 
-        if (disk === undefined) throw new Error(`Disk "${diskName as string}" not found.`);
+        if (disk === undefined) throw new Error(`Disk "${String(diskName)}" not found.`);
 
         return disk;
     }

package/server/services/email/index.ts

@@ -57,7 +57,7 @@ type TOptions = { transporter?: string };
 /*----------------------------------
 - FONCTIONS
 ----------------------------------*/
-export default abstract class Email<TConfig extends Config, TApplication extends Application = Application> extends Service<
+export default abstract class Email<TConfig extends Config, TApplication extends Application> extends Service<
     TConfig,
     Hooks,
     TApplication,

package/server/services/prisma/Facet.ts

@@ -1,9 +1,10 @@
-import type { PrismaClient } from '@models/types';
-
 export type TDelegate<R = unknown> = {
     findMany(args?: Record<string, unknown>): Promise<R[]>;
     findFirst(args?: Record<string, unknown>): Promise<R | null>;
 };
+type TPrismaRawClient = {
+    $queryRawUnsafe(query: string): Promise<Record<string, unknown>[]>;
+};
 
 export type TWithStats = { $table: string; $key: string } & Record<string, string>;
 
@@ -18,7 +19,7 @@ export default class Facet<
     RT = R,
 > {
     constructor(
-        private readonly prisma: PrismaClient,
+        private readonly prisma: TPrismaRawClient,
         private readonly delegate: D,
         private readonly subset: S,
         private readonly transform?: Transform<R, RT>,
@@ -57,13 +58,13 @@ export default class Facet<
             ), 0)) as ${key}`,
         );
 
-        const statRows = (await this.prisma.$queryRawUnsafe(`
+        const statRows = await this.prisma.$queryRawUnsafe(`
             SELECT ${$key}, ${select.join(', ')} 
             FROM ${$table} 
             WHERE ${$key} IN (
                 ${(results as Array<Record<string, unknown>>).map((row) => "'" + row[$key] + "'").join(',')}
             )
-        `)) as Record<string, unknown>[];
+        `);
 
         for (const stat of statRows) {
             for (const key in stat) {

package/server/services/router/index.ts

@@ -19,7 +19,8 @@ import zod, { ZodError } from 'zod';
 export { default as schema } from 'zod';
 
 // Core
-import Service, { AnyService, TServiceArgs } from '@server/app/service';
+import type { Application } from '@server/app/index';
+import Service, { TServiceArgs } from '@server/app/service';
 import context from '@server/context';
 import type DisksManager from '@server/services/disks';
 import { CoreError, InputError, NotFound, toJson as errorToJson } from '@common/errors';
@@ -104,16 +105,16 @@ const staticHtmlCacheControl = 'public, max-age=0, must-revalidate';
 ----------------------------------*/
 
 export type TAnyRouter = ServerRouter<
-    AnyService['app'],
+    Application,
     TRouterServicesList,
-    Config<TRouterServicesList, AnyService['app']>
+    Config<TRouterServicesList, Application>
 >;
 
 const LogPrefix = '[router]';
 
 export type Config<
     TServices extends TRouterServicesList,
-    TApplication extends AnyService['app'] = AnyService['app'],
+    TApplication extends Application = Application,
 > = {
     debug: boolean;
 
@@ -147,16 +148,16 @@ export type TControllerDefinition = {
 };
 
 export type TServerRouter = ServerRouter<
-    AnyService['app'],
+    Application,
     TRouterServicesList,
-    Config<TRouterServicesList, AnyService['app']>
+    Config<TRouterServicesList, Application>
 >;
 
 /*----------------------------------
 - CLASSE
 ----------------------------------*/
 export default class ServerRouter<
-        TApplication extends AnyService['app'] = AnyService['app'],
+        TApplication extends Application = Application,
         TServices extends TRouterServicesList = TRouterServicesList,
         TConfig extends Config<TServices, TApplication> = Config<TServices, TApplication>,
     >

package/server/services/router/request/validation/zod.ts

@@ -4,6 +4,8 @@ import zod from 'zod';
 export type TRichTextValidatorOptions = { attachements?: boolean };
 export type TValidationSchema = zod.ZodTypeAny;
 export type TValidationShape = zod.ZodRawShape;
+export type TInferValidationSchema<TSchema extends TValidationSchema> = zod.infer<TSchema>;
+export type TTypedValidationSchema<TOutput> = zod.ZodType<TOutput>;
 
 type TChoiceOption = { value: PrimitiveValue; label: string };
 

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

@@ -12,7 +12,7 @@ import express from 'express';
 
 // Core
 import context from '@server/context';
-import type { AnyRouterService, default as ServerRouter, TServerRouter, TAnyRouter } from '@server/services/router';
+import type { default as ServerRouter, TServerRouter, TAnyRouter } from '@server/services/router';
 import ServerRequest from '@server/services/router/request';
 import { TMatchedRoute, TRoute, TAnyRoute } from '@common/router';
 import { NotFound, Forbidden, Anomaly } from '@common/errors';
@@ -40,8 +40,7 @@ export type TBasicSSrData = {
     currentDomain: string;
 };
 
-type TServerRouterApplication<TRouter extends TServerRouter> =
-    TRouter extends ServerRouter<infer TApplication, any, any> ? TApplication : never;
+type TServerRouterApplication<TRouter extends TServerRouter> = TRouter['app'];
 
 type TServerRouterPlugins<TRouter extends TServerRouter> =
     TRouter extends ServerRouter<any, any, infer TConfig>
@@ -80,8 +79,10 @@ export type TRouterContextServices<
     // Custom context via servuces
     // For each roiuter service, return the request service (returned by roiuterService.requestService() )
     {
-        [serviceName in keyof TPlugins]: TPlugins[serviceName] extends AnyRouterService
-            ? Exclude<ReturnType<TPlugins[serviceName]['requestService']>, null | undefined>
+        [serviceName in keyof TPlugins]: TPlugins[serviceName] extends { requestService: infer TRequestServiceMethod }
+            ? TRequestServiceMethod extends (...args: infer TRequestServiceArgs) => infer TRequestService
+                ? Exclude<TRequestService, null | undefined>
+                : TPlugins[serviceName]
             : TPlugins[serviceName];
     };
 
@@ -97,7 +98,6 @@ const getRouteTraceTarget = (route: TAnyRoute<TRouterContext<TServerRouter>>) =>
 ----------------------------------*/
 export default class ServerResponse<
     TRouter extends TAnyRouter,
-    TRequestContext extends TRouterContext<TRouter> = TRouterContext<TRouter>,
     TData extends TResponseData = TResponseData,
 > extends BaseResponse<TData, ServerRequest<TRouter>> {
     // Services
@@ -220,13 +220,13 @@ export default class ServerResponse<
     ----------------------------------*/
 
     // Start controller services
-    private async createContext(route: TAnyRoute<TRouterContext<TRouter>>): Promise<TRequestContext> {
+    private async createContext(route: TAnyRoute<TRouterContext<TRouter>>): Promise<TRouterContext<TRouter>> {
         const contextServices = this.router.createContextServices(this.request);
         const controllers = createControllers(this.request.api);
         const customSsrData = this.router.config.context(this.request, this.app) as TRouterRequestContext<TRouter>;
 
         // TODO: transmiss safe data (especially for Router), as Router info could be printed on client side
-        const requestContext = {
+        const requestContext: TRouterContext<TRouter> = {
             // Router context
             app: this.app,
             context: undefined!,
@@ -242,7 +242,7 @@ export default class ServerResponse<
             // Router services
             ...(contextServices as TRouterContextServices<TRouter>),
             ...customSsrData,
-        } as TRequestContext;
+        };
 
         requestContext.context = requestContext;
 

package/server/services/router/service.ts

@@ -7,15 +7,16 @@ import type { Application } from '@server/app/index';
 import Service, { TSetupConfig } from '@server/app/service';
 
 // Specific
-import type { default as Router } from '.';
 import type ServerRequest from './request';
 import type { TAnyRouter } from '.';
 
-export type AnyRouterService = RouterService<any, TAnyRouter, object | null>;
+export type AnyRouterService = Service<{}, {}, Application, object> & {
+    requestService(request: object): object | null;
+};
 
-export type TRouterServiceArgs<TConfig extends {} = {}, TRouter extends TAnyRouter = TAnyRouter> = [
+export type TRouterServiceArgs<TConfig extends {} = {}> = [
     getConfig: TSetupConfig<TConfig> | null | undefined,
-    app: TRouter['app'],
+    app: Application,
 ];
 
 /*----------------------------------
@@ -23,11 +24,14 @@ export type TRouterServiceArgs<TConfig extends {} = {}, TRouter extends TAnyRout
 ----------------------------------*/
 export default abstract class RouterService<
     TConfig extends {},
-    TRouter extends TAnyRouter = TAnyRouter,
+    TRouter extends TAnyRouter,
     TRequestService extends object | null = object | null,
-> extends Service<TConfig, {}, TRouter['app'], TRouter> {
-    public constructor(...[config, app]: TRouterServiceArgs<TConfig, TRouter>) {
-        super(app as TRouter['app'] & TRouter, config, app);
+> extends Service<TConfig, {}, Application, object> {
+    public declare parent: TRouter;
+    public declare app: TRouter extends { app: infer TApplication extends Application } ? TApplication : Application;
+
+    public constructor(...[config, app]: TRouterServiceArgs<TConfig>) {
+        super(app, config, app);
     }
 
     public abstract requestService(request: ServerRequest<TRouter>): TRequestService;

package/tests/agents-utils.test.cjs

@@ -0,0 +1,207 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const test = require('node:test');
+
+const coreRoot = path.resolve(__dirname, '..');
+process.env.TS_NODE_PROJECT = path.join(coreRoot, 'cli', 'tsconfig.json');
+process.env.TS_NODE_TRANSPILE_ONLY = '1';
+require('ts-node/register/transpile-only');
+
+const { configureProjectAgentInstructions, resolveProjectAgentMonorepoRoot } = require('../cli/utils/agents.ts');
+
+const writeFile = (filepath, content) => {
+    fs.mkdirSync(path.dirname(filepath), { recursive: true });
+    fs.writeFileSync(filepath, content);
+};
+
+const makeTempRoot = () => fs.mkdtempSync(path.join(os.tmpdir(), 'proteum-agents-'));
+
+const createCoreFixture = () => {
+    const root = makeTempRoot();
+    const agentsRoot = path.join(root, 'agents', 'project');
+
+    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, 'client', 'AGENTS.md'), '# Client Rules\n\n- Client rule\n');
+
+    return root;
+};
+
+const createAppFixture = () => {
+    const appRoot = makeTempRoot();
+
+    for (const dir of ['client/pages', 'server/routes', 'server/services', 'tests/e2e']) {
+        fs.mkdirSync(path.join(appRoot, dir), { recursive: true });
+    }
+
+    writeFile(
+        path.join(appRoot, '.gitignore'),
+        [
+            'node_modules',
+            '# Proteum-managed instruction files',
+            '/AGENTS.md',
+            '/CODING_STYLE.md',
+            '# End Proteum-managed instruction files',
+            '/.proteum',
+            '',
+        ].join('\n'),
+    );
+
+    return appRoot;
+};
+
+test('standalone configure creates tracked instruction files with embedded corpus', () => {
+    const coreRoot = createCoreFixture();
+    const appRoot = createAppFixture();
+    const result = configureProjectAgentInstructions({ appRoot, coreRoot });
+    const agentsContent = fs.readFileSync(path.join(appRoot, 'AGENTS.md'), 'utf8');
+    const codingStyleContent = fs.readFileSync(path.join(appRoot, 'CODING_STYLE.md'), 'utf8');
+    const gitignoreContent = fs.readFileSync(path.join(appRoot, '.gitignore'), 'utf8');
+
+    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.doesNotMatch(agentsContent, /Before reading or applying instructions from this file/);
+    assert.doesNotMatch(gitignoreContent, /Proteum-managed instruction files/);
+    assert.doesNotMatch(gitignoreContent, /^\/AGENTS\.md$/m);
+});
+
+test('configure preserves project content outside the managed section', () => {
+    const coreRoot = createCoreFixture();
+    const appRoot = createAppFixture();
+
+    writeFile(
+        path.join(appRoot, 'AGENTS.md'),
+        [
+            '# Product Notes',
+            '',
+            'Keep this product note.',
+            '',
+            '# Proteum Instructions',
+            '<!-- proteum-instructions:start -->',
+            '',
+            'Old managed content.',
+            '',
+            '<!-- proteum-instructions:end -->',
+            '',
+            '# Local Footer',
+            '',
+            'Keep this footer.',
+            '',
+        ].join('\n'),
+    );
+
+    configureProjectAgentInstructions({ appRoot, coreRoot });
+
+    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.doesNotMatch(content, /Old managed content/);
+    assert.match(content, /# Local Footer/);
+    assert.match(content, /Keep this footer\./);
+});
+
+test('configure preserves project content around legacy managed stubs', () => {
+    const coreRoot = createCoreFixture();
+    const appRoot = createAppFixture();
+
+    writeFile(
+        path.join(appRoot, 'AGENTS.md'),
+        [
+            '## Product Bootstrap',
+            '',
+            'Keep these local bootstrap notes.',
+            '',
+            '# Proteum Managed Instructions',
+            '',
+            'This file is managed by `proteum configure agents`.',
+            '',
+            'Before reading or applying instructions from this file, read and follow the canonical Proteum instruction file at:',
+            '',
+            '`node_modules/proteum/agents/project/AGENTS.md`',
+            '',
+            'Resolve that path relative to this file. Treat the canonical file as if its full contents were written here.',
+            '',
+            'If the canonical file cannot be read, stop and run `npx proteum configure agents` before continuing.',
+            '',
+            '## Local Footer',
+            '',
+            'Keep this footer too.',
+            '',
+        ].join('\n'),
+    );
+
+    configureProjectAgentInstructions({ appRoot, coreRoot });
+
+    const content = fs.readFileSync(path.join(appRoot, 'AGENTS.md'), 'utf8');
+    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.doesNotMatch(content, /# Proteum Managed Instructions/);
+    assert.doesNotMatch(content, /Before reading or applying instructions from this file/);
+    assert.match(content, /## Local Footer/);
+    assert.match(content, /Keep this footer too\./);
+});
+
+test('monorepo configure writes root and app instruction files', () => {
+    const coreRoot = createCoreFixture();
+    const monorepoRoot = makeTempRoot();
+    const appRoot = path.join(monorepoRoot, 'apps', 'product');
+
+    fs.mkdirSync(path.join(monorepoRoot, '.git'));
+    fs.mkdirSync(path.join(appRoot, 'client'), { recursive: true });
+
+    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/);
+});
+
+test('configure migrates legacy managed symlinks to embedded files', () => {
+    const coreRoot = createCoreFixture();
+    const appRoot = createAppFixture();
+    const installedCoreRoot = createCoreFixture();
+    const target = path.join(installedCoreRoot, 'agents', 'project', 'AGENTS.md');
+    const linkPath = path.join(appRoot, 'AGENTS.md');
+
+    fs.symlinkSync(target, linkPath);
+
+    const result = configureProjectAgentInstructions({ appRoot, coreRoot });
+    const stats = fs.lstatSync(linkPath);
+    const content = fs.readFileSync(linkPath, 'utf8');
+
+    assert.equal(result.updated.some((entry) => entry.endsWith('/AGENTS.md')), true);
+    assert.equal(stats.isSymbolicLink(), false);
+    assert.match(content, /# Proteum Instructions/);
+});
+
+test('configure reports blocked paths unless overwrite is allowed', () => {
+    const coreRoot = createCoreFixture();
+    const appRoot = createAppFixture();
+    const blockedPath = path.join(appRoot, 'CODING_STYLE.md');
+
+    fs.mkdirSync(blockedPath);
+
+    const preview = configureProjectAgentInstructions({ appRoot, coreRoot, dryRun: true });
+    assert.equal(preview.blocked.some((entry) => entry.endsWith('/CODING_STYLE.md')), true);
+
+    const result = configureProjectAgentInstructions({
+        appRoot,
+        coreRoot,
+        overwriteBlockedPaths: [blockedPath],
+    });
+
+    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/);
+});