@ryuenn3123/agentic-senior-core 6.2.4 → 6.4.0

package/lib/cli/commands/adapter.mjs

@@ -1,6 +1,7 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { installGitPreCommitHook } from './git-hook-generator.mjs';
 
 const currentFilePath = fileURLToPath(import.meta.url);
 const currentDirectoryPath = path.dirname(currentFilePath);
@@ -157,5 +158,12 @@ export async function runAdapterCommand(commandArguments) {
     if (success) successCount++;
   }
 
-  console.log(`\nGenerated ${successCount}/${requestedAdapters.length} adapter file(s).`);
+  // Automatically install Git pre-commit hook for non-hook host backstop
+  const hookResult = installGitPreCommitHook({ cwd: targetDirectory });
+  if (hookResult.installed) {
+    const relPath = path.relative(targetDirectory, hookResult.hookPath) || hookResult.hookPath;
+    console.log(`  Git Pre-Commit Hook: ${relPath} ... OK`);
+  }
+
+  console.log(`\nGenerated ${successCount}/${requestedAdapters.length} adapter file(s) and configured Git pre-commit hook.`);
 }

package/lib/cli/commands/git-hook-generator.mjs

@@ -0,0 +1,273 @@
+import fs from 'fs';
+import path from 'path';
+import { compileAndSaveValidator } from '../../core/rule-compiler.mjs';
+
+export const ASC_HOOK_HEADER = '# Agentic Senior Core Git Pre-Commit Hook';
+export const ASC_HOOK_RUNNER_REL_PATH = path.join('.asc', 'hooks', 'pre-commit-runner.cjs').replace(/\\/g, '/');
+
+export function generatePreCommitRunnerScript() {
+  return `#!/usr/bin/env node
+// # Agentic Senior Core -- Git Pre-Commit Dedup & Quality Gate
+// Auto-generated by Agentic Senior Core (ASC). DO NOT EDIT DIRECTLY.
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+const SOURCE_EXTENSIONS = new Set([
+  'js', 'ts', 'mjs', 'cjs', 'jsx', 'tsx',
+  'py', 'rb', 'go', 'rs', 'java', 'kt', 'swift', 'cs',
+]);
+
+const JSCPD_TIMEOUT_MS = 10000;
+
+function getStagedFiles(cwd) {
+  try {
+    const output = execSync('git diff --cached --name-only --diff-filter=ACM', { encoding: 'utf8', cwd });
+    return output.split('\\n').map(f => f.trim()).filter(Boolean);
+  } catch (err) {
+    return [];
+  }
+}
+
+function loadDedupConfig(cwd) {
+  const candidates = [
+    path.join(cwd, '.asc', 'dedup-config.json'),
+    path.join(cwd, '.agents', 'dedup-config.json'),
+  ];
+  for (let i = 0; i < candidates.length; i++) {
+    try {
+      if (fs.existsSync(candidates[i])) {
+        return JSON.parse(fs.readFileSync(candidates[i], 'utf8'));
+      }
+    } catch (_) {}
+  }
+  return { minTokens: 30, ignoreDirs: ['tests', 'migrations', 'generated', 'node_modules'] };
+}
+
+function runEslintAutoFix(cwd, stagedFiles) {
+  const hasTsConfig = fs.existsSync(path.join(cwd, 'tsconfig.json'));
+  if (!hasTsConfig) return;
+
+  const eslintConfigNames = [
+    'eslint.config.js', 'eslint.config.mjs', 'eslint.config.cjs', 'eslint.config.ts',
+    '.eslintrc', '.eslintrc.js', '.eslintrc.cjs', '.eslintrc.json', '.eslintrc.yaml', '.eslintrc.yml'
+  ];
+  const hasEslintConfig = eslintConfigNames.some(name => fs.existsSync(path.join(cwd, name)));
+  if (!hasEslintConfig) return;
+
+  const tsJsExts = new Set(['js', 'ts', 'jsx', 'tsx', 'mjs', 'cjs']);
+  const stagedTsJsFiles = stagedFiles.filter(file => {
+    const ext = path.extname(file).slice(1).toLowerCase();
+    return tsJsExts.has(ext);
+  });
+
+  if (stagedTsJsFiles.length === 0) return;
+
+  try {
+    const fileList = stagedTsJsFiles.map(f => \`"\${f}"\`).join(' ');
+    execSync(\`npx eslint --fix \${fileList}\`, { stdio: 'ignore', cwd });
+    execSync(\`git add \${fileList}\`, { stdio: 'ignore', cwd });
+  } catch (_) {
+    // Silently ignore ESLint auto-fix errors (never block commit on lint failure alone)
+  }
+}
+
+function runJscpdScan(scanCmd, cwd, tmpDir) {
+  const binaries = ['bunx jscpd', 'npx jscpd@5', 'npx jscpd'];
+  for (let i = 0; i < binaries.length; i++) {
+    try {
+      execSync(binaries[i] + scanCmd, {
+        timeout: JSCPD_TIMEOUT_MS,
+        stdio: 'pipe',
+        cwd,
+      });
+      return loadReport(tmpDir);
+    } catch (_) {
+      // Try next binary
+    }
+  }
+  return null;
+}
+
+function loadReport(tmpDir) {
+  const reportPath = path.join(tmpDir, 'jscpd-report.json');
+  if (!fs.existsSync(reportPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(reportPath, 'utf8'));
+  } catch (_) {
+    return null;
+  }
+}
+
+function checkForDuplicates(report, stagedSourceFiles, cwd) {
+  const duplicates = report.duplicates || [];
+  if (duplicates.length === 0) return null;
+
+  const normalizedStagedMap = new Map();
+  for (const f of stagedSourceFiles) {
+    const norm = path.resolve(cwd, f).replace(/\\\\/g, '/').toLowerCase();
+    normalizedStagedMap.set(norm, f);
+  }
+
+  for (let i = 0; i < duplicates.length; i++) {
+    const dup = duplicates[i];
+    const firstName = path.resolve(cwd, dup.firstFile.name).replace(/\\\\/g, '/').toLowerCase();
+    const secondName = path.resolve(cwd, dup.secondFile.name).replace(/\\\\/g, '/').toLowerCase();
+
+    const isFirstStaged = normalizedStagedMap.has(firstName);
+    const isSecondStaged = normalizedStagedMap.has(secondName);
+
+    if (isFirstStaged || isSecondStaged) {
+      const stagedFile = isFirstStaged ? normalizedStagedMap.get(firstName) : normalizedStagedMap.get(secondName);
+      const matchedFile = isFirstStaged ? path.basename(dup.secondFile.name) : path.basename(dup.firstFile.name);
+      const lines = dup.lines || 0;
+      const totalLines = (report.statistics && report.statistics.total && report.statistics.total.lines) || 1;
+      const percent = Math.round((lines / totalLines) * 100);
+      return { stagedFile, matchedFile, lines, percent };
+    }
+  }
+  return null;
+}
+
+function runPreCommitGate() {
+  const cwd = process.cwd();
+
+  // 0. Run syntactic validator if present
+  const validatorPath = path.join(cwd, '.asc', 'hooks', 'pre-commit-validator.cjs');
+  if (fs.existsSync(validatorPath)) {
+    try {
+      execSync(\`node "\${validatorPath}"\`, { stdio: 'inherit', cwd });
+    } catch (valErr) {
+      process.exit(valErr.status || 1);
+    }
+  }
+
+  const stagedFiles = getStagedFiles(cwd);
+  if (stagedFiles.length === 0) {
+    process.exit(0);
+  }
+
+  // 1. Filter staged files by SOURCE_EXTENSIONS
+  const stagedSourceFiles = stagedFiles.filter(f => {
+    const ext = path.extname(f).slice(1).toLowerCase();
+    return SOURCE_EXTENSIONS.has(ext);
+  });
+
+  if (stagedSourceFiles.length === 0) {
+    process.exit(0);
+  }
+
+  // 2. Optional pre-step: ESLint auto-fix
+  runEslintAutoFix(cwd, stagedFiles);
+
+  // Re-fetch staged files after possible eslint auto-fix & git add
+  const currentStagedSource = getStagedFiles(cwd).filter(f => {
+    const ext = path.extname(f).slice(1).toLowerCase();
+    return SOURCE_EXTENSIONS.has(ext);
+  });
+
+  if (currentStagedSource.length === 0) {
+    process.exit(0);
+  }
+
+  // 3. Run jscpd dedup scan
+  const config = loadDedupConfig(cwd);
+  const scanDirs = Array.from(new Set(currentStagedSource.map(f => {
+    const resolved = path.resolve(cwd, f);
+    return path.dirname(resolved);
+  })));
+
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'asc-git-dedup-'));
+  const ignoreFlags = (config.ignoreDirs || ['tests', 'migrations', 'generated', 'node_modules'])
+    .map(d => \`--ignore "\${d}"\`).join(' ');
+  const minTokens = config.minTokens || 30;
+
+  let finding = null;
+
+  for (const scanDir of scanDirs) {
+    const scanCmd = \` "\${scanDir}" --min-tokens \${minTokens} --reporters json --silent --output "\${tmpDir}" \${ignoreFlags}\`;
+    const report = runJscpdScan(scanCmd, cwd, tmpDir);
+    if (report) {
+      finding = checkForDuplicates(report, currentStagedSource, cwd);
+      if (finding) break;
+    }
+  }
+
+  try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch (_) {}
+
+  if (finding) {
+    console.error(\`\\x1b[31m[ASC Dedup]\\x1b[0m \${path.basename(finding.stagedFile)} looks similar to \${finding.matchedFile} (\${finding.percent}% overlap, \${finding.lines} lines)\`);
+    console.error(\`\\x1b[33mCommit blocked to prevent duplication. Use 'git commit --no-verify' to bypass if intentional.\\x1b[0m\`);
+    process.exit(1);
+  }
+
+  process.exit(0);
+}
+
+runPreCommitGate();
+`;
+}
+
+/**
+ * Installs or updates the Git pre-commit hook in the target repository.
+ * @param {Object} options
+ * @param {string} [options.cwd] Working directory.
+ * @returns {{ installed: boolean, hookPath: string, runnerPath: string, reason?: string }} Installation result.
+ */
+export function installGitPreCommitHook({ cwd = process.cwd() } = {}) {
+  const gitDir = path.join(cwd, '.git');
+  const huskyDir = path.join(cwd, '.husky');
+
+  if (!fs.existsSync(gitDir) && !fs.existsSync(huskyDir)) {
+    return { installed: false, hookPath: '', runnerPath: '', reason: 'Not a git repository' };
+  }
+
+  const ascHooksDir = path.join(cwd, '.asc', 'hooks');
+  if (!fs.existsSync(ascHooksDir)) {
+    fs.mkdirSync(ascHooksDir, { recursive: true });
+  }
+
+  // Compile syntactic validator script as fallback/compatibility
+  try { compileAndSaveValidator({ cwd }); } catch (_) {}
+
+  const runnerPath = path.join(ascHooksDir, 'pre-commit-runner.cjs');
+  const runnerScriptContent = generatePreCommitRunnerScript();
+  fs.writeFileSync(runnerPath, runnerScriptContent, { encoding: 'utf8', mode: 0o755 });
+
+  let hookPath = '';
+  const invocationCommand = `node .asc/hooks/pre-commit-runner.cjs`;
+
+  if (fs.existsSync(huskyDir)) {
+    hookPath = path.join(huskyDir, 'pre-commit');
+    if (fs.existsSync(hookPath)) {
+      const existing = fs.readFileSync(hookPath, 'utf8');
+      if (!existing.includes(ASC_HOOK_HEADER) && !existing.includes(ASC_HOOK_RUNNER_REL_PATH)) {
+        const updated = existing.trimEnd() + `\n\n${ASC_HOOK_HEADER}\n${invocationCommand}\n`;
+        fs.writeFileSync(hookPath, updated, { encoding: 'utf8', mode: 0o755 });
+      }
+    } else {
+      const content = `#!/bin/sh\n${ASC_HOOK_HEADER}\n${invocationCommand}\n`;
+      fs.writeFileSync(hookPath, content, { encoding: 'utf8', mode: 0o755 });
+    }
+  } else {
+    const hooksDir = path.join(gitDir, 'hooks');
+    if (!fs.existsSync(hooksDir)) {
+      fs.mkdirSync(hooksDir, { recursive: true });
+    }
+    hookPath = path.join(hooksDir, 'pre-commit');
+    if (fs.existsSync(hookPath)) {
+      const existing = fs.readFileSync(hookPath, 'utf8');
+      if (!existing.includes(ASC_HOOK_HEADER) && !existing.includes(ASC_HOOK_RUNNER_REL_PATH)) {
+        const updated = existing.trimEnd() + `\n\n${ASC_HOOK_HEADER}\n${invocationCommand}\n`;
+        fs.writeFileSync(hookPath, updated, { encoding: 'utf8', mode: 0o755 });
+      }
+    } else {
+      const content = `#!/bin/sh\n${ASC_HOOK_HEADER}\n${invocationCommand}\n`;
+      fs.writeFileSync(hookPath, content, { encoding: 'utf8', mode: 0o755 });
+    }
+  }
+
+  return { installed: true, hookPath, runnerPath };
+}

package/lib/cli/commands/git-hook.mjs

@@ -0,0 +1,24 @@
+import path from 'node:path';
+import { installGitPreCommitHook } from './git-hook-generator.mjs';
+
+/**
+ * Runs the `asc install-git-hook` command to install Git pre-commit hooks.
+ * @param {string[]} commandArguments
+ */
+export async function runGitHookCommand(commandArguments) {
+  const targetDirectory = process.cwd();
+  console.log('Agentic Senior Core -- Git Pre-Commit Hook Installer\n');
+
+  const result = installGitPreCommitHook({ cwd: targetDirectory });
+
+  if (!result.installed) {
+    console.error(`Failed: ${result.reason || 'Could not install pre-commit hook'}`);
+    process.exit(1);
+  }
+
+  console.log(`  Pre-commit hook: ${result.hookPath} ... OK`);
+  if (result.runnerPath) {
+    console.log(`  Runner script: ${result.runnerPath} ... OK`);
+  }
+  console.log('\nGit pre-commit hook successfully installed.');
+}

package/lib/cli/commands/global.mjs

@@ -316,5 +316,27 @@ export async function runGlobalCommand(commandArguments) {
     if (success) successCount++;
   }
 
-  console.log(`\nInstalled ${successCount}/${requestedTargets.length} global target(s).`);
+  // Automatically setup global Git hook runner in ~/.asc/hooks and configure git config --global core.hooksPath
+  try {
+    const { execSync } = await import('node:child_process');
+    const { generatePreCommitRunnerScript } = await import('./git-hook-generator.mjs');
+
+    const ascGlobalHooksDir = path.join(HOME, '.asc', 'hooks');
+    await fs.mkdir(ascGlobalHooksDir, { recursive: true });
+
+    const globalRunnerPath = path.join(ascGlobalHooksDir, 'pre-commit-runner.cjs');
+    const runnerContent = generatePreCommitRunnerScript();
+    await fs.writeFile(globalRunnerPath, runnerContent, { encoding: 'utf8', mode: 0o755 });
+
+    const globalHookPath = path.join(ascGlobalHooksDir, 'pre-commit');
+    const hookContent = `#!/bin/sh\n# Agentic Senior Core Global Git Pre-Commit Hook\nnode "${globalRunnerPath.replace(/\\/g, '/')}"\n`;
+    await fs.writeFile(globalHookPath, hookContent, { encoding: 'utf8', mode: 0o755 });
+
+    execSync(`git config --global core.hooksPath "${ascGlobalHooksDir.replace(/\\/g, '/')}"`, { stdio: 'ignore' });
+    console.log(`  Global Git Pre-Commit Hook: ~/.asc/hooks (via git config --global) ... OK`);
+  } catch (err) {
+    // Best effort global git hook registration
+  }
+
+  console.log(`\nInstalled ${successCount}/${requestedTargets.length} global target(s) and configured Global Git Hook.`);
 }

