@ngockhoale/ukit 1.1.6

package/templates/.claude/ukit/runtime/reinject-context.mjs

@@ -0,0 +1,874 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import {
+  buildCompactMachineKey,
+  buildRuntimePaths,
+  compactContextBlock,
+  estimateTokenCount,
+  readJson,
+  readPromptCacheEntry,
+  recordCompaction,
+  writePromptCacheEntry,
+} from './token-utils.mjs';
+import {
+  buildThresholdCompactPlan,
+  readCompactPressureState,
+  writeThresholdCompactPlan,
+} from './compact-threshold.mjs';
+
+const STATE_TTL_MS = 30 * 60 * 1000;
+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,
+];
+
+async function main() {
+  const projectRoot = process.env.CLAUDE_PROJECT_DIR && path.isAbsolute(process.env.CLAUDE_PROJECT_DIR)
+    ? process.env.CLAUDE_PROJECT_DIR
+    : process.cwd();
+  const config = await loadRuntimeConfig(projectRoot);
+  const state = await loadFreshRouteState(projectRoot);
+  const compressEnabled = shouldCompress(config);
+  const header = '=== PROJECT CONTEXT (post-compaction) ===';
+  const footer = '=== END ===';
+
+  const rawStaticLines = buildStaticGuidanceLines(state, { compact: false });
+  const staticLines = buildStaticGuidanceLines(state, { compact: compressEnabled });
+
+  const dynamicLines = [
+    ...await buildRouteStateLines(state),
+    ...await buildPreviousContextLines(projectRoot, state, config),
+    ...await buildRecentOutputLines(projectRoot, config),
+    ...await buildResolverHintLines(projectRoot, state),
+    ...await buildDuraOneHintLines(projectRoot),
+    '- If Claude hooks block broad verification, follow the routed targeted order or ask for explicit full-suite confirmation.',
+  ].filter(Boolean);
+
+  const rawBodyLines = [...rawStaticLines, ...dynamicLines];
+  const bodyLines = [...staticLines, ...dynamicLines];
+  const pressureState = await readCompactPressureState(projectRoot, config);
+  const anchorLines = dynamicLines.filter((line) => (
+    line.startsWith('- Recent routed lane:')
+    || line.startsWith('- Previous context:')
+    || line.startsWith('- Recent command output:')
+    || line.startsWith('- Recent delegation hint:')
+  ));
+  const maxTokens = Math.max(160, Math.min(320, Number(config.memory?.maxInjectionTokens) || 320));
+  const thresholdPlan = buildThresholdCompactPlan({
+    state: pressureState,
+    config,
+    routeState: state,
+    staticLines,
+    dynamicLines,
+    maxTokens,
+  });
+  const requestKey = buildCompactMachineKey('precompact-reinject-v1', {
+    maxTokens,
+    taskPrompt: String(state?.routingContext?.lastExplicitUserPromptText || state?.routingContext?.promptText || '').trim(),
+    targetFile: state?.routingContext?.targetFile || null,
+    routeSummary: state?.routeSummary || null,
+    activeSkills: Array.isArray(state?.activeSkills) ? state.activeSkills.map((item) => getActiveSkillPath(item)) : [],
+    bodyLines: thresholdPlan.active ? thresholdPlan.lines : bodyLines,
+    thresholdPhase: thresholdPlan.active ? thresholdPlan.phase : 'monitor',
+    estimatedTotalTokens: thresholdPlan.active ? thresholdPlan.estimatedTotalTokens : pressureState.estimatedTotalTokens,
+  });
+
+  if (config.tokenPipeline?.promptCache) {
+    const cached = await readPromptCacheEntry(projectRoot, requestKey, { touch: true });
+    if (cached?.content) {
+      process.stdout.write(String(cached.content));
+      return;
+    }
+  }
+
+  const rawText = [header, ...rawBodyLines, footer].join('\n');
+  const compactedBody = thresholdPlan.active
+    ? {
+        text: thresholdPlan.lines.join('\n'),
+        tokensBefore: estimateTokenCount(rawBodyLines.join('\n')),
+        tokensAfter: estimateTokenCount(thresholdPlan.lines.join('\n')),
+        savedTokens: Math.max(0, estimateTokenCount(rawBodyLines.join('\n')) - estimateTokenCount(thresholdPlan.lines.join('\n'))),
+      }
+    : (
+      compressEnabled
+        ? compactContextBlock(bodyLines, {
+            maxTokens,
+            maxLines: 12,
+            anchorLines: anchorLines.slice(0, 3),
+            maxAnchors: 3,
+          })
+        : {
+            text: bodyLines.join('\n'),
+            tokensBefore: estimateTokenCount(bodyLines.join('\n')),
+            tokensAfter: estimateTokenCount(bodyLines.join('\n')),
+            savedTokens: 0,
+          }
+    );
+  const compactedLines = compactedBody.text ? compactedBody.text.split(/\r?\n/) : [];
+  const output = [header, ...compactedLines, footer].join('\n');
+
+  if (thresholdPlan.active) {
+    await writeThresholdCompactPlan(projectRoot, {
+      ...thresholdPlan,
+      tokensBefore: compactedBody.tokensBefore,
+      tokensAfter: compactedBody.tokensAfter,
+      savedTokens: compactedBody.savedTokens,
+    }, config);
+  }
+
+  const compactSource = thresholdPlan.active
+    ? `threshold-${thresholdPlan.phase}-precompact`
+    : 'precompact-reinject';
+  const rawTokens = estimateTokenCount(rawText);
+  const outputTokens = estimateTokenCount(output);
+
+  if (config.tokenPipeline?.promptCache) {
+    await writePromptCacheEntry(projectRoot, {
+      requestKey,
+      kind: compactSource,
+      updatedAt: Date.now(),
+      tokensBefore: rawTokens,
+      tokensAfter: outputTokens,
+      savedTokens: Math.max(0, rawTokens - outputTokens),
+      content: output,
+      metadata: {
+        hasRouteSummary: Boolean(state?.routeSummary),
+        hasPreviousContext: dynamicLines.some((line) => line.startsWith('- Previous context:')),
+        thresholdPhase: thresholdPlan.active ? thresholdPlan.phase : null,
+      },
+    });
+  }
+
+  await recordCompaction(projectRoot, {
+    timestamp: Date.now(),
+    source: compactSource,
+    tokensBefore: rawTokens,
+    tokensAfter: outputTokens,
+    savedTokens: Math.max(0, rawTokens - outputTokens),
+    metadata: {
+      hasRouteSummary: Boolean(state?.routeSummary),
+      hasPreviousContext: dynamicLines.some((line) => line.startsWith('- Previous context:')),
+      thresholdPhase: thresholdPlan.active ? thresholdPlan.phase : null,
+    },
+  });
+
+  process.stdout.write(output);
+}
+
+function shouldCompress(config) {
+  return Boolean(
+    config?.compact?.enabled
+    || config?.tokenPipeline?.inputCompression
+    || config?.tokenPipeline?.outputCompression,
+  );
+}
+
+function defaultRuntimeConfig() {
+  return {
+    compact: {
+      enabled: true,
+    },
+    tokenPipeline: {
+      inputCompression: true,
+      outputCompression: true,
+      promptCache: true,
+    },
+    memory: {
+      enabled: true,
+      progressiveRetrieval: true,
+      maxInjectionTokens: 320,
+    },
+  };
+}
+
+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;
+}
+
+async function loadRuntimeConfig(projectRoot) {
+  const runtimePaths = buildRuntimePaths(projectRoot);
+  const raw = await readJson(runtimePaths.configPath, {});
+  return deepMerge(defaultRuntimeConfig(), raw && typeof raw === 'object' ? raw : {});
+}
+
+async function loadFreshRouteState(projectRoot) {
+  const statePath = path.join(projectRoot, '.claude', 'ukit', 'skill-router-state.json');
+  const state = await readJson(statePath, {});
+  if (typeof state?.ts === 'number' && (Date.now() - state.ts) > STATE_TTL_MS) {
+    return {};
+  }
+  return state && typeof state === 'object' ? state : {};
+}
+
+function unique(values) {
+  return [...new Set((values || []).filter(Boolean))];
+}
+
+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 summarize(values, limit = 2) {
+  const normalized = unique(values);
+  return {
+    items: normalized.slice(0, limit),
+    total: normalized.length,
+  };
+}
+
+function normalizeTaskType(taskType) {
+  const normalized = String(taskType || '').trim().toLowerCase();
+  return ['trivial', 'simple', 'non-trivial'].includes(normalized) ? normalized : '';
+}
+
+function buildStaticGuidanceLines(state = {}, { compact = true } = {}) {
+  const taskType = normalizeTaskType(state?.routingContext?.taskType);
+  if (!compact) {
+    return [
+      '- Trivial: act directly; no doc reads.',
+      '- Simple: read docs/MEMORY.md; use context resolver for related files.',
+      '- Non-trivial: read docs/MEMORY.md + docs/PROJECT.md + docs/CODE_MAP.md.',
+      '- WORKLOG: read only for continuation/debugging.',
+      '- If confidence is low or the area is high-risk, escalate analysis or ask 1 short clarify question.',
+      '- Reuse existing code. Use yarn. Run tests after code changes.',
+      '- Scope-based verification: match verify effort to change scope.',
+      '- Auto-activate matching project-local skills from prompt + tool/file signals.',
+    ];
+  }
+
+  const currentLaneLine = taskType === 'trivial'
+    ? '- Current lane: trivial => act directly; no doc reads.'
+    : (
+      taskType === 'simple'
+        ? '- Current lane: simple => read docs/MEMORY.md; use context resolver for related files.'
+        : (
+          taskType === 'non-trivial'
+            ? '- Current lane: non-trivial => read docs/MEMORY.md + docs/PROJECT.md + docs/CODE_MAP.md.'
+            : '- Task lanes: trivial=act directly; simple=read docs/MEMORY.md + resolver; non-trivial=read docs/MEMORY.md + docs/PROJECT.md + docs/CODE_MAP.md.'
+        )
+    );
+
+  return [
+    currentLaneLine,
+    '- WORKLOG: read only for continuation/debugging.',
+    '- If confidence is low or the area is high-risk, escalate analysis or ask 1 short clarify question.',
+    '- Reuse existing code; use yarn; verify after changes with scope-matched effort.',
+    '- Auto-activate matching project-local skills from prompt + tool/file signals.',
+  ];
+}
+
+function formatSegment(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 stripShellQuotes(value) {
+  return String(value || '').replace(/^['"]|['"]$/g, '');
+}
+
+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 extractSegment(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 hasStructuredRouteSummaryField(state, field) {
+  return Boolean(
+    state?.routeSummary
+    && Object.prototype.hasOwnProperty.call(state.routeSummary, field),
+  );
+}
+
+function derivePolicyMode(state) {
+  return hasStructuredRouteSummaryField(state, 'policyMode')
+    ? (state?.routeSummary?.policyMode || null)
+    : (
+      state?.verificationRecommendation?.executionPolicy?.policyMode
+      || null
+    );
+}
+
+function deriveHelperHint(state) {
+  const hasStructuredNextActionCommand = hasStructuredRouteSummaryField(state, 'nextActionCommand');
+  return state?.routeSummary?.helperHint
+    || state?.helpers?.verificationHelperHint
+    || (
+      (!hasStructuredNextActionCommand && state?.nextAction?.command)
+        ? null
+        : compactHelperHint(
+            (
+              hasStructuredRouteSummaryField(state, 'nextActionType')
+                ? state?.routeSummary?.nextActionType
+                : state?.nextAction?.type
+            ) === 'pull-indexed-context'
+              ? state?.contextRecommendation?.command
+              : state?.verificationRecommendation?.helperCommand,
+          )
+    )
+    || null;
+}
+
+function deriveNextActionSegment(state) {
+  const nextActionCommand = hasStructuredRouteSummaryField(state, 'nextActionCommand')
+    ? (state?.routeSummary?.nextActionCommand || '')
+    : (state?.nextAction?.command || '');
+  if (nextActionCommand) {
+    return `next=${nextActionCommand}`;
+  }
+
+  const nextActionType = hasStructuredRouteSummaryField(state, 'nextActionType')
+    ? (state?.routeSummary?.nextActionType || '')
+    : (state?.nextAction?.type || '');
+  return nextActionType ? `next=${nextActionType}` : null;
+}
+
+function deriveNextActionType(state) {
+  return hasStructuredRouteSummaryField(state, 'nextActionType')
+    ? (state?.routeSummary?.nextActionType || '')
+    : (state?.nextAction?.type || '');
+}
+
+function inferTargetSegmentFromHelperHint(helperHint) {
+  if (typeof helperHint !== 'string' || !helperHint.trim()) {
+    return null;
+  }
+
+  const match = helperHint.match(/(?:^|\s)target=([^\s]+)/);
+  return match ? `targets=${String(match[1] || '').trim()}` : null;
+}
+
+function buildStructuredRouteLine(state, legacyRouteLine = '') {
+  const helperHint = deriveHelperHint(state);
+  const policyMode = derivePolicyMode(state);
+  const nextActionType = deriveNextActionType(state);
+  const hasStructuredPolicyMode = hasStructuredRouteSummaryField(state, 'policyMode');
+  const hasStructuredNextAction = hasStructuredRouteSummaryField(state, 'nextActionCommand')
+    || hasStructuredRouteSummaryField(state, 'nextActionType');
+  const hasStructuredHelperHint = hasStructuredRouteSummaryField(state, 'helperHint');
+  const helperOwnsTarget = typeof helperHint === 'string'
+    && /(?:^|\s)target=([^\s]+)/.test(helperHint);
+  const helperFirstLane = helperOwnsTarget && (
+    nextActionType === 'pull-indexed-context'
+    || nextActionType === 'ask-user-confirmation'
+  );
+
+  return [
+    state?.routingContext?.taskType ? 'task=' + state.routingContext.taskType : null,
+    helperFirstLane
+      ? null
+      : (extractSegment(legacyRouteLine, 'targets') || inferTargetSegmentFromHelperHint(helperHint)),
+    helperFirstLane ? null : extractSegment(legacyRouteLine, 'tests'),
+    helperFirstLane ? null : extractSegment(legacyRouteLine, 'styles'),
+    policyMode
+      ? 'policy=' + policyMode
+      : (hasStructuredPolicyMode ? null : extractSegment(legacyRouteLine, 'policy')),
+    deriveNextActionSegment(state)
+      || (hasStructuredNextAction ? null : extractSegment(legacyRouteLine, 'next')),
+    helperHint
+      ? 'helper=' + helperHint
+      : (hasStructuredHelperHint ? null : extractSegment(legacyRouteLine, 'helper')),
+  ].filter(Boolean).join(' | ');
+}
+
+function extractDelegateHint(state, routeLine) {
+  const explicit = typeof state?.routeSummary?.delegateHint === 'string'
+    ? state.routeSummary.delegateHint.trim()
+    : '';
+  if (explicit) {
+    return explicit;
+  }
+  if (hasStructuredRouteSummaryField(state, 'delegateHint')) {
+    return '';
+  }
+
+  const line = typeof routeLine === 'string' ? routeLine : '';
+  const match = line.match(/(?:^|\|\s*)delegate=([^|]+)/i);
+  return match ? String(match[1] || '').trim() : '';
+}
+
+function inferIndexFirstDelegationOrder(state, routeLine) {
+  const nextActionType = deriveNextActionType(state);
+  if (nextActionType === 'pull-indexed-context') {
+    return true;
+  }
+
+  const helperHint = deriveHelperHint(state);
+  if (typeof helperHint === 'string' && /^resolve-context\.mjs(?:\s|$)/i.test(helperHint)) {
+    return true;
+  }
+
+  return typeof routeLine === 'string' && /(?:^|\|\s*)next=pull-indexed-context(?:\s*\||$)/i.test(routeLine);
+}
+
+function buildLegacyRouteLine(state) {
+  const preview = state?.contextRecommendation?.preview || {};
+  const nextAction = state?.nextAction || null;
+  const policyMode = state?.verificationRecommendation?.executionPolicy?.policyMode || null;
+  const helperHint = nextAction?.command
+    ? null
+    : compactHelperHint(
+        nextAction?.type === 'pull-indexed-context'
+          ? state?.contextRecommendation?.command
+          : state?.verificationRecommendation?.helperCommand,
+      );
+
+  return [
+    state?.routingContext?.taskType ? 'task=' + state.routingContext.taskType : null,
+    formatSegment('targets', summarize(preview.primaryTargets || [], 2)),
+    formatSegment('tests', summarize(preview.relatedTests || [], 2)),
+    formatSegment('styles', summarize(preview.styleFiles || [], 1)),
+    policyMode ? 'policy=' + policyMode : null,
+    nextAction?.command
+      ? 'next=' + nextAction.command
+      : nextAction?.type
+        ? 'next=' + nextAction.type
+        : null,
+    helperHint ? 'helper=' + helperHint : null,
+  ].filter(Boolean).join(' | ');
+}
+
+async function buildRouteStateLines(state) {
+  const lines = [];
+  const rawSkillPaths = unique(
+    Array.isArray(state?.activeSkills) ? state.activeSkills.map((item) => getActiveSkillPath(item)) : [],
+  );
+  const legacyRouteLine = state?.routeSummary?.line || buildLegacyRouteLine(state);
+  const routeLine = buildStructuredRouteLine(state, legacyRouteLine) || legacyRouteLine;
+  const delegateHint = extractDelegateHint(state, legacyRouteLine || routeLine);
+  const indexFirstDelegationOrder = inferIndexFirstDelegationOrder(state, legacyRouteLine || routeLine);
+  const shouldShowSkillSignals = rawSkillPaths.length > 0 && (!routeLine || rawSkillPaths.length > 1);
+  const skillPaths = summarize(rawSkillPaths, routeLine ? 1 : 2);
+
+  if (shouldShowSkillSignals && skillPaths.items.length > 0) {
+    lines.push('- Recent skill signals: ' + skillPaths.items.join(', ') + (skillPaths.total > skillPaths.items.length ? ', +' + (skillPaths.total - skillPaths.items.length) + ' more' : ''));
+  }
+  if (routeLine) {
+    lines.push('- Recent routed lane: ' + routeLine);
+  }
+  if (delegateHint) {
+    lines.push('- Recent delegation hint: ' + (indexFirstDelegationOrder
+      ? `after indexed context, prefer internal lane ${delegateHint}`
+      : `prefer internal lane ${delegateHint}`));
+  }
+
+  return lines;
+}
+
+async function buildRecentOutputLines(projectRoot, config) {
+  if (!config?.tokenPipeline?.outputCompression) {
+    return [];
+  }
+
+  const runtimePaths = buildRuntimePaths(projectRoot);
+  const outputHistory = await readJson(runtimePaths.outputHistoryPath, { entries: [] });
+  const entries = Array.isArray(outputHistory?.entries) ? outputHistory.entries : [];
+  const fresh = entries
+    .filter((entry) => typeof entry?.timestamp === 'number' && (Date.now() - entry.timestamp) <= (30 * 60 * 1000))
+    .slice(0, 1);
+
+  if (fresh.length === 0) {
+    return [];
+  }
+
+  return fresh.map((entry) => `- Recent command output: ${compactInlineSummary(entry.summary)}`);
+}
+
+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] ?? '';
+}
+
+function routeStateHasExplicitResolverHint(state = {}) {
+  const helperHint = String(state?.routeSummary?.helperHint || '').trim();
+  if (/resolve-context\.mjs/i.test(helperHint)) {
+    return true;
+  }
+
+  const routeLine = String(state?.routeSummary?.line || '').trim();
+  const lineHelperMatch = routeLine.match(/(?:^|\|\s*)helper=([^|]+)/i);
+  if (lineHelperMatch && /resolve-context\.mjs/i.test(String(lineHelperMatch[1] || '').trim())) {
+    return true;
+  }
+
+  return false;
+}
+
+async function buildResolverHintLines(projectRoot, state = {}) {
+  if (routeStateHasExplicitResolverHint(state)) {
+    return [];
+  }
+
+  try {
+    await fs.access(path.join(projectRoot, '.cache', 'index', 'analogs.json'));
+    return [
+      '- Context resolver available: node .claude/ukit/index/resolve-context.mjs "<intent>"; use analog retrieval for clone/follow-pattern tasks.',
+    ];
+  } catch {
+    return [];
+  }
+}
+
+async function buildDuraOneHintLines(projectRoot) {
+  try {
+    await fs.access(path.join(projectRoot, '.claude', 'skills', 'duraone', 'SKILL.md'));
+    return ['- DuraOne active: ALWAYS read .claude/skills/duraone/SKILL.md before coding.'];
+  } catch {
+    return [];
+  }
+}
+
+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(projectRoot) {
+  const pkg = await readJson(path.join(projectRoot, 'package.json'), null);
+  if (typeof pkg?.name === 'string' && pkg.name.trim()) {
+    return pkg.name.trim();
+  }
+
+  return path.basename(projectRoot);
+}
+
+async function listMemoryItems(projectRoot) {
+  const runtimePaths = buildRuntimePaths(projectRoot);
+  const userMemory = (await readJson(runtimePaths.userMemoryPath, null)) ?? { preferences: {}, rules: [] };
+  const projectMemories = await readDirectoryJsonItems(runtimePaths.projectsDir);
+  const sessionMemories = await 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 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('; ');
+}
+
+function readSharedPreviousContextLine(state) {
+  const line = typeof state?.previousContext?.line === 'string'
+    ? state.previousContext.line.trim()
+    : '';
+
+  return line || null;
+}
+
+async function buildPreviousContextLines(projectRoot, state, config) {
+  if (!config?.memory?.enabled || !config?.memory?.progressiveRetrieval) {
+    return [];
+  }
+
+  const taskQuery = String(
+    state?.routingContext?.lastExplicitUserPromptText
+    || state?.routingContext?.promptText
+    || state?.routingContext?.targetFile
+    || '',
+  ).trim();
+  if (!taskQuery) {
+    return [];
+  }
+
+  const sharedPreviousContextLine = readSharedPreviousContextLine(state);
+  if (sharedPreviousContextLine) {
+    return [`- Previous context: ${sharedPreviousContextLine}`];
+  }
+
+  const projectId = await detectProjectId(projectRoot);
+  const items = await listMemoryItems(projectRoot);
+  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 [];
+  }
+
+  return [`- Previous context: ${rankedItems.map((item) => buildPreviousContextSnippet(item)).join(' | ')}`];
+}
+
+main().catch((error) => {
+  console.error('[UKit] Failed to build compact reinject context:', error?.message || String(error));
+  process.exitCode = 1;
+});