@ryuenn3123/agentic-senior-core 5.9.0 → 6.0.0

package/.agents/plugins/agentic-senior-core/commands/asc-dedup.md

@@ -0,0 +1 @@
+Run the duplicate code audit from skills/asc-dedup/SKILL.md. Scan the specified scope (directory, package, or full repo) for near-duplicate code blocks using jscpd token-level clone detection. Report clusters ranked by duplicated lines, and suggest consolidation only for patterns appearing 3+ times (Rule of Three).

package/.agents/plugins/agentic-senior-core/commands/asc-dedup.toml

@@ -0,0 +1,2 @@
+description = "On-demand duplicate code audit using token-level clone detection"
+prompt = "Load and follow the asc-dedup skill. Scan the current project (or specified scope) for near-duplicate code blocks using jscpd. Report clusters ranked by duplicated lines. Suggest consolidation only for patterns appearing 3+ times per the Rule of Three."

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

@@ -0,0 +1,21 @@
+// 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 SOURCE_EXTENSIONS = new Set([
+  'js', 'ts', 'mjs', 'cjs', 'jsx', 'tsx',
+  'py', 'rb', 'go', 'rs', 'java', 'kt', 'swift', 'cs',
+]);
+
+const LOC_DELTA_THRESHOLD = 30;
+const NEW_FILE_LINE_THRESHOLD = 50;
+const SESSION_DRIFT_THRESHOLD = 4;
+const LADDER_PULSE_INTERVAL = 3;
+
+module.exports = {
+  SOURCE_EXTENSIONS,
+  LOC_DELTA_THRESHOLD,
+  NEW_FILE_LINE_THRESHOLD,
+  SESSION_DRIFT_THRESHOLD,
+  LADDER_PULSE_INTERVAL,
+};

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

@@ -0,0 +1,283 @@
+#!/usr/bin/env node
+// Agentic Senior Core — PostToolUse duplicate-code detection hook
+// Fires after Edit/Write on qualifying source files. Runs a scoped jscpd scan
+// to detect near-duplicate code blocks. Advisory by default; configurable to block.
+// Supports Claude Code, Codex CLI, GitHub Copilot CLI, and Antigravity IDE.
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+const {
+  SOURCE_EXTENSIONS,
+  LOC_DELTA_THRESHOLD,
+  NEW_FILE_LINE_THRESHOLD,
+} = require('./constants.cjs');
+
+const JSCPD_TIMEOUT_MS = 10000;
+
+// Recognized source root directories — scan scope walks up to the first match
+const SOURCE_ROOTS = ['src', 'lib', 'app'];
+
+let inputBuffer = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => {
+  inputBuffer += chunk;
+  try {
+    const data = JSON.parse(inputBuffer);
+
+    let toolName = '';
+    let toolInput = {};
+    let isAntigravity = false;
+
+    if (data.toolCall) {
+      // Antigravity PreToolUse shape (has toolCall directly)
+      isAntigravity = true;
+      toolName = data.toolCall.name;
+      toolInput = data.toolCall.args || {};
+    } else if (data.stepIdx !== undefined && data.transcriptPath) {
+      // Antigravity PostToolUse shape — no toolCall in payload,
+      // read the tool call details from the transcript at stepIdx
+      isAntigravity = true;
+      var extracted = extractToolCallFromTranscript(data.transcriptPath, data.stepIdx);
+      if (!extracted) { process.exit(0); return; }
+      toolName = extracted.toolName;
+      toolInput = extracted.toolInput;
+    } else {
+      // Claude Code / Codex / Copilot path
+      toolName = data.tool_name || data.toolName || '';
+      toolInput = data.tool_input || data.toolInput || {};
+    }
+
+    const filePath = toolInput.file_path || toolInput.TargetFile || toolInput.path || toolInput.target_file || '';
+    if (!filePath) { process.exit(0); return; }
+
+    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();
+    const scanDir = resolveScanDir(filePath, config);
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'asc-dedup-'));
+
+    const ignoreFlags = (config.ignoreDirs || []).map(function (d) { return '--ignore "' + d + '"'; }).join(' ');
+    const minTokens = config.minTokens || 30;
+    const scanCmd = ' "' + scanDir + '" --min-tokens ' + minTokens
+      + ' --reporters json --silent --output "' + tmpDir + '" ' + ignoreFlags;
+
+    const report = runJscpdScan(scanCmd, tmpDir);
+    if (!report) { cleanup(tmpDir); process.exit(0); return; }
+
+    const finding = checkForDuplicates(report, filePath);
+    if (!finding) { cleanup(tmpDir); process.exit(0); return; }
+
+    const nudge = '[ASC Dedup] ' + path.basename(filePath) + ' looks similar to '
+      + finding.matchedFile + ' (' + finding.percent + '% overlap, '
+      + finding.lines + ' lines). Ladder step 2: does the codebase already have this? '
+      + 'Reuse it, or confirm this is intentional.';
+
+    if (config.mode === 'block') {
+      emitDeny(nudge, isAntigravity);
+    } else {
+      emitAdvisory(nudge, isAntigravity);
+    }
+
+    cleanup(tmpDir);
+    process.exit(0);
+  } catch (e) {
+    // incomplete json, wait for more chunks
+  }
+});
+
+// Extract tool call details from the Antigravity transcript at a given step index.
+// PostToolUse on Antigravity only provides stepIdx — the actual tool call args
+// must be recovered from the transcript log. Same approach as post-edit-enforce.js.
+function extractToolCallFromTranscript(transcriptPath, stepIdx) {
+  try {
+    if (!fs.existsSync(transcriptPath)) return null;
+    var lines = fs.readFileSync(transcriptPath, 'utf8').split('\n').filter(Boolean);
+
+    // 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 || '',
+            },
+          };
+        }
+      }
+    }
+    return null;
+  } catch (_) {
+    return null;
+  }
+}
+
+function isQualifyingEdit(toolName, toolInput) {
+  var isWrite = ['Write', 'write_to_file', 'write_file'].indexOf(toolName) !== -1;
+  var isEdit = ['Edit', 'replace_file_content', 'multi_replace_file_content'].indexOf(toolName) !== -1;
+
+  if (isWrite) {
+    var content = toolInput.content || toolInput.CodeContent || '';
+    return content.split('\n').length > NEW_FILE_LINE_THRESHOLD;
+  }
+  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 false;
+}
+
+function resolveScanDir(filePath, config) {
+  var cwd = process.cwd();
+
+  // User override takes priority
+  if (config.scanRoot) {
+    var override = path.resolve(cwd, config.scanRoot);
+    if (fs.existsSync(override)) return override;
+  }
+
+  // Walk up from the file's directory to find a recognized source root
+  var dir = path.dirname(path.resolve(filePath));
+  while (dir.length >= cwd.length) {
+    var basename = path.basename(dir);
+    if (SOURCE_ROOTS.indexOf(basename) !== -1) return dir;
+    var parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  // Fallback: project root
+  return cwd;
+}
+
+function loadDedupConfig() {
+  var candidates = [
+    path.join(process.cwd(), '.asc', 'dedup-config.json'),
+    path.join(process.cwd(), '.agents', 'dedup-config.json'),
+  ];
+  for (var i = 0; i < candidates.length; i++) {
+    try {
+      if (fs.existsSync(candidates[i])) {
+        return JSON.parse(fs.readFileSync(candidates[i], 'utf8'));
+      }
+    } catch (_) {}
+  }
+  return { mode: 'advisory', minTokens: 30, ignoreDirs: ['tests', 'migrations', 'generated', 'node_modules'] };
+}
+
+// minimal: attempt-then-fallback — try scan directly, fall back on failure.
+// No separate --version probes. Upgrade if jscpd provides a stable JS API.
+function runJscpdScan(scanCmd, tmpDir) {
+  var binaries = ['bunx jscpd', 'npx jscpd@5', 'npx jscpd'];
+  for (var i = 0; i < binaries.length; i++) {
+    try {
+      execSync(binaries[i] + scanCmd, {
+        timeout: JSCPD_TIMEOUT_MS,
+        stdio: 'pipe',
+        cwd: process.cwd(),
+      });
+      return loadReport(tmpDir);
+    } catch (_) {
+      // Try next binary
+    }
+  }
+  return null;
+}
+
+function loadReport(tmpDir) {
+  var 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, filePath) {
+  var duplicates = report.duplicates || [];
+  if (duplicates.length === 0) return null;
+
+  var normalizedTarget = path.resolve(filePath).replace(/\\/g, '/').toLowerCase();
+
+  for (var i = 0; i < duplicates.length; i++) {
+    var dup = duplicates[i];
+    var firstName = path.resolve(dup.firstFile.name).replace(/\\/g, '/').toLowerCase();
+    var secondName = path.resolve(dup.secondFile.name).replace(/\\/g, '/').toLowerCase();
+
+    if (firstName === normalizedTarget || secondName === normalizedTarget) {
+      var matchedFile = firstName === normalizedTarget
+        ? path.basename(dup.secondFile.name)
+        : path.basename(dup.firstFile.name);
+      var lines = dup.lines || 0;
+      // jscpd v5 reports fragments; estimate overlap percentage from line count
+      var totalLines = (report.statistics && report.statistics.total && report.statistics.total.lines) || 1;
+      var percent = Math.round((lines / totalLines) * 100);
+      return { matchedFile: matchedFile, lines: lines, percent: percent };
+    }
+  }
+  return null;
+}
+
+function emitAdvisory(nudge, isAntigravity) {
+  if (isAntigravity) {
+    process.stdout.write(JSON.stringify({
+      injectSteps: [{ ephemeralMessage: nudge }],
+    }) + '\n');
+  } else {
+    var isCopilot = Boolean(process.env.COPILOT_PLUGIN_DATA);
+    if (isCopilot) {
+      process.stdout.write(JSON.stringify({ additionalContext: nudge }) + '\n');
+    } else {
+      process.stdout.write(JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: 'PostToolUse',
+          additionalContext: nudge,
+        },
+      }) + '\n');
+    }
+  }
+}
+
+function emitDeny(reason, isAntigravity) {
+  if (isAntigravity) {
+    process.stdout.write(JSON.stringify({ decision: 'deny', reason: reason }) + '\n');
+  } else {
+    process.stdout.write(JSON.stringify({
+      allow_tool: false,
+      deny_reason: reason,
+      hookSpecificOutput: {
+        hookEventName: 'PostToolUse',
+        permissionDecision: 'deny',
+        permissionDecisionReason: reason,
+      },
+    }) + '\n');
+  }
+  process.exit(2);
+}
+
+function cleanup(tmpDir) {
+  try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch (_) {}
+}

