@rclr-labs/dsh-plugin-qa 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,106 @@
-# Temporary Holding Version
+# @rclr-labs/dsh-plugin-qa
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**“Este plugin instala e boota num perfil limpo?”** — respondido executando, não opinando.
+
+O DSH isola falha de plugin: um plugin que quebra no carregamento **não derruba mais o
+boot** — o processo sai 0 e apenas avisa (`N entries did not activate`). Por isso
+“instalou” nunca significou “funciona”, e nem CI nem o usuário percebem a diferença.
+Num catálogo real, **93% dos plugins falhavam na instalação**. Este pacote é o nosso
+`npm run verify` empacotado para terceiros: ele instala a spec num `DSH_HOME`
+descartável, **boota de verdade** e lê os avisos de ativação.
+
+## O que ele faz
+
+Para cada spec (diretório local, tarball `.tgz` ou nome no registry):
+
+1. cria um perfil descartável (template `headless`, `DSH_HOME` temporário — o seu perfil real não é tocado);
+2. instala com o **`dsh plugin add` real** (não é simulação de `node_modules`);
+3. boota e parseia a saída de ativação;
+4. descarta o perfil (inclusive em falha) e devolve um relatório estruturado:
+
+```json
+{
+  "spec": "packages/meu-plugin",
+  "nome": "dsh-meu-plugin",
+  "versao": "1.2.0",
+  "instala": true,
+  "boota": false,
+  "entradasNaoAtivadas": [
+    { "id": "meu-plugin", "pacote": "dsh-meu-plugin", "motivo": "failed to import", "detalhe": "..." }
+  ],
+  "camadas": ["@deepseek-ai/dsh-base", "@deepseek-ai/dsh-headless", "dsh-meu-plugin"],
+  "erro": "1 entrada(s) não ativaram",
+  "duracaoMs": 908
+}
+```
+
+## CLI
+
+```bash
+# no checkout deste repo
+node packages/plugin-qa/bin/plugin-qa.mjs check packages/meu-plugin
+
+# instalado globalmente
+npm i -g @rclr-labs/dsh-plugin-qa
+plugin-qa check packages/meu-plugin
+plugin-qa check dsh-context --strict
+plugin-qa check packages/a dist/b.tgz --json      # várias specs, resultado agregado
+```
+
+| opção | efeito |
+|---|---|
+| `--json` | imprime o selo agregado em JSON (consumível por CI/agente) |
+| `--strict` | exit 1 se **qualquer** spec não instalar ou não bootar |
+
+Exit codes: `0` = verificação concluída (sem `--strict`, mesmo reprovado); `1` = `--strict`
+e alguma spec reprovada; `2` = erro de uso/infraestrutura.
+
+## Como plugin (ferramenta para o agente)
+
+```bash
+dsh plugin --profile <perfil> add @rclr-labs/dsh-plugin-qa
+```
+
+O pacote traz `cordis.patch.yml` no `files` e registra a ferramenta **`plugin_qa`**
+(`spec` obrigatória, `strict` opcional). O agente passa a poder responder sozinho
+“esse plugin instala e boota?” com a mesma prova que o CLI produz.
+
+## O selo
+
+O resultado agregado é o selo:
+
+```json
+{ "selo": "aprovado", "ok": true, "total": 2, "aprovados": 2, "reprovados": 0, "resultados": [ ... ] }
+```
+
+- **aprovado** — toda spec `instala: true` **e** `boota: true` (nenhuma entrada ficou de fora);
+- **reprovado** — qualquer spec que não instale, ou que instale mas deixe alguma entrada sem ativar.
+
+`boota` exige que a árvore tenha montado **e** que zero entradas tenham ficado de fora.
+O código de saída do boot não é usado como sinal: o `headless` sem tarefa sai 1 por uso
+(“a task is required”) depois de montar a árvore — o sinal é a fase de montagem.
+
+## Verificação deste pacote (no checkout)
+
+```bash
+node packages/plugin-qa/test/plugin-qa.test.mjs     # o teste que falha sem o pacote
+node test-support/compat.mjs --spec=packages/plugin-qa
+node test-support/profile.mjs --demo --spec=packages/plugin-qa
+node packages/plugin-qa/bin/plugin-qa.mjs check packages/locale-pt-br   # dogfooding
+```
+
+## Limitações honestas
+
+- **Não julga qualidade.** Não lê o código, não avalia intenção, segurança, licença nem
+  desempenho — responde só “instala e boota num perfil limpo?”. Não substitui revisão de código.
+- **Não é análise estática.** É uma prova de execução: exige o CLI do DSH instalado
+  (`DSH_BIN` ou o app Desktop) e uma instalação real da spec (registry/rede quando for o caso).
+- **Um perfil por spec, em sequência.** Determinístico e limpo, mas não paralelo; ~1s por spec
+  local depois do primeiro boot.
+- **O harness de perfil vive fora do pacote.** O núcleo importa
+  `test-support/profile.mjs` do checkout (`../../../test-support/profile.mjs`), então o
+  `verify` roda **no checkout**. Um pacote instalado isoladamente ativa como plugin (a linha
+  compõe), mas o CLI/tool exige o checkout do `dsh-plugins` até que o harness seja embutido.
+- **Specs locais resolvem a partir da raiz do checkout**, como em `profile.addSpec`.
+- Um perfil limpo do template `headless` **não** é o perfil do usuário: um plugin que boota
+  aqui ainda pode conflitar com as outras camadas que você instalou.

