proteum 2.5.6 → 2.5.8

package/agents/project/AGENTS.md

@@ -81,7 +81,6 @@ Managed compact root routers must use trigger -> canonical instruction file refe
 - Before finishing, re-check touched files against root-level `CODING_STYLE.md` and any narrower area `AGENTS.md` that applied to the edit. Re-check against root-level `optimizations.md` only for touched client-side files. Re-check against root-level `diagnostics.md` only if the task involved an issue, diagnosis, runtime reproduction, or verification failure.
 - Before finishing a production code change, re-check root-level `DOCUMENTATION.md` update rules. If behavior changed, a bug was fixed, a decision changed, or an important route, auth/OAuth, or integration issue was addressed, update the relevant docs before committing or explicitly explain why no docs update was needed.
 - Run targeted tests and checks that match the changed surface before finishing each feature or change. When the repository defines `proteum.verify.config.ts`, use `npx proteum verify changed` as the first post-change verification pass and expand only when the selected plan is insufficient. Continue running tests after changes, but do not run coverage by default. Downstream app commit workflows run only `proteum refresh`, then targeted lint, typecheck, and test commands in parallel; framework-repo commit workflows skip this downstream app verification. Reserve the full `npm run check` gate for push workflows, explicit user requests, or when project-local instructions require the full gate. After implementing a new feature or changing existing feature behavior, update the relevant end-to-end coverage and run the cheapest trustworthy Playwright or browser verification for that behavior before finishing. For docs-only, wording-only, type-only, generated-output cleanup, or clearly local non-runtime refactors, skip Playwright unless the user explicitly asks for it or verification reveals a real issue.
-- Before finishing a task, stop every `proteum dev` session started during the task and confirm cleanup with `npx proteum dev list --json` or an explicit `npx proteum dev stop --session-file <path>`.
 - When you have finished your work, ask the user whether they want a commit message. After providing a commit message or after creating a commit, immediately follow it with this exact prompt and obey it:
   `Explain in short minimalistic and few bullet points what we changed in this thread, like you would do to your grandma. Start with a verb in the past.`
 

package/agents/project/root/AGENTS.md

@@ -67,7 +67,6 @@ Managed compact root routers must use trigger -> canonical instruction file refe
 - Before finishing a production code change, re-check root-level `DOCUMENTATION.md` update rules. If behavior changed, a bug was fixed, a decision changed, or an important route, auth/OAuth, or integration issue was addressed, update the relevant docs before committing or explicitly explain why no docs update was needed.
 - For production changes, always add or update focused unit tests and run the targeted unit or integration tests that match the changed behavior. Do not run coverage after every ordinary change by default. Reserve whole-project coverage for the repository's full `npm run check` gate during push workflows or when the user explicitly requests it; downstream app commit-only workflows run `proteum refresh`, then targeted lint, typecheck, and test commands in parallel unless the user explicitly requests more, while framework-repo commits skip this downstream app verification. Document any generated files, migrations, framework shims, unreachable defensive branches, or changes that cannot reasonably be unit-tested as explicit exceptions.
 - Run targeted tests and checks that match the changed surface before finishing each feature or change. When the repository defines `proteum.verify.config.ts`, use `npx proteum verify changed` as the first post-change verification pass and expand only when the selected plan is insufficient. Continue running tests after changes, but do not run coverage by default. Downstream app commit workflows run only `proteum refresh`, then targeted lint, typecheck, and test commands in parallel; framework-repo commit workflows skip this downstream app verification. Reserve the full `npm run check` gate for push workflows, explicit user requests, or when project-local instructions require the full gate. After implementing a new feature or changing existing feature behavior, update the relevant end-to-end coverage and run the cheapest trustworthy Playwright or browser verification for that behavior before finishing. For docs-only, wording-only, type-only, generated-output cleanup, or clearly local non-runtime refactors, skip Playwright unless the user explicitly asks for it or verification reveals a real issue.
