sinapse-ai 1.25.0 → 1.25.2

package/bin/commands/uninstall.js

@@ -3,6 +3,8 @@
 
 const fs = require('fs');
 const path = require('path');
+const crypto = require('crypto');
+const legacyClaudeCommandHashes = require('../../packages/installer/src/migrations/legacy-claude-agent-command-hashes.json');
 const { getLogger } = require('../../.sinapse-ai/core/logger');
 const {
   HOME,
@@ -58,22 +60,61 @@ async function removeGitHooksConfig(projectDir = process.cwd()) {
 // and removes only those files (preserving anything the user added by hand).
 const INSTALLED_AGENTS_MANIFEST = path.join(SINAPSE_HOME, 'installed-agents.json');
 
-function recordInstalledAgents(filenames, ides) {
+function installedAgentsManifestPath(home = HOME) {
+  return home === HOME
+    ? INSTALLED_AGENTS_MANIFEST
+    : path.join(home, '.sinapse', 'installed-agents.json');
+}
+
+function digestFile(filePath) {
   try {
-    fs.mkdirSync(SINAPSE_HOME, { recursive: true });
-    fs.writeFileSync(INSTALLED_AGENTS_MANIFEST, JSON.stringify({
-      version: 1,
+    return crypto.createHash('sha256').update(fs.readFileSync(filePath)).digest('hex');
+  } catch {
+    return null;
+  }
+}
+
+function providerAgentPath(home, provider, filename) {
+  const providerDir = provider === 'codex'
+    ? path.join(home, '.codex', 'agents')
+    : path.join(home, '.claude', 'agents');
+  return path.join(providerDir, filename);
+}
+
+function inferProviderFromAgentDir(dir) {
+  const normalized = path.resolve(dir).replace(/\\/g, '/').toLowerCase();
+  if (normalized.includes('/.codex/agents')) return 'codex';
+  if (normalized.includes('/.claude/agents')) return 'claude-code';
+  return null;
+}
+
+function recordInstalledAgents(filenames, ides, home = HOME) {
+  try {
+    const manifestPath = installedAgentsManifestPath(home);
+    fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
+    const artifacts = [...filenames].map((filename) => {
+      const provider = filename.endsWith('.toml') ? 'codex' : 'claude-code';
+      return {
+        provider,
+        filename,
+        sha256: digestFile(providerAgentPath(home, provider, filename)),
+      };
+    });
+    fs.writeFileSync(manifestPath, JSON.stringify({
+      version: 2,
       timestamp: new Date().toISOString(),
       ides,
       filenames: [...filenames].sort(),
+      artifacts: artifacts.sort((a, b) => `${a.provider}/${a.filename}`.localeCompare(`${b.provider}/${b.filename}`)),
     }, null, 2));
   } catch { /* non-critical */ }
 }
 
-function readInstalledAgentsManifest() {
+function readInstalledAgentsManifest(home = HOME) {
   try {
-    if (!fs.existsSync(INSTALLED_AGENTS_MANIFEST)) return null;
-    const raw = fs.readFileSync(INSTALLED_AGENTS_MANIFEST, 'utf8');
+    const manifestPath = installedAgentsManifestPath(home);
+    if (!fs.existsSync(manifestPath)) return null;
+    const raw = fs.readFileSync(manifestPath, 'utf8');
     const parsed = JSON.parse(raw);
     if (!parsed || !Array.isArray(parsed.filenames)) return null;
     return parsed;
@@ -85,35 +126,36 @@ function readInstalledAgentsManifest() {
 function removeInstalledAgentsFrom(dir, manifestOverride = null) {
   if (!fs.existsSync(dir)) return { removed: 0, existed: false };
   let removed = 0;
+  const manifest = manifestOverride || readInstalledAgentsManifest();
+  const provider = inferProviderFromAgentDir(dir);
   let candidates;
 
-  const manifest = manifestOverride || readInstalledAgentsManifest();
-  if (manifest && Array.isArray(manifest.filenames)) {
-    // Manifest path — surgical removal of exactly what install wrote.
-    candidates = manifest.filenames;
+  if (manifest?.version >= 2 && Array.isArray(manifest.artifacts)) {
+    candidates = manifest.artifacts.filter((artifact) => {
+      if (!artifact || typeof artifact.filename !== 'string') return false;
+      return provider ? artifact.provider === provider : true;
+    });
   } else {
-    // Backward-compat fallback for installs predating the manifest
-    // (rc.10 and earlier). Heuristic: SINAPSE-authored files end in
-    // `-orqx.md`, OR start with `name: sinapse-` in their frontmatter.
-    try {
-      candidates = fs.readdirSync(dir).filter((f) => {
-        if (f.endsWith('.toml')) {
-          try { return /SINAPSE/i.test(fs.readFileSync(path.join(dir, f), 'utf8').slice(0, 4000)); } catch { return false; }
-        }
-        if (!f.endsWith('.md')) return false;
-        if (/-orqx\.md$/.test(f)) return true;
-        try {
-          const head = fs.readFileSync(path.join(dir, f), 'utf8').slice(0, 600);
-          return /^\s*name:\s*sinapse-/im.test(head);
-        } catch { return false; }
-      });
-    } catch { return { removed: 0, existed: true }; }
+    // Legacy manifests did not record provider or digests. Ownership must be
+    // proven by the marker in the actual provider directory before deletion.
+    const filenames = Array.isArray(manifest?.filenames)
+      ? manifest.filenames
+      : fs.readdirSync(dir);
+    candidates = filenames.map((filename) => ({ filename, sha256: null, legacy: true }));
   }
 
-  for (const f of candidates) {
-    const filepath = path.join(dir, f);
+  for (const { filename, sha256, legacy } of candidates) {
+    const filepath = path.join(dir, filename);
     if (!fs.existsSync(filepath)) continue;
     try {
+      if (sha256) {
+        if (digestFile(filepath) !== sha256) continue;
+      } else {
+        // A v2 entry without a digest does not prove the installer wrote it.
+        if (!legacy) continue;
+        const content = fs.readFileSync(filepath, 'utf8');
+        if (!content.includes('SINAPSE-MANAGED:global-agent')) continue;
+      }
       fs.unlinkSync(filepath);
       removed++;
     } catch { /* best-effort */ }
@@ -128,44 +170,166 @@ function removeOrqxAgentsFrom(dir) {
   return removeInstalledAgentsFrom(dir);
 }
 
-const MANAGED_GLOBAL_SKILL_IDS = ['snps', 'sinapse', 'snps-orqx', 'sinapse-agent'];
+const MANAGED_GLOBAL_SKILL_IDS = ['snps', 'sinapse', 'snps-orqx', 'sinapse-orqx', 'sinapse-agent'];
 const MANAGED_GLOBAL_SKILL_MARKER = 'SINAPSE-MANAGED:global-skill';
 
-function removeManagedGlobalSkills(home = HOME) {
+function removeManagedGlobalSkills(home = HOME, options = {}) {
   let removed = 0;
-  for (const skillId of MANAGED_GLOBAL_SKILL_IDS) {
-    const skillDir = path.join(home, '.agents', 'skills', skillId);
-    const skillPath = path.join(skillDir, 'SKILL.md');
-    if (!fs.existsSync(skillPath)) continue;
-    try {
-      const content = fs.readFileSync(skillPath, 'utf8');
-      if (!content.includes(MANAGED_GLOBAL_SKILL_MARKER)) continue;
-      fs.unlinkSync(skillPath);
-      if (fs.readdirSync(skillDir).length === 0) fs.rmdirSync(skillDir);
-      removed++;
-    } catch { /* best-effort */ }
+  const providers = options.providers || ['codex', 'claude-code'];
+  const skillRoots = [];
+  if (providers.includes('codex')) skillRoots.push(path.join(home, '.agents', 'skills'));
+  if (providers.includes('claude-code')) skillRoots.push(path.join(home, '.claude', 'skills'));
+  for (const skillsRoot of skillRoots) {
+    for (const skillId of MANAGED_GLOBAL_SKILL_IDS) {
+      const skillDir = path.join(skillsRoot, skillId);
+      const skillPath = path.join(skillDir, 'SKILL.md');
+      if (!fs.existsSync(skillPath)) continue;
+      try {
+        const content = fs.readFileSync(skillPath, 'utf8');
+        if (!content.includes(MANAGED_GLOBAL_SKILL_MARKER)) continue;
+        fs.unlinkSync(skillPath);
+        if (fs.readdirSync(skillDir).length === 0) fs.rmdirSync(skillDir);
+        removed++;
+      } catch { /* best-effort */ }
+    }
   }
   return { removed };
 }
 
 function reconcileInstalledAgents(home, desiredFilenames) {
-  const manifest = readInstalledAgentsManifest();
-  if (!manifest) return { removed: 0 };
+  const manifest = readInstalledAgentsManifest(home);
   const desired = new Set(desiredFilenames);
+  const desiredByProvider = {
+    'claude-code': new Set([...desired].filter((name) => name.endsWith('.md'))),
+    codex: new Set([...desired].filter((name) => name.endsWith('.toml'))),
+  };
   let removed = 0;
-  for (const filename of manifest.filenames) {
-    if (desired.has(filename)) continue;
-    const providerDir = filename.endsWith('.toml')
-      ? path.join(home, '.codex', 'agents')
-      : path.join(home, '.claude', 'agents');
-    const filepath = path.join(providerDir, filename);
+  const legacyArtifacts = (manifest?.filenames || []).map((filename) => ({
+    provider: filename.endsWith('.toml') ? 'codex' : 'claude-code',
+    filename,
+    sha256: null,
+  }));
+  const manifestArtifacts = Array.isArray(manifest?.artifacts) ? manifest.artifacts : legacyArtifacts;
+  const manifestOwned = new Set(manifestArtifacts.map(({ provider, filename }) => `${provider}/${filename}`));
+  const versionedOwned = new Set(Array.isArray(manifest?.artifacts)
+    ? manifestArtifacts.map(({ provider, filename }) => `${provider}/${filename}`)
+    : []);
+  const managedMarker = 'SINAPSE-MANAGED:global-agent';
+  for (const { provider, filename, sha256 } of manifestArtifacts) {
+    if (!desiredByProvider[provider] || desiredByProvider[provider].has(filename)) continue;
+    const filepath = providerAgentPath(home, provider, filename);
     if (!fs.existsSync(filepath)) continue;
     try {
+      const content = fs.readFileSync(filepath, 'utf8');
+      const digestMatches = Boolean(sha256) && digestFile(filepath) === sha256;
+      const legacyMarkerMatches = !Array.isArray(manifest?.artifacts) && content.includes(managedMarker);
+      if (sha256 ? !digestMatches : !legacyMarkerMatches) continue;
       fs.unlinkSync(filepath);
       removed++;
     } catch { /* best-effort */ }
   }
-  return { removed };
+
+  for (const [provider, providerDir, extension] of [
+    ['claude-code', path.join(home, '.claude', 'agents'), '.md'],
+    ['codex', path.join(home, '.codex', 'agents'), '.toml'],
+    ['codex', path.join(home, '.codex', 'agents'), '.md'],
+  ]) {
+    if (!fs.existsSync(providerDir)) continue;
+    for (const filename of fs.readdirSync(providerDir).filter((name) => name.endsWith(extension))) {
+      if (desiredByProvider[provider].has(filename)) continue;
+      const filepath = path.join(providerDir, filename);
+      try {
+        const content = fs.readFileSync(filepath, 'utf8');
+        if (versionedOwned.has(`${provider}/${filename}`)) continue;
+        if (!manifestOwned.has(`${provider}/${filename}`) && !content.includes(managedMarker)) continue;
+        // A manifest entry alone is not proof of current ownership: users can
+        // replace a formerly managed file. Only marked artifacts reach this
+        // sweep; exact recorded content was handled by the digest path above.
+        if (!content.includes(managedMarker)) continue;
+        fs.unlinkSync(filepath);
+        removed++;
+      } catch { /* best-effort */ }
+    }
+  }
+
+  const legacyCommands = path.join(home, '.claude', 'commands', 'SINAPSE', 'agents');
+  let legacyCommandDirectoryRemoved = false;
+  let legacyCommandsRemoved = 0;
+  let legacyCommandsPreserved = 0;
+  if (fs.existsSync(legacyCommands)) {
+    for (const entry of fs.readdirSync(legacyCommands, { withFileTypes: true })) {
+      const filePath = path.join(legacyCommands, entry.name);
+      if (!entry.isFile()) {
+        legacyCommandsPreserved++;
+        continue;
+      }
+      try {
+        const content = fs.readFileSync(filePath);
+        const digest = crypto.createHash('sha256').update(content).digest('hex');
+        const knownHashes = legacyClaudeCommandHashes.files[entry.name] || [];
+        if (!knownHashes.includes(digest)) {
+          legacyCommandsPreserved++;
+          continue;
+        }
+        fs.unlinkSync(filePath);
+        legacyCommandsRemoved++;
+      } catch {
+        legacyCommandsPreserved++;
+      }
+    }
+    try {
+      if (fs.readdirSync(legacyCommands).length === 0) {
+        fs.rmdirSync(legacyCommands);
+        legacyCommandDirectoryRemoved = true;
+      }
+    } catch { /* best-effort */ }
+  }
+  return {
+    removed,
+    legacyCommandDirectoryRemoved,
+    legacyCommandsRemoved,
+    legacyCommandsPreserved,
+  };
+}
+
+function hasManagedInstalledAgents(home = HOME) {
+  const manifest = readInstalledAgentsManifest(home);
+  if (!manifest) {
+    for (const [providerDir, extensions] of [
+      [path.join(home, '.claude', 'agents'), new Set(['.md'])],
+      [path.join(home, '.codex', 'agents'), new Set(['.toml', '.md'])],
+    ]) {
+      try {
+        for (const filename of fs.readdirSync(providerDir)) {
+          if (!extensions.has(path.extname(filename))) continue;
+          try {
+            const content = fs.readFileSync(path.join(providerDir, filename), 'utf8');
+            if (content.includes('SINAPSE-MANAGED:global-agent')) return true;
+          } catch { /* unreadable or non-regular entries are not evidence */ }
+        }
+      } catch { /* missing or unreadable provider dir */ }
+    }
+    return false;
+  }
+  const versioned = Array.isArray(manifest?.artifacts);
+  const artifacts = versioned
+    ? manifest.artifacts
+    : (manifest?.filenames || []).map((filename) => ({
+      provider: filename.endsWith('.toml') ? 'codex' : 'claude-code',
+      filename,
+      sha256: null,
+    }));
+  return artifacts.some(({ provider, filename, sha256 }) => {
+    const filePath = providerAgentPath(home, provider, filename);
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      return sha256
+        ? digestFile(filePath) === sha256
+        : !versioned && content.includes('SINAPSE-MANAGED:global-agent');
+    } catch {
+      return false;
+    }
+  });
 }
 
 // Story 10.40 — Strip SINAPSE-owned keys from ~/.claude/settings.json without
@@ -312,6 +476,7 @@ module.exports = {
   removeOrqxAgentsFrom,
   removeManagedGlobalSkills,
   reconcileInstalledAgents,
+  hasManagedInstalledAgents,
   cleanClaudeSettingsJson,
   removeGitHooksConfig,
   INSTALLED_AGENTS_MANIFEST,

package/bin/commands/update.js

@@ -36,6 +36,7 @@ const {
 } = require('./uninstall');
 const { regenerateAgentCommands } = require('../lib/command-generator');
 const { deliverGlobalProviderAdapters, getGlobalCommandStagingDir } = require('../lib/global-provider-adapters');
+const { assertProviderAdapterParity } = require('../lib/provider-parity');
 const { execSync } = require('child_process');
 
 // Query the latest version published to npm. Returns null when npm is unreachable.
@@ -180,12 +181,14 @@ async function cmdUpdateGlobal() {
 
   // Phase 2b: Install global agents based on LLM choice
   const globalAdapters = deliverGlobalProviderAdapters({ llmChoice, home: HOME, commandsDir: commandStagingDir });
+  const activeAgentCount = assertProviderAdapterParity(llmChoice, globalAdapters, totalAgents);
   if (globalAdapters.claude.length) logger.always(`  ${GREEN}OK${NC} Claude Code global agents (${globalAdapters.claude.length})`);
   if (globalAdapters.codex.length) logger.always(`  ${GREEN}OK${NC} Codex global agents (${globalAdapters.codex.length} TOML, ${globalAdapters.skills.length} skills)`);
 
   const installedAgentFilenames = new Set([...globalAdapters.claude, ...globalAdapters.codex]);
   reconcileInstalledAgents(HOME, installedAgentFilenames);
-  if (llmChoice === 'claude-code') removeManagedGlobalSkills(HOME);
+  if (llmChoice === 'claude-code') removeManagedGlobalSkills(HOME, { providers: ['codex'] });
+  if (llmChoice === 'codex') removeManagedGlobalSkills(HOME, { providers: ['claude-code'] });
   const installedIdes = [];
   if (globalAdapters.claude.length) installedIdes.push('claude-code');
   if (globalAdapters.codex.length) installedIdes.push('codex');
@@ -203,7 +206,8 @@ async function cmdUpdateGlobal() {
   meta.updatedAt = new Date().toISOString();
   meta.version = VERSION;
   meta.squads = squads.length;
-  meta.commands = writtenAgents.size;
+  meta.agents = activeAgentCount;
+  meta.commands = activeAgentCount;
   meta.llm = llmChoice;
   fs.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
 
@@ -246,9 +250,9 @@ async function cmdUpdateGlobal() {
   logger.always(`${GREEN}  SINAPSE AI atualizado para v${VERSION}!${NC}`);
   logger.always(`${GREEN}══════════════════════════════════════════════════════════════${NC}`);
   logger.always('');
-  logger.always(`  ${BOLD}${squads.length} squads${NC} | ${BOLD}${totalAgents} agents${NC} | ${BOLD}${writtenAgents.size} command files${NC}`);
+  logger.always(`  ${BOLD}${squads.length} squads${NC} | ${BOLD}${activeAgentCount} agents${NC} | ${BOLD}${activeAgentCount} native adapters${NC}`);
   logger.always(`  ${startCmd}`);
   logger.always('');
 }
 
-module.exports = { cmdUpdateGlobal };
+module.exports = { cmdUpdateGlobal, assertProviderAdapterParity };

package/bin/lib/global-provider-adapters.js

@@ -3,6 +3,22 @@
 const fs = require('fs');
 const path = require('path');
 
+const NOFOLLOW_READ_FLAGS = fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW || 0);
+
+function readRegularFileNoFollowSync(filePath, encoding = null) {
+  let handle;
+  try {
+    handle = fs.openSync(filePath, NOFOLLOW_READ_FLAGS);
+    if (!fs.fstatSync(handle).isFile()) return null;
+    return fs.readFileSync(handle, encoding || undefined);
+  } catch (error) {
+    if (['ENOENT', 'ELOOP', 'EISDIR'].includes(error.code)) return null;
+    throw error;
+  } finally {
+    if (handle !== undefined) fs.closeSync(handle);
+  }
+}
+
 function parseAgentMarkdown(content, fallbackName) {
   const name = content.match(/^name:\s*([^\r\n]+)$/m)?.[1]?.trim() || fallbackName;
   const raw = content.match(/^description:\s*(.+)$/m)?.[1]?.trim() || `SINAPSE ${name} agent`;
@@ -18,6 +34,15 @@ function renderCodexToml(name, description, instructions) {
   ].join('\n');
 }
 
+function markGlobalAgent(markdown, fileName = '') {
+  let content = markdown;
+  if (fileName === 'snps-orqx.md') {
+    content = content.replace(/^name:\s*snps-orqx\s*$/m, 'name: sinapse-orqx');
+  }
+  if (content.includes('SINAPSE-MANAGED:global-agent')) return content;
+  return `${content.trimEnd()}\n\n<!-- SINAPSE-MANAGED:global-agent -->\n`;
+}
+
 function renderGlobalSkill(skillId) {
   const generic = skillId === 'sinapse-agent';
   return [
@@ -28,7 +53,7 @@ function renderGlobalSkill(skillId) {
     '<!-- SINAPSE-MANAGED:global-skill -->', '',
     generic ? '# SINAPSE Global Agent Activator' : '# SINAPSE Global Orchestrator', '',
     generic
-      ? 'Use the requested ID from `~/.codex/agents/<id>.toml`; reject unknown IDs without guessing.'
+      ? 'Resolve the requested ID through the native agent catalog of the active provider; reject unknown IDs without guessing.'
       : 'Resolve this alias to the `sinapse-orqx` custom agent and preserve its delegation-only authority.',
     'Canonical global persona and task sources live under `~/.sinapse/`.',
     'Use native Codex delegation and never start a nested CLI.', '',
@@ -88,25 +113,63 @@ function writeGlobalSkillIfManaged(skillPath, content) {
   }
 }
 
+function removeStaleManagedAgents(targetDir, expectedFiles, extension) {
+  if (!fs.existsSync(targetDir)) return [];
+  const expected = new Set(expectedFiles);
+  const removed = [];
+  for (const file of fs.readdirSync(targetDir).filter((name) => name.endsWith(extension))) {
+    if (expected.has(file)) continue;
+    const filePath = path.join(targetDir, file);
+    const content = readRegularFileNoFollowSync(filePath, 'utf8');
+    if (content === null) continue;
+    const explicitlyManaged = content.includes('SINAPSE-MANAGED:global-agent');
+    const legacyManaged = content.includes('ACTIVATION-NOTICE: This command activates an agent from sinapse.')
+      && /\.sinapse[\\/]sinapse[\\/]agents[\\/]/.test(content)
+      && content.includes('Load the squad manifest');
+    if (!explicitlyManaged && !legacyManaged) continue;
+    fs.unlinkSync(filePath);
+    removed.push(file);
+  }
+  return removed;
+}
+
 function deliverGlobalProviderAdapters({ llmChoice, home, commandsDir }) {
-  const commandFiles = fs.existsSync(commandsDir)
+  let commandFiles = fs.existsSync(commandsDir)
     ? fs.readdirSync(commandsDir).filter((file) => file.endsWith('.md')).sort()
     : [];
-  const written = { claude: [], codex: [], skills: [] };
+  if (commandFiles.includes('snps-orqx.md')) {
+    const aliasFiles = new Set(['sinapse.md', 'sinapse-orqx.md', 'snps.md']);
+    commandFiles = commandFiles.filter((file) => !aliasFiles.has(file));
+  }
+  const written = { claude: [], claudeSkills: [], codex: [], skills: [] };
 
   if (llmChoice === 'claude-code' || llmChoice === 'both') {
     const targetDir = path.join(home, '.claude', 'agents');
     fs.mkdirSync(targetDir, { recursive: true });
+    removeStaleManagedAgents(targetDir, commandFiles, '.md');
     for (const file of commandFiles) {
-      fs.copyFileSync(path.join(commandsDir, file), path.join(targetDir, file));
+      const markdown = markGlobalAgent(fs.readFileSync(path.join(commandsDir, file), 'utf8'), file);
+      fs.writeFileSync(path.join(targetDir, file), markdown, 'utf8');
       written.claude.push(file);
     }
+    const skillsRoot = path.join(home, '.claude', 'skills');
+    for (const skillId of ['snps', 'sinapse', 'snps-orqx', 'sinapse-orqx', 'sinapse-agent']) {
+      const skillPath = path.join(skillsRoot, skillId, 'SKILL.md');
+      if (writeGlobalSkillIfManaged(skillPath, renderGlobalSkill(skillId))) {
+        written.claudeSkills.push(skillId);
+      }
+    }
   }
   if (llmChoice === 'codex' || llmChoice === 'both') {
     const targetDir = path.join(home, '.codex', 'agents');
     fs.mkdirSync(targetDir, { recursive: true });
+    removeStaleManagedAgents(
+      targetDir,
+      commandFiles.map((file) => file.replace(/\.md$/, '.toml')),
+      '.toml',
+    );
     for (const file of commandFiles) {
-      const markdown = fs.readFileSync(path.join(commandsDir, file), 'utf8');
+      const markdown = markGlobalAgent(fs.readFileSync(path.join(commandsDir, file), 'utf8'), file);
       const id = file.replace(/\.md$/, '');
       const metadata = parseAgentMarkdown(markdown, id);
       const tomlName = `${id}.toml`;
@@ -116,7 +179,7 @@ function deliverGlobalProviderAdapters({ llmChoice, home, commandsDir }) {
       written.codex.push(tomlName);
     }
     const skillsRoot = path.join(home, '.agents', 'skills');
-    for (const skillId of ['snps', 'sinapse', 'snps-orqx', 'sinapse-agent']) {
+    for (const skillId of ['snps', 'sinapse', 'snps-orqx', 'sinapse-orqx', 'sinapse-agent']) {
       const skillDir = path.join(skillsRoot, skillId);
       const skillPath = path.join(skillDir, 'SKILL.md');
       if (writeGlobalSkillIfManaged(skillPath, renderGlobalSkill(skillId))) {
@@ -128,9 +191,9 @@ function deliverGlobalProviderAdapters({ llmChoice, home, commandsDir }) {
 }
 
 function getGlobalCommandStagingDir({ llmChoice, sinapseHome, claudeCommandsDir }) {
-  return llmChoice === 'codex'
-    ? path.join(sinapseHome, '.generated', 'agents')
-    : claudeCommandsDir;
+  void llmChoice;
+  void claudeCommandsDir;
+  return path.join(sinapseHome, '.generated', 'agents');
 }
 
-module.exports = { parseAgentMarkdown, renderCodexToml, renderGlobalSkill, writeGlobalSkillIfManaged, deliverGlobalProviderAdapters, getGlobalCommandStagingDir };
+module.exports = { parseAgentMarkdown, renderCodexToml, markGlobalAgent, renderGlobalSkill, writeGlobalSkillIfManaged, removeStaleManagedAgents, deliverGlobalProviderAdapters, getGlobalCommandStagingDir };

package/bin/lib/provider-parity.js

@@ -0,0 +1,22 @@
+'use strict';
+
+function assertProviderAdapterParity(llmChoice, adapters, canonicalCount) {
+  if (!['claude-code', 'codex', 'both'].includes(llmChoice)) {
+    throw new Error(`Invalid LLM choice for provider parity: ${llmChoice}`);
+  }
+  const providerCounts = [];
+  if (llmChoice === 'claude-code' || llmChoice === 'both') {
+    providerCounts.push(['Claude Code', adapters.claude.length]);
+  }
+  if (llmChoice === 'codex' || llmChoice === 'both') {
+    providerCounts.push(['Codex', adapters.codex.length]);
+  }
+  const divergent = providerCounts.filter(([, count]) => count !== canonicalCount);
+  if (divergent.length) {
+    const details = divergent.map(([provider, count]) => `${provider}: ${count}/${canonicalCount}`).join(', ');
+    throw new Error(`Provider adapter parity failed (${details})`);
+  }
+  return canonicalCount;
+}
+
+module.exports = { assertProviderAdapterParity };

package/bin/postinstall.js

@@ -17,7 +17,7 @@
  *
  * Execution order (see Story A.1 AC 4):
  *   1. env guard (SINAPSE_SKIP_POSTINSTALL / CI)
- *   2. npm run sync:ide -- --ide claude-code
+ *   2. npm run sync:providers
  *   3. mkdir -p .sinapse/handoffs
  *   4. mkdir -p .sinapse/scratchpad
  *   5. sinapse doctor --quiet (exit code 2 = abort, 0/1 = OK)
@@ -30,7 +30,7 @@
  *
  * Exit codes:
  *   0  success OR non-critical warning (framework operational)
- *   2  critical failure (sync:ide failed, or doctor exit >= 2)
+ *   2  critical failure (provider sync failed, or doctor exit >= 2)
  *
  * Note: exit 1 is NOT used. npm treats any non-zero postinstall exit as
  * `command failed`, which scares users when the install is actually operational.
@@ -273,7 +273,7 @@ function run(command, args, opts = {}) {
  * Detect if we're running inside a global npm install.
  * Global installs land in /usr/local/lib/node_modules (Mac/Linux) or
  * %APPDATA%\npm\node_modules (Windows). Agent sync to those paths is pointless
- * — sync:ide must run inside a real project (per-project install).
+ * — sync:providers must run inside a real project (per-project install).
  */
 function isGlobalInstall() {
   if (process.env.npm_config_global === 'true') return true;
@@ -287,8 +287,8 @@ function isGlobalInstall() {
 }
 
 /**
- * Step 1: sync:ide --ide claude-code.
- * Copies agent definitions to .claude/commands/SINAPSE/agents/ so Claude Code can resolve @developer, etc.
+ * Step 1: synchronize native Claude and Codex provider adapters.
+ * Writes Claude agents to .claude/agents and Codex skills to .agents/skills.
  *
  * Skipped on global installs (no project to sync to). EACCES is treated as a
  * non-critical warning — the user can run `sinapse install` inside their project
@@ -296,17 +296,17 @@ function isGlobalInstall() {
  */
 function stepSyncIde() {
   if (isGlobalInstall()) {
-    verboseLog(`${c.dim}sync:ide pulado (install global — rode 'sinapse install' no seu projeto)${c.reset}`);
+    verboseLog(`${c.dim}sync:providers pulado (install global — rode 'sinapse install' no seu projeto)${c.reset}`);
     return { ok: true, critical: false, skipped: true };
   }
-  verboseLog(`${c.cyan}›${c.reset} Sincronizando agents para Claude Code...`);
-  const result = run('npm', ['run', 'sync:ide', '--silent', '--', '--ide', 'claude-code', '--quiet']);
+  verboseLog(`${c.cyan}›${c.reset} Sincronizando adapters para Claude Code e Codex...`);
+  const result = run('npm', ['run', 'sync:providers', '--silent']);
   if (result.error) {
     if (result.error.code === 'EACCES' || result.error.code === 'EPERM') {
       warn("Sem permissão pra sincronizar agents. Rode 'sinapse install' dentro do seu projeto.");
       return { ok: false, critical: false };
     }
-    warn(`sync:ide falhou ao iniciar: ${result.error.message} — rode 'sinapse install' no projeto pra completar.`);
+    warn(`sync:providers falhou ao iniciar: ${result.error.message} — rode 'sinapse install' no projeto pra completar.`);
     return { ok: false, critical: false };
   }
   if (result.status !== 0) {
@@ -315,7 +315,7 @@ function stepSyncIde() {
       warn("Sem permissão pra sincronizar agents (npm global sem write). Rode 'sinapse install' no seu projeto.");
       return { ok: false, critical: false };
     }
-    warn(`sync:ide saiu com código ${result.status} — rode 'sinapse install' no projeto pra completar.`);
+    warn(`sync:providers saiu com código ${result.status} — rode 'sinapse install' no projeto pra completar.`);
     return { ok: false, critical: false };
   }
   verboseLog(`${c.green}✓${c.reset} Agents sincronizados`);
@@ -380,7 +380,7 @@ function stepGenerateSynapse() {
     return { ok: true, critical: false, skipped: true };
   }
   // Run in-process (not a subprocess) — faster, and keeps the shared run()
-  // sequence (sync:ide → doctor) intact for callers/tests. The wrapper's
+  // sequence (sync:providers → doctor) intact for callers/tests. The wrapper's
   // generate() is tolerant and never throws; preserve our own exit code since
   // the underlying generator sets process.exitCode=1 on a miss.
   const savedExit = process.exitCode;