@daniellins/power-claude 0.16.3

package/installer/uninstall.js

@@ -0,0 +1,99 @@
+'use strict';
+/**
+ * uninstall.js — remoção do POWER CLAUDE do cwd.
+ *
+ * Regras:
+ * - Remove EXATAMENTE os arquivos do manifest cujo hash continua idêntico ao
+ *   instalado.
+ * - Arquivos modificados pelo usuário (ou mesclados, origin "merged"): lista e
+ *   pergunta um a um; em --yes, preserva todos.
+ * - Remove diretórios que ficarem vazios.
+ * - NUNCA toca em arquivos fora do manifest.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { readManifest, manifestPath, MANIFEST_DIR, sha256OfFile } = require('./manifest');
+const { createPrompter, pruneEmptyDirs } = require('./util');
+
+async function uninstall({ yes = false } = {}) {
+  const destDir = process.cwd();
+  const manifest = readManifest(destDir);
+  if (!manifest) {
+    console.error('Nenhuma instalação encontrada (.power-claude/manifest.json ausente). Nada a fazer.');
+    return 1;
+  }
+
+  console.log(`POWER CLAUDE uninstall — ${destDir} (versão instalada: ${manifest.version})\n`);
+
+  const intact = [];
+  const modified = [];
+  const missing = [];
+  for (const entry of manifest.files) {
+    const p = path.join(destDir, ...entry.path.split('/'));
+    if (!fs.existsSync(p)) {
+      missing.push(entry);
+    } else if (entry.origin === 'merged' || sha256OfFile(p) !== entry.sha256) {
+      modified.push(entry);
+    } else {
+      intact.push(entry);
+    }
+  }
+
+  const toRemove = [...intact];
+  const preserved = [];
+
+  if (modified.length > 0) {
+    console.log('Arquivos modificados por você (ou mesclados com seu conteúdo) desde a instalação:');
+    for (const entry of modified) console.log(`  - ${entry.path}${entry.origin === 'merged' ? ' (merged)' : ''}`);
+    if (yes) {
+      console.log('Modo --yes: todos os modificados serão PRESERVADOS.\n');
+      preserved.push(...modified);
+    } else {
+      const prompter = createPrompter();
+      try {
+        for (const entry of modified) {
+          const remove = await prompter.confirm(`  Remover ${entry.path} mesmo modificado?`, false);
+          if (remove) toRemove.push(entry);
+          else preserved.push(entry);
+        }
+      } finally {
+        prompter.close();
+      }
+    }
+  }
+
+  let removedCount = 0;
+  for (const entry of toRemove) {
+    const p = path.join(destDir, ...entry.path.split('/'));
+    try {
+      fs.unlinkSync(p);
+      removedCount++;
+      pruneEmptyDirs(path.dirname(p), destDir);
+    } catch (error) {
+      console.error(`Erro ao remover ${entry.path}: ${error.message}`);
+    }
+  }
+
+  // Remove o manifest e o diretório .power-claude se vazio.
+  try {
+    fs.unlinkSync(manifestPath(destDir));
+    pruneEmptyDirs(path.join(destDir, MANIFEST_DIR), destDir);
+  } catch (error) {
+    console.error(`Erro ao remover manifest: ${error.message}`);
+  }
+
+  console.log('\n--- Relatório de remoção ---');
+  console.log(`Removidos: ${removedCount}`);
+  if (preserved.length > 0) {
+    console.log('Preservados (modificados por você):');
+    for (const entry of preserved) console.log(`  - ${entry.path}`);
+  }
+  if (missing.length > 0) {
+    console.log(`Já ausentes: ${missing.length}`);
+  }
+  console.log('\nPOWER CLAUDE removido.');
+  return 0;
+}
+
+module.exports = { uninstall };

package/installer/update.js

@@ -0,0 +1,376 @@
+'use strict';
+/**
+ * update.js — atualização de uma instalação existente do POWER CLAUDE.
+ *
+ * Recompara template atual vs manifest:
+ * - arquivo intacto (hash no disco == hash do manifest) → atualiza para a
+ *   versão nova do template;
+ * - modificado pelo usuário → mostra diff resumido e pergunta (--yes preserva
+ *   o do usuário);
+ * - novos arquivos do template → adiciona;
+ * - pods que o usuário optou por não instalar (nenhum rastro no manifest nem
+ *   no disco) continuam de fora;
+ * - `.claude/settings.json` → re-merge aditivo (`hooks`/`permissions` acrescentam
+ *   a entrada nova do template sem remover o que o usuário tem; nas demais
+ *   chaves, chaves novas do template entram, chaves do usuário são preservadas).
+ *
+ * `--scope motor` (SF10.20 / ADR-019 `DF-SF10.20-5`): restringe a atualização às
+ * entradas de `motor-scripts.json` (ADR-007) cujo owner está instalado, e trata
+ * divergência como DEFASAGEM (sobrescreve), não como customização do usuário. Ver
+ * `updateScopedMotor` abaixo para o porquê de a precedência ser outra nesse escopo.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { readManifest, writeManifest, sha256OfFile } = require('./manifest');
+const { walkFiles, createPrompter, ensureParentDir, diffSummary } = require('./util');
+const { podOf, SETTINGS_REL } = require('./copy');
+const { motorEntries, ownerInstalled } = require('./motor-scripts');
+
+const SCOPES = new Set(['motor']);
+
+async function update({ yes = false, scope = null } = {}) {
+  const destDir = process.cwd();
+  const pkgRoot = path.resolve(__dirname, '..');
+  const templateDir = path.join(pkgRoot, 'template');
+  const pkg = require(path.join(pkgRoot, 'package.json'));
+
+  if (scope !== null && !SCOPES.has(scope)) {
+    console.error(`Escopo desconhecido: "${scope}". Escopos válidos: ${[...SCOPES].join(', ')}.`);
+    return 2;
+  }
+
+  const manifest = readManifest(destDir);
+  if (!manifest) {
+    console.error('Nenhuma instalação encontrada. Rode "power-claude install" primeiro.');
+    return 1;
+  }
+
+  if (scope === 'motor') return updateScopedMotor({ yes, destDir, pkgRoot, pkg, manifest });
+
+  console.log(`POWER CLAUDE update — ${manifest.version} → ${pkg.version} em ${destDir}\n`);
+
+  const manifestMap = new Map(manifest.files.map((f) => [f.path, f]));
+  const installedPods = new Set(
+    manifest.files.map((f) => podOf(f.path)).filter(Boolean)
+  );
+
+  // Fontes: template/ inteiro + scripts do motor (manifest ADR-007) do pacote.
+  // Incluir nas MESMAS listas `sources` — o contrato de preservação existente é
+  // keyed por path+hash, não por viver sob template/ (nenhum caminho paralelo).
+  const sources = walkFiles(templateDir).map((rel) => ({ rel, src: path.join(templateDir, ...rel.split('/')) }));
+  for (const { path: rel } of motorEntries()) {
+    const src = path.join(pkgRoot, ...rel.split('/'));
+    if (fs.existsSync(src)) sources.push({ rel, src });
+  }
+
+  const report = { updated: [], added: [], preserved: [], unchanged: [], merged: [], skippedPods: new Set() };
+  const newEntries = [];
+  const prompter = yes ? null : createPrompter();
+
+  try {
+    for (const { rel, src } of sources) {
+      const pod = podOf(rel);
+      const destPath = path.join(destDir, ...rel.split('/'));
+      const destExists = fs.existsSync(destPath);
+      const entry = manifestMap.get(rel);
+
+      // Pod que o usuário optou por não instalar: sem rastro no manifest nem no disco.
+      if (pod && !installedPods.has(pod) && !destExists && !entry) {
+        report.skippedPods.add(pod);
+        continue;
+      }
+
+      // settings.json: re-merge aditivo (hooks/permissions; override raso nas demais chaves).
+      if (rel === SETTINGS_REL && destExists) {
+        const result = remergeSettings(src, destPath);
+        if (result.merged) {
+          newEntries.push({ path: rel, sha256: result.sha256, origin: 'merged' });
+          report.merged.push(rel);
+        } else {
+          report.preserved.push(`${rel} (JSON inválido no destino; mantido sem merge)`);
+          if (entry) newEntries.push(entry);
+        }
+        continue;
+      }
+
+      const srcHash = sha256OfFile(src);
+
+      if (!destExists) {
+        // Novo no template, ou removido do disco: (re)instala.
+        ensureParentDir(destPath);
+        fs.copyFileSync(src, destPath);
+        newEntries.push({ path: rel, sha256: srcHash });
+        (entry ? report.updated : report.added).push(rel);
+        continue;
+      }
+
+      const destHash = sha256OfFile(destPath);
+
+      if (destHash === srcHash) {
+        newEntries.push({ path: rel, sha256: srcHash });
+        report.unchanged.push(rel);
+        continue;
+      }
+
+      const userModified = !entry || destHash !== entry.sha256 || entry.origin === 'merged';
+      if (!userModified) {
+        // Intacto desde a instalação → atualiza sem perguntar.
+        fs.copyFileSync(src, destPath);
+        newEntries.push({ path: rel, sha256: srcHash });
+        report.updated.push(rel);
+        continue;
+      }
+
+      // Modificado pelo usuário: diff resumido + decisão.
+      let overwrite = false;
+      if (!yes && prompter) {
+        printDiffSummary(rel, destPath, src);
+        overwrite = await prompter.confirm(`  Substituir SEU ${rel} pela versão nova do template?`, false);
+      }
+      if (overwrite) {
+        fs.copyFileSync(src, destPath);
+        newEntries.push({ path: rel, sha256: srcHash });
+        report.updated.push(rel);
+      } else {
+        report.preserved.push(rel);
+        if (entry) newEntries.push(entry); // mantém o hash de instalação original
+      }
+    }
+  } finally {
+    if (prompter) prompter.close();
+  }
+
+  // Arquivos do manifest que saíram do template: permanecem no disco e no manifest.
+  const sourceRels = new Set(sources.map((s) => s.rel));
+  for (const entry of manifest.files) {
+    if (!sourceRels.has(entry.path)) {
+      newEntries.push(entry);
+      report.preserved.push(`${entry.path} (não faz mais parte do template; mantido)`);
+    }
+  }
+
+  writeManifest(destDir, {
+    version: pkg.version,
+    installedAt: manifest.installedAt,
+    updatedAt: new Date().toISOString(),
+    files: newEntries,
+  });
+
+  report.skippedPods = [...report.skippedPods];
+  console.log('\n--- Relatório de atualização ---');
+  console.log(`Atualizados: ${report.updated.length}`);
+  console.log(`Adicionados (novos no template): ${report.added.length}`);
+  console.log(`Sem mudança: ${report.unchanged.length}`);
+  if (report.merged.length > 0) console.log(`Mesclados: ${report.merged.join(', ')}`);
+  if (report.preserved.length > 0) {
+    console.log('Preservados (seus, não sobrescritos):');
+    for (const f of report.preserved) console.log(`  - ${f}`);
+  }
+  if (report.skippedPods.length > 0) {
+    console.log(`Pods não instalados (mantidos de fora): ${report.skippedPods.join(', ')}`);
+  }
+  console.log('\nAtualização concluída.');
+  return 0;
+}
+
+/**
+ * SF10.20 / ADR-019 `DF-SF10.20-5` — plano do sync escopado ao motor. PURO (só lê
+ * disco, nada escreve) para que a tabela de auditoria e o teste vejam exatamente o
+ * mesmo cálculo que a escrita usa.
+ *
+ * Estados: `same` (byte-idêntico), `stale` (diverge → será sobrescrito), `missing`
+ * (ausente → será instalado), `skipped-owner` (owner do script não instalado neste
+ * projeto — ADR-007 Decisão 3; fora do escopo, não é dívida).
+ */
+function planMotorSync({ pkgRoot, destDir }) {
+  const rows = [];
+  for (const { path: rel, owner } of motorEntries()) {
+    const src = path.join(pkgRoot, ...rel.split('/'));
+    if (!fs.existsSync(src)) continue; // entrada do manifesto sem fonte no pacote
+    if (!ownerInstalled(destDir, owner)) {
+      rows.push({ rel, owner, state: 'skipped-owner', srcHash: null, destHash: null });
+      continue;
+    }
+    const destPath = path.join(destDir, ...rel.split('/'));
+    const srcHash = sha256OfFile(src);
+    if (!fs.existsSync(destPath)) {
+      rows.push({ rel, owner, state: 'missing', srcHash, destHash: null });
+      continue;
+    }
+    const destHash = sha256OfFile(destPath);
+    rows.push({ rel, owner, state: destHash === srcHash ? 'same' : 'stale', srcHash, destHash });
+  }
+  return rows;
+}
+
+/**
+ * `power-claude update --scope motor`.
+ *
+ * Duas diferenças deliberadas em relação ao update completo, ambas de ADR-019:
+ *
+ * 1. ESCOPO — só as entradas de `motor-scripts.json` com owner instalado. O update
+ *    sem escopo avalia o `template/` inteiro (centenas de arquivos: settings, hooks,
+ *    skills, agentes), superfície sem relação causal com um motor defasado (ADR-004).
+ *
+ * 2. PRECEDÊNCIA — divergência é DEFASAGEM, não customização. No update completo,
+ *    `destHash !== entry.sha256` significa "o usuário mexeu, preserve"; aplicada a
+ *    scripts de motor, essa regra faz o sync reportar SUCESSO preservando justamente
+ *    o binário velho que causou o defeito (é o achado que derrubou a presunção
+ *    `adopt && update` da SF10.20). Aqui vale a semântica que o `install` sempre teve
+ *    (`motor-scripts.js`: a cópia do motor é incondicional): script de motor não tem
+ *    semântica de fork do usuário.
+ *
+ * Guarda-corpo da precedência: a tabela `sha256 antes → depois` é impressa ANTES de
+ * qualquer escrita, e a confirmação é ÚNICA para o conjunto (nunca 15 prompts, que é
+ * como se erra o clique no arquivo que importa). Reversível por git.
+ */
+async function updateScopedMotor({ yes, destDir, pkgRoot, pkg, manifest }) {
+  console.log(`POWER CLAUDE update --scope motor — framework ${pkg.version} em ${destDir}`);
+  console.log('Escopo: scripts do motor (installer/motor-scripts.json, ADR-007) com owner instalado.\n');
+
+  const rows = planMotorSync({ pkgRoot, destDir });
+  const toWrite = rows.filter((r) => r.state === 'stale' || r.state === 'missing');
+  const same = rows.filter((r) => r.state === 'same');
+  const skipped = rows.filter((r) => r.state === 'skipped-owner');
+
+  printMotorTable(rows);
+  console.log(
+    `\nsame ${same.length} · defasados ${rows.filter((r) => r.state === 'stale').length} · ` +
+    `ausentes ${rows.filter((r) => r.state === 'missing').length} · owner-ausente(pulado) ${skipped.length}`
+  );
+
+  if (toWrite.length === 0) {
+    console.log('\nMotor já sincronizado — nada a escrever.');
+    // SF11.1 — o REGISTRO é recarimbado mesmo quando nenhum ARQUIVO muda.
+    //
+    // `frameworkRoot` (manifest.js) responde "de onde este comando rodou", e só é
+    // gravado por `writeManifest`. Enquanto esta função retornava aqui, uma instalação
+    // JÁ SINCRONIZADA não tinha nenhum comando suportado capaz de reancorar o campo
+    // (`adopt` recusa com manifest presente) — e o valor envelhecido só se manifesta
+    // muito depois, degradando para placeholder o comando de correção que a SF10.20
+    // criou, exatamente quando o dono está com uma rodada quebrada e mais precisa dele.
+    //
+    // O que é recarimbado: `frameworkRoot` e `updatedAt`. O que NÃO muda: `version`
+    // (mesma regra das linhas abaixo), as entradas de `files` (repassadas verbatim —
+    // nada é reclassificado, adicionado nem removido) e o relatório de console, que
+    // continua dizendo que nenhum arquivo foi escrito, porque nenhum foi.
+    writeManifest(destDir, {
+      version: manifest.version,
+      installedAt: manifest.installedAt,
+      updatedAt: new Date().toISOString(),
+      files: manifest.files,
+    });
+    console.log(
+      `Manifest: proveniência recarimbada (frameworkRoot=${pkgRoot}, updatedAt) — ` +
+      `0 arquivos escritos, ${manifest.files.length} entradas inalteradas, version mantida em ${manifest.version}.`
+    );
+    return 0;
+  }
+
+  if (!yes) {
+    const prompter = createPrompter();
+    let go = false;
+    try {
+      console.log(
+        '\nOs arquivos marcados DEFASADO serão SOBRESCRITOS (script de motor não tem\n' +
+        'semântica de fork do usuário — divergência aqui é defasagem). Reversível por git.'
+      );
+      go = await prompter.confirm(`Aplicar as ${toWrite.length} escritas acima?`, false);
+    } finally {
+      prompter.close();
+    }
+    if (!go) {
+      console.log('\nCancelado — nenhum arquivo escrito.');
+      return 0;
+    }
+  }
+
+  for (const row of toWrite) {
+    const src = path.join(pkgRoot, ...row.rel.split('/'));
+    const destPath = path.join(destDir, ...row.rel.split('/'));
+    ensureParentDir(destPath);
+    fs.copyFileSync(src, destPath);
+  }
+
+  // Manifest: só as entradas DENTRO do escopo são reescritas; todo o resto do
+  // manifest fica intacto (um update escopado não pode alegar nada sobre o template).
+  const inScope = new Set(rows.filter((r) => r.state !== 'skipped-owner').map((r) => r.rel));
+  const entries = manifest.files.filter((f) => !inScope.has(f.path));
+  for (const row of rows) {
+    if (row.state === 'skipped-owner') continue;
+    entries.push({ path: row.rel, sha256: row.srcHash });
+  }
+
+  // `version` NÃO é bumpada: o template não foi atualizado, e um número que alegasse
+  // o contrário seria a mesma mentira que ADR-019 rejeitou nos oráculos de versão.
+  writeManifest(destDir, {
+    version: manifest.version,
+    installedAt: manifest.installedAt,
+    updatedAt: new Date().toISOString(),
+    files: entries,
+  });
+
+  console.log(`\n--- Relatório (escopo motor) ---`);
+  console.log(`Sobrescritos (defasados): ${rows.filter((r) => r.state === 'stale').length}`);
+  console.log(`Instalados (ausentes):    ${rows.filter((r) => r.state === 'missing').length}`);
+  console.log(`Já idênticos:             ${same.length}`);
+  console.log(`Manifest: ${inScope.size} entradas de motor regravadas; version mantida em ${manifest.version} (escopo não cobre o template).`);
+  const cliPath = path.join(pkgRoot, 'bin', 'cli.js');
+  console.log(
+    '\nAVISO — escopo é sticky por decisão sua, não pelo manifest: rodar\n' +
+    `  node ${cliPath} update\n` +
+    'SEM --scope motor neste projeto volta a avaliar o template inteiro, instalando os\n' +
+    'arquivos de template ausentes. Ver docs/mecanismos/update-scope-motor.md.'
+  );
+  console.log('\nAtualização (escopo motor) concluída.');
+  return 0;
+}
+
+function printMotorTable(rows) {
+  const width = Math.max(...rows.map((r) => r.rel.length), 4);
+  const label = { same: 'IGUAL   ', stale: 'DEFASADO', missing: 'AUSENTE ', 'skipped-owner': 'PULADO  ' };
+  console.log(`estado   ${'path'.padEnd(width)}  sha256 instalado → sha256 framework`);
+  for (const r of rows) {
+    const before = r.destHash ? r.destHash.slice(0, 12) : (r.state === 'missing' ? '(ausente)   ' : '(n/a)       ');
+    const after = r.srcHash ? r.srcHash.slice(0, 12) : '(n/a)';
+    const suffix = r.state === 'skipped-owner' ? `owner ${r.owner} não instalado` : `${before} → ${after}`;
+    console.log(`${label[r.state]} ${r.rel.padEnd(width)}  ${suffix}`);
+  }
+}
+
+function remergeSettings(srcPath, destPath) {
+  const { shallowMergeSettings } = require('./copy');
+  const { sha256OfBuffer } = require('./manifest');
+  const templateObj = JSON.parse(fs.readFileSync(srcPath, 'utf8'));
+  let userObj;
+  try {
+    userObj = JSON.parse(fs.readFileSync(destPath, 'utf8'));
+  } catch {
+    return { merged: false };
+  }
+  const mergedObj = shallowMergeSettings(templateObj, userObj);
+  const content = JSON.stringify(mergedObj, null, 2) + '\n';
+  fs.writeFileSync(destPath, content, 'utf8');
+  return { merged: true, sha256: sha256OfBuffer(Buffer.from(content, 'utf8')) };
+}
+
+function printDiffSummary(rel, userPath, templatePath) {
+  try {
+    const userText = fs.readFileSync(userPath, 'utf8');
+    const templateText = fs.readFileSync(templatePath, 'utf8');
+    const diff = diffSummary(userText, templateText);
+    console.log(`\n  ${rel} — diff resumido (seu arquivo → template novo):`);
+    console.log(`    +${diff.added} linha(s) novas, -${diff.removed} linha(s) suas sairiam`);
+    for (const line of diff.sampleAdded) console.log(`    + ${truncate(line)}`);
+    for (const line of diff.sampleRemoved) console.log(`    - ${truncate(line)}`);
+  } catch {
+    console.log(`\n  ${rel} — conteúdo binário ou ilegível; diff indisponível.`);
+  }
+}
+
+function truncate(line, max = 80) {
+  return line.length > max ? line.slice(0, max - 1) + '…' : line;
+}
+
+module.exports = { update, planMotorSync, remergeSettings };

