@ngockhoale/ukit 1.1.6 → 1.1.7

package/CHANGELOG.md

@@ -4,6 +4,17 @@ All notable changes to UKit are documented here.
 
 ## Unreleased
 
+## 1.1.7 - 2026-04-25
+
+### Impact Confidence
+
+- Added impact-confidence indexing for changed shared/runtime files, including lightweight call extraction and `calls.json` artifacts.
+- Added shared-impact classification so source index runtime, install/runtime core, shipped hooks/helpers, manifests, and templates are routed as higher-confidence verification work instead of ordinary simple edits.
+- Added mirror-counterpart guidance between source modules and installed helper mirrors, helping agents catch source/template drift before release.
+- Added shipped `impact-context.mjs` helper and manifest coverage so installed workspaces can resolve impact context after `ukit install`.
+- Tightened verification planning and guard behavior so impact-test lanes run targeted checks first, while broad verification remains advisory unless explicitly enforced.
+- Added package-artifact, hook, indexing, impact-context, and impact-catalog coverage for the new release surface.
+
 ## 1.1.6 - 2026-04-23
 
 ### Hidden Runtime Root

package/README.md

@@ -66,7 +66,7 @@ If maintainers roll out a newer CLI build, the in-project workflow still stays t
 - `.ukit/` — hidden shared runtime storage for config, cache, and cross-agent memory
 - `docs/` — PROJECT / MEMORY / WORKLOG baseline
 
-## UKit v1.1.6 Runtime
+## UKit v1.1.7 Runtime
 
 UKit now installs a hidden shared local runtime at `.ukit/` for production-oriented state that should survive across agent sessions:
 
@@ -83,13 +83,15 @@ When long sessions approach the compact threshold, UKit now uses a conservative
 - compact only safe-zone history/noise
 - preserve active task, rules, decisions, and current code focus
 
-UKit v1.1.6 keeps the same shared runtime contract while the npm distribution now lives under the owned maintainer scope:
+UKit v1.1.7 keeps the same shared runtime contract while adding impact-confidence routing for shared runtime/template changes:
 
 - install globally with `npm install -g @ngockhoale/ukit`
 - keep using the exact same human workflow inside projects: `ukit install`
 - preserve the same `ukit` binary, hooks, and install-first orchestration while standardizing the runtime root as hidden `.ukit/`
+- route shared index/helper/hook/template edits as higher-impact work instead of treating them like ordinary simple changes
+- surface mirror-counterpart and impact-test hints so agents verify source/runtime/template changes with better confidence
 
-UKit v1.1.6 also keeps the fast path improvements from the recent runtime releases:
+UKit v1.1.7 also keeps the fast path improvements from the recent runtime releases:
 
 - Vietnamese prompts now normalize more effectively for English-heavy code symbols and paths
 - localized simple direct-target lanes skip extra previous-context / recent-output work when it would not change the next action

package/manifests/platform.full.yaml

@@ -1000,6 +1000,19 @@ items:
     packs:
       - core
 
+  - id: ukit-index-impact-context-script
+    type: config
+    sourceTemplate: .claude/ukit/index/impact-context.mjs
+    targetPath: .claude/ukit/index/impact-context.mjs
+    requires:
+      - ukit-index-core-lib
+      - ukit-index-cache-utils-script
+    mergeStrategy: overwrite_with_backup
+    variables: []
+    enabledByDefault: true
+    packs:
+      - core
+
   - id: ukit-index-cache-utils-script
     type: config
     sourceTemplate: .claude/ukit/index/cache-utils.mjs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngockhoale/ukit",
-  "version": "1.1.6",
+  "version": "1.1.7",
   "description": "Install/update an index-first AI workspace for Claude Code, Antigravity, OpenAI Codex, and OpenCode.",
   "license": "MIT",
   "type": "module",

package/src/core/runtimeConfig.js

