agentverify 1.3.0 → 1.6.0

package/dist/cli.js

@@ -2,7 +2,7 @@
 "use strict";
 
 // src/cli.ts
-var import_fs = require("fs");
+var import_fs2 = require("fs");
 var import_path = require("path");
 
 // src/sdk.ts
@@ -55,7 +55,12 @@ function normalizeScanResult(data) {
       scanDuration: 0
     },
     saved: data.saved === true,
-    reportUrl: data.reportUrl ?? null
+    reportUrl: data.reportUrl ?? null,
+    artifactFingerprint: data.artifactFingerprint,
+    reportIntegrity: data.reportIntegrity,
+    policyProfile: data.policyProfile ?? null,
+    policyResult: data.policyResult ?? null,
+    attestation: data.attestation ?? null
   };
 }
 async function scan(input, options) {
@@ -81,7 +86,8 @@ async function scan(input, options) {
       body: JSON.stringify({
         content: input.content,
         fileName: input.fileName ?? "agent",
-        platform: input.platform
+        platform: input.platform,
+        policyId: input.policyId
       }),
       signal: controller.signal
     });
@@ -109,10 +115,263 @@ async function scan(input, options) {
   }
 }
 
+// src/profile.ts
+var import_fs = require("fs");
+var SUPPORTED_PROFILES = ["owasp-agentic-skills-2026"];
+var SUPPORTED_ASSESSMENT_SCHEMA = "1.1.0";
+var LOCAL_LIMITS = { maxFiles: 5e3, maxFileBytes: 8 * 1024 * 1024, maxTotalBytes: 32 * 1024 * 1024, maxDepth: 64 };
+var VENDORED_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "__pycache__"]);
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".ico",
+  ".bmp",
+  ".tif",
+  ".tiff",
+  ".avif",
+  ".pdf",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".eot",
+  ".zip",
+  ".gz",
+  ".tgz",
+  ".tar",
+  ".bz2",
+  ".xz",
+  ".7z",
+  ".mp3",
+  ".mp4",
+  ".mov",
+  ".wav",
+  ".ogg",
+  ".webm",
+  ".wasm",
+  ".so",
+  ".dll",
+  ".dylib",
+  ".exe",
+  ".class",
+  ".jar",
+  ".pyc",
+  ".sqlite",
+  ".db"
+]);
+var PackageError = class extends Error {
+};
+function displayPath(path) {
+  return JSON.stringify(safeText(path));
+}
+function safeText(text) {
+  let out = "";
+  for (const ch of text) {
+    const cp = ch.codePointAt(0);
+    const hidden = cp < 32 || cp >= 127 && cp <= 159 || cp === 173 || cp === 1564 || cp === 6158 || cp === 65279 || cp >= 8203 && cp <= 8207 || cp >= 8234 && cp <= 8238 || cp >= 8288 && cp <= 8292 || cp >= 8294 && cp <= 8297 || cp >= 917504 && cp <= 917999 || cp >= 55296 && cp <= 57343;
+    out += hidden ? `\\u{${cp.toString(16).toUpperCase().padStart(4, "0")}}` : ch;
+  }
+  return out;
+}
+function nameProblem(name) {
+  for (let i = 0; i < name.length; i++) {
+    const c2 = name.charCodeAt(i);
+    if (c2 >= 55296 && c2 <= 56319) {
+      const next = name.charCodeAt(i + 1);
+      if (next >= 56320 && next <= 57343) {
+        i++;
+        continue;
+      }
+      return "contains an unpaired UTF-16 surrogate";
+    }
+    if (c2 >= 56320 && c2 <= 57343) return "contains an unpaired UTF-16 surrogate";
+  }
+  return null;
+}
+var strictUtf8 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+function decodeStrict(bytes) {
+  return strictUtf8.decode(bytes);
+}
+function listEntries(dir, shown) {
+  const entries = [];
+  if (process.platform === "win32") {
+    for (const d of (0, import_fs.readdirSync)(dir, { withFileTypes: true })) {
+      const problem = nameProblem(d.name);
+      if (problem) throw new PackageError(`An entry in ${displayPath(shown)} ${problem}, so it cannot be sent faithfully.`);
+      entries.push({ name: d.name, kind: d.isSymbolicLink() ? "symlink" : d.isDirectory() ? "dir" : d.isFile() ? "file" : "other" });
+    }
+  } else {
+    for (const d of (0, import_fs.readdirSync)(dir, { withFileTypes: true, encoding: "buffer" })) {
+      let name;
+      try {
+        name = decodeStrict(d.name);
+      } catch {
+        throw new PackageError(`An entry in ${displayPath(shown)} has a name that is not valid UTF-8, so it cannot be sent faithfully.`);
+      }
+      entries.push({ name, kind: d.isSymbolicLink() ? "symlink" : d.isDirectory() ? "dir" : d.isFile() ? "file" : "other" });
+    }
+  }
+  return entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+}
+var symlinkMessage = (rel) => `${displayPath(rel)} is a symbolic link. The CLI does not follow symbolic links, and a package containing one cannot be represented faithfully. Replace it with the file or directory it points to, or remove it.`;
+var specialMessage = (rel) => `${displayPath(rel)} is not a regular file or directory (it is a device, socket or pipe), so it cannot be sent.`;
+function readRegularFile(full, rel, budget) {
+  let fd;
+  try {
+    fd = (0, import_fs.openSync)(full, import_fs.constants.O_RDONLY | (import_fs.constants.O_NOFOLLOW ?? 0));
+  } catch (e) {
+    const code = e.code;
+    if (code === "ELOOP") throw new PackageError(symlinkMessage(rel));
+    throw new PackageError(`Could not read ${displayPath(rel)}: ${code ?? "unknown error"}.`);
+  }
+  try {
+    const st = (0, import_fs.fstatSync)(fd);
+    if (!st.isFile()) throw new PackageError(specialMessage(rel));
+    if (st.size > LOCAL_LIMITS.maxFileBytes) throw new PackageError(`${displayPath(rel)} is ${st.size} bytes, over the CLI's local read guard of ${LOCAL_LIMITS.maxFileBytes} bytes.`);
+    const bytes = (0, import_fs.readFileSync)(fd);
+    if (bytes.length > LOCAL_LIMITS.maxFileBytes) throw new PackageError(`${displayPath(rel)} grew past the CLI's local read guard while it was being read.`);
+    budget.total += bytes.length;
+    if (budget.total > LOCAL_LIMITS.maxTotalBytes) throw new PackageError(`The package is larger than the CLI's local guard of ${LOCAL_LIMITS.maxTotalBytes} bytes.`);
+    return bytes;
+  } finally {
+    (0, import_fs.closeSync)(fd);
+  }
+}
+var extensionOf = (name) => {
+  const i = name.lastIndexOf(".");
+  return i <= 0 ? "" : name.slice(i).toLowerCase();
+};
+function buildPackage(root) {
+  let rootStat;
+  try {
+    rootStat = (0, import_fs.lstatSync)(root);
+  } catch {
+    throw new PackageError(`${displayPath(root)} does not exist or cannot be read.`);
+  }
+  if (rootStat.isSymbolicLink()) throw new PackageError(symlinkMessage(root));
+  if (!rootStat.isDirectory()) throw new PackageError(`${displayPath(root)} is not a directory. A profile assessment takes a directory.`);
+  const files = [];
+  const skipped = [];
+  const budget = { total: 0 };
+  const walk = (dir, prefix, depth) => {
+    if (depth > LOCAL_LIMITS.maxDepth) throw new PackageError(`The package is nested deeper than ${LOCAL_LIMITS.maxDepth} directories.`);
+    for (const entry of listEntries(dir, prefix || ".")) {
+      const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+      const full = `${dir}/${entry.name}`;
+      if (entry.kind === "symlink") throw new PackageError(symlinkMessage(rel));
+      if (entry.kind === "other") throw new PackageError(specialMessage(rel));
+      if (entry.kind === "dir") {
+        if (VENDORED_DIRS.has(entry.name)) {
+          skipped.push({ path: rel, reason: "vendored directory" });
+          continue;
+        }
+        walk(full, rel, depth + 1);
+        continue;
+      }
+      if (BINARY_EXTENSIONS.has(extensionOf(entry.name))) {
+        skipped.push({ path: rel, reason: "binary asset" });
+        continue;
+      }
+      if (files.length >= LOCAL_LIMITS.maxFiles) throw new PackageError(`The package has more than ${LOCAL_LIMITS.maxFiles} files, over the CLI's local guard.`);
+      const bytes = readRegularFile(full, rel, budget);
+      let content;
+      try {
+        content = decodeStrict(bytes);
+      } catch {
+        throw new PackageError(`${displayPath(rel)} is not valid UTF-8 text, so it cannot be sent faithfully. If it is a binary asset, give it a recognized binary extension or remove it from the package.`);
+      }
+      files.push({ path: rel, content });
+    }
+  };
+  walk(root, "", 0);
+  if (files.length === 0) throw new PackageError(`${displayPath(root)} contains no files to assess.`);
+  return { files, skipped };
+}
+function serializeRequest(profile, files) {
+  return JSON.stringify({ profile, files });
+}
+async function postProfile(apiUrl, apiKey, body, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(apiUrl, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json", "User-Agent": "agentverify-cli/1.6.0" },
+      body,
+      signal: controller.signal
+    });
+    const text = await response.text();
+    let json = null;
+    try {
+      json = JSON.parse(text);
+    } catch {
+      json = null;
+    }
+    return { kind: "response", status: response.status, text, json };
+  } catch (e) {
+    if (e instanceof Error && e.name === "AbortError") return { kind: "failure", message: `Request timed out after ${timeoutMs}ms` };
+    return { kind: "failure", message: `Request failed: ${e instanceof Error ? e.message : String(e)}` };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var str = (v) => typeof v === "string" ? safeText(v) : typeof v === "number" || typeof v === "boolean" ? String(v) : "";
+function formatAssessment(body, skipped) {
+  const a = isObj(body.assessment) ? body.assessment : {};
+  const profile = isObj(a.profile) ? a.profile : {};
+  const pkg = isObj(a.package) ? a.package : {};
+  const lines = [];
+  lines.push("Agent Verify profile assessment");
+  lines.push(`Profile:            ${str(body.profile)}`);
+  lines.push(`Framework:          ${str(profile.framework)} (upstream ${str(profile.upstreamRepo)} @ ${str(profile.upstreamCommit).slice(0, 12)}, ${str(profile.upstreamStatus)}; profile version ${str(profile.agentverifyProfileVersion)})`);
+  lines.push(`Assessment schema:  ${str(a.schemaVersion)}`);
+  lines.push(`Interpretation:     scanner ${str(profile.scannerVersion)}, engine ${str(profile.assessmentEngineVersion)}, risk rubric ${str(profile.riskRubricVersion)}, key allowlist ${str(profile.keyAllowlistVersion)}, normalization ${str(profile.normalizationVersion)}`);
+  lines.push(`Package:            ${str(pkg.fileCount)} files, digest ${str(pkg.digest)}`);
+  lines.push(`Attestation:        ${body.attestation === null ? "none (this profile assessment is unsigned)" : "present (not verified by this CLI)"}`);
+  lines.push("");
+  for (const control of Array.isArray(a.controls) ? a.controls : []) {
+    if (!isObj(control)) continue;
+    const cov = isObj(control.coverage) ? control.coverage : {};
+    lines.push(`${str(control.controlId)} ${str(control.title)}: ${str(control.status)} (confidence ${str(control.confidence)})`);
+    lines.push(`  ${str(cov.evidenceObserved)} evidence observed, ${str(cov.gapIdentified)} gaps identified, ${str(cov.notAssessed)} not assessed, of ${str(cov.total)} checks`);
+    for (const check of Array.isArray(control.checks) ? control.checks : []) {
+      if (isObj(check)) lines.push(`  ${str(check.checkId)} ${str(check.status)}: ${str(check.title)}`);
+    }
+    lines.push("");
+  }
+  const gaps = (Array.isArray(a.evidence) ? a.evidence : []).filter((e) => isObj(e) && e.polarity === "gap");
+  lines.push(`Gaps identified (${gaps.length}):`);
+  for (const g of gaps) {
+    lines.push(`  [${str(g.severity)}] ${str(g.kind)}: ${str(g.summary)}`);
+    const locations = (Array.isArray(g.locations) ? g.locations : []).filter(isObj).slice(0, 3).map((l) => `${str(l.file)}${l.line !== void 0 ? `:${str(l.line)}` : ""}`);
+    if (locations.length) lines.push(`      at ${locations.join(", ")}`);
+  }
+  if (gaps.length === 0) lines.push("  none");
+  const notImplemented = Array.isArray(a.notImplementedControls) ? a.notImplementedControls.map(str).join(", ") : "";
+  lines.push("");
+  lines.push(`Not assessed by this profile version: ${notImplemented || "none"}`);
+  for (const note of Array.isArray(a.notes) ? a.notes : []) lines.push(`Note: ${str(note)}`);
+  if (skipped.length > 0) {
+    lines.push("");
+    lines.push(`Skipped from the package (${skipped.length}), not sent:`);
+    for (const s of skipped.slice(0, 20)) lines.push(`  ${displayPath(s.path)}: ${s.reason}`);
+    if (skipped.length > 20) lines.push(`  and ${skipped.length - 20} more`);
+  }
+  return lines;
+}
+
 // src/cli.ts
-var VERSION = "1.3.0";
+var VERSION = "1.6.0";
 var API_URL = process.env.AGENTVERIFY_API_URL ?? "https://agentverify-api.agentverify.workers.dev/v1/scan";
 var A2SPA_DOCS_URL = "https://aimodularity.com/A2SPA/docs";
+var EXIT_OK = 0;
+var EXIT_NOT_VERIFIED = 1;
+var EXIT_NOT_ASSESSED = 2;
+var EXIT_EXECUTION_ERROR = 3;
 var c = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
@@ -126,16 +385,17 @@ var c = {
 };
 var write = (value = "") => process.stdout.write(`${value}
 `);
-var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".ts", ".py", ".json", ".yaml", ".yml", ".md", ".mjs", ".cjs"]);
+var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".jsx", ".ts", ".tsx", ".py", ".json", ".yaml", ".yml", ".toml", ".md", ".mjs", ".cjs", ".sh"]);
+var MAX_SCAN_FILE_BYTES = 5 * 1024 * 1024;
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", "vendor", "coverage", ".cache"]);
 function collectFiles(dir) {
   const files = [];
   try {
-    const entries = (0, import_fs.readdirSync)(dir);
+    const entries = (0, import_fs2.readdirSync)(dir);
     for (const entry of entries) {
       if (SKIP_DIRS.has(entry)) continue;
       const fullPath = (0, import_path.join)(dir, entry);
-      const stat = (0, import_fs.statSync)(fullPath);
+      const stat = (0, import_fs2.statSync)(fullPath);
       if (stat.isDirectory()) {
         files.push(...collectFiles(fullPath));
       } else if (SUPPORTED_EXTENSIONS.has((0, import_path.extname)(entry).toLowerCase())) {
@@ -158,7 +418,10 @@ function parseArgs(argv) {
     ci: false,
     allowNotAssessed: false,
     help: false,
-    version: false
+    version: false,
+    policy: "",
+    summaryFile: "",
+    profiles: []
   };
   if (result.command === "--help" || result.command === "-h") {
     result.command = "";
@@ -176,6 +439,10 @@ function parseArgs(argv) {
     else if (arg === "--markdown") result.markdown = true;
     else if (arg === "--ci") result.ci = true;
     else if (arg === "--allow-not-assessed") result.allowNotAssessed = true;
+    else if (arg === "--policy") result.policy = args[++i] ?? "";
+    else if (arg === "--summary-file") result.summaryFile = args[++i] ?? "";
+    else if (arg === "--profile") result.profiles.push(args[++i] ?? "");
+    else if (arg.startsWith("--profile=")) result.profiles.push(arg.slice("--profile=".length));
     else if (arg === "--help" || arg === "-h") result.help = true;
     else if (arg === "--version" || arg === "-v") result.version = true;
     else if (!arg.startsWith("-")) result.dir = arg;
@@ -203,6 +470,15 @@ ${c.bold}Options:${c.reset}
   --ci          CI mode: concise output and non-zero exit for NOT VERIFIED
   --allow-not-assessed
                 In CI mode, do not fail only because content is NOT_ASSESSED
+  --policy <id> Evaluate a built-in policy profile against this scan's evidence
+                in addition to the scanner's own verdict (e.g. financial-agent)
+  --summary-file <path>
+                Write results as JSON to this path (in addition to any other output)
+  --profile <id>
+                (alpha) Assess a directory against an assessment profile instead of
+                scanning files individually. Supported: ${SUPPORTED_PROFILES.join(", ")}
+                Takes a directory; not combinable with --file, --ci, --policy,
+                --allow-not-assessed, --markdown or --summary-file.
   --version, -v Print version
   --help, -h    Show this help message
 
@@ -222,6 +498,20 @@ ${c.bold}Examples:${c.reset}
   ${c.gray}# Markdown summary for pull requests${c.reset}
   agentverify scan . --key av_your_key --markdown
 
+  ${c.gray}# Assess a skill directory against a profile (alpha); --json prints the service's response${c.reset}
+  agentverify scan ./my-skill --profile ${SUPPORTED_PROFILES[0]} --key av_your_key
+
+${c.bold}Exit codes (--ci):${c.reset}
+  0   All scanned files verified
+  1   NOT VERIFIED \u2014 a security/verification check failed
+  2   NOT ASSESSED \u2014 insufficient evidence for a verdict (see --allow-not-assessed)
+  3   Execution error \u2014 the scan itself could not run (bad key, network, missing file)
+
+${c.bold}Exit codes (--profile):${c.reset}
+  0   The assessment completed. Control and check statuses (including GAP_IDENTIFIED)
+      do not affect the exit code.
+  3   Usage or execution error \u2014 nothing was assessed
+
 ${c.bold}Get your API key:${c.reset}
   https://aimodularity.com/agentverify/dashboard
 
@@ -243,6 +533,16 @@ function getFixFirst(result) {
 function getRelevantThreatCategories(result) {
   return (result.threatCategories ?? []).filter((item) => item.status !== "not_assessed").slice(0, 6).map((item) => `${item.label} (${item.status.replace("_", " ")})`);
 }
+function criticalCount(result) {
+  return result.findings.filter((f) => f.severity === "critical").length;
+}
+function highCount(result) {
+  return result.findings.filter((f) => f.severity === "high").length;
+}
+function fingerprintPreview(result) {
+  const hash = result.artifactFingerprint?.artifactHash;
+  return hash ? `${hash.slice(0, 12)}\u2026` : null;
+}
 function printDetailedSummary(result, fileName) {
   const verified = result.verdict === "VERIFIED";
   const verdictColor = verified ? c.green : result.verdict === "NOT_ASSESSED" ? c.yellow : c.red;
@@ -253,6 +553,10 @@ ${c.bold}${c.cyan}Agent Verify${c.reset}`);
   write(`${c.bold}Verdict:${c.reset} ${verdictColor}${result.verdict === "NOT_VERIFIED" ? "NOT VERIFIED" : result.verdict.replace("_", " ")}${c.reset}`);
   write(`${c.bold}Risk level:${c.reset} ${result.riskLevel}`);
   write(`${c.bold}Confidence:${c.reset} ${result.confidence}/100`);
+  write(`${c.bold}Critical / High findings:${c.reset} ${criticalCount(result)} / ${highCount(result)}`);
+  if (result.metadata?.scannerVersion) write(`${c.bold}Ruleset version:${c.reset} ${result.metadata.scannerVersion}`);
+  if (fingerprintPreview(result)) write(`${c.bold}Artifact fingerprint:${c.reset} ${fingerprintPreview(result)}`);
+  if (result.policyProfile) write(`${c.bold}Policy (${result.policyProfile}):${c.reset} ${result.policyResult === "PASS" ? `${c.green}PASS${c.reset}` : `${c.red}FAIL${c.reset}`}`);
   write(`${c.bold}Top blocker:${c.reset} ${getTopBlocker(result)}`);
   write(`
 ${c.bold}Fix first:${c.reset}`);
@@ -261,6 +565,8 @@ ${c.bold}Fix first:${c.reset}`);
   else write(`  No blocking fixes detected. Re-scan after any material change.`);
   if (result.reportInsights?.nextAction) write(`
 ${c.bold}Next action:${c.reset} ${result.reportInsights.nextAction}`);
+  const lockedFixes = (result.findings ?? []).filter((f) => f.fixLocked).length;
+  if (lockedFixes > 0) write(`${c.gray}Step-by-step fixes and corrected code for ${lockedFixes} finding${lockedFixes === 1 ? "" : "s"} are included with Pro: https://aimodularity.com/agentverify/pricing/${c.reset}`);
   const threats = getRelevantThreatCategories(result);
   if (threats.length) {
     write(`
@@ -279,7 +585,11 @@ function markdownSummary(results, summary) {
       lines.push(`## ${item.file}`, "", `Error: ${item.error ?? "Unknown error"}`, "");
       continue;
     }
-    lines.push(`## ${item.file}`, "", `Score: ${item.result.riskScore}/100`, `Verdict: ${item.result.verdict === "NOT_VERIFIED" ? "NOT VERIFIED" : item.result.verdict.replace("_", " ")}`, `Risk level: ${item.result.riskLevel}`, `Top blocker: ${getTopBlocker(item.result)}`, "");
+    lines.push(`## ${item.file}`, "", `Score: ${item.result.riskScore}/100`, `Verdict: ${item.result.verdict === "NOT_VERIFIED" ? "NOT VERIFIED" : item.result.verdict.replace("_", " ")}`, `Risk level: ${item.result.riskLevel}`, `Critical / High findings: ${criticalCount(item.result)} / ${highCount(item.result)}`);
+    if (item.result.metadata?.scannerVersion) lines.push(`Ruleset version: ${item.result.metadata.scannerVersion}`);
+    if (fingerprintPreview(item.result)) lines.push(`Artifact fingerprint: \`${fingerprintPreview(item.result)}\``);
+    if (item.result.policyProfile) lines.push(`Policy (${item.result.policyProfile}): ${item.result.policyResult}`);
+    lines.push(`Top blocker: ${getTopBlocker(item.result)}`, "");
     const fixes = getFixFirst(item.result);
     if (fixes.length) lines.push("Fix first:", ...fixes.map((fix, index) => `${index + 1}. ${fix}`), "");
     const threats = getRelevantThreatCategories(item.result);
@@ -289,6 +599,24 @@ function markdownSummary(results, summary) {
   lines.push(`A2SPA docs: ${A2SPA_DOCS_URL}`);
   return lines.join("\n");
 }
+function writeGithubJobSummary(results, summary) {
+  const summaryPath = process.env.GITHUB_STEP_SUMMARY;
+  if (!summaryPath) return;
+  try {
+    (0, import_fs2.appendFileSync)(summaryPath, `${markdownSummary(results, summary)}
+`);
+  } catch (e) {
+    console.error(`Warning: could not write GitHub job summary: ${e instanceof Error ? e.message : e}`);
+  }
+}
+function writeSummaryFile(path, results, summary) {
+  if (!path) return;
+  try {
+    (0, import_fs2.writeFileSync)(path, JSON.stringify({ results, summary }, null, 2));
+  } catch (e) {
+    console.error(`Warning: could not write summary file: ${e instanceof Error ? e.message : e}`);
+  }
+}
 function printVerdict(result, fileName) {
   const verified = result.verdict === "VERIFIED";
   const notAssessed = result.verdict === "NOT_ASSESSED";
@@ -311,7 +639,7 @@ ${c.red}Error:${c.reset} API key required
     console.error(`  Get your key at https://aimodularity.com/agentverify/dashboard/`);
     console.error(`  Example: AGENTVERIFY_API_KEY=av_your_key agentverify scan .
 `);
-    process.exit(1);
+    process.exit(EXIT_EXECUTION_ERROR);
   }
   let files = [];
   if (args.file) {
@@ -327,7 +655,7 @@ ${c.bold}Agent Verify${c.reset} ${c.gray}v${VERSION}${c.reset}`);
     files = collectFiles(dir);
     if (files.length === 0) {
       write(`${c.yellow}No agent files found in ${dir}${c.reset}`);
-      write(`${c.gray}Supported: .js .ts .py .json .yaml .yml .md${c.reset}
+      write(`${c.gray}Supported: .js .jsx .ts .tsx .py .json .yaml .yml .toml .md .sh${c.reset}
 `);
       process.exit(0);
     }
@@ -342,10 +670,14 @@ ${c.bold}Agent Verify${c.reset} ${c.gray}v${VERSION}${c.reset}`);
     const batch = files.slice(i, i + CONCURRENCY);
     const batchResults = await Promise.allSettled(
       batch.map(async (filePath) => {
-        const content = (0, import_fs.readFileSync)(filePath, "utf-8");
+        const fileStat = (0, import_fs2.statSync)(filePath);
+        if (fileStat.size > MAX_SCAN_FILE_BYTES) {
+          throw new Error(`File is ${(fileStat.size / 1024 / 1024).toFixed(1)}MB, over the ${MAX_SCAN_FILE_BYTES / 1024 / 1024}MB scan limit \u2014 skipped`);
+        }
+        const content = (0, import_fs2.readFileSync)(filePath, "utf-8");
         const relPath = (0, import_path.relative)(args.dir === "." ? process.cwd() : args.dir, filePath);
         const result = await scan(
-          { content, fileName: relPath },
+          { content, fileName: relPath, policyId: args.policy || void 0 },
           { apiKey: args.key, apiUrl: API_URL }
         );
         return { filePath, relPath, result };
@@ -376,21 +708,23 @@ ${c.bold}Agent Verify${c.reset} ${c.gray}v${VERSION}${c.reset}`);
     }
   }
   const summary = { total: files.length, verified, notVerified, notAssessed, errors };
+  writeGithubJobSummary(jsonResults, summary);
+  writeSummaryFile(args.summaryFile, jsonResults, summary);
   if (args.json) {
     write(JSON.stringify({ results: jsonResults, summary }, null, 2));
-    if (errors > 0) process.exit(1);
+    if (errors > 0) process.exit(EXIT_EXECUTION_ERROR);
     if (args.ci) {
-      if (notVerified > 0) process.exit(1);
-      if (notAssessed > 0 && !args.allowNotAssessed) process.exit(2);
+      if (notVerified > 0) process.exit(EXIT_NOT_VERIFIED);
+      if (notAssessed > 0 && !args.allowNotAssessed) process.exit(EXIT_NOT_ASSESSED);
     }
     return;
   }
   if (args.markdown) {
     write(markdownSummary(jsonResults, summary));
-    if (errors > 0) process.exit(1);
+    if (errors > 0) process.exit(EXIT_EXECUTION_ERROR);
     if (args.ci) {
-      if (notVerified > 0) process.exit(1);
-      if (notAssessed > 0 && !args.allowNotAssessed) process.exit(2);
+      if (notVerified > 0) process.exit(EXIT_NOT_VERIFIED);
+      if (notAssessed > 0 && !args.allowNotAssessed) process.exit(EXIT_NOT_ASSESSED);
     }
     return;
   }
@@ -410,34 +744,118 @@ ${c.gray}Saved CLI reports appear in your dashboard: https://aimodularity.com/ag
 ${c.gray}No dashboard report was saved. Check API key access and retry if you need dashboard sync.${c.reset}`);
   write(`${c.gray}A2SPA docs: ${A2SPA_DOCS_URL}${c.reset}
 `);
-  if (errors > 0) process.exit(1);
+  if (errors > 0) process.exit(EXIT_EXECUTION_ERROR);
   if (args.ci) {
-    if (notVerified > 0) process.exit(1);
-    if (notAssessed > 0 && !args.allowNotAssessed) process.exit(2);
+    if (notVerified > 0) process.exit(EXIT_NOT_VERIFIED);
+    if (notAssessed > 0 && !args.allowNotAssessed) process.exit(EXIT_NOT_ASSESSED);
+  }
+}
+var PROFILE_TIMEOUT_MS = 6e4;
+function profileUsageError(message) {
+  console.error(`
+${c.red}Error:${c.reset} ${message}`);
+  console.error(`Run ${c.cyan}agentverify --help${c.reset} for usage
+`);
+  process.exitCode = EXIT_EXECUTION_ERROR;
+}
+function profileFailure(json, message, detail = {}) {
+  if (json) write(JSON.stringify({ error: message, ...detail }, null, 2));
+  else console.error(`
+${c.red}Error:${c.reset} ${safeText(message)}
+`);
+  process.exitCode = EXIT_EXECUTION_ERROR;
+}
+async function runProfile(args) {
+  if (args.profiles.length > 1) return profileUsageError("--profile was given more than once.");
+  const profile = args.profiles[0];
+  if (profile === "") return profileUsageError(`--profile requires a value. Supported profiles: ${SUPPORTED_PROFILES.join(", ")}`);
+  if (!SUPPORTED_PROFILES.includes(profile)) {
+    return profileUsageError(`Unknown profile ${JSON.stringify(safeText(profile))}. Supported profiles: ${SUPPORTED_PROFILES.join(", ")}`);
+  }
+  const conflicts = [];
+  if (args.file) conflicts.push("--file");
+  if (args.ci) conflicts.push("--ci");
+  if (args.allowNotAssessed) conflicts.push("--allow-not-assessed");
+  if (args.policy) conflicts.push("--policy");
+  if (args.markdown) conflicts.push("--markdown");
+  if (args.summaryFile) conflicts.push("--summary-file");
+  if (conflicts.length > 0) return profileUsageError(`--profile cannot be combined with ${conflicts.join(", ")}. A profile assessment takes a directory and reports its own result.`);
+  if (!args.key) {
+    console.error(`
+${c.red}Error:${c.reset} API key required
+`);
+    console.error(`  Set with --key av_your_key or AGENTVERIFY_API_KEY env var.`);
+    console.error(`  Get your key at https://aimodularity.com/agentverify/dashboard/
+`);
+    process.exitCode = EXIT_EXECUTION_ERROR;
+    return;
+  }
+  let built;
+  try {
+    built = buildPackage(args.dir);
+  } catch (e) {
+    return profileFailure(args.json, e instanceof PackageError ? e.message : `Could not read the package: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  if (args.json && built.skipped.length > 0) {
+    console.error(`Note: ${built.skipped.length} entries were skipped from the package and not sent: ${built.skipped.slice(0, 20).map((s) => `${displayPath(s.path)} (${s.reason})`).join(", ")}${built.skipped.length > 20 ? `, and ${built.skipped.length - 20} more` : ""}`);
+  }
+  const result = await postProfile(API_URL, args.key, serializeRequest(profile, built.files), PROFILE_TIMEOUT_MS);
+  if (result.kind === "failure") return profileFailure(args.json, result.message);
+  const body = result.json;
+  const isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+  if (result.status !== 200) {
+    if (isObject(body) && typeof body.error === "string") {
+      if (args.json) {
+        write(JSON.stringify(body, null, 2));
+      } else {
+        console.error(`
+${c.red}Error:${c.reset} ${safeText(body.error)} (HTTP ${result.status})`);
+        const rejection = body.rejection;
+        if (isObject(rejection)) console.error(`  rejection: ${safeText(String(rejection.code ?? ""))}: ${safeText(String(rejection.message ?? ""))}${typeof rejection.path === "string" ? ` (${JSON.stringify(safeText(rejection.path))})` : ""}`);
+        if (Array.isArray(body.supportedProfiles)) console.error(`  supported profiles: ${body.supportedProfiles.map((p) => safeText(String(p))).join(", ")}`);
+        console.error("");
+      }
+      process.exitCode = EXIT_EXECUTION_ERROR;
+      return;
+    }
+    return profileFailure(args.json, `Unexpected response from the service (HTTP ${result.status})`, { status: result.status });
+  }
+  if (!isObject(body) || typeof body.profile !== "string" || !isObject(body.assessment)) {
+    return profileFailure(args.json, "The service returned a response that is not a profile assessment", { status: result.status });
+  }
+  if (args.json) {
+    write(JSON.stringify(body, null, 2));
+    return;
+  }
+  const schema = body.assessment.schemaVersion;
+  if (schema !== SUPPORTED_ASSESSMENT_SCHEMA) {
+    return profileFailure(false, `This CLI prints assessment schema ${SUPPORTED_ASSESSMENT_SCHEMA}, but the service returned ${JSON.stringify(safeText(String(schema)))}. Update the CLI, or use --json to receive the raw response.`);
   }
+  for (const line of formatAssessment(body, built.skipped)) write(line);
 }
 async function main() {
   const args = parseArgs(process.argv);
   if (args.version) {
     write(`agentverify v${VERSION}`);
-    process.exit(0);
+    process.exit(EXIT_OK);
   }
   if (args.help || !args.command) {
     printHelp();
-    process.exit(0);
+    process.exit(EXIT_OK);
   }
   if (args.command === "scan") {
-    await runScan(args);
+    if (args.profiles.length > 0) await runProfile(args);
+    else await runScan(args);
   } else {
     console.error(`
 ${c.red}Unknown command: ${args.command}${c.reset}`);
     console.error(`Run ${c.cyan}agentverify --help${c.reset} for usage
 `);
-    process.exit(1);
+    process.exit(EXIT_EXECUTION_ERROR);
   }
 }
 main().catch((err) => {
   console.error(`
 ${c.red}Fatal error:${c.reset}`, err instanceof Error ? err.message : err);
-  process.exit(1);
+  process.exit(EXIT_EXECUTION_ERROR);
 });