@pathbit/agentdevkit 0.0.13 → 0.0.15

package/.pbai4devs/scripts/lib/gitignore.mjs

@@ -1,5 +1,5 @@
 import { createHash, randomUUID } from 'node:crypto';
-import { chmodSync, closeSync, lstatSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { chmodSync, closeSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { basename, dirname, isAbsolute, join, posix, relative, resolve, sep } from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
@@ -112,7 +112,7 @@ function checkedOutput(path) {
 function escapePattern(path) { return path.replace(/[\\!#*?\[\] ]/g, '\\$&'); }
 
 function rootProbes(root, roots) {
-  return roots.filter(path => { const item = localStat(join(root, path)); return !item || item.isDirectory(); }).map(path => `${path}/.agentdevkit-ignore-probe`);
+  return roots.filter(path => { const item = localStat(join(root, path)); return !item || item.isDirectory() && !item.isSymbolicLink(); }).map(path => `${path}/.agentdevkit-ignore-probe`);
 }
 
 function artifactPolicy(templateFile) {
@@ -150,7 +150,7 @@ function safeIgnoreProbe(root, path) {
   for (const part of path.split('/').slice(0, -1)) {
     parent = join(parent, part);
     const item = localStat(parent);
-    if (item && !item.isDirectory()) return false;
+    if (item && (!item.isDirectory() || item.isSymbolicLink())) return false;
   }
   return true;
 }
@@ -166,7 +166,7 @@ function artifactProbes(root, patterns) {
         let parent = root, safe = true;
         for (const part of path.split('/').slice(0, -1)) {
           parent = join(parent, part); const item = localStat(parent);
-          if (item && !item.isDirectory()) { safe = false; break; }
+          if (item && (!item.isDirectory() || item.isSymbolicLink())) { safe = false; break; }
         }
         if (safe) probes.add(path);
       }
@@ -204,8 +204,8 @@ function visibleArtifactProbes(root, location, patterns) {
   const listed = gitCommand(location.top, ['--literal-pathspecs', '-c', 'core.excludesFile=', 'ls-files', '--cached', '--others', '--exclude-standard', '-z', '--', location.prefix ? `${location.prefix}/` : '.']);
   if (listed.error || listed.status !== 0) throw new Error(listed.error?.message || listed.stderr || 'Falha ao conferir artefatos existentes.');
   const paths = listed.stdout.split('\0').filter(Boolean), prefix = location.prefix ? `${location.prefix}/` : '';
-  const probes = new Set(paths.filter(path => path.startsWith(prefix)).map(path => path.slice(prefix.length)).filter(path => artifactPath(path, patterns)));
-  const ignores = new Set(paths.filter(path => path.startsWith(prefix) && (path === '.gitignore' || path.endsWith('/.gitignore'))));
+  const probes = new Set(paths.filter(path => path.startsWith(prefix)).map(path => path.slice(prefix.length)).filter(path => artifactPath(path, patterns) && safeIgnoreProbe(root, path)));
+  const ignores = new Set(paths.filter(path => path.startsWith(prefix) && (path === '.gitignore' || path.endsWith('/.gitignore')) && safeIgnoreProbe(root, path.slice(prefix.length))));
   let ancestor = root;
   while (true) {
     ignores.add(portable(relative(location.top, join(ancestor, '.gitignore'))));
@@ -224,12 +224,111 @@ function visibleArtifactProbes(root, location, patterns) {
       const ruleBase = !rule.startsWith('/') && !literal.includes('/') && relative(dirname(file), root).split(sep)[0] !== '..' ? root : dirname(file);
       const candidate = portable(relative(root, resolve(ruleBase, literal.replace(/\\(.)/g, '$1'))));
       if (!candidate || candidate === '..' || candidate.startsWith('../') || !artifactPath(candidate, patterns, directory)) continue;
-      probes.add(checkedOutput(directory ? `${candidate}/.agentdevkit-artifact-probe` : candidate));
+      const probe = checkedOutput(directory ? `${candidate}/.agentdevkit-artifact-probe` : candidate);
+      if (safeIgnoreProbe(root, probe)) probes.add(probe);
     }
   }
   return [...probes];
 }
 
+// Existing unignored private files and literal/mixed-case root exceptions must
+// not slip through merely because a synthetic wildcard used another spelling.
+function visiblePrivateProbes(root, location, clientRoots) {
+  const listed = gitCommand(location.top, ['--literal-pathspecs', '-c', 'core.excludesFile=', 'ls-files', '--others', '--exclude-standard', '-z', '--', location.prefix ? `${location.prefix}/` : '.']);
+  if (listed.error || listed.status !== 0) throw new Error(listed.error?.message || listed.stderr || 'Falha ao conferir arquivos privados.');
+  const prefix = location.prefix ? `${location.prefix}/` : '', roots = new Set(clientRoots);
+  const probes = new Set(listed.stdout.split('\0').filter(path => path.startsWith(prefix)).map(path => path.slice(prefix.length))
+    .filter(path => roots.has(path.split('/')[0]) && isGeneratedOutput(path) && safeIgnoreProbe(root, path)));
+  const ignore = join(root, '.gitignore'), item = localStat(ignore);
+  if (item?.isFile() && !item.isSymbolicLink()) for (const line of readFileSync(ignore, 'utf8').replace(/^\uFEFF/, '').split(/\r?\n/)) {
+    if (!line.startsWith('!') || line.length === 1) continue;
+    const rule = line.slice(1), directory = rule.endsWith('/');
+    const witness = rule.replace(/^\//, '').replace(/\*\*\//g, '').replace(/\[([^\]]+)\]/g, (_m, letters) => letters[0]).replace(/\*/g, '').replace(/\?/g, 'x').replace(/\/$/, '');
+    if (!witness || /[\\\x00-\x1f]/.test(witness)) continue;
+    const candidates = roots.has(witness.split('/')[0]) ? [witness] : [...roots].map(client => `${client}/${witness}`);
+    for (const path of candidates) {
+      const probe = checkedOutput(directory ? `${path}/.agentdevkit-ignore-probe` : path);
+      if (isGeneratedOutput(path, directory) && safeIgnoreProbe(root, probe)) probes.add(probe);
+    }
+  }
+  return [...probes];
+}
+
+// Wildcard negations may expose files that do not exist yet. Inspect client
+// ignores directly, even when an old rule currently hides the entire client.
+function ambiguousExceptions(root, location, clientRoots, artifacts) {
+  const files = [];
+  const visit = directory => {
+    const item = localStat(directory);
+    if (!item?.isDirectory() || item.isSymbolicLink()) return;
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+      const path = join(directory, entry.name);
+      if (entry.isSymbolicLink()) continue;
+      if (entry.isFile() && entry.name === '.gitignore') files.push(path);
+      else if (entry.isDirectory()) {
+        const local = portable(relative(root, path)), client = clientRoots.includes(local.split('/')[0]);
+        const downloaded = entry.name === 'node_modules' || /^\.pbai4devs\/(?:tools\/(?:npm-cache|bin)|external-skills\/[^/]+)$/.test(local);
+        const gitPath = location.prefix ? `${location.prefix}/${local}/` : `${local}/`;
+        const ignoredDownload = downloaded && gitCommand(location.top, ['-c', 'core.excludesFile=', 'check-ignore', '--no-index', '-q', '--', gitPath]).status === 0;
+        const protectedDir = entry.name === '.git' || artifactPath(local, artifacts, true)
+          || ignoredDownload || (client || local.startsWith('.pbai4devs/')) && isGeneratedOutput(local, true);
+        if (!protectedDir) visit(path);
+      }
+    }
+  };
+  visit(root);
+  let ancestor = dirname(root);
+  while (root !== location.top && (ancestor === location.top || !relative(location.top, ancestor).startsWith(`..${sep}`))) {
+    files.push(join(ancestor, '.gitignore'));
+    if (ancestor === location.top) break;
+    ancestor = dirname(ancestor);
+  }
+  const rootIgnore = join(root, '.gitignore');
+  const conflicts = [];
+  for (const file of files) {
+    const item = localStat(file);
+    if (!item?.isFile() || item.isSymbolicLink()) continue;
+    const lines = readFileSync(file, 'utf8').replace(/^\uFEFF/, '').split(/\r?\n/);
+    for (const line of lines) {
+      if (!line.startsWith('!')) continue;
+      const rule = line.slice(1).replace(/^\/?(?:\*\*\/)?/, '');
+      if (/^\.env\.(?:example|sample|template|\*\.example)$/.test(rule)) continue;
+      const wildcard = /(^|[^\\])[*?\[]/.test(line);
+      const scope = portable(relative(dirname(file), root));
+      if (scope && !scope.startsWith('..') && !/^!\/?\*\*\//.test(line) && rule.includes('/')) {
+        const parts = rule.split('/'), project = scope.split('/');
+        if (project.some((part, index) => parts[index] && !/[*?\[]/.test(parts[index]) && parts[index] !== part && parts.slice(0, index).every(value => value && !/[*?\[]/.test(value)))) continue;
+      }
+      if (!wildcard) {
+        if (file !== rootIgnore && isGeneratedOutput(portable(relative(root, join(dirname(file), rule))), rule.endsWith('/'))) conflicts.push(portable(relative(root, file)) + ': ' + line);
+        continue;
+      }
+      conflicts.push(portable(relative(root, file)) + ': ' + line);
+    }
+  }
+  return conflicts;
+}
+
+function foreignHiddenClients(plan) {
+  if (!plan.location) return [];
+  const content = localRead(plan.location.exclude) || '', ranges = [];
+  let start = null;
+  content.split(/\r?\n/).forEach((line, index) => {
+    const begin = line.match(/^# BEGIN AGENTDEVKIT LOCAL ([a-f0-9]{16})$/);
+    const end = line.match(/^# END AGENTDEVKIT LOCAL ([a-f0-9]{16})$/);
+    if (begin) start = { id: begin[1], line: index + 1 };
+    else if (end && start?.id === end[1]) { ranges.push({ ...start, end: index + 1 }); start = null; }
+  });
+  const probes = plan.clientRoots.filter(path => { const item = localStat(join(plan.root, path)); return !item || item.isDirectory() && !item.isSymbolicLink(); }).map(path => `${path}/.agentdevkit-human-probe.md`);
+  if (!probes.length) return [];
+  const { paths, matches } = ignoreMatches(plan.location, probes);
+  return paths.flatMap((path, index) => {
+    const match = matches.get(path);
+    if (!match || match.pattern.startsWith('!') || resolve(plan.location.top, match.source) !== plan.location.exclude) return [];
+    return ranges.some(range => `# BEGIN AGENTDEVKIT LOCAL ${range.id}` !== plan.first && match.line >= range.line && match.line <= range.end) ? [probes[index]] : [];
+  });
+}
+
 function localIgnoreSource(location, source) {
   const path = resolve(location.top, source);
   if (path === location.exclude) return true;
@@ -238,6 +337,8 @@ function localIgnoreSource(location, source) {
 }
 
 function ignoreMatches(location, probes) {
+  const root = join(location.top, location.prefix);
+  if (probes.some(path => !safeIgnoreProbe(root, path))) throw new Error('Probe atravessa caminho simbolico.');
   const paths = probes.map(path => location.prefix ? `${location.prefix}/${path}` : path);
   const result = gitCommand(location.top, ['-c', 'core.excludesFile=', 'check-ignore', '--verbose', '--no-index', '--stdin', '-z'], paths.join('\0') + '\0');
   if (result.error || ![0, 1].includes(result.status)) throw new Error(result.error?.message || result.stderr || 'Falha ao conferir exclusoes Git.');
@@ -297,46 +398,29 @@ export function planLocalIgnore(root, { outputs = [], templateRoot } = {}) {
     if (line.startsWith('!/')) return `!/${escapePattern(location.prefix)}${line.slice(1)}`;
     return line.startsWith('/') ? `/${escapePattern(location.prefix)}${line}` : line;
   }).join('\n');
-  const target = location?.exclude ?? checkedLocalPath(join(root, '.gitignore'));
-  const before = localRead(target), after = localBlock(before, first, last, body);
+  const target = location?.exclude;
+  const before = target ? localRead(target) : null, after = target ? localBlock(before, first, last, body) : null;
   const edits = before === after ? [] : [{ path: target, before, after, beforeMode: localMode(target) }];
   const probes = [...paths, ...rootProbes(root, roots)];
-  const artifactPaths = [...new Set([...artifactProbes(root, artifacts), ...privateClients.probes.filter(path => safeIgnoreProbe(root, path)), ...(location ? visibleArtifactProbes(root, location, artifacts) : [])])];
-  const privateProbes = privateClients.probes.filter(path => safeIgnoreProbe(root, path));
-  const rootOverrideProbes = new Set();
-  const overrideFirst = `# BEGIN AGENTDEVKIT PRIVATE ${id}`, overrideLast = `# END AGENTDEVKIT PRIVATE ${id}`;
-  if (location) {
-    const humanIgnore = localRead(checkedLocalPath(join(root, '.gitignore')));
-    const withoutFallback = localBlock(humanIgnore, first, last, null);
-    const withoutOwned = localBlock(withoutFallback, overrideFirst, overrideLast, null);
-    // Any root negation can match an arbitrary spelling or wildcard value.
-    // Protect private client paths deterministically instead of sampling it.
-    if (withoutOwned.replace(/^\uFEFF/, '').split(/\r?\n/).some(line => line.startsWith('!'))) for (const path of privateProbes) rootOverrideProbes.add(path);
-  }
+  const existingPrivate = privateClients.probes.filter(path => localStat(join(root, path.split('/')[0]))?.isDirectory() && safeIgnoreProbe(root, path));
+  const artifactPaths = [...new Set([...artifactProbes(root, artifacts), ...existingPrivate, ...(location ? [...visibleArtifactProbes(root, location, artifacts), ...visiblePrivateProbes(root, location, clientRoots)] : [])])];
   const wanted = new Set(probes.map(path => location?.prefix ? `${location.prefix}/${path}` : path));
-  if (location && !before?.includes(first) && !localRead(join(root, '.gitignore'))?.includes(first)) {
-    const ignored = ignoreMatches(location, [...probes, ...artifactPaths]);
+  if (location && !before?.includes(first)) {
+    const ignored = ignoreMatches(location, [...probes, ...artifactPaths].filter(path => safeIgnoreProbe(root, path)));
     if (ignored.paths.every(path => { const match = ignored.matches.get(path); return match && !match.pattern.startsWith('!') && localIgnoreSource(location, match.source); })) edits.length = 0;
   }
-  if (location) {
-    const fallback = checkedLocalPath(join(root, '.gitignore'));
-    const old = localRead(fallback);
-    let next = localBlock(old, first, last, null);
-    if (rootOverrideProbes.size || old?.includes(overrideFirst) || old?.includes(overrideLast)) {
-      const overrideBody = privateClients.rules.join('\n');
-      if ((old?.includes(overrideFirst) || old?.includes(overrideLast)) && localBlock(old, overrideFirst, overrideLast, overrideBody) !== old) throw new Error('Bloco privado AgentDevKit alterado; conteudo preservado.');
-      const end = next.indexOf(overrideLast);
-      if (end >= 0 && next.slice(end + overrideLast.length).split(/\r?\n/).some(line => line.startsWith('!'))) next = localBlock(next, overrideFirst, overrideLast, null);
-      next = localBlock(next, overrideFirst, overrideLast, overrideBody);
-    }
-    if (old !== null && old !== next) edits.push({ path: fallback, before: old, after: next, beforeMode: localMode(fallback) });
-  }
-  const tracked = location ? gitCommand(location.top, ['ls-files', '-z']).stdout.split('\0').filter(path => wanted.has(path)).map(path => location.prefix ? path.slice(location.prefix.length + 1) : path) : [];
-  return { root, status: location ? 'git' : 'fallback', location, paths, roots, artifactPatterns: artifacts, artifactProbes: artifactPaths, edits, trackedOutputs: tracked, first, last, rootOverrideProbes: [...rootOverrideProbes] };
+  const prefix = location?.prefix ? `${location.prefix}/` : '';
+  const tracked = location ? gitCommand(location.top, ['ls-files', '-z']).stdout.split('\0').filter(path => {
+    if (!path.startsWith(prefix)) return false;
+    const local = path.slice(prefix.length);
+    return wanted.has(path) || artifactPath(local, artifacts) || clientRoots.includes(local.split('/')[0]) && isGeneratedOutput(local);
+  }).map(path => path.slice(prefix.length)) : [];
+  return { root, status: location ? 'git' : 'no-git', location, paths, roots, clientRoots, artifactPatterns: artifacts, artifactProbes: artifactPaths, privateProbes: privateClients.probes, edits, trackedOutputs: tracked, first, last };
 }
 
 export function checkLocalIgnore(plan, { replacedBlocks = [] } = {}) {
   const missing = [];
+  if (plan.location) missing.push(...ambiguousExceptions(plan.root, plan.location, plan.clientRoots || [], plan.artifactPatterns || []), ...foreignHiddenClients(plan));
   const replacements = replacedBlocks.map(item => {
     const path = canonicalExisting(checkedLocalPath(resolve(item.path))), inside = relative(localRoot(plan.root).root, path);
     if (isAbsolute(inside) || inside === '..' || inside.startsWith(`..${sep}`) || !Number.isInteger(item.firstLine) || !Number.isInteger(item.lastLine) || item.firstLine < 1 || item.lastLine < item.firstLine || !/^[a-f0-9]{64}$/.test(item.sha256)) throw new Error('Faixa de ignore gerenciado invalida.');
@@ -349,8 +433,11 @@ export function checkLocalIgnore(plan, { replacedBlocks = [] } = {}) {
     return { ...item, path };
   });
   if (plan.location && (plan.paths.length || plan.artifactProbes?.length)) {
-    const probes = [...new Set([...plan.paths, ...rootProbes(plan.root, plan.roots || []), ...(plan.artifactProbes || []),
-      ...(plan.artifactPatterns ? visibleArtifactProbes(plan.root, plan.location, plan.artifactPatterns) : [])])];
+    missing.push(...plan.paths.filter(path => !safeIgnoreProbe(plan.root, path)));
+    const privateProbes = (plan.privateProbes || []).filter(path => localStat(join(plan.root, path.split('/')[0]))?.isDirectory() && safeIgnoreProbe(plan.root, path));
+    const probes = [...new Set([...plan.paths, ...rootProbes(plan.root, plan.roots || []), ...(plan.artifactProbes || []), ...privateProbes,
+      ...(plan.artifactPatterns ? visibleArtifactProbes(plan.root, plan.location, plan.artifactPatterns) : []),
+      ...visiblePrivateProbes(plan.root, plan.location, plan.clientRoots || [])])].filter(path => safeIgnoreProbe(plan.root, path));
     const { paths: relativePaths, matches } = ignoreMatches(plan.location, probes);
     for (let index = 0; index < relativePaths.length; index++) {
       const match = matches.get(relativePaths[index]);
@@ -358,11 +445,10 @@ export function checkLocalIgnore(plan, { replacedBlocks = [] } = {}) {
       const local = match && localIgnoreSource(plan.location, match.source);
       const humanOverride = negative && local && /(?:^|[\\/])\.gitignore$/.test(match.source);
       const replaced = negative && replacements.some(item => item.path === canonicalExisting(resolve(plan.location.top, match.source)) && match.line >= item.firstLine && match.line <= item.lastLine);
-      const pendingRootOverride = humanOverride && plan.rootOverrideProbes?.includes(probes[index]) && plan.edits.some(edit => edit.path === join(plan.root, '.gitignore'));
-      if (!replaced && !pendingRootOverride && ((!plan.edits.length && (!match || negative || !local)) || humanOverride)) missing.push(probes[index]);
+      if (!replaced && ((!plan.edits.length && (!match || negative || !local)) || humanOverride)) missing.push(probes[index]);
     }
   }
-  return { ok: plan.edits.length === 0 && missing.length === 0 && plan.trackedOutputs.length === 0, status: plan.status, missing, trackedOutputs: plan.trackedOutputs, changed: plan.edits.length };
+  return { ok: plan.status === 'git' && plan.edits.length === 0 && missing.length === 0 && plan.trackedOutputs.length === 0, status: plan.status, missing, trackedOutputs: plan.trackedOutputs, changed: plan.edits.length };
 }
 
 export function assertLocalIgnoreUnchanged(plan) {

package/.pbai4devs/scripts/sincronizar-agentes/README.md

@@ -37,7 +37,7 @@ a seleção, use `agentdevkit agents <lista>`; não edite o manifesto gerado.
 
 Os derivados ficam locais: catálogos, manifesto, estado e apontamentos são
 excluídos pelo Git. O bloco em `.git/info/exclude` preserva regras próprias;
-sem Git, usa um bloco na raiz que migra ao executar depois de `git init`.
+sem Git, informa que a proteção fica pendente até `git init` e sincronização.
 Somente arquivos integralmente gerados são excluídos; pastas de clientes podem
 conter arquivos humanos versionados. Conteúdo próprio não é desindexado pela
 presença de um bloco gerenciado.

package/.pbai4devs/scripts/sincronizar-agentes/SCRIPT.mjs

@@ -577,9 +577,10 @@ export function synchronize({ root = projectRoot, check = false, force = false,
   const touched = new Set(), createdDirectories = new Set(), restoredDirectories = new Set();
   const prunedDirectories = new Map();
   let restoring = false;
-  const summary = { changed: changed.length + rootEntryChanges.length, stale: removals.length, conflicts: conflicts.size, missing: missing.length, legacy: legacy.length, registries: registries.size, gitignores: ignoreFiles.size, manifests: configExists ? 0 : 1, localIgnores: localStatus.changed + localStatus.missing.length + localStatus.trackedOutputs.length };
+  const summary = { changed: changed.length + rootEntryChanges.length, stale: removals.length, conflicts: conflicts.size, missing: missing.length, legacy: legacy.length, registries: registries.size, gitignores: ignoreFiles.size, manifests: configExists ? 0 : 1, localIgnores: localStatus.changed + localStatus.missing.length + localStatus.trackedOutputs.length + (localStatus.status === 'no-git' ? 1 : 0) };
   const dirty = Object.values(summary).some(Boolean);
   output(`${summary.changed} desatualizadas; ${summary.stale} obsoletas; ${summary.conflicts} conflitos; ${summary.missing} origens nativas ausentes; ${summary.legacy} documentos antigos; ${summary.registries} indices derivados; ${summary.gitignores} gitignores; ${summary.localIgnores} exclusoes locais.`);
+  if (localStatus.status === 'no-git') output('Git ausente: apos git init, execute a sincronizacao para proteger os arquivos locais.');
   const preservedPaths = sorted(preserved.keys()).map(path => preserved.get(path));
   if (check) return { ...summary, ownedOutputs, managedBlocks, preserved: preservedPaths, exitCode: dirty ? 1 : 0 };
   if (conflicts.size) fail(`Use --force para reconstruir somente os caminhos gerenciados: ${sorted(conflicts).join(', ')}`);

package/.pbai4devs/scripts/sincronizar-agentes/tests/LOCAL_IGNORE.mjs

@@ -23,14 +23,14 @@ function git(root, args, input) {
   assert.ifError(result.error); assert.equal(result.status, 0, result.stderr); return result.stdout;
 }
 
-test('fallback protege outputs antes de git init e migra para exclude preservando regras', t => {
+test('sem Git preserva ignore e informa pendência; após git init protege outputs', t => {
   const root = fixture(t), outputs = ['.github/skills/generated/SKILL.md', '.vscode/.gitignore', 'AGENTS.md'];
   put(root, '.gitignore', '# Regras humanas\n*.own-cache\n');
   const plan = planLocalIgnore(root, { outputs });
-  assert.equal(plan.status, 'fallback'); assert.equal(checkLocalIgnore(plan).ok, false);
+  assert.equal(plan.status, 'no-git'); assert.equal(checkLocalIgnore(plan).ok, false);
   applyLocalIgnore(plan);
-  assert.equal(checkLocalIgnore(planLocalIgnore(root, { outputs })).ok, true);
-  assert.match(readFileSync(join(root, '.gitignore'), 'utf8'), /^# Regras humanas\n\*\.own-cache\n/);
+  assert.equal(checkLocalIgnore(planLocalIgnore(root, { outputs })).ok, false);
+  assert.equal(readFileSync(join(root, '.gitignore'), 'utf8'), '# Regras humanas\n*.own-cache\n');
   git(root, ['init', '-q']);
   put(root, '.git/info/exclude', '# Exclusoes humanas\n*.local-backup\n');
   applyLocalIgnore(planLocalIgnore(root, { outputs }));
@@ -68,10 +68,10 @@ test('check identifica negação humana e outputs rastreados sem alterar o índi
   assert.equal(git(root, ['ls-files', 'generated.md']).trim(), 'generated.md');
 });
 
-test('negação genérica de cache preserva regras humanas e protege caches de clientes', t => {
+test('exceções de templates preservam o ignore raiz e protegem dados privados', t => {
   const root = fixture(t); git(root, ['init', '-q']);
   git(root, ['config', 'core.ignorecase', 'false']);
-  const original = '# Regras do projeto\n!*.[Cc]ache/\n';
+  const original = '# Regras do projeto\n.env.*\n!.env.example\n!.env.*.example\n';
   put(root, '.gitignore', original); git(root, ['add', '.gitignore']);
   const index = git(root, ['ls-files', '--stage', '-z']);
   const plan = planLocalIgnore(root);
@@ -79,7 +79,7 @@ test('negação genérica de cache preserva regras humanas e protege caches de c
   assert.equal(existsSync(join(root, '.cursor')), false);
   applyLocalIgnore(plan);
   const updated = readFileSync(join(root, '.gitignore'), 'utf8');
-  assert.ok(updated.startsWith(original));
+  assert.equal(updated, original);
   assert.equal(git(root, ['ls-files', '--stage', '-z']), index);
   assert.equal(existsSync(join(root, '.cursor')), false);
   assert.equal(checkLocalIgnore(planLocalIgnore(root)).ok, true);
@@ -96,18 +96,12 @@ test('negação genérica de cache preserva regras humanas e protege caches de c
   assert.equal(checkLocalIgnore(planLocalIgnore(root)).ok, true);
 });
 
-test('bloco privado modificado é preservado e recusa atualização', t => {
+test('bloco legado na raiz pertence ao projeto e permanece intacto', t => {
   const root = fixture(t); git(root, ['init', '-q']);
-  put(root, '.gitignore', '!*.[Cc]ache/\n');
+  const original = '# BEGIN AGENTDEVKIT PRIVATE legado\n# edição humana\n# END AGENTDEVKIT PRIVATE legado\n';
+  put(root, '.gitignore', original);
   applyLocalIgnore(planLocalIgnore(root));
-  const path = join(root, '.gitignore');
-  const changed = readFileSync(path, 'utf8').replace('# Estado local', '# Estado alterado');
-  // Alter a concrete managed rule, even if the template has no heading here.
-  const edited = changed.replace('/.cursor/', '/.cursor-alterado/');
-  assert.notEqual(edited, readFileSync(path, 'utf8'));
-  writeFileSync(path, edited);
-  assert.throws(() => planLocalIgnore(root), /Bloco privado AgentDevKit alterado/);
-  assert.equal(readFileSync(path, 'utf8'), edited);
+  assert.equal(readFileSync(join(root, '.gitignore'), 'utf8'), original);
 });
 
 test('negação com caixa mista não expõe cache em Git sensível a maiúsculas', t => {
@@ -115,9 +109,8 @@ test('negação com caixa mista não expõe cache em Git sensível a maiúsculas
   git(root, ['config', 'core.ignorecase', 'false']);
   put(root, '.gitignore', '!*.CaChE/\n');
   put(root, '.cursor/.CaChE/private.json', 'local');
-  applyLocalIgnore(planLocalIgnore(root));
-  assert.equal(checkLocalIgnore(planLocalIgnore(root)).ok, true);
-  assert.ok(git(root, ['check-ignore', '--no-index', '.cursor/.CaChE/private.json']).includes('.cursor/.CaChE/private.json'));
+  assert.throws(() => applyLocalIgnore(planLocalIgnore(root)), /Regras humanas/);
+  assert.equal(readFileSync(join(root, '.gitignore'), 'utf8'), '!*.CaChE/\n');
 });
 
 test('negações literais e com caixa mista não expõem estado privado', t => {
@@ -125,41 +118,36 @@ test('negações literais e com caixa mista não expõem estado privado', t => {
   git(root, ['config', 'core.ignorecase', 'false']);
   put(root, '.gitignore', '!*.LoCaL/\n!/.cursor/.env.production\n');
   for (const path of ['.cursor/.LoCaL/private.json', '.cursor/.env.production']) put(root, path, 'privado');
-  applyLocalIgnore(planLocalIgnore(root));
-  for (const path of ['.cursor/.LoCaL/private.json', '.cursor/.env.production']) assert.ok(git(root, ['check-ignore', '--no-index', path]).includes(path));
-  assert.equal(checkLocalIgnore(planLocalIgnore(root)).ok, true);
+  assert.throws(() => applyLocalIgnore(planLocalIgnore(root)), /Regras humanas/);
+  assert.equal(readFileSync(join(root, '.gitignore'), 'utf8'), '!*.LoCaL/\n!/.cursor/.env.production\n');
 });
 
 test('negação na primeira linha com BOM preserva bytes e protege segredos', t => {
   const root = fixture(t); git(root, ['init', '-q']);
   const original = '\uFEFF!/.cursor/.env.production\r\n';
   put(root, '.gitignore', original); put(root, '.cursor/.env.production', 'privado');
-  applyLocalIgnore(planLocalIgnore(root));
-  assert.ok(readFileSync(join(root, '.gitignore'), 'utf8').startsWith(original));
-  assert.ok(git(root, ['check-ignore', '--no-index', '.cursor/.env.production']).includes('.cursor/.env.production'));
-  assert.equal(checkLocalIgnore(planLocalIgnore(root)).ok, true);
+  assert.throws(() => applyLocalIgnore(planLocalIgnore(root)), /Regras humanas/);
+  assert.equal(readFileSync(join(root, '.gitignore'), 'utf8'), original);
 });
 
-test('negação humana acrescentada após o bloco recebe proteção na próxima sincronização', t => {
+test('negação humana posterior é informada sem reescrever a raiz', t => {
   const root = fixture(t); git(root, ['init', '-q']);
-  put(root, '.gitignore', '!*.cache/\n'); applyLocalIgnore(planLocalIgnore(root));
+  put(root, '.gitignore', '# humano\n'); applyLocalIgnore(planLocalIgnore(root));
   const path = join(root, '.gitignore');
   writeFileSync(path, readFileSync(path, 'utf8') + '!/.cursor/.env.production\n');
   put(root, '.cursor/.env.production', 'privado');
   const plan = planLocalIgnore(root);
-  assert.ok(plan.edits.some(edit => edit.path === path));
-  applyLocalIgnore(plan);
-  assert.match(readFileSync(path, 'utf8'), /!\*\.cache\/\n!\/\.cursor\/\.env\.production\n/);
-  assert.ok(git(root, ['check-ignore', '--no-index', '.cursor/.env.production']).includes('.cursor/.env.production'));
-  assert.equal(checkLocalIgnore(planLocalIgnore(root)).ok, true);
+  assert.ok(checkLocalIgnore(plan).missing.includes('.cursor/.env.production'));
+  assert.throws(() => applyLocalIgnore(plan), /Regras humanas/);
+  assert.equal(readFileSync(path, 'utf8'), '# humano\n!/.cursor/.env.production\n');
 });
 
-test('planejamento é somente leitura e aplicação detecta mudança concorrente', t => {
+test('planejamento sem Git não modifica ignore nem edição humana posterior', t => {
   const root = fixture(t); put(root, '.gitignore', 'antes\r\n');
   const plan = planLocalIgnore(root, { outputs: ['generated.md'] });
   assert.equal(readFileSync(join(root, '.gitignore'), 'utf8'), 'antes\r\n');
   put(root, '.gitignore', 'depois\r\n');
-  assert.throws(() => applyLocalIgnore(plan), /alterada apos planejar/);
+  applyLocalIgnore(plan);
   assert.equal(readFileSync(join(root, '.gitignore'), 'utf8'), 'depois\r\n');
   for (const path of ['../outside', '/absolute', 'line\nname', 'a\\b']) assert.throws(() => planLocalIgnore(root, { outputs: [path] }), /invalida/);
 });
@@ -185,7 +173,7 @@ test('plano de instalação em alvo inexistente não cria arquivos', t => {
   const root = fixture(t);
   const target = join(root, 'new project', 'nested');
   const fallback = planLocalIgnore(target, { outputs: ['AGENTS.md'] });
-  assert.equal(fallback.status, 'fallback'); assert.equal(existsSync(target), false);
+  assert.equal(fallback.status, 'no-git'); assert.equal(existsSync(target), false);
   git(root, ['init', '-q']);
   const plan = planLocalIgnore(target, { outputs: ['AGENTS.md'] });
   assert.equal(plan.status, 'git'); assert.equal(existsSync(target), false);
@@ -217,21 +205,21 @@ test('configurações humanas dos clientes continuam versionáveis', t => {
   assert.ok(tracked.includes('.github/settings.json')); assert.ok(tracked.includes('.vscode/settings.json'));
 });
 
-test('artefatos vêm da política compartilhada e não entram na lista de outputs', t => {
+test('artefatos vêm da política compartilhada e rastreados são informados', t => {
   const root = fixture(t); git(root, ['init', '-q']);
   put(root, '.agent-tests/human.txt', 'evidência humana'); git(root, ['add', '-f', '.agent-tests/human.txt']);
   const plan = planLocalIgnore(root, { outputs: ['AGENTS.md'] });
   assert.ok(plan.artifactProbes.some(path => path.startsWith('.agent-tests/')));
   assert.ok(plan.artifactProbes.some(path => path.startsWith('.agentdevkit-ignore-probes/')));
   assert.ok(plan.paths.every(path => !plan.artifactProbes.includes(path)));
-  assert.ok(!plan.trackedOutputs.includes('.agent-tests/human.txt'));
+  assert.ok(plan.trackedOutputs.includes('.agent-tests/human.txt'));
   applyLocalIgnore(plan);
   for (const path of ['.agent-tests/x', 'TMP/x', 'nested/TeMp/x', '.PlAyWrIgHt-McP/x', 'nested/playwright-report/x', 'TEST-RESULTS/x', 'nested/TestResults/x', 'BLOB-REPORT/x']) {
     assert.equal(git(root, ['check-ignore', '--no-index', path]).trim(), path);
   }
   assert.equal(git(root, ['ls-files', '.agent-tests/human.txt']).trim(), '.agent-tests/human.txt');
   assert.equal(readFileSync(join(root, '.agent-tests/human.txt'), 'utf8'), 'evidência humana');
-  assert.equal(checkLocalIgnore(planLocalIgnore(root, { outputs: ['AGENTS.md'] })).ok, true);
+  assert.equal(checkLocalIgnore(planLocalIgnore(root, { outputs: ['AGENTS.md'] })).ok, false);
 });
 
 test('regras de artefatos são limitadas ao projeto dentro do monorepo', t => {
@@ -467,6 +455,63 @@ test('arquivo real reaberto por glob é detectado também se surgir após o plan
   assert.equal(readFileSync(join(root, path), 'utf8'), 'artefato local\n');
 });
 
+test('negações globais e aninhadas não expõem futuros arquivos privados', t => {
+  for (const [file, rule] of [['.gitignore', '!/.claude/s*.json'], ['.claude/.gitignore', '!s*.json'], ['.claude/.gitignore', '!/settings.local.json'], ['.pbai4devs/.gitignore', '!.playwright-*/'], ['.pbai4devs/module/.gitignore', '!.playwright-*/'], ['logs/.gitignore', '!.playwright-*/'], ['.gitignore', '!**/foo/s*.json'], ['.gitignore', '!**/foo/.playwright-*.png'], ['.gitignore', '!/docs/.playwright-*.png'], ['docs/.gitignore', '!.playwright-*/'], ['.gitignore', '!*.CaChE/'], ['.gitignore', '!/.playwright-*.png']]) {
+    const root = fixture(t); git(root, ['init', '-q']);
+    put(root, file, `\uFEFF${rule}\n`);
+    const before = readFileSync(join(root, '.git/info/exclude'));
+    const index = git(root, ['ls-files', '--stage', '-z']);
+    const plan = planLocalIgnore(root);
+    assert.ok(checkLocalIgnore(plan).missing.some(value => value.includes(rule)), rule);
+    assert.throws(() => applyLocalIgnore(plan), /Regras humanas/);
+    assert.deepEqual(readFileSync(join(root, '.git/info/exclude')), before);
+    assert.equal(git(root, ['ls-files', '--stage', '-z']), index);
+    assert.equal(readFileSync(join(root, file), 'utf8'), `\uFEFF${rule}\n`);
+  }
+});
+
+test('glob ancestral do subprojeto é detectado antes de alterar o exclude', t => {
+  const root = fixture(t); git(root, ['init', '-q']);
+  const child = join(root, 'packages/app'); mkdirSync(child, { recursive: true });
+  put(root, '.gitignore', '!/packages/app/.claude/s*.json\n');
+  const before = readFileSync(join(root, '.git/info/exclude'));
+  const plan = planLocalIgnore(child);
+  assert.ok(checkLocalIgnore(plan).missing.some(value => value.includes('s*.json')));
+  assert.throws(() => applyLocalIgnore(plan), /Regras humanas/);
+  assert.deepEqual(readFileSync(join(root, '.git/info/exclude')), before);
+});
+
+test('dependências já ignoradas não causam conflito, mas ignores visíveis são verificados', t => {
+  const root = fixture(t); git(root, ['init', '-q']);
+  put(root, '.gitignore', 'node_modules/\n');
+  put(root, 'node_modules/pacote/.gitignore', '!.playwright-*/\n');
+  assert.equal(checkLocalIgnore(planLocalIgnore(root)).missing.length, 0);
+  put(root, '.gitignore', '# dependências visíveis\n');
+  assert.ok(checkLocalIgnore(planLocalIgnore(root)).missing.some(value => value.includes('!.playwright-*/')));
+});
+
+test('bloco antigo de outro caminho não oculta arquivos humanos silenciosamente', t => {
+  const root = fixture(t); git(root, ['init', '-q']);
+  const old = '# BEGIN AGENTDEVKIT LOCAL 0123456789abcdef\n/.claude/\n# END AGENTDEVKIT LOCAL 0123456789abcdef\n';
+  put(root, '.git/info/exclude', old);
+  const plan = planLocalIgnore(root);
+  assert.ok(checkLocalIgnore(plan).missing.includes('.claude/.agentdevkit-human-probe.md'));
+  assert.throws(() => applyLocalIgnore(plan), /Regras humanas/);
+  assert.equal(readFileSync(join(root, '.git/info/exclude'), 'utf8'), old);
+});
+
+test('artefatos já versionados são informados sem alterar o índice', t => {
+  const root = fixture(t); git(root, ['init', '-q']);
+  const artifacts = ['.playwright-mcp/trace.zip', 'playwright-report/index.html', 'test-results/result.txt', '.agent-tests/log.txt', '.claude/settings.local.json', '.codex/.env'];
+  for (const path of artifacts) put(root, path, 'trace');
+  git(root, ['add', '-f', ...artifacts]);
+  const before = git(root, ['ls-files', '--stage', '-z']);
+  const plan = planLocalIgnore(root);
+  assert.deepEqual([...plan.trackedOutputs].sort(), artifacts.sort());
+  assert.equal(checkLocalIgnore(plan).ok, false);
+  assert.equal(git(root, ['ls-files', '--stage', '-z']), before);
+});
+
 test('regras customizadas aninhadas continuam válidas e incluem pais ocultos', t => {
   const root = fixture(t); git(root, ['init', '-q']);
   const policy = readFileSync(join(projectRoot, '.pbai4devs/templates/gitignore/agents.ignore'), 'utf8');
@@ -485,7 +530,7 @@ test('chaves literais em padrões Git não viram expansão de glob', t => {
   const policy = readFileSync(join(projectRoot, '.pbai4devs/templates/gitignore/agents.ignore'), 'utf8');
   put(root, '.pbai4devs/templates/gitignore/agents.ignore', `${policy}\n**/cache{keep,archive}/\n`);
   put(root, 'cachekeep/source.txt', 'código humano\n');
-  put(root, '.gitignore', '!cachekeep/**\n');
+  put(root, '.gitignore', '!cachekeep/source.txt\n');
   assert.doesNotThrow(() => applyLocalIgnore(planLocalIgnore(root)));
   assert.equal(readFileSync(join(root, 'cachekeep/source.txt'), 'utf8'), 'código humano\n');
 });
@@ -510,32 +555,28 @@ test('escrita de exclusões preserva permissões e detecta alteração concorren
   assert.equal(statSync(exclude).mode & 0o777, 0o640);
 });
 
-test('fallback e rollback de exclusões mantêm o modo original', { skip: process.platform === 'win32' }, t => {
+test('ignore raiz mantém modo e bytes antes e depois de git init', { skip: process.platform === 'win32' }, t => {
   const root = fixture(t), ignore = join(root, '.gitignore');
   put(root, '.gitignore', '# humano\n'); chmodSync(ignore, 0o600);
   applyLocalIgnore(planLocalIgnore(root));
   assert.equal(statSync(ignore).mode & 0o777, 0o600);
   const original = readFileSync(ignore); git(root, ['init', '-q']);
-  const exclude = join(root, '.git/info/exclude'), before = readFileSync(exclude);
-  chmodSync(exclude, 0o600);
-  const plan = planLocalIgnore(root); assert.equal(plan.edits.length, 2);
-  Object.defineProperty(plan.edits[1], 'after', { get() { throw new Error('injected rollback failure'); } });
-  assert.throws(() => applyLocalIgnore(plan), /injected rollback failure/);
-  assert.deepEqual(readFileSync(exclude), before); assert.equal(statSync(exclude).mode & 0o777, 0o600);
+  const exclude = join(root, '.git/info/exclude'); chmodSync(exclude, 0o600);
+  applyLocalIgnore(planLocalIgnore(root));
+  assert.equal(statSync(exclude).mode & 0o777, 0o600);
   assert.deepEqual(readFileSync(ignore), original); assert.equal(statSync(ignore).mode & 0o777, 0o600);
 });
 
-test('rollback restaura exclusão somente leitura com escrita atômica', { skip: process.platform === 'win32' }, t => {
+test('ignore raiz somente leitura não impede exclusão local no Git', { skip: process.platform === 'win32' }, t => {
   const root = fixture(t), ignore = join(root, '.gitignore');
   put(root, '.gitignore', '# humano\n'); chmodSync(ignore, 0o444);
   applyLocalIgnore(planLocalIgnore(root));
   const original = readFileSync(ignore); git(root, ['init', '-q']);
-  const exclude = join(root, '.git/info/exclude'), before = readFileSync(exclude);
+  const exclude = join(root, '.git/info/exclude');
   chmodSync(exclude, 0o444);
   const plan = planLocalIgnore(root);
-  Object.defineProperty(plan.edits[1], 'after', { get() { throw new Error('readonly rollback probe'); } });
-  assert.throws(() => applyLocalIgnore(plan), /readonly rollback probe/);
-  assert.deepEqual(readFileSync(exclude), before); assert.equal(statSync(exclude).mode & 0o777, 0o444);
+  applyLocalIgnore(plan);
+  assert.equal(statSync(exclude).mode & 0o777, 0o444);
   assert.deepEqual(readFileSync(ignore), original); assert.equal(statSync(ignore).mode & 0o777, 0o444);
 });
 

package/.pbai4devs/skills/README.md

@@ -13,6 +13,13 @@ as capacidades do cliente.
 - `projeto`: configuração, criação e manutenção dos recursos.
 - `produto`: PRD, experiência e design técnico.
 - `specs`: especificações, roadmap e implementação.
+- `arquitetura`: [avaliar decisões e riscos](arquitetura/avaliar-arquitetura/SKILL.md).
+- `desenvolvimento`: [backend](desenvolvimento/implementar-backend/SKILL.md) e
+  [frontend](desenvolvimento/implementar-frontend/SKILL.md).
+- `qualidade`: [QA](qualidade/planejar-qa/SKILL.md),
+  [validação adversarial](qualidade/validar-adversarial/SKILL.md),
+  [revisão de código](qualidade/revisar-codigo/SKILL.md) e
+  [performance](qualidade/avaliar-performance/SKILL.md).
 - `seguranca`: [revisão](seguranca/revisar-seguranca/SKILL.md),
   [autorização](seguranca/revisar-autorizacao/SKILL.md),
   [ameaças](seguranca/modelar-ameacas/SKILL.md) e

package/.pbai4devs/skills/arquitetura/avaliar-arquitetura/SKILL.md

@@ -0,0 +1,21 @@
+---
+name: avaliar-arquitetura
+description: Avalia e orienta decisões de arquitetura conforme requisitos e restrições do software.
+---
+
+# Avaliar arquitetura
+
+Examine o produto, os fluxos, o design e o sistema existente. Reúna dúvidas
+que mudam decisões; quando faltar definição, encaminhe ao
+[design técnico](../../produto/criar-design-doc/SKILL.md). Não imponha stack.
+
+Identifique componentes, responsabilidades, contratos, dados e fronteiras de
+confiança. Avalie operação, evolução, falhas, segurança, desempenho e custos
+conforme o contexto. Compare alternativas e consequências; registre decisões,
+compensações e migração quando necessárias. Diagramas só quando esclarecerem.
+
+Questione acoplamento, perda de dados, dependências e falhas simultâneas com
+cenários concretos. Delegue uma análise independente quando disponível e
+permitido. Entregue decisão proposta, evidências, riscos e verificações abertas;
+não apresente hipóteses como fatos. Consulte [C4](https://c4model.com/diagrams)
+quando um diagrama ajudar.

package/.pbai4devs/skills/desenvolvimento/implementar-backend/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: implementar-backend
+description: Implementa mudanças de backend com contratos, dados e provas de comportamento.
+---
+
+# Implementar backend
+
+Siga a spec e o plano aprovados, os contratos e a stack existentes. Esclareça
+dúvidas sobre entradas, saídas, persistência,
+compatibilidade e falhas antes de decidir. Altere somente o escopo atribuído.
+
+Verifique validação de entrada, autorização por recurso e isolamento de dados.
+Considere limites, concorrência, repetição, timeout, migração e recuperação
+quando se aplicarem; não registre segredos. Reutilize convenções e ferramentas
+do projeto sem presumir banco, framework ou serviço externo.
+
+Prove casos normais e negativos por testes automatizados e, quando aplicável,
+por chamadas reais à API com dados isolados. Mocks não comprovam integrações
+que não foram executadas. Versione testes; mantenha resultados locais ignorados.
+Relate critérios, comandos, observações e dependências não verificadas.