ai-dev-analytics 1.1.11 → 2.0.0

package/dist/utils/memory.js

@@ -1,7 +1,8 @@
-import { readdirSync, statSync } from 'node:fs';
+import { readdirSync, renameSync, rmSync, statSync } from 'node:fs';
 import { basename, dirname, resolve } from 'node:path';
 import { ensureDir, fileExists, readJson, readText, writeJson, writeText } from './fs.js';
-import { branchDir, memoriesDir, memoryIndexPath, moduleMemoriesDir, moduleMemoryPath, moduleMemoryViewPath, requirementPath, runContextPath, runMemoryPackViewPath, runContextViewPath, runsDir, } from './paths.js';
+import { branchDir, legacyModuleMemoryPath, legacyModuleMemoryViewPath, memoriesDir, memoryIndexPath, moduleMemoriesDir, moduleMemoryPath, moduleMemoryViewPath, requirementPath, runContextPath, runsDir, } from './paths.js';
+const MEMORY_SCHEMA_VERSION = '2.0';
 function uniqueStrings(values) {
     const result = [];
     const seen = new Set();
@@ -14,18 +15,71 @@ function uniqueStrings(values) {
     }
     return result;
 }
+function latestIso(a, b) {
+    if (!a)
+        return b || '';
+    if (!b)
+        return a;
+    return new Date(a).getTime() >= new Date(b).getTime() ? a : b;
+}
 function normalizeRepoPath(value) {
     return value.trim().replace(/\\/g, '/');
 }
+function stripKnownSourcePrefix(path) {
+    const normalized = normalizeRepoPath(path);
+    const prefixes = [
+        'src/modules/',
+        'src/module/',
+        'src/features/',
+        'src/feature/',
+        'src/pages/',
+        'src/views/',
+        'src/components/',
+        'src/',
+    ];
+    for (const prefix of prefixes) {
+        if (normalized.startsWith(prefix)) {
+            return normalized.slice(prefix.length);
+        }
+    }
+    return normalized;
+}
+function isNoisePath(value) {
+    const path = normalizeRepoPath(value);
+    const fileName = basename(path);
+    return path.startsWith('.../')
+        || fileName.startsWith('.')
+        || fileName === 'yarn.lock'
+        || fileName === 'package-lock.json'
+        || fileName === 'pnpm-lock.yaml'
+        || fileName === 'bun.lockb';
+}
+function isGeneratedToolingPath(value) {
+    const path = normalizeRepoPath(value);
+    return path === 'AGENTS.md'
+        || path === 'CLAUDE.md'
+        || path === '.mcp.json'
+        || path.startsWith('.claude/')
+        || path.startsWith('.cursor/')
+        || path.startsWith('.codex/')
+        || path.startsWith('.kiro/')
+        || path.startsWith('.agents/')
+        || path.startsWith('.agent/')
+        || path.startsWith('.roo/')
+        || path.startsWith('.roo-code/')
+        || path.startsWith('.augment/')
+        || path.startsWith('.gemini/')
+        || path.startsWith('.vscode/')
+        || path.startsWith('.lingma/')
+        || path.startsWith('.windsurf/');
+}
 function isAidaRuntimePath(value) {
     const path = normalizeRepoPath(value);
-    return path.startsWith('.aida/runs/')
-        || path.startsWith('.aida/memories/')
-        || path === '.aida/bootstrap-state.local.json';
+    return path.startsWith('.aida/');
 }
 function filterMeaningfulPaths(values, limit) {
     const filtered = uniqueStrings(values.map((value) => normalizeRepoPath(value || '')))
-        .filter((value) => value && !isAidaRuntimePath(value));
+        .filter((value) => value && !isAidaRuntimePath(value) && !isNoisePath(value) && !isGeneratedToolingPath(value));
     return typeof limit === 'number' ? filtered.slice(0, limit) : filtered;
 }
 function topItems(values, limit = 8) {
@@ -71,6 +125,46 @@ function walkMarkdownFiles(rootDir) {
     }
     return result.sort();
 }
