opencode-v2-guard 1.0.2 → 1.1.0

package/README.md

@@ -18,7 +18,16 @@ Audit: JSONL at `~/.local/share/opencode/guard/guard-audit.jsonl` — categories
 
 ## Dependency installation guard
 
-`npm/pnpm/yarn add`, `pip install`, `cargo add` are parsed before execution (phase 2): a built-in blocklist of known-malicious packages (event-stream, node-ipc, ua-parser-js, coa, rc, flatmap-stream) vetoes the install, and names at Levenshtein distance 1 from a curated top-120 npm list are flagged as typosquats (npm only — other ecosystems reuse the same names legitimately). Global installs (`-g`) are out of scope. Post-install auditing (npm audit / OSV) is planned for phase 2.5.
+`npm/pnpm/yarn add`, `pip install`, `cargo add` are parsed before execution (phase 2): a built-in blocklist of known-malicious packages (event-stream, node-ipc, ua-parser-js, coa, rc, flatmap-stream) vetoes the install, and names at Levenshtein distance 1 from a curated top-120 npm list are flagged as typosquats (npm only — other ecosystems reuse the same names legitimately). Global installs (`-g`) are out of scope.
+
+Phase 2.5 additions:
+
+- `npx pkg`, `pnpm dlx`, `yarn dlx` are checked the same way (execution without install)
+- `@types/*` scoped squatting (`@types/lodahs` → veto), affix squatting (`lodashjs`, `node-lodash`, `react-cli`)
+- `blockedPackages`/`allowedPackages` accept `name@version` (blocks only that version; plain `name` covers all versions)
+- post-audit: ~60s after an allowed npm install, `npm audit --json` runs in the project directory; findings are warn-only audit entries (`postAudit`, default on)
+
+Known gaps: `npm exec` is not parsed; `npx -c "<string>"` contents are not scanned; versioned entries match literally (`rc@1.2.0` does not catch `rc@^1.2.0` or `rc@latest` unless written exactly); post-audit is npm-only (no yarn/pnpm audit) and its 120s timeout is enforced via `taskkill` on Windows (best-effort elsewhere); a forced-kill partial report is dropped; `corepack <pm> ...` indirection and command substitution (`$(npm i x)`) are not expanded.
 
 ## Detection (29 patterns)
 
