proteum 2.2.8 → 2.3.0

package/agents/project/tests/e2e/REAL_WORLD_JOURNEY_TESTS.md

@@ -0,0 +1,192 @@
+# Write Real World Journey Tests
+
+Source: `/Users/gaetan/.codex/skills/write-real-world-journey-tests/SKILL.md`
+
+## Goal
+
+Create journey tests that read like an executable product spec. Prefer a realistic sequence of actions by real roles over a collection of disconnected UI checks.
+
+The journey should cover the requested feature area broadly, but every step must be justified by normal user behavior and by state created earlier in the journey.
+
+## Workflow
+
+1. Inspect the feature surface before designing the test.
+   - Read existing journey tests, page objects, factories, workflows, fixtures, selectors, and test utilities.
+   - Identify local conventions for auth, data creation, navigation, assertions, cleanup, retries, and timeouts.
+   - Reuse existing helpers before adding new ones.
+   - Preserve the repository's test-file organization instead of putting every helper inside the journey spec.
+
+2. Follow the local E2E file organization.
+   - Put complete user journeys in `tests/e2e/journeys/*.spec.ts` or the repository's equivalent journey/spec directory.
+   - Put reusable screen abstractions in `tests/e2e/pages/**`, grouped by product area; use focused page objects for pages, modals, filter bars, pickers, and detail panels.
+   - Put reusable multi-step business flows in `tests/e2e/workflows/**`, such as login, signup via invite, create entity with invite link, or other flows shared by several journeys.
+   - Put generated domain data in `tests/e2e/factories/**`, with separate minimum, maximum, and edited payload factories when the journey needs create/edit coverage.
+   - Put shared technical/domain helpers in `tests/e2e/utils/**`, such as context creation, constants, API response parsing, date formatting, KPI expectations, number/currency parsers, display-name builders, and journey tree logging.
+   - Add a helper to the nearest existing page/workflow/factory/utils module when it is reusable; keep it local to the spec only when it is specific to that one journey's memory or assertions.
+
+3. Map the real-world story.
+   - List the roles involved, their permissions, and why each role appears in the scenario.
+   - Identify the entities that move through the journey: account, team, organization, customer, order, lead, report, subscription, etc.
+   - Define the natural order: setup, invite/signup/login, empty state, creation, assignment, action by another role, management, reporting, audit/review.
+   - Prefer one coherent story over feature stuffing. Cover many features only when they belong to the same user journey.
+
+4. Make the report-visible hierarchy explicit.
+   - Group journeys with `describe` blocks or the framework equivalent by business phase, such as acquisition, activation, setup, core workflow, limits, billing, and admin review.
+   - Split each journey test into named substeps with `test.step(...)`, Cypress command logs, or the local framework equivalent so CI reports and traces show what business phase failed.
+   - Name steps from the user or business perspective, such as `Launch plan blocks the third filter`, not from implementation details, such as `Click button`.
+   - Use nested substeps for repeated matrices like roles, plans, permissions, limits, or locales, with one visible step per case and smaller substeps for settings, allowed actions, and blocked actions.
+   - Preserve local file organization and helper conventions; hierarchy should improve readability without moving unrelated code or hiding assertions.
+
+5. Use serial state only for real dependency chains.
+   - Use a serial describe block when later tests intentionally depend on state created by earlier actors.
+   - Split the journey into tests by actor/session or meaningful product phase.
+   - Use fresh browser contexts or sessions for different roles.
+   - Keep setup assertions at the top of each dependent test so failures explain the missing prerequisite.
+
+6. Keep journey memory as the source of truth.
+   - Store created IDs, invite links, generated users, current payloads, assignment state, statuses, dates, and monetary values in typed in-memory objects.
+   - Update memory immediately after successful UI/API responses.
+   - Compute expectations from memory instead of duplicating constants in assertions.
+   - Track both `createdPayload` and `currentPayload` when edits are part of the journey.
+
+7. Assert the product contract at each phase.
+   - Empty states and initial KPIs for new users.
+   - Role-specific navigation, tabs, menu labels, and restricted access.
+   - Created rows/cards/details match generated input.
+   - Default ownership, assignment, channel/source, payment terms, status, or permission behavior.
+   - Cross-role visibility after another role acts.
+   - Details modals, edit flows, notes/activity timelines, status changes, derived fields, filters, date ranges, and aggregate KPIs.
+   - Final manager/admin review across the whole organization or feature scope.
+
+8. Make derived assertions resilient.
+   - Use polling for eventually consistent UI totals, KPI cards, async table updates, revenue/pipeline calculations, closing rates, and status text.
+   - Parse formatted numbers, currency, and percentages with shared utilities.
+   - Use deterministic date helpers for UI date formatting and date-range assertions.
+   - Wait for important create/update responses when IDs or persistence are needed.
+
+9. Prefer expressive helpers.
+   - Introduce small helpers for repeated domain assertions, such as row basics, row KPI checks, snapshot comparison, filter setup, and derived totals.
+   - Keep helper names product-facing, not implementation-facing.
+   - Use page objects and workflow helpers to keep the test readable at the story level.
+
+10. Log or snapshot the journey shape when useful.
+   - For long multi-role journeys, optionally keep a small tree or timeline logger showing created roles and entities.
+   - Use it for debugging and readability, not as a substitute for assertions.
+
+## Implementation Pattern
+
+Use this shape as a guide, adapting to the repository's test framework:
+
+```ts
+test.describe.serial('Domain - Feature journey', () => {
+  test.describe.configure({ timeout: 300_000 });
+
+  let organization = createEmptyOrganizationMemory();
+  let manager = createEmptyAccountMemory();
+  let operator = createEmptyAccountMemory();
+  let externalPartner = createEmptyPartnerMemory();
+  let itemA = createItemMemory(createMinimumPayload(), { type: 'operator' });
+  let itemB = createItemMemory(createMaximumPayload(), { type: 'external-partner' });
+
+  const getCreatedItems = () => [itemA, itemB].filter((item) => item.id);
+  const buildKpis = () => ({
+    'Total Items': getCreatedItems().length,
+    'Completed': getCreatedItems().filter((item) => item.status === 'Completed').length,
+  });
+  const matrixCases = [{ name: 'Manager' }, { name: 'Operator' }];
+
+  test.describe('Setup and activation', () => {
+    test('Admin or owner creates the parent scope', async ({ browser }) => {
+      await test.step('Create the organization through the normal product path', async () => {
+        // Store IDs, invite links, and display data in memory.
+      });
+    });
+
+    test('Manager signs up and prepares the working structure', async ({ browser }) => {
+      await test.step('Assert restricted navigation and empty state', async () => {});
+      await test.step('Create the team and invite the next role', async () => {});
+    });
+  });
+
+  test.describe('Core workflow', () => {
+    test('Primary role performs the core workflow and delegates work', async ({ browser }) => {
+      await test.step('Create a minimum item', async () => {});
+      await test.step('Assert default ownership and visible table state', async () => {});
+      await test.step('Delegate the item to another role', async () => {});
+    });
+
+    test('Secondary role acts on assigned state', async ({ browser }) => {
+      await test.step('Assert this role only sees assigned work', async () => {});
+      await test.step('Create or update a maximum-data item', async () => {});
+      await test.step('Assert role-specific defaults and KPIs', async () => {});
+    });
+
+    test('Primary role manages resulting activity', async ({ browser }) => {
+      await test.step('Open details and validate data from the secondary role', async () => {});
+      await test.step('Add notes, edit fields, and change status', async () => {});
+      await test.step('Assert recalculated derived values', async () => {});
+    });
+  });
+
+  test.describe('Review and reporting', () => {
+    test('Manager or auditor reviews aggregate state', async ({ browser }) => {
+      await test.step('Assert cross-role visibility and filters', async () => {});
+      await test.step('Assert aggregate KPIs and final business outcomes', async () => {});
+    });
+
+    test('Plan, role, or permission matrix exposes the correct behavior', async ({ browser }) => {
+      for (const caseItem of matrixCases) {
+        await test.step(`${caseItem.name} shows the right settings and limits`, async () => {
+          await test.step(`${caseItem.name} settings match contract`, async () => {});
+          await test.step(`${caseItem.name} allowed actions succeed`, async () => {});
+          await test.step(`${caseItem.name} blocked actions fail with the expected reason`, async () => {});
+        });
+      }
+    });
+  });
+});
+```
+
+## Coverage Heuristics
+
+Include a feature when it naturally belongs to the journey and creates a durable assertion later. Strong candidates:
+
+- Invite/signup/login boundaries.
+- Permission differences between roles.
+- Empty state to populated state.
+- Minimum-data and maximum-data creation paths.
+- Assignment, reassignment, ownership, membership, or sharing.
+- Details view, edit view, notes, activity history, and status changes.
+- Derived totals, dashboards, reporting cards, and tables.
+- Filters, search, date ranges, sorting, and snapshots.
+- Cross-role consistency: what one actor creates, another actor sees or manages.
+
+Exclude or move to narrower tests:
+
+- Pure component styling.
+- Exhaustive validation errors.
+- Every filter permutation.
+- Rare edge cases that interrupt the main story.
+- Admin-only setup that is unrelated to the requested feature.
+
+## Quality Bar
+
+- The scenario should be explainable as a real customer workflow.
+- Each role should do work that role would actually do.
+- Assertions should prove business behavior, not only that buttons are clickable.
+- Later assertions should depend on earlier created state.
+- Names, IDs, and dates should be generated uniquely enough for shared test environments.
+- The test should fail near the broken product behavior, with step names that explain the business phase.
+- The test report should expose a clear hierarchy of phases, tests, and substeps so a reader can understand the journey without opening the source file.
+- Comments should clarify product intent or non-obvious timing behavior, not narrate obvious code.
+
+## Anti-Patterns
+
+- One huge test with no actor boundaries.
+- Flat journey tests with no report-visible phases or substeps.
+- Serial dependency without explicit prerequisite assertions.
+- Hardcoded duplicate KPI values that drift after edits.
+- Creating data directly in the database when the product flow under test is creation, signup, invite, assignment, or editing.
+- Covering unrelated features just to increase line count.
+- Hiding flakiness with arbitrary sleeps instead of waiting on UI state, network responses, or polling derived values.
+- Testing only the creator role when the feature's value appears through another role's visibility or management flow.

