auditor-lambda 0.3.29 → 0.3.32

package/audit-code-wrapper-lib.mjs

@@ -1371,6 +1371,18 @@ const INSTALL_HOST_DEFINITIONS = {
     profile: {
       writeAgents: true,
     },
+    async verify({ checks, assetPaths, collectVerifyCheck: collect }) {
+      await collect(checks, 'codex_global_surface', async () => {
+        const content = await readFile(assetPaths.agentsInstructionsPath, 'utf8');
+        if (!content.includes('/audit-code')) {
+          throw new Error(`AGENTS instructions do not reference /audit-code: ${assetPaths.agentsInstructionsPath}`);
+        }
+        return {
+          summary: 'Codex uses the global skill surface with AGENTS fallback instructions.',
+          path: assetPaths.agentsInstructionsPath,
+        };
+      });
+    },
   },
   'claude-desktop': {
     host: 'claude-desktop',
@@ -1394,6 +1406,85 @@ const INSTALL_HOST_DEFINITIONS = {
     profile: {
       writeClaudeDesktop: true,
     },
+    async verify({ checks, root, assetPaths, collectVerifyCheck: collect }) {
+      const bundleManifestPath = join(
+        root,
+        '.audit-code',
+        'install',
+        'claude-desktop',
+        'bundle',
+        'manifest.json',
+      );
+      const bundleServerPath = join(
+        root,
+        '.audit-code',
+        'install',
+        'claude-desktop',
+        'bundle',
+        'server',
+        'index.js',
+      );
+
+      await collect(checks, 'claude_bundle_manifest', async () => {
+        const manifest = await readJson(bundleManifestPath, 'Claude Desktop bundle manifest');
+        if (manifest?.server?.entry_point !== 'server/index.js') {
+          throw new Error(`Claude Desktop bundle manifest has an unexpected entry_point: ${manifest?.server?.entry_point ?? 'missing'}.`);
+        }
+        return {
+          summary: 'Claude Desktop bundle manifest parsed successfully.',
+          path: bundleManifestPath,
+        };
+      });
+      await collect(checks, 'claude_connector_template', async () => {
+        const connector = await readJson(
+          assetPaths.claudeDesktopRemoteConnectorPath,
+          'Claude Desktop remote connector template',
+        );
+        if (connector?.transport !== 'remote-mcp') {
+          throw new Error(`Claude Desktop remote connector transport must be "remote-mcp", got ${connector?.transport ?? 'missing'}.`);
+        }
+        return {
+          summary: 'Claude Desktop remote connector template parsed successfully.',
+          path: assetPaths.claudeDesktopRemoteConnectorPath,
+        };
+      });
+      await collect(checks, 'claude_dxt_archive', async () => ({
+        summary: 'Claude Desktop .dxt bundle is present.',
+        path: assetPaths.claudeDesktopDxtPath,
+        size_bytes: await verifyZipFile(
+          assetPaths.claudeDesktopDxtPath,
+          'Claude Desktop .dxt bundle',
+        ),
+      }));
+      await collect(checks, 'claude_mcpb_archive', async () => ({
+        summary: 'Claude Desktop .mcpb bundle is present.',
+        path: assetPaths.claudeDesktopMcpbPath,
+        size_bytes: await verifyZipFile(
+          assetPaths.claudeDesktopMcpbPath,
+          'Claude Desktop .mcpb bundle',
+        ),
+      }));
+      await collect(checks, 'claude_bundle_mcp', async () => {
+        const probe = await probeMcpServer({
+          label: 'Claude Desktop bundle server',
+          command: process.execPath,
+          args: [bundleServerPath],
+          cwd: root,
+          env: {
+            AUDIT_CODE_REPO_ROOT: root,
+            AUDIT_CODE_ARTIFACTS_DIR: join(root, '.audit-artifacts'),
+          },
+        });
+        const toolNames = (probe.tools?.tools ?? []).map((tool) => tool.name);
+        if (!toolNames.includes('start_audit')) {
+          throw new Error('Claude Desktop bundle server did not expose the start_audit tool.');
+        }
+        return {
+          summary: 'Claude Desktop bundle completed an MCP handshake.',
+          tool_count: toolNames.length,
+        };
+      });
+    },
   },
   opencode: {
     host: 'opencode',
@@ -1416,6 +1507,23 @@ const INSTALL_HOST_DEFINITIONS = {
       writeOpenCode: true,
       writeAgents: true,
     },
+    async verify({ checks, assetPaths, collectVerifyCheck: collect }) {
+      await collect(checks, 'opencode_config', async () => {
+        const config = await readJson(assetPaths.opencodeConfigPath, 'OpenCode project config');
+        if (config?.command?.['audit-code']) {
+          throw new Error('OpenCode project config must not define command["audit-code"]; the slash command is global npm-installed state. Run "audit-code install --host opencode" to remove the stale local command.');
+        }
+        if (config?.mcp?.auditor) {
+          throw new Error('OpenCode project config must not define mcp.auditor; the MCP server is supplied by the global npm-installed config. Run "audit-code install --host opencode" to remove the stale project-level MCP entry.');
+        }
+        assertOpenCodeAuditPermissionConfig(config?.permission, 'permission');
+        assertOpenCodeAuditPermissionConfig(config?.agent?.auditor?.permission, 'agent.auditor.permission');
+        return {
+          summary: 'OpenCode project config has audit permissions; MCP server and /audit-code command are supplied by the global npm-installed config.',
+          path: assetPaths.opencodeConfigPath,
+        };
+      });
+    },
   },
   vscode: {
     host: 'vscode',
@@ -1439,6 +1547,39 @@ const INSTALL_HOST_DEFINITIONS = {
       writeVSCode: true,
       writeCopilotInstructions: true,
     },
+    async verify({ checks, assetPaths, collectVerifyCheck: collect }) {
+      await collect(checks, 'vscode_prompt', async () => {
+        const content = await readFile(assetPaths.vscodePromptPath, 'utf8');
+        if (!content.includes('name: audit-code')) {
+          throw new Error(`VS Code prompt file is missing the expected frontmatter name: ${assetPaths.vscodePromptPath}`);
+        }
+        const { body: promptBody } = splitFrontmatter(content);
+        const { body: sourceBody } = splitFrontmatter(await readFile(promptAssetPath, 'utf8'));
+        if (promptBody !== sourceBody.trimStart()) {
+          throw new Error(
+            `VS Code prompt body is out of sync with the source prompt. Run "audit-code install --host vscode" or "audit-code install".`,
+          );
+        }
+        return {
+          summary: 'VS Code prompt file is present and uses the source prompt body.',
+          path: assetPaths.vscodePromptPath,
+        };
+      });
+      await collect(checks, 'vscode_mcp_config', async () => {
+        const config = await readJson(assetPaths.vscodeMcpConfigPath, 'VS Code MCP config');
+        const args = config?.servers?.auditor?.args;
+        if (config?.servers?.auditor?.command !== 'node') {
+          throw new Error(`VS Code MCP config must use node as the command, got ${config?.servers?.auditor?.command ?? 'missing'}.`);
+        }
+        if (!Array.isArray(args) || args[0] !== '${workspaceFolder}/.audit-code/install/run-mcp-server.mjs') {
+          throw new Error(`VS Code MCP config must point at \${workspaceFolder}/.audit-code/install/${MCP_LAUNCHER_FILENAME}.`);
+        }
+        return {
+          summary: 'VS Code MCP config parsed successfully.',
+          path: assetPaths.vscodeMcpConfigPath,
+        };
+      });
+    },
   },
   antigravity: {
     host: 'antigravity',
@@ -1465,6 +1606,28 @@ const INSTALL_HOST_DEFINITIONS = {
       writeAntigravity: true,
       writeAgents: true,
     },
+    async verify({ checks, assetPaths, collectVerifyCheck: collect }) {
+      await collect(checks, 'antigravity_skill', async () => {
+        const content = await readFile(assetPaths.antigravitySkillPath, 'utf8');
+        if (!content.includes('name: audit-code')) {
+          throw new Error('Antigravity skill SKILL.md must contain "name: audit-code" in frontmatter.');
+        }
+        return {
+          summary: 'Antigravity .agent/skills/audit-code/SKILL.md is present and valid.',
+          path: assetPaths.antigravitySkillPath,
+        };
+      });
+      await collect(checks, 'antigravity_guide', async () => {
+        const content = await readFile(assetPaths.antigravityPlanningGuidePath, 'utf8');
+        if (!content.includes(MCP_LAUNCHER_FILENAME) || !content.includes(INSTALLED_PROMPT_FILENAME)) {
+          throw new Error(`Antigravity guide must reference both ${MCP_LAUNCHER_FILENAME} and ${INSTALLED_PROMPT_FILENAME}.`);
+        }
+        return {
+          summary: 'Antigravity planning guide references the repo-local prompt asset and MCP launcher.',
+          path: assetPaths.antigravityPlanningGuidePath,
+        };
+      });
+    },
   },
 };
 
