auditor-lambda 0.2.8 → 0.2.10

package/dist/orchestrator/flowPlanning.js

@@ -3,33 +3,58 @@ const DEFAULT_FLOW_LENS_PRIORITY = [
     "reliability",
     "correctness",
 ];
-export function buildFlowAwareTaskAugmentations(existingTasks, criticalFlows, _lineIndex) {
-    const seenTaskIds = new Set(existingTasks.map((task) => task.task_id));
-    // 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 = [];
+function lensPathKey(lens, path) {
+    return `${lens}:${path}`;
+}
+function flowLensPriority(lens) {
+    const index = DEFAULT_FLOW_LENS_PRIORITY.indexOf(lens);
+    return index >= 0 ? index : DEFAULT_FLOW_LENS_PRIORITY.length;
+}
+export function claimFlowReviewBlocks(criticalFlows, pendingByLens, assigned) {
+    const candidates = [];
     for (const flow of criticalFlows.flows) {
-        const desiredLenses = flow.concerns.filter((concern) => DEFAULT_FLOW_LENS_PRIORITY.includes(concern));
+        const flowPaths = [...new Set(flow.paths)].sort((a, b) => a.localeCompare(b));
+        const desiredLenses = flow.concerns
+            .filter((concern) => DEFAULT_FLOW_LENS_PRIORITY.includes(concern))
+            .sort((a, b) => flowLensPriority(a) - flowLensPriority(b));
         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)) {
+            const pendingPaths = pendingByLens.get(lens);
+            if (!pendingPaths || pendingPaths.size === 0) {
+                continue;
+            }
+            const filePaths = flowPaths.filter((path) => pendingPaths.has(path));
+            if (filePaths.length === 0) {
                 continue;
             }
-            extraTasks.push({
-                task_id: taskId,
-                unit_id: `flow:${flow.id}`,
-                pass_id: `flow-pass:${lens}`,
+            candidates.push({
+                flow_id: flow.id,
                 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.`,
+                file_paths: filePaths,
             });
-            seenTaskIds.add(taskId);
-            existingSignatures.add(signature);
         }
     }
-    return extraTasks;
+    candidates.sort((a, b) => {
+        const sizeDelta = b.file_paths.length - a.file_paths.length;
+        if (sizeDelta !== 0)
+            return sizeDelta;
+        const lensDelta = flowLensPriority(a.lens) - flowLensPriority(b.lens);
+        if (lensDelta !== 0)
+            return lensDelta;
+        return a.flow_id.localeCompare(b.flow_id);
+    });
+    const blocks = [];
+    for (const candidate of candidates) {
+        const unclaimedPaths = candidate.file_paths.filter((path) => !assigned.has(lensPathKey(candidate.lens, path)));
+        if (unclaimedPaths.length === 0) {
+            continue;
+        }
+        for (const path of unclaimedPaths) {
+            assigned.add(lensPathKey(candidate.lens, path));
+        }
+        blocks.push({
+            ...candidate,
+            file_paths: unclaimedPaths,
+        });
+    }
+    return blocks;
 }

package/dist/orchestrator/flowRequeue.js

@@ -10,7 +10,17 @@ function isLens(value) {
         "tests",
         "operability",
         "config_deployment",
-    ].includes(value);
+    ].includes(String(value));
+}
+function getExternalSignalPaths(externalAnalyzerResults) {
+    const results = Array.isArray(externalAnalyzerResults?.results)
+        ? externalAnalyzerResults.results
+        : [];
+    return new Set(results
+        .map((item) => item && typeof item.path === "string" && item.path.length > 0
+        ? item.path
+        : null)
+        .filter((path) => path !== null));
 }
 function taskPriority(hasExternalSignal, lens) {
     if (hasExternalSignal &&
@@ -19,8 +29,8 @@ function taskPriority(hasExternalSignal, lens) {
     }
     return hasExternalSignal ? "medium" : "low";
 }
-function fileStillNeedsLens(coverageMatrix, path, lens) {
-    const record = coverageMatrix.files.find((file) => file.path === path);
+function fileStillNeedsLens(coverageByPath, path, lens) {
+    const record = coverageByPath.get(path);
     if (!record || record.audit_status === "excluded") {
         return false;
     }
@@ -28,21 +38,31 @@ function fileStillNeedsLens(coverageMatrix, path, lens) {
 }
 export function buildFlowRequeueTasks(criticalFlows, flowCoverage, coverageMatrix, externalAnalyzerResults) {
     const flowMap = new Map(criticalFlows.flows.map((flow) => [flow.id, flow]));
+    const coverageByPath = new Map(coverageMatrix.files.map((file) => [file.path, file]));
     const tasks = [];
     const seen = new Set();
-    const externalPaths = new Set((externalAnalyzerResults?.results ?? []).map((item) => item.path));
+    const externalPaths = getExternalSignalPaths(externalAnalyzerResults);
     for (const record of flowCoverage.flows) {
         const flow = flowMap.get(record.flow_id);
         if (!flow) {
             continue;
         }
-        const missingLenses = record.required_lenses.filter((lens) => !record.completed_lenses.includes(lens));
+        const requiredLenses = Array.isArray(record.required_lenses)
+            ? record.required_lenses.filter((lens) => typeof lens === "string")
+            : [];
+        const completedLenses = new Set(Array.isArray(record.completed_lenses)
+            ? record.completed_lenses.filter((lens) => typeof lens === "string")
+            : []);
+        const missingLenses = requiredLenses.filter((lens) => !completedLenses.has(lens));
+        const flowPaths = Array.isArray(flow.paths)
+            ? flow.paths.filter((path) => typeof path === "string")
+            : [];
         for (const lensName of missingLenses) {
             if (!isLens(lensName)) {
-                continue;
+                throw new Error(`buildFlowRequeueTasks encountered unsupported lens "${String(lensName)}" for flow ${record.flow_id}.`);
             }
-            for (const path of flow.paths) {
-                if (!fileStillNeedsLens(coverageMatrix, path, lensName)) {
+            for (const path of flowPaths) {
+                if (!fileStillNeedsLens(coverageByPath, path, lensName)) {
                     continue;
                 }
                 const signature = `${flow.id}|${lensName}|${path}`;

package/dist/orchestrator/internalExecutors.js

@@ -6,16 +6,16 @@ import { buildRiskRegister } from "../extractors/risk.js";
 import { buildSurfaceManifest } from "../extractors/surfaces.js";
 import { initializeCoverageFromPlan } from "./planning.js";
 import { buildFlowCoverage } from "./flowCoverage.js";
-import { buildFlowAwareTaskAugmentations } from "./flowPlanning.js";
 import { buildRequeuePayload } from "./requeueCommand.js";
 import { buildRuntimeValidationTasks, discoverRuntimeValidationCommand, mergeRuntimeValidationReport, } from "./runtimeValidation.js";
 import { buildAuditReportModel, renderAuditReportMarkdown, } from "../reporting/synthesis.js";
-import { buildChunkedAuditTasks, buildExternalSignalTasks, } from "./taskBuilder.js";
+import { buildChunkedAuditTasks, } from "./taskBuilder.js";
 import { buildUnitManifest } from "./unitBuilder.js";
 import { buildRepoManifestFromFs } from "../extractors/fsIntake.js";
 import { loadIgnoreFile } from "../extractors/ignore.js";
 import { ingestAuditResults, updateAuditTaskStatuses, } from "./resultIngestion.js";
 import { updateRuntimeValidationReport } from "./runtimeValidationUpdate.js";
+import { autoCompleteTrivialCoverage } from "./trivialAudit.js";
 async function runCommand(command, cwd) {
     return await new Promise((resolve) => {
         const child = spawn(command[0], command.slice(1), {
@@ -117,6 +117,7 @@ export async function runPlanningExecutor(bundle, root, lineIndex = {}) {
     }
     const externalAnalyzerResults = bundle.external_analyzer_results;
     const coverage = initializeCoverageFromPlan(bundle.repo_manifest, bundle.unit_manifest, bundle.file_disposition, externalAnalyzerResults);
+    const skippedTrivialPaths = autoCompleteTrivialCoverage(coverage, lineIndex, externalAnalyzerResults);
     const flowCoverage = buildFlowCoverage(bundle.critical_flows, coverage);
     const runtimeCommand = await discoverRuntimeValidationCommand(root);
     const runtimeValidationTasks = buildRuntimeValidationTasks({
@@ -128,12 +129,11 @@ export async function runPlanningExecutor(bundle, root, lineIndex = {}) {
     const runtimeValidationReport = runtimeValidationTasks.tasks.length > 0
         ? mergeRuntimeValidationReport(runtimeValidationTasks, bundle.runtime_validation_report)
         : undefined;
-    const baseTasks = buildChunkedAuditTasks(bundle.unit_manifest, lineIndex, {
+    const auditTasks = buildChunkedAuditTasks(coverage, lineIndex, {
         external_analyzer_results: externalAnalyzerResults,
+        critical_flows: bundle.critical_flows,
     });
-    const analyzerTasks = buildExternalSignalTasks(coverage, lineIndex, externalAnalyzerResults);
-    const flowTasks = buildFlowAwareTaskAugmentations([...baseTasks, ...analyzerTasks], bundle.critical_flows, lineIndex);
-    const auditTasks = [...baseTasks, ...analyzerTasks, ...flowTasks].map((task) => ({
+    const taggedAuditTasks = auditTasks.map((task) => ({
         ...task,
         status: task.status ?? "pending",
     }));
@@ -145,7 +145,7 @@ export async function runPlanningExecutor(bundle, root, lineIndex = {}) {
             flow_coverage: flowCoverage,
             runtime_validation_tasks: runtimeValidationTasks,
             runtime_validation_report: runtimeValidationReport,
-            audit_tasks: auditTasks,
+            audit_tasks: taggedAuditTasks,
             requeue_tasks: requeuePayload.tasks,
             audit_report: undefined,
         },
@@ -157,7 +157,10 @@ export async function runPlanningExecutor(bundle, root, lineIndex = {}) {
             "audit_tasks.json",
             "requeue_tasks.json",
         ],
-        progress_summary: `Built planning artifacts; generated ${auditTasks.length} tasks and ${requeuePayload.task_count} requeue tasks.` +
+        progress_summary: `Built planning artifacts; generated ${taggedAuditTasks.length} review blocks and ${requeuePayload.task_count} requeue tasks.` +
+            (skippedTrivialPaths.length > 0
+                ? ` Skipped ${skippedTrivialPaths.length} trivial path${skippedTrivialPaths.length === 1 ? "" : "s"} from semantic review.`
+                : "") +
             (runtimeCommand
                 ? ` Runtime validation will use: ${runtimeCommand.join(" ")}.`
                 : " No deterministic runtime validation command was discovered."),
@@ -265,6 +268,7 @@ export function runSynthesisExecutor(bundle, results) {
         criticalFlows: bundle.critical_flows,
         coverageMatrix: bundle.coverage_matrix,
         runtimeValidationReport: bundle.runtime_validation_report,
+        externalAnalyzerResults: bundle.external_analyzer_results,
     });
     return {
         updated: {

package/dist/orchestrator/localCommands.d.ts

@@ -0,0 +1,14 @@
+export interface LocalCommandCandidate {
+    command: string;
+    args: string[];
+    display?: string;
+}
+export interface LocalCommandResult {
+    candidate: LocalCommandCandidate;
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+    error?: Error;
+}
+export declare function runFirstAvailableCommand(root: string, candidates: LocalCommandCandidate[]): LocalCommandResult | null;
+export declare function resolveNodeTool(root: string, relativePath: string, args: string[], display: string): LocalCommandCandidate[];

package/dist/orchestrator/localCommands.js

@@ -0,0 +1,124 @@
+import { existsSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { delimiter, isAbsolute, join } from "node:path";
+function isWindowsBatchCommand(path) {
+    return process.platform === "win32" && /\.(cmd|bat)$/i.test(path);
+}
+function quoteForCmd(arg) {
+    if (arg.length === 0)
+        return '""';
+    if (!/[\s"]/u.test(arg))
+        return arg;
+    return `"${arg.replace(/"/g, '""')}"`;
+}
+function toSpawnTuple(candidate) {
+    if (!isWindowsBatchCommand(candidate.command)) {
+        return {
+            command: candidate.command,
+            args: candidate.args,
+        };
+    }
+    return {
+        command: process.env.ComSpec ?? "cmd.exe",
+        args: [
+            "/d",
+            "/s",
+            "/c",
+            [candidate.command, ...candidate.args].map(quoteForCmd).join(" "),
+        ],
+    };
+}
+function resolveFromPath(command) {
+    if (command.trim().length === 0) {
+        return null;
+    }
+    if (command.includes("\\") ||
+        command.includes("/") ||
+        isAbsolute(command)) {
+        return existsSync(command) ? command : null;
+    }
+    const pathValue = process.env.PATH ?? "";
+    const pathEntries = pathValue
+        .split(delimiter)
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+    const extensions = process.platform === "win32"
+        ? (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD")
+            .split(";")
+            .map((ext) => ext.toLowerCase())
+        : [""];
+    for (const dir of pathEntries) {
+        const directPath = join(dir, command);
+        if (existsSync(directPath)) {
+            return directPath;
+        }
+        for (const ext of extensions) {
+            const candidatePath = join(dir, `${command}${ext}`);
+            if (existsSync(candidatePath)) {
+                return candidatePath;
+            }
+        }
+    }
+    return null;
+}
+function resolveCandidate(root, candidate) {
+    if (candidate.command === process.execPath) {
+        return candidate;
+    }
+    const resolvedPath = resolveFromPath(candidate.command);
+    if (resolvedPath) {
+        return {
+            ...candidate,
+            command: resolvedPath,
+        };
+    }
+    const repoLocalPath = join(root, candidate.command);
+    if (existsSync(repoLocalPath)) {
+        return {
+            ...candidate,
+            command: repoLocalPath,
+        };
+    }
+    return null;
+}
+export function runFirstAvailableCommand(root, candidates) {
+    for (const candidate of candidates) {
+        const resolved = resolveCandidate(root, candidate);
+        if (!resolved) {
+            continue;
+        }
+        const spawnTarget = toSpawnTuple(resolved);
+        const result = spawnSync(spawnTarget.command, spawnTarget.args, {
+            cwd: root,
+            env: process.env,
+            encoding: "utf8",
+            windowsHide: true,
+            stdio: "pipe",
+        });
+        return {
+            candidate: {
+                ...resolved,
+                display: candidate.display ?? [candidate.command, ...candidate.args].join(" "),
+            },
+            exitCode: result.status,
+            stdout: result.stdout ?? "",
+            stderr: result.stderr ?? "",
+            error: result.error
+                ? new Error(result.error.message, { cause: result.error })
+                : undefined,
+        };
+    }
+    return null;
+}
+export function resolveNodeTool(root, relativePath, args, display) {
+    const localToolPath = join(root, relativePath);
+    const candidates = [];
+    if (existsSync(localToolPath)) {
+        candidates.push({
+            command: process.execPath,
+            args: [localToolPath, ...args],
+            display,
+        });
+    }
+    return candidates;
+}

package/dist/orchestrator/planning.js

@@ -1,5 +1,6 @@
 import { applyUnitCoverage, createCoverageMatrix, markExcludedPath, } from "../coverage.js";
 import { isAuditExcludedStatus } from "../extractors/disposition.js";
+import { deriveRequiredLensesForPath } from "./unitBuilder.js";
 const CATEGORY_LENS_TABLE = [
     [["security", "secret"], ["security", "correctness"]],
     [["dependency", "vuln"], ["security", "config_deployment"]],
@@ -21,8 +22,17 @@ function applyAnalyzerCoverage(coverage, externalAnalyzerResults) {
     if (!externalAnalyzerResults) {
         return;
     }
-    for (const result of externalAnalyzerResults.results) {
-        const record = coverage.files.find((file) => file.path === result.path);
+    const coverageByPath = new Map(coverage.files.map((file) => [file.path, file]));
+    const results = Array.isArray(externalAnalyzerResults.results)
+        ? externalAnalyzerResults.results
+        : [];
+    for (const result of results) {
+        if (!result ||
+            typeof result.path !== "string" ||
+            typeof result.category !== "string") {
+            continue;
+        }
+        const record = coverageByPath.get(result.path);
         if (!record || record.audit_status === "excluded") {
             continue;
         }
@@ -44,9 +54,21 @@ export function initializeCoverageFromPlan(repoManifest, unitManifest, dispositi
             markExcludedPath(coverage, file.path, status);
         }
     }
+    const unitIdsByPath = new Map();
     for (const unit of unitManifest.units) {
         for (const path of unit.files) {
-            applyUnitCoverage(coverage, path, unit.unit_id, unit.required_lenses);
+            const existing = unitIdsByPath.get(path) ?? [];
+            if (!existing.includes(unit.unit_id)) {
+                existing.push(unit.unit_id);
+            }
+            unitIdsByPath.set(path, existing);
+        }
+    }
+    for (const file of repoManifest.files) {
+        const unitIds = unitIdsByPath.get(file.path) ?? [];
+        const requiredLenses = deriveRequiredLensesForPath(file.path);
+        for (const unitId of unitIds) {
+            applyUnitCoverage(coverage, file.path, unitId, requiredLenses);
         }
     }
     applyAnalyzerCoverage(coverage, externalAnalyzerResults);

package/dist/orchestrator/requeue.js

@@ -7,10 +7,20 @@ function taskPriority(hasExternalSignal, lens) {
     }
     return "low";
 }
+function getExternalSignalPaths(externalAnalyzerResults) {
+    const results = Array.isArray(externalAnalyzerResults?.results)
+        ? externalAnalyzerResults.results
+        : [];
+    return new Set(results
+        .map((item) => item && typeof item.path === "string" && item.path.length > 0
+        ? item.path
+        : null)
+        .filter((path) => path !== null));
+}
 export function buildRequeueTasks(matrix, externalAnalyzerResults) {
     const targets = buildRequeueTargets(matrix);
     const tasks = [];
-    const externalPaths = new Set((externalAnalyzerResults?.results ?? []).map((item) => item.path));
+    const externalPaths = getExternalSignalPaths(externalAnalyzerResults);
     for (const target of targets) {
         for (const lens of target.missing_lenses) {
             const hasExternalSignal = externalPaths.has(target.path);

package/dist/orchestrator/syntaxResolutionExecutor.js

@@ -1,74 +1,75 @@
-import { execSync } from "node:child_process";
+import { join } from "node:path";
+import { resolveNodeTool, runFirstAvailableCommand } from "./localCommands.js";
 function runTsc(root) {
     const results = [];
-    try {
-        execSync("npx tsc --noEmit", {
-            cwd: root,
-            stdio: "pipe",
-            windowsHide: true,
-        });
+    const command = runFirstAvailableCommand(root, [
+        ...resolveNodeTool(root, join("node_modules", "typescript", "bin", "tsc"), ["--noEmit"], "tsc --noEmit"),
+        { command: "tsc", args: ["--noEmit"], display: "tsc --noEmit" },
+    ]);
+    if (!command || command.error) {
+        return results;
     }
-    catch (error) {
-        if (error.stdout) {
-            const output = error.stdout.toString();
-            const lines = output.split("\n");
-            for (const line of lines) {
-                const match = line.match(/^([^:]+)\((\d+),\d+\):\s+(error\s+TS\d+:.*)$/);
-                if (match) {
-                    results.push({
-                        id: `tsc-${results.length}`,
-                        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`);
+    const output = [command.stdout, command.stderr].filter(Boolean).join("\n");
+    const lines = output.split("\n");
+    for (const line of lines) {
+        const match = line.match(/^([^:]+)\((\d+),\d+\):\s+(error\s+TS\d+:.*)$/);
+        if (match) {
+            results.push({
+                id: `tsc-${results.length}`,
+                category: "correctness",
+                severity: "error",
+                path: match[1].replace(/\\/g, "/"),
+                line_start: parseInt(match[2], 10),
+                summary: match[3],
+                rule: "tsc",
+            });
         }
     }
+    if (command.exitCode === 0 && output.trim().length === 0) {
+        return results;
+    }
+    if (results.length === 0 && output.trim().length > 0) {
+        process.stderr.write(`[syntax-resolution] tsc output could not be parsed: ${output.slice(0, 200)}\n`);
+    }
     return results;
 }
 function runEslint(root) {
     const results = [];
-    try {
-        execSync("npx eslint . --ext .ts,.js,.tsx,.jsx --format json", {
-            cwd: root,
-            stdio: "pipe",
-            windowsHide: true,
-        });
+    const command = runFirstAvailableCommand(root, [
+        ...resolveNodeTool(root, join("node_modules", "eslint", "bin", "eslint.js"), [".", "--ext", ".ts,.js,.tsx,.jsx", "--format", "json"], "eslint . --ext .ts,.js,.tsx,.jsx --format json"),
+        {
+            command: "eslint",
+            args: [".", "--ext", ".ts,.js,.tsx,.jsx", "--format", "json"],
+            display: "eslint . --ext .ts,.js,.tsx,.jsx --format json",
+        },
+    ]);
+    if (!command || command.error) {
+        return results;
     }
-    catch (error) {
-        if (error.stdout) {
-            try {
-                const output = JSON.parse(error.stdout.toString());
-                for (const fileResult of output) {
-                    for (const msg of fileResult.messages) {
-                        results.push({
-                            id: `eslint-${results.length}`,
-                            category: "maintainability",
-                            severity: msg.severity === 2 ? "error" : "warning",
-                            path: fileResult.filePath
-                                .replace(/\\/g, "/")
-                                .replace(root.replace(/\\/g, "/") + "/", ""),
-                            line_start: msg.line,
-                            summary: msg.message,
-                            rule: msg.ruleId || "eslint-error",
-                        });
-                    }
-                }
-            }
-            catch (e) {
-                process.stderr.write(`[syntax-resolution] eslint output could not be parsed: ${(error.stdout?.toString() ?? "").slice(0, 200)}\n`);
+    const output = [command.stdout, command.stderr].filter(Boolean).join("\n").trim();
+    if (output.length === 0) {
+        return results;
+    }
+    try {
+        const parsed = JSON.parse(output);
+        for (const fileResult of parsed) {
+            for (const msg of fileResult.messages) {
+                results.push({
+                    id: `eslint-${results.length}`,
+                    category: "maintainability",
+                    severity: msg.severity === 2 ? "error" : "warning",
+                    path: fileResult.filePath
+                        .replace(/\\/g, "/")
+                        .replace(root.replace(/\\/g, "/") + "/", ""),
+                    line_start: msg.line,
+                    summary: msg.message,
+                    rule: msg.ruleId || "eslint-error",
+                });
             }
         }
-        else {
-            process.stderr.write(`[syntax-resolution] eslint exited with no stdout; stderr: ${(error.stderr?.toString() ?? "").slice(0, 200)}\n`);
-        }
+    }
+    catch {
+        process.stderr.write(`[syntax-resolution] eslint output could not be parsed: ${output.slice(0, 200)}\n`);
     }
     return results;
 }

package/dist/orchestrator/taskBuilder.d.ts

@@ -1,5 +1,6 @@
 import type { ExternalAnalyzerResults } from "../types/externalAnalyzer.js";
-import type { AuditTask, CoverageMatrix, Lens, UnitManifest } from "../types.js";
+import type { AuditTask, CoverageMatrix, Lens } from "../types.js";
+import type { CriticalFlowManifest } from "../types/flows.js";
 export interface UnitLineIndex {
     [path: string]: number;
 }
@@ -12,6 +13,7 @@ export interface BuildChunkedTaskOptions {
     file_split_threshold?: number;
     limit_lenses?: Lens[];
     external_analyzer_results?: ExternalAnalyzerResults;
+    critical_flows?: CriticalFlowManifest;
 }
-export declare function buildChunkedAuditTasks(unitManifest: UnitManifest, unitLineIndex: UnitLineIndex, options?: BuildChunkedTaskOptions): AuditTask[];
+export declare function buildChunkedAuditTasks(coverageMatrix: CoverageMatrix, unitLineIndex: UnitLineIndex, options?: BuildChunkedTaskOptions): AuditTask[];
 export declare function buildExternalSignalTasks(coverageMatrix: CoverageMatrix, _unitLineIndex: UnitLineIndex, externalAnalyzerResults?: ExternalAnalyzerResults): AuditTask[];