auditor-lambda 0.1.0 → 0.2.2

package/dist/extractors/flows.js

@@ -1,27 +1,18 @@
 import { isAuditExcludedStatus } from "./disposition.js";
+import { isSecuritySensitivePath, isDataLayerPath, isConcurrencyPath, isInterfacePath, isDeploymentConfigPath, } from "./pathPatterns.js";
 function inferConcerns(paths) {
     const concerns = new Set();
     for (const path of paths) {
         const normalized = path.toLowerCase();
-        if (normalized.includes("auth") ||
-            normalized.includes("token") ||
-            normalized.includes("session"))
+        if (isSecuritySensitivePath(normalized))
             concerns.add("security");
-        if (normalized.includes("db") ||
-            normalized.includes("model") ||
-            normalized.includes("schema") ||
-            normalized.includes("migration") ||
+        if (isDataLayerPath(normalized) ||
             normalized.includes("invoice") ||
             normalized.includes("payment"))
             concerns.add("data_integrity");
-        if (normalized.includes("worker") ||
-            normalized.includes("job") ||
-            normalized.includes("retry") ||
-            normalized.includes("queue"))
+        if (isConcurrencyPath(normalized))
             concerns.add("reliability");
-        if (normalized.includes("api") ||
-            normalized.includes("route") ||
-            normalized.includes("controller"))
+        if (isInterfacePath(normalized))
             concerns.add("correctness");
     }
     return concerns.size > 0 ? [...concerns] : ["correctness"];
@@ -33,13 +24,15 @@ function relatedPaths(entry, availablePaths) {
         const lower = path.toLowerCase();
         if (path === entry)
             continue;
-        if ((normalized.includes("auth") || normalized.includes("session")) &&
+        // Auth / session flows: link sibling auth, session, token, user paths
+        if (isSecuritySensitivePath(normalized) &&
             (lower.includes("auth") ||
                 lower.includes("session") ||
                 lower.includes("token") ||
                 lower.includes("user"))) {
             linked.add(path);
         }
+        // Billing / payment flows: link ledger and subscription paths
         if ((normalized.includes("billing") ||
             normalized.includes("invoice") ||
             normalized.includes("payment")) &&
@@ -50,9 +43,8 @@ function relatedPaths(entry, availablePaths) {
                 lower.includes("subscription"))) {
             linked.add(path);
         }
-        if ((normalized.includes("job") ||
-            normalized.includes("worker") ||
-            normalized.includes("queue")) &&
+        // Async / queue flows: link worker, job, retry, and task paths
+        if (isConcurrencyPath(normalized) &&
             (lower.includes("queue") ||
                 lower.includes("retry") ||
                 lower.includes("worker") ||
@@ -60,7 +52,8 @@ function relatedPaths(entry, availablePaths) {
                 lower.includes("task"))) {
             linked.add(path);
         }
-        if ((normalized.includes("deploy") || normalized.includes("docker")) &&
+        // Deployment / infra flows: link docker, k8s, terraform, workflow paths
+        if (isDeploymentConfigPath(normalized) &&
             (lower.includes("deploy") ||
                 lower.includes("docker") ||
                 lower.includes("workflow") ||
@@ -75,7 +68,7 @@ function dedupeFlows(flows) {
     const seen = new Set();
     const deduped = [];
     for (const flow of flows) {
-        const signature = `${flow.name}|${flow.paths.join(",")}|${flow.concerns.join(",")}`;
+        const signature = `${flow.name}|${[...flow.paths].sort().join(",")}|${[...flow.concerns].sort().join(",")}`;
         if (seen.has(signature))
             continue;
         seen.add(signature);
@@ -108,9 +101,7 @@ export function buildCriticalFlowManifest(repoManifest, surfaceManifest, disposi
     }
     for (const path of availablePaths) {
         const lower = path.toLowerCase();
-        if (lower.includes("migration") ||
-            lower.includes("schema") ||
-            lower.includes("seed")) {
+        if (isDataLayerPath(lower) || lower.includes("seed")) {
             flows.push({
                 id: `flow:data:${path.replace(/[^a-zA-Z0-9:_-]/g, "-")}`,
                 name: `data evolution flow for ${path}`,

package/dist/extractors/pathPatterns.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Centralised path-pattern predicates shared across disposition, bucketing,
+ * surfaces, and flows extractors.  Every function operates on the
+ * already-lower-cased form of the path.
+ */
+export declare function isNodeModulesOrGit(normalized: string): boolean;
+export declare function isBuildOutput(normalized: string): boolean;
+export declare function isVendorPath(normalized: string): boolean;
+export declare function isBinaryArtifact(normalized: string): boolean;
+export declare function isDocPath(normalized: string): boolean;
+export declare function isTestPath(normalized: string): boolean;
+export declare function isInterfacePath(normalized: string): boolean;
+export declare function isDataLayerPath(normalized: string): boolean;
+export declare function isSecuritySensitivePath(normalized: string): boolean;
+export declare function isConcurrencyPath(normalized: string): boolean;
+export declare function isScriptPath(normalized: string): boolean;
+export declare function isDeploymentConfigPath(normalized: string): boolean;
+export declare function isGeneratedPath(normalized: string): boolean;
+export declare function isSurfacePath(normalized: string): boolean;

package/dist/extractors/pathPatterns.js

@@ -0,0 +1,87 @@
+/**
+ * Centralised path-pattern predicates shared across disposition, bucketing,
+ * surfaces, and flows extractors.  Every function operates on the
+ * already-lower-cased form of the path.
+ */
+export function isNodeModulesOrGit(normalized) {
+    return (normalized.startsWith("node_modules/") ||
+        normalized === "node_modules" ||
+        normalized.startsWith(".git/") ||
+        normalized === ".git");
+}
+export function isBuildOutput(normalized) {
+    return normalized.startsWith("dist/") || normalized.startsWith("build/");
+}
+export function isVendorPath(normalized) {
+    return normalized.includes("vendor") || normalized.includes("third_party");
+}
+export function isBinaryArtifact(normalized) {
+    return (normalized.endsWith(".png") ||
+        normalized.endsWith(".jpg") ||
+        normalized.endsWith(".jpeg") ||
+        normalized.endsWith(".gif") ||
+        normalized.endsWith(".pdf") ||
+        normalized.endsWith(".zip"));
+}
+export function isDocPath(normalized) {
+    return normalized.endsWith(".md") || normalized.startsWith("docs/");
+}
+export function isTestPath(normalized) {
+    return (normalized.includes("test") ||
+        normalized.includes("spec") ||
+        normalized.includes("__tests__"));
+}
+export function isInterfacePath(normalized) {
+    return (normalized.includes("route") ||
+        normalized.includes("controller") ||
+        normalized.includes("handler") ||
+        normalized.includes("api/"));
+}
+export function isDataLayerPath(normalized) {
+    return (normalized.includes("model") ||
+        normalized.includes("schema") ||
+        normalized.includes("migration") ||
+        normalized.includes("seed") ||
+        normalized.includes("db/"));
+}
+export function isSecuritySensitivePath(normalized) {
+    return (normalized.includes("auth") ||
+        normalized.includes("secret") ||
+        normalized.includes("token") ||
+        normalized.includes("permission") ||
+        normalized.includes("session"));
+}
+export function isConcurrencyPath(normalized) {
+    return (normalized.includes("queue") ||
+        normalized.includes("worker") ||
+        normalized.includes("job") ||
+        normalized.includes("cache") ||
+        normalized.includes("retry") ||
+        normalized.includes("lock"));
+}
+export function isScriptPath(normalized) {
+    return (normalized.includes("script") ||
+        normalized.startsWith("scripts/") ||
+        normalized.startsWith("bin/"));
+}
+export function isDeploymentConfigPath(normalized) {
+    return (normalized.includes("docker") ||
+        normalized.includes("terraform") ||
+        normalized.includes("deploy") ||
+        normalized.includes("workflow") ||
+        normalized.includes("k8s") ||
+        normalized.endsWith(".yml") ||
+        normalized.endsWith(".yaml"));
+}
+export function isGeneratedPath(normalized) {
+    return normalized.includes("vendor") || normalized.includes("generated");
+}
+export function isSurfacePath(normalized) {
+    return (normalized.includes("api/") ||
+        normalized.includes("route") ||
+        normalized.includes("controller") ||
+        normalized.includes("worker") ||
+        normalized.includes("job") ||
+        normalized.includes("command") ||
+        normalized.includes("cli"));
+}

package/dist/extractors/surfaces.js

@@ -1,4 +1,5 @@
 import { isAuditExcludedStatus } from "./disposition.js";
+import { isSurfacePath } from "./pathPatterns.js";
 function methodsForPath(path) {
     const normalized = path.toLowerCase();
     if (normalized.includes("api") || normalized.includes("route")) {
@@ -15,13 +16,7 @@ export function buildSurfaceManifest(repoManifest, disposition) {
             continue;
         }
         const normalized = file.path.toLowerCase();
-        if (normalized.includes("api/") ||
-            normalized.includes("route") ||
-            normalized.includes("controller") ||
-            normalized.includes("worker") ||
-            normalized.includes("job") ||
-            normalized.includes("command") ||
-            normalized.includes("cli")) {
+        if (isSurfacePath(normalized)) {
             surfaces.push({
                 id: `surface:${file.path}`,
                 kind: normalized.includes("worker") || normalized.includes("job")

package/dist/io/artifacts.d.ts

@@ -32,7 +32,29 @@ export interface ArtifactBundle {
     audit_state?: AuditState;
     artifact_metadata?: ArtifactMetadataManifest;
 }
-export declare const ARTIFACT_FILE_TO_BUNDLE_KEY: Record<string, keyof ArtifactBundle>;
+export declare const ARTIFACT_FILE_TO_BUNDLE_KEY: {
+    readonly "repo_manifest.json": "repo_manifest";
+    readonly "file_disposition.json": "file_disposition";
+    readonly "auto_fixes_applied.json": "auto_fixes_applied";
+    readonly "unit_manifest.json": "unit_manifest";
+    readonly "graph_bundle.json": "graph_bundle";
+    readonly "surface_manifest.json": "surface_manifest";
+    readonly "critical_flows.json": "critical_flows";
+    readonly "flow_coverage.json": "flow_coverage";
+    readonly "risk_register.json": "risk_register";
+    readonly "coverage_matrix.json": "coverage_matrix";
+    readonly "runtime_validation_tasks.json": "runtime_validation_tasks";
+    readonly "runtime_validation_report.json": "runtime_validation_report";
+    readonly "external_analyzer_results.json": "external_analyzer_results";
+    readonly "audit_results.jsonl": "audit_results";
+    readonly "audit_tasks.json": "audit_tasks";
+    readonly "requeue_tasks.json": "requeue_tasks";
+    readonly "merged_findings.json": "merged_findings";
+    readonly "root_cause_clusters.json": "root_cause_clusters";
+    readonly "synthesis_report.json": "synthesis_report";
+    readonly "audit_state.json": "audit_state";
+    readonly "artifact_metadata.json": "artifact_metadata";
+};
 export declare function getArtifactValue(bundle: ArtifactBundle, artifactName: string): unknown;
 export declare function loadArtifactBundle(root: string): Promise<ArtifactBundle>;
 export declare function writeCoreArtifacts(root: string, bundle: ArtifactBundle): Promise<void>;

package/dist/io/artifacts.js

@@ -22,8 +22,10 @@ export const ARTIFACT_FILE_TO_BUNDLE_KEY = {
     "audit_state.json": "audit_state",
     "artifact_metadata.json": "artifact_metadata",
 };
+const _bundleKeyCoverage = true;
 export function getArtifactValue(bundle, artifactName) {
-    const key = ARTIFACT_FILE_TO_BUNDLE_KEY[artifactName];
+    const map = ARTIFACT_FILE_TO_BUNDLE_KEY;
+    const key = map[artifactName];
     return key ? bundle[key] : undefined;
 }
 export async function loadArtifactBundle(root) {

package/dist/io/runArtifacts.js

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { writeJsonFile } from "./json.js";
 export function buildRunId(obligationId, index) {
     const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-    const obligation = obligationId ?? "terminal";
+    const obligation = (obligationId ?? "terminal").replace(/[^a-zA-Z0-9_-]/g, "-");
     return `${timestamp}_${obligation}_${String(index).padStart(3, "0")}`;
 }
 export function getRunPaths(artifactsDir, runId) {

package/dist/orchestrator/advance.js

@@ -13,7 +13,7 @@ export async function advanceAudit(bundle, options = {}) {
         : decision.selected_obligation;
     if (!selectedExecutor) {
         const state = deriveAuditState(bundle);
-        state.last_executor = selectedExecutor ?? undefined;
+        // Do not overwrite last_executor when no executor was selected — preserve prior value
         state.last_obligation = selectedObligation ?? undefined;
         return {
             audit_state: state,

package/dist/orchestrator/flowPlanning.d.ts

@@ -1,3 +1,3 @@
 import type { AuditTask } from "../types.js";
 import type { CriticalFlowManifest } from "../types/flows.js";
-export declare function buildFlowAwareTaskAugmentations(existingTasks: AuditTask[], criticalFlows: CriticalFlowManifest, lineIndex: Record<string, number>): AuditTask[];
+export declare function buildFlowAwareTaskAugmentations(existingTasks: AuditTask[], criticalFlows: CriticalFlowManifest, _lineIndex: Record<string, number>): AuditTask[];

package/dist/orchestrator/flowPlanning.js

@@ -3,39 +3,32 @@ const DEFAULT_FLOW_LENS_PRIORITY = [
     "reliability",
     "correctness",
 ];
-function normalizeTaskSignature(task) {
-    const path = task.file_paths.join(",");
-    const range = task.line_ranges?.map((r) => `${r.path}:${r.start}-${r.end}`).join(",") ??
-        "full";
-    return `${task.lens}|${path}|${range}`;
-}
-export function buildFlowAwareTaskAugmentations(existingTasks, criticalFlows, lineIndex) {
+export function buildFlowAwareTaskAugmentations(existingTasks, criticalFlows, _lineIndex) {
     const seenTaskIds = new Set(existingTasks.map((task) => task.task_id));
-    const existingSignatures = new Set(existingTasks.map(normalizeTaskSignature));
+    // Signature: lens + sorted file list, so duplicate (flow, lens) combos across
+    // different flow groupings are still deduplicated.
+    const existingSignatures = new Set(existingTasks.map((t) => `${t.lens}|${[...t.file_paths].sort().join(",")}`));
     const extraTasks = [];
     for (const flow of criticalFlows.flows) {
         const desiredLenses = flow.concerns.filter((concern) => DEFAULT_FLOW_LENS_PRIORITY.includes(concern));
-        for (const path of flow.paths) {
-            const totalLines = lineIndex[path] ?? 0;
-            for (const lens of desiredLenses) {
-                const candidate = {
-                    task_id: `flow:${flow.id}:${lens}:${path}`,
-                    unit_id: `flow:${flow.id}`,
-                    pass_id: `flow-pass:${lens}`,
-                    lens,
-                    file_paths: [path],
-                    line_ranges: totalLines > 0 ? [{ path, start: 1, end: totalLines }] : undefined,
-                    rationale: `Flow-aware audit for ${path} because it participates in critical flow ${flow.id} under the ${lens} lens.`,
-                };
-                const signature = normalizeTaskSignature(candidate);
-                if (seenTaskIds.has(candidate.task_id) ||
-                    existingSignatures.has(signature)) {
-                    continue;
-                }
-                extraTasks.push(candidate);
-                seenTaskIds.add(candidate.task_id);
-                existingSignatures.add(signature);
+        for (const lens of desiredLenses) {
+            // One task per (flow, lens) with all flow paths together so the agent
+            // can trace data across file boundaries in a single pass.
+            const taskId = `flow:${flow.id}:${lens}`;
+            const signature = `${lens}|${[...flow.paths].sort().join(",")}`;
+            if (seenTaskIds.has(taskId) || existingSignatures.has(signature)) {
+                continue;
             }
+            extraTasks.push({
+                task_id: taskId,
+                unit_id: `flow:${flow.id}`,
+                pass_id: `flow-pass:${lens}`,
+                lens,
+                file_paths: [...flow.paths],
+                rationale: `Flow-aware audit for critical flow "${flow.id}" (${flow.paths.length} file${flow.paths.length === 1 ? "" : "s"}) under the ${lens} lens.`,
+            });
+            seenTaskIds.add(taskId);
+            existingSignatures.add(signature);
         }
     }
     return extraTasks;

package/dist/orchestrator/internalExecutors.js

@@ -87,7 +87,6 @@ export function runPlanningExecutor(bundle, lineIndex = {}) {
     const runtimeValidationTasks = buildRuntimeValidationTasks(bundle.unit_manifest, bundle.critical_flows, flowCoverage);
     const runtimeValidationReport = preserveOrPlaceholder(runtimeValidationTasks, bundle.runtime_validation_report);
     const baseTasks = buildChunkedAuditTasks(bundle.unit_manifest, lineIndex, {
-        chunk_size: 200,
         external_analyzer_results: externalAnalyzerResults,
     });
     const analyzerTasks = buildExternalSignalTasks(coverage, lineIndex, externalAnalyzerResults);
@@ -119,9 +118,9 @@ export function runResultIngestionExecutor(bundle, results) {
     if (!bundle.coverage_matrix) {
         throw new Error("Cannot ingest results without coverage_matrix");
     }
-    ingestAuditResults(bundle.coverage_matrix, results);
+    const updatedCoverageMatrix = ingestAuditResults(bundle.coverage_matrix, results);
     const flowCoverage = bundle.critical_flows
-        ? buildFlowCoverage(bundle.critical_flows, bundle.coverage_matrix)
+        ? buildFlowCoverage(bundle.critical_flows, updatedCoverageMatrix)
         : bundle.flow_coverage;
     const runtimeValidationTasks = bundle.unit_manifest
         ? buildRuntimeValidationTasks(bundle.unit_manifest, bundle.critical_flows, flowCoverage)
@@ -129,15 +128,13 @@ export function runResultIngestionExecutor(bundle, results) {
     const runtimeValidationReport = runtimeValidationTasks
         ? preserveOrPlaceholder(runtimeValidationTasks, bundle.runtime_validation_report)
         : bundle.runtime_validation_report;
-    const requeuePayload = bundle.coverage_matrix
-        ? buildRequeuePayload(bundle.coverage_matrix, bundle.critical_flows, flowCoverage, bundle.external_analyzer_results)
-        : { tasks: [], task_count: 0 };
+    const requeuePayload = buildRequeuePayload(updatedCoverageMatrix, bundle.critical_flows, flowCoverage, bundle.external_analyzer_results);
     const mergedResults = [...(bundle.audit_results ?? []), ...results];
     const synthesisReport = buildSynthesisReport(mergedResults, runtimeValidationReport, bundle.external_analyzer_results);
     return {
         updated: {
             ...bundle,
-            coverage_matrix: bundle.coverage_matrix,
+            coverage_matrix: updatedCoverageMatrix,
             flow_coverage: flowCoverage,
             runtime_validation_tasks: runtimeValidationTasks,
             runtime_validation_report: runtimeValidationReport,

package/dist/orchestrator/planning.js

@@ -1,27 +1,19 @@
 import { applyUnitCoverage, createCoverageMatrix, markExcludedPath, } from "../coverage.js";
 import { isAuditExcludedStatus } from "../extractors/disposition.js";
+const CATEGORY_LENS_TABLE = [
+    [["security", "secret"], ["security", "correctness"]],
+    [["dependency", "vuln"], ["security", "config_deployment"]],
+    [["tests", "coverage"], ["tests"]],
+    [["data"], ["data_integrity", "correctness"]],
+    [["reliability", "concurrency"], ["reliability", "correctness"]],
+    [["maintainability", "lint", "style"], ["maintainability"]],
+];
 function analyzerCategoryToLenses(category) {
     const normalized = category.toLowerCase();
-    if (normalized.includes("security") || normalized.includes("secret")) {
-        return ["security", "correctness"];
-    }
-    if (normalized.includes("dependency") || normalized.includes("vuln")) {
-        return ["security", "config_deployment"];
-    }
-    if (normalized.includes("tests") || normalized.includes("coverage")) {
-        return ["tests"];
-    }
-    if (normalized.includes("data")) {
-        return ["data_integrity", "correctness"];
-    }
-    if (normalized.includes("reliability") ||
-        normalized.includes("concurrency")) {
-        return ["reliability", "correctness"];
-    }
-    if (normalized.includes("maintainability") ||
-        normalized.includes("lint") ||
-        normalized.includes("style")) {
-        return ["maintainability"];
+    for (const [keywords, lenses] of CATEGORY_LENS_TABLE) {
+        if (keywords.some((kw) => normalized.includes(kw))) {
+            return lenses;
+        }
     }
     return ["correctness"];
 }

package/dist/orchestrator/resultIngestion.js

@@ -1,5 +1,6 @@
 import { applyReviewedRanges } from "../coverage.js";
 export function ingestAuditResults(coverageMatrix, results) {
+    const matrix = JSON.parse(JSON.stringify(coverageMatrix));
     const reviewedRanges = results.flatMap((result) => result.reviewed_ranges.map((range) => ({
         path: range.path,
         start: range.start,
@@ -8,6 +9,6 @@ export function ingestAuditResults(coverageMatrix, results) {
         lens: result.lens,
         agent_role: result.agent_role,
     })));
-    applyReviewedRanges(coverageMatrix, reviewedRanges);
-    return coverageMatrix;
+    applyReviewedRanges(matrix, reviewedRanges);
+    return matrix;
 }

package/dist/orchestrator/runtimeValidation.js

@@ -63,6 +63,11 @@ export function buildRuntimeValidationTasks(unitManifest, criticalFlows, flowCov
             });
         }
     }
+    const RUNTIME_TASK_CAP = 100;
+    if (tasks.length > RUNTIME_TASK_CAP) {
+        process.stderr.write(`[runtime-validation] generated ${tasks.length} tasks which exceeds the cap of ${RUNTIME_TASK_CAP}; truncating to avoid runaway expansion\n`);
+        tasks.splice(RUNTIME_TASK_CAP);
+    }
     return { tasks };
 }
 export function buildPlaceholderRuntimeValidationReport(tasks) {

package/dist/orchestrator/syntaxResolutionExecutor.js

@@ -20,12 +20,16 @@ function runTsc(root) {
                         category: "correctness",
                         severity: "error",
                         path: match[1].replace(/\\/g, "/"),
+                        line_start: parseInt(match[2], 10),
                         summary: match[3],
                         rule: "tsc",
                     });
                 }
             }
         }
+        else {
+            process.stderr.write(`[syntax-resolution] tsc exited with no stdout; stderr: ${(error.stderr?.toString() ?? "").slice(0, 200)}\n`);
+        }
     }
     return results;
 }
@@ -51,6 +55,7 @@ function runEslint(root) {
                             path: fileResult.filePath
                                 .replace(/\\/g, "/")
                                 .replace(root.replace(/\\/g, "/") + "/", ""),
+                            line_start: msg.line,
                             summary: msg.message,
                             rule: msg.ruleId || "eslint-error",
                         });
@@ -58,9 +63,12 @@ function runEslint(root) {
                 }
             }
             catch (e) {
-                // failed to parse
+                process.stderr.write(`[syntax-resolution] eslint output could not be parsed: ${(error.stdout?.toString() ?? "").slice(0, 200)}\n`);
             }
         }
+        else {
+            process.stderr.write(`[syntax-resolution] eslint exited with no stdout; stderr: ${(error.stderr?.toString() ?? "").slice(0, 200)}\n`);
+        }
     }
     return results;
 }
@@ -78,7 +86,7 @@ export function runSyntaxResolutionExecutor(bundle, root) {
     const seen = new Set();
     const deduped = [];
     for (const r of merged) {
-        const key = `${r.path}:${r.rule}:${r.summary}`;
+        const key = `${r.path}:${r.line_start ?? ""}:${r.rule}:${r.summary}`;
         if (!seen.has(key)) {
             seen.add(key);
             deduped.push(r);

package/dist/orchestrator/taskBuilder.d.ts

@@ -4,9 +4,14 @@ export interface UnitLineIndex {
     [path: string]: number;
 }
 export interface BuildChunkedTaskOptions {
-    chunk_size?: number;
+    /**
+     * Line count above which a single file gets its own task rather than being
+     * grouped with the rest of its unit. Default: 3000. Set to 0 to disable
+     * splitting entirely.
+     */
+    file_split_threshold?: number;
     limit_lenses?: Lens[];
     external_analyzer_results?: ExternalAnalyzerResults;
 }
 export declare function buildChunkedAuditTasks(unitManifest: UnitManifest, unitLineIndex: UnitLineIndex, options?: BuildChunkedTaskOptions): AuditTask[];
-export declare function buildExternalSignalTasks(coverageMatrix: CoverageMatrix, unitLineIndex: UnitLineIndex, externalAnalyzerResults?: ExternalAnalyzerResults): AuditTask[];
+export declare function buildExternalSignalTasks(coverageMatrix: CoverageMatrix, _unitLineIndex: UnitLineIndex, externalAnalyzerResults?: ExternalAnalyzerResults): AuditTask[];