proteum 2.1.9 → 2.2.1

package/cli/utils/agents.ts

@@ -12,17 +12,41 @@ import { logVerbose } from '../runtime/verbose';
 ----------------------------------*/
 
 type TProjectInstructionArgs = { coreRoot: string };
-type TEnsureProjectAgentSymlinksArgs = { appRoot: string; coreRoot: string };
+type TConfigureProjectAgentSymlinksArgs = {
+    appRoot: string;
+    coreRoot: string;
+    dryRun?: boolean;
+    monorepoRoot?: string;
+    overwriteBlockedPaths?: string[];
+};
 
 type TAgentLinkDefinition = { projectPath: string; sourcePath: string; ensureParentDir?: boolean };
 
+type TEnsureSymlinksResult = {
+    blocked: string[];
+    created: string[];
+    overwritten: string[];
+    skipped: string[];
+    updated: string[];
+};
+
+export type TConfigureProjectAgentSymlinksResult = {
+    appRoot: string;
+    blocked: string[];
+    created: string[];
+    monorepoRoot?: string;
+    mode: 'monorepo' | 'standalone';
+    overwritten: string[];
+    skipped: string[];
+    updated: string[];
+    updatedGitignores: string[];
+};
+
 /*----------------------------------
 - CONSTANTS
 ----------------------------------*/
 
