diff --git a/.aios-core/core/code-intel/code-intel-client.js b/.aios-core/core/code-intel/code-intel-client.js
index 2717d699f..f850c9eca 100644
--- a/.aios-core/core/code-intel/code-intel-client.js
+++ b/.aios-core/core/code-intel/code-intel-client.js
@@ -1,6 +1,7 @@
'use strict';
const { CodeGraphProvider } = require('./providers/code-graph-provider');
+const { RegistryProvider } = require('./providers/registry-provider');
// --- Constants (adjustable, not hardcoded magic numbers) ---
const CIRCUIT_BREAKER_THRESHOLD = 3;
@@ -51,10 +52,19 @@ class CodeIntelClient {
/**
* Register default providers based on configuration.
+ * Provider priority: RegistryProvider FIRST (native, T1), then CodeGraphProvider (MCP, T3).
+ * First provider with isAvailable() === true wins.
* @private
*/
_registerDefaultProviders(options) {
- // Code Graph MCP is the primary (and currently only) provider
+ // RegistryProvider — native, T1, always available when registry exists
+ const registryProvider = new RegistryProvider({
+ registryPath: options.registryPath || null,
+ projectRoot: options.projectRoot || null,
+ });
+ this._providers.push(registryProvider);
+
+ // Code Graph MCP — T3, available when mcpCallFn is configured
const codeGraphProvider = new CodeGraphProvider({
mcpServerName: options.mcpServerName || 'code-graph',
mcpCallFn: options.mcpCallFn || null,
@@ -74,6 +84,7 @@ class CodeIntelClient {
/**
* Detect and return the first available provider.
+ * Uses polymorphic isAvailable() — first provider that returns true wins.
* @returns {import('./providers/provider-interface').CodeIntelProvider|null}
* @private
*/
@@ -81,10 +92,13 @@ class CodeIntelClient {
if (this._activeProvider) return this._activeProvider;
for (const provider of this._providers) {
- // A provider is considered "available" if it has a configured mcpCallFn
- if (provider.options && typeof provider.options.mcpCallFn === 'function') {
- this._activeProvider = provider;
- return provider;
+ try {
+ if (typeof provider.isAvailable === 'function' && provider.isAvailable()) {
+ this._activeProvider = provider;
+ return provider;
+ }
+ } catch (_err) {
+ // Provider threw during availability check — treat as unavailable
}
}
diff --git a/.aios-core/core/code-intel/hook-runtime.js b/.aios-core/core/code-intel/hook-runtime.js
new file mode 100644
index 000000000..5b9ceda61
--- /dev/null
+++ b/.aios-core/core/code-intel/hook-runtime.js
@@ -0,0 +1,186 @@
+'use strict';
+
+const path = require('path');
+const { RegistryProvider } = require('./providers/registry-provider');
+
+/** Cached provider instance (survives across hook invocations in same process). */
+let _provider = null;
+let _providerRoot = null;
+
+/**
+ * Get or create a RegistryProvider singleton.
+ * Resets if projectRoot changes between calls.
+ * @param {string} projectRoot - Project root directory
+ * @returns {RegistryProvider}
+ */
+function getProvider(projectRoot) {
+ if (!_provider || _providerRoot !== projectRoot) {
+ _provider = new RegistryProvider({ projectRoot });
+ _providerRoot = projectRoot;
+ }
+ return _provider;
+}
+
+/**
+ * Resolve code intelligence context for a file being written/edited.
+ *
+ * Queries RegistryProvider for:
+ * - Entity definition (path, layer, purpose, type)
+ * - References (files that use this entity)
+ * - Dependencies (entities this file depends on)
+ *
+ * @param {string} filePath - Absolute or relative path to the target file
+ * @param {string} cwd - Project root / working directory
+ * @returns {{ entity: Object|null, references: Array|null, dependencies: Object|null }|null}
+ */
+async function resolveCodeIntel(filePath, cwd) {
+ if (!filePath || !cwd) return null;
+
+ try {
+ const provider = getProvider(cwd);
+ if (!provider.isAvailable()) return null;
+
+ // Normalize to relative path (registry uses relative paths)
+ let relativePath = filePath;
+ if (path.isAbsolute(filePath)) {
+ relativePath = path.relative(cwd, filePath).replace(/\\/g, '/');
+ } else {
+ relativePath = filePath.replace(/\\/g, '/');
+ }
+
+ // Run all three queries in parallel
+ const [definition, references, dependencies] = await Promise.all([
+ provider.findDefinition(relativePath),
+ provider.findReferences(relativePath),
+ provider.analyzeDependencies(relativePath),
+ ]);
+
+ // Treat empty dependency graph as no data
+ const hasUsefulDeps = dependencies && dependencies.nodes && dependencies.nodes.length > 0;
+
+ // If nothing found at all, try searching by the file basename
+ if (!definition && !references && !hasUsefulDeps) {
+ const basename = path.basename(relativePath, path.extname(relativePath));
+ const fallbackDef = await provider.findDefinition(basename);
+ if (!fallbackDef) return null;
+
+ const [fallbackRefs, fallbackDeps] = await Promise.all([
+ provider.findReferences(basename),
+ provider.analyzeDependencies(basename),
+ ]);
+
+ return {
+ entity: fallbackDef,
+ references: fallbackRefs,
+ dependencies: fallbackDeps,
+ };
+ }
+
+ return {
+ entity: definition,
+ references,
+ dependencies,
+ };
+ } catch (_err) {
+ // Guard against provider exceptions to avoid unhandled rejections in hook runtime
+ return null;
+ }
+}
+
+/**
+ * Format code intelligence data as XML for injection into Claude context.
+ *
+ * @param {Object|null} intel - Result from resolveCodeIntel()
+ * @param {string} filePath - Target file path (for display)
+ * @returns {string|null} XML string or null if no data
+ */
+function formatAsXml(intel, filePath) {
+ if (!intel) return null;
+
+ const { entity, references, dependencies } = intel;
+
+ // At least one piece of data must exist
+ if (!entity && !references && !dependencies) return null;
+
+ const lines = [''];
+ lines.push(` ${escapeXml(filePath)}`);
+
+ // Entity definition
+ if (entity) {
+ lines.push(' ');
+ if (entity.file) lines.push(` ${escapeXml(entity.file)}`);
+ if (entity.context) lines.push(` ${escapeXml(entity.context)}`);
+ lines.push(' ');
+ }
+
+ // References
+ if (references && references.length > 0) {
+ // Deduplicate by file path
+ const uniqueRefs = [];
+ const seen = new Set();
+ for (const ref of references) {
+ if (ref.file && !seen.has(ref.file)) {
+ seen.add(ref.file);
+ uniqueRefs.push(ref);
+ }
+ }
+
+ lines.push(` `);
+ for (const ref of uniqueRefs.slice(0, 15)) {
+ const ctx = ref.context ? ` context="${escapeXml(ref.context)}"` : '';
+ lines.push(`