@@ -1505,6 +1668,13 @@ function getInstallProfile(host) {
   return profile;
 }
 
+export {
+  INSTALL_HOST_ORDER as _INSTALL_HOST_ORDER,
+  INSTALL_HOST_DEFINITIONS as _INSTALL_HOST_DEFINITIONS,
+  getInstallHostKeys as _getInstallHostKeys,
+  getInstallProfile as _getInstallProfile,
+};
+
 function buildHostCatalog({ root, host, assets }) {
   return getInstallHostKeys(host)
     .map((hostKey) => {
@@ -2028,177 +2198,15 @@ async function verifyInstalledBootstrap(argv) {
       primary_path: hostEntry.primary_path,
     }));
 
-    switch (hostKey) {
-      case 'codex':
-        await collectVerifyCheck(checks, 'codex_global_surface', async () => {
-          const content = await readFile(assetPaths.agentsInstructionsPath, 'utf8');
-          if (!content.includes('/audit-code')) {
-            throw new Error(`AGENTS instructions do not reference /audit-code: ${assetPaths.agentsInstructionsPath}`);
-          }
-          return {
-            summary: 'Codex uses the global skill surface with AGENTS fallback instructions.',
-            path: assetPaths.agentsInstructionsPath,
-          };
-        });
-        break;
-      case 'claude-desktop': {
-        const bundleManifestPath = join(
-          root,
-          '.audit-code',
-          'install',
-          'claude-desktop',
-          'bundle',
-          'manifest.json',
-        );
-        const bundleServerPath = join(
-          root,
-          '.audit-code',
-          'install',
-          'claude-desktop',
-          'bundle',
-          'server',
-          'index.js',
-        );
-
-        await collectVerifyCheck(checks, 'claude_bundle_manifest', async () => {
-          const manifest = await readJson(bundleManifestPath, 'Claude Desktop bundle manifest');
-          if (manifest?.server?.entry_point !== 'server/index.js') {
-            throw new Error(`Claude Desktop bundle manifest has an unexpected entry_point: ${manifest?.server?.entry_point ?? 'missing'}.`);
-          }
-          return {
-            summary: 'Claude Desktop bundle manifest parsed successfully.',
-            path: bundleManifestPath,
-          };
-        });
-        await collectVerifyCheck(checks, 'claude_connector_template', async () => {
-          const connector = await readJson(
-            assetPaths.claudeDesktopRemoteConnectorPath,
-            'Claude Desktop remote connector template',
-          );
-          if (connector?.transport !== 'remote-mcp') {
-            throw new Error(`Claude Desktop remote connector transport must be "remote-mcp", got ${connector?.transport ?? 'missing'}.`);
-          }
-          return {
-            summary: 'Claude Desktop remote connector template parsed successfully.',
-            path: assetPaths.claudeDesktopRemoteConnectorPath,
-          };
-        });
-        await collectVerifyCheck(checks, 'claude_dxt_archive', async () => ({
-          summary: 'Claude Desktop .dxt bundle is present.',
-          path: assetPaths.claudeDesktopDxtPath,
-          size_bytes: await verifyZipFile(
-            assetPaths.claudeDesktopDxtPath,
-            'Claude Desktop .dxt bundle',
-          ),
-        }));
-        await collectVerifyCheck(checks, 'claude_mcpb_archive', async () => ({
-          summary: 'Claude Desktop .mcpb bundle is present.',
-          path: assetPaths.claudeDesktopMcpbPath,
-          size_bytes: await verifyZipFile(
-            assetPaths.claudeDesktopMcpbPath,
-            'Claude Desktop .mcpb bundle',
-          ),
-        }));
-        await collectVerifyCheck(checks, 'claude_bundle_mcp', async () => {
-          const probe = await probeMcpServer({
-            label: 'Claude Desktop bundle server',
-            command: process.execPath,
-            args: [bundleServerPath],
-            cwd: root,
-            env: {
-              AUDIT_CODE_REPO_ROOT: root,
-              AUDIT_CODE_ARTIFACTS_DIR: join(root, '.audit-artifacts'),
-            },
-          });
-          const toolNames = (probe.tools?.tools ?? []).map((tool) => tool.name);
-          if (!toolNames.includes('start_audit')) {
-            throw new Error('Claude Desktop bundle server did not expose the start_audit tool.');
-          }
-          return {
-            summary: 'Claude Desktop bundle completed an MCP handshake.',
-            tool_count: toolNames.length,
-          };
-        });
-        break;
-      }
-      case 'opencode':
-        await collectVerifyCheck(checks, 'opencode_config', async () => {
-          const config = await readJson(assetPaths.opencodeConfigPath, 'OpenCode project config');
-          if (config?.command?.['audit-code']) {
-            throw new Error('OpenCode project config must not define command["audit-code"]; the slash command is global npm-installed state. Run "audit-code install --host opencode" to remove the stale local command.');
-          }
-          if (config?.mcp?.auditor) {
-            throw new Error('OpenCode project config must not define mcp.auditor; the MCP server is supplied by the global npm-installed config. Run "audit-code install --host opencode" to remove the stale project-level MCP entry.');
-          }
-          assertOpenCodeAuditPermissionConfig(config?.permission, 'permission');
-          assertOpenCodeAuditPermissionConfig(config?.agent?.auditor?.permission, 'agent.auditor.permission');
-          return {
-            summary: 'OpenCode project config has audit permissions; MCP server and /audit-code command are supplied by the global npm-installed config.',
-            path: assetPaths.opencodeConfigPath,
-          };
-        });
-        break;
-      case 'vscode':
-        await collectVerifyCheck(checks, 'vscode_prompt', async () => {
-          const content = await readFile(assetPaths.vscodePromptPath, 'utf8');
-          if (!content.includes('name: audit-code')) {
-            throw new Error(`VS Code prompt file is missing the expected frontmatter name: ${assetPaths.vscodePromptPath}`);
-          }
-          const { body: promptBody } = splitFrontmatter(content);
-          const { body: sourceBody } = splitFrontmatter(await readFile(promptAssetPath, 'utf8'));
-          if (promptBody !== sourceBody.trimStart()) {
-            throw new Error(
-              `VS Code prompt body is out of sync with the source prompt. Run "audit-code install --host vscode" or "audit-code install".`,
-            );
-          }
-          return {
-            summary: 'VS Code prompt file is present and uses the source prompt body.',
-            path: assetPaths.vscodePromptPath,
-          };
-        });
-        await collectVerifyCheck(checks, 'vscode_mcp_config', async () => {
-          const config = await readJson(assetPaths.vscodeMcpConfigPath, 'VS Code MCP config');
-          const args = config?.servers?.auditor?.args;
-          if (config?.servers?.auditor?.command !== 'node') {
-            throw new Error(`VS Code MCP config must use node as the command, got ${config?.servers?.auditor?.command ?? 'missing'}.`);
-          }
-          if (!Array.isArray(args) || args[0] !== '${workspaceFolder}/.audit-code/install/run-mcp-server.mjs') {
-            throw new Error(`VS Code MCP config must point at \${workspaceFolder}/.audit-code/install/${MCP_LAUNCHER_FILENAME}.`);
-          }
-          return {
-            summary: 'VS Code MCP config parsed successfully.',
-            path: assetPaths.vscodeMcpConfigPath,
-          };
-        });
-        break;
-      case 'antigravity':
-        await collectVerifyCheck(checks, 'antigravity_skill', async () => {
-          const content = await readFile(assetPaths.antigravitySkillPath, 'utf8');
-          if (!content.includes('name: audit-code')) {
-            throw new Error('Antigravity skill SKILL.md must contain "name: audit-code" in frontmatter.');
-          }
-          return {
-            summary: 'Antigravity .agent/skills/audit-code/SKILL.md is present and valid.',
-            path: assetPaths.antigravitySkillPath,
-          };
-        });
-        await collectVerifyCheck(checks, 'antigravity_guide', async () => {
-          const content = await readFile(assetPaths.antigravityPlanningGuidePath, 'utf8');
-          if (!content.includes(MCP_LAUNCHER_FILENAME) || !content.includes(INSTALLED_PROMPT_FILENAME)) {
-            throw new Error(`Antigravity guide must reference both ${MCP_LAUNCHER_FILENAME} and ${INSTALLED_PROMPT_FILENAME}.`);
-          }
-          return {
-            summary: 'Antigravity planning guide references the repo-local prompt asset and MCP launcher.',
-            path: assetPaths.antigravityPlanningGuidePath,
-          };
-        });
-        break;
-      default:
-        checks.push({
-          id: 'host_handler',
-          status: 'error',
-          summary: `No verification handler is implemented for host "${hostKey}".`,
-        });
+    const hostDefinition = INSTALL_HOST_DEFINITIONS[hostKey];
+    if (hostDefinition?.verify) {
+      await hostDefinition.verify({ checks, root, assetPaths, collectVerifyCheck });
+    } else {
+      checks.push({
+        id: 'host_handler',
+        status: 'error',
+        summary: `No verification handler is implemented for host "${hostKey}".`,
+      });
     }
 
     hostResults.push({

package/dist/cli.js

@@ -112,6 +112,21 @@ function quoteCommandArg(value) {
 function renderCommand(argv) {
     return argv.map((item) => quoteCommandArg(item)).join(" ");
 }
+function summarizeLaunchExit(result) {
+    if (result.accepted !== false && !result.error) {
+        return null;
+    }
+    const parts = [
+        result.signal
+            ? `signal ${result.signal}`
+            : `exit code ${result.exitCode ?? "unknown"}`,
+        result.command ? `command: ${result.command}` : null,
+        result.stdoutPath ? `stdout: ${result.stdoutPath}` : null,
+        result.stderrPath ? `stderr: ${result.stderrPath}` : null,
+        result.error ?? null,
+    ].filter((part) => Boolean(part));
+    return parts.join("; ");
+}
 function taskResultPath(taskResultsDir, taskId) {
     return join(taskResultsDir, artifactNameForId(taskId, "json"));
 }
@@ -1548,6 +1563,12 @@ async function cmdRunToCompletion(argv) {
                         ? outcome.reason.message
                         : String(outcome.reason));
                 }
+                else if (outcome?.status === "fulfilled") {
+                    const launchExitSummary = summarizeLaunchExit(outcome.value);
+                    if (launchExitSummary) {
+                        launchErrorsByRunId.set(workerSlots[index].runId, launchExitSummary);
+                    }
+                }
             }
             // Result ingestion is intentionally sequential even though agent launch
             // was parallel. Writing to coverage_matrix.json is not atomic, so
@@ -1856,8 +1877,9 @@ async function cmdRunToCompletion(argv) {
         }
         const startedAt = new Date().toISOString();
         let workerResult;
+        let launchResult = null;
         try {
-            await provider.launch({
+            launchResult = await provider.launch({
                 repoRoot: root,
                 runId,
                 obligationId,
@@ -1870,9 +1892,12 @@ async function cmdRunToCompletion(argv) {
                 timeoutMs,
             });
             const candidate = await readJsonFile(paths.resultPath);
-            workerResult = isWorkerResult(candidate)
-                ? candidate
-                : {
+            if (isWorkerResult(candidate)) {
+                workerResult = candidate;
+            }
+            else {
+                const launchExitSummary = summarizeLaunchExit(launchResult);
+                workerResult = {
                     contract_version: WORKER_RESULT_CONTRACT_VERSION,
                     run_id: runId,
                     obligation_id: obligationId,
@@ -1880,13 +1905,17 @@ async function cmdRunToCompletion(argv) {
                     progress_made: false,
                     selected_executor: preferredExecutor,
                     artifacts_written: [],
-                    summary: "Worker did not emit a valid worker result.",
+                    summary: launchExitSummary
+                        ? `Worker did not emit a valid worker result after provider exit: ${launchExitSummary}`
+                        : "Worker did not emit a valid worker result.",
                     next_likely_step: decision.selected_obligation,
                     errors: ["Invalid worker result contract."],
                 };
+            }
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
+            const launchExitSummary = launchResult && summarizeLaunchExit(launchResult);
             workerResult = {
                 contract_version: WORKER_RESULT_CONTRACT_VERSION,
                 run_id: runId,
@@ -1895,9 +1924,9 @@ async function cmdRunToCompletion(argv) {
                 progress_made: false,
                 selected_executor: preferredExecutor,
                 artifacts_written: [],
-                summary: `Worker launch failed for ${preferredExecutor}: ${message}`,
+                summary: `Worker launch failed for ${preferredExecutor}: ${launchExitSummary ?? message}`,
                 next_likely_step: decision.selected_obligation,
-                errors: [message],
+                errors: launchExitSummary ? [message, launchExitSummary] : [message],
             };
             await persistWorkerRunArtifacts(paths, workerResult, "provider-launch");
         }

package/dist/extractors/risk.js

@@ -1,3 +1,4 @@
+const MAX_RISK_SCORE = 10;
 export function buildRiskRegister(unitManifest, criticalFlows, externalAnalyzerResults) {
     const flowMap = new Map();
     for (const flow of criticalFlows?.flows ?? []) {
@@ -30,12 +31,13 @@ export function buildRiskRegister(unitManifest, criticalFlows, externalAnalyzerR
         if (externalHits > 0) {
             signals.push("external_analyzer_signal");
         }
+        const riskScore = (unit.risk_score ?? 0) +
+            flowHits +
+            externalHits +
+            (signals.includes("path_level_stateful_behavior") ? 1 : 0);
         return {
             unit_id: unit.unit_id,
-            risk_score: (unit.risk_score ?? 0) +
-                flowHits +
-                externalHits +
-                (signals.includes("path_level_stateful_behavior") ? 1 : 0),
+            risk_score: Math.min(MAX_RISK_SCORE, riskScore),
             signals,
             notes: [
                 "Initial heuristic risk scoring.",

package/dist/io/artifacts.d.ts

@@ -26,6 +26,7 @@ type ArtifactPayloadMap = {
     runtime_validation_tasks: RuntimeValidationTaskManifest;
     runtime_validation_report: RuntimeValidationReport;
     external_analyzer_results: ExternalAnalyzerResults;
+    syntax_resolution_status: unknown;
     audit_results: AuditResult[];
     audit_tasks: AuditTask[];
     audit_plan_metrics: AuditPlanMetrics;
@@ -63,6 +64,7 @@ export declare const ARTIFACT_DEFINITIONS: {
     readonly runtime_validation_tasks: ArtifactDefinition<"runtime_validation_tasks">;
     readonly runtime_validation_report: ArtifactDefinition<"runtime_validation_report">;
     readonly external_analyzer_results: ArtifactDefinition<"external_analyzer_results">;
+    readonly syntax_resolution_status: ArtifactDefinition<"syntax_resolution_status">;
     readonly audit_results: ArtifactDefinition<"audit_results">;
     readonly audit_tasks: ArtifactDefinition<"audit_tasks">;
     readonly audit_plan_metrics: ArtifactDefinition<"audit_plan_metrics">;

package/dist/io/artifacts.js

@@ -40,6 +40,7 @@ export const ARTIFACT_DEFINITIONS = {
     runtime_validation_tasks: jsonArtifact("runtime_validation_tasks.json", "execution"),
     runtime_validation_report: jsonArtifact("runtime_validation_report.json", "execution"),
     external_analyzer_results: jsonArtifact("external_analyzer_results.json", "execution"),
+    syntax_resolution_status: jsonArtifact("syntax_resolution_status.json", "execution"),
     audit_results: ndjsonArtifact("audit_results.jsonl", "execution"),
     audit_tasks: jsonArtifact("audit_tasks.json", "execution"),
     audit_plan_metrics: jsonArtifact("audit_plan_metrics.json", "execution"),

package/dist/io/toolingManifest.d.ts

@@ -1,2 +1,3 @@
 import type { ToolingManifest } from "../types/toolingManifest.js";
+export declare const TOOLING_INPUTS: readonly ["audit-code.mjs", "audit-code-wrapper-lib.mjs", "package.json", "dist", "schemas", "skills/audit-code"];
 export declare function buildToolingManifest(): Promise<ToolingManifest>;

package/dist/io/toolingManifest.js

@@ -3,7 +3,7 @@ import { readdir, readFile, stat } from "node:fs/promises";
 import { dirname, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
-const TOOLING_INPUTS = [
+export const TOOLING_INPUTS = [
     "audit-code.mjs",
     "audit-code-wrapper-lib.mjs",
     "package.json",

package/dist/mcp/server.d.ts

@@ -1 +1,72 @@
+interface ServerOptions {
+    root: string;
+    artifactsDir: string;
+}
+interface JsonRpcRequest {
+    jsonrpc?: string;
+    id?: string | number | null;
+    method?: string;
+    params?: Record<string, unknown>;
+}
+interface JsonRpcResponse {
+    jsonrpc: "2.0";
+    id: string | number | null;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+interface ToolCallContext {
+    root: string;
+    artifactsDir: string;
+}
+export declare function parseContentLength(headerBlock: string): number;
+interface ResourceRegistryEntry {
+    uri: string;
+    name: string;
+    description: string;
+    mimeType: string;
+    read: (context: ToolCallContext) => Promise<{
+        mimeType: string;
+        text: string;
+    }>;
+}
+export declare const resourceRegistry: ResourceRegistryEntry[];
+interface PromptRegistryEntry {
+    name: string;
+    description: string;
+    arguments: Array<{
+        name: string;
+        required?: boolean;
+        description: string;
+    }>;
+    render: (args: Record<string, unknown> | undefined) => string;
+}
+export declare const promptRegistry: PromptRegistryEntry[];
+/**
+ * Extract zero or more complete Content-Length framed messages from a buffer.
+ * Returns an array of parsed body strings and the remaining unconsumed buffer.
+ * On framing errors, emits a framing error response via `emit` and resets the buffer.
+ */
+export declare function extractFrames(buffer: Buffer, emit: (response: JsonRpcResponse) => void): {
+    bodies: string[];
+    remaining: Buffer<ArrayBufferLike>;
+};
+interface DispatchContext {
+    version: string;
+    defaults: ServerOptions;
+    shutdownRequested: boolean;
+}
+/**
+ * Dispatch a single JSON-RPC request and return the response(s) to send,
+ * plus updated shutdown state.
+ */
+export declare function dispatchRequest(request: JsonRpcRequest, ctx: DispatchContext): Promise<{
+    responses: JsonRpcResponse[];
+    shutdownRequested: boolean;
+    exit?: number;
+}>;
 export declare function runAuditCodeMcpServer(argv: string[]): Promise<void>;
+export {};