auditor-lambda 0.5.0 → 0.6.3

package/dist/cli/dispatch.js

@@ -187,9 +187,12 @@ export async function prepareDispatchArtifacts(params) {
     }
     const bundle = await loadArtifactBundle(artifactsDir);
     const tasksPath = join(runDir, "pending-audit-tasks.json");
-    const tasks = await readJsonFile(tasksPath).catch((error) => {
-        if (isFileMissingError(error))
-            return buildPendingAuditTasks(bundle);
+    const tasks = await readJsonFile(tasksPath).catch(async (error) => {
+        if (isFileMissingError(error)) {
+            const generated = buildPendingAuditTasks(bundle);
+            await writeJsonFile(tasksPath, generated);
+            return generated;
+        }
         throw error;
     });
     const sessionConfig = params.sessionConfig ?? (await loadSessionConfig(artifactsDir).catch(() => ({})));
@@ -353,7 +356,7 @@ export async function prepareDispatchArtifacts(params) {
                 "",
             ];
         });
-        const submitCommand = `"${process.execPath}" "${join(params.packageRoot, "audit-code.mjs")}" submit-packet ` +
+        const submitCommand = `node packages/audit-code/audit-code.mjs submit-packet ` +
             `--run-id-b64 ${toBase64Url(runId)} ` +
             `--packet-id-b64 ${toBase64Url(packet.packet_id)} ` +
             `--artifacts-dir-b64 ${toBase64Url(artifactsDir)}`;
@@ -395,7 +398,7 @@ export 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}] - copy the exact template from each task section above",
+            "  file_coverage [{path, total_lines}] - copy the exact template from each task section above. You MUST include total_lines. Do not omit or zero it out, as this will cause fatal validation errors.",
             "  findings      [] or array of finding objects",
             "",
             "Lens verification tasks:",
@@ -425,6 +428,7 @@ export async function prepareDispatchArtifacts(params) {
             "## Submit",
             "Pipe the JSON array on stdin to this command:",
             `  ${submitCommand}`,
+            "  (If using Windows PowerShell, you MUST use `Get-Content <file> | & <command>` instead of the `<` operator.)",
             "",
             "The command validates and writes the packet-owned result files. Exit 0 means accepted.",
             "Non-zero: read the errors, fix the JSON, and run the same submit command again. Retry up to 3 times.",

package/dist/cli.js

@@ -10,7 +10,7 @@ import { buildUnitManifest } from "./orchestrator/unitBuilder.js";
 import { buildFlowCoverage } from "./orchestrator/flowCoverage.js";
 import { buildRuntimeValidationTasks, } from "./orchestrator/runtimeValidation.js";
 import { initializeCoverageFromPlan } from "./orchestrator/planning.js";
-import { loadArtifactBundle, writeCoreArtifacts, promoteFinalAuditReport, } from "./io/artifacts.js";
+import { loadArtifactBundle, writeCoreArtifacts, promoteFinalAuditReport, AUDIT_REPORT_FILENAME, } from "./io/artifacts.js";
 import { isFileMissingError, readJsonFile, writeJsonFile, prefixValidationIssues, RunLogger } from "@audit-tools/shared";
 import { validateArtifactBundle } from "./validation/artifacts.js";
 import { validateAuditResults, formatAuditResultIssues, } from "./validation/auditResults.js";
@@ -630,8 +630,8 @@ async function runDeterministicForNextStep(params) {
                 state,
                 bundle,
                 finalReportPath: promoted.promoted
-                    ? join(params.root, "audit-report.md")
-                    : join(params.artifactsDir, "audit-report.md"),
+                    ? join(params.root, AUDIT_REPORT_FILENAME)
+                    : join(params.artifactsDir, AUDIT_REPORT_FILENAME),
             };
         }
         if (index === 0 && bundle.repo_manifest) {
@@ -879,6 +879,89 @@ async function runDeterministicForNextStep(params) {
         reason: `Reached max run limit (${params.maxRuns}) before a review, report, or blocker step was ready.`,
     };
 }