-- Before finishing a task, stop every `proteum dev` session started during the task and confirm cleanup with `npx proteum dev list --json` or an explicit `npx proteum dev stop --session-file <path>`.
 - When you have finished your work, ask the user whether they want a commit message. After providing a commit message or after creating a commit, immediately follow it with this exact prompt and obey it:
   `Explain in short minimalistic and few bullet points what we changed in this thread, like you would do to your grandma. Start with a verb in the past.`
 

package/cli/commands/dev.ts

@@ -6,7 +6,7 @@
 import path from 'path';
 import { spawn, ChildProcess } from 'child_process';
 import fs from 'fs-extra';
-import type { FSWatcher } from 'fs';
+import { realpathSync, watch, type FSWatcher } from 'fs';
 import prompts from 'prompts';
 import { UsageError } from 'clipanion';
 
@@ -677,6 +677,16 @@ function normalizeWatchPath(watchPath: string) {
     return path.resolve(watchPath).replace(/\\/g, '/').replace(/\/$/, '');
 }
 
+const resolveWatchPathAliases = (watchPath: string) => {
+    const aliases = new Set([normalizeWatchPath(watchPath)]);
+
+    try {
+        aliases.add(normalizeWatchPath(realpathSync(watchPath)));
+    } catch {}
+
+    return [...aliases];
+};
+
 type TIndexedSourceWatchEvent = 'change' | 'rename';
 type TIndexedSourceWatchCompilerName = 'server' | 'client';
 type TIndexedSourceWatchInvalidateTarget = 'all' | TIndexedSourceWatchCompilerName;
@@ -692,14 +702,7 @@ type TMultiWatchingLike = TDevWatching & { watchings?: TNamedWatching[] };
 
 const resolveIndexedSourceWatchRules = (): TIndexedSourceWatchRule[] => {
     const transpileWatchRoots = app.transpileModuleDirectories
-        .map((rootPath) => {
-            try {
-                return fs.realpathSync(rootPath);
-            } catch {
-                return rootPath;
-            }
-        })
-        .map(normalizeWatchPath)
+        .flatMap((rootPath) => resolveWatchPathAliases(rootPath))
         .filter((rootPath, index, list) => list.indexOf(rootPath) === index);
 
     return [
@@ -723,7 +726,7 @@ const resolveIndexedSourceWatchRules = (): TIndexedSourceWatchRule[] => {
                 rootPath,
                 relativePathPattern: transpileSourceWatchPattern,
                 eventTypes: ['change', 'rename'],
-                invalidateTargets: ['client', 'server'],
+                invalidateTargets: ['all'],
             }),
         ),
     ];