package/cli/commands/check.ts

@@ -19,19 +19,37 @@ export const run = async (): Promise<void> => {
 
     console.info(
         [
-            await renderTitle('PROTEUM CHECK', 'Refreshing contracts, running TypeScript, then running ESLint.'),
+            await renderTitle('PROTEUM CHECK', 'Refreshing contracts, then running TypeScript and ESLint.'),
             renderRows([{ label: 'app', value: cli.paths.appRoot === process.cwd() ? '.' : cli.paths.appRoot }]),
         ].join('\n\n'),
     );
+
     if (hasAppConfig()) {
         console.info(await renderStep('[1/3]', 'Refreshing generated typings.'));
         await refreshGeneratedTypings();
     } else {
         console.info(await renderStep('[1/3]', 'Skipping generated typings: no Proteum app config found.'));
     }
+
+    const failures: Error[] = [];
+
     console.info(await renderStep('[2/3]', 'Running TypeScript typechecking.'));
-    await runAppTypecheck();
+    try {
+        await runAppTypecheck();
+    } catch (error) {
+        failures.push(error instanceof Error ? error : new Error(String(error)));
+    }
+
     console.info(await renderStep('[3/3]', 'Running ESLint.'));
-    await runAppLint();
+    try {
+        await runAppLint();
+    } catch (error) {
+        failures.push(error instanceof Error ? error : new Error(String(error)));
+    }
+
+    if (failures.length > 0) {
+        throw new AggregateError(failures, 'Proteum check failed. See TypeScript and ESLint output above.');
+    }
+
     console.info(await renderSuccess('All checks passed.'));
 };

