@yeaft/webchat-agent 1.0.349 → 1.0.351

package/yeaft/dream/runner.js

@@ -17,7 +17,7 @@
  *
  *   mergeByTarget()                    → per-target actions
  *   for each merged target:
- *       applyMergedTarget()            (snapshot + UPDATE/CREATE + atomic write)
+ *       applyMergedTarget()            (snapshot + canonical content UPDATE/CREATE)
  *
  *   bookkeep:
  *     for each processed session:
@@ -41,7 +41,7 @@
 import { existsSync } from 'fs';
 import { join } from 'path';
 
-import { listScopes, readSummary } from '../memory/store.js';
+import { listScopes, readContent, readSummary } from '../memory/store.js';
 import {
   DEFAULT_LIMITS,
 } from './limits.js';
@@ -51,6 +51,7 @@ import { triageGroupSegments } from './triage.js';
 import { mergeByTarget } from './merge.js';
 import { applyMergedTarget } from './apply.js';
 import { extractAndWriteMemorySegments } from './segment-extract.js';
+import { consolidateSessionTopics } from './topic-consolidation.js';
 import { tsForBackup, pruneOldSnapshots } from './snapshot.js';
 
 /**
@@ -64,7 +65,7 @@ import { tsForBackup, pruneOldSnapshots } from './snapshot.js';
  * @property {(sessionId: string, sinceMessageId: string|null) => Promise<Array<object>>} [loadSessionDiff]
  * @property {(sessionId: string, sinceMessageId: string|null) => Promise<Array<object>>} [loadGroupDiff] — legacy alias for loadSessionDiff
  * @property {(sessionId: string, beforeMessageId: string|null, count: number) => Promise<Array<object>>} loadOverlapPreamble
- * @property {() => Promise<Array<{path:string, summary:string}>>} [listTopicSummaries]
+ * @property {(sessionId:string) => Promise<Array<{path:string, summary:string}>>} [listTopicSummaries]
  * @property {(target: string) => Promise<Array<{path:string, summary:string}>>} [siblingTopicsFor]
  * @property {import('../memory/index-db.js').SegmentIndex|null} [segmentIndex] — optional derived FTS segment index to sync after segment writes
  * @property {(event: object) => void} [onProgress]
@@ -98,8 +99,8 @@ export async function runDream(opts) {
   const processedSessions = [];
 
   // 2. per-session: skip / segment / triage
-  // Topic summaries are resolved inside the per-session loop
-  // them inside the per-session loop instead of once up front.
+  // Topic summaries are resolved inside the per-session loop so every Session
+  // sees its complete current canonical catalog.
   const resolveTopicSummaries = async (sessionId) => {
     if (opts.listTopicSummaries) {
       return await safeCall(() => opts.listTopicSummaries(sessionId), []);
@@ -128,7 +129,25 @@ export async function runDream(opts) {
       && beforeCount > 0;
 
     if (newCount === 0 && !rerunScopedManual) {
-      sessionsReport.push({ sessionId, new: 0, status: 'skipped', reason: 'no-new-messages' });
+      const topics = await resolveTopicSummaries(sessionId);
+      if (opts.manual && topics.length >= 2) {
+        try {
+          const result = await consolidateSessionTopics({
+            root: opts.root,
+            sessionId,
+            topics,
+            llm: dreamLlmForSession(opts.llm, sessionId),
+            language: opts.language,
+            ts,
+            segmentIndex: opts.segmentIndex || null,
+          });
+          sessionsReport.push({ sessionId, new: 0, status: 'consolidated', ...result });
+        } catch (err) {
+          sessionsReport.push({ sessionId, new: 0, status: 'error', phase: 'topic-consolidation', error: err.message });
+        }
+      } else {
+        sessionsReport.push({ sessionId, new: 0, status: 'skipped', reason: 'no-new-messages' });
+      }
       continue;
     }
     if (!opts.manual && newCount < limits.MIN_NEW_PER_GROUP) {
@@ -163,6 +182,7 @@ export async function runDream(opts) {
     try {
       const topicSummaries = await resolveTopicSummaries(sessionId);
       actions = await triageGroupSegments({
+        root: opts.root,
         sessionId,
         segments,
         topicSummaries,
@@ -213,6 +233,7 @@ export async function runDream(opts) {
         nowIso: opts.nowIso || (() => nowIso),
         onProgress,
         siblingTopicsFor: opts.siblingTopicsFor,
+        segmentIndex: opts.segmentIndex || null,
         language: opts.language,
       });
       await clearDreamError(opts.root, merged.target);
@@ -238,9 +259,10 @@ export async function runDream(opts) {
     }
   }
 
-  // 5. extract atomic H2 memory segments. The apply step above keeps the
-  // coarse summary layer (`summary.md`); this step keeps bounded, evidence-
-  // backed current details in segment-formatted `memory.md`.
+  // 5. Extract atomic H2 evidence segments. Apply owns canonical `content.md`
+  // plus the short catalog `summary.md`; this step owns only provenance-backed
+  // segment records in `memory.md`, so the two writers never overwrite each
+  // other's representation.
   const segmentReports = [];
   for (const triage of sessionTriages) {
     const appliedTargets = new Set(targetsReport.filter(r => r.status === 'done').map(r => r.target));
@@ -272,7 +294,37 @@ export async function runDream(opts) {
     }
   }
 
-  // 6. bookkeep — only when at least one apply for this session's actions
+  // 6. Consolidate the complete topic catalog after new content and evidence
+  // have landed. This is the only stage allowed to retire duplicate scopes.
+  const topicConsolidation = [];
+  const consolidatedSessionIds = [...new Set(sessionTriages.map(triage => triage.sessionId))];
+  for (const sessionId of consolidatedSessionIds) {
+    try {
+      const topics = await resolveTopicSummaries(sessionId);
+      onProgress({ phase: 'topic-consolidation', sessionId, status: 'running', topics: topics.length });
+      const result = await consolidateSessionTopics({
+        root: opts.root,
+        sessionId,
+        topics,
+        llm: dreamLlmForSession(opts.llm, sessionId),
+        language: opts.language,
+        ts,
+        segmentIndex: opts.segmentIndex || null,
+      });
+      topicConsolidation.push({ sessionId, status: 'done', ...result });
+      onProgress({ phase: 'topic-consolidation', sessionId, status: 'done', ...result });
+    } catch (err) {
+      topicConsolidation.push({ sessionId, status: 'error', error: err.message });
+      onProgress({ phase: 'topic-consolidation', sessionId, status: 'error', error: err.message });
+      await writeDreamError(opts.root, `sessions/${sessionId}`, {
+        phase: 'topic-consolidation',
+        message: err.message,
+        stack: err.stack,
+      });
+    }
+  }
+
+  // 7. bookkeep — only when at least one apply for this session's actions
   // succeeded. We use a permissive policy: if ANY merged-target apply
   // succeeded for a session's contributed actions, advance that session's
   // cursor. (If everything errored, we keep the cursor so next run
@@ -292,7 +344,7 @@ export async function runDream(opts) {
     }
   }
 
-  // 6. prune backups
+  // 8. prune backups
   const pruned = await pruneOldSnapshots(opts.root, limits.DREAM_BACKUP_KEEP);
 
   const duration = Date.now() - startedAt;
@@ -311,6 +363,7 @@ export async function runDream(opts) {
     sessions: sessionsReport,
     targets: targetsReport,
     memorySegments: segmentReports,
+    topicConsolidation,
     backups: pruned,
     ts,
   };
@@ -360,10 +413,13 @@ async function defaultListTopicSummaries(root, sessionId, language) {
   const all = await listScopes({ root });
   const out = [];
   for (const sc of all) {
-    if (sc.kind !== 'group-topic') continue;
+    if (sc.kind !== 'session-topic') continue;
     if (sc.sessionId !== sessionId) continue;
     const summary = await readSummary(sc, { root, language });
-    out.push({ path: sc.path.join('/'), summary });
+    const content = summary ? '' : await readContent(sc, { root });
+    const catalogText = String(summary || content || '').trim();
+    if (!catalogText) continue;
+    out.push({ path: sc.path.join('/'), summary: catalogText });
   }
   return out;
 }

package/yeaft/dream/segment-extract.js

@@ -1,9 +1,9 @@
 /**
  * dream/segment-extract.js.
  *
- * Minimal H2 Dream bridge: extract atomic memory segments for the session
- * scopes touched by a Dream pass and persist them through memory/segment-store.
- * The existing apply path still maintains summary.md as the coarse layer.
+ * Extract atomic evidence segments for scopes touched by a Dream pass and
+ * persist them through memory/segment-store. Dream Apply separately maintains
+ * canonical content.md and the short catalog summary.md.
  */
 
 import { readScope, writeScope } from '../memory/segment-store.js';
