@cdxgen/cdxgen 13.6.0 → 13.7.0

package/lib/evinser/evinser.js

@@ -17,6 +17,7 @@ import {
   safeRmSync,
   safeWriteSync,
 } from "../core/fs.js";
+import { thoughtLog } from "../core/logger.js";
 import { isProjectToolingAllowed } from "../core/projectTooling.js";
 import { hasCppSources } from "../ecosystems/cppEvidence.js";
 import {
@@ -42,6 +43,7 @@ import {
   kosiWorkspaceComponent,
   mergeKosiEvidence,
 } from "../ecosystems/kosi.js";
+import { keepResolvedNpmVersions } from "../ecosystems/npmVersionResolution.js";
 import {
   analyzeRusiProject,
   collectRusiEvidence,
@@ -71,6 +73,10 @@ import {
   findCryptoAlgos,
 } from "../inventory/cbomutils.js";
 import { cmakeBuildDirCandidates } from "../inventory/cmakeBuildDirs.js";
+import {
+  formatReadLossNotice,
+  loadBomForAnalysis,
+} from "../inventory/cyclonedx20.js";
 import { collectMvnDependencies } from "../inventory/deps.js";
 import { mergeServices } from "../inventory/depsUtils.js";
 import {
@@ -86,6 +92,7 @@ import {
   dosaiOmittedSections,
   dosaiReportFileOmittedSections,
   dosaiSectionsCdxgenReads,
+  dosaiSlicesFileIsFresh,
   isDosaiDotnetLanguage,
   normalizeDosaiServiceMap,
   persistDosaiSemanticsReport,
@@ -93,6 +100,10 @@ import {
   readDosaiMethodsReport,
 } from "../inventory/dosai.js";
 import { parseOccurrenceEvidenceLocation } from "../inventory/evidenceUtils.js";
+import {
+  dropSubsumedOccurrenceKeys,
+  occurrenceLocationKey,
+} from "../inventory/occurrenceKey.js";
 import { splitPurlLoose } from "../inventory/purl.js";
 import { executeOsQuery } from "../managers/binary.js";
 import { MAX_JSON_TEXT_BYTES, readJsonFile } from "../parsers/largeJson.js";
@@ -298,6 +309,45 @@ export function buildEvinseOptions(options, args, input) {
   };
 }
 
+/**
+ * Read the evinse input BOM as cdxgen's 1.x-shaped internal model. A
+ * CycloneDX 2.0 document is converted with loadBomForAnalysis; a 1.x document
+ * (or an internal model) is returned as is. When `options.inputBomJson` holds
+ * a model converted earlier, a copy of it is returned instead of reading
+ * `options.input` again, so prepareDB, analyzeProject and createEvinseFile
+ * each get their own object, as they did when each parsed the file.
+ *
+ * @param {Object} options Evinse options with `input` and optional
+ *   `inputBomJson`
+ * @returns {{bomJson: Object, losses: Array<{pointer: string, reason: string}>}}
+ *   The internal model and the losses of the 2.0 read (none when
+ *   `inputBomJson` was given)
+ */
+export function loadEvinseInputBom(options) {
+  if (options?.inputBomJson && typeof options.inputBomJson === "object") {
+    return { bomJson: structuredClone(options.inputBomJson), losses: [] };
+  }
+  const parsedBom = JSON.parse(fs.readFileSync(options.input, "utf8"));
+  const { internalBom, losses } = loadBomForAnalysis(parsedBom);
+  return { bomJson: internalBom, losses };
+}
+
+/**
+ * Print the one-line notice for the losses of reading a 2.0 evinse input,
+ * with the details in thoughtLog.
+ *
+ * @param {Array<{pointer: string, reason: string}>} losses Reader losses
+ */
+export function reportEvinseInputLosses(losses) {
+  if (!losses?.length) {
+    return;
+  }
+  console.log(formatReadLossNotice(losses));
+  for (const loss of losses) {
+    thoughtLog(`evinse 2.0 loss at ${loss.pointer}: ${loss.reason}`);
+  }
+}
+
 /**
  * Function to create the db for the libraries referred in the sbom.
  *
@@ -317,7 +367,7 @@ export async function prepareDB(options) {
     }
     return;
   }
-  const bomJson = JSON.parse(fs.readFileSync(bomJsonFile, "utf8"));
+  const { bomJson } = loadEvinseInputBom(options);
   if (bomJson.specVersion < 1.5) {
     console.log(
       "Evinse requires the input SBOM in CycloneDX 1.5 format or above. You can generate one by invoking cdxgen without any --spec-version argument.",
@@ -845,15 +895,18 @@ export function purlToLanguage(purl, filePath) {
  * Walks the supplied components reading `internal:ImportedModules` (or
  * `internal:Namespaces` for php/ruby, plus the `internal:ImportedSymbols` the
  * C/C++ collector records) and `evidence.occurrences` properties to construct
- * lookup maps used during slice analysis.
+ * lookup maps used during slice analysis. An occurrence that carries `offset`
+ * or `symbol` seeds those too, so a re-run over a previous evinse output keys
+ * and annotates the same use sites the fresh slice adds.
  *
  * @param {Object[]} components CycloneDX components from the input SBOM
  * @param {string} language Application language used to select the import property name
- * @returns {{ purlLocationMap: Object<string, Set>, purlImportsMap: Object<string, string[]> }} Seeded purl location and import maps
+ * @returns {{ purlLocationMap: Object<string, Set>, purlImportsMap: Object<string, string[]>, purlSymbolMap: Object<string, Object<string, string>> }} Seeded purl location, import and symbol maps
  */
 export function initFromSbom(components, language) {
   const purlLocationMap = {};
   const purlImportsMap = {};
+  const purlSymbolMap = {};
   for (const comp of components) {
     if (!comp?.evidence) {
       continue;
@@ -886,17 +939,30 @@ export function initFromSbom(components, language) {
     if (comp.evidence.occurrences) {
       // Keep the `location#line` shape so a re-run over a cdxgen BOM does not
       // degrade seeded occurrences to file-only entries and duplicate the
-      // richer locations the fresh slice merge adds to the same set.
+      // richer locations the fresh slice merge adds to the same set. The key
+      // function also writes the location with `/`, so a Windows BOM's
+      // backslash spelling and a slice's forward-slash spelling of one place
+      // are one occurrence.
       purlLocationMap[comp.purl] = new Set(
-        comp.evidence.occurrences.map((v) =>
-          v.line ? `${v.location}#${v.line}` : v.location,
-        ),
+        comp.evidence.occurrences
+          .map((v) => occurrenceLocationKey(v.location, v.line, v.offset))
+          .filter(Boolean),
       );
+      // The first symbol a key carries wins, so a line two records without a
+      // column share keeps one symbol across a re-run over this output.
+      const symbols = (purlSymbolMap[comp.purl] ??= {});
+      for (const v of comp.evidence.occurrences) {
+        const key = occurrenceLocationKey(v.location, v.line, v.offset);
+        if (v.symbol && key && symbols[key] === undefined) {
+          symbols[key] = v.symbol;
+        }
+      }
     }
   }
   return {
     purlLocationMap,
     purlImportsMap,
+    purlSymbolMap,
   };
 }
 
@@ -1250,7 +1316,7 @@ export async function analyzeProject(dbObjMap, options) {
   let retMap = {};
   let userDefinedTypesMap = {};
   const bomFile = options.input;
-  const bomJson = JSON.parse(fs.readFileSync(bomFile, "utf8"));
+  const { bomJson } = loadEvinseInputBom(options);
   const components = bomJson.components || [];
   let cryptoComponents = [];
   let aiComponents = [];
@@ -1258,7 +1324,22 @@ export async function analyzeProject(dbObjMap, options) {
   let openapiSpecFile;
   // Load any existing purl-location information from the sbom.
   // For eg: cdxgen populates this information for javascript projects
-  let { purlLocationMap, purlImportsMap } = initFromSbom(components, language);
+  let { purlLocationMap, purlImportsMap, purlSymbolMap } = initFromSbom(
+    components,
+    language,
+  );
+  // purls whose input occurrences all belong to another installed version
+  let clearedOccurrencePurls = new Set();
+  // The places the input BOM's own import evidence gives each npm version,
+  // before any slice adds to them: they say which version a file uses.
+  const seededJsLocationMap = JS_LANGUAGES.includes(language)
+    ? Object.fromEntries(
+        Object.entries(purlLocationMap).map(([purl, keys]) => [
+          purl,
+          new Set(keys),
+        ]),
+      )
+    : {};
 
   if (isGolemGoLanguage(language)) {
     const golemReport = analyzeGolemProject(dirPath, options);
@@ -1277,6 +1358,7 @@ export async function analyzeProject(dbObjMap, options) {
         cryptoGeneratePurls: golemEvidence.cryptoGeneratePurls,
         servicesMap,
         userDefinedTypesMap,
+        purlSymbolMap,
       };
     }
     return {
@@ -1284,6 +1366,7 @@ export async function analyzeProject(dbObjMap, options) {
       servicesMap,
       dataFlowFrames,
       userDefinedTypesMap,
+      purlSymbolMap,
     };
   }
 
@@ -1303,6 +1386,7 @@ export async function analyzeProject(dbObjMap, options) {
         cryptoGeneratePurls: rusiEvidence.cryptoGeneratePurls,
         servicesMap,
         userDefinedTypesMap,
+        purlSymbolMap,
       };
     }
     return {
@@ -1310,6 +1394,7 @@ export async function analyzeProject(dbObjMap, options) {
       servicesMap,
       dataFlowFrames,
       userDefinedTypesMap,
+      purlSymbolMap,
     };
   }
 
@@ -1381,6 +1466,7 @@ export async function analyzeProject(dbObjMap, options) {
         servicesMap,
         userDefinedTypesMap,
         workspaceComponent,
+        purlSymbolMap,
       };
     }
     return {
@@ -1388,6 +1474,7 @@ export async function analyzeProject(dbObjMap, options) {
       servicesMap,
       dataFlowFrames,
       userDefinedTypesMap,
+      purlSymbolMap,
     };
   }
 
@@ -1449,6 +1536,17 @@ export async function analyzeProject(dbObjMap, options) {
             `The dosai deps slices file "${options.depsSlicesFile}" omits sections (${omittedSections.join(", ")}); running dosai for the full usages report.`,
           );
         }
+      } else if (
+        !dosaiSlicesFileIsFresh(options.depsSlicesFile, dirPath, options)
+      ) {
+        // A slice older than the sources it describes holds the occurrences
+        // of the sources as they were when it was written, so reusing it
+        // keeps occurrences of call sites that no longer exist (issue 4675).
+        if (DEBUG_MODE) {
+          console.log(
+            `The dosai deps slices file "${options.depsSlicesFile}" is older than the sources it describes; running dosai for a fresh usages report.`,
+          );
+        }
       } else {
         if (DEBUG_MODE) {
           console.log(
@@ -1546,6 +1644,7 @@ export async function analyzeProject(dbObjMap, options) {
       cryptoComponents,
       aiComponents,
       cryptoGeneratePurls,
+      purlSymbolMap,
     };
   }
   // Do reachables first so that usages slicing can reuse the atom file
@@ -1695,8 +1794,21 @@ export async function analyzeProject(dbObjMap, options) {
       }
     }
     if (callsitesSlice?.callsites?.length) {
-      attributeJsCallsites(callsitesSlice, purlImportsMap, purlLocationMap);
+      attributeJsCallsites(
+        callsitesSlice,
+        purlImportsMap,
+        purlLocationMap,
+        purlSymbolMap,
+      );
     }
+    // A slice record names a package, not a version: keep each occurrence on
+    // the installed version its file uses.
+    clearedOccurrencePurls = keepResolvedNpmVersions(
+      purlLocationMap,
+      purlSymbolMap,
+      seededJsLocationMap,
+      bomJson,
+    );
   }
   // A component whose calls the slices do not show (code inside the project,
   // such as a vendored library) is still used where its header is included
@@ -1771,6 +1883,8 @@ export async function analyzeProject(dbObjMap, options) {
     reachablesSlicesFile,
     semanticsSlicesFile,
     purlLocationMap,
+    purlSymbolMap,
+    clearedOccurrencePurls,
     servicesMap,
     dataFlowFrames,
     tempDir: retMap?.tempDir,
@@ -1877,11 +1991,7 @@ export function attributeCIncludes(
       continue;
     }
     const known = locations.get(purl) || new Set();
-    known.add(
-      slice.lineNumber
-        ? `${slice.fileName}#${slice.lineNumber}`
-        : slice.fileName,
-    );
+    known.add(occurrenceLocationKey(slice.fileName, slice.lineNumber));
     locations.set(purl, known);
   }
   return { symbols, locations };
@@ -2284,7 +2394,7 @@ export function parseSemanticSlices(_language, components, semanticsSlice) {
             continue;
           }
           for (const aline of lines) {
-            locations.add(`${aswiftFile}#${aline}`);
+            locations.add(occurrenceLocationKey(aswiftFile, aline));
           }
         }
       }
@@ -2294,7 +2404,7 @@ export function parseSemanticSlices(_language, components, semanticsSlice) {
         fileIndexes,
       )) {
         for (const aline of ahit.lineNumbers) {
-          locations.add(`${ahit.file}#${aline}`);
+          locations.add(occurrenceLocationKey(ahit.file, aline));
         }
       }
     }
