@westbayberry/dg 2.1.0 → 2.3.0

package/dist/launcher/run.js

@@ -3,46 +3,77 @@ import { existsSync, writeFileSync } from "node:fs";
 import { constants as osConstants } from "node:os";
 import { fileURLToPath } from "node:url";
 import { EXIT_UNAVAILABLE } from "../commands/types.js";
-import { loadUserConfig } from "../config/settings.js";
+import { loadUserConfig, trustsProjectOverrides } from "../config/settings.js";
+import { findProjectRoot, loadDgFile } from "../project/dgfile.js";
+import { honoredOverrides } from "../project/override-trust.js";
+import { writeCooldownExemptionsFile } from "../proxy/cooldown-exemptions-file.js";
+import { writePreverifiedFile } from "../proxy/preverified.js";
 import { describeBlockedInstall, describeFlaggedWarn, renderInstallDecision } from "../install-ui/block-render.js";
 import { enforceProtectedInstall } from "../proxy/enforcement.js";
 import { isCiEnv, resolvePresentation } from "../presentation/mode.js";
+import { maybeSetupNudge } from "../runtime/nudges.js";
 import { createTheme } from "../presentation/theme.js";
 import { readProxySessionState } from "../proxy/server.js";
+import { readServiceState } from "../service/state.js";
 import { cleanupSessionSync, createSessionSync, resolveDgPaths } from "../state/index.js";
 import { classifyPackageManagerInvocation } from "./classify.js";
-import { buildProxyChildEnv } from "./env.js";
+import { buildProxyChildEnv, scrubChildSecrets } from "./env.js";
+import { prepareCargoHome, userCargoHome } from "./cargo-cache.js";
 import { cachedPipResolution } from "./install-preflight.js";
-import { parsePipReportInstallCount } from "./pip-report.js";
 import { createStreamRedactor, redactSecrets } from "./output-redaction.js";
+import { resolveSpawnInvocation } from "./spawn-invocation.js";
 import { resolveRealBinary } from "./resolve-real-binary.js";
-import { runScriptGateAfterInstall } from "../scripts/gate.js";
+import { runScriptGateAfterInstall, scriptGateChildEnv, scriptGateInstallArgs } from "../scripts/gate.js";
 export const EXIT_INSTALL_BLOCKED = 2;
