auditor-lambda 0.3.41 → 0.6.0

package/dist/cli/dispatch.js

@@ -3,7 +3,7 @@ import { existsSync } from "node:fs";
 import { isAbsolute, join, relative, resolve } from "node:path";
 import { isFileMissingError, readJsonFile, writeJsonFile } from "@audit-tools/shared";
 import { loadArtifactBundle } from "../io/artifacts.js";
-import { orderTasksForPacketReview, buildReviewPackets } from "../orchestrator/reviewPackets.js";
+import { orderTasksForPacketReview, buildReviewPackets, sizeIndexFromManifest, } from "../orchestrator/reviewPackets.js";
 import { buildFileAnchorSummary } from "../orchestrator/fileAnchors.js";
 import { resolveFreshSessionProviderName } from "../providers/index.js";
 import { loadSessionConfig } from "../supervisor/sessionConfig.js";
@@ -166,6 +166,7 @@ export function buildPendingAuditTasks(bundle) {
     return orderTasksForPacketReview(pendingTasks, {
         graphBundle: bundle.graph_bundle,
         lineIndex,
+        sizeIndex: sizeIndexFromManifest(bundle.repo_manifest),
     });
 }
 export async function prepareDispatchArtifacts(params) {
@@ -205,13 +206,16 @@ export async function prepareDispatchArtifacts(params) {
         ? tasks.filter((task) => !priorResultTaskIds.has(task.task_id))
         : tasks;
     const lineIndex = Object.fromEntries(dispatchTasks.flatMap((task) => Object.entries(task.file_line_counts ?? {})));
+    const sizeIndex = sizeIndexFromManifest(bundle.repo_manifest);
     const orderedTasks = orderTasksForPacketReview(dispatchTasks, {
         graphBundle: bundle.graph_bundle,
         lineIndex,
+        sizeIndex,
     });
     const packets = buildReviewPackets(orderedTasks, {
         graphBundle: bundle.graph_bundle,
         lineIndex,
+        sizeIndex,
     });
     const tasksById = new Map(orderedTasks.map((task) => [task.task_id, task]));
     const resultPathByTaskId = new Map(orderedTasks.map((task) => [

package/dist/cli/prompts.d.ts

@@ -1,4 +1,5 @@
 import type { ActiveReviewRun } from "../supervisor/operatorHandoff.js";
+import type { AnalyzerPlanEntry } from "../extractors/analyzers/types.js";
 export declare function nextStepCommand(root: string, artifactsDir: string): string;
 export declare function mergeAndIngestCommand(artifactsDir: string, runId: string): string;
 export declare function renderDispatchReviewPrompt(params: {
@@ -14,5 +15,23 @@ export declare function renderSingleTaskFallbackStepPrompt(params: {
     singleTaskPromptPath: string;
     activeReviewRun: ActiveReviewRun;
 }): string;
+export declare function renderEdgeReasoningStepPrompt(params: {
+    basePrompt: string;
+    resultsPath: string;
+    continueCommand: string;
+    contentHash: string;
+}): string;
+export declare function renderEdgeReasoningDispatchPrompt(params: {
+    promptPath: string;
+    resultsPath: string;
+    continueCommand: string;
+    contentHash: string;
+    candidateCount: number;
+}): string;
 export declare function renderPresentReportPrompt(finalReportPath: string): string;
+export declare function renderAnalyzerInstallPrompt(params: {
+    unresolved: AnalyzerPlanEntry[];
+    decisionsPath: string;
+    continueCommand: string;
+}): string;
 export declare function renderBlockedStepPrompt(reason: string): string;

package/dist/cli/prompts.js

@@ -102,6 +102,62 @@ export function renderSingleTaskFallbackStepPrompt(params) {
         "",
     ].join("\n");
 }
+export function renderEdgeReasoningStepPrompt(params) {
+    return [
+        params.basePrompt,
+        "",
+        "## Results path",
+        "",
+        'Write the JSON object ({"rewrites":[{"from":"...","to":"...","kind":"...","reason":"..."}]}) to:',
+        "",
+        `  ${params.resultsPath}`,
+        "",
+        `Cache key (edge-set content hash): ${params.contentHash}.`,
+        "If you already produced rewrites for this exact key, you may reuse them instead of regenerating.",
+        "",
+        `Then run: ${params.continueCommand}`,
+        "",
+        "Read and follow only the new step prompt returned by that command.",
+        "",
+    ].join("\n");
+}
+export function renderEdgeReasoningDispatchPrompt(params) {
+    return [
+        "# audit-code edge reasoning (subagent dispatch)",
+        "",
+        `The dependency graph has ${params.candidateCount} low-confidence edge(s) whose`,
+        "machine-generated `reason` text can be clarified. This is a single, bounded,",
+        "optional pass: it only rewrites the `reason` string of those edges — it never",
+        "adds, removes, re-targets, or re-weights an edge.",
+        "",
+        "Dispatch exactly ONE subagent (via the `task` tool or equivalent). Hand it this",
+        "prompt file path; do not load the file into this orchestrator context:",
+        "",
+        `  ${params.promptPath}`,
+        "",
+        "Subagent prompt shape:",
+        "",
+        "  Read and follow the edge-reasoning instructions in: <prompt path above>",
+        "",
+        'The subagent must write its JSON result ({"rewrites":[...]}) to:',
+        "",
+        `  ${params.resultsPath}`,
+        "",
+        `Cache key (edge-set content hash): ${params.contentHash}.`,
+        "If you hold a cached result for this exact key from a previous run, you may write",
+        "it to the results path directly instead of dispatching a subagent.",
+        "",
+        "**File access pre-approval:** if your host supports per-subagent file access",
+        `restrictions, allow the subagent to read ${params.promptPath} and write ${params.resultsPath}.`,
+        "",
+        "After the subagent writes the result, run exactly:",
+        "",
+        `  ${params.continueCommand}`,
+        "",
+        "Read and follow only the new step prompt returned by that command.",
+        "",
+    ].join("\n");
+}
 export function renderPresentReportPrompt(finalReportPath) {
     return [
         "# audit-code present report",
@@ -116,6 +172,45 @@ export function renderPresentReportPrompt(finalReportPath) {
         "",
     ].join("\n");
 }
+export function renderAnalyzerInstallPrompt(params) {
+    const analyzerLines = params.unresolved.flatMap((entry) => [
+        `- **${entry.id}** — needs \`${entry.dependency ?? entry.id}\`; ${entry.supportedCount} in-scope file(s) would be analyzed.`,
+    ]);
+    const exampleObject = `{ ${params.unresolved
+        .map((entry) => `"${entry.id}": "ephemeral"`)
+        .join(", ")} }`;
+    return [
+        "# audit-code analyzer install",
+        "",
+        "The deterministic regex graph is built. These optional language analyzers can",
+        "produce a richer graph (real module resolution, inheritance, and a call graph),",
+        "but their compiler dependency is not installed in the audited repo:",
+        "",
+        ...analyzerLines,
+        "",
+        "Choose how to resolve each one and write a JSON object of `{ \"<analyzer-id>\": <setting> }`",
+        "to the decisions path below. Valid settings:",
+        "",
+        "- `ephemeral` — install into a shared, version-keyed cache (never touches this project); compile once, reuse across audits.",
+        "- `permanent` — same as `ephemeral` but a durable opt-in recorded in session config.",
+        "- `skip` — do not run this analyzer; keep the regex floor.",
+        "",
+        "Default if you are unsure or cannot install: choose `skip`. The audit proceeds either way.",
+        "",
+        "## Decisions path",
+        "",
+        "Write your choices to:",
+        "",
+        `  ${params.decisionsPath}`,
+        "",
+        `Example: ${exampleObject}`,
+        "",
+        `Then run: ${params.continueCommand}`,
+        "",
+        "Read and follow only the new step prompt returned by that command.",
+        "",
+    ].join("\n");
+}
 export function renderBlockedStepPrompt(reason) {
     return [
         "# audit-code blocked",

package/dist/cli/steps.d.ts

@@ -1,7 +1,7 @@
 import type { StepStatus } from "@audit-tools/shared";
 import type { AccessDeclaration } from "../types/workerSession.js";
 export declare const STEP_CONTRACT_VERSION = "audit-code-step/v1alpha1";
-export type StepKind = "dispatch_review" | "single_task_fallback" | "design_review" | "present_report" | "blocked";
+export type StepKind = "dispatch_review" | "single_task_fallback" | "design_review" | "analyzer_install" | "edge_reasoning" | "edge_reasoning_dispatch" | "synthesis_narrative" | "present_report" | "blocked";
 export interface StepArtifact {
     contract_version: typeof STEP_CONTRACT_VERSION;
     step_kind: StepKind;