@ngockhoale/ukit 1.1.6

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

@@ -0,0 +1,1681 @@
+#!/bin/bash
+# Hook: route prompt/tool signals to the smallest useful installed skill set.
+# Used from UserPromptSubmit and PreToolUse so end users do not need to name skills.
+
+INPUT=$(cat)
+PROJECT_ROOT="${CLAUDE_PROJECT_DIR:-$(pwd)}"
+STATE_FILE="$PROJECT_ROOT/.claude/ukit/skill-router-state.json"
+HOOK_DIR="$(cd "$(dirname "$0")" && pwd)"
+THRESHOLD_SCRIPT="$HOOK_DIR/../ukit/runtime/compact-threshold.mjs"
+
+INPUT="$INPUT" PROJECT_ROOT="$PROJECT_ROOT" STATE_FILE="$STATE_FILE" HOOK_DIR="$HOOK_DIR" node <<'NODE'
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { pathToFileURL } = require('url');
+
+(async () => {
+  const STOPWORDS = new Set([
+    'the', 'a', 'an', 'and', 'or', 'to', 'for', 'of', 'with', 'in', 'on', 'is', 'are',
+    'this', 'that', 'it', 'as', 'by', 'be', 'use', 'using', 'implement', 'fix', 'task',
+    'cần', 'và', 'là', 'cho', 'một', 'những', 'dùng',
+  ]);
+
+  function readJson(filePath, fallback = null) {
+    try {
+      return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    } catch {
+      return fallback;
+    }
+  }
+
+  function ensureDir(filePath) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  }
+
+  function defaultRuntimeConfig() {
+    return {
+      memory: {
+        enabled: true,
+        progressiveRetrieval: true,
+      },
+    };
+  }
+
+  function deepMerge(base, override) {
+    if (!override || typeof override !== 'object' || Array.isArray(override)) {
+      return override === undefined ? base : override;
+    }
+
+    const merged = { ...base };
+    for (const [key, value] of Object.entries(override)) {
+      if (
+        value
+        && typeof value === 'object'
+        && !Array.isArray(value)
+        && merged[key]
+        && typeof merged[key] === 'object'
+        && !Array.isArray(merged[key])
+      ) {
+        merged[key] = deepMerge(merged[key], value);
+        continue;
+      }
+
+      merged[key] = value;
+    }
+
+    return merged;
+  }
+
+  function buildRuntimePaths(projectRoot) {
+    const runtimeRoot = path.join(projectRoot, '.ukit');
+    const storageRoot = path.join(runtimeRoot, 'storage');
+    const memoryRoot = path.join(storageRoot, 'memory');
+
+    return {
+      configPath: path.join(storageRoot, 'config.json'),
+      userMemoryPath: path.join(memoryRoot, 'user.json'),
+      projectsDir: path.join(memoryRoot, 'projects'),
+      sessionsDir: path.join(memoryRoot, 'sessions'),
+    };
+  }
+
+  function loadRuntimeConfig(projectRoot) {
+    const runtimePaths = buildRuntimePaths(projectRoot);
+    const raw = readJson(runtimePaths.configPath, {});
+    return deepMerge(defaultRuntimeConfig(), raw && typeof raw === 'object' ? raw : {});
+  }
+
+  function readIndexGeneratedAtMs(projectRoot) {
+    const artifact = readJson(path.join(projectRoot, '.cache', 'index', 'files.json'), null);
+    const generatedAtRaw = String(artifact?.generatedAt || '').trim();
+    if (!generatedAtRaw) {
+      return null;
+    }
+
+    const generatedAtMs = Date.parse(generatedAtRaw);
+    return Number.isNaN(generatedAtMs) ? null : generatedAtMs;
+  }
+
+  async function loadRouteCatalog(projectRoot) {
+    const routeCatalogPath = path.join(projectRoot, '.claude', 'ukit', 'index', 'route-catalog.mjs');
+    if (!fs.existsSync(routeCatalogPath)) {
+      return [];
+    }
+
+    try {
+      const mod = await import(pathToFileURL(routeCatalogPath).href);
+      return Array.isArray(mod.ROUTE_CATALOG) ? mod.ROUTE_CATALOG : [];
+    } catch {
+      return [];
+    }
+  }
+
+  async function loadLanguageTools(projectRoot) {
+    const candidatePaths = [
+      path.join(projectRoot, '.claude', 'ukit', 'index', 'lib', 'index-core.mjs'),
+      process.env.HOOK_DIR
+        ? path.resolve(process.env.HOOK_DIR, '..', 'ukit', 'index', 'lib', 'index-core.mjs')
+        : null,
+    ].filter(Boolean);
+
+    for (const indexCorePath of candidatePaths) {
+      if (!fs.existsSync(indexCorePath)) {
+        continue;
+      }
+
+      try {
+        const mod = await import(pathToFileURL(indexCorePath).href);
+        if (typeof mod.buildRouteSignalText === 'function') {
+          return {
+            buildRouteSignalText: mod.buildRouteSignalText,
+          };
+        }
+      } catch {}
+    }
+
+    return {
+      buildRouteSignalText: (...values) => values
+        .map((value) => String(value || '').trim())
+        .filter(Boolean)
+        .join('\n')
+        .toLowerCase(),
+    };
+  }
+
+  function existsSkill(projectRoot, relativePath) {
+    return fs.existsSync(path.join(projectRoot, relativePath));
+  }
+
+  function scoreSkillRouteEntry(entry, routeSignals = {}) {
+    let score = 0;
+    const reasons = [];
+
+    for (const signal of entry.signals) {
+      const { directText, normalizedText } = getSignalTexts(signal.type, routeSignals);
+      signal.regex.lastIndex = 0;
+      const directMatch = signal.regex.test(directText);
+      signal.regex.lastIndex = 0;
+      const normalizedMatch = !directMatch && Boolean(normalizedText) && signal.regex.test(normalizedText);
+      if (!directMatch && !normalizedMatch) continue;
+      score += directMatch
+        ? signal.score
+        : Math.max(1, signal.score - 1);
+      reasons.push(signal.type);
+    }
+
+    score += deriveSkillPriorityBoost(entry.id, routeSignals);
+
+    return {
+      id: entry.id,
+      path: entry.path,
+      contextMode: entry.contextMode || 'indexed',
+      score,
+      order: entry.order,
+      reasons: [...new Set(reasons)],
+    };
+  }
+
+  function deriveSkillPriorityBoost(skillId, routeSignals = {}) {
+    const combinedPromptSignals = [
+      routeSignals.promptRawText || '',
+      routeSignals.promptNormalizedText || '',
+      routeSignals.commandRawText || '',
+      routeSignals.commandNormalizedText || '',
+    ].join('\n');
+
+    if (
+      skillId === 'testing-quality'
+      && /\b(test|tests|spec|coverage|mock|fixture|assert|vitest|jest|playwright)\b/.test(combinedPromptSignals)
+    ) {
+      return 1;
+    }
+
+    return 0;
+  }
+
+  function getSignalTexts(signalType, routeSignals = {}) {
+    if (signalType === 'command') {
+      return {
+        directText: routeSignals.commandRawText || '',
+        normalizedText: routeSignals.commandNormalizedText || '',
+      };
+    }
+
+    if (signalType === 'file') {
+      return {
+        directText: routeSignals.fileText || '',
+        normalizedText: '',
+      };
+    }
+
+    return {
+      directText: routeSignals.promptRawText || '',
+      normalizedText: routeSignals.promptNormalizedText || '',
+    };
+  }
+
+  function shouldUseIndexedContext({ activeSkills = [], targetFile = null } = {}) {
+    if (activeSkills.length === 0) {
+      return Boolean(targetFile);
+    }
+
+    const primarySkill = activeSkills[0] || null;
+    const primaryIsStandalone = primarySkill?.contextMode === 'standalone';
+    if (!primaryIsStandalone) {
+      return true;
+    }
+
+    if (isStandaloneNonIndexedTarget(primarySkill, targetFile)) {
+      return false;
+    }
+
+    if (activeSkills.some((skill) => skill?.contextMode !== 'standalone')) {
+      return true;
+    }
+
+    return isCodeIndexedTarget(targetFile);
+  }
+
+  function isStandaloneNonIndexedTarget(primarySkill, targetFile) {
+    if (typeof targetFile !== 'string' || !targetFile.trim()) {
+      return false;
+    }
+
+    const normalized = targetFile.replaceAll('\\', '/');
+    if (primarySkill?.id === 'docker-packaging') {
+      return /(?:^|\/)(?:Dockerfile|docker-compose(?:\.ya?ml)?|compose\.ya?ml|\.dockerignore)$/i.test(normalized);
+    }
+
+    return false;
+  }
+
+  function isCodeIndexedTarget(filePath) {
+    if (typeof filePath !== 'string' || !filePath.trim()) {
+      return false;
+    }
+
+    const normalized = filePath.replaceAll('\\', '/');
+    if (/\.(?:[cm]?js|jsx|tsx?|vue|py|rb|go|rs|java|kt|swift|php|cs|c|cc|cpp|cxx|h|hpp|m|mm|scala|sh|bash|zsh|sql|psql|css|scss|sass|less|html|xml|json|ya?ml|toml)$/i.test(normalized)) {
+      return true;
+    }
+
+    return /(?:^|\/)(?:src|test|tests|app|lib|components|pages|screens|layouts|composables|api|routes?|controllers?|services?|db|database|migrations?|prisma|SQL)\//i.test(normalized);
+  }
+
+  function extractPrompt(payload) {
+    const candidates = [
+      payload.prompt,
+      payload.user_prompt,
+      payload.text,
+      payload.message,
+      payload.input,
+    ];
+    return candidates.find((value) => typeof value === 'string' && value.trim()) || '';
+  }
+
+  function normalizeRelativeFile(projectRoot, rawFilePath) {
+    if (typeof rawFilePath !== 'string' || !rawFilePath.trim()) {
+      return null;
+    }
+
+    const trimmed = rawFilePath.trim();
+    if (path.isAbsolute(trimmed)) {
+      const relative = path.relative(projectRoot, trimmed);
+      if (relative && !relative.startsWith('..') && !path.isAbsolute(relative)) {
+        return relative.replaceAll('\\', '/');
+      }
+      return trimmed.replaceAll('\\', '/');
+    }
+
+    return trimmed.replace(/^\.\/+/, '').replaceAll('\\', '/');
+  }
+
+  function buildRouteRequestKey({
+    commandNamespace = '.claude',
+    indexGeneratedAtMs = null,
+    projectFingerprint = null,
+    activeSkills = [],
+    routingContext = {},
+    previousContextFingerprint = null,
+  }) {
+    return buildCompactMachineKey('route-v2', {
+      commandNamespace,
+      indexGeneratedAtMs,
+      projectFingerprint,
+      skillIds: activeSkills.map((item) => item.id),
+      skillPaths: activeSkills.map((item) => item.path),
+      skillContextModes: activeSkills.map((item) => item.contextMode || 'indexed'),
+      promptText: routingContext.promptText || '',
+      lastExplicitUserPromptText: routingContext.lastExplicitUserPromptText || '',
+      commandText: routingContext.commandText || '',
+      targetFile: routingContext.targetFile || '',
+      contextIntent: routingContext.contextIntent || '',
+      taskType: routingContext.taskType || '',
+      previousContextFingerprint: previousContextFingerprint || null,
+    });
+  }
+
+  function buildRouteStateFingerprint({
+    activeSkills = [],
+    routingContext = {},
+    previousContext = null,
+    routeSummary = null,
+  } = {}) {
+    return buildCompactMachineKey('routefp-v3', {
+      skills: activeSkills.map((item) => item.id),
+      taskType: routingContext?.taskType || null,
+      previousContextLine: previousContext?.line || null,
+      previousContextIds: unique(previousContext?.selectedIds ?? []),
+      policyMode: routeSummary?.policyMode || null,
+      delegateHint: routeSummary?.delegateHint || null,
+      nextActionType: routeSummary?.nextActionType || null,
+      nextActionCommand: routeSummary?.nextActionCommand || null,
+      helperHint: routeSummary?.helperHint || null,
+      primaryCommands: [...new Set((routeSummary?.primaryCommands || []).filter(Boolean))],
+      fallbackCommands: [...new Set((routeSummary?.fallbackCommands || []).filter(Boolean))],
+      preferredOrder: [...new Set((routeSummary?.preferredOrder || []).filter(Boolean))],
+    });
+  }
+
+  function buildCompactMachineKey(prefix, payload) {
+    return `${prefix}:${stableMachineDigest(payload)}`;
+  }
+
+  function stableMachineDigest(payload) {
+    return crypto
+      .createHash('sha256')
+      .update(JSON.stringify(payload))
+      .digest('base64url');
+  }
+
+  function unique(values = []) {
+    return [...new Set((values || []).filter(Boolean))];
+  }
+
+  function deriveContextIntent({ promptText, commandText, targetFile, selectedIds }) {
+    if (promptText.trim()) {
+      return promptText.trim();
+    }
+
+    if (commandText.includes('triage.mjs')) {
+      return `debug ${commandText.trim()}`.trim();
+    }
+
+    if (commandText.includes('query-index.mjs')) {
+      return `investigate ${commandText.trim()}`.trim();
+    }
+
+    if (/\b(test|vitest|jest|playwright|cypress)\b/i.test(commandText)) {
+      return targetFile ? `fix failing test around ${targetFile}` : 'fix failing test';
+    }
+
+    if (targetFile) {
+      if (/^docs\//i.test(targetFile)) {
+        return `update docs for ${targetFile}`;
+      }
+      return `work on ${targetFile}`;
+    }
+
+    if (selectedIds.includes('docs-quality')) return 'update documentation';
+    if (selectedIds.includes('debugging-toolkit')) return 'debug failing issue';
+    if (selectedIds.includes('testing-quality')) return 'write targeted test';
+    if (selectedIds.includes('code-review')) return 'review change for regressions';
+    if (selectedIds.includes('repo-maintenance')) return 'refresh stale workspace';
+    if (selectedIds.includes('discover-security')) return 'review security-sensitive change';
+    return '';
+  }
+
+  function inferTaskType({ promptText, commandText, selectedIds, buildRouteSignalText }) {
+    const lower = buildRouteSignalText(promptText, commandText);
+
+    if (
+      selectedIds.includes('discover-security')
+      || selectedIds.includes('repo-maintenance')
+      || /\b(auth|security|token|permission|secret|migration|uninstall|delete all|drop table|race|flaky|timeout)\b/.test(lower)
+    ) {
+      return 'non-trivial';
+    }
+
+    if (/\b(typo|label|text|rename|color|spacing|toggle|comment)\b/.test(lower)) {
+      return 'trivial';
+    }
+
+    return 'simple';
+  }
+
+  function shellEscape(value) {
+    if (typeof value !== 'string') return '';
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+  }
+
+  function buildContextCommand({ intent, targetFile, taskType }) {
+    const parts = ['node .claude/ukit/index/resolve-context.mjs'];
+    if (intent) {
+      parts.push(shellEscape(intent));
+    }
+    if (targetFile) {
+      parts.push('--target', shellEscape(targetFile));
+    }
+    if (taskType) {
+      parts.push('--type', taskType);
+    }
+    return parts.join(' ');
+  }
+
+  function buildVerificationHelperCommand({ intent, targetFile, taskType }) {
+    const parts = ['node .claude/ukit/index/verify-context.mjs'];
+    if (intent) {
+      parts.push(shellEscape(intent));
+    }
+    if (targetFile) {
+      parts.push('--target', shellEscape(targetFile));
+    }
+    if (taskType) {
+      parts.push('--type', taskType);
+    }
+    return parts.join(' ');
+  }
+
+  async function buildContextRecommendation({ projectRoot, intent, targetFile, taskType }) {
+    if (!intent && !targetFile) {
+      return null;
+    }
+
+    const recommendation = {
+      command: buildContextCommand({ intent, targetFile, taskType }),
+      preview: null,
+    };
+
+    const indexCorePath = path.join(projectRoot, '.claude', 'ukit', 'index', 'lib', 'index-core.mjs');
+    if (!fs.existsSync(indexCorePath)) {
+      return recommendation;
+    }
+
+    try {
+      const mod = await import(pathToFileURL(indexCorePath).href);
+      if (typeof mod.resolveContext !== 'function') {
+        return recommendation;
+      }
+
+      const result = await mod.resolveContext({
+        rootDir: projectRoot,
+        intent,
+        targetFile,
+        taskType,
+      });
+
+      recommendation.preview = {
+        taskType: result.taskType,
+        primaryTargets: result.primaryTargets ?? [],
+        analogFiles: result.analogFiles ?? [],
+        sharedAbstractions: result.sharedAbstractions ?? [],
+        relatedTests: result.relatedTests ?? [],
+        styleFiles: result.styleFiles ?? [],
+      };
+      return recommendation;
+    } catch {
+      return recommendation;
+    }
+  }
+
+  function readProjectPackage(projectRoot) {
+    return readJson(path.join(projectRoot, 'package.json'), null);
+  }
+
+  function readProjectVerificationFingerprint(projectRoot) {
+    let pkg = null;
+    const entries = [];
+
+    try {
+      const packageJsonPath = path.join(projectRoot, 'package.json');
+      const raw = fs.readFileSync(packageJsonPath, 'utf8');
+      const stat = fs.statSync(packageJsonPath);
+      pkg = JSON.parse(raw);
+      entries.push({
+        filePath: 'package.json',
+        size: stat.size,
+        mtimeMs: stat.mtimeMs,
+      });
+    } catch {
+      entries.push({
+        filePath: 'package.json',
+        size: null,
+        mtimeMs: null,
+      });
+    }
+
+    const trackedFiles = getDeclaredPackageManager(pkg)
+      ? []
+      : [
+          'package-lock.json',
+          'pnpm-lock.yaml',
+          'yarn.lock',
+          'bun.lockb',
+          'bun.lock',
+        ];
+    entries.push(...trackedFiles.map((relativePath) => {
+      try {
+        const stat = fs.statSync(path.join(projectRoot, relativePath));
+        return {
+          filePath: relativePath,
+          size: stat.size,
+          mtimeMs: stat.mtimeMs,
+        };
+      } catch {
+        return {
+          filePath: relativePath,
+          size: null,
+          mtimeMs: null,
+        };
+      }
+    }));
+
+    return {
+      pkg,
+      entries,
+      fingerprint: JSON.stringify(entries),
+    };
+  }
+
+  function getDeclaredPackageManager(pkg) {
+    const declared = typeof pkg?.packageManager === 'string'
+      ? pkg.packageManager.split('@')[0]
+      : null;
+    if (declared && ['npm', 'yarn', 'pnpm', 'bun'].includes(declared)) {
+      return declared;
+    }
+
+    return null;
+  }
+
+  function detectProjectId(projectRoot) {
+    const pkg = readJson(path.join(projectRoot, 'package.json'), null);
+    if (typeof pkg?.name === 'string' && pkg.name.trim()) {
+      return pkg.name.trim();
+    }
+
+    return path.basename(projectRoot);
+  }
+
+  function readDirectoryJsonItems(dirPath) {
+    let entries = [];
+    try {
+      entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+
+    const items = [];
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith('.json')) {
+        continue;
+      }
+
+      const fullPath = path.join(dirPath, entry.name);
+      const content = readJson(fullPath, null);
+      if (content && typeof content === 'object') {
+        items.push({
+          fileName: entry.name,
+          filePath: fullPath,
+          content,
+        });
+      }
+    }
+
+    return items.sort((left, right) => left.fileName.localeCompare(right.fileName));
+  }
+
+  function listMemoryItems(projectRoot) {
+    const runtimePaths = buildRuntimePaths(projectRoot);
+    const userMemory = readJson(runtimePaths.userMemoryPath, null) ?? { preferences: {}, rules: [] };
+    const projectMemories = readDirectoryJsonItems(runtimePaths.projectsDir);
+    const sessionMemories = readDirectoryJsonItems(runtimePaths.sessionsDir);
+
+    return [
+      {
+        id: 'user:user',
+        type: 'user',
+        content: userMemory,
+      },
+      ...projectMemories.map((item) => ({
+        id: `project:${item.content.id ?? item.fileName.replace(/\.json$/, '')}`,
+        type: 'project',
+        content: item.content,
+      })),
+      ...sessionMemories.map((item) => ({
+        id: `session:${item.content.id ?? item.fileName.replace(/\.json$/, '')}`,
+        type: 'session',
+        content: item.content,
+      })),
+    ];
+  }
+
+  function normalizeMemoryText(text) {
+    return String(text ?? '')
+      .toLowerCase()
+      .replace(/[^\p{L}\p{N}\s./:_-]/gu, ' ')
+      .replace(/\s+/g, ' ')
+      .trim();
+  }
+
+  function tokenizeMemoryText(text) {
+    return normalizeMemoryText(text)
+      .split(/\s+/)
+      .filter((token) => token && !STOPWORDS.has(token) && token.length > 1);
+  }
+
+  function getMemoryTimestamp(item) {
+    return item.content?.updatedAt
+      ?? item.content?.endedAt
+      ?? item.content?.startedAt
+      ?? 0;
+  }
+
+  function buildMemorySegments(item) {
+    const content = item.content ?? {};
+    if (item.type === 'project') {
+      return [
+        { text: content.name, weight: 2 },
+        { text: content.architecture, weight: 3 },
+        { text: (content.techStack ?? []).join(' '), weight: 2 },
+        { text: (content.activeRules ?? []).join(' '), weight: 2 },
+        { text: (content.decisions ?? []).map((decision) => `${decision.what} ${decision.why}`).join(' '), weight: 7 },
+      ];
+    }
+
+    if (item.type === 'session') {
+      return [
+        { text: content.taskDescription, weight: 4 },
+        { text: content.outcome, weight: 1 },
+        { text: (content.keyActions ?? []).join(' '), weight: 3 },
+        { text: (content.nextSteps ?? []).join(' '), weight: 2 },
+        { text: (content.filesChanged ?? []).join(' '), weight: 1 },
+        { text: (content.decisionsMade ?? []).map((decision) => `${decision.what} ${decision.why}`).join(' '), weight: 4 },
+      ];
+    }
+
+    return [
+      { text: JSON.stringify(content.preferences ?? {}), weight: 1 },
+      { text: (content.rules ?? []).join(' '), weight: 2 },
+    ];
+  }
+
+  function scoreMemoryItem(item, queryTokens) {
+    if (queryTokens.length === 0) {
+      return 0;
+    }
+
+    let score = 0;
+    for (const segment of buildMemorySegments(item)) {
+      const segmentTokens = new Set(tokenizeMemoryText(segment.text));
+      for (const token of queryTokens) {
+        if (segmentTokens.has(token)) {
+          score += segment.weight;
+        }
+      }
+    }
+
+    if (score === 0) {
+      return 0;
+    }
+
+    const recencyBonus = getMemoryTimestamp(item) > 0 ? Math.min(1, getMemoryTimestamp(item) / Date.now()) : 0;
+    return score + recencyBonus;
+  }
+
+  function buildPreviousContextSnippet(item) {
+    const content = item.content ?? {};
+    if (item.type === 'project') {
+      const decisions = (content.decisions ?? []).map((decision) => decision.what).slice(0, 2).join('; ');
+      const rules = (content.activeRules ?? []).slice(0, 2).join('; ');
+      return `[project] ${content.name ?? content.id ?? 'project'} — decisions: ${decisions || 'n/a'}${rules ? ` — rules: ${rules}` : ''}`;
+    }
+
+    if (item.type === 'session') {
+      const actions = (content.keyActions ?? []).slice(0, 2).join('; ');
+      const nextSteps = (content.nextSteps ?? []).slice(0, 1).join('; ');
+      return `[session] ${content.taskDescription ?? item.id} — outcome: ${content.outcome ?? 'unknown'}${actions ? ` — actions: ${actions}` : ''}${nextSteps ? ` — next: ${nextSteps}` : ''}`;
+    }
+
+    const rules = (content.rules ?? []).slice(0, 2).join('; ');
+    return `[user] rules: ${rules || 'n/a'}`;
+  }
+
+  function buildPreviousContextSnapshot({
+    projectRoot,
+    routingContext = {},
+    config = defaultRuntimeConfig(),
+  } = {}) {
+    if (!config?.memory?.enabled || !config?.memory?.progressiveRetrieval) {
+      return null;
+    }
+
+    const taskQuery = String(
+      routingContext?.lastExplicitUserPromptText
+      || routingContext?.promptText
+      || routingContext?.targetFile
+      || ''
+    ).trim();
+    if (!taskQuery) {
+      return null;
+    }
+
+    const projectId = detectProjectId(projectRoot);
+    const items = listMemoryItems(projectRoot);
+    const queryTokens = tokenizeMemoryText(taskQuery);
+    const rankedItems = items
+      .filter((item) => item.type !== 'user')
+      .filter((item) => (
+        item.type === 'project'
+          ? (item.content?.id === projectId)
+          : (item.type === 'session' ? item.content?.projectId === projectId : true)
+      ))
+      .map((item) => ({
+        item,
+        score: scoreMemoryItem(item, queryTokens),
+      }))
+      .filter((entry) => entry.score > 0)
+      .sort((left, right) => (
+        right.score - left.score
+        || getMemoryTimestamp(right.item) - getMemoryTimestamp(left.item)
+      ))
+      .slice(0, 2)
+      .map((entry) => entry.item);
+
+    if (rankedItems.length === 0) {
+      return null;
+    }
+
+    return {
+      line: rankedItems.map((item) => buildPreviousContextSnippet(item)).join(' | '),
+      selectedIds: rankedItems.map((item) => item.id),
+      fingerprint: buildCompactMachineKey('route-memory-v1', {
+        taskQuery: normalizeMemoryText(taskQuery),
+        projectId,
+        items: rankedItems.map((item) => ({
+          id: item.id,
+          timestamp: getMemoryTimestamp(item),
+        })),
+      }),
+    };
+  }
+
+  function detectPackageManager(projectRoot, pkg) {
+    const declared = getDeclaredPackageManager(pkg);
+    if (declared) return declared;
+
+    if (fs.existsSync(path.join(projectRoot, 'pnpm-lock.yaml'))) return 'pnpm';
+    if (fs.existsSync(path.join(projectRoot, 'yarn.lock'))) return 'yarn';
+    if (fs.existsSync(path.join(projectRoot, 'bun.lockb')) || fs.existsSync(path.join(projectRoot, 'bun.lock'))) return 'bun';
+    return 'npm';
+  }
+
+  function buildScriptCommand(packageManager, scriptName, args = []) {
+    const safeArgs = args.filter(Boolean);
+
+    if (packageManager === 'npm') {
+      if (scriptName === 'test') {
+        return ['npm', 'test', safeArgs.length > 0 ? '--' : '', ...safeArgs]
+          .filter(Boolean)
+          .join(' ');
+      }
+
+      return ['npm', 'run', scriptName, safeArgs.length > 0 ? '--' : '', ...safeArgs]
+        .filter(Boolean)
+        .join(' ');
+    }
+
+    return [packageManager, scriptName, ...safeArgs].join(' ');
+  }
+
+  function buildVerificationRecommendation({
+    projectRoot,
+    selectedIds,
+    contextRecommendation,
+    contextIntent,
+    targetFile,
+    taskType,
+    pkg = null,
+  }) {
+    const resolvedPkg = pkg || readProjectPackage(projectRoot) || {};
+    const scripts = typeof resolvedPkg.scripts === 'object' && resolvedPkg.scripts ? resolvedPkg.scripts : {};
+    const packageManager = detectPackageManager(projectRoot, resolvedPkg);
+    const preview = contextRecommendation?.preview || {};
+    const relatedTests = [...new Set([
+      ...(Array.isArray(preview.relatedTests) ? preview.relatedTests : []),
+      ...(targetFile && /\.(test|spec)\./.test(targetFile) ? [targetFile] : []),
+    ])];
+    const primaryTargets = [...new Set([
+      ...(Array.isArray(preview.primaryTargets) ? preview.primaryTargets : []),
+      ...(targetFile ? [targetFile] : []),
+    ])];
+    const commands = [];
+    const fallbackCommands = [];
+    const reasons = [];
+    const notes = [];
+    const docsOnly = primaryTargets.length > 0
+      && primaryTargets.every((filePath) => /^docs\//.test(filePath));
+    const highRisk = taskType === 'non-trivial'
+      || selectedIds.some((id) => id === 'discover-security' || id === 'repo-maintenance');
+
+    let mode = 'minimal';
+
+    if (docsOnly) {
+      mode = 'docs-only';
+      reasons.push('docsOnly');
+      if (scripts.lint) {
+        fallbackCommands.push(buildScriptCommand(packageManager, 'lint'));
+      }
+      notes.push('Docs-focused change: prefer docs syntax/format checks if available; broad test runs are not the default.');
+      const commandList = [...new Set(commands)];
+      const fallbackList = [...new Set(fallbackCommands.filter((command) => !commandList.includes(command)))];
+      const reasonList = [...new Set(reasons)];
+      return {
+        packageManager,
+        mode,
+        helperCommand: buildVerificationHelperCommand({ intent: contextIntent, targetFile, taskType }),
+        commands: commandList,
+        fallbackCommands: fallbackList,
+        reasons: reasonList,
+        notes,
+        relatedTests,
+        primaryTargets,
+        executionPolicy: deriveExecutionPolicy({
+          taskType: preview.taskType || taskType,
+          mode,
+          commands: commandList,
+          fallbackCommands: fallbackList,
+          reasons: reasonList,
+          context: {
+            primaryTargets,
+            sharedAbstractions: Array.isArray(preview.sharedAbstractions) ? preview.sharedAbstractions : [],
+            relatedTests,
+          },
+        }),
+      };
+    }
+
+    if (relatedTests.length > 0) {
+      mode = 'targeted-tests-first';
+      reasons.push('relatedTests');
+      if (scripts.test) {
+        for (const testFile of relatedTests.slice(0, 2)) {
+          commands.push(buildScriptCommand(packageManager, 'test', [testFile]));
+        }
+      } else {
+        notes.push(`Run the most relevant related tests first: ${relatedTests.slice(0, 2).join(', ')}`);
+      }
+    }
+
+    if (highRisk) {
+      reasons.push('riskySkillOrTask');
+      if (scripts.test) {
+        const broaderTest = buildScriptCommand(packageManager, 'test');
+        if (!commands.includes(broaderTest)) {
+          fallbackCommands.push(broaderTest);
+        }
+      }
+    }
+
+    if (selectedIds.some((id) => ['debugging-toolkit', 'testing-quality', 'code-review', 'discover-security', 'repo-maintenance'].includes(id))) {
+      if (scripts.lint) {
+        fallbackCommands.push(buildScriptCommand(packageManager, 'lint'));
+      }
+      if (scripts.typecheck) {
+        fallbackCommands.push(buildScriptCommand(packageManager, 'typecheck'));
+      }
+    }
+
+    if (commands.length === 0 && scripts.test && (highRisk || selectedIds.some((id) => ['testing-quality', 'code-review'].includes(id)))) {
+      mode = highRisk ? 'broader-verification' : 'default-test-first';
+      reasons.push(highRisk ? 'highRiskFallback' : 'defaultTestScript');
+      commands.push(buildScriptCommand(packageManager, 'test'));
+    }
+
+    if (commands.length === 0 && fallbackCommands.length === 0) {
+      notes.push('Match verification effort to scope; no project test/lint/typecheck scripts were detected.');
+    }
+
+    const commandList = [...new Set(commands)];
+    const fallbackList = [...new Set(fallbackCommands.filter((command) => !commandList.includes(command)))];
+    const reasonList = [...new Set(reasons)];
+
+    return {
+      packageManager,
+      mode,
+      helperCommand: buildVerificationHelperCommand({ intent: contextIntent, targetFile, taskType }),
+      commands: commandList,
+      fallbackCommands: fallbackList,
+      reasons: reasonList,
+      notes: [...new Set(notes)],
+      relatedTests,
+      primaryTargets,
+      executionPolicy: deriveExecutionPolicy({
+        taskType: preview.taskType || taskType,
+        mode,
+        commands: commandList,
+        fallbackCommands: fallbackList,
+        reasons: reasonList,
+        context: {
+          primaryTargets,
+          sharedAbstractions: Array.isArray(preview.sharedAbstractions) ? preview.sharedAbstractions : [],
+          relatedTests,
+        },
+      }),
+    };
+  }
+
+  function deriveExecutionPolicy({
+    taskType = 'simple',
+    mode = 'minimal',
+    commands = [],
+    fallbackCommands = [],
+    reasons = [],
+    context = {},
+  }) {
+    const relatedTests = Array.isArray(context.relatedTests) ? context.relatedTests : [];
+    const sharedAbstractions = Array.isArray(context.sharedAbstractions) ? context.sharedAbstractions : [];
+    const docsOnly = mode === 'docs-only' || reasons.includes('docsOnly');
+    const risky = taskType === 'non-trivial'
+      || reasons.includes('riskySkillOrTask')
+      || reasons.includes('highRiskFallback');
+    const hasPrimaryCommands = commands.length > 0;
+    const hasTargetedPrimaryCommands = mode === 'targeted-tests-first' && hasPrimaryCommands;
+    const sharedScope = sharedAbstractions.length > 0;
+    const noRelatedTests = relatedTests.length === 0;
+    const broadOnlyPrimary = hasPrimaryCommands && !hasTargetedPrimaryCommands && noRelatedTests;
+    const requiresHumanConfirmationForBroadOrRisky = risky && broadOnlyPrimary;
+    const shouldAutoRunPrimaryCommands = hasPrimaryCommands && !docsOnly && !requiresHumanConfirmationForBroadOrRisky;
+    const shouldEscalateToFallbacks = !docsOnly && fallbackCommands.length > 0 && (risky || sharedScope);
+    const shouldAutoRunFallbacks = shouldEscalateToFallbacks && !requiresHumanConfirmationForBroadOrRisky;
+
+    let policyMode = 'recommend-only';
+    if (docsOnly) {
+      policyMode = 'docs-light';
+    } else if (hasTargetedPrimaryCommands && shouldEscalateToFallbacks) {
+      policyMode = 'auto-run-targeted-then-fallback';
+    } else if (hasTargetedPrimaryCommands) {
+      policyMode = 'auto-run-targeted';
+    } else if (requiresHumanConfirmationForBroadOrRisky) {
+      policyMode = 'confirm-then-broad';
+    } else if (shouldAutoRunPrimaryCommands) {
+      policyMode = 'auto-run-primary';
+    }
+
+    return {
+      policyMode,
+      shouldAutoRunPrimaryCommands,
+      shouldAutoRunTargetedVerification: hasTargetedPrimaryCommands && shouldAutoRunPrimaryCommands,
+      shouldEscalateToFallbacks,
+      shouldAutoRunFallbacks,
+      requiresHumanConfirmationForBroadOrRisky,
+      preferredOrder: [...commands, ...fallbackCommands],
+      reasons: [...new Set([
+        ...reasons,
+        sharedScope ? 'sharedScope' : null,
+        noRelatedTests ? 'noRelatedTests' : null,
+      ].filter(Boolean))],
+    };
+  }
+
+  function deriveNextAction({
+    activeSkills = [],
+    contextRecommendation = null,
+    verificationRecommendation = null,
+  }) {
+    const policy = verificationRecommendation?.executionPolicy || null;
+    const primaryCommands = Array.isArray(verificationRecommendation?.commands) ? verificationRecommendation.commands : [];
+    const fallbackCommands = Array.isArray(verificationRecommendation?.fallbackCommands) ? verificationRecommendation.fallbackCommands : [];
+
+    if (policy?.requiresHumanConfirmationForBroadOrRisky) {
+      return {
+        type: 'ask-user-confirmation',
+        reason: 'Ask before broad verification because index evidence could not localize a safe targeted lane.',
+        followUpCommands: [...primaryCommands, ...fallbackCommands],
+      };
+    }
+
+    if (policy?.shouldAutoRunPrimaryCommands && primaryCommands.length > 0) {
+      return {
+        type: 'run-primary-verification',
+        command: primaryCommands[0],
+        reason: 'Targeted related verification is available from indexed context.',
+        followUpCommands: fallbackCommands,
+      };
+    }
+
+    if (policy?.shouldAutoRunFallbacks && fallbackCommands.length > 0) {
+      return {
+        type: 'run-fallback-verification',
+        command: fallbackCommands[0],
+        reason: 'No primary verification command was auto-runnable, but routed fallbacks are allowed.',
+        followUpCommands: fallbackCommands.slice(1),
+      };
+    }
+
+    if (contextRecommendation?.command) {
+      return {
+        type: 'pull-indexed-context',
+        command: contextRecommendation.command,
+        reason: 'Resolve the minimal indexed file bundle before widening reads.',
+      };
+    }
+
+    if (activeSkills.length > 0) {
+      return {
+        type: 'read-skill-instructions',
+        skillPaths: activeSkills.map((item) => item.path),
+        reason: 'Open the matching project-local skill before acting.',
+      };
+    }
+
+    return {
+      type: 'inspect-structure',
+      reason: 'No strong route found; inspect repository structure and indexed files first.',
+    };
+  }
+
+  function deriveDelegationRecommendation({
+    activeSkills = [],
+    routingContext = {},
+    contextRecommendation = null,
+    verificationRecommendation = null,
+  } = {}) {
+    const skillIds = activeSkills.map((item) => item.id);
+    const lower = `${routingContext.promptText || ''}\n${routingContext.commandText || ''}`.toLowerCase();
+    const preview = contextRecommendation?.preview || {};
+    const contextBreadth = countDelegationContextBreadth(preview);
+    const hasExplicitTarget = Boolean(routingContext.targetFile);
+    const localizedIndexedLane = hasExplicitTarget && contextBreadth > 0 && contextBreadth <= 3;
+    const hasRelatedTests = Array.isArray(preview.relatedTests) && preview.relatedTests.length > 0;
+    const when = contextRecommendation?.command ? 'after-context' : 'now';
+
+    if (routingContext.taskType === 'trivial') {
+      return null;
+    }
+
+    if (
+      skillIds.includes('executing-plans')
+      || /\b(execute this plan|follow this plan|implementation plan|rollout plan|controlled batches?|review checkpoints?|batch execution|execute in batches)\b/.test(lower)
+    ) {
+      return {
+        hint: 'subagent-driven-development',
+        when,
+        reason: 'Explicit plan/batch execution is separable enough for deliberate subagent passes.',
+      };
+    }
+
+    const noisyDebugLane = skillIds.includes('debugging-toolkit') && (
+      Boolean(String(routingContext.commandText || '').trim())
+      || /\b(debug|error|crash|stack(?: trace)?|failing|flake|flaky|timeout|triage|root cause)\b/.test(lower)
+      || verificationRecommendation?.executionPolicy?.policyMode === 'confirm-then-broad'
+    );
+    if (noisyDebugLane && (!localizedIndexedLane || !hasRelatedTests || contextBreadth >= 4)) {
+      return {
+        hint: 'bug-debugger',
+        when,
+        reason: 'A noisy reproduce/trace/fix loop benefits from isolated debugging context.',
+      };
+    }
+
+    const hasImplementationSkill = skillIds.some((id) => DELEGATABLE_IMPLEMENTATION_SKILL_IDS.has(id));
+    const clearImplementationSignal = /\b(implement|build|create|add|ship|deliver|refactor|integrat(?:e|ion)|scaffold|feature)\b/.test(lower);
+    const multiLaneSignal = /\b(multiple|several|parallel|independent|across files|across modules|batch)\b/.test(lower);
+    if (
+      hasImplementationSkill
+      && clearImplementationSignal
+      && routingContext.taskType === 'non-trivial'
+      && (!localizedIndexedLane || !hasExplicitTarget || contextBreadth >= 4 || multiLaneSignal)
+    ) {
+      return {
+        hint: 'feature-implementer',
+        when,
+        reason: 'A broader implementation lane can be delegated without dragging all details through the main context.',
+      };
+    }
+
+    return null;
+  }
+
+  function buildRouteSummary({
+    activeSkills = [],
+    routingContext = {},
+    contextRecommendation = null,
+    verificationRecommendation = null,
+    nextAction = null,
+  }) {
+    const delegationRecommendation = deriveDelegationRecommendation({
+      activeSkills,
+      routingContext,
+      contextRecommendation,
+      verificationRecommendation,
+    });
+    const preview = contextRecommendation?.preview || {};
+    const primaryTargets = summarizeCompactList(Array.isArray(preview.primaryTargets) ? preview.primaryTargets : [], 2);
+    const relatedTests = summarizeCompactList(Array.isArray(preview.relatedTests) ? preview.relatedTests : [], 2);
+    const styleFiles = summarizeCompactList(Array.isArray(preview.styleFiles) ? preview.styleFiles : [], 1);
+    const primaryCommands = [...new Set(Array.isArray(verificationRecommendation?.commands) ? verificationRecommendation.commands.filter(Boolean) : [])];
+    const fallbackCommands = [...new Set(Array.isArray(verificationRecommendation?.fallbackCommands) ? verificationRecommendation.fallbackCommands.filter(Boolean) : [])];
+    const preferredOrder = [...new Set(
+      Array.isArray(verificationRecommendation?.executionPolicy?.preferredOrder)
+        ? verificationRecommendation.executionPolicy.preferredOrder.filter(Boolean)
+        : [...primaryCommands, ...fallbackCommands]
+    )];
+    const policyMode = verificationRecommendation?.executionPolicy?.policyMode || null;
+    const compactHelperLane = nextAction?.type === 'pull-indexed-context'
+      && typeof contextRecommendation?.command === 'string'
+      && contextRecommendation.command.trim();
+    const helperHint = compactHelperHint(
+      compactHelperLane
+        ? contextRecommendation?.command
+        : (
+          nextAction?.command
+            ? null
+            : verificationRecommendation?.helperCommand
+        ),
+    );
+    const nextActionCommand = compactHelperLane ? null : nextAction?.command || null;
+    const line = [
+      routingContext.taskType ? `task=${routingContext.taskType}` : null,
+      formatCompactSegment('targets', primaryTargets),
+      formatCompactSegment('tests', relatedTests),
+      formatCompactSegment('styles', styleFiles),
+      policyMode ? `policy=${policyMode}` : null,
+    ].filter(Boolean).join(' | ');
+
+    return {
+      primaryCommands,
+      fallbackCommands,
+      preferredOrder,
+      policyMode,
+      delegateHint: delegationRecommendation?.hint || null,
+      nextActionType: nextAction?.type || null,
+      nextActionCommand,
+      helperHint,
+      line: line || 'task=unknown',
+    };
+  }
+
+  function summarizeCompactList(values, limit = 2) {
+    const normalized = [...new Set((values || []).filter(Boolean))];
+    return {
+      items: normalized.slice(0, limit),
+      total: normalized.length,
+    };
+  }
+
+  function countDelegationContextBreadth(preview = {}) {
+    return [
+      ...new Set([
+        ...((Array.isArray(preview.primaryTargets) ? preview.primaryTargets : []).filter(Boolean)),
+        ...((Array.isArray(preview.analogFiles) ? preview.analogFiles : []).filter(Boolean)),
+        ...((Array.isArray(preview.sharedAbstractions) ? preview.sharedAbstractions : []).filter(Boolean)),
+        ...((Array.isArray(preview.relatedTests) ? preview.relatedTests : []).filter(Boolean)),
+      ]),
+    ].length;
+  }
+
+  function formatCompactSegment(label, summary) {
+    const items = summary?.items || [];
+    if (items.length === 0) {
+      return null;
+    }
+
+    const extraCount = Math.max((summary?.total || items.length) - items.length, 0);
+    return `${label}=${items.join(',')}${extraCount > 0 ? `,+${extraCount}` : ''}`;
+  }
+
+  function compactHelperHint(command) {
+    if (typeof command !== 'string' || !command.trim()) {
+      return null;
+    }
+
+    const normalized = command.trim().replace(/\s+/g, ' ');
+    const scriptMatch = normalized.match(/^node\s+([^\s]+)(?:\s+(.*))?$/i);
+    if (!scriptMatch) {
+      return normalized.length > 96 ? `${normalized.slice(0, 93)}...` : normalized;
+    }
+
+    const scriptName = scriptMatch[1].split('/').pop() || scriptMatch[1];
+    const rest = scriptMatch[2] || '';
+    const targetMatch = rest.match(/--target\s+("[^"]+"|'[^']+'|\S+)/);
+    const typeMatch = rest.match(/--type\s+(\S+)/);
+    const parts = [scriptName];
+
+    if (targetMatch) {
+      parts.push(`target=${stripShellQuotes(targetMatch[1])}`);
+    }
+    if (typeMatch) {
+      parts.push(`type=${typeMatch[1]}`);
+    }
+
+    return parts.join(' ');
+  }
+
+  function stripShellQuotes(value) {
+    return String(value || '').replace(/^['"]|['"]$/g, '');
+  }
+
+  function deriveCanonicalSkillPath(skillId) {
+    const normalized = String(skillId || '').trim();
+    if (!normalized) {
+      return null;
+    }
+
+    return `.claude/skills/${normalized}/SKILL.md`;
+  }
+
+  function getActiveSkillPath(skill = {}) {
+    const explicitPath = typeof skill?.path === 'string' ? skill.path.trim() : '';
+    if (explicitPath) {
+      return explicitPath;
+    }
+
+    return deriveCanonicalSkillPath(skill?.id);
+  }
+
+  function getActiveSkillPaths(activeSkills = []) {
+    return unique(activeSkills.map((item) => getActiveSkillPath(item)).filter(Boolean));
+  }
+
+  function compactActiveSkills(activeSkills = []) {
+    return activeSkills.map((item) => ({
+      id: item.id,
+    }));
+  }
+
+  function compactPreviousContext(previousContext = null) {
+    if (!previousContext || typeof previousContext !== 'object') {
+      return null;
+    }
+
+    const line = typeof previousContext.line === 'string' ? previousContext.line.trim() : '';
+    if (!line) {
+      return null;
+    }
+
+    return {
+      line,
+      selectedIds: unique(previousContext.selectedIds ?? []).slice(0, 3),
+    };
+  }
+
+  function compactRoutingContext(routingContext = {}) {
+    return {
+      lastExplicitUserPromptText: routingContext.lastExplicitUserPromptText || '',
+      taskType: routingContext.taskType || null,
+    };
+  }
+
+  function compactHelpers({
+    verificationRecommendation = null,
+    routeSummary = null,
+  } = {}) {
+    const verificationHelperHint = routeSummary?.helperHint
+      ? null
+      : compactHelperHint(verificationRecommendation?.helperCommand || null);
+
+    if (!verificationHelperHint) {
+      return null;
+    }
+
+    return {
+      verificationHelperHint,
+    };
+  }
+
+  function compactRouteSummary(routeSummary = null) {
+    if (!routeSummary) {
+      return null;
+    }
+
+    return {
+      line: routeSummary.line || 'task=unknown',
+      primaryCommands: [...new Set((routeSummary.primaryCommands || []).filter(Boolean))].slice(0, 2),
+      fallbackCommands: [...new Set((routeSummary.fallbackCommands || []).filter(Boolean))].slice(0, 3),
+      preferredOrder: [...new Set((routeSummary.preferredOrder || []).filter(Boolean))].slice(0, 5),
+      policyMode: routeSummary.policyMode || null,
+      delegateHint: routeSummary.delegateHint || null,
+      nextActionType: routeSummary.nextActionType || null,
+      nextActionCommand: routeSummary.nextActionCommand || null,
+      helperHint: routeSummary.helperHint || null,
+    };
+  }
+
+  function shouldIncludePreviousContext({ routingContext = {}, useIndexedContext = true } = {}) {
+    const taskType = String(routingContext?.taskType || '').trim();
+    const hasExplicitTarget = Boolean(String(routingContext?.targetFile || '').trim());
+
+    if (!hasExplicitTarget) {
+      return true;
+    }
+
+    if (!useIndexedContext) {
+      return true;
+    }
+
+    return taskType !== 'simple' && taskType !== 'trivial';
+  }
+
+  function hasRouteSummaryField(routeSummary, field) {
+    return Boolean(
+      routeSummary
+      && typeof routeSummary === 'object'
+      && Object.prototype.hasOwnProperty.call(routeSummary, field),
+    );
+  }
+
+  function extractRouteLineSegment(line, label) {
+    if (typeof line !== 'string' || !line.trim()) {
+      return null;
+    }
+
+    const match = line.match(new RegExp(`(?:^|\\|\\s*)${label}=([^|]+)`, 'i'));
+    return match ? `${label}=${String(match[1] || '').trim()}` : null;
+  }
+
+  function formatDisplayRouteSummary(routeSummary = null, routingContext = {}) {
+    const line = String(routeSummary?.line ?? '').trim();
+    const taskSegment = routingContext?.taskType
+      ? `task=${routingContext.taskType}`
+      : extractRouteLineSegment(line, 'task');
+    const policySegment = routeSummary?.policyMode
+      ? `policy=${routeSummary.policyMode}`
+      : (
+        hasRouteSummaryField(routeSummary, 'policyMode')
+          ? null
+          : extractRouteLineSegment(line, 'policy')
+      );
+
+    const segments = [
+      taskSegment,
+      extractRouteLineSegment(line, 'targets'),
+      extractRouteLineSegment(line, 'tests'),
+      extractRouteLineSegment(line, 'styles'),
+      policySegment,
+    ].filter(Boolean);
+
+    return segments.join(' | ') || 'task=unknown';
+  }
+
+  function formatDisplayNextAction(routeSummary = null) {
+    if (!routeSummary || typeof routeSummary !== 'object') {
+      return '';
+    }
+
+    const nextActionCommand = String(routeSummary.nextActionCommand ?? '').trim();
+    if (nextActionCommand) {
+      return nextActionCommand;
+    }
+
+    const nextActionType = String(routeSummary.nextActionType ?? '').trim();
+    if (!nextActionType || nextActionType === 'read-skill-instructions') {
+      return '';
+    }
+
+    return nextActionType;
+  }
+
+  const DELEGATABLE_IMPLEMENTATION_SKILL_IDS = new Set([
+    'delivery',
+    'frontend',
+    'frontend-vue',
+    'backend-api',
+    'postgres',
+    'sql-optimization-patterns',
+  ]);
+
+  function compactRouteCacheState(sharedState = {}) {
+    if (!sharedState || typeof sharedState !== 'object') {
+      return sharedState;
+    }
+
+    const compactState = { ...sharedState };
+    delete compactState.source;
+    delete compactState.ts;
+    return compactState;
+  }
+
+  const rawInput = process.env.INPUT || '';
+  const projectRoot = process.env.PROJECT_ROOT || process.cwd();
+  const statePath = process.env.STATE_FILE || path.join(projectRoot, '.claude', 'ukit', 'skill-router-state.json');
+  const routeCachePath = path.join(projectRoot, '.claude', 'ukit', 'route-cache.json');
+  const cacheUtilsPath = path.join(projectRoot, '.claude', 'ukit', 'index', 'cache-utils.mjs');
+  const previous = readJson(statePath, {});
+  const runtimeConfig = loadRuntimeConfig(projectRoot);
+
+  let payload = {};
+  try {
+    payload = JSON.parse(rawInput || '{}');
+  } catch {
+    payload = {};
+  }
+
+  const promptText = extractPrompt(payload);
+  const commandText = payload.tool_input?.command || payload.command || '';
+  const filePath = normalizeRelativeFile(projectRoot, payload.tool_input?.file_path || payload.file_path || '');
+  const { buildRouteSignalText } = await loadLanguageTools(projectRoot);
+  const routeSignals = {
+    promptRawText: String(promptText || '').toLowerCase(),
+    promptNormalizedText: buildRouteSignalText(promptText),
+    commandRawText: String(commandText || '').toLowerCase(),
+    commandNormalizedText: buildRouteSignalText(commandText),
+    fileText: String(filePath || '').toLowerCase(),
+  };
+
+  const catalog = await loadRouteCatalog(projectRoot);
+
+  const active = catalog
+    .map((entry) => scoreSkillRouteEntry(entry, routeSignals))
+    .filter((entry) => entry.score > 0 && existsSkill(projectRoot, entry.path));
+
+  const now = Date.now();
+  const debounceMs = 10 * 60 * 1000;
+  const previousTs = Number(previous?.ts || 0);
+
+  if (active.length === 0) {
+    const lastExplicitUserPromptText = promptText.trim()
+      || previous?.routingContext?.lastExplicitUserPromptText
+      || '';
+    const routingContext = {
+      promptText,
+      lastExplicitUserPromptText,
+      commandText,
+      targetFile: filePath,
+      contextIntent: '',
+      taskType: '',
+    };
+    const previousContext = buildPreviousContextSnapshot({
+      projectRoot,
+      routingContext,
+      config: runtimeConfig,
+    });
+    const fingerprint = buildRouteStateFingerprint({
+      activeSkills: [],
+      routingContext,
+      previousContext,
+      routeSummary: null,
+    });
+
+    if (
+      previous?.fingerprint === fingerprint
+      && !previous?.routeSummary
+      && Array.isArray(previous?.activeSkills)
+      && previous.activeSkills.length === 0
+      && now - previousTs < debounceMs
+    ) {
+      process.exit(0);
+    }
+
+    ensureDir(statePath);
+    fs.writeFileSync(statePath, JSON.stringify({
+      fingerprint,
+      ts: now,
+      source: 'skill-router',
+      activeSkills: [],
+      routingContext: compactRoutingContext(routingContext),
+      ...(previousContext ? { previousContext: compactPreviousContext(previousContext) } : {}),
+    }));
+    process.exit(0);
+  }
+
+  active.sort((a, b) => b.score - a.score || a.order - b.order);
+  const selected = active.slice(0, 2);
+  const selectedIds = selected.map((entry) => entry.id);
+  const contextIntent = deriveContextIntent({
+    promptText,
+    commandText,
+    targetFile: filePath,
+    selectedIds,
+  });
+  const taskType = inferTaskType({
+    promptText,
+    commandText,
+    selectedIds,
+    buildRouteSignalText,
+  });
+  const lastExplicitUserPromptText = promptText.trim()
+    || previous?.routingContext?.lastExplicitUserPromptText
+    || '';
+  const routingContext = {
+    promptText,
+    lastExplicitUserPromptText,
+    commandText,
+    targetFile: filePath,
+    contextIntent,
+    taskType,
+  };
+  const useIndexedContext = shouldUseIndexedContext({
+    activeSkills: selected,
+    targetFile: filePath,
+  });
+  const previousContext = shouldIncludePreviousContext({
+    routingContext,
+    useIndexedContext,
+  })
+    ? buildPreviousContextSnapshot({
+        projectRoot,
+        routingContext,
+        config: runtimeConfig,
+      })
+    : null;
+  const indexGeneratedAtMs = useIndexedContext
+    ? readIndexGeneratedAtMs(projectRoot)
+    : null;
+  const projectVerification = useIndexedContext
+    ? readProjectVerificationFingerprint(projectRoot)
+    : null;
+  const requestKey = buildRouteRequestKey({
+    commandNamespace: '.claude',
+    indexGeneratedAtMs,
+    projectFingerprint: projectVerification?.fingerprint || null,
+    activeSkills: selected,
+    routingContext,
+    previousContextFingerprint: previousContext?.fingerprint || null,
+  });
+  let cacheUtils = null;
+  if (fs.existsSync(cacheUtilsPath)) {
+    try {
+      cacheUtils = await import(pathToFileURL(cacheUtilsPath).href);
+    } catch {
+      cacheUtils = null;
+    }
+  }
+
+  if (
+    previous?.requestKey === requestKey
+    && previous?.routeSummary
+    && now - previousTs < debounceMs
+  ) {
+    process.exit(0);
+  }
+
+  const cachedRouteState = typeof cacheUtils?.readRecentCacheEntry === 'function'
+    ? await cacheUtils.readRecentCacheEntry(routeCachePath, requestKey, {
+        maxEntries: cacheUtils.DEFAULT_RECENT_CACHE_MAX_ENTRIES,
+        touch: true,
+      })
+    : null;
+  if (
+    cachedRouteState?.requestKey === requestKey
+    && cachedRouteState?.routeSummary
+    && Array.isArray(cachedRouteState?.activeSkills)
+  ) {
+    const reusedState = {
+      ...cachedRouteState,
+      source: 'skill-router',
+      ts: now,
+      requestKey,
+    };
+
+    if (previous?.fingerprint === reusedState.fingerprint && now - previousTs < debounceMs) {
+      process.exit(0);
+    }
+
+    ensureDir(statePath);
+    fs.writeFileSync(statePath, JSON.stringify(reusedState));
+
+    process.stdout.write(`[ukit-skill-router] Read skills: ${getActiveSkillPaths(reusedState.activeSkills || []).join(', ')}\n`);
+    process.stdout.write(`[ukit-skill-router] Route: ${formatDisplayRouteSummary(reusedState.routeSummary, reusedState.routingContext)}\n`);
+    const reusedNextDisplay = formatDisplayNextAction(reusedState.routeSummary);
+    if (reusedNextDisplay) {
+      process.stdout.write(`[ukit-skill-router] Next: ${reusedNextDisplay}\n`);
+    }
+    if (reusedState.routeSummary?.delegateHint) {
+      process.stdout.write(`[ukit-skill-router] Delegate: ${reusedState.routeSummary.delegateHint}\n`);
+    }
+    if (reusedState.routeSummary?.helperHint && !reusedState.routeSummary?.nextActionCommand) {
+      process.stdout.write(`[ukit-skill-router] Helper: ${reusedState.routeSummary.helperHint}\n`);
+    }
+    process.exit(0);
+  }
+
+  const contextRecommendation = useIndexedContext
+    ? await buildContextRecommendation({
+        projectRoot,
+        intent: contextIntent,
+        targetFile: filePath,
+        taskType,
+      })
+    : null;
+  const verificationRecommendation = useIndexedContext
+    ? buildVerificationRecommendation({
+        projectRoot,
+        selectedIds,
+        contextRecommendation,
+        contextIntent,
+        targetFile: filePath,
+        taskType,
+        pkg: projectVerification?.pkg,
+      })
+    : null;
+  const nextAction = deriveNextAction({
+    activeSkills: selected,
+    contextRecommendation,
+    verificationRecommendation,
+  });
+  const routeSummary = buildRouteSummary({
+    activeSkills: selected,
+    routingContext,
+    contextRecommendation,
+    verificationRecommendation,
+    nextAction,
+  });
+
+  const fingerprint = buildRouteStateFingerprint({
+    activeSkills: selected,
+    routingContext,
+    previousContext,
+    routeSummary,
+  });
+
+  if (previous?.fingerprint === fingerprint && now - previousTs < debounceMs) {
+    process.exit(0);
+  }
+
+  ensureDir(statePath);
+  const helpers = compactHelpers({
+    verificationRecommendation,
+    routeSummary,
+  });
+  const sharedState = {
+    requestKey,
+    fingerprint,
+    ts: now,
+    source: 'skill-router',
+    activeSkills: compactActiveSkills(selected),
+    routingContext: compactRoutingContext(routingContext),
+    ...(previousContext ? { previousContext: compactPreviousContext(previousContext) } : {}),
+    ...(helpers ? { helpers } : {}),
+    routeSummary: compactRouteSummary(routeSummary),
+  };
+  fs.writeFileSync(statePath, JSON.stringify(sharedState));
+  if (typeof cacheUtils?.writeRecentCacheEntry === 'function') {
+    await cacheUtils.writeRecentCacheEntry(routeCachePath, compactRouteCacheState(sharedState), {
+      maxEntries: cacheUtils.DEFAULT_RECENT_CACHE_MAX_ENTRIES,
+    });
+  }
+
+  process.stdout.write(`[ukit-skill-router] Read skills: ${getActiveSkillPaths(selected).join(', ')}\n`);
+  process.stdout.write(`[ukit-skill-router] Route: ${formatDisplayRouteSummary(routeSummary, routingContext)}\n`);
+  const nextDisplay = formatDisplayNextAction(routeSummary);
+  if (nextDisplay) {
+    process.stdout.write(`[ukit-skill-router] Next: ${nextDisplay}\n`);
+  }
+  if (routeSummary.delegateHint) {
+    process.stdout.write(`[ukit-skill-router] Delegate: ${routeSummary.delegateHint}\n`);
+  }
+  if (routeSummary.helperHint && !routeSummary.nextActionCommand) {
+    process.stdout.write(`[ukit-skill-router] Helper: ${routeSummary.helperHint}\n`);
+  }
+})().catch(() => {
+  process.exit(0);
+});
+NODE
+
+if [ -f "$THRESHOLD_SCRIPT" ]; then
+  printf '%s' "$INPUT" | CLAUDE_PROJECT_DIR="$PROJECT_ROOT" node "$THRESHOLD_SCRIPT" prompt >/dev/null 2>&1 || true
+fi
+
+exit 0