multimodel-dev-os 3.1.0 → 3.5.0

package/scripts/verify.js

@@ -189,6 +189,24 @@ checkFile('scripts/pack-template.sh');
 checkFile('scripts/prepublish-guard.js');
 checkFile('bin/multimodel-dev-os.js');
 
+// --- Modular Source Files ---
+console.log('\nModular Source Files:');
+checkFile('src/cli/main.js');
+checkFile('src/cli/args.js');
+checkFile('src/cli/help.js');
+checkFile('src/core/yaml.js');
+checkFile('src/core/hashes.js');
+checkFile('src/core/policy.js');
+checkFile('src/core/security.js');
+checkFile('src/core/globals.js');
+checkFile('src/registry/validation.js');
+checkFile('src/registry/sources.js');
+checkFile('src/registry/provenance.js');
+checkFile('src/registry/signing.js');
+checkFile('src/registry/trust-store.js');
+checkFile('src/catalog/loader.js');
+checkFile('src/plugin/manifest.js');
+
 // --- GitHub Integration ---
 console.log('\nGitHub Workflows:');
 checkFile('.github/workflows/verify.yml');
@@ -231,6 +249,8 @@ checkFile('docs/registry-contribution.md');
 checkFile('docs/v2-migration.md');
 checkFile('docs/v2-release-checklist.md');
 checkFile('docs/package-safety.md');
+checkFile('docs/registry-signing.md');
+checkFile('docs/registry-trust-store.md');
 
 // --- v2.1.0 Intelligence Layer Documentation ---
 console.log('\nIntelligence Layer Documentation:');
@@ -265,6 +285,7 @@ console.log('\nJSON Schemas:');
 checkFile('.ai/schema/config.schema.json');
 checkFile('.ai/schema/template.schema.json');
 checkFile('.ai/schema/adapter.schema.json');
+checkFile('.ai/schema/trusted-keys.schema.json');
 
 // --- v2.1.0 Intelligence Layer (Schemas, Policies, Registries) ---
 console.log('\nIntelligence Layer Schemas:');
@@ -287,8 +308,25 @@ console.log('\nIntelligence Layer Registries:');
 checkFile('.ai/registries/capabilities.yaml');
 checkFile('.ai/registries/tools.yaml');
 checkFile('.ai/registries/workflows.yaml');
-
-// --- Test Blueprints ---
+checkFile('.ai/registries/trusted-keys.yaml');
+
+// --- Unit Tests ---
+console.log('\nUnit Tests:');
+checkFile('tests/unit/yaml.test.js');
+checkFile('tests/unit/registry-url-validation.test.js');
+checkFile('tests/unit/registry-policy.test.js');
+checkFile('tests/unit/registry-provenance.test.js');
+checkFile('tests/unit/registry-signing.test.js');
+checkFile('tests/unit/registry-public-signing.test.js');
+checkFile('tests/unit/registry-trust-store.test.js');
+checkFile('tests/unit/registry-signature-policy.test.js');
+checkFile('tests/unit/path-safety.test.js');
+checkFile('tests/unit/plugin-manifest.test.js');
+checkFile('tests/unit/catalog-loader.test.js');
+checkFile('tests/unit/build-output.test.js');
+checkFile('tests/unit/prepublish-guard.test.js');
+
+// --- Test Manuals & Fixtures ---
 console.log('\nTest Manuals:');
 checkFile('tests/README.md');
 checkFile('tests/fixtures/README.md');
@@ -549,7 +587,7 @@ try {
     }
   }
 