+function pruneEmptyModuleMemoryDirs(rootDir) {
+    if (!fileExists(rootDir))
+        return;
+    for (const name of readdirSync(rootDir)) {
+        const full = resolve(rootDir, name);
+        if (!statSync(full).isDirectory())
+            continue;
+        pruneEmptyModuleMemoryDirs(full);
+        if (readdirSync(full).length === 0) {
+            rmSync(full, { recursive: true, force: true });
+        }
+    }
+}
+function migrateLegacyNestedModuleMemoryLayout(projectRoot) {
+    const rootDir = moduleMemoriesDir(projectRoot);
+    if (!fileExists(rootDir))
+        return;
+    const files = [
+        ...walkJsonFiles(rootDir).filter((file) => basename(file) !== 'index.json'),
+        ...walkMarkdownFiles(rootDir),
+    ];
+    for (const file of files) {
+        const relative = file.slice(rootDir.length + 1).replace(/\\/g, '/');
+        if (!relative.includes('/'))
+            continue;
+        const moduleKey = relative.replace(/\.(json|md)$/u, '');
+        const target = file.endsWith('.json')
+            ? moduleMemoryPath(projectRoot, moduleKey)
+            : moduleMemoryViewPath(projectRoot, moduleKey);
+        if (target === file)
+            continue;
+        ensureDir(dirname(target));
+        if (fileExists(target)) {
+            rmSync(file, { force: true });
+            continue;
+        }
+        renameSync(file, target);
+    }
+    pruneEmptyModuleMemoryDirs(rootDir);
+}
 function walkRunJsonFiles(rootDir) {
     if (!fileExists(rootDir))
         return [];
@@ -195,7 +289,7 @@ function pickKeyFiles(runs) {
     const score = new Map();
     for (const run of runs) {
         for (const file of run.files || []) {
-            if (isAidaRuntimePath(file.path))
+            if (isAidaRuntimePath(file.path) || isNoisePath(file.path) || isGeneratedToolingPath(file.path))
                 continue;
             const path = normalizeRepoPath(file.path);
             const weight = (file.linesAdded || 0) + (file.linesRemoved || 0) + ((file.changeCount || 1) * 5);
@@ -217,14 +311,54 @@ function deriveCurrentPhase(runs) {
         return 'Completed';
     return 'Not Started';
 }
-function inferModules(requirement, runs) {
+function inferModuleDescriptors(requirement, runs) {
+    const byKey = new Map();
+    const meaningfulRunPaths = runs
+        .flatMap((run) => run.files || [])
+        .filter((file) => !isAidaRuntimePath(file.path) && !isNoisePath(file.path) && !isGeneratedToolingPath(file.path))
+        .map((file) => file.path);
+    const put = (descriptor) => {
+        const key = normalizeModuleKey(descriptor.key);
+        if (!key || key === 'default')
+            return;
+        const existing = byKey.get(key);
+        if (!existing) {
+            byKey.set(key, {
+                key,
+                title: descriptor.title || key,
+                description: descriptor.description || undefined,
+            });
+            return;
+        }
+        byKey.set(key, {
+            key,
+            title: existing.title || descriptor.title || key,
+            description: existing.description || descriptor.description || undefined,
+        });
+    };
     if (requirement?.modules?.length) {
-        return uniqueStrings(requirement.modules.map((module) => module.name).filter(Boolean));
+        for (const module of requirement.modules) {
+            const candidatePaths = typeof module.file === 'string' && module.file.trim().length > 0
+                ? [module.file]
+                : meaningfulRunPaths;
+            put(deriveModuleDescriptor(module.name, candidatePaths, module.description || ''));
+        }
+    }
+    else {
+        const stageNames = uniqueStrings(runs
+            .flatMap((run) => run.tasks || [])
+            .map((task) => task.stageName)
+            .filter((stage) => stage && stage !== 'default'));
+        for (const stageName of stageNames) {
+            put(deriveModuleDescriptor(stageName, meaningfulRunPaths));
+        }
+        if (byKey.size === 0) {
+            for (const descriptor of inferModuleDescriptorsFromPaths(meaningfulRunPaths)) {
+                put(descriptor);
+            }
+        }
     }
-    return uniqueStrings(runs
-        .flatMap((run) => run.tasks || [])
-        .map((task) => task.stageName)
-        .filter((stage) => stage && stage !== 'default'));
+    return [...byKey.values()].sort((a, b) => a.key.localeCompare(b.key));
 }
 function renderListSection(title, values) {
     if (values.length === 0)
@@ -274,44 +408,185 @@ export function normalizeModuleKey(value) {
     return value
         .trim()
         .toLowerCase()
+        .replace(/\s*\/\s*/g, '/')
+        .replace(/-\//g, '/')
+        .replace(/\/-/g, '/')
         .replace(/[^a-z0-9/_\u4e00-\u9fa5-]+/g, '-')
         .replace(/\/+/g, '/')
         .replace(/-+/g, '-')
         .replace(/^-|-$/g, '');
 }
+function normalizeModuleSegment(value) {
+    return normalizeModuleKey(value).replace(/\//g, '-');
+}
+function isGenericPathStem(value) {
+    return new Set([
+        'index',
+        'page',
+        'view',
+        'component',
+        'service',
+        'services',
+        'store',
+        'model',
+        'models',
+        'type',
+        'types',
+        'utils',
+        'util',
+        'helper',
+        'helpers',
+        'api',
+        'hooks',
+        'hook',
+    ]).has(value);
+}
+function isGenericModuleName(value) {
+    return new Set([
+        'module',
+        'modules',
+        'feature',
+        'features',
+        'page',
+        'pages',
+        'view',
+        'views',
+        'component',
+        'components',
+        'api',
+        'utils',
+        'util',
+        'helper',
+        'helpers',
+        '基础设施',
+        '视图层',
+        '集成',
+        '国际化',
+        '公共工具',
+        '工具',
+        '配置',
+    ]).has(value);
+}
+function areAllModulesGeneric(values) {
+    return values.length > 0 && values.every((value) => isGenericModuleName(normalizeModuleKey(value)));
+}
+function isPlaceholderBranchText(value, branchName) {
+    if (!value)
+        return true;
+    const normalized = value.trim();
+    if (!normalized)
+        return true;
+    return normalized === branchName || normalized === branchName.replace(/-/g, '/');
+}
+function inferModuleDescriptorsFromPaths(paths) {
+    const byKey = new Map();
+    for (const path of filterMeaningfulPaths(paths)) {
+        const key = deriveModuleKeyFromPaths([path]);
+        if (!key || byKey.has(key))
+            continue;
+        byKey.set(key, { key, title: key });
+    }
+    return [...byKey.values()];
+}
+export function deriveModuleKeyFromPaths(paths) {
+    for (const value of paths) {
+        const normalized = stripKnownSourcePrefix(value || '');
+        if (!normalized)
+            continue;
+        const segments = normalized
+            .split('/')
+            .map((segment, index, all) => {
+            if (index === all.length - 1)
+                return segment.replace(/\.[^.]+$/u, '');
+            return segment;
+        })
+            .map((segment) => normalizeModuleSegment(segment))
+            .filter(Boolean);
+        while (segments.length > 1 && isGenericPathStem(segments[segments.length - 1])) {
+            segments.pop();
+        }
+        if (segments.length >= 2)
+            return `${segments[0]}/${segments[1]}`;
+        if (segments.length === 1)
+            return segments[0];
+    }
+    return '';
+}
+function deriveModuleDescriptor(rawName, candidatePaths = [], description = '') {
+    const normalizedName = normalizeModuleKey(rawName);
+    const pathDerived = deriveModuleKeyFromPaths(candidatePaths);
+    const key = normalizedName.includes('/')
+        ? normalizedName
+        : (!normalizedName || isGenericModuleName(normalizedName))
+            ? (pathDerived || normalizedName)
+            : normalizedName;
+    return {
+        key: key || normalizedName || 'module',
+        title: rawName.trim() || key || 'module',
+        description: description.trim() || undefined,
+    };
+}
+function normalizeModuleMemoryRecord(record) {
+    return {
+        ...record,
+        moduleKey: normalizeModuleKey(record.moduleKey),
+    };
+}
 export function loadMemoryIndex(projectRoot) {
     const path = memoryIndexPath(projectRoot);
     if (!fileExists(path)) {
         return {
+            schemaVersion: MEMORY_SCHEMA_VERSION,
             updatedAt: new Date().toISOString(),
-            modules: [],
+            items: [],
         };
     }
-    return readJson(path);
+    const raw = readJson(path);
+    const items = Array.isArray(raw?.items)
+        ? raw.items
+        : Array.isArray(raw?.modules)
+            ? raw.modules
+            : [];
+    return {
+        schemaVersion: raw?.schemaVersion || MEMORY_SCHEMA_VERSION,
+        updatedAt: raw?.updatedAt || new Date().toISOString(),
+        items,
+    };
 }
 export function saveMemoryIndex(projectRoot, index) {
     ensureDir(memoriesDir(projectRoot));
-    writeJson(memoryIndexPath(projectRoot), index);
+    writeJson(memoryIndexPath(projectRoot), {
+        schemaVersion: index.schemaVersion || MEMORY_SCHEMA_VERSION,
+        updatedAt: index.updatedAt,
+        items: index.items,
+    });
 }
 export function loadModuleMemory(projectRoot, moduleKey) {
     const normalized = normalizeModuleKey(moduleKey);
     const path = moduleMemoryPath(projectRoot, normalized);
     if (fileExists(path))
         return readJson(path);
+    const legacyPath = legacyModuleMemoryPath(projectRoot, normalized);
+    if (fileExists(legacyPath))
+        return readJson(legacyPath);
     const viewPath = moduleMemoryViewPath(projectRoot, normalized);
-    if (!fileExists(viewPath))
+    if (fileExists(viewPath))
+        return moduleMemoryRecordFromMarkdown(readText(viewPath));
+    const legacyViewPath = legacyModuleMemoryViewPath(projectRoot, normalized);
+    if (!fileExists(legacyViewPath))
         return null;
-    return moduleMemoryRecordFromMarkdown(readText(viewPath));
+    return moduleMemoryRecordFromMarkdown(readText(legacyViewPath));
 }
 function upsertMemoryIndexEntry(projectRoot, record) {
     const index = loadMemoryIndex(projectRoot);
     const entry = memoryIndexEntryFromRecord(record);
-    const next = index.modules.filter((item) => item.key !== record.moduleKey);
+    const next = index.items.filter((item) => item.key !== record.moduleKey);
     next.push(entry);
     next.sort((a, b) => a.key.localeCompare(b.key));
     saveMemoryIndex(projectRoot, {
+        schemaVersion: MEMORY_SCHEMA_VERSION,
         updatedAt: new Date().toISOString(),
-        modules: next,
+        items: next,
     });
 }
 function memoryIndexEntryFromRecord(record) {
@@ -321,9 +596,72 @@ function memoryIndexEntryFromRecord(record) {
         summary: record.summary,
         keywords: topItems([record.moduleKey, record.title, ...record.keywords], 12),
         paths: filterMeaningfulPaths([...record.entryFiles, ...record.relatedPaths], 12),
+        tickets: topItems([...(record.tickets || [])]
+            .map((ticket) => ticket.ticket || ticket.branch || '')
+            .filter(Boolean), 8),
         updatedAt: record.updatedAt,
     };
 }
+function mergeTicketReferences(existing, incoming) {
+    const byKey = new Map();
+    for (const ticket of [...existing, ...incoming]) {
+        const summary = ticket.summary.trim();
+        if (!summary)
+            continue;
+        const key = `${ticket.ticket || ''}|${ticket.branch || ''}`;
+        const current = byKey.get(key);
+        if (!current) {
+            byKey.set(key, {
+                ticket: ticket.ticket,
+                branch: ticket.branch,
+                summary,
+                updatedAt: ticket.updatedAt,
+            });
+            continue;
+        }
+        const useIncoming = latestIso(current.updatedAt, ticket.updatedAt) === ticket.updatedAt;
+        byKey.set(key, {
+            ticket: current.ticket || ticket.ticket,
+            branch: current.branch || ticket.branch,
+            summary: useIncoming ? summary : current.summary,
+            updatedAt: latestIso(current.updatedAt, ticket.updatedAt),
+        });
+    }
+    return [...byKey.values()].sort((a, b) => `${b.updatedAt || ''}`.localeCompare(a.updatedAt || '') || `${a.ticket || a.branch || ''}`.localeCompare(`${b.ticket || b.branch || ''}`));
+}
+function mergeChangeEntries(existing, incoming) {
+    const byKey = new Map();
+    for (const change of [...existing, ...incoming]) {
+        const summary = change.summary.trim();
+        if (!summary)
+            continue;
+        const key = change.ticket || change.branch
+            ? `${change.ticket || ''}|${change.branch || ''}`
+            : `${change.title || ''}|${summary}`;
+        const current = byKey.get(key);
+        if (!current) {
+            byKey.set(key, {
+                ticket: change.ticket,
+                branch: change.branch,
+                title: change.title,
+                summary,
+                updatedAt: change.updatedAt,
+            });
+            continue;
+        }
+        const useIncoming = latestIso(current.updatedAt, change.updatedAt) === change.updatedAt;
+        byKey.set(key, {
+            ticket: current.ticket || change.ticket,
+            branch: current.branch || change.branch,
+            title: useIncoming ? (change.title || current.title) : (current.title || change.title),
+            summary: useIncoming ? summary : current.summary,
+            updatedAt: latestIso(current.updatedAt, change.updatedAt),
+        });
+    }
+    return [...byKey.values()]
+        .sort((a, b) => `${b.updatedAt}`.localeCompare(`${a.updatedAt}`))
+        .slice(0, 20);
+}
 function mergeMemoryIndexEntry(existing, next) {
     if (!existing)
         return next;
@@ -333,6 +671,7 @@ function mergeMemoryIndexEntry(existing, next) {
         summary: next.summary || existing.summary,
         keywords: topItems([...(existing.keywords || []), ...(next.keywords || [])], 12),
         paths: filterMeaningfulPaths([...(existing.paths || []), ...(next.paths || [])], 12),
+        tickets: topItems([...(existing.tickets || []), ...(next.tickets || [])], 8),
         updatedAt: next.updatedAt || existing.updatedAt,
     };
 }
@@ -346,6 +685,7 @@ function moduleMemoryRecordFromMarkdown(raw) {
     const sections = extractMarkdownSections(raw);
     const summary = sections.get('summary') || '';
     return {
+        schemaVersion: MEMORY_SCHEMA_VERSION,
         moduleKey,
         title: raw.match(/^- Title:\s+(.+)$/m)?.[1]?.trim() || moduleKey,
         summary,
@@ -358,32 +698,54 @@ function moduleMemoryRecordFromMarkdown(raw) {
         pitfalls: parseListSection(raw, 'pitfalls'),
         relatedRules: parseListSection(raw, 'related rules'),
         tickets: [],
+        changes: [],
         updatedAt: raw.match(/^- Updated At:\s+(.+)$/m)?.[1]?.trim() || new Date().toISOString(),
     };
 }
 export function rebuildMemoryIndexFromDisk(projectRoot) {
     ensureDir(moduleMemoriesDir(projectRoot));
+    migrateLegacyNestedModuleMemoryLayout(projectRoot);
     const byKey = new Map();
-    for (const entry of loadMemoryIndex(projectRoot).modules || []) {
-        byKey.set(entry.key, entry);
-    }
+    const expectedMarkdownViews = new Set();
     for (const file of walkJsonFiles(moduleMemoriesDir(projectRoot))) {
         if (basename(file) === 'index.json')
             continue;
-        const record = readJson(file);
+        const original = readJson(file);
+        const record = normalizeModuleMemoryRecord(original);
+        if (record.moduleKey !== original.moduleKey) {
+            saveModuleMemory(projectRoot, record);
+            rmSync(file, { force: true });
+        }
         const entry = memoryIndexEntryFromRecord(record);
         byKey.set(record.moduleKey, mergeMemoryIndexEntry(byKey.get(record.moduleKey), entry));
+        expectedMarkdownViews.add(moduleMemoryViewPath(projectRoot, record.moduleKey));
     }
     for (const file of walkMarkdownFiles(moduleMemoriesDir(projectRoot))) {
         const record = moduleMemoryRecordFromMarkdown(readText(file));
         if (!record)
             continue;
-        const entry = memoryIndexEntryFromRecord(record);
-        byKey.set(record.moduleKey, mergeMemoryIndexEntry(byKey.get(record.moduleKey), entry));
+        const normalized = normalizeModuleMemoryRecord(record);
+        if (normalized.moduleKey !== record.moduleKey) {
+            const targetViewPath = moduleMemoryViewPath(projectRoot, normalized.moduleKey);
+            ensureDir(dirname(targetViewPath));
+            if (!fileExists(targetViewPath)) {
+                writeText(targetViewPath, renderModuleMemoryMarkdown(normalized));
+            }
+            rmSync(file, { force: true });
+        }
+        const entry = memoryIndexEntryFromRecord(normalized);
+        byKey.set(normalized.moduleKey, mergeMemoryIndexEntry(byKey.get(normalized.moduleKey), entry));
+        expectedMarkdownViews.add(moduleMemoryViewPath(projectRoot, normalized.moduleKey));
+    }
+    for (const file of walkMarkdownFiles(moduleMemoriesDir(projectRoot))) {
+        if (!expectedMarkdownViews.has(file)) {
+            rmSync(file, { force: true });
+        }
     }
     const index = {
+        schemaVersion: MEMORY_SCHEMA_VERSION,
         updatedAt: new Date().toISOString(),
-        modules: [...byKey.values()].sort((a, b) => a.key.localeCompare(b.key)),
+        items: [...byKey.values()].sort((a, b) => a.key.localeCompare(b.key)),
     };
     saveMemoryIndex(projectRoot, index);
     return index;
@@ -391,7 +753,10 @@ export function rebuildMemoryIndexFromDisk(projectRoot) {
 export function saveModuleMemory(projectRoot, record) {
     const path = moduleMemoryPath(projectRoot, record.moduleKey);
     ensureDir(dirname(path));
-    writeJson(path, record);
+    writeJson(path, {
+        schemaVersion: record.schemaVersion || MEMORY_SCHEMA_VERSION,
+        ...record,
+    });
     upsertMemoryIndexEntry(projectRoot, record);
 }
 export function loadRunContext(projectRoot, branchName) {
@@ -432,6 +797,12 @@ export function renderModuleMemoryMarkdown(record) {
         '',
         renderListSection('Related Rules', record.relatedRules).trimEnd(),
         '',
+        '## Changes',
+        '',
+        ...((record.changes || []).length > 0
+            ? (record.changes || []).map((change) => `- ${[change.ticket || change.branch, change.title, change.summary].filter(Boolean).join(' | ')}`)
+            : ['- None']),
+        '',
         '## Related Tickets',
         '',
         ...(record.tickets.length > 0
@@ -492,50 +863,34 @@ export function renderRunMemoryPackMarkdown(context, modules) {
 }
 export function buildMemoryViews(projectRoot) {
     ensureDir(moduleMemoriesDir(projectRoot));
+    migrateLegacyNestedModuleMemoryLayout(projectRoot);
     let moduleViews = 0;
     for (const file of walkJsonFiles(moduleMemoriesDir(projectRoot))) {
         if (basename(file) === 'index.json')
             continue;
-        const record = readJson(file);
+        const original = readJson(file);
+        const record = normalizeModuleMemoryRecord(original);
+        if (record.moduleKey !== original.moduleKey) {
+            saveModuleMemory(projectRoot, record);
+            rmSync(file, { force: true });
+        }
         const viewPath = moduleMemoryViewPath(projectRoot, record.moduleKey);
         ensureDir(dirname(viewPath));
         writeText(viewPath, renderModuleMemoryMarkdown(record));
         moduleViews++;
     }
-    let contextViews = 0;
-    let packViews = 0;
-    const root = runsDir(projectRoot);
-    if (!fileExists(root)) {
-        rebuildMemoryIndexFromDisk(projectRoot);
-        return { moduleViews, contextViews, packViews };
-    }
-    for (const branchName of readdirSync(root)) {
-        const safeBranchDir = resolve(root, branchName);
-        if (!fileExists(safeBranchDir) || !statSync(safeBranchDir).isDirectory())
-            continue;
-        const contextPath = resolve(safeBranchDir, 'context.json');
-        if (!fileExists(contextPath))
-            continue;
-        const record = readJson(contextPath);
-        writeText(runContextViewPath(projectRoot, record.branch), renderRunContextMarkdown(record));
-        contextViews++;
-        const modules = record.modules
-            .map((moduleName) => loadModuleMemory(projectRoot, moduleName))
-            .filter((item) => item !== null);
-        writeText(runMemoryPackViewPath(projectRoot, record.branch), renderRunMemoryPackMarkdown(record, modules));
-        packViews++;
-    }
     rebuildMemoryIndexFromDisk(projectRoot);
-    return { moduleViews, contextViews, packViews };
+    return { moduleViews, contextViews: 0, packViews: 0 };
 }
 export function buildRunContextFromBranch(projectRoot, branchName) {
+    const existing = loadRunContext(projectRoot, branchName);
     const requirement = loadRequirement(projectRoot, branchName);
     const analysis = loadAnalysis(projectRoot, branchName);
     const runs = loadBranchRuns(projectRoot, branchName);
     if (!requirement && !analysis && runs.length === 0) {
         return null;
     }
-    const modules = inferModules(requirement, runs);
+    const moduleDescriptors = inferModuleDescriptors(requirement, runs);
     const completed = topItems(runs.flatMap((run) => run.tasks || []).filter((task) => task.status === 'done').map((task) => task.title));
     const inProgress = topItems(runs.flatMap((run) => run.tasks || []).filter((task) => task.status === 'in-progress').map((task) => task.title));
     const next = topItems(runs.flatMap((run) => run.tasks || []).filter((task) => task.status === 'pending').map((task) => task.title));
@@ -547,25 +902,44 @@ export function buildRunContextFromBranch(projectRoot, branchName) {
         ...runs.flatMap((run) => run.deviations || []).map((deviation) => deviation.title),
     ];
     const title = requirement?.title || extractTicket(branchName) || branchName;
+    const derivedPhase = deriveCurrentPhase(runs);
+    const derivedModules = moduleDescriptors.map((descriptor) => descriptor.key);
+    const derivedKeyFiles = pickKeyFiles(runs);
+    const derivedRisks = topItems([...analysisRisks, ...runRisks]);
+    const existingModules = existing?.modules || [];
+    const fallbackPathModules = inferModuleDescriptorsFromPaths([
+        ...derivedKeyFiles,
+        ...(existing?.keyFiles || []),
+    ]).map((descriptor) => descriptor.key);
+    const nextModules = derivedModules.length > 0
+        ? derivedModules
+        : areAllModulesGeneric(existingModules) && fallbackPathModules.length > 0
+            ? fallbackPathModules
+            : existingModules;
+    const nextTitle = isPlaceholderBranchText(existing?.title, branchName) ? title : (existing?.title || title);
+    const nextSummary = requirement?.summary
+        || extractSummaryFromAnalysis(analysis)
+        || (!isPlaceholderBranchText(existing?.summary, branchName) ? existing.summary : '')
+        || (nextModules.length > 0 ? `涉及模块: ${nextModules.join(', ')}` : title);
     return {
         branch: branchName,
         ticket: extractTicket(requirement?.title || '') || extractTicket(branchName),
-        title,
-        summary: requirement?.summary || extractSummaryFromAnalysis(analysis) || title,
-        currentPhase: deriveCurrentPhase(runs),
-        modules,
-        completed,
-        inProgress,
-        next,
-        decisions,
-        constraints,
-        keyFiles: pickKeyFiles(runs),
-        risks: topItems([...analysisRisks, ...runRisks]),
+        title: nextTitle,
+        summary: nextSummary,
+        currentPhase: derivedPhase === 'Not Started' && existing?.currentPhase ? existing.currentPhase : derivedPhase,
+        modules: nextModules,
+        completed: completed.length > 0 ? completed : (existing?.completed || []),
+        inProgress: inProgress.length > 0 ? inProgress : (existing?.inProgress || []),
+        next: next.length > 0 ? next : (existing?.next || []),
+        decisions: decisions.length > 0 ? decisions : (existing?.decisions || []),
+        constraints: constraints.length > 0 ? constraints : (existing?.constraints || []),
+        keyFiles: derivedKeyFiles.length > 0 ? derivedKeyFiles : (existing?.keyFiles || []),
+        risks: derivedRisks.length > 0 ? derivedRisks : (existing?.risks || []),
         updatedAt: new Date().toISOString(),
     };
 }
-function collectRelatedPaths(moduleName, branchContext, runs) {
-    const query = moduleName.toLowerCase();
+function collectRelatedPaths(moduleDescriptor, branchContext, runs) {
+    const query = moduleDescriptor.key.toLowerCase();
     const tokens = splitQueryTokens(query);
     const scored = new Map();
     for (const path of branchContext.keyFiles) {
@@ -575,10 +949,11 @@ function collectRelatedPaths(moduleName, branchContext, runs) {
     }
     for (const run of runs) {
         for (const task of run.tasks || []) {
-            if (task.stageName !== moduleName)
+            const taskDescriptor = deriveModuleDescriptor(task.stageName || '', (run.files || []).map((file) => file.path));
+            if (taskDescriptor.key !== moduleDescriptor.key)
                 continue;
             for (const file of run.files || []) {
-                if (isAidaRuntimePath(file.path))
+                if (isAidaRuntimePath(file.path) || isNoisePath(file.path) || isGeneratedToolingPath(file.path))
                     continue;
                 const path = normalizeRepoPath(file.path);
                 const bonus = (file.linesAdded || 0) + (file.linesRemoved || 0) + 10;
@@ -592,24 +967,31 @@ function collectRelatedPaths(moduleName, branchContext, runs) {
 export function upsertModuleMemory(projectRoot, input) {
     const moduleKey = normalizeModuleKey(input.moduleKey);
     const existing = loadModuleMemory(projectRoot, moduleKey);
+    const existingEntryFiles = filterMeaningfulPaths(existing?.entryFiles || [], 8);
+    const existingRelatedPaths = filterMeaningfulPaths(existing?.relatedPaths || [], 12);
+    const nextChanges = ((input.tickets || []).filter((ticket) => ticket.summary.trim().length > 0))
+        .map((ticket) => ({
+        ticket: ticket.ticket,
+        branch: ticket.branch,
+        title: input.changeTitle || ticket.ticket || ticket.branch || input.title || existing?.title || moduleKey,
+        summary: ticket.summary,
+        updatedAt: ticket.updatedAt || new Date().toISOString(),
+    }));
     const record = {
+        schemaVersion: MEMORY_SCHEMA_VERSION,
         moduleKey,
         title: input.title || existing?.title || moduleKey,
         summary: input.summary || existing?.summary || '',
         keywords: topItems([...(existing?.keywords || []), ...(input.keywords || []), moduleKey, input.title || ''], 16),
-        entryFiles: filterMeaningfulPaths([...(existing?.entryFiles || []), ...(input.entryFiles || [])], 8),
-        relatedPaths: filterMeaningfulPaths([...(existing?.relatedPaths || []), ...(input.relatedPaths || [])], 12),
+        entryFiles: filterMeaningfulPaths([...existingEntryFiles, ...(input.entryFiles || [])], 8),
+        relatedPaths: filterMeaningfulPaths([...existingRelatedPaths, ...(input.relatedPaths || [])], 12),
         dataFlow: topItems([...(existing?.dataFlow || []), ...(input.dataFlow || [])]),
         decisions: topItems([...(existing?.decisions || []), ...(input.decisions || [])]),
         constraints: topItems([...(existing?.constraints || []), ...(input.constraints || [])]),
         pitfalls: topItems([...(existing?.pitfalls || []), ...(input.pitfalls || [])]),
         relatedRules: topItems([...(existing?.relatedRules || []), ...(input.relatedRules || [])], 12),
-        tickets: [
-            ...(existing?.tickets || []),
-            ...((input.tickets || []).filter((ticket) => ticket.summary.trim().length > 0)),
-        ].filter((ticket, index, array) => array.findIndex((item) => item.ticket === ticket.ticket
-            && item.branch === ticket.branch
-            && item.summary === ticket.summary) === index),
+        tickets: mergeTicketReferences(existing?.tickets || [], (input.tickets || []).filter((ticket) => ticket.summary.trim().length > 0)),
+        changes: mergeChangeEntries(existing?.changes || [], nextChanges),
         updatedAt: new Date().toISOString(),
     };
     saveModuleMemory(projectRoot, record);
@@ -643,10 +1025,10 @@ export function searchModuleMemories(projectRoot, query, pathHints = []) {
     const tokens = splitQueryTokens(normalizedQuery);
     const hints = pathHints.map((hint) => hint.toLowerCase());
     let index = loadMemoryIndex(projectRoot);
-    if (index.modules.length === 0 && fileExists(moduleMemoriesDir(projectRoot))) {
+    if (index.items.length === 0 && fileExists(moduleMemoriesDir(projectRoot))) {
         index = rebuildMemoryIndexFromDisk(projectRoot);
     }
-    return index.modules
+    return index.items
         .map((entry) => {
         let score = 0;
         score += scoreText(normalizedQuery, tokens, entry.key) * 2;
@@ -686,7 +1068,19 @@ export function migrateLegacyMemories(projectRoot) {
         const requirementData = requirement
             ? readJson(resolve(branchPath, 'requirement.json'))
             : null;
-        const branchName = requirementData?.branch || safeBranch.replace(/-/g, '/');
+        const branchRunsFromFiles = runFiles
+            .map((path) => {
+            try {
+                return readJson(path);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((item) => item !== null);
+        const branchName = requirementData?.branch
+            || branchRunsFromFiles.find((run) => run.meta?.branch)?.meta?.branch
+            || safeBranch;
         const context = buildRunContextFromBranch(projectRoot, branchName);
         if (!context)
             continue;
@@ -695,24 +1089,22 @@ export function migrateLegacyMemories(projectRoot) {
         contextsWritten++;
         const runs = loadBranchRuns(projectRoot, branchName);
         const req = loadRequirement(projectRoot, branchName);
-        const moduleCandidates = req?.modules?.length
-            ? req.modules.map((module) => ({ name: module.name, description: module.description }))
-            : context.modules.map((name) => ({ name, description: '' }));
-        for (const candidate of moduleCandidates) {
-            if (!candidate.name.trim())
+        const moduleDescriptors = inferModuleDescriptors(req, runs);
+        for (const descriptor of moduleDescriptors) {
+            if (!descriptor.key.trim())
                 continue;
-            const moduleKey = normalizeModuleKey(candidate.name);
-            const relatedPaths = collectRelatedPaths(candidate.name, context, runs);
+            const relatedPaths = collectRelatedPaths(descriptor, context, runs);
             upsertModuleMemory(projectRoot, {
-                moduleKey,
-                title: candidate.name,
-                summary: candidate.description || context.summary,
-                keywords: [candidate.name, moduleKey, context.title],
+                moduleKey: descriptor.key,
+                title: descriptor.title,
+                summary: descriptor.description || context.summary,
+                keywords: [descriptor.title, descriptor.key, context.title],
                 entryFiles: relatedPaths.slice(0, 5),
                 relatedPaths,
                 decisions: context.decisions,
                 constraints: context.constraints,
                 pitfalls: context.risks,
+                changeTitle: context.title,
                 tickets: [{
                         ticket: context.ticket,
                         branch: branchName,
@@ -721,7 +1113,7 @@ export function migrateLegacyMemories(projectRoot) {
                     }],
             });
             moduleMemoriesWritten++;
-            modulesTouched.add(moduleKey);
+            modulesTouched.add(descriptor.key);
         }
     }
     buildMemoryViews(projectRoot);
@@ -742,18 +1134,19 @@ export function rebuildCurrentBranchMemory(projectRoot, branchName) {
     const req = loadRequirement(projectRoot, branchName);
     const runs = loadBranchRuns(projectRoot, branchName);
     const modules = [];
-    for (const moduleName of inferModules(req, runs)) {
-        const relatedPaths = collectRelatedPaths(moduleName, context, runs);
+    for (const descriptor of inferModuleDescriptors(req, runs)) {
+        const relatedPaths = collectRelatedPaths(descriptor, context, runs);
         modules.push(upsertModuleMemory(projectRoot, {
-            moduleKey: moduleName,
-            title: moduleName,
-            summary: req?.modules?.find((module) => module.name === moduleName)?.description || context.summary,
-            keywords: [moduleName, context.title],
+            moduleKey: descriptor.key,
+            title: descriptor.title,
+            summary: descriptor.description || context.summary,
+            keywords: [descriptor.title, descriptor.key, context.title],
             entryFiles: relatedPaths.slice(0, 5),
             relatedPaths,
             decisions: context.decisions,
             constraints: context.constraints,
             pitfalls: context.risks,
+            changeTitle: context.title,
             tickets: [{
                     ticket: context.ticket,
                     branch: branchName,