-// Project-local instruction entrypoints mapped to their canonical shipped source files.
-const projectAgentLinkDefinitions: TAgentLinkDefinition[] = [
-    { projectPath: 'AGENTS.md', sourcePath: 'AGENTS.md' },
+const sharedAppAgentLinkDefinitions: TAgentLinkDefinition[] = [
     { projectPath: 'CODING_STYLE.md', sourcePath: 'CODING_STYLE.md' },
     { projectPath: 'diagnostics.md', sourcePath: 'diagnostics.md' },
     { projectPath: 'optimizations.md', sourcePath: 'optimizations.md' },
@@ -35,6 +59,21 @@ const projectAgentLinkDefinitions: TAgentLinkDefinition[] = [
     { projectPath: path.join('server', 'routes', 'AGENTS.md'), sourcePath: path.join('server', 'routes', 'AGENTS.md') },
     { projectPath: path.join('tests', 'e2e', 'AGENTS.md'), sourcePath: path.join('tests', 'AGENTS.md') },
 ];
+
+const standaloneAppAgentLinkDefinitions: TAgentLinkDefinition[] = [
+    { projectPath: 'AGENTS.md', sourcePath: 'AGENTS.md' },
+    ...sharedAppAgentLinkDefinitions,
+];
+
+const monorepoAppAgentLinkDefinitions: TAgentLinkDefinition[] = [
+    { projectPath: 'AGENTS.md', sourcePath: path.join('app-root', 'AGENTS.md') },
+    ...sharedAppAgentLinkDefinitions,
+];
+
+const monorepoRootAgentLinkDefinitions: TAgentLinkDefinition[] = [
+    { projectPath: 'AGENTS.md', sourcePath: path.join('root', 'AGENTS.md') },
+];
+
 const projectInstructionGitignoreBlockStart = '# Proteum-managed instruction symlinks';
 const projectInstructionGitignoreBlockEnd = '# End Proteum-managed instruction symlinks';
 
@@ -42,71 +81,130 @@ const projectInstructionGitignoreBlockEnd = '# End Proteum-managed instruction s
 - PUBLIC API
 ----------------------------------*/
 
-export function ensureProjectAgentSymlinks({ appRoot, coreRoot }: TEnsureProjectAgentSymlinksArgs) {
-    ensureSymlinks(appRoot, getProjectAgentLinkDefinitions({ coreRoot }), '[agents]');
-    ensureSymlinks(appRoot, getProjectSkillLinkDefinitions({ coreRoot }), '[skills]');
-    ensureProjectInstructionGitignoreEntries({ appRoot, coreRoot });
-}
+export function configureProjectAgentSymlinks({
+    appRoot,
+    coreRoot,
+    dryRun = false,
+    monorepoRoot,
+    overwriteBlockedPaths = [],
+}: TConfigureProjectAgentSymlinksArgs): TConfigureProjectAgentSymlinksResult {
+    const normalizedAppRoot = path.resolve(appRoot);
+    const normalizedMonorepoRoot = monorepoRoot ? path.resolve(monorepoRoot) : undefined;
+    const normalizedOverwriteBlockedPaths = new Set(
+        overwriteBlockedPaths.map((blockedPath) => normalizeAbsolutePath(path.resolve(blockedPath))),
+    );
+    const mode =
+        normalizedMonorepoRoot && normalizedMonorepoRoot !== normalizedAppRoot ? ('monorepo' as const) : ('standalone' as const);
+    const result: TConfigureProjectAgentSymlinksResult = {
+        appRoot: normalizedAppRoot,
+        blocked: [],
+        created: [],
+        mode,
+        overwritten: [],
+        skipped: [],
+        updated: [],
+        updatedGitignores: [],
+    };
+
+    if (mode === 'monorepo' && normalizedMonorepoRoot) {
+        result.monorepoRoot = normalizedMonorepoRoot;
+
+        const rootLinks = getRootAgentLinkDefinitions({ coreRoot });
+        const rootSymlinks = ensureSymlinks(normalizedMonorepoRoot, rootLinks, '[agents]', path.join(coreRoot, 'agents', 'project'), {
+            dryRun,
+            overwriteBlockedPaths: normalizedOverwriteBlockedPaths,
+        });
+        mergeSymlinkResults(result, rootSymlinks, normalizedMonorepoRoot);
+
+        if (!dryRun && ensureInstructionGitignoreEntries({ rootDir: normalizedMonorepoRoot, linkDefinitions: rootLinks }))
+            result.updatedGitignores.push(path.join(normalizedMonorepoRoot, '.gitignore'));
+    }
 
-export function getProjectInstructionGitignoreEntries({ coreRoot }: TProjectInstructionArgs) {
-    const entries = new Set<string>();
+    const appLinks = getAppAgentLinkDefinitions({ coreRoot, mode });
+    const appSymlinks = ensureSymlinks(normalizedAppRoot, appLinks, '[agents]', path.join(coreRoot, 'agents', 'project'), {
+        dryRun,
+        overwriteBlockedPaths: normalizedOverwriteBlockedPaths,
+    });
+    mergeSymlinkResults(result, appSymlinks, normalizedAppRoot);
 
-    for (const linkDefinition of [
-        ...getProjectAgentLinkDefinitions({ coreRoot }),
-        ...getProjectSkillLinkDefinitions({ coreRoot }),
-    ]) {
-        entries.add(`/${normalizeProjectPathForGitignore(linkDefinition.projectPath)}`);
-    }
+    if (!dryRun && ensureInstructionGitignoreEntries({ rootDir: normalizedAppRoot, linkDefinitions: appLinks }))
+        result.updatedGitignores.push(path.join(normalizedAppRoot, '.gitignore'));
 
-    return Array.from(entries);
+    return result;
+}
+
+export function getProjectInstructionGitignoreEntries({ coreRoot }: TProjectInstructionArgs) {
+    return Array.from(
+        new Set(
+            getAppAgentLinkDefinitions({ coreRoot, mode: 'standalone' }).map((linkDefinition) =>
+                `/${normalizeProjectPathForGitignore(linkDefinition.projectPath)}`,
+            ),
+        ),
+    );
 }
 
 export function renderProjectInstructionGitignoreBlock({ coreRoot }: TProjectInstructionArgs) {
-    return [
-        projectInstructionGitignoreBlockStart,
-        ...getProjectInstructionGitignoreEntries({ coreRoot }),
-        projectInstructionGitignoreBlockEnd,
-    ].join('\n');
+    return renderInstructionGitignoreBlock({ linkDefinitions: getAppAgentLinkDefinitions({ coreRoot, mode: 'standalone' }) });
 }
 
 /*----------------------------------
 - HELPERS
 ----------------------------------*/
 
-function getProjectAgentLinkDefinitions({ coreRoot }: TProjectInstructionArgs) {
+function getAppAgentLinkDefinitions({
+    coreRoot,
+    mode,
+}: TProjectInstructionArgs & { mode: 'monorepo' | 'standalone' }) {
     const agentSourceRoot = path.join(coreRoot, 'agents', 'project');
+    const sourceDefinitions = mode === 'monorepo' ? monorepoAppAgentLinkDefinitions : standaloneAppAgentLinkDefinitions;
+
+    return resolveAgentLinkDefinitions({
+        agentSourceRoot,
+        linkDefinitions: sourceDefinitions,
+    });
+}
+
+function getRootAgentLinkDefinitions({ coreRoot }: TProjectInstructionArgs) {
+    return resolveAgentLinkDefinitions({
+        agentSourceRoot: path.join(coreRoot, 'agents', 'project'),
+        linkDefinitions: monorepoRootAgentLinkDefinitions,
+    });
+}
 
-    return projectAgentLinkDefinitions.map((linkDefinition) => ({
+function resolveAgentLinkDefinitions({
+    agentSourceRoot,
+    linkDefinitions,
+}: {
+    agentSourceRoot: string;
+    linkDefinitions: TAgentLinkDefinition[];
+}) {
+    return linkDefinitions.map((linkDefinition) => ({
         ...linkDefinition,
         sourcePath: path.join(agentSourceRoot, linkDefinition.sourcePath),
     }));
 }
 
-function getProjectSkillLinkDefinitions({ coreRoot }: TProjectInstructionArgs) {
-    const frameworkSkillsRoot = path.join(coreRoot, 'skills');
-    if (!fs.existsSync(frameworkSkillsRoot)) return [];
+function renderInstructionGitignoreBlock({ linkDefinitions }: { linkDefinitions: TAgentLinkDefinition[] }) {
+    const entries = Array.from(
+        new Set(linkDefinitions.map((linkDefinition) => `/${normalizeProjectPathForGitignore(linkDefinition.projectPath)}`)),
+    );
 
-    return fs
-        .readdirSync(frameworkSkillsRoot, { withFileTypes: true })
-        .filter((dirent) => dirent.isDirectory())
-        .sort((left, right) => left.name.localeCompare(right.name))
-        .map((dirent) => ({
-            projectPath: path.join('skills', dirent.name),
-            sourcePath: path.join(frameworkSkillsRoot, dirent.name),
-            ensureParentDir: true,
-        }))
-        .filter((linkDefinition) => pathEntryExists(path.join(linkDefinition.sourcePath, 'SKILL.md')));
+    return [projectInstructionGitignoreBlockStart, ...entries, projectInstructionGitignoreBlockEnd].join('\n');
 }
 
-function ensureProjectInstructionGitignoreEntries({ appRoot, coreRoot }: TEnsureProjectAgentSymlinksArgs) {
-    const gitignoreFilepath = path.join(appRoot, '.gitignore');
-    if (!pathEntryExists(gitignoreFilepath)) return;
-
-    const managedEntries = getProjectInstructionGitignoreEntries({ coreRoot });
-    const managedNormalizedEntries = new Set(managedEntries.map(normalizeGitignoreEntry));
+function ensureInstructionGitignoreEntries({
+    rootDir,
+    linkDefinitions,
+}: {
+    rootDir: string;
+    linkDefinitions: TAgentLinkDefinition[];
+}) {
+    const gitignoreFilepath = path.join(rootDir, '.gitignore');
+    if (!pathEntryExists(gitignoreFilepath)) return false;
+
+    const managedEntries = new Set(linkDefinitions.map((linkDefinition) => normalizeGitignoreEntry(linkDefinition.projectPath)));
     const lines = fs.readFileSync(gitignoreFilepath, 'utf8').split(/\r?\n/);
     const filteredLines: string[] = [];
-
     let insideManagedBlock = false;
 
     for (const line of lines) {
@@ -123,41 +221,158 @@ function ensureProjectInstructionGitignoreEntries({ appRoot, coreRoot }: TEnsure
         }
 
         if (insideManagedBlock) continue;
-        if (shouldSkipLegacyManagedGitignoreLine(line, managedNormalizedEntries)) continue;
+        if (shouldSkipLegacyManagedGitignoreLine(line, managedEntries)) continue;
 
         filteredLines.push(line);
     }
 
     const baseContent = trimTrailingBlankLines(filteredLines).join('\n');
-    const managedBlock = renderProjectInstructionGitignoreBlock({ coreRoot });
+    const managedBlock = renderInstructionGitignoreBlock({ linkDefinitions });
     const nextContent = baseContent ? `${baseContent}\n\n${managedBlock}\n` : `${managedBlock}\n`;
 
-    if (nextContent === fs.readFileSync(gitignoreFilepath, 'utf8')) return;
+    if (nextContent === fs.readFileSync(gitignoreFilepath, 'utf8')) return false;
 
     fs.writeFileSync(gitignoreFilepath, nextContent);
-    logVerbose(`[agents] Updated ${path.relative(appRoot, gitignoreFilepath) || '.gitignore'} with Proteum-managed instruction ignore entries.`);
+    logVerbose(`[agents] Updated ${path.relative(rootDir, gitignoreFilepath) || '.gitignore'} with Proteum-managed instruction ignore entries.`);
+
+    return true;
 }
 
-function ensureSymlinks(appRoot: string, linkDefinitions: TAgentLinkDefinition[], logPrefix: string) {
+function ensureSymlinks(
+    rootDir: string,
+    linkDefinitions: TAgentLinkDefinition[],
+    logPrefix: string,
+    managedSourceRoot: string,
+    {
+        dryRun,
+        overwriteBlockedPaths,
+    }: {
+        dryRun: boolean;
+        overwriteBlockedPaths: Set<string>;
+    },
+): TEnsureSymlinksResult {
+    const result: TEnsureSymlinksResult = {
+        blocked: [],
+        created: [],
+        overwritten: [],
+        skipped: [],
+        updated: [],
+    };
+
     for (const linkDefinition of linkDefinitions) {
-        const projectFilepath = path.join(appRoot, linkDefinition.projectPath);
+        const projectFilepath = path.join(rootDir, linkDefinition.projectPath);
         const projectParentDir = path.dirname(projectFilepath);
+        const relativeProjectPath = path.relative(rootDir, projectFilepath) || '.';
 
         if (linkDefinition.ensureParentDir) fs.ensureDirSync(projectParentDir);
-        else if (!fs.existsSync(projectParentDir)) continue;
-
-        if (pathEntryExists(projectFilepath)) continue;
+        else if (!fs.existsSync(projectParentDir)) {
+            result.skipped.push(relativeProjectPath);
+            continue;
+        }
 
         const sourceFilepath = linkDefinition.sourcePath;
-        if (!fs.existsSync(sourceFilepath)) {
-            throw new Error(`Missing project instruction asset: ${sourceFilepath}`);
+        if (!fs.existsSync(sourceFilepath)) throw new Error(`Missing project instruction asset: ${sourceFilepath}`);
+
+        const existingState = inspectExistingPath({
+            managedSourceRoot,
+            projectFilepath,
+            sourceFilepath,
+        });
+
+        if (existingState.kind === 'match') {
+            result.skipped.push(relativeProjectPath);
+            continue;
+        }
+
+        const normalizedProjectFilepath = normalizeAbsolutePath(projectFilepath);
+        if (existingState.kind === 'blocked' && !overwriteBlockedPaths.has(normalizedProjectFilepath)) {
+            result.blocked.push(relativeProjectPath);
+            continue;
         }
 
         const symlinkTarget = path.relative(projectParentDir, sourceFilepath);
-        fs.symlinkSync(symlinkTarget, projectFilepath);
 
-        logVerbose(`${logPrefix} Created ${path.relative(appRoot, projectFilepath) || '.'} -> ${symlinkTarget}`);
+        if (existingState.kind === 'managed-different') {
+            if (!dryRun) {
+                fs.unlinkSync(projectFilepath);
+                fs.symlinkSync(symlinkTarget, projectFilepath);
+            }
+            result.updated.push(relativeProjectPath);
+            logVerbose(`${logPrefix} Updated ${relativeProjectPath} -> ${symlinkTarget}`);
+            continue;
+        }
+
+        if (existingState.kind === 'blocked') {
+            if (!dryRun) {
+                fs.removeSync(projectFilepath);
+                fs.symlinkSync(symlinkTarget, projectFilepath);
+            }
+            result.overwritten.push(relativeProjectPath);
+            logVerbose(`${logPrefix} Replaced ${relativeProjectPath} -> ${symlinkTarget}`);
+            continue;
+        }
+
+        if (!dryRun) fs.symlinkSync(symlinkTarget, projectFilepath);
+        result.created.push(relativeProjectPath);
+        logVerbose(`${logPrefix} Created ${relativeProjectPath} -> ${symlinkTarget}`);
     }
+
+    return result;
+}
+
+function inspectExistingPath({
+    managedSourceRoot,
+    projectFilepath,
+    sourceFilepath,
+}: {
+    managedSourceRoot: string;
+    projectFilepath: string;
+    sourceFilepath: string;
+}) {
+    if (!pathEntryExists(projectFilepath)) return { kind: 'missing' as const };
+
+    const stats = fs.lstatSync(projectFilepath);
+    if (!stats.isSymbolicLink()) return { kind: 'blocked' as const };
+
+    const existingTarget = resolveSymlinkTarget(projectFilepath);
+    const normalizedExistingTarget = normalizeAbsolutePath(existingTarget);
+    const normalizedSourceFilepath = normalizeAbsolutePath(sourceFilepath);
+    const normalizedManagedSourceRoot = normalizeAbsolutePath(managedSourceRoot);
+
+    if (normalizedExistingTarget === normalizedSourceFilepath) return { kind: 'match' as const };
+    if (
+        normalizedExistingTarget === normalizedManagedSourceRoot ||
+        normalizedExistingTarget.startsWith(`${normalizedManagedSourceRoot}/`)
+    )
+        return { kind: 'managed-different' as const };
+
+    return { kind: 'blocked' as const };
+}
+
+function resolveSymlinkTarget(projectFilepath: string) {
+    const projectParentDir = path.dirname(projectFilepath);
+    const rawTarget = fs.readlinkSync(projectFilepath);
+    return path.resolve(projectParentDir, rawTarget);
+}
+
+function mergeSymlinkResults(
+    result: TConfigureProjectAgentSymlinksResult,
+    next: TEnsureSymlinksResult,
+    rootDir: string,
+) {
+    result.created.push(...next.created.map((entry) => formatResultPath(rootDir, entry)));
+    result.overwritten.push(...next.overwritten.map((entry) => formatResultPath(rootDir, entry)));
+    result.updated.push(...next.updated.map((entry) => formatResultPath(rootDir, entry)));
+    result.skipped.push(...next.skipped.map((entry) => formatResultPath(rootDir, entry)));
+    result.blocked.push(...next.blocked.map((entry) => formatResultPath(rootDir, entry)));
+}
+
+function formatResultPath(rootDir: string, relativePath: string) {
+    return normalizeProjectPathForGitignore(path.join(rootDir, relativePath));
+}
+
+function normalizeAbsolutePath(filepath: string) {
+    return filepath.replace(/\\/g, '/');
 }
 
 function normalizeProjectPathForGitignore(projectPath: string) {

package/client/dev/profiler/index.tsx

@@ -1166,12 +1166,13 @@ const traceEventDepths: Record<TTraceEventType, number> = {
     'resolve.not-found': 1,
     'controller.start': 2,
     'controller.result': 2,
-    'setup.options': 3,
     'context.create': 3,
     'page.data': 3,
     'ssr.payload': 3,
     'render.start': 2,
     'render.end': 2,
+    'cache.hit': 2,
+    'cache.write': 2,
     'response.send': 1,
     'request.finish': 0,
     error: 0,
@@ -3799,7 +3800,7 @@ const renderPanel = (panel: TProfilerPanel, session: TProfilerNavigationSession,
     }
 
     if (panel === 'controller') {
-        const controllerEvents = findTraceEvents(primaryTrace, ['controller.start', 'controller.result', 'setup.options', 'context.create']);
+        const controllerEvents = findTraceEvents(primaryTrace, ['controller.start', 'controller.result', 'context.create']);
         const controllerFlowChart = buildHorizontalBarChartOptions({
             color: profilerChartTheme.indigo,
             entries: buildCountEntries(controllerEvents.map((event) => event.type.replace(/\./g, ' '))),

package/client/router.ts

@@ -2,12 +2,20 @@ import type Router from '@client/services/router';
 
 const getRouter = (): Router => {
     if (typeof window === 'undefined') {
-        throw new Error(`Client router is not available on the server.`);
+        throw new Error(
+            'Proteum client router was accessed during SSR or server execution. This is a framework contract failure. ' +
+                'Likely fix: remove `@/client/router` from server or `.ssr` code and pass request or router data explicitly. ' +
+                'Re-check both SSR and client navigation after the fix.',
+        );
     }
 
     const router = (window.app as (Record<string, unknown> & { Router?: Router }) | undefined)?.Router;
     if (!router) {
-        throw new Error(`Client router was accessed before the application booted.`);
+        throw new Error(
+            'Proteum client router was accessed before the browser app finished booting. This is a framework contract failure. ' +
+                'Likely fix: call the router from code that runs after App mount or from a component under the Proteum router tree. ' +
+                'Re-check both SSR and client navigation after the fix.',
+        );
     }
 
     return router;

package/client/services/router/index.tsx

@@ -28,7 +28,7 @@ import type { TRegisterPageArgs, TSsrUnresolvedRoute } from '@common/router/cont
 import { getLayout } from '@common/router/layouts';
 import { getRegisterPageArgs, buildRegex } from '@common/router/register';
 import { TFetcherList } from '@common/router/request/api';
-import type { TFrontRenderer, TPageSetup } from '@common/router/response/page';
+import type { TFrontRenderer, TPageDataProvider } from '@common/router/response/page';
 
 import App from '@client/app/component';
 import type ClientApplication from '@client/app';
@@ -241,32 +241,15 @@ export default class ClientRouter<
         return currentRoute;
     }
 
-    public page<TProvidedData extends {} = {}>(
-        path: string,
-        renderer: TFrontRenderer<TProvidedData>,
-    ): TClientPageRoute<this>;
-
-    public page<TProvidedData extends {} = {}>(
-        path: string,
-        setup: TPageSetup<TProvidedData>,
-        renderer: TFrontRenderer<TProvidedData>,
-    ): TClientPageRoute<this>;
-
-    public page<TProvidedData extends {} = {}>(
-        path: string,
-        options: Partial<TRouteOptions>,
-        renderer: TFrontRenderer<TProvidedData>,
-    ): TClientPageRoute<this>;
-
     public page<TProvidedData extends {} = {}>(
         path: string,
         options: Partial<TRouteOptions>,
-        setup: TPageSetup<TProvidedData>,
+        data: TPageDataProvider<TProvidedData> | null,
         renderer: TFrontRenderer<TProvidedData>,
     ): TClientPageRoute<this>;
 
     public page(...args: TRegisterPageArgs<any, TRouteOptions>): TClientPageRoute<this> {
-        const { path, options, setup, renderer, layout } = getRegisterPageArgs(...args);
+        const { path, options, data, renderer, layout } = getRegisterPageArgs(...args);
 
         // Page ids are injected by the generated route wrapper modules.
         const id = options.id;
@@ -279,7 +262,8 @@ export default class ClientRouter<
             path,
             regex,
             keys,
-            options: { ...defaultOptions, setup, ...options },
+            data,
+            options: { ...defaultOptions, ...options },
             controller: (context) => new ClientPage(route, renderer, context as any, layout),
         };
 
@@ -406,7 +390,7 @@ export default class ClientRouter<
 
         const response = await this.createResponse(route, request, apiData);
 
-        ReactDOM.hydrate(<App context={response.context as AppPropsContext} />, document.body, () => {
+        ReactDOM.hydrate(<App context={response.context as unknown as AppPropsContext} />, document.body, () => {
             console.log(`Render complete`);
             withProfiler((runtime) => runtime.markInitialHydrated({ chunkId: response.chunkId, title: response.title }));
 

package/common/dev/connect.ts

@@ -1,5 +1,3 @@
-import fs from 'fs';
-
 import {
     formatManifestFilepath,
     formatManifestLocation,
@@ -53,6 +51,24 @@ export type TConnectResponse = {
     diagnostics: TProteumManifestDiagnostic[];
 };
 
+type TNodeFs = {
+    existsSync: (filepath: string) => boolean;
+};
+
+let cachedNodeFs: TNodeFs | null | undefined;
+
+const getNodeFs = () => {
+    if (cachedNodeFs !== undefined) return cachedNodeFs || undefined;
+
+    try {
+        cachedNodeFs = (eval('require')('fs') as TNodeFs) || null;
+    } catch (_error) {
+        cachedNodeFs = null;
+    }
+
+    return cachedNodeFs || undefined;
+};
+
 const createDiagnostic = ({
     code,
     filepath,
@@ -102,7 +118,7 @@ export const buildConnectResponse = (
             .sort((left, right) => left.clientAccessor.localeCompare(right.clientAccessor));
         const sourceConfigured = typeof project.sourceValue === 'string' && project.sourceValue.trim() !== '';
         const urlInternalConfigured = typeof project.urlInternal === 'string' && project.urlInternal.trim() !== '';
-        const cachedContractExists = project.cachedContractFilepath ? fs.existsSync(project.cachedContractFilepath) : false;
+        const cachedContractExists = project.cachedContractFilepath ? getNodeFs()?.existsSync(project.cachedContractFilepath) === true : false;
 
         if (!sourceConfigured) {
             diagnostics.push(
@@ -258,7 +274,7 @@ export const renderConnectHuman = (manifest: TProteumManifest, response: TConnec
         title: 'Diagnostics',
         items: response.diagnostics.map(
             (diagnostic) =>
-                `[${diagnostic.level}] ${diagnostic.code} ${diagnostic.message} source=${formatManifestFilepath(manifest, diagnostic.filepath)}${formatManifestLocation(diagnostic.sourceLocation?.line, diagnostic.sourceLocation?.column)}`,
+                `[${diagnostic.level}] ${diagnostic.code} ${diagnostic.message} source=${formatManifestFilepath(manifest, diagnostic.filepath)}${formatManifestLocation(diagnostic.sourceLocation?.line, diagnostic.sourceLocation?.column)}${diagnostic.fixHint ? ` fix=${diagnostic.fixHint}` : ''}`,
         ),
         empty: 'No connect diagnostics were found.',
     });

package/common/dev/console.ts

@@ -9,9 +9,16 @@ export type TDevConsoleLogLevel = 'silly' | 'log' | 'info' | 'warn' | 'error';
 export type TDevConsoleLogChannel = {
     channelType: 'cron' | 'master' | 'request' | 'socket';
     channelId?: string;
+    silentLogs?: boolean;
     method?: string;
     path?: string;
     user?: string;
+    connectedNamespace?: string;
+    ownerLabel?: string;
+    ownerFilepath?: string;
+    serviceLabel?: string;
+    cacheKey?: string;
+    cachePhase?: string;
     traceCallId?: string;
     traceCallOrigin?: TTraceCallOrigin;
     traceCallLabel?: string;