arc-1 0.3.0 → 0.4.1

package/dist/handlers/intent.js

@@ -9,17 +9,23 @@
  * responses. Internal details (stack traces, SAP XML) are NOT
  * leaked to the LLM — only user-friendly error messages.
  */
-import { findDefinition, findReferences, getCompletion } from '../adt/codeintel.js';
+import { findDefinition, findReferences, findWhereUsed, getCompletion, } from '../adt/codeintel.js';
 import { createObject, deleteObject, lockObject, safeUpdateSource, unlockObject } from '../adt/crud.js';
-import { activate, runAtcCheck, runUnitTests, syntaxCheck } from '../adt/devtools.js';
+import { activate, activateBatch, runAtcCheck, runUnitTests, syntaxCheck } from '../adt/devtools.js';
+import { getDump, getTraceDbAccesses, getTraceHitlist, getTraceStatements, listDumps, listTraces, } from '../adt/diagnostics.js';
 import { AdtApiError, AdtNetworkError, AdtSafetyError } from '../adt/errors.js';
 import { mapSapReleaseToAbaplintVersion, probeFeatures } from '../adt/features.js';
+import { isOperationAllowed, OperationType } from '../adt/safety.js';
 import { createTransport, getTransport, listTransports, releaseTransport } from '../adt/transport.js';
-import { compressContext } from '../context/compressor.js';
-import { detectFilename, lintAbapSource } from '../lint/lint.js';
+import { extractCdsElements } from '../context/cds-deps.js';
+import { compressCdsContext, compressContext } from '../context/compressor.js';
+import { extractMethod, formatMethodListing, listMethods, spliceMethod } from '../context/method-surgery.js';
+import { buildLintConfig, listRulesFromConfig, } from '../lint/config-builder.js';
+import { detectFilename, lintAbapSource, lintAndFix, validateBeforeWrite } from '../lint/lint.js';
 import { sanitizeArgs } from '../server/audit.js';
 import { generateRequestId, requestContext } from '../server/context.js';
 import { logger } from '../server/logger.js';
+import { expandHyperfocusedArgs, getHyperfocusedScope } from './hyperfocused.js';
 /**
  * Scope required for each tool.
  *
@@ -86,7 +92,7 @@ function classifyError(err) {
  *   all tools are allowed (backward compatibility).
  * @param server - MCP Server instance for elicitation support.
  */