@@ -67,6 +76,7 @@ OpenCode installs the npm package automatically on startup. Then `opencode servi
 | `scanOutbound` | `true` | scrub outbound context |
 | `scanSkillsOnLoad` | `true` | scan installed skills at startup (warn-only audit) |
 | `depsCheck` | `true` | intercept package installs (blocklist + typosquat) |
+| `postAudit` | `true` | npm audit ~60s after an allowed npm install (warn-only) |
 | `blockedPackages` | `[]` | extra package names blocked from install (union) |
 | `allowedPackages` | `[]` | names exempted from the blocklist (escape hatch) |
 | `blockPaths` | built-in list | **added** to defaults (union) |
@@ -140,7 +150,16 @@ opencode service restart
 
 ## Защита установки зависимостей
 
-`npm/pnpm/yarn add`, `pip install`, `cargo add` парсятся до исполнения (фаза 2): встроенный blocklist известных вредоносных пакетов (event-stream, node-ipc, ua-parser-js, coa, rc, flatmap-stream) блокирует установку, а имена на расстоянии Левенштейна 1 от топ-120 npm ловятся как typosquat (только npm — в других экосистемах те же имена легитимны). Глобальные установки (`-g`) вне зоны охвата. Пост-аудит (npm audit / OSV) — фаза 2.5.
+`npm/pnpm/yarn add`, `pip install`, `cargo add` парсятся до исполнения (фаза 2): встроенный blocklist известных вредоносных пакетов (event-stream, node-ipc, ua-parser-js, coa, rc, flatmap-stream) блокирует установку, а имена на расстоянии Левенштейна 1 от топ-120 npm ловятся как typosquat (только npm — в других экосистемах те же имена легитимны). Глобальные установки (`-g`) вне зоны охвата.
+
+Добавления фазы 2.5:
+
+- `npx pkg`, `pnpm dlx`, `yarn dlx` проверяются так же (исполнение без install)
+- scoped-сквоттинг `@types/*` (`@types/lodahs` → вето), affix-сквоттинг (`lodashjs`, `node-lodash`, `react-cli`)
+- `blockedPackages`/`allowedPackages` принимают `name@version` (блокирует только эту версию; голое `name` — все версии)
+- пост-аудит: через ~60 секунд после пропущенной npm-установки в каталоге проекта запускается `npm audit --json`; находки пишутся в аудит как warn (`postAudit`, по умолчанию включён)
+
+Известные пробелы: `npm exec` не парсится; содержимое `npx -c "<строка>"` не сканируется; версионные записи сопоставляются литерально (`rc@1.2.0` не поймает `rc@^1.2.0` или `rc@latest`, если записано иначе); пост-аудит только для npm (yarn/pnpm — нет), таймаут 120s на Windows исполняется через `taskkill` (best-effort), оборванный принудительным kill отчёт отбрасывается; косвенность `corepack <pm> ...` и подстановка команд (`$(npm i x)`) не раскрываются.
 
 ## Детекция (29 паттернов)
 
@@ -190,6 +209,7 @@ OpenCode сам установит npm-пакет при старте. Зате
 | `scanOutbound` | `true` | скраб исходящего контекста |
 | `scanSkillsOnLoad` | `true` | стартовый скан установленных скиллов (только warn-аудит) |
 | `depsCheck` | `true` | перехват установки пакетов (blocklist + typosquat) |
+| `postAudit` | `true` | npm audit через ~60с после пропущенной npm-установки (только warn) |
 | `blockedPackages` | `[]` | дополнительные запрещённые имена пакетов (union) |
 | `allowedPackages` | `[]` | имена, снятые с блоклиста (обход ложных срабатываний) |
 | `blockPaths` | дефолтный список | **добавляется** к дефолтам (union) |

package/docs/deps25-spec.md

@@ -0,0 +1,106 @@
+# Спека: deps-guard фаза 2.5 — доводка перехвата зависимостей
+
+Статус: принята к реализации. Процесс: спека → тесты (красный) → реализация (зелёный) → ревью субагентами → живая проверка → v1.1.0.
+
+Закрывает §9 deps-spec.md. Исследование API (шаг 0): `shell.create.before` несёт `cwd` —
+пост-аудит реализуем на нём; `tool.execute.before` cwd не несёт (sessionID/agent/messageID/input).
+
+## 1. npx / dlx-перехват (загрузка без install)
+
+`npx pkg[@ver]`, `pnpm dlx pkg`, `yarn dlx pkg` скачивают и исполняют пакет без install — тот же
+риск, что у install. Детерминированный парсинг:
+
+- менеджер: `npx` (+Windows `npx.cmd`/`.ps1`/`.exe`), подкоманды `dlx` у `pnpm`/`yarn`.
+- флаги пропускаются; `-p`/`--package` (npx) — операнд(ы) ЭТО пакеты (проверяются).
+- первый позиционный токен после флагов — пакет для исполнения (имя до `@`, версия после).
+  Токены после `--` — аргументы исполняемой команды, НЕ пакеты (стоп).
+- `-c`/`--call` со строкой-командой — не парсим (содержимое строки не трогаем).
+- git/url-спеки (`npx github:user/repo`) → null.
+- применяются те же проверки: blocklist (case-insens) + squat npm-only + affix (п.3).
+- `npm exec` НЕ покрывается (семантика позиционных аргументов неоднозначна) — documented gap.
+
+## 2. Scoped-сквоттинг (@types)
+
+`@types/<base>`: если `<base>` ∈ TRUSTED_TOP → ок; иначе levenshtein(base, trusted) == 1 → typosquat.
+Примеры: `@types/lodahs` → lodash (вето); `@types/lodash` → ок; `@scope/lodahs` → ок (фаза 3:
+scoped-сквоттинг произвольных скоупов требует списка официальных скоупов).
+
+## 3. Affix-сквоттинг (префикс/суффикс)
+
+Имя = trusted + словарный аффикс (склейка или через дефис):
+- суффиксы: `js`, `ts`, `node`, `cli`, `dev` (+ дефисные формы `-js`, `-ts`, `-node`, `-cli`, `-dev`)
+- префиксы: `node-`, `nodejs-`
+Ловит `lodashjs`, `node-lodash`, `react-cli`, `lodash-js`. Не ловит `lodash-es` (сам в TRUSTED_TOP).
+Allowlist легитимных исторических имён: `angularjs`, `reactjs`, `vuejs`, `expressjs`, `nodejs`,
+`vue-cli`, `angular-cli` (официальные legacy CLI). Только npm-экосистема.
+Причина в аудите: `typosquat` (target = trusted).
+
+## 4. Версионный блоклист
+
+Записи `blockedPackages` вида `name@version` блокируют ТОЛЬКО эту версию; голые `name` — как раньше,
+всё имя. `rc@1.2.9` в блоклисте: `npm i rc@1.2.9` → вето, `npm i rc` → ок, `npm i rc@2.0.0` → ок.
+Scoped: `@scope/pkg@1.0.0` парсится корректно (последний `@`).
+`allowedPackages` поддерживает обе формы; голое имя exempt-ит все версии.
+Версионный allow НЕ снимает имённый блок (только версионную запись того же имени).
+Встроенный BLOCKED_PACKAGES остаётся имённым (инцидентные имена).
+
+## 5. Пост-аудит (npm audit, warn-only)
+
+В `shell.create.before`: если команда — пропущенный npm-install (npm/yarn/pnpm? — только npm:
+npm audit работает по npm-lockfile; yarn/pnpm — gap) и `postAudit` (default true) —
+через 60 сек (эвристика: install успеет завершиться) отсоединённо запускаем
+`npm audit --json` в `event.cwd` (timeout 120s, stdio pipe, ошибки глотаем).
+Результат: `parseAuditReport(json)` агрегирует по severity (v2: `auditReport.vulnerabilities`,
+v1: `advisories`; неизвестные severity → `unknown` — блокирует `__proto__`-строки). Находки → аудит
+`{"kind":"deps","categories":["audit-vulnerability"],"count":N,"action":"warn",severities:{...}}`
++ console.warn. Блокировать постфактум нельзя — это детекция уже установленного.
+Планируется и для пропущенных команд в warn-режиме (install выполнился — самый опасный класс).
+Дедуп по cwd (5 мин). Таймаут: на win32 свой `taskkill /PID /T /F` (встроенный spawn-timeout
+убивает только cmd.exe-обёртку), иначе SIGTERM; оборванный отчёт отбрасывается.
+
+## 6. Конфиг
+
+Новый ключ: `postAudit: boolean` (default `true`). Остальное — через существующие
+blockedPackages/allowedPackages (новые формы записи, п.4).
+
+## 7. Файлы
+
+| Файл | Изменение |
+|---|---|
+| `src/deps.ts` | npx/dlx парсинг, @types-scoped, affix, версионный блоклист, parseAuditReport |
+| `src/guard.ts` | post-audit планировщик в shell.create.before |
+| `src/config.ts` | `postAudit` |
+| `src/audit.ts` | AuditEvent: опциональный `severities?: Record<string, number>` |
+| `test/deps.test.ts` | +~25 тестов |
+| `README.md` | секция deps: npx/dlx, @types, affix, версионный блоклист, пост-аудит (EN+RU) |
+
+## 8. План тестов (TDD)
+
+1. npx: `npx lodahs`→squat; `npx -y lodahs@1.2.3`→squat; `npx -p event-stream`→blocklist;
+   `npx -p lodash node x.js`→первый позиционный `node`… подождать: `-p` пакеты проверяются,
+   позиционные тоже; `npx lodash`→null; `npx node script.js`→null; `npx -- lodahs`→null
+   (после `--` аргументы); `npx.cmd lodahs`→squat (Windows); `npx github:x/y`→null.
+2. dlx: `pnpm dlx lodahs`→squat; `yarn dlx event-stream`→blocklist; `pnpm dlx lodash`→null.
+3. @types: `@types/lodahs`→squat(lodash); `@types/lodash`→null; `@types/reactt`→squat(react);
+   `@scope/lodahs`→null.
+4. affix: `lodashjs`/`node-lodash`/`react-cli`→squat; `angularjs`/`expressjs`/`vuejs`/
+   `nodejs`/`reactjs`→null (allowlist); `lodash-es`→null (trusted); `nodemailer`→null.
+5. версионный блоклист: `rc@1.2.9` блокирует только эту версию; `@scope/pkg@1.0.0` scoped-парс;
+   allowed `rc` снимает версионный тоже; allowed `rc@1.2.9` снимает только её.
+6. parseAuditReport: v2-фикстура (2 critical, 1 high) → severities агрегированы; v1-фикстура;
+   мусор → null; пустой отчёт → нули.
+7. регрессии: все существующие 111 тестов зелёные.
+
+## 9. Критерии готовности
+
+- 111 + новые тесты зелёные, tsc чисто.
+- Ревью субагентом: critical/major исправлены.
+- Живая проверка: `npx lodahs` → вето; `npm install lodash` → ок + через ~60с в аудите
+  kind:"deps" с audit-vulnerability (если в проекте есть уязвимости) либо тишина.
+- Публикация v1.1.0.
+
+## 10. Known gaps (после 2.5)
+
+- `npm exec`, произвольные scoped-скоупы, yarn/pnpm audit, affix-словарь фиксирован.
+- пост-аудит: эвристическая задержка 60s, npm-only, детекция без блокировки.
+- OSV-API как альтернатива npm audit — фаза 3 (нужен выбор источника без ключа).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-v2-guard",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Security plugin for OpenCode V2 — deterministic secret/PII redaction, sensitive-path blocking, prompt-injection detection in skills, package-install interception (blocklist + typosquat)",
   "type": "module",
   "license": "MIT",

package/src/audit.ts

@@ -9,6 +9,8 @@ export interface AuditEvent {
   categories: string[]
   count: number
   action: "redacted" | "blocked" | "warn"
+  /** optional severity breakdown (npm post-audit) */
+  severities?: Record<string, number>
 }
 
 /**

package/src/config.ts

@@ -13,6 +13,8 @@ export interface GuardConfig {
   exemptSkills: string[]
   /** intercept package installation commands (blocklist + typosquat) */
   depsCheck: boolean
