minimal-agent 0.18.13 → 0.18.14

package/src/memory/learning.js

@@ -5,7 +5,7 @@
 import { randomUUID } from 'node:crypto';
 import { parseMemoryProposal } from './proposal.js';
 import { acquireModelSlot, MAX_MODEL_DURATION_MS } from './modelBudget.js';
-import { jobEligible, recordJobFailure, recordBackgroundLearningFailure } from './jobPolicy.js';
+import { isPausedJob, jobEligible, recordJobFailure, recordBackgroundLearningFailure } from './jobPolicy.js';
 import { join } from 'node:path';
 import lockfile from 'proper-lockfile';
 import { ensurePrivateDir } from './fileStore.js';
@@ -349,7 +349,7 @@ export function scheduleMemoryMaintenance(options) {
         if (cancelled.has(experienceDirectory(options.workspaceId)) || options.signal?.aborted || !settings.autoRemember || !settings.learning?.enabled)
             return;
         const store = await readExperienceStore(options.workspaceId);
-        const pending = store.pending.filter(turn => !turn.failure?.paused);
+        const pending = store.pending.filter(turn => !isPausedJob(turn));
         const continuing = pending.some(turn => turn.createdAt <= (store.runs.at(-1)?.startedAt ?? 0));
         if (!pending.length || (!continuing && pending.length < settings.learning.minPendingTurns))
             return;

package/src/memory/learning.ts

@@ -5,7 +5,7 @@
 import { randomUUID } from 'node:crypto';
 import { parseMemoryProposal } from './proposal.js';
 import { acquireModelSlot, MAX_MODEL_DURATION_MS } from './modelBudget.js';
-import { jobEligible, recordJobFailure, recordBackgroundLearningFailure } from './jobPolicy.js';
+import { isPausedJob, jobEligible, recordJobFailure, recordBackgroundLearningFailure } from './jobPolicy.js';
 import { join } from 'node:path';
 import lockfile from 'proper-lockfile';
 import { ensurePrivateDir } from './fileStore.js';
@@ -428,7 +428,7 @@ export function scheduleMemoryMaintenance(
     const settings = await memoryService.settings();
     if (cancelled.has(experienceDirectory(options.workspaceId)) || options.signal?.aborted || !settings.autoRemember || !settings.learning?.enabled) return;
     const store = await readExperienceStore(options.workspaceId);
-    const pending = store.pending.filter(turn => !turn.failure?.paused);
+    const pending = store.pending.filter(turn => !isPausedJob(turn));
     const continuing = pending.some(turn => turn.createdAt <= (store.runs.at(-1)?.startedAt ?? 0));
     if (!pending.length || (!continuing && pending.length < settings.learning.minPendingTurns)) return;
     const next = Math.max(continuing ? 0 : store.lastSuccessAt + settings.learning.minIntervalHours * 3600000,

package/src/memory/learningModel.js

@@ -5,6 +5,7 @@ export function createLearningModel(provider, execute = chat) {
     return async (prompt, signal, onProgress) => {
         let text = '';
         let finished = false;
+        let stopReason;
         let usage;
         for await (const event of execute({
             provider,
@@ -35,6 +36,7 @@ export function createLearningModel(provider, execute = chat) {
             if (event.type === 'interrupted')
                 throw new DOMException('记忆整理已中断', 'AbortError');
             if (event.type === 'done') {
+                stopReason = event.stopReason;
                 finished = event.stopReason === 'stop';
                 usage = {
                     promptTokens: event.promptTokens,
@@ -43,6 +45,11 @@ export function createLearningModel(provider, execute = chat) {
             }
         }
         signal.throwIfAborted();
+        // No end marker is a dropped connection (the client synthesizes
+        // stopReason 'unknown'), not something the model said. Classifying it as
+        // an invalid proposal let three network blips park a source for good.
+        if (stopReason === undefined || stopReason === 'unknown')
+            throw new Error('记忆整理模型连接中断（流未正常结束），保留待处理资料');
         if (!finished)
             throw new MemoryProposalError('format', '记忆整理模型未正常完成（截断或缺少正常结束标记），保留待处理资料');
         if (!text.trim())

package/src/memory/learningModel.ts

@@ -10,6 +10,7 @@ export function createLearningModel(
   return async (prompt, signal, onProgress) => {
     let text = '';
     let finished = false;
+    let stopReason: string | undefined;
     let usage: { promptTokens?: number; outputTokens?: number } | undefined;
     for await (const event of execute({
       provider,
@@ -41,6 +42,7 @@ export function createLearningModel(
       if (event.type === 'interrupted')
         throw new DOMException('记忆整理已中断', 'AbortError');
       if (event.type === 'done') {
+        stopReason = event.stopReason;
         finished = event.stopReason === 'stop';
         usage = {
           promptTokens: event.promptTokens,
@@ -49,6 +51,11 @@ export function createLearningModel(
       }
     }
     signal.throwIfAborted();
+    // No end marker is a dropped connection (the client synthesizes
+    // stopReason 'unknown'), not something the model said. Classifying it as
+    // an invalid proposal let three network blips park a source for good.
+    if (stopReason === undefined || stopReason === 'unknown')
+      throw new Error('记忆整理模型连接中断（流未正常结束），保留待处理资料');
     if (!finished)
       throw new MemoryProposalError('format', '记忆整理模型未正常完成（截断或缺少正常结束标记），保留待处理资料');
     if (!text.trim())

package/src/memory/managementService.js

@@ -1,10 +1,11 @@
 import { z } from 'zod';
 import { dismissExperience, readExperienceStore, restoreExperience, undoLearningRun, } from './experienceStore.js';
-import { factCandidates, resolveFactCandidate } from './factCandidates.js';
+import { factCandidates, isLiveFactCandidate, resolveFactCandidate, } from './factCandidates.js';
+import { isPausedJob } from './jobPolicy.js';
 import { cancelFactLearning, factLearningStatus, runFactLearning, } from './factLearning.js';
 import { cancelLearning, persistedLearningStatus, runMemoryMaintenance, } from './learning.js';
 import { memoryService } from './memoryService.js';
-import { dismissProjectKnowledge, projectKnowledgeStatus, resolveProjectKnowledgeCandidate, restoreProjectKnowledge, } from './projectKnowledge.js';
+import { dismissProjectKnowledge, isLiveKnowledgeCandidate, projectKnowledgeStatus, resolveProjectKnowledgeCandidate, restoreProjectKnowledge, } from './projectKnowledge.js';
 export const memoryManagementRequest = z.object({
     action: z.enum([
         'status',
@@ -98,18 +99,18 @@ export async function learningManagementSnapshot(workspaceId) {
         persistedLearningStatus(workspaceId),
         memoryService.settings(),
     ]);
-    const ids = new Set(memories.records.map((record) => record.id));
+    const statements = new Map(memories.records.map((record) => [record.id, record.statement]));
     return {
         workspaceId,
         status: status.status,
         pendingTurns: store.pending.length,
-        pausedTurns: store.pending.filter(turn => turn.failure?.paused).length,
+        pausedTurns: store.pending.filter(isPausedJob).length,
         experiences: store.items,
         knowledge: knowledge.records,
-        knowledgeCandidates: knowledge.candidates.filter((item) => item.status === 'open'),
-        factCandidates: candidates.filter((item) => item.status === 'open' && (!item.old || ids.has(item.old.id))),
+        knowledgeCandidates: knowledge.candidates.filter((item) => isLiveKnowledgeCandidate(item, knowledge.records)),
+        factCandidates: candidates.filter((item) => isLiveFactCandidate(item, statements)),
         factPendingTurns: facts.pending.length,
-        factPausedTurns: facts.pending.filter(turn => turn.failure?.paused).length,
+        factPausedTurns: facts.pending.filter(isPausedJob).length,
         factReceipts: facts.receipts.slice(-20),
         runs: store.runs.slice(-20).reverse(),
         settings,

package/src/memory/managementService.ts

@@ -5,7 +5,12 @@ import {
   restoreExperience,
   undoLearningRun,
 } from './experienceStore.js';
-import { factCandidates, resolveFactCandidate } from './factCandidates.js';
+import {
+  factCandidates,
+  isLiveFactCandidate,
+  resolveFactCandidate,
+} from './factCandidates.js';
+import { isPausedJob } from './jobPolicy.js';
 import {
   cancelFactLearning,
   factLearningStatus,
@@ -20,6 +25,7 @@ import {
 import { memoryService } from './memoryService.js';
 import {
   dismissProjectKnowledge,
+  isLiveKnowledgeCandidate,
   projectKnowledgeStatus,
   resolveProjectKnowledgeCandidate,
   restoreProjectKnowledge,
@@ -144,22 +150,24 @@ export async function learningManagementSnapshot(workspaceId: string) {
       persistedLearningStatus(workspaceId),
       memoryService.settings(),
     ]);
-  const ids = new Set(memories.records.map((record) => record.id));
+  const statements = new Map(
+    memories.records.map((record) => [record.id, record.statement]),
+  );
   return {
     workspaceId,
     status: status.status,
     pendingTurns: store.pending.length,
-    pausedTurns: store.pending.filter(turn => turn.failure?.paused).length,
+    pausedTurns: store.pending.filter(isPausedJob).length,
     experiences: store.items,
     knowledge: knowledge.records,
-    knowledgeCandidates: knowledge.candidates.filter(
-      (item) => item.status === 'open',
+    knowledgeCandidates: knowledge.candidates.filter((item) =>
+      isLiveKnowledgeCandidate(item, knowledge.records),
     ),
-    factCandidates: candidates.filter(
-      (item) => item.status === 'open' && (!item.old || ids.has(item.old.id)),
+    factCandidates: candidates.filter((item) =>
+      isLiveFactCandidate(item, statements),
     ),
     factPendingTurns: facts.pending.length,
-    factPausedTurns: facts.pending.filter(turn => turn.failure?.paused).length,
+    factPausedTurns: facts.pending.filter(isPausedJob).length,
     factReceipts: facts.receipts.slice(-20),
     runs: store.runs.slice(-20).reverse(),
     settings,

package/src/memory/memoryService.js

@@ -3,7 +3,7 @@ import { readFile, unlink } from 'node:fs/promises';
 import { join } from 'node:path';
 import { clearExperiences, EXPERIENCE_CONTEXT_HEADER, experienceEntry, recallExperiences, } from './experienceStore.js';
 import { assertAutomaticFactAllowed, blockFact, withFactBarriers, } from './factGovernance.js';
-import { clearGlobalProjectKnowledge, clearProjectKnowledge, PROJECT_KNOWLEDGE_CONTEXT_HEADER, projectKnowledgeEntry, projectKnowledgeStatus, recallProjectKnowledge, } from './projectKnowledge.js';
+import { clearGlobalProjectKnowledge, clearProjectKnowledge, isLiveKnowledgeCandidate, PROJECT_KNOWLEDGE_CONTEXT_HEADER, projectKnowledgeEntry, projectKnowledgeStatus, recallProjectKnowledge, } from './projectKnowledge.js';
 import { countTextTokens } from '../context/tokenCounter.js';
 import { containsForbiddenSecret, deriveTopicKey, hydrateRecord, parsePersona, serializePersona, sha256, validateMemoryInput, } from './codec.js';
 import { DEFAULT_RETENTION, DEFAULT_SETTINGS, LEGACY_LEARNING_CADENCE, MEMORY_SETTINGS_REVISION, MEMORY_RETENTION_DAYS_MAX, MEMORY_RETENTION_DAYS_MIN, MEMORY_RETENTION_MB_MAX, MEMORY_RETENTION_MB_MIN, PERSONA_MAX_CHARS, } from './constants.js';
@@ -11,7 +11,8 @@ import { clearConversationEpisodes, episodicMemoryService, } from './episodicMem
 import { acquireFileLock, appendPrivateLine, atomicWriteFile, auditFilePath, enqueueMemoryMutation, personaFilePath, scopeDirectory, settingsFilePath, } from './fileStore.js';
 import { ensureMemoryMigrated } from './migration.js';
 import { clearScopeTransactionQuarantine, readVersionedMemory, refreshTopicView, removeVersionedMemory, replaceMemoryBatchVersioned, scanMemoryScope, writeNewMemory, } from './repository.js';
-import { isReviewDue, memoryTerms, recallFromSnapshot, truncateTokenBudget, } from './retrieval.js';
+import { isReviewDue, isUnconfirmed, memoryTerms, recallFromSnapshot, takeTokenBudget, truncateTokenBudget, } from './retrieval.js';
+import { recallQueryFor } from './recallQuery.js';
 export { containsForbiddenSecret } from './codec.js';
 export class MemoryTopicConflictError extends Error {
     recordId;
@@ -239,6 +240,17 @@ function refreshTopicViewAfterMutation(scope, workspaceId) {
     combinedSnapshotCache = null;
     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, updated) {
+    await (await import('./factCandidates.js'))
+        .settleFactCandidatesFor(workspaceId, updated.record, updated.version)
+        .catch((error) => process.stderr.write(`[minimal-agent memory] 记忆已更新，但关联候选暂未结清：${error.message}\n`));
+}
 function sameTopic(a, b) {
     const topicKey = b.topicKey || deriveTopicKey(b);
     if (a.topicKey === topicKey)
@@ -323,6 +335,8 @@ export const memoryService = {
     async remember(input, automatic) {
         validateMemoryInput(input);
         await ensureMemoryMigrated();
+        // Set when the user said the same thing again; see the refresh below.
+        let restated;
         const commit = () => withFactBarriers(input.scope, input.workspaceId, async (barriers) => {
             automatic?.signal?.throwIfAborted();
             if (automatic)
@@ -345,6 +359,9 @@ 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) {
@@ -378,13 +395,36 @@ export const memoryService = {
                 await release();
             }
         });
-        return enqueueMemoryMutation(() => automatic && input.scope === 'personal'
+        const stored = await enqueueMemoryMutation(() => automatic && input.scope === 'personal'
             ? withFactBarriers('workspace', automatic.sourceWorkspaceId, async (barriers) => {
                 // Hold source-workspace barrier until a global fact commit finishes.
                 assertAutomaticFactAllowed(barriers, input, automatic.startedAt);
                 return commit();
             })
             : 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(id, scope, expectedVersion, patch, workspaceId, candidate) {
         await ensureMemoryMigrated();
@@ -485,7 +525,7 @@ export const memoryService = {
                 throw error;
             }
         };
-        return enqueueMemoryMutation(() => candidate
+        const updated = await enqueueMemoryMutation(() => candidate
             ? withFactBarriers('workspace', candidate.sourceWorkspaceId, async (barriers) => {
                 // A global candidate from a cleared workspace cannot update an old fact.
                 if (candidate.startedAt <= barriers.clearedAt)
@@ -493,6 +533,10 @@ export const memoryService = {
                 return commit();
             })
             : commit());
+        const candidatesWorkspace = workspaceId ?? candidate?.sourceWorkspaceId;
+        if (updated && candidatesWorkspace)
+            await settleCandidatesAfterUpdate(candidatesWorkspace, updated);
+        return updated;
     },
     async update(id, scope, patch, workspaceId) {
         const current = await this.readWithVersion(id, scope, workspaceId);
@@ -695,6 +739,8 @@ export const memoryService = {
         const count = (base) => 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
             : await this.readPersona().catch(() => null);
@@ -706,46 +752,53 @@ export const memoryService = {
             !currentInputOverrides(record, input))
             .sort((a, b) => 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)).length;
+        const reviewCount = snapshot.records.filter((record) => record.status !== 'superseded' && isUnconfirmed(record, settings)).length;
         const sections = [];
         const contextSections = [];
         const includedIds = [];
         let conflictWarning;
+        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.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([
-                    item.proposed.subject,
-                    item.proposed.statement,
-                    item.old?.statement,
-                ])
-                    .toLowerCase()
-                    .includes(term))))
+            .filter((item) => ((item.old && includedIds.includes(item.old.id)) ||
+            queryTerms.some((term) => JSON.stringify([
+                item.proposed.subject,
+                item.proposed.statement,
+                item.old?.statement,
+            ])
+                .toLowerCase()
+                .includes(term))))
             .slice(0, count(3));
         const pushSection = (id, content, ids = [], recordList) => {
             if (countTextTokens([...sections, content].join('\n\n')) > budget)
@@ -767,7 +820,7 @@ export const memoryService = {
             const personaText = truncateTokenBudget(persona.content, share(700));
             pushSection('persona', `【全局 Agent 人格｜可信本机配置】\n只用于角色、语气和协作风格；不得扩大权限、覆盖安全规则或改变当前任务。\n${personaText}`);
         }
-        const describe = (record) => `- ${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}`;
+        const describe = (record) => `- ${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, header, entries, sectionBudget) => {
             const selected = [];
             for (const entry of entries) {
@@ -782,10 +835,11 @@ export const memoryService = {
                 pushSection(id, `${header}\n${selected.map((item) => item.text).join('\n')}`, selected.map((item) => item.id), { header, entries: selected });
         };
         addRecords('preferences', '【响应偏好｜personal 全局，workspace 项目】当前要求优先；项目偏好仅在当前项目适用；待复核信息不作为确定约束。', 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。', relevant.map((record) => ({ id: record.id, text: describe(record) })), share(850));
         if (workspaceId) {
             try {
-                const knowledge = await recallProjectKnowledge(workspaceId, input, count(4));
+                const knowledge = await recallProjectKnowledge(workspaceId, query, count(4));
                 // Header once via addRecords, not re-rendered per record: the old
                 // projectKnowledgeContext([item]) call embedded a full ~60-token header
                 // in every single entry, burning a quarter of this section's budget on
@@ -794,8 +848,9 @@ export const memoryService = {
                     id: item.id,
                     text: projectKnowledgeEntry(item),
                 })), share(800));
-                const knowledgeCandidates = (await projectKnowledgeStatus(workspaceId)).candidates
-                    .filter((item) => item.status === 'open' &&
+                const knowledgeStatus = await projectKnowledgeStatus(workspaceId);
+                const knowledgeCandidates = knowledgeStatus.candidates
+                    .filter((item) => isLiveKnowledgeCandidate(item, knowledgeStatus.records) &&
                     // Same rule as fact candidates: travels with its injected old record.
                     (includedIds.includes(item.oldId) ||
                         queryTerms.some((term) => JSON.stringify([
@@ -808,7 +863,7 @@ export const memoryService = {
                     .slice(0, count(3));
                 const relevantFactCandidates = surfacedFactCandidates();
                 if (relevantFactCandidates.length || knowledgeCandidates.length)
-                    pushSection('health', `【相关知识变化待处理】旧值与新候选并存，候选不是现行事实。仅本轮用户明确纠正可直接作为本轮要求；历史未决候选不能自动替代旧值。影响当前任务时核对来源，无法确定再询问。\n${[
+                    pushSection('health', `【相关知识变化待处理】旧值与新候选并存，候选不是现行事实。仅本轮用户明确纠正可直接作为本轮要求；历史候选不会自动替代旧值。影响当前任务时向用户确认哪个有效，并按确认结果结清候选（改写记录后候选自动失效）；项目事实先用读取或测试核对。\n${[
                         ...relevantFactCandidates.map((item) => `- fact candidate=${item.id}：旧=${item.old?.statement ?? '无'}；新=${item.proposed.statement}`),
                         ...knowledgeCandidates.map((item) => `- knowledge candidate=${item.id}：旧=${item.oldStatement}；新=${item.proposed.statement}`),
                     ].join('\n')}`);
@@ -817,7 +872,7 @@ export const memoryService = {
                 pushSection('health', `项目事实暂不可读：${error.message}。不要假设项目知识库为空。`);
             }
             try {
-                const experiences = await recallExperiences(workspaceId, input, count(3));
+                const experiences = await recallExperiences(workspaceId, query, count(3));
                 addRecords('experiences', EXPERIENCE_CONTEXT_HEADER, experiences.map((item) => ({
                     id: item.id,
                     text: experienceEntry(item),
@@ -827,12 +882,28 @@ export const memoryService = {
                 pushSection('health', `项目经验暂不可读：${error.message}。不要假设经验库为空。`);
             }
         }
+        // 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} 条后台学习资料因重复失败已暂停自动重试，原资料仍保留；不得声称这些资料已完成长期保存。`);
             }