@@ -848,7 +851,7 @@ const createIndexedSourceWatching = ({
         if (!fs.existsSync(rootPath)) continue;
 
         watchers.push(
-            fs.watch(rootPath, { recursive: true }, (eventType, filename) => {
+            watch(rootPath, { recursive: true }, (eventType, filename) => {
                 const relativePath = typeof filename === 'string' ? filename.replace(/\\/g, '/').replace(/^\.\//, '') : '';
                 const normalizedEventType: TIndexedSourceWatchEvent = eventType === 'change' ? 'change' : 'rename';
 

package/cli/compiler/common/index.ts

@@ -44,10 +44,12 @@ export default function createCommonConfig(
     outputTarget: TCompileOutputTarget = mode === 'dev' ? 'dev' : 'bin',
 ): Configuration {
     const dev = mode === 'dev';
-    const enableFilesystemCache = dev ? cli.args.cache !== false : cli.args.cache === true;
     const transpileModuleDirectories = app.transpileModuleDirectories;
+    const hasTranspileModuleDirectories = transpileModuleDirectories.length > 0;
+    // Persistent cache can restore stale modules from mutable workspace packages even after manual invalidation.
+    const enableFilesystemCache = dev ? cli.args.cache !== false && !hasTranspileModuleDirectories : cli.args.cache === true;
     const transpileModuleSnapshot =
-        dev && transpileModuleDirectories.length > 0
+        dev && hasTranspileModuleDirectories
             ? {
                   // Transpiled local packages can resolve through node_modules symlinks,
                   // but they still need live invalidation like mutable app sources in dev.

package/cli/utils/agents.ts

@@ -16,6 +16,7 @@ type TProjectInstructionArgs = {
     appRoot?: string;
     coreRoot: string;
     includeMonorepoRegistry?: boolean;
+    instructionRoot: string;
     monorepoRegistryCurrentAppRoot?: string;
     monorepoRoot?: string;
 };
@@ -106,6 +107,14 @@ const sharedTestAgentInstructionDefinitions: TAgentInstructionDefinition[] = [
     { projectPath: path.join('tests', 'e2e', 'REAL_WORLD_JOURNEY_TESTS.md'), ensureParentDir: true, content: 'source' },
 ];
 
+const projectInstructionSourceMapEntries = [
+    { label: 'Root contract fallback', projectPath: 'AGENTS.md' },
+    { label: 'Documentation fallback', projectPath: 'DOCUMENTATION.md' },
+    { label: 'Diagnostics fallback', projectPath: 'diagnostics.md' },
+    { label: 'Optimization fallback', projectPath: 'optimizations.md' },
+    { label: 'Coding style fallback', projectPath: 'CODING_STYLE.md' },
+];
+
 const standaloneAppAgentInstructionDefinitions: TAgentInstructionDefinition[] = [
     { projectPath: 'AGENTS.md', content: 'router' },
     ...sharedRootDocumentInstructionDefinitions,
@@ -164,6 +173,7 @@ export function configureProjectAgentInstructions({
     const appEmbeddedInstructions = renderEmbeddedProjectInstructions({
         appRoot: normalizedAppRoot,
         coreRoot,
+        instructionRoot: normalizedAppRoot,
         monorepoRoot: normalizedMonorepoRoot,
     });
     const rootEmbeddedInstructions =
@@ -172,6 +182,7 @@ export function configureProjectAgentInstructions({
                   appRoot: normalizedAppRoot,
                   coreRoot,
                   includeMonorepoRegistry: true,
+                  instructionRoot: normalizedMonorepoRoot,
                   monorepoRegistryCurrentAppRoot: markCurrentAppInMonorepoRegistry ? normalizedAppRoot : undefined,
                   monorepoRoot: normalizedMonorepoRoot,
               })
@@ -973,6 +984,7 @@ function renderEmbeddedProjectInstructions({
     appRoot,
     coreRoot,
     includeMonorepoRegistry = false,
+    instructionRoot,
     monorepoRegistryCurrentAppRoot,
     monorepoRoot,
 }: TProjectInstructionArgs) {
@@ -1063,11 +1075,14 @@ function renderEmbeddedProjectInstructions({
         '',
         '## Canonical Source Map',
         '',
-        `- Root contract fallback: ${normalizeProjectPathForGitignore(path.join(coreRoot, 'agents', 'project', 'AGENTS.md'))}`,
-        `- Documentation fallback: ${normalizeProjectPathForGitignore(path.join(coreRoot, 'agents', 'project', 'DOCUMENTATION.md'))}`,
-        `- Diagnostics fallback: ${normalizeProjectPathForGitignore(path.join(coreRoot, 'agents', 'project', 'diagnostics.md'))}`,
-        `- Optimization fallback: ${normalizeProjectPathForGitignore(path.join(coreRoot, 'agents', 'project', 'optimizations.md'))}`,
-        `- Coding style fallback: ${normalizeProjectPathForGitignore(path.join(coreRoot, 'agents', 'project', 'CODING_STYLE.md'))}`,
+        ...projectInstructionSourceMapEntries.map(
+            ({ label, projectPath }) =>
+                `- ${label}: ${formatProjectInstructionSourceMapPath({
+                    coreRoot,
+                    instructionRoot,
+                    projectPath,
+                })}`,
+        ),
         '',
     ];
 
@@ -1209,6 +1224,41 @@ function formatResultPath(rootDir: string, relativePath: string) {
     return normalizeProjectPathForGitignore(path.join(rootDir, relativePath));
 }
 
+function formatProjectInstructionSourceMapPath({
+    coreRoot,
+    instructionRoot,
+    projectPath,
+}: {
+    coreRoot: string;
+    instructionRoot: string;
+    projectPath: string;
+}) {
+    const sourceRoot = resolveProjectInstructionSourceMapRoot({ coreRoot, instructionRoot });
+    const sourcePath = path.resolve(sourceRoot, 'agents', 'project', projectPath);
+    const relativePath = path.relative(path.resolve(instructionRoot), sourcePath);
+
+    return normalizeProjectPathForGitignore(relativePath);
+}
+
+function resolveProjectInstructionSourceMapRoot({ coreRoot, instructionRoot }: { coreRoot: string; instructionRoot: string }) {
+    const visibleInstallRoot = findVisibleProteumInstructionRoot(instructionRoot);
+
+    return visibleInstallRoot || coreRoot;
+}
+
+function findVisibleProteumInstructionRoot(startRoot: string) {
+    let currentPath = path.resolve(startRoot);
+
+    while (true) {
+        const candidate = path.join(currentPath, 'node_modules', 'proteum');
+        if (fs.existsSync(path.join(candidate, 'agents', 'project'))) return candidate;
+
+        const parentPath = path.dirname(currentPath);
+        if (parentPath === currentPath) return undefined;
+        currentPath = parentPath;
+    }
+}
+
 export function resolveCanonicalPath(inputPath: string) {
     const resolvedPath = path.resolve(inputPath);
 

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "proteum",
 	"description": "LLM-first Opinionated Typescript Framework for web applications.",
-	"version": "2.5.6",
+	"version": "2.5.8",
 	"author": "Gaetan Le Gac (https://github.com/gaetanlegac)",
 	"repository": "git://github.com/gaetanlegac/proteum.git",
 	"license": "MIT",

package/tests/agents-utils.test.cjs

@@ -38,8 +38,9 @@ const pathEntryExists = (filepath) => {
 
 const makeTempRoot = () => fs.mkdtempSync(path.join(os.tmpdir(), 'proteum-agents-'));
 
-const createCoreFixture = () => {
-    const root = makeTempRoot();
+const normalizePath = (value) => value.replace(/\\/g, '/');
+
+const createCoreFixture = (root = makeTempRoot()) => {
     const agentsRoot = path.join(root, 'agents', 'project');
 
     writeFile(path.join(agentsRoot, 'AGENTS.md'), '# Root Contract\n\n- Root rule\n');
@@ -61,6 +62,20 @@ const createCoreFixture = () => {
     return root;
 };
 
+const expectedSourceMapPath = ({ coreRoot, instructionRoot, projectPath }) =>
+    normalizePath(path.relative(instructionRoot, path.join(coreRoot, 'agents', 'project', projectPath)));
+
+const assertSourceMapPath = ({ content, coreRoot, instructionRoot, label, projectPath }) => {
+    assert.equal(
+        content.includes(`- ${label}: ${expectedSourceMapPath({ coreRoot, instructionRoot, projectPath })}`),
+        true,
+    );
+};
+
+const assertNoAbsoluteCoreSourceMapPath = ({ content, coreRoot }) => {
+    assert.equal(content.includes(normalizePath(path.join(coreRoot, 'agents', 'project'))), false);
+};
+
 const createAppFixture = () => {
     const appRoot = makeTempRoot();
 
@@ -173,6 +188,53 @@ test('standalone configure creates tracked instruction files with routing contra
     assert.doesNotMatch(gitignoreContent, /^\/DOCUMENTATION\.md$/m);
 });
 
+test('standalone configure writes install-relative source map fallbacks', () => {
+    const appRoot = createAppFixture();
+    const coreRoot = createCoreFixture(path.join(appRoot, 'node_modules', 'proteum'));
+    const result = configureProjectAgentInstructions({ appRoot, coreRoot });
+    const agentsContent = fs.readFileSync(path.join(appRoot, 'AGENTS.md'), 'utf8');
+
+    assert.equal(result.blocked.length, 0);
+    assertSourceMapPath({
+        content: agentsContent,
+        coreRoot,
+        instructionRoot: appRoot,
+        label: 'Root contract fallback',
+        projectPath: 'AGENTS.md',
+    });
+    assertSourceMapPath({
+        content: agentsContent,
+        coreRoot,
+        instructionRoot: appRoot,
+        label: 'Documentation fallback',
+        projectPath: 'DOCUMENTATION.md',
+    });
+    assertNoAbsoluteCoreSourceMapPath({ content: agentsContent, coreRoot });
+    assert.match(agentsContent, /Root contract fallback: node_modules\/proteum\/agents\/project\/AGENTS\.md/);
+});
+
+test('standalone configure source map prefers project install over active external core', () => {
+    const activeCoreRoot = createCoreFixture();
+    const appRoot = createAppFixture();
+    createCoreFixture(path.join(appRoot, 'node_modules', 'proteum'));
+
+    configureProjectAgentInstructions({ appRoot, coreRoot: activeCoreRoot });
+
+    const agentsContent = fs.readFileSync(path.join(appRoot, 'AGENTS.md'), 'utf8');
+    assert.match(agentsContent, /Root contract fallback: node_modules\/proteum\/agents\/project\/AGENTS\.md/);
+    assert.equal(
+        agentsContent.includes(
+            `Root contract fallback: ${expectedSourceMapPath({
+                coreRoot: activeCoreRoot,
+                instructionRoot: appRoot,
+                projectPath: 'AGENTS.md',
+            })}`,
+        ),
+        false,
+    );
+    assertNoAbsoluteCoreSourceMapPath({ content: agentsContent, coreRoot: activeCoreRoot });
+});
+
 test('configure preserves project content outside the managed section', () => {
     const coreRoot = createCoreFixture();
     const appRoot = createAppFixture();
@@ -296,6 +358,22 @@ test('monorepo configure writes root and app instruction files', () => {
     assert.match(appAgentsContent, /## Agent Routing Contract/);
     assert.doesNotMatch(appAgentsContent, /## Known Proteum Apps/);
     assert.doesNotMatch(appAgentsContent, /Eligible Proteum commands run across the apps below/);
+    assertSourceMapPath({
+        content: fs.readFileSync(path.join(monorepoRoot, 'AGENTS.md'), 'utf8'),
+        coreRoot,
+        instructionRoot: monorepoRoot,
+        label: 'Root contract fallback',
+        projectPath: 'AGENTS.md',
+    });
+    assertSourceMapPath({
+        content: appAgentsContent,
+        coreRoot,
+        instructionRoot: appRoot,
+        label: 'Root contract fallback',
+        projectPath: 'AGENTS.md',
+    });
+    assertNoAbsoluteCoreSourceMapPath({ content: fs.readFileSync(path.join(monorepoRoot, 'AGENTS.md'), 'utf8'), coreRoot });
+    assertNoAbsoluteCoreSourceMapPath({ content: appAgentsContent, coreRoot });
     assert.match(fs.readFileSync(path.join(appRoot, 'client', 'AGENTS.md'), 'utf8'), /## Source: client\/AGENTS\.md/);
     assertClaudeSymlink(appRoot);
     assertClaudeSymlink(appRoot, 'client');
@@ -306,6 +384,28 @@ test('monorepo configure writes root and app instruction files', () => {
     assert.equal(result.removed.some((entry) => entry.endsWith('/apps/product/CODING_STYLE.md')), true);
 });
 
+test('monorepo configure source map uses workspace install from root and nested apps', () => {
+    const activeCoreRoot = createCoreFixture();
+    const monorepoRoot = makeTempRoot();
+    const appRoot = path.join(monorepoRoot, 'apps', 'product');
+
+    createCoreFixture(path.join(monorepoRoot, 'node_modules', 'proteum'));
+    fs.mkdirSync(path.join(monorepoRoot, '.git'));
+    fs.mkdirSync(path.join(appRoot, 'client'), { recursive: true });
+    writeFile(path.join(appRoot, 'package.json'), '{"name":"product"}\n');
+    writeFile(path.join(appRoot, 'identity.config.ts'), 'export default {};\n');
+    writeFile(path.join(appRoot, 'proteum.config.ts'), 'export default {};\n');
+
+    configureProjectAgentInstructions({ appRoot, coreRoot: activeCoreRoot, monorepoRoot });
+
+    const rootAgentsContent = fs.readFileSync(path.join(monorepoRoot, 'AGENTS.md'), 'utf8');
+    const appAgentsContent = fs.readFileSync(path.join(appRoot, 'AGENTS.md'), 'utf8');
+    assert.match(rootAgentsContent, /Root contract fallback: node_modules\/proteum\/agents\/project\/AGENTS\.md/);
+    assert.match(appAgentsContent, /Root contract fallback: \.\.\/\.\.\/node_modules\/proteum\/agents\/project\/AGENTS\.md/);
+    assertNoAbsoluteCoreSourceMapPath({ content: rootAgentsContent, coreRoot: activeCoreRoot });
+    assertNoAbsoluteCoreSourceMapPath({ content: appAgentsContent, coreRoot: activeCoreRoot });
+});
+
 test('monorepo-wide configure writes shared root once and all app instruction files', () => {
     const coreRoot = createCoreFixture();
     const monorepoRoot = makeTempRoot();

package/tests/dev-transpile-watch.test.cjs

@@ -103,6 +103,21 @@ const waitForAssetContaining = async (appRoot, extension, marker, timeoutMs = 60
     throw new Error(`Timed out waiting for ${extension} asset containing ${marker}.`);
 };
 
+const waitForBodyContaining = async (port, urlPath, marker, timeoutMs = 60000) => {
+    const deadline = Date.now() + timeoutMs;
+
+    while (Date.now() < deadline) {
+        try {
+            const { body } = await request(port, urlPath, { Accept: 'text/html' });
+            if (body.includes(marker)) return body;
+        } catch {}
+
+        await sleep(250);
+    }
+
+    throw new Error(`Timed out waiting for ${urlPath} body containing ${marker}.`);
+};
+
 const waitForSessionReady = async (sessionFile, child, getOutput, timeoutMs = 90000) => {
     const deadline = Date.now() + timeoutMs;
 
@@ -199,8 +214,13 @@ const createSharedStyleSource = (marker) => `.shared-style-marker {
 `;
 
 const createFixture = (root, port, options = {}) => {
-    const appRoot = path.join(root, 'app');
-    const sharedRoot = path.join(root, 'shared');
+    const monorepoRootInstall = options.monorepoRootInstall === true;
+    const appRoot = monorepoRootInstall ? path.join(root, 'apps', 'app') : path.join(root, 'app');
+    const sharedRoot = monorepoRootInstall ? path.join(root, 'packages', 'shared') : path.join(root, 'shared');
+    const sharedDependency = monorepoRootInstall ? 'file:../../packages/shared' : 'file:../shared';
+    const sharedInstallRoot = monorepoRootInstall
+        ? path.join(root, 'node_modules', '@test', 'shared')
+        : path.join(appRoot, 'node_modules', '@test', 'shared');
     const cacheConfigSource = options.routerCache ? `        cache: ${options.routerCache},\n` : '';
 
     fs.mkdirSync(path.join(appRoot, 'public'), { recursive: true });
@@ -217,7 +237,7 @@ const createFixture = (root, port, options = {}) => {
                 private: true,
                 version: '0.0.0',
                 dependencies: {
-                    '@test/shared': 'file:../shared',
+                    '@test/shared': sharedDependency,
                     proteum: `file:${coreRoot}`,
                 },
             },
@@ -474,7 +494,7 @@ export default definePageRoute({
     writeFile(path.join(sharedRoot, 'styles.css'), createSharedStyleSource('STYLE_MARKER_INITIAL'));
 
     createSymlink(coreRoot, path.join(appRoot, 'node_modules', 'proteum'));
-    createSymlink(sharedRoot, path.join(appRoot, 'node_modules', '@test', 'shared'));
+    createSymlink(sharedRoot, sharedInstallRoot);
 
     return {
         appRoot,
@@ -500,11 +520,14 @@ const stopDevServer = async (child) => {
     });
 };
 
-const startDevServer = (appRoot, port, sessionFile) => {
+const startDevServer = (appRoot, port, sessionFile, options = {}) => {
     let output = '';
+    const args = [cliBin, 'dev', '--cwd', appRoot, '--port', String(port), '--session-file', sessionFile];
+    if (options.noCache !== false) args.push('--no-cache');
+    args.push('--verbose');
     const child = spawn(
         process.execPath,
-        [cliBin, 'dev', '--cwd', appRoot, '--port', String(port), '--session-file', sessionFile, '--no-cache', '--verbose'],
+        args,
         {
             cwd: appRoot,
             env: {
@@ -577,6 +600,41 @@ test('proteum dev invalidates client assets and reloads for transpiled package s
     }
 });
 
+test(
+    'proteum dev invalidates SSR and client assets for monorepo-root transpiled package installs',
+    { timeout: 180000 },
+    async () => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'proteum-monorepo-transpile-watch-'));
+        const port = await resolvePortPair();
+        const { appRoot, sharedRoot } = createFixture(root, port, { monorepoRootInstall: true });
+        const sessionFile = path.join(appRoot, 'var', 'run', 'proteum', 'dev', 'monorepo-transpile-watch-test.json');
+        const { child, getOutput } = startDevServer(appRoot, port, sessionFile, { noCache: false });
+
+        try {
+            await waitForSessionReady(sessionFile, child, getOutput);
+            await waitForBodyContaining(port, '/', 'SCRIPT_MARKER_INITIAL').catch((error) => {
+                throw new Error(`${error.message}\n${getOutput()}`);
+            });
+            await waitForAssetContaining(appRoot, '.js', 'SCRIPT_MARKER_INITIAL').catch((error) => {
+                throw new Error(`${error.message}\n${getOutput()}`);
+            });
+
+            const reloadStream = await connectToReloadStream(port + 1);
+            writeFile(path.join(sharedRoot, 'index.tsx'), createSharedIndexSource('SCRIPT_MARKER_MONOREPO_UPDATED'));
+
+            await waitForAssetContaining(appRoot, '.js', 'SCRIPT_MARKER_MONOREPO_UPDATED');
+            await waitForBodyContaining(port, '/', 'SCRIPT_MARKER_MONOREPO_UPDATED');
+            const reloadEvent = await reloadStream.waitForReload();
+            reloadStream.close();
+
+            assert.equal(reloadEvent.type, 'reload');
+        } finally {
+            await stopDevServer(child);
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    },
+);
+
 test('proteum dev applies router HTTP cache config to HTML and public assets', { timeout: 180000 }, async () => {
     const root = fs.mkdtempSync(path.join(os.tmpdir(), 'proteum-router-cache-'));
     const port = await resolvePortPair();