-  // Test 2: Allows version 3.1.0 with MMDO_ALLOW_PUBLISH=true
+  // Test 2: Allows version 3.5.0 with MMDO_ALLOW_PUBLISH=true
   try {
     const output = execSync('node scripts/prepublish-guard.js', { 
       cwd: projectRoot, 
@@ -557,7 +595,7 @@ try {
       encoding: 'utf8' 
     });
     if (output.includes('Prepublish guard passed')) {
-      console.log(`  ${GREEN}✓${NC} prepublish guard allows version 3.1.0 when MMDO_ALLOW_PUBLISH=true`);
+      console.log(`  ${GREEN}✓${NC} prepublish guard allows version 3.5.0 when MMDO_ALLOW_PUBLISH=true`);
       pass++;
     } else {
       console.error(`  ${RED}✗${NC} prepublish guard passed but stdout missing success indicator`);
@@ -565,7 +603,7 @@ try {
     }
   } catch (err) {
     const errText = err.stderr ? err.stderr.toString() : '';
-    console.error(`  ${RED}✗${NC} prepublish guard blocked version 3.1.0: ${errText || err.message}`);
+    console.error(`  ${RED}✗${NC} prepublish guard blocked version 3.5.0: ${errText || err.message}`);
     fail++;
   }
 
@@ -579,12 +617,12 @@ try {
     pass++;
   }
 
-  // Test 4: Package.json version is exactly 3.1.0
-  if (expectedVersion === '3.1.0') {
-    console.log(`  ${GREEN}✓${NC} package.json version is exactly 3.1.0`);
+  // Test 4: Package.json version is exactly 3.5.0
+  if (expectedVersion === '3.5.0') {
+    console.log(`  ${GREEN}✓${NC} package.json version is exactly 3.5.0`);
     pass++;
   } else {
-    console.error(`  ${RED}✗${NC} package.json version is not 3.1.0 (found ${expectedVersion})`);
+    console.error(`  ${RED}✗${NC} package.json version is not 3.5.0 (found ${expectedVersion})`);
     fail++;
   }
 } catch (e) {
@@ -592,6 +630,52 @@ try {
   fail++;
 }
 
+// --- Post-build Generated CLI Checks ---
+console.log('\nPost-build Generated CLI Checks:');
+try {
+  // 0. Check build freshness
+  try {
+    execSync('node scripts/check-build-fresh.js', { cwd: projectRoot, stdio: 'ignore' });
+    console.log(`  ${GREEN}✓${NC} generated bin matches current source layout`);
+    pass++;
+  } catch (err) {
+    console.error(`  ${RED}✗${NC} generated bin is stale! Run 'npm run build' and commit bin/multimodel-dev-os.js`);
+    fail++;
+  }
+
+  const buildPath = join(projectRoot, 'bin', 'multimodel-dev-os.js');
+  const binContent = readFileSync(buildPath, 'utf8');
+  
+  const totalShebangs = (binContent.match(/#!/g) || []).length;
+  if (binContent.startsWith('#!/usr/bin/env node') && totalShebangs === 1) {
+    console.log(`  ${GREEN}✓${NC} generated bin has exactly one shebang at the top`);
+    pass++;
+  } else {
+    console.error(`  ${RED}✗${NC} generated bin has invalid shebang layout (count: ${totalShebangs})`);
+    fail++;
+  }
+  
+  if (binContent.includes('// Generated from src/. Do not edit directly.')) {
+    console.log(`  ${GREEN}✓${NC} generated bin has warning header`);
+    pass++;
+  } else {
+    console.error(`  ${RED}✗${NC} generated bin is missing the warning header`);
+    fail++;
+  }
+  
+  const hasUnsafeSync = binContent.includes("mod.get('${targetUrl}'") || (binContent.includes('execSync(`node -e "') && binContent.includes('${targetUrl}'));
+  if (!hasUnsafeSync && binContent.includes('execFileSync(process.execPath')) {
+    console.log(`  ${GREEN}✓${NC} generated bin is free of unsafe URL interpolation and uses execFileSync`);
+    pass++;
+  } else {
+    console.error(`  ${RED}✗${NC} generated bin fails safety scan (unsafe interpolation found)`);
+    fail++;
+  }
+} catch (e) {
+  console.error(`  ${RED}✗${NC} post-build generated CLI checks failed: ${e.message}`);
+  fail++;
+}
+
 // --- v2.8.0 / v2.8.1 Dashboard & Plugin Tests ---
 console.log('\nRunning TUI Dashboard & Plugin Pre-Flight Tests...');
 
@@ -921,22 +1005,77 @@ try {
   fail++;
 }
 
-// Verify npm pack dry-run shows current version dynamically
+// Verify npm pack dry-run shows current version dynamically and has clean hygiene
 try {
-  const packOutput = execSync('npm pack --dry-run', { cwd: projectRoot, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
-  if (packOutput.includes(`multimodel-dev-os@${expectedVersion}`) || packOutput.includes(`multimodel-dev-os-${expectedVersion}.tgz`) || packOutput.includes(`version: ${expectedVersion}`)) {
+  const packOutput = execSync('npm pack --dry-run 2>&1', { cwd: projectRoot, encoding: 'utf8' });
+  const combinedOutput = packOutput;
+  
+  const hasVersion = combinedOutput.includes(`multimodel-dev-os@${expectedVersion}`) || combinedOutput.includes(`multimodel-dev-os-${expectedVersion}.tgz`) || combinedOutput.includes(`version: ${expectedVersion}`);
+  if (hasVersion) {
     console.log(`  ${GREEN}✓${NC} npm pack --dry-run reports version ${expectedVersion}`);
     pass++;
   } else {
-    console.error(`  ${RED}✗${NC} npm pack --dry-run did not report ${expectedVersion} in stdout`);
+    console.error(`  ${RED}✗${NC} npm pack --dry-run did not report ${expectedVersion} in output`);
+    fail++;
+  }
+
+  // Hygiene checks
+  const lines = combinedOutput.split('\n');
+  const files = lines
+    .filter(l => l.includes('npm notice') && !l.includes('Tarball Details') && !l.includes('Tarball Filename') && !l.includes('package size:') && !l.includes('unpacked size:') && !l.includes('shasum:') && !l.includes('integrity:') && !l.includes('total files:'))
+    .map(l => {
+      const match = l.match(/npm notice\s+\d+(\.\d+)?[a-zA-Z]+\s+(.+)$/);
+      return match ? match[2].trim() : '';
+    })
+    .filter(f => f !== '');
+
+  const hasSrc = files.some(f => f.startsWith('src/'));
+  const hasTests = files.some(f => f.startsWith('tests/'));
+  
+  if (hasSrc && hasTests) {
+    console.log(`  ${GREEN}✓${NC} npm pack includes 'src/' and 'tests/' directories`);
+    pass++;
+  } else {
+    console.error(`  ${RED}✗${NC} npm pack is missing 'src/' or 'tests/' directory`);
+    fail++;
+  }
+
+  const hasBlacklisted = files.some(f => f.includes('.npmrc') || f.includes('.env') || f.includes('node_modules') || f.endsWith('.tgz') || f.includes('coverage/'));
+  if (!hasBlacklisted) {
+    console.log(`  ${GREEN}✓${NC} npm pack excludes sensitive and temporary files (.npmrc, .env, node_modules, .tgz, coverage)`);
+    pass++;
+  } else {
+    console.error(`  ${RED}✗${NC} npm pack contains blacklisted files!`);
     fail++;
   }
 } catch (e) {
   const stdErrOut = e.stderr ? e.stderr.toString() : '';
   const stdOutOut = e.stdout ? e.stdout.toString() : '';
-  if (stdErrOut.includes(`multimodel-dev-os@${expectedVersion}`) || stdErrOut.includes(`multimodel-dev-os-${expectedVersion}.tgz`) || stdOutOut.includes(`multimodel-dev-os-${expectedVersion}.tgz`)) {
+  const combined = stdErrOut + '\n' + stdOutOut;
+  
+  const hasVersion = combined.includes(`multimodel-dev-os@${expectedVersion}`) || combined.includes(`multimodel-dev-os-${expectedVersion}.tgz`) || combined.includes(`version: ${expectedVersion}`);
+  if (hasVersion) {
     console.log(`  ${GREEN}✓${NC} npm pack --dry-run reports version ${expectedVersion}`);
     pass++;
+    
+    const hasSrc = combined.includes('src/') || combined.includes('src\\');
+    const hasTests = combined.includes('tests/') || combined.includes('tests\\');
+    if (hasSrc && hasTests) {
+      console.log(`  ${GREEN}✓${NC} npm pack includes 'src/' and 'tests/' directories`);
+      pass++;
+    } else {
+      console.error(`  ${RED}✗${NC} npm pack is missing 'src/' or 'tests/' directory`);
+      fail++;
+    }
+
+    const hasBlacklisted = combined.includes('.npmrc') || combined.includes('.env') || combined.includes('node_modules') || combined.includes('.tgz') || combined.includes('coverage/');
+    if (!hasBlacklisted) {
+      console.log(`  ${GREEN}✓${NC} npm pack excludes sensitive and temporary files`);
+      pass++;
+    } else {
+      console.error(`  ${RED}✗${NC} npm pack contains blacklisted files!`);
+      fail++;
+    }
   } else {
     console.error(`  ${RED}✗${NC} npm pack --dry-run failed or did not report ${expectedVersion}: ${e.message}`);
     fail++;
@@ -1271,6 +1410,180 @@ const checkExamplesHygiene = (dir) => {
 };
 checkExamplesHygiene(join(projectRoot, 'examples'));
 
+// --- Registry Signing & Provenance Checks ---
+console.log('\nRegistry Signing & Provenance Checks:');
+
+// Check .gitignore contains registry-signing-key
+try {
+  const gitignoreContent = readFileSync(join(projectRoot, '.gitignore'), 'utf8');
+  if (gitignoreContent.includes('registry-signing-key')) {
+    console.log(`  ${GREEN}✓${NC} .gitignore includes registry-signing-key pattern`);
+    pass++;
+  } else {
+    console.error(`  ${RED}✗${NC} .gitignore is missing the registry-signing-key entry (secrets must be gitignored)`);
+    fail++;
+  }
+} catch (e) {
+  console.error(`  ${RED}✗${NC} Failed to read .gitignore: ${e.message}`);
+  fail++;
+}
+
+// Check provenance.js exports the expected API surface
+try {
+  const provenanceSrc = readFileSync(join(projectRoot, 'src', 'registry', 'provenance.js'), 'utf8');
+  const hasLoadLockfile = provenanceSrc.includes('export function loadRegistryLockfile');
+  const hasSaveLockfile = provenanceSrc.includes('export function saveRegistryLockfile');
+  const hasUpdateEntry = provenanceSrc.includes('export function updateLockfileEntry');
+  const hasGetPath = provenanceSrc.includes('export function getLockfilePath');
+  if (hasLoadLockfile && hasSaveLockfile && hasUpdateEntry && hasGetPath) {
+    console.log(`  ${GREEN}✓${NC} src/registry/provenance.js exports complete API (load/save/update/getPath)`);
+    pass++;
+  } else {
+    console.error(`  ${RED}✗${NC} src/registry/provenance.js is missing expected exports`);
+    fail++;
+  }
+} catch (e) {
+  console.error(`  ${RED}✗${NC} Failed to check provenance.js: ${e.message}`);
+  fail++;
+}
+
+// Check signing.js exports the expected API surface
+try {
+  const signingSrc = readFileSync(join(projectRoot, 'src', 'registry', 'signing.js'), 'utf8');
+  const hasLoadKey = signingSrc.includes('export function loadSigningKey');
+  const hasGenKey = signingSrc.includes('export function generateSigningKey');
+  const hasSaveKey = signingSrc.includes('export function saveSigningKey');
+  const hasSign = signingSrc.includes('export function signPayload');
+  const hasVerify = signingSrc.includes('export function verifySignature');
+  const hasTimingSafe = signingSrc.includes('timingSafeEqual');
+  const hasEdKeygen = signingSrc.includes('export function generateEd25519KeyPair');
+  const hasEdSign = signingSrc.includes('export function signEd25519Payload');
+  const hasEdVerify = signingSrc.includes('export function verifyEd25519Payload');
+  const hasSigBlockVerify = signingSrc.includes('export function verifySignatureBlock');
+  
+  if (hasLoadKey && hasGenKey && hasSaveKey && hasSign && hasVerify && hasTimingSafe && hasEdKeygen && hasEdSign && hasEdVerify && hasSigBlockVerify) {
+    console.log(`  ${GREEN}✓${NC} src/registry/signing.js exports complete API (HMAC + Ed25519)`);
+    pass++;
+  } else {
+    console.error(`  ${RED}✗${NC} src/registry/signing.js is missing expected exports`);
+    fail++;
+  }
+} catch (e) {
+  console.error(`  ${RED}✗${NC} Failed to check signing.js: ${e.message}`);
+  fail++;
+}
+
+// Check trust-store.js exports expected API surface
+try {
+  const trustSrc = readFileSync(join(projectRoot, 'src', 'registry', 'trust-store.js'), 'utf8');
+  const hasLoadTrustedKeys = trustSrc.includes('export function loadTrustedKeys');
+  if (hasLoadTrustedKeys) {
+    console.log(`  ${GREEN}✓${NC} src/registry/trust-store.js exports loadTrustedKeys`);
+    pass++;
+  } else {
+    console.error(`  ${RED}✗${NC} src/registry/trust-store.js is missing expected exports`);
+    fail++;
+  }
+} catch (e) {
+  console.error(`  ${RED}✗${NC} Failed to check trust-store.js: ${e.message}`);
+  fail++;
+}
+
+// Check main.js imports the new modules
+try {
+  const mainSrc = readFileSync(join(projectRoot, 'src', 'cli', 'main.js'), 'utf8');
+  const hasProvenanceImport = mainSrc.includes("from '../registry/provenance.js'");
+  const hasSigningImport = mainSrc.includes("from '../registry/signing.js'");
+  const hasTrustImport = mainSrc.includes("from '../registry/trust-store.js'");
+  const hasKeygenHandler = mainSrc.includes('handleRegistryKeygen');
+  const hasLockHandler = mainSrc.includes('handleRegistryLock');
+  const hasTrustHandler = mainSrc.includes('handleRegistryTrustList');
+  if (hasProvenanceImport && hasSigningImport && hasTrustImport && hasKeygenHandler && hasLockHandler && hasTrustHandler) {
+    console.log(`  ${GREEN}✓${NC} src/cli/main.js imports provenance/signing/trust-store and registers handlers`);
+    pass++;
+  } else {
+    console.error(`  ${RED}✗${NC} src/cli/main.js is missing required imports or handlers`);
+    fail++;
+  }
+} catch (e) {
+  console.error(`  ${RED}✗${NC} Failed to check main.js integrations: ${e.message}`);
+  fail++;
+}
+
+// Check that policy.js has the new fields in defaults
+try {
+  const policySrc = readFileSync(join(projectRoot, 'src', 'core', 'policy.js'), 'utf8');
+  const hasLockfileField = policySrc.includes('require_lockfile_on_verify');
+  const hasUnsignedLocal = policySrc.includes('allow_unsigned_local');
+  const hasUnsignedBundled = policySrc.includes('allow_unsigned_bundled');
+  const hasUnsignedRemote = policySrc.includes('allow_unsigned_remote');
+  const hasTrustedKeysFile = policySrc.includes('trusted_keys_file');
+  const hasAllowedAlgs = policySrc.includes('allowed_signature_algorithms');
+  const hasRequireTrustedPublisher = policySrc.includes('require_trusted_publisher');
+  const hasProvenanceRequired = policySrc.includes('provenance_required');
+  
+  if (hasLockfileField && hasUnsignedLocal && hasUnsignedBundled && hasUnsignedRemote && hasTrustedKeysFile && hasAllowedAlgs && hasRequireTrustedPublisher && hasProvenanceRequired) {
+    console.log(`  ${GREEN}✓${NC} src/core/policy.js includes all Sprint 2 policy defaults`);
+    pass++;
+  } else {
+    console.error(`  ${RED}✗${NC} src/core/policy.js is missing required policy defaults`);
+    fail++;
+  }
+} catch (e) {
+  console.error(`  ${RED}✗${NC} Failed to check policy.js: ${e.message}`);
+  fail++;
+}
+
+// --- v3.5.0 Sprint 3 E2E Fixtures & Threat Model Checks ---
+console.log('\nSprint 3 Signed Registry E2E & Readiness Checks:');
+checkFile('src/registry/verdict.js');
+checkFile('tests/unit/registry-e2e-signature-fixtures.test.js');
+checkFile('docs/security-threat-model.md');
+checkFile('docs/v3.5.0-readiness.md');
+
+// Verify that the trusted-keys.yaml in the E2E fixtures directory exists
+const e2eKeysPath = 'tests/fixtures/signed-registries/trusted-keys.yaml';
+if (checkFile(e2eKeysPath)) {
+  const e2eKeysContent = readFileSync(join(projectRoot, e2eKeysPath), 'utf8');
+  if (e2eKeysContent.includes('test-key-valid') && e2eKeysContent.includes('test-key-revoked')) {
+    console.log(`  ${GREEN}✓${NC} ${e2eKeysPath} is populated with test fixtures and marked for testing`);
+    pass++;
+  } else {
+    console.error(`  ${RED}✗${NC} ${e2eKeysPath} is missing expected test keys`);
+    fail++;
+  }
+}
+
+// Verify that the threat model document has a standard threat modeling structure
+try {
+  const threatModelContent = readFileSync(join(projectRoot, 'docs/security-threat-model.md'), 'utf8');
+  if (threatModelContent.includes('Threat Model') && (threatModelContent.includes('STRIDE') || threatModelContent.includes('stride'))) {
+    console.log(`  ${GREEN}✓${NC} docs/security-threat-model.md structure verified`);
+    pass++;
+  } else {
+    console.error(`  ${RED}✗${NC} docs/security-threat-model.md is missing standard threat modeling structure`);
+    fail++;
+  }
+} catch (e) {
+  console.error(`  ${RED}✗${NC} Failed to verify threat model document: ${e.message}`);
+  fail++;
+}
+
+// Verify that no private keys are committed in main directories (like .ai/)
+try {
+  const rootKeyFile = '.ai/registry-signing-key';
+  if (existsSync(join(projectRoot, rootKeyFile))) {
+    console.error(`  ${RED}✗${NC} Private signing key ${rootKeyFile} should not be committed!`);
+    fail++;
+  } else {
+    console.log(`  ${GREEN}✓${NC} No private registry-signing-key found in codebase root`);
+    pass++;
+  }
+} catch (e) {
+  console.error(`  ${RED}✗${NC} Failed to check private key existence: ${e.message}`);
+  fail++;
+}
+
 console.log('\n=====================================================');
 const total = pass + fail + warn;
 console.log(`  Pass: ${GREEN}${pass}${NC}  Fail: ${RED}${fail}${NC}  Warn: ${YELLOW}${warn}${NC}  Total: ${total}`);

package/scripts/verify.sh

@@ -192,6 +192,8 @@ check_file "docs/cli-roadmap.md"
 check_file "docs/faq.md"
 check_file "docs/testing.md"
 check_file "docs/npm-publishing.md"
+check_file "docs/release-policy.md"
+check_file "docs/package-safety.md"
 
 # --- CLI & Packaging Pre-Flight Tests ---
 echo ""
@@ -235,6 +237,14 @@ else
   PASS=$((PASS + 1))
 fi
 
+if ! npm run check:build >/dev/null; then
+  echo -e "  ${RED}✗${NC} Generated CLI is stale. Run npm run build."
+  FAIL=$((FAIL + 1))
+else
+  echo -e "  ${GREEN}✓${NC} Generated CLI is fresh"
+  PASS=$((PASS + 1))
+fi
+
 if ! node bin/multimodel-dev-os.js init --dry-run --force >/dev/null; then
   echo -e "  ${RED}✗${NC} node bin/multimodel-dev-os.js init --dry-run failed"
   FAIL=$((FAIL + 1))

package/src/catalog/loader.js

@@ -0,0 +1,117 @@
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { sourceRoot } from '../core/globals.js';
+import { parseYaml } from '../core/yaml.js';
+import { loadRegistrySources } from '../registry/sources.js';
+import { loadRegistryPolicy } from '../core/policy.js';
+import { validateRegistryUrl } from '../registry/validation.js';
+
+export function loadCatalog(options = {}) {
+  let catalog;
+  if (options.allSources) {
+    catalog = loadAllCatalogs(options);
+  } else if (options.source) {
+    catalog = loadCatalogFromSource(options.source, options);
+  } else {
+    const path = join(sourceRoot, '.ai', 'plugins', 'catalog.yaml');
+    try {
+      if (existsSync(path)) {
+        const reg = parseYaml(readFileSync(path, 'utf8'));
+        catalog = reg.catalog || { plugins: [] };
+      } else {
+        catalog = { plugins: [] };
+      }
+    } catch (e) {
+      catalog = { plugins: [] };
+    }
+    (catalog.plugins || []).forEach(p => { p._source = 'bundled'; });
+  }
+  return catalog;
+}
+
+export function loadCatalogFromSource(source, options = {}) {
+  if (!source || source === 'bundled') {
+    return loadCatalog();
+  } else if (source === 'local') {
+    const localPath = join(options.target || process.cwd(), '.ai', 'plugins', 'catalog.yaml');
+    try {
+      if (existsSync(localPath)) {
+        const reg = parseYaml(readFileSync(localPath, 'utf8'));
+        const catalog = reg.catalog || { plugins: [] };
+        (catalog.plugins || []).forEach(p => { p._source = 'local'; });
+        return catalog;
+      }
+    } catch (e) {}
+    return { plugins: [] };
+  } else if (source.startsWith('remote:')) {
+    const regName = source.substring(7);
+    const sources = loadRegistrySources();
+    const src = sources.find(s => s.name === regName);
+    if (src && src.type !== 'local') {
+      const policy = loadRegistryPolicy(options.target || process.cwd());
+      try {
+        validateRegistryUrl(src.url, policy);
+      } catch (err) {
+        console.error(`\x1b[31mError: Registry '${regName}' has an invalid URL: ${err.message}\x1b[0m`);
+        process.exit(1);
+      }
+    }
+    const cachePath = join(sourceRoot, '.ai', 'registry-cache', regName, 'catalog.yaml');
+    try {
+      if (existsSync(cachePath)) {
+        const reg = parseYaml(readFileSync(cachePath, 'utf8'));
+        const catalog = reg.catalog || { plugins: [] };
+        (catalog.plugins || []).forEach(p => { p._source = `remote:${regName}`; });
+        return catalog;
+      }
+    } catch (e) {}
+    return { plugins: [] };
+  }
+  return { plugins: [] };
+}
+
+export function loadAllCatalogs(options = {}) {
+  const sources = loadRegistrySources();
+  const policy = loadRegistryPolicy(options.target || process.cwd());
+  const allPlugins = [];
+
+  // Always include bundled
+  const bundled = loadCatalog();
+  (bundled.plugins || []).forEach(p => { p._source = 'bundled'; allPlugins.push(p); });
+
+  // Include local workspace catalog if different from bundled
+  const localPath = join(options.target || process.cwd(), '.ai', 'plugins', 'catalog.yaml');
+  if (existsSync(localPath)) {
+    try {
+      const localCat = parseYaml(readFileSync(localPath, 'utf8'));
+      const localPlugins = (localCat.catalog || {}).plugins || [];
+      localPlugins.forEach(p => {
+        if (!allPlugins.some(bp => bp.slug === p.slug)) {
+          p._source = 'local';
+          allPlugins.push(p);
+        }
+      });
+    } catch (e) {}
+  }
+
+  // Include remote caches if policy allows
+  if (policy.allow_remote_registries) {
+    sources.filter(s => s.type !== 'local' && s.enabled).forEach(s => {
+      const cachePath = join(sourceRoot, '.ai', 'registry-cache', s.name, 'catalog.yaml');
+      if (existsSync(cachePath)) {
+        try {
+          const remoteCat = parseYaml(readFileSync(cachePath, 'utf8'));
+          const remotePlugins = (remoteCat.catalog || {}).plugins || [];
+          remotePlugins.forEach(p => {
+            if (!allPlugins.some(bp => bp.slug === p.slug)) {
+              p._source = `remote:${s.name}`;
+              allPlugins.push(p);
+            }
+          });
+        } catch (e) {}
+      }
+    });
+  }
+
+  return { plugins: allPlugins };
+}

package/src/cli/args.js

@@ -0,0 +1,118 @@
+import { resolve } from 'path';
+
+export function parseArgs(args) {
+  const params = {
+    command: null,
+    target: process.cwd(),
+    template: 'general-app',
+    adapters: [],
+    caveman: false,
+    dryRun: false,
+    force: false,
+    help: false,
+    tokens: false,
+    modelPreset: null,
+    agent: null,
+    stack: null,
+    mobile: null,
+    aiApp: null,
+    json: false,
+    threshold: null,
+    registry: null,
+    allRegistries: false,
+    release: false,
+    type: 'unknown',
+    tags: '',
+    files: '',
+    title: null,
+    approved: false,
+    intelligence: false,
+    onboarding: false,
+    listActions: false,
+    category: null,
+    source: null,
+    allSources: false
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--target' || arg === '-t') {
+      params.target = resolve(args[++i]);
+    } else if (arg === '--template') {
+      params.template = args[++i];
+    } else if (arg === '--adapter' || arg === '-a') {
+      params.adapters.push(args[++i]);
+    } else if (arg === '--caveman') {
+      params.caveman = true;
+    } else if (arg === '--dry-run' || arg === '-d') {
+      params.dryRun = true;
+    } else if (arg === '--list-actions') {
+      params.listActions = true;
+    } else if (arg === '--force' || arg === '-f') {
+      params.force = true;
+    } else if (arg === '--help' || arg === '-h') {
+      params.help = true;
+    } else if (arg === '--tokens') {
+      params.tokens = true;
+    } else if (arg === '--all-registries') {
+      params.allRegistries = true;
+    } else if (arg === '--release') {
+      params.release = true;
+    } else if (arg === '--intelligence') {
+      params.intelligence = true;
+    } else if (arg === '--onboarding') {
+      params.onboarding = true;
+    } else if (arg === '--json') {
+      params.json = true;
+    } else if (arg === '--threshold') {
+      params.threshold = args[++i];
+    } else if (arg === '--registry') {
+      params.registry = args[++i];
+    } else if (arg === '--model-preset') {
+      params.modelPreset = args[++i];
+    } else if (arg === '--agent') {
+      params.agent = args[++i];
+    } else if (arg === '--stack') {
+      params.stack = args[++i];
+    } else if (arg === '--mobile') {
+      params.mobile = args[++i];
+    } else if (arg === '--type') {
+      params.type = args[++i];
+    } else if (arg === '--tags') {
+      params.tags = args[++i];
+    } else if (arg === '--files') {
+      params.files = args[++i];
+    } else if (arg === '--title') {
+      params.title = args[++i];
+    } else if (arg === '--approved') {
+      params.approved = true;
+    } else if (arg === '--category') {
+      params.category = args[++i];
+    } else if (arg === '--source') {
+      params.source = args[++i];
+    } else if (arg === '--all-sources') {
+      params.allSources = true;
+    } else if (!params.command && !arg.startsWith('-')) {
+      params.command = arg;
+    }
+  }
+  return params;
+}
+
+export function getPositionalArgs(args) {
+  const positionalArgs = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--target' || arg === '-t' || arg === '--template' || arg === '--adapter' || arg === '-a' ||
+        arg === '--threshold' || arg === '--registry' || arg === '--model-preset' || arg === '--agent' ||
+        arg === '--stack' || arg === '--mobile' || arg === '--type' || arg === '--tags' || arg === '--files' ||
+        arg === '--title' || arg === '--category') {
+      i++; // skip next arg (its value)
+    } else if (arg.startsWith('-')) {
+      // it's a flag, skip
+    } else {
+      positionalArgs.push(arg);
+    }
+  }
+  return positionalArgs;
+}