package/installer/util.js

@@ -0,0 +1,113 @@
+'use strict';
+/**
+ * util.js — helpers compartilhados do instalador POWER CLAUDE.
+ * Node >= 18, sem dependências externas.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const readline = require('node:readline');
+
+/** Converte um path relativo para separadores POSIX (formato canônico do manifest). */
+function toPosix(relPath) {
+  return relPath.split(path.sep).join('/');
+}
+
+/**
+ * Percorre um diretório recursivamente e retorna os paths relativos (POSIX)
+ * de todos os arquivos, ordenados.
+ */
+function walkFiles(rootDir) {
+  const out = [];
+  if (!fs.existsSync(rootDir)) return out;
+  const stack = [rootDir];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(full);
+      } else if (entry.isFile()) {
+        out.push(toPosix(path.relative(rootDir, full)));
+      }
+    }
+  }
+  return out.sort();
+}
+
+/** Cria um prompter interativo (readline). Feche com .close() ao terminar. */
+function createPrompter() {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return {
+    ask(question) {
+      return new Promise((resolve) => rl.question(question, (answer) => resolve(answer.trim())));
+    },
+    async confirm(question, defaultYes = true) {
+      const suffix = defaultYes ? ' [S/n] ' : ' [s/N] ';
+      const answer = (await this.ask(question + suffix)).toLowerCase();
+      if (answer === '') return defaultYes;
+      return answer === 's' || answer === 'sim' || answer === 'y' || answer === 'yes';
+    },
+    close() {
+      rl.close();
+    },
+  };
+}
+
+/** Garante que o diretório pai de filePath existe. */
+function ensureParentDir(filePath) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+
+/**
+ * Remove diretórios vazios subindo a partir de startDir até (exclusive) stopDir.
+ */
+function pruneEmptyDirs(startDir, stopDir) {
+  let dir = startDir;
+  const stop = path.resolve(stopDir);
+  while (path.resolve(dir) !== stop && path.resolve(dir).startsWith(stop)) {
+    try {
+      const entries = fs.readdirSync(dir);
+      if (entries.length > 0) break;
+      fs.rmdirSync(dir);
+    } catch {
+      break;
+    }
+    dir = path.dirname(dir);
+  }
+}
+
+/**
+ * Resumo de diff entre dois textos (sem LCS — contagem por multiconjunto de linhas).
+ * Retorna { added, removed, sampleAdded, sampleRemoved }.
+ */
+function diffSummary(oldText, newText, sampleSize = 5) {
+  const count = (lines) => {
+    const map = new Map();
+    for (const l of lines) map.set(l, (map.get(l) || 0) + 1);
+    return map;
+  };
+  const oldLines = oldText.split(/\r?\n/);
+  const newLines = newText.split(/\r?\n/);
+  const oldCount = count(oldLines);
+  const newCount = count(newLines);
+
+  const removed = [];
+  for (const [line, n] of oldCount) {
+    const extra = n - (newCount.get(line) || 0);
+    for (let i = 0; i < extra; i++) removed.push(line);
+  }
+  const added = [];
+  for (const [line, n] of newCount) {
+    const extra = n - (oldCount.get(line) || 0);
+    for (let i = 0; i < extra; i++) added.push(line);
+  }
+  return {
+    added: added.length,
+    removed: removed.length,
+    sampleAdded: added.slice(0, sampleSize),
+    sampleRemoved: removed.slice(0, sampleSize),
+  };
+}
+
+module.exports = { toPosix, walkFiles, createPrompter, ensureParentDir, pruneEmptyDirs, diffSummary };

