@optave/codegraph 3.1.4 → 3.2.0

package/src/graph/classifiers/roles.js

@@ -1,7 +1,7 @@
 /**
  * Node role classification — pure logic, no DB.
  *
- * Roles: entry, core, utility, adapter, leaf, dead
+ * Roles: entry, core, utility, adapter, leaf, dead, test-only
  */
 
 export const FRAMEWORK_ENTRY_PREFIXES = ['route:', 'event:', 'command:'];
@@ -15,7 +15,7 @@ function median(sorted) {
 /**
  * Classify nodes into architectural roles based on fan-in/fan-out metrics.
  *
- * @param {{ id: string, name: string, fanIn: number, fanOut: number, isExported: boolean }[]} nodes
+ * @param {{ id: string, name: string, fanIn: number, fanOut: number, isExported: boolean, testOnlyFanIn?: number }[]} nodes
  * @returns {Map<string, string>} nodeId → role
  */
 export function classifyRoles(nodes) {
@@ -38,15 +38,18 @@ export function classifyRoles(nodes) {
   for (const node of nodes) {
     const highIn = node.fanIn >= medFanIn && node.fanIn > 0;
     const highOut = node.fanOut >= medFanOut && node.fanOut > 0;
+    const hasProdFanIn = typeof node.productionFanIn === 'number';
 
     let role;
     const isFrameworkEntry = FRAMEWORK_ENTRY_PREFIXES.some((p) => node.name.startsWith(p));
     if (isFrameworkEntry) {
       role = 'entry';
     } else if (node.fanIn === 0 && !node.isExported) {
-      role = 'dead';
+      role = node.testOnlyFanIn > 0 ? 'test-only' : 'dead';
     } else if (node.fanIn === 0 && node.isExported) {
       role = 'entry';
+    } else if (hasProdFanIn && node.fanIn > 0 && node.productionFanIn === 0) {
+      role = 'test-only';
     } else if (highIn && !highOut) {
       role = 'core';
     } else if (highIn && highOut) {

package/src/index.cjs

@@ -0,0 +1,16 @@
+/**
+ * CJS compatibility wrapper — delegates to ESM via dynamic import().
+ *
+ * This wrapper always returns a Promise on every Node version, because
+ * import() is unconditionally async. You must always await the result:
+ *
+ *   const codegraph = await require('@optave/codegraph');
+ *
+ * // Named destructuring at require-time does NOT work — always await the full result first.
+ * // BAD:  const { buildGraph } = require('@optave/codegraph');  // buildGraph is undefined
+ * // GOOD: const { buildGraph } = await require('@optave/codegraph');
+ */
+// Note: if import() rejects (e.g. missing dependency), the rejected Promise is cached
+// by the CJS module system and every subsequent require() call will re-surface the same
+// rejection without re-attempting the load.
+module.exports = import('./index.js');

package/src/index.js

@@ -9,42 +9,10 @@
  *   import { buildGraph, queryNameData, findCycles, exportDOT } from '@optave/codegraph';
  */
 
-export { astQueryData } from './ast.js';
-export { auditData } from './audit.js';
-export { batchData } from './batch.js';
-export { branchCompareData } from './branch-compare.js';
-export { buildGraph } from './builder.js';
-export { cfgData } from './cfg.js';
-export { checkData } from './check.js';
-export { coChangeData } from './cochange.js';
-export { communitiesData } from './communities.js';
-export { complexityData } from './complexity.js';
-export { loadConfig } from './config.js';
-export { EXTENSIONS, IGNORE_DIRS } from './constants.js';
-export { findCycles } from './cycles.js';
-export { dataflowData } from './dataflow.js';
-export {
-  buildEmbeddings,
-  hybridSearchData,
-  multiSearchData,
-  searchData,
-} from './embeddings/index.js';
-export {
-  AnalysisError,
-  BoundaryError,
-  CodegraphError,
-  ConfigError,
-  DbError,
-  EngineError,
-  ParseError,
-  ResolutionError,
-} from './errors.js';
-export { exportDOT, exportJSON, exportMermaid } from './export.js';
-export { flowData, listEntryPointsData } from './flow.js';
-export { EVERY_EDGE_KIND, EVERY_SYMBOL_KIND } from './kinds.js';
-export { manifestoData } from './manifesto.js';
-export { ownersData } from './owners.js';
+export { buildGraph } from './domain/graph/builder.js';
+export { findCycles } from './domain/graph/cycles.js';
 export {
+  briefData,
   childrenData,
   contextData,
   diffImpactData,
@@ -60,7 +28,40 @@ export {
   rolesData,
   statsData,
   whereData,
-} from './queries.js';
-export { sequenceData } from './sequence.js';
-export { hotspotsData, moduleBoundariesData, structureData } from './structure.js';
-export { triageData } from './triage.js';
+} from './domain/queries.js';
+export {
+  buildEmbeddings,
+  hybridSearchData,
+  multiSearchData,
+  searchData,
+} from './domain/search/index.js';
+export { astQueryData } from './features/ast.js';
+export { auditData } from './features/audit.js';
+export { batchData } from './features/batch.js';
+export { branchCompareData } from './features/branch-compare.js';
+export { cfgData } from './features/cfg.js';
+export { checkData } from './features/check.js';
+export { coChangeData } from './features/cochange.js';
+export { communitiesData } from './features/communities.js';
+export { complexityData } from './features/complexity.js';
+export { dataflowData } from './features/dataflow.js';
+export { exportDOT, exportJSON, exportMermaid } from './features/export.js';
+export { flowData, listEntryPointsData } from './features/flow.js';
+export { manifestoData } from './features/manifesto.js';
+export { ownersData } from './features/owners.js';
+export { sequenceData } from './features/sequence.js';
+export { hotspotsData, moduleBoundariesData, structureData } from './features/structure.js';
+export { triageData } from './features/triage.js';
+export { loadConfig } from './infrastructure/config.js';
+export { EXTENSIONS, IGNORE_DIRS } from './shared/constants.js';
+export {
+  AnalysisError,
+  BoundaryError,
+  CodegraphError,
+  ConfigError,
+  DbError,
+  EngineError,
+  ParseError,
+  ResolutionError,
+} from './shared/errors.js';
+export { EVERY_EDGE_KIND, EVERY_SYMBOL_KIND } from './shared/kinds.js';

package/src/{native.js → infrastructure/native.js}

@@ -8,7 +8,7 @@
 
 import { createRequire } from 'node:module';
 import os from 'node:os';
-import { EngineError } from './errors.js';
+import { EngineError } from '../shared/errors.js';
 
 let _cached; // undefined = not yet tried, null = failed, object = module
 let _loadError = null;

package/src/mcp/middleware.js

@@ -2,7 +2,7 @@
  * MCP middleware helpers — pagination defaults and limits.
  */
 
-import { MCP_DEFAULTS, MCP_MAX_LIMIT } from '../paginate.js';
+import { MCP_DEFAULTS, MCP_MAX_LIMIT } from '../shared/paginate.js';
 
 export { MCP_DEFAULTS, MCP_MAX_LIMIT };
 

package/src/mcp/server.js

@@ -6,9 +6,9 @@
  */
 
 import { createRequire } from 'node:module';
-import { findDbPath } from '../db.js';
-import { CodegraphError, ConfigError } from '../errors.js';
-import { MCP_MAX_LIMIT } from '../paginate.js';
+import { findDbPath } from '../db/index.js';
+import { CodegraphError, ConfigError } from '../shared/errors.js';
+import { MCP_MAX_LIMIT } from '../shared/paginate.js';
 import { buildToolList } from './tool-registry.js';
 import { TOOL_HANDLERS } from './tools/index.js';
 
@@ -21,45 +21,84 @@ import { TOOL_HANDLERS } from './tools/index.js';
  * @param {boolean} [options.multiRepo] - Enable multi-repo access (default: false)
  * @param {string[]} [options.allowedRepos] - Restrict access to these repo names only
  */
-export async function startMCPServer(customDbPath, options = {}) {
-  const { allowedRepos } = options;
-  const multiRepo = options.multiRepo || !!allowedRepos;
-  let Server, StdioServerTransport, ListToolsRequestSchema, CallToolRequestSchema;
+async function loadMCPSdk() {
   try {
     const sdk = await import('@modelcontextprotocol/sdk/server/index.js');
-    Server = sdk.Server;
     const transport = await import('@modelcontextprotocol/sdk/server/stdio.js');
-    StdioServerTransport = transport.StdioServerTransport;
     const types = await import('@modelcontextprotocol/sdk/types.js');
-    ListToolsRequestSchema = types.ListToolsRequestSchema;
-    CallToolRequestSchema = types.CallToolRequestSchema;
+    return {
+      Server: sdk.Server,
+      StdioServerTransport: transport.StdioServerTransport,
+      ListToolsRequestSchema: types.ListToolsRequestSchema,
+      CallToolRequestSchema: types.CallToolRequestSchema,
+    };
   } catch {
     throw new ConfigError(
       'MCP server requires @modelcontextprotocol/sdk.\nInstall it with: npm install @modelcontextprotocol/sdk',
     );
   }
+}
 
-  // Connect transport FIRST so the server can receive the client's
-  // `initialize` request while heavy modules (queries, better-sqlite3)
-  // are still loading.  These are lazy-loaded on the first tool call
-  // and cached for subsequent calls.
+function createLazyLoaders() {
   let _queries;
   let _Database;
+  return {
+    async getQueries() {
+      if (!_queries) _queries = await import('../domain/queries.js');
+      return _queries;
+    },
+    getDatabase() {
+      if (!_Database) {
+        const require = createRequire(import.meta.url);
+        _Database = require('better-sqlite3');
+      }
+      return _Database;
+    },
+  };
+}
 
-  async function getQueries() {
-    if (!_queries) {
-      _queries = await import('../queries.js');
+async function resolveDbPath(customDbPath, args, allowedRepos) {
+  let dbPath = customDbPath || undefined;
+  if (args.repo) {
+    if (allowedRepos && !allowedRepos.includes(args.repo)) {
+      throw new ConfigError(`Repository "${args.repo}" is not in the allowed repos list.`);
     }
-    return _queries;
+    const { resolveRepoDbPath } = await import('../infrastructure/registry.js');
+    const resolved = resolveRepoDbPath(args.repo);
+    if (!resolved)
+      throw new ConfigError(
+        `Repository "${args.repo}" not found in registry or its database is missing.`,
+      );
+    dbPath = resolved;
   }
+  return dbPath;
+}
 
-  function getDatabase() {
-    if (!_Database) {
-      const require = createRequire(import.meta.url);
-      _Database = require('better-sqlite3');
-    }
-    return _Database;
+function validateMultiRepoAccess(multiRepo, name, args) {
+  if (!multiRepo && args.repo) {
+    throw new ConfigError(
+      'Multi-repo access is disabled. Restart with `codegraph mcp --multi-repo` to access other repositories.',
+    );
+  }
+  if (!multiRepo && name === 'list_repos') {
+    throw new ConfigError(
+      'Multi-repo access is disabled. Restart with `codegraph mcp --multi-repo` to list repositories.',
+    );
   }
+}
+
+export async function startMCPServer(customDbPath, options = {}) {
+  const { allowedRepos } = options;
+  const multiRepo = options.multiRepo || !!allowedRepos;
+
+  const { Server, StdioServerTransport, ListToolsRequestSchema, CallToolRequestSchema } =
+    await loadMCPSdk();
+
+  // Connect transport FIRST so the server can receive the client's
+  // `initialize` request while heavy modules (queries, better-sqlite3)
+  // are still loading.  These are lazy-loaded on the first tool call
+  // and cached for subsequent calls.
+  const { getQueries, getDatabase } = createLazyLoaders();
 
   const server = new Server(
     { name: 'codegraph', version: '1.0.0' },
@@ -73,47 +112,17 @@ export async function startMCPServer(customDbPath, options = {}) {
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     try {
-      if (!multiRepo && args.repo) {
-        throw new ConfigError(
-          'Multi-repo access is disabled. Restart with `codegraph mcp --multi-repo` to access other repositories.',
-        );
-      }
-      if (!multiRepo && name === 'list_repos') {
-        throw new ConfigError(
-          'Multi-repo access is disabled. Restart with `codegraph mcp --multi-repo` to list repositories.',
-        );
-      }
-
-      let dbPath = customDbPath || undefined;
-      if (args.repo) {
-        if (allowedRepos && !allowedRepos.includes(args.repo)) {
-          throw new ConfigError(`Repository "${args.repo}" is not in the allowed repos list.`);
-        }
-        const { resolveRepoDbPath } = await import('../registry.js');
-        const resolved = resolveRepoDbPath(args.repo);
-        if (!resolved)
-          throw new ConfigError(
-            `Repository "${args.repo}" not found in registry or its database is missing.`,
-          );
-        dbPath = resolved;
-      }
+      validateMultiRepoAccess(multiRepo, name, args);
+      const dbPath = await resolveDbPath(customDbPath, args, allowedRepos);
 
       const toolEntry = TOOL_HANDLERS.get(name);
       if (!toolEntry) {
         return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
       }
 
-      const ctx = {
-        dbPath,
-        getQueries,
-        getDatabase,
-        findDbPath,
-        allowedRepos,
-        MCP_MAX_LIMIT,
-      };
-
+      const ctx = { dbPath, getQueries, getDatabase, findDbPath, allowedRepos, MCP_MAX_LIMIT };
       const result = await toolEntry.handler(args, ctx);
-      if (result?.content) return result; // pass-through MCP responses
+      if (result?.content) return result;
       return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
     } catch (err) {
       const code = err instanceof CodegraphError ? err.code : 'UNKNOWN_ERROR';

package/src/mcp/tool-registry.js

@@ -4,8 +4,8 @@
  * Owns BASE_TOOLS, LIST_REPOS_TOOL, buildToolList(), and the backward-compatible TOOLS export.
  */
 
-import { AST_NODE_KINDS } from '../ast.js';
-import { EVERY_EDGE_KIND, EVERY_SYMBOL_KIND, VALID_ROLES } from '../queries.js';
+import { EVERY_EDGE_KIND, EVERY_SYMBOL_KIND, VALID_ROLES } from '../domain/queries.js';
+import { AST_NODE_KINDS } from '../features/ast.js';
 
 const REPO_PROP = {
   repo: {
@@ -99,6 +99,19 @@ const BASE_TOOLS = [
       required: ['file'],
     },
   },
+  {
+    name: 'brief',
+    description:
+      'Token-efficient file summary: symbols with roles and transitive caller counts, importer counts, and file risk tier (high/medium/low). Designed for context injection.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        file: { type: 'string', description: 'File path (partial match supported)' },
+        no_tests: { type: 'boolean', description: 'Exclude test files', default: false },
+      },
+      required: ['file'],
+    },
+  },
   {
     name: 'file_exports',
     description:

package/src/mcp/tools/ast-query.js

@@ -3,7 +3,7 @@ import { effectiveLimit, effectiveOffset } from '../middleware.js';
 export const name = 'ast_query';
 
 export async function handler(args, ctx) {
-  const { astQueryData } = await import('../../ast.js');
+  const { astQueryData } = await import('../../features/ast.js');
   return astQueryData(args.pattern, ctx.dbPath, {
     kind: args.kind,
     file: args.file,

package/src/mcp/tools/audit.js

@@ -11,7 +11,7 @@ export async function handler(args, ctx) {
       offset: effectiveOffset(args),
     });
   }
-  const { auditData } = await import('../../audit.js');
+  const { auditData } = await import('../../features/audit.js');
   return auditData(args.target, ctx.dbPath, {
     depth: args.depth,
     file: args.file,

package/src/mcp/tools/batch-query.js

@@ -1,7 +1,7 @@
 export const name = 'batch_query';
 
 export async function handler(args, ctx) {
-  const { batchData } = await import('../../batch.js');
+  const { batchData } = await import('../../features/batch.js');
   return batchData(args.command, args.targets, ctx.dbPath, {
     depth: args.depth,
     file: args.file,

package/src/mcp/tools/branch-compare.js

@@ -1,7 +1,9 @@
 export const name = 'branch_compare';
 
 export async function handler(args, _ctx) {
-  const { branchCompareData, branchCompareMermaid } = await import('../../branch-compare.js');
+  const { branchCompareData, branchCompareMermaid } = await import(
+    '../../features/branch-compare.js'
+  );
   const bcData = await branchCompareData(args.base, args.target, {
     depth: args.depth,
     noTests: args.no_tests,

package/src/mcp/tools/brief.js

@@ -0,0 +1,8 @@
+export const name = 'brief';
+
+export async function handler(args, ctx) {
+  const { briefData } = await ctx.getQueries();
+  return briefData(args.file, ctx.dbPath, {
+    noTests: args.no_tests,
+  });
+}

package/src/mcp/tools/cfg.js

@@ -3,7 +3,7 @@ import { effectiveOffset, MCP_DEFAULTS } from '../middleware.js';
 export const name = 'cfg';
 
 export async function handler(args, ctx) {
-  const { cfgData, cfgToDOT, cfgToMermaid } = await import('../../cfg.js');
+  const { cfgData, cfgToDOT, cfgToMermaid } = await import('../../features/cfg.js');
   const cfgResult = cfgData(args.name, ctx.dbPath, {
     file: args.file,
     kind: args.kind,

package/src/mcp/tools/check.js

@@ -6,7 +6,7 @@ export async function handler(args, ctx) {
   const isDiffMode = args.ref || args.staged;
 
   if (!isDiffMode && !args.rules) {
-    const { manifestoData } = await import('../../manifesto.js');
+    const { manifestoData } = await import('../../features/manifesto.js');
     return manifestoData(ctx.dbPath, {
       file: args.file,
       noTests: args.no_tests,
@@ -16,7 +16,7 @@ export async function handler(args, ctx) {
     });
   }
 
-  const { checkData } = await import('../../check.js');
+  const { checkData } = await import('../../features/check.js');
   const checkResult = checkData(ctx.dbPath, {
     ref: args.ref,
     staged: args.staged,
@@ -29,7 +29,7 @@ export async function handler(args, ctx) {
   });
 
   if (args.rules) {
-    const { manifestoData } = await import('../../manifesto.js');
+    const { manifestoData } = await import('../../features/manifesto.js');
     const manifestoResult = manifestoData(ctx.dbPath, {
       file: args.file,
       noTests: args.no_tests,

package/src/mcp/tools/co-changes.js

@@ -3,7 +3,7 @@ import { effectiveLimit, effectiveOffset } from '../middleware.js';
 export const name = 'co_changes';
 
 export async function handler(args, ctx) {
-  const { coChangeData, coChangeTopData } = await import('../../cochange.js');
+  const { coChangeData, coChangeTopData } = await import('../../features/cochange.js');
   return args.file
     ? coChangeData(args.file, ctx.dbPath, {
         limit: effectiveLimit(args, name),

package/src/mcp/tools/code-owners.js

@@ -1,7 +1,7 @@
 export const name = 'code_owners';
 
 export async function handler(args, ctx) {
-  const { ownersData } = await import('../../owners.js');
+  const { ownersData } = await import('../../features/owners.js');
   return ownersData(ctx.dbPath, {
     file: args.file,
     owner: args.owner,

package/src/mcp/tools/communities.js

@@ -3,7 +3,7 @@ import { effectiveLimit, effectiveOffset } from '../middleware.js';
 export const name = 'communities';
 
 export async function handler(args, ctx) {
-  const { communitiesData } = await import('../../communities.js');
+  const { communitiesData } = await import('../../features/communities.js');
   return communitiesData(ctx.dbPath, {
     functions: args.functions,
     resolution: args.resolution,

package/src/mcp/tools/complexity.js

@@ -3,7 +3,7 @@ import { effectiveLimit, effectiveOffset } from '../middleware.js';
 export const name = 'complexity';
 
 export async function handler(args, ctx) {
-  const { complexityData } = await import('../../complexity.js');
+  const { complexityData } = await import('../../features/complexity.js');
   return complexityData(ctx.dbPath, {
     target: args.name,
     file: args.file,

package/src/mcp/tools/dataflow.js

@@ -5,7 +5,7 @@ export const name = 'dataflow';
 export async function handler(args, ctx) {
   const dfMode = args.mode || 'edges';
   if (dfMode === 'impact') {
-    const { dataflowImpactData } = await import('../../dataflow.js');
+    const { dataflowImpactData } = await import('../../features/dataflow.js');
     return dataflowImpactData(args.name, ctx.dbPath, {
       depth: args.depth,
       file: args.file,
@@ -15,7 +15,7 @@ export async function handler(args, ctx) {
       offset: effectiveOffset(args),
     });
   }
-  const { dataflowData } = await import('../../dataflow.js');
+  const { dataflowData } = await import('../../features/dataflow.js');
   return dataflowData(args.name, ctx.dbPath, {
     file: args.file,
     kind: args.kind,

package/src/mcp/tools/execution-flow.js

@@ -4,7 +4,7 @@ export const name = 'execution_flow';
 
 export async function handler(args, ctx) {
   if (args.list) {
-    const { listEntryPointsData } = await import('../../flow.js');
+    const { listEntryPointsData } = await import('../../features/flow.js');
     return listEntryPointsData(ctx.dbPath, {
       noTests: args.no_tests,
       limit: effectiveLimit(args, name),
@@ -14,7 +14,7 @@ export async function handler(args, ctx) {
   if (!args.name) {
     return { error: 'Provide a name or set list=true' };
   }
-  const { flowData } = await import('../../flow.js');
+  const { flowData } = await import('../../features/flow.js');
   return flowData(args.name, ctx.dbPath, {
     depth: args.depth,
     file: args.file,

package/src/mcp/tools/export-graph.js

@@ -1,11 +1,11 @@
-import { findDbPath } from '../../db.js';
+import { findDbPath } from '../../db/index.js';
 import { effectiveOffset, MCP_DEFAULTS, MCP_MAX_LIMIT } from '../middleware.js';
 
 export const name = 'export_graph';
 
 export async function handler(args, ctx) {
   const { exportDOT, exportGraphML, exportGraphSON, exportJSON, exportMermaid, exportNeo4jCSV } =
-    await import('../../export.js');
+    await import('../../features/export.js');
   const Database = ctx.getDatabase();
   const db = new Database(findDbPath(ctx.dbPath), { readonly: true });
   const fileLevel = args.file_level !== false;

package/src/mcp/tools/find-cycles.js

@@ -1,5 +1,5 @@
-import { findCycles } from '../../cycles.js';
-import { findDbPath } from '../../db.js';
+import { findDbPath } from '../../db/index.js';
+import { findCycles } from '../../domain/graph/cycles.js';
 
 export const name = 'find_cycles';
 

package/src/mcp/tools/index.js

@@ -6,6 +6,7 @@ import * as astQuery from './ast-query.js';
 import * as audit from './audit.js';
 import * as batchQuery from './batch-query.js';
 import * as branchCompare from './branch-compare.js';
+import * as brief from './brief.js';
 import * as cfg from './cfg.js';
 import * as check from './check.js';
 import * as coChanges from './co-changes.js';
@@ -67,5 +68,6 @@ export const TOOL_HANDLERS = new Map([
   [dataflow.name, dataflow],
   [check.name, check],
   [astQuery.name, astQuery],
+  [brief.name, brief],
   [listRepos.name, listRepos],
 ]);

package/src/mcp/tools/list-repos.js

@@ -1,7 +1,7 @@
 export const name = 'list_repos';
 
 export async function handler(_args, ctx) {
-  const { listRepos, pruneRegistry } = await import('../../registry.js');
+  const { listRepos, pruneRegistry } = await import('../../infrastructure/registry.js');
   pruneRegistry();
   let repos = listRepos();
   if (ctx.allowedRepos) {

package/src/mcp/tools/sequence.js

@@ -3,7 +3,7 @@ import { effectiveOffset, MCP_DEFAULTS } from '../middleware.js';
 export const name = 'sequence';
 
 export async function handler(args, ctx) {
-  const { sequenceData, sequenceToMermaid } = await import('../../sequence.js');
+  const { sequenceData, sequenceToMermaid } = await import('../../features/sequence.js');
   const seqResult = sequenceData(args.name, ctx.dbPath, {
     depth: args.depth,
     file: args.file,

package/src/mcp/tools/structure.js

@@ -3,7 +3,7 @@ import { effectiveLimit, effectiveOffset } from '../middleware.js';
 export const name = 'structure';
 
 export async function handler(args, ctx) {
-  const { structureData } = await import('../../structure.js');
+  const { structureData } = await import('../../features/structure.js');
   return structureData(ctx.dbPath, {
     directory: args.directory,
     depth: args.depth,

package/src/mcp/tools/triage.js

@@ -4,7 +4,7 @@ export const name = 'triage';
 
 export async function handler(args, ctx) {
   if (args.level === 'file' || args.level === 'directory') {
-    const { hotspotsData } = await import('../../structure.js');
+    const { hotspotsData } = await import('../../features/structure.js');
     const TRIAGE_TO_HOTSPOT = {
       risk: 'fan-in',
       complexity: 'density',
@@ -20,7 +20,7 @@ export async function handler(args, ctx) {
       noTests: args.no_tests,
     });
   }
-  const { triageData } = await import('../../triage.js');
+  const { triageData } = await import('../../features/triage.js');
   return triageData(ctx.dbPath, {
     sort: args.sort,
     minScore: args.min_score,

package/src/{commands → presentation}/audit.js

@@ -1,6 +1,6 @@
-import { auditData } from '../audit.js';
+import { kindIcon } from '../domain/queries.js';
+import { auditData } from '../features/audit.js';
 import { outputResult } from '../infrastructure/result-formatter.js';
-import { kindIcon } from '../queries.js';
 
 /**
  * CLI formatter for the audit command.

package/src/{commands → presentation}/batch.js

@@ -1,4 +1,4 @@
-import { batchData, multiBatchData } from '../batch.js';
+import { batchData, multiBatchData } from '../features/batch.js';
 
 /**
  * CLI wrapper — calls batchData and prints JSON to stdout.

package/src/{commands → presentation}/branch-compare.js

@@ -1,6 +1,6 @@
-import { branchCompareData, branchCompareMermaid } from '../branch-compare.js';
+import { kindIcon } from '../domain/queries.js';
+import { branchCompareData, branchCompareMermaid } from '../features/branch-compare.js';
 import { outputResult } from '../infrastructure/result-formatter.js';
-import { kindIcon } from '../queries.js';
 
 // ─── Text Formatting ────────────────────────────────────────────────────