auditor-lambda 0.3.39 → 0.3.40

package/dist/cli.js

@@ -2142,6 +2142,7 @@ async function cmdWorkerRun(argv) {
     }
 }
 const DISPATCH_RESULT_MAP_FILENAME = "dispatch-result-map.json";
+const ACTIVE_DISPATCH_FILENAME = "active-dispatch.json";
 function dispatchResultMapPath(runDir) {
     return join(runDir, DISPATCH_RESULT_MAP_FILENAME);
 }
@@ -2437,6 +2438,10 @@ async function prepareDispatchArtifacts(params) {
                     .map(([key, value]) => `input.${key}: ${value}`)
                 : [];
             const isLensVerification = task.tags?.includes("lens_verification") ?? false;
+            const coverageTemplate = task.file_paths.map((path) => ({
+                path,
+                total_lines: task.file_line_counts?.[path] ?? lineIndex[path] ?? 0,
+            }));
             return [
                 `### ${task.task_id}`,
                 `unit_id: ${task.unit_id}`,
@@ -2457,6 +2462,11 @@ async function prepareDispatchArtifacts(params) {
                     ]
                     : []),
                 "",
+                "file_coverage (copy exactly into your AuditResult for this task):",
+                "```json",
+                JSON.stringify(coverageTemplate),
+                "```",
+                "",
             ];
         });
         const submitCommand = `"${process.execPath}" "${join(packageRoot, "audit-code.mjs")}" submit-packet ` +