package/bin/plugin-qa.mjs

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+/**
+ * plugin-qa — "este plugin instala e boota num perfil limpo?"
+ *
+ *   plugin-qa check <spec> [<spec>...] [--json] [--strict]
+ *
+ * A spec é aceita em qualquer forma que o `dsh plugin add` aceite: diretório
+ * local, `.tgz` empacotado ou nome no registry. Cada spec roda num DSH_HOME
+ * descartável e é sempre limpa — inclusive em falha.
+ *
+ * `--json`  imprime o selo agregado (consumível por CI/agente).
+ * `--strict` devolve exit 1 quando alguma spec não instala ou não boota.
+ *
+ * Por que existe: o DSH isola a falha do plugin — o boot sai 0 e só avisa — então
+ * "instalou" nunca foi o mesmo que "funciona". Este é o nosso `npm run verify`
+ * empacotado para terceiros.
+ */
+
+import { verificar } from '../lib/core.mjs'
+
+const argv = process.argv.slice(2)
+const flag = (nome) => argv.includes(`--${nome}`)
+const comando = argv.find((a) => !a.startsWith('-')) ?? null
+const specs = argv.filter((a) => !a.startsWith('-') && a !== comando)
+
+const uso = () => {
+  console.log(`
+  plugin-qa — este plugin instala e boota num perfil limpo?
+
+  uso:
+    plugin-qa check <spec> [<spec>...] [--json] [--strict]
+
+  spec:
+    diretório local (ex.: packages/meu-plugin), tarball (.tgz) ou nome no registry
+
+  opções:
+    --json     imprime o selo agregado em JSON
+    --strict   exit 1 se alguma spec não instalar ou não bootar
+
+  exemplos:
+    plugin-qa check packages/meu-plugin
+    plugin-qa check dsh-context --strict
+    plugin-qa check packages/a dist/b.tgz --json
+`)
+}
+
+if (flag('help')) {
+  uso()
+  process.exit(0)
+}
+
+if (!comando) {
+  uso()
+  process.exit(2)
+}
+
+if (comando !== 'check') {
+  console.error(`  ✗ comando desconhecido: ${comando} (use: check)`)
+  process.exit(2)
+}
+
+if (!specs.length) {
+  console.error('  ✗ falta pelo menos uma spec. Ex.: plugin-qa check packages/meu-plugin')
+  process.exit(2)
+}
+
+let selo
+try {
+  selo = await verificar(specs, {
+    bin: process.env.DSH_BIN,
+    timeoutMs: Number(process.env.QA_TIMEOUT_MS ?? 300_000),
+    bootTimeoutMs: Number(process.env.QA_BOOT_TIMEOUT_MS ?? 60_000),
+  })
+} catch (err) {
+  // Só chega aqui um erro de infraestrutura (ex.: harness de perfil ausente).
+  console.error(`  ✗ ${err?.message ?? err}`)
+  if (flag('json')) console.log(JSON.stringify({ selo: 'reprovado', ok: false, erro: String(err?.message ?? err), resultados: [] }, null, 2))
+  process.exit(2)
+}
+
+if (flag('json')) {
+  console.log(JSON.stringify(selo, null, 2))
+} else {
+  console.log(`\n  plugin-qa — "instala e boota num perfil limpo?"\n`)
+  for (const r of selo.resultados) {
+    const aprovado = r.instala && r.boota
+    console.log(`  ${aprovado ? '✓' : '✗'} ${r.spec}`)
+    console.log(`      nome:    ${r.nome ?? '—'}${r.versao ? `@${r.versao}` : ''}`)
+    console.log(`      instala: ${r.instala ? 'sim' : 'NÃO'}`)
+    console.log(`      boota:   ${r.boota ? 'sim' : 'NÃO'}`)
+    console.log(`      camadas: ${r.camadas.length}`)
+    if (r.entradasNaoAtivadas.length) {
+      console.log(`      não ativou:`)
+      for (const e of r.entradasNaoAtivadas) console.log(`        - ${e.id} (${e.pacote}): ${e.motivo}`)
+    }
+    if (r.erro) console.log(`      erro:    ${r.erro}`)
+    console.log(`      tempo:   ${r.duracaoMs}ms`)
+    console.log()
+  }
+  console.log(`  selo: ${selo.selo} (${selo.aprovados}/${selo.total} aprovados)\n`)
+  if (selo.selo === 'reprovado' && !flag('strict')) {
+    console.log('  use --strict para transformar o selo em código de saída.\n')
+  }
+}
+
+const exit = flag('strict') && !selo.ok ? 1 : 0
+process.exit(exit)

