arc-1 1.0.2 → 1.1.0

package/dist/handlers/diagnose.js

@@ -2,12 +2,444 @@
  * SAPDiagnose handler — runtime diagnostics: short dumps (ST22), traces, gateway errors, object
  * state, ATC, unit tests, CDS test cases.
  */
+import { AunitIncompleteError, appendAunitJunitDiagnostic, aunitIncompleteToJunit, aunitResultToJunit, DEFAULT_PUBLIC_AUNIT_TIMEOUT_MS, findStaticAbapIncludes, probePublicAunit, reconcileAunitProgramSources, reconcileAunitSourceDeclarations, runPublicAunit, } from '../adt/aunit.js';
+import { resolveAunitPackageSelection, } from '../adt/aunit-package.js';
 import { applyFixProposal, getAtcSystemDefaultVariant, getCdsTestCases, getFixProposals, listAtcVariants, runAtcCheck, runUnitTests, supportsCdsTestCases, syntaxCheck, } from '../adt/devtools.js';
 import { createTraceRequest, deleteTraceRequest, getAuthorizationTrace, getCdsCreateStatements, getDump, getGatewayErrorDetail, getObjectState, getSqlTraceDirectory, getSqlTraceState, getTraceDbAccesses, getTraceHitlist, getTraceStatements, listDumps, listGatewayErrors, listSystemMessages, listTraceRequests, listTraces, probeODataPerformance, setSqlTraceState, } from '../adt/diagnostics.js';
-import { AdtApiError } from '../adt/errors.js';
+import { AdtApiError, AdtNetworkError } from '../adt/errors.js';
 import { isBtpSystem } from './feature-cache.js';
 import { classIncludeUrl, normalizeObjectType, objectUrlForType, sourceUrlForType } from './object-types.js';
 import { errorResult, textResult, toolJson } from './shared.js';