package/cli/commands/configure.ts

@@ -119,6 +119,7 @@ const renderConfigureResultSections = (result: TConfigureProjectAgentInstruction
     if (result.updated.length > 0) sections.push(['Updated:', ...result.updated.map((entry) => `- ${entry}`)].join('\n'));
     if (result.overwritten.length > 0)
         sections.push(['Overwritten:', ...result.overwritten.map((entry) => `- ${entry}`)].join('\n'));
+    if (result.removed.length > 0) sections.push(['Removed:', ...result.removed.map((entry) => `- ${entry}`)].join('\n'));
     if (result.updatedGitignores.length > 0)
         sections.push(['Updated .gitignore:', ...result.updatedGitignores.map((entry) => `- ${entry}`)].join('\n'));
     if (result.blocked.length > 0)

package/cli/commands/connect.ts

@@ -2,8 +2,9 @@ import cli from '..';
 import Compiler from '../compiler';
 import { readProteumManifest } from '../compiler/common/proteumManifest';
 import { buildConnectResponse, renderConnectHuman } from '@common/dev/connect';
+import { compactList, printAgentResponse, printJson, truncateForAgent } from '../utils/agentOutput';
 
-const allowedConnectArgs = new Set(['controllers', 'json', 'strict']);
+const allowedConnectArgs = new Set(['controllers', 'full', 'human', 'json', 'strict']);
 
 const validateConnectArgs = () => {
     const enabledArgs = Object.entries(cli.args)
@@ -19,6 +20,29 @@ const validateConnectArgs = () => {
     }
 };
 
+const compactDiagnostic = (diagnostic: ReturnType<typeof buildConnectResponse>['diagnostics'][number]) => ({
+    level: diagnostic.level,
+    code: diagnostic.code,
+    message: truncateForAgent(diagnostic.message),
+    filepath: diagnostic.filepath,
+    sourceLocation: diagnostic.sourceLocation,
+});
+
+const compactProject = (project: ReturnType<typeof buildConnectResponse>['projects'][number]) => ({
+    namespace: project.namespace,
+    identityIdentifier: project.identityIdentifier,
+    identityName: project.identityName,
+    sourceKind: project.sourceKind,
+    sourceConfigured: project.sourceConfigured,
+    urlInternalConfigured: project.urlInternalConfigured,
+    urlInternal: project.urlInternal,
+    controllerCount: project.controllerCount,
+    cachedContractExists: project.cachedContractExists,
+    cachedContractFilepath: project.cachedContractFilepath,
+    typingMode: project.typingMode,
+    controllers: project.controllers ? compactList(project.controllers, 8) : undefined,
+});
+
 export const run = async (): Promise<void> => {
     validateConnectArgs();
 
@@ -31,10 +55,22 @@ export const run = async (): Promise<void> => {
         strict: cli.args.strict === true,
     });
 
-    if (cli.args.json === true) {
-        console.log(JSON.stringify(response, null, 2));
-    } else {
+    if (cli.args.full === true) {
+        printJson(response);
+    } else if (cli.args.human === true) {
         console.log(renderConnectHuman(manifest, response));
+    } else {
+        printAgentResponse({
+            summary: `Connect: ${response.summary.connectedProjects} projects, ${response.summary.importedControllers} controllers, ${response.summary.errors} errors, ${response.summary.warnings} warnings`,
+            data: {
+                app: response.app,
+                summary: response.summary,
+                projects: response.projects.map(compactProject),
+                diagnostics: compactList(response.diagnostics, 10).map(compactDiagnostic),
+                totalDiagnostics: response.diagnostics.length,
+            },
+            fullDetailCommand: `proteum connect${cli.args.controllers === true ? ' --controllers' : ''} --full`,
+        });
     }
 
     if (cli.args.strict === true && response.diagnostics.length > 0) {

package/cli/commands/diagnose.ts

@@ -12,6 +12,7 @@ import type { TRequestTraceErrorResponse, TRequestTraceArmResponse } from '../..
 import type { TDevSessionErrorResponse, TDevSessionStartResponse } from '../../common/dev/session';
 import { summarizeTraceForDiagnose } from '@common/dev/inspection';
 import { readProteumManifest } from '../compiler/common/proteumManifest';
+import { compactList, printAgentResponse, printJson, quoteCommandArgument, truncateForAgent } from '../utils/agentOutput';
 
 const normalizeBaseUrl = (value: string) => value.replace(/\/+$/, '');
 const truncate = (value: string, max = 160) => (value.length <= max ? value : `${value.slice(0, max)}...`);
@@ -237,6 +238,132 @@ const renderHuman = (manifest: ReturnType<typeof readProteumManifest>, response:
         renderLogs(response.serverLogs),
     ].join('\n');
 
+const compactOwnerMatch = (match: TDiagnoseResponse['owner']['matches'][number]) => ({
+    kind: match.kind,
+    label: match.label,
+    score: match.score,
+    scope: match.scopeLabel,
+    origin: match.originHint,
+    source: match.source,
+});
+
+const compactDiagnostic = (diagnostic: TDiagnoseResponse['doctor']['diagnostics'][number]) => ({
+    level: diagnostic.level,
+    code: diagnostic.code,
+    message: truncateForAgent(diagnostic.message),
+    filepath: diagnostic.filepath,
+    sourceLocation: diagnostic.sourceLocation,
+    fixHint: diagnostic.fixHint ? truncateForAgent(diagnostic.fixHint) : undefined,
+});
+
+const compactRequest = (request: TDiagnoseResponse['request']) =>
+    request
+        ? {
+              id: request.id,
+              method: request.method,
+              path: request.path,
+              statusCode: request.statusCode,
+              durationMs: request.durationMs,
+              capture: request.capture,
+              user: request.user,
+              errorMessage: request.errorMessage,
+              counts: {
+                  calls: request.calls.length,
+                  events: request.events.length,
+                  sqlQueries: request.sqlQueries.length,
+                  droppedEvents: request.droppedEvents,
+              },
+          }
+        : undefined;
+
+const buildDiagnoseFullDetailCommand = ({
+    hitPath,
+    query,
+}: {
+    hitPath: string;
+    query: string;
+}) =>
+    [
+        'proteum diagnose',
+        quoteCommandArgument(query),
+        hitPath ? `--hit ${quoteCommandArgument(hitPath)}` : '',
+        typeof cli.args.port === 'string' && cli.args.port ? `--port ${cli.args.port}` : '',
+        typeof cli.args.url === 'string' && cli.args.url ? `--url ${quoteCommandArgument(cli.args.url)}` : '',
+        '--full',
+    ]
+        .filter(Boolean)
+        .join(' ');
+
+const printCompactDiagnose = ({
+    hitPath,
+    query,
+    response,
+}: {
+    hitPath: string;
+    query: string;
+    response: TDiagnoseResponse;
+}) => {
+    const request = compactRequest(response.request);
+    const traceSummary = summarizeTraceForDiagnose(response.request);
+    const doctorSummary = `${response.doctor.summary.errors} doctor errors/${response.doctor.summary.warnings} warnings`;
+    const contractsSummary = `${response.contracts.summary.errors} contract errors/${response.contracts.summary.warnings} warnings`;
+    const summary = `${response.query || query || 'request'}: ${traceSummary}; ${doctorSummary}; ${contractsSummary}`;
+    const nextActions = response.orientation?.nextSteps || [];
+    const requestId = response.request?.id;
+
+    printAgentResponse({
+        summary,
+        data: {
+            query: response.query,
+            request,
+            owner: {
+                top: response.owner.matches[0] ? compactOwnerMatch(response.owner.matches[0]) : undefined,
+                matches: compactList(response.owner.matches, 4).map(compactOwnerMatch),
+                totalReturned: response.owner.matches.length,
+            },
+            suspects: compactList(response.suspects, 6),
+            chain: compactList(response.chain || [], 8),
+            diagnostics: {
+                doctor: {
+                    summary: response.doctor.summary,
+                    top: compactList(response.doctor.diagnostics, 6).map(compactDiagnostic),
+                    total: response.doctor.diagnostics.length,
+                },
+                contracts: {
+                    summary: response.contracts.summary,
+                    top: compactList(response.contracts.diagnostics, 6).map(compactDiagnostic),
+                    total: response.contracts.diagnostics.length,
+                },
+            },
+            logs: compactList(response.serverLogs.logs, 10).map((entry) => ({
+                level: entry.level,
+                time: entry.time,
+                text: truncateForAgent(entry.text),
+            })),
+            instructions: response.orientation
+                ? {
+                      mustRead: [...new Set([response.orientation.guidance.agents, ...response.orientation.guidance.areaAgents])],
+                      diagnostics: response.orientation.guidance.diagnostics,
+                      codingStyle: response.orientation.guidance.codingStyle,
+                      optimizations: response.orientation.guidance.optimizations,
+                  }
+                : undefined,
+        },
+        nextActions,
+        fullDetailCommand: buildDiagnoseFullDetailCommand({ hitPath, query }),
+        omitted: [
+            ...(requestId
+                ? [
+                      {
+                          reason: 'Full request events, API call payloads, and SQL text are omitted from the default diagnose response.',
+                          command: `proteum trace show ${quoteCommandArgument(requestId)} --events`,
+                      },
+                  ]
+                : []),
+        ],
+    });
+};
+
 const resolveManifest = async () => {
     try {
         return readProteumManifest(cli.paths.appRoot);
@@ -258,7 +385,6 @@ export const run = async () => {
     const method = typeof cli.args.method === 'string' && cli.args.method ? cli.args.method.trim().toUpperCase() : 'GET';
     const logsLevel = typeof cli.args.logsLevel === 'string' && cli.args.logsLevel ? cli.args.logsLevel.trim() : 'warn';
     const logsLimit = typeof cli.args.logsLimit === 'string' && cli.args.logsLimit ? cli.args.logsLimit.trim() : '40';
-    const shouldPrintJson = cli.args.json === true;
     const hitPath = hit || (target.startsWith('/') ? target : '');
     const query = target || hitPath;
     let parsedDataJson: unknown;
@@ -308,11 +434,16 @@ export const run = async () => {
     const diagnose = await requestJson<TDiagnoseResponse>(
         `/__proteum/diagnose?${new URLSearchParams(diagnoseRequest).toString()}`,
     );
-    if (shouldPrintJson) {
-        console.log(JSON.stringify(diagnose.body, null, 2));
+    if (cli.args.full === true) {
+        printJson(diagnose.body);
+        return;
+    }
+
+    if (cli.args.human === true) {
+        const manifest = await resolveManifest();
+        console.log(renderHuman(manifest, diagnose.body));
         return;
     }
 
-    const manifest = await resolveManifest();
-    console.log(renderHuman(manifest, diagnose.body));
+    printCompactDiagnose({ hitPath, query, response: diagnose.body });
 };

package/cli/commands/doctor.ts

@@ -3,8 +3,9 @@ import Compiler from '../compiler';
 import { readProteumManifest } from '../compiler/common/proteumManifest';
 import { buildContractsDoctorResponse } from '@common/dev/contractsDoctor';
 import { buildDoctorResponse, renderDoctorHuman, renderDoctorResponseHuman } from '@common/dev/diagnostics';
+import { compactList, printAgentResponse, printJson, truncateForAgent } from '../utils/agentOutput';
 
-const allowedDoctorArgs = new Set(['contracts', 'json', 'strict']);
+const allowedDoctorArgs = new Set(['contracts', 'full', 'human', 'json', 'strict']);
 
 const validateDoctorArgs = () => {
     const enabledArgs = Object.entries(cli.args)
@@ -20,6 +21,15 @@ const validateDoctorArgs = () => {
     }
 };
 
+const compactDiagnostic = (diagnostic: ReturnType<typeof buildDoctorResponse>['diagnostics'][number]) => ({
+    level: diagnostic.level,
+    code: diagnostic.code,
+    message: truncateForAgent(diagnostic.message),
+    filepath: diagnostic.filepath,
+    sourceLocation: diagnostic.sourceLocation,
+    fixHint: diagnostic.fixHint ? truncateForAgent(diagnostic.fixHint) : undefined,
+});
+
 export const run = async (): Promise<void> => {
     validateDoctorArgs();
 
@@ -32,9 +42,9 @@ export const run = async (): Promise<void> => {
             ? buildContractsDoctorResponse(manifest, cli.args.strict === true)
             : buildDoctorResponse(manifest, cli.args.strict === true);
 
-    if (cli.args.json === true) {
-        console.log(JSON.stringify(response, null, 2));
-    } else {
+    if (cli.args.full === true) {
+        printJson(response);
+    } else if (cli.args.human === true) {
         console.log(
             cli.args.contracts === true
                 ? renderDoctorResponseHuman({
@@ -45,6 +55,16 @@ export const run = async (): Promise<void> => {
                   })
                 : renderDoctorHuman(manifest, cli.args.strict === true),
         );
+    } else {
+        printAgentResponse({
+            summary: `${cli.args.contracts === true ? 'Doctor contracts' : 'Doctor'}: ${response.summary.errors} errors, ${response.summary.warnings} warnings`,
+            data: {
+                summary: response.summary,
+                diagnostics: compactList(response.diagnostics, 10).map(compactDiagnostic),
+                totalDiagnostics: response.diagnostics.length,
+            },
+            fullDetailCommand: `proteum doctor${cli.args.contracts === true ? ' --contracts' : ''} --full`,
+        });
     }
 
     if (cli.args.strict === true && response.diagnostics.length > 0) {