@seedgrid/ai-toolkit 0.0.0-stage → 0.3.1

package/dist/cli.js

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+import { realpathSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { parseArgs } from 'node:util';
+import { EXIT_ERROR } from './commands/common.js';
+import { doctorCommand } from './commands/doctor.js';
+import { initCommand } from './commands/init.js';
+import { removeCommand } from './commands/remove.js';
+import { reviewCommand } from './commands/review.js';
+import { selfInstallCommand } from './commands/selfinstall.js';
+import { statusCommand } from './commands/status.js';
+import { updateCommand } from './commands/update.js';
+import { validateCommand } from './commands/validate.js';
+import { cliVersion } from './core/env.js';
+import { TOOL_NAME } from './core/lock.js';
+import { ToolkitError } from './core/types.js';
+import { checkLatest, confirm, isInteractive, npxCommandLine, runPublishedVersion, } from './core/updates.js';
+const HELP = `seedgrid-ai — instala o SeedGrid AI Toolkit em projetos locais (Claude Code e Codex)
+
+Comandos:
+  install   Instala o comando seedgrid-ai nesta máquina (npm install -g), para usar sem npx; não altera nenhum projeto
+  init      Instala o toolkit (regras, papéis, skills, base de conhecimento) no projeto; idempotente
+  update    Leva o projeto ao conteúdo da versão do CLI em execução (use npx @seedgrid/ai-toolkit@latest para a mais nova)
+  status    Mostra versões, opções e divergências da instalação
+  doctor    Diagnostica sintaxe, consistência e limitações; --probe confirma a descoberta real no Codex
+  remove    Remove só o que o toolkit instalou e continua intacto
+  validate  Valida uma fonte de conteúdo (manifesto, papéis, skills, KB) sem tocar em projetos
+  review    Confere o código contra os padrões SeedGrid, chamando a skill seedgrid-review no Claude Code ou no Codex
+  help      Mostra esta ajuda
+
+Uso:
+  seedgrid-ai install  [--dry-run]
+  seedgrid-ai init     [--target claude|codex|both] [--mode shared|native] [--source <pasta>] [--dry-run]
+  seedgrid-ai update   [--target ...] [--mode ...] [--source <pasta>] [--dry-run]
+  seedgrid-ai status
+  seedgrid-ai doctor   [--probe]
+  seedgrid-ai remove   [--dry-run]
+  seedgrid-ai validate [--source <pasta>]
+  seedgrid-ai review   [front|back] [--tool claude|codex] [--full]
+
+Opções comuns:
+  --project <caminho>  Projeto alvo (padrão: pasta atual)
+  --json               Saída JSON para scripts
+  --dry-run            Mostra o plano sem escrever nenhum arquivo
+  --probe              (doctor) Confirma a descoberta real onde a ferramenta oferece sonda local
+                       (Codex: codex debug prompt-input; não chama o modelo, mas inicia a CLI com sua configuração)
+  --tool, --full       (review) Ferramenta que executa a revisão (padrão: Claude Code, depois Codex) e revisão do projeto inteiro
+                       (padrão: só os arquivos alterados). Chama o modelo da ferramenta com o seu login e consome tokens;
+                       roda em modo somente leitura. Código de saída 3 quando há violações.
+  --no-update-check    Não consulta o npm por versões mais novas (também: SEEDGRID_AI_NO_UPDATE_CHECK=1)
+  --version, --help
+
+Primeira vez: npx @seedgrid/ai-toolkit@latest install  (depois use seedgrid-ai init, update, ... sem npx)
+Padrões do init: --target both --mode shared (ou as opções do lock existente).
+Em terminal interativo, init/update/status perguntam se devem usar uma versão mais nova publicada no npm.
+Conflitos abortam a operação inteira (código de saída 2); nada é sobrescrito.`;
+const COMMANDS = {
+    install: { handler: selfInstallCommand, allowed: ['dry-run'] },
+    init: { handler: initCommand, allowed: ['target', 'mode', 'source', 'dry-run'] },
+    update: { handler: updateCommand, allowed: ['target', 'mode', 'source', 'dry-run'] },
+    status: { handler: statusCommand, allowed: [] },
+    doctor: { handler: doctorCommand, allowed: ['probe'] },
+    remove: { handler: removeCommand, allowed: ['dry-run'] },
+    validate: { handler: validateCommand, allowed: ['source'] },
+    review: { handler: reviewCommand, allowed: ['tool', 'full'] },
+};
+export async function main(argv) {
+    let parsed;
+    try {
+        parsed = parseArgs({
+            args: argv,
+            allowPositionals: true,
+            strict: true,
+            options: {
+                target: { type: 'string' },
+                mode: { type: 'string' },
+                source: { type: 'string' },
+                project: { type: 'string' },
+                'dry-run': { type: 'boolean' },
+                json: { type: 'boolean' },
+                probe: { type: 'boolean' },
+                tool: { type: 'string' },
+                full: { type: 'boolean' },
+                'no-update-check': { type: 'boolean' },
+                help: { type: 'boolean', short: 'h' },
+                version: { type: 'boolean', short: 'v' },
+            },
+        });
+    }
+    catch (err) {
+        console.error(`${err.message}\n\n${HELP}`);
+        return EXIT_ERROR;
+    }
+    const { values, positionals } = parsed;
+    if (values.version) {
+        console.log(cliVersion());
+        return 0;
+    }
+    const name = positionals[0];
+    if (values.help || !name || name === 'help') {
+        console.log(HELP);
+        return 0;
+    }
+    const command = COMMANDS[name];
+    const maxPositionals = name === 'review' ? 2 : 1;
+    if (!command || positionals.length > maxPositionals) {
+        console.error(`Comando desconhecido: ${positionals.join(' ')}\n\n${HELP}`);
+        return EXIT_ERROR;
+    }
+    for (const opt of ['target', 'mode', 'source', 'dry-run', 'probe', 'tool', 'full']) {
+        if (values[opt] !== undefined && !command.allowed.includes(opt)) {
+            console.error(`A opção --${opt} não se aplica ao comando ${name}.`);
+            return EXIT_ERROR;
+        }
+    }
+    const opts = {
+        project: values.project,
+        source: values.source,
+        target: values.target,
+        mode: values.mode,
+        dryRun: values['dry-run'] ?? false,
+        json: values.json ?? false,
+        probe: values.probe ?? false,
+        scope: name === 'review' ? positionals[1] : undefined,
+        tool: values.tool,
+        full: values.full ?? false,
+    };
+    // Consulta somente leitura ao npm; nunca com --source (conteúdo local em teste).
+    const checkUpdates = ['init', 'update', 'status', 'doctor'].includes(name) && !values['no-update-check'] && !opts.source;
+    const update = checkUpdates ? await checkLatest(cliVersion()) : null;
+    const newer = update?.newer ? update : null;
+    const canAsk = newer !== null && isInteractive() && !opts.json;
+    try {
+        if (newer && (name === 'init' || name === 'update')) {
+            if (canAsk) {
+                console.log(`Versão ${newer.latest} do SeedGrid AI Toolkit disponível (este CLI: ${newer.current}).`);
+                if (await confirm(`Usar a ${newer.latest} neste ${name}?`))
+                    return delegate(newer, argv);
+            }
+            else if (!opts.json) {
+                console.error(updateNotice(newer, argv));
+            }
+        }
+        const result = await command.handler(opts);
+        if (newer)
+            result.report.npm = { latest: newer.latest, newer: true };
+        if (opts.json)
+            console.log(JSON.stringify(result.report, null, 2));
+        else
+            console.log(result.lines.join('\n'));
+        if (newer && (name === 'status' || name === 'doctor') && !opts.json) {
+            const installed = result.report.installed === true;
+            const followUp = [installed ? 'update' : 'init', '--project', String(result.report.project)];
+            console.log('');
+            if (canAsk && name === 'status' && installed) {
+                console.log(`Versão ${newer.latest} do SeedGrid AI Toolkit disponível (este CLI: ${newer.current}).`);
+                if (await confirm('Atualizar este projeto agora?'))
+                    return delegate(newer, followUp);
+            }
+            else {
+                console.log(updateNotice(newer, followUp));
+            }
+        }
+        return result.exitCode;
+    }
+    catch (err) {
+        const isKnown = err instanceof ToolkitError;
+        const details = isKnown ? err.details : [];
+        if (opts.json) {
+            console.log(JSON.stringify({ command: name, error: err.message, details }, null, 2));
+        }
+        else {
+            console.error(`ERRO: ${err.message}`);
+            for (const d of details)
+                console.error(`  - ${d}`);
+            if (!isKnown)
+                console.error(err.stack);
+        }
+        return EXIT_ERROR;
+    }
+}
+function updateNotice(info, args) {
+    return `Aviso: versão ${info.latest} disponível no npm (este CLI: ${info.current}). Para usá-la: ${npxCommandLine(info.latest, args)}. Para atualizar o comando seedgrid-ai instalado na máquina: npx ${TOOL_NAME}@latest install`;
+}
+/** Repassa o comando para a versão publicada mais nova. */
+async function delegate(info, args) {
+    console.log(`> ${npxCommandLine(info.latest, args)}`);
+    const code = await runPublishedVersion(info.latest, args);
+    if (code === null) {
+        console.error('Os argumentos contêm caracteres que não podem ser repassados com segurança. Rode o comando acima manualmente.');
+        return EXIT_ERROR;
+    }
+    return code;
+}
+function invokedDirectly() {
+    if (!process.argv[1])
+        return false;
+    try {
+        return realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
+    }
+    catch {
+        return false;
+    }
+}
+if (invokedDirectly()) {
+    main(process.argv.slice(2)).then((code) => {
+        process.exitCode = code;
+    });
+}

package/dist/commands/common.js

@@ -0,0 +1,98 @@
+import path from 'node:path';
+import { isInside, toPosix } from '../core/paths.js';
+import { ALL_MODES, ToolkitError } from '../core/types.js';
+export const EXIT_OK = 0;
+export const EXIT_ERROR = 1;
+export const EXIT_CONFLICT = 2;
+/** review: a revisão terminou e encontrou violações. */
+export const EXIT_VIOLATIONS = 3;
+export function parseTargets(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === 'both')
+        return ['claude', 'codex'];
+    if (value === 'claude' || value === 'codex')
+        return [value];
+    throw new ToolkitError(`--target inválido: ${value} (use claude, codex ou both)`);
+}
+export function parseMode(value) {
+    if (value === undefined)
+        return undefined;
+    if (ALL_MODES.includes(value))
+        return value;
+    throw new ToolkitError(`--mode inválido: ${value} (use shared ou native)`);
+}
+/** Caminho relativo portável da fonte local, apenas se estiver dentro do projeto. */
+export function sourceRelPath(projectRoot, sourceDir) {
+    if (!isInside(projectRoot, sourceDir) || sourceDir === projectRoot)
+        return undefined;
+    return toPosix(path.relative(projectRoot, sourceDir));
+}
+const FILE_LABELS = {
+    create: 'criar',
+    update: 'atualizar',
+    unchanged: 'sem mudança',
+    adopt: 'adotar',
+    delete: 'remover',
+    forget: 'esquecer',
+    'create-file': 'criar arquivo',
+    insert: 'inserir bloco',
+    remove: 'remover bloco',
+    'delete-file': 'remover arquivo',
+};
+export function planOperations(plan) {
+    return [
+        ...plan.fileOps.map((o) => ({ path: o.path, type: 'file', action: o.action, reason: o.reason })),
+        ...plan.blockOps.map((o) => ({ path: o.file, type: 'block', action: o.action, reason: o.reason })),
+        {
+            path: '.ai/toolkit-lock.json',
+            type: 'lock',
+            action: plan.lockOp.action === 'write'
+                ? plan.lockOp.expectedHash === null
+                    ? 'create'
+                    : 'update'
+                : plan.lockOp.action === 'delete'
+                    ? 'delete'
+                    : 'unchanged',
+            reason: 'registro da instalação',
+        },
+    ];
+}
+export function planSummary(plan) {
+    const summary = {};
+    for (const op of planOperations(plan))
+        summary[op.action] = (summary[op.action] ?? 0) + 1;
+    return summary;
+}
+export function renderPlan(plan) {
+    const lines = [];
+    const ops = planOperations(plan);
+    const changing = ops.filter((o) => o.action !== 'unchanged');
+    for (const o of changing) {
+        const label = o.type === 'block' && o.action === 'update' ? 'atualizar bloco' : FILE_LABELS[o.action] ?? o.action;
+        lines.push(`  ${label.padEnd(16)} ${o.path}`);
+    }
+    const unchanged = ops.length - changing.length;
+    if (unchanged > 0)
+        lines.push(`  ${'sem mudança'.padEnd(16)} ${unchanged} item(ns)`);
+    if (plan.warnings.length > 0) {
+        lines.push('', 'Avisos:');
+        for (const w of plan.warnings)
+            lines.push(`  - ${w}`);
+    }
+    if (plan.conflicts.length > 0) {
+        lines.push('', `Conflitos (${plan.conflicts.length}):`);
+        for (const c of plan.conflicts)
+            lines.push(`  ! ${c.path}: ${c.reason}`);
+    }
+    return lines;
+}
+export function conflictHelp() {
+    return [
+        '',
+        'Operação abortada: nada foi alterado.',
+        'Para resolver: mova suas personalizações para .ai/local/, restaure o arquivo original',
+        '(o backup da última operação fica em .ai/backups/<operação>/) ou renomeie o arquivo conflitante.',
+        'O toolkit não sobrescreve customizações, nem com --yes.',
+    ];
+}