@@ -12,7 +12,6 @@ import { makeSegment } from '../memory/segment.js';
 import { render, extractTemplateForScope } from './prompts/index.js';
 import { parseJsonSafe } from './triage.js';
 
-const MAX_TARGETS = 24;
 const MAX_MESSAGES = 80;
 const MAX_BODY_CHARS = 1200;
 const MAX_SEGMENTS_PER_SCOPE = 64;
@@ -50,6 +49,7 @@ export async function extractAndWriteMemorySegments(opts) {
 
   const messages = normalizeMessages(opts.messages || []);
   if (messages.length === 0) return { scopes: 0, segments: 0, errors: [] };
+  const allowedSourceIds = new Set(messages.map(message => message.id));
 
   const targetScopes = normalizeTargetScopes(opts.sessionId, opts.targets || []);
   const now = opts.nowIso ? opts.nowIso() : new Date().toISOString();
@@ -57,7 +57,7 @@ export async function extractAndWriteMemorySegments(opts) {
   let scopeCount = 0;
   const errors = [];
 
-  for (const scope of targetScopes.slice(0, MAX_TARGETS)) {
+  for (const scope of targetScopes) {
     let extracted = [];
     try {
       extracted = await extractScopeSegments({
@@ -67,6 +67,7 @@ export async function extractAndWriteMemorySegments(opts) {
         llm: opts.llm,
         language: opts.language,
         now,
+        allowedSourceIds,
       });
     } catch (err) {
       errors.push({ scope, error: err.message, rawSnippet: err.rawSnippet || '' });
@@ -90,7 +91,7 @@ export async function extractAndWriteMemorySegments(opts) {
   return { scopes: scopeCount, segments: segmentCount, errors };
 }
 
-async function extractScopeSegments({ scope, sessionId, messages, llm, language, now }) {
+async function extractScopeSegments({ scope, sessionId, messages, llm, language, now, allowedSourceIds }) {
   const template = extractTemplateForScope(scope);
   const base = render(template, templateVarsForScope(scope, sessionId), { language });
   const prompt = `${base}\n\nTarget scope: ${scope}\n\nConversation diff, oldest first:\n${renderMessages(messages)}\n\nReturn only the JSON array. Do not wrap it in Markdown.`;
@@ -98,7 +99,7 @@ async function extractScopeSegments({ scope, sessionId, messages, llm, language,
   const firstParsed = parseJsonSafe(firstRaw);
   if (Array.isArray(firstParsed)) {
     return firstParsed
-      .map(item => normalizeExtractedSegment({ item, scope, now }))
+      .map(item => normalizeExtractedSegment({ item, scope, now, allowedSourceIds }))
       .filter(Boolean);
   }
 
@@ -112,7 +113,7 @@ async function extractScopeSegments({ scope, sessionId, messages, llm, language,
   }
 
   return retryParsed
-    .map(item => normalizeExtractedSegment({ item, scope, now }))
+    .map(item => normalizeExtractedSegment({ item, scope, now, allowedSourceIds }))
     .filter(Boolean);
 }
 
@@ -142,14 +143,14 @@ function normalizeMessages(messages) {
   return messages
     .filter(m => m && typeof m === 'object')
     .slice(-MAX_MESSAGES)
-    .map((m, index) => ({
-      id: String(m.id || m.messageId || `dream_msg_${index}`),
+    .map(m => ({
+      id: String(m.id || m.messageId || '').trim(),
       role: String(m.role || m.type || 'unknown'),
       vpId: typeof m.vpId === 'string' ? m.vpId : '',
       body: String(m.body || m.content || '').slice(0, MAX_BODY_CHARS),
       kind: String(m.kind || ''),
     }))
-    .filter(m => m.body.trim());
+    .filter(m => m.id && m.body.trim());
 }
 
 function renderMessages(messages) {
@@ -162,13 +163,15 @@ function renderMessages(messages) {
   })), null, 2);
 }
 
-function normalizeExtractedSegment({ item, scope, now }) {
+function normalizeExtractedSegment({ item, scope, now, allowedSourceIds }) {
   if (!item || typeof item !== 'object') return null;
   const body = String(item.body || item.content || item.summary || '').trim();
   if (!body) return null;
   const kind = VALID_KINDS.has(String(item.kind || '')) ? String(item.kind) : 'context';
   const tags = Array.isArray(item.tags) ? item.tags.map(t => String(t).trim()).filter(Boolean) : [];
-  const sourceMessages = normalizeSourceMessageIds(item.sourceMessages);
+  const sourceMessages = [...new Set(normalizeSourceMessageIds(item.sourceMessages))];
+  if (sourceMessages.length === 0) return null;
+  if (sourceMessages.some(id => !allowedSourceIds.has(id))) return null;
   return makeSegment({
     scope,
     kind,

package/yeaft/dream/session-wiring.js

@@ -32,8 +32,8 @@
  *                        targets, error, skipped, skippedReason } }
  *   dream_progress:    runner-emitted phase events (`start`/`load-diff`/`triage`/
  *                      `merge`/`apply`/`done`). The `apply/done` variant carries
- *                      `kind, memoryMdPreview, summaryMdPreview, memoryMdLength,
- *                      summaryMdLength` (see apply.js).
+ *                      `kind, contentMdPreview, summaryMdPreview, contentMdLength,
+ *                      summaryMdLength` plus legacy memoryMd* debug aliases (see apply.js).
  *
  * `sessionId` may be inherited via `stampDreamScope()` when a scope is active.
  */

package/yeaft/dream/snapshot.js

@@ -1,7 +1,7 @@
 /**
  * dream/snapshot.js.
  *
- * Pre-Apply backup of memory.md + summary.md to
+ * Pre-Apply backup of content.md + memory.md + summary.md to
  * `~/.yeaft/memory/.dream-bak/<ts>/<scope-path>/`. The runner takes a
  * snapshot once per merged target before Apply mutates it; that snapshot
  * is the unit of rollback in case of LLM error or write failure.
@@ -29,7 +29,7 @@ export function tsForBackup(d = new Date()) {
 }
 
 /**
- * Snapshot a single scope's memory.md + summary.md into
+ * Snapshot a single scope's content.md + memory.md + summary.md into
  * `<root>/.dream-bak/<ts>/<scopeRelDir>/`. Missing source files are
  * skipped silently; the destination dir is always created so that an
  * absent snapshot is still distinguishable from "didn't run".
@@ -45,7 +45,7 @@ export async function snapshotScope(root, ts, scopeRelDir) {
   const dstDir = join(root, BACKUP_DIRNAME, ts, scopeRelDir);
   await fsp.mkdir(dstDir, { recursive: true });
   const copied = [];
-  for (const name of ['memory.md', 'summary.md']) {
+  for (const name of ['content.md', 'memory.md', 'summary.md', 'summary.zh.md']) {
     const s = join(srcDir, name);
     if (!existsSync(s)) continue;
     const d = join(dstDir, name);

package/yeaft/dream/topic-consolidation.js

@@ -0,0 +1,316 @@
+import {
+  existsSync,
+  mkdirSync,
+  renameSync,
+  rmdirSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { dirname, join } from 'node:path';
+
+import { readContent, readMemory, readSummary } from '../memory/store.js';
+import { readScope, writeScope } from '../memory/segment-store.js';
+import { computeSegmentId } from '../memory/segment.js';
+import { syncScope } from '../memory/segment-sync.js';
+import {
+  normalizeTopicPath,
+  resolveTopicRedirect,
+  TOPIC_REDIRECT_FILE,
+} from '../memory/topic-redirect.js';
+import { render } from './prompts/index.js';
+import { parseJsonSafe } from './triage.js';
+import { snapshotScope } from './snapshot.js';
+
+const MAX_TOPICS_PER_BATCH = 240;
+const MAX_CONSOLIDATION_GROUPS_PER_SESSION = 12;
+
+function topicConsolidationSystem(language) {
+  return String(language || '').toLowerCase().startsWith('zh')
+    ? '你是 Dream 记忆主题整理阶段。只回复严格 JSON，不要输出说明文字或 markdown fence。'
+    : 'You are the Dream memory topic-consolidation stage. Reply with strict JSON only, without prose or markdown fences.';
+}
+
+export async function consolidateSessionTopics(opts) {
+  if (!opts?.root || !opts?.sessionId || typeof opts.llm !== 'function') {
+    throw new Error('consolidateSessionTopics: root, sessionId, and llm are required');
+  }
+  const topics = normalizeTopics(normalizeTopics(opts.topics).map(topic => ({
+    ...topic,
+    path: resolveTopicRedirect(opts.root, opts.sessionId, topic.path),
+  })).filter(topic => topic.path));
+  if (topics.length < 2) {
+    return { considered: topics.length, checked: topics.length, merged: 0, groups: [] };
+  }
+
+  const groups = [];
+  const batchStep = topics.length <= MAX_TOPICS_PER_BATCH
+    ? MAX_TOPICS_PER_BATCH
+    : MAX_TOPICS_PER_BATCH - Math.min(40, MAX_TOPICS_PER_BATCH - 1);
+  for (let start = 0; start < topics.length; start += batchStep) {
+    const batch = topics.length <= MAX_TOPICS_PER_BATCH
+      ? topics
+      : buildOverlappingBatch(topics, start, MAX_TOPICS_PER_BATCH);
+    if (batch.length < 2) continue;
+    const parsed = parseJsonSafe(await opts.llm({
+      pass: 'topic-consolidation',
+      system: topicConsolidationSystem(opts.language),
+      prompt: render('consolidateTopics', {
+        topics: batch.map(topic => `- ${topic.path}: ${topic.summary}`).join('\n'),
+      }, { language: opts.language }),
+    }));
+    if (!Array.isArray(parsed?.groups)) continue;
+    groups.push(...validateGroups(parsed.groups, topics));
+  }
+
+  const applied = [];
+  for (const group of nonOverlappingGroups(groups).slice(0, MAX_CONSOLIDATION_GROUPS_PER_SESSION)) {
+    const result = await applyConsolidationGroup(group, opts);
+    if (result) applied.push(result);
+  }
+  return {
+    considered: topics.length,
+    checked: topics.length,
+    merged: applied.reduce((count, group) => count + group.merged.length, 0),
+    groups: applied,
+  };
+}
+
+function normalizeTopics(topics) {
+  const byPath = new Map();
+  for (const topic of Array.isArray(topics) ? topics : []) {
+    const path = normalizeTopicPath(topic?.path);
+    if (!path || byPath.has(path)) continue;
+    byPath.set(path, { path, summary: String(topic?.summary || '').trim() });
+  }
+  return [...byPath.values()].sort((a, b) => a.path.localeCompare(b.path));
+}
+
+function buildOverlappingBatch(topics, start, limit) {
+  const batch = topics.slice(start, start + limit);
+  if (start === 0 || batch.length >= limit) return batch;
+  const overlap = Math.min(40, start, limit - batch.length);
+  return [...topics.slice(start - overlap, start), ...batch];
+}
+
+function validateGroups(groups, topics) {
+  const known = new Set(topics.map(topic => topic.path));
+  const out = [];
+  for (const group of groups) {
+    const canonical = normalizeTopicPath(group?.canonical);
+    const members = [...new Set([
+      canonical,
+      ...(Array.isArray(group?.merge) ? group.merge.map(normalizeTopicPath) : []),
+    ].filter(path => known.has(path)))];
+    if (!known.has(canonical) || members.length < 2) continue;
+    out.push({ canonical, merge: members.filter(path => path !== canonical) });
+  }
+  return out;
+}
+
+function nonOverlappingGroups(groups) {
+  const claimed = new Set();
+  const out = [];
+  for (const group of groups) {
+    const members = [group.canonical, ...group.merge];
+    if (members.some(path => claimed.has(path))) continue;
+    members.forEach(path => claimed.add(path));
+    out.push(group);
+  }
+  return out;
+}
+
+async function applyConsolidationGroup(group, opts) {
+  const records = await Promise.all([group.canonical, ...group.merge].map(path => readTopicRecord(path, opts)));
+  const available = records.filter(record => record.content || record.summary || record.memory);
+  if (available.length < 2) return null;
+
+  const canonical = records[0];
+  const raw = await opts.llm({
+    pass: 'topic-merge',
+    system: topicConsolidationSystem(opts.language),
+    prompt: render('mergeTopics', {
+      canonical: canonical.path,
+      topicContents: available.map(record => [
+        `## ${record.path}`,
+        record.content || record.memory || record.summary,
+      ].join('\n')).join('\n\n'),
+    }, { language: opts.language }),
+  });
+  const parsed = parseJsonSafe(raw);
+  const mergedContent = String(parsed?.content_md || '').trim();
+  const mergedSummary = String(parsed?.summary_md || '').trim();
+  if (!mergedContent) return null;
+
+  for (const record of available) await snapshotScope(opts.root, opts.ts, record.scope);
+  const mergedSegments = dedupeSegments(
+    available.flatMap(record => record.segments),
+    canonical.scope,
+  );
+  const transaction = stageConsolidationTransaction({
+    root: opts.root,
+    sessionId: opts.sessionId,
+    canonical: canonical.path,
+    mergedContent,
+    mergedSummary,
+    mergedSegments,
+    duplicates: available.slice(1).map(record => record.path),
+    ts: opts.ts,
+    fileOps: opts.fileOps,
+  });
+
+  try {
+    transaction.activate();
+    if (opts.segmentIndex) {
+      syncScope(opts.root, opts.segmentIndex, canonical.scope);
+      for (const record of available.slice(1)) {
+        opts.segmentIndex.deleteScope(record.scope);
+        syncScope(opts.root, opts.segmentIndex, record.scope);
+      }
+    }
+    transaction.commit();
+    removeEmptyDirectory(join(opts.root, '.topic-consolidation'));
+  } catch (error) {
+    try {
+      transaction.rollback();
+      removeEmptyDirectory(join(opts.root, '.topic-consolidation'));
+    } catch (rollbackError) {
+      error.rollbackError = rollbackError;
+    }
+    if (opts.segmentIndex) {
+      for (const record of available) {
+        try { syncScope(opts.root, opts.segmentIndex, record.scope); } catch { /* best effort */ }
+      }
+    }
+    throw error;
+  }
+
+  return { canonical: canonical.path, merged: available.slice(1).map(record => record.path) };
+}
+
+async function readTopicRecord(path, opts) {
+  const scopeObject = { kind: 'session-topic', sessionId: opts.sessionId, path: path.split('/') };
+  const scope = `sessions/${opts.sessionId}/topic/${path}`;
+  return {
+    path,
+    scope,
+    content: await readContent(scopeObject, { root: opts.root }),
+    memory: await readMemory(scopeObject, { root: opts.root }),
+    summary: await readSummary(scopeObject, { root: opts.root, language: opts.language }),
+    segments: readScope(opts.root, scope),
+  };
+}
+
+function dedupeSegments(segments, canonicalScope) {
+  const out = new Map();
+  for (const segment of segments) {
+    if (!segment?.id || !segment?.body) continue;
+    const key = `${segment.kind || 'context'}\u0000${segment.body.trim().toLowerCase()}`;
+    const current = out.get(key);
+    const sourceMessages = [...new Set([
+      ...(current?.sourceMessages || []),
+      ...(segment.sourceMessages || []),
+    ].map(String).filter(Boolean))];
+    out.set(key, { ...(current || segment), scope: canonicalScope, sourceMessages });
+  }
+  return [...out.values()].map(segment => ({
+    ...segment,
+    id: computeSegmentId({
+      scope: canonicalScope,
+      kind: segment.kind || 'context',
+      body: segment.body,
+    }),
+  }));
+}
+
+function stageConsolidationTransaction({ root, sessionId, canonical, mergedContent, mergedSummary, mergedSegments, duplicates, ts, fileOps }) {
+  const topicRoot = join(root, 'sessions', sessionId, 'topic');
+  const nonce = `${String(ts || Date.now()).replace(/[^a-zA-Z0-9_-]/g, '-')}-${Math.random().toString(36).slice(2, 10)}`;
+  const transactionRoot = join(root, '.topic-consolidation', nonce);
+  const stagedRoot = join(transactionRoot, 'staged');
+  const backupRoot = join(transactionRoot, 'backup');
+  const operations = [];
+
+  stageFile(join(stagedRoot, canonical, 'content.md'), `${mergedContent}\n`);
+  stageFile(join(stagedRoot, canonical, 'summary.md'), `${mergedSummary}\n`);
+  writeScope(stagedRoot, canonical, mergedSegments);
+  operations.push({ scope: canonical, file: 'content.md', desired: join(stagedRoot, canonical, 'content.md') });
+  operations.push({ scope: canonical, file: 'summary.md', desired: join(stagedRoot, canonical, 'summary.md') });
+  operations.push({ scope: canonical, file: 'memory.md', desired: join(stagedRoot, canonical, 'memory.md') });
+  operations.push({ scope: canonical, file: TOPIC_REDIRECT_FILE, desired: null });
+
+  for (const duplicate of duplicates) {
+    const redirectPath = join(stagedRoot, duplicate, TOPIC_REDIRECT_FILE);
+    stageFile(redirectPath, `${JSON.stringify({ version: 1, canonical }, null, 2)}\n`);
+    operations.push({ scope: duplicate, file: 'content.md', desired: null });
+    operations.push({ scope: duplicate, file: 'summary.md', desired: null });
+    operations.push({ scope: duplicate, file: 'memory.md', desired: null });
+    operations.push({ scope: duplicate, file: TOPIC_REDIRECT_FILE, desired: redirectPath });
+  }
+
+  const renameFile = typeof fileOps?.renameSync === 'function'
+    ? fileOps.renameSync
+    : renameSync;
+  const applied = [];
+  let closed = false;
+  return {
+    activate() {
+      for (const operation of operations) {
+        const live = join(topicRoot, operation.scope, operation.file);
+        const backup = join(backupRoot, operation.scope, operation.file);
+        const state = {
+          ...operation,
+          live,
+          backup,
+          hadLive: existsSync(live),
+          liveMoved: false,
+          desiredActivated: false,
+        };
+        // Register before the first live mutation. If staged activation fails
+        // after live moved to backup, rollback still owns this operation.
+        applied.push(state);
+        if (state.hadLive) {
+          mkdirSync(dirname(backup), { recursive: true });
+          renameFile(live, backup);
+          state.liveMoved = true;
+        }
+        if (operation.desired) {
+          mkdirSync(dirname(live), { recursive: true });
+          renameFile(operation.desired, live);
+          state.desiredActivated = true;
+        }
+      }
+    },
+    commit() {
+      if (closed) return;
+      closed = true;
+      rmSync(transactionRoot, { recursive: true, force: true });
+    },
+    rollback() {
+      if (closed) return;
+      let firstError = null;
+      for (const operation of applied.slice().reverse()) {
+        try {
+          if (operation.desiredActivated) rmSync(operation.live, { force: true });
+          if (operation.liveMoved && existsSync(operation.backup)) {
+            mkdirSync(dirname(operation.live), { recursive: true });
+            renameFile(operation.backup, operation.live);
+          }
+        } catch (error) {
+          if (!firstError) firstError = error;
+        }
+      }
+      if (firstError) throw firstError;
+      rmSync(transactionRoot, { recursive: true, force: true });
+      closed = true;
+    },
+  };
+}
+
+function removeEmptyDirectory(path) {
+  try { rmdirSync(path); } catch { /* absent or not empty */ }
+}
+
+function stageFile(path, content) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, content, 'utf8');
+}

package/yeaft/dream/triage.js

@@ -38,6 +38,7 @@ import { isValidTopic } from '../memory/store.js';
 
 import { truncateMessage } from './segment.js';
 import { render } from './prompts/index.js';
+import { resolveTopicRedirect } from '../memory/topic-redirect.js';
 
 function triageSystem(language) {
   return String(language || '').toLowerCase().startsWith('zh')
@@ -182,7 +183,10 @@ export async function classifySoft({ sessionId, messages, topicSummaries, llm, l
     const segs = path.split('/').filter(Boolean);
     if (!sessionId || sessionId === '_no-session') continue;
     if (!isValidTopic({ kind: 'session-topic', sessionId, path: segs })) continue;
-    const scope = `sessions/${sessionId}/topic/${segs.join('/')}`;
+    const redirected = args.root
+      ? resolveTopicRedirect(args.root, sessionId, segs.join('/'))
+      : segs.join('/');
+    const scope = `sessions/${sessionId}/topic/${redirected}`;
     if (pass2.decision === 'match') {
       out.push({ kind: 'update', scope });
     } else if (pass2.decision === 'new') {
@@ -223,13 +227,14 @@ export async function triageOneSegment(args) {
  * }} args
  * @returns {Promise<Array<{ kind: 'update'|'create', scope: string }>>}
  */
-export async function triageGroupSegments({ sessionId, segments, topicSummaries, llm, onProgress, language }) {
+export async function triageGroupSegments({ root, sessionId, segments, topicSummaries, llm, onProgress, language }) {
   let acc = [];
   let i = 0;
   for (const seg of (segments || [])) {
     i += 1;
     if (onProgress) onProgress({ phase: 'triage', sessionId, segment: i, total: segments.length });
     const segActions = await triageOneSegment({
+      root,
       sessionId,
       messages: seg.messages,
       topicSummaries,