@ngockhoale/ukit 1.1.6

package/templates/.claude/ukit/index/route-task.mjs

@@ -0,0 +1,1994 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import * as indexCore from './lib/index-core.mjs';
+import {
+  DEFAULT_RECENT_CACHE_MAX_ENTRIES,
+  readRecentCacheEntry,
+  writeRecentCacheEntry,
+} from './cache-utils.mjs';
+import { ROUTE_CATALOG } from './route-catalog.mjs';
+
+const {
+  resolveContext,
+  buildCodeIndex,
+  DEFAULT_INDEX_CACHE_MAX_AGE_MS,
+  getIndexArtifactGeneratedAt,
+} = indexCore;
+
+const MAX_ACTIVE_ROUTE_SKILLS = 2;
+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',
+]);
+const INLINE_SUMMARY_MAX_SEGMENTS = 5;
+const INLINE_SUMMARY_SIGNAL_PATTERNS = [
+  /\b(error|fail(?:ed)?|warning|assertionerror|exception|fatal|deprecated|unmet peer|ignored build scripts)\b/i,
+  /(^|\s)(src|app|lib|docs|ukit|\.claude|\.codex|tests?)\//i,
+  /^\s*FAIL\b/i,
+  /^\s*stderr\s*\|/i,
+  /^\s*stdout\s*\|/i,
+];
+const INLINE_SUMMARY_TAIL_PATTERNS = [
+  /\b(Test Files|Tests|Packages:|Done in|short test summary info)\b/i,
+  /\b(Duration|Start at)\b/i,
+];
+
+const buildNormalizedRouteSignalText = typeof indexCore.buildRouteSignalText === 'function'
+  ? indexCore.buildRouteSignalText
+  : (...values) => values
+      .map((value) => String(value || '').trim())
+      .filter(Boolean)
+      .join('\n')
+      .toLowerCase();
+
+async function main() {
+  const args = process.argv.slice(2);
+  const rootDir = getRootDir(args);
+  const sharedStatePath = path.join(rootDir, '.claude', 'ukit', 'skill-router-state.json');
+  const routeCachePath = path.join(rootDir, '.claude', 'ukit', 'route-cache.json');
+  const previousState = await readJson(sharedStatePath, {});
+  const targetFile = readFlagValue(args, '--target');
+  const taskType = readFlagValue(args, '--type');
+  const commandText = readFlagValue(args, '--tool-command') ?? '';
+  const lastPrompt = readFlagValue(args, '--last-prompt')
+    ?? previousState?.routingContext?.lastExplicitUserPromptText
+    ?? '';
+  const adapter = readFlagValue(args, '--adapter') ?? inferAdapterFromInvocation(process.argv[1] || '');
+  const commandNamespace = adapter === 'codex'
+    ? '.codex'
+    : (adapter === 'antigravity' ? '.antigravity' : '.claude');
+  const promptText = args
+    .filter((arg, index) => !isFlagOrValue(args, index))
+    .join(' ')
+    .trim();
+
+  if (!promptText && !commandText && !targetFile) {
+    console.error('Usage: node .codex/ukit/index/route-task.mjs "<prompt>" [--tool-command <cmd>] [--target <file>] [--type trivial|simple|non-trivial] [--adapter codex|claude|antigravity|opencode]');
+    process.exitCode = 1;
+    return;
+  }
+
+  const preparedRoute = await prepareTaskRoute({
+    rootDir,
+    promptText,
+    commandText,
+    targetFile,
+    taskType,
+    adapter,
+    lastExplicitUserPromptText: lastPrompt,
+    commandNamespace,
+  });
+  const useIndexedContext = shouldUseIndexedContext({
+    activeSkills: preparedRoute.activeSkills,
+    targetFile: preparedRoute.routingContext?.targetFile ?? null,
+  });
+  const recentOutputSnapshot = shouldIncludeRecentOutput({
+    activeSkills: preparedRoute.activeSkills,
+    routingContext: preparedRoute?.routingContext ?? {},
+    useIndexedContext,
+  })
+    ? await buildRecentOutputSnapshot({
+        rootDir,
+      })
+    : null;
+  const previousContextSnapshot = shouldIncludePreviousContext({
+    routingContext: preparedRoute?.routingContext ?? {},
+    useIndexedContext,
+  })
+    ? await buildPreviousContextSnapshot({
+        rootDir,
+        routingContext: preparedRoute?.routingContext ?? {},
+      })
+    : null;
+  const indexGeneratedAtMs = useIndexedContext
+    ? await ensureFreshIndex({
+        rootDir,
+        logPrefix: 'route',
+      })
+    : null;
+  const projectVerification = useIndexedContext
+    ? await readProjectVerificationFingerprint(rootDir)
+    : null;
+  const requestKey = buildRouteRequestKey({
+    commandNamespace,
+    indexGeneratedAtMs,
+    projectFingerprint: projectVerification?.fingerprint ?? null,
+    activeSkills: preparedRoute.activeSkills,
+    routingContext: preparedRoute.routingContext,
+    previousContextSnapshot,
+    recentOutputSnapshot,
+  });
+  const reusableState = reuseSharedRouteState({
+    previousState,
+    requestKey,
+  });
+  if (reusableState) {
+    printRouteState(reusableState);
+    return;
+  }
+
+  const cachedRouteState = reuseSharedRouteState({
+    previousState: await readRecentCacheEntry(routeCachePath, requestKey, {
+      maxEntries: DEFAULT_RECENT_CACHE_MAX_ENTRIES,
+      touch: true,
+    }),
+    requestKey,
+  });
+  if (cachedRouteState) {
+    const sharedState = {
+      ...cachedRouteState,
+      source: 'task-route',
+      ts: Date.now(),
+      requestKey,
+    };
+    await writeJson(sharedStatePath, sharedState);
+    printRouteState(sharedState);
+    return;
+  }
+
+  const helperCacheSnapshot = await readHelperCacheSnapshot({
+    rootDir,
+    indexGeneratedAtMs,
+    projectFingerprint: projectVerification?.fingerprint ?? '',
+    routingContext: preparedRoute.routingContext,
+    useIndexedContext,
+  });
+  const route = await finalizeTaskRoute({
+    rootDir,
+    commandNamespace,
+    preparedRoute,
+    projectVerification,
+    cachedContextResult: helperCacheSnapshot.contextResult,
+    cachedVerificationPlan: helperCacheSnapshot.verificationPlan,
+    useIndexedContext,
+    previousContextSnapshot,
+    recentOutputSnapshot,
+  });
+  await seedHelperCaches({
+    rootDir,
+    indexGeneratedAtMs,
+    projectFingerprint: projectVerification?.fingerprint ?? '',
+    helperCacheSnapshot,
+    route,
+  });
+
+  const sharedState = createSharedRouteState({
+    route,
+    source: 'task-route',
+    requestKey,
+    indexGeneratedAtMs,
+  });
+  await writeJson(sharedStatePath, sharedState);
+  await writeRecentCacheEntry(routeCachePath, compactRouteCacheState(sharedState), {
+    maxEntries: DEFAULT_RECENT_CACHE_MAX_ENTRIES,
+  });
+
+  printRouteState(sharedState);
+}
+
+async function ensureFreshIndex({ rootDir, logPrefix }) {
+  const lastRefreshMs = await getIndexArtifactGeneratedAt({ rootDir });
+  const stale = lastRefreshMs === null
+    ? true
+    : typeof indexCore.isIndexStale === 'function'
+      ? await indexCore.isIndexStale({
+          rootDir,
+          maxAgeMs: DEFAULT_INDEX_CACHE_MAX_AGE_MS,
+          now: Date.now(),
+          generatedAtMs: lastRefreshMs,
+        })
+      : (Date.now() - lastRefreshMs) > DEFAULT_INDEX_CACHE_MAX_AGE_MS;
+
+  if (!stale) {
+    return lastRefreshMs;
+  }
+
+  const summary = await buildCodeIndex({ rootDir });
+  if (lastRefreshMs !== null) {
+    console.log(`[ukit:${logPrefix}] stale index refreshed (last=${new Date(lastRefreshMs).toISOString()})`);
+  } else {
+    console.log(`[ukit:${logPrefix}] stale index refreshed (no previous cache timestamp)`);
+  }
+  return Number.isFinite(summary?.generatedAtMs)
+    ? summary.generatedAtMs
+    : getIndexArtifactGeneratedAt({ rootDir });
+}
+
+async function prepareTaskRoute({
+  rootDir = process.cwd(),
+  promptText = '',
+  commandText = '',
+  targetFile = null,
+  taskType = null,
+  adapter = 'claude',
+  lastExplicitUserPromptText = '',
+} = {}) {
+  const absoluteRoot = path.resolve(rootDir);
+  const normalizedPrompt = String(promptText || '').trim();
+  const normalizedCommand = String(commandText || '').trim();
+  const normalizedTarget = normalizeRelativeFile(absoluteRoot, targetFile);
+  const activeSkills = await selectActiveSkills({
+    rootDir: absoluteRoot,
+    promptText: normalizedPrompt,
+    commandText: normalizedCommand,
+    targetFile: normalizedTarget,
+  });
+  const selectedIds = activeSkills.map((entry) => entry.id);
+  const contextIntent = deriveContextIntent({
+    promptText: normalizedPrompt,
+    commandText: normalizedCommand,
+    targetFile: normalizedTarget,
+    selectedIds,
+  });
+  const inferredTaskType = taskType ?? inferTaskType({
+    promptText: normalizedPrompt,
+    commandText: normalizedCommand,
+    selectedIds,
+  });
+  const preservedPrompt = normalizedPrompt || String(lastExplicitUserPromptText || '').trim();
+
+  return {
+    rootDir: absoluteRoot,
+    activeSkills,
+    routingContext: {
+      adapter: String(adapter || 'claude').trim() || 'claude',
+      promptText: normalizedPrompt,
+      lastExplicitUserPromptText: preservedPrompt,
+      commandText: normalizedCommand,
+      targetFile: normalizedTarget,
+      contextIntent,
+      taskType: inferredTaskType,
+    },
+  };
+}
+
+async function finalizeTaskRoute({
+  rootDir = process.cwd(),
+  commandNamespace = '.claude',
+  preparedRoute,
+  projectVerification = null,
+  cachedContextResult = null,
+  cachedVerificationPlan = null,
+  useIndexedContext = true,
+  previousContextSnapshot = null,
+  recentOutputSnapshot = null,
+} = {}) {
+  const absoluteRoot = path.resolve(rootDir);
+  const activeSkills = preparedRoute?.activeSkills ?? [];
+  const routingContext = preparedRoute?.routingContext ?? {};
+  const selectedIds = activeSkills.map((entry) => entry.id);
+  const {
+    contextIntent,
+    targetFile: normalizedTarget,
+    taskType: inferredTaskType,
+  } = routingContext;
+  const contextResult = useIndexedContext
+    ? cachedContextResult ?? (
+        contextIntent || normalizedTarget
+          ? await resolveContext({
+              rootDir: absoluteRoot,
+              intent: contextIntent,
+              targetFile: normalizedTarget,
+              taskType: inferredTaskType,
+            })
+          : null
+      )
+    : null;
+  const enrichedContextResult = expandRouteContext(contextResult);
+  const verificationSnapshot = useIndexedContext
+    ? projectVerification ?? await readProjectVerificationFingerprint(absoluteRoot)
+    : null;
+  const verificationPlan = useIndexedContext
+    ? cachedVerificationPlan ?? await deriveVerificationPlan({
+        rootDir: absoluteRoot,
+        intent: contextIntent,
+        targetFile: normalizedTarget,
+        taskType: inferredTaskType,
+        contextResult: enrichedContextResult,
+        skillIds: selectedIds,
+        fingerprintEntries: verificationSnapshot.entries,
+        pkg: verificationSnapshot.pkg,
+      })
+    : null;
+  const contextCommand = buildHelperCommand({ commandNamespace, scriptName: 'resolve-context.mjs', intent: contextIntent, targetFile: normalizedTarget, taskType: inferredTaskType });
+  const verifyCommand = buildHelperCommand({ commandNamespace, scriptName: 'verify-context.mjs', intent: contextIntent, targetFile: normalizedTarget, taskType: inferredTaskType });
+  const contextRecommendation = useIndexedContext
+    ? {
+        command: contextCommand,
+        preview: enrichedContextResult ? summarizeContext(enrichedContextResult) : null,
+      }
+    : null;
+  const verificationRecommendation = verificationPlan
+    ? {
+        ...verificationPlan,
+        helperCommand: verifyCommand,
+      }
+    : null;
+  const nextAction = deriveNextAction({
+    activeSkills,
+    contextRecommendation,
+    verificationRecommendation,
+  });
+  const routeSummary = buildRouteSummary({
+    activeSkills,
+    routingContext,
+    contextRecommendation,
+    verificationRecommendation,
+    nextAction,
+  });
+
+  return {
+    activeSkills,
+    routingContext,
+    previousContext: previousContextSnapshot,
+    recentOutput: recentOutputSnapshot,
+    contextRecommendation,
+    verificationRecommendation,
+    resolvedContextResult: contextResult,
+    resolvedVerificationPlan: verificationPlan,
+    nextAction,
+    routeSummary,
+  };
+}
+
+function printRouteState(state) {
+  const compactSummary = formatDisplayRouteSummary(state.routeSummary, state.routingContext);
+  const nextDisplay = formatDisplayNextAction(state.routeSummary);
+  const previousContextDisplay = formatDisplayPreviousContext(state.previousContext);
+  const recentOutputDisplay = formatDisplayRecentOutput(state.recentOutput);
+  const helperDisplay = formatDisplayHelperHint(state.routeSummary, compactSummary);
+  console.log('[ukit:route]');
+  console.log(`skills: ${(state.activeSkills ?? []).map((item) => item.id).join(', ') || 'none'}`);
+  if (previousContextDisplay) {
+    console.log(`previous-context: ${previousContextDisplay}`);
+  }
+  if (recentOutputDisplay) {
+    console.log(`recent-output: ${recentOutputDisplay}`);
+  }
+  console.log(`summary: ${compactSummary}`);
+  if (nextDisplay) {
+    console.log(`next: ${nextDisplay}`);
+  }
+  if (state.routeSummary?.delegateHint) {
+    console.log(`delegate: ${state.routeSummary.delegateHint}`);
+  }
+  if (helperDisplay) {
+    console.log(`helper: ${helperDisplay}`);
+  }
+}
+
+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 extractRouteLineValue(line, label) {
+  const segment = extractRouteLineSegment(line, label);
+  return segment ? String(segment.slice(label.length + 1) || '').trim() : '';
+}
+
+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(' | ') || 'none';
+}
+
+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;
+}
+
+function formatDisplayPreviousContext(previousContext = null) {
+  const line = typeof previousContext?.line === 'string' ? previousContext.line.trim() : '';
+  if (!line) {
+    return '';
+  }
+
+  return line
+    .split(/\s+\|\s+/)
+    .map((segment) => String(segment || '').trim())
+    .filter(Boolean)
+    .map((segment) => segment
+      .replace(/^\[(project|session|user)\]\s*/i, (_, label) => `${String(label || '').toLowerCase()}=`)
+      .replace(/\s+—\s+/g, '; ')
+      .replace(/\b(decisions|rules|outcome|actions|next):\s*/gi, '$1=')
+      .replace(/\(\+(\d+)\s+more\)/gi, '+$1 more'))
+    .join(' | ');
+}
+
+function formatDisplayRecentOutput(recentOutput = null) {
+  const line = typeof recentOutput?.line === 'string' ? recentOutput.line.trim() : '';
+  if (!line) {
+    return '';
+  }
+
+  return line
+    .replace(/^-\s*/, '')
+    .replace(/^Recent command:\s*/i, 'cmd=')
+    .replace(/\s+\|\s+-\s+/g, ' | ')
+    .trim();
+}
+
+function formatDisplayHelperHint(routeSummary = null, compactSummary = '') {
+  if (!routeSummary || typeof routeSummary !== 'object') {
+    return '';
+  }
+
+  if (String(routeSummary.nextActionCommand ?? '').trim()) {
+    return '';
+  }
+
+  let helperHint = String(routeSummary.helperHint ?? '').trim().replace(/\s+/g, ' ');
+  if (!helperHint) {
+    return '';
+  }
+
+  const helperTargetMatch = helperHint.match(/(?:^|\s)target=([^\s]+)/);
+  const summaryTargets = extractRouteLineValue(compactSummary, 'targets');
+  if (helperTargetMatch && summaryTargets && summaryTargets === String(helperTargetMatch[1] || '').trim()) {
+    helperHint = helperHint.replace(` target=${helperTargetMatch[1]}`, '');
+  }
+
+  return helperHint.trim();
+}
+
+async function seedHelperCaches({
+  rootDir = process.cwd(),
+  indexGeneratedAtMs = null,
+  projectFingerprint = '',
+  helperCacheSnapshot = null,
+  route = null,
+} = {}) {
+  const absoluteRoot = path.resolve(rootDir);
+  const routingContext = route?.routingContext ?? {};
+  const normalizedIntent = String(routingContext.contextIntent ?? '').trim();
+  const normalizedTargetFile = String(routingContext.targetFile ?? '').trim();
+  const normalizedTaskType = String(routingContext.taskType ?? '').trim();
+
+  if (!normalizedIntent && !normalizedTargetFile) {
+    return;
+  }
+
+  const updatedAt = Date.now();
+  const resolveContextResult = route?.resolvedContextResult ?? null;
+  const verificationPlan = route?.resolvedVerificationPlan ?? null;
+  const contextCacheHit = Boolean(helperCacheSnapshot?.contextCacheHit);
+  const verificationCacheHit = Boolean(helperCacheSnapshot?.verificationCacheHit);
+
+  if (resolveContextResult && !contextCacheHit) {
+    const resolveContextCachePath = path.join(absoluteRoot, '.claude', 'ukit', 'resolve-context-cache.json');
+    await writeRecentCacheEntry(resolveContextCachePath, {
+      requestKey: buildResolveContextRequestKey({
+        indexGeneratedAtMs,
+        intent: normalizedIntent,
+        targetFile: normalizedTargetFile,
+        taskType: normalizedTaskType,
+      }),
+      updatedAt,
+      result: resolveContextResult,
+    }, {
+      maxEntries: DEFAULT_RECENT_CACHE_MAX_ENTRIES,
+    });
+  }
+
+  if (verificationPlan && !verificationCacheHit) {
+    const verifyContextCachePath = path.join(absoluteRoot, '.claude', 'ukit', 'verify-context-cache.json');
+    await writeRecentCacheEntry(verifyContextCachePath, {
+      requestKey: buildVerifyContextRequestKey({
+        indexGeneratedAtMs,
+        projectFingerprint,
+        intent: normalizedIntent,
+        targetFile: normalizedTargetFile,
+        taskType: normalizedTaskType,
+      }),
+      updatedAt,
+      result: verificationPlan,
+    }, {
+      maxEntries: DEFAULT_RECENT_CACHE_MAX_ENTRIES,
+    });
+  }
+}
+
+async function readHelperCacheSnapshot({
+  rootDir = process.cwd(),
+  indexGeneratedAtMs = null,
+  projectFingerprint = '',
+  routingContext = {},
+  useIndexedContext = true,
+} = {}) {
+  if (!useIndexedContext) {
+    return {
+      contextCacheHit: false,
+      verificationCacheHit: false,
+      contextResult: null,
+      verificationPlan: null,
+    };
+  }
+
+  const absoluteRoot = path.resolve(rootDir);
+  const normalizedIntent = String(routingContext.contextIntent ?? '').trim();
+  const normalizedTargetFile = String(routingContext.targetFile ?? '').trim();
+  const normalizedTaskType = String(routingContext.taskType ?? '').trim();
+
+  if (!normalizedIntent && !normalizedTargetFile) {
+    return {
+      contextCacheHit: false,
+      verificationCacheHit: false,
+      contextResult: null,
+      verificationPlan: null,
+    };
+  }
+
+  const resolveContextCachePath = path.join(absoluteRoot, '.claude', 'ukit', 'resolve-context-cache.json');
+  const verifyContextCachePath = path.join(absoluteRoot, '.claude', 'ukit', 'verify-context-cache.json');
+  const [cachedContextEntry, cachedVerificationEntry] = await Promise.all([
+    readRecentCacheEntry(
+      resolveContextCachePath,
+      buildResolveContextRequestKey({
+        indexGeneratedAtMs,
+        intent: normalizedIntent,
+        targetFile: normalizedTargetFile,
+        taskType: normalizedTaskType,
+      }),
+      {
+        maxEntries: DEFAULT_RECENT_CACHE_MAX_ENTRIES,
+      },
+    ),
+    readRecentCacheEntry(
+      verifyContextCachePath,
+      buildVerifyContextRequestKey({
+        indexGeneratedAtMs,
+        projectFingerprint,
+        intent: normalizedIntent,
+        targetFile: normalizedTargetFile,
+        taskType: normalizedTaskType,
+      }),
+      {
+        maxEntries: DEFAULT_RECENT_CACHE_MAX_ENTRIES,
+      },
+    ),
+  ]);
+
+  return {
+    contextCacheHit: Boolean(cachedContextEntry?.result),
+    verificationCacheHit: Boolean(cachedVerificationEntry?.result),
+    contextResult: cachedContextEntry?.result ?? null,
+    verificationPlan: cachedVerificationEntry?.result ?? null,
+  };
+}
+
+async function selectActiveSkills({ rootDir, promptText, commandText, targetFile }) {
+  const routeSignals = {
+    promptRawText: String(promptText || '').toLowerCase(),
+    promptNormalizedText: buildNormalizedRouteSignalText(promptText),
+    commandRawText: String(commandText || '').toLowerCase(),
+    commandNormalizedText: buildNormalizedRouteSignalText(commandText),
+    fileText: String(targetFile || '').toLowerCase(),
+  };
+  const scoredEntries = ROUTE_CATALOG
+    .map((entry) => scoreSkillRouteEntry(entry, routeSignals))
+    .filter((entry) => entry.score > 0)
+    .sort((a, b) => b.score - a.score || a.order - b.order);
+  const active = [];
+
+  for (const entry of scoredEntries) {
+    if (await pathExists(path.join(rootDir, entry.path))) {
+      active.push(entry);
+      if (active.length >= MAX_ACTIVE_ROUTE_SKILLS) {
+        break;
+      }
+    }
+  }
+
+  return active.map(({ order, ...rest }) => rest);
+}
+
+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',
+    reasons: [...new Set(reasons)],
+    score,
+    order: entry.order,
+  };
+}
+
+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);
+}
+
+async function deriveVerificationPlan({
+  rootDir = process.cwd(),
+  intent = '',
+  targetFile = null,
+  taskType = null,
+  contextResult = null,
+  skillIds = [],
+  fingerprintEntries = [],
+  pkg = null,
+} = {}) {
+  const absoluteRoot = path.resolve(rootDir);
+  const context = contextResult ?? await resolveContext({
+    rootDir: absoluteRoot,
+    intent,
+    targetFile,
+    taskType,
+  });
+
+  const resolvedPkg = pkg ?? await readPackageJson(absoluteRoot);
+  const scripts = resolvedPkg?.scripts && typeof resolvedPkg.scripts === 'object' ? resolvedPkg.scripts : {};
+  const packageManager = detectPackageManager({ fingerprintEntries, pkg: resolvedPkg });
+  const primaryTargets = unique([
+    ...(context?.primaryTargets ?? []),
+    ...(targetFile ? [targetFile] : []),
+  ]);
+  const relatedTests = unique([
+    ...(context?.relatedTests ?? []),
+    ...(targetFile && /\.(test|spec)\./.test(targetFile) ? [targetFile] : []),
+  ]);
+  const commands = [];
+  const fallbackCommands = [];
+  const reasons = [];
+  const notes = [];
+  const docsOnly = primaryTargets.length > 0
+    && primaryTargets.every((filePath) => filePath.startsWith('docs/'));
+  const risky = context?.taskType === 'non-trivial'
+    || skillIds.some((skillId) => ['discover-security', 'repo-maintenance'].includes(skillId));
+
+  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 verification if available; broad test runs are not the default.');
+  } else {
+    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 related tests first: ${relatedTests.slice(0, 2).join(', ')}`);
+      }
+    }
+
+    if (risky) {
+      reasons.push('riskySkillOrTask');
+      if (scripts.test) {
+        fallbackCommands.push(buildScriptCommand(packageManager, 'test'));
+      }
+    }
+
+    if (scripts.lint) {
+      fallbackCommands.push(buildScriptCommand(packageManager, 'lint'));
+    }
+    if (scripts.typecheck) {
+      fallbackCommands.push(buildScriptCommand(packageManager, 'typecheck'));
+    }
+
+    if (commands.length === 0 && scripts.test && risky) {
+      mode = 'broader-verification';
+      reasons.push('highRiskFallback');
+      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 summarizedContext = summarizeContext(context);
+  const primaryCommandList = unique(commands);
+  const fallbackCommandList = unique(fallbackCommands.filter((command) => !primaryCommandList.includes(command)));
+  const reasonList = unique(reasons);
+
+  return {
+    taskType: context?.taskType ?? taskType ?? 'simple',
+    packageManager,
+    mode,
+    commands: primaryCommandList,
+    fallbackCommands: fallbackCommandList,
+    reasons: reasonList,
+    notes: unique(notes),
+    executionPolicy: deriveExecutionPolicy({
+      taskType: context?.taskType ?? taskType ?? 'simple',
+      mode,
+      commands: primaryCommandList,
+      fallbackCommands: fallbackCommandList,
+      reasons: reasonList,
+      context: summarizedContext,
+    }),
+  };
+}
+
+function summarizeContext(contextResult) {
+  return {
+    primaryTargets: contextResult?.primaryTargets ?? [],
+    analogFiles: contextResult?.analogFiles ?? [],
+    sharedAbstractions: contextResult?.sharedAbstractions ?? [],
+    relatedTests: contextResult?.relatedTests ?? [],
+    styleFiles: contextResult?.styleFiles ?? [],
+  };
+}
+
+function expandRouteContext(contextResult) {
+  if (!contextResult) return contextResult;
+  const directTestTargets = (contextResult.primaryTargets ?? []).filter(isTestLikeFile);
+  if (directTestTargets.length === 0) return contextResult;
+  return {
+    ...contextResult,
+    relatedTests: unique([
+      ...(contextResult.relatedTests ?? []),
+      ...directTestTargets,
+    ]),
+  };
+}
+
+function deriveNextAction({ activeSkills = [], contextRecommendation = null, verificationRecommendation = null }) {
+  const policy = verificationRecommendation?.executionPolicy ?? null;
+  const primaryCommands = verificationRecommendation?.commands ?? [];
+  const 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 = (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(preview.primaryTargets ?? [], 2);
+  const relatedTests = summarizeCompactList(preview.relatedTests ?? [], 2);
+  const styleFiles = summarizeCompactList(preview.styleFiles ?? [], 1);
+  const primaryCommands = unique(verificationRecommendation?.commands ?? []);
+  const fallbackCommands = unique(verificationRecommendation?.fallbackCommands ?? []);
+  const preferredOrder = unique(
+    verificationRecommendation?.executionPolicy?.preferredOrder
+      ?? [...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 deriveExecutionPolicy({
+  taskType = 'simple',
+  mode = 'minimal',
+  commands = [],
+  fallbackCommands = [],
+  reasons = [],
+  context = {},
+} = {}) {
+  const relatedTests = context.relatedTests ?? [];
+  const 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: unique([
+      ...reasons,
+      sharedScope ? 'sharedScope' : null,
+      noRelatedTests ? 'noRelatedTests' : null,
+    ]),
+  };
+}
+
+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 }) {
+  const lower = buildNormalizedRouteSignalText(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 buildHelperCommand({ commandNamespace = '.claude', scriptName, intent = '', targetFile = null, taskType = null }) {
+  const parts = ['node', `${commandNamespace}/ukit/index/${scriptName}`];
+  if (intent) parts.push(JSON.stringify(intent));
+  if (targetFile) parts.push('--target', JSON.stringify(targetFile));
+  if (taskType) parts.push('--type', taskType);
+  return parts.join(' ');
+}
+
+function isTestLikeFile(filePath) {
+  return /\.(test|spec)\.[a-z0-9]+$/i.test(filePath)
+    || /(^|\/)(?:__tests__|tests?|specs?)\//i.test(filePath);
+}
+
+function summarizeCompactList(values, limit = 2) {
+  const normalized = unique(values);
+  return {
+    items: normalized.slice(0, limit),
+    total: normalized.length,
+  };
+}
+
+function countDelegationContextBreadth(preview = {}) {
+  return unique([
+    ...(preview.primaryTargets ?? []),
+    ...(preview.analogFiles ?? []),
+    ...(preview.sharedAbstractions ?? []),
+    ...(preview.relatedTests ?? []),
+  ]).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, '');
+}
+
+async function readPackageJson(rootDir) {
+  try {
+    const raw = await fs.readFile(path.join(rootDir, 'package.json'), 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function detectPackageManager({ fingerprintEntries = [], pkg = null } = {}) {
+  const declaredPackageManager = getDeclaredPackageManager(pkg);
+  if (declaredPackageManager) return declaredPackageManager;
+
+  const existingFiles = new Set(
+    fingerprintEntries
+      .filter((entry) => entry && entry.mtimeMs !== null)
+      .map((entry) => entry.filePath),
+  );
+
+  const checks = [
+    ['pnpm-lock.yaml', 'pnpm'],
+    ['yarn.lock', 'yarn'],
+    ['bun.lockb', 'bun'],
+    ['bun.lock', 'bun'],
+    ['package-lock.json', 'npm'],
+  ];
+
+  for (const [lockFile, pm] of checks) {
+    if (existingFiles.has(lockFile)) {
+      return pm;
+    }
+  }
+
+  return 'npm';
+}
+
+async function readProjectVerificationFingerprint(rootDir) {
+  const entries = [];
+  let pkg = null;
+
+  try {
+    const packageJsonPath = path.join(rootDir, 'package.json');
+    const [raw, stat] = await Promise.all([
+      fs.readFile(packageJsonPath, 'utf8'),
+      fs.stat(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',
+      ];
+
+  for (const relativePath of trackedFiles) {
+    const absolutePath = path.join(rootDir, relativePath);
+    try {
+      const stat = await fs.stat(absolutePath);
+      entries.push({
+        filePath: relativePath,
+        size: stat.size,
+        mtimeMs: stat.mtimeMs,
+      });
+    } catch {
+      entries.push({
+        filePath: relativePath,
+        size: null,
+        mtimeMs: null,
+      });
+    }
+  }
+
+  return {
+    pkg,
+    entries,
+    fingerprint: JSON.stringify(entries),
+  };
+}
+
+function getDeclaredPackageManager(pkg = null) {
+  const declared = String(pkg?.packageManager ?? '').toLowerCase();
+  if (declared.startsWith('pnpm')) return 'pnpm';
+  if (declared.startsWith('yarn')) return 'yarn';
+  if (declared.startsWith('bun')) return 'bun';
+  if (declared.startsWith('npm')) return 'npm';
+  return null;
+}
+
+function buildScriptCommand(packageManager, scriptName, args = []) {
+  const filteredArgs = args.filter(Boolean);
+  if (packageManager === 'npm') {
+    if (scriptName === 'test') {
+      return ['npm', 'test', filteredArgs.length > 0 ? '--' : '', ...filteredArgs].filter(Boolean).join(' ');
+    }
+    return ['npm', 'run', scriptName, filteredArgs.length > 0 ? '--' : '', ...filteredArgs].filter(Boolean).join(' ');
+  }
+  return [packageManager, scriptName, ...filteredArgs].join(' ');
+}
+
+function normalizeRelativeFile(rootDir, rawFilePath) {
+  if (typeof rawFilePath !== 'string' || !rawFilePath.trim()) return null;
+
+  const trimmed = rawFilePath.trim();
+  if (path.isAbsolute(trimmed)) {
+    const relative = path.relative(rootDir, trimmed);
+    if (relative && !relative.startsWith('..') && !path.isAbsolute(relative)) {
+      return relative.replaceAll('\\', '/');
+    }
+    return trimmed.replaceAll('\\', '/');
+  }
+
+  return trimmed.replace(/^\.\/+/, '').replaceAll('\\', '/');
+}
+
+async function pathExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function unique(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+
+const DELEGATABLE_IMPLEMENTATION_SKILL_IDS = new Set([
+  'delivery',
+  'frontend',
+  'frontend-vue',
+  'backend-api',
+  'postgres',
+  'sql-optimization-patterns',
+]);
+
+function getRootDir(argv) {
+  const value = readFlagValue(argv, '--root');
+  return value ? path.resolve(value) : process.cwd();
+}
+
+function readFlagValue(argv, flag) {
+  const exact = argv.indexOf(flag);
+  if (exact >= 0 && argv[exact + 1]) return argv[exact + 1];
+  const withEquals = argv.find((item) => item.startsWith(`${flag}=`));
+  return withEquals ? withEquals.slice(flag.length + 1) : null;
+}
+
+function isFlagOrValue(argv, index) {
+  const arg = argv[index];
+  if (!arg.startsWith('--')) {
+    const prev = argv[index - 1];
+    return Boolean(prev && ['--root', '--target', '--type', '--tool-command', '--last-prompt', '--adapter'].includes(prev));
+  }
+  return true;
+}
+
+function inferAdapterFromInvocation(invocationPath) {
+  if (invocationPath.includes('.codex/')) return 'codex';
+  if (invocationPath.includes('.antigravity/')) return 'antigravity';
+  return 'claude';
+}
+
+function buildResolveContextRequestKey({
+  indexGeneratedAtMs = null,
+  intent = '',
+  targetFile = null,
+  taskType = null,
+} = {}) {
+  return buildCompactMachineKey('resolve-v1', {
+    indexGeneratedAtMs,
+    intent: String(intent || '').trim(),
+    targetFile: String(targetFile || '').trim(),
+    taskType: String(taskType || '').trim(),
+  });
+}
+
+function buildVerifyContextRequestKey({
+  indexGeneratedAtMs = null,
+  projectFingerprint = '',
+  intent = '',
+  targetFile = null,
+  taskType = null,
+} = {}) {
+  return buildCompactMachineKey('verify-v1', {
+    indexGeneratedAtMs,
+    projectFingerprint,
+    intent: String(intent || '').trim(),
+    targetFile: String(targetFile || '').trim(),
+    taskType: String(taskType || '').trim(),
+  });
+}
+
+function buildRouteRequestKey({
+  commandNamespace = '.claude',
+  indexGeneratedAtMs = null,
+  projectFingerprint = null,
+  activeSkills = [],
+  routingContext = {},
+  previousContextSnapshot = null,
+  recentOutputSnapshot = null,
+} = {}) {
+  return buildCompactMachineKey('route-v2', {
+    commandNamespace,
+    indexGeneratedAtMs,
+    projectFingerprint,
+    previousContextFingerprint: previousContextSnapshot?.fingerprint ?? null,
+    recentOutputFingerprint: recentOutputSnapshot?.fingerprint ?? null,
+    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 ?? '',
+    adapter: routingContext.adapter ?? 'claude',
+    commandText: routingContext.commandText ?? '',
+    targetFile: routingContext.targetFile ?? '',
+    contextIntent: routingContext.contextIntent ?? '',
+    taskType: routingContext.taskType ?? '',
+  });
+}
+
+function buildRouteStateFingerprint(route = {}) {
+  return buildCompactMachineKey('routefp-v3', buildStructuredRouteFingerprintPayload(route));
+}
+
+function buildStructuredRouteFingerprintPayload(route = {}) {
+  const routeSummary = route.routeSummary ?? null;
+  return {
+    skills: (route.activeSkills ?? []).map((item) => item.id),
+    adapter: route.routingContext?.adapter ?? null,
+    taskType: route.routingContext?.taskType ?? null,
+    previousContextLine: route.previousContext?.line ?? null,
+    previousContextIds: unique(route.previousContext?.selectedIds ?? []),
+    recentOutputLine: route.recentOutput?.line ?? null,
+    policyMode: routeSummary?.policyMode ?? null,
+    delegateHint: routeSummary?.delegateHint ?? null,
+    nextActionType: routeSummary?.nextActionType ?? null,
+    nextActionCommand: routeSummary?.nextActionCommand ?? null,
+    helperHint: routeSummary?.helperHint ?? null,
+    primaryCommands: unique(routeSummary?.primaryCommands ?? []),
+    fallbackCommands: unique(routeSummary?.fallbackCommands ?? []),
+    preferredOrder: unique(routeSummary?.preferredOrder ?? []),
+  };
+}
+
+function buildCompactMachineKey(prefix, payload) {
+  return `${prefix}:${stableMachineDigest(payload)}`;
+}
+
+function stableMachineDigest(payload) {
+  return crypto
+    .createHash('sha256')
+    .update(JSON.stringify(payload))
+    .digest('base64url');
+}
+
+function reuseSharedRouteState({ previousState, requestKey }) {
+  if (!previousState || previousState.requestKey !== requestKey) {
+    return null;
+  }
+
+  if (!previousState.routeSummary || !Array.isArray(previousState.activeSkills)) {
+    return null;
+  }
+
+  return previousState;
+}
+
+function createSharedRouteState({
+  route,
+  source = 'task-route',
+  requestKey = null,
+}) {
+  const helpers = compactHelpers({
+    verificationRecommendation: route.verificationRecommendation ?? null,
+    routeSummary: route.routeSummary ?? null,
+  });
+
+  return {
+    requestKey,
+    fingerprint: buildRouteStateFingerprint(route),
+    ts: Date.now(),
+    source,
+    activeSkills: compactActiveSkills(route.activeSkills ?? []),
+    routingContext: compactRoutingContext(route.routingContext ?? {}),
+    ...(route.previousContext ? { previousContext: compactPreviousContext(route.previousContext) } : {}),
+    ...(route.recentOutput ? { recentOutput: compactRecentOutput(route.recentOutput) } : {}),
+    ...(helpers ? { helpers } : {}),
+    routeSummary: compactRouteSummary(route.routeSummary ?? null),
+  };
+}
+
+function compactRouteCacheState(sharedState = {}) {
+  if (!sharedState || typeof sharedState !== 'object') {
+    return sharedState;
+  }
+
+  const compactState = { ...sharedState };
+  delete compactState.source;
+  delete compactState.ts;
+  return compactState;
+}
+
+function compactActiveSkills(activeSkills = []) {
+  return activeSkills.map((item) => ({
+    id: item.id,
+  }));
+}
+
+function compactRoutingContext(routingContext = {}) {
+  return {
+    adapter: routingContext.adapter ?? 'claude',
+    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 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 compactRecentOutput(recentOutput = null) {
+  if (!recentOutput || typeof recentOutput !== 'object') {
+    return null;
+  }
+
+  const line = typeof recentOutput.line === 'string' ? recentOutput.line.trim() : '';
+  if (!line) {
+    return null;
+  }
+
+  return {
+    line,
+  };
+}
+
+function compactRouteSummary(routeSummary = null) {
+  if (!routeSummary) {
+    return null;
+  }
+
+  return {
+    line: routeSummary.line ?? 'task=unknown',
+    primaryCommands: unique(routeSummary.primaryCommands ?? []).slice(0, 2),
+    fallbackCommands: unique(routeSummary.fallbackCommands ?? []).slice(0, 3),
+    preferredOrder: unique(routeSummary.preferredOrder ?? []).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 shouldIncludeRecentOutput({
+  activeSkills = [],
+  routingContext = {},
+  useIndexedContext = true,
+} = {}) {
+  const taskType = String(routingContext?.taskType ?? '').trim();
+  const hasExplicitTarget = Boolean(String(routingContext?.targetFile ?? '').trim());
+  const primarySkillId = String(activeSkills?.[0]?.id ?? '').trim();
+
+  if (!useIndexedContext) {
+    return false;
+  }
+
+  if (!hasExplicitTarget) {
+    return true;
+  }
+
+  if (
+    (taskType === 'simple' || taskType === 'trivial')
+    && primarySkillId === 'testing-quality'
+  ) {
+    return false;
+  }
+
+  return true;
+}
+
+async function readJson(filePath, fallback = null) {
+  try {
+    return JSON.parse(await fs.readFile(filePath, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+async function writeJson(filePath, value) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, JSON.stringify(value), 'utf8');
+}
+
+function normalize(text) {
+  return String(text ?? '')
+    .toLowerCase()
+    .replace(/[^\p{L}\p{N}\s./:_-]/gu, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function tokenize(text) {
+  return normalize(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(tokenize(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;
+}
+
+async function readDirectoryJsonItems(dirPath) {
+  let entries = [];
+  try {
+    entries = await fs.readdir(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 = await 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));
+}
+
+async function detectProjectId(rootDir) {
+  const pkg = await readJson(path.join(rootDir, 'package.json'), null);
+  if (typeof pkg?.name === 'string' && pkg.name.trim()) {
+    return pkg.name.trim();
+  }
+
+  return path.basename(rootDir);
+}
+
+async function listMemoryItems(rootDir) {
+  const runtimeRoot = path.join(rootDir, '.ukit', 'storage', 'memory');
+  const userMemory = (await readJson(path.join(runtimeRoot, 'user.json'), null)) ?? { preferences: {}, rules: [] };
+  const projectMemories = await readDirectoryJsonItems(path.join(runtimeRoot, 'projects'));
+  const sessionMemories = await readDirectoryJsonItems(path.join(runtimeRoot, 'sessions'));
+
+  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 buildPreviousContextSnippet(item) {
+  const content = item.content ?? {};
+  if (item.type === 'project') {
+    const decisions = compactPhraseList((content.decisions ?? []).map((decision) => decision.what), { limit: 1 });
+    const rules = compactPhraseList(content.activeRules ?? [], { limit: 1 });
+    return `[project] ${content.name ?? content.id ?? 'project'} — decisions: ${decisions || 'n/a'}${rules ? ` — rules: ${rules}` : ''}`;
+  }
+
+  if (item.type === 'session') {
+    const actions = compactPhraseList(content.keyActions ?? [], { limit: 1 });
+    const nextSteps = compactPhraseList(content.nextSteps ?? [], { limit: 1 });
+    return `[session] ${content.taskDescription ?? item.id} — outcome: ${content.outcome ?? 'unknown'}${actions ? ` — actions: ${actions}` : ''}${nextSteps ? ` — next: ${nextSteps}` : ''}`;
+  }
+
+  const rules = compactPhraseList(content.rules ?? [], { limit: 1 });
+  return `[user] rules: ${rules || 'n/a'}`;
+}
+
+function compactPhraseList(values, { limit = 1, fallback = 'n/a' } = {}) {
+  const normalized = unique(
+    (values ?? [])
+      .map((value) => String(value ?? '').trim())
+      .filter(Boolean),
+  );
+
+  if (normalized.length === 0) {
+    return fallback;
+  }
+
+  const shown = normalized.slice(0, limit);
+  const remaining = normalized.length - shown.length;
+  return remaining > 0
+    ? `${shown.join('; ')} (+${remaining} more)`
+    : shown.join('; ');
+}
+
+async function buildPreviousContextSnapshot({ rootDir = process.cwd(), routingContext = {} } = {}) {
+  const taskQuery = String(
+    routingContext?.lastExplicitUserPromptText
+    || routingContext?.promptText
+    || routingContext?.targetFile
+    || ''
+  ).trim();
+  if (!taskQuery) {
+    return null;
+  }
+
+  const projectId = await detectProjectId(rootDir);
+  const items = await listMemoryItems(rootDir);
+  const queryTokens = tokenize(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: normalize(taskQuery),
+      projectId,
+      items: rankedItems.map((item) => ({
+        id: item.id,
+        timestamp: getMemoryTimestamp(item),
+      })),
+    }),
+  };
+}
+
+async function buildRecentOutputSnapshot({ rootDir = process.cwd() } = {}) {
+  const outputHistoryPath = path.join(rootDir, '.ukit', 'storage', 'cache', 'output-history.json');
+  const outputHistory = await readJson(outputHistoryPath, { entries: [] });
+  const entries = Array.isArray(outputHistory?.entries) ? outputHistory.entries : [];
+  const freshEntries = entries
+    .filter((entry) => (
+      typeof entry?.timestamp === 'number'
+      && (Date.now() - entry.timestamp) <= (30 * 60 * 1000)
+      && typeof entry?.summary === 'string'
+      && entry.summary.trim()
+    ))
+    .sort((left, right) => Number(right?.timestamp || 0) - Number(left?.timestamp || 0));
+  const entry = freshEntries[0];
+  if (!entry) {
+    return null;
+  }
+
+  return {
+    line: compactInlineSummary(entry.summary),
+    fingerprint: buildCompactMachineKey('route-output-v1', {
+      command: String(entry.command || ''),
+      summary: String(entry.summary || ''),
+      timestamp: entry.timestamp,
+      savedTokens: Number.isFinite(entry.savedTokens) ? entry.savedTokens : null,
+    }),
+  };
+}
+
+function compactInlineSummary(summary, { maxSegments = INLINE_SUMMARY_MAX_SEGMENTS } = {}) {
+  const lines = unique(
+    String(summary || '')
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter(Boolean),
+  );
+  if (lines.length === 0) {
+    return '';
+  }
+
+  if (lines.length <= maxSegments) {
+    return lines.join(' | ');
+  }
+
+  const firstLine = lines[0];
+  const middleLines = lines.slice(1, -1);
+  const selectedMiddle = [];
+
+  for (const line of middleLines) {
+    if (selectedMiddle.length >= Math.max(0, maxSegments - 2)) {
+      break;
+    }
+    if (!INLINE_SUMMARY_SIGNAL_PATTERNS.some((pattern) => pattern.test(line))) {
+      continue;
+    }
+    if (!selectedMiddle.includes(line)) {
+      selectedMiddle.push(line);
+    }
+  }
+
+  for (const line of middleLines) {
+    if (selectedMiddle.length >= Math.max(0, maxSegments - 2)) {
+      break;
+    }
+    if (!selectedMiddle.includes(line)) {
+      selectedMiddle.push(line);
+    }
+  }
+
+  const tailLine = selectInlineSummaryTail(lines);
+  const selected = unique([firstLine, ...selectedMiddle, tailLine]).slice(0, maxSegments);
+  const remaining = Math.max(0, lines.length - selected.length);
+  return remaining > 0
+    ? `${selected.join(' | ')} | +${remaining} more`
+    : selected.join(' | ');
+}
+
+function selectInlineSummaryTail(lines = []) {
+  for (const pattern of INLINE_SUMMARY_TAIL_PATTERNS) {
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+      if (pattern.test(lines[index])) {
+        return lines[index];
+      }
+    }
+  }
+
+  return lines[lines.length - 1] ?? '';
+}
+
+await main();