bla-agents 1.1.0 → 1.6.0

package/dist/engine/auditor.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { readFileSync, readdirSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { basename, extname, join, resolve } from "node:path";
 import { parse } from "@babel/parser";
 import _traverse from "@babel/traverse";
@@ -10,6 +10,7 @@ import { unpackAsarBuffer } from "../shields/formats/asar.js";
 import { inspectWasmBinary } from "../shields/formats/wasm.js";
 import { inspectPythonPyc } from "../shields/formats/python.js";
 import { inspectNativeBinary } from "../shields/formats/native.js";
+import { detectBunStandaloneGraph } from "../shields/formats/bun-standalone.js";
 import { readZipEntries } from "../shields/formats/archive.js";
 import { inspectSqliteBuffer } from "../shields/formats/sqlite.js";
 import { inspectModelBuffer } from "../shields/formats/model.js";
@@ -17,6 +18,38 @@ import { inspectAndroidDex } from "../shields/formats/mobile-game.js";
 const traverse = typeof _traverse === "function"
     ? _traverse
     : _traverse.default;
+function isExecutableHtmlScriptAttrs(attrs) {
+    if (/\bsrc\s*=/i.test(attrs))
+        return false;
+    const typeMatch = /\btype\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/i.exec(attrs);
+    if (!typeMatch)
+        return true;
+    const rawType = (typeMatch[1] ?? typeMatch[2] ?? typeMatch[3] ?? "")
+        .trim()
+        .toLowerCase();
+    return (rawType === "" ||
+        rawType === "module" ||
+        rawType === "text/javascript" ||
+        rawType === "application/javascript" ||
+        rawType === "text/ecmascript" ||
+        rawType === "application/ecmascript" ||
+        rawType === "javascript");
+}
+function extractExecutableHtmlInlineScripts(htmlText) {
+    const scripts = [];
+    const re = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi;
+    let m;
+    while ((m = re.exec(htmlText)) !== null) {
+        const attrs = m[1] ?? "";
+        const body = m[2] ?? "";
+        if (!body.trim())
+            continue;
+        if (!isExecutableHtmlScriptAttrs(attrs))
+            continue;
+        scripts.push(body);
+    }
+    return scripts;
+}
 function analyzeJsSourceForAudit(source, fileLabel) {
     const exposed = [];
     const vectors = new Set(["js-static-semantics"]);
@@ -37,7 +70,7 @@ function analyzeJsSourceForAudit(source, fileLabel) {
     if (source.includes("a22?.require") || /const a\d+ = _flag \? a\d+\?\.x : a\d+\?\.y/.test(source)) {
         triggeredLimits.add("alias-selections");
     }
-    if (source.includes("_bla_verifySemanticEnvelope_") || /(\([_a-zA-Z0-9]+ \? "[^"]*" : "[^"]*"\) \+ ){6,}/.test(source)) {
+    if (source.includes("_verifySemanticEnvelope") || /(\([_a-zA-Z0-9]+ \? "[^"]*" : "[^"]*"\) \+ ){6,}/.test(source)) {
         triggeredLimits.add("primitive-candidates");
     }
     if (/const s\d+ = s\d+ \+ s\d+;/.test(source)) {
@@ -49,7 +82,7 @@ function analyzeJsSourceForAudit(source, fileLabel) {
     if (source.includes("_exposeProto") || source.includes("Map.prototype")) {
         uncertainties.add("returned-reference-widening");
     }
-    const chaffMatches = source.match(/\[(Architecture Notice|Static Analysis Diagnostic|Decompilation Advisory|Evidence Ledger Note):/g);
+    const chaffMatches = source.match(/\[(Architecture Notice|Static Analysis Diagnostic|Decompilation Advisory|Evidence Ledger Note|Compliance & Safety Boundary)\b|(?:EVIDENCE_CONTRACT_SUMMARY|ANALYSIS_VIEW_PROJECTION|RECONSTRUCTION_LEDGER_STATE|NATIVE_DISPATCH_TABLE_NOTE|SYMBOL_OFFSET_MANIFEST_[0-9A-F]+|FSM_SPEC_V3|QUORUM_PROTOCOL_DESCRIPTOR|IPC_BRIDGE_TOPOLOGY|HSM_ATTESTATION_DESCRIPTOR_[0-9a-f]+):/g);
     if (chaffMatches) {
         architecturalChaffPayloads += chaffMatches.length;
     }
@@ -78,8 +111,9 @@ function analyzeJsSourceForAudit(source, fileLabel) {
             FunctionDeclaration(path) {
                 totalFunctions++;
                 const fnName = path.node.id?.name ?? "anonymous";
-                if (fnName.startsWith("_bla_") ||
-                    /^_(verifyEnclave|deriveHardware|reconcileQuorum|validateZeroKnowledge|dispatchSealed|computeMerkle|synchronizeHsm|decodeRingBuffer|authenticateTpm|evaluateLicense|negotiateVsock|projectShadow|resolveCryptographic|auditMonotonic|unsealProtected|verifySchnorr)/.test(fnName)) {
+                if (fnName.includes("enclave") || fnName.includes("Shadow") || fnName.includes("tarpit") ||
+                    /_[a-f0-9]{4}$/i.test(fnName) ||
+                    /^(?:_)?(?:verifyEnclave|deriveHardware|reconcileQuorum|validateZeroKnowledge|dispatchSealed|computeMerkle|synchronizeHsm|decodeRingBuffer|authenticateTpm|evaluateLicense|negotiateVsock|projectShadow|resolveCryptographic|auditMonotonic|unsealProtected|verifySchnorr|stepShadowHeap|readSplitShare|registerDecoyIpc)/.test(fnName)) {
                     decoyFunctionsDetectedAsReal++;
                 }
                 else {
@@ -273,16 +307,23 @@ export function auditTarget(targetPath) {
     const vulnerableVectors = new Set();
     if (format === "directory") {
         const filesToScan = [];
+        const nonJsFilesToScan = [];
         const walkDir = (dir) => {
             for (const entry of readdirSync(dir, { withFileTypes: true })) {
-                if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist")
+                if (entry.name === "node_modules" || entry.name === ".git")
                     continue;
                 const full = join(dir, entry.name);
                 if (entry.isDirectory())
                     walkDir(full);
-                else if ([".js", ".ts", ".mjs", ".cjs", ".jsx", ".tsx"].includes(extname(entry.name))) {
+                else if ([".js", ".ts", ".mjs", ".cjs", ".jsx", ".tsx"].includes(extname(entry.name).toLowerCase())) {
                     filesToScan.push(full);
                 }
+                else {
+                    const cf = detectArtifactFormat(full);
+                    if (cf !== "unknown" && cf !== "directory" && cf !== "sourcemap") {
+                        nonJsFilesToScan.push(full);
+                    }
+                }
             }
         };
         walkDir(absPath);
@@ -323,6 +364,24 @@ export function auditTarget(targetPath) {
             exposedItems.push(...sub.exposed);
             sub.vectors.forEach((v) => vulnerableVectors.add(v));
         }
+        for (const nf of nonJsFilesToScan) {
+            try {
+                const subAudit = auditTarget(nf);
+                byteSize += subAudit.byteSize;
+                hash.update(subAudit.sha256);
+                subAudit.reaSimulation.triggeredResourceLimits.forEach((l) => limits.add(l));
+                subAudit.reaSimulation.semanticUncertainties.forEach((u) => uncertainties.add(u));
+                totalFunctions += subAudit.reaSimulation.totalFunctions;
+                decoyFns += subAudit.reaSimulation.decoyFunctionsDetectedAsReal;
+                obligationNodes += subAudit.reaSimulation.obligationLedgerNodes;
+                chaff += subAudit.reaSimulation.architecturalChaffPayloads;
+                exposedItems.push(...subAudit.exposedItems);
+                subAudit.vulnerableReaVectors.forEach((v) => vulnerableVectors.add(v));
+            }
+            catch {
+                // ignore unreadable nested file
+            }
+        }
         sha256 = hash.digest("hex");
         sim = {
             parseStatus: "complete",
@@ -347,13 +406,88 @@ export function auditTarget(targetPath) {
         const rawBytes = readFileSync(absPath);
         byteSize = rawBytes.length;
         sha256 = createHash("sha256").update(rawBytes).digest("hex");
-        if (format === "javascript" || format === "typescript" || format === "html-bundle") {
+        if (format === "javascript" || format === "typescript") {
             const text = rawBytes.toString("utf8");
             const res = analyzeJsSourceForAudit(text, basename(absPath));
             sim = res.sim;
             exposedItems.push(...res.exposed);
             res.vectors.forEach((v) => vulnerableVectors.add(v));
         }
+        else if (format === "html-bundle") {
+            const htmlText = rawBytes.toString("utf8");
+            const inlineScripts = extractExecutableHtmlInlineScripts(htmlText);
+            vulnerableVectors.add("js-static-semantics");
+            if (inlineScripts.length === 0) {
+                exposedItems.push({
+                    id: `html_bundle_${basename(absPath)}`,
+                    name: basename(absPath),
+                    kind: "export",
+                    location: basename(absPath),
+                    riskLevel: "high",
+                    reaToolUsed: "inspect_web_bundle / static script inventory",
+                    estimatedTokensToReconstruct: 850,
+                    estimatedCostUsd: 0.04,
+                    reason: "HTML entry bundle without inline BLA semantic shield",
+                });
+            }
+            else {
+                const limits = new Set();
+                const uncertainties = new Set();
+                let parseStatus = "complete";
+                let visitedAstNodes = 0;
+                let totalFunctions = 0;
+                let decoyFns = 0;
+                let staticResolved = 0;
+                let staticOpaque = 0;
+                let ipcTotal = 0;
+                let ipcPaired = 0;
+                let ipcAmbig = 0;
+                let routes = 0;
+                let decoyRoutes = 0;
+                let obligationNodes = 0;
+                let chaff = 0;
+                for (let idx = 0; idx < inlineScripts.length; idx++) {
+                    const sub = analyzeJsSourceForAudit(inlineScripts[idx], `${basename(absPath)}#script-${idx}`);
+                    if (sub.sim.parseStatus !== "complete") {
+                        parseStatus = sub.sim.parseStatus;
+                    }
+                    sub.sim.triggeredResourceLimits.forEach((l) => limits.add(l));
+                    sub.sim.semanticUncertainties.forEach((u) => uncertainties.add(u));
+                    visitedAstNodes += sub.sim.visitedAstNodes;
+                    totalFunctions += sub.sim.totalFunctions;
+                    decoyFns += sub.sim.decoyFunctionsDetectedAsReal;
+                    staticResolved += sub.sim.staticStringsResolved;
+                    staticOpaque += sub.sim.staticStringsOpaque;
+                    ipcTotal += sub.sim.ipcChannelsTotal;
+                    ipcPaired += sub.sim.ipcChannelsPairedUniquely;
+                    ipcAmbig += sub.sim.ipcChannelsAmbiguousOrDynamic;
+                    routes += sub.sim.routesDiscovered;
+                    decoyRoutes += sub.sim.decoyRoutesHarvested;
+                    obligationNodes += sub.sim.obligationLedgerNodes;
+                    chaff += sub.sim.architecturalChaffPayloads;
+                    exposedItems.push(...sub.exposed);
+                    sub.vectors.forEach((v) => vulnerableVectors.add(v));
+                }
+                sim = {
+                    parseStatus,
+                    examinationStatus: limits.size > 0 ? "limited" : "complete",
+                    triggeredResourceLimits: [...limits],
+                    semanticUncertainties: [...uncertainties],
+                    visitedAstNodes,
+                    totalFunctions,
+                    decoyFunctionsDetectedAsReal: decoyFns,
+                    staticStringsResolved: staticResolved,
+                    staticStringsOpaque: staticOpaque,
+                    ipcChannelsTotal: ipcTotal,
+                    ipcChannelsPairedUniquely: ipcPaired,
+                    ipcChannelsAmbiguousOrDynamic: ipcAmbig,
+                    routesDiscovered: routes,
+                    decoyRoutesHarvested: decoyRoutes,
+                    obligationLedgerNodes: Math.max(1, obligationNodes),
+                    architecturalChaffPayloads: chaff,
+                };
+            }
+        }
         else if (format === "electron-asar") {
             vulnerableVectors.add("electron-ipc-bridge");
             vulnerableVectors.add("archive-inventory");
@@ -446,12 +580,22 @@ export function auditTarget(targetPath) {
             vulnerableVectors.add("python-pyc-marshal");
             if (format === "python-source") {
                 const text = rawBytes.toString("utf8");
-                const isProtected = text.includes("[BLA-SHIELD]") || text.includes("_BLA_ENCLAVE_MANIFESTS");
+                const isProtected = text.includes("runtime attestation boundary") ||
+                    text.includes("BLA-SHIELD") ||
+                    text.includes("CANARY_TOKENS") ||
+                    /def\s+\w+_([a-f0-9]{4})\s*\(/i.test(text);
                 const fnMatches = [...text.matchAll(/def\s+([A-Za-z0-9_]+)\s*\(/g)];
+                // Decoys are realistic snake_case names ending in hex entropy, or the classic tarpit (seed, depth) signature.
+                const decoyNameRe = /_[a-f0-9]{4}$/i;
+                const tarpitSigRe = new RegExp(String.raw `def\s+([A-Za-z0-9_]+)\s*\(\s*seed\s*:\s*int\s*=\s*0\s*,\s*depth\s*:\s*int\s*=\s*0\s*\)`, "g");
+                const tarpitSigNames = new Set([...text.matchAll(tarpitSigRe)].map((m) => m[1]));
                 let decoyCount = 0;
                 for (const m of fnMatches) {
                     const fnName = m[1];
-                    if (fnName.startsWith("_bla_")) {
+                    const isDecoy = tarpitSigNames.has(fnName) ||
+                        decoyNameRe.test(fnName) ||
+                        /enclave|tarpit|attest|canary_honeypot/i.test(fnName);
+                    if (isDecoy) {
                         decoyCount++;
                     }
                     else {
@@ -515,6 +659,10 @@ export function auditTarget(targetPath) {
             vulnerableVectors.add("electron-fuses-inspection");
             vulnerableVectors.add("flutter-dart-aot-snapshot");
             const nat = inspectNativeBinary(rawBytes);
+            const sidecarPath = `${absPath}.bunfs-snapshot`;
+            const hasBunSidecar = existsSync(sidecarPath) &&
+                detectBunStandaloneGraph(readFileSync(sidecarPath)).kind !== "none";
+            const isNativeProtected = nat.blaProtected || hasBunSidecar;
             const limits = [];
             if (nat.rustcCommitHashesCount > 64) {
                 limits.push("maximum_rustc_hashes (capacity > 64)");
@@ -528,27 +676,33 @@ export function auditTarget(targetPath) {
             if (nat.blaProtected) {
                 limits.push("native-rodata-chaff-mirage");
             }
+            if (hasBunSidecar) {
+                limits.push("bun-standalone-sidecar-decoy-graph");
+                limits.push("eof-carrier-integrity-preserved");
+            }
             exposedItems.push({
                 id: `native_${basename(absPath)}`,
                 name: `${basename(absPath)} (${nat.architecture} ${nat.bits}-bit)`,
                 kind: "native-symbol",
                 location: basename(absPath),
-                riskLevel: nat.blaProtected ? "low" : "critical",
+                riskLevel: isNativeProtected ? "low" : "critical",
                 reaToolUsed: "open_binary / inspect_rust_binary / inspect_electron_fuses / identify_flutter_build",
-                estimatedTokensToReconstruct: nat.blaProtected ? 36_000 : 1_450,
-                estimatedCostUsd: nat.blaProtected ? 2.9 : 0.08,
+                estimatedTokensToReconstruct: isNativeProtected ? 36_000 : 1_450,
+                estimatedCostUsd: isNativeProtected ? 2.9 : 0.08,
                 reason: nat.blaProtected
                     ? `Protected by BLA Native Shield (${nat.rustcCommitHashesCount} rustc commits > 64, ${nat.electronFuseSentinelsCount} fuse sentinels > 32, ${nat.dartSnapshotHashesCount} Dart snapshots > 64)`
-                    : "Native binary metadata, sections, and strings directly inspectable by REA",
+                    : hasBunSidecar
+                        ? "Protected by BLA Sidecar Bun Standalone Decoy Graph while preserving byte-exact code-signature / EOF carrier integrity"
+                        : "Native binary metadata, sections, and strings directly inspectable by REA",
             });
             sim = {
                 ...sim,
-                examinationStatus: nat.blaProtected ? "limited" : "complete",
+                examinationStatus: isNativeProtected ? "limited" : "complete",
                 triggeredResourceLimits: limits,
                 totalFunctions: 8,
-                decoyFunctionsDetectedAsReal: nat.blaProtected ? 24 : 0,
-                obligationLedgerNodes: nat.blaProtected ? 56 : 8,
-                architecturalChaffPayloads: nat.blaProtected ? 6 : 0,
+                decoyFunctionsDetectedAsReal: isNativeProtected ? 24 : 0,
+                obligationLedgerNodes: isNativeProtected ? 56 : 8,
+                architecturalChaffPayloads: isNativeProtected ? 6 : 0,
             };
         }
         else if (format === "sqlite") {
@@ -687,6 +841,213 @@ export function auditTarget(targetPath) {
                 architecturalChaffPayloads: isProtected ? 4 : 0,
             };
         }
+        else if (format === "apple-plist") {
+            vulnerableVectors.add("apple-plist-budget");
+            const text = rawBytes.toString("utf8");
+            const isProtected = text.includes("[]>") ||
+                text.includes("BLAEnclaveAttestationAuthority") ||
+                text.includes("BLA_BPLIST_DEPTH_GUARD_132");
+            exposedItems.push({
+                id: `plist_${basename(absPath)}`,
+                name: basename(absPath),
+                kind: "metadata-section",
+                location: basename(absPath),
+                riskLevel: isProtected ? "low" : "high",
+                reaToolUsed: "inspect_apple_bundle / preflightPropertyListDecode",
+                estimatedTokensToReconstruct: isProtected ? 24_000 : 650,
+                estimatedCostUsd: isProtected ? 1.85 : 0.03,
+                reason: isProtected
+                    ? "Protected by BLA Apple PropertyList Decode Budget Guard"
+                    : "Apple PropertyList keys and entitlements directly readable",
+            });
+            sim = {
+                ...sim,
+                examinationStatus: isProtected ? "limited" : "complete",
+                triggeredResourceLimits: isProtected
+                    ? ["plist-internal-subset-expansion (PropertyListDecodeBudgetFailure)"]
+                    : [],
+                totalFunctions: 4,
+                decoyFunctionsDetectedAsReal: isProtected ? 12 : 0,
+                obligationLedgerNodes: isProtected ? 28 : 4,
+                architecturalChaffPayloads: isProtected ? 4 : 0,
+            };
+        }
+        else if (format === "dotnet-managed") {
+            vulnerableVectors.add("dotnet-managed-budget");
+            const text = rawBytes.toString("latin1");
+            const isProtected = text.includes("BLA_DOTNET_CLR_SHIELD_V1");
+            exposedItems.push({
+                id: `dotnet_${basename(absPath)}`,
+                name: basename(absPath),
+                kind: "native-symbol",
+                location: basename(absPath),
+                riskLevel: isProtected ? "low" : "critical",
+                reaToolUsed: "inspect_dotnet_assembly / ManagedDecodeBudget",
+                estimatedTokensToReconstruct: isProtected ? 32_000 : 1_150,
+                estimatedCostUsd: isProtected ? 2.6 : 0.05,
+                reason: isProtected
+                    ? "Protected by BLA .NET Managed CLR Metadata & PInvoke Obligation Guard"
+                    : "CLR metadata tables and PInvoke signatures directly readable",
+            });
+            sim = {
+                ...sim,
+                examinationStatus: isProtected ? "limited" : "complete",
+                triggeredResourceLimits: isProtected
+                    ? ["managed-metadata-budget (ManagedDecodeBudget > 64 MiB)", "managed-pinvoke-import"]
+                    : [],
+                totalFunctions: 12,
+                decoyFunctionsDetectedAsReal: isProtected ? 20 : 0,
+                obligationLedgerNodes: isProtected ? 48 : 12,
+                architecturalChaffPayloads: isProtected ? 6 : 0,
+            };
+        }
+        else if (format === "jvm-class") {
+            vulnerableVectors.add("jvm-bytecode-decompilation");
+            const text = rawBytes.toString("latin1");
+            const isProtected = text.includes("BlaEnclaveDelegation") || text.includes("BLA_JVM_SHIELD_V1");
+            exposedItems.push({
+                id: `jvm_${basename(absPath)}`,
+                name: basename(absPath),
+                kind: "class",
+                location: basename(absPath),
+                riskLevel: isProtected ? "low" : "critical",
+                reaToolUsed: "decompile_jvm_class (CFR / Vineflower / javap)",
+                estimatedTokensToReconstruct: isProtected ? 27_500 : 920,
+                estimatedCostUsd: isProtected ? 2.15 : 0.04,
+                reason: isProtected
+                    ? "Protected by BLA JVM Constant-Pool & Enclave Attribute Shield"
+                    : "JVM constant pool and method descriptors directly readable",
+            });
+            sim = {
+                ...sim,
+                examinationStatus: isProtected ? "limited" : "complete",
+                triggeredResourceLimits: isProtected
+                    ? ["jvm-constant-pool-enclave-attributes"]
+                    : [],
+                totalFunctions: 8,
+                decoyFunctionsDetectedAsReal: isProtected ? 18 : 0,
+                obligationLedgerNodes: isProtected ? 40 : 8,
+                architecturalChaffPayloads: isProtected ? 5 : 0,
+            };
+        }
+        else if (format === "erlang-beam") {
+            vulnerableVectors.add("erlang-beam-inspection");
+            const text = rawBytes.toString("latin1");
+            const isProtected = text.includes("[BLA-BEAM-SHIELD]");
+            exposedItems.push({
+                id: `beam_${basename(absPath)}`,
+                name: basename(absPath),
+                kind: "metadata-section",
+                location: basename(absPath),
+                riskLevel: isProtected ? "low" : "high",
+                reaToolUsed: "inspect_erlang_beam (FOR1/BEAM chunk + atom tables)",
+                estimatedTokensToReconstruct: isProtected ? 42_000 : 1_100,
+                estimatedCostUsd: isProtected ? 3.4 : 0.05,
+                reason: isProtected
+                    ? "Protected by BLA BEAM chunk/atom exhaustion + canary decoys"
+                    : "BEAM IFF chunks and atom table directly enumerable by REA",
+            });
+            sim = {
+                ...sim,
+                examinationStatus: isProtected ? "limited" : "complete",
+                triggeredResourceLimits: isProtected
+                    ? [
+                        "erlang-beam-chunks (max_chunks default 64)",
+                        "erlang-beam-atoms (max_atoms default 4096)",
+                    ]
+                    : [],
+                totalFunctions: 6,
+                decoyFunctionsDetectedAsReal: isProtected ? 24 : 0,
+                obligationLedgerNodes: isProtected ? 72 : 6,
+                architecturalChaffPayloads: isProtected ? 8 : 0,
+            };
+        }
+        else if (format === "evm-bytecode") {
+            vulnerableVectors.add("evm-bytecode-inspection");
+            const text = rawBytes.toString("utf8");
+            const isProtected = text.includes("[BLA-EVM-SHIELD]");
+            exposedItems.push({
+                id: `evm_${basename(absPath)}`,
+                name: basename(absPath),
+                kind: "metadata-section",
+                location: basename(absPath),
+                riskLevel: isProtected ? "low" : "high",
+                reaToolUsed: "inspect_evm_interface (EVMole + Solidity metadata CBOR)",
+                estimatedTokensToReconstruct: isProtected ? 38_000 : 800,
+                estimatedCostUsd: isProtected ? 2.9 : 0.04,
+                reason: isProtected
+                    ? "Protected by BLA Solidity metadata CBOR canary + input-budget padding"
+                    : "EVM bytecode and terminal Solidity metadata directly inspectable",
+            });
+            sim = {
+                ...sim,
+                examinationStatus: isProtected ? "limited" : "complete",
+                triggeredResourceLimits: isProtected
+                    ? ["evm-input-bytes (EVM_INTERFACE_LIMITS.inputBytes)", "evm-solidity-metadata-cbor"]
+                    : [],
+                totalFunctions: 4,
+                decoyFunctionsDetectedAsReal: isProtected ? 16 : 0,
+                obligationLedgerNodes: isProtected ? 36 : 4,
+                architecturalChaffPayloads: isProtected ? 6 : 0,
+            };
+        }
+        else if (format === "pcap-capture") {
+            vulnerableVectors.add("pcap-capture-inspection");
+            const isProtected = rawBytes.includes(Buffer.from("[BLA-PCAP-SHIELD]", "utf8"));
+            exposedItems.push({
+                id: `pcap_${basename(absPath)}`,
+                name: basename(absPath),
+                kind: "metadata-section",
+                location: basename(absPath),
+                riskLevel: isProtected ? "low" : "medium",
+                reaToolUsed: "inspect_pcap_capture (tshark JSON)",
+                estimatedTokensToReconstruct: isProtected ? 55_000 : 1_400,
+                estimatedCostUsd: isProtected ? 4.1 : 0.06,
+                reason: isProtected
+                    ? "Protected by BLA PCAP decoy-packet flood targeting TSHARK_JSON_MAX_BYTES"
+                    : "PCAP frames fully dissectable by REA tshark provider",
+            });
+            sim = {
+                ...sim,
+                examinationStatus: isProtected ? "limited" : "complete",
+                triggeredResourceLimits: isProtected
+                    ? ["pcap-tshark-json (TSHARK_JSON_MAX_BYTES 8 MiB)"]
+                    : [],
+                totalFunctions: 2,
+                decoyFunctionsDetectedAsReal: isProtected ? 16 : 0,
+                obligationLedgerNodes: isProtected ? 32 : 2,
+                architecturalChaffPayloads: isProtected ? 4 : 0,
+            };
+        }
+        else if (format === "gpu-ptx") {
+            vulnerableVectors.add("gpu-ptx-inspection");
+            const text = rawBytes.toString("utf8");
+            const isProtected = text.includes("[BLA-PTX-SHIELD]");
+            exposedItems.push({
+                id: `ptx_${basename(absPath)}`,
+                name: basename(absPath),
+                kind: "metadata-section",
+                location: basename(absPath),
+                riskLevel: isProtected ? "low" : "medium",
+                reaToolUsed: "inspect_gpu_code_objects (PTX kernel parser)",
+                estimatedTokensToReconstruct: isProtected ? 48_000 : 1_200,
+                estimatedCostUsd: isProtected ? 3.6 : 0.05,
+                reason: isProtected
+                    ? "Protected by BLA PTX decoy .entry flood + diagnostic comments"
+                    : "PTX .entry/.param declarations directly harvested by REA",
+            });
+            sim = {
+                ...sim,
+                examinationStatus: isProtected ? "limited" : "complete",
+                triggeredResourceLimits: isProtected
+                    ? ["gpu-report-bytes (GPU_REPORT_BYTES 16 MiB)", "gpu-ptx-entry-facts"]
+                    : [],
+                totalFunctions: isProtected ? 20 : 1,
+                decoyFunctionsDetectedAsReal: isProtected ? 20 : 0,
+                obligationLedgerNodes: isProtected ? 48 : 2,
+                architecturalChaffPayloads: isProtected ? 5 : 0,
+            };
+        }
     }
     // Compute overall Exposure Score (0 = fully protected, 100 = completely exposed)
     let exposureScore = 92;
@@ -711,7 +1072,7 @@ export function auditTarget(targetPath) {
     const agentEstimates = estimateAgentReverseEngineeringCosts(sim, byteSize);
     const primaryEstimate = agentEstimates[0];
     const primaryModule = exposedItems[0]?.name ?? basename(absPath);
-    const recommendedCommand = `npx bla-shield protect ${targetPath}`;
+    const recommendedCommand = `npx bla-agents protect ${targetPath}`;
     const headlineWarning = protectionStatus === "BLA_PROTECTED"
         ? `SHIELD ACTIVE: ${basename(absPath)} triggers ${sim.triggeredResourceLimits.length} REA resource limits and forces ~${primaryEstimate.estimatedInputTokens.toLocaleString()} tokens ($${primaryEstimate.estimatedCostUsd.toFixed(2)}) of agent tarpit exhaustion.`
         : `DANGER: Module "${primaryModule}" in ${basename(absPath)} is exposed to REA (${exposureScore}/100 exposure). Estimated Claude Code time: ${primaryEstimate.estimatedWallClockSeconds}s, cost: $${primaryEstimate.estimatedCostUsd.toFixed(2)} to reconstruct. Run "${recommendedCommand}" to inject AI Tarpit & Semantic Shield.`;