fullcourtdefense-cli 1.36.0 → 1.36.2

package/dist/commands/discoverSecrets.js

@@ -33,7 +33,13 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.probeWindowsFileAttributes = void 0;
+exports.dockerConfigCredentialFacts = dockerConfigCredentialFacts;
+exports.isCloudPlaceholderAttributes = isCloudPlaceholderAttributes;
+exports.isCloudSyncedPath = isCloudSyncedPath;
+exports.dropCloudPlaceholders = dropCloudPlaceholders;
 exports.scanSecrets = scanSecrets;
+const child_process_1 = require("child_process");
 const crypto = __importStar(require("crypto"));
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
@@ -158,17 +164,58 @@ function looksLikePlaceholder(raw, line) {
         return true;
     return false;
 }
+/** Fields of a Docker `auths` entry that carry a usable credential (docker/cli configfile AuthConfig). */
+const DOCKER_INLINE_CREDENTIAL_KEYS = new Set(['auth', 'password', 'identitytoken', 'registrytoken']);
+/**
+ * Whether ~/.docker/config.json holds credentials itself. `auths` entries that
+ * only name a registry are metadata when `credsStore` / `credHelpers` keep the
+ * secret in the OS store (Docker Desktop on Windows: `credsStore: desktop` =
+ * Windows Credential Manager). Counts only; never returns a value.
+ */
+function dockerConfigCredentialFacts(content) {
+    let config;
+    try {
+        config = JSON.parse(content);
+    }
+    catch {
+        // Unparseable: fall back to "a credential field with a non-empty string value".
+        const inline = /"(?:auth|password|identitytoken|registrytoken)"\s*:\s*"[^"\s]+"/i.test(content);
+        return { inlineRegistries: inline ? 1 : 0, usesCredentialStore: /"(?:credsStore|credHelpers)"\s*:/.test(content) };
+    }
+    if (!config || typeof config !== 'object')
+        return { inlineRegistries: 0, usesCredentialStore: false };
+    const record = config;
+    const credsStore = typeof record.credsStore === 'string' && record.credsStore.trim() !== '';
+    const credHelpers = !!record.credHelpers && typeof record.credHelpers === 'object' && Object.keys(record.credHelpers).length > 0;
+    let inlineRegistries = 0;
+    const auths = record.auths;
+    if (auths && typeof auths === 'object' && !Array.isArray(auths)) {
+        for (const entry of Object.values(auths)) {
+            if (!entry || typeof entry !== 'object')
+                continue;
+            const hasInline = Object.entries(entry).some(([key, value]) => DOCKER_INLINE_CREDENTIAL_KEYS.has(key.toLowerCase()) && typeof value === 'string' && value.trim() !== '');
+            if (hasInline)
+                inlineRegistries += 1;
+        }
+    }
+    return { inlineRegistries, usesCredentialStore: credsStore || credHelpers };
+}
 function scanCredentialStorePosture(filePath, content, category, out, seen) {
     const normalized = filePath.replace(/\\/g, '/').toLowerCase();
-    if (normalized.endsWith('/.docker/config.json') && /"auths"\s*:|"auth"\s*:|"identitytoken"\s*:/i.test(content)) {
-        pushStoreFinding(out, seen, {
-            filePath,
-            category,
-            provider: 'docker',
-            severity: 'high',
-            title: 'Docker registry credentials',
-            detail: 'Docker config contains registry auth material that agent tools or local malware can read.',
-        });
+    if (normalized.endsWith('/.docker/config.json')) {
+        const docker = dockerConfigCredentialFacts(content);
+        if (docker.inlineRegistries > 0) {
+            pushStoreFinding(out, seen, {
+                filePath,
+                category,
+                provider: 'docker',
+                severity: 'high',
+                title: 'Docker registry credentials',
+                detail: docker.usesCredentialStore
+                    ? `Docker config stores credentials inline for ${docker.inlineRegistries} registr${docker.inlineRegistries === 1 ? 'y' : 'ies'} next to a credential store; the inline entries bypass it and agent tools or local malware can read them.`
+                    : `Docker config stores credentials inline for ${docker.inlineRegistries} registr${docker.inlineRegistries === 1 ? 'y' : 'ies'} that agent tools or local malware can read.`,
+            });
+        }
     }
     if (normalized.endsWith('/.kube/config') && /\b(?:token|client-key-data|client-certificate-data)\s*:/i.test(content)) {
         pushStoreFinding(out, seen, {
@@ -402,10 +449,15 @@ function scanSshKeys(home, out, seen, excludedRoots = []) {
     }
     return scanned;
 }
+// Every root starts at depth 0 in one breadth-first queue, and a folder is
+// walked once: a project root that also sits under the home folder is walked
+// from its own top level (depth 0) before the home walk could reach it at
+// depth 4+, and its files are never read twice.
 function collectEnvFiles(roots, maxDepth, excludedRoots = []) {
     const found = [];
     let excluded = 0;
     let depthLimited = false;
+    const visited = new Set();
     const queue = roots.map(dir => ({ dir, depth: 0 }));
     while (queue.length > 0 && found.length < MAX_ENV_FILES) {
         const { dir, depth } = queue.shift();
@@ -413,6 +465,10 @@ function collectEnvFiles(roots, maxDepth, excludedRoots = []) {
             excluded += 1;
             continue;
         }
+        const key = (0, discoverPaths_1.normalizedPath)(dir);
+        if (visited.has(key))
+            continue;
+        visited.add(key);
         let entries;
         try {
             entries = fs.readdirSync(dir, { withFileTypes: true });
@@ -447,12 +503,14 @@ function collectEnvFiles(roots, maxDepth, excludedRoots = []) {
             }
         }
     }
-    return { files: found, truncated: depthLimited || found.length >= MAX_ENV_FILES || queue.length > 0, excluded };
+    const countLimited = found.length >= MAX_ENV_FILES;
+    return { files: found, truncated: depthLimited || countLimited || queue.length > 0, depthLimited, countLimited: countLimited || queue.length > 0, excluded };
 }
 function collectProjectCredentialFiles(roots, maxDepth, excludedRoots = []) {
     const found = [];
     let excluded = 0;
     let depthLimited = false;
+    const visited = new Set();
     const queue = roots.map(dir => ({ dir, depth: 0 }));
     const isCredentialFile = (filePath) => {
         const normalized = filePath.replace(/\\/g, '/').toLowerCase();
@@ -470,6 +528,10 @@ function collectProjectCredentialFiles(roots, maxDepth, excludedRoots = []) {
             excluded += 1;
             continue;
         }
+        const key = (0, discoverPaths_1.normalizedPath)(dir);
+        if (visited.has(key))
+            continue;
+        visited.add(key);
         let entries;
         try {
             entries = fs.readdirSync(dir, { withFileTypes: true });
@@ -501,7 +563,81 @@ function collectProjectCredentialFiles(roots, maxDepth, excludedRoots = []) {
                 found.push(full);
         }
     }
-    return { files: found, truncated: depthLimited || found.length >= MAX_ENV_FILES || queue.length > 0, excluded };
+    const countLimited = found.length >= MAX_ENV_FILES;
+    return { files: found, truncated: depthLimited || countLimited || queue.length > 0, depthLimited, countLimited: countLimited || queue.length > 0, excluded };
+}
+// Windows file attributes that mark a cloud-sync placeholder (OneDrive Files
+// On-Demand): reading such a file makes the sync client download it.
+const FILE_ATTRIBUTE_OFFLINE = 0x1000;
+const FILE_ATTRIBUTE_RECALL_ON_OPEN = 0x40000;
+const FILE_ATTRIBUTE_RECALL_ON_DATA_ACCESS = 0x400000;
+function isCloudPlaceholderAttributes(attributes) {
+    return Number.isInteger(attributes) && attributes >= 0
+        && (attributes & (FILE_ATTRIBUTE_OFFLINE | FILE_ATTRIBUTE_RECALL_ON_OPEN | FILE_ATTRIBUTE_RECALL_ON_DATA_ACCESS)) !== 0;
+}
+/** True for paths inside a OneDrive folder (by env root or a "OneDrive…" path segment). */
+function isCloudSyncedPath(filePath, env = process.env) {
+    const roots = [env.OneDrive, env.OneDriveCommercial, env.OneDriveConsumer].filter((root) => !!root);
+    if (roots.some(root => (0, discoverPaths_1.pathIsWithin)(filePath, root)))
+        return true;
+    return filePath.split(/[\\/]/).some(segment => /^onedrive\b/i.test(segment));
+}
+/**
+ * One PowerShell call reads the attributes of every candidate (no file is
+ * opened, so nothing is downloaded). Paths go in base64 on stdin so non-ASCII
+ * folder names survive the console code page; one integer per line comes back
+ * in input order. Returns null when PowerShell is unavailable or times out.
+ */
+const probeWindowsFileAttributes = files => {
+    if (files.length === 0)
+        return [];
+    const script = [
+        "$ErrorActionPreference = 'SilentlyContinue'",
+        'foreach ($line in [Console]::In.ReadToEnd() -split "`n") {',
+        '  $line = $line.Trim(); if (-not $line) { continue }',
+        '  try { $p = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($line)); [Console]::Out.WriteLine([int][IO.File]::GetAttributes($p)) }',
+        '  catch { [Console]::Out.WriteLine(-1) }',
+        '}',
+    ].join('\n');
+    try {
+        const result = (0, child_process_1.spawnSync)('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', script], {
+            input: files.map(file => Buffer.from(file, 'utf8').toString('base64')).join('\n'),
+            encoding: 'utf8',
+            timeout: 15000,
+            windowsHide: true,
+        });
+        if (result.status !== 0 || typeof result.stdout !== 'string')
+            return null;
+        const values = result.stdout.split(/\r?\n/).map(line => line.trim()).filter(Boolean).map(Number);
+        if (values.length !== files.length)
+            return null;
+        return values.map(value => (Number.isInteger(value) && value >= 0 ? value : undefined));
+    }
+    catch {
+        return null;
+    }
+};
+exports.probeWindowsFileAttributes = probeWindowsFileAttributes;
+/**
+ * Drop OneDrive online-only placeholders before any read. Only files under a
+ * OneDrive folder are probed; a failed probe keeps every file (the per-file
+ * size cap still bounds what is read).
+ */
+function dropCloudPlaceholders(files, options = {}) {
+    if ((options.platform ?? process.platform) !== 'win32')
+        return { files, skipped: 0 };
+    const env = options.env ?? process.env;
+    const synced = files.filter(file => isCloudSyncedPath(file, env));
+    if (synced.length === 0)
+        return { files, skipped: 0 };
+    const attributes = (options.probe ?? exports.probeWindowsFileAttributes)(synced);
+    if (!attributes)
+        return { files, skipped: 0 };
+    const placeholders = new Set(synced.filter((_, index) => {
+        const value = attributes[index];
+        return value !== undefined && isCloudPlaceholderAttributes(value);
+    }).map(file => (0, discoverPaths_1.normalizedPath)(file)));
+    return { files: files.filter(file => !placeholders.has((0, discoverPaths_1.normalizedPath)(file))), skipped: placeholders.size };
 }
 function scanSecrets(options = {}) {
     const home = os.homedir();
@@ -550,10 +686,13 @@ function scanSecrets(options = {}) {
         path.join(home, 'Documents'),
         path.join(home, 'code'),
     ].filter(root => fs.existsSync(root) && !(0, discoverPaths_1.isExcludedPath)(root, disabledRoots)));
+    const placeholderOptions = { platform: options.platform, env: options.env, probe: options.probeFileAttributes };
     const envCollection = collectEnvFiles(envRoots, maxDepth, disabledRoots);
     excludedFiles += envCollection.excluded;
     candidatesTruncated = candidatesTruncated || envCollection.truncated;
-    for (const envFile of envCollection.files) {
+    const envFiles = dropCloudPlaceholders(envCollection.files, placeholderOptions);
+    let cloudPlaceholdersSkipped = envFiles.skipped;
+    for (const envFile of envFiles.files) {
         if (findings.length >= MAX_FINDINGS)
             break;
         const content = readTextFile(envFile);
@@ -565,7 +704,9 @@ function scanSecrets(options = {}) {
     const credentialCollection = collectProjectCredentialFiles([cwd, ...extraRoots], maxDepth, disabledRoots);
     excludedFiles += credentialCollection.excluded;
     candidatesTruncated = candidatesTruncated || credentialCollection.truncated;
-    for (const credentialFile of credentialCollection.files) {
+    const credentialFiles = dropCloudPlaceholders(credentialCollection.files, placeholderOptions);
+    cloudPlaceholdersSkipped += credentialFiles.skipped;
+    for (const credentialFile of credentialFiles.files) {
         if (findings.length >= MAX_FINDINGS)
             break;
         const content = readTextFile(credentialFile);
@@ -602,7 +743,10 @@ function scanSecrets(options = {}) {
         scannedStores,
         healthScore: scoreFromFindings(findings),
         limits: { maxFileBytes: MAX_FILE_BYTES, maxEnvFiles: MAX_ENV_FILES, maxFindings: MAX_FINDINGS, maxDepth },
-        stats: { candidateFiles: scannedFiles, excludedFiles },
+        stats: { candidateFiles: scannedFiles, excludedFiles, cloudPlaceholdersSkipped },
         truncated: { candidateFiles: candidatesTruncated, findings: findings.length >= MAX_FINDINGS },
+        truncatedReasons: {
+            candidateFiles: (0, discoverPaths_1.truncationReason)(envCollection.depthLimited || credentialCollection.depthLimited, envCollection.countLimited || credentialCollection.countLimited),
+        },
     };
 }

package/dist/commands/hook.js

@@ -1248,11 +1248,13 @@ function explainGuardStop(kind, event, call, reason, ruleId) {
     });
 }
 function spoolLocalFinding(input) {
+    // An action that ran is never recorded as "Blocked …" (monitor showed "Blocked recursive force delete" on a warn).
+    const recorded = input.decision === 'warn' ? input.recorded || 'warned' : undefined;
     (0, telemetry_1.spoolEvent)({
         decision: input.decision || 'block',
         toolName: input.toolName,
         operation: input.operation,
-        reason: input.finding.reason,
+        reason: recorded ? (0, blockExplanation_1.recordedReason)(input.finding.reason, recorded) : input.finding.reason,
         ruleId: input.finding.ruleId,
         category: input.finding.category,
         categoryId: input.finding.categoryId,
@@ -1811,8 +1813,9 @@ async function hookCommandInner(args, config, io) {
         }
         // An ask carries the dialog envelope for the per-event hook process in the
         // developer's session (askDialog.ts); it is removed before the IDE reads the verdict.
+        // The same client the runtime event records as `agentClient`: the dialog names the agent the console shows.
         if (ask && askEnvelope)
-            decision = (0, askDialog_1.attachAskEnvelope)(decision, askEnvelope);
+            decision = (0, askDialog_1.attachAskEnvelope)(decision, { ...askEnvelope, agentClient: client });
         (0, hookIo_1.dbg)({ phase: 'verdict', event, format: hookFormat, blocked, decision: ask && askEnvelope ? { ...decision, [askDialog_1.ASK_ENVELOPE_FIELD]: '(envelope)' } : decision });
         if (hookFormat === 'claude' && event === 'prompt' && denied) {
             // Claude Desktop/Code variants do not all honor the structured
@@ -1914,8 +1917,8 @@ async function hookCommandInner(args, config, io) {
             (0, hookIo_1.dbg)({ phase: 'local_deterministic_prompt_block', event, ruleId: localBlock.ruleId, category: localBlock.category });
             if (shadow) {
                 // Truth-in-reporting: this prompt RAN (shadow/monitor) — 'warn', never 'block'.
-                spoolLocalFinding({ finding: localBlock, toolName: 'prompt', operation: 'prompt', decision: 'warn' });
-                respond(false, undefined, `[FullCourtDefense shadow] would block prompt: ${localBlock.reason}`);
+                spoolLocalFinding({ finding: localBlock, toolName: 'prompt', operation: 'prompt', decision: 'warn', recorded: 'would_block' });
+                respond(false, undefined, `[FullCourtDefense shadow] ${(0, blockExplanation_1.recordedReason)(localBlock.reason, 'would_block')}`);
                 return;
             }
             spoolLocalFinding({ finding: localBlock, toolName: 'prompt', operation: 'prompt' });
@@ -2059,8 +2062,8 @@ async function enforceActionPolicy(ctx) {
         (0, hookIo_1.dbg)({ phase: 'local_deterministic_block', event, tool: call.toolName, ruleId: localBlock.ruleId, category: localBlock.category });
         if (shadow) {
             // Truth-in-reporting: this action RAN (shadow/monitor) — 'warn', never 'block'.
-            spoolLocalFinding({ finding: localBlock, toolName: call.toolName, operation: event, decision: 'warn' });
-            respond(false, undefined, `[FullCourtDefense shadow] would block ${call.toolName}: ${localBlock.reason}`);
+            spoolLocalFinding({ finding: localBlock, toolName: call.toolName, operation: event, decision: 'warn', recorded: 'would_block' });
+            respond(false, undefined, `[FullCourtDefense shadow] ${call.toolName}: ${(0, blockExplanation_1.recordedReason)(localBlock.reason, 'would_block')}`);
             return;
         }
         spoolLocalFinding({ finding: localBlock, toolName: call.toolName, operation: event });
@@ -2077,7 +2080,7 @@ async function enforceActionPolicy(ctx) {
     if (localAsk) {
         (0, hookIo_1.dbg)({ phase: 'local_deterministic_ask', event, tool: call.toolName, ruleId: localAsk.ruleId, humanPresent: (0, devConfirm_1.isHumanPresent)(), shadow });
         if (shadow) {
-            spoolLocalFinding({ finding: localAsk, toolName: call.toolName, operation: event, decision: 'warn' });
+            spoolLocalFinding({ finding: localAsk, toolName: call.toolName, operation: event, decision: 'warn', recorded: 'would_ask' });
         }
         else if (!(0, devConfirm_1.isHumanPresent)()) {
             spoolLocalFinding({ finding: localAsk, toolName: call.toolName, operation: event });

package/dist/commands/mcpGateway.js

@@ -1546,7 +1546,7 @@ class McpGatewayServer {
                     process.stderr.write(`FullCourtDefense asking the developer to confirm ${toolName}: ${ask.reason} (${origin} "${ask.itemId}", ${ask.ruleId})\n`);
                     const alwaysScopeLabel = (0, devConfirm_1.describeGrantScope)(grantScope);
                     const alwaysLimitsLabel = grantLimits ? (0, devConfirm_1.describeGrantLimits)(grantLimits) : undefined;
-                    const answer = await this.confirmWithDeveloper({ toolName, reason: ask.reason, ruleLabel: `${origin} "${ask.itemId}" (${ask.ruleId})`, evidence: ask.evidence, argsDigest: digest, allowAlways: Boolean(grantLimits), alwaysScopeLabel, alwaysLimitsLabel });
+                    const answer = await this.confirmWithDeveloper({ toolName, reason: ask.reason, ruleLabel: `${origin} "${ask.itemId}" (${ask.ruleId})`, evidence: ask.evidence, argsDigest: digest, allowAlways: Boolean(grantLimits), alwaysScopeLabel, alwaysLimitsLabel, alwaysCovers: (0, devConfirm_1.grantCoverage)(grantScope) });
                     if (answer.answer === 'accept') {
                         // Settle through the shared ledger so "remember for this session" is
                         // recorded exactly like an IDE approval would be.
@@ -1594,8 +1594,9 @@ class McpGatewayServer {
                     // where the scan can still yield block-action findings. Record the
                     // would-block and let the call through.
                     const would = requestOutcome.blockingFinding ? 'would block' : 'would ask you to confirm';
-                    this.spoolLocalFinding({ ...localBlock, reason: `[monitor] ${localBlock.reason}` }, toolName, operation, 'warn');
-                    process.stderr.write(`FullCourtDefense (monitor) ${would} ${toolName}: ${localBlock.reason} (${origin} "${localBlock.itemId}", ${localBlock.ruleId})\n`);
+                    const recorded = (0, blockExplanation_1.recordedReason)(localBlock.reason, requestOutcome.blockingFinding ? 'would_block' : 'would_ask');
+                    this.spoolLocalFinding({ ...localBlock, reason: `[monitor] ${recorded}` }, toolName, operation, 'warn');
+                    process.stderr.write(`FullCourtDefense (monitor) ${would} ${toolName}: ${recorded.replace(/^Would (?:block|ask): /, '')} (${origin} "${localBlock.itemId}", ${localBlock.ruleId})\n`);
                 }
                 else {
                     this.spoolLocalFinding(localBlock, toolName, operation);
@@ -1881,7 +1882,7 @@ class McpGatewayServer {
                 const responseOrigin = localResponseBlock.source === 'custom' ? 'org custom rule' : 'built-in Local Safety rule';
                 if (reportOnlyMode) {
                     // MONITOR CONTRACT (see request-side block above): record, never block.
-                    this.spoolLocalFinding({ ...localResponseBlock, reason: `[monitor] ${localResponseBlock.reason}` }, toolName, operation, 'warn');
+                    this.spoolLocalFinding({ ...localResponseBlock, reason: `[monitor] ${(0, blockExplanation_1.recordedReason)(localResponseBlock.reason, 'would_block')}` }, toolName, operation, 'warn');
                     process.stderr.write(`FullCourtDefense (monitor) would block the ${toolName} response: ${localResponseBlock.reason} (${responseOrigin} "${localResponseBlock.itemId}", ${localResponseBlock.ruleId})\n`);
                 }
                 else {
@@ -1901,7 +1902,7 @@ class McpGatewayServer {
                 if (!fullyMasked) {
                     const finding = responseOutcome.maskFindings[0];
                     if (reportOnlyMode) {
-                        this.spoolLocalFinding({ ...finding, reason: `[monitor] ${finding.reason}` }, toolName, operation, 'warn');
+                        this.spoolLocalFinding({ ...finding, reason: `[monitor] ${(0, blockExplanation_1.recordedReason)(finding.reason, 'would_block')}` }, toolName, operation, 'warn');
                         process.stderr.write(`FullCourtDefense (monitor) would block the ${toolName} response: mask rule "${finding.itemId}" could not rewrite this payload.\n`);
                     }
                     else {
@@ -2243,6 +2244,7 @@ class McpGatewayServer {
             allowAlways,
             alwaysScopeLabel,
             alwaysLimitsLabel,
+            alwaysCovers: (0, devConfirm_1.grantCoverage)(grantScope),
         });
         if (answer.answer === 'accept') {
             // Policy memory limits are authoritative; a client cannot upgrade 'none'.
@@ -2320,7 +2322,7 @@ class McpGatewayServer {
     }
     async askInOsDialog(input, clientAutoAnswered) {
         const evidence = input.evidence ? `\nEvidence: ${input.evidence.slice(0, 240)}` : '';
-        const dialog = await (0, devConfirm_1.confirmNativeActionDetailed)(`Agent: ${this.gatewayConfig.agentName}\nIDE: ${this.gatewayConfig.agentClient}\nDeveloper: ${this.gatewayConfig.developerName || 'Unknown'}\nTool: ${input.toolName}\nRule: ${input.ruleLabel}\nWhy: ${input.reason}${evidence}\n\nYour answer is reported to your security dashboard as your decision.`, OS_DIALOG_TIMEOUT_MS, { allowAlways: input.allowAlways === true, alwaysScopeLabel: input.alwaysScopeLabel, alwaysLimitsLabel: input.alwaysLimitsLabel });
+        const dialog = await (0, devConfirm_1.confirmNativeActionDetailed)(`Agent: ${this.gatewayConfig.agentName}\nIDE: ${this.gatewayConfig.agentClient}\nDeveloper: ${this.gatewayConfig.developerName || 'Unknown'}\nTool: ${input.toolName}\nRule: ${input.ruleLabel}\nWhy: ${input.reason}${evidence}\n\nYour answer is reported to your security dashboard as your decision.`, OS_DIALOG_TIMEOUT_MS, { allowAlways: input.allowAlways === true, alwaysScopeLabel: input.alwaysScopeLabel, alwaysLimitsLabel: input.alwaysLimitsLabel, alwaysCovers: input.alwaysCovers });
         process.stderr.write(`FullCourtDefense: dialog for ${input.toolName} ended with "${dialog.outcome}" after ${dialog.latencyMs}ms.\n`);
         const answer = dialog.outcome === 'allow' || dialog.outcome === 'allow_always' ? 'accept' : dialog.outcome === 'deny' ? 'decline' : dialog.outcome;
         return { answer, remember: false, always: dialog.outcome === 'allow_always', latencyMs: dialog.latencyMs, channel: 'os_dialog', clientAutoAnswered };
@@ -3079,7 +3081,7 @@ function healCodexTomlAgentIdentities(file, dryRun) {
  * runtime-agnostic agent identity that protect-all/auto-protect produce (`<developer>-<server>`).
  * Otherwise the gateway reports a generic `<developer>-<client>` name and a dashboard policy
  * targeting the MCP server (agentName contains <server>) silently never matches — the exact
- * bug where a block policy on `patria-bank-finance` did not fire because the Claude Desktop
+ * bug where a block policy on `contoso-bank-finance` did not fire because the Claude Desktop
  * entry reported `boazl-claude-desktop`. An explicit --agent-name / FCD_AGENT_NAME still wins.
  */
 function applyPerServerAgentName(gatewayConfig, args, serverName) {

package/dist/commands/posixShellGuard.js

@@ -171,7 +171,7 @@ function buildGuardJs(nodePath, cliEntry) {
         `// Execution view (aligned with the CLI's stripInertDataSegments): quoted spans containing whitespace are`,
         `// prose (inert) unless in a code position — interpreter -c/-Command flags, remote executors (ssh/wsl/docker`,
         `// exec), $( ) substitution, or real backtick command substitution (>=2 chars; a 1-char pair is a PS escape).`,
-        `function execView(line){if(/\\b(?:iex|invoke-expression|invoke-command)\\b|\\beval\\b|\\bxargs\\b|\\bbase64\\b[^\\n]*(?:-d\\b|--decode\\b)|frombase64string|-encodedcommand\\b|\\s-enc\\s|\\|\\s*&?\\s*(?:sh|bash|zsh|dash|ksh|csh|pwsh|powershell(?:\\.exe)?|cmd(?:\\.exe)?|node|python[0-9.]*|perl|ruby)\\b|\\b(?:sh|bash|zsh|dash|ksh|csh|pwsh|powershell(?:\\.exe)?|cmd(?:\\.exe)?|node|python[0-9.]*|perl|ruby)\\s+(?:-c|\\/c|-e|-command|-scriptblock)\\b|\\b(?:ssh|wsl(?:\\.exe)?|chroot)\\b|\\b(?:docker|kubectl|podman|nerdctl)(?:\\.exe)?\\s+(?:exec|run)\\b/i.test(line))return line;const K=/\\$\\(|\`[^\`]{2,}\`/;const C=/(?:(?:^|[;&|(]|\\s)(?:-c|\\/c|-e|-command|-scriptblock|-filter)[= ]\\s*|(?:^|[;&|(]\\s*)(?:\\S*[\\\\\\/])?(?:sudo\\s+|doas\\s+)?(?:ssh|wsl(?:\\.exe)?|chroot|su|screen|tmux)(?:\\s[^;&|"']*)?\\s|(?:\\S*[\\\\\\/])?(?:docker|kubectl|podman|nerdctl)(?:\\.exe)?\\s+(?:exec|run)\\b[^;&|"']*\\s)$/i;let o=line;o=o.replace(/@'[\\s\\S]*?'@/g,' fcd_inert_data ');o=o.replace(/@"[\\s\\S]*?"@/g,m=>m.includes('$(')?m:' fcd_inert_data ');o=o.replace(/<<-?\\s*'(\\w+)'[\\s\\S]*?(?:\\n\\1\\b|$)/g,' fcd_inert_data ');o=o.replace(/<<-?\\s*"?(\\w+)"?[\\s\\S]*?(?:\\n\\1\\b|$)/g,m=>K.test(m)?m:' fcd_inert_data ');const s=o;o=s.replace(/"((?:[^"\\\\]|\\\\.)*)"|'((?:[^'\\\\]|\\\\.)*)'/g,(w,dq,sq,i)=>{const b=dq!==undefined?dq:(sq||'');if(!/\\s/.test(b))return w;if(C.test(s.slice(Math.max(0,i-80),i)))return w;if(dq!==undefined&&K.test(b))return w;return ' fcd_inert_data ';});return o;}`,
+        `function execView(line){if(/\\b(?:iex|invoke-expression|invoke-command)\\b|\\beval\\b|\\bxargs\\b|\\bbase64\\b[^\\n]*(?:-d\\b|--decode\\b)|frombase64string|-encodedcommand\\b|\\s-enc\\s|(?<!\\|)\\|(?!\\|)\\s*&?\\s*(?:sh|bash|zsh|dash|ksh|csh|pwsh|powershell(?:\\.exe)?|cmd(?:\\.exe)?|node|python[0-9.]*|perl|ruby)\\b|\\b(?:sh|bash|zsh|dash|ksh|csh|pwsh|powershell(?:\\.exe)?|cmd(?:\\.exe)?|node|python[0-9.]*|perl|ruby)\\s+(?:-c|\\/c|-e|-command|-scriptblock)\\b|\\b(?:ssh|wsl(?:\\.exe)?|chroot)\\b|\\b(?:docker|kubectl|podman|nerdctl)(?:\\.exe)?\\s+(?:exec|run)\\b/i.test(line))return line;const K=/\\$\\(|\`[^\`]{2,}\`/;const C=/(?:(?:^|[;&|(]|\\s)(?:-c|\\/c|-e|-command|-scriptblock|-filter)[= ]\\s*|(?:^|[;&|(]\\s*)(?:\\S*[\\\\\\/])?(?:sudo\\s+|doas\\s+)?(?:ssh|wsl(?:\\.exe)?|chroot|su|screen|tmux)(?:\\s[^;&|"']*)?\\s|(?:\\S*[\\\\\\/])?(?:docker|kubectl|podman|nerdctl)(?:\\.exe)?\\s+(?:exec|run)\\b[^;&|"']*\\s)$/i;let o=line;o=o.replace(/@'[\\s\\S]*?'@/g,' fcd_inert_data ');o=o.replace(/@"[\\s\\S]*?"@/g,m=>m.includes('$(')?m:' fcd_inert_data ');o=o.replace(/<<-?\\s*'(\\w+)'[\\s\\S]*?(?:\\n\\1\\b|$)/g,' fcd_inert_data ');o=o.replace(/<<-?\\s*"?(\\w+)"?[\\s\\S]*?(?:\\n\\1\\b|$)/g,m=>K.test(m)?m:' fcd_inert_data ');const s=o;o=s.replace(/"((?:[^"\\\\]|\\\\.)*)"|'((?:[^'\\\\]|\\\\.)*)'/g,(w,dq,sq,i)=>{const b=dq!==undefined?dq:(sq||'');if(!/\\s/.test(b))return w;if(C.test(s.slice(Math.max(0,i-80),i)))return w;if(dq!==undefined&&K.test(b))return w;return ' fcd_inert_data ';});return o;}`,
         `// Precedence on one line: block outranks ask, ask outranks warn.`,
         `function matchLine(line,rules){const n=line.replace(/\\s+/g,' ').trim();const x=execView(line);const xn=x.replace(/\\s+/g,' ').trim();let warnHit=null;const asks=[];for(const r of rules){try{const t=r.source==='custom'?line:x;const tn=r.source==='custom'?n:xn;if(r.re.test(tn)||r.re.test(t)){if(r.action==='block')return r;if(r.action==='ask'){asks.push(r);}else if(!warnHit)warnHit=r;}}catch{}}if(asks.length===1)return asks[0];if(asks.length>1){asks.sort((a,b)=>a.id<b.id?-1:a.id>b.id?1:0);return{...asks[0],id:'asks:'+asks.map(r=>encodeURIComponent(r.id)).join('+'),reason:asks.map(r=>r.reason).join('; ')}}return warnHit;}`,
         `function triggerFlush(){try{if(fs.existsSync(NODE_PATH)&&fs.existsSync(CLI_ENTRY)){const c=spawn(NODE_PATH,[CLI_ENTRY,'flush-spool','--heartbeat','true'],{detached:true,stdio:'ignore'});c.unref();}}catch{}}`,

package/dist/commands/shellGuard.js

@@ -183,10 +183,32 @@ function compileSpec(spec) {
         pattern += `(?=${SEG}\\s(?:${spec.target.join('|')}))`;
     return { id: spec.id, category: spec.category, severity: spec.severity, reason: spec.reason, source: 'builtin', pattern };
 }
+/**
+ * Every body must occur on one line, in any order. Tried only at line starts: an
+ * unanchored `(?=.*a)(?=.*b)` re-scans the rest of the line from every
+ * character, which is quadratic on a long line that does not match (a 16 KB
+ * commit message took seconds per rule). Same matches in .NET and JS: a hit from
+ * mid-line implies one from the start of that line.
+ */
+function sameLine(...bodies) {
+    return String.raw `(?:^|[\n\r\u2028\u2029])` + bodies.map(body => `(?=.*${body})`).join('');
+}
 // Reusable target fragments.
-const T_UNIX_ROOT = String.raw `["']?/["']?(?:\s|$|[;&|])|\*(?:\s|$|[;&|])`;
+/** The root itself; a bare `*` (the current folder's contents) is its own finding. */
+const T_UNIX_ROOT_ONLY = String.raw `["']?/\*?["']?(?:\s|$|[;&|])`;
+const T_BARE_STAR = String.raw `\*(?:\s|$|[;&|])`;
 const T_WIN_DRIVE = String.raw `["']?[a-z]:(?:[\\/](?:\*(?:\.\*)?)?)?["']?\s*(?:$|[;&|])`;
 const T_WIN_SYSDIR = String.raw `["']?[a-z]:[\\/](?:windows|program files(?: \(x86\))?|programdata|users)\b`;
+/**
+ * A bare `*` right after `cd /` (or `cd ~`) is the root's (home's) contents, not "the current
+ * folder". Whole-line literal rules, listed before the bare-star specs so the line reads first.
+ */
+const CD_ROOT = String.raw `(?:^|[;&|\n]\s*)cd\s+["']?/["']?\s*(?:&&|;|\n)\s*(?:sudo\s+)?`;
+const CD_HOME = String.raw `(?:^|[;&|\n]\s*)cd\s+["']?(?:~|\$HOME|\$\{HOME\})[\\/]?["']?\s*(?:&&|;|\n)\s*(?:sudo\s+)?`;
+function starAfterCd(cd, command, flags) {
+    return `${cd}${command}\\b${flags.map(f => `(?=[^;&|\\n]*\\s(?:${f})(?:\\s|$))`).join('')}[^;&|\\n]*\\s\\*(?:\\s|$|[;&|])`;
+}
+const F_RECURSIVE = String.raw `-[a-z]*r[a-z]*|--recursive`;
 /**
  * Built-in dangerous-command rules. Flag/target-bearing rules are compiled from
  * specs (order-independent by construction); the rest are literal regexes. Item
@@ -196,7 +218,14 @@ const T_WIN_SYSDIR = String.raw `["']?[a-z]:[\\/](?:windows|program files(?: \(x
 const BUILTIN_RULES = [
     // Destructive filesystem — spec-compiled (order-independent, optional flags not required).
     compileSpec({ id: 'rm_rf_root', category: 'destructive_command', severity: 'critical', reason: 'recursive delete of filesystem root',
-        command: ['rm'], flags: [String.raw `-[a-z]*r[a-z]*|--recursive`], target: [T_UNIX_ROOT] }),
+        command: ['rm'], flags: [String.raw `-[a-z]*r[a-z]*|--recursive`], target: [T_UNIX_ROOT_ONLY] }),
+    { id: 'rm_rf_root', category: 'destructive_command', severity: 'critical', reason: 'recursive delete of filesystem root', source: 'builtin',
+        pattern: starAfterCd(CD_ROOT, 'rm', [F_RECURSIVE]) },
+    { id: 'rm_rf_root', category: 'destructive_command', severity: 'critical', reason: 'recursive delete of the home directory', source: 'builtin',
+        pattern: starAfterCd(CD_HOME, 'rm', [F_RECURSIVE]) },
+    // Same item (same verdict and console row); the fact is the current folder, not the root.
+    compileSpec({ id: 'rm_rf_root', category: 'destructive_command', severity: 'critical', reason: 'recursive delete of everything in the current folder (rm -r *)',
+        command: ['rm'], flags: [String.raw `-[a-z]*r[a-z]*|--recursive`], target: [T_BARE_STAR] }),
     compileSpec({ id: 'rm_rf_home', category: 'destructive_command', severity: 'critical', reason: 'recursive delete of the home directory',
         command: ['rm'], flags: [String.raw `-[a-z]*r[a-z]*|--recursive`], target: [String.raw `["']?(?:~|\$HOME|\$\{HOME\}|%USERPROFILE%|\$env:USERPROFILE)(?:[\\/]\*?)?["']?(?:\s|$|[;&|])`] }),
     compileSpec({ id: 'windows_drive_delete', category: 'destructive_command', severity: 'critical', reason: 'recursive Windows drive delete',
@@ -210,10 +239,19 @@ const BUILTIN_RULES = [
     // switch and an action.
     compileSpec({ id: 'windows_drive_delete', category: 'destructive_command', severity: 'critical', reason: 'recursive Remove-Item on a drive root',
         command: ['remove-item', 'ri'], flags: [String.raw `-recurse\w*`], target: [String.raw `["']?[a-z]:[\\/]?["']?(?:\s|$|[;&|])`] }),
+    // Root vs a bare `*` (the current folder, or the root after `cd /`): same item, the right fact.
     compileSpec({ id: 'chmod_root_777', category: 'destructive_command', severity: 'high', reason: 'recursive world-writable permission change on root',
-        command: ['chmod'], flags: [String.raw `-[a-z]*r[a-z]*|--recursive`, String.raw `[0-7]?777`], target: [T_UNIX_ROOT] }),
+        command: ['chmod'], flags: [F_RECURSIVE, String.raw `[0-7]?777`], target: [T_UNIX_ROOT_ONLY] }),
+    { id: 'chmod_root_777', category: 'destructive_command', severity: 'high', reason: 'recursive world-writable permission change on root', source: 'builtin',
+        pattern: starAfterCd(CD_ROOT, 'chmod', [F_RECURSIVE, String.raw `[0-7]?777`]) },
+    compileSpec({ id: 'chmod_root_777', category: 'destructive_command', severity: 'high', reason: 'recursive world-writable permission change on everything in the current folder (chmod -R 777 *)',
+        command: ['chmod'], flags: [F_RECURSIVE, String.raw `[0-7]?777`], target: [T_BARE_STAR] }),
     compileSpec({ id: 'chown_root_recursive', category: 'destructive_command', severity: 'high', reason: 'recursive ownership change on the filesystem root',
-        command: ['chown'], flags: [String.raw `-[a-z]*r[a-z]*|--recursive`], target: [T_UNIX_ROOT] }),
+        command: ['chown'], flags: [F_RECURSIVE], target: [T_UNIX_ROOT_ONLY] }),
+    { id: 'chown_root_recursive', category: 'destructive_command', severity: 'high', reason: 'recursive ownership change on the filesystem root', source: 'builtin',
+        pattern: starAfterCd(CD_ROOT, 'chown', [F_RECURSIVE]) },
+    compileSpec({ id: 'chown_root_recursive', category: 'destructive_command', severity: 'high', reason: 'recursive ownership change on everything in the current folder (chown -R *)',
+        command: ['chown'], flags: [F_RECURSIVE], target: [T_BARE_STAR] }),
     compileSpec({ id: 'dd_disk_overwrite', category: 'destructive_command', severity: 'critical', reason: 'raw disk overwrite command',
         command: ['dd'], target: [String.raw `of=/dev/(?:sd|xvd|hd|nvme|disk)\S*`] }),
     { id: 'disk_device_overwrite', category: 'destructive_command', severity: 'critical', reason: 'redirecting output over a raw disk device', source: 'builtin',
@@ -248,7 +286,7 @@ const BUILTIN_RULES = [
     { id: 'remote_pipe_interpreter', category: 'reverse_shell', severity: 'high', reason: 'remote script piped to an interpreter', source: 'builtin',
         pattern: String.raw `\b(?:curl|wget)\b[^|;&]{0,300}\|\s*(?:sudo\s+)?(?:python[0-9.]*|perl|ruby|node|php)\b` },
     { id: 'powershell_download_exec', category: 'reverse_shell', severity: 'high', reason: 'download-and-execute (IEX + web download)', source: 'builtin',
-        pattern: String.raw `(?=.*\b(?:iex\b|invoke-expression\b))(?=.*(?:downloadstring|net\.webclient|invoke-webrequest\b|\biwr\b|invoke-restmethod\b|\birm\b))` },
+        pattern: sameLine(String.raw `\b(?:iex\b|invoke-expression\b)`, String.raw `(?:downloadstring|net\.webclient|invoke-webrequest\b|\biwr\b|invoke-restmethod\b|\birm\b)`) },
     { id: 'python_socket_subprocess', category: 'reverse_shell', severity: 'high', reason: 'python reverse shell', source: 'builtin',
         pattern: String.raw `\bpython(?:3)?\s+-c\b(?=.*socket)(?=.*subprocess)` },
     { id: 'perl_reverse_shell', category: 'reverse_shell', severity: 'high', reason: 'perl reverse shell', source: 'builtin',
@@ -259,15 +297,15 @@ const BUILTIN_RULES = [
     // One terminal rule per CONSOLE toggle (catalog ids) — a single combined rule
     // meant switching off / asking on one endpoint changed nothing in a shell.
     { id: 'aws_gcp_metadata_ip', category: 'metadata_ssrf', severity: 'high', reason: 'request to the AWS/GCP metadata endpoint (169.254.169.254)', source: 'builtin',
-        pattern: String.raw `(?=.*\b(?:curl|wget|iwr|invoke-webrequest|invoke-restmethod|irm)\b)(?=.*169\.254\.169\.254)` },
+        pattern: sameLine(String.raw `\b(?:curl|wget|iwr|invoke-webrequest|invoke-restmethod|irm)\b`, String.raw `169\.254\.169\.254`) },
     { id: 'gcp_metadata_host', category: 'metadata_ssrf', severity: 'high', reason: 'request to the GCP metadata host (metadata.google.internal)', source: 'builtin',
-        pattern: String.raw `(?=.*\b(?:curl|wget|iwr|invoke-webrequest|invoke-restmethod|irm)\b)(?=.*metadata\.google\.internal)` },
+        pattern: sameLine(String.raw `\b(?:curl|wget|iwr|invoke-webrequest|invoke-restmethod|irm)\b`, String.raw `metadata\.google\.internal`) },
     { id: 'azure_metadata_host', category: 'metadata_ssrf', severity: 'high', reason: 'request to the Azure metadata host (metadata.azure.com)', source: 'builtin',
-        pattern: String.raw `(?=.*\b(?:curl|wget|iwr|invoke-webrequest|invoke-restmethod|irm)\b)(?=.*metadata\.azure\.com)` },
+        pattern: sameLine(String.raw `\b(?:curl|wget|iwr|invoke-webrequest|invoke-restmethod|irm)\b`, String.raw `metadata\.azure\.com`) },
     { id: 'alibaba_metadata_ip', category: 'metadata_ssrf', severity: 'high', reason: 'request to the Alibaba metadata endpoint (100.100.100.200)', source: 'builtin',
-        pattern: String.raw `(?=.*\b(?:curl|wget|iwr|invoke-webrequest|invoke-restmethod|irm)\b)(?=.*100\.100\.100\.200)` },
+        pattern: sameLine(String.raw `\b(?:curl|wget|iwr|invoke-webrequest|invoke-restmethod|irm)\b`, String.raw `100\.100\.100\.200`) },
     { id: 'credential_exfiltration', category: 'secret_exfiltration', severity: 'critical', reason: 'credential file sent to the network', source: 'builtin',
-        pattern: String.raw `(?=.*\b(?:curl|wget|iwr|invoke-webrequest|invoke-restmethod|scp|nc|ncat)\b)(?=.*(?:\.ssh[\\/]id_(?:rsa|ed25519|ecdsa|dsa)|\.aws[\\/]credentials|application_default_credentials\.json|\.npmrc|\.netrc|\.kube[\\/]config))` },
+        pattern: sameLine(String.raw `\b(?:curl|wget|iwr|invoke-webrequest|invoke-restmethod|scp|nc|ncat)\b`, String.raw `(?:\.ssh[\\/]id_(?:rsa|ed25519|ecdsa|dsa)|\.aws[\\/]credentials|application_default_credentials\.json|\.npmrc|\.netrc|\.kube[\\/]config)`) },
     // Infra destroy — spec-compiled where flags matter (order-independent).
     compileSpec({ id: 'terraform_destroy_auto', category: 'infra_destroy', severity: 'high', reason: 'terraform destroy with auto-approve',
         command: ['terraform'], extra: [String.raw `\bdestroy\b`], flags: [String.raw `--auto-approve`] }),
@@ -616,25 +654,32 @@ function evaluateShellCommand(line, rules = activeShellGuardRules()) {
     }).filter((x) => !!x);
     // Whole line first (some rules intentionally span a pipe, e.g. curl | sh),
     // then each &&/||/;/newline segment (catches "cleanup && del /s c:\").
-    const candidates = [line, ...line.split(/&&|\|\||[;&\n]|\|/).map(s => s.trim()).filter(Boolean)];
+    // Built-in rules judge the execution view — quoted prose (a grep pattern, a
+    // commit message) is inert — exactly as the live PowerShell / cmd / posix
+    // guards do; org custom rules see the raw line, as they do there.
+    const segmentsOf = (text) => [text, ...text.split(/&&|\|\||[;&\n]|\|/).map(s => s.trim()).filter(Boolean)];
+    const views = [[false, segmentsOf((0, deterministicGuard_1.stripInertDataSegments)(line))], [true, segmentsOf(line)]];
     const seen = new Set();
     const matches = [];
-    for (const candidate of candidates) {
-        const norm = candidate.replace(/\s+/g, ' ').trim();
-        for (const { rule, re } of compiled) {
-            try {
-                if (re.test(norm) || re.test(candidate)) {
-                    const key = `${rule.id}|${candidate}`;
-                    if (seen.has(key))
-                        continue;
-                    seen.add(key);
-                    matches.push({ rule, segment: candidate });
-                    break; // first rule per segment is enough
+    for (const [custom, candidates] of views)
+        for (const candidate of candidates) {
+            const norm = candidate.replace(/\s+/g, ' ').trim();
+            for (const { rule, re } of compiled) {
+                if ((rule.source === 'custom') !== custom)
+                    continue;
+                try {
+                    if (re.test(norm) || re.test(candidate)) {
+                        const key = `${rule.id}|${candidate}`;
+                        if (seen.has(key))
+                            continue;
+                        seen.add(key);
+                        matches.push({ rule, segment: candidate });
+                        break; // first rule per segment is enough
+                    }
                 }
+                catch { /* skip bad regex */ }
             }
-            catch { /* skip bad regex */ }
         }
-    }
     return matches;
 }
 /**
@@ -733,7 +778,7 @@ function buildGuardPs1(nodePath, cliEntry) {
         `# false-negative-safe. Single-token quoted args stay: argv (rm -rf "/").`,
         `function global:Get-FcdExecView {`,
         `  param([string]$CommandLine)`,
-        String.raw `  if ($CommandLine -match '(?i)\b(?:iex|invoke-expression|invoke-command)\b|\beval\b|\bxargs\b|\bbase64\b[^\n]*(?:-d\b|--decode\b)|frombase64string|-encodedcommand\b|\s-enc\s|\|\s*&?\s*(?:sh|bash|zsh|dash|ksh|csh|pwsh|powershell(?:\.exe)?|cmd(?:\.exe)?|node|python[0-9.]*|perl|ruby)\b|\b(?:sh|bash|zsh|dash|ksh|csh|pwsh|powershell(?:\.exe)?|cmd(?:\.exe)?|node|python[0-9.]*|perl|ruby)\s+(?:-c|/c|-e|-command|-scriptblock)\b|\b(?:ssh|wsl(?:\.exe)?|chroot)\b|\b(?:docker|kubectl|podman|nerdctl)(?:\.exe)?\s+(?:exec|run)\b') { return $CommandLine }`,
+        String.raw `  if ($CommandLine -match '(?i)\b(?:iex|invoke-expression|invoke-command)\b|\beval\b|\bxargs\b|\bbase64\b[^\n]*(?:-d\b|--decode\b)|frombase64string|-encodedcommand\b|\s-enc\s|(?<!\|)\|(?!\|)\s*&?\s*(?:sh|bash|zsh|dash|ksh|csh|pwsh|powershell(?:\.exe)?|cmd(?:\.exe)?|node|python[0-9.]*|perl|ruby)\b|\b(?:sh|bash|zsh|dash|ksh|csh|pwsh|powershell(?:\.exe)?|cmd(?:\.exe)?|node|python[0-9.]*|perl|ruby)\s+(?:-c|/c|-e|-command|-scriptblock)\b|\b(?:ssh|wsl(?:\.exe)?|chroot)\b|\b(?:docker|kubectl|podman|nerdctl)(?:\.exe)?\s+(?:exec|run)\b') { return $CommandLine }`,
         `  $out = $CommandLine`,
         "  $interp = '\\$\\(|" + '`[^`]{2,}`' + "'",
         "  $keepIfInterpolates = [System.Text.RegularExpressions.MatchEvaluator]{ param($m) if ($m.Value -match $interp) { $m.Value } else { ' fcd_inert_data ' } }",

package/dist/commands/uninstallAll.d.ts

@@ -28,13 +28,7 @@ export declare function removeFcdConfigBackups(): {
 export declare function purgeLocalState(config: BotGuardConfig): {
     failures: string[];
 };
-/**
- * Product code of the installed FullCourtDefense MSI, from the registry
- * uninstall hive (both 64-bit and WOW6432Node views). Undefined on npm
- * installs or when the MSI entry is missing.
- */
-export declare function parseMsiProductCodeFromRegOutput(output: string): string | undefined;
-export declare function findMsiProductCode(): string | undefined;
+export { findMsiProductCode, parseMsiProductCodeFromRegOutput } from '../msiProductCode';
 /**
  * `fullcourtdefense detach` — reverse `onboard`/`install-all` protection but
  * KEEP machine credentials and the installed application, so the machine can