package/lib/cli/commands/uninstall.mjs

@@ -18,6 +18,12 @@ const ADAPTER_FILES = [
   { label: 'Roo Code', path: '.roo/rules/agentic-senior-core.md' },
   { label: 'OpenHands', path: '.openhands/microagents/agentic-senior-core.md' },
   { label: 'ASC Compiled Validator', path: '.asc/hooks/pre-commit-validator.cjs' },
+  { label: 'ASC Git Pre-Commit Runner', path: '.asc/hooks/pre-commit-runner.cjs' },
+];
+
+const GIT_HOOK_PATHS = [
+  { label: 'Husky Pre-Commit Hook', path: '.husky/pre-commit' },
+  { label: 'Git Pre-Commit Hook', path: '.git/hooks/pre-commit' },
 ];
 
 async function pathExists(filePath) {
@@ -32,7 +38,7 @@ async function pathExists(filePath) {
 async function isAscFile(filePath) {
   try {
     const content = await fs.readFile(filePath, 'utf8');
-    return content.includes(ASC_SIGNATURE);
+    return content.includes(ASC_SIGNATURE) || content.includes('pre-commit-runner.cjs');
   } catch {
     return false;
   }
@@ -69,6 +75,50 @@ export async function runUninstallCommand(commandArguments) {
     }
   }
 
+  for (const hookItem of GIT_HOOK_PATHS) {
+    const fullPath = path.join(targetDirectory, hookItem.path);
+    if (!(await pathExists(fullPath))) continue;
+
+    try {
+      const content = await fs.readFile(fullPath, 'utf8');
+      if (!content.includes('Agentic Senior Core') && !content.includes('pre-commit-runner.cjs')) {
+        continue;
+      }
+
+      found++;
+
+      // Check if file contains ONLY ASC lines or if it has extra user commands
+      const lines = content.split('\n');
+      const nonAscLines = lines.filter(l => {
+        const trimmed = l.trim();
+        return trimmed && !trimmed.startsWith('#!') && !trimmed.includes('Agentic Senior Core') && !trimmed.includes('pre-commit-runner.cjs') && !trimmed.includes('pre-commit-validator.cjs');
+      });
+
+      if (nonAscLines.length === 0) {
+        // Safe to remove completely
+        if (dryRun) {
+          console.log(`  would remove: ${hookItem.path} (${hookItem.label})`);
+        } else {
+          await fs.rm(fullPath, { force: true });
+          console.log(`  removed: ${hookItem.path} (${hookItem.label})`);
+          removed++;
+        }
+      } else {
+        // File has user modifications / additional commands — preserve user commands, remove ASC block
+        if (dryRun) {
+          console.log(`  would clean ASC block from: ${hookItem.path} (${hookItem.label})`);
+        } else {
+          const cleanedLines = lines.filter(l => !l.includes('Agentic Senior Core') && !l.includes('pre-commit-runner.cjs') && !l.includes('pre-commit-validator.cjs'));
+          await fs.writeFile(fullPath, cleanedLines.join('\n').trimEnd() + '\n', 'utf8');
+          console.log(`  cleaned ASC lines from: ${hookItem.path} (${hookItem.label})`);
+          removed++;
+        }
+      }
+    } catch (err) {
+      console.log(`  warn: could not process ${hookItem.path}: ${err.message}`);
+    }
+  }
+
   if (found === 0) {
     console.log('No ASC adapter files found in this project.');
     return;

package/lib/core/adaptive-preferences.mjs

@@ -0,0 +1,178 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+export const DEFAULT_RULE_CAP = 25;
+
+/**
+ * Resolves the global user configuration directory path.
+ * @returns {string} Absolute path to global config directory.
+ */
+export function getUserConfigDir() {
+  return path.join(os.homedir(), '.gemini', 'config');
+}
+
+/**
+ * Resolves the project-local configuration directory path.
+ * @param {string} cwd Working directory of the project.
+ * @returns {string} Absolute path to project config directory.
+ */
+export function getProjectConfigDir(cwd = process.cwd()) {
+  return path.join(cwd, '.agents');
+}
+
+/**
+ * Resolves the JSON preferences file path for a given scope.
+ * @param {Object} options
+ * @param {string} [options.cwd] Project working directory.
+ * @param {'user'|'project'} options.scope Preference scope.
+ * @returns {string} Absolute path to preferences JSON file.
+ */
+export function getPreferencesFilePath({ cwd = process.cwd(), scope = 'project' } = {}) {
+  const baseDir = scope === 'user' ? getUserConfigDir() : getProjectConfigDir(cwd);
+  return path.join(baseDir, 'adaptive_preferences.json');
+}
+
+/**
+ * Initializes an empty preferences structure.
+ * @returns {Object} Fresh preferences data object.
+ */
+export function createEmptyPreferences() {
+  return {
+    version: '1.0.0',
+    updatedAt: new Date().toISOString(),
+    rules: []
+  };
+}
+
+/**
+ * Loads preference rules from storage for a specific scope.
+ * @param {Object} options
+ * @param {string} [options.cwd] Project working directory.
+ * @param {'user'|'project'} [options.scope] Target scope.
+ * @returns {Object} Preferences data object.
+ */
+export function loadPreferences({ cwd = process.cwd(), scope = 'project' } = {}) {
+  const filePath = getPreferencesFilePath({ cwd, scope });
+  if (!fs.existsSync(filePath)) {
+    return createEmptyPreferences();
+  }
+
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (!parsed || !Array.isArray(parsed.rules)) {
+      return createEmptyPreferences();
+    }
+    return parsed;
+  } catch (err) {
+    return createEmptyPreferences();
+  }
+}
+
+/**
+ * Saves preference rules to storage for a specific scope.
+ * @param {Object} options
+ * @param {string} [options.cwd] Project working directory.
+ * @param {'user'|'project'} [options.scope] Target scope.
+ * @param {Object} options.preferences Preferences payload to write.
+ */
+export function savePreferences({ cwd = process.cwd(), scope = 'project', preferences } = {}) {
+  const filePath = getPreferencesFilePath({ cwd, scope });
+  const dirPath = path.dirname(filePath);
+
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+
+  const payload = {
+    ...createEmptyPreferences(),
+    ...preferences,
+    updatedAt: new Date().toISOString()
+  };
+
+  fs.writeFileSync(filePath, JSON.stringify(payload, null, 2), 'utf8');
+  return payload;
+}
+
+/**
+ * Adds or updates a rule within the specified scope, enforcing deduplication and max rule cap.
+ * @param {Object} options
+ * @param {string} [options.cwd] Project working directory.
+ * @param {'user'|'project'} [options.scope] Target scope.
+ * @param {Object} options.rule Rule definition object.
+ * @param {number} [options.maxCap] Maximum allowed rules per scope.
+ * @returns {{ preferences: Object, added: boolean, capExceeded: boolean }} Result summary.
+ */
+export function addRule({ cwd = process.cwd(), scope = 'project', rule, maxCap = DEFAULT_RULE_CAP } = {}) {
+  if (!rule || !rule.pattern) {
+    throw new Error('Rule pattern is required');
+  }
+
+  const prefs = loadPreferences({ cwd, scope });
+  const normalizedPattern = String(rule.pattern).trim().toLowerCase();
+
+  const existingIndex = prefs.rules.findIndex(
+    r => String(r.pattern).trim().toLowerCase() === normalizedPattern
+  );
+
+  const formattedRule = {
+    id: rule.id || `rule_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`,
+    type: rule.type === 'syntactic' ? 'syntactic' : 'taste',
+    pattern: String(rule.pattern).trim(),
+    reason: String(rule.reason || '').trim(),
+    source: rule.source || 'learn',
+    createdAt: rule.createdAt || new Date().toISOString()
+  };
+
+  let added = false;
+  if (existingIndex >= 0) {
+    // Update existing rule
+    prefs.rules[existingIndex] = {
+      ...prefs.rules[existingIndex],
+      ...formattedRule
+    };
+  } else {
+    // Append new rule
+    prefs.rules.push(formattedRule);
+    added = true;
+  }
+
+  let capExceeded = false;
+  if (prefs.rules.length > maxCap) {
+    capExceeded = true;
+    // Trim oldest rules exceeding cap
+    prefs.rules = prefs.rules.slice(prefs.rules.length - maxCap);
+  }
+
+  const saved = savePreferences({ cwd, scope, preferences: prefs });
+  return { preferences: saved, added, capExceeded };
+}
+
+/**
+ * Resolves active combined rules from both user and project scopes.
+ * User scope rules come first, project scope rules override or extend.
+ * @param {Object} options
+ * @param {string} [options.cwd] Project working directory.
+ * @returns {{ syntactic: Array<Object>, taste: Array<Object> }} Active rules grouped by track.
+ */
+export function resolveActiveRules({ cwd = process.cwd() } = {}) {
+  const userPrefs = loadPreferences({ cwd, scope: 'user' });
+  const projectPrefs = loadPreferences({ cwd, scope: 'project' });
+
+  const combinedRules = [...userPrefs.rules, ...projectPrefs.rules];
+
+  // Deduplicate combined by pattern (project scope overrides user scope if identical)
+  const ruleMap = new Map();
+  for (const r of combinedRules) {
+    const key = String(r.pattern).trim().toLowerCase();
+    ruleMap.set(key, r);
+  }
+
+  const allActive = Array.from(ruleMap.values());
+
+  return {
+    syntactic: allActive.filter(r => r.type === 'syntactic'),
+    taste: allActive.filter(r => r.type === 'taste')
+  };
+}

package/lib/core/bootstrap-wizard.mjs

@@ -0,0 +1,64 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { addRule } from './adaptive-preferences.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Loads the curated catalog of known UI/code slop patterns.
+ * @returns {Array<{ id: string, regex: string, message: string }>} Catalog patterns.
+ */
+export function getSlopCatalog() {
+  const catalogPath = path.resolve(
+    __dirname,
+    '../../.agents/plugins/agentic-senior-core/hooks/lib/known-ui-slop-patterns.json'
+  );
+
+  if (!fs.existsSync(catalogPath)) {
+    return [];
+  }
+
+  try {
+    const content = fs.readFileSync(catalogPath, 'utf8');
+    const parsed = JSON.parse(content);
+    return parsed.patterns || [];
+  } catch (err) {
+    return [];
+  }
+}
+
+/**
+ * Seeds selected slop pattern IDs into the target preference scope (Khroma Elicitation pattern).
+ * @param {Object} options
+ * @param {string} [options.cwd] Working directory.
+ * @param {'user'|'project'} [options.scope] Target scope.
+ * @param {Array<string>} options.selectedIds List of pattern IDs selected by the user.
+ * @returns {Array<Object>} List of added rule results.
+ */
+export function bootstrapPreferences({ cwd = process.cwd(), scope = 'project', selectedIds = [] } = {}) {
+  const catalog = getSlopCatalog();
+  const results = [];
+
+  for (const id of selectedIds) {
+    const matched = catalog.find(item => item.id === id);
+    if (!matched) continue;
+
+    const res = addRule({
+      cwd,
+      scope,
+      rule: {
+        id: `bootstrap_${matched.id}`,
+        type: 'syntactic',
+        pattern: matched.regex,
+        reason: matched.message,
+        source: 'bootstrap'
+      }
+    });
+
+    results.push(res);
+  }
+
+  return results;
+}