-const CMD_SCRIPT_PATTERN = /\.(cmd|bat)$/i;
-const CMD_META_CHARS = /([()\][%!^"`<>&|;, *?])/g;
-export function resolveSpawnInvocation(binary, args, platform = process.platform) {
-    if (platform !== "win32" || !CMD_SCRIPT_PATTERN.test(binary)) {
-        return { command: binary, args, windowsVerbatimArguments: false };
-    }
-    const commandLine = [escapeCmdCommand(binary), ...args.map(escapeCmdArgument)].join(" ");
-    return {
-        command: process.env.comspec ?? "cmd.exe",
-        args: ["/d", "/s", "/c", `"${commandLine}"`],
-        windowsVerbatimArguments: true
-    };
-}
-function escapeCmdCommand(command) {
-    return command.replace(CMD_META_CHARS, "^$1");
-}
-// cmd shims parse their command line twice, hence the doubled meta-char escape (cross-spawn's algorithm)
-function escapeCmdArgument(argument) {
-    const quoted = `"${argument.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\*)$/, "$1$1")}"`;
-    return quoted.replace(CMD_META_CHARS, "^$1").replace(CMD_META_CHARS, "^$1");
-}
+export { resolveSpawnInvocation } from "./spawn-invocation.js";
 export function shimDepth(env) {
     const parsed = Number.parseInt(env.DG_SHIM_DEPTH ?? "", 10);
     return Number.isInteger(parsed) && parsed > 0 ? parsed : 0;
 }
+// A genuine parent dg proxy sets DG_PROXY_ACTIVE=1 and routes the child through a
+// loopback proxy URL that carries the proxy's auth token (buildProxyChildEnv ->
+// proxyUrlWithAuth). All of these must hold for a nested invocation to safely run
+// the real package manager directly (its traffic still flows through the live
+// parent proxy). DG_PROXY_ACTIVE + a bare loopback URL are both forgeable, so:
+//  - the URL must carry a dg auth token (a forged HTTPS_PROXY=http://127.0.0.1:1
+//    with no credential is rejected), and
+//  - when a persistent dg service is the parent (the agent-routing case), the URL
+//    must match that live service's proxy, so a forged token cannot impersonate it.
+// If neither matches, we start our own verifying proxy rather than trust the env.
+export function inheritedDgProxyActive(env) {
+    if (env.DG_PROXY_ACTIVE !== "1") {
+        return false;
+    }
+    const proxyUrl = env.HTTPS_PROXY ?? env.https_proxy ?? env.HTTP_PROXY ?? env.http_proxy;
+    if (!proxyUrl) {
+        return false;
+    }
+    let url;
+    try {
+        url = new URL(proxyUrl);
+    }
+    catch {
+        return false;
+    }
+    const host = url.hostname.replace(/^\[(.*)\]$/, "$1");
+    if (host !== "127.0.0.1" && host !== "::1" && host !== "localhost") {
+        return false;
+    }
+    if (!url.username && !url.password) {
+        return false;
+    }
+    try {
+        const { state } = readServiceState(env);
+        if (state.running && state.proxy) {
+            const live = new URL(state.proxy.proxyUrl);
+            return live.hostname.replace(/^\[(.*)\]$/, "$1") === host && live.port === url.port;
+        }
+    }
+    catch {
+        // No readable service state — fall through to the session-proxy path below.
+    }
+    return true;
+}
 export function rootUnprotectedNotice(env, uid = process.getuid?.()) {
     if (uid !== 0) {
         return "";
@@ -74,11 +105,11 @@ export function createLaunchPlan(manager, args, env = process.env) {
         classification,
         realBinary,
         startsProxy: classification.kind === "protected",
-        childEnv: {
+        childEnv: scrubChildSecrets({
             ...env,
             DG_SHIM_ACTIVE: shimNonce(manager, env),
             DG_SHIM_DEPTH: String(shimDepth(env) + 1)
-        }
+        })
     };
 }
 export async function runPackageManager(manager, args, options = {}) {
@@ -99,15 +130,20 @@ export async function runPackageManager(manager, args, options = {}) {
             stderr: `dg: ${manager} shim exec loop detected (DG_SHIM_DEPTH=${depth}) — refusing to re-enter\n`
         };
     }
-    if (depth === 1 && plan.startsProxy) {
-        const child = await spawnPackageManager(plan, args, options);
-        return {
-            exitCode: child.exitCode,
-            stdout: streamedOut(child.stdout, options),
-            stderr: `dg: re-entered through its own shim — running the real ${plan.classification.realBinaryName} directly\n${streamedErr(child.stderr, options)}`
-        };
-    }
     if (plan.startsProxy) {
+        // Reuse a parent dg proxy ONLY when one is genuinely live in this environment
+        // (the parent set DG_PROXY_ACTIVE and a loopback proxy URL). An env var such as
+        // a forged or stale DG_SHIM_DEPTH must never be what decides to skip
+        // verification: if no live dg proxy is detected, start one rather than run the
+        // install unproxied. DG_SHIM_DEPTH is only the >=2 infinite-recursion backstop.
+        if (inheritedDgProxyActive(options.env ?? process.env)) {
+            const child = await spawnPackageManager(plan, args, options);
+            return {
+                exitCode: child.exitCode,
+                stdout: streamedOut(child.stdout, options),
+                stderr: `dg: re-entered through its own shim — running the real ${plan.classification.realBinaryName} directly\n${streamedErr(child.stderr, options)}`
+            };
+        }
         if (!options.proxyVerdict) {
             return runWithProductionProxy(plan, args, options);
         }
@@ -130,7 +166,7 @@ export async function runPackageManager(manager, args, options = {}) {
         return {
             exitCode: child.exitCode,
             stdout: streamedOut(child.stdout, options),
-            stderr: `${rendered}${streamedErr(child.stderr, options)}${scriptGateLine(plan, child.exitCode, options)}`
+            stderr: `${rendered}${streamedErr(child.stderr, options)}${scriptGateLine(plan, child.exitCode, options)}${setupNudgeAfterInstall(plan, child.exitCode, options)}`
         };
     }
     const child = await spawnPackageManager(plan, args, options);
@@ -152,6 +188,7 @@ async function runWithProductionProxy(plan, args, options) {
     }
     const restoreSignalHandlers = installProxySignalHandlers(proxy);
     try {
+        const cacheDir = prepareProxyCacheDir(plan.classification.manager, proxy.session.dir, env);
         const proxiedPlan = {
             ...plan,
             childEnv: buildProxyChildEnv({
@@ -159,7 +196,7 @@ async function runWithProductionProxy(plan, args, options) {
                 baseEnv: plan.childEnv,
                 proxyUrl: proxy.proxyUrl,
                 caBundlePath: proxy.session.files.ca,
-                cacheDir: `${proxy.session.dir}/pm-cache`
+                cacheDir
             })
         };
         const child = await spawnPackageManager(proxiedPlan, args, options);
@@ -196,7 +233,7 @@ async function runWithProductionProxy(plan, args, options) {
         return {
             exitCode: child.exitCode,
             stdout: streamedOut(child.stdout, options),
-            stderr: `${rendered}${streamedErr(child.stderr, options)}${scriptGateLine(plan, child.exitCode, options)}`
+            stderr: `${rendered}${streamedErr(child.stderr, options)}${scriptGateLine(plan, child.exitCode, options)}${setupNudgeAfterInstall(plan, child.exitCode, options)}`
         };
     }
     finally {
@@ -214,6 +251,12 @@ function scriptGateLine(plan, exitCode, options) {
         ...(options.projectDir ? { projectDir: options.projectDir } : {})
     });
 }
+function setupNudgeAfterInstall(plan, exitCode, options) {
+    if (exitCode !== 0) {
+        return "";
+    }
+    return maybeSetupNudge(plan.classification.manager, { env: options.env ?? process.env });
+}
 export function deriveLiveView(state, phase, resolvedTotal) {
     const verified = state.decisions.filter((decision) => decision.action === "pass").length;
     const warnDecisions = state.decisions.filter((decision) => decision.action === "warn");
@@ -232,57 +275,43 @@ export function deriveLiveView(state, phase, resolvedTotal) {
         ...(blocked ? { blocked: describeBlockedInstall(blocked) } : {})
     };
 }
-function resolvePipInstallTotal(binary, args, env, register) {
-    if (!binary)
-        return Promise.resolve(undefined);
-    return new Promise((resolve) => {
-        let stdout = "";
-        let settled = false;
-        let timer;
-        const finish = (value) => {
-            if (settled)
+export function prepareProxyWorker(classification, env) {
+    const worker = startProxyWorker(classification, env, undefined);
+    let discarded = false;
+    return {
+        worker,
+        discard: () => {
+            if (discarded) {
                 return;
-            settled = true;
-            if (timer)
-                clearTimeout(timer);
-            resolve(value);
-        };
-        let child;
-        try {
-            const invocation = resolveSpawnInvocation(binary, [...args, "--dry-run", "--report", "-", "--quiet"]);
-            child = spawn(invocation.command, [...invocation.args], {
-                env,
-                stdio: ["ignore", "pipe", "ignore"],
-                windowsVerbatimArguments: invocation.windowsVerbatimArguments
+            }
+            discarded = true;
+            void worker.then((proxy) => {
+                if (!("decision" in proxy)) {
+                    stopProxyWorker(proxy);
+                }
             });
         }
-        catch {
-            finish(undefined);
-            return;
-        }
-        register(child);
-        timer = setTimeout(() => {
-            try {
-                child.kill();
-            }
-            catch { /* already exited */ }
-            finish(undefined);
-        }, 30_000);
-        child.stdout?.on("data", (chunk) => { stdout += chunk.toString("utf8"); });
-        child.on("error", () => finish(undefined));
-        child.on("close", (code) => finish(code === 0 ? parsePipReportInstallCount(stdout) : undefined));
-    });
+    };
 }
-export async function runWithProductionProxyLive(plan, args, options, onView) {
+export async function runWithProductionProxyLive(plan, args, options, onView, prepared) {
     if (options.onStdout || options.onStderr) {
         throw new Error("live install mode renders its own UI and owns the terminal; streaming output callbacks are not supported");
     }
     const env = options.env ?? process.env;
     maybeWarnRootWithoutState(env);
-    const proxy = await startProxyWorker(plan.classification, env, options.forceOverride);
+    if (prepared && options.forceOverride) {
+        prepared.discard();
+        prepared = undefined;
+    }
+    const proxy = prepared
+        ? await prepared.worker
+        : await startProxyWorker(plan.classification, env, options.forceOverride);
     if ("decision" in proxy) {
         return { exitCode: EXIT_INSTALL_BLOCKED, stdout: "", stderr: redactSecrets(renderInstallDecision(proxy.decision)) };
     }
+    if (options.preverified && options.preverified.length > 0) {
+        writePreverifiedFile(proxy.session.dir, options.preverified);
+    }
     const restoreSignalHandlers = installProxySignalHandlers(proxy);
     try {
         const childEnv = buildProxyChildEnv({
@@ -290,22 +319,11 @@ export async function runWithProductionProxyLive(plan, args, options, onView) {
             baseEnv: plan.childEnv,
             proxyUrl: proxy.proxyUrl,
             caBundlePath: proxy.session.files.ca,
-            cacheDir: `${proxy.session.dir}/pm-cache`
+            cacheDir: prepareProxyCacheDir(plan.classification.manager, proxy.session.dir, env)
         });
         const spawner = options.spawner ?? defaultSpawner;
-        let resolvedTotal;
-        let dryRunChild;
-        if (plan.classification.manager === "pip") {
-            const cached = cachedPipResolution(plan.realBinary.path ?? "", args);
-            if (cached) {
-                resolvedTotal = cached.count;
-            }
-            else {
-                void resolvePipInstallTotal(plan.realBinary.path ?? "", args, childEnv, (child) => { dryRunChild = child; })
-                    .then((count) => { resolvedTotal = count; })
-                    .catch(() => undefined);
-            }
-        }
+        const hardened = applyScriptGateHardening(plan, args, childEnv, env);
+        const resolvedTotal = plan.classification.manager === "pip" ? cachedPipResolution(plan.realBinary.path ?? "", args)?.count : undefined;
         const poll = setInterval(() => {
             onView(deriveLiveView(readProxySessionState(proxy.session), "scanning", resolvedTotal));
         }, 90);
@@ -313,18 +331,12 @@ export async function runWithProductionProxyLive(plan, args, options, onView) {
         try {
             finished = await spawner({
                 binary: plan.realBinary.path ?? "",
-                args,
-                env: childEnv
+                args: hardened.args,
+                env: hardened.env
             });
         }
         finally {
             clearInterval(poll);
-            if (dryRunChild) {
-                try {
-                    dryRunChild.kill();
-                }
-                catch { /* already exited */ }
-            }
         }
         const proxyState = readProxySessionState(proxy.session);
         onView(deriveLiveView(proxyState, "done", resolvedTotal));
@@ -342,13 +354,20 @@ export async function runWithProductionProxyLive(plan, args, options, onView) {
             const outcome = installOutcome(finished.stdout);
             return { exitCode: EXIT_INSTALL_BLOCKED, stdout: outcome, stderr: cacheOnlyNotice(outcome.length > 0) };
         }
-        return { exitCode: finished.exitCode, stdout: installOutcome(finished.stdout), stderr: scriptGateLine(plan, finished.exitCode, options) };
+        return { exitCode: finished.exitCode, stdout: installOutcome(finished.stdout), stderr: `${scriptGateLine(plan, finished.exitCode, options)}${setupNudgeAfterInstall(plan, finished.exitCode, options)}` };
     }
     finally {
         restoreSignalHandlers();
         stopProxyWorker(proxy);
     }
 }
+function prepareProxyCacheDir(manager, sessionDir, env) {
+    const cacheDir = `${sessionDir}/pm-cache`;
+    if (manager === "cargo") {
+        prepareCargoHome(cacheDir, userCargoHome(env));
+    }
+    return cacheDir;
+}
 function cacheOnlyNotice(installedFresh) {
     const theme = createTheme(resolvePresentation().color);
     const reason = installedFresh ? "used a saved copy" : "already installed";
@@ -359,6 +378,22 @@ function installOutcome(stdout) {
         /^(added|changed|removed|updated) \d/.test(line.trim()));
     return lines.length > 0 ? `${lines.join("\n")}\n` : "";
 }
+// scriptGate.mode === "enforce" is applied HERE, at the spawn boundary: it
+// rewrites the install args (--ignore-scripts) and child env
+// (npm_config_ignore_scripts) for npm/yarn so a reputation-clean package can't
+// run a lifecycle script. observe/off leave the install untouched. Without this
+// the mode setting was inert — the verdict screens what is fetched, this gates
+// what the fetched package is allowed to execute.
+function applyScriptGateHardening(plan, args, childEnv, configEnv) {
+    const mode = loadUserConfig(configEnv).scriptGate.mode;
+    const manager = plan.classification.manager;
+    const hardenedArgs = scriptGateInstallArgs({ mode, manager, args, env: childEnv });
+    const gateEnv = scriptGateChildEnv({ mode, manager, args, env: childEnv });
+    return {
+        args: hardenedArgs,
+        env: Object.keys(gateEnv).length > 0 ? { ...childEnv, ...gateEnv } : childEnv
+    };
+}
 async function spawnPackageManager(plan, args, options) {
     if (!plan.realBinary.path) {
         return {
@@ -368,10 +403,11 @@ async function spawnPackageManager(plan, args, options) {
         };
     }
     const spawner = options.spawner ?? defaultSpawner;
+    const hardened = applyScriptGateHardening(plan, args, plan.childEnv, options.env ?? process.env);
     return spawner({
         binary: plan.realBinary.path,
-        args,
-        env: plan.childEnv,
+        args: hardened.args,
+        env: hardened.env,
         onStdout: options.onStdout,
         onStderr: options.onStderr
     });
@@ -436,6 +472,41 @@ function renderDecisions(decisions, env) {
     const visible = isCiEnv(env) ? decisions.filter((decision) => decision.action !== "pass") : decisions;
     return visible.map((decision) => redactSecrets(renderInstallDecision(decision))).join("");
 }
+export function loadProjectCooldownExemptions(env, cwd = process.cwd()) {
+    try {
+        const root = findProjectRoot(cwd, env);
+        if (!root) {
+            return [];
+        }
+        const file = loadDgFile(root);
+        if (!file.readable) {
+            return [];
+        }
+        return honoredOverrides(file, root, env, trustsProjectOverrides(env)).exemptions;
+    }
+    catch {
+        return [];
+    }
+}
+export function dgFileExemptionsNotice(exemptions) {
+    if (exemptions.length === 0) {
+        return "";
+    }
+    const plural = exemptions.length === 1 ? "exemption" : "exemptions";
+    return `dg: applying ${exemptions.length} cooldown ${plural} from this project's dg.json\n`;
+}
+let dgFileExemptionNoticeWritten = false;
+function maybeNoticeDgFileExemptions(exemptions) {
+    if (dgFileExemptionNoticeWritten) {
+        return;
+    }
+    const notice = dgFileExemptionsNotice(exemptions);
+    if (!notice) {
+        return;
+    }
+    dgFileExemptionNoticeWritten = true;
+    process.stderr.write(notice);
+}
 async function startProxyWorker(classification, env, forceOverride) {
     const paths = resolveDgPaths(env);
     const session = createSessionSync(paths);
@@ -450,11 +521,15 @@ async function startProxyWorker(classification, env, forceOverride) {
             throw new Error("production proxy worker is not built");
         }
         const config = loadUserConfig(env);
+        const exemptions = loadProjectCooldownExemptions(env);
+        maybeNoticeDgFileExemptions(exemptions);
+        const exemptionsEnv = writeCooldownExemptionsFile(session.dir, exemptions);
         const child = spawn(process.execPath, [workerPath, sessionBootstrapPath, config.api.baseUrl], {
             env: {
                 ...env,
                 DG_PROXY_CLASSIFICATION: JSON.stringify(classification),
-                ...(forceOverride ? { DG_FORCE_OVERRIDE_REQUEST: JSON.stringify(forceOverride) } : {})
+                ...(forceOverride ? { DG_FORCE_OVERRIDE_REQUEST: JSON.stringify(forceOverride) } : {}),
+                ...exemptionsEnv
             },
             stdio: ["pipe", "pipe", "pipe"]
         });

package/dist/launcher/spawn-invocation.js

@@ -0,0 +1,21 @@
+const CMD_SCRIPT_PATTERN = /\.(cmd|bat)$/i;
+const CMD_META_CHARS = /([()\][%!^"`<>&|;, *?])/g;
+export function resolveSpawnInvocation(binary, args, platform = process.platform) {
+    if (platform !== "win32" || !CMD_SCRIPT_PATTERN.test(binary)) {
+        return { command: binary, args, windowsVerbatimArguments: false };
+    }
+    const commandLine = [escapeCmdCommand(binary), ...args.map(escapeCmdArgument)].join(" ");
+    return {
+        command: process.env.comspec ?? "cmd.exe",
+        args: ["/d", "/s", "/c", `"${commandLine}"`],
+        windowsVerbatimArguments: true
+    };
+}
+function escapeCmdCommand(command) {
+    return command.replace(CMD_META_CHARS, "^$1");
+}
+// cmd shims parse their command line twice, hence the doubled meta-char escape (cross-spawn's algorithm)
+function escapeCmdArgument(argument) {
+    const quoted = `"${argument.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\*)$/, "$1$1")}"`;
+    return quoted.replace(CMD_META_CHARS, "^$1").replace(CMD_META_CHARS, "^$1");
+}

package/dist/policy/cooldown.js

@@ -1,4 +1,7 @@
 import { parseCooldownAge } from "../config/settings.js";
+import { cooldownExemptionActive } from "../project/dgfile.js";
+import { canonicalCooldownName, normalizePypiName } from "./pypi-name.js";
+export { normalizePypiName };
 export function durationToDays(value) {
     const trimmed = value.trim();
     if (trimmed === "" || trimmed === "0" || trimmed === "off") {
@@ -28,23 +31,33 @@ export function effectiveCooldownAge(config, env, ecosystem) {
             : config.cooldown.cargoAge;
     return perEcosystem !== "" ? perEcosystem : config.cooldown.age;
 }
-function normalizePypiName(name) {
-    return name.toLowerCase().replace(/[-_.]+/g, "-");
-}
 export function isCooldownExempt(packageName, exempt, ecosystem) {
-    const name = ecosystem === "pypi" ? normalizePypiName(packageName) : packageName;
+    const name = ecosystem ? canonicalCooldownName(ecosystem, packageName) : packageName;
     return exempt
         .split(",")
         .map((entry) => entry.trim())
         .filter(Boolean)
         .some((pattern) => {
-        const candidate = ecosystem === "pypi" ? normalizePypiName(pattern) : pattern;
+        const candidate = ecosystem ? canonicalCooldownName(ecosystem, pattern) : pattern;
         if (candidate.endsWith("*")) {
             return name.startsWith(candidate.slice(0, -1));
         }
         return name === candidate;
     });
 }
+export function isCooldownExemptByDgFile(packageName, ecosystem, exemptions, now = new Date()) {
+    if (ecosystem !== "npm" && ecosystem !== "pypi" && ecosystem !== "cargo") {
+        return false;
+    }
+    const target = canonicalCooldownName(ecosystem, packageName);
+    return exemptions.some((e) => {
+        if (e.ecosystem !== ecosystem) {
+            return false;
+        }
+        const candidate = canonicalCooldownName(ecosystem, e.name);
+        return candidate === target && cooldownExemptionActive(e, now);
+    });
+}
 export function cooldownRequestParam(config, env, ecosystem, packageName) {
     const minAgeDays = durationToDays(effectiveCooldownAge(config, env, ecosystem));
     if (minAgeDays <= 0) {

package/dist/policy/evaluate.js

@@ -1,4 +1,4 @@
-import { emitWebhookEvent, recordAuditEvent } from "../audit/events.js";
+import { recordAuditEvent } from "../audit/events.js";
 import { DEFAULT_CONFIG } from "../config/settings.js";
 export function resolveEffectivePolicy(options) {
     if (options.orgPolicy) {
@@ -69,21 +69,21 @@ export function applyForceOverride(options, env = process.env) {
         return {
             allowed: false,
             reason: "force override was not requested",
-            webhookQueued: false
+            auditRecorded: false
         };
     }
     if (options.currentAction !== "block") {
         return {
             allowed: false,
             reason: "force override is only valid for block decisions",
-            webhookQueued: false
+            auditRecorded: false
         };
     }
     if (!options.policy.allowForceOverride) {
         return {
             allowed: false,
             reason: "force override is disabled by policy",
-            webhookQueued: false
+            auditRecorded: false
         };
     }
     const event = {
@@ -93,11 +93,10 @@ export function applyForceOverride(options, env = process.env) {
         policyMode: options.policy.mode,
         createdAt: (options.now ?? new Date()).toISOString()
     };
-    recordAuditEvent(event, env);
     return {
         allowed: true,
         reason: event.reason,
-        webhookQueued: emitWebhookEvent(event, env)
+        auditRecorded: recordAuditEvent(event, env)
     };
 }
 function findTrustedAllowlist(packageName, policy, allowlists) {

package/dist/policy/pypi-name.js

@@ -0,0 +1,17 @@
+export function normalizePypiName(name) {
+    return name.toLowerCase().replace(/[-_.]+/g, "-");
+}
+// crates.io is case-insensitive and treats '-' and '_' as equivalent, so fold
+// both to a single canonical form for exemption matching.
+export function normalizeCargoName(name) {
+    return name.toLowerCase().replace(/_/g, "-");
+}
+export function canonicalCooldownName(ecosystem, name) {
+    if (ecosystem === "pypi") {
+        return normalizePypiName(name);
+    }
+    if (ecosystem === "cargo") {
+        return normalizeCargoName(name);
+    }
+    return name;
+}

package/dist/presentation/mode.js

@@ -19,8 +19,9 @@ export function colorEnabled(input) {
     if (input.forceColorFlag) {
         return true;
     }
-    if (truthyEnv(input.env.FORCE_COLOR)) {
-        return true;
+    const forceColor = input.env.FORCE_COLOR;
+    if (forceColor !== undefined) {
+        return forceColor !== "0" && forceColor !== "false";
     }
     if (input.noColorFlag) {
         return false;

package/dist/presentation/package-page.js

@@ -0,0 +1,9 @@
+const SITE = "https://westbayberry.com";
+// Only npm and pypi have public, indexable per-package pages today; cargo and
+// other ecosystems have none, so return null rather than link to a 404.
+export function packagePageUrl(ecosystem, name) {
+    if (ecosystem !== "npm" && ecosystem !== "pypi") {
+        return null;
+    }
+    return `${SITE}/${ecosystem}/${name}`;
+}

package/dist/presentation/theme.js

@@ -1,12 +1,12 @@
 const ANSI = {
-    block: "",
-    warn: "",
-    pass: "",
-    unknown: "",
-    muted: "",
-    accent: ""
+    block: "\u001b[31m",
+    warn: "\u001b[33m",
+    pass: "\u001b[32m",
+    unknown: "\u001b[36m",
+    muted: "\u001b[2m",
+    accent: "\u001b[1m"
 };
-const RESET = "";
+const RESET = "\u001b[0m";
 const BADGES = {
     block: { word: "BLOCK", glyph: "✘", role: "block" },
     warn: { word: "WARN", glyph: "⚠", role: "warn" },