package/.agents/plugins/agentic-senior-core/hooks/ladder-pulse.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+// Agentic Senior Core — PreInvocation ladder persistence hook
+// Counters context rot by re-injecting a short decision-ladder reminder
+// periodically, late in context, rather than relying only on rules/ content
+// that sits at the start of the conversation.
+// Antigravity-only: PreInvocation fires before every model call with
+// invocationNum in the input payload. For other hosts, the equivalent
+// pulse is integrated into post-edit-enforce.js via the sourceEditCount counter.
+
+const { LADDER_PULSE_INTERVAL } = require('./constants.cjs');
+
+const LADDER_REMINDER = '[ASC] Ladder check: (1) needed? (2) exists already \u2014 reuse? '
+  + '(3) stdlib/native? (4) existing dep? (5) one function? Then minimal code.';
+
+let inputBuffer = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => {
+    inputBuffer += chunk;
+    try {
+        const payload = JSON.parse(inputBuffer);
+        
+        let shouldInject = false;
+        const invNum = payload.invocationNum || 0;
+        if (invNum > 0 && invNum % LADDER_PULSE_INTERVAL === 0) {
+            shouldInject = true;
+        }
+
+        if (shouldInject) {
+            process.stdout.write(JSON.stringify({
+                injectSteps: [{
+                    ephemeralMessage: `**ASC LADDER PULSE**: You have completed several steps. Remember to review the 1-6 decision ladder. Document deferred debt if you take shortcuts.`
+                }]
+            }) + '\n');
+        } else {
+            process.stdout.write('{}\n');
+        }
+        process.exit(0);
+    } catch (e) {
+        // wait for more chunks
+    }
+});

package/.agents/plugins/agentic-senior-core/hooks/post-edit-enforce.js

@@ -37,22 +37,21 @@ try {
   }
 } catch (_) {}
 
-const SOURCE_EXTENSIONS = new Set([
-  'js', 'ts', 'mjs', 'cjs', 'jsx', 'tsx',
-  'py', 'rb', 'go', 'rs', 'java', 'kt', 'swift', 'cs',
-]);
-
-const LOC_DELTA_THRESHOLD = 30;
-const NEW_FILE_LINE_THRESHOLD = 50;
-const SESSION_DRIFT_THRESHOLD = 4;
+const {
+  SOURCE_EXTENSIONS,
+  LOC_DELTA_THRESHOLD,
+  NEW_FILE_LINE_THRESHOLD,
+  SESSION_DRIFT_THRESHOLD,
+  LADDER_PULSE_INTERVAL,
+} = require('./constants.cjs');
 
 // Module-level counter for Claude Code path (resets per process spawn)
 let sourceEditCount = 0;
 
 let inputBuffer = '';
 process.stdin.setEncoding('utf8');
