windows-exe-decompiler-mcp-server 0.1.0 → 0.1.3

package/dist/tools/report-summarize.js

@@ -3,6 +3,8 @@
  * Generates quick triage report with summary, confidence, IOCs, evidence, and recommendations.
  */
 import { z } from 'zod';
+import { BinaryRoleProfileDataSchema, createBinaryRoleProfileHandler, } from './binary-role-profile.js';
+import { RustBinaryAnalyzeDataSchema, createRustBinaryAnalyzeHandler, } from './rust-binary-analyze.js';
 import { createTriageWorkflowHandler } from '../workflows/triage.js';
 import { loadDynamicTraceEvidence } from '../dynamic-trace.js';
 import { loadSemanticFunctionExplanationIndex, } from '../semantic-name-suggestion-artifacts.js';
@@ -144,6 +146,8 @@ export const ReportSummarizeOutputSchema = z.object({
         evidence: z.array(z.string()).describe('Evidence supporting the assessment'),
         evidence_lineage: EvidenceLineageSchema.optional().describe('Explicit evidence layers separating static-only, simulated, memory/hybrid, and executed runtime evidence.'),
         confidence_semantics: ReportAssessmentConfidenceSchema.optional().describe('Explains how to interpret confidence scores. These are heuristic evidence scores, not calibrated probabilities.'),
+        binary_profile: BinaryRoleProfileDataSchema.optional().describe('Optional binary role profile summarizing EXE/DLL/COM/service/plugin/export characteristics.'),
+        rust_profile: RustBinaryAnalyzeDataSchema.optional().describe('Optional Rust-oriented binary analysis summary, including crate hints, recovered symbols, and recovery priorities.'),
         provenance: AnalysisProvenanceSchema.optional().describe('Explicit runtime/semantic artifact selection used to produce this report, including scope, session selector, and selected artifact IDs.'),
         selection_diffs: AnalysisSelectionDiffSchema.optional().describe('Optional comparison between the current artifact selection and a caller-provided baseline runtime/semantic selection.'),
         function_explanations: z
@@ -208,6 +212,176 @@ export const reportSummarizeToolDefinition = {
     inputSchema: ReportSummarizeInputSchema,
     outputSchema: ReportSummarizeOutputSchema,
 };
+function buildBinaryProfileSummary(binaryProfile) {
+    const lifecycleSurface = binaryProfile.lifecycle_surface || [];
+    const classFactorySurface = binaryProfile.com_profile.class_factory_surface || [];
+    const callbackSurface = binaryProfile.host_interaction_profile.callback_surface || [];
+    const parts = [
+        `Binary role profile suggests ${binaryProfile.binary_role} (confidence=${binaryProfile.role_confidence.toFixed(2)})`,
+    ];
+    if (binaryProfile.export_surface.total_exports > 0) {
+        parts.push(`exports=${binaryProfile.export_surface.total_exports}`);
+    }
+    if (binaryProfile.indicators.com_server.likely) {
+        parts.push('COM-like surface detected');
+    }
+    if (binaryProfile.indicators.service_binary.likely) {
+        parts.push('service indicators detected');
+    }
+    if (binaryProfile.export_dispatch_profile.likely_dispatch_model !== 'none') {
+        parts.push(`dispatch_model=${binaryProfile.export_dispatch_profile.likely_dispatch_model}`);
+    }
+    if (binaryProfile.export_dispatch_profile.registration_exports.length > 0) {
+        parts.push(`registration_exports=${binaryProfile.export_dispatch_profile.registration_exports.slice(0, 2).join(', ')}`);
+    }
+    if (lifecycleSurface.length > 0) {
+        parts.push(`dll_lifecycle=${lifecycleSurface.slice(0, 2).join(', ')}`);
+    }
+    if (binaryProfile.com_profile.class_factory_exports.length > 0) {
+        parts.push(`class_factory_exports=${binaryProfile.com_profile.class_factory_exports.slice(0, 2).join(', ')}`);
+    }
+    if (classFactorySurface.length > 0) {
+        parts.push(`class_factory_surface=${classFactorySurface.slice(0, 2).join(', ')}`);
+    }
+    if (binaryProfile.host_interaction_profile.callback_exports.length > 0) {
+        parts.push(`callback_exports=${binaryProfile.host_interaction_profile.callback_exports.slice(0, 2).join(', ')}`);
+    }
+    if (callbackSurface.length > 0) {
+        parts.push(`callback_surface=${callbackSurface.slice(0, 2).join(', ')}`);
+    }
+    if (binaryProfile.host_interaction_profile.likely_hosted) {
+        parts.push('host/plugin interaction surface detected');
+    }
+    if (binaryProfile.host_interaction_profile.host_hints.length > 0) {
+        parts.push(`host_hints=${binaryProfile.host_interaction_profile.host_hints.slice(0, 2).join(', ')}`);
+    }
+    if (binaryProfile.packed) {
+        parts.push('packing signals present');
+    }
+    return `${parts.join(', ')}.`;
+}
+function augmentWithBinaryProfile(triageData, binaryProfile) {
+    if (!binaryProfile) {
+        return triageData;
+    }
+    const summaryLine = buildBinaryProfileSummary(binaryProfile);
+    const lifecycleSurface = binaryProfile.lifecycle_surface || [];
+    const classFactorySurface = binaryProfile.com_profile.class_factory_surface || [];
+    const callbackSurface = binaryProfile.host_interaction_profile.callback_surface || [];
+    const evidenceLines = dedupe([
+        summaryLine,
+        ...binaryProfile.analysis_priorities.map((item) => `binary_profile_priority: ${item}`),
+        ...binaryProfile.export_dispatch_profile.registration_exports.map((item) => `binary_profile_surface: registration_export=${item}`),
+        ...lifecycleSurface.map((item) => `binary_profile_surface: dll_lifecycle=${item}`),
+        ...binaryProfile.com_profile.class_factory_exports.map((item) => `binary_profile_surface: class_factory_export=${item}`),
+        ...classFactorySurface.map((item) => `binary_profile_surface: class_factory_surface=${item}`),
+        ...binaryProfile.host_interaction_profile.callback_exports.map((item) => `binary_profile_surface: callback_export=${item}`),
+        ...callbackSurface.map((item) => `binary_profile_surface: callback_surface=${item}`),
+        ...binaryProfile.host_interaction_profile.host_hints.map((item) => `binary_profile_surface: host_hint=${item}`),
+    ]);
+    const recommendationSuffix = binaryProfile.analysis_priorities.length > 0
+        ? ` Binary role priorities: ${binaryProfile.analysis_priorities.join(', ')}.`
+        : '';
+    return {
+        ...triageData,
+        summary: `${triageData.summary} ${summaryLine}`,
+        evidence: dedupe([...triageData.evidence, ...evidenceLines]),
+        binary_profile: binaryProfile,
+        recommendation: `${triageData.recommendation}${recommendationSuffix}`.trim(),
+        inference: triageData.inference
+            ? {
+                ...triageData.inference,
+                hypotheses: dedupe([
+                    ...triageData.inference.hypotheses,
+                    `Binary role profile suggests ${binaryProfile.binary_role}.`,
+                ]),
+            }
+            : triageData.inference,
+    };
+}
+function buildRustProfileSummary(rustProfile) {
+    const parts = [
+        `Rust-focused analysis ${rustProfile.suspected_rust ? 'suggests a Rust-oriented binary' : 'did not strongly confirm Rust'} (confidence=${rustProfile.confidence.toFixed(2)})`,
+    ];
+    if (rustProfile.primary_runtime) {
+        parts.push(`runtime=${rustProfile.primary_runtime}`);
+    }
+    if (rustProfile.crate_hints.length > 0) {
+        parts.push(`crate_hints=${rustProfile.crate_hints.slice(0, 4).join(', ')}`);
+    }
+    if (rustProfile.recovered_function_count > 0) {
+        parts.push(`recovered_functions=${rustProfile.recovered_function_count}`);
+    }
+    if (rustProfile.recovered_symbol_count > 0) {
+        parts.push(`recovered_symbols=${rustProfile.recovered_symbol_count}`);
+    }
+    return `${parts.join(', ')}.`;
+}
+function augmentWithRustProfile(triageData, rustProfile) {
+    if (!rustProfile) {
+        return triageData;
+    }
+    const summaryLine = buildRustProfileSummary(rustProfile);
+    const rustPriorityLines = rustProfile.analysis_priorities.map((item) => `rust_analysis_priority: ${item}`);
+    const compilerArtifacts = {
+        ...(triageData.iocs.compiler_artifacts || {}),
+        cargo_paths: dedupe([
+            ...(triageData.iocs.compiler_artifacts?.cargo_paths || []),
+            ...rustProfile.cargo_paths,
+        ]),
+        rust_markers: dedupe([
+            ...(triageData.iocs.compiler_artifacts?.rust_markers || []),
+            ...rustProfile.rust_markers,
+        ]),
+        library_profile: rustProfile.library_profile || triageData.iocs.compiler_artifacts?.library_profile,
+    };
+    const recommendationSuffix = rustProfile.analysis_priorities.length > 0
+        ? ` Rust recovery priorities: ${rustProfile.analysis_priorities.join(', ')}.`
+        : '';
+    return {
+        ...triageData,
+        summary: `${triageData.summary} ${summaryLine}`.trim(),
+        iocs: {
+            ...triageData.iocs,
+            compiler_artifacts: compilerArtifacts,
+        },
+        evidence: dedupe([summaryLine, ...triageData.evidence, ...rustProfile.evidence, ...rustPriorityLines]),
+        rust_profile: rustProfile,
+        recommendation: `${triageData.recommendation}${recommendationSuffix}`.trim(),
+        inference: triageData.inference
+            ? {
+                ...triageData.inference,
+                hypotheses: dedupe([
+                    ...triageData.inference.hypotheses,
+                    rustProfile.suspected_rust
+                        ? 'Rust/toolchain evidence is strong enough to prioritize non-Ghidra function recovery paths.'
+                        : 'Rust/toolchain evidence remains weak; keep recovery paths heuristic.',
+                ]),
+                tooling_assessment: triageData.inference.tooling_assessment
+                    ? {
+                        ...triageData.inference.tooling_assessment,
+                        framework_hints: dedupe([
+                            ...triageData.inference.tooling_assessment.framework_hints,
+                            ...rustProfile.crate_hints,
+                        ]),
+                        toolchain_markers: dedupe([
+                            ...triageData.inference.tooling_assessment.toolchain_markers,
+                            ...rustProfile.runtime_hints,
+                        ]),
+                        library_profile: triageData.inference.tooling_assessment.library_profile ||
+                            rustProfile.library_profile,
+                    }
+                    : {
+                        help_text_detected: false,
+                        cli_surface_detected: false,
+                        framework_hints: rustProfile.crate_hints,
+                        toolchain_markers: rustProfile.runtime_hints,
+                        library_profile: rustProfile.library_profile,
+                    },
+            }
+            : triageData.inference,
+    };
+}
 function toolMetrics(startTime) {
     return {
         elapsed_ms: Date.now() - startTime,
@@ -334,6 +508,18 @@ function augmentWithDynamicEvidence(triageData, dynamicEvidence) {
             buildEvidenceLayerHeadline(evidenceLineage),
             ...triageData.evidence,
             ...dynamicEvidence.evidence,
+            ...(dynamicEvidence.protections || []).length > 0
+                ? [`Runtime protections: ${(dynamicEvidence.protections || []).slice(0, 4).join(', ')}.`]
+                : [],
+            ...(dynamicEvidence.region_owners || []).length > 0
+                ? [`Runtime region owners: ${(dynamicEvidence.region_owners || []).slice(0, 4).join(', ')}.`]
+                : [],
+            ...(dynamicEvidence.observed_modules || []).length > 0
+                ? [`Runtime observed modules: ${(dynamicEvidence.observed_modules || []).slice(0, 4).join(', ')}.`]
+                : [],
+            ...(dynamicEvidence.segment_names || []).length > 0
+                ? [`Runtime segment names: ${(dynamicEvidence.segment_names || []).slice(0, 4).join(', ')}.`]
+                : [],
         ]),
         evidence_lineage: evidenceLineage,
         evidence_weights: {
@@ -348,6 +534,12 @@ function augmentWithDynamicEvidence(triageData, dynamicEvidence) {
                 hypotheses: dedupe([
                     ...triageData.inference.hypotheses,
                     ...dynamicEvidence.stages.map((item) => `Imported runtime evidence indicates stage: ${item}.`),
+                    ...(dynamicEvidence.observed_modules || [])
+                        .slice(0, 3)
+                        .map((item) => `Imported runtime evidence observed module: ${item}.`),
+                    ...(dynamicEvidence.segment_names || [])
+                        .slice(0, 3)
+                        .map((item) => `Imported runtime evidence observed segment: ${item}.`),
                 ]),
                 false_positive_risks: dedupe([
                     ...triageData.inference.false_positive_risks,
@@ -367,7 +559,7 @@ function augmentWithDynamicEvidence(triageData, dynamicEvidence) {
             },
     };
 }
-function createMinimalDotnetFallback(triageResult, startTime, functionExplanations = [], provenance, evidenceScope = 'all') {
+function createMinimalDotnetFallback(triageResult, startTime, functionExplanations = [], provenance, evidenceScope = 'all', binaryProfile, rustProfile) {
     const triageErrors = triageResult.errors || [];
     const warnings = [
         'report.summarize(mode=dotnet) is not fully implemented; returned degraded fallback output.',
@@ -390,8 +582,12 @@ function createMinimalDotnetFallback(triageResult, startTime, functionExplanatio
             evidence: [
                 'Dotnet mode unavailable; triage fallback failed.',
                 ...triageErrors.map((item) => `triage_error: ${item}`),
+                ...(binaryProfile ? [buildBinaryProfileSummary(binaryProfile)] : []),
+                ...(rustProfile ? [buildRustProfileSummary(rustProfile)] : []),
             ],
             confidence_semantics: buildAssessmentConfidencePayload(0.2, evidenceScope),
+            binary_profile: binaryProfile,
+            rust_profile: rustProfile,
             provenance,
             function_explanations: functionExplanations.length > 0 ? functionExplanations : undefined,
             inference: {
@@ -401,20 +597,20 @@ function createMinimalDotnetFallback(triageResult, startTime, functionExplanatio
                 ],
                 false_positive_risks: ['No triage evidence is available in this degraded fallback result.'],
             },
-            recommendation: 'Re-run after ensuring workspace/original sample file exists, then use workflow.reconstruct or dotnet.reconstruct.export for .NET-specific structure.',
+            recommendation: `Re-run after ensuring workspace/original sample file exists, then use workflow.reconstruct or dotnet.reconstruct.export for .NET-specific structure.${binaryProfile?.analysis_priorities?.length ? ` Binary role priorities: ${binaryProfile.analysis_priorities.join(', ')}.` : ''}${rustProfile?.analysis_priorities?.length ? ` Rust recovery priorities: ${rustProfile.analysis_priorities.join(', ')}.` : ''}`,
         },
         warnings,
         errors: triageErrors.length > 0 ? triageErrors : undefined,
         metrics: toolMetrics(startTime),
     };
 }
-function createDynamicEvidenceFallback(dynamicEvidence, triageResult, startTime, functionExplanations = [], provenance, evidenceScope = 'all') {
+function createDynamicEvidenceFallback(dynamicEvidence, triageResult, startTime, functionExplanations = [], provenance, evidenceScope = 'all', binaryProfile, rustProfile) {
     const evidenceLineage = buildEvidenceLineage(dynamicEvidence);
     const threatLevel = dynamicEvidence.high_signal_apis.length > 0 ? 'suspicious' : dynamicEvidence.executed ? 'suspicious' : 'unknown';
     return {
         ok: true,
         data: {
-            summary: `Triage pipeline failed, but imported runtime evidence is available. ${buildEvidenceLayerHeadline(evidenceLineage)} ${dynamicEvidence.summary}`,
+            summary: `Triage pipeline failed, but imported runtime evidence is available. ${buildEvidenceLayerHeadline(evidenceLineage)} ${dynamicEvidence.summary}${binaryProfile ? ` ${buildBinaryProfileSummary(binaryProfile)}` : ''}${rustProfile ? ` ${buildRustProfileSummary(rustProfile)}` : ''}`,
             confidence: dynamicEvidence.executed ? 0.66 : 0.5,
             threat_level: threatLevel,
             iocs: {
@@ -425,9 +621,16 @@ function createDynamicEvidenceFallback(dynamicEvidence, triageResult, startTime,
                     suspicious_apis: dynamicEvidence.high_signal_apis,
                 },
             },
-            evidence: dedupe([buildEvidenceLayerHeadline(evidenceLineage), ...dynamicEvidence.evidence]),
+            evidence: dedupe([
+                buildEvidenceLayerHeadline(evidenceLineage),
+                ...dynamicEvidence.evidence,
+                ...(binaryProfile ? [buildBinaryProfileSummary(binaryProfile)] : []),
+                ...(rustProfile ? [buildRustProfileSummary(rustProfile)] : []),
+            ]),
             evidence_lineage: evidenceLineage,
             confidence_semantics: buildAssessmentConfidencePayload(dynamicEvidence.executed ? 0.66 : 0.5, evidenceScope, evidenceLineage),
+            binary_profile: binaryProfile,
+            rust_profile: rustProfile,
             provenance,
             function_explanations: functionExplanations.length > 0 ? functionExplanations : undefined,
             evidence_weights: {
@@ -444,7 +647,7 @@ function createDynamicEvidenceFallback(dynamicEvidence, triageResult, startTime,
                         : 'Memory/hybrid evidence is suggestive but not equivalent to a fully executed trace.',
                 ],
             },
-            recommendation: 'Correlate imported runtime evidence with code.functions.search, code.functions.reconstruct, and code.reconstruct.export to assign concrete function ownership.',
+            recommendation: `Correlate imported runtime evidence with code.functions.search, code.functions.reconstruct, and code.reconstruct.export to assign concrete function ownership.${binaryProfile?.analysis_priorities?.length ? ` Binary role priorities: ${binaryProfile.analysis_priorities.join(', ')}.` : ''}${rustProfile?.analysis_priorities?.length ? ` Rust recovery priorities: ${rustProfile.analysis_priorities.join(', ')}.` : ''}`,
         },
         warnings: [
             'Triage pipeline failed; returned imported runtime-evidence fallback.',
@@ -456,6 +659,10 @@ function createDynamicEvidenceFallback(dynamicEvidence, triageResult, startTime,
 }
 export function createReportSummarizeHandler(workspaceManager, database, cacheManager, deps) {
     const triageHandler = deps?.triageHandler || createTriageWorkflowHandler(workspaceManager, database, cacheManager);
+    const binaryRoleProfileHandler = deps?.binaryRoleProfileHandler ||
+        createBinaryRoleProfileHandler(workspaceManager, database, cacheManager);
+    const rustBinaryAnalyzeHandler = deps?.rustBinaryAnalyzeHandler ||
+        createRustBinaryAnalyzeHandler(workspaceManager, database, cacheManager);
     return async (args) => {
         const startTime = Date.now();
         try {
@@ -467,10 +674,31 @@ export function createReportSummarizeHandler(workspaceManager, database, cacheMa
                     errors: [`Sample not found: ${input.sample_id}`],
                 };
             }
+            const warnings = [];
             const dynamicEvidence = await loadDynamicTraceEvidence(workspaceManager, database, input.sample_id, {
                 evidenceScope: input.evidence_scope,
                 sessionTag: input.evidence_session_tag,
             });
+            const binaryRoleProfileResult = await binaryRoleProfileHandler({ sample_id: input.sample_id });
+            const binaryProfile = binaryRoleProfileResult.ok && binaryRoleProfileResult.data
+                ? binaryRoleProfileResult.data
+                : undefined;
+            if (!binaryRoleProfileResult.ok) {
+                warnings.push(`binary.role.profile unavailable: ${(binaryRoleProfileResult.errors || ['unknown error']).join('; ')}`);
+            }
+            else if (binaryRoleProfileResult.warnings?.length) {
+                warnings.push(...binaryRoleProfileResult.warnings.map((item) => `binary.role.profile: ${item}`));
+            }
+            const rustBinaryAnalyzeResult = await rustBinaryAnalyzeHandler({ sample_id: input.sample_id });
+            const rustProfile = rustBinaryAnalyzeResult.ok && rustBinaryAnalyzeResult.data
+                ? rustBinaryAnalyzeResult.data
+                : undefined;
+            if (!rustBinaryAnalyzeResult.ok) {
+                warnings.push(`rust_binary.analyze unavailable: ${(rustBinaryAnalyzeResult.errors || ['unknown error']).join('; ')}`);
+            }
+            else if (rustBinaryAnalyzeResult.warnings?.length) {
+                warnings.push(...rustBinaryAnalyzeResult.warnings.map((item) => `rust_binary.analyze: ${item}`));
+            }
             const functionExplanationBundle = await loadFunctionExplanationSummaries(workspaceManager, database, input.sample_id, {
                 scope: input.semantic_scope,
                 sessionTag: input.semantic_session_tag,
@@ -502,7 +730,7 @@ export function createReportSummarizeHandler(workspaceManager, database, cacheMa
             if (input.mode === 'triage') {
                 if (!triageResult.ok || !triageResult.data) {
                     if (dynamicEvidence) {
-                        return createDynamicEvidenceFallback(dynamicEvidence, triageResult, startTime, functionExplanations, provenance, input.evidence_scope);
+                        return createDynamicEvidenceFallback(dynamicEvidence, triageResult, startTime, functionExplanations, provenance, input.evidence_scope, binaryProfile, rustProfile);
                     }
                     return {
                         ok: false,
@@ -515,7 +743,9 @@ export function createReportSummarizeHandler(workspaceManager, database, cacheMa
                 const triageData = dynamicEvidence
                     ? augmentWithDynamicEvidence(triageDataBase, dynamicEvidence)
                     : triageDataBase;
-                const enrichedTriageData = augmentWithFunctionExplanations(triageData, functionExplanations);
+                const binaryEnrichedTriageData = augmentWithBinaryProfile(triageData, binaryProfile);
+                const rustEnrichedTriageData = augmentWithRustProfile(binaryEnrichedTriageData, rustProfile);
+                const enrichedTriageData = augmentWithFunctionExplanations(rustEnrichedTriageData, functionExplanations);
                 return {
                     ok: true,
                     data: {
@@ -526,6 +756,8 @@ export function createReportSummarizeHandler(workspaceManager, database, cacheMa
                         evidence: enrichedTriageData.evidence,
                         evidence_lineage: enrichedTriageData.evidence_lineage || buildEvidenceLineage(dynamicEvidence),
                         confidence_semantics: buildAssessmentConfidencePayload(enrichedTriageData.confidence, input.evidence_scope, enrichedTriageData.evidence_lineage || buildEvidenceLineage(dynamicEvidence)),
+                        binary_profile: enrichedTriageData.binary_profile,
+                        rust_profile: enrichedTriageData.rust_profile,
                         provenance,
                         selection_diffs: Object.keys(selectionDiffs).length > 0 ? selectionDiffs : undefined,
                         function_explanations: enrichedTriageData.function_explanations,
@@ -535,18 +767,19 @@ export function createReportSummarizeHandler(workspaceManager, database, cacheMa
                     },
                     warnings: dynamicEvidence
                         ? dedupe([
+                            ...warnings,
                             ...(triageResult.warnings || []),
                             `Merged imported runtime evidence from ${dynamicEvidence.artifact_count} artifact(s) using scope=${input.evidence_scope}${input.evidence_session_tag ? ` selector=${input.evidence_session_tag}` : ''}.`,
                             dynamicEvidence.scope_note || '',
                         ])
-                        : triageResult.warnings,
+                        : dedupe([...warnings, ...(triageResult.warnings || [])]),
                     errors: triageResult.errors,
                     metrics: toolMetrics(startTime),
                 };
             }
             if (input.mode === 'dotnet') {
                 if (!triageResult.ok || !triageResult.data) {
-                    return createMinimalDotnetFallback(triageResult, startTime, functionExplanations, provenance, input.evidence_scope);
+                    return createMinimalDotnetFallback(triageResult, startTime, functionExplanations, provenance, input.evidence_scope, binaryProfile, rustProfile);
                 }
                 const triageData = triageResult.data;
                 return {
@@ -563,6 +796,8 @@ export function createReportSummarizeHandler(workspaceManager, database, cacheMa
                         ],
                         evidence_lineage: triageData.evidence_lineage || buildEvidenceLineage(dynamicEvidence),
                         confidence_semantics: buildAssessmentConfidencePayload(Math.max(0.05, Math.min(0.95, triageData.confidence * 0.92)), input.evidence_scope, triageData.evidence_lineage || buildEvidenceLineage(dynamicEvidence)),
+                        binary_profile: binaryProfile,
+                        rust_profile: rustProfile,
                         provenance,
                         selection_diffs: Object.keys(selectionDiffs).length > 0 ? selectionDiffs : undefined,
                         function_explanations: functionExplanations.length > 0 ? functionExplanations : undefined,
@@ -572,6 +807,7 @@ export function createReportSummarizeHandler(workspaceManager, database, cacheMa
                             'dotnet.reconstruct.export / workflow.reconstruct for .NET-specific structure.',
                     },
                     warnings: [
+                        ...warnings,
                         'report.summarize(mode=dotnet) not fully implemented; returned triage fallback.',
                         ...(triageResult.warnings || []),
                     ],

package/dist/tools/runtime-detect.d.ts

@@ -83,10 +83,6 @@ export declare const RuntimeDetectOutputSchema: z.ZodObject<{
     }>>;
 }, "strip", z.ZodTypeAny, {
     ok: boolean;
-    metrics?: {
-        elapsed_ms: number;
-        tool: string;
-    } | undefined;
     data?: {
         is_dotnet: boolean;
         dotnet_version: string | null;
@@ -98,15 +94,15 @@ export declare const RuntimeDetectOutputSchema: z.ZodObject<{
         }[];
         import_dlls: string[];
     } | undefined;
+    metrics?: {
+        elapsed_ms: number;
+        tool: string;
+    } | undefined;
     warnings?: string[] | undefined;
     errors?: string[] | undefined;
     artifacts?: any[] | undefined;
 }, {
     ok: boolean;
-    metrics?: {
-        elapsed_ms: number;
-        tool: string;
-    } | undefined;
     data?: {
         is_dotnet: boolean;
         dotnet_version: string | null;
@@ -118,6 +114,10 @@ export declare const RuntimeDetectOutputSchema: z.ZodObject<{
         }[];
         import_dlls: string[];
     } | undefined;
+    metrics?: {
+        elapsed_ms: number;
+        tool: string;
+    } | undefined;
     warnings?: string[] | undefined;
     errors?: string[] | undefined;
     artifacts?: any[] | undefined;

package/dist/tools/runtime-detect.js

@@ -5,11 +5,11 @@
  */
 import { z } from 'zod';
 import { spawn } from 'child_process';
-import path from 'path';
 import { v4 as uuidv4 } from 'uuid';
 import { generateCacheKey } from '../cache-manager.js';
 import { resolvePackagePath } from '../runtime-paths.js';
 import { lookupCachedResult, formatCacheWarning } from './cache-observability.js';
+import { resolvePrimarySamplePath } from '../sample-workspace.js';
 // ============================================================================
 // Constants
 // ============================================================================
@@ -174,17 +174,7 @@ export function createRuntimeDetectHandler(workspaceManager, database, cacheMana
                 }
             }
             // 3. Get sample path from workspace
-            const workspace = await workspaceManager.getWorkspace(input.sample_id);
-            // Find the sample file in the original directory
-            const fs = await import('fs/promises');
-            const files = await fs.readdir(workspace.original);
-            if (files.length === 0) {
-                return {
-                    ok: false,
-                    errors: ['Sample file not found in workspace'],
-                };
-            }
-            const samplePath = path.join(workspace.original, files[0]);
+            const { samplePath } = await resolvePrimarySamplePath(workspaceManager, input.sample_id);
             // 4. Prepare worker request
             const workerRequest = {
                 job_id: uuidv4(),