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

package/dist/workflows/function-explanation-review.js

@@ -5,6 +5,10 @@
 import { z } from 'zod';
 import { createCodeFunctionExplainReviewHandler } from '../tools/code-function-explain-review.js';
 import { createReconstructWorkflowHandler } from './reconstruct.js';
+import { AnalysisProvenanceSchema } from '../analysis-provenance.js';
+import { AnalysisSelectionDiffSchema } from '../selection-diff.js';
+import { BinaryRoleProfileDataSchema } from '../tools/binary-role-profile.js';
+import { RequiredUserInputSchema, SetupActionSchema, collectSetupGuidanceFromWorkerResult, mergeRequiredUserInputs, mergeSetupActions, } from '../setup-guidance.js';
 const TOOL_NAME = 'workflow.function_explanation_review';
 export const functionExplanationReviewWorkflowInputSchema = z
     .object({
@@ -55,6 +59,22 @@ export const functionExplanationReviewWorkflowInputSchema = z
         .string()
         .optional()
         .describe('Optional semantic review session selector used when semantic_scope=session or to narrow all/latest results'),
+    compare_evidence_scope: z
+        .enum(['all', 'latest', 'session'])
+        .optional()
+        .describe('Optional baseline runtime evidence scope used when refreshing export for comparison-aware workflow output'),
+    compare_evidence_session_tag: z
+        .string()
+        .optional()
+        .describe('Optional baseline runtime evidence session selector used when compare_evidence_scope=session'),
+    compare_semantic_scope: z
+        .enum(['all', 'latest', 'session'])
+        .optional()
+        .describe('Optional baseline semantic artifact scope used when refreshing export for comparison-aware workflow output'),
+    compare_semantic_session_tag: z
+        .string()
+        .optional()
+        .describe('Optional baseline semantic artifact session selector used when compare_semantic_scope=session'),
     persist_artifact: z
         .boolean()
         .default(true)
@@ -131,6 +151,14 @@ export const functionExplanationReviewWorkflowInputSchema = z
         .max(64)
         .optional()
         .describe('Optional export folder name used for the refresh run'),
+    include_preflight: z
+        .boolean()
+        .default(true)
+        .describe('Run binary role and language-specific preflight profiling before refresh export'),
+    auto_recover_function_index: z
+        .boolean()
+        .default(true)
+        .describe('When native function-index coverage is missing, automatically recover it before refresh export'),
     include_plan: z
         .boolean()
         .default(false)
@@ -187,58 +215,86 @@ export const functionExplanationReviewWorkflowInputSchema = z
     .refine((value) => value.semantic_scope !== 'session' || Boolean(value.semantic_session_tag?.trim()), {
     message: 'semantic_session_tag is required when semantic_scope=session',
     path: ['semantic_session_tag'],
+})
+    .refine((value) => value.compare_evidence_scope !== 'session' || Boolean(value.compare_evidence_session_tag?.trim()), {
+    message: 'compare_evidence_session_tag is required when compare_evidence_scope=session',
+    path: ['compare_evidence_session_tag'],
+})
+    .refine((value) => value.compare_semantic_scope !== 'session' || Boolean(value.compare_semantic_session_tag?.trim()), {
+    message: 'compare_semantic_session_tag is required when compare_semantic_scope=session',
+    path: ['compare_semantic_session_tag'],
 });
 export const functionExplanationReviewWorkflowOutputSchema = z.object({
     ok: z.boolean(),
     data: z
-        .object({
-        sample_id: z.string(),
-        review: z.object({
-            review_status: z.string(),
-            prompt_name: z.string(),
-            client: z.object({
-                name: z.string().nullable(),
-                version: z.string().nullable(),
-                sampling_available: z.boolean(),
-            }),
-            prepare: z.object({
-                prepared_count: z.number().int().nonnegative(),
-                artifact_id: z.string().nullable(),
-            }),
-            sampling: z.object({
-                attempted: z.boolean(),
-                model: z.string().nullable(),
-                stop_reason: z.string().nullable(),
-                parsed_explanation_count: z.number().int().nonnegative(),
+        .union([
+        z.object({
+            job_id: z.string(),
+            status: z.literal('queued'),
+            tool: z.literal(TOOL_NAME),
+            sample_id: z.string(),
+            progress: z.number().int().min(0).max(100),
+        }),
+        z.object({
+            sample_id: z.string(),
+            review: z.object({
+                review_status: z.string(),
+                prompt_name: z.string(),
+                client: z.object({
+                    name: z.string().nullable(),
+                    version: z.string().nullable(),
+                    sampling_available: z.boolean(),
+                }),
+                prepare: z.object({
+                    prepared_count: z.number().int().nonnegative(),
+                    artifact_id: z.string().nullable(),
+                }),
+                sampling: z.object({
+                    attempted: z.boolean(),
+                    model: z.string().nullable(),
+                    stop_reason: z.string().nullable(),
+                    parsed_explanation_count: z.number().int().nonnegative(),
+                }),
+                apply: z.object({
+                    attempted: z.boolean(),
+                    accepted_count: z.number().int().nonnegative(),
+                    rejected_count: z.number().int().nonnegative(),
+                    artifact_id: z.string().nullable(),
+                }),
+                confidence_policy: z.object({
+                    calibrated: z.boolean(),
+                    explanation_scores_are_heuristic: z.boolean(),
+                    meaning: z.string(),
+                }),
             }),
-            apply: z.object({
+            export: z.object({
                 attempted: z.boolean(),
-                accepted_count: z.number().int().nonnegative(),
-                rejected_count: z.number().int().nonnegative(),
-                artifact_id: z.string().nullable(),
-            }),
-            confidence_policy: z.object({
-                calibrated: z.boolean(),
-                explanation_scores_are_heuristic: z.boolean(),
-                meaning: z.string(),
+                status: z.enum(['completed', 'failed', 'skipped']),
+                selected_path: z.enum(['native', 'dotnet']).nullable(),
+                export_tool: z.string().nullable(),
+                export_root: z.string().nullable(),
+                manifest_path: z.string().nullable(),
+                build_validation_status: z.string().nullable(),
+                harness_validation_status: z.string().nullable(),
+                preflight: z
+                    .object({
+                    binary_profile: BinaryRoleProfileDataSchema.nullable(),
+                    rust_profile: z.any().nullable(),
+                    function_index_recovery: z.any().nullable(),
+                })
+                    .nullable(),
+                provenance: AnalysisProvenanceSchema.nullable(),
+                selection_diffs: AnalysisSelectionDiffSchema.nullable(),
+                notes: z.array(z.string()),
             }),
+            next_steps: z.array(z.string()),
         }),
-        export: z.object({
-            attempted: z.boolean(),
-            status: z.enum(['completed', 'failed', 'skipped']),
-            selected_path: z.enum(['native', 'dotnet']).nullable(),
-            export_tool: z.string().nullable(),
-            export_root: z.string().nullable(),
-            manifest_path: z.string().nullable(),
-            build_validation_status: z.string().nullable(),
-            harness_validation_status: z.string().nullable(),
-            notes: z.array(z.string()),
-        }),
-        next_steps: z.array(z.string()),
-    })
+    ])
         .optional(),
     warnings: z.array(z.string()).optional(),
     errors: z.array(z.string()).optional(),
+    setup_actions: z.array(SetupActionSchema).optional(),
+    required_user_inputs: z.array(RequiredUserInputSchema).optional(),
     artifacts: z.array(z.any()).optional(),
     metrics: z
         .object({
@@ -253,7 +309,7 @@ export const functionExplanationReviewWorkflowToolDefinition = {
     inputSchema: functionExplanationReviewWorkflowInputSchema,
     outputSchema: functionExplanationReviewWorkflowOutputSchema,
 };
-export function createFunctionExplanationReviewWorkflowHandler(workspaceManager, database, cacheManager, mcpServer, dependencies) {
+export function createFunctionExplanationReviewWorkflowHandler(workspaceManager, database, cacheManager, mcpServer, dependencies, jobQueue) {
     const explainReviewHandler = dependencies?.explainReviewHandler ||
         createCodeFunctionExplainReviewHandler(workspaceManager, database, cacheManager, mcpServer);
     const reconstructWorkflowHandler = dependencies?.reconstructWorkflowHandler ||
@@ -263,8 +319,51 @@ export function createFunctionExplanationReviewWorkflowHandler(workspaceManager,
         const warnings = [];
         const errors = [];
         const artifacts = [];
+        let setupActions = [];
+        let requiredUserInputs = [];
         try {
             const input = functionExplanationReviewWorkflowInputSchema.parse(args);
+            const sample = database.findSample(input.sample_id);
+            if (!sample) {
+                return {
+                    ok: false,
+                    errors: [`Sample not found: ${input.sample_id}`],
+                    metrics: {
+                        elapsed_ms: Date.now() - startTime,
+                        tool: TOOL_NAME,
+                    },
+                };
+            }
+            if (jobQueue) {
+                const jobTimeoutMs = Math.max(input.build_timeout_ms + input.run_timeout_ms + 45 * 60 * 1000, 60 * 60 * 1000);
+                const jobId = jobQueue.enqueue({
+                    type: 'static',
+                    tool: TOOL_NAME,
+                    sampleId: input.sample_id,
+                    args: input,
+                    priority: 5,
+                    timeout: jobTimeoutMs,
+                    retryPolicy: {
+                        maxRetries: 1,
+                        backoffMs: 5000,
+                        retryableErrors: ['E_TIMEOUT', 'E_RESOURCE_EXHAUSTED'],
+                    },
+                });
+                return {
+                    ok: true,
+                    data: {
+                        job_id: jobId,
+                        status: 'queued',
+                        tool: TOOL_NAME,
+                        sample_id: input.sample_id,
+                        progress: 0,
+                    },
+                    metrics: {
+                        elapsed_ms: Date.now() - startTime,
+                        tool: TOOL_NAME,
+                    },
+                };
+            }
             const reviewResult = await explainReviewHandler({
                 sample_id: input.sample_id,
                 address: input.address,
@@ -289,11 +388,18 @@ export function createFunctionExplanationReviewWorkflowHandler(workspaceManager,
             });
             warnings.push(...(reviewResult.warnings || []));
             artifacts.push(...(reviewResult.artifacts || []));
+            {
+                const setupGuidance = collectSetupGuidanceFromWorkerResult(reviewResult);
+                setupActions = mergeSetupActions(setupActions, setupGuidance.setupActions);
+                requiredUserInputs = mergeRequiredUserInputs(requiredUserInputs, setupGuidance.requiredUserInputs);
+            }
             if (!reviewResult.ok) {
                 return {
                     ok: false,
                     errors: reviewResult.errors || ['code.function.explain.review failed'],
                     warnings: warnings.length > 0 ? warnings : undefined,
+                    setup_actions: setupActions.length > 0 ? setupActions : undefined,
+                    required_user_inputs: requiredUserInputs.length > 0 ? requiredUserInputs : undefined,
                     artifacts: artifacts.length > 0 ? artifacts : undefined,
                     metrics: {
                         elapsed_ms: Date.now() - startTime,
@@ -315,6 +421,9 @@ export function createFunctionExplanationReviewWorkflowHandler(workspaceManager,
                 manifest_path: null,
                 build_validation_status: null,
                 harness_validation_status: null,
+                preflight: null,
+                provenance: null,
+                selection_diffs: null,
                 notes: [],
             };
             if (canRefreshExport) {
@@ -330,8 +439,14 @@ export function createFunctionExplanationReviewWorkflowHandler(workspaceManager,
                     run_timeout_ms: input.run_timeout_ms,
                     evidence_scope: input.evidence_scope,
                     evidence_session_tag: input.evidence_session_tag,
+                    compare_evidence_scope: input.compare_evidence_scope,
+                    compare_evidence_session_tag: input.compare_evidence_session_tag,
                     semantic_scope: input.semantic_scope === 'all' && input.session_tag ? 'session' : input.semantic_scope,
                     semantic_session_tag: input.semantic_session_tag || input.session_tag,
+                    compare_semantic_scope: input.compare_semantic_scope,
+                    compare_semantic_session_tag: input.compare_semantic_session_tag,
+                    include_preflight: input.include_preflight,
+                    auto_recover_function_index: input.auto_recover_function_index,
                     include_plan: input.include_plan,
                     include_obfuscation_fallback: input.include_obfuscation_fallback,
                     fallback_on_error: input.fallback_on_error,
@@ -340,6 +455,11 @@ export function createFunctionExplanationReviewWorkflowHandler(workspaceManager,
                 });
                 warnings.push(...(exportResult.warnings || []));
                 artifacts.push(...(exportResult.artifacts || []));
+                {
+                    const setupGuidance = collectSetupGuidanceFromWorkerResult(exportResult);
+                    setupActions = mergeSetupActions(setupActions, setupGuidance.setupActions);
+                    requiredUserInputs = mergeRequiredUserInputs(requiredUserInputs, setupGuidance.requiredUserInputs);
+                }
                 if (!exportResult.ok) {
                     errors.push(...(exportResult.errors || ['workflow.reconstruct failed during export refresh']));
                     exportSummary = {
@@ -351,6 +471,9 @@ export function createFunctionExplanationReviewWorkflowHandler(workspaceManager,
                         manifest_path: null,
                         build_validation_status: null,
                         harness_validation_status: null,
+                        preflight: null,
+                        provenance: null,
+                        selection_diffs: null,
                         notes: ['Refresh export failed after function explanation apply.'],
                     };
                 }
@@ -365,6 +488,9 @@ export function createFunctionExplanationReviewWorkflowHandler(workspaceManager,
                         manifest_path: exportData.export?.manifest_path || null,
                         build_validation_status: exportData.export?.build_validation_status || null,
                         harness_validation_status: exportData.export?.harness_validation_status || null,
+                        preflight: exportData.preflight || null,
+                        provenance: exportData.provenance || null,
+                        selection_diffs: exportData.selection_diffs || null,
                         notes: Array.isArray(exportData.notes) ? exportData.notes : [],
                     };
                 }
@@ -418,6 +544,8 @@ export function createFunctionExplanationReviewWorkflowHandler(workspaceManager,
                 },
                 warnings: warnings.length > 0 ? warnings : undefined,
                 errors: errors.length > 0 ? errors : undefined,
+                setup_actions: setupActions.length > 0 ? setupActions : undefined,
+                required_user_inputs: requiredUserInputs.length > 0 ? requiredUserInputs : undefined,
                 artifacts: artifacts.length > 0 ? artifacts : undefined,
                 metrics: {
                     elapsed_ms: Date.now() - startTime,
@@ -429,6 +557,8 @@ export function createFunctionExplanationReviewWorkflowHandler(workspaceManager,
             return {
                 ok: false,
                 errors: [error instanceof Error ? error.message : String(error)],
+                setup_actions: setupActions.length > 0 ? setupActions : undefined,
+                required_user_inputs: requiredUserInputs.length > 0 ? requiredUserInputs : undefined,
                 metrics: {
                     elapsed_ms: Date.now() - startTime,
                     tool: TOOL_NAME,

package/dist/workflows/function-index-recover.d.ts

@@ -0,0 +1,333 @@
+import { z } from 'zod';
+import type { ToolArgs, ToolDefinition, WorkerResult } from '../types.js';
+import type { WorkspaceManager } from '../workspace-manager.js';
+import type { DatabaseManager } from '../database.js';
+import type { CacheManager } from '../cache-manager.js';
+export declare const FunctionIndexRecoverWorkflowInputSchema: z.ZodObject<{
+    sample_id: z.ZodString;
+    define_from: z.ZodDefault<z.ZodEnum<["auto", "smart_recover", "symbols_recover"]>>;
+    max_string_hints: z.ZodDefault<z.ZodNumber>;
+    replace_all: z.ZodDefault<z.ZodBoolean>;
+    persist_artifact: z.ZodDefault<z.ZodBoolean>;
+    register_analysis: z.ZodDefault<z.ZodBoolean>;
+    session_tag: z.ZodOptional<z.ZodString>;
+    include_rank_preview: z.ZodDefault<z.ZodBoolean>;
+    rank_topk: z.ZodDefault<z.ZodNumber>;
+    force_refresh: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    sample_id: string;
+    force_refresh: boolean;
+    max_string_hints: number;
+    replace_all: boolean;
+    persist_artifact: boolean;
+    register_analysis: boolean;
+    define_from: "auto" | "smart_recover" | "symbols_recover";
+    include_rank_preview: boolean;
+    rank_topk: number;
+    session_tag?: string | undefined;
+}, {
+    sample_id: string;
+    session_tag?: string | undefined;
+    force_refresh?: boolean | undefined;
+    max_string_hints?: number | undefined;
+    replace_all?: boolean | undefined;
+    persist_artifact?: boolean | undefined;
+    register_analysis?: boolean | undefined;
+    define_from?: "auto" | "smart_recover" | "symbols_recover" | undefined;
+    include_rank_preview?: boolean | undefined;
+    rank_topk?: number | undefined;
+}>;
+export declare const FunctionIndexRecoverWorkflowOutputSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    data: z.ZodOptional<z.ZodObject<{
+        sample_id: z.ZodString;
+        define_from: z.ZodEnum<["smart_recover", "symbols_recover"]>;
+        recovered_function_count: z.ZodNumber;
+        recovered_symbol_count: z.ZodNumber;
+        imported_count: z.ZodNumber;
+        function_index_status: z.ZodEnum<["ready"]>;
+        decompile_status: z.ZodEnum<["missing"]>;
+        cfg_status: z.ZodEnum<["missing"]>;
+        recovery_strategy: z.ZodArray<z.ZodString, "many">;
+        imported_artifact: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodString;
+            path: z.ZodString;
+            sha256: z.ZodString;
+            mime: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            type: string;
+            id: string;
+            sha256: string;
+            mime?: string | undefined;
+        }, {
+            path: string;
+            type: string;
+            id: string;
+            sha256: string;
+            mime?: string | undefined;
+        }>>;
+        analysis_id: z.ZodOptional<z.ZodString>;
+        imported_function_preview: z.ZodArray<z.ZodObject<{
+            address: z.ZodString;
+            rva: z.ZodNullable<z.ZodNumber>;
+            size: z.ZodNullable<z.ZodNumber>;
+            name: z.ZodString;
+            is_entry_point: z.ZodBoolean;
+            is_exported: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            address: string;
+            name: string;
+            size: number | null;
+            is_entry_point: boolean;
+            is_exported: boolean;
+            rva: number | null;
+        }, {
+            address: string;
+            name: string;
+            size: number | null;
+            is_entry_point: boolean;
+            is_exported: boolean;
+            rva: number | null;
+        }>, "many">;
+        recovered_symbol_preview: z.ZodArray<z.ZodObject<{
+            address: z.ZodString;
+            recovered_name: z.ZodString;
+            name_strategy: z.ZodString;
+            confidence: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            address: string;
+            confidence: number;
+            recovered_name: string;
+            name_strategy: string;
+        }, {
+            address: string;
+            confidence: number;
+            recovered_name: string;
+            name_strategy: string;
+        }>, "many">;
+        rank_preview: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            address: z.ZodString;
+            name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            score: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            summary: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            address: string;
+            name?: string | null | undefined;
+            score?: number | null | undefined;
+            tags?: string[] | undefined;
+            summary?: string | null | undefined;
+        }, {
+            address: string;
+            name?: string | null | undefined;
+            score?: number | null | undefined;
+            tags?: string[] | undefined;
+            summary?: string | null | undefined;
+        }>, "many">>;
+        next_steps: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        sample_id: string;
+        recovered_function_count: number;
+        recovered_symbol_count: number;
+        recovered_symbol_preview: {
+            address: string;
+            confidence: number;
+            recovered_name: string;
+            name_strategy: string;
+        }[];
+        next_steps: string[];
+        imported_count: number;
+        function_index_status: "ready";
+        decompile_status: "missing";
+        cfg_status: "missing";
+        define_from: "smart_recover" | "symbols_recover";
+        recovery_strategy: string[];
+        imported_function_preview: {
+            address: string;
+            name: string;
+            size: number | null;
+            is_entry_point: boolean;
+            is_exported: boolean;
+            rva: number | null;
+        }[];
+        analysis_id?: string | undefined;
+        imported_artifact?: {
+            path: string;
+            type: string;
+            id: string;
+            sha256: string;
+            mime?: string | undefined;
+        } | undefined;
+        rank_preview?: {
+            address: string;
+            name?: string | null | undefined;
+            score?: number | null | undefined;
+            tags?: string[] | undefined;
+            summary?: string | null | undefined;
+        }[] | undefined;
+    }, {
+        sample_id: string;
+        recovered_function_count: number;
+        recovered_symbol_count: number;
+        recovered_symbol_preview: {
+            address: string;
+            confidence: number;
+            recovered_name: string;
+            name_strategy: string;
+        }[];
+        next_steps: string[];
+        imported_count: number;
+        function_index_status: "ready";
+        decompile_status: "missing";
+        cfg_status: "missing";
+        define_from: "smart_recover" | "symbols_recover";
+        recovery_strategy: string[];
+        imported_function_preview: {
+            address: string;
+            name: string;
+            size: number | null;
+            is_entry_point: boolean;
+            is_exported: boolean;
+            rva: number | null;
+        }[];
+        analysis_id?: string | undefined;
+        imported_artifact?: {
+            path: string;
+            type: string;
+            id: string;
+            sha256: string;
+            mime?: string | undefined;
+        } | undefined;
+        rank_preview?: {
+            address: string;
+            name?: string | null | undefined;
+            score?: number | null | undefined;
+            tags?: string[] | undefined;
+            summary?: string | null | undefined;
+        }[] | undefined;
+    }>>;
+    warnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    errors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    artifacts: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    metrics: z.ZodOptional<z.ZodObject<{
+        elapsed_ms: z.ZodNumber;
+        tool: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        elapsed_ms: number;
+        tool: string;
+    }, {
+        elapsed_ms: number;
+        tool: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    ok: boolean;
+    data?: {
+        sample_id: string;
+        recovered_function_count: number;
+        recovered_symbol_count: number;
+        recovered_symbol_preview: {
+            address: string;
+            confidence: number;
+            recovered_name: string;
+            name_strategy: string;
+        }[];
+        next_steps: string[];
+        imported_count: number;
+        function_index_status: "ready";
+        decompile_status: "missing";
+        cfg_status: "missing";
+        define_from: "smart_recover" | "symbols_recover";
+        recovery_strategy: string[];
+        imported_function_preview: {
+            address: string;
+            name: string;
+            size: number | null;
+            is_entry_point: boolean;
+            is_exported: boolean;
+            rva: number | null;
+        }[];
+        analysis_id?: string | undefined;
+        imported_artifact?: {
+            path: string;
+            type: string;
+            id: string;
+            sha256: string;
+            mime?: string | undefined;
+        } | undefined;
+        rank_preview?: {
+            address: string;
+            name?: string | null | undefined;
+            score?: number | null | undefined;
+            tags?: string[] | undefined;
+            summary?: string | null | undefined;
+        }[] | undefined;
+    } | undefined;
+    metrics?: {
+        elapsed_ms: number;
+        tool: string;
+    } | undefined;
+    warnings?: string[] | undefined;
+    errors?: string[] | undefined;
+    artifacts?: any[] | undefined;
+}, {
+    ok: boolean;
+    data?: {
+        sample_id: string;
+        recovered_function_count: number;
+        recovered_symbol_count: number;
+        recovered_symbol_preview: {
+            address: string;
+            confidence: number;
+            recovered_name: string;
+            name_strategy: string;
+        }[];
+        next_steps: string[];
+        imported_count: number;
+        function_index_status: "ready";
+        decompile_status: "missing";
+        cfg_status: "missing";
+        define_from: "smart_recover" | "symbols_recover";
+        recovery_strategy: string[];
+        imported_function_preview: {
+            address: string;
+            name: string;
+            size: number | null;
+            is_entry_point: boolean;
+            is_exported: boolean;
+            rva: number | null;
+        }[];
+        analysis_id?: string | undefined;
+        imported_artifact?: {
+            path: string;
+            type: string;
+            id: string;
+            sha256: string;
+            mime?: string | undefined;
+        } | undefined;
+        rank_preview?: {
+            address: string;
+            name?: string | null | undefined;
+            score?: number | null | undefined;
+            tags?: string[] | undefined;
+            summary?: string | null | undefined;
+        }[] | undefined;
+    } | undefined;
+    metrics?: {
+        elapsed_ms: number;
+        tool: string;
+    } | undefined;
+    warnings?: string[] | undefined;
+    errors?: string[] | undefined;
+    artifacts?: any[] | undefined;
+}>;
+export declare const functionIndexRecoverWorkflowToolDefinition: ToolDefinition;
+interface FunctionIndexRecoverWorkflowDependencies {
+    smartRecoverHandler?: (args: ToolArgs) => Promise<WorkerResult>;
+    symbolsRecoverHandler?: (args: ToolArgs) => Promise<WorkerResult>;
+    defineHandler?: (args: ToolArgs) => Promise<WorkerResult>;
+}
+export declare function createFunctionIndexRecoverWorkflowHandler(workspaceManager: WorkspaceManager, database: DatabaseManager, cacheManager: CacheManager, dependencies?: FunctionIndexRecoverWorkflowDependencies): (args: ToolArgs) => Promise<WorkerResult>;
+export {};
+//# sourceMappingURL=function-index-recover.d.ts.map