auditor-lambda 0.6.6 → 0.6.8

package/audit-code-wrapper-lib.mjs

@@ -59,6 +59,25 @@ function nodeExecutable() {
   return process.execPath;
 }
 
+// When the wrapper runs from a source checkout (its package dir is NOT inside a
+// node_modules tree), generated continuation commands should re-invoke THIS
+// wrapper via `node <path>` so a dogfooded monorepo run stays pinned to local
+// code instead of silently falling back to a globally-installed `audit-code`
+// bin. Installed copies leave the hint unset so the dist CLI keeps emitting the
+// `audit-code` bin. Returned as an env fragment scoped to the spawned child so
+// it never leaks into the parent process (e.g. the test runner).
+function selfInvocationEnv() {
+  if (process.env.AUDIT_CODE_INVOCATION) {
+    return { AUDIT_CODE_INVOCATION: process.env.AUDIT_CODE_INVOCATION };
+  }
+  if (/[\\/]node_modules[\\/]/.test(repoRoot)) {
+    return {};
+  }
+  return {
+    AUDIT_CODE_INVOCATION: JSON.stringify(['node', join(repoRoot, 'audit-code.mjs')]),
+  };
+}
+
 function quoteForCmd(arg) {
   if (arg.length === 0) return '""';
   if (!/[\s"]/u.test(arg)) return arg;
@@ -82,7 +101,7 @@ function run(command, args, options = {}) {
     const child = spawn(resolved.command, resolved.args, {
       cwd: repoRoot,
       stdio: options.capture ? ['ignore', 'pipe', 'pipe'] : 'inherit',
-      env: process.env
+      env: options.env ?? process.env
     });
 
     let stdout = '';
@@ -1008,6 +1027,13 @@ function renderSharedMcpLauncher(sourcePackageRoot) {
     'const scriptDir = dirname(fileURLToPath(import.meta.url));',
     "const repoRoot = resolve(scriptDir, '..', '..');",
     "const artifactsDir = join(repoRoot, '.audit-artifacts');",
+    '// Absolute path to the auditor-lambda package that generated this launcher.',
+    '// Intentionally machine-specific: it is a load-bearing fallback candidate',
+    '// (tried after a repo-local dependency) that lets the launcher find the',
+    '// backend entrypoint when the target repo has no local auditor-lambda dep.',
+    '// This file is regenerated per-install by `audit-code ensure`/`install` and',
+    '// is gitignored, so the path is always re-derived for the current machine;',
+    '// if it ever goes stale the launcher degrades gracefully to PATH/npx below.',
     `const sourcePackageRoot = ${JSON.stringify(sourcePackageRoot)};`,
     '',
     'async function exists(path) {',
@@ -2767,7 +2793,9 @@ async function runDistCommand(commandName, argv, { ensureArtifactsDir = false }
   }
 
   await ensureBuilt();
-  await run(nodeExecutable(), [distEntry, commandName, ...commandArgs]);
+  await run(nodeExecutable(), [distEntry, commandName, ...commandArgs], {
+    env: { ...process.env, ...selfInvocationEnv() },
+  });
 }
 
 async function runDistCommandInline(commandName, argv) {
@@ -2781,6 +2809,12 @@ async function runDistCommandInline(commandName, argv) {
   await mkdir(artifactsDir, { recursive: true });
   await ensureBuilt();
 
+  // Propagate the invocation hint into this (long-lived) server process so it
+  // and the wrapper subprocesses it spawns emit continuation commands that
+  // match how the backend was launched. Safe here: this path is only the `mcp`
+  // server, not a shared/test process.
+  Object.assign(process.env, selfInvocationEnv());
+
   // Import the module that exports runCli (dist/cli.js). dist/index.js has no
   // exports — it is the bare entrypoint that runs `runCli(process.argv)` as an
   // import side effect — so importing it here both fails to provide runCli and

package/dist/cli/dispatch.d.ts

@@ -41,6 +41,8 @@ export interface PrepareDispatchResult {
     packet_count: number;
     task_count: number;
     skipped_task_count: number;
+    /** Subagent parallelism resolved for this dispatch run. */
+    wave_size: number;
     largest_packet: {
         packet_id: string;
         total_lines: number;

package/dist/cli/dispatch.js

@@ -533,6 +533,7 @@ export async function prepareDispatchArtifacts(params) {
         packet_count: plan.length,
         task_count: orderedTasks.length,
         skipped_task_count: priorResultTaskIds.size,
+        wave_size: waveSchedule.wave_size,
         largest_packet: largestPacketId
             ? {
                 packet_id: largestPacketId,

package/dist/cli/prompts.js

@@ -1,7 +1,32 @@
 import { renderCommand } from "./args.js";
+/**
+ * Token prefix the host should use to re-invoke the backend in generated
+ * continuation commands. Defaults to the `audit-code` bin (correct for an
+ * installed global). The wrapper sets `AUDIT_CODE_INVOCATION` to e.g.
+ * `["node","<path>/audit-code.mjs"]` when it runs from a source checkout, so a
+ * dogfooded monorepo run keeps generated commands pinned to local code instead
+ * of silently falling back to a globally-installed `audit-code`.
+ */
+function cliInvocationTokens() {
+    const raw = process.env.AUDIT_CODE_INVOCATION;
+    if (raw) {
+        try {
+            const parsed = JSON.parse(raw);
+            if (Array.isArray(parsed) &&
+                parsed.length > 0 &&
+                parsed.every((t) => typeof t === "string" && t.length > 0)) {
+                return parsed;
+            }
+        }
+        catch {
+            // malformed override — fall back to the default bin
+        }
+    }
+    return ["audit-code"];
+}
 export function nextStepCommand(root, artifactsDir) {
     return renderCommand([
-        "audit-code",
+        ...cliInvocationTokens(),
         "next-step",
         "--root",
         root,
@@ -11,7 +36,7 @@ export function nextStepCommand(root, artifactsDir) {
 }
 export function mergeAndIngestCommand(artifactsDir, runId) {
     return renderCommand([
-        "audit-code",
+        ...cliInvocationTokens(),
         "merge-and-ingest",
         "--artifacts-dir",
         artifactsDir,
@@ -22,9 +47,12 @@ export function mergeAndIngestCommand(artifactsDir, runId) {
 export function renderDispatchReviewPrompt(params) {
     const mergeCommand = mergeAndIngestCommand(params.artifactsDir, params.activeReviewRun.run_id);
     const continueCommand = nextStepCommand(params.root, params.artifactsDir);
+    // Only mention model_hint when the host can actually act on it. When it
+    // cannot, the field is left as inert plan metadata rather than surfacing a
+    // contradictory "here is model_hint, now ignore it" instruction.
     const modelLine = params.hostCanSelectSubagentModel
         ? "When launching each subagent, map `entry.model_hint.tier` (`small`, `standard`, `deep`) to an available host model without asking the user for model names."
-        : "Ignore `entry.model_hint`; this host did not report per-subagent model selection.";
+        : null;
     const toolsLine = params.hostCanRestrictSubagentTools
         ? "Restrict review subagents to read/search plus the packet submit command named in their prompt. Do not give them source edit/write tools."
         : "Do not ask the user about per-subagent tool restrictions; this host did not report a callable restriction facility.";
@@ -59,7 +87,7 @@ export function renderDispatchReviewPrompt(params) {
         "",
         '  Read and follow the audit instructions in: <entry.prompt_path>',
         "",
-        modelLine,
+        ...(modelLine ? [modelLine] : []),
         toolsLine,
         "",
         "Each subagent must submit its packet through the submit command printed in its packet prompt and stop after successful submission.",

package/dist/cli/steps.d.ts

@@ -2,13 +2,39 @@ 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" | "analyzer_install" | "edge_reasoning" | "edge_reasoning_dispatch" | "synthesis_narrative" | "present_report" | "blocked";
+/**
+ * Lightweight run-level orientation surfaced in the step contract so a host
+ * resuming an in-flight audit knows where it stands without reading artifacts.
+ */
+export interface StepProgress {
+    /** One-line, human-readable summary safe to show a resuming host. */
+    summary: string;
+    /** Pending review packets in the active dispatch run, when applicable. */
+    pending_packets?: number;
+    /** Audit tasks covered by the pending packets. */
+    pending_tasks?: number;
+    /** Audit tasks already completed before this run (skipped as done). */
+    completed_tasks?: number;
+    /** Subagent parallelism resolved for this dispatch run. */
+    wave_size?: number;
+}
 export interface StepArtifact {
     contract_version: typeof STEP_CONTRACT_VERSION;
     step_kind: StepKind;
     prompt_path: string;
     status: StepStatus;
     run_id: string | null;
+    /** Run-level orientation; omitted for steps that have no meaningful summary. */
+    progress?: StepProgress;
+    /** Shell commands the host may run for this step. */
     allowed_commands: string[];
+    /**
+     * MCP tool names equivalent to `allowed_commands`, for hosts driving the
+     * backend through the MCP adapter. Omitted when the step has no MCP
+     * equivalents, so a shell host never has to guess which list entries are
+     * tool names versus runnable commands.
+     */
+    allowed_mcp_tools?: string[];
     stop_condition: string;
     repo_root: string;
     artifacts_dir: string;
@@ -21,6 +47,8 @@ export declare function writeCurrentStep(params: {
     status: StepStatus;
     runId: string | null;
     allowedCommands: string[];
+    allowedMcpTools?: string[];
+    progress?: StepProgress;
     stopCondition: string;
     repoRoot: string;
     artifactPaths: Record<string, string | null>;

package/dist/cli/steps.js

@@ -14,7 +14,11 @@ export async function writeCurrentStep(params) {
         prompt_path: promptPath,
         status: params.status,
         run_id: params.runId,
+        ...(params.progress ? { progress: params.progress } : {}),
         allowed_commands: params.allowedCommands,
+        ...(params.allowedMcpTools && params.allowedMcpTools.length > 0
+            ? { allowed_mcp_tools: params.allowedMcpTools }
+            : {}),
         stop_condition: params.stopCondition,
         repo_root: params.repoRoot,
         artifacts_dir: params.artifactsDir,

package/dist/cli.js

@@ -935,12 +935,19 @@ async function renderSemanticReviewStep(params) {
         stepKind: "dispatch_review",
         status: "ready",
         runId: activeReviewRun.run_id,
-        allowedCommands: [
-            "auditor_merge_and_ingest",
-            "auditor_continue_audit",
-            mergeCommand,
-            continueCommand,
-        ],
+        allowedCommands: [mergeCommand, continueCommand],
+        allowedMcpTools: ["auditor_merge_and_ingest", "auditor_continue_audit"],
+        progress: {
+            summary: `Dispatching ${dispatch.packet_count} review packet(s) covering ` +
+                `${dispatch.task_count} task(s) in waves of ${dispatch.wave_size}` +
+                (dispatch.skipped_task_count > 0
+                    ? `; ${dispatch.skipped_task_count} task(s) already completed.`
+                    : "."),
+            pending_packets: dispatch.packet_count,
+            pending_tasks: dispatch.task_count,
+            completed_tasks: dispatch.skipped_task_count,
+            wave_size: dispatch.wave_size,
+        },
         stopCondition: "Dispatch every packet, run merge-and-ingest once, then run next-step.",
         repoRoot: root,
         artifactPaths: {

package/dist/quota/scheduler.js

@@ -87,6 +87,14 @@ export function scheduleWave(options) {
                 : computeMaxSafeConcurrency(quotaStateEntry, halfLifeHours);
             waveSize = Math.min(waveSize, learnedCap);
         }
+        else if (hostConcurrencyLimit !== null) {
+            // The host explicitly reported its active-subagent capacity. That is a
+            // real concurrency signal, so it supersedes the conservative
+            // unknown-provider fallback (which exists only when we have no signal at
+            // all). Leaving waveSize untouched here lets applyHostConcurrencyLimit()
+            // below enforce the reported limit as the hard ceiling, while any RPM/TPM
+            // caps applied above still bind.
+        }
         else {
             const providerType = classifyProvider(providerName);
             const fallbackCap = providerType === "local"

package/package.json

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

package/skills/audit-code/audit-code.prompt.md

@@ -25,16 +25,22 @@ monorepo root). From the monorepo root use:
 node packages/audit-code/audit-code.mjs ensure --quiet
 ```
 
-Then ask the backend for exactly one next step:
+Then ask the backend for exactly one next step. This host can dispatch review
+subagents in parallel (via the `Agent`/`task` tool), so report that capacity on
+every `next-step` call — otherwise the backend assumes it cannot parallelize and
+sizes dispatch waves to one packet at a time:
 
 ```bash
-audit-code next-step
+audit-code next-step --host-max-active-subagents 4
 ```
 
+`4` is a safe default for this host; raise it for more parallelism or lower it
+under rate-limit pressure. The backend's learned quota adapts from there.
+
 When developing `auditor-lambda` itself, from the monorepo root use:
 
 ```bash
-node packages/audit-code/audit-code.mjs next-step
+node packages/audit-code/audit-code.mjs next-step --host-max-active-subagents 4
 ```
 
 Read the returned JSON only far enough to find `prompt_path`, then read and
@@ -47,7 +53,8 @@ Use MCP tools only as a compatibility adapter when direct shell access to
 `continue_audit` tools return the same one-step contract; they are not a
 separate orchestration path.
 
-When a step prompt tells you to continue, run `audit-code next-step` again and
-follow only the newly returned `prompt_path`.
+When a step prompt tells you to continue, run
+`audit-code next-step --host-max-active-subagents 4` again and follow only the
+newly returned `prompt_path`.
 
 Stop when the current step prompt tells you to stop.