package/cordis.patch.yml

@@ -0,0 +1,8 @@
+# O plugin-qa registra a própria linha na árvore do perfil.
+#
+# Sem este arquivo no `files` do package.json, o pacote instalado do registry não
+# ativa nenhuma camada e o DSH RECUSA a instalação — foi o defeito real do
+# locale-pt-BR em 02/10/2026.
+- insert:
+    - id: plugin-qa
+      name: '@rclr-labs/dsh-plugin-qa'

package/lib/core.mjs

@@ -0,0 +1,274 @@
+/**
+ * Núcleo do plugin-qa — pura, sem dependência do runtime do DSH.
+ *
+ * Responde a UMA pergunta, com prova executável: **esta spec instala e boota num
+ * perfil limpo?** É a pergunta que o ecossistema não respondia — 93% dos plugins
+ * de um catálogo falhavam na instalação, e o boot do DSH isola a falha (sai 0 e
+ * só avisa) — então nem CI nem o usuário percebem.
+ *
+ * Desenho:
+ *   1. `test-support/profile.mjs` cria o perfil descartável (DSH_HOME temporário);
+ *      NADA é escrito fora do tmp e o perfil é sempre descartado.
+ *   2. a spec é instalada pelo próprio `dsh plugin add` (aceita diretório, `.tgz`
+ *      ou nome no registry) — é o caminho REAL de instalação, não uma simulação.
+ *   3. o boot é exercitado e a saída é lida de verdade: o DSH emite
+ *      `warning: N entries did not activate` + `<id> (<pacote>): <motivo>`.
+ *      Como o boot sem tarefa sai 1 por uso ("a task is required"), o código de
+ *      saída NÃO é o sinal — o sinal é a árvore ter montado e nenhuma entrada
+ *      ter ficado de fora.
+ *
+ * Reuso deliberado: o harness de perfil vive FORA do pacote
+ * (`test-support/profile.mjs`). O `verify` roda no checkout do dsh-plugins; um
+ * pacote publicado não embute o harness (limitação documentada no README).
+ */
+
+import fs from 'node:fs'
+import path from 'node:path'
+import { spawn } from 'node:child_process'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+const AQUI = path.dirname(fileURLToPath(import.meta.url))
+
+/** `test-support/profile.mjs` do checkout (três níveis acima de lib/). */
+export const HELPER_PROFILE = path.resolve(AQUI, '..', '..', '..', 'test-support', 'profile.mjs')
+/** Raiz do checkout — a MESMA base que `profile.addSpec` usa para resolver specs locais. */
+export const RAIZ_CHECKOUT = path.resolve(path.dirname(HELPER_PROFILE), '..')
+
+/** Sinais de que o DSH terminou de montar a árvore (o plugin pode estar quebrado, mas montou). */
+const MONTAGEM = /a task is required|did not activate/
+/** `dsh: warning: 2 entries did not activate` */
+const AVISO = /warning:\s*(\d+)\s+entr(?:y|ies) did not activate/
+
+const primeiraLinha = (s) => String(s ?? '').split('\n').find((l) => l.trim())?.trim() ?? ''
+const ultimaLinha = (s) => String(s ?? '').trim().split('\n').filter(Boolean).pop()?.trim() ?? ''
+
+/**
+ * Lê os avisos de ativação do boot.
+ * Formato: `<id> (<pacote>): <motivo>`, com linhas de continuação indentadas.
+ */
+export function parseNaoAtivadas(saida) {
+  const texto = String(saida ?? '')
+  const declarado = Number(texto.match(AVISO)?.[1] ?? 0)
+  const linhas = texto.split('\n')
+  const entradas = []
+
+  for (let i = 0; i < linhas.length; i++) {
+    const m = linhas[i].match(/^(\S+)\s+\(([^)]+)\):\s*(.+)$/)
+    if (!m) continue
+    const [, id, pacote, motivo] = m
+    const detalhe = [motivo]
+    for (let j = i + 1; j < linhas.length; j++) {
+      if (!/^\s{2,}\S/.test(linhas[j])) break
+      detalhe.push(linhas[j])
+    }
+    entradas.push({ id, pacote, motivo, detalhe: detalhe.join('\n').trimEnd() })
+  }
+  return { declarado, entradas }
+}
+
+/** Deriva o nome npm de uma spec (`dsh-x`, `@escopo/nome@1.2.3`) — sem tocar na rede. */
+export function nomeDeSpecNpm(spec) {
+  if (!spec || spec.startsWith('.') || spec.startsWith('/') || spec.startsWith('file:') || spec.endsWith('.tgz')) return null
+  if (spec.startsWith('@')) {
+    const barra = spec.indexOf('/')
+    if (barra === -1) return spec
+    const arroba = spec.indexOf('@', barra)
+    return arroba === -1 ? spec : spec.slice(0, arroba)
+  }
+  const arroba = spec.indexOf('@')
+  return arroba === -1 ? spec : spec.slice(0, arroba)
+}
+
+/** Diretório local correspondente à spec, na mesma base do `profile.addSpec`. */
+function caminhoLocal(spec) {
+  for (const base of [RAIZ_CHECKOUT, process.cwd()]) {
+    const abs = path.resolve(base, spec)
+    try {
+      if (fs.existsSync(abs) && fs.statSync(abs).isDirectory()) return abs
+    } catch {
+      /* segue */
+    }
+  }
+  return null
+}
+
+function lerManifesto(dir) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+function resolverNome(spec, novas) {
+  const local = caminhoLocal(spec)
+  if (local) {
+    const pkg = lerManifesto(local)
+    if (pkg?.name) return pkg.name
+  }
+  if (novas.length) return novas[0]
+  return nomeDeSpecNpm(spec)
+}
+
+function lerVersao(perfil, spec, nome) {
+  if (nome) {
+    const pkg = lerManifesto(path.join(perfil.dir, 'node_modules', ...nome.split('/')))
+    if (pkg?.version) return pkg.version
+  }
+  const local = caminhoLocal(spec)
+  return local ? (lerManifesto(local)?.version ?? null) : null
+}
+
+/** Importa o harness de perfil do checkout, com erro explícito se ele não existir. */
+export async function carregarHelper() {
+  if (!fs.existsSync(HELPER_PROFILE)) {
+    throw new Error(
+      `o núcleo do plugin-qa reutiliza test-support/profile.mjs do checkout (${HELPER_PROFILE}) e ele não existe. ` +
+        `Rode a partir do checkout do dsh-plugins; o pacote publicado ainda não embute o harness.`,
+    )
+  }
+  return import(pathToFileURL(HELPER_PROFILE).href)
+}
+
+/**
+ * Boota o perfil e devolve a saída crua.
+ *
+ * `stdio[0] = 'ignore'` é essencial: o headless lê a tarefa do stdin e, com um
+ * pipe aberto que nunca fecha, ficaria pendurado até o timeout — foi assim que um
+ * teste existente passou a medir timeout como se fosse "boot exit 0".
+ */
+export function bootar(bin, nomePerfil, env, { timeoutMs = 60_000 } = {}) {
+  return new Promise((resolve) => {
+    let finalizado = false
+    let timer = null
+    let saida = ''
+    const encerrar = (r) => {
+      if (finalizado) return
+      finalizado = true
+      if (timer) clearTimeout(timer)
+      resolve(r)
+    }
+
+    let child
+    try {
+      child = spawn(bin, ['--profile', nomePerfil], { env, stdio: ['ignore', 'pipe', 'pipe'] })
+    } catch (err) {
+      resolve({ code: null, saida: '', timeout: false, erro: String(err?.message ?? err) })
+      return
+    }
+
+    timer = setTimeout(() => {
+      encerrar({ code: null, saida, timeout: true, erro: `o boot não terminou em ${timeoutMs}ms` })
+      try {
+        child.kill('SIGKILL')
+      } catch {
+        /* já morreu */
+      }
+    }, timeoutMs)
+
+    child.stdout?.on('data', (d) => (saida += d))
+    child.stderr?.on('data', (d) => (saida += d))
+    child.on('error', (err) => encerrar({ code: null, saida, timeout: false, erro: String(err?.message ?? err) }))
+    child.on('close', (code) => encerrar({ code, saida, timeout: false, erro: null }))
+  })
+}
+
+/**
+ * Verifica UMA spec num perfil limpo e descartável.
+ *
+ * Relatório: `{ spec, nome, versao, instala, boota, entradasNaoAtivadas, camadas, erro, duracaoMs }`.
+ * - `instala`  — a spec entrou em `dsh.profile.bundles` (a instalação real aceitou o pacote);
+ * - `boota`    — a árvore montou e NENHUMA entrada ficou de fora;
+ * - `erro`     — o motivo, quando instalar ou bootar não puderam ser confirmados.
+ */
+export async function checkSpec(spec, { bin, timeoutMs = 300_000, bootTimeoutMs = 60_000 } = {}) {
+  const t0 = Date.now()
+  const relatorio = {
+    spec,
+    nome: null,
+    versao: null,
+    instala: false,
+    boota: false,
+    entradasNaoAtivadas: [],
+    camadas: [],
+    erro: null,
+  }
+
+  let perfil
+  try {
+    const { createProfile } = await carregarHelper()
+    perfil = await createProfile({ bin })
+    try {
+      await perfil.init()
+
+      const antes = perfil.bundles()
+      await perfil.addSpec(spec, { timeoutMs })
+      const depois = perfil.bundles()
+      const novas = depois.filter((b) => !antes.includes(b))
+
+      relatorio.nome = resolverNome(spec, novas)
+      relatorio.versao = lerVersao(perfil, spec, relatorio.nome)
+      relatorio.instala = Boolean(relatorio.nome) && depois.includes(relatorio.nome)
+
+      if (!relatorio.instala) {
+        relatorio.erro = `a instalação não registrou nenhuma camada em dsh.profile.bundles (bundles: ${depois.join(', ') || '—'})`
+      }
+
+      try {
+        relatorio.camadas = await perfil.layers()
+      } catch (err) {
+        relatorio.erro ??= `não consegui ler a composição: ${primeiraLinha(err?.message)}`
+      }
+
+      const boot = await bootar(perfil.bin, perfil.name, perfil.env, { timeoutMs: bootTimeoutMs })
+      const { declarado, entradas } = parseNaoAtivadas(boot.saida)
+      relatorio.entradasNaoAtivadas = entradas
+
+      if (boot.timeout) {
+        relatorio.boota = false
+        relatorio.erro ??= boot.erro
+      } else if (!MONTAGEM.test(boot.saida)) {
+        relatorio.boota = false
+        relatorio.erro ??= `o boot não chegou a montar a árvore: ${ultimaLinha(boot.saida) || 'sem saída'}`
+      } else if (declarado > entradas.length) {
+        // O DSH mudou o formato do aviso: melhor reprovar alto do que aprovar sem prova.
+        relatorio.boota = false
+        relatorio.erro ??= `o DSH avisou ${declarado} entrada(s) não ativada(s) e só consegui nomear ${entradas.length} — formato do aviso mudou`
+      } else {
+        relatorio.boota = entradas.length === 0
+        if (!relatorio.boota) relatorio.erro ??= `${entradas.length} entrada(s) não ativaram`
+      }
+    } finally {
+      perfil.dispose()
+    }
+  } catch (err) {
+    const detalhe = primeiraLinha(err?.message ?? err)
+    // Distingue "a spec não instala" de uma falha do próprio harness.
+    relatorio.erro = relatorio.instala ? detalhe : `não consegui instalar/verificar "${spec}": ${detalhe}`
+  }
+
+  relatorio.duracaoMs = Date.now() - t0
+  return relatorio
+}
+
+/** Agrega relatórios num "selo" consumível por pessoa, CI ou agente. */
+export function agregar(resultados) {
+  const aprovados = resultados.filter((r) => r.instala && r.boota).length
+  const reprovados = resultados.length - aprovados
+  const ok = resultados.length > 0 && reprovados === 0
+  return {
+    selo: ok ? 'aprovado' : 'reprovado',
+    ok,
+    total: resultados.length,
+    aprovados,
+    reprovados,
+    resultados,
+  }
+}
+
+/** Verifica N specs, em sequência (um perfil descartável por spec). */
+export async function verificar(specs, opcoes = {}) {
+  const resultados = []
+  for (const spec of specs) resultados.push(await checkSpec(spec, opcoes))
+  return agregar(resultados)
+}