+// Renders the actionable semantic-review step (packet dispatch or single-task
+// fallback) and writes steps/current-step.json. Shared by next-step and
+// run-to-completion so the backend produces the actionable step itself rather
+// than handing the host a second command. Host dispatch capability is resolved
+// by the caller (flag -> session config -> env -> default true) and is never
+// required from the host to make progress.
+async function renderSemanticReviewStep(params) {
+    const { root, artifactsDir, activeReviewRun } = params;
+    if (!params.hostCanDispatch) {
+        const singleTaskPromptPath = join(artifactsDir, "dispatch", "current-single-task-prompt.md");
+        const workerCommand = renderCommand(activeReviewRun.worker_command);
+        return writeCurrentStep({
+            artifactsDir,
+            stepKind: "single_task_fallback",
+            status: "ready",
+            runId: activeReviewRun.run_id,
+            allowedCommands: [workerCommand],
+            stopCondition: "Run the exact worker_command after one result, then stop without looping.",
+            repoRoot: root,
+            artifactPaths: {
+                active_review_task: activeReviewRun.task_path,
+                active_review_prompt: activeReviewRun.prompt_path,
+                pending_audit_tasks: activeReviewRun.pending_audit_tasks_path ?? null,
+                audit_results: activeReviewRun.audit_results_path,
+                single_task_prompt: singleTaskPromptPath,
+            },
+            prompt: renderSingleTaskFallbackStepPrompt({
+                singleTaskPromptPath,
+                activeReviewRun,
+            }),
+            access: {
+                read_paths: [singleTaskPromptPath],
+                write_paths: [activeReviewRun.audit_results_path],
+            },
+        });
+    }
+    const dispatch = await prepareDispatchArtifacts({
+        packageRoot,
+        runId: activeReviewRun.run_id,
+        artifactsDir,
+        root,
+        hostActiveSubagentLimit: params.hostMaxActiveSubagents,
+    });
+    const mergeCommand = mergeAndIngestCommand(artifactsDir, activeReviewRun.run_id);
+    const continueCommand = nextStepCommand(root, artifactsDir);
+    return writeCurrentStep({
+        artifactsDir,
+        stepKind: "dispatch_review",
+        status: "ready",
+        runId: activeReviewRun.run_id,
+        allowedCommands: [
+            "auditor_merge_and_ingest",
+            "auditor_continue_audit",
+            mergeCommand,
+            continueCommand,
+        ],
+        stopCondition: "Dispatch every packet, run merge-and-ingest once, then run next-step.",
+        repoRoot: root,
+        artifactPaths: {
+            dispatch_plan: dispatch.dispatch_plan_path,
+            dispatch_quota: dispatch.dispatch_quota_path,
+            dispatch_warnings: dispatch.dispatch_warnings_path,
+            active_review_task: activeReviewRun.task_path,
+            pending_audit_tasks: activeReviewRun.pending_audit_tasks_path ?? null,
+        },
+        prompt: renderDispatchReviewPrompt({
+            root,
+            artifactsDir,
+            activeReviewRun,
+            dispatchPlanPath: dispatch.dispatch_plan_path,
+            dispatchQuotaPath: dispatch.dispatch_quota_path,
+            hostCanRestrictSubagentTools: params.hostCanRestrictSubagentTools,
+            hostCanSelectSubagentModel: params.hostCanSelectSubagentModel,
+        }),
+        access: {
+            read_paths: [
+                dispatch.dispatch_plan_path,
+                ...(dispatch.dispatch_quota_path ? [dispatch.dispatch_quota_path] : []),
+            ],
+            write_paths: [],
+        },
+    });
+}
 async function cmdNextStep(argv) {
     const root = getRootDir(argv);
     warnIfNotGitRepo(root);
@@ -1123,81 +1206,14 @@ async function cmdNextStep(argv) {
         console.log(JSON.stringify(step, null, 2));
         return;
     }
-    if (!hostCanDispatch) {
-        const singleTaskPromptPath = join(artifactsDir, "dispatch", "current-single-task-prompt.md");
-        const workerCommand = renderCommand(result.activeReviewRun.worker_command);
-        const step = await writeCurrentStep({
-            artifactsDir,
-            stepKind: "single_task_fallback",
-            status: "ready",
-            runId: result.activeReviewRun.run_id,
-            allowedCommands: [workerCommand],
-            stopCondition: "Run the exact worker_command after one result, then stop without looping.",
-            repoRoot: root,
-            artifactPaths: {
-                active_review_task: result.activeReviewRun.task_path,
-                active_review_prompt: result.activeReviewRun.prompt_path,
-                pending_audit_tasks: result.activeReviewRun.pending_audit_tasks_path ?? null,
-                audit_results: result.activeReviewRun.audit_results_path,
-                single_task_prompt: singleTaskPromptPath,
-            },
-            prompt: renderSingleTaskFallbackStepPrompt({
-                singleTaskPromptPath,
-                activeReviewRun: result.activeReviewRun,
-            }),
-            access: {
-                read_paths: [singleTaskPromptPath],
-                write_paths: [result.activeReviewRun.audit_results_path],
-            },
-        });
-        console.log(JSON.stringify(step, null, 2));
-        return;
-    }
-    const dispatch = await prepareDispatchArtifacts({
-        packageRoot,
-        runId: result.activeReviewRun.run_id,
-        artifactsDir,
+    const step = await renderSemanticReviewStep({
         root,
-        hostActiveSubagentLimit: hostMaxActiveSubagents,
-    });
-    const mergeCommand = mergeAndIngestCommand(artifactsDir, result.activeReviewRun.run_id);
-    const continueCommand = nextStepCommand(root, artifactsDir);
-    const step = await writeCurrentStep({
         artifactsDir,
-        stepKind: "dispatch_review",
-        status: "ready",
-        runId: result.activeReviewRun.run_id,
-        allowedCommands: [
-            "auditor_merge_and_ingest",
-            "auditor_continue_audit",
-            mergeCommand,
-            continueCommand,
-        ],
-        stopCondition: "Dispatch every packet, run merge-and-ingest once, then run next-step.",
-        repoRoot: root,
-        artifactPaths: {
-            dispatch_plan: dispatch.dispatch_plan_path,
-            dispatch_quota: dispatch.dispatch_quota_path,
-            dispatch_warnings: dispatch.dispatch_warnings_path,
-            active_review_task: result.activeReviewRun.task_path,
-            pending_audit_tasks: result.activeReviewRun.pending_audit_tasks_path ?? null,
-        },
-        prompt: renderDispatchReviewPrompt({
-            root,
-            artifactsDir,
-            activeReviewRun: result.activeReviewRun,
-            dispatchPlanPath: dispatch.dispatch_plan_path,
-            dispatchQuotaPath: dispatch.dispatch_quota_path,
-            hostCanRestrictSubagentTools,
-            hostCanSelectSubagentModel,
-        }),
-        access: {
-            read_paths: [
-                dispatch.dispatch_plan_path,
-                ...(dispatch.dispatch_quota_path ? [dispatch.dispatch_quota_path] : []),
-            ],
-            write_paths: [],
-        },
+        activeReviewRun: result.activeReviewRun,
+        hostCanDispatch,
+        hostMaxActiveSubagents,
+        hostCanRestrictSubagentTools,
+        hostCanSelectSubagentModel,
     });
     console.log(JSON.stringify(step, null, 2));
 }
@@ -1365,6 +1381,37 @@ async function cmdRunToCompletion(argv) {
             const blockPrompt = renderWorkerPrompt(blockTask);
             await writeWorkerTaskFiles(blockTask, blockPrompt, blockPaths, artifactsDir, blockPendingTasks);
             await writeJsonFile(blockPendingTasksPath, blockPendingTasks);
+            const reviewRun = {
+                run_id: blockRunId,
+                task_path: blockPaths.taskPath,
+                prompt_path: blockPaths.promptPath,
+                pending_audit_tasks_path: blockPendingTasksPath,
+                audit_results_path: blockAuditResultsPath,
+                worker_command: blockTask.worker_command,
+            };
+            // Render the actionable dispatch / single-task step here instead of
+            // leaving the host to issue next-step as a second command. Capability is
+            // resolved from flags/config/env with a sane default, so nothing is
+            // required from the host to make progress. If rendering fails we still
+            // emit the hand-off below — run-to-completion is never worse than before,
+            // and next-step will re-render and surface the error loudly.
+            try {
+                await renderSemanticReviewStep({
+                    root,
+                    artifactsDir,
+                    activeReviewRun: reviewRun,
+                    hostCanDispatch: resolveHostDispatchCapability({
+                        explicit: getOptionalBooleanFlag(argv, "--host-can-dispatch-subagents"),
+                        sessionConfig,
+                    }),
+                    hostMaxActiveSubagents: getHostMaxActiveSubagents(argv),
+                    hostCanRestrictSubagentTools: getOptionalBooleanFlag(argv, "--host-can-restrict-subagent-tools") ?? false,
+                    hostCanSelectSubagentModel: getOptionalBooleanFlag(argv, "--host-can-select-subagent-model") ?? false,
+                });
+            }
+            catch (stepError) {
+                process.stderr.write(`[audit-code] Could not pre-render the review step; the operator hand-off points to next-step instead. ${stepError instanceof Error ? stepError.message : String(stepError)}\n`);
+            }
             await emitEnvelope({
                 root,
                 artifactsDir,
@@ -1380,14 +1427,7 @@ async function cmdRunToCompletion(argv) {
                 progress_summary: blocker,
                 next_likely_step: null,
                 providerName: provider.name,
-                activeReviewRun: {
-                    run_id: blockRunId,
-                    task_path: blockPaths.taskPath,
-                    prompt_path: blockPaths.promptPath,
-                    pending_audit_tasks_path: blockPendingTasksPath,
-                    audit_results_path: blockAuditResultsPath,
-                    worker_command: blockTask.worker_command,
-                },
+                activeReviewRun: reviewRun,
             });
             return;
         }

package/dist/io/artifacts.d.ts

@@ -55,6 +55,7 @@ interface ArtifactDefinition<K extends ArtifactBundleKey = ArtifactBundleKey> {
     read: (path: string) => Promise<ArtifactPayloadMap[K] | undefined>;
     write: (path: string, value: ArtifactPayloadMap[K]) => Promise<void>;
 }
+export declare const AUDIT_REPORT_FILENAME = "audit-report.md";
 export declare const ARTIFACT_DEFINITIONS: {
     readonly repo_manifest: ArtifactDefinition<"repo_manifest">;
     readonly file_disposition: ArtifactDefinition<"file_disposition">;

package/dist/io/artifacts.js

@@ -2,6 +2,10 @@ import { cp, rm, unlink } from "node:fs/promises";
 import { join } from "node:path";
 import { isFileMissingError, readOptionalJsonFile, readOptionalNdjsonFile, readOptionalTextFile, writeJsonFile, writeNdjsonFile, writeTextFile, } from "@audit-tools/shared";
 import { buildToolingManifest } from "./toolingManifest.js";
+// Canonical filename for the rendered findings report. Single source of truth
+// for path construction. The dependency table below still lists it as plain
+// data alongside its sibling artifact-name literals.
+export const AUDIT_REPORT_FILENAME = "audit-report.md";
 function jsonArtifact(fileName, phase) {
     return {
         fileName,
@@ -49,7 +53,7 @@ export const ARTIFACT_DEFINITIONS = {
     audit_plan_metrics: jsonArtifact("audit_plan_metrics.json", "execution"),
     review_packets: jsonArtifact("review_packets.json", "execution"),
     requeue_tasks: jsonArtifact("requeue_tasks.json", "execution"),
-    audit_report: textArtifact("audit-report.md", "reporting"),
+    audit_report: textArtifact(AUDIT_REPORT_FILENAME, "reporting"),
     audit_findings: jsonArtifact("audit-findings.json", "reporting"),
     synthesis_narrative: jsonArtifact("synthesis-narrative.json", "reporting"),
     audit_state: jsonArtifact("audit_state.json", "supervisor"),
@@ -103,8 +107,8 @@ export async function cleanupIntermediateArtifacts(root) {
     return deleted;
 }
 export async function promoteFinalAuditReport(params, options = {}) {
-    const source = join(params.artifactsDir, "audit-report.md");
-    const destination = join(params.repoRoot, "audit-report.md");
+    const source = join(params.artifactsDir, AUDIT_REPORT_FILENAME);
+    const destination = join(params.repoRoot, AUDIT_REPORT_FILENAME);
     const copy = options.copy ?? cp;
     const remove = options.remove ?? rm;
     const warn = options.warn ?? ((message) => process.stderr.write(`${message}\n`));

package/dist/mcp/server.js

@@ -2,7 +2,7 @@ import { readFile } from "node:fs/promises";
 import { spawn } from "node:child_process";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { loadArtifactBundle } from "../io/artifacts.js";
+import { loadArtifactBundle, AUDIT_REPORT_FILENAME } from "../io/artifacts.js";
 import { readOptionalTextFile } from "@audit-tools/shared";
 import { deriveAuditState } from "../orchestrator/state.js";
 import { decideNextStep } from "../orchestrator/nextStep.js";
@@ -225,8 +225,8 @@ export const resourceRegistry = [
         description: "Current deterministic audit report if available.",
         mimeType: "text/markdown",
         async read(context) {
-            const report = (await readOptionalTextFile(join(context.artifactsDir, "audit-report.md"))) ??
-                (await readOptionalTextFile(join(context.root, "audit-report.md"))) ??
+            const report = (await readOptionalTextFile(join(context.artifactsDir, AUDIT_REPORT_FILENAME))) ??
+                (await readOptionalTextFile(join(context.root, AUDIT_REPORT_FILENAME))) ??
                 "The audit report has not been rendered yet.";
             return { mimeType: this.mimeType, text: report };
         },

package/dist/supervisor/operatorHandoff.d.ts

@@ -1,4 +1,4 @@
-import type { ArtifactBundle } from "../io/artifacts.js";
+import { type ArtifactBundle } from "../io/artifacts.js";
 import type { AuditState, AuditTopLevelStatus } from "../types/auditState.js";
 export interface AuditCodeHandoffInput {
     flag: "--results" | "--batch-results" | "--updates" | "--external-analyzer-results";

package/dist/supervisor/operatorHandoff.js

@@ -1,6 +1,7 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { writeJsonFile } from "@audit-tools/shared";
+import { AUDIT_REPORT_FILENAME } from "../io/artifacts.js";
 import { LOCAL_SUBPROCESS_PROVIDER_NAME } from "../providers/constants.js";
 export const CONFIG_ERROR_BLOCKER_PREFIX = "config-error:";
 const INCOMING_DIRNAME = "incoming";
@@ -11,8 +12,6 @@ const RUN_LEDGER_FILENAME = "run-ledger.json";
 const CURRENT_TASK_FILENAME = "current-task.json";
 const CURRENT_PROMPT_FILENAME = "current-prompt.md";
 const CURRENT_TASKS_FILENAME = "current-tasks.json";
-const CURRENT_SINGLE_TASK_FILENAME = "current-single-task.json";
-const CURRENT_SINGLE_TASK_PROMPT_FILENAME = "current-single-task-prompt.md";
 const AUDIT_TASKS_FILENAME = "audit_tasks.json";
 const RUNTIME_VALIDATION_TASKS_FILENAME = "runtime_validation_tasks.json";
 const BLOCKED_STATUS = "blocked";
@@ -123,6 +122,26 @@ function buildInteractiveProviderHint(status, providerName, sessionConfigPath, i
     const providerLabel = providerName ?? LOCAL_SUBPROCESS_PROVIDER_NAME;
     return `Provider: ${providerLabel}. This is a deterministic semantic-review handoff, not a failed audit. Use host subagents when the active toolset provides them; otherwise use the single-task fallback and stop after the worker command. For automatic LLM review, configure an interactive provider in ${sessionConfigPath}; that is only needed for backend-launched review.`;
 }
+// Single source for which artifact paths render in the markdown handoff and how
+// absent ones read. renderMarkdown and file_map both source paths from the
+// artifact path model (AuditCodeHandoffArtifactPaths), so adding or renaming a
+// handoff artifact is one edit here instead of coordinated edits across sites.
+const ARTIFACT_PATH_RENDER_FIELDS = [
+    { label: "operator handoff json", key: "operator_handoff_json" },
+    { label: "operator handoff markdown", key: "operator_handoff_markdown" },
+    { label: "incoming dir", key: "incoming_dir" },
+    { label: "session config", key: "session_config" },
+    { label: "run ledger", key: "run_ledger" },
+    { label: "current task", key: "current_task", fallback: "not available" },
+    { label: "current prompt", key: "current_prompt", fallback: "not available" },
+    { label: "current tasks", key: "current_tasks", fallback: "not available" },
+    { label: "audit tasks", key: "audit_tasks", fallback: "not available yet" },
+    {
+        label: "runtime validation tasks",
+        key: "runtime_validation_tasks",
+        fallback: "not available yet",
+    },
+];
 function renderMarkdown(handoff) {
     const lines = [
         "# audit-code operator handoff",
@@ -145,16 +164,10 @@ function renderMarkdown(handoff) {
         }
     }
     lines.push("", "Useful artifact paths:");
-    lines.push(`- operator handoff json: ${handoff.artifact_paths.operator_handoff_json}`);
-    lines.push(`- operator handoff markdown: ${handoff.artifact_paths.operator_handoff_markdown}`);
-    lines.push(`- incoming dir: ${handoff.artifact_paths.incoming_dir}`);
-    lines.push(`- session config: ${handoff.artifact_paths.session_config}`);
-    lines.push(`- run ledger: ${handoff.artifact_paths.run_ledger}`);
-    lines.push(`- current task: ${handoff.artifact_paths.current_task ?? "not available"}`);
-    lines.push(`- current prompt: ${handoff.artifact_paths.current_prompt ?? "not available"}`);
-    lines.push(`- current tasks: ${handoff.artifact_paths.current_tasks ?? "not available"}`);
-    lines.push(`- audit tasks: ${handoff.artifact_paths.audit_tasks ?? "not available yet"}`);
-    lines.push(`- runtime validation tasks: ${handoff.artifact_paths.runtime_validation_tasks ?? "not available yet"}`);
+    for (const field of ARTIFACT_PATH_RENDER_FIELDS) {
+        const value = handoff.artifact_paths[field.key];
+        lines.push(`- ${field.label}: ${value ?? field.fallback ?? "not available"}`);
+    }
     if (handoff.suggested_inputs.length > 0) {
         lines.push("", "Suggested evidence inputs:");
         for (const item of handoff.suggested_inputs) {
@@ -238,11 +251,8 @@ export function buildAuditCodeHandoff(params) {
         handoff.file_map = {
             current_task: artifactPaths.current_task,
             current_prompt: artifactPaths.current_prompt,
-            single_task: join(params.artifactsDir, "dispatch", CURRENT_SINGLE_TASK_FILENAME),
-            single_task_prompt: join(params.artifactsDir, "dispatch", CURRENT_SINGLE_TASK_PROMPT_FILENAME),
-            dispatch_plan: join(params.artifactsDir, "runs", params.activeReviewRun.run_id, "dispatch-plan.json"),
             audit_results: params.activeReviewRun.audit_results_path,
-            final_report: join(params.root, "audit-report.md"),
+            final_report: join(params.root, AUDIT_REPORT_FILENAME),
         };
     }
     return handoff;

package/docs/contracts.md

@@ -90,9 +90,16 @@ backend writes the current step contract to:
 includes `step_kind`, `prompt_path`, `status`, `run_id`, `allowed_commands`,
 `stop_condition`, `repo_root`, `artifacts_dir`, and relevant `artifact_paths`.
 
-When semantic review is blocked, `next-step` first emits a `capability_check`.
-After the host reports `--host-can-dispatch-subagents true|false`, the backend
-renders exactly one review path: packet dispatch or the single-task fallback.
+When semantic review is reached, the backend resolves host dispatch capability
+from `--host-can-dispatch-subagents true|false` (optional) → session config
+(`host_can_dispatch_subagents`) → `AUDIT_CODE_HOST_CAN_DISPATCH` → default
+`true`, then renders exactly one review path: packet dispatch (`dispatch_review`)
+or the single-task fallback (`single_task_fallback`). No capability handshake is
+required; pass the flag only to override the resolved default.
+
+`run-to-completion` renders the same step when it reaches the semantic-review
+boundary, so a host on the batch entrypoint can act on `steps/current-step.json`
+directly instead of issuing a second `next-step`.
 
 ## Dispatch packets
 

package/package.json

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