-process.stdin.on('data', function (chunk) { inputBuffer += chunk; });
-process.stdin.on('end', function () {
+process.stdin.on('data', chunk => {
+  inputBuffer += chunk;
   try {
     const data = JSON.parse(inputBuffer);
     
@@ -66,8 +65,9 @@ process.stdin.on('end', function () {
     processSingleEdit(toolName, toolInput, function(nudge) {
       emitClaude(nudge);
     });
-  } catch (_) {
-    // Silent fail
+    process.exit(0);
+  } catch (e) {
+    // incomplete json, wait for more chunks
   }
 });
 
@@ -146,6 +146,9 @@ function processSingleEdit(toolName, toolInput, emitFn, skipArray) {
       findings.push('[ASC Session Drift] ' + SESSION_DRIFT_THRESHOLD + '+ source file edits this session. '
         + 'Re-read the decision ladder before continuing: (1) Does this need to be built? '
         + '(2) Does the codebase already have this? (3) Stdlib/native? (4) Existing dependency?');
+    } else if (sourceEditCount > 0 && sourceEditCount % LADDER_PULSE_INTERVAL === 0) {
+      findings.push('[ASC] Ladder check: (1) needed? (2) exists already \u2014 reuse? '
+        + '(3) stdlib/native? (4) existing dep? (5) one function? Then minimal code.');
     }
   }
 
@@ -243,9 +246,11 @@ function checkLocDelta(toolInput, filePath, findings) {
 function checkNewFileSize(toolInput, filePath, findings) {
   var lines = (toolInput.content || '').split('\n').length;
   if (lines > NEW_FILE_LINE_THRESHOLD) {
+    // Step 1-2 coverage ("does this already exist?") moved to dedup-gate.js
+    // which provides concrete file-name + overlap-percentage feedback.
     findings.push(
       'New file ' + path.basename(filePath) + ' created with ' + lines + ' lines. '
-      + 'Ladder step 1-2: does this need to be built? Does the codebase already have this?'
+      + 'Ladder step 5: can this be one straightforward function?'
     );
   }
 }

package/.agents/plugins/agentic-senior-core/hooks/pre-tool-dependency-gate.js

@@ -23,8 +23,8 @@ try {
 
 let inputBuffer = '';
 process.stdin.setEncoding('utf8');
-process.stdin.on('data', function (chunk) { inputBuffer += chunk; });
-process.stdin.on('end', function () {
+process.stdin.on('data', chunk => {
+  inputBuffer += chunk;
   try {
     const data = JSON.parse(inputBuffer);
     const isAntigravity = !!data.toolCall;
@@ -117,10 +117,10 @@ process.stdin.on('end', function () {
       process.exit(2);
       return;
     }
-  } catch (_) {
-    // Silent fail to ensure session stability
+    process.exit(0);
+  } catch (e) {
+    // incomplete json, wait for more chunks
   }
-  process.exit(0);
 });
 
 function isGitCommitOrPush(command) {

package/.agents/plugins/agentic-senior-core/hooks/session-pulse.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+// Agentic Senior Core — PreInvocation session pulse hook (Antigravity-specific)
+// Antigravity has no SessionStart event. This fires on the FIRST model call
+// (invocationNum === 0) to inject AGENTS.md into the conversation — the same
+// role session-start.js fills for Claude Code / Codex / Copilot via their
+// real SessionStart hook.
+// Does NOT replace session-start.js — that file still serves other hosts.
+
+const fs = require('fs');
+const path = require('path');
+
+const pluginRoot = process.env.CLAUDE_PLUGIN_ROOT || path.resolve(__dirname, '..');
+
+let inputBuffer = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => {
+    inputBuffer += chunk;
+    try {
+        const data = JSON.parse(inputBuffer);
+        
+        // Only fire on the very first model call of the session
+        if (data.invocationNum !== 0) {
+            process.stdout.write(JSON.stringify({}) + '\n');
+            process.exit(0);
+            return;
+        }
+
+        const agentsPath = path.join(pluginRoot, 'rules', 'agentic-senior-core.md');
+        let content;
+        try {
+            content = fs.readFileSync(agentsPath, 'utf8');
+        } catch (_) {
+            // Fallback to AGENTS.md at plugin root
+            content = fs.readFileSync(path.join(pluginRoot, 'AGENTS.md'), 'utf8');
+        }
+
+        process.stdout.write(JSON.stringify({
+            injectSteps: [{ ephemeralMessage: content }],
+        }) + '\n');
+        process.exit(0);
+    } catch (e) {
+        // wait for more chunks
+    }
+});

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

@@ -74,14 +74,31 @@
             "statusMessage": "ASC ladder & spec gate check..."
           },
           {
-            "type": "prompt",
-            "if": "Edit(**/package.json)",
-            "prompt": "A new dependency '$ARGUMENTS' was added to package.json. Does it duplicate Node.js standard library or platform features? If yes, return JSON: {\"hookSpecificOutput\": {\"hookEventName\": \"PostToolUse\", \"additionalContext\": \"[ASC Advisory] The newly added dependency appears to duplicate stdlib or platform features. Consider native alternatives.\"}}. If no, return {}.",
-            "timeout": 30
+            "type": "command",
+            "command": "node -e \"const p=require('path'),fs=require('fs'),os=require('os');const local=p.join(process.cwd(),'.agents','plugins','agentic-senior-core','hooks','dedup-gate.js');const global=p.join(os.homedir(),'.gemini','config','plugins','agentic-senior-core','hooks','dedup-gate.js');require(fs.existsSync(local)?local:global);\"",
+            "commandWindows": "if (Get-Command node -ErrorAction SilentlyContinue) { $root = if ($env:CLAUDE_PLUGIN_ROOT) { $env:CLAUDE_PLUGIN_ROOT } else { \"$env:USERPROFILE\\.gemini\\config\\plugins\\agentic-senior-core\" }; node \"$root\\hooks\\dedup-gate.js\" }",
+            "timeout": 15,
+            "statusMessage": "ASC duplicate-code scan..."
           }
         ]
       }
     ],
+    "PreInvocation": [
+      {
+        "type": "command",
+        "command": "node -e \"const p=require('path'),fs=require('fs'),os=require('os');const local=p.join(process.cwd(),'.agents','plugins','agentic-senior-core','hooks','session-pulse.js');const global=p.join(os.homedir(),'.gemini','config','plugins','agentic-senior-core','hooks','session-pulse.js');require(fs.existsSync(local)?local:global);\"",
+        "commandWindows": "if (Get-Command node -ErrorAction SilentlyContinue) { $root = if ($env:CLAUDE_PLUGIN_ROOT) { $env:CLAUDE_PLUGIN_ROOT } else { \"$env:USERPROFILE\\.gemini\\config\\plugins\\agentic-senior-core\" }; node \"$root\\hooks\\session-pulse.js\" }",
+        "timeout": 5,
+        "statusMessage": "Loading ASC rules..."
+      },
+      {
+        "type": "command",
+        "command": "node -e \"const p=require('path'),fs=require('fs'),os=require('os');const local=p.join(process.cwd(),'.agents','plugins','agentic-senior-core','hooks','ladder-pulse.js');const global=p.join(os.homedir(),'.gemini','config','plugins','agentic-senior-core','hooks','ladder-pulse.js');require(fs.existsSync(local)?local:global);\"",
+        "commandWindows": "if (Get-Command node -ErrorAction SilentlyContinue) { $root = if ($env:CLAUDE_PLUGIN_ROOT) { $env:CLAUDE_PLUGIN_ROOT } else { \"$env:USERPROFILE\\.gemini\\config\\plugins\\agentic-senior-core\" }; node \"$root\\hooks\\ladder-pulse.js\" }",
+        "timeout": 5,
+        "statusMessage": "ASC ladder pulse..."
+      }
+    ],
     "PostInvocation": [
       {
         "type": "command",

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

@@ -1,7 +1,7 @@
 {
   "name": "agentic-senior-core",
-  "version": "5.9.0",
-  "description": "Universal AI coding rules. Write code like a staff engineer.",
+  "version": "6.0.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": [
     "rules/"

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

@@ -80,6 +80,10 @@ whether to invoke it. Skip this for trivial edits.
 - Non-trivial feature in an existing codebase → `/asc-add-feature` (research/plan gate before implementation)
 - Refactor spanning multiple files or changing architecture → `/asc-refactor` (classifies scope, gates on high-level changes)
 
+### Enforcement Fallbacks (For hosts without hook support)
+- **Duplicate-Code Check**: When creating new functions or components, actively check for existing near-duplicates across directories (not just siblings) before implementing. If a similar pattern exists, reuse it. Apply the Rule of Three: consolidate only if a pattern appears 3+ times.
+- **Ladder Persistence**: Before completing a task, explicitly verify you have selected the lowest feasible step on the 1-6 decision ladder. Document deferred technical debt (via `/asc-debt` or inline comment) if a shortcut is taken.
+
 ## Response Style
 
 Lead with what the developer needs to act: the command, file path, code change, or decision point. Follow with context only when the action depends on it.

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

@@ -0,0 +1,52 @@
+---
+name: asc-dedup
+description: >
+  Trigger this skill when the user says: "find duplicate code", "check
+  for clones", "audit for duplication", "is this repeated elsewhere",
+  "scan for copy-paste", "run jscpd", "dedup report", "consolidate
+  duplicate logic". Use for whole-repo or whole-directory duplication
+  audits on demand — this is a deep, on-demand scan, distinct from the
+  continuous per-edit check already enforced by the dedup-gate hook.
+---
+
+# Duplicate Code Audit
+
+On-demand deep duplication scan using jscpd (token-level clone detection). Distinct from the continuous per-edit `dedup-gate` hook — this skill runs a full-scope scan and produces a ranked report.
+
+Grounded in: GitClear 2024 analysis (211M LOC, 8x increase in duplicated code blocks in AI-assisted repos). Token-level clone detection catches near-duplicates that differ in names/structure — something diff-only review tools and pattern matching cannot do.
+
+## When to Use
+
+- User asks to scan a directory, package, or entire repo for duplicated code
+- Before a refactoring pass, to identify consolidation targets
+- After a multi-file feature addition, to verify no accidental duplication was introduced
+
+## Scan Procedure
+
+1. Determine scope from user's request (specific directory, package, or full repo).
+2. Check for `.asc/dedup-config.json` — use `ignoreDirs` and `minTokens` from it if present.
+3. Run: `npx jscpd@5 "<scope>" --min-tokens <minTokens> --reporters console,json --output ./report/`
+   - If `bunx` is available, prefer `bunx jscpd` for speed (24-37x faster per jscpd v5 benchmarks).
+   - Apply `--ignore` flags from config `ignoreDirs`.
+4. Parse the JSON report and present findings ranked by number of duplicated lines (largest clusters first).
+
+## Report Format
+
+For each duplicate cluster, report:
+- **Files involved** and line ranges
+- **Duplicated lines count** and overlap percentage
+- **Consolidation recommendation** (only if pattern appears 3+ times — Rule of Three)
+
+## Consolidation Rules
+
+Per this repo's asc-refactor YAGNI and Rule of Three conventions:
+
+- **2 occurrences**: Report the duplication. Do NOT suggest a shared abstraction — "three similar lines is better than a premature abstraction."
+- **3+ occurrences**: Suggest the smallest safe consolidation — extract a shared function, component, or module. Explain what risk or friction the duplication creates and what the consolidated shape looks like.
+- **Structural boilerplate** (imports, prop types, export statements): Flag but do not count as actionable duplication — these are framework-mandated patterns, not logic clones.
+
+## Integration
+
+- The `dedup-gate` hook provides continuous per-edit detection (PostToolUse, scoped, fast).
+- This skill provides deep on-demand audits (full scope, thorough, user-triggered).
+- Findings from either can be logged to the debt ledger via `/asc-debt` if deferred.

package/.asc/dedup-config.json

@@ -0,0 +1,6 @@
+{
+  "mode": "advisory",
+  "minTokens": 30,
+  "scanRoot": null,
+  "ignoreDirs": ["tests", "migrations", "generated", "node_modules"]
+}

package/AGENTS.md

@@ -75,6 +75,9 @@ whether to invoke it. Skip this for trivial edits.
 - Non-trivial feature in an existing codebase → `/asc-add-feature` (research/plan gate before implementation)
 - Refactor spanning multiple files or changing architecture → `/asc-refactor` (classifies scope, gates on high-level changes)
 
+### Enforcement Fallbacks (For hosts without hook support)
+- **Duplicate-Code Check**: When creating new functions or components, actively check for existing near-duplicates across directories (not just siblings) before implementing. If a similar pattern exists, reuse it. Apply the Rule of Three: consolidate only if a pattern appears 3+ times.
+- **Ladder Persistence**: Before completing a task, explicitly verify you have selected the lowest feasible step on the 1-6 decision ladder. Document deferred technical debt (via `/asc-debt` or inline comment) if a shortcut is taken.
 ## Response Style
 
 Lead with what the developer needs to act: the command, file path, code change, or decision point. Follow with context only when the action depends on it.

package/README.md

@@ -2,7 +2,7 @@
 
 # Agentic-Senior-Core
 
-### Universal AI coding rules. Write code like a staff engineer, not a junior.
+### Universal AI coding rules. Because your AI writes code like it gets paid by the line.
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](CONTRIBUTING.md)
@@ -13,326 +13,23 @@
 
 </div>
 
-## Project Status
-
-| Component | Status | Notes |
-|-----------|--------|-------|
-| Rules & Skills (Instructional Layer) | Stable | Universal across 23+ AI tools |
-| Hooks (Enforcement Layer) | Stable | Claude Code, Antigravity IDE, Copilot CLI, Cursor |
-| `ascx` (Output Compression) | Beta | 7 adapters (git, npm, tsc, rg); unsupported commands pass through safely |
-| CLI (`asc adapter`, `asc global`) | Stable | Install adapters for any supported host |
-
-## How Skills & Hooks Work (Multi-Tier Architecture)
-
-Agentic Senior Core operates on a two-tier architecture:
-
-1. **Instructional Layer (Universal — Works in 23+ AI Tools)**:
-   - **Rules (`AGENTS.md` / `agentic-senior-core.md`) & Skills (`SKILL.md`)** are cross-compatible across **Google Antigravity IDE, Claude Code, Cursor, Windsurf, Copilot, Codex, Kiro, Roo, OpenCode, Zed, Aider, etc.**.
-   - **Automatic Skill Triggering**: Agents attempt to detect and load skills if your prompt matches the skill's description (e.g., asking "perform a security audit" loads `asc-audit`).
-   - **Manual Skill Triggering (Highly Recommended)**: Explicitly call skills using commands like `/asc-refactor` or `/asc-new-project` for guaranteed execution.
-
-2. **Active Enforcement Layer (Hooks — Host-Specific Hard Guardrails)**:
-   - **Hard-Block Guardrails**: For tools supporting active hook execution engines (Claude Code, GitHub Copilot CLI, Google Antigravity IDE, Cursor), ASC automatically intercepts tool calls:
-     - **PreToolUse Hard Block**: Immediately rejects edits adding stdlib-duplicating dependencies (e.g., `lodash`, `moment`, `uuid`) before execution (`permissionDecision: "deny"`). Escape hatch available via `.asc/dependency-allowlist.json`.
-     - **PostToolUse Advisory**: Soft nudges for LOC deltas, spec drift, and workflow gate bypasses.
-
----
-
-## Install
-
-### Step 1: Install / Update the package
+## Quick Start
 
+### 1. Install the package
 To install or forcefully update to the absolute latest version:
 
 ```bash
 npm install -g @ryuenn3123/agentic-senior-core@latest
 ```
 
-> [!TIP]
-> **Why not `npm update -g`?** npm's update command aggressively respects SemVer restrictions and local cache, which can trap you on older patch versions. Always use `@latest` to forcefully pull the absolute newest build.
-
-### Step 2: Set up for your AI tool
-
-<details>
-<summary><b>Claude Code</b> (terminal agent)</summary>
-
-Rules load automatically via plugin hooks. No per-project files needed.
-
-From inside Claude Code, add the marketplace then install:
-
-```
-/plugin marketplace add fatidaprilian/Agentic-Senior-Core
-/plugin install agentic-senior-core@agentic-senior-core
-```
-
-Or from your terminal shell:
-
-```bash
-claude plugin marketplace add fatidaprilian/Agentic-Senior-Core
-claude plugin install agentic-senior-core@agentic-senior-core
-```
-
-After install, every Claude Code session injects the rules on startup -- including subagents.
-
-</details>
-
-<details>
-<summary><b>Codex CLI</b> (terminal agent)</summary>
-
-```bash
-codex plugins install agentic-senior-core
-```
-
-Rules load automatically via plugin hooks on every session.
-
-</details>
-
-<details>
-<summary><b>Gemini CLI</b> (terminal agent)</summary>
-
-Auto-detected. Gemini CLI reads `gemini-extension.json` from the installed package and loads `AGENTS.md` as context. Commands available as `.toml` format (`/asc-refactor`, `/asc-review`, `/asc-audit`).
-
-</details>
-
-<details>
-<summary><b>Copilot CLI</b> (terminal agent)</summary>
-
-Plugin files ship at `.github/plugin/`. After global npm install, register the plugin per your Copilot CLI version. Rules inject via hooks on every session.
-
-</details>
-
-<details>
-<summary><b>Cursor</b> (IDE)</summary>
-
-Run from your project root:
-
-```bash
-asc adapter --cursor
-```
-
-This copies one file to `.cursor/rules/agentic-senior-core.mdc`. Cursor reads it automatically on every session. Repeat per project.
-
-</details>
-
-<details>
-<summary><b>Windsurf / Devin Desktop</b> (IDE)</summary>
-
-Windsurf was acquired by Cognition and renamed to Devin Desktop. Use `--devin` for the preferred path:
-
-```bash
-asc adapter --devin
-```
-
-This copies one file to `.devin/rules/agentic-senior-core.md`. For legacy Windsurf installations:
-
-```bash
-asc adapter --windsurf
-```
-
-Repeat per project — or install once globally with `asc global --windsurf` (writes `~/.codeium/windsurf/memories/global_rules.md`, applies to all workspaces; skipped if you already have your own global rules file).
-
-</details>
-
-<details>
-<summary><b>Cline</b> (VS Code extension)</summary>
-
-```bash
-asc adapter --cline
-```
-
-Copies one file to `.clinerules/agentic-senior-core.md`. Repeat per project — or install once globally with `asc global --cline` (rules land in `~/Documents/Cline/Rules/`, apply to all projects).
-
-</details>
-
-<details>
-<summary><b>GitHub Copilot</b> (VS Code extension)</summary>
-
-```bash
-asc adapter --copilot
-```
-
-Copies one file to `.github/copilot-instructions.md`. Repeat per project — or install once globally with `asc global --copilot` (user-level instructions file in your VS Code profile, applies to all workspaces).
-
-</details>
-
-<details>
-<summary><b>Kiro</b> (IDE)</summary>
-
-```bash
-asc adapter --kiro
-```
-
-Copies one file to `.kiro/steering/agentic-senior-core.md`. Repeat per project. A global option exists (`asc global --kiro` → `~/.kiro/steering/`), but some Kiro builds have known bugs loading global steering — prefer the per-project adapter if rules are not picked up.
-
-</details>
-
-<details>
-<summary><b>Continue</b> (VS Code extension)</summary>
-
-```bash
-asc adapter --continue
-```
-
-Copies one file to `.continue/rules/agentic-senior-core.md`. Repeat per project.
-
-</details>
-
-<details>
-<summary><b>Zed</b> (IDE)</summary>
-
-```bash
-asc adapter --zed
-```
-
-Copies one file to `.zed/rules/agentic-senior-core.md`. Zed also reads `AGENTS.md` natively, so this is optional if you already have AGENTS.md in your project. Repeat per project.
-
-</details>
-
-<details>
-<summary><b>Aider</b> (terminal agent)</summary>
-
-```bash
-asc adapter --aider
-```
-
-Copies one file to `CONVENTIONS.md` at project root. Aider reads this automatically. Repeat per project — or set it once globally in `~/.aider.conf.yml` with an absolute path into the npm package (`read: <npm root -g>/@ryuenn3123/agentic-senior-core/CONVENTIONS.md`). That pointer auto-updates with `npm update -g`.
-
-</details>
-
-<details>
-<summary><b>Kilo Code</b> (VS Code extension)</summary>
-
-```bash
-asc adapter --kilocode
-```
-
-Copies one file to `.kilocode/rules/agentic-senior-core.md`. Repeat per project — or install once globally with `asc global --kilocode`. On Kilo v7+, the zero-maintenance option is pointing the `instructions:` array in `~/.config/kilo/kilo.jsonc` at the rules file inside the npm package (auto-updates with `npm update -g`).
-
-</details>
-
-<details>
-<summary><b>Roo Code</b> (VS Code extension)</summary>
-
-```bash
-asc adapter --roo
-```
-
-Copies one file to `.roo/rules/agentic-senior-core.md`. Repeat per project — or install once globally with `asc global --roo` (`~/.roo/rules/`). Note: Roo Code was discontinued in May 2026; support is kept for existing installs.
-
-</details>
-
-<details>
-<summary><b>OpenHands</b></summary>
-
-```bash
-asc adapter --openhands
-```
-
-Copies one file to `.openhands/microagents/agentic-senior-core.md`. Repeat per project — or install once globally with `asc global --openhands` (`~/.openhands/microagents/`, loaded in all conversations for CLI/headless/dev modes; Docker runs need the directory mounted).
-
-</details>
-
-<details>
-<summary><b>Google Antigravity (2.0, IDE, and CLI)</b></summary>
-
-**Option A -- workspace rules (per project for 2.0 and IDE only):**
-
-Copy the rules file into your project's `.agents/rules/` directory:
-
-```bash
-# Create the directory first, then copy
-mkdir -p .agents/rules
-
-# From the npm package (after Step 1)
-cp "$(npm root -g)/@ryuenn3123/agentic-senior-core/.agents/rules/agentic-senior-core.md" .agents/rules/
-```
-
-PowerShell (Windows):
-```powershell
-mkdir .agents\rules -Force
-cp "$(npm root -g)/@ryuenn3123/agentic-senior-core/.agents/rules/agentic-senior-core.md" .agents\rules\
-```
-
-Antigravity IDE and 2.0 read it automatically with `trigger: always_on`. *(Note: Antigravity CLI does not support workspace plugins, use Option B for CLI).*
-
-**Option B -- global install (all projects and ALL clients):**
-
-One command (works on all platforms):
-
-```bash
-asc global --antigravity
-```
-
-This automatically stages the plugin bundle (skills, rules, hooks, and MCP servers) for:
-- **Antigravity 2.0 & IDE** (`~/.gemini/config/plugins/agentic-senior-core/`)
-- **Antigravity CLI** (`~/.gemini/antigravity-cli/plugins/agentic-senior-core/`)
-
-If you previously installed to legacy locations (v5.8.4 or earlier), the old paths are cleaned up automatically.
-
-> Note: `npm update -g` refreshes the npm package only. The global copy does not auto-update -- re-run `asc global --antigravity` after each update.
-
-> **WSL / dual-environment:** `asc global --antigravity` writes to the HOME directory of the current environment. If you use both Windows native and WSL, run it separately in each terminal.
-
-</details>
-
-<details>
-<summary><b>Devin / Hermes / OpenCode / OpenClaw</b></summary>
-
-Plugin manifests ship in the npm package at their standard paths (`.devin-plugin/`, `plugin.yaml`, `.opencode/plugins/`, `.openclaw/skills/`). After global npm install, each host auto-discovers or manually register per host docs.
-
-</details>
-
-<details>
-<summary><b>All IDE adapters at once</b></summary>
-
-```bash
-asc adapter --all
-```
-
-Generates adapter files for Cursor, Devin Desktop, Windsurf, Cline, Copilot, Kiro, Continue, Zed, Aider, Kilo Code, Roo Code, and OpenHands in one go.
-
-</details>
-
-**Terminal agents** (Claude Code, Codex, Gemini, Copilot CLI) = install once, always-on, zero per-project files.
-**IDE agents** = one file per project via `asc adapter`, or install once globally via `asc global` (below).
-
-### Global install (all projects, zero project files)
-
-Most IDE tools also support user-level rules that apply to **every project** — no files in any repo root. One command installs them all:
+### 2. Set up globally (Recommended)
+To automatically configure all supported IDEs and Agents at once across your entire system, run:
 
 ```bash
 asc global --all
 ```
 
-| Tool | Global location | Notes |
-|------|----------------|-------|
-| Google Antigravity (2.0, IDE, CLI) | `~/.gemini/config/plugins/...` and `~/.gemini/antigravity-cli/plugins/...` | Plugin bundle (skills, hooks, rules) |
-| Cline | `~/Documents/Cline/Rules/` | Toggleable in the Cline rules panel |
-| Kilo Code | `~/.kilocode/rules/` | Or point `instructions:` in `~/.config/kilo/kilo.jsonc` at the npm package path — that variant auto-updates |
-| Kiro | `~/.kiro/steering/` | Some builds have global-steering loading bugs; fall back to `asc adapter --kiro` |
-| OpenHands | `~/.openhands/microagents/` | CLI/headless/dev modes; Docker runs need the mount |
-| Windsurf / Devin Desktop | `~/.codeium/windsurf/memories/global_rules.md` | 6,000-char global limit (ASC rules fit); skipped if you already have your own file |
-| GitHub Copilot (VS Code) | VS Code profile `prompts/` folder | Installed as a user `*.instructions.md` with `applyTo: '**'` |
-| Roo Code | `~/.roo/rules/` | Roo Code was discontinued May 2026; kept for existing installs |
-
-Tools without a global rules **file** (manual one-time setup instead):
-
-- **Cursor** — Settings → Rules → User Rules: paste the contents of `AGENTS.md` (plain text field; a global rules directory is still a Cursor feature request).
-- **Zed** — Rules Library in the Agent Panel: create a rule from `AGENTS.md` and mark it as default (paper clip icon).
-- **Continue** — add a rules block to the global `config.yaml`.
-- **Aider** — add `read: <absolute path to npm package>/CONVENTIONS.md` in `~/.aider.conf.yml`. This is a live pointer: it auto-updates with `npm update -g`, no re-copy ever.
-
-Global rules load first; per-project adapter files (if present) take precedence on conflicts in every tool that supports both.
-
-### Updating
-
-Already installed? Just update the global package:
-
-```bash
-npm update -g @ryuenn3123/agentic-senior-core
-```
-
-Terminal agent plugins pick up the new version automatically on next session. Global installs and IDE adapter files are static copies — after updating, re-run `asc global --all` once and `asc adapter --all` in each project that uses per-project files. (Aider's `read:` pointer and Kilo's `kilo.jsonc` path variant auto-update — nothing to re-run.)
+**[See the full Installation Guide](docs/INSTALLATION.md)** for per-project (local) setups or specific tool instructions.
 
 ---
 
@@ -351,16 +48,6 @@ This plugin loads universal engineering rules on every session. Before writing a
 5. Can this be one straightforward function?
 6. Only then: write the minimum code that works.
 
-## Marking Simplification
-
-When you pick the minimal option at step 5 or 6, and it isn't obviously trivial:
-- Leave a one-line comment noting why, and the upgrade trigger if there is a ceiling.
-  Example: `// minimal: single global lock — split per-account if throughput becomes an issue`
-- Leave one runnable check (assertion, small test, or `__main__` demo) proving it works.
-  Skip only for genuinely trivial one-liners.
-
-The rules also cover security, architecture, testing, error handling, API design, database safety, frontend accessibility, infrastructure, resilience, and async patterns. All universal invariants -- no project-specific configuration needed.
-
 ### Before / After
 
 <details>
@@ -384,9 +71,7 @@ app.post('/users', (req, res) => {
   });
 });
 ```
-
 Issues: no input validation, SQL injection, plaintext password stored and returned, internal error details leaked, no auth check.
-
 </details>
 
 <details>
@@ -406,152 +91,39 @@ app.post('/users', authenticate, async (req, res) => {
   res.status(201).json({ name, email });
 });
 ```
-
 Validated input, parameterized query, hashed password, safe error response, auth middleware, no sensitive data in response.
-
 </details>
 
-### Not lazy about
-
-Input validation at trust boundaries, parameterized queries, auth checks, error handling that prevents data loss, accessibility, anything explicitly requested. These are never skipped.
-
----
-
-## Supported Hosts
-
-| Host | Type | Install | Per-project files? |
-|------|------|---------|-------------------|
-| Claude Code | Terminal agent | `/plugin install` | No |
-| Codex CLI | Terminal agent | `codex plugins install` | No |
-| Gemini CLI | Terminal agent | Auto-detected | No |
-| Copilot CLI | Terminal agent | Plugin registration | No |
-| Devin | Terminal agent | Auto-detected | No |
-| Hermes | Terminal agent | Plugin registration | No |
-| OpenCode | Terminal agent | Auto-detected | No |
-| OpenClaw | Terminal agent | Auto-detected | No |
-| Antigravity IDE | IDE | `asc global --antigravity` | No (global) |
-| Antigravity CLI | Terminal agent | `agy plugin install` | No |
-| Cursor | IDE | `asc adapter --cursor` | Yes (1 file) — or paste User Rules once |
-| Devin Desktop | IDE | `asc adapter --devin` | Yes (1 file) |
-| Windsurf (legacy) | IDE | `asc global --windsurf` | No (global) — or `asc adapter --windsurf` |
-| Cline | VS Code ext | `asc global --cline` | No (global) — or `asc adapter --cline` |
-| GitHub Copilot | VS Code ext | `asc global --copilot` | No (global) — or `asc adapter --copilot` |
-| Kiro | IDE | `asc adapter --kiro` | Yes (1 file) — global via `asc global --kiro` (buggy in some builds) |
-| Continue | VS Code ext | `asc adapter --continue` | Yes (1 file) — or global config.yaml rules |
-| Zed | IDE | `asc adapter --zed` | Yes (1 file) — or default rule in Rules Library |
-| Aider | Terminal agent | `asc adapter --aider` | Yes (1 file) — or `read:` pointer in `~/.aider.conf.yml` |
-| Kilo Code | VS Code ext | `asc global --kilocode` | No (global) — or `asc adapter --kilocode` |
-| Roo Code | VS Code ext | `asc global --roo` | No (global) — discontinued May 2026 |
-| OpenHands | Agent | `asc global --openhands` | No (global) — or `asc adapter --openhands` |
-
----
-
-## Commands
-
-Available on plugin hosts (Claude Code, Codex, Gemini CLI):
-
-| Command | Purpose |
-|---------|---------|
-| `/asc-new-project` | Greenfield workflow (Define -> Spec -> Implement -> Validate) |
-| `/asc-add-feature` | Brownfield workflow (Research -> Plan -> Implement) |
-| `/asc-refactor` | Structured refactoring workflow |
-| `/asc-review` | Production-risk code review with severity-ordered findings |
-| `/asc-audit` | Security and architecture audit |
-| `/asc-reference` | Domain-specific rules (testing, API, database, frontend, infra, resilience) |
-| `/asc-debt` | Track deferred enforcement violations (add, list, resolve, summary) |
-| `/asc-help` | Show available commands |
-
----
-
-## CLI
-
-```bash
-asc adapter [--cursor|--devin|--windsurf|--cline|--copilot|--kiro|--continue|--zed|--aider|--kilocode|--roo|--openhands|--all]
-asc global [--antigravity|--cline|--kilocode|--kiro|--openhands|--windsurf|--copilot|--roo|--all]
-asc uninstall [--dry-run]
-asc clean [--dry-run]
-asc status
-asc mcp
-asc --version
-asc --help
-```
-
-`ascx` is a token-saving command wrapper that compresses noisy output while preserving debugging evidence. Install globally and use as: `ascx git status`, `ascx npm test`.
-
----
-
-## Works With Other Plugins
-
-ASC covers security, architecture, testing, API design, database safety, accessibility, infrastructure, and resilience — domains that code-reduction and minimalism plugins explicitly leave out of scope. They reduce volume; ASC enforces safety on what remains.
-
-Use them together. No conflicts — ASC is designed to be complementary.
-
 ---
 
-## Benchmarks
-
-Measured on `claude-opus-4-6` using headless Claude Code sessions against real tasks.
+## Configuration & Overrides
 
-| | LOC | Tokens | Cost | Duration | Safety |
-|---|---|---|---|---|---|
-| **Simple tasks** | 0% | -3% to -8% | -1% | -2% to -13% | 100% |
-| **Complex tasks** | **-18%** | **-30%** | **-42%** | **-18%** | 100% |
+By default, ASC works perfectly out of the box with zero configuration. It enforces guardrails silently in the background. 
 
-On complex, ambiguous tasks (auth systems, insecure CRUD refactors) — where over-engineering typically occurs — ASC produces **18% less code**, uses **30% fewer tokens**, costs **42% less**, and finishes **18% faster**.
+If you need to override these defaults (e.g., to whitelist a specific dependency or ignore specific folders for code-duplication scanning), you can create an `.asc/` folder in your project root.
 
-On trivial tasks the model is already concise, so gains are marginal.
-
-Full methodology and raw data: [`benchmarks/RESULTS.md`](benchmarks/RESULTS.md)
-
-> Model: `claude-opus-4-6` · n=1-2 per task · Baseline = Claude without rules (not zero-prompt).
-> Opus is inherently disciplined — gains on more verbose models would likely be larger.
+**[Read the Configuration Guide](docs/CONFIGURATION.md)**
 
 ---
 
-## Migration from v4.x
-
-v5.0 is a breaking change. The per-project system (`.agent-context/`, bridge files, project scaffolding) is replaced by the universal plugin system.
+## Commands & CLI
 
-Clean up v4 artifacts from any project:
-```bash
-# Preview what will be removed
-asc clean --dry-run
-
-# Remove v4 files (.agent-context/, AGENTS.md, CLAUDE.md, GEMINI.md, etc.)
-asc clean
-```
+ASC provides powerful commands to steer your agents (e.g. `/asc-refactor`, `/asc-audit`). 
+It also provides a CLI to manage your local setup (e.g. `asc adapter --all`, `asc global --all`).
 
-This removes `.agent-context/`, `AGENTS.md`, `CLAUDE.md`, `GEMINI.md`, and other v4 bridge files from the current project directory. The global plugin replaces all of them.
+**[See all available CLI Options and Agent Commands](docs/INSTALLATION.md#commands--cli)**
 
 ---
 
-## Token Budget
-
-| Component | Tokens | When loaded |
-|-----------|--------|------------|
-| Rules (`AGENTS.md`) | ~1,200 | Every session + every subagent |
-| Each skill | ~500-800 | On user invocation only |
-| Commands | 0 | Metadata only |
+## Documentation Index
 
-Total always-on cost: ~1,200 tokens per session.
+- **[Installation & Supported Hosts](docs/INSTALLATION.md)** - Setup instructions for Claude Code, Copilot, Antigravity, Cursor, Windsurf, Zed, Aider, and more.
+- **[Configuration Overrides](docs/CONFIGURATION.md)** - How to use `.asc/dedup-config.json` and `.asc/dependency-allowlist.json`.
+- **[Architecture & Philosophy](docs/ARCHITECTURE.md)** - How the hooks work, our engineering principles, and Migration guide from v4.x.
+- **[Benchmarks](benchmarks/RESULTS.md)** - ASC produces **18% less code**, uses **30% fewer tokens**, costs **42% less**, and finishes **18% faster**.
 
 ---
 
-## Grounded In
-
-Every rule and skill workflow is derived from established engineering standards, not invented conventions.
-
-| Domain | Standards |
-|--------|-----------|
-| Security & audit | OWASP Top 10, OWASP ASVS v4, CWE classification, CVSS report structure |
-| Code review | OWASP Risk Rating Methodology, Google Engineering Practices |
-| Architecture | Clean Architecture, Hexagonal Architecture |
-| Workflows | RPI & QRSPI (Dex Horthy/HumanLayer), SDD (GitHub Spec Kit) |
-| Refactoring | Fowler's Refactoring, Rule of Three, YAGNI (XP/Kent Beck) |
-| Database | Fowler's Money Pattern, UTC timestamp convention, migration versioning |
-| Accessibility | WCAG 2.2 AA |
-| Resilience | Nygard's Release It!, AWS Well-Architected Reliability Pillar |
-| Technical debt | Cunningham's debt metaphor (1992) |
-| Instruction design | Low instruction density for higher LLM compliance — supported by IFScale (arXiv:2507.11538) and RECAST (arXiv:2505.19030) |
+## Works With Other Plugins
 
-The decision ladder (check before building) and debt ledger format are ASC-specific implementations grounded in these principles.
+ASC covers security, architecture, testing, API design, database safety, accessibility, infrastructure, and resilience — domains that code-reduction and minimalism plugins explicitly leave out of scope. They reduce volume; ASC enforces safety on what remains. Use them together. No conflicts — ASC is designed to be complementary.

package/gemini-extension.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryuenn3123/agentic-senior-core",
-  "version": "5.9.0",
+  "version": "6.0.0",
   "type": "module",
   "description": "Agentic Senior Core: Universal AI coding rules and workflows. Write code like a staff engineer, not a junior.",
   "bin": {
@@ -9,6 +9,7 @@
     "ascx": "bin/ascx.js"
   },
   "files": [
+    ".asc/",
     "bin/",
     "lib/cli/commands/adapter.mjs",
     "lib/cli/commands/global.mjs",

package/plugin.yaml

@@ -1,5 +1,5 @@
 name: agentic-senior-core
-version: 5.9.0
+version: 6.0.0
 description: Universal AI coding rules. Write code like a staff engineer.
 author: fatidaprilian
 provides_hooks:
@@ -18,6 +18,7 @@ provides_skills:
   - asc-add-feature
   - asc-audit
   - asc-debt
+  - asc-dedup
   - asc-new-project
   - asc-refactor
   - asc-reference