-export async function handleToolCall(client, _config, toolName, args, authInfo, _server) {
+export async function handleToolCall(client, config, toolName, args, authInfo, _server, cachingLayer) {
     const reqId = generateRequestId();
     const start = Date.now();
     // Build user context for audit logging
@@ -127,7 +133,7 @@ export async function handleToolCall(client, _config, toolName, args, authInfo,
             let result;
             switch (toolName) {
                 case 'SAPRead':
-                    result = await handleSAPRead(client, args);
+                    result = await handleSAPRead(client, args, cachingLayer);
                     break;
                 case 'SAPSearch':
                     result = await handleSAPSearch(client, args);
@@ -136,7 +142,7 @@ export async function handleToolCall(client, _config, toolName, args, authInfo,
                     result = await handleSAPQuery(client, args);
                     break;
                 case 'SAPWrite':
-                    result = await handleSAPWrite(client, args);
+                    result = await handleSAPWrite(client, args, config, cachingLayer);
                     break;
                 case 'SAPActivate':
                     result = await handleSAPActivate(client, args);
@@ -145,7 +151,7 @@ export async function handleToolCall(client, _config, toolName, args, authInfo,
                     result = await handleSAPNavigate(client, args);
                     break;
                 case 'SAPLint':
-                    result = await handleSAPLint(client, args);
+                    result = await handleSAPLint(client, args, config);
                     break;
                 case 'SAPDiagnose':
                     result = await handleSAPDiagnose(client, args);
@@ -154,11 +160,30 @@ export async function handleToolCall(client, _config, toolName, args, authInfo,
                     result = await handleSAPTransport(client, args);
                     break;
                 case 'SAPContext':
-                    result = await handleSAPContext(client, args);
+                    result = await handleSAPContext(client, args, cachingLayer);
                     break;
                 case 'SAPManage':
-                    result = await handleSAPManage(client, _config, args);
+                    result = await handleSAPManage(client, config, args, cachingLayer);
                     break;
+                case 'SAP': {
+                    // Hyperfocused mode: route to the appropriate handler
+                    const expanded = expandHyperfocusedArgs(args);
+                    if ('error' in expanded) {
+                        result = errorResult(expanded.error);
+                        break;
+                    }
+                    // Check scope for the delegated action
+                    if (authInfo) {
+                        const requiredScope = getHyperfocusedScope(String(args.action ?? ''));
+                        if (!authInfo.scopes.includes(requiredScope)) {
+                            result = errorResult(`Insufficient scope: '${requiredScope}' required for SAP(action="${args.action}"). Your scopes: [${authInfo.scopes.join(', ')}]`);
+                            break;
+                        }
+                    }
+                    // Delegate to the real handler (recursive call, but with the mapped tool name)
+                    result = await handleToolCall(client, config, expanded.toolName, expanded.expandedArgs, authInfo, _server, cachingLayer);
+                    break;
+                }
                 default:
                     result = errorResult(`Unknown tool: ${toolName}`);
             }
@@ -168,7 +193,7 @@ export async function handleToolCall(client, _config, toolName, args, authInfo,
             const resultPreview = fullText.length > 500 ? `${fullText.slice(0, 500)}...` : fullText;
             logger.emitAudit({
                 timestamp: new Date().toISOString(),
-                level: 'info',
+                level: result.isError ? 'error' : 'info',
                 event: 'tool_call_end',
                 requestId: reqId,
                 user,
@@ -177,6 +202,7 @@ export async function handleToolCall(client, _config, toolName, args, authInfo,
                 durationMs,
                 status: result.isError ? 'error' : 'success',
                 errorMessage: result.isError ? result.content[0]?.text : undefined,
+                errorClass: result.isError ? 'result-path' : undefined,
                 resultSize,
                 resultPreview,
             });
@@ -215,31 +241,64 @@ const BTP_HINTS = {
     TEXT_ELEMENTS: 'Text elements are not available on BTP ABAP Environment (no classic programs). Use message classes or constant classes instead.',
     VARIANTS: 'Variants are not available on BTP ABAP Environment (no classic programs).',
     SOBJ: 'BOR business objects (SOBJ) are not available on BTP ABAP Environment. Use RAP behavior definitions (BDEF) instead.',
+    TRAN: 'Transaction codes (TRAN) are not available on BTP ABAP Environment. Use SAPSearch to find apps and services instead.',
 };
-async function handleSAPRead(client, args) {
+async function handleSAPRead(client, args, cachingLayer) {
     const type = String(args.type ?? '');
     const name = String(args.name ?? '');
     // BTP: return helpful error for unavailable types
     if (isBtpSystem() && BTP_HINTS[type]) {
         return errorResult(BTP_HINTS[type]);
     }
+    // Helper: get source with cache support
+    const cachedGet = async (objType, objName, fetcher) => {
+        if (!cachingLayer)
+            return fetcher();
+        const { source } = await cachingLayer.getSource(objType, objName, fetcher);
+        return source;
+    };
     switch (type) {
         case 'PROG':
-            return textResult(await client.getProgram(name));
-        case 'CLAS':
+            return textResult(await cachedGet('PROG', name, () => client.getProgram(name)));
+        case 'CLAS': {
+            const methodParam = args.method;
+            if (methodParam && !args.include) {
+                // Method-level read — fetch full source then extract
+                const fullSource = await cachedGet('CLAS', name, () => client.getClass(name));
+                const abaplintVer = cachedFeatures?.abapRelease
+                    ? mapSapReleaseToAbaplintVersion(cachedFeatures.abapRelease)
+                    : undefined;
+                if (methodParam === '*') {
+                    const listing = listMethods(fullSource, name, abaplintVer);
+                    return textResult(formatMethodListing(listing));
+                }
+                const extracted = extractMethod(fullSource, name, methodParam, abaplintVer);
+                if (!extracted.success) {
+                    return errorResult(extracted.error ?? `Method "${methodParam}" not found in ${name}.`);
+                }
+                return textResult(extracted.methodSource);
+            }
+            // Only cache the full merged source (no include param), not individual includes
+            if (!args.include) {
+                return textResult(await cachedGet('CLAS', name, () => client.getClass(name)));
+            }
             return textResult(await client.getClass(name, args.include));
+        }
         case 'INTF':
-            return textResult(await client.getInterface(name));
+            return textResult(await cachedGet('INTF', name, () => client.getInterface(name)));
         case 'FUNC': {
             let group = String(args.group ?? '');
             if (!group) {
-                const resolved = await client.resolveFunctionGroup(name);
+                // Use cached func group resolution if available
+                const resolved = cachingLayer
+                    ? await cachingLayer.resolveFuncGroup(client, name)
+                    : await client.resolveFunctionGroup(name);
                 if (!resolved) {
                     return errorResult(`Cannot resolve function group for "${name}". Provide the group parameter explicitly, or use SAPSearch("${name}") to find the function group.`);
                 }
                 group = resolved;
             }
-            return textResult(await client.getFunction(group, name));
+            return textResult(await cachedGet('FUNC', name, () => client.getFunction(group, name)));
         }
         case 'FUGR': {
             const expand = Boolean(args.expand_includes);
@@ -265,17 +324,53 @@ async function handleSAPRead(client, args) {
             return textResult(JSON.stringify(fg, null, 2));
         }
         case 'INCL':
-            return textResult(await client.getInclude(name));
-        case 'DDLS':
-            return textResult(await client.getDdls(name));
+            return textResult(await cachedGet('INCL', name, () => client.getInclude(name)));
+        case 'DDLS': {
+            const ddlSource = await cachedGet('DDLS', name, () => client.getDdls(name));
+            if (args.include?.toLowerCase() === 'elements') {
+                return textResult(extractCdsElements(ddlSource, name));
+            }
+            return textResult(ddlSource);
+        }
         case 'BDEF':
-            return textResult(await client.getBdef(name));
+            return textResult(await cachedGet('BDEF', name, () => client.getBdef(name)));
         case 'SRVD':
-            return textResult(await client.getSrvd(name));
+            return textResult(await cachedGet('SRVD', name, () => client.getSrvd(name)));
+        case 'DDLX':
+            return textResult(await cachedGet('DDLX', name, () => client.getDdlx(name)));
+        case 'SRVB':
+            return textResult(await cachedGet('SRVB', name, () => client.getSrvb(name)));
         case 'TABL':
-            return textResult(await client.getTable(name));
+            return textResult(await cachedGet('TABL', name, () => client.getTable(name)));
         case 'VIEW':
-            return textResult(await client.getView(name));
+            return textResult(await cachedGet('VIEW', name, () => client.getView(name)));
+        case 'STRU':
+            return textResult(await cachedGet('STRU', name, () => client.getStructure(name)));
+        case 'DOMA': {
+            const domain = await client.getDomain(name);
+            return textResult(JSON.stringify(domain, null, 2));
+        }
+        case 'DTEL': {
+            const dtel = await client.getDataElement(name);
+            return textResult(JSON.stringify(dtel, null, 2));
+        }
+        case 'TRAN': {
+            const tran = await client.getTransaction(name);
+            // Enrich with program name via SQL — only if free SQL is allowed by safety config
+            if (isOperationAllowed(client.safety, OperationType.FreeSQL)) {
+                try {
+                    const safeName = name.toUpperCase().replace(/[^A-Z0-9_/]/g, '');
+                    const data = await client.runQuery(`SELECT TCODE, PGMNA FROM TSTC WHERE TCODE = '${safeName}'`, 1);
+                    if (data.rows.length > 0) {
+                        tran.program = String(data.rows[0].PGMNA ?? '').trim();
+                    }
+                }
+                catch {
+                    // SQL failed (e.g., TSTC not found on BTP) — still return metadata
+                }
+            }
+            return textResult(JSON.stringify(tran, null, 2));
+        }
         case 'TABLE_CONTENTS': {
             const maxRows = Number(args.maxRows ?? 100);
             const data = await client.getTableContents(name, maxRows, args.sqlFilter);
@@ -326,7 +421,7 @@ async function handleSAPRead(client, args) {
         case 'VARIANTS':
             return textResult(await client.getVariants(name));
         default:
-            return errorResult(`Unknown SAPRead type: ${type}. Supported: PROG, CLAS, INTF, FUNC, FUGR, INCL, DDLS, BDEF, SRVD, TABL, VIEW, TABLE_CONTENTS, DEVC, SOBJ, SYSTEM, COMPONENTS, MESSAGES, TEXT_ELEMENTS, VARIANTS`);
+            return errorResult(`Unknown SAPRead type: ${type}. Supported: PROG, CLAS, INTF, FUNC, FUGR, INCL, DDLS, DDLX, BDEF, SRVD, SRVB, TABL, VIEW, STRU, DOMA, DTEL, TRAN, TABLE_CONTENTS, DEVC, SOBJ, SYSTEM, COMPONENTS, MESSAGES, TEXT_ELEMENTS, VARIANTS`);
     }
 }
 async function handleSAPSearch(client, args) {
@@ -382,20 +477,69 @@ async function handleSAPQuery(client, args) {
         throw err;
     }
 }
-async function handleSAPLint(_client, args) {
+// _client unused: SAPLint runs offline via @abaplint/core (no SAP round-trip).
+// Signature matches other handlers for consistency with handleToolCall dispatch.
+async function handleSAPLint(_client, args, config) {
     const action = String(args.action ?? '');
+    const ruleOverrides = args.rules;
+    const configOptions = buildLintConfigOptions(config, ruleOverrides);
     switch (action) {
         case 'lint': {
             const source = String(args.source ?? '');
+            if (!source)
+                return errorResult('"source" is required for lint action.');
             const name = String(args.name ?? 'UNKNOWN');
             const filename = detectFilename(source, name);
-            const issues = lintAbapSource(source, filename);
+            const lintConfig = buildLintConfig(configOptions);
+            const issues = lintAbapSource(source, filename, lintConfig);
             return textResult(JSON.stringify(issues, null, 2));
         }
+        case 'lint_and_fix': {
+            const source = String(args.source ?? '');
+            if (!source)
+                return errorResult('"source" is required for lint_and_fix action.');
+            const name = String(args.name ?? 'UNKNOWN');
+            const filename = detectFilename(source, name);
+            const lintConfig = buildLintConfig(configOptions);
+            const result = lintAndFix(source, filename, lintConfig);
+            return textResult(JSON.stringify(result, null, 2));
+        }
+        case 'list_rules': {
+            const lintConfig = buildLintConfig(configOptions);
+            const rules = listRulesFromConfig(lintConfig);
+            const enabled = rules.filter((r) => r.enabled);
+            const disabled = rules.filter((r) => !r.enabled);
+            return textResult(JSON.stringify({
+                preset: configOptions.systemType === 'btp' ? 'cloud' : 'onprem',
+                abapVersion: cachedFeatures?.abapRelease ?? 'unknown',
+                enabledRules: enabled.length,
+                disabledRules: disabled.length,
+                rules: enabled,
+                disabledRuleNames: disabled.map((r) => r.rule),
+            }, null, 2));
+        }
         default:
-            return errorResult(`Unknown SAPLint action: ${action}. Supported: lint, atc, syntax`);
+            return errorResult(`Unknown SAPLint action: "${action}". Supported: lint, lint_and_fix, list_rules. For atc/syntax/unittest, use SAPDiagnose instead.`);
     }
 }
+/**
+ * Build LintConfigOptions from server config and cached features.
+ *
+ * Uses cachedFeatures (from SAPManage probe) when available, but falls back
+ * to config.systemType so that --system-type btp works even before the first
+ * probe. Without this fallback, cloud lint rules wouldn't apply until a probe
+ * populates cachedFeatures.
+ */
+function buildLintConfigOptions(config, ruleOverrides) {
+    // Probe-detected system type is most accurate; fall back to CLI config
+    const systemType = cachedFeatures?.systemType ?? (config.systemType !== 'auto' ? config.systemType : undefined);
+    return {
+        systemType,
+        abapRelease: cachedFeatures?.abapRelease,
+        configFile: config.abaplintConfig,
+        ruleOverrides,
+    };
+}
 // ─── Object URL Mapping ──────────────────────────────────────────────
 /** Map object type + name to the ADT object URL used by CRUD/DevTools/etc. */
 function objectUrlForType(type, name) {
@@ -419,8 +563,20 @@ function objectUrlForType(type, name) {
             return `/sap/bc/adt/bo/behaviordefinitions/${encoded}`;
         case 'SRVD':
             return `/sap/bc/adt/ddic/srvd/sources/${encoded}`;
+        case 'DDLX':
+            return `/sap/bc/adt/ddic/ddlx/sources/${encoded}`;
+        case 'SRVB':
+            return `/sap/bc/adt/businessservices/bindings/${encoded}`;
         case 'TABL':
             return `/sap/bc/adt/ddic/tables/${encoded}`;
+        case 'STRU':
+            return `/sap/bc/adt/ddic/structures/${encoded}`;
+        case 'DOMA':
+            return `/sap/bc/adt/ddic/domains/${encoded}`;
+        case 'DTEL':
+            return `/sap/bc/adt/ddic/dataelements/${encoded}`;
+        case 'TRAN':
+            return `/sap/bc/adt/vit/wb/object_type/trant/object_name/${encoded}`;
         default:
             return `/sap/bc/adt/programs/programs/${encoded}`;
     }
@@ -430,7 +586,7 @@ function sourceUrlForType(type, name) {
     return `${objectUrlForType(type, name)}/source/main`;
 }
 // ─── SAPWrite Handler ────────────────────────────────────────────────
-async function handleSAPWrite(client, args) {
+async function handleSAPWrite(client, args, config, cachingLayer) {
     const action = String(args.action ?? '');
     const type = String(args.type ?? '');
     const name = String(args.name ?? '');
@@ -440,8 +596,14 @@ async function handleSAPWrite(client, args) {
     const srcUrl = sourceUrlForType(type, name);
     switch (action) {
         case 'update': {
+            // Pre-write lint validation
+            const lintWarnings = runPreWriteLint(source, type, name, config);
+            if (lintWarnings.blocked)
+                return lintWarnings.result;
             await safeUpdateSource(client.http, client.safety, objectUrl, srcUrl, source, transport);
-            return textResult(`Successfully updated ${type} ${name}.`);
+            cachingLayer?.invalidate(type, name);
+            const msg = `Successfully updated ${type} ${name}.`;
+            return lintWarnings.warnings ? textResult(`${msg}\n\n${lintWarnings.warnings}`) : textResult(msg);
         }
         case 'create': {
             const pkg = String(args.package ?? '$TMP');
@@ -453,6 +615,37 @@ async function handleSAPWrite(client, args) {
             const result = await createObject(client.http, client.safety, objectUrl, body, 'application/xml', transport);
             return textResult(`Created ${type} ${name} in package ${pkg}.\n${result}`);
         }
+        case 'edit_method': {
+            const method = String(args.method ?? '');
+            if (!method)
+                return errorResult('"method" is required for edit_method action.');
+            if (!source)
+                return errorResult('"source" (new method body) is required for edit_method action.');
+            if (type !== 'CLAS')
+                return errorResult('edit_method is only supported for type=CLAS.');
+            // Fetch current full source (use cache if available)
+            const currentSource = cachingLayer
+                ? (await cachingLayer.getSource('CLAS', name, () => client.getClass(name))).source
+                : await client.getClass(name);
+            // Use detected ABAP version from probe if available
+            const abaplintVer = cachedFeatures?.abapRelease
+                ? mapSapReleaseToAbaplintVersion(cachedFeatures.abapRelease)
+                : undefined;
+            // Splice in the new method body
+            const spliced = spliceMethod(currentSource, name, method, source, abaplintVer);
+            if (!spliced.success) {
+                return errorResult(spliced.error ?? `Failed to splice method "${method}" in ${name}.`);
+            }
+            // Pre-write lint validation on the full spliced source
+            const lintWarnings = runPreWriteLint(spliced.newSource, type, name, config);
+            if (lintWarnings.blocked)
+                return lintWarnings.result;
+            // Write the full source back (existing lock/modify/unlock flow)
+            await safeUpdateSource(client.http, client.safety, objectUrl, srcUrl, spliced.newSource, transport);
+            cachingLayer?.invalidate(type, name);
+            const msg = `Successfully updated method "${method}" in ${type} ${name}.`;
+            return lintWarnings.warnings ? textResult(`${msg}\n\n${lintWarnings.warnings}`) : textResult(msg);
+        }
         case 'delete': {
             // Lock, delete, unlock pattern
             await client.http.withStatefulSession(async (session) => {
@@ -469,16 +662,81 @@ async function handleSAPWrite(client, args) {
                     }
                 }
             });
+            cachingLayer?.invalidate(type, name);
             return textResult(`Deleted ${type} ${name}.`);
         }
         default:
-            return errorResult(`Unknown SAPWrite action: ${action}. Supported: create, update, delete`);
+            return errorResult(`Unknown SAPWrite action: ${action}. Supported: create, update, delete, edit_method`);
+    }
+}
+/**
+ * Run pre-write lint validation on source code.
+ *
+ * This is a "lint-before-lock" optimization (pattern from vibing-steampunk):
+ * by validating locally before acquiring the SAP object lock, we avoid
+ * holding locks on objects that would fail validation anyway.
+ *
+ * Only runs a strict subset of correctness rules (parser_error, cloud_types, etc.)
+ * — not style/formatting rules. This prevents false rejections from opinionated
+ * style checks while catching genuine errors that would fail server-side anyway.
+ *
+ * If lint itself throws (e.g., abaplint bug on unusual syntax), we don't block
+ * the write — we let the SAP server-side syntax check handle it instead.
+ */
+function runPreWriteLint(source, type, name, config) {
+    if (!config.lintBeforeWrite || !source) {
+        return { blocked: false };
+    }
+    try {
+        const filename = detectFilename(source, name);
+        const systemType = cachedFeatures?.systemType ?? (config.systemType !== 'auto' ? config.systemType : undefined);
+        const configOptions = {
+            systemType,
+            abapRelease: cachedFeatures?.abapRelease,
+            configFile: config.abaplintConfig,
+        };
+        const result = validateBeforeWrite(source, filename, configOptions);
+        if (!result.pass) {
+            const errorLines = result.errors.map((e) => `  Line ${e.line}: [${e.rule}] ${e.message}`).join('\n');
+            return {
+                blocked: true,
+                result: errorResult(`Pre-write lint check failed for ${type} ${name}. Fix these errors before writing:\n${errorLines}\n\n` +
+                    'Use SAPLint action="lint_and_fix" to auto-fix, or disable with --lint-before-write=false.'),
+            };
+        }
+        if (result.warnings.length > 0) {
+            const warningLines = result.warnings.map((w) => `  Line ${w.line}: [${w.rule}] ${w.message}`).join('\n');
+            return {
+                blocked: false,
+                warnings: `Lint warnings:\n${warningLines}`,
+            };
+        }
+        return { blocked: false };
+    }
+    catch {
+        // If lint itself fails, don't block the write
+        return { blocked: false };
     }
 }
 // ─── SAPActivate Handler ─────────────────────────────────────────────
 async function handleSAPActivate(client, args) {
-    const name = String(args.name ?? '');
     const type = String(args.type ?? '');
+    // Batch activation: multiple objects at once (for RAP stacks etc.)
+    if (args.objects && Array.isArray(args.objects)) {
+        const objects = args.objects.map((o) => {
+            const objType = String(o.type ?? type);
+            const objName = String(o.name ?? '');
+            return { url: objectUrlForType(objType, objName), name: objName };
+        });
+        const result = await activateBatch(client.http, client.safety, objects);
+        const names = objects.map((o) => o.name).join(', ');
+        if (result.success) {
+            return textResult(`Successfully activated ${objects.length} objects: ${names}.${result.messages.length > 0 ? `\nMessages: ${result.messages.join('; ')}` : ''}`);
+        }
+        return errorResult(`Batch activation failed for: ${names}.\nErrors: ${result.messages.join('; ')}`);
+    }
+    // Single activation (existing behavior)
+    const name = String(args.name ?? '');
     const objectUrl = objectUrlForType(type, name);
     const result = await activate(client.http, client.safety, objectUrl);
     if (result.success) {
@@ -526,7 +784,31 @@ async function handleSAPNavigate(client, args) {
             if (!uri) {
                 return errorResult('Provide uri or type+name to find references.');
             }
-            const results = await findReferences(client.http, client.safety, uri);
+            const objectType = args.objectType ? String(args.objectType) : undefined;
+            let results;
+            try {
+                results = await findWhereUsed(client.http, client.safety, uri, objectType);
+            }
+            catch (err) {
+                // Only fall back for HTTP errors indicating the endpoint is not available (older SAP systems)
+                if (err instanceof AdtApiError && [404, 405, 415, 501].includes(err.statusCode)) {
+                    results = await findReferences(client.http, client.safety, uri);
+                    if (results.length === 0) {
+                        return textResult('No references found.');
+                    }
+                    const json = JSON.stringify(results, null, 2);
+                    if (objectType) {
+                        return textResult(JSON.stringify({
+                            note: `This SAP system does not support scope-based Where-Used. The objectType filter "${objectType}" was ignored — results below are unfiltered.`,
+                            results,
+                        }, null, 2));
+                    }
+                    return textResult(json);
+                }
+                else {
+                    throw err;
+                }
+            }
             if (results.length === 0) {
                 return textResult('No references found.');
             }
@@ -545,23 +827,64 @@ async function handleSAPDiagnose(client, args) {
     const action = String(args.action ?? '');
     const name = String(args.name ?? '');
     const type = String(args.type ?? '');
-    const objectUrl = objectUrlForType(type, name);
     switch (action) {
         case 'syntax': {
+            const objectUrl = objectUrlForType(type, name);
             const result = await syntaxCheck(client.http, client.safety, objectUrl);
             return textResult(JSON.stringify(result, null, 2));
         }
         case 'unittest': {
+            const objectUrl = objectUrlForType(type, name);
             const results = await runUnitTests(client.http, client.safety, objectUrl);
             return textResult(JSON.stringify(results, null, 2));
         }
         case 'atc': {
+            const objectUrl = objectUrlForType(type, name);
             const variant = args.variant;
             const result = await runAtcCheck(client.http, client.safety, objectUrl, variant);
             return textResult(JSON.stringify(result, null, 2));
         }
+        case 'dumps': {
+            const id = args.id;
+            if (id) {
+                // Get single dump detail
+                const detail = await getDump(client.http, client.safety, id);
+                return textResult(JSON.stringify(detail, null, 2));
+            }
+            // List dumps
+            const user = args.user;
+            const maxResults = args.maxResults ? Number(args.maxResults) : undefined;
+            const dumps = await listDumps(client.http, client.safety, { user, maxResults });
+            return textResult(JSON.stringify(dumps, null, 2));
+        }
+        case 'traces': {
+            const id = args.id;
+            if (id) {
+                // Get trace analysis
+                const analysis = String(args.analysis ?? 'hitlist');
+                switch (analysis) {
+                    case 'hitlist': {
+                        const hitlist = await getTraceHitlist(client.http, client.safety, id);
+                        return textResult(JSON.stringify(hitlist, null, 2));
+                    }
+                    case 'statements': {
+                        const statements = await getTraceStatements(client.http, client.safety, id);
+                        return textResult(JSON.stringify(statements, null, 2));
+                    }
+                    case 'dbAccesses': {
+                        const dbAccesses = await getTraceDbAccesses(client.http, client.safety, id);
+                        return textResult(JSON.stringify(dbAccesses, null, 2));
+                    }
+                    default:
+                        return errorResult(`Unknown trace analysis type: ${analysis}. Supported: hitlist, statements, dbAccesses`);
+                }
+            }
+            // List traces
+            const traces = await listTraces(client.http, client.safety);
+            return textResult(JSON.stringify(traces, null, 2));
+        }
         default:
-            return errorResult(`Unknown SAPDiagnose action: ${action}. Supported: syntax, unittest, atc`);
+            return errorResult(`Unknown SAPDiagnose action: ${action}. Supported: syntax, unittest, atc, dumps, traces`);
     }
 }
 // ─── SAPTransport Handler ────────────────────────────────────────────
@@ -601,14 +924,44 @@ async function handleSAPTransport(client, args) {
     }
 }
 // ─── SAPContext Handler ───────────────────────────────────────────────
-async function handleSAPContext(client, args) {
+async function handleSAPContext(client, args, cachingLayer) {
+    const action = String(args.action ?? '');
     const type = String(args.type ?? '');
     const name = String(args.name ?? '');
     const maxDeps = Number(args.maxDeps ?? 20);
     const depth = Math.min(Math.max(Number(args.depth ?? 1), 1), 3);
+    // ─── Reverse dep lookup (pre-warmer only) ─────────────────────────
+    if (action === 'usages') {
+        if (!name)
+            return errorResult('"name" is required for usages action.');
+        if (!cachingLayer) {
+            return errorResult('Reverse dependency lookup requires object caching. Cache is disabled (ARC1_CACHE=none). ' +
+                'Enable caching and run cache warmup to use this feature.');
+        }
+        const usages = cachingLayer.getUsages(name);
+        if (usages === null) {
+            return errorResult(`Reverse dependency lookup requires a pre-warmed cache. The cache warmup has not been run yet.\n\n` +
+                `To enable this feature:\n` +
+                `1. Start ARC-1 with --cache-warmup (or set ARC1_CACHE_WARMUP=true)\n` +
+                `2. Wait for the warmup to complete (indexes all custom objects)\n` +
+                `3. Then retry SAPContext(action="usages", name="${name}")\n\n` +
+                `Alternative: Use SAPNavigate(action="references", type="CLAS", name="${name}") for a live ADT lookup (slower, but works without warmup).`);
+        }
+        if (usages.length === 0) {
+            return textResult(`No objects found that depend on "${name}" in the cached index.`);
+        }
+        return textResult(JSON.stringify({ name, usageCount: usages.length, usages }, null, 2));
+    }
     if (!type || !name) {
         return errorResult('Both "type" and "name" are required for SAPContext.');
     }
+    // Helper: get source with cache support
+    const cachedGet = async (objType, objName, fetcher) => {
+        if (!cachingLayer)
+            return fetcher();
+        const { source } = await cachingLayer.getSource(objType, objName, fetcher);
+        return source;
+    };
     // Get source — either provided or fetched from SAP
     let source;
     if (args.source) {
@@ -617,37 +970,70 @@ async function handleSAPContext(client, args) {
     else {
         switch (type) {
             case 'CLAS':
-                source = await client.getClass(name);
+                source = await cachedGet('CLAS', name, () => client.getClass(name));
                 break;
             case 'INTF':
-                source = await client.getInterface(name);
+                source = await cachedGet('INTF', name, () => client.getInterface(name));
                 break;
             case 'PROG':
-                source = await client.getProgram(name);
+                source = await cachedGet('PROG', name, () => client.getProgram(name));
                 break;
             case 'FUNC': {
                 const group = String(args.group ?? '');
                 if (!group) {
                     return errorResult('The "group" parameter is required for FUNC type. Use SAPSearch to find the function group.');
                 }
-                source = await client.getFunction(group, name);
+                source = await cachedGet('FUNC', name, () => client.getFunction(group, name));
                 break;
             }
+            case 'DDLS': {
+                const ddlSource = await cachedGet('DDLS', name, () => client.getDdls(name));
+                const cdsResult = await compressCdsContext(client, ddlSource, name, maxDeps, depth, cachingLayer);
+                return textResult(cdsResult.output);
+            }
             default:
-                return errorResult(`SAPContext supports types: CLAS, INTF, PROG, FUNC. Got: ${type}`);
+                return errorResult(`SAPContext supports types: CLAS, INTF, PROG, FUNC, DDLS. Got: ${type}`);
+        }
+    }
+    // Check dep graph cache — if source hash matches, return cached contracts
+    if (cachingLayer) {
+        const cachedGraph = cachingLayer.getCachedDepGraph(source);
+        if (cachedGraph) {
+            const successful = cachedGraph.contracts.filter((c) => c.success);
+            const failed = cachedGraph.contracts.filter((c) => !c.success);
+            const lines = [];
+            lines.push(`* === Dependency context for ${name} (${successful.length} deps resolved${failed.length > 0 ? `, ${failed.length} failed` : ''}) [cached] ===`);
+            lines.push('');
+            for (const contract of successful) {
+                const typeLabel = contract.type.toLowerCase();
+                const methodLabel = contract.methodCount > 0 ? `, ${contract.methodCount} methods` : '';
+                lines.push(`* --- ${contract.name} (${typeLabel}${methodLabel}) ---`);
+                lines.push(contract.source.trim());
+                lines.push('');
+            }
+            if (failed.length > 0) {
+                lines.push('* --- Failed dependencies ---');
+                for (const f of failed) {
+                    lines.push(`* ${f.name}: ${f.error}`);
+                }
+                lines.push('');
+            }
+            const totalLines = lines.length;
+            lines.push(`* Stats: ${successful.length + failed.length} deps found, ${successful.length} resolved, ${failed.length} failed, ${totalLines} lines [from cache]`);
+            return textResult(lines.join('\n'));
         }
     }
     // Use detected ABAP version from probe if available, otherwise Cloud (superset)
     const abaplintVersion = cachedFeatures?.abapRelease
         ? mapSapReleaseToAbaplintVersion(cachedFeatures.abapRelease)
         : undefined;
-    const result = await compressContext(client, source, name, type, maxDeps, depth, abaplintVersion);
+    const result = await compressContext(client, source, name, type, maxDeps, depth, abaplintVersion, cachingLayer);
     return textResult(result.output);
 }
 // ─── SAPManage Handler ────────────────────────────────────────────────
 /** Cached feature status — populated on first probe */
 let cachedFeatures;
-async function handleSAPManage(client, config, args) {
+async function handleSAPManage(client, config, args, cachingLayer) {
     const action = String(args.action ?? '');
     switch (action) {
         case 'features': {
@@ -656,6 +1042,17 @@ async function handleSAPManage(client, config, args) {
             }
             return textResult(JSON.stringify(cachedFeatures, null, 2));
         }
+        case 'cache_stats': {
+            if (!cachingLayer) {
+                return textResult(JSON.stringify({ enabled: false, message: 'Object cache is disabled (ARC1_CACHE=none).' }));
+            }
+            const stats = cachingLayer.stats();
+            return textResult(JSON.stringify({
+                enabled: true,
+                warmupAvailable: cachingLayer.isWarmupAvailable,
+                ...stats,
+            }, null, 2));
+        }
         case 'probe': {
             const { defaultFeatureConfig } = await import('../adt/config.js');
             const featureConfig = defaultFeatureConfig();