+const AUNIT_SOURCE_MAX_BLOCKS = 80;
+const AUNIT_SOURCE_MAX_DEPTH = 5;
+const AUNIT_PACKAGE_SOURCE_CONCURRENCY = 8;
+const AUNIT_SOURCE_REQUEST_LIMIT = 500;
+class AunitSourceBudgetError extends Error {
+    constructor() {
+        super(`The ABAP Unit source audit exceeded its ${AUNIT_SOURCE_REQUEST_LIMIT}-request limit.`);
+        this.name = 'AunitSourceBudgetError';
+    }
+}
+function reserveAunitSourceRequests(budget, count = 1) {
+    if (budget.remainingSourceRequests < count)
+        throw new AunitSourceBudgetError();
+    budget.remainingSourceRequests -= count;
+    return { deadline: budget.deadline };
+}
+function isAunitDeadlineFailure(error) {
+    return (error instanceof AdtNetworkError &&
+        (error.cause?.name === 'TimeoutError' || /deadline was exceeded|timed out|\btimeout\b/i.test(error.message)));
+}
+function presentAunitSourceBlock(id, result) {
+    return {
+        id,
+        status: 'present',
+        source: result.source,
+        ...(result.etag ? { etag: result.etag } : {}),
+    };
+}
+async function readOptionalAunitClassInclude(client, name, include, budget) {
+    try {
+        return presentAunitSourceBlock(`CLAS:${name.toUpperCase()}:${include}`, await client.getClassInclude(name, include, {
+            ...reserveAunitSourceRequests(budget),
+            version: 'active',
+        }));
+    }
+    catch (error) {
+        if (!(error instanceof AdtApiError) || error.statusCode !== 404)
+            throw error;
+        return { id: `CLAS:${name.toUpperCase()}:${include}`, status: 'absent', source: '' };
+    }
+}
+async function readAunitSourceTree(client, type, name, budget) {
+    let initialBlocks;
+    try {
+        if (type === 'CLAS') {
+            const main = await client.getClass(name, undefined, {
+                ...reserveAunitSourceRequests(budget),
+                version: 'active',
+            });
+            const testBlock = await readOptionalAunitClassInclude(client, name, 'testclasses', budget);
+            const macrosBlock = await readOptionalAunitClassInclude(client, name, 'macros', budget);
+            // Global test classes declare FOR TESTING in main. Production classes normally keep local
+            // test declarations and macros in dedicated optional includes; a 404 is a verified absence.
+            initialBlocks = [presentAunitSourceBlock(`CLAS:${name.toUpperCase()}:main`, main), testBlock, macrosBlock];
+        }
+        else if (type === 'PROG') {
+            initialBlocks = [
+                presentAunitSourceBlock(`PROG:${name.toUpperCase()}:main`, await client.getProgram(name, { ...reserveAunitSourceRequests(budget), version: 'active' })),
+            ];
+        }
+        else if (type === 'FUGR') {
+            initialBlocks = [
+                presentAunitSourceBlock(`FUGR:${name.toUpperCase()}:main`, await client.getFunctionGroupSource(name, {
+                    ...reserveAunitSourceRequests(budget),
+                    version: 'active',
+                })),
+            ];
+        }
+        else {
+            return {
+                source: '',
+                complete: false,
+                incompleteReason: 'Source-selection verification is supported only for CLAS, PROG, and FUGR test runs.',
+                blocks: [],
+            };
+        }
+    }
+    catch (error) {
+        return {
+            source: '',
+            complete: false,
+            incompleteReason: error instanceof AunitSourceBudgetError
+                ? error.message
+                : isAunitDeadlineFailure(error)
+                    ? 'The ABAP Unit evidence deadline expired while reading active source.'
+                    : 'The source containing ABAP Unit class declarations could not be read from SAP.',
+            blocks: [],
+        };
+    }
+    const blocks = [...initialBlocks];
+    const seen = new Set();
+    let frontier = initialBlocks
+        .filter((block) => block.status === 'present')
+        .map((block) => ({ source: block.source, depth: 0 }));
+    let complete = true;
+    let incompleteReason;
+    while (frontier.length > 0) {
+        const pending = [];
+        for (const block of frontier) {
+            const includes = findStaticAbapIncludes(block.source);
+            if (block.depth >= AUNIT_SOURCE_MAX_DEPTH && includes.some((include) => !seen.has(include))) {
+                complete = false;
+                incompleteReason = 'The ABAP INCLUDE graph exceeded the source-audit depth limit.';
+                continue;
+            }
+            for (const include of includes) {
+                if (seen.has(include))
+                    continue;
+                seen.add(include);
+                if (blocks.length + pending.length >= AUNIT_SOURCE_MAX_BLOCKS) {
+                    complete = false;
+                    incompleteReason = 'The ABAP INCLUDE graph exceeded the source-audit block limit.';
+                    continue;
+                }
+                pending.push({ name: include, depth: block.depth + 1 });
+            }
+        }
+        if (pending.length === 0)
+            break;
+        const fetched = await Promise.allSettled(pending.map(async ({ name: include }) => client.getInclude(include, { ...reserveAunitSourceRequests(budget), version: 'active' })));
+        const next = [];
+        for (let index = 0; index < fetched.length; index += 1) {
+            const response = fetched[index];
+            if (response.status === 'rejected') {
+                complete = false;
+                incompleteReason =
+                    response.reason instanceof AunitSourceBudgetError
+                        ? response.reason.message
+                        : isAunitDeadlineFailure(response.reason)
+                            ? 'The ABAP Unit evidence deadline expired while reading static INCLUDE source.'
+                            : 'One or more static ABAP INCLUDE sources could not be read from SAP.';
+                continue;
+            }
+            blocks.push(presentAunitSourceBlock(`INCL:${pending[index].name}`, response.value));
+            next.push({ source: response.value.source, depth: pending[index].depth });
+        }
+        frontier = next;
+    }
+    return {
+        source: blocks
+            .filter((block) => block.status === 'present')
+            .map((block) => block.source)
+            .join('\n'),
+        complete,
+        ...(incompleteReason ? { incompleteReason } : {}),
+        blocks,
+    };
+}
+async function readAunitPackageSourceSnapshot(client, packageName, includeSubpackages, budget, snapshotsRemaining) {
+    let selection;
+    try {
+        selection = await resolveAunitPackageSelection(client.http, client.safety, packageName, includeSubpackages, reserveAunitSourceRequests(budget, 2));
+    }
+    catch (error) {
+        if (!(error instanceof AunitSourceBudgetError) && !isAunitDeadlineFailure(error))
+            throw error;
+        const incompleteReason = error instanceof AunitSourceBudgetError
+            ? error.message
+            : 'The ABAP Unit evidence deadline expired while resolving package membership.';
+        return {
+            selection: {
+                packageName: packageName.trim().toUpperCase(),
+                includeSubpackages,
+                objects: [],
+                membership: [],
+                complete: false,
+                incompleteReason,
+            },
+            entries: [],
+            complete: false,
+            incompleteReason,
+        };
+    }
+    const minimumSourceRequests = selection.objects.reduce((total, object) => total + (object.type === 'CLAS' ? 3 : 1), 0);
+    const futureSelectionRequests = snapshotsRemaining === 2 ? 2 : 0;
+    const minimumRemainingRequests = minimumSourceRequests * snapshotsRemaining + futureSelectionRequests;
+    if (!selection.complete || minimumRemainingRequests > budget.remainingSourceRequests) {
+        const incompleteReason = selection.incompleteReason ??
+            `The package requires at least ${minimumRemainingRequests} additional source-audit requests, exceeding the ${AUNIT_SOURCE_REQUEST_LIMIT}-request limit.`;
+        return { selection, entries: [], complete: false, incompleteReason };
+    }
+    const entries = [];
+    for (let offset = 0; offset < selection.objects.length; offset += AUNIT_PACKAGE_SOURCE_CONCURRENCY) {
+        const batch = selection.objects.slice(offset, offset + AUNIT_PACKAGE_SOURCE_CONCURRENCY);
+        const trees = await Promise.all(batch.map((object) => readAunitSourceTree(client, object.type, object.name, budget)));
+        entries.push(...batch.map((object, index) => ({ ...object, tree: trees[index] })));
+    }
+    const incompleteEntry = entries.find((entry) => !entry.tree.complete);
+    const incompleteReason = selection.incompleteReason ??
+        (incompleteEntry
+            ? `${incompleteEntry.type} ${incompleteEntry.name}: ${incompleteEntry.tree.incompleteReason ?? 'active source was incomplete'}`
+            : undefined);
+    return {
+        selection,
+        entries,
+        complete: selection.complete && incompleteEntry === undefined,
+        ...(incompleteReason ? { incompleteReason } : {}),
+    };
+}
+function aunitProgramName(object) {
+    if (object.type !== 'FUGR')
+        return object.name.toUpperCase();
+    const separator = object.name.lastIndexOf('/');
+    return separator > 0
+        ? `${object.name.slice(0, separator + 1)}SAPL${object.name.slice(separator + 1)}`.toUpperCase()
+        : `SAPL${object.name}`.toUpperCase();
+}
+function packageProgramSources(snapshot) {
+    return snapshot.entries.map((entry) => ({ program: aunitProgramName(entry), source: entry.tree.source }));
+}
+async function readAunitSelectionSnapshot(client, type, name, includeSubpackages, budget) {
+    return type === 'DEVC'
+        ? {
+            kind: 'package',
+            package: await readAunitPackageSourceSnapshot(client, name, includeSubpackages, budget, 2),
+        }
+        : { kind: 'object', tree: await readAunitSourceTree(client, type, name, budget) };
+}
+function sameAunitSourceSnapshot(before, after) {
+    if (before.blocks.length !== after.blocks.length)
+        return false;
+    return before.blocks.every((block, index) => {
+        const later = after.blocks[index];
+        return (later !== undefined &&
+            later.id === block.id &&
+            later.status === block.status &&
+            later.source === block.source &&
+            later.etag === block.etag);
+    });
+}
+function sameAunitPackageSnapshot(before, after) {
+    if (before.selection.packageName !== after.selection.packageName ||
+        before.selection.includeSubpackages !== after.selection.includeSubpackages ||
+        before.selection.membership.length !== after.selection.membership.length ||
+        !before.selection.membership.every((row, index) => after.selection.membership[index] === row) ||
+        before.entries.length !== after.entries.length) {
+        return false;
+    }
+    return before.entries.every((entry, index) => {
+        const later = after.entries[index];
+        return (later !== undefined &&
+            later.type === entry.type &&
+            later.name === entry.name &&
+            later.packageName === entry.packageName &&
+            later.uri === entry.uri &&
+            sameAunitSourceSnapshot(entry.tree, later.tree));
+    });
+}
+async function verifyAunitSourceSnapshot(client, type, name, before, budget) {
+    if (!before.complete)
+        return before;
+    const after = await readAunitSourceTree(client, type, name, budget);
+    if (!after.complete) {
+        return {
+            ...before,
+            complete: false,
+            incompleteReason: after.incompleteReason ?? 'The active ABAP source tree could not be re-read after the ABAP Unit run.',
+        };
+    }
+    if (!sameAunitSourceSnapshot(before, after)) {
+        return {
+            ...before,
+            complete: false,
+            incompleteReason: 'The active ABAP source tree changed while ABAP Unit evidence was being collected.',
+        };
+    }
+    return before;
+}
+async function verifyAunitSelectionSnapshot(client, type, name, includeSubpackages, before, budget) {
+    if (before.kind === 'object') {
+        return {
+            kind: 'object',
+            tree: await verifyAunitSourceSnapshot(client, type, name, before.tree, budget),
+        };
+    }
+    if (!before.package.complete)
+        return before;
+    const after = await readAunitPackageSourceSnapshot(client, name, includeSubpackages, budget, 1);
+    if (!after.complete) {
+        return {
+            kind: 'package',
+            package: {
+                ...before.package,
+                complete: false,
+                incompleteReason: after.incompleteReason ?? 'The package selection could not be re-read after the ABAP Unit run.',
+            },
+        };
+    }
+    if (!sameAunitPackageSnapshot(before.package, after)) {
+        return {
+            kind: 'package',
+            package: {
+                ...before.package,
+                complete: false,
+                incompleteReason: 'Package membership or active ABAP source changed while ABAP Unit evidence was collected.',
+            },
+        };
+    }
+    return before;
+}
+function reconcileAunitWithSource(result, evidence) {
+    return reconcileAunitSourceDeclarations(result, evidence.source, {
+        complete: evidence.complete,
+        ...(evidence.incompleteReason ? { incompleteReason: evidence.incompleteReason } : {}),
+    });
+}
+function reconcileAunitWithSelection(result, evidence) {
+    if (evidence.kind === 'object')
+        return reconcileAunitWithSource(result, evidence.tree);
+    return reconcileAunitProgramSources(result, packageProgramSources(evidence.package), {
+        complete: evidence.package.complete,
+        ...(evidence.package.incompleteReason ? { incompleteReason: evidence.package.incompleteReason } : {}),
+    });
+}
+function emptyAunitRunResult(coverage) {
+    return {
+        outcome: 'no_tests',
+        summary: { tests: 0, passed: 0, failures: 0, errors: 0, skipped: 0, warnings: 0 },
+        selection: { maxRisk: 'harmless', durations: ['short', 'medium', 'long'] },
+        tests: [],
+        alerts: [],
+        coverageEvidence: coverage ? 'unavailable' : 'not_requested',
+        ...(coverage ? { coverageUnavailableReason: 'measurement_not_reported' } : {}),
+    };
+}
+function incompleteAunitRunResult(coverage, message) {
+    return {
+        ...emptyAunitRunResult(coverage),
+        outcome: 'incomplete',
+        summary: { tests: 0, passed: 0, failures: 0, errors: 0, skipped: 0, warnings: 1 },
+        alerts: [
+            {
+                scope: 'run',
+                kind: 'deadline',
+                severity: 'tolerable',
+                title: 'ABAP Unit evidence collection did not complete',
+                details: [message],
+                message,
+                stack: [],
+            },
+        ],
+    };
+}
+function aunitSelectionRunnable(evidence) {
+    return evidence.kind === 'object' || evidence.package.complete;
+}
+async function runLegacyAunitForSelection(client, type, name, evidence, coverage, budget) {
+    if (!aunitSelectionRunnable(evidence))
+        return emptyAunitRunResult(coverage);
+    const objectUrls = evidence.kind === 'package'
+        ? evidence.package.selection.objects.map((object) => object.uri)
+        : [objectUrlForType(type, name)];
+    if (objectUrls.length === 0)
+        return emptyAunitRunResult(coverage);
+    try {
+        return await runUnitTests(client.http, client.safety, objectUrls, {
+            coverage,
+            requestOptions: { deadline: budget.deadline },
+        });
+    }
+    catch (error) {
+        if (isAunitDeadlineFailure(error)) {
+            return incompleteAunitRunResult(coverage, 'The ABAP Unit evidence deadline expired while executing the harmless legacy run.');
+        }
+        throw error;
+    }
+}
+function legacyAlertStatus(alerts) {
+    return alerts.some((alert) => alert.severity !== 'tolerable') ? 'failed' : 'skipped';
+}
+function legacyAlertRow(alert, testClass, testMethod) {
+    return {
+        program: alert.program ?? '',
+        testClass,
+        testMethod,
+        status: legacyAlertStatus([alert]),
+        ...(alert.message ? { message: alert.message } : {}),
+    };
+}
+/** Compatibility adapter kept at the SAPDiagnose legacy-output boundary. */
+export function toLegacyAunitResults(result) {
+    const rows = result.alerts
+        .filter((alert) => alert.scope === 'run')
+        .map((alert) => legacyAlertRow(alert, '(run)', '(alert)'));
+    const programs = new Set();
+    for (const test of result.tests)
+        programs.add(test.program);
+    for (const alert of result.alerts) {
+        if (alert.scope !== 'run')
+            programs.add(alert.program ?? '');
+    }
+    for (const program of programs) {
+        rows.push(...result.alerts
+            .filter((alert) => alert.scope === 'program' && (alert.program ?? '') === program)
+            .map((alert) => legacyAlertRow(alert, '(program)', '(alert)')));
+        const classes = new Set();
+        for (const test of result.tests) {
+            if (test.program === program)
+                classes.add(test.testClass);
+        }
+        for (const alert of result.alerts) {
+            if (alert.scope === 'class' && (alert.program ?? '') === program)
+                classes.add(alert.testClass ?? '');
+        }
+        for (const testClass of classes) {
+            const classAlerts = result.alerts.filter((alert) => alert.scope === 'class' && (alert.program ?? '') === program && (alert.testClass ?? '') === testClass);
+            const hasReportedClassAlert = classAlerts.some((alert) => alert.kind !== 'emptyClass');
+            for (const alert of classAlerts) {
+                if (alert.kind === 'emptyClass' && hasReportedClassAlert)
+                    continue;
+                rows.push(legacyAlertRow(alert.kind === 'emptyClass'
+                    ? { ...alert, message: 'test class reported no test methods and no alert' }
+                    : alert, testClass, '(class-level alert)'));
+            }
+            for (const test of result.tests) {
+                if (test.program !== program || test.testClass !== testClass)
+                    continue;
+                rows.push({
+                    program,
+                    testClass,
+                    testMethod: test.testMethod,
+                    status: test.alerts.length > 0 ? legacyAlertStatus(test.alerts) : 'passed',
+                    ...(test.alerts[0]?.message ? { message: test.alerts[0].message } : {}),
+                    ...(test.durationMs !== undefined ? { duration: test.durationMs / 1000 } : {}),
+                });
+            }
+        }
+    }
+    return rows;
+}
 export async function handleSAPDiagnose(client, args) {
     const action = String(args.action ?? '');
     const name = String(args.name ?? '');
@@ -23,18 +455,179 @@ export async function handleSAPDiagnose(client, args) {
             if (content !== undefined)
                 opts.content = content;
             const result = await syntaxCheck(client.http, client.safety, objectUrl, Object.keys(opts).length > 0 ? opts : undefined);
+            // Fail closed: SAP checked nothing (object does not exist yet) → never report "clean", or
+            // callers read hasErrors:false as "SAP will accept this source".
+            if (!result.checked) {
+                return textResult(toolJson({
+                    ...result,
+                    hasErrors: true,
+                    messages: [
+                        {
+                            severity: 'error',
+                            text: `Not checked — ${(result.statusText || 'SAP did not process this check').replace(/\.$/, '')}. The source was NOT validated; create the object first (SAPWrite action="create"), then re-run the syntax check.`,
+                            line: 0,
+                            column: 0,
+                        },
+                    ],
+                }));
+            }
             return textResult(toolJson(result));
         }
         case 'unittest': {
-            const objectUrl = objectUrlForType(type, name);
             const coverage = args.coverage === true;
-            const result = await runUnitTests(client.http, client.safety, objectUrl, { coverage });
+            const resultFormat = String(args.resultFormat ?? 'legacy');
+            const includeSubpackages = type === 'DEVC' && args.includeSubpackages === true;
+            const timeoutMs = args.timeoutSeconds === undefined ? DEFAULT_PUBLIC_AUNIT_TIMEOUT_MS : Number(args.timeoutSeconds) * 1000;
+            const evidenceBudget = {
+                deadline: Date.now() + timeoutMs,
+                remainingSourceRequests: AUNIT_SOURCE_REQUEST_LIMIT,
+            };
+            if (resultFormat === 'junit' && !coverage) {
+                let publicAvailable;
+                try {
+                    publicAvailable = await probePublicAunit(client.http, client.safety, {
+                        deadline: evidenceBudget.deadline,
+                    });
+                }
+                catch (error) {
+                    if (!isAunitDeadlineFailure(error))
+                        throw error;
+                    const message = 'The ABAP Unit evidence deadline expired while probing the public run API.';
+                    return textResult(toolJson({
+                        protocol: 'public-api',
+                        outcome: 'incomplete',
+                        summary: { tests: 0, passed: 0, failures: 0, errors: 0, skipped: 0, warnings: 0 },
+                        coverageEvidence: 'not_requested',
+                        incompleteReason: 'timeout',
+                        junit: aunitIncompleteToJunit(message, `${type} ${name}`),
+                        polls: 0,
+                        elapsedMs: Date.now() - (evidenceBudget.deadline - timeoutMs),
+                    }));
+                }
+                if (publicAvailable) {
+                    const sourceSnapshot = await readAunitSelectionSnapshot(client, type, name, includeSubpackages, evidenceBudget);
+                    let native;
+                    try {
+                        native = await runPublicAunit(client.http, client.safety, type, name, {
+                            includeSubpackages,
+                            timeoutMs,
+                            deadline: evidenceBudget.deadline,
+                        });
+                    }
+                    catch (error) {
+                        if (!(error instanceof AunitIncompleteError))
+                            throw error;
+                        const message = error.message;
+                        return textResult(toolJson({
+                            protocol: 'public-api',
+                            outcome: 'incomplete',
+                            summary: { tests: 0, passed: 0, failures: 0, errors: 0, skipped: 0, warnings: 0 },
+                            coverageEvidence: 'not_requested',
+                            incompleteReason: 'timeout',
+                            junit: aunitIncompleteToJunit(message, `${type} ${name}`),
+                            ...error.evidence,
+                        }));
+                    }
+                    const legacyEvidence = await runLegacyAunitForSelection(client, type, name, sourceSnapshot, false, evidenceBudget);
+                    const stableSourceSnapshot = await verifyAunitSelectionSnapshot(client, type, name, includeSubpackages, sourceSnapshot, evidenceBudget);
+                    const legacy = reconcileAunitWithSelection(legacyEvidence, stableSourceSnapshot);
+                    let outcome = native.summary.outcome;
+                    let incompleteReason;
+                    // Native JUnit omits run/class alerts, including harmless-selection refusals. Reconcile
+                    // every public run with one harmless legacy run; disagreement is evidence, never green.
+                    if (native.summary.failures > 0 || native.summary.errors > 0 || legacy.outcome === 'failed') {
+                        outcome = 'failed';
+                    }
+                    else if (native.summary.tests !== legacy.summary.tests) {
+                        outcome = 'incomplete';
+                        incompleteReason = 'native_legacy_result_mismatch';
+                    }
+                    else if (legacy.outcome === 'incomplete' ||
+                        (native.summary.tests > 0 && native.summary.skipped === native.summary.tests)) {
+                        outcome = 'incomplete';
+                        incompleteReason =
+                            legacy.sourceSelectionEvidence?.status === 'unavailable'
+                                ? 'source_selection_unavailable'
+                                : (legacy.sourceSelectionEvidence?.omittedNonHarmlessTestClasses.length ?? 0) > 0
+                                    ? 'source_declared_non_harmless_omitted'
+                                    : legacy.outcome === 'incomplete'
+                                        ? 'harmless_selection_incomplete'
+                                        : 'all_tests_skipped';
+                    }
+                    else if (native.summary.tests === 0 && legacy.outcome === 'no_tests') {
+                        outcome = 'no_tests';
+                    }
+                    else {
+                        outcome = 'passed';
+                    }
+                    const summary = {
+                        tests: native.summary.tests,
+                        passed: Math.max(0, native.summary.tests - native.summary.failures - native.summary.errors - native.summary.skipped),
+                        failures: native.summary.failures,
+                        errors: native.summary.errors,
+                        skipped: native.summary.skipped,
+                        warnings: legacy.summary.warnings,
+                    };
+                    let junit = native.junit;
+                    if ((outcome === 'failed' || outcome === 'incomplete') &&
+                        (outcome !== native.summary.outcome || incompleteReason !== undefined)) {
+                        const diagnosticMessage = outcome === 'failed'
+                            ? 'ARC-1 reconciliation found failure or error evidence in the harmless legacy ABAP Unit result that SAP native JUnit did not represent.'
+                            : `ARC-1 reconciliation could not verify a complete harmless ABAP Unit run (${incompleteReason ?? 'incomplete legacy evidence'}).`;
+                        junit = appendAunitJunitDiagnostic(native.junit, native.summary, outcome, diagnosticMessage);
+                    }
+                    return textResult(toolJson({
+                        protocol: native.protocol,
+                        outcome,
+                        summary,
+                        coverageEvidence: 'not_requested',
+                        ...(incompleteReason ? { incompleteReason } : {}),
+                        selectionEvidence: {
+                            outcome: legacy.outcome,
+                            summary: legacy.summary,
+                            alerts: legacy.alerts,
+                        },
+                        sourceSelectionEvidence: legacy.sourceSelectionEvidence,
+                        junit,
+                        runPath: native.runPath,
+                        resultPath: native.resultPath,
+                        polls: native.polls,
+                        elapsedMs: native.elapsedMs,
+                    }));
+                }
+            }
+            // SAP 7.58 can silently omit dangerous/critical classes from harmless-only legacy results.
+            // Audit a stable active-source snapshot for every format, including the compatibility array
+            // and coverage object, so the generic tool path cannot report a partial run as green.
+            const sourceSnapshot = await readAunitSelectionSnapshot(client, type, name, includeSubpackages, evidenceBudget);
+            const result = await runLegacyAunitForSelection(client, type, name, sourceSnapshot, coverage, evidenceBudget);
+            const stableSourceSnapshot = await verifyAunitSelectionSnapshot(client, type, name, includeSubpackages, sourceSnapshot, evidenceBudget);
+            const structured = reconcileAunitWithSelection(result, stableSourceSnapshot);
+            if (resultFormat === 'structured')
+                return textResult(toolJson(structured));
+            if (resultFormat === 'junit') {
+                return textResult(toolJson({
+                    protocol: 'legacy-generated',
+                    outcome: structured.outcome,
+                    summary: structured.summary,
+                    coverage: structured.coverage,
+                    coverageEvidence: structured.coverageEvidence,
+                    sourceSelectionEvidence: structured.sourceSelectionEvidence,
+                    junit: aunitResultToJunit(structured, `${type} ${name}`),
+                }));
+            }
+            const sourceSelectionUnsafe = structured.sourceSelectionEvidence?.status !== 'verified' ||
+                (structured.sourceSelectionEvidence?.omittedTestClasses.length ?? 0) > 0;
+            if (structured.outcome === 'incomplete' || sourceSelectionUnsafe) {
+                return errorResult(toolJson(structured));
+            }
             // Default (no coverage) keeps the historical array output; coverage requested → {tests, coverage}.
+            const tests = toLegacyAunitResults(structured);
             if (!coverage)
-                return textResult(toolJson(result.tests));
-            const out = { tests: result.tests };
-            if (result.coverage)
-                out.coverage = result.coverage;
+                return textResult(toolJson(tests));
+            const out = { tests };
+            if (structured.coverage)
+                out.coverage = structured.coverage;
             else
                 out.coverageNote =
                     'Coverage unavailable on this system (the coverage-measurement endpoint or measurement result was not available).';
@@ -43,8 +636,22 @@ export async function handleSAPDiagnose(client, args) {
         case 'atc': {
             const objectUrl = objectUrlForType(type, name);
             const variant = args.variant;
-            const result = await runAtcCheck(client.http, client.safety, objectUrl, variant);
-            return textResult(toolJson(result));
+            const result = await runAtcCheck(client.http, client.safety, objectUrl, variant, {
+                ...(args.timeoutSeconds === undefined ? {} : { timeoutMs: Number(args.timeoutSeconds) * 1000 }),
+            });
+            const response = result.processedObjectCount === 0
+                ? {
+                    ...result,
+                    hint: 'SAP reported no processed ATC objects. Verify the object, package, and selected check variant, then rerun ATC.',
+                }
+                : result;
+            if (args.resultFormat === 'structured')
+                return textResult(toolJson(response));
+            // Keep the successful legacy `{findings}` shape, but never discard completeness failures:
+            // a generic tool/CLI call must not turn malformed or missing worklist evidence into a clean run.
+            if (!result.complete)
+                return errorResult(toolJson(response));
+            return textResult(toolJson({ findings: result.findings }));
         }
         case 'atc_variants': {
             // Discover which check variant to pass to action="atc": the system default (used when none is