@ngockhoale/ukit 1.1.6 → 1.1.8

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/routeCatalog.js

@@ -223,8 +223,30 @@ export const ROUTE_CATALOG = [
     path: '.claude/skills/docs-quality/SKILL.md',
     order: 12,
     signals: [
-      { type: 'prompt', regex: /\b(docs|documentation|readme|changelog|handoff|worklog|memory|code map)\b/i, score: 4 },
-      { type: 'file', regex: /\bdocs\/|readme\.md$|project\.md$|memory\.md$|worklog\.md$|code_map\.md$/i, score: 4 },
+      { type: 'prompt', regex: /\b(docs|documentation|readme|changelog|handoff|worklog|memory|code map|status\.md)\b/i, score: 4 },
+      { type: 'file', regex: /\bdocs\/|readme\.md$|project\.md$|memory\.md$|status\.md$|worklog\.md$|code_map\.md$/i, score: 4 },
+    ],
+  },
+  {
+    id: 'next-step',
+    path: '.claude/skills/next-step/SKILL.md',
+    order: 12.1,
+    contextMode: 'standalone',
+    signals: [
+      { type: 'prompt', regex: /\b(what(?:'s| is)? next|next steps?|project status|current status|where are we|continue(?: from)?(?: last session)?|roadmap|status\.md)\b/i, score: 7 },
+      { type: 'prompt', regex: /\b(làm gì tiếp|bước tiếp theo|tiếp theo làm gì|làm tiếp|đang ở đâu|trạng thái project|tình trạng project)\b/i, score: 7 },
+    ],
+  },
+  {
+    id: 'update-status',
+    path: '.claude/skills/update-status/SKILL.md',
+    order: 12.2,
+    contextMode: 'standalone',
+    signals: [
+      { type: 'prompt', regex: /\b(update|refresh|write|sync|record|capture|summari[sz]e).{0,48}\b(status\.md|project status|current state|next candidates?|session state)\b/i, score: 9 },
+      { type: 'prompt', regex: /\b(status\.md|project status).{0,48}\b(update|refresh|write|sync|record|capture|summari[sz]e)\b/i, score: 9 },
+      { type: 'prompt', regex: /\b(wrap up|handoff|end(?:ing)? this session|session summary|before final)\b/i, score: 7 },
+      { type: 'prompt', regex: /\b(cập nhật|ghi lại|tổng kết|chốt session|bàn giao).{0,48}\b(status|trạng thái|việc tiếp theo)\b/i, score: 9 },
     ],
   },
   {

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;
 
@@ -21,11 +22,17 @@ export async function deriveTaskRoute({
   const normalizedPrompt = String(promptText || '').trim();
   const normalizedCommand = String(commandText || '').trim();
   const normalizedTarget = normalizeRelativeFile(absoluteRoot, targetFile);
+  const intentMode = deriveIntentMode({
+    promptText: normalizedPrompt,
+    commandText: normalizedCommand,
+    targetFile: normalizedTarget,
+  });
   const activeSkills = await selectActiveSkills({
     rootDir: absoluteRoot,
     promptText: normalizedPrompt,
     commandText: normalizedCommand,
     targetFile: normalizedTarget,
+    intentMode,
   });
   const useIndexedContext = shouldUseIndexedContext({
     activeSkills,
@@ -42,6 +49,7 @@ export async function deriveTaskRoute({
     promptText: normalizedPrompt,
     commandText: normalizedCommand,
     selectedIds,
+    targetFile: normalizedTarget,
   });
   const preservedPrompt = normalizedPrompt || String(lastExplicitUserPromptText || '').trim();
   const contextResult = useIndexedContext && (contextIntent || normalizedTarget)
@@ -100,6 +108,7 @@ export async function deriveTaskRoute({
       targetFile: normalizedTarget,
       contextIntent,
       taskType: inferredTaskType,
+      intentMode,
     },
     contextRecommendation,
     verificationRecommendation,
@@ -115,6 +124,7 @@ export async function deriveTaskRoute({
       targetFile: normalizedTarget,
       contextIntent,
       taskType: inferredTaskType,
+      intentMode,
     },
     contextRecommendation,
     verificationRecommendation,
@@ -173,6 +183,7 @@ export function buildRouteSummary({
     fallbackCommands,
     preferredOrder,
     policyMode,
+    intentMode: routingContext.intentMode ?? null,
     delegateHint: delegationRecommendation?.hint ?? null,
     nextActionType: nextAction?.type ?? null,
     nextActionCommand,
@@ -181,7 +192,7 @@ export function buildRouteSummary({
   };
 }
 
-async function selectActiveSkills({ rootDir, promptText, commandText, targetFile }) {
+async function selectActiveSkills({ rootDir, promptText, commandText, targetFile, intentMode = null }) {
   const routeSignals = {
     promptRawText: String(promptText || '').toLowerCase(),
     promptNormalizedText: buildRouteSignalText(promptText),
@@ -192,6 +203,7 @@ async function selectActiveSkills({ rootDir, promptText, commandText, targetFile
   const scoredEntries = ROUTE_CATALOG
     .map((entry) => scoreSkillRouteEntry(entry, routeSignals))
     .filter((entry) => entry.score > 0)
+    .filter((entry) => shouldKeepRouteEntryForIntent(entry, intentMode))
     .sort((a, b) => b.score - a.score || a.order - b.order);
   const active = [];
 
@@ -207,6 +219,22 @@ async function selectActiveSkills({ rootDir, promptText, commandText, targetFile
   return active.map(({ order, ...rest }) => rest);
 }
 
+function shouldKeepRouteEntryForIntent(entry, intentMode) {
+  if (entry.id === 'next-step' && ['scoped-advice', 'docs-specific'].includes(intentMode)) {
+    return false;
+  }
+
+  if (entry.id === 'update-status' && intentMode === 'docs-specific') {
+    return false;
+  }
+
+  if (entry.id === 'docs-quality' && ['open-ended-status', 'status-update'].includes(intentMode)) {
+    return false;
+  }
+
+  return true;
+}
+
 function scoreSkillRouteEntry(entry, routeSignals = {}) {
   let score = 0;
   const reasons = [];
@@ -280,6 +308,116 @@ function getSignalTexts(signalType, routeSignals = {}) {
   };
 }
 
+function deriveIntentMode({ promptText = '', commandText = '', targetFile = null } = {}) {
+  const lower = buildRouteSignalText(promptText, commandText);
+  const raw = `${promptText ?? ''}\n${commandText ?? ''}`.toLowerCase();
+  const docsSpecific = hasDocsSpecificTaskSignal(lower, raw, targetFile);
+  const statusUpdate = hasStatusUpdateSignal(lower, raw);
+  const openEndedStatus = hasOpenEndedStatusSignal(lower, raw);
+  const concreteTask = hasConcreteTaskSignal(lower, raw, targetFile);
+
+  if (docsSpecific) {
+    return 'docs-specific';
+  }
+
+  if (statusUpdate) {
+    return 'status-update';
+  }
+
+  if (concreteTask && openEndedStatus) {
+    return 'scoped-advice';
+  }
+
+  if (openEndedStatus) {
+    return 'open-ended-status';
+  }
+
+  if (concreteTask) {
+    if (/\b(bug|debug|error|crash|broken|failing|stack trace|triage|fix|login|timeout)\b/.test(lower)) {
+      return 'debug-specific';
+    }
+    if (/\b(review|audit|diff|pr feedback|code review|kiem tra|soat)\b/.test(lower)) {
+      return 'review-specific';
+    }
+    if (/\b(implement|build|create|add|ship|deliver|refactor|integrate|integration|scaffold|feature)\b/.test(lower)) {
+      return 'implement-specific';
+    }
+  }
+
+  return null;
+}
+
+function hasStatusUpdateSignal(lower, raw) {
+  return /\b(update|refresh|write|sync|record|capture|summarize|summarise).{0,64}\b(status\.md|project status|current state|next candidates|session state)\b/.test(lower)
+    || /\b(status\.md|project status).{0,64}\b(update|refresh|write|sync|record|capture|summarize|summarise)\b/.test(lower)
+    || /\b(wrap up|handoff|end this session|ending this session|session summary|before final)\b/.test(lower)
+    || /\b(cap nhat|ghi lai|tong ket|chot session|ban giao).{0,64}\b(status|trang thai|viec tiep theo)\b/.test(lower)
+    || /\b(cập nhật|ghi lại|tổng kết|chốt session|bàn giao).{0,64}\b(status|trạng thái|việc tiếp theo)\b/.test(raw);
+}
+
+function hasOpenEndedStatusSignal(lower, raw) {
+  return /\b(what next|what is next|what's next|next step|next steps|project status|current status|where are we|continue|continue from last session|roadmap|status\.md)\b/.test(lower)
+    || /\b(lam gi tiep|buoc tiep theo|tiep theo lam gi|lam tiep|dang o dau|trang thai project|tinh trang project)\b/.test(lower)
+    || /\b(làm gì tiếp|bước tiếp theo|tiếp theo làm gì|làm tiếp|đang ở đâu|trạng thái project|tình trạng project)\b/.test(raw);
+}
+
+function hasConcreteTaskSignal(lower, raw, targetFile) {
+  if (targetFile && !isStatusFileTarget(targetFile)) {
+    return true;
+  }
+
+  return /\b(bug|debug|error|crash|broken|failing|stack trace|triage|fix|implement|build|create|add|ship|deliver|refactor|integrate|integration|scaffold|feature|review|audit|diff|pr feedback|code review|auth|login|api|endpoint|test|spec)\b/.test(lower)
+    || /\b(sửa|fix|lỗi|bug|debug|implement|cài|thêm|review|kiểm tra|soát|đăng nhập)\b/.test(raw);
+}
+
+function hasDocsSpecificTaskSignal(lower, raw, targetFile) {
+  if (!targetFile || !isDocsTarget(targetFile)) {
+    return false;
+  }
+
+  const targetName = path.posix.basename(String(targetFile || '').replaceAll('\\', '/')).toLowerCase();
+  const explicitStatusUpdate = hasExplicitStatusUpdateSignal(lower, raw);
+
+  if (!isStatusFileTarget(targetFile)) {
+    if (explicitStatusUpdate && !mentionsTargetDoc(lower, targetName)) {
+      return false;
+    }
+
+    return mentionsTargetDoc(lower, targetName)
+      || /\b(edit|write|improve|document|docs?|readme|changelog|worklog|memory|code map|template|wording|copy|grammar|format|structure|heading|section|handoff notes?)\b/.test(lower)
+      || /\b(câu chữ|chỉnh|sửa chữ|ngữ pháp|định dạng|cấu trúc|tài liệu|ghi chú bàn giao)\b/.test(raw);
+  }
+
+  return /\b(template|wording|edit|copy|grammar|format|structure|heading|section|docs?)\b/.test(lower)
+    || /\b(mẫu|câu chữ|chỉnh|sửa chữ|ngữ pháp|định dạng|cấu trúc|tài liệu)\b/.test(raw);
+}
+
+function hasExplicitStatusUpdateSignal(lower, raw) {
+  return /\b(update|refresh|write|sync|record|capture|summarize|summarise).{0,64}\b(status\.md|project status|current state|next candidates|session state)\b/.test(lower)
+    || /\b(status\.md|project status).{0,64}\b(update|refresh|write|sync|record|capture|summarize|summarise)\b/.test(lower)
+    || /\b(cap nhat|ghi lai|tong ket|chot session|ban giao).{0,64}\b(status|trang thai|viec tiep theo)\b/.test(lower)
+    || /\b(cập nhật|ghi lại|tổng kết|chốt session|bàn giao).{0,64}\b(status|trạng thái|việc tiếp theo)\b/.test(raw);
+}
+
+function mentionsTargetDoc(lower, targetName) {
+  if (!targetName) {
+    return false;
+  }
+
+  const escaped = targetName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const withoutExt = escaped.replace(/\\\.md$/i, '');
+  return new RegExp(`\\b(?:${escaped}|${withoutExt})\\b`, 'i').test(lower);
+}
+
+function isStatusFileTarget(targetFile) {
+  return /(?:^|\/)docs\/STATUS\.md$|(?:^|\/)STATUS\.md$/i.test(String(targetFile || ''));
+}
+
+function isDocsTarget(targetFile) {
+  const normalized = String(targetFile || '').replaceAll('\\', '/');
+  return /(?:^|\/)docs\/.+\.md$|(?:^|\/)(?:README|CHANGELOG|AGENTS|CLAUDE|STATUS)\.md$/i.test(normalized);
+}
+
 function shouldUseIndexedContext({ activeSkills = [], targetFile = null } = {}) {
   if (activeSkills.length === 0) {
     return Boolean(targetFile);
@@ -531,7 +669,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 +680,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) {

package/src/index/verificationPlan.js

@@ -23,6 +23,7 @@ export async function deriveVerificationPlan({
   targetFile = null,
   taskType = null,
   contextResult = null,
+  impactContext = null,
   skillIds = [],
 } = {}) {
   const absoluteRoot = path.resolve(rootDir);
@@ -72,7 +73,15 @@ export async function deriveVerificationPlan({
     const notes = [];
     const docsOnly = primaryTargets.length > 0
       && primaryTargets.every((filePath) => filePath.startsWith('docs/'));
+    const impactTests = unique(impactContext?.recommendedTestFiles ?? []);
+    const impactRisk = Boolean(
+      impactContext?.requiresImpactCheck
+      || (impactContext?.riskLabels ?? []).length > 0,
+    );
+    const sharedSimple = effectiveTaskType === 'shared-simple' || taskType === 'shared-simple';
     const risky = effectiveTaskType === 'non-trivial'
+      || sharedSimple
+      || impactRisk
       || skillIds.some((skillId) => RISKY_SKILL_IDS.has(skillId));
 
     let mode = 'minimal';
@@ -98,6 +107,14 @@ export async function deriveVerificationPlan({
         }
       }
 
+      if (impactTests.length > 0 && scripts.test) {
+        mode = relatedTests.length > 0 ? mode : 'impact-tests-first';
+        reasons.push('impactTests');
+        for (const testFile of impactTests.slice(0, 2)) {
+          commands.push(buildScriptCommand(packageManager, 'test', [testFile]));
+        }
+      }
+
       if (risky) {
         reasons.push('riskySkillOrTask');
         if (scripts.test) {
@@ -345,7 +362,7 @@ function deriveExecutionPolicy({
     || reasons.includes('riskySkillOrTask')
     || reasons.includes('highRiskFallback');
   const hasPrimaryCommands = commands.length > 0;
-  const hasTargetedPrimaryCommands = mode === 'targeted-tests-first' && hasPrimaryCommands;
+  const hasTargetedPrimaryCommands = (mode === 'targeted-tests-first' || mode === 'impact-tests-first') && hasPrimaryCommands;
   const sharedScope = sharedAbstractions.length > 0;
   const noRelatedTests = relatedTests.length === 0;
   const broadOnlyPrimary = hasPrimaryCommands && !hasTargetedPrimaryCommands && noRelatedTests;

package/templates/.claude/hooks/skill-router.sh

@@ -386,7 +386,7 @@ const { pathToFileURL } = require('url');
     return '';
   }
 
-  function inferTaskType({ promptText, commandText, selectedIds, buildRouteSignalText }) {
+  function inferTaskType({ promptText, commandText, selectedIds, buildRouteSignalText, targetFile = null }) {
     const lower = buildRouteSignalText(promptText, commandText);
 
     if (