package/lib/index.js

@@ -0,0 +1,60 @@
+/**
+ * Metade DSH do plugin-qa: registra a ferramenta `plugin_qa` no agente.
+ *
+ * Fina de propósito — toda a lógica vive em `core.mjs` e no CLI, para que a
+ * resposta seja a mesma quando rodada por uma pessoa, por CI ou por um agente.
+ */
+
+import path from 'node:path'
+import { execFile } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+import { defineTool } from '@deepseek-ai/dsh-tools'
+
+export const name = 'plugin-qa'
+export const inject = ['tools']
+
+const AQUI = path.dirname(fileURLToPath(import.meta.url))
+const CLI = path.join(AQUI, '..', 'bin', 'plugin-qa.mjs')
+
+/** Roda o CLI do plugin-qa e devolve a saída como texto. */
+function rodarCli(args) {
+  return new Promise((resolve) => {
+    execFile(process.execPath, [CLI, ...args], { maxBuffer: 32e6, timeout: 600_000 }, (err, stdout, stderr) => {
+      const saida = (stdout || '').trim() || (stderr || '').trim()
+      resolve(saida || `plugin-qa falhou: ${err?.message ?? 'erro desconhecido'}`)
+    })
+  })
+}
+
+export function apply(ctx) {
+  ctx.tools.register(
+    defineTool({
+      name: 'plugin_qa',
+      description:
+        'Answer "does this plugin install and boot in a clean DeepSeek Harness profile?" by actually doing it: ' +
+        'a disposable DSH_HOME, a real `dsh plugin add`, and a real boot whose activation warnings are parsed. ' +
+        'The harness isolates a broken plugin (the boot exits 0 and only warns), so "it installed" never meant ' +
+        '"it works" — this tool reports install/boot separately, names every entry that did not activate, and ' +
+        'returns a machine-readable verdict. Accepts a local directory, a .tgz tarball, or an npm name. ' +
+        'It judges installability and activation only, not code quality or security.',
+      parameters: {
+        spec: {
+          type: 'string',
+          required: true,
+          description: 'Pacote a verificar: diretório local (ex.: packages/meu-plugin), tarball .tgz ou nome no registry',
+        },
+        strict: {
+          type: 'boolean',
+          description: 'Quando true, falha também em código de saída se a spec não instalar ou não bootar (útil em CI)',
+        },
+      },
+      output: {
+        schema: { type: 'string' },
+        render: (_args, value) => [{ type: 'text', text: value }],
+      },
+      async execute(args) {
+        return rodarCli(['check', args.spec, ...(args.strict ? ['--strict'] : [])])
+      },
+    }),
+  )
+}