+  /** run `npm audit --json` ~60s after an allowed npm install (warn-only detection) */
+  postAudit: boolean
   /** extra package names blocked from installation (union with built-in list) */
   blockedPackages: string[]
   /** package names exempted from the blocklist (escape hatch for legit installs) */
@@ -67,6 +69,7 @@ export function resolveConfig(options: unknown): GuardConfig {
     scanSkillsOnLoad: o.scanSkillsOnLoad !== false,
     exemptSkills: strArray(o.exemptSkills) ? [...o.exemptSkills] : [],
     depsCheck: o.depsCheck !== false,
+    postAudit: o.postAudit !== false,
     blockedPackages: strArray(o.blockedPackages) ? [...o.blockedPackages] : [],
     allowedPackages: strArray(o.allowedPackages) ? [...o.allowedPackages] : [],
     blockPaths: strArray(o.blockPaths) ? [...new Set([...DEFAULT_BLOCK_PATHS, ...o.blockPaths])] : [...DEFAULT_BLOCK_PATHS],

package/src/deps.ts

@@ -12,19 +12,20 @@ export interface InstallPackage {
 }
 
 export interface InstallTarget {
-  manager: "npm" | "yarn" | "pnpm" | "pip" | "cargo"
+  manager: "npm" | "yarn" | "pnpm" | "pip" | "cargo" | "npx" | "bun"
   packages: InstallPackage[]
 }
 
-const MANAGERS = new Set(["npm", "yarn", "pnpm", "pip", "pip3", "cargo"])
+const MANAGERS = new Set(["npm", "yarn", "pnpm", "pip", "pip3", "cargo", "npx", "pnpx", "bun", "bunx"])
 
 const SUBCOMMANDS: Record<string, readonly string[]> = {
   npm: ["install", "i"],
-  yarn: ["add"],
-  pnpm: ["add", "install"],
+  yarn: ["add", "dlx"],
+  pnpm: ["add", "install", "dlx"],
   pip: ["install"],
   pip3: ["install"],
   cargo: ["add"],
+  bun: ["add", "install", "x"],
 }
 
 /** flags that consume the NEXT token as their operand (never a package name) */
@@ -46,6 +47,71 @@ export const BLOCKED_PACKAGES: ReadonlySet<string> = new Set([
   "rc", // 2021: hijack, same campaign as coa
 ])
 
+/** affix squatting: trusted + short dictionary affix, with or without a dash (npm-only check) */
+const AFFIX_SUFFIXES = ["js", "ts", "node", "cli", "dev", "-js", "-ts", "-node", "-cli", "-dev"] as const
+const AFFIX_PREFIXES = ["node-", "nodejs-"] as const
+/** historical legit names that would otherwise match the affix rule */
+const AFFIX_ALLOWLIST: ReadonlySet<string> = new Set(["angularjs", "reactjs", "vuejs", "expressjs", "nodejs", "vue-cli", "angular-cli"])
+
+/** git/url install specs are not registry names — never flag them */
+function isGitOrUrlSpec(token: string): boolean {
+  return (
+    /:\/\//.test(token) ||
+    /^(?:git@|github:|gitlab:|bitbucket:|gist:)/.test(token) ||
+    /\.(?:tgz|tar\.gz|zip)$/i.test(token)
+  )
+}
+
+/** split name@version on the LAST '@' (respects scoped names: @scope/pkg@1.0.0) */
+function splitNameVersion(entry: string): { name: string; version?: string } {
+  const at = entry.lastIndexOf("@")
+  if (at > 0) return { name: entry.slice(0, at), version: entry.slice(at + 1) || undefined }
+  return { name: entry }
+}
+
+/**
+ * npx / pnpm dlx / yarn dlx: the executed package is a positional token, not an install operand.
+ * Flags skipped; -p/--package operands ARE packages; everything after `--` is the command's args.
+ */
+function parseExecTokens(tokens: string[], start: number): InstallTarget | null {
+  const packages: InstallPackage[] = []
+  let positionalTaken = false
+  let ignorePositional = false
+  for (let j = start; j < tokens.length; j++) {
+    const t = tokens[j]
+    if (t === "--") break // rest belongs to the executed command
+    if (t.startsWith("-")) {
+      if (t === "-p" || t === "--package") {
+        const next = tokens[++j]
+        if (next && !isGitOrUrlSpec(next)) packages.push(splitNameVersion(next))
+        continue
+      }
+      if (t.startsWith("-p=")) {
+        const v = t.slice(3)
+        if (v && !isGitOrUrlSpec(v)) packages.push(splitNameVersion(v))
+        continue
+      }
+      if (t.startsWith("--package=")) {
+        const v = t.slice("--package=".length)
+        if (v && !isGitOrUrlSpec(v)) packages.push(splitNameVersion(v))
+        continue
+      }
+      if (t === "-c" || t === "--call") {
+        j++ // consume the shell string
+        ignorePositional = true
+        continue
+      }
+      continue
+    }
+    if (!positionalTaken && !ignorePositional && !isGitOrUrlSpec(t)) {
+      packages.push(splitNameVersion(t))
+      positionalTaken = true
+    }
+  }
+  if (packages.length === 0) return null
+  return { manager: "npx", packages }
+}
+
 /** curated popular npm names for typosquat distance-1 checks (119 unique) */
 export const TRUSTED_TOP: ReadonlySet<string> = new Set([
   "lodash", "react", "react-dom", "vue", "angular", "express", "axios", "moment",
@@ -98,15 +164,34 @@ function parseSegment(segment: string): InstallTarget | null {
   // Windows runners: npm.cmd, pnpm.cmd, pip.exe, yarn.ps1, ... — strip the script/extension suffix
   const raw = tokens[i]
   if (!raw) return null
-  const manager = raw.replace(/\.(?:cmd|ps1|exe|bat)$/i, "")
+  const manager = raw.replace(/\.(?:cmd|ps1|exe|bat)$/i, "").toLowerCase()
   if (!MANAGERS.has(manager)) return null
-  const sub = tokens[i + 1]
+  // execution-without-install forms: npx/pnpx/bunx pkg / pnpm|yarn dlx / bun x
+  if (manager === "npx" || manager === "pnpx" || manager === "bunx") return parseExecTokens(tokens, i + 1)
+  if ((manager === "pnpm" || manager === "yarn") && tokens[i + 1]?.toLowerCase() === "dlx") {
+    return parseExecTokens(tokens, i + 2)
+  }
+  if (manager === "bun" && tokens[i + 1]?.toLowerCase() === "x") {
+    return parseExecTokens(tokens, i + 2)
+  }
+  // global flags may precede the subcommand: npm --prefix . install pkg / yarn --cwd p add pkg
+  const takesArgEarly = FLAG_TAKES_ARG[manager]
+  let k = i + 1
+  let globalFlag = false
+  while (k < tokens.length && tokens[k].startsWith("-")) {
+    const flag = tokens[k]
+    if (flag === "-g" || flag === "--global") globalFlag = true
+    k++
+    if (takesArgEarly?.has(flag) && k < tokens.length) k++ // consume the flag's operand
+  }
+  if (globalFlag) return null
+  const sub = tokens[k]?.toLowerCase()
   if (!SUBCOMMANDS[manager]?.includes(sub)) return null
-  if (manager === "yarn" && tokens[i + 2] === "global") return null
+  if (manager === "yarn" && tokens[k + 1]?.toLowerCase() === "global") return null
 
   const takesArg = FLAG_TAKES_ARG[manager]
   const packages: InstallPackage[] = []
-  for (let j = i + 2; j < tokens.length; j++) {
+  for (let j = k + 1; j < tokens.length; j++) {
     const t = tokens[j]
     if (t.startsWith("-")) {
       if (t === "-g" || t === "--global") return null
@@ -118,13 +203,18 @@ function parseSegment(segment: string): InstallTarget | null {
     if (manager === "pip" || manager === "pip3") {
       const m = /^([^=<>~!]+?)([=<>~!].*)?$/.exec(t)
       if (!m || !m[1]) continue
-      name = m[1]
+      name = m[1].replace(/\[[^\]]*\]$/, "") // extras: event-stream[socks] -> event-stream
       version = m[2] ? m[2].replace(/^[=<>~!]+/, "") : undefined
     } else {
       const at = t.lastIndexOf("@")
       if (at > 0) {
         name = t.slice(0, at)
         version = t.slice(at + 1)
+        // npm alias: alias@npm:event-stream actually installs event-stream
+        if (version.startsWith("npm:") && version.length > 4) {
+          name = version.slice(4)
+          version = undefined
+        }
       }
     }
     if (!name) continue
@@ -140,7 +230,7 @@ function parseSegment(segment: string): InstallTarget | null {
  */
 export function parseSegments(command: string): InstallTarget[] {
   const out: InstallTarget[] = []
-  for (const segment of command.split(/&&|\|\||[;|]|\n/)) {
+  for (const segment of command.split(/&&|\|\||[;|&]|\n/)) {
     const hit = parseSegment(segment)
     if (hit) out.push(hit)
   }
@@ -181,7 +271,18 @@ export function levenshtein(a: string, b: string): number {
 /** returns the trusted name this package is squatting, or null (case-insensitive) */
 export function isTyposquat(name: string): string | null {
   const n = name.toLowerCase()
-  if (n.startsWith("@") || n.length < 4) return null
+  if (n.length < 4) return null
+  // scoped: only @types/* is checked (arbitrary scopes need an official-scope list — phase 3)
+  if (n.startsWith("@")) {
+    if (!n.startsWith("@types/")) return null
+    const base = n.slice("@types/".length)
+    if (TRUSTED_TOP.has(base)) return null
+    for (const trusted of TRUSTED_TOP) {
+      if (Math.abs(trusted.length - base.length) > 1) continue
+      if (levenshtein(base, trusted) === 1) return trusted
+    }
+    return null
+  }
   if (TRUSTED_TOP.has(n)) return null
   for (const trusted of TRUSTED_TOP) {
     if (Math.abs(trusted.length - n.length) > 1) continue
@@ -190,6 +291,21 @@ export function isTyposquat(name: string): string | null {
   return null
 }
 
+/** affix squatting: lodashjs / node-lodash / react-cli — trusted + dictionary affix */
+export function isAffixSquat(name: string): string | null {
+  const n = name.toLowerCase()
+  if (TRUSTED_TOP.has(n) || AFFIX_ALLOWLIST.has(n)) return null
+  for (const trusted of TRUSTED_TOP) {
+    for (const suffix of AFFIX_SUFFIXES) {
+      if (n === trusted + suffix) return trusted
+    }
+    for (const prefix of AFFIX_PREFIXES) {
+      if (n === prefix + trusted) return trusted
+    }
+  }
+  return null
+}
+
 export interface DepsVerdict {
   name: string
   reason: "blocklist" | "typosquat"
@@ -198,24 +314,56 @@ export interface DepsVerdict {
 
 /**
  * Check a raw shell command; returns the first violation or null.
- * extraBlocked: user names added to the blocklist; allowed: user names exempted from it.
+ * extraBlocked/allowed entries: plain "name" (all versions) or "name@version" (that version only).
  */
 export function checkInstall(command: string, extraBlocked: readonly string[] = [], allowed: readonly string[] = []): DepsVerdict | null {
   const targets = parseSegments(command)
   if (targets.length === 0) return null
-  const ok = new Set(allowed.map((p) => p.toLowerCase()))
-  const blocked = new Set([...BLOCKED_PACKAGES, ...extraBlocked].map((p) => p.toLowerCase()))
+
+  const allowedWide = new Set<string>()
+  const allowedVer = new Set<string>() // "name@version", lowercased
+  for (const e of allowed) {
+    const { name, version } = splitNameVersion(e)
+    const l = name.toLowerCase()
+    if (version) allowedVer.add(l + "@" + version.toLowerCase())
+    else allowedWide.add(l)
+  }
+
+  const blockedWide = new Set<string>()
+  const blockedVer = new Map<string, Set<string>>()
+  for (const e of [...BLOCKED_PACKAGES, ...extraBlocked]) {
+    const { name, version } = splitNameVersion(e)
+    const l = name.toLowerCase()
+    if (version) {
+      const s = blockedVer.get(l) ?? new Set<string>()
+      s.add(version.toLowerCase())
+      blockedVer.set(l, s)
+    } else {
+      blockedWide.add(l)
+    }
+  }
+
+  const npmish = new Set(["npm", "yarn", "pnpm", "npx", "bun"])
   for (const target of targets) {
-    const npmish = target.manager === "npm" || target.manager === "yarn" || target.manager === "pnpm"
     for (const pkg of target.packages) {
       const lower = pkg.name.toLowerCase()
-      if (ok.has(lower)) continue
-      if (blocked.has(lower)) {
+      const ver = pkg.version ? pkg.version.toLowerCase() : undefined
+      if (allowedWide.has(lower)) continue
+      // a versioned allow entry must NOT lift a name-wide block (spec: it lifts only versioned blocks)
+      if (blockedWide.has(lower)) {
         return { name: pkg.name, reason: "blocklist" }
       }
-      // squat check is npm-only: other ecosystems reuse the same names legitimately (pip "requests" vs npm "request")
-      if (npmish) {
-        const squat = isTyposquat(pkg.name)
+      if (ver && allowedVer.has(lower + "@" + ver)) continue
+      if (ver) {
+        const s = blockedVer.get(lower)
+        if (s?.has(ver)) {
+          return { name: pkg.name, reason: "blocklist" }
+        }
+      }
+      // squat checks are npm-ecosystem-only: other ecosystems reuse the same names legitimately (pip "requests" vs npm "request")
+      if (npmish.has(target.manager)) {
+        // affix first: "lodash-js" is affix of lodash (exact form), not a dist-1 edit of lodash-es
+        const squat = isAffixSquat(pkg.name) ?? isTyposquat(pkg.name)
         if (squat) {
           return { name: pkg.name, reason: "typosquat", target: squat }
         }
@@ -224,3 +372,49 @@ export function checkInstall(command: string, extraBlocked: readonly string[] =
   }
   return null
 }
+
+/** true if any segment is an npm install (drives the post-audit scheduler; npx/dlx don't count) */
+export function isNpmInstall(command: string): boolean {
+  return parseSegments(command).some((t) => t.manager === "npm")
+}
+
+export interface AuditSummary {
+  total: number
+  severities: Record<string, number>
+}
+
+/** npm audit severity vocabulary; anything else folds into "unknown" (blocks __proto__-style key damage) */
+const SEVERITY_NAMES = new Set(["info", "low", "moderate", "high", "critical"])
+
+/** aggregate `npm audit --json` output (v2 auditReport.vulnerabilities or v1 advisories); null if unusable */
+export function parseAuditReport(text: string): AuditSummary | null {
+  let json: unknown
+  try {
+    json = JSON.parse(text)
+  } catch {
+    return null
+  }
+  if (typeof json !== "object" || json === null) return null
+  const obj = json as Record<string, unknown>
+  const sources: unknown[] = []
+  if (typeof obj.auditReport === "object" && obj.auditReport !== null) {
+    sources.push((obj.auditReport as Record<string, unknown>).vulnerabilities)
+  }
+  if (typeof obj.advisories === "object" && obj.advisories !== null) {
+    sources.push(obj.advisories)
+  }
+  const found = sources.filter((s) => typeof s === "object" && s !== null && !Array.isArray(s))
+  if (found.length === 0) return null
+  const severities: Record<string, number> = {}
+  let total = 0
+  for (const s of found) {
+    for (const entry of Object.values(s as Record<string, unknown>)) {
+      if (typeof entry !== "object" || entry === null) continue
+      const sev = (entry as Record<string, unknown>).severity
+      const key = typeof sev === "string" && SEVERITY_NAMES.has(sev) ? sev : "unknown"
+      severities[key] = (severities[key] ?? 0) + 1
+      total++
+    }
+  }
+  return { total, severities }
+}

package/src/guard.ts

@@ -1,6 +1,7 @@
 import { Error as ToolError } from "@opencode/plugin/promise/tool"
 import type { Plugin } from "@opencode/plugin"
 import { createHash } from "node:crypto"
+import { spawn } from "node:child_process"
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs"
 import { homedir } from "node:os"
 import { join } from "node:path"
@@ -10,7 +11,7 @@ import { isPathBlocked, isPathExempt, isPathWriteProtected } from "./glob.ts"
 import type { GuardConfig } from "./config.ts"
 import { appendAudit, type AuditEvent } from "./audit.ts"
 import { scanSkillDir } from "./skillcheck.ts"
-import { checkInstall } from "./deps.ts"
+import { checkInstall, isNpmInstall, parseAuditReport } from "./deps.ts"
 
 type Ctx = Plugin.Context
 
@@ -140,6 +141,81 @@ const tracked: { dispose(): Promise<void> }[] = []
 const DEPS_AUDIT_TTL_MS = 2000
 const depsAuditRecent = new Map<string, number>()
 
+/** post-audit: give the install ~60s to finish, then npm audit in the project dir (warn-only) */
+const POST_AUDIT_DELAY_MS = 60_000
+const POST_AUDIT_TIMEOUT_MS = 120_000
+/** don't stack audits for the same project dir (a burst of installs schedules one audit) */
+const postAuditRecent = new Map<string, number>()
+const POST_AUDIT_DEDUP_MS = 5 * 60_000
+
+function schedulePostAudit(command: string, cwd: string, cfg: GuardConfig): void {
+  try {
+    if (!isNpmInstall(command)) return
+    const last = postAuditRecent.get(cwd)
+    if (last && Date.now() - last < POST_AUDIT_DEDUP_MS) return
+    postAuditRecent.set(cwd, Date.now())
+    if (postAuditRecent.size > 100) postAuditRecent.clear()
+    const timer = setTimeout(() => {
+      try {
+        const child = spawn("npm", ["audit", "--json"], {
+          cwd,
+          shell: process.platform === "win32",
+          detached: true,
+          windowsHide: true,
+        })
+        let stdout = ""
+        child.stdout?.on("data", (d: Buffer) => {
+          stdout += d.toString()
+        })
+        child.on("error", () => {})
+        // built-in spawn timeout only kills the win32 cmd.exe wrapper — enforce our own
+        let closed = false
+        const killer = setTimeout(() => {
+          try {
+            if (closed) return
+            if (process.platform === "win32") {
+              if (child.pid === undefined) return
+              spawn("taskkill", ["/PID", String(child.pid), "/T", "/F"], { windowsHide: true }).on("error", () => {})
+            } else {
+              child.kill("SIGTERM")
+            }
+          } catch {}
+        }, POST_AUDIT_TIMEOUT_MS)
+        killer.unref?.()
+        child.on("close", () => {
+          try {
+            closed = true
+            clearTimeout(killer)
+            // partial JSON after a forced kill simply fails to parse — dropped, by design
+            const report = parseAuditReport(stdout)
+            if (!report || report.total === 0) return
+            const sev = Object.entries(report.severities)
+              .map(([k, v]) => `${k}:${v}`)
+              .join(" ")
+            audit(cfg, {
+              ts: new Date().toISOString(),
+              kind: "deps",
+              categories: ["audit-vulnerability"],
+              count: report.total,
+              action: "warn",
+              severities: report.severities,
+            })
+            console.warn(`guard: npm audit в ${cwd} — ${report.total} уязвимостей (${sev}), детали в аудите`)
+          } catch {
+            // never crash the plugin over a post-audit result
+          }
+        })
+        child.unref?.()
+      } catch {
+        // never crash the plugin over scheduling
+      }
+    }, POST_AUDIT_DELAY_MS)
+    timer.unref?.()
+  } catch {
+    // never crash the hook
+  }
+}
+
 export function registerGuard(ctx: Ctx, cfg: GuardConfig): () => Promise<void> {
   const patterns = activePatterns(cfg.disabledPatterns)
   const now = () => new Date().toISOString()
@@ -368,9 +444,12 @@ export function registerGuard(ctx: Ctx, cfg: GuardConfig): () => Promise<void> {
           if (!last || Date.now() - last > DEPS_AUDIT_TTL_MS) {
             audit(cfg, { ts: now(), kind: "deps", categories: [cat], count: 1, action: mutate ? "blocked" : "warn" })
           }
+          // warn mode lets the install through — it still qualifies for post-audit
+          if (!mutate && cfg.postAudit) schedulePostAudit(event.command, event.cwd, cfg)
           return
         }
       }
+      if (cfg.postAudit) schedulePostAudit(event.command, event.cwd, cfg)
       if (!cfg.redactOnWrite) return
       const r = redact(event.command, patterns)
       if (r.matches.length > 0) {