minimal-agent 0.18.13 → 0.18.14

package/src/memory/dependencies.js

@@ -1,5 +1,5 @@
 import { readFile, stat } from 'node:fs/promises';
-import { isAbsolute, relative, resolve } from 'node:path';
+import { isAbsolute, relative, resolve, sep } from 'node:path';
 import { z } from 'zod';
 import { sha256 } from './codec.js';
 export const dependencySchema = z.object({
@@ -40,14 +40,22 @@ async function fingerprint(path) {
             : 'unavailable';
     }
 }
+/** Bindings captured on Windows before paths were stored in portable form. */
+export function portableDependencyPath(path, platform) {
+    return platform === 'win32' ? path.replaceAll('\\', '/') : path;
+}
 export async function captureDependencies(cwd, paths) {
     const root = resolve(cwd);
     const files = [];
     const unavailable = [];
     for (const input of [...new Set([...paths.slice(0, 24), ...manifests])]) {
-        const path = relative(root, resolve(root, input));
-        if (!path || path.startsWith('..') || isAbsolute(path))
+        const native = relative(root, resolve(root, input));
+        if (!native || native.startsWith('..') || isAbsolute(native))
             continue;
+        // Stored in portable form: Windows `relative()` yields backslashes, which
+        // broke comparisons against `/`-joined tool paths and data moved between
+        // machines (portable MINIMAL_AGENT_HOME). resolve() accepts both on Windows.
+        const path = native.split(sep).join('/');
         const hash = await fingerprint(resolve(root, path));
         if (hash === 'unavailable')
             unavailable.push(path);

package/src/memory/dependencies.ts

@@ -1,5 +1,5 @@
 import { readFile, stat } from 'node:fs/promises';
-import { isAbsolute, relative, resolve } from 'node:path';
+import { isAbsolute, relative, resolve, sep } from 'node:path';
 import { z } from 'zod';
 import { sha256 } from './codec.js';
 
@@ -42,6 +42,10 @@ async function fingerprint(path: string): Promise<string> {
       : 'unavailable';
   }
 }
+/** Bindings captured on Windows before paths were stored in portable form. */
+export function portableDependencyPath(path: string, platform: string): string {
+  return platform === 'win32' ? path.replaceAll('\\', '/') : path;
+}
 export async function captureDependencies(
   cwd: string,
   paths: string[],
@@ -50,8 +54,12 @@ export async function captureDependencies(
   const files: Dependencies['files'] = [];
   const unavailable: string[] = [];
   for (const input of [...new Set([...paths.slice(0, 24), ...manifests])]) {
-    const path = relative(root, resolve(root, input));
-    if (!path || path.startsWith('..') || isAbsolute(path)) continue;
+    const native = relative(root, resolve(root, input));
+    if (!native || native.startsWith('..') || isAbsolute(native)) continue;
+    // Stored in portable form: Windows `relative()` yields backslashes, which
+    // broke comparisons against `/`-joined tool paths and data moved between
+    // machines (portable MINIMAL_AGENT_HOME). resolve() accepts both on Windows.
+    const path = native.split(sep).join('/');
     const hash = await fingerprint(resolve(root, path));
     if (hash === 'unavailable') unavailable.push(path);
     else files.push({ path, hash });

package/src/memory/episodicMemory.js

@@ -8,6 +8,8 @@ import { memoryTerms } from './retrieval.js';
 import { indexEpisodeTimes } from './episodeTimeIndex.js';
 import { BM25_DOCUMENT_THRESHOLD, Bm25Index, recordSearchIndexBuild, recordSearchIndexCacheHit, recordSearchIndexFallback, recordSearchStrategy, } from './searchIndex.js';
 const MAX_EPISODE_CHARS = 8_000;
+/** A longer message keeps this many leading and trailing episodes, never the whole. */
+const KEPT_EDGE_PARTS = 2;
 const MAX_SEARCH_FILES = 200;
 const MAX_SEARCH_LINES = 20_000;
 const MAX_SNIPPET_CHARS = 500;
@@ -86,37 +88,72 @@ function backfillMarkerPath(workspaceId) {
 function workspaceJournalLockPath(workspaceId) {
     return join(episodeRoot(), `.workspace-${validPart(workspaceId)}.journal`);
 }
-export function sanitizeEpisodeContent(content) {
+export function sanitizeEpisodeContent(content, maxChars = MAX_EPISODE_CHARS) {
     const normalized = content
         .replace(/data:[^;\s]+;base64,[A-Za-z0-9+/=]{80,}/g, '[binary omitted]')
         .replace(/-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/gi, '[secret omitted]')
         .trim()
-        .slice(0, MAX_EPISODE_CHARS);
+        .slice(0, maxChars);
     if (!normalized || containsForbiddenSecret(normalized))
         return null;
     return normalized;
 }
+/**
+ * One message → consecutive episodes of at most MAX_EPISODE_CHARS each. The
+ * per-episode cap is what bounds search memory (the file cache is counted in
+ * episodes), so it stays; but cutting the message itself at the cap lost the
+ * end of long discussions, which is where the decision, the correction and the
+ * acceptance conclusion are. A message longer than the kept edges stores its
+ * head and its tail and says how much of the middle is gone.
+ */
+export function splitEpisodeContent(content) {
+    if (content.length <= MAX_EPISODE_CHARS)
+        return [{ text: content }];
+    const parts = [];
+    for (let at = 0; at < content.length; at += MAX_EPISODE_CHARS)
+        parts.push(content.slice(at, at + MAX_EPISODE_CHARS));
+    const edges = KEPT_EDGE_PARTS * 2;
+    if (parts.length <= edges)
+        return parts.map((text, index) => ({ text, part: { index, total: parts.length } }));
+    const kept = [...parts.slice(0, KEPT_EDGE_PARTS), ...parts.slice(-KEPT_EDGE_PARTS)];
+    const omittedChars = content.length - kept.reduce((sum, text) => sum + text.length, 0);
+    return kept.map((text, index) => ({
+        text,
+        part: { index, total: kept.length, ...(index === KEPT_EDGE_PARTS ? { omittedChars } : {}) },
+    }));
+}
+/** Keeps the head and tail of a pathologically large message for the splitter. */
+const MAX_MESSAGE_INTAKE_CHARS = 2_000_000;
 export async function appendConversationEpisode(input, signal) {
     signal?.throwIfAborted();
-    const content = sanitizeEpisodeContent(input.content);
+    // Head + tail of an absurd paste are enough for the splitter to keep both edges.
+    const raw = input.content.length > MAX_MESSAGE_INTAKE_CHARS
+        ? `${input.content.slice(0, MAX_MESSAGE_INTAKE_CHARS / 2)}${input.content.slice(-MAX_MESSAGE_INTAKE_CHARS / 2)}`
+        : input.content;
+    const content = sanitizeEpisodeContent(raw, Number.POSITIVE_INFINITY);
     if (!content)
         return null;
     const createdAt = input.createdAt ?? Date.now();
     const messageId = input.messageId || randomUUID();
-    const episode = {
-        id: randomUUID(),
-        workspaceId: input.workspaceId,
-        sessionId: input.sessionId,
-        messageId,
-        role: input.role,
-        content,
-        createdAt,
-        contentHash: sha256(`${input.role}\0${content}`),
-    };
     const path = episodePath(input.workspaceId, input.sessionId);
     await ensurePrivateDir(dirname(path));
-    await appendPrivateLine(path, JSON.stringify(episode), { signal });
-    return episode;
+    let first = null;
+    for (const { text, part } of splitEpisodeContent(content)) {
+        const episode = {
+            id: randomUUID(),
+            workspaceId: input.workspaceId,
+            sessionId: input.sessionId,
+            messageId,
+            role: input.role,
+            content: text,
+            createdAt,
+            contentHash: sha256(`${input.role}\0${text}`),
+            ...(part ? { part } : {}),
+        };
+        await appendPrivateLine(path, JSON.stringify(episode), { signal });
+        first ??= episode;
+    }
+    return first;
 }
 /** 删除某工作区（缺省为全部）的会话原文日志。供 Desktop「清空记忆」一并调用。 */
 export async function clearConversationEpisodes(workspaceId) {
@@ -737,9 +774,13 @@ function rankConversationEpisodes(episodes, query, options, signature, batchIden
             const bm25 = scores.get(episode.id) ?? 0;
             const phrase = normalized && episode.content.toLocaleLowerCase().includes(normalized) ? 35 : 0;
             const roleWeight = episode.role === 'user' ? 4 : 0;
-            return { episode, bm25, score: bm25 * 10 + phrase + roleWeight + episode.createdAt / 1e13 };
+            // Same rule as memory records: BM25 matches whole tokens only, so a
+            // substring hit (`postgres` in `postgresql`) that the small-corpus
+            // path finds must not vanish once the corpus passes the threshold.
+            const substring = bm25 > 0 ? 0 : searchScore(episode, query);
+            return { episode, bm25, substring, score: bm25 * 10 + phrase + roleWeight + episode.createdAt / 1e13 + substring };
         })
-            .filter((item) => item.bm25 > 0)
+            .filter((item) => item.bm25 > 0 || item.substring >= 6)
             .sort((a, b) => b.score - a.score)
             .map(({ episode, score }) => conversationResult(episode, score, query));
     }
@@ -784,7 +825,7 @@ export async function readConversationEpisode(workspaceId, sessionId, episodeId,
         previousId: file.episodes[index - 1]?.id ?? null,
         nextId: file.episodes[index + 1]?.id ?? null,
         sourceKind: 'persisted-conversation-text',
-        limitation: `这是持久化会话文本，不含工具和图片原文；每条最多保存 ${MAX_EPISODE_CHARS} 字符，不保证完整原始消息。`,
+        limitation: `这是持久化会话文本，不含工具和图片原文；超过 ${MAX_EPISODE_CHARS} 字符的消息会拆成相邻的多段（episode.part 标出序号），过长时只保留开头和结尾、part.omittedChars 标出丢掉的中段；不保证完整原始消息。`,
     };
 }
 export const episodicMemoryService = {

package/src/memory/episodicMemory.ts

@@ -29,6 +29,8 @@ import type {
 } from './types.js';
 
 const MAX_EPISODE_CHARS = 8_000;
+/** A longer message keeps this many leading and trailing episodes, never the whole. */
+const KEPT_EDGE_PARTS = 2;
 const MAX_SEARCH_FILES = 200;
 const MAX_SEARCH_LINES = 20_000;
 const MAX_SNIPPET_CHARS = 500;
@@ -142,7 +144,7 @@ function workspaceJournalLockPath(workspaceId: string): string {
   return join(episodeRoot(), `.workspace-${validPart(workspaceId)}.journal`);
 }
 
-export function sanitizeEpisodeContent(content: string): string | null {
+export function sanitizeEpisodeContent(content: string, maxChars = MAX_EPISODE_CHARS): string | null {
   const normalized = content
     .replace(/data:[^;\s]+;base64,[A-Za-z0-9+/=]{80,}/g, '[binary omitted]')
     .replace(
@@ -150,11 +152,36 @@ export function sanitizeEpisodeContent(content: string): string | null {
       '[secret omitted]',
     )
     .trim()
-    .slice(0, MAX_EPISODE_CHARS);
+    .slice(0, maxChars);
   if (!normalized || containsForbiddenSecret(normalized)) return null;
   return normalized;
 }
 
+/**
+ * One message → consecutive episodes of at most MAX_EPISODE_CHARS each. The
+ * per-episode cap is what bounds search memory (the file cache is counted in
+ * episodes), so it stays; but cutting the message itself at the cap lost the
+ * end of long discussions, which is where the decision, the correction and the
+ * acceptance conclusion are. A message longer than the kept edges stores its
+ * head and its tail and says how much of the middle is gone.
+ */
+export function splitEpisodeContent(content: string): { text: string; part?: ConversationEpisode['part'] }[] {
+  if (content.length <= MAX_EPISODE_CHARS) return [{ text: content }];
+  const parts: string[] = [];
+  for (let at = 0; at < content.length; at += MAX_EPISODE_CHARS) parts.push(content.slice(at, at + MAX_EPISODE_CHARS));
+  const edges = KEPT_EDGE_PARTS * 2;
+  if (parts.length <= edges) return parts.map((text, index) => ({ text, part: { index, total: parts.length } }));
+  const kept = [...parts.slice(0, KEPT_EDGE_PARTS), ...parts.slice(-KEPT_EDGE_PARTS)];
+  const omittedChars = content.length - kept.reduce((sum, text) => sum + text.length, 0);
+  return kept.map((text, index) => ({
+    text,
+    part: { index, total: kept.length, ...(index === KEPT_EDGE_PARTS ? { omittedChars } : {}) },
+  }));
+}
+
+/** Keeps the head and tail of a pathologically large message for the splitter. */
+const MAX_MESSAGE_INTAKE_CHARS = 2_000_000;
+
 export async function appendConversationEpisode(input: {
   workspaceId: string;
   sessionId: string;
@@ -164,24 +191,33 @@ export async function appendConversationEpisode(input: {
   createdAt?: number;
 }, signal?: AbortSignal): Promise<ConversationEpisode | null> {
   signal?.throwIfAborted();
-  const content = sanitizeEpisodeContent(input.content);
+  // Head + tail of an absurd paste are enough for the splitter to keep both edges.
+  const raw = input.content.length > MAX_MESSAGE_INTAKE_CHARS
+    ? `${input.content.slice(0, MAX_MESSAGE_INTAKE_CHARS / 2)}${input.content.slice(-MAX_MESSAGE_INTAKE_CHARS / 2)}`
+    : input.content;
+  const content = sanitizeEpisodeContent(raw, Number.POSITIVE_INFINITY);
   if (!content) return null;
   const createdAt = input.createdAt ?? Date.now();
   const messageId = input.messageId || randomUUID();
-  const episode: ConversationEpisode = {
-    id: randomUUID(),
-    workspaceId: input.workspaceId,
-    sessionId: input.sessionId,
-    messageId,
-    role: input.role,
-    content,
-    createdAt,
-    contentHash: sha256(`${input.role}\0${content}`),
-  };
   const path = episodePath(input.workspaceId, input.sessionId);
   await ensurePrivateDir(dirname(path));
-  await appendPrivateLine(path, JSON.stringify(episode), { signal });
-  return episode;
+  let first: ConversationEpisode | null = null;
+  for (const { text, part } of splitEpisodeContent(content)) {
+    const episode: ConversationEpisode = {
+      id: randomUUID(),
+      workspaceId: input.workspaceId,
+      sessionId: input.sessionId,
+      messageId,
+      role: input.role,
+      content: text,
+      createdAt,
+      contentHash: sha256(`${input.role}\0${text}`),
+      ...(part ? { part } : {}),
+    };
+    await appendPrivateLine(path, JSON.stringify(episode), { signal });
+    first ??= episode;
+  }
+  return first;
 }
 
 /** 删除某工作区（缺省为全部）的会话原文日志。供 Desktop「清空记忆」一并调用。 */
@@ -858,9 +894,13 @@ function rankConversationEpisodes(episodes: ConversationEpisode[], query: string
         const bm25 = scores.get(episode.id) ?? 0;
         const phrase = normalized && episode.content.toLocaleLowerCase().includes(normalized) ? 35 : 0;
         const roleWeight = episode.role === 'user' ? 4 : 0;
-        return { episode, bm25, score: bm25 * 10 + phrase + roleWeight + episode.createdAt / 1e13 };
+        // Same rule as memory records: BM25 matches whole tokens only, so a
+        // substring hit (`postgres` in `postgresql`) that the small-corpus
+        // path finds must not vanish once the corpus passes the threshold.
+        const substring = bm25 > 0 ? 0 : searchScore(episode, query);
+        return { episode, bm25, substring, score: bm25 * 10 + phrase + roleWeight + episode.createdAt / 1e13 + substring };
       })
-      .filter((item) => item.bm25 > 0)
+      .filter((item) => item.bm25 > 0 || item.substring >= 6)
       .sort((a, b) => b.score - a.score)
             .map(({ episode, score }) => conversationResult(episode, score, query));
   } catch {
@@ -908,7 +948,7 @@ export async function readConversationEpisode(workspaceId: string, sessionId: st
     previousId: file.episodes[index - 1]?.id ?? null,
     nextId: file.episodes[index + 1]?.id ?? null,
     sourceKind: 'persisted-conversation-text' as const,
-    limitation: `这是持久化会话文本，不含工具和图片原文；每条最多保存 ${MAX_EPISODE_CHARS} 字符，不保证完整原始消息。`,
+    limitation: `这是持久化会话文本，不含工具和图片原文；超过 ${MAX_EPISODE_CHARS} 字符的消息会拆成相邻的多段（episode.part 标出序号），过长时只保留开头和结尾、part.omittedChars 标出丢掉的中段；不保证完整原始消息。`,
   };
 }
 

package/src/memory/experienceStore.js

@@ -8,7 +8,7 @@ import { readFile, readdir, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { z } from 'zod';
 import { containsForbiddenSecret, sha256 } from './codec.js';
-import { checkDependencies, dependencySchema } from './dependencies.js';
+import { checkDependencies, dependencySchema, portableDependencyPath } from './dependencies.js';
 import { acquireFileLock, atomicWriteFile, scopeDirectory, } from './fileStore.js';
 import { parseProjectKnowledgeSnapshot, projectKnowledgeKindSchema, restoreProjectKnowledgeSnapshot, saveProjectKnowledgeBatch, snapshotProjectKnowledge, } from './projectKnowledge.js';
 import { memoryTerms, takeTokenBudget } from './retrieval.js';
@@ -693,9 +693,10 @@ export async function recallExperiences(workspaceId, query, limit = 5) {
         const groups = new Map();
         for (const binding of bindings) {
             const previous = groups.get(binding.root);
-            const files = new Map(previous?.files.map((file) => [file.path, file]) ?? []);
+            const key = (path) => portableDependencyPath(path, binding.platform);
+            const files = new Map(previous?.files.map((file) => [key(file.path), file]) ?? []);
             for (const file of binding.files)
-                files.set(file.path, file);
+                files.set(key(file.path), file);
             groups.set(binding.root, { ...binding, files: [...files.values()] });
         }
         return {

package/src/memory/experienceStore.ts

@@ -8,7 +8,7 @@ import { readFile, readdir, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { z } from 'zod';
 import { containsForbiddenSecret, sha256 } from './codec.js';
-import { checkDependencies, dependencySchema } from './dependencies.js';
+import { checkDependencies, dependencySchema, portableDependencyPath } from './dependencies.js';
 import {
   acquireFileLock,
   atomicWriteFile,
@@ -873,10 +873,11 @@ export async function recallExperiences(
       const groups = new Map<string, (typeof bindings)[number]>();
       for (const binding of bindings) {
         const previous = groups.get(binding.root);
+        const key = (path: string) => portableDependencyPath(path, binding.platform);
         const files = new Map(
-          previous?.files.map((file) => [file.path, file]) ?? [],
+          previous?.files.map((file) => [key(file.path), file]) ?? [],
         );
-        for (const file of binding.files) files.set(file.path, file);
+        for (const file of binding.files) files.set(key(file.path), file);
         groups.set(binding.root, { ...binding, files: [...files.values()] });
       }
       return {

package/src/memory/factCandidates.js

@@ -75,6 +75,56 @@ export async function retainFactCandidate(workspaceId, proposed, reason, old, st
         return persist();
     });
 }
+/**
+ * A change candidate proposes replacing one exact statement. Once the record no
+ * longer says that — the user corrected it (to this proposal or anything else)
+ * or forgot it — the candidate is settled history, not a pending change.
+ * Surfacing it anyway kept "旧=npm" in every prompt and flagged the corrected
+ * record as unconfirmed. This is the single liveness rule for prompts, status
+ * and management views: it holds even when the correction happened in another
+ * workspace, where the candidate file itself cannot be reached.
+ */
+export function isLiveFactCandidate(item, statements) {
+    if (item.status !== 'open')
+        return false;
+    if (!item.old)
+        return true;
+    const current = statements.get(item.old.id);
+    return (current !== undefined &&
+        current === item.old.statement &&
+        current !== item.proposed.statement);
+}
+/**
+ * Persist the rule above after a record changed. A reconfirmation that keeps
+ * the statement only moves the version: refresh it so accept still works.
+ */
+export async function settleFactCandidatesFor(workspaceId, record, version) {
+    const release = await acquireFileLock(pathFor(workspaceId));
+    try {
+        const items = await factCandidates(workspaceId);
+        let changed = false;
+        for (const item of items) {
+            if (item.status !== 'open' || item.old?.id !== record.id)
+                continue;
+            if (record.statement === item.proposed.statement)
+                item.status = 'accepted';
+            else if (record.statement !== item.old.statement) {
+                item.status = 'rejected';
+                item.reason = `${item.reason}；原记录已被改写为其他内容，候选失效`;
+            }
+            else if (item.old.version !== version)
+                item.old.version = version;
+            else
+                continue;
+            changed = true;
+        }
+        if (changed)
+            await atomicWriteFile(pathFor(workspaceId), JSON.stringify(items) + '\n');
+    }
+    finally {
+        await release();
+    }
+}
 /**
  * Forgetting a record must take every candidate hanging off it too — open or
  * resolved — because each one stores the record's statement in plaintext.
@@ -125,7 +175,9 @@ export async function resolveFactCandidate(workspaceId, id, decision, signal) {
                     current.record.sourceMessageId === item.proposed.sourceMessageId &&
                     current.record.validUntil === item.proposed.validUntil;
                 if (!applied) {
-                    if (current.version !== item.old.version)
+                    // A candidate replaces a statement, not a version: reconfirming the
+                    // same statement elsewhere must not make the proposal unacceptable.
+                    if (current.record.statement !== item.old.statement)
                         throw new Error('MEMORY_VERSION_CONFLICT：原事实已改变，请重新评估');
                     const updated = await memoryService.updateWithVersion(current.record.id, current.record.scope, current.version, {
                         ...item.proposed,

package/src/memory/factCandidates.ts

@@ -103,6 +103,57 @@ export async function retainFactCandidate(
     return persist();
   });
 }
+/**
+ * A change candidate proposes replacing one exact statement. Once the record no
+ * longer says that — the user corrected it (to this proposal or anything else)
+ * or forgot it — the candidate is settled history, not a pending change.
+ * Surfacing it anyway kept "旧=npm" in every prompt and flagged the corrected
+ * record as unconfirmed. This is the single liveness rule for prompts, status
+ * and management views: it holds even when the correction happened in another
+ * workspace, where the candidate file itself cannot be reached.
+ */
+export function isLiveFactCandidate(
+  item: FactCandidate,
+  statements: ReadonlyMap<string, string>,
+): boolean {
+  if (item.status !== 'open') return false;
+  if (!item.old) return true;
+  const current = statements.get(item.old.id);
+  return (
+    current !== undefined &&
+    current === item.old.statement &&
+    current !== item.proposed.statement
+  );
+}
+/**
+ * Persist the rule above after a record changed. A reconfirmation that keeps
+ * the statement only moves the version: refresh it so accept still works.
+ */
+export async function settleFactCandidatesFor(
+  workspaceId: string,
+  record: { id: string; statement: string },
+  version: string,
+) {
+  const release = await acquireFileLock(pathFor(workspaceId));
+  try {
+    const items = await factCandidates(workspaceId);
+    let changed = false;
+    for (const item of items) {
+      if (item.status !== 'open' || item.old?.id !== record.id) continue;
+      if (record.statement === item.proposed.statement) item.status = 'accepted';
+      else if (record.statement !== item.old.statement) {
+        item.status = 'rejected';
+        item.reason = `${item.reason}；原记录已被改写为其他内容，候选失效`;
+      } else if (item.old.version !== version) item.old.version = version;
+      else continue;
+      changed = true;
+    }
+    if (changed)
+      await atomicWriteFile(pathFor(workspaceId), JSON.stringify(items) + '\n');
+  } finally {
+    await release();
+  }
+}
 /**
  * Forgetting a record must take every candidate hanging off it too — open or
  * resolved — because each one stores the record's statement in plaintext.
@@ -165,7 +216,9 @@ export async function resolveFactCandidate(
           current.record.sourceMessageId === item.proposed.sourceMessageId &&
           current.record.validUntil === item.proposed.validUntil;
         if (!applied) {
-          if (current.version !== item.old.version)
+          // A candidate replaces a statement, not a version: reconfirming the
+          // same statement elsewhere must not make the proposal unacceptable.
+          if (current.record.statement !== item.old.statement)
             throw new Error(
               'MEMORY_VERSION_CONFLICT：原事实已改变，请重新评估',
             );

package/src/memory/factLearning.js

@@ -2,7 +2,7 @@
  * its source material. A durable receipt makes retries idempotent. */
 import { readFile } from 'node:fs/promises';
 import { parseMemoryProposal } from './proposal.js';
-import { failureSchema, jobEligible, recordJobFailure, recordBackgroundLearningFailure } from './jobPolicy.js';
+import { failureSchema, isPausedJob, jobEligible, recordJobFailure, recordBackgroundLearningFailure } from './jobPolicy.js';
 import { join } from 'node:path';
 import lockfile from 'proper-lockfile';
 import { z } from 'zod';
@@ -446,7 +446,7 @@ export function scheduleFactLearning(options) {
             !settings.autoRemember ||
             !settings.factLearning)
             return;
-        const pending = (await factLearningStatus(options.workspaceId)).pending.filter(turn => !turn.failure?.paused);
+        const pending = (await factLearningStatus(options.workspaceId)).pending.filter(turn => !isPausedJob(turn));
         if (cancelled.has(directory(options.workspaceId)) ||
             running.has(directory(options.workspaceId)))
             return;

package/src/memory/factLearning.ts

@@ -2,7 +2,7 @@
  * its source material. A durable receipt makes retries idempotent. */
 import { readFile } from 'node:fs/promises';
 import { parseMemoryProposal } from './proposal.js';
-import { failureSchema, jobEligible, recordJobFailure, recordBackgroundLearningFailure } from './jobPolicy.js';
+import { failureSchema, isPausedJob, jobEligible, recordJobFailure, recordBackgroundLearningFailure } from './jobPolicy.js';
 import { join } from 'node:path';
 import lockfile from 'proper-lockfile';
 import { z } from 'zod';
@@ -585,7 +585,7 @@ export function scheduleFactLearning(
         !settings.factLearning
       )
         return;
-      const pending = (await factLearningStatus(options.workspaceId)).pending.filter(turn => !turn.failure?.paused);
+      const pending = (await factLearningStatus(options.workspaceId)).pending.filter(turn => !isPausedJob(turn));
       if (
         cancelled.has(directory(options.workspaceId)) ||
         running.has(directory(options.workspaceId))

package/src/memory/jobPolicy.js

@@ -4,24 +4,43 @@ import { retryAt } from './maintenanceQueue.js';
 export const failureSchema = z.object({
     kind: z.enum(['proposal', 'transient', 'conflict', 'unknown']),
     consecutive: z.number().int().nonnegative(),
+    /** Consecutive invalid proposals only; the pause looks at this, not `consecutive`. */
+    proposalStreak: z.number().int().nonnegative().optional(),
     paused: z.boolean(),
 });
-/** Legacy attempt counters are retained, but do not silently pause old work. */
+/**
+ * Only a source that keeps producing invalid proposals — three in a row — is
+ * parked: that failure reproduces with the same input, so retrying burns calls
+ * without progress. Other failures interleaved in the streak reset it; an
+ * outage followed by one bad answer is not a poisoned source.
+ * Timeouts, rate limits, network, conflicts and unknown errors only back off
+ * (capped at one hour by retryAt) and never pause. Pausing them used to recreate
+ * the incident the attempt cap caused: a ~16-minute provider outage parked
+ * every pending source until someone ran maintenance by hand, and TUI users
+ * get no terminal notice. Legacy attempt counters never pause old work.
+ */
 export function recordJobFailure(job, error) {
     const message = error instanceof Error ? error.message : '';
     const kind = error instanceof MemoryProposalError ? 'proposal'
         : /VERSION_CONFLICT|SOURCE_CHANGED/.test(message) ? 'conflict'
             : /timeout|超时|429|503|fetch|network|ECONN|连接/i.test(message) ? 'transient'
                 : 'unknown';
-    // Changing failure categories is not recovery. Otherwise alternating provider
-    // and proposal failures can keep a source retrying forever.
+    // Changing failure categories is not recovery: backoff keeps growing across
+    // kinds, so alternating failures cannot reset it.
     const consecutive = (job.failure?.consecutive ?? 0) + 1;
+    const previous = job.failure?.proposalStreak ?? (job.failure?.kind === 'proposal' ? 1 : 0);
+    const proposalStreak = kind === 'proposal' ? previous + 1 : 0;
     job.attempts = (job.attempts ?? 0) + 1;
-    job.failure = { kind, consecutive, paused: Boolean(job.failure?.paused) || consecutive >= (kind === 'proposal' ? 3 : 6) };
+    job.failure = { kind, consecutive, proposalStreak, paused: proposalStreak >= 3 };
     job.nextAttemptAt = retryAt(consecutive);
 }
+/** Honors only proposal pauses, so sources parked by the old policy for
+ * transient errors resume on their own after upgrade. */
+export function isPausedJob(job) {
+    return job.failure?.paused === true && job.failure.kind === 'proposal';
+}
 export function jobEligible(job, force = false, now = Date.now()) {
-    return force || (!job.failure?.paused && (job.nextAttemptAt ?? 0) <= now);
+    return force || (!isPausedJob(job) && (job.nextAttemptAt ?? 0) <= now);
 }
 const health = new Map();
 /** Background services never write over a host's TUI. Durable queues retain

package/src/memory/jobPolicy.ts

@@ -5,27 +5,47 @@ import { retryAt } from './maintenanceQueue.js';
 export const failureSchema = z.object({
   kind: z.enum(['proposal', 'transient', 'conflict', 'unknown']),
   consecutive: z.number().int().nonnegative(),
+  /** Consecutive invalid proposals only; the pause looks at this, not `consecutive`. */
+  proposalStreak: z.number().int().nonnegative().optional(),
   paused: z.boolean(),
 });
 type Job = { attempts?: number; nextAttemptAt?: number; failure?: z.infer<typeof failureSchema> };
 
-/** Legacy attempt counters are retained, but do not silently pause old work. */
+/**
+ * Only a source that keeps producing invalid proposals — three in a row — is
+ * parked: that failure reproduces with the same input, so retrying burns calls
+ * without progress. Other failures interleaved in the streak reset it; an
+ * outage followed by one bad answer is not a poisoned source.
+ * Timeouts, rate limits, network, conflicts and unknown errors only back off
+ * (capped at one hour by retryAt) and never pause. Pausing them used to recreate
+ * the incident the attempt cap caused: a ~16-minute provider outage parked
+ * every pending source until someone ran maintenance by hand, and TUI users
+ * get no terminal notice. Legacy attempt counters never pause old work.
+ */
 export function recordJobFailure(job: Job, error: unknown): void {
   const message = error instanceof Error ? error.message : '';
   const kind = error instanceof MemoryProposalError ? 'proposal'
     : /VERSION_CONFLICT|SOURCE_CHANGED/.test(message) ? 'conflict'
     : /timeout|超时|429|503|fetch|network|ECONN|连接/i.test(message) ? 'transient'
     : 'unknown';
-  // Changing failure categories is not recovery. Otherwise alternating provider
-  // and proposal failures can keep a source retrying forever.
+  // Changing failure categories is not recovery: backoff keeps growing across
+  // kinds, so alternating failures cannot reset it.
   const consecutive = (job.failure?.consecutive ?? 0) + 1;
+  const previous = job.failure?.proposalStreak ?? (job.failure?.kind === 'proposal' ? 1 : 0);
+  const proposalStreak = kind === 'proposal' ? previous + 1 : 0;
   job.attempts = (job.attempts ?? 0) + 1;
-  job.failure = { kind, consecutive, paused: Boolean(job.failure?.paused) || consecutive >= (kind === 'proposal' ? 3 : 6) };
+  job.failure = { kind, consecutive, proposalStreak, paused: proposalStreak >= 3 };
   job.nextAttemptAt = retryAt(consecutive);
 }
 
+/** Honors only proposal pauses, so sources parked by the old policy for
+ * transient errors resume on their own after upgrade. */
+export function isPausedJob(job: Job): boolean {
+  return job.failure?.paused === true && job.failure.kind === 'proposal';
+}
+
 export function jobEligible(job: Job, force = false, now = Date.now()): boolean {
-  return force || (!job.failure?.paused && (job.nextAttemptAt ?? 0) <= now);
+  return force || (!isPausedJob(job) && (job.nextAttemptAt ?? 0) <= now);
 }
 
 type Partition = 'facts' | 'experience';