package/installer/wizard.js

@@ -0,0 +1,64 @@
+'use strict';
+/**
+ * wizard.js — perguntas de instalação do POWER CLAUDE.
+ *
+ * 3 perguntas:
+ *   1. Instalar todos os pods? [S/n] — se n, lista para escolher.
+ *   2. Inicializar git com commit inicial? [S/n] — pulada se já houver .git.
+ *   3. Informativo: .env.example para preencher depois.
+ *
+ * Modo --yes assume os padrões: todos os pods, git sim.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+/**
+ * @param {object} opts
+ * @param {boolean} opts.yes
+ * @param {string[]} opts.pods       nomes dos pods disponíveis
+ * @param {string} opts.destDir      projeto destino
+ * @param {object|null} opts.prompter
+ * @returns {Promise<{selectedPods: string[], initGit: boolean}>}
+ */
+async function runWizard({ yes, pods, destDir, prompter }) {
+  const hasGit = fs.existsSync(path.join(destDir, '.git'));
+
+  if (yes || !prompter) {
+    return { selectedPods: [...pods], initGit: !hasGit };
+  }
+
+  // Pergunta 1 — pods
+  let selectedPods = [...pods];
+  const allPods = await prompter.confirm(`Instalar todos os ${pods.length} pods?`, true);
+  if (!allPods) {
+    console.log('\nPods disponíveis:');
+    pods.forEach((name, i) => console.log(`  ${i + 1}. ${name}`));
+    const answer = await prompter.ask('Quais instalar? (números separados por vírgula, vazio = todos) ');
+    const indexes = answer
+      .split(',')
+      .map((s) => Number.parseInt(s.trim(), 10))
+      .filter((n) => Number.isInteger(n) && n >= 1 && n <= pods.length);
+    if (indexes.length > 0) {
+      selectedPods = [...new Set(indexes)].sort((a, b) => a - b).map((n) => pods[n - 1]);
+    }
+  }
+
+  // Pergunta 2 — git
+  let initGit = false;
+  if (hasGit) {
+    console.log('\nRepositório git já existe — etapa de git init pulada.');
+  } else {
+    initGit = await prompter.confirm('Inicializar git com commit inicial?', true);
+  }
+
+  // Pergunta 3 — informativo
+  console.log(
+    '\nDica: se o template incluir um .env.example, copie-o para .env e preencha' +
+      ' suas variáveis depois da instalação. O .env nunca deve ser commitado.'
+  );
+
+  return { selectedPods, initGit };
+}
+
+module.exports = { runWizard };

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@daniellins/power-claude",
+  "version": "0.16.3",
+  "description": "Lean, budget-gated agent framework for Claude Code — pods by job-to-be-done",
+  "author": "Daniel Lins",
+  "license": "MIT",
+  "bin": {
+    "power-claude": "bin/cli.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin",
+    "installer",
+    "template",
+    "scripts"
+  ],
+  "scripts": {
+    "test": "node scripts/validate-install.js && node scripts/validate-adopt.js && node scripts/validate-update-scope-motor.js && node scripts/__tests__/validate-pod-workflow.test.cjs && node scripts/__tests__/pc-run-pod.test.cjs && node scripts/__tests__/pc-run-pod-counter.test.cjs && node scripts/pc-run-pod-countgte.test.cjs && node scripts/forge.test.cjs && node scripts/forge-assess-tier.test.cjs && node scripts/forge-additive.test.cjs && node scripts/forge-canonical.test.cjs && node scripts/migration-manifest.test.cjs && node scripts/migration-manifest-sf3.2.test.cjs && node scripts/migration-manifest-sf3.3.test.cjs && node scripts/migration-manifest-sf5.5.test.cjs && node scripts/validate-no-clone.test.cjs && node scripts/migrate-squad-orchestration.test.cjs && node scripts/pod-memory.test.cjs && node scripts/pod-memory-budget.test.cjs && node scripts/pod-memory-note.test.cjs && node scripts/forge-harden-learning.test.cjs && node scripts/harden-knowledge.test.cjs && node scripts/consolidate-knowledge-runner.test.cjs && node scripts/smoke-pod-workflow.cjs scripts/__fixtures__/smoke-canary/workflows/wf-canary.yaml && node scripts/smoke-sweep.test.cjs && node scripts/smoke-isolation.test.cjs && node scripts/harness-g5-lite.test.cjs && node scripts/__tests__/motor-scripts.test.cjs && node scripts/validate-fidelity-output.test.cjs && node scripts/validate-source-audit.test.cjs && node scripts/arena.test.cjs && node scripts/veto-checks.test.cjs && node scripts/phash-gate.test.cjs && node scripts/render-png.test.cjs && node scripts/hn-carousel-contrato-entrada.test.cjs && node scripts/anti-path.test.cjs && node scripts/brief-leitura-obrigatoria.test.cjs && node scripts/pc-run-pipeline.test.cjs && node scripts/pod-export-compile.test.cjs && node scripts/pod-export-executor.test.cjs && node scripts/pod-export-postprocess.test.cjs && node scripts/pod-export-release.test.cjs && node scripts/pod-export-service.test.cjs && node scripts/pod-export-ui.test.cjs && node scripts/pod-export-hardening.test.cjs && node scripts/pod-export-queue-race.test.cjs && node scripts/npm-scope-invocation.test.cjs && node scripts/default-funcional.test.cjs && node scripts/owner-layer.test.cjs && node scripts/__tests__/enforce-cycle-authority.test.cjs && node scripts/__tests__/enforce-git-push-authority.test.cjs && node scripts/__tests__/validate-story-acs.test.cjs && node scripts/__tests__/enforce-ready-oracles.test.cjs && node scripts/__tests__/derive-ready-transitions.test.cjs && node installer/__tests__/doctor-ready-oracles.test.cjs && node installer/__tests__/merge-settings.test.cjs",
+    "validate": "node scripts/validate-budgets.js template/pods template/.claude/agents && node scripts/validate-branding.js && node scripts/validate-no-clone.cjs template"
+  }
+}