package/dist/commands/doctor.js

@@ -0,0 +1,290 @@
+import { readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { parse as parseToml } from 'smol-toml';
+import { ADAPTERS } from '../adapters/index.js';
+import { loadContent } from '../core/content.js';
+import { bundledContentDir, cliVersion, resolveProject } from '../core/env.js';
+import { parseFrontmatter } from '../core/frontmatter.js';
+import { inspectInstallation, readIfFile } from '../core/inspect.js';
+import { readLock } from '../core/lock.js';
+import { resolveInProject } from '../core/paths.js';
+import { BLOCK_BEGIN } from '../core/blocks.js';
+import { detectTool, runProbe } from '../core/tools.js';
+import { EXIT_ERROR, EXIT_OK } from './common.js';
+const HOW_TO_VERIFY = {
+    claude: {
+        instruções: 'Abra uma nova sessão (claude) na pasta do projeto e pergunte quais regras do SeedGrid AI Toolkit estão carregadas; /memory lista os arquivos de memória.',
+        skills: 'Em nova sessão, digite / e confira as skills do toolkit no menu, ou peça a lista de skills disponíveis.',
+        agentes: 'Em nova sessão, use /agents e confira os papéis do catálogo.',
+    },
+    codex: {
+        instruções: 'Rode seedgrid-ai doctor --probe, ou abra nova sessão (codex) e pergunte quais instruções de AGENTS.md foram carregadas.',
+        skills: 'Rode seedgrid-ai doctor --probe, ou em nova sessão digite $ e confira as skills do toolkit.',
+        agentes: 'Marque o projeto como confiável (trust) e, em nova sessão, peça os tipos de agente aceitos por spawn_agent; sem confiança, .codex/agents/ é ignorado.',
+    },
+};
+async function skillNamesIn(projectRoot, dir) {
+    const byName = new Map();
+    let entries;
+    try {
+        entries = await readdir(resolveInProject(projectRoot, dir), { withFileTypes: true });
+    }
+    catch {
+        return byName;
+    }
+    for (const e of entries) {
+        if (!e.isDirectory())
+            continue;
+        const text = await readIfFile(resolveInProject(projectRoot, `${dir}/${e.name}/SKILL.md`));
+        if (text === null)
+            continue;
+        const fm = parseFrontmatter(text);
+        const name = 'error' in fm || typeof fm.data.name !== 'string' ? e.name : fm.data.name;
+        byName.set(name, [...(byName.get(name) ?? []), `${dir}/${e.name}`]);
+    }
+    return byName;
+}
+async function agentNamesIn(projectRoot, adapter) {
+    const byName = new Map();
+    const dir = adapter.nativeAgentsDir;
+    let files = [];
+    try {
+        files = (await readdir(resolveInProject(projectRoot, dir), { recursive: true })).map(String);
+    }
+    catch {
+        return byName;
+    }
+    for (const f of files.filter((x) => x.endsWith(adapter.nativeAgentExtension))) {
+        const rel = `${dir}/${f.split(path.sep).join('/')}`;
+        const text = await readIfFile(resolveInProject(projectRoot, rel));
+        if (text === null)
+            continue;
+        let name;
+        if (adapter.nativeAgentExtension === '.toml') {
+            try {
+                name = parseToml(text).name;
+            }
+            catch {
+                continue;
+            }
+        }
+        else {
+            const fm = parseFrontmatter(text);
+            name = 'error' in fm ? undefined : fm.data.name;
+        }
+        if (typeof name === 'string')
+            byName.set(name, [...(byName.get(name) ?? []), rel]);
+    }
+    return byName;
+}
+function probeResult(probe, found) {
+    if (typeof probe !== 'string')
+        return 'não verificada';
+    return found ? 'confirmada' : 'não encontrada';
+}
+async function checkTarget(projectRoot, lock, adapter, checks, discovery, probe) {
+    const area = adapter.displayName;
+    const how = HOW_TO_VERIFY[adapter.target];
+    const managed = new Set(lock.files.map((f) => f.path));
+    // Instruções
+    const instrFile = adapter.target === 'claude' ? 'CLAUDE.md' : 'AGENTS.md';
+    const instrOk = lock.blocks.some((b) => b.file === instrFile);
+    discovery.push({
+        target: adapter.target,
+        kind: 'instruções',
+        location: instrFile,
+        syntax: instrOk ? 'válida' : 'inválida',
+        realDiscovery: probeResult(probe, typeof probe === 'string' && probe.includes(BLOCK_BEGIN)),
+        howToVerify: how.instruções,
+    });
+    for (const issue of await adapter.projectChecks(projectRoot, lock.mode)) {
+        checks.push({ level: issue.level, area, message: issue.message });
+    }
+    // Skills
+    const skillNames = [...new Set(lock.files.filter((f) => f.component.startsWith('skill:')).map((f) => f.component.slice(6)))];
+    const found = await skillNamesIn(projectRoot, adapter.skillsDir);
+    let skillsValid = true;
+    for (const name of skillNames) {
+        const rel = `${adapter.skillsDir}/${name}/SKILL.md`;
+        if (!managed.has(rel))
+            continue;
+        const text = await readIfFile(resolveInProject(projectRoot, rel));
+        if (text === null) {
+            checks.push({ level: 'erro', area, message: `${rel} ausente` });
+            skillsValid = false;
+            continue;
+        }
+        const fm = parseFrontmatter(text);
+        if ('error' in fm) {
+            checks.push({ level: 'erro', area, message: `${rel}: ${fm.error}` });
+            skillsValid = false;
+        }
+        else if (fm.data.name !== name || typeof fm.data.description !== 'string' || fm.data.description.trim() === '') {
+            checks.push({ level: 'erro', area, message: `${rel}: name deve ser "${name}" e description é obrigatória` });
+            skillsValid = false;
+        }
+        const dirs = found.get(name) ?? [];
+        if (dirs.length > 1) {
+            checks.push({ level: 'aviso', area, message: `skill "${name}" declarada em mais de uma pasta: ${dirs.join(', ')}` });
+        }
+    }
+    discovery.push({
+        target: adapter.target,
+        kind: 'skills',
+        location: `${adapter.skillsDir}/ (${skillNames.length})`,
+        syntax: skillsValid ? 'válida' : 'inválida',
+        realDiscovery: probeResult(probe, typeof probe === 'string' && skillNames.every((n) => probe.includes(n))),
+        howToVerify: how.skills,
+    });
+    // Agentes nativos
+    if (lock.mode === 'native') {
+        const agentFiles = lock.files.filter((f) => f.path.startsWith(`${adapter.nativeAgentsDir}/`));
+        let valid = agentFiles.length > 0;
+        for (const f of agentFiles) {
+            const text = await readIfFile(resolveInProject(projectRoot, f.path));
+            if (text === null) {
+                checks.push({ level: 'erro', area, message: `${f.path} ausente` });
+                valid = false;
+                continue;
+            }
+            const issues = adapter.checkNativeAgent(f.path, text);
+            for (const i of issues)
+                checks.push({ level: i.level, area, message: i.message });
+            if (issues.some((i) => i.level === 'erro'))
+                valid = false;
+        }
+        for (const [name, files] of await agentNamesIn(projectRoot, adapter)) {
+            if (files.length > 1)
+                checks.push({ level: 'aviso', area, message: `agente "${name}" definido mais de uma vez: ${files.join(', ')}` });
+        }
+        discovery.push({
+            target: adapter.target,
+            kind: 'agentes',
+            location: `${adapter.nativeAgentsDir}/ (${agentFiles.length})`,
+            syntax: valid ? 'válida' : 'inválida',
+            realDiscovery: 'não verificada',
+            howToVerify: how.agentes,
+        });
+    }
+}
+function toolCheck(info, mode) {
+    if (!info.installed) {
+        return {
+            level: 'aviso',
+            area: info.displayName,
+            message: `${info.displayName} não encontrado no PATH: o teste real de descoberta não foi executado.`,
+        };
+    }
+    if (info.validated) {
+        return { level: 'ok', area: info.displayName, message: `${info.displayName} ${info.version} (versão validada).` };
+    }
+    return {
+        level: mode === 'native' ? 'aviso' : 'info',
+        area: info.displayName,
+        message: `${info.displayName} ${info.version ?? '(versão desconhecida)'} não consta das versões validadas (${info.validatedVersions.join(', ')}).`,
+    };
+}
+/**
+ * Diagnóstico: valida sintaxe e consistência dos destinos de descoberta e
+ * relata o que não pode ser verificado sem abrir a ferramenta.
+ */
+export async function doctorCommand(opts) {
+    const projectRoot = resolveProject(opts.project);
+    const checks = [];
+    const discovery = [];
+    const limitations = [];
+    const tools = [];
+    try {
+        const bundle = await loadContent(bundledContentDir());
+        checks.push({ level: 'ok', area: 'conteúdo', message: `Conteúdo empacotado ${bundle.contentVersion} válido.` });
+    }
+    catch (err) {
+        checks.push({ level: 'erro', area: 'conteúdo', message: `Conteúdo empacotado inválido: ${err.message}` });
+    }
+    const lockState = await readLock(projectRoot);
+    let lock = null;
+    if (lockState.status === 'absent') {
+        checks.push({ level: 'info', area: 'instalação', message: 'Toolkit não instalado neste projeto.' });
+    }
+    else if (lockState.status === 'invalid') {
+        checks.push({ level: 'erro', area: 'instalação', message: `Lock inválido: ${lockState.errors.join('; ')}` });
+    }
+    else {
+        lock = lockState.lock;
+        checks.push({ level: 'ok', area: 'instalação', message: `Lock válido: conteúdo ${lock.contentVersion}, ${lock.targets.join('+')}, ${lock.mode}.` });
+        const insp = await inspectInstallation(projectRoot, lock);
+        for (const f of insp.files.filter((x) => x.state !== 'ok')) {
+            checks.push({ level: 'erro', area: 'arquivos', message: `${f.path}: ${f.state}${f.detail ? ` (${f.detail})` : ''}` });
+        }
+        for (const b of insp.blocks.filter((x) => x.state !== 'ok')) {
+            checks.push({ level: 'erro', area: 'blocos', message: `${b.file}: bloco ${b.state}${b.detail ? ` (${b.detail})` : ''}` });
+        }
+        if (insp.files.every((f) => f.state === 'ok') && insp.blocks.every((b) => b.state === 'ok')) {
+            checks.push({ level: 'ok', area: 'arquivos', message: `${insp.files.length} arquivos e ${insp.blocks.length} blocos conferem com os hashes do lock.` });
+        }
+        // Cópias de skills entre targets devem ser idênticas (mesma fonte).
+        const bySkillFile = new Map();
+        for (const f of lock.files.filter((x) => x.component.startsWith('skill:'))) {
+            const rel = f.path.replace(/^\.(claude|agents)\/skills\//, '');
+            if (!bySkillFile.has(rel))
+                bySkillFile.set(rel, new Set());
+            bySkillFile.get(rel).add(f.sha256);
+        }
+        for (const [rel, hashes] of bySkillFile) {
+            if (hashes.size > 1)
+                checks.push({ level: 'erro', area: 'skills', message: `cópias divergentes de ${rel} entre targets` });
+        }
+        const hasLocal = (await readdir(resolveInProject(projectRoot, '.ai/local')).catch(() => null)) !== null;
+        checks.push({
+            level: 'info',
+            area: 'personalização',
+            message: hasLocal ? '.ai/local/ presente: personalizações locais serão consideradas.' : '.ai/local/ não existe (opcional).',
+        });
+    }
+    const targets = lock?.targets ?? ['claude', 'codex'];
+    for (const t of targets) {
+        const adapter = ADAPTERS[t];
+        const info = await detectTool(adapter);
+        tools.push(info);
+        checks.push(toolCheck(info, lock?.mode ?? 'shared'));
+        let probe;
+        if (lock && opts.probe && adapter.probeCommand && info.installed) {
+            probe = await runProbe(adapter.probeCommand, projectRoot);
+            checks.push(probe === null
+                ? { level: 'aviso', area: adapter.displayName, message: `sonda falhou: ${adapter.probeCommand}` }
+                : { level: 'info', area: adapter.displayName, message: `sonda executada: ${adapter.probeCommand}` });
+        }
+        else if (lock && opts.probe && !adapter.probeCommand) {
+            checks.push({ level: 'info', area: adapter.displayName, message: 'sem sonda automática; use o smoke test manual.' });
+        }
+        if (lock) {
+            await checkTarget(projectRoot, lock, adapter, checks, discovery, probe);
+            limitations.push(...adapter.limitations(lock.mode).map((l) => `${adapter.displayName}: ${l}`));
+        }
+    }
+    limitations.push('O doctor valida sintaxe e consistência. A descoberta real só é confirmada com --probe (Codex: instruções e skills) ou abrindo uma nova sessão de cada ferramenta.', 'Seleção de papéis e delegação seguem instruções; não são garantias determinísticas do instalador.');
+    for (const d of discovery.filter((x) => x.realDiscovery === 'não encontrada')) {
+        checks.push({ level: 'erro', area: d.target, message: `${d.kind}: a sonda não encontrou o conteúdo instalado em ${d.location}` });
+    }
+    const hasError = checks.some((c) => c.level === 'erro');
+    const icon = { ok: '[ok]', info: '[i]', aviso: '[!]', erro: '[x]' };
+    const lines = [`seedgrid-ai doctor (CLI ${cliVersion()}) em ${projectRoot}`, ''];
+    for (const c of checks)
+        lines.push(`${icon[c.level].padEnd(5)}${c.area}: ${c.message}`);
+    if (discovery.length > 0) {
+        lines.push('', 'Destinos de descoberta (sintaxe x descoberta real):');
+        for (const d of discovery) {
+            lines.push(`  ${d.target.padEnd(7)} ${d.kind.padEnd(11)} ${d.location.padEnd(28)} sintaxe ${d.syntax}; descoberta real ${d.realDiscovery}`);
+            lines.push(`          como verificar: ${d.howToVerify}`);
+        }
+    }
+    lines.push('', 'Limitações:');
+    for (const l of limitations)
+        lines.push(`  - ${l}`);
+    lines.push('', 'Após instalar ou atualizar, abra uma nova sessão: não há recarga garantida em todas as ferramentas.');
+    return {
+        exitCode: hasError ? EXIT_ERROR : EXIT_OK,
+        report: { command: 'doctor', project: projectRoot, cliVersion: cliVersion(), installed: lock !== null, tools, checks, discovery, limitations },
+        lines,
+    };
+}

package/dist/commands/init.js

@@ -0,0 +1,9 @@
+import { runInstall } from './install.js';
+/**
+ * Instala o toolkit no projeto. Idempotente: repetir não altera arquivos nem
+ * duplica blocos. Sem --target/--mode, reaproveita as opções do lock existente
+ * (ou usa both/shared numa instalação nova).
+ */
+export function initCommand(opts) {
+    return runInstall('init', opts);
+}