@@ -2958,8 +3068,11 @@ export function indexVersionlessCrypto(cryptoGeneratePurls) {
  * Method to create the SBOM with evidence file called evinse file.
  *
  * @param {Object} sliceArtefacts Various artefacts from the slice operation
- * @param {Object} options Command line options
- * @returns
+ * @param {Object} options Command line options. With `returnInternalModel`,
+ *   a CycloneDX 2.0 run returns the 1.x-shaped internal model instead of the
+ *   rendered document; the file written is the rendered document either way.
+ * @returns {Promise<Object>} The BOM written to the output file, or its
+ *   internal model when `returnInternalModel` is set
  */
 export async function createEvinseFile(sliceArtefacts, options) {
   const {
@@ -2969,6 +3082,8 @@ export async function createEvinseFile(sliceArtefacts, options) {
     dataFlowSlicesFile,
     reachablesSlicesFile,
     purlLocationMap,
+    purlSymbolMap = {},
+    clearedOccurrencePurls,
     servicesMap,
     dataFlowFrames,
     componentPropertiesMap = {},
@@ -2978,9 +3093,13 @@ export async function createEvinseFile(sliceArtefacts, options) {
     cryptoGeneratePurls,
     workspaceComponent,
   } = sliceArtefacts;
-  const bomFile = options.input;
   const evinseOutFile = options.output;
-  const bomJson = JSON.parse(fs.readFileSync(bomFile, "utf8"));
+  // A 2.0 input is read into the 1.x internal model; everything below works
+  // on the 1.x shape and the final postProcess renders 2.0 again. A caller
+  // that converted the input already (bin/evinse.js) passes the model as
+  // `inputBomJson` and has printed the losses.
+  const { bomJson, losses: bomLosses } = loadEvinseInputBom(options);
+  reportEvinseInputLosses(bomLosses);
   const components = bomJson.components || [];
   // Clear existing annotations
   bomJson.annotations = [];
@@ -3020,19 +3139,40 @@ export async function createEvinseFile(sliceArtefacts, options) {
     }
     delete comp.signature;
     appendComponentProperties(comp, componentPropertiesMap[comp.purl]);
-    const locationOccurrences = Array.from(
-      purlLocationMap[comp.purl] || [],
-    ).sort();
+    // A key with an offset names a use site; the line-only key of the same
+    // line names no place of its own then, so it is dropped rather than
+    // counted beside the use sites (see dropSubsumedOccurrenceKeys).
+    const locationOccurrences = dropSubsumedOccurrenceKeys(
+      Array.from(purlLocationMap[comp.purl] || [])
+        .filter(Boolean)
+        .sort(),
+    );
     if (locationOccurrences.length) {
       if (!comp.evidence) {
         comp.evidence = {};
       }
       // This step would replace any existing occurrences
       // This is fine as long as the input sbom was also generated by cdxgen
-      comp.evidence.occurrences = locationOccurrences
-        .filter((l) => !!l)
-        .map((l) => parseOccurrenceEvidenceLocation(l));
+      // A callsites occurrence carries its column as `offset` and its member
+      // as `symbol`; an occurrence from any other source has neither.
+      const symbols = purlSymbolMap[comp.purl] || {};
+      comp.evidence.occurrences = locationOccurrences.map((l) =>
+        parseOccurrenceEvidenceLocation(
+          l,
+          symbols[l] ? { symbol: symbols[l] } : {},
+        ),
+      );
       occEvidencePresent = true;
+    } else if (
+      clearedOccurrencePurls?.has(comp.purl) &&
+      comp.evidence?.occurrences
+    ) {
+      // The input BOM credited this version with places another installed
+      // version of the package takes.
+      delete comp.evidence.occurrences;
+      if (!Object.keys(comp.evidence).length) {
+        delete comp.evidence;
+      }
     }
     const compKey = versionlessPurlKey(comp.purl);
     let dfFrames = dataFlowFrames[comp.purl];
@@ -3147,9 +3287,10 @@ export async function createEvinseFile(sliceArtefacts, options) {
   // Redo post-processing with evinse data. `executeOsQuery` has to be injected
   // because postgen no longer imports it directly (stages is below managers);
   // without it the crypto formulation path receives `undefined` and throws.
+  const { inputBomJson: _inputBomJson, ...postProcessOptions } = options;
   const bomNSData = await postProcess(
     { bomJson },
-    { ...options, executeOsQuery },
+    { ...postProcessOptions, executeOsQuery },
   );
   safeWriteSync(
     evinseOutFile,
@@ -3190,6 +3331,9 @@ export async function createEvinseFile(sliceArtefacts, options) {
   if (tempDirOwned && tempDir?.startsWith(getTmpDir())) {
     safeRmSync(tempDir, { recursive: true, force: true });
   }
+  if (options.returnInternalModel && bomNSData?.internalBomJson) {
+    return bomNSData.internalBomJson;
+  }
   return bomNSData?.bomJson;
 }
 
@@ -3653,7 +3797,7 @@ export function attributeJsModules(
       if (!purlLocationMap[apurl]) {
         purlLocationMap[apurl] = new Set();
       }
-      purlLocationMap[apurl].add(`${fileName}#${line}`);
+      purlLocationMap[apurl].add(occurrenceLocationKey(fileName, line));
     }
   };
   const calls = []
@@ -3683,17 +3827,23 @@ export function attributeJsModules(
  * Attribute a callsites slice's records to the packages providing their modules.
  *
  * Each record of `{"callsites": [...]}` (atom `callsites` command) is one external use site
- * carrying its own file and line; the record is an occurrence of every purl whose package
- * matches the record's module.
+ * carrying its own file, line and column; the record is an occurrence of every purl whose
+ * package matches the record's module. A record with a column (0 or more; atom writes -1 for
+ * none) is keyed `file:line:col`, so two use sites on one line are two occurrences, and its
+ * occurrence carries the column as `offset` and `module` joined with `path` by `.` as
+ * `symbol`. A record without a column keys the line (`file#line`) and its occurrence carries
+ * the `symbol` alone; a record without a `path` leaves the symbol at the bare `module`.
  *
  * @param {Object} callsitesSlice callsites slice with a `callsites` array
  * @param {Object} purlImportsMap purl -> imported modules and symbols
- * @param {Object} purlLocationMap purl -> Set of `file#line`
+ * @param {Object} purlLocationMap purl -> Set of occurrence keys
+ * @param {Object} [purlSymbolMap] purl -> occurrence key -> symbol, filled in place
  */
 export function attributeJsCallsites(
   callsitesSlice,
   purlImportsMap,
   purlLocationMap,
+  purlSymbolMap = {},
 ) {
   const byPackage = jsPurlsByPackage(purlImportsMap);
   for (const record of callsitesSlice?.callsites || []) {
@@ -3701,11 +3851,23 @@ export function attributeJsCallsites(
     if (!pkg || !(record.line > 0)) {
       continue;
     }
+    const key = occurrenceLocationKey(record.file, record.line, record.col);
+    const symbol = record.path
+      ? `${record.module}.${record.path}`
+      : record.module;
     for (const apurl of byPackage[pkg] || []) {
       if (!purlLocationMap[apurl]) {
         purlLocationMap[apurl] = new Set();
       }
-      purlLocationMap[apurl].add(`${record.file}#${record.line}`);
+      purlLocationMap[apurl].add(key);
+      // The first symbol a key carries wins, so a re-run over a previous
+      // output, which seeds the symbol the first run wrote, stays stable.
+      if (symbol) {
+        const symbols = (purlSymbolMap[apurl] ??= {});
+        if (symbols[key] === undefined) {
+          symbols[key] = symbol;
+        }
+      }
     }
   }
 }
@@ -3714,5 +3876,5 @@ function addToOverrides(lKeyOverrides, atype, fileName, ausageLineNumber) {
   if (!lKeyOverrides[atype]) {
     lKeyOverrides[atype] = new Set();
   }
-  lKeyOverrides[atype].add(`${fileName}#${ausageLineNumber}`);
+  lKeyOverrides[atype].add(occurrenceLocationKey(fileName, ausageLineNumber));
 }

package/lib/evinser/scalasem.js

@@ -1,3 +1,5 @@
+import { occurrenceLocationKey } from "../inventory/occurrenceKey.js";
+
 function buildNSCache(components) {
   const typePurlsCache = {};
   for (const comp of components) {
@@ -52,7 +54,9 @@ export function findPurlLocations(components, semanticsSlice) {
           if (!purlLocationsSet[apurl]) {
             purlLocationsSet[apurl] = new Set();
           }
-          purlLocationsSet[apurl].add(values.sourceFile || key);
+          purlLocationsSet[apurl].add(
+            occurrenceLocationKey(values.sourceFile || key),
+          );
         }
       }
     }

package/lib/helpers/agenticToolutils.js

@@ -10,6 +10,10 @@ import { readUserFileText } from "../core/boundedFile.js";
 import { safeExistsSync } from "../core/fs.js";
 import { isMac, isWin, redactHomePath } from "../core/paths.js";
 import { parseToml } from "../core/toml.js";
+import {
+  kiroPermissionSummaryEntries,
+  summarizeKiroPermissions,
+} from "../parsers/kiroPermissions.js";
 import { findIdeProductInfo, IDE_PRODUCTS } from "./vsixutils.js";
 
 export { redactHomePath };
@@ -109,6 +113,7 @@ export function getAgenticToolDirs(home = homedir()) {
         join(home, ".kiro", "sessions", "cli"),
       ],
       homeDir: join(home, ".kiro"),
+      mcpConfigs: [{ file: join("settings", "mcp.json"), key: "mcpServers" }],
       supportDirs: isWin
         ? [join(appData, "kiro-cli")]
         : isMac
@@ -361,6 +366,28 @@ function parseJsonFile(filePath) {
   }
 }
 
+/**
+ * Read a small YAML settings file, such as a Kiro permissions document,
+ * through the bounded user-file reader. A file that exists but holds no
+ * document, such as an empty or comment-only permissions file, reads as an
+ * empty object so its presence still counts.
+ *
+ * @param {string} filePath Absolute file path
+ * @returns {Object|undefined} Parsed document, or undefined when the file is
+ *   missing, unreadable, or malformed
+ */
+function parseYamlFile(filePath) {
+  try {
+    const raw = readConfigText(filePath);
+    if (typeof raw !== "string") {
+      return undefined;
+    }
+    return loadYaml(raw) || {};
+  } catch {
+    return undefined;
+  }
+}
+
 /**
  * Strip `//` line comments, block comments, and trailing commas from JSONC
  * text.
@@ -556,6 +583,58 @@ function readToolVersion(tool, dir, supportDir) {
   return undefined;
 }
 
+/**
+ * Collect the workspace-scope permission counts under
+ * `~/.kiro/workspace-roots/<hash>/permissions.yaml`. Only counts and booleans
+ * are returned; the hash-named directories, the file paths, and the rule
+ * match patterns stay out of the result.
+ *
+ * @param {string} dir Kiro home directory
+ * @returns {{workspacePermissionFileCount?: number, trustedWorkspaceCount?: number, workspaceWithAllowRuleCount?: number}}
+ *   Aggregate workspace posture counts
+ */
+function countKiroWorkspacePermissions(dir) {
+  const rootsDir = join(dir, "workspace-roots");
+  if (!safeExistsSync(rootsDir)) {
+    return {};
+  }
+  let entries = [];
+  try {
+    entries = readdirSync(rootsDir, { withFileTypes: true });
+  } catch {
+    return {};
+  }
+  let fileCount = 0;
+  let trustedCount = 0;
+  let withAllowRuleCount = 0;
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const permissionsPath = join(rootsDir, entry.name, "permissions.yaml");
+    const doc = parseYamlFile(permissionsPath);
+    if (doc === undefined) {
+      continue;
+    }
+    fileCount += 1;
+    const summary = summarizeKiroPermissions(doc);
+    if (summary.workspaceTrusted === true) {
+      trustedCount += 1;
+    }
+    if (summary.allowRuleCount > 0) {
+      withAllowRuleCount += 1;
+    }
+  }
+  if (!fileCount) {
+    return {};
+  }
+  return {
+    trustedWorkspaceCount: trustedCount,
+    workspacePermissionFileCount: fileCount,
+    workspaceWithAllowRuleCount: withAllowRuleCount,
+  };
+}
+
 function countKiroSignals(dir, supportDir) {
   const signals = {};
   const agentsDir = join(dir, "agents");
@@ -578,6 +657,17 @@ function countKiroSignals(dir, supportDir) {
   if (settings && typeof settings["chat.defaultAgent"] === "string") {
     signals.defaultAgent = settings["chat.defaultAgent"];
   }
+  // The V3 user-scope permission posture from ~/.kiro/settings/permissions.yaml.
+  const userPermissions = parseYamlFile(
+    join(dir, "settings", "permissions.yaml"),
+  );
+  if (userPermissions !== undefined) {
+    Object.assign(
+      signals,
+      kiroPermissionSummaryEntries(summarizeKiroPermissions(userPermissions)),
+    );
+  }
+  Object.assign(signals, countKiroWorkspacePermissions(dir));
   return signals;
 }
 
@@ -954,7 +1044,10 @@ function childBomRef(parentRef, kind, id) {
  * Parse Kiro agent definitions (`~/.kiro/agents/*.json`) into components.
  *
  * Each agent contributes its name, model, and redacted counts of MCP servers,
- * tools, and allowed tools. Prompts and resource values are never copied.
+ * tools, and allowed tools, plus the permission posture of its V3
+ * `permissions` object and the integer `kiroUpgrade` revision. Prompts,
+ * resource values, match patterns, and the upgrade fingerprint or source are
+ * never copied.
  *
  * @param {string} dir Kiro home directory
  * @param {string} parentRef Parent tool bom-ref
@@ -1010,6 +1103,24 @@ function parseKiroAgents(dir, parentRef, home = homedir()) {
         value: String(agent.allowedTools.length),
       });
     }
+    if (agent.permissions && typeof agent.permissions === "object") {
+      for (const [suffix, value] of Object.entries(
+        kiroPermissionSummaryEntries(
+          summarizeKiroPermissions(agent.permissions),
+        ),
+      )) {
+        properties.push({
+          name: `cdx:agentic:${suffix}`,
+          value: String(value),
+        });
+      }
+    }
+    if (Number.isInteger(agent.kiroUpgrade?.revision)) {
+      properties.push({
+        name: "cdx:agentic:upgradeRevision",
+        value: String(agent.kiroUpgrade.revision),
+      });
+    }
     components.push({
       "bom-ref": childBomRef(parentRef, "agent", agent.name),
       type: "application",