@ryuenn3123/agentic-senior-core 6.3.0 → 6.4.0

package/.agents/plugins/agentic-senior-core/hooks/constants.cjs

@@ -1,6 +1,5 @@
-// Agentic Senior Core — shared constants for hook modules
-// Single source of truth for thresholds and extension sets used by
-// post-edit-enforce.js and dedup-gate.js.
+const fs = require('fs');
+const path = require('path');
 
 const SOURCE_EXTENSIONS = new Set([
   'js', 'ts', 'mjs', 'cjs', 'jsx', 'tsx',
@@ -12,10 +11,39 @@ const NEW_FILE_LINE_THRESHOLD = 50;
 const SESSION_DRIFT_THRESHOLD = 4;
 const LADDER_PULSE_INTERVAL = 3;
 
+function loadDedupConfig(cwd = process.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 {};
+}
+
+function getThresholds(cwd = process.cwd()) {
+  const config = loadDedupConfig(cwd);
+  return {
+    NEW_FILE_LINE_THRESHOLD: typeof config.NEW_FILE_LINE_THRESHOLD === 'number'
+      ? config.NEW_FILE_LINE_THRESHOLD
+      : NEW_FILE_LINE_THRESHOLD,
+    LOC_DELTA_THRESHOLD: typeof config.LOC_DELTA_THRESHOLD === 'number'
+      ? config.LOC_DELTA_THRESHOLD
+      : LOC_DELTA_THRESHOLD,
+  };
+}
+
 module.exports = {
   SOURCE_EXTENSIONS,
   LOC_DELTA_THRESHOLD,
   NEW_FILE_LINE_THRESHOLD,
   SESSION_DRIFT_THRESHOLD,
   LADDER_PULSE_INTERVAL,
+  getThresholds,
+  loadDedupConfig,
 };

package/.agents/plugins/agentic-senior-core/hooks/dedup-gate.js

@@ -56,9 +56,9 @@ process.stdin.on('data', chunk => {
     const ext = path.extname(filePath).slice(1);
     if (!SOURCE_EXTENSIONS.has(ext)) { process.exit(0); return; }
 
-    if (!isQualifyingEdit(toolName, toolInput)) { process.exit(0); return; }
-
     const config = loadDedupConfig();
+    if (!isQualifyingEdit(toolName, toolInput, config)) { process.exit(0); return; }
+
     const scanDir = resolveScanDir(filePath, config);
     const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'asc-dedup-'));
 
@@ -101,50 +101,67 @@ function extractToolCallFromTranscript(transcriptPath, stepIdx) {
 
     // Find the step with matching step_index that contains tool_calls
     for (var i = lines.length - 1; i >= 0; i--) {
-      var step = JSON.parse(lines[i]);
-      if (step.step_index !== stepIdx || !step.tool_calls) continue;
-
-      for (var j = 0; j < step.tool_calls.length; j++) {
-        var tc = step.tool_calls[j];
-        if (tc.name === 'replace_file_content' || tc.name === 'multi_replace_file_content') {
-          return {
-            toolName: 'Edit',
-            toolInput: {
-              file_path: tc.args.TargetFile || '',
-              new_string: tc.args.ReplacementContent || '',
-              old_string: tc.args.TargetContent || '',
-            },
-          };
-        } else if (tc.name === 'write_to_file') {
-          return {
-            toolName: 'Write',
-            toolInput: {
-              file_path: tc.args.TargetFile || '',
-              content: tc.args.CodeContent || '',
-            },
-          };
+      try {
+        var step = JSON.parse(lines[i]);
+        if (step.step_index !== stepIdx || !step.tool_calls) continue;
+
+        for (var j = 0; j < step.tool_calls.length; j++) {
+          var tc = step.tool_calls[j];
+          if (tc.name === 'replace_file_content' || tc.name === 'multi_replace_file_content') {
+            return {
+              toolName: 'Edit',
+              toolInput: {
+                file_path: tc.args.TargetFile || '',
+                new_string: tc.args.ReplacementContent || '',
+                old_string: tc.args.TargetContent || '',
+              },
+            };
+          } else if (tc.name === 'write_to_file') {
+            return {
+              toolName: 'Write',
+              toolInput: {
+                file_path: tc.args.TargetFile || '',
+                content: tc.args.CodeContent || '',
+              },
+            };
+          }
+        }
+      } catch (lineErr) {
+        if (process.env.ASC_DEBUG) {
+          console.error('[ASC Debug] Transcript line parse failed line ' + i + ':', lineErr.message);
         }
+        // Skip malformed line and keep scanning
       }
     }
     return null;
-  } catch (_) {
+  } catch (err) {
+    if (process.env.ASC_DEBUG) {
+      console.error('[ASC Debug] extractToolCallFromTranscript failed:', err.message);
+    }
     return null;
   }
 }
 
-function isQualifyingEdit(toolName, toolInput) {
+function isQualifyingEdit(toolName, toolInput, config) {
   var isWrite = ['Write', 'write_to_file', 'write_file'].indexOf(toolName) !== -1;
   var isEdit = ['Edit', 'replace_file_content', 'multi_replace_file_content'].indexOf(toolName) !== -1;
 
+  var newFileThreshold = (config && typeof config.NEW_FILE_LINE_THRESHOLD === 'number')
+    ? config.NEW_FILE_LINE_THRESHOLD
+    : NEW_FILE_LINE_THRESHOLD;
+  var locDeltaThreshold = (config && typeof config.LOC_DELTA_THRESHOLD === 'number')
+    ? config.LOC_DELTA_THRESHOLD
+    : LOC_DELTA_THRESHOLD;
+
   if (isWrite) {
     var content = toolInput.content || toolInput.CodeContent || '';
-    return content.split('\n').length > NEW_FILE_LINE_THRESHOLD;
+    return content.split('\n').length > newFileThreshold;
   }
   if (isEdit) {
     var newStr = toolInput.new_string || toolInput.ReplacementContent || toolInput.content || '';
     var oldStr = toolInput.old_string || toolInput.TargetContent || '';
     var delta = newStr.split('\n').length - oldStr.split('\n').length;
-    return delta > LOC_DELTA_THRESHOLD;
+    return delta > locDeltaThreshold;
   }
   return false;
 }

package/.agents/plugins/agentic-senior-core/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-senior-core",
-  "version": "6.3.0",
+  "version": "6.4.0",
   "description": "Universal AI coding rules. Because your AI writes code like it gets paid by the line.",
   "contextFileName": "rules/agentic-senior-core.md",
   "rules": [

package/.agents/plugins/agentic-senior-core/rules/agentic-senior-core.md

@@ -38,6 +38,7 @@ When you pick the minimal option at step 5 or 6, and it isn't obviously trivial:
 - Delete code that carries no behavior, safety, or test value.
 - When brevity and readability conflict, readability wins.
 - Prefer named functions over closures/inline lambdas once logic exceeds a trivial expression.
+- Arrow function shorthand (no braces, implicit return) must not return a void-typed expression — e.g. `onClick={() => setCount(count + 1)}` or `arr.forEach(item => sideEffect(item))`. This trips `@typescript-eslint/no-confusing-void-expression` under strict TS lint configs. Not JSX-specific — applies to any callback assignment in `.js`/`.ts`/`.jsx`/`.tsx` where the shorthand body calls a void-returning function. Use braces instead: `onClick={() => { setCount(count + 1); }}`.
 
 ## Architecture
 

package/.agents/plugins/agentic-senior-core/skills/asc-adapter/SKILL.md

@@ -31,7 +31,8 @@ Adapter hosts (one file per project): Cursor, Devin Desktop, Cline, GitHub Copil
 asc status                # Show detected hosts
 asc adapter --all         # Generate all adapters
 asc adapter --cursor      # Generate for specific host
-asc uninstall             # Remove all ASC adapter files
+asc install-git-hook      # Install native Git pre-commit hook (recommended for all hosts)
+asc uninstall             # Remove all ASC adapter files and git hooks
 asc uninstall --dry-run   # Preview what would be removed
 ```
 
@@ -41,3 +42,4 @@ asc uninstall --dry-run   # Preview what would be removed
 - Cursor uses `.mdc` format with `alwaysApply: true` frontmatter.
 - Windsurf is now Devin Desktop. Use `--devin` for the preferred path, `--windsurf` for legacy.
 - Zed also reads `AGENTS.md` natively, so the adapter is optional.
+- **Git Pre-Commit Hook (`asc install-git-hook`)**: Host plugin runtimes vary — adapter hosts and certain chat surfaces (e.g., Antigravity IDE / Antigravity 2.0 chat interface) do not run agent lifecycle hooks. Installing the native Git pre-commit hook ensures 100% deterministic duplicate code blocking and ESLint auto-fixing directly via Git on all hosts.

package/.agents/rules/agentic-senior-core.md

@@ -38,6 +38,7 @@ When you pick the minimal option at step 5 or 6, and it isn't obviously trivial:
 - Delete code that carries no behavior, safety, or test value.
 - When brevity and readability conflict, readability wins.
 - Prefer named functions over closures/inline lambdas once logic exceeds a trivial expression.
+- Arrow function shorthand (no braces, implicit return) must not return a void-typed expression — e.g. `onClick={() => setCount(count + 1)}` or `arr.forEach(item => sideEffect(item))`. This trips `@typescript-eslint/no-confusing-void-expression` under strict TS lint configs. Not JSX-specific — applies to any callback assignment in `.js`/`.ts`/`.jsx`/`.tsx` where the shorthand body calls a void-returning function. Use braces instead: `onClick={() => { setCount(count + 1); }}`.
 
 ## Architecture
 

package/AGENTS.md

@@ -33,6 +33,7 @@ When you pick the minimal option at step 5 or 6, and it isn't obviously trivial:
 - Delete code that carries no behavior, safety, or test value.
 - When brevity and readability conflict, readability wins.
 - Prefer named functions over closures/inline lambdas once logic exceeds a trivial expression.
+- Arrow function shorthand (no braces, implicit return) must not return a void-typed expression — e.g. `onClick={() => setCount(count + 1)}` or `arr.forEach(item => sideEffect(item))`. This trips `@typescript-eslint/no-confusing-void-expression` under strict TS lint configs. Not JSX-specific — applies to any callback assignment in `.js`/`.ts`/`.jsx`/`.tsx` where the shorthand body calls a void-returning function. Use braces instead: `onClick={() => { setCount(count + 1); }}`.
 
 ## Architecture
 

package/bin/agentic-senior-core.js

@@ -31,14 +31,15 @@ function printUsage() {
   console.log('Adapter install (one file per project):');
   console.log('  asc adapter --cursor --devin --cline --copilot --kiro --continue --zed --aider --kilocode --roo --openhands --windsurf --all\n');
   console.log('Commands:');
-  console.log('  adapter       Generate instruction-tier adapter files');
-  console.log('  global        Install rules to user-level (global) locations');
-  console.log('  uninstall     Remove ASC adapter files from this project');
-  console.log('  clean         Remove v4 per-project artifacts');
-  console.log('  status        Show detected IDEs and install hints');
-  console.log('  mcp           Start MCP stdio server');
-  console.log('  --version     Show version');
-  console.log('  --help        Show this help');
+  console.log('  adapter           Generate instruction-tier adapter files');
+  console.log('  global            Install rules to user-level (global) locations');
+  console.log('  install-git-hook  Install Git pre-commit hook for duplicate code enforcement');
+  console.log('  uninstall         Remove ASC adapter files and git hooks from this project');
+  console.log('  clean             Remove v4 per-project artifacts');
+  console.log('  status            Show detected IDEs and install hints');
+  console.log('  mcp               Start MCP stdio server');
+  console.log('  --version         Show version');
+  console.log('  --help            Show this help');
 }
 
 async function main() {
@@ -55,6 +56,12 @@ async function main() {
     return;
   }
 
+  if (commandArgument === 'install-git-hook' || commandArgument === 'git-hook') {
+    const { runGitHookCommand } = await import('../lib/cli/commands/git-hook.mjs');
+    await runGitHookCommand(commandArguments);
+    return;
+  }
+
   if (commandArgument === 'adapter') {
     const { runAdapterCommand } = await import('../lib/cli/commands/adapter.mjs');
     await runAdapterCommand(commandArguments);

package/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-senior-core",
-  "version": "6.3.0",
+  "version": "6.4.0",
   "description": "Universal AI coding rules. Write code like a staff engineer.",
   "author": "fatidaprilian",
   "license": "MIT",

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;
+}

package/lib/core/revert-detector.mjs

@@ -0,0 +1,35 @@
+import { execSync } from 'child_process';
+
+/**
+ * Detects recent git file rollbacks or reverts in the workspace to trigger signal denoising.
+ * @param {Object} options
+ * @param {string} [options.cwd] Working directory.
+ * @returns {{ hasReverts: boolean, revertedFiles: Array<string>, prompt: string }} Denoising status payload.
+ */
+export function detectRevertedFiles({ cwd = process.cwd() } = {}) {
+  try {
+    // Check unstaged or staged diffs showing file deletions/rollbacks
+    const statusOutput = execSync('git status --porcelain', { cwd, encoding: 'utf8' });
+    const lines = statusOutput.split('\n').map(l => l.trim()).filter(Boolean);
+
+    // Filter modified or deleted files
+    const modifiedOrDeleted = lines
+      .filter(line => line.startsWith(' M') || line.startsWith(' D') || line.startsWith('D '))
+      .map(line => line.substring(3).trim());
+
+    if (modifiedOrDeleted.length === 0) {
+      return { hasReverts: false, revertedFiles: [], prompt: '' };
+    }
+
+    const firstFile = modifiedOrDeleted[0];
+    const prompt = `[ASC Signal Denoising] Revert/edit detected on ${firstFile}. Was this caused by a specific UI/code slop pattern? (Run /asc-learn to log or press Enter to skip)`;
+
+    return {
+      hasReverts: true,
+      revertedFiles: modifiedOrDeleted,
+      prompt
+    };
+  } catch (err) {
+    return { hasReverts: false, revertedFiles: [], prompt: '' };
+  }
+}

package/lib/core/rule-compiler.mjs

@@ -0,0 +1,105 @@
+import fs from 'fs';
+import path from 'path';
+import { resolveActiveRules } from './adaptive-preferences.mjs';
+
+/**
+ * Compiles active syntactic preference rules into a standalone Node.js validator script string.
+ * @param {Object} options
+ * @param {string} [options.cwd] Working directory.
+ * @returns {string} Executable Node.js script code.
+ */
+export function generateValidatorScript({ cwd = process.cwd() } = {}) {
+  const { syntactic } = resolveActiveRules({ cwd });
+
+  const rulesJson = JSON.stringify(syntactic, null, 2);
+
+  return `#!/usr/bin/env node
+// # Agentic Senior Core -- Compiled Pre-Commit Validator
+// Auto-generated by Agentic Senior Core (ASC) Adaptive Preference Compiler
+// DO NOT EDIT DIRECTLY. Compiled from Track A Syntactic Rules.
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const ACTIVE_SYNTACTIC_RULES = ${rulesJson};
+
+function getStagedFiles() {
+  try {
+    const output = execSync('git diff --cached --name-only --diff-filter=ACM', { encoding: 'utf8' });
+    return output.split('\\n').map(f => f.trim()).filter(Boolean);
+  } catch (err) {
+    return [];
+  }
+}
+
+function runValidation() {
+  if (ACTIVE_SYNTACTIC_RULES.length === 0) {
+    process.exit(0);
+  }
+
+  const stagedFiles = getStagedFiles();
+  if (stagedFiles.length === 0) {
+    process.exit(0);
+  }
+
+  let violationFound = false;
+
+  for (const filePath of stagedFiles) {
+    if (!fs.existsSync(filePath)) continue;
+    // Skip binary / non-text files
+    const ext = path.extname(filePath).toLowerCase();
+    if (['.png', '.jpg', '.jpeg', '.gif', '.ico', '.pdf', '.zip'].includes(ext)) continue;
+
+    let content;
+    try {
+      content = fs.readFileSync(filePath, 'utf8');
+    } catch (e) {
+      continue;
+    }
+
+    for (const rule of ACTIVE_SYNTACTIC_RULES) {
+      if (!rule.pattern) continue;
+      try {
+        const regex = new RegExp(rule.pattern, 'i');
+        if (regex.test(content)) {
+          console.error(\`\\x1b[31m[ASC Rule Violation]\\x1b[0m File \${filePath} violates active syntactic rule:\`);
+          console.error(\`  Pattern: \${rule.pattern}\`);
+          console.error(\`  Reason:  \${rule.reason || 'Banned pattern'}\`);
+          violationFound = true;
+        }
+      } catch (err) {
+        // Invalid regex ignore
+      }
+    }
+  }
+
+  if (violationFound) {
+    console.error('\\x1b[31m[ASC Gate Abort]\\x1b[0m Commit blocked by ASC compiled syntactic preference check.');
+    process.exit(1);
+  }
+
+  process.exit(0);
+}
+
+runValidation();
+`;
+}
+
+/**
+ * Writes the compiled validator script to disk.
+ * @param {Object} options
+ * @param {string} [options.cwd] Working directory.
+ * @returns {string} Absolute path to compiled script.
+ */
+export function compileAndSaveValidator({ cwd = process.cwd() } = {}) {
+  const ascDir = path.join(cwd, '.asc', 'hooks');
+  if (!fs.existsSync(ascDir)) {
+    fs.mkdirSync(ascDir, { recursive: true });
+  }
+
+  const scriptContent = generateValidatorScript({ cwd });
+  const scriptPath = path.join(ascDir, 'pre-commit-validator.cjs');
+  fs.writeFileSync(scriptPath, scriptContent, { encoding: 'utf8', mode: 0o755 });
+  return scriptPath;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryuenn3123/agentic-senior-core",
-  "version": "6.3.0",
+  "version": "6.4.0",
   "type": "module",
   "description": "Agentic Senior Core: Universal AI coding rules and workflows. Write code like a staff engineer, not a junior.",
   "bin": {
@@ -11,13 +11,7 @@
   "files": [
     ".asc/",
     "bin/",
-    "lib/cli/commands/adapter.mjs",
-    "lib/cli/commands/global.mjs",
-    "lib/cli/commands/clean.mjs",
-    "lib/cli/commands/uninstall.mjs",
-    "lib/cli/commands/status.mjs",
-    "lib/cli/commands/mcp.mjs",
-    "lib/cli/ascx/",
+    "lib/",
     ".agents/",
     "CONVENTIONS.md",
     "gemini-extension.json",

package/plugin.yaml

@@ -1,5 +1,5 @@
 name: agentic-senior-core
-version: 6.3.0
+version: 6.4.0
 description: Universal AI coding rules. Write code like a staff engineer.
 author: fatidaprilian
 provides_hooks: