disk-space-saviour 0.13.1 → 0.15.2

package/src/liveness.js

@@ -1,16 +1,20 @@
 /**
  * Liveness checks: is anything using a path right now?
  *
- * Three independent signals, any of which blocks deletion:
+ * Independent signals, any of which blocks deletion:
  * - recent writes: newest file mtime inside the stale-age window;
  * - a relevant tool is running (by process name), optionally only when its
  *   working directory is inside the project;
  * - a process holds a file, working directory, or executable inside the path
  *   (`/proc/<pid>/{fd,cwd,exe}` on Linux, `lsof` on macOS).
+ * - a command argument names a path inside the item (including scripts
+ *   whose interpreter has already closed its input descriptor).
  *
  * The cleaner refreshes the probe right before acting on each item.
  */
 
+import path from 'node:path';
+
 import { isWithin } from './paths.js';
 import { formatDuration } from './units.js';
 
@@ -25,6 +29,76 @@ function nameMatches(name, candidate) {
   );
 }
 
+/** Arguments preserved by /proc; command titles are a fallback. */
+export function processArgs(proc) {
+  return (
+    proc.argv ??
+    (proc.command ?? '')
+      .match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g)
+      ?.map((arg) => arg.replace(/^["']|["']$/g, '')) ??
+    []
+  );
+}
+
+function scriptIndex(args) {
+  const first = path.posix.basename(args[0] ?? '');
+  if (!/^(node|nodejs|bun|deno|python[\d.]*|bash|sh)$/.test(first)) {
+    return 0;
+  }
+  // Only the interpreter's script operand; option values and arbitrary
+  // arguments are not executable names.
+  let index = 1;
+  while (args[index]?.startsWith('-')) {
+    if (['-e', '--eval', '-p', '--print', '-c'].includes(args[index])) {
+      return -1;
+    }
+    index += ['-r', '--require', '--import', '--loader'].includes(args[index])
+      ? 2
+      : 1;
+  }
+  return index;
+}
+
+function commandNames(proc) {
+  const args = processArgs(proc);
+  const first = path.posix.basename(args[0] ?? '');
+  const names = [first];
+  if (/^npm(?: |$)/.test(proc.name ?? '') || /^npm(?: |$)/.test(first)) {
+    names.push('npm');
+  }
+  const index = scriptIndex(args);
+  if (index > 0) {
+    const script = path.posix.basename(args[index] ?? '');
+    names.push(
+      script,
+      ...(script === 'npm-cli.js' ? ['npm'] : []),
+      ...(script === 'npx-cli.js' ? ['npx'] : [])
+    );
+  }
+  // An explicit npm launcher package is also a tool (e.g. Playwright MCP).
+  if (isNpmExec(proc)) {
+    const packageArg = args.find((arg) => /^@[^/]+\/[^/]+$/.test(arg));
+    if (packageArg) {
+      names.push(packageArg.slice(1).split('/')[0]);
+    }
+  }
+  return names;
+}
+
+export function isNpmExec(proc) {
+  const args = processArgs(proc);
+  const index = scriptIndex(args);
+  const executable = path.posix.basename(args[Math.max(index, 0)] ?? '');
+  return (
+    /^npm (exec|x)(?: |$)|^npx(?: |$)/.test(proc.name ?? '') ||
+    /^npm (exec|x)(?: |$)|^npx(?: |$)/.test(args[0] ?? '') ||
+    (index >= 0 &&
+      (['npx', 'npx-cli.js'].includes(executable) ||
+        (['npm', 'npm-cli.js'].includes(executable) &&
+          ['exec', 'x'].includes(args[index + 1]))))
+  );
+}
+
 /**
  * Name of `proc` that matches one of `names`, or null. Besides the kernel
  * name (`comm`, which programs may rename: Node.js calls its main thread
@@ -32,18 +106,12 @@ function nameMatches(name, candidate) {
  * base names.
  */
 export function matchingName(proc, names) {
-  const own = [proc.name ?? '', ...(proc.aliases ?? [])];
+  const own = [proc.name ?? '', ...(proc.aliases ?? []), ...commandNames(proc)];
   for (const name of own) {
     if (name && names.some((candidate) => nameMatches(name, candidate))) {
       return name;
     }
   }
-  const commandWords = (proc.command ?? '').toLowerCase().split(/[^a-z0-9_-]+/);
-  for (const candidate of names) {
-    if (commandWords.includes(candidate.toLowerCase())) {
-      return candidate;
-    }
-  }
   return null;
 }
 
@@ -62,16 +130,17 @@ export class LivenessProbe {
     this.openPaths = null;
     this.probeError = false;
     this.realPaths = new Map();
+    this.pathOwners = new Map();
   }
 
   async refresh(force = false) {
     if (!force && this.now() - this.refreshedAt < this.refreshMs) {
       return;
     }
+    this.openPaths = await this.env.openPaths().catch(() => null);
     const processes = await this.env.processes().catch(() => null);
     this.listed = processes !== null;
     this.processes = processes ?? [];
-    this.openPaths = await this.env.openPaths().catch(() => null);
     this.probeError =
       (processes === null || this.openPaths === null) &&
       (this.env.platform === 'linux' || this.env.platform === 'darwin');
@@ -90,6 +159,11 @@ export class LivenessProbe {
    * @param {string[]} paths
    */
   async resolve(paths) {
+    if (this.env.unreadableProcesses?.length && this.env.stat) {
+      for (const target of paths) {
+        this.pathOwners.set(target, (await this.env.stat(target))?.uid);
+      }
+    }
     if (typeof this.env.realPath !== 'function') {
       return;
     }
@@ -111,12 +185,18 @@ export class LivenessProbe {
     return null;
   }
 
-  runningTool(names, cwd) {
+  runningTool(names, cwd, item = {}) {
     if (!names || names.length === 0) {
       return null;
     }
     const pathApi = this.env.path;
     for (const proc of this.processes) {
+      if (
+        ['npm-cache', 'node-gyp-cache', 'npx-cache'].includes(item.rule) &&
+        isNpmExec(proc)
+      ) {
+        continue;
+      }
       const name = matchingName(proc, names);
       if (!name) {
         continue;
@@ -169,6 +249,58 @@ export class LivenessProbe {
     return open;
   }
 
+  commandUsage(paths) {
+    for (const proc of this.processes) {
+      for (const arg of processArgs(proc)) {
+        const candidate = arg.startsWith('/')
+          ? arg
+          : proc.cwd && !arg.startsWith('-')
+            ? this.env.path.resolve(proc.cwd, arg)
+            : null;
+        if (
+          candidate &&
+          paths.some((target) => isWithin(candidate, target, this.env.path))
+        ) {
+          return `in use: ${candidate} (pid ${proc.pid})`;
+        }
+      }
+    }
+    return null;
+  }
+
+  uncertainUsage(paths) {
+    for (const proc of this.env.unreadableProcesses ?? []) {
+      const args = processArgs(proc);
+      const roots = args.flatMap((arg) => {
+        const value = arg.includes('=') ? arg.slice(arg.indexOf('=') + 1) : arg;
+        return value.startsWith('/') ? [value] : [];
+      });
+      if (proc.name === 'dockerd') {
+        roots.push('/var/lib/docker', '/run');
+      }
+      if (proc.name === 'containerd') {
+        roots.push('/var/lib/containerd', '/run/containerd');
+      }
+      for (const target of paths) {
+        const intersects = roots.some(
+          (root) =>
+            isWithin(root, target, this.env.path) ||
+            isWithin(target, root, this.env.path)
+        );
+        const owner = this.pathOwners.get(target);
+        if (
+          intersects ||
+          proc.uid === null ||
+          owner === undefined ||
+          owner === proc.uid
+        ) {
+          return `unreadable process ${proc.name || 'unknown'} (pid ${proc.pid}, uid ${proc.uid ?? 'unknown'}) may use ${target}`;
+        }
+      }
+    }
+    return null;
+  }
+
   /**
    * First reason the item is busy, or null when it is idle. Items with
    * `checks.perPath` leave open files to `openPathsOf`: the caller skips
@@ -179,12 +311,27 @@ export class LivenessProbe {
     const checks = item.checks ?? {};
     const paths = checks.perPath ? [] : (item.paths ?? []);
     return (
+      this.installationBlocker(item.paths ?? []) ??
       (this.probeError
-        ? 'cannot verify process and open-file activity'
+        ? `cannot verify process and open-file activity${this.env.probeDiagnostic ? `: ${this.env.probeDiagnostic}` : ''}`
         : null) ??
       (checks.mtime === false ? null : this.recentWrite(item.newestMtimeMs)) ??
-      this.runningTool(checks.busy, checks.cwd) ??
-      this.openInside(paths)
+      this.runningTool(checks.busy, checks.cwd, item) ??
+      this.openInside(paths) ??
+      this.commandUsage(paths) ??
+      this.uncertainUsage(item.paths ?? [])
     );
   }
+
+  installationBlocker(paths) {
+    return paths.some((target) =>
+      (this.env.protectedPaths ?? []).some(
+        (root) =>
+          isWithin(root, target, this.env.path) ||
+          isWithin(target, root, this.env.path)
+      )
+    )
+      ? 'dss current installation is protected'
+      : null;
+  }
 }

package/src/options.js

@@ -21,6 +21,7 @@ export const DEFAULTS = {
   exclude: [],
   includeVolumes: false,
   removeStoppedContainers: false,
+  investigationMaxAge: null,
   removeContainers: [],
   removeImages: [],
   allowDirtyRepos: false,
@@ -77,6 +78,10 @@ export function resolveOptions(input = {}) {
     dockerDepth: Number(merged.dockerDepth),
     staleAgeMs: toMs(staleAge),
     inactiveMs: toMs(merged.inactive),
+    investigationMaxAgeMs:
+      merged.investigationMaxAge === null
+        ? null
+        : toMs(merged.investigationMaxAge),
     minSizeBytes: toBytes(merged.minSize),
     journalKeepBytes: toBytes(merged.journalKeep),
     containerFilter: toList(merged.containers),

package/src/paths.js

@@ -13,8 +13,17 @@ export function globToRegExp(glob) {
   let cached = globCache.get(glob);
   if (!cached) {
     let source = '';
-    for (const char of glob) {
-      if (char === '*') {
+    for (let index = 0; index < glob.length; index++) {
+      const char = glob[index];
+      if (char === '*' && glob[index + 1] === '*') {
+        index++;
+        if (glob[index + 1] === '/') {
+          source += '(?:.*/)?';
+          index++;
+        } else {
+          source += '.*';
+        }
+      } else if (char === '*') {
         source += '[^/\\\\]*';
       } else if (char === '?') {
         source += '[^/\\\\]';
@@ -38,6 +47,29 @@ export function matchesGlob(name, glob) {
   return globToRegExp(glob).test(name);
 }
 
+/** Match exclusions against a path and each ancestor, including dotfiles. */
+export function matchesExcluded(target, patterns, pathApi) {
+  const normalize = (value) => {
+    const normalized = value.replaceAll('\\', '/');
+    return pathApi.sep === '\\' ? normalized.toLowerCase() : normalized;
+  };
+  for (const pattern of patterns ?? []) {
+    const full = /[/\\]/.test(pattern);
+    for (let current = pathApi.resolve(target); ; ) {
+      const candidate = full ? current : pathApi.basename(current);
+      if (matchesGlob(normalize(candidate), normalize(pattern))) {
+        return true;
+      }
+      const parent = pathApi.dirname(current);
+      if (parent === current) {
+        break;
+      }
+      current = parent;
+    }
+  }
+  return false;
+}
+
 /**
  * Whether `child` equals `parent` or lies below it.
  * @param {string} child

package/src/report.js

@@ -4,7 +4,7 @@
  */
 
 import { TIERS, consentFlag } from './items.js';
-import { formatBytes } from './units.js';
+import { formatBytes, formatDuration } from './units.js';
 
 const DEFAULT_LIMIT = 25;
 
@@ -51,7 +51,12 @@ function itemLine(item, showEnv) {
   const confirm = item.requiresConfirmation
     ? `  (needs ${consentFlag(item)})`
     : '';
-  return `  ${pad(formatBytes(item.bytes), 10)}  ${env}${item.rule}  ${itemLocation(item)}${confirm}`;
+  const storage = item.sizeUnknown
+    ? '  (may be in an image layer; freeable bytes unknown, excluded from totals)'
+    : item.imageBytes
+      ? `  (${formatBytes(item.imageBytes)} in image${item.imageRef ? ` ${item.imageRef}` : ''}; 0 B of that data freeable now; remove the stopped container and unused image after the task completes)`
+      : '';
+  return `  ${pad(formatBytes(item.bytes), 10)}  ${env}${item.rule}  ${itemLocation(item)}${confirm}${storage}`;
 }
 
 function limited(lines, limit) {
@@ -108,7 +113,12 @@ function repoSummary(repo) {
   }
   const parts = [];
   if (repo.dirty) {
-    parts.push(`${repo.dirty} uncommitted`);
+    parts.push(
+      `${repo.dirty} uncommitted${repo.untracked ? ` (${repo.untracked} untracked)` : ''}`
+    );
+    if (repo.preservedOn) {
+      parts.push(`uncommitted work preserved on ${repo.preservedOn}`);
+    }
   }
   if (repo.unpushed) {
     parts.push(`${repo.unpushed} unpushed`);
@@ -155,6 +165,14 @@ function containerLines(container, stoppedItems) {
     lines.push(`      ${ended}`);
   }
   const item = stoppedItems.get(container.id);
+  if (container.sizeUnknown) {
+    lines.push('      writable layer size unknown');
+  }
+  if (container.pinnedImage) {
+    lines.push(
+      `      ${formatBytes(container.pinnedImage.bytes)} unique image bytes pinned by this container (${container.pinnedImage.ref}); after removing it, approve the unused image separately with --remove-image ${container.pinnedImage.ref}`
+    );
+  }
   if (item?.container?.investigation) {
     lines.push(`      ${item.container.investigation}`);
   }
@@ -192,6 +210,25 @@ function imageLine(item) {
     )}) unused, ${formatBytes(image.bytes)}, ${created}${lastUseText(image.lastUsedBy)}${consent}`;
 }
 
+function investigationSummary(docker, stoppedItems, createdAt) {
+  const lines = [];
+  const kept = docker.containers.filter(
+    (container) => stoppedItems.get(container.id)?.container?.investigation
+  );
+  if (kept.length) {
+    const dates = kept
+      .map((container) => Date.parse(container.owner?.finishedAt))
+      .filter(Number.isFinite);
+    const age = dates.length
+      ? `, oldest ${formatDuration(Math.max(0, Date.parse(createdAt) - Math.min(...dates)))}`
+      : '';
+    lines.push(
+      `  ${formatBytes(kept.reduce((sum, container) => sum + container.bytes, 0))} in ${kept.length} containers kept for investigation${age}`
+    );
+  }
+  return lines;
+}
+
 function dockerSection(report) {
   const docker = report.docker;
   if (!docker || docker.daemons.length === 0) {
@@ -202,7 +239,11 @@ function dockerSection(report) {
       .filter((item) => item.container)
       .map((item) => [item.container.id, item])
   );
-  const lines = ['', 'DOCKER'];
+  const lines = [
+    '',
+    'DOCKER',
+    ...investigationSummary(docker, stoppedItems, report.createdAt),
+  ];
   for (const daemon of docker.daemons) {
     lines.push(
       `  daemon ${daemon.name} (depth ${daemon.depth}, ${daemon.serverVersion}, ${daemon.driver}) via ${daemon.env}`
@@ -214,9 +255,20 @@ function dockerSection(report) {
   for (const item of report.items.filter((entry) => entry.image)) {
     lines.push(imageLine(item));
   }
+  const grouped = new Map();
   for (const hint of docker.hints ?? []) {
+    const key = `${(hint.images ?? [hint.image]).join(', ')}\0${hint.hint}`;
+    const group = grouped.get(key);
+    if (group) {
+      group.bytes += hint.bytes;
+      group.layers += 1;
+    } else {
+      grouped.set(key, { ...hint, layers: 1 });
+    }
+  }
+  for (const hint of grouped.values()) {
     lines.push(
-      `  hint ${(hint.images ?? [hint.image]).join(', ')}: ${formatBytes(hint.bytes)} layer, ${hint.hint}`
+      `  hint ${(hint.images ?? [hint.image]).join(', ')}: ${formatBytes(hint.bytes)} in ${hint.layers} layer${hint.layers === 1 ? '' : 's'}, ${hint.hint}`
     );
   }
   for (const volume of docker.volumes ?? []) {
@@ -246,7 +298,7 @@ function errorsSection(errors) {
   }
   return [
     '',
-    'ERRORS',
+    'ERRORS (scan incomplete)',
     ...errors.map(
       (error) => `  ${error.env} ${error.scanner}: ${error.message}`
     ),
@@ -269,6 +321,11 @@ export function formatReport(report, options = {}) {
   for (const tier of TIERS) {
     lines.push(...tierSection(report, tier, { limit }));
   }
+  for (const env of report.environments) {
+    if (env.hint) {
+      lines.push(`  ${env.label}: ${env.hint}`);
+    }
+  }
   lines.push(...blockedSection(report, { limit }));
   lines.push(...dockerSection(report));
   lines.push(...errorsSection(report.errors));
@@ -310,7 +367,7 @@ function healthLines(records) {
     if (!record.available) {
       return `  ${record.envLabel}: processes could not be listed`;
     }
-    return `  ${record.envLabel}: ${record.watched.length} watched processes still running`;
+    return `  ${record.envLabel}: ${record.watched.length} watched processes still running: ${record.watched.map((proc) => `${proc.name} (pid ${proc.pid})`).join(', ')}`;
   });
   return lines.length > 0 ? ['', 'Task health:', ...lines] : [];
 }
@@ -358,6 +415,9 @@ export function formatAudit(audit, options = {}) {
     '',
     ...limited(shown.map(entryLine), limit),
   ];
+  if (audit.aborted) {
+    lines.push(`  cleanup aborted: ${audit.error ?? 'interrupted'}`);
+  }
   if (hidden > 0) {
     lines.push(`  ${hidden} skipped (use --verbose to list them)`);
   }

package/src/rules/apps.js

@@ -0,0 +1,178 @@
+/** Only regenerable cache leaves; profiles, databases and local storage survive. */
+export const CACHE_LEAVES = [
+  'Cache',
+  'Code Cache',
+  'GPUCache',
+  'DawnGraphiteCache',
+  'DawnWebGPUCache',
+  'Service Worker/CacheStorage',
+  'Service Worker/ScriptCache',
+];
+const telegramAccounts =
+  '~/Library/Group Containers/*.ru.keepcoder.Telegram/*/account-*/postbox/media';
+const telegramDesktop = [
+  '~/.local/share/TelegramDesktop/tdata',
+  '~/Library/Application Support/Telegram Desktop/tdata',
+  '{APPDATA}/Telegram Desktop/tdata',
+];
+export const APP_RULES = [
+  {
+    id: 'telegram-caches',
+    ecosystem: 'apps',
+    description: 'Telegram regenerable media cache partitions',
+    paths: [
+      ...['cache', 'cache-storage', 'short-cache'].map(
+        (leaf) => `${telegramAccounts}/${leaf}`
+      ),
+      '~/Library/Containers/ru.keepcoder.Telegram/Data/Library/Caches',
+      '~/Library/Caches/ru.keepcoder.Telegram',
+      ...telegramDesktop.flatMap((root) =>
+        ['cache', 'user_data/cache', 'user_data/media_cache'].map(
+          (leaf) => `${root}/${leaf}`
+        )
+      ),
+    ],
+    busy: ['Telegram', 'telegram-desktop'],
+  },
+  {
+    id: 'telegram-downloaded-media',
+    excludeNames: ['cache', 'cache-storage', 'short-cache'],
+    ecosystem: 'apps',
+    tier: 'moderate',
+    description:
+      'Telegram downloaded media: secret-chat media may not be recoverable',
+    paths: [
+      `${telegramAccounts}/*`,
+      ...telegramDesktop.map((root) => `${root}/user_data/downloads`),
+    ],
+    busy: ['Telegram', 'telegram-desktop'],
+  },
+  {
+    id: 'safari-webkit-caches',
+    ecosystem: 'browsers',
+    description: 'Safari and WebKit HTTP/compiled resource caches',
+    paths: [
+      '~/Library/Caches/com.apple.Safari',
+      '~/Library/Caches/com.apple.WebKit.Networking',
+      '~/Library/Caches/*/WebKit',
+      '~/Library/Containers/com.apple.Safari/Data/Library/Caches',
+      '~/Library/Containers/com.apple.Safari/Data/Library/WebKit/WebsiteData/Default/CacheStorage',
+      '~/Library/WebKit/com.apple.Safari/WebsiteData/Default/CacheStorage',
+    ],
+    busy: ['Safari', 'com.apple.WebKit'],
+  },
+  {
+    id: 'electron-profile-caches',
+    ecosystem: 'apps',
+    description: 'Electron app regenerable caches',
+    paths: [
+      '~/Library/Application Support/*',
+      '~/.config/*',
+      '{APPDATA}/*',
+    ].flatMap((root) => CACHE_LEAVES.map((leaf) => `${root}/${leaf}`)),
+    markers: ['Local Storage', 'Preferences'],
+    busy: ['electron', 'Electron'],
+  },
+  {
+    id: 'agent-scratch-sessions',
+    directoryOnly: true,
+    ecosystem: 'agents',
+    scope: 'tmp',
+    tier: 'moderate',
+    description:
+      'inactive Claude/Codex scratch sessions and partial work copies',
+    paths: [
+      '{TMP}/claude-*/*/*',
+      '{TMP}/codex-*/*/*',
+      '{TMP}/codex-scratch-*',
+      '{TMP}/claude-copy-*',
+      '{TMP}/codex-copy-*',
+    ],
+    minAge: 'inactive',
+    git: 'ifPresent',
+    busy: ['claude', 'codex', 'git', 'node', 'bun'],
+  },
+  {
+    id: 'agent-scratch-files',
+    ecosystem: 'agents',
+    scope: 'tmp',
+    tier: 'moderate',
+    description: 'inactive agent-named temporary logs and scripts',
+    paths: [
+      '{TMP}/claude-*.log',
+      '{TMP}/claude-*.sh',
+      '{TMP}/codex-*.log',
+      '{TMP}/codex-*.sh',
+    ],
+    minAge: 'inactive',
+    busy: ['claude', 'codex', 'bash', 'sh'],
+    fileOnly: true,
+  },
+  {
+    id: 'bunx-cache',
+    ecosystem: 'javascript',
+    description: 'per-entry bunx package cache',
+    scope: 'tmp',
+    paths: ['{TMP}/bunx-*'],
+    minAge: 'stale',
+    busy: [],
+  },
+  {
+    id: 'pnpm-dlx-cache',
+    ecosystem: 'javascript',
+    description: 'per-entry pnpm dlx package cache',
+    paths: [
+      '~/.cache/pnpm/dlx/*',
+      '~/Library/Caches/pnpm/dlx/*',
+      '{LOCALAPPDATA}/pnpm-cache/dlx/*',
+    ],
+    minAge: 'stale',
+    busy: [],
+  },
+  {
+    id: 'yarn-dlx-cache',
+    ecosystem: 'javascript',
+    description: 'per-entry Yarn dlx temporary cache',
+    scope: 'tmp',
+    paths: ['{TMP}/dlx-*'],
+    minAge: 'stale',
+    busy: [],
+  },
+];
+
+export function expandChromiumCaches(rules) {
+  return rules.map((rule) => {
+    if (
+      !rule.id.includes('http-caches') ||
+      !rule.paths.some((p) => p.includes('/Code Cache'))
+    ) {
+      return rule;
+    }
+    const bases = rule.paths
+      .filter((p) => p.endsWith('/Code Cache'))
+      .map((p) => p.slice(0, -'/Code Cache'.length));
+    const support = bases
+      .filter((p) => p.includes('~/Library/Caches/'))
+      .map((p) =>
+        p.replace('~/Library/Caches/', '~/Library/Application Support/')
+      );
+    const profiles = [...bases, ...support];
+    const roots = profiles.map((p) => (p.endsWith('/*') ? p.slice(0, -2) : p));
+    return {
+      ...rule,
+      paths: [
+        ...new Set([
+          ...rule.paths,
+          ...profiles.flatMap((p) =>
+            CACHE_LEAVES.map((leaf) => `${p}/${leaf}`)
+          ),
+          ...roots.flatMap((p) =>
+            ['GrShaderCache', 'ShaderCache', 'component_crx_cache'].map(
+              (leaf) => `${p}/${leaf}`
+            )
+          ),
+        ]),
+      ],
+    };
+  });
+}

package/src/rules/ecosystems.js

@@ -31,15 +31,16 @@ export const ECOSYSTEMS = [
     caches: [
       {
         id: 'npm-cache',
+        mtime: true,
         description: 'npm download cache',
         paths: ['~/.npm/_cacache', '{LOCALAPPDATA}/npm-cache/_cacache'],
-        native: { tool: 'npm', argv: ['npm', 'cache', 'clean', '--force'] },
         busy: ['npm'],
       },
       {
         id: 'npx-cache',
         description: 'npx package cache',
-        paths: ['~/.npm/_npx', '{LOCALAPPDATA}/npm-cache/_npx'],
+        paths: ['~/.npm/_npx/*', '{LOCALAPPDATA}/npm-cache/_npx/*'],
+        minAge: 'stale',
         busy: ['npm', 'npx'],
       },
       {
@@ -84,6 +85,7 @@ export const ECOSYSTEMS = [
       },
       {
         id: 'node-gyp-cache',
+        mtime: true,
         description: 'node-gyp headers cache',
         paths: ['~/.cache/node-gyp', '~/Library/Caches/node-gyp'],
         busy: ['node-gyp', 'npm'],
@@ -724,7 +726,6 @@ export const ECOSYSTEMS = [
         id: 'opam-download-cache',
         description: 'opam download cache',
         paths: ['~/.opam/download-cache'],
-        native: { tool: 'opam', argv: ['opam', 'clean', '--download-cache'] },
         busy: ['opam', 'dune', 'ocaml'],
       },
     ],