minimal-agent 0.18.13 → 0.18.14

package/src/memory/memoryService.ts

@@ -15,6 +15,7 @@ import {
 import {
   clearGlobalProjectKnowledge,
   clearProjectKnowledge,
+  isLiveKnowledgeCandidate,
   PROJECT_KNOWLEDGE_CONTEXT_HEADER,
   projectKnowledgeEntry,
   projectKnowledgeStatus,
@@ -69,10 +70,13 @@ import {
 } from './repository.js';
 import {
   isReviewDue,
+  isUnconfirmed,
   memoryTerms,
   recallFromSnapshot,
+  takeTokenBudget,
   truncateTokenBudget,
 } from './retrieval.js';
+import { recallQueryFor } from './recallQuery.js';
 import type {
   ConversationSearchOptions,
   MemoryContextBundle,
@@ -397,6 +401,25 @@ function refreshTopicViewAfterMutation(
   void refreshTopicView(scope, workspaceId).catch(() => undefined);
 }
 
+/**
+ * Candidates live per workspace, so callers pass the workspace whose candidate
+ * file they can reach (a personal record's candidates may sit anywhere; the
+ * prompt-side liveness rule covers the rest). The update itself already
+ * succeeded: a settle failure is reported, never turned into a failed update.
+ */
+export async function settleCandidatesAfterUpdate(
+  workspaceId: string,
+  updated: VersionedMemoryRecord,
+): Promise<void> {
+  await (await import('./factCandidates.js'))
+    .settleFactCandidatesFor(workspaceId, updated.record, updated.version)
+    .catch((error) =>
+      process.stderr.write(
+        `[minimal-agent memory] 记忆已更新，但关联候选暂未结清：${(error as Error).message}\n`,
+      ),
+    );
+}
+
 function sameTopic(
   a: MemoryRecordV2,
   b: Pick<MemoryRecord, 'category' | 'subject'> & {
@@ -551,6 +574,8 @@ export const memoryService = {
   ): Promise<MemoryRecordV2> {
     validateMemoryInput(input);
     await ensureMemoryMigrated();
+    // Set when the user said the same thing again; see the refresh below.
+    let restated: MemoryRecordV2 | undefined;
     const commit = () =>
       withFactBarriers(input.scope, input.workspaceId, async (barriers) => {
         automatic?.signal?.throwIfAborted();
@@ -582,6 +607,8 @@ export const memoryService = {
               record: duplicate,
               result: 'ok',
             });
+            // A queued turn older than the last confirmation confirms nothing new.
+            if (!automatic || automatic.startedAt > duplicate.lastConfirmedAt) restated = duplicate;
             return duplicate;
           }
           if (duplicate) {
@@ -614,7 +641,7 @@ export const memoryService = {
           await release();
         }
       });
-    return enqueueMemoryMutation(() =>
+    const stored = await enqueueMemoryMutation(() =>
       automatic && input.scope === 'personal'
         ? withFactBarriers(
             'workspace',
@@ -627,6 +654,32 @@ export const memoryService = {
           )
         : commit(),
     );
+    if (!restated) return stored;
+    // Saying the same thing again is a fresh confirmation. Returning the old
+    // record untouched left `lastConfirmedAt` at the first mention, so a fact
+    // the user kept repeating still aged into "待复核" on the first date's clock.
+    // Done after the queue/lock are released: the update takes them itself.
+    try {
+      const current = await this.readWithVersion(restated.id, restated.scope, restated.workspaceId);
+      if (!current) return stored;
+      const refreshed = await this.updateWithVersion(
+        restated.id,
+        restated.scope,
+        current.version,
+        {
+          evidence: input.evidence,
+          evidenceQuote: input.evidenceQuote,
+          sourceSessionId: input.sourceSessionId,
+          sourceMessageId: input.sourceMessageId,
+          status: 'active',
+        },
+        restated.workspaceId,
+      );
+      return refreshed?.record ?? stored;
+    } catch {
+      // Losing the refresh to a concurrent edit is harmless; the record is intact.
+      return stored;
+    }
   },
 
   async updateWithVersion(
@@ -748,7 +801,7 @@ export const memoryService = {
         throw error;
       }
     };
-    return enqueueMemoryMutation(() =>
+    const updated = await enqueueMemoryMutation(() =>
       candidate
         ? withFactBarriers(
             'workspace',
@@ -762,6 +815,10 @@ export const memoryService = {
           )
         : commit(),
     );
+    const candidatesWorkspace = workspaceId ?? candidate?.sourceWorkspaceId;
+    if (updated && candidatesWorkspace)
+      await settleCandidatesAfterUpdate(candidatesWorkspace, updated);
+    return updated;
   },
 
   async update(
@@ -1011,7 +1068,13 @@ export const memoryService = {
   async buildContextBundle(
     input: string,
     workspaceId?: string,
-    options: { includePersona?: boolean; budgetTokens?: number } = {},
+    options: {
+      includePersona?: boolean;
+      budgetTokens?: number;
+      /** The user's previous request: "继续/为什么" alone names no topic, so a
+       * pure follow-up is recalled against the request it continues. */
+      previousInput?: string;
+    } = {},
   ): Promise<MemoryContextBundle> {
     // Every cap below used to be a flat constant that ignored the model's
     // context window — the same bug class as the old flat transient budget one
@@ -1033,6 +1096,8 @@ export const memoryService = {
     const count = (base: number) => Math.max(base, Math.round(base * scale));
     const snapshot = await combinedSnapshot(workspaceId);
     const settings = await this.settings();
+    // Only retrieval widens; `input` still decides what the user is correcting.
+    const query = recallQueryFor(input, options.previousInput);
     const persona =
       options.includePersona === false
         ? null
@@ -1051,49 +1116,61 @@ export const memoryService = {
           Number(b.scope === 'workspace') - Number(a.scope === 'workspace') ||
           b.lastConfirmedAt - a.lastConfirmedAt,
       );
-    const relevant = recallFromSnapshot(snapshot, input, settings, count(12))
+    // "Who the user is" is a handful of high-value records that no query
+    // word would ever match ("帮我润色文案" never says 后端工程师), so like
+    // preferences they are injected wholesale rather than by lexical hit.
+    const profile = snapshot.records
+      .filter(
+        (record) =>
+          record.category === 'profile' &&
+          record.sensitivity === 'normal' &&
+          record.status !== 'superseded' &&
+          (!record.validUntil || record.validUntil > Date.now()) &&
+          !currentInputOverrides(record, input),
+      )
+      .sort((a, b) => b.lastConfirmedAt - a.lastConfirmedAt);
+    const relevant = recallFromSnapshot(snapshot, query, settings, count(12))
       .filter(
         (record) =>
           record.sensitivity === 'normal' &&
           record.category !== 'preference' &&
+          record.category !== 'profile' &&
           !currentInputOverrides(record, input),
       )
       .slice(0, count(5));
     const reviewCount = snapshot.records.filter(
       (record) =>
-        record.status !== 'superseded' && isReviewDue(record, settings),
+        record.status !== 'superseded' && isUnconfirmed(record, settings),
     ).length;
     const sections: string[] = [];
     const contextSections: MemoryContextBundle['sections'] = [];
     const includedIds: string[] = [];
     let conflictWarning: string | undefined;
+    const candidateModule = await import('./factCandidates.js');
+    // Settled (corrected or forgotten) candidates are dropped here, before they
+    // can flag the current record as unconfirmed or bring old text back.
+    const statements = new Map(
+      snapshot.records.map((record) => [record.id, record.statement]),
+    );
     const conflicts = workspaceId
-      ? await (await import('./factCandidates.js'))
-          .factCandidates(workspaceId)
-          .catch((error) => {
+      ? (
+          await candidateModule.factCandidates(workspaceId).catch((error) => {
             conflictWarning = `【记忆健康提示】冲突候选暂不可读：${(error as Error).message.slice(0, 300)}`;
             return [];
           })
+        ).filter((item) => candidateModule.isLiveFactCandidate(item, statements))
       : [];
-    const pendingIds = new Set(
-      conflicts
-        .filter((item) => item.status === 'open')
-        .map((item) => item.old?.id),
-    );
-    const queryTerms = memoryTerms(input);
+    const pendingIds = new Set(conflicts.map((item) => item.old?.id));
+    const queryTerms = memoryTerms(query);
     // Evaluated after records are injected: a candidate whose old record is in
     // this prompt must travel with it. Otherwise the model sees "旧值·待复核"
     // with no new value — the user said "以后改用 pnpm" and the only thing the
     // next turn learns is that npm might be stale. Preferences are injected
     // wholesale, so relying on query overlap alone dropped exactly those.
-    const liveRecordIds = new Set(snapshot.records.map((record) => record.id));
     const surfacedFactCandidates = () =>
       conflicts
         .filter(
           (item) =>
-            item.status === 'open' &&
-            // Orphaned by a forget: its old text must never come back.
-            (!item.old || liveRecordIds.has(item.old.id)) &&
             ((item.old && includedIds.includes(item.old.id)) ||
               queryTerms.some((term) =>
                 JSON.stringify([
@@ -1134,9 +1211,9 @@ export const memoryService = {
       );
     }
     const describe = (record: MemoryRecordV2) =>
-      `- ${record.scope}/${record.category}/${record.subject} [${pendingIds.has(record.id) || record.status === 'needs_review' || isReviewDue(record, settings) ? '待复核，不能当作当前已确认事实' : '已记录'}；确认 ${new Date(record.lastConfirmedAt).toISOString().slice(0, 10)}]: ${record.statement}`;
+      `- ${record.scope}/${record.category}/${record.subject} [${pendingIds.has(record.id) || isUnconfirmed(record, settings) ? '待复核，不能当作当前已确认事实' : '已记录'}；确认 ${new Date(record.lastConfirmedAt).toISOString().slice(0, 10)}]: ${record.statement}`;
     const addRecords = (
-      id: 'preferences' | 'relevant' | 'projectKnowledge' | 'experiences',
+      id: 'preferences' | 'profile' | 'relevant' | 'projectKnowledge' | 'experiences',
       header: string,
       entries: { id: string; text: string }[],
       sectionBudget: number,
@@ -1166,6 +1243,12 @@ export const memoryService = {
       preferences.map((record) => ({ id: record.id, text: describe(record) })),
       share(550),
     );
+    addRecords(
+      'profile',
+      '【用户画像｜稳定背景】只在与任务相关时使用，不要主动复述；当前消息优先。',
+      profile.map((record) => ({ id: record.id, text: describe(record) })),
+      share(400),
+    );
     addRecords(
       'relevant',
       '【相关本机记忆｜低优先级、可纠正】当前消息优先；来源见 RecallMemory。',
@@ -1176,7 +1259,7 @@ export const memoryService = {
       try {
         const knowledge = await recallProjectKnowledge(
           workspaceId,
-          input,
+          query,
           count(4),
         );
         // Header once via addRecords, not re-rendered per record: the old
@@ -1192,12 +1275,11 @@ export const memoryService = {
           })),
           share(800),
         );
-        const knowledgeCandidates = (
-          await projectKnowledgeStatus(workspaceId)
-        ).candidates
+        const knowledgeStatus = await projectKnowledgeStatus(workspaceId);
+        const knowledgeCandidates = knowledgeStatus.candidates
           .filter(
             (item) =>
-              item.status === 'open' &&
+              isLiveKnowledgeCandidate(item, knowledgeStatus.records) &&
               // Same rule as fact candidates: travels with its injected old record.
               (includedIds.includes(item.oldId) ||
                 queryTerms.some((term) =>
@@ -1215,7 +1297,7 @@ export const memoryService = {
         if (relevantFactCandidates.length || knowledgeCandidates.length)
           pushSection(
             'health',
-            `【相关知识变化待处理】旧值与新候选并存，候选不是现行事实。仅本轮用户明确纠正可直接作为本轮要求；历史未决候选不能自动替代旧值。影响当前任务时核对来源，无法确定再询问。\n${[
+            `【相关知识变化待处理】旧值与新候选并存，候选不是现行事实。仅本轮用户明确纠正可直接作为本轮要求；历史候选不会自动替代旧值。影响当前任务时向用户确认哪个有效，并按确认结果结清候选（改写记录后候选自动失效）；项目事实先用读取或测试核对。\n${[
               ...relevantFactCandidates.map(
                 (item) =>
                   `- fact candidate=${item.id}：旧=${item.old?.statement ?? '无'}；新=${item.proposed.statement}`,
@@ -1235,7 +1317,7 @@ export const memoryService = {
       try {
         const experiences = await recallExperiences(
           workspaceId,
-          input,
+          query,
           count(3),
         );
         addRecords(
@@ -1254,12 +1336,34 @@ export const memoryService = {
         );
       }
     }
+    // RecallMemory searches blind: the model cannot ask for what it does not
+    // know exists. A subject-only index of the records not injected above
+    // (no bodies, so it stays cheap) lets it decide what is worth reading.
+    const injected = new Set(includedIds);
+    const indexLines = snapshot.records
+      .filter(
+        (record) =>
+          !injected.has(record.id) &&
+          record.sensitivity === 'normal' &&
+          record.status !== 'superseded' &&
+          (!record.validUntil || record.validUntil > Date.now()),
+      )
+      .sort((a, b) => b.lastConfirmedAt - a.lastConfirmedAt)
+      .map((record) => `- ${record.scope}/${record.category}/${record.subject}`);
+    if (indexLines.length) {
+      const shown = takeTokenBudget(indexLines, share(400)).slice(0, count(60));
+      if (shown.length)
+        pushSection(
+          'index',
+          `【其它已存记忆索引｜仅主题，正文未载入】需要其中某条细节时用 RecallMemory 读取${shown.length < indexLines.length ? `（另有 ${indexLines.length - shown.length} 条未列出）` : ''}。\n${shown.join('\n')}`,
+        );
+    }
     const settingsWarning = settingsWarnings.get(settingsFilePath());
     if (workspaceId) {
       try {
         const facts = await (await import('./factLearning.js')).factLearningStatus(workspaceId);
         const experiences = await (await import('./experienceStore.js')).readExperienceStore(workspaceId);
-        const paused = [...facts.pending, ...experiences.pending].filter(turn => turn.failure?.paused).length;
+        const paused = [...facts.pending, ...experiences.pending].filter((await import('./jobPolicy.js')).isPausedJob).length;
         if (paused) pushSection('health', `【记忆健康提示】${paused} 条后台学习资料因重复失败已暂停自动重试，原资料仍保留；不得声称这些资料已完成长期保存。`);
       } catch {
         pushSection('health', '【记忆健康提示】后台学习状态暂不可读，不代表队列为空或已完成。');

package/src/memory/projectKnowledge.js

@@ -75,6 +75,19 @@ const storeSchema = z.object({
     records: z.array(recordSchema),
     candidates: z.array(candidateSchema),
 });
+/** Matches the `project` review window users already see in memory settings. */
+export const KNOWLEDGE_REVIEW_DAYS = 90;
+/**
+ * Knowledge with a dependency snapshot learns when it went stale from the
+ * files themselves; a deployment convention or a decision has none, so without
+ * this it stayed "active" forever however long ago anyone checked it.
+ */
+export function unverifiedDays(item, now = Date.now()) {
+    if (item.dependencies)
+        return undefined;
+    const days = Math.floor((now - (item.lastVerifiedAt ?? item.createdAt)) / 86_400_000);
+    return days >= KNOWLEDGE_REVIEW_DAYS ? days : undefined;
+}
 export const parseProjectKnowledgeSnapshot = (input) => storeSchema.parse(input);
 const pathFor = (scope, workspaceId) => join(scope === 'global'
     ? globalMemoryDir()
@@ -320,8 +333,24 @@ export async function recallProjectKnowledge(workspaceId, query, limit = 5) {
         dependencyWarning: item.dependencies
             ? await checkDependencies(item.dependencies)
             : [],
+        unverifiedDays: unverifiedDays(item),
     })));
 }
+/**
+ * Same rule as fact candidates (factCandidates.ts::isLiveFactCandidate): a
+ * candidate proposes replacing one exact statement of one live record. Once
+ * that record is dismissed, replaced or rewritten, the candidate is history —
+ * surfacing it put a dismissed statement back into prompts as "旧=…".
+ */
+export function isLiveKnowledgeCandidate(item, records) {
+    if (item.status !== 'open')
+        return false;
+    const current = records.find((record) => record.id === item.oldId);
+    return (current !== undefined &&
+        current.status !== 'superseded' &&
+        current.statement === item.oldStatement &&
+        current.statement !== item.proposed.statement);
+}
 export async function resolveProjectKnowledgeCandidate(workspaceId, id, decision, signal) {
     const global = await readStore('global');
     const workspace = await readStore('workspace', workspaceId);
@@ -343,8 +372,14 @@ export async function resolveProjectKnowledgeCandidate(workspaceId, id, decision
         const current = store.records.find((item) => item.id === candidate.oldId);
         if (!current ||
             current.status === 'superseded' ||
-            current.statement !== candidate.oldStatement)
-            throw new Error('PROJECT_KNOWLEDGE_VERSION_CONFLICT');
+            current.statement !== candidate.oldStatement) {
+            // A stale proposal can never be accepted, but refusing to reject it too
+            // left it open forever with nothing able to close it.
+            if (decision === 'accept')
+                throw new Error('PROJECT_KNOWLEDGE_VERSION_CONFLICT');
+            candidate.status = 'rejected';
+            return;
+        }
         if (decision === 'accept') {
             current.status = 'superseded';
             current.revision++;
@@ -511,7 +546,8 @@ export function projectKnowledgeEntry(item) {
             agent_inferred: '助手推断',
         })[source.type])),
     ].join('、');
-    return `- [${item.id}] ${item.kind}/${item.subject} (${item.scope}${item.status === 'needs_review' ? '; 待复核' : ''}; 来源：${sourceLabel(item)})：${item.statement}\n适用：${item.applicability}${item.dependencyWarning?.length ? `\n依赖已变化：${item.dependencyWarning.join('、')}；请读取/测试后更新或确认。` : ''}`;
+    return `- [${item.id}] ${item.kind}/${item.subject} (${item.scope}${item.status === 'needs_review' ? '; 待复核' : ''}; 来源：${sourceLabel(item)})：${item.statement}\n适用：${item.applicability}${item.dependencyWarning?.length ? `\n依赖已变化：${item.dependencyWarning.join('、')}；请读取/测试后更新或确认。` : ''}${item.unverifiedDays ? `
+已 ${item.unverifiedDays} 天未验证；依赖它之前先核对现状，核对后可保存更新。` : ''}`;
 }
 export function projectKnowledgeContext(items) {
     if (!items.length)

package/src/memory/projectKnowledge.ts

@@ -91,7 +91,22 @@ const storeSchema = z.object({
 });
 export type ProjectKnowledge = z.infer<typeof recordSchema> & {
   dependencyWarning?: string[];
+  /** Whole days since this was last verified, set only once it is overdue. */
+  unverifiedDays?: number;
 };
+
+/** Matches the `project` review window users already see in memory settings. */
+export const KNOWLEDGE_REVIEW_DAYS = 90;
+/**
+ * Knowledge with a dependency snapshot learns when it went stale from the
+ * files themselves; a deployment convention or a decision has none, so without
+ * this it stayed "active" forever however long ago anyone checked it.
+ */
+export function unverifiedDays(item: ProjectKnowledge, now = Date.now()): number | undefined {
+  if (item.dependencies) return undefined;
+  const days = Math.floor((now - (item.lastVerifiedAt ?? item.createdAt)) / 86_400_000);
+  return days >= KNOWLEDGE_REVIEW_DAYS ? days : undefined;
+}
 export type ProjectKnowledgeDraft = z.infer<typeof candidateSchema>['proposed'];
 export type ProjectKnowledgeCandidate = z.infer<typeof candidateSchema>;
 type Store = z.infer<typeof storeSchema>;
@@ -453,10 +468,31 @@ export async function recallProjectKnowledge(
       dependencyWarning: item.dependencies
         ? await checkDependencies(item.dependencies)
         : [],
+      unverifiedDays: unverifiedDays(item),
     })),
   );
 }
 
+/**
+ * Same rule as fact candidates (factCandidates.ts::isLiveFactCandidate): a
+ * candidate proposes replacing one exact statement of one live record. Once
+ * that record is dismissed, replaced or rewritten, the candidate is history —
+ * surfacing it put a dismissed statement back into prompts as "旧=…".
+ */
+export function isLiveKnowledgeCandidate(
+  item: ProjectKnowledgeCandidate,
+  records: readonly Pick<ProjectKnowledge, 'id' | 'status' | 'statement'>[],
+): boolean {
+  if (item.status !== 'open') return false;
+  const current = records.find((record) => record.id === item.oldId);
+  return (
+    current !== undefined &&
+    current.status !== 'superseded' &&
+    current.statement === item.oldStatement &&
+    current.statement !== item.proposed.statement
+  );
+}
+
 export async function resolveProjectKnowledgeCandidate(
   workspaceId: string,
   id: string,
@@ -487,8 +523,13 @@ export async function resolveProjectKnowledgeCandidate(
         !current ||
         current.status === 'superseded' ||
         current.statement !== candidate.oldStatement
-      )
-        throw new Error('PROJECT_KNOWLEDGE_VERSION_CONFLICT');
+      ) {
+        // A stale proposal can never be accepted, but refusing to reject it too
+        // left it open forever with nothing able to close it.
+        if (decision === 'accept') throw new Error('PROJECT_KNOWLEDGE_VERSION_CONFLICT');
+        candidate.status = 'rejected';
+        return;
+      }
       if (decision === 'accept') {
         current.status = 'superseded';
         current.revision++;
@@ -730,7 +771,8 @@ export function projectKnowledgeEntry(item: ProjectKnowledge): string {
         ),
       ),
     ].join('、');
-  return `- [${item.id}] ${item.kind}/${item.subject} (${item.scope}${item.status === 'needs_review' ? '; 待复核' : ''}; 来源：${sourceLabel(item)})：${item.statement}\n适用：${item.applicability}${item.dependencyWarning?.length ? `\n依赖已变化：${item.dependencyWarning.join('、')}；请读取/测试后更新或确认。` : ''}`;
+  return `- [${item.id}] ${item.kind}/${item.subject} (${item.scope}${item.status === 'needs_review' ? '; 待复核' : ''}; 来源：${sourceLabel(item)})：${item.statement}\n适用：${item.applicability}${item.dependencyWarning?.length ? `\n依赖已变化：${item.dependencyWarning.join('、')}；请读取/测试后更新或确认。` : ''}${item.unverifiedDays ? `
+已 ${item.unverifiedDays} 天未验证；依赖它之前先核对现状，核对后可保存更新。` : ''}`;
 }
 
 export function projectKnowledgeContext(items: ProjectKnowledge[]): string {

package/src/memory/recallQuery.js

@@ -0,0 +1,56 @@
+/**
+ * A message that is nothing but a continuation. Anchored at both ends: "为什么
+ * Redis 连接超时" or "详细说明部署流程" start the same way but carry their own
+ * topic, so treating them as follow-ups would skip them and recall against an
+ * older request instead. (The advisor has a looser prefix check of its own; a
+ * false positive there is harmless, here it points recall at the wrong topic.)
+ */
+const BARE_FOLLOW_UP = /^(?:继续|接着(?:说|来|做)?|然后呢|展开(?:说说|讲讲)?|详细(?:点|说说)?|深入(?:点|说说)?|再说(?:说)?|还有呢|为什么|为啥|怎么说|第[一二三四五六七八九十\d]+[点条项个]|go on|continue|elaborate|more detail|why)[\s，,。.！!？?~呢吧啊]*$/i;
+export function isFollowUpRequest(text) {
+    return BARE_FOLLOW_UP.test(text.trim());
+}
+/** Enough of the earlier request to carry its topic, not its whole paste. */
+const PREVIOUS_QUERY_CHARS = 500;
+/** "继续" after "继续" still continues the request before it; bound the walk. */
+const MAX_FOLLOW_UP_HOPS = 4;
+function userText(message) {
+    if (typeof message.content === 'string')
+        return message.content;
+    if (!Array.isArray(message.content))
+        return '';
+    return message.content
+        .filter((part) => part.type === 'text')
+        .map(part => part.text)
+        .join('\n');
+}
+/**
+ * The most recent user request before the current one, walking past bare
+ * follow-ups so "继续" → "为什么" still resolves to the request that named the
+ * topic. Hosts call this with the history as it stood before the new message.
+ */
+export function previousUserRequest(history) {
+    if (!history)
+        return undefined;
+    let hops = 0;
+    for (let index = history.length - 1; index >= 0; index -= 1) {
+        const message = history[index];
+        if (message.role !== 'user')
+            continue;
+        const text = userText(message).trim();
+        if (!text)
+            continue;
+        if (isFollowUpRequest(text) && (hops += 1) < MAX_FOLLOW_UP_HOPS)
+            continue;
+        return text.slice(0, PREVIOUS_QUERY_CHARS);
+    }
+    return undefined;
+}
+/**
+ * What memory is searched with. A pure follow-up ("继续", "为什么") has no
+ * topic words of its own, so recall against the request it continues; any
+ * other message is its own query. Recall only — what the current message
+ * corrects or overrides is still decided from the current message alone.
+ */
+export function recallQueryFor(current, previous) {
+    return previous && isFollowUpRequest(current) ? `${previous}\n${current}` : current;
+}

package/src/memory/recallQuery.ts

@@ -0,0 +1,58 @@
+import type { Message } from '../types.js';
+
+/**
+ * A message that is nothing but a continuation. Anchored at both ends: "为什么
+ * Redis 连接超时" or "详细说明部署流程" start the same way but carry their own
+ * topic, so treating them as follow-ups would skip them and recall against an
+ * older request instead. (The advisor has a looser prefix check of its own; a
+ * false positive there is harmless, here it points recall at the wrong topic.)
+ */
+const BARE_FOLLOW_UP =
+  /^(?:继续|接着(?:说|来|做)?|然后呢|展开(?:说说|讲讲)?|详细(?:点|说说)?|深入(?:点|说说)?|再说(?:说)?|还有呢|为什么|为啥|怎么说|第[一二三四五六七八九十\d]+[点条项个]|go on|continue|elaborate|more detail|why)[\s，,。.！!？?~呢吧啊]*$/i;
+
+export function isFollowUpRequest(text: string): boolean {
+  return BARE_FOLLOW_UP.test(text.trim());
+}
+
+/** Enough of the earlier request to carry its topic, not its whole paste. */
+const PREVIOUS_QUERY_CHARS = 500;
+/** "继续" after "继续" still continues the request before it; bound the walk. */
+const MAX_FOLLOW_UP_HOPS = 4;
+
+function userText(message: Message): string {
+  if (typeof message.content === 'string') return message.content;
+  if (!Array.isArray(message.content)) return '';
+  return message.content
+    .filter((part): part is Extract<typeof part, { type: 'text' }> => part.type === 'text')
+    .map(part => part.text)
+    .join('\n');
+}
+
+/**
+ * The most recent user request before the current one, walking past bare
+ * follow-ups so "继续" → "为什么" still resolves to the request that named the
+ * topic. Hosts call this with the history as it stood before the new message.
+ */
+export function previousUserRequest(history: readonly Message[] | undefined): string | undefined {
+  if (!history) return undefined;
+  let hops = 0;
+  for (let index = history.length - 1; index >= 0; index -= 1) {
+    const message = history[index]!;
+    if (message.role !== 'user') continue;
+    const text = userText(message).trim();
+    if (!text) continue;
+    if (isFollowUpRequest(text) && (hops += 1) < MAX_FOLLOW_UP_HOPS) continue;
+    return text.slice(0, PREVIOUS_QUERY_CHARS);
+  }
+  return undefined;
+}
+
+/**
+ * What memory is searched with. A pure follow-up ("继续", "为什么") has no
+ * topic words of its own, so recall against the request it continues; any
+ * other message is its own query. Recall only — what the current message
+ * corrects or overrides is still decided from the current message alone.
+ */
+export function recallQueryFor(current: string, previous: string | undefined): string {
+  return previous && isFollowUpRequest(current) ? `${previous}\n${current}` : current;
+}