@westbayberry/dg 2.0.11 → 2.2.0

package/dist/launcher/env.js

@@ -1,53 +1,100 @@
+import { dirname } from "node:path";
+import { proxyUrlWithAuth, readProxyAuthToken } from "../proxy/auth.js";
+// The client read timeout must exceed the proxy's per-artifact verdict ceiling
+// (DG_INSTALL_VERDICT_TIMEOUT_MS, default 240s) plus download headroom, so the
+// package manager never gives up on a legitimately-slow verify. Overridable for
+// constrained environments via DG_CLIENT_READ_TIMEOUT_S.
+function clientReadTimeoutSeconds(env) {
+    const override = Number(env.DG_CLIENT_READ_TIMEOUT_S);
+    if (Number.isFinite(override) && override > 0) {
+        return Math.ceil(override);
+    }
+    const verdictMs = Number(env.DG_INSTALL_VERDICT_TIMEOUT_MS);
+    const verdictSeconds = Number.isFinite(verdictMs) && verdictMs > 0 ? verdictMs / 1000 : 240;
+    return Math.ceil(verdictSeconds + 60);
+}
 export function buildProxyChildEnv(options) {
+    const authToken = readProxyAuthToken(dirname(options.caBundlePath));
+    const proxyUrl = authToken ? proxyUrlWithAuth(options.proxyUrl, authToken) : options.proxyUrl;
     const env = {
         ...options.baseEnv,
         DG_PROXY_ACTIVE: "1"
     };
-    const noProxy = mergeNoProxy(options.baseEnv.NO_PROXY ?? options.baseEnv.no_proxy, options.noProxyHosts ?? ["127.0.0.1", "localhost"]);
+    // The wrapped package manager and every lifecycle/postinstall script it runs
+    // are untrusted. The dg account credential must never reach them; only the
+    // trusted proxy worker (which makes the authenticated API calls) keeps it.
+    delete env.DG_API_KEY;
+    delete env.DG_API_TOKEN;
+    // dg fully controls NO_PROXY (loopback only). An inherited NO_PROXY that names
+    // the registry (or a `*`/`.org` glob) would route the manager straight past the
+    // firewall, so the inherited value is dropped, not merged.
+    const noProxy = (options.noProxyHosts ?? ["127.0.0.1", "localhost"]).join(",");
+    env.NO_PROXY = noProxy;
+    env.no_proxy = noProxy;
+    const readTimeoutSeconds = clientReadTimeoutSeconds(options.baseEnv);
     if (["npm", "npx", "pnpm", "pnpx", "yarn"].includes(options.manager)) {
-        env.HTTP_PROXY = options.proxyUrl;
-        env.HTTPS_PROXY = options.proxyUrl;
-        env.npm_config_proxy = options.proxyUrl;
-        env.npm_config_https_proxy = options.proxyUrl;
-        env.NO_PROXY = noProxy;
+        env.HTTP_PROXY = proxyUrl;
+        env.HTTPS_PROXY = proxyUrl;
+        env.npm_config_proxy = proxyUrl;
+        env.npm_config_https_proxy = proxyUrl;
         env.NODE_EXTRA_CA_CERTS = options.caBundlePath;
+        // The proxy withholds every artifact byte until its verdict resolves, so the
+        // package manager sees no response data until then. Its own network read
+        // timeout must outlast the proxy's worst-case verdict wait or it aborts a
+        // legitimate install mid-verify (pip's 15s default is what made large cold
+        // installs fail). Set it explicitly so a user-lowered global config can't
+        // undercut the proxy.
+        env.npm_config_fetch_timeout = String(readTimeoutSeconds * 1000);
+        if (options.manager === "yarn") {
+            env.YARN_NETWORK_TIMEOUT = String(readTimeoutSeconds * 1000);
+        }
+        if (options.manager === "yarn") {
+            // Yarn Berry (2+) ignores HTTP(S)_PROXY/npm_config_*; without its own
+            // proxy + CA config it fetches straight from the registry, bypassing the
+            // firewall. Classic Yarn ignores these YARN_ vars, so set them for both.
+            env.YARN_HTTP_PROXY = proxyUrl;
+            env.YARN_HTTPS_PROXY = proxyUrl;
+            env.YARN_HTTPS_CA_FILE_PATH = options.caBundlePath;
+        }
         if (options.cacheDir) {
             env.npm_config_cache = options.cacheDir;
             if (options.manager === "yarn") {
+                // Both: YARN_CACHE_FOLDER is Berry's per-project cache, but Berry 2+
+                // defaults to a shared global cache (~/.yarn/berry) that a warm install
+                // serves from without ever fetching, so redirect that too.
                 env.YARN_CACHE_FOLDER = options.cacheDir;
+                env.YARN_GLOBAL_FOLDER = options.cacheDir;
             }
         }
         return env;
     }
     if (options.manager === "pip" || options.manager === "pipx") {
-        env.http_proxy = options.proxyUrl;
-        env.https_proxy = options.proxyUrl;
-        env.no_proxy = noProxy;
+        env.http_proxy = proxyUrl;
+        env.https_proxy = proxyUrl;
         env.REQUESTS_CA_BUNDLE = options.caBundlePath;
         env.PIP_CERT = options.caBundlePath;
         env.PIP_NO_CACHE_DIR = "1";
+        env.PIP_DEFAULT_TIMEOUT = String(readTimeoutSeconds);
         return env;
     }
     if (options.manager === "uv" || options.manager === "uvx") {
-        env.HTTP_PROXY = options.proxyUrl;
-        env.HTTPS_PROXY = options.proxyUrl;
-        env.ALL_PROXY = options.proxyUrl;
-        env.NO_PROXY = noProxy;
+        env.HTTP_PROXY = proxyUrl;
+        env.HTTPS_PROXY = proxyUrl;
+        env.ALL_PROXY = proxyUrl;
         env.SSL_CERT_FILE = options.caBundlePath;
         env.UV_NO_CACHE = "1";
+        env.UV_HTTP_TIMEOUT = String(readTimeoutSeconds);
         return env;
     }
-    env.HTTPS_PROXY = options.proxyUrl;
-    env.https_proxy = options.proxyUrl;
-    env.http_proxy = options.proxyUrl;
-    env.NO_PROXY = noProxy;
+    env.HTTPS_PROXY = proxyUrl;
+    env.https_proxy = proxyUrl;
+    env.http_proxy = proxyUrl;
     env.CARGO_HTTP_CAINFO = options.caBundlePath;
-    return env;
-}
-function mergeNoProxy(existing, required) {
-    const values = new Set((existing ?? "").split(",").map((part) => part.trim()).filter(Boolean));
-    for (const host of required) {
-        values.add(host);
+    env.CARGO_HTTP_TIMEOUT = String(readTimeoutSeconds);
+    if (options.cacheDir) {
+        // cargo serves a cached crate from ~/.cargo with zero network, skipping the
+        // firewall; pointing CARGO_HOME at the throwaway dir forces a re-fetch.
+        env.CARGO_HOME = options.cacheDir;
     }
-    return [...values].join(",");
+    return env;
 }

package/dist/launcher/install-preflight.js

@@ -1,8 +1,48 @@
 import { spawn } from "node:child_process";
 import { createInterface } from "node:readline";
 import { analyzePackages } from "../api/analyze.js";
+import { loadUserConfig } from "../config/settings.js";
+import { matchDecision, packageKey } from "../decisions/apply.js";
+import { offerRememberOnIo } from "../decisions/remember-prompt.js";
+import { provenanceDowngradeLine } from "../presentation/provenance.js";
 import { defaultPromptIo } from "../install-ui/prompt.js";
+import { cooldownRequestParam, formatCooldownDuration, formatPackageAge, isCooldownExempt, isCooldownExemptByDgFile } from "../policy/cooldown.js";
+import { findProjectRoot, loadDgFile, resolveAcceptedBy, warnUnreadableDgFile } from "../project/dgfile.js";
 import { parsePipReportInstallCount, parsePipReportInstallSet } from "./pip-report.js";
+import { resolveSpawnInvocation } from "./spawn-invocation.js";
+export function resolvePreflightCooldown(env, ecosystem) {
+    try {
+        const config = loadUserConfig(env);
+        const param = cooldownRequestParam(config, env, ecosystem, "");
+        return param ? { param, exempt: config.cooldown.exempt, ecosystem } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isQuarantined(pkg, context, dgExemptions = []) {
+    if (!context || !pkg.cooldown) {
+        return false;
+    }
+    if (isCooldownExempt(pkg.name, context.exempt, context.ecosystem)
+        || isCooldownExemptByDgFile(pkg.name, context.ecosystem, dgExemptions)) {
+        return false;
+    }
+    return pkg.cooldown.status === "quarantine"
+        || (pkg.cooldown.status === "unknown" && context.param.onUnknown === "block");
+}
+export function resolvePreflightDecisions(ecosystem, cwd, env = process.env) {
+    const root = findProjectRoot(cwd, env);
+    if (!root) {
+        return null;
+    }
+    const file = loadDgFile(root);
+    warnUnreadableDgFile(file);
+    if (!file.readable) {
+        return null;
+    }
+    return { root, file, ecosystem, env };
+}
 const PROCEED = { proceed: true };
 const UNRESOLVED = { set: undefined, count: undefined };
 const approvedFlagRanks = new Map();
@@ -32,6 +72,15 @@ export function cachedPipResolution(binary, args) {
 function pipResolutionKey(binary, args) {
     return JSON.stringify([binary, ...args]);
 }
+// pip's dry-run resolve downloads sdists/wheels it cannot get PEP 658
+// metadata for, so big dependency trees legitimately take minutes on a cold
+// pip cache. A short timeout here silently skips the preflight (and with it
+// the batched analyze + preverified handoff), pushing every package onto the
+// slow per-artifact verdict path.
+function pipResolveTimeoutMs(env) {
+    const raw = Number(env.DG_PIP_RESOLVE_TIMEOUT_MS);
+    return Number.isFinite(raw) && raw > 0 ? raw : 120_000;
+}
 function resolvePipInstallSet(binary, args, env) {
     if (!binary)
         return Promise.resolve(UNRESOLVED);
@@ -49,9 +98,11 @@ function resolvePipInstallSet(binary, args, env) {
         };
         let child;
         try {
-            child = spawn(binary, [...args, "--dry-run", "--report", "-", "--quiet"], {
+            const invocation = resolveSpawnInvocation(binary, [...args, "--dry-run", "--report", "-", "--quiet"]);
+            child = spawn(invocation.command, [...invocation.args], {
                 env,
-                stdio: ["ignore", "pipe", "ignore"]
+                stdio: ["ignore", "pipe", "ignore"],
+                windowsVerbatimArguments: invocation.windowsVerbatimArguments
             });
         }
         catch {
@@ -64,7 +115,7 @@ function resolvePipInstallSet(binary, args, env) {
             }
             catch { /* already exited */ }
             finish(UNRESOLVED);
-        }, 30_000);
+        }, pipResolveTimeoutMs(env));
         child.stdout?.on("data", (chunk) => { stdout += chunk.toString("utf8"); });
         child.on("error", () => finish(UNRESOLVED));
         child.on("close", (code) => finish(code === 0
@@ -75,18 +126,48 @@ function resolvePipInstallSet(binary, args, env) {
 function findingSummary(pkg) {
     return pkg.reasons[0] ?? pkg.findings[0]?.title ?? pkg.findings[0]?.id ?? "flagged";
 }
+function cooldownSummary(pkg) {
+    const cooldown = pkg.cooldown;
+    if (!cooldown) {
+        return "release too new";
+    }
+    const window = cooldown.requiredDays !== undefined ? formatCooldownDuration(cooldown.requiredDays) : "your cooldown";
+    if (cooldown.ageDays === undefined) {
+        return `publish time unknown; cooldown ${window}`;
+    }
+    return `published ${formatPackageAge(cooldown.ageDays)}; cooldown ${window}`;
+}
 function renderPreflight(flagged, out) {
-    const blocks = flagged.filter((pkg) => pkg.action === "block").length;
+    const blocks = flagged.filter((entry) => entry.action === "block").length;
     const noun = flagged.length === 1 ? "package" : "packages";
     const tail = blocks > 0 ? ` (${blocks} blocked)` : "";
     out.write(`\n  DG flagged ${flagged.length} ${noun} before install${tail}:\n`);
-    for (const pkg of flagged) {
-        const tag = pkg.action === "block" ? "block" : "warn";
-        out.write(`    ${pkg.name}@${pkg.version}   ${tag}   ${findingSummary(pkg)}\n`);
+    for (const entry of flagged) {
+        const tag = entry.viaCooldown ? "cooldown" : entry.action === "block" ? "block" : "warn";
+        const summary = entry.viaCooldown ? cooldownSummary(entry.pkg) : findingSummary(entry.pkg);
+        out.write(`    ${entry.pkg.name}@${entry.pkg.version}   ${tag}   ${summary}${provenanceSuffix(entry.pkg)}\n`);
+    }
+    out.write("\n");
+}
+function provenanceSuffix(pkg) {
+    const prov = pkg.provenance;
+    if (!prov || prov.status === "unknown") {
+        return "";
+    }
+    return `   provenance: ${prov.status}`;
+}
+export function renderProvenanceDowngrades(packages, out) {
+    const downgraded = packages.filter((pkg) => pkg.provenance?.downgrade);
+    if (downgraded.length === 0) {
+        return;
     }
     out.write("\n");
+    for (const pkg of downgraded) {
+        const line = provenanceDowngradeLine(pkg.version, pkg.provenance);
+        out.write(`  ⚠ ${pkg.name}@${pkg.version}: ${line} (display only, verdict unchanged)\n`);
+    }
 }
-export async function runInstallPreflight(manager, binary, childArgs, env) {
+export async function runInstallPreflight(manager, binary, childArgs, env, cwd = process.cwd(), beforeInteraction) {
     if (manager !== "pip" || !binary) {
         return PROCEED;
     }
@@ -97,32 +178,101 @@ export async function runInstallPreflight(manager, binary, childArgs, env) {
         pipResolutions.set(key, resolution);
     }
     const set = resolution.set;
-    if (!set || set.length === 0) {
+    if (!set) {
+        process.stderr.write("  dg: could not resolve the install set ahead of time — verifying during install instead\n");
         return PROCEED;
     }
+    if (set.length === 0) {
+        return PROCEED;
+    }
+    const cooldownContext = resolvePreflightCooldown(env, "pypi");
     let verdicts;
     try {
-        verdicts = await analyzePackages(set.map((pkg) => ({ name: pkg.name, version: pkg.version })), { ecosystem: "pypi", env });
+        verdicts = await analyzePackages(set.map((pkg) => ({ name: pkg.name, version: pkg.version })), { ecosystem: "pypi", env, ...(cooldownContext ? { cooldown: cooldownContext.param } : {}) });
     }
     catch {
+        process.stderr.write("  dg: pre-install check unavailable — verifying during install instead\n");
         return PROCEED;
     }
-    return decideFromVerdicts(verdicts.packages, defaultPromptIo());
+    beforeInteraction?.();
+    const decision = await decideFromVerdicts(verdicts.packages, defaultPromptIo(), cooldownContext, resolvePreflightDecisions("pypi", cwd, env));
+    if (!decision.proceed || decision.forceOverride) {
+        return decision;
+    }
+    const preverified = preverifiedEntries(verdicts.packages, cooldownContext !== undefined);
+    return preverified.length > 0 ? { ...decision, preverified } : decision;
+}
+export function preverifiedEntries(packages, cooldownRequested) {
+    return packages
+        .filter((pkg) => pkg.action === "pass" || pkg.action === "warn")
+        .map((pkg) => ({
+        ecosystem: "pypi",
+        name: pkg.name,
+        version: pkg.version,
+        action: pkg.action,
+        ...(pkg.reasons[0] ? { reason: pkg.reasons[0] } : {}),
+        ...(typeof pkg.artifactSha256 === "string" && pkg.artifactSha256.length > 0 ? { scannedSha256: pkg.artifactSha256 } : {}),
+        cooldownEvaluated: cooldownRequested && pkg.cooldown !== undefined
+    }));
 }
-export async function decideFromVerdicts(packages, io) {
-    const flagged = packages.filter((pkg) => (pkg.action === "warn" || pkg.action === "block") && !isPreflightApproved({ name: pkg.name, version: pkg.version, action: pkg.action }));
-    if (flagged.length === 0 || !io.isTTY) {
+export async function decideFromVerdicts(packages, io, cooldownContext, decisions = null) {
+    if (io.isTTY) {
+        renderProvenanceDowngrades(packages, io.output);
+    }
+    const covered = [];
+    const entries = packages
+        .map((pkg) => {
+        const viaCooldown = isQuarantined(pkg, cooldownContext, decisions?.file.cooldownExemptions ?? []) && pkg.action !== "block";
+        const action = viaCooldown ? "block" : pkg.action ?? "pass";
+        return { pkg, action, viaCooldown };
+    })
+        .filter((entry) => {
+        if ((entry.action !== "warn" && entry.action !== "block")
+            || isPreflightApproved({ name: entry.pkg.name, version: entry.pkg.version, action: entry.action })) {
+            return false;
+        }
+        if (decisions && entry.action === "warn" && matchDecision(entry.pkg, decisions.ecosystem, decisions.file.decisions).acknowledged) {
+            covered.push(entry.pkg);
+            return false;
+        }
+        return true;
+    });
+    if (covered.length > 0 && io.isTTY) {
+        renderCoveredWarns(covered, decisions, io.output);
+        recordPreflightApprovals(covered.map((pkg) => ({ name: pkg.name, version: pkg.version, action: "warn" })));
+    }
+    if (entries.length === 0 || !io.isTTY) {
         return PROCEED;
     }
-    renderPreflight(flagged, io.output);
-    const hasBlock = flagged.some((pkg) => pkg.action === "block");
+    renderPreflight(entries, io.output);
+    const hasBlock = entries.some((entry) => entry.action === "block");
     const accepted = await promptPreflightYesNo(hasBlock ? "  Override and install anyway?" : "  Proceed?", io, false);
     if (!accepted) {
         return { proceed: false };
     }
-    recordPreflightApprovals(flagged.map((pkg) => ({ name: pkg.name, version: pkg.version, action: pkg.action ?? "warn" })));
+    recordPreflightApprovals(entries.map((entry) => ({ name: entry.pkg.name, version: entry.pkg.version, action: entry.action })));
+    if (!hasBlock && decisions) {
+        await offerRememberOnIo({
+            io,
+            file: decisions.file,
+            packages: entries
+                .filter((entry) => entry.action === "warn")
+                .map((entry) => ({ ecosystem: decisions.ecosystem, name: entry.pkg.name, version: entry.pkg.version, findings: entry.pkg.findings })),
+            acceptedBy: resolveAcceptedBy(decisions.root, decisions.env ?? process.env),
+            surface: "install preflight",
+            env: decisions.env ?? process.env
+        });
+    }
     return hasBlock ? { proceed: true, forceOverride: { force: true } } : PROCEED;
 }
+export function renderCoveredWarns(covered, decisions, out) {
+    for (const pkg of covered) {
+        const match = decisions ? matchDecision(pkg, decisions.ecosystem, decisions.file.decisions) : { acknowledged: false };
+        const who = match.acknowledged ? match.entry.acceptedBy : "dg.json";
+        const when = match.acknowledged && match.entry.acceptedAt ? ` on ${match.entry.acceptedAt.slice(0, 10)}` : "";
+        out.write(`  ⚠ ${packageKey(pkg.name, pkg.version)} warn previously accepted by ${who}${when} — see 'dg decisions'\n`);
+    }
+}
 export async function promptPreflightYesNo(question, io, defaultYes) {
     if (!io.isTTY) {
         return false;

package/dist/launcher/live-install.js

@@ -1,7 +1,8 @@
-import { createLaunchPlan, runWithProductionProxyLive, EXIT_INSTALL_BLOCKED } from "./run.js";
+import { createLaunchPlan, prepareProxyWorker, runWithProductionProxyLive, EXIT_INSTALL_BLOCKED } from "./run.js";
 import { runInstallPreflight } from "./install-preflight.js";
 import { isSupportedPackageManager } from "./classify.js";
 import { isCiEnv, resolvePresentation } from "../presentation/mode.js";
+import { startPrepSpinner } from "../install-ui/prep-spinner.js";
 const FALL_THROUGH = { handled: false };
 export async function maybeRunLiveInstall(args, options = {}) {
     const env = options.env ?? process.env;
@@ -17,24 +18,43 @@ export async function maybeRunLiveInstall(args, options = {}) {
     if (plan.classification.kind !== "protected" || !plan.realBinary.path) {
         return FALL_THROUGH;
     }
+    const appLoading = import("../install-ui/live-install-app.js");
+    appLoading.catch(() => undefined);
+    let prepared = forceOverride ? undefined : prepareProxyWorker(plan.classification, env);
     let effectiveOverride = forceOverride;
+    let preverified;
     if (!forceOverride) {
-        const preflight = await runInstallPreflight(manager, plan.realBinary.path, childArgs, env);
+        const spinner = startPrepSpinner("DG preparing…");
+        let preflight;
+        try {
+            preflight = await runInstallPreflight(manager, plan.realBinary.path, childArgs, env, process.cwd(), spinner.stop);
+        }
+        finally {
+            spinner.stop();
+        }
         if (!preflight.proceed) {
+            prepared?.discard();
             return { handled: true, result: { exitCode: EXIT_INSTALL_BLOCKED, stdout: "", stderr: "  Install cancelled.\n" } };
         }
         effectiveOverride = preflight.forceOverride;
+        preverified = preflight.preverified;
+        if (effectiveOverride) {
+            prepared?.discard();
+            prepared = undefined;
+        }
     }
     const runOptions = {
         env,
-        ...(effectiveOverride ? { forceOverride: effectiveOverride } : {})
+        ...(effectiveOverride ? { forceOverride: effectiveOverride } : {}),
+        ...(preverified && preverified.length > 0 && !effectiveOverride ? { preverified } : {})
     };
-    const { renderLiveInstall } = await import("../install-ui/live-install-app.js");
     try {
-        const result = await renderLiveInstall((onView) => runWithProductionProxyLive(plan, childArgs, runOptions, onView));
+        const { renderLiveInstall } = await appLoading;
+        const result = await renderLiveInstall((onView) => runWithProductionProxyLive(plan, childArgs, runOptions, onView, prepared));
         return { handled: true, result };
     }
     catch (error) {
+        prepared?.discard();
         return {
             handled: true,
             result: {

package/dist/launcher/output-redaction.js

@@ -1,23 +1,26 @@
 const credentialUrlPattern = /\b([a-z][a-z0-9+.-]{0,31}:\/\/)([^/\s:@]+):([^/\s@]+)@/gi;
 const authHeaderPattern = /\b(proxy-authorization|authorization):\s*[^\r\n]+/gi;
-const tokenAssignmentPattern = /(?<![A-Za-z0-9])([A-Za-z0-9_-]*(?:secret[_-]key|access[_-]key|api[_-]key|token|password|secret))=([^\s]+)/gi;
+// Matches both KEY=value and colon-form (KEY: value, YAML) secret assignments;
+// the separator and any opening quote are preserved in the replacement.
+const tokenAssignmentPattern = /(?<![A-Za-z0-9])([A-Za-z0-9_-]*(?:secret[_-]key|access[_-]key|api[_-]key|token|password|secret))(\s*[:=]\s*)("?)([^\s"]+)/gi;
 const npmrcAuthPattern = /(_authToken|_auth|_password)\s*=\s*("[^"]*"|[^\s;,]+)/gi;
 const jsonSecretPattern = /("[A-Za-z0-9_.$-]*(?:secret[_-]key|access[_-]key|api[_-]key|token|password|secret)"\s*:\s*)"(?:[^"\\]|\\.)*"/gi;
 const bearerPattern = /\bBearer\s+[A-Za-z0-9._~+/=-]{8,}/g;
-const knownTokenShapePattern = /\b(npm_[A-Za-z0-9]{36}|gh[pousr]_[A-Za-z0-9]{36,255}|pypi-[A-Za-z0-9_-]{20,}|glpat-[A-Za-z0-9_-]{20,}|xox[bp]-[A-Za-z0-9-]{10,})\b/g;
+// Bare tokens (not in URL userinfo or KEY=value form), by their published shape.
+const knownTokenShapePattern = /\b(npm_[A-Za-z0-9]{36}|gh[pousr]_[A-Za-z0-9]{36,255}|github_pat_[A-Za-z0-9_]{22,255}|pypi-[A-Za-z0-9_-]{20,}|glpat-[A-Za-z0-9_-]{20,}|hf_[A-Za-z0-9]{30,}|AKIA[0-9A-Z]{16}|ASIA[0-9A-Z]{16}|AIza[0-9A-Za-z_-]{35}|sk_(?:live|test)_[A-Za-z0-9]{20,}|rk_live_[A-Za-z0-9]{20,}|sk-(?:proj-)?[A-Za-z0-9_-]{20,}|xox[abdeprs]-[A-Za-z0-9-]{10,})\b/g;
 export function redactSecrets(text) {
     return text
         .replace(credentialUrlPattern, "$1<redacted>@")
         .replace(authHeaderPattern, (_match, header) => `${header}: <redacted>`)
         .replace(npmrcAuthPattern, "$1=<redacted>")
         .replace(jsonSecretPattern, '$1"<redacted>"')
-        .replace(tokenAssignmentPattern, "$1=<redacted>")
+        .replace(tokenAssignmentPattern, "$1$2$3<redacted>")
         .replace(bearerPattern, "Bearer <redacted>")
         .replace(knownTokenShapePattern, "<redacted>");
 }
 const STREAM_FLUSH_QUIET_MS = 80;
 const SECRET_TAIL_SCAN_CHARS = 80;
-const secretTailPattern = /(Bearer\s+[\w.~+/=-]*|npm_[A-Za-z0-9]*|gh[pousr]_[A-Za-z0-9]*|pypi-[\w-]*|glpat-[\w-]*|xox[bp]-[\w-]*|[\w-]*(?:_authToken|_auth|_password|secret[_-]key|access[_-]key|api[_-]key|token|password|secret)=\S*|"[\w.$-]*(?:secret[_-]key|access[_-]key|api[_-]key|token|password|secret)"\s*:\s*"?[^"\n]*)$/i;
+const secretTailPattern = /(Bearer\s+[\w.~+/=-]*|npm_[A-Za-z0-9]*|gh[pousr]_[A-Za-z0-9]*|github_pat_[A-Za-z0-9_]*|pypi-[\w-]*|glpat-[\w-]*|hf_[A-Za-z0-9]*|AKIA[0-9A-Z]*|ASIA[0-9A-Z]*|AIza[\w-]*|sk_(?:live|test)_[A-Za-z0-9]*|rk_live_[A-Za-z0-9]*|sk-(?:proj-)?[\w-]*|xox[abdeprs]-[\w-]*|[\w-]*(?:_authToken|_auth|_password|secret[_-]key|access[_-]key|api[_-]key|token|password|secret)\s*[:=]\s*"?\S*|"[\w.$-]*(?:secret[_-]key|access[_-]key|api[_-]key|token|password|secret)"\s*:\s*"?[^"\n]*)$/i;
 export function createStreamRedactor(emit) {
     let pending = "";
     let timer;

package/dist/launcher/preflight-prompt.js

@@ -1,11 +1,16 @@
 import { analyzePackages } from "../api/analyze.js";
 import { isCiEnv } from "../presentation/mode.js";
+import { matchDecision } from "../decisions/apply.js";
+import { offerRememberOnIo } from "../decisions/remember-prompt.js";
 import { renderInstallDecision } from "../install-ui/block-render.js";
 import { defaultPromptIo } from "../install-ui/prompt.js";
+import { normalizePypiName } from "../policy/pypi-name.js";
+import { resolveAcceptedBy } from "../project/dgfile.js";
 import { enforceProtectedInstall } from "../proxy/enforcement.js";
 import { classifyPackageManagerInvocation, isSupportedPackageManager } from "./classify.js";
-import { actionRank, promptPreflightYesNo, recordPreflightApprovals } from "./install-preflight.js";
+import { actionRank, promptPreflightYesNo, recordPreflightApprovals, renderCoveredWarns, renderProvenanceDowngrades, resolvePreflightDecisions } from "./install-preflight.js";
 import { redactSecrets } from "./output-redaction.js";
+import { startPrepSpinner } from "../install-ui/prep-spinner.js";
 const ECOSYSTEM_BY_MANAGER = {
     npm: "npm",
     pnpm: "npm",
@@ -38,25 +43,42 @@ export async function maybePreflightInstallPrompt(args, options = {}) {
     if (specs.length === 0) {
         return FALL_THROUGH;
     }
+    const decisions = options.decisionsCwd ? resolvePreflightDecisions(ecosystem, options.decisionsCwd, env) : null;
     const flagged = [];
+    const covered = [];
+    const spinner = startPrepSpinner("DG preparing…");
     try {
         const response = await (options.analyze ?? analyzePackages)(specs.map((spec) => ({ name: spec.name, version: spec.version })), { ecosystem, env });
+        spinner.stop();
+        renderProvenanceDowngrades(response.packages, io.output);
         for (const spec of specs) {
-            const pkg = response.packages.find((entry) => entry.name === spec.name && entry.version === spec.version);
+            const pkg = response.packages.find((entry) => sameSpecName(entry.name, spec.name, ecosystem) && entry.version === spec.version);
             const action = pkg?.action ?? "pass";
             if (action === "pass") {
                 continue;
             }
+            if (decisions && pkg && action === "warn" && matchDecision(pkg, decisions.ecosystem, decisions.file.decisions).acknowledged) {
+                covered.push(pkg);
+                continue;
+            }
             flagged.push({
                 action,
                 spec,
-                reason: pkg?.reasons[0] ?? pkg?.findings[0]?.title ?? "flagged by the scanner"
+                reason: pkg?.reasons[0] ?? pkg?.findings[0]?.title ?? "flagged by the scanner",
+                findings: pkg?.findings ?? []
             });
         }
     }
     catch {
         return FALL_THROUGH;
     }
+    finally {
+        spinner.stop();
+    }
+    if (covered.length > 0) {
+        renderCoveredWarns(covered, decisions, io.output);
+        recordPreflightApprovals(covered.map((pkg) => ({ name: pkg.name, version: pkg.version, action: "warn" })));
+    }
     const worst = flagged.reduce((top, entry) => (!top || actionRank(entry.action) > actionRank(top.action) ? entry : top), undefined);
     if (!worst) {
         return FALL_THROUGH;
@@ -97,6 +119,18 @@ export async function maybePreflightInstallPrompt(args, options = {}) {
     const proceed = await promptPreflightYesNo(`⚠ DG flagged ${label} (warn) — ${worst.reason}. Proceed?`, io, false);
     if (proceed) {
         recordPreflightApprovals(flagged.map(asFlaggedPackage));
+        if (decisions) {
+            await offerRememberOnIo({
+                io,
+                file: decisions.file,
+                packages: flagged
+                    .filter((entry) => entry.action === "warn")
+                    .map((entry) => ({ ecosystem, name: entry.spec.name, version: entry.spec.version, findings: entry.findings })),
+                acceptedBy: resolveAcceptedBy(decisions.root, env),
+                surface: "install preflight",
+                env
+            });
+        }
         return FALL_THROUGH;
     }
     return {
@@ -104,6 +138,12 @@ export async function maybePreflightInstallPrompt(args, options = {}) {
         result: { exitCode: 1, stdout: "", stderr: "Declined. Nothing was installed.\n" }
     };
 }
+function sameSpecName(entryName, specName, ecosystem) {
+    if (ecosystem === "pypi") {
+        return normalizePypiName(entryName) === normalizePypiName(specName);
+    }
+    return entryName === specName;
+}
 function asFlaggedPackage(entry) {
     return {
         name: entry.spec.name,