@@ -2501,7 +2511,7 @@ async function prepareDispatchArtifacts(params) {
             "  unit_id       copy from the task metadata",
             "  pass_id       copy from the task metadata",
             "  lens          copy from the task metadata",
-            "  file_coverage [{path, total_lines}] - one entry per assigned file; use the line counts listed above",
+            "  file_coverage [{path, total_lines}] - copy the exact template from each task section above",
             "  findings      [] or array of finding objects",
             "",
             "Lens verification tasks:",
@@ -2614,6 +2624,14 @@ async function prepareDispatchArtifacts(params) {
     if (warningsPath) {
         await writeJsonFile(warningsPath, warnings);
     }
+    const activeDispatch = {
+        run_id: runId,
+        created_at: new Date().toISOString(),
+        packet_count: plan.length,
+        task_count: orderedTasks.length,
+        status: "active",
+    };
+    await writeJsonFile(join(artifactsDir, ACTIVE_DISPATCH_FILENAME), activeDispatch);
     return {
         run_id: runId,
         dispatch_plan_path: dispatchPlanPath,
@@ -2661,12 +2679,23 @@ async function cmdSubmitPacket(argv) {
     if (!resultMap) {
         throw new Error(`No ${DISPATCH_RESULT_MAP_FILENAME} found for run ${runId}; run prepare-dispatch first.`);
     }
-    const packetEntries = resultMap.entries.filter((entry) => entry.packet_id === packetId);
+    let packetEntries = resultMap.entries.filter((entry) => entry.packet_id === packetId);
+    let resolvedPacketId = packetId;
     if (packetEntries.length === 0) {
-        throw new Error(`Unknown packet_id '${packetId}' for run ${runId}.`);
+        const trimmed = packetId.trim();
+        packetEntries = resultMap.entries.filter((entry) => entry.packet_id.trim().toLowerCase() === trimmed.toLowerCase());
+        if (packetEntries.length > 0) {
+            resolvedPacketId = packetEntries[0].packet_id;
+            process.stderr.write(`[submit-packet] Resolved packet_id '${packetId}' → '${resolvedPacketId}' (case/whitespace normalization)\n`);
+        }
+    }
+    if (packetEntries.length === 0) {
+        const knownIds = [...new Set(resultMap.entries.map((e) => e.packet_id))];
+        throw new Error(`Unknown packet_id '${packetId}' for run ${runId}.\n` +
+            `Valid packet IDs: ${knownIds.join(", ")}`);
     }
     if (entriesByTaskId(packetEntries).size !== packetEntries.length) {
-        throw new Error(`Dispatch result map has duplicate task entries for packet '${packetId}'.`);
+        throw new Error(`Dispatch result map has duplicate task entries for packet '${resolvedPacketId}'.`);
     }
     const allTasks = await readJsonFile(tasksPath);
     const taskById = new Map(allTasks.map((task) => [task.task_id, task]));
@@ -2717,7 +2746,7 @@ async function cmdSubmitPacket(argv) {
             }
             seen.add(taskId);
             if (!expectedTaskIds.has(taskId)) {
-                resultErrors.push(`Result at index ${index} uses task_id '${taskId}', which is not assigned to packet '${packetId}'.`);
+                resultErrors.push(`Result at index ${index} uses task_id '${taskId}', which is not assigned to packet '${resolvedPacketId}'.`);
             }
         }
         for (const task of tasks) {
@@ -2727,7 +2756,44 @@ async function cmdSubmitPacket(argv) {
         }
     }
     if (resultErrors.length > 0) {
-        throw new Error(`submit-packet rejected ${packetId}:\n${resultErrors.join("\n")}`);
+        throw new Error(`submit-packet rejected ${resolvedPacketId}:\n${resultErrors.join("\n")}`);
+    }
+    // Check for duplicate findings against already-submitted results in this run
+    const existingFindingKeys = new Set();
+    const otherEntries = resultMap.entries.filter((e) => e.packet_id !== resolvedPacketId);
+    for (const other of otherEntries) {
+        try {
+            const existing = JSON.parse(await readFile(other.result_path, "utf8"));
+            if (existing?.findings) {
+                for (const f of existing.findings) {
+                    const key = [
+                        (f.lens ?? "").trim().toLowerCase(),
+                        (f.category ?? "").trim().toLowerCase(),
+                        (f.title ?? "").trim().toLowerCase(),
+                        f.affected_files?.[0]?.path ?? "",
+                    ].join("|");
+                    existingFindingKeys.add(key);
+                }
+            }
+        }
+        catch { /* file doesn't exist yet or invalid — skip */ }
+    }
+    let dupCount = 0;
+    for (const result of payload) {
+        for (const f of result.findings ?? []) {
+            const key = [
+                (f.lens ?? "").trim().toLowerCase(),
+                (f.category ?? "").trim().toLowerCase(),
+                (f.title ?? "").trim().toLowerCase(),
+                f.affected_files?.[0]?.path ?? "",
+            ].join("|");
+            if (existingFindingKeys.has(key)) {
+                dupCount++;
+            }
+        }
+    }
+    if (dupCount > 0) {
+        process.stderr.write(`[submit-packet] Warning: ${dupCount} finding(s) appear to duplicate findings from other packets in this run.\n`);
     }
     const entryByTaskId = entriesByTaskId(packetEntries);
     for (const result of payload) {
@@ -2740,9 +2806,10 @@ async function cmdSubmitPacket(argv) {
     const findingCount = payload.reduce((sum, result) => sum + result.findings.length, 0);
     console.log(JSON.stringify({
         run_id: runId,
-        packet_id: packetId,
+        packet_id: resolvedPacketId,
         accepted_count: payload.length,
         finding_count: findingCount,
+        ...(dupCount > 0 ? { duplicate_warning_count: dupCount } : {}),
     }, null, 2));
 }
 async function cmdMergeAndIngest(argv) {
@@ -2781,11 +2848,24 @@ async function cmdMergeAndIngest(argv) {
     const failing = [];
     const seenTaskIds = new Set();
     let spuriousFileCount = 0;
+    const fallbackByTaskId = new Map();
     for (const filename of files) {
         const filePath = resolve(join(taskResultsDir, filename));
         if (!expectedPaths.has(filePath)) {
             spuriousFileCount++;
-            process.stderr.write(`[merge-and-ingest] Warning: ignoring unexpected file in task-results/: ${filename}\n`);
+            try {
+                const raw = await readFile(filePath, "utf8");
+                const parsed = JSON.parse(raw);
+                if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                    const tid = typeof parsed.task_id === "string"
+                        ? String(parsed.task_id) : undefined;
+                    if (tid && !fallbackByTaskId.has(tid)) {
+                        fallbackByTaskId.set(tid, parsed);
+                    }
+                }
+            }
+            catch { /* not parseable — skip */ }
+            process.stderr.write(`[merge-and-ingest] Warning: unexpected file in task-results/: ${filename}\n`);
         }
     }
     for (const task of allTasks) {
@@ -2804,15 +2884,23 @@ async function cmdMergeAndIngest(argv) {
         }
         catch (e) {
             if (isFileMissingError(e)) {
-                failing.push({
-                    task_id: task.task_id,
-                    errors: ["Missing audit result for assigned task."],
-                });
+                const fallback = fallbackByTaskId.get(task.task_id);
+                if (fallback) {
+                    process.stderr.write(`[merge-and-ingest] Recovered result for '${task.task_id}' from unexpected file (matched by task_id)\n`);
+                    obj = fallback;
+                }
+                else {
+                    failing.push({
+                        task_id: task.task_id,
+                        errors: ["Missing audit result for assigned task."],
+                    });
+                    continue;
+                }
             }
             else {
                 failing.push({ task_id: task.task_id, errors: [`Invalid JSON: ${e.message}`] });
+                continue;
             }
-            continue;
         }
         const record = obj && typeof obj === "object" && !Array.isArray(obj)
             ? obj
@@ -2843,45 +2931,87 @@ async function cmdMergeAndIngest(argv) {
         }
     }
     await writeJsonFile(auditResultsPath, passing);
+    const failedTasksPath = join(runDir, "failed-tasks.json");
     if (failing.length > 0) {
-        const failedTasksPath = join(runDir, "failed-tasks.json");
         await writeJsonFile(failedTasksPath, failing);
-        throw new Error(`${failing.length} assigned task result(s) were missing or invalid; blocked before ingestion. See ${failedTasksPath}`);
+    }
+    if (passing.length === 0 && failing.length > 0) {
+        throw new Error(`All ${failing.length} assigned task result(s) were missing or invalid; blocked before ingestion. See ${failedTasksPath}`);
     }
     const findingCount = passing.reduce((sum, result) => sum + result.findings.length, 0);
-    const result = await runAuditStep({
-        root: workerTask.repo_root,
-        artifactsDir,
-        preferredExecutor: "result_ingestion_executor",
-        auditResultsPath,
-    });
-    const updatedPendingTasks = await addFileLineCountHints(workerTask.repo_root, buildPendingAuditTasks(result.updated_bundle));
-    await writeJsonFile(tasksPath, updatedPendingTasks);
+    let result = null;
+    if (passing.length > 0) {
+        result = await runAuditStep({
+            root: workerTask.repo_root,
+            artifactsDir,
+            preferredExecutor: "result_ingestion_executor",
+            auditResultsPath,
+        });
+        const updatedPendingTasks = await addFileLineCountHints(workerTask.repo_root, buildPendingAuditTasks(result.updated_bundle));
+        await writeJsonFile(tasksPath, updatedPendingTasks);
+    }
+    const activeDispatchPath = join(artifactsDir, ACTIVE_DISPATCH_FILENAME);
+    try {
+        const dispatch = await readJsonFile(activeDispatchPath);
+        if (dispatch.run_id === runId) {
+            dispatch.status = failing.length > 0 ? "active" : "merged";
+            await writeJsonFile(activeDispatchPath, dispatch);
+        }
+    }
+    catch { /* no active dispatch file — skip */ }
+    let retryDispatchPath = null;
+    if (failing.length > 0) {
+        const failedTaskIds = new Set(failing.map((f) => f.task_id));
+        const failedPacketIds = [
+            ...new Set(resultMap.entries
+                .filter((e) => failedTaskIds.has(e.task_id))
+                .map((e) => e.packet_id)),
+        ];
+        const retryDispatch = {
+            run_id: runId,
+            retry_packet_ids: failedPacketIds,
+            failed_task_count: failing.length,
+            accepted_task_count: passing.length,
+        };
+        retryDispatchPath = join(runDir, "retry-dispatch.json");
+        await writeJsonFile(retryDispatchPath, retryDispatch);
+        process.stderr.write(`[merge-and-ingest] ${passing.length} accepted, ${failing.length} failed. ` +
+            `Retry packets: ${failedPacketIds.join(", ")}\n`);
+    }
+    const status = failing.length > 0
+        ? "partial"
+        : (result?.progress_made ? "completed" : "no_progress");
     const workerResult = buildWorkerResult({
         runId,
         obligationId: workerTask.obligation_id,
-        status: result.progress_made ? "completed" : "no_progress",
-        progressMade: result.progress_made,
-        selectedExecutor: result.selected_executor,
-        artifactsWritten: result.artifacts_written,
-        summary: result.progress_summary,
-        nextLikelyStep: result.next_likely_step,
+        status: failing.length > 0 ? "no_progress" : (result?.progress_made ? "completed" : "no_progress"),
+        progressMade: result?.progress_made ?? false,
+        selectedExecutor: result?.selected_executor ?? null,
+        artifactsWritten: result?.artifacts_written ?? [],
+        summary: result?.progress_summary ?? `${failing.length} task(s) failed`,
+        nextLikelyStep: result?.next_likely_step ?? null,
         errors: [],
     });
     await writeJsonFile(workerTask.result_path, workerResult);
     console.log(JSON.stringify({
         run_id: runId,
-        status: workerResult.status,
+        status,
         accepted_count: passing.length,
-        rejected_count: 0,
+        rejected_count: failing.length,
         spurious_file_count: spuriousFileCount,
         finding_count: findingCount,
         audit_results_path: auditResultsPath,
-        selected_executor: workerResult.selected_executor,
-        progress_made: workerResult.progress_made,
-        progress_summary: workerResult.summary,
-        next_likely_step: workerResult.next_likely_step,
+        ...(retryDispatchPath ? { retry_dispatch_path: retryDispatchPath } : {}),
+        ...(result ? {
+            selected_executor: workerResult.selected_executor,
+            progress_made: workerResult.progress_made,
+            progress_summary: workerResult.summary,
+            next_likely_step: workerResult.next_likely_step,
+        } : {}),
     }, null, 2));
+    if (failing.length > 0) {
+        process.exitCode = 2;
+    }
 }
 async function cmdValidateResult(argv) {
     const rawRunId = getFlag(argv, "--run-id");
@@ -3357,6 +3487,69 @@ async function cmdQuota(argv) {
         quota_state_path: getQuotaStatePath(),
     }, null, 2));
 }
+async function cmdDispatchStatus(argv) {
+    const artifactsDir = getArtifactsDir(argv);
+    const activeDispatchPath = join(artifactsDir, ACTIVE_DISPATCH_FILENAME);
+    let activeDispatch = null;
+    try {
+        activeDispatch = await readJsonFile(activeDispatchPath);
+    }
+    catch (e) {
+        if (!isFileMissingError(e))
+            throw e;
+    }
+    if (!activeDispatch) {
+        console.log(JSON.stringify({ status: "no_active_dispatch" }, null, 2));
+        return;
+    }
+    const runDir = join(artifactsDir, "runs", activeDispatch.run_id);
+    const resultMap = await loadDispatchResultMap(runDir);
+    if (!resultMap) {
+        console.log(JSON.stringify({
+            status: "missing_result_map",
+            run_id: activeDispatch.run_id,
+        }, null, 2));
+        return;
+    }
+    const packetIds = [...new Set(resultMap.entries.map((e) => e.packet_id))];
+    const packetStatus = [];
+    for (const pid of packetIds) {
+        if (pid === "__prior_dispatch__")
+            continue;
+        const entries = resultMap.entries.filter((e) => e.packet_id === pid);
+        let completed = 0;
+        const missing = [];
+        for (const entry of entries) {
+            try {
+                await readFile(entry.result_path, "utf8");
+                completed++;
+            }
+            catch {
+                missing.push(entry.task_id);
+            }
+        }
+        packetStatus.push({
+            packet_id: pid,
+            task_count: entries.length,
+            completed_count: completed,
+            missing_task_ids: missing,
+        });
+    }
+    const totalTasks = packetStatus.reduce((s, p) => s + p.task_count, 0);
+    const completedTasks = packetStatus.reduce((s, p) => s + p.completed_count, 0);
+    const completedPackets = packetStatus.filter((p) => p.missing_task_ids.length === 0).length;
+    console.log(JSON.stringify({
+        run_id: activeDispatch.run_id,
+        dispatch_status: activeDispatch.status,
+        created_at: activeDispatch.created_at,
+        total_packets: packetStatus.length,
+        completed_packets: completedPackets,
+        total_tasks: totalTasks,
+        completed_tasks: completedTasks,
+        missing_tasks: totalTasks - completedTasks,
+        packets: packetStatus,
+    }, null, 2));
+}
 async function main(argv) {
     const command = argv[2] ?? "sample-run";
     switch (command) {
@@ -3429,9 +3622,12 @@ async function main(argv) {
         case "status":
             await cmdStatus(argv);
             return;
+        case "dispatch-status":
+            await cmdDispatchStatus(argv);
+            return;
         default:
             console.error(`Unknown command: ${command}`);
-            console.error("Available commands: sample-run, advance-audit, next-step, run-to-completion, worker-run, import-external-analyzer, intake, plan, ingest-results, explain-task, update-runtime-validation, validate, validate-results, requeue, synthesize, cleanup, mcp, prepare-dispatch, merge-and-ingest, submit-packet, validate-result, quota, status");
+            console.error("Available commands: sample-run, advance-audit, next-step, run-to-completion, worker-run, import-external-analyzer, intake, plan, ingest-results, explain-task, update-runtime-validation, validate, validate-results, requeue, synthesize, cleanup, mcp, prepare-dispatch, merge-and-ingest, submit-packet, validate-result, quota, status, dispatch-status");
             process.exitCode = 1;
     }
 }

package/dist/validation/auditResults.d.ts

@@ -1,6 +1,7 @@
 import type { AuditTask } from "../types.js";
 import { type ValidationIssue } from "./basic.js";
 export type IssueSeverity = "error" | "warning";
+export declare function normalizeCoveragePath(path: string): string;
 export interface AuditResultIssue extends ValidationIssue {
     result_index: number;
     task_id: string;

package/dist/validation/auditResults.js

@@ -1,4 +1,7 @@
 import { describeValue, formatValidationIssues, isRecord, } from "./basic.js";
+export function normalizeCoveragePath(path) {
+    return path.replace(/\\/g, "/").replace(/^\.\//, "");
+}
 const REQUIRED_FINDING_FIELDS = [
     "id",
     "title",
@@ -423,6 +426,18 @@ export function validateAuditResults(results, tasks, options = {}) {
                     tasks.map((item) => item.task_id).join(", "),
             });
         }
+        const taskNormMap = new Map();
+        if (task) {
+            for (const fp of task.file_paths) {
+                taskNormMap.set(normalizeCoveragePath(fp), fp);
+            }
+        }
+        const normLineIndex = new Map();
+        if (options.lineIndex) {
+            for (const [k, v] of Object.entries(options.lineIndex)) {
+                normLineIndex.set(normalizeCoveragePath(k), v);
+            }
+        }
         const fileCoverage = result.file_coverage;
         const normalizedFileCoverage = [];
         const declaredAssignedCoveragePaths = new Set();
@@ -447,6 +462,10 @@ export function validateAuditResults(results, tasks, options = {}) {
                     });
                     continue;
                 }
+                const entryNorm = isNonEmptyString(entry.path)
+                    ? normalizeCoveragePath(entry.path)
+                    : "";
+                const canonicalPath = taskNormMap.get(entryNorm);
                 if (!isNonEmptyString(entry.path)) {
                     pushIssue(issues, {
                         result_index: i,
@@ -455,7 +474,7 @@ export function validateAuditResults(results, tasks, options = {}) {
                         message: "file_coverage entry has an empty path.",
                     });
                 }
-                else if (task && !task.file_paths.includes(entry.path)) {
+                else if (task && !canonicalPath) {
                     pushIssue(issues, {
                         result_index: i,
                         task_id: taskId,
@@ -463,7 +482,7 @@ export function validateAuditResults(results, tasks, options = {}) {
                         message: `file_coverage path '${entry.path}' is not listed in the task file_paths.`,
                     });
                 }
-                else if (seenCoveragePaths.has(entry.path)) {
+                else if (seenCoveragePaths.has(entryNorm)) {
                     pushIssue(issues, {
                         result_index: i,
                         task_id: taskId,
@@ -472,11 +491,10 @@ export function validateAuditResults(results, tasks, options = {}) {
                     });
                 }
                 else {
-                    seenCoveragePaths.add(entry.path);
+                    seenCoveragePaths.add(entryNorm);
                 }
-                if (isNonEmptyString(entry.path) &&
-                    (!task || task.file_paths.includes(entry.path))) {
-                    declaredAssignedCoveragePaths.add(entry.path);
+                if (entryNorm.length > 0 && (!task || canonicalPath)) {
+                    declaredAssignedCoveragePaths.add(canonicalPath ?? entryNorm);
                 }
                 if (!Number.isInteger(entry.total_lines)) {
                     pushIssue(issues, {
@@ -495,8 +513,8 @@ export function validateAuditResults(results, tasks, options = {}) {
                         message: "file_coverage total_lines must be zero or greater.",
                     });
                 }
-                const expectedLineCount = typeof entry.path === "string"
-                    ? options.lineIndex?.[entry.path]
+                const expectedLineCount = entryNorm.length > 0
+                    ? normLineIndex.get(entryNorm)
                     : undefined;
                 if (Number.isInteger(entry.total_lines) &&
                     typeof expectedLineCount === "number" &&
@@ -509,19 +527,19 @@ export function validateAuditResults(results, tasks, options = {}) {
                             `(expected ${expectedLineCount}, got ${entry.total_lines}).`,
                     });
                 }
-                if (isNonEmptyString(entry.path) &&
+                if (entryNorm.length > 0 &&
                     Number.isInteger(entry.total_lines) &&
                     Number(entry.total_lines) >= 0 &&
-                    (!task || task.file_paths.includes(entry.path))) {
+                    (!task || canonicalPath)) {
                     normalizedFileCoverage.push({
-                        path: entry.path,
+                        path: canonicalPath ?? entryNorm,
                         total_lines: Number(entry.total_lines),
                     });
                 }
             }
             if (task) {
                 for (const path of task.file_paths) {
-                    if (!seenCoveragePaths.has(path)) {
+                    if (!seenCoveragePaths.has(normalizeCoveragePath(path))) {
                         pushIssue(issues, {
                             result_index: i,
                             task_id: taskId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auditor-lambda",
-  "version": "0.3.39",
+  "version": "0.3.40",
   "private": false,
   "description": "Portable hybrid code-auditing framework for arbitrary repositories.",
   "type": "module",