package/package.json

@@ -1,6 +1,65 @@
 {
   "name": "@rclr-labs/dsh-plugin-qa",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "type": "module",
+  "description": "QA de plugins do DeepSeek Harness: verifica, num perfil limpo e descartável, se um pacote instala e boota de verdade — e devolve um selo consumível por CI",
+  "license": "MIT",
+  "author": "Rafael Nunes",
+  "homepage": "https://github.com/rclr-labs/dsh-plugins/tree/main/packages/plugin-qa",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rclr-labs/dsh-plugins.git",
+    "directory": "packages/plugin-qa"
+  },
+  "bugs": {
+    "url": "https://github.com/rclr-labs/dsh-plugins/issues"
+  },
+  "keywords": [
+    "dsh-plugin",
+    "deepseek-harness",
+    "dsh",
+    "qa",
+    "verification",
+    "install-check",
+    "cordis-plugin"
+  ],
+  "engines": {
+    "node": ">=22.19"
+  },
+  "bin": {
+    "plugin-qa": "bin/plugin-qa.mjs"
+  },
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./core": "./lib/core.mjs",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "cordis.patch.yml",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "qa": "node bin/plugin-qa.mjs",
+    "test": "node test/plugin-qa.test.mjs",
+    "verify": "node test/plugin-qa.test.mjs"
+  },
+  "dsh": {
+    "manifestVersion": 1,
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.4",
+    "@deepseek-ai/dsh-tools": ">=0.1.5-rc.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/dsh-tools": "^0.2.0-rc.2"
+  }
+}