@@ -42,7 +42,7 @@ export function buildDefaultRuntimeConfig(overrides = {}) {
   const safeOverrides = isPlainObject(overrides) ? overrides : {};
 
   return mergeObjects({
-    version: '1.1.6',
+    version: '1.1.7',
     agent: 'claude-code',
     compact: {
       enabled: true,

package/src/index/buildIndex.js

@@ -34,6 +34,9 @@ const TRACKED_EXTENSIONS = new Set(['.js', '.mjs', '.cjs', '.ts', '.tsx', '.jsx'
 const DISCOVERED_EXTENSIONS = new Set([...TRACKED_EXTENSIONS, ...STYLE_EXTENSIONS]);
 export const DEFAULT_INDEX_CACHE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
 const INDEX_PARSE_BATCH_SIZE = 8;
+const CALL_IGNORE_WORDS = new Set([
+  'if', 'for', 'while', 'switch', 'catch', 'function', 'return', 'typeof',
+]);
 
 export async function buildCodeIndex({ rootDir = process.cwd() } = {}) {
   const absoluteRoot = path.resolve(rootDir);
@@ -89,6 +92,7 @@ export async function buildCodeIndex({ rootDir = process.cwd() } = {}) {
 
   const symbols = [];
   const imports = [];
+  const calls = [];
   const reusableCodeFiles = [];
   let filesToParse = [];
   let reusedCodeFileCount = 0;
@@ -109,20 +113,24 @@ export async function buildCodeIndex({ rootDir = process.cwd() } = {}) {
   }
 
   if (reusableCodeFiles.length > 0) {
-    const [previousSymbolsArtifact, previousImportsArtifact] = await Promise.all([
+    const [previousSymbolsArtifact, previousImportsArtifact, previousCallsArtifact] = await Promise.all([
       readArtifactIfExists(absoluteRoot, INDEX_ARTIFACTS.symbols),
       readArtifactIfExists(absoluteRoot, INDEX_ARTIFACTS.imports),
+      readArtifactIfExists(absoluteRoot, INDEX_ARTIFACTS.calls),
     ]);
     canReuseParsedArtifacts = previousSymbolsArtifact?.schemaVersion === INDEX_SCHEMA_VERSION
-      && previousImportsArtifact?.schemaVersion === INDEX_SCHEMA_VERSION;
+      && previousImportsArtifact?.schemaVersion === INDEX_SCHEMA_VERSION
+      && previousCallsArtifact?.schemaVersion === INDEX_SCHEMA_VERSION;
 
     if (canReuseParsedArtifacts) {
       const previousSymbolsByPath = groupBy(previousSymbolsArtifact.items ?? [], (item) => item.filePath);
       const previousImportsByPath = groupBy(previousImportsArtifact.items ?? [], (item) => item.from);
+      const previousCallsByPath = groupBy(previousCallsArtifact.items ?? [], (item) => item.filePath);
 
       for (const filePath of reusableCodeFiles) {
         symbols.push(...(previousSymbolsByPath.get(filePath) ?? []));
         imports.push(...(previousImportsByPath.get(filePath) ?? []));
+        calls.push(...(previousCallsByPath.get(filePath) ?? []));
         reusedCodeFileCount += 1;
       }
     } else {
@@ -145,6 +153,7 @@ export async function buildCodeIndex({ rootDir = process.cwd() } = {}) {
             ...extractImports(filePath, scriptContent),
             ...extractSupplementalImports(filePath, content),
           ],
+          calls: extractFunctionCalls(filePath, scriptContent),
         };
       } catch {
         return null;
@@ -154,6 +163,7 @@ export async function buildCodeIndex({ rootDir = process.cwd() } = {}) {
     for (const parsedFile of parsedBatch) {
       symbols.push(...parsedFile.symbols);
       imports.push(...parsedFile.imports);
+      calls.push(...parsedFile.calls);
     }
   }
 
@@ -279,6 +289,12 @@ export async function buildCodeIndex({ rootDir = process.cwd() } = {}) {
       rootDir: absoluteRoot,
       items: imports,
     });
+    await writeArtifact(absoluteRoot, INDEX_ARTIFACTS.calls, {
+      schemaVersion: INDEX_SCHEMA_VERSION,
+      generatedAt,
+      rootDir: absoluteRoot,
+      items: calls,
+    });
   }
   if (!canReuseTestsMap) {
     await writeArtifact(absoluteRoot, INDEX_ARTIFACTS.testsMap, {
@@ -579,6 +595,76 @@ function extractSupplementalImports(filePath, content) {
   return imports;
 }
 
+function extractFunctionBlocks(content) {
+  const blocks = [];
+
+  for (const match of content.matchAll(/export\s+(async\s+)?function\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*\([^)]*\)\s*\{/g)) {
+    blocks.push({ symbol: match[2], exported: true, bodyStart: match.index + match[0].length });
+  }
+
+  for (const match of content.matchAll(/function\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*\([^)]*\)\s*\{/g)) {
+    const prefix = content.slice(Math.max(0, match.index - 16), match.index);
+    if (/export\s+$/.test(prefix)) {
+      continue;
+    }
+    blocks.push({ symbol: match[1], exported: false, bodyStart: match.index + match[0].length });
+  }
+
+  for (const match of content.matchAll(/export\s+const\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*(?:async\s*)?(?:\([^)]*\)|[A-Za-z_$][A-Za-z0-9_$]*)\s*=>\s*\{/g)) {
+    blocks.push({ symbol: match[1], exported: true, bodyStart: match.index + match[0].length });
+  }
+
+  for (const match of content.matchAll(/const\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*(?:async\s*)?(?:\([^)]*\)|[A-Za-z_$][A-Za-z0-9_$]*)\s*=>\s*\{/g)) {
+    const prefix = content.slice(Math.max(0, match.index - 16), match.index);
+    if (/export\s+$/.test(prefix)) {
+      continue;
+    }
+    blocks.push({ symbol: match[1], exported: false, bodyStart: match.index + match[0].length });
+  }
+
+  return blocks
+    .map((block) => ({ ...block, body: sliceBalancedBlock(content, block.bodyStart) }))
+    .filter((block) => block.body);
+}
+
+function sliceBalancedBlock(content, startIndex) {
+  let depth = 1;
+  for (let index = startIndex; index < content.length; index += 1) {
+    const char = content[index];
+    if (char === '{') {
+      depth += 1;
+    }
+    if (char === '}') {
+      depth -= 1;
+    }
+    if (depth === 0) {
+      return content.slice(startIndex, index);
+    }
+  }
+  return '';
+}
+
+function extractFunctionCalls(filePath, content) {
+  return extractFunctionBlocks(content).map((block) => {
+    const calls = [];
+    for (const match of block.body.matchAll(/(?:\b|\.)([A-Za-z_$][A-Za-z0-9_$]*)\s*\(/g)) {
+      const name = match[1];
+      if (!name || CALL_IGNORE_WORDS.has(name)) {
+        continue;
+      }
+      if (!calls.includes(name)) {
+        calls.push(name);
+      }
+    }
+    return {
+      filePath,
+      symbol: block.symbol,
+      exported: block.exported,
+      calls,
+    };
+  });
+}
+
 function buildTestsMap(fileRecords) {
   const testFiles = fileRecords.filter((file) => isLikelyTestFile(file.filePath));
   const sourceFiles = fileRecords.filter((file) => CODE_EXTENSIONS.has(file.ext) && !isLikelyTestFile(file.filePath));

package/src/index/impactCatalog.js

@@ -0,0 +1,126 @@
+const SHARED_IMPACT_PATTERNS = [
+  {
+    regex: /^src\/index\//,
+    label: 'shared-index-runtime',
+  },
+  {
+    regex: /^src\/core\/(runInstallPipeline|applyPlan|buildPlan|diffPlan|metadata|migrateLegacy|uninstall|runtimeConfig|runtimePaths)\.js$/,
+    label: 'shared-install-runtime',
+  },
+  {
+    regex: /^src\/core\/(output|token|compact)\//,
+    label: 'shared-token-runtime',
+  },
+  {
+    regex: /^templates\/\.claude\/hooks\//,
+    label: 'installed-hook-runtime',
+  },
+  {
+    regex: /^templates\/\.claude\/ukit\//,
+    label: 'installed-helper-runtime',
+  },
+  {
+    regex: /^manifests\/platform\.full\.yaml$/,
+    label: 'install-manifest',
+  },
+  {
+    regex: /^templates\//,
+    label: 'published-template-surface',
+  },
+];
+
+const MIRROR_PAIRS = [
+  {
+    source: 'src/index/buildIndex.js',
+    mirror: 'templates/.claude/ukit/index/lib/index-core.mjs',
+    reason: 'installed index-core mirror embeds source index behavior',
+  },
+  {
+    source: 'src/index/queryIndex.js',
+    mirror: 'templates/.claude/ukit/index/lib/index-core.mjs',
+    reason: 'installed index-core mirror embeds source query behavior',
+  },
+  {
+    source: 'src/index/resolveContext.js',
+    mirror: 'templates/.claude/ukit/index/lib/index-core.mjs',
+    reason: 'installed index-core mirror embeds context resolution behavior',
+  },
+  {
+    source: 'src/index/verificationPlan.js',
+    mirror: 'templates/.claude/ukit/index/lib/index-core.mjs',
+    reason: 'installed index-core mirror embeds verification planning behavior',
+  },
+  {
+    source: 'src/index/taskRouting.js',
+    mirror: 'templates/.claude/ukit/index/route-task.mjs',
+    reason: 'installed route-task helper mirrors source task routing behavior',
+  },
+  {
+    source: 'src/index/routeCatalog.js',
+    mirror: 'templates/.claude/ukit/index/route-catalog.mjs',
+    reason: 'installed route catalog must match source route catalog',
+  },
+  {
+    source: 'src/core/output/index.js',
+    mirror: 'templates/.claude/ukit/runtime/output-compression.mjs',
+    reason: 'source output compression runtime should stay aligned with installed hook runtime',
+  },
+  {
+    source: 'src/core/token/index.js',
+    mirror: 'templates/.claude/ukit/runtime/token-utils.mjs',
+    reason: 'source token runtime should stay aligned with installed token utilities',
+  },
+  {
+    source: 'src/core/compact/threshold.js',
+    mirror: 'templates/.claude/ukit/runtime/compact-threshold.mjs',
+    reason: 'source compact threshold runtime should stay aligned with installed compact threshold hook',
+  },
+];
+
+function normalizePath(filePath) {
+  return String(filePath ?? '').trim().replace(/\\/g, '/').replace(/^\.\//, '');
+}
+
+export function isSharedImpactFile(filePath) {
+  const normalized = normalizePath(filePath);
+  return SHARED_IMPACT_PATTERNS.some((entry) => entry.regex.test(normalized));
+}
+
+export function classifyImpactRisk(filePaths = []) {
+  const normalizedPaths = [...new Set(filePaths.map(normalizePath).filter(Boolean))];
+  const riskLabels = [];
+
+  for (const filePath of normalizedPaths) {
+    for (const entry of SHARED_IMPACT_PATTERNS) {
+      if (entry.regex.test(filePath) && !riskLabels.includes(entry.label)) {
+        riskLabels.push(entry.label);
+      }
+    }
+  }
+
+  return {
+    changedFiles: normalizedPaths,
+    riskLabels,
+    requiresImpactCheck: riskLabels.length > 0,
+  };
+}
+
+export function findMirrorCounterparts(filePaths = []) {
+  const normalizedSet = new Set(filePaths.map(normalizePath).filter(Boolean));
+  const counterparts = [];
+
+  for (const pair of MIRROR_PAIRS) {
+    if (normalizedSet.has(pair.source)) {
+      counterparts.push({ filePath: pair.mirror, reason: pair.reason, source: pair.source });
+    }
+    if (normalizedSet.has(pair.mirror)) {
+      counterparts.push({ filePath: pair.source, reason: pair.reason, source: pair.mirror });
+    }
+  }
+
+  return counterparts.filter((entry, index, list) => (
+    list.findIndex((candidate) => candidate.filePath === entry.filePath && candidate.source === entry.source) === index
+  ));
+}
+
+export { MIRROR_PAIRS, SHARED_IMPACT_PATTERNS };

package/src/index/impactContext.js

@@ -0,0 +1,232 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { getArtifactPath, INDEX_ARTIFACTS } from './paths.js';
+import { classifyImpactRisk, findMirrorCounterparts } from './impactCatalog.js';
+import { inferRelatedTestsFromArtifacts, loadRelatedTestArtifacts } from './relatedTests.js';
+
+const DEFAULT_IMPACT_LIMITS = {
+  maxCallers: 8,
+  maxCallees: 8,
+  maxImporters: 8,
+  maxTests: 8,
+  maxMirrors: 4,
+};
+
+const RISK_TEST_RECOMMENDATIONS = {
+  'shared-index-runtime': ['tests/index/indexing.test.js', 'tests/index/taskRouting.test.js'],
+  'shared-install-runtime': ['tests/integration/installPipeline.test.js'],
+  'installed-hook-runtime': ['tests/hooks/skillRouterHook.test.js', 'tests/integration/installPipeline.test.js'],
+  'published-template-surface': ['tests/integration/packageArtifact.test.js', 'tests/integration/installPipeline.test.js'],
+  'install-manifest': ['tests/integration/packageArtifact.test.js', 'tests/integration/installPipeline.test.js'],
+};
+
+async function readArtifact(rootDir, artifactName) {
+  try {
+    const raw = await fs.readFile(getArtifactPath(path.resolve(rootDir), artifactName), 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return { items: [] };
+  }
+}
+
+function normalizePath(filePath) {
+  return String(filePath ?? '').trim().replace(/\\/g, '/').replace(/^\.\//, '');
+}
+
+function unique(values = []) {
+  return [...new Set(values.filter(Boolean))];
+}
+
+function resolveImportTarget(fromFilePath, specifier) {
+  const from = normalizePath(fromFilePath);
+  const to = String(specifier ?? '').trim();
+  if (!from || !to || !to.startsWith('.')) {
+    return null;
+  }
+
+  const fromDir = path.posix.dirname(from);
+  const base = path.posix.normalize(path.posix.join(fromDir, to));
+  const candidates = [
+    base,
+    `${base}.js`,
+    `${base}.mjs`,
+    `${base}.cjs`,
+    `${base}.ts`,
+    `${base}.tsx`,
+    `${base}.jsx`,
+    `${base}.vue`,
+    path.posix.join(base, 'index.js'),
+    path.posix.join(base, 'index.ts'),
+    path.posix.join(base, 'index.mjs'),
+  ];
+
+  return unique(candidates);
+}
+
+export async function resolveImpactContext({
+  rootDir = process.cwd(),
+  changedFiles = [],
+  changedSymbols = [],
+  limits = {},
+} = {}) {
+  const absoluteRoot = path.resolve(rootDir);
+  const budget = { ...DEFAULT_IMPACT_LIMITS, ...(limits ?? {}) };
+  const normalizedChangedFiles = unique(changedFiles.map(normalizePath));
+  const normalizedChangedSymbols = unique(changedSymbols.map((symbol) => String(symbol ?? '').trim()));
+
+  const [callsArtifact, importsArtifact, relatedArtifacts] = await Promise.all([
+    readArtifact(absoluteRoot, INDEX_ARTIFACTS.calls),
+    readArtifact(absoluteRoot, INDEX_ARTIFACTS.imports),
+    loadRelatedTestArtifacts({ rootDir: absoluteRoot }),
+  ]);
+
+  const callItems = callsArtifact.items ?? [];
+  const importItems = importsArtifact.items ?? [];
+  const risk = classifyImpactRisk(normalizedChangedFiles);
+  const mirrorCounterparts = findMirrorCounterparts(normalizedChangedFiles).slice(0, budget.maxMirrors);
+
+  const changedFileSet = new Set(normalizedChangedFiles);
+  const changedSymbolSet = new Set(normalizedChangedSymbols);
+
+  const changedRecords = callItems.filter((item) => {
+    const fileMatched = changedFileSet.has(normalizePath(item.filePath));
+    if (!fileMatched) {
+      return false;
+    }
+    if (changedSymbolSet.size === 0) {
+      return true;
+    }
+    return changedSymbolSet.has(item.symbol);
+  });
+
+  const callees = [];
+  for (const record of changedRecords) {
+    for (const symbol of record.calls ?? []) {
+      callees.push({ filePath: record.filePath, fromSymbol: record.symbol, symbol });
+    }
+  }
+
+  const callers = [];
+  const callerTargets = new Set([
+    ...normalizedChangedSymbols,
+    ...changedRecords.map((record) => record.symbol),
+  ]);
+  if (callerTargets.size > 0) {
+    for (const record of callItems) {
+      const matchedSymbol = (record.calls ?? []).find((name) => callerTargets.has(name));
+      if (!matchedSymbol) {
+        continue;
+      }
+
+      if (
+        changedFileSet.has(normalizePath(record.filePath))
+        && changedSymbolSet.has(record.symbol)
+      ) {
+        continue;
+      }
+
+      callers.push({ filePath: record.filePath, symbol: record.symbol, reason: `calls ${matchedSymbol}` });
+    }
+  }
+
+  const importers = [];
+  const dependencies = [];
+  for (const imp of importItems) {
+    const from = normalizePath(imp.from);
+    const targets = resolveImportTarget(from, imp.to) ?? [];
+    const matched = targets.find((candidate) => changedFileSet.has(normalizePath(candidate)));
+
+    if (matched) {
+      importers.push(from);
+      dependencies.push(matched);
+    }
+  }
+
+  const candidateFiles = unique([
+    ...normalizedChangedFiles,
+    ...importers,
+    ...callers.map((item) => item.filePath),
+    ...mirrorCounterparts.map((item) => item.filePath),
+  ]);
+  const relatedTests = inferRelatedTestsFromArtifacts({
+    candidateFiles,
+    analogsMap: relatedArtifacts.analogsMap,
+    relationsMap: relatedArtifacts.relationsMap,
+    limit: budget.maxTests,
+  }).map((entry) => entry.filePath);
+
+  const recommendedTestFiles = unique([
+    ...relatedTests,
+    ...risk.riskLabels.flatMap((label) => RISK_TEST_RECOMMENDATIONS[label] ?? []),
+  ]);
+
+  return {
+    changedFiles: normalizedChangedFiles,
+    changedSymbols: normalizedChangedSymbols,
+    riskLabels: risk.riskLabels,
+    requiresImpactCheck: risk.requiresImpactCheck,
+    callees: unique(callees.map((item) => JSON.stringify(item))).map((value) => JSON.parse(value)).slice(0, budget.maxCallees),
+    callers: unique(callers.map((item) => JSON.stringify(item))).map((value) => JSON.parse(value)).slice(0, budget.maxCallers),
+    importers: unique(importers).slice(0, budget.maxImporters),
+    dependencies: unique(dependencies).slice(0, budget.maxImporters),
+    mirrorCounterparts,
+    relatedTests,
+    recommendedTestFiles,
+    explanations: {
+      callees: changedRecords.map((record) => `${record.filePath}:${record.symbol}`),
+      callers: callers.map((entry) => `${entry.filePath}:${entry.symbol}`),
+      importers,
+      relatedTests,
+      mirrorCounterparts: mirrorCounterparts.map((entry) => `${entry.source} -> ${entry.filePath}`),
+    },
+  };
+}
+
+export function formatImpactConfidenceSummary(impact = {}) {
+  const lines = ['Impact checked:'];
+
+  if ((impact.changedFiles ?? []).length > 0) {
+    lines.push(`- Changed: ${(impact.changedFiles ?? []).slice(0, 3).join(', ')}`);
+  }
+  if ((impact.changedSymbols ?? []).length > 0) {
+    lines.push(`- Symbols: ${(impact.changedSymbols ?? []).slice(0, 5).join(', ')}`);
+  }
+  if ((impact.riskLabels ?? []).length > 0) {
+    lines.push(`- Risk: ${(impact.riskLabels ?? []).join(', ')}`);
+  }
+
+  const calleeSymbols = (impact.callees ?? []).map((item) => item?.symbol).filter(Boolean).slice(0, 5);
+  if (calleeSymbols.length > 0) {
+    lines.push(`- Callees: ${calleeSymbols.join(', ')}`);
+  }
+
+  const callerFiles = (impact.callers ?? []).map((item) => item?.filePath).filter(Boolean).slice(0, 5);
+  if (callerFiles.length > 0) {
+    lines.push(`- Callers: ${callerFiles.join(', ')}`);
+  }
+
+  const importers = (impact.importers ?? []).slice(0, 5);
+  if (importers.length > 0) {
+    lines.push(`- Importers: ${importers.join(', ')}`);
+  }
+
+  const mirrors = (impact.mirrorCounterparts ?? []).map((item) => item?.filePath).filter(Boolean).slice(0, 3);
+  if (mirrors.length > 0) {
+    lines.push(`- Mirrors: ${mirrors.join(', ')}`);
+  }
+
+  const relatedTests = (impact.relatedTests ?? []).slice(0, 4);
+  if (relatedTests.length > 0) {
+    lines.push(`- Related tests: ${relatedTests.join(', ')}`);
+  }
+
+  const recommendedTests = (impact.recommendedTestFiles ?? []).slice(0, 4);
+  if (recommendedTests.length > 0) {
+    lines.push(`- Recommended tests: ${recommendedTests.join(', ')}`);
+  }
+
+  return lines.join('\n');
+}
+
+export { DEFAULT_IMPACT_LIMITS };

package/src/index/paths.js

@@ -5,6 +5,7 @@ export const INDEX_ARTIFACTS = {
   files: 'files.json',
   symbols: 'symbols.json',
   imports: 'imports.json',
+  calls: 'calls.json',
   testsMap: 'tests-map.json',
   hotspots: 'hotspots.json',
   archetypes: 'archetypes.json',

package/src/index/resolveContext.js

@@ -4,6 +4,7 @@ import { inferRelatedTestsFromArtifacts, loadRelatedTestArtifacts } from './rela
 const TASK_TYPE_BUDGETS = {
   trivial: { minFiles: 1, maxFiles: 2 },
   simple: { minFiles: 2, maxFiles: 5 },
+  'shared-simple': { minFiles: 3, maxFiles: 8 },
   'non-trivial': { minFiles: 4, maxFiles: 8 },
 };
 

package/src/index/taskRouting.js

@@ -5,6 +5,7 @@ import { ROUTE_CATALOG } from './routeCatalog.js';
 import { buildRouteSignalText } from './languageTools.js';
 import { resolveContext } from './resolveContext.js';
 import { deriveVerificationPlan } from './verificationPlan.js';
+import { isSharedImpactFile } from './impactCatalog.js';
 
 const MAX_ACTIVE_ROUTE_SKILLS = 2;
 
@@ -42,6 +43,7 @@ export async function deriveTaskRoute({
     promptText: normalizedPrompt,
     commandText: normalizedCommand,
     selectedIds,
+    targetFile: normalizedTarget,
   });
   const preservedPrompt = normalizedPrompt || String(lastExplicitUserPromptText || '').trim();
   const contextResult = useIndexedContext && (contextIntent || normalizedTarget)
@@ -531,7 +533,7 @@ function deriveContextIntent({ promptText, commandText, targetFile, selectedIds
   return '';
 }
 
-function inferTaskType({ promptText, commandText, selectedIds }) {
+function inferTaskType({ promptText, commandText, selectedIds, targetFile = null }) {
   const lower = buildRouteSignalText(promptText, commandText);
 
   if (
@@ -542,11 +544,16 @@ function inferTaskType({ promptText, commandText, selectedIds }) {
     return 'non-trivial';
   }
 
+  let inferred = 'simple';
   if (/\b(typo|label|text|rename|color|spacing|toggle|comment)\b/.test(lower)) {
-    return 'trivial';
+    inferred = 'trivial';
+  }
+
+  if ((inferred === 'simple' || inferred === 'trivial') && isSharedImpactFile(targetFile)) {
+    return 'shared-simple';
   }
 
-  return 'simple';
+  return inferred;
 }
 
 function shellEscape(str) {