dsh-lite-memory 0.11.1 → 0.16.2

package/learning.js

@@ -160,25 +160,13 @@ export function normalizeConditions(conditions) {
 /** 构造一次受限调用输入：无工具、无前台历史，只有身份、少量规则和反馈映射。 */
 export function buildCallInput({ projectId, episodeId, taskKind, seriesId, phase, feedback, rules, ranges, maxBytes = LIMITS.inputBytes } = {}) {
   const refs = { feedback: {}, rules: {} };
-  const inputRules = [];
-  let index = 0;
-  for (const record of Array.isArray(rules) ? rules : []) {
-    if (!record || !record.id) continue;
-    if (index >= 6) break;
-    const ref = `r${index}`;
-    refs.rules[ref] = record.id;
-    inputRules.push({
-      ref,
-      revision: record.revision || 1,
-      title: bounded(record.title, 60),
-      summary: bounded(record.summary, 120),
-      body: bounded(record.body, 360),
-      applicability: record.applicability || 'unresolved',
-      conditions: normalizeConditions(record.conditions),
-      state: record.learning?.state || record.state || 'trial',
-    });
-    index += 1;
-  }
+  const source = (Array.isArray(rules) ? rules : []).filter((record) => record && record.id);
+  /** 用户这次纠正涉及的规则先入输入：固定取前 6 条会把真正相关的旧经验挤掉。 */
+  const dimension = String(feedback?.cue?.dimension || '');
+  const prioritized = dimension
+    ? [...source.filter((record) => `${record.title || ''}${record.summary || ''}${record.body || ''}`.includes(dimension)),
+      ...source.filter((record) => !`${record.title || ''}${record.summary || ''}${record.body || ''}`.includes(dimension))]
+    : source;
   refs.feedback.u0 = feedback.messageIds[0] || '';
   const project = {
     projectId: bounded(projectId, 80),
@@ -193,10 +181,11 @@ export function buildCallInput({ projectId, episodeId, taskKind, seriesId, phase
     phase: PHASES.slice(),
   };
   const system = '你是项目记忆整理器，只输出 JSON。只能依据给定反馈修改已有规则或新建一条项目规则；不得调用工具，不得输出 JSON 之外的文字。没有可确定的长期变化时输出 {"changes":[]}。';
-  const payload = {
-    project,
-    feedback: { refs: [['u0', feedback.text.slice(0, 600)]], type: feedback.cue?.type || 'unclear', longTerm: Boolean(feedback.cue?.explicitLongTerm) },
-    rules: inputRules,
+  const feedbackHead = {
+    type: feedback.cue?.type || 'unclear',
+    longTerm: Boolean(feedback.cue?.explicitLongTerm),
+  };
+  const tail = {
     allowed: { conditions: view.CONDITION_KEYS, ranges: rangesInput, maxChanges: LIMITS.maxChanges, execution_miss: '仅已有规则，currentText 写检查点', artifact_accept: '仅已有规则，记验收样例' },
     output: {
       changes: [{
@@ -204,19 +193,49 @@ export function buildCallInput({ projectId, episodeId, taskKind, seriesId, phase
       }],
     },
   };
-  let prompt = JSON.stringify(payload);
-  while (Buffer.byteLength(system) + Buffer.byteLength(prompt) > maxBytes && prompt.length > 600) {
-    prompt = prompt.slice(0, Math.floor(prompt.length * 0.85));
+  const render = (selected, feedbackText) => JSON.stringify({
+    project,
+    feedback: { ...feedbackHead, refs: [['u0', feedbackText]] },
+    rules: selected,
+    ...tail,
+  });
+  /** 反馈正文按整段回退，不切开 JSON；仍放不下就是本次调用不可行。 */
+  let feedbackText = bounded(feedback.text, 600);
+  let prompt = render([], feedbackText);
+  while (Buffer.byteLength(system) + Buffer.byteLength(prompt) > maxBytes && feedbackText.length > 0) {
+    feedbackText = feedbackText.slice(0, Math.floor(feedbackText.length * 0.6));
+    prompt = render([], feedbackText);
+  }
+  if (Buffer.byteLength(system) + Buffer.byteLength(prompt) > maxBytes) {
+    return { system, prompt: '', messages: [], refs, rules: [], bytes: Buffer.byteLength(system), overLimit: true };
+  }
+  const inputRules = [];
+  for (const record of prioritized.slice(0, 6)) {
+    const ref = `r${inputRules.length}`;
+    refs.rules[ref] = record.id;
+    const row = {
+      ref,
+      revision: record.revision || 1,
+      title: bounded(record.title, 60),
+      summary: bounded(record.summary, 120),
+      body: bounded(record.body, 360),
+      applicability: record.applicability || 'unresolved',
+      conditions: normalizeConditions(record.conditions),
+      state: record.learning?.state || record.state || 'trial',
+    };
+    const next = render([...inputRules, row], feedbackText);
+    if (Buffer.byteLength(system) + Buffer.byteLength(next) > maxBytes) break;
+    inputRules.push(row);
+    prompt = next;
   }
   return { system, prompt, messages: [{ role: 'user', content: prompt }], refs, rules: inputRules, bytes: Buffer.byteLength(system) + Buffer.byteLength(prompt) };
 }
-
 /** 严格解析：截断、工具调用、额外字段、超限都整批拒绝，不做第二次修复调用。 */
 export function parseOutput(text, { finish, refs, rules, ranges } = {}) {
   if (finish && finish.kind !== 'stop' && finish.kind !== 'completed') return { ok: false, reason: '整理没有正常结束' };
   const raw = String(text || '').trim();
   if (!raw) return { ok: false, reason: '整理没有返回内容' };
-  if (raw.length > LIMITS.outputBytes) return { ok: false, reason: '整理输出太长' };
+  if (Buffer.byteLength(raw, 'utf8') > LIMITS.outputBytes) return { ok: false, reason: '整理输出太长' };
   if (/<[^>]+>/.test(raw) && !raw.startsWith('{')) return { ok: false, reason: '整理返回了工具调用' };
   let data;
   try {
@@ -388,23 +407,29 @@ export function addCheckpoint(learning, checkpoint = {}) {
 }
 
 /** 状态只看证据强度：明确长期要求或两个独立作品才 active；条件不确定就 pending。 */
-export function nextLearningState({ existing, change, evidence, now } = {}) {
+export function nextLearningState({ existing, change, evidence, now, specChanged = false } = {}) {
   const at = new Date(now || Date.now()).toISOString();
   const learning = existing?.learning ? JSON.parse(JSON.stringify(existing.learning)) : { state: 'pending', supportedEpisodeIds: [], evidence: [] };
   const priorState = LEARNING_STATES.includes(learning.state) ? learning.state : 'pending';
-  const episodes = Array.isArray(learning.supportedEpisodeIds) ? learning.supportedEpisodeIds.slice() : [];
+  /** 规范正文或适用条件变了：旧证据不再支持新规范，只保留本次这一条。 */
+  const episodes = specChanged ? [] : (Array.isArray(learning.supportedEpisodeIds) ? learning.supportedEpisodeIds.slice() : []);
   if (evidence?.episodeId && !episodes.includes(evidence.episodeId)) episodes.push(evidence.episodeId);
-  const anchors = Array.isArray(learning.evidence) ? learning.evidence.slice() : [];
+  const anchors = specChanged ? [] : (Array.isArray(learning.evidence) ? learning.evidence.slice() : []);
   if (evidence?.episodeId && !anchors.some((row) => row.episodeId === evidence.episodeId)) anchors.push(evidence);
   learning.supportedEpisodeIds = episodes.slice(-LIMITS.evidence);
   learning.evidence = anchors.slice(-LIMITS.evidence).map((row) => ({ ...row }));
   learning.updatedAt = at;
   learning.lastFeedbackType = change?.feedbackType || learning.lastFeedbackType || '';
   if (change?.currentText) learning.lastText = change.currentText;
-  if (priorState === 'paused') {
+  if (priorState === 'paused' && !specChanged && !Boolean(evidence?.explicitLongTerm)) {
     learning.state = 'paused';
     return learning;
   }
+  if (priorState === 'paused') {
+    delete learning.blockedReason;
+    delete learning.pausedAt;
+    delete learning.pausedBy;
+  }
   const conditions = normalizeConditions(change?.conditions !== undefined ? change.conditions : existing?.conditions);
   const determinate = (change?.applicability || existing?.applicability) === 'conditional' && conditions.length > 0;
   const explicit = Boolean(evidence?.explicitLongTerm);
@@ -425,6 +450,7 @@ export function nextLearningState({ existing, change, evidence, now } = {}) {
   })) learning.state = 'trial';
   else learning.state = 'pending';
   if (learning.state === 'trial') learning.trialUntil = new Date((now || Date.now()) + LIMITS.trialMs).toISOString();
+  else delete learning.trialUntil;
   if (learning.state === 'active') {
     learning.acceptedAt = learning.acceptedAt || at;
     delete learning.trialUntil;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-lite-memory",
-  "version": "0.11.1",
+  "version": "0.16.2",
   "description": "On-demand memory for the DeepSeek Harness: nothing in the system prompt, one muted line only when something is saved, hit or suggested.",
   "type": "module",
   "main": "index.js",
@@ -8,7 +8,7 @@
     "dsh": ">=0.1.5"
   },
   "scripts": {
-    "test": "node test/store.test.mjs && node test/state.test.mjs && node test/view.test.mjs && node test/anchor.test.mjs && node test/recall.test.mjs && node test/evolution-read.test.mjs && node test/learning.test.mjs && node test/scenario.test.mjs && node test/crossing.test.mjs && node test/client.test.mjs && node test/contract.test.mjs",
+    "test": "node test/store.test.mjs && node test/state.test.mjs && node test/view.test.mjs && node test/anchor.test.mjs && node test/recall.test.mjs && node test/evolution-read.test.mjs && node test/lexical.test.mjs && node test/control.test.mjs && node test/learning.test.mjs && node test/scenario.test.mjs && node test/crossing.test.mjs && node test/client.test.mjs && node test/contract.test.mjs",
     "bench": "node bench/bench.mjs",
     "bench:evolution": "node bench/evolution.mjs"
   },

package/state.js

@@ -99,7 +99,51 @@ export function evolutionOf(state) {
   };
 }
 
-/** 开关事务里的纯状态部分：旋转 epoch、推进反馈代次；关闭时把试用条目转暂停待复核。 */
+/**
+ * 项目记忆总开关：缺字段按开启处理，老状态不用迁移。
+ * 它管这一层的所有读取、写入、召回和学习；全局层仍按发起项目判断，不跟着关。
+ */
+export function controlOf(state) {
+  const raw = state && state.control;
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+    return { enabled: true, epoch: '', changedAt: '', compatible: true };
+  }
+  return {
+    enabled: raw.enabled !== false,
+    epoch: typeof raw.epoch === 'string' ? raw.epoch : '',
+    changedAt: typeof raw.changedAt === 'string' ? raw.changedAt : '',
+    compatible: true,
+  };
+}
+
+/**
+ * 关总开关只是收回授权：候选、试用、生效规则、证据、默认绑定和已用额度都保留，
+ * 只清运行层（在途整理、临时锚点、旧召回快照）。重新打开也换代次，关闭前排队的任务不能补交。
+ * 自进化跟随总开关一起停：重新打开记忆后，自进化仍是关闭的，等用户单独开启。
+ */
+export function applyControl(draft, enabled) {
+  const now = new Date().toISOString();
+  const current = controlOf(draft);
+  const next = Boolean(enabled);
+  if (current.enabled === next) return { changed: false, enabled: next };
+  const config = { enabled: next, epoch: crypto.randomUUID(), changedAt: now };
+  draft.control = config;
+  const evolution = draft.experimental && draft.experimental.projectEvolution;
+  if (evolution && typeof evolution === 'object' && !Array.isArray(evolution)) {
+    const ledger = normalizeLearning(evolution.learning);
+    evolution.enabled = false;
+    evolution.epoch = crypto.randomUUID();
+    evolution.feedbackGeneration = Number.isInteger(evolution.feedbackGeneration) ? evolution.feedbackGeneration + 1 : 1;
+    evolution.changedAt = now;
+    /** 默认绑定属于已确认结果；临时锚点和在途观察不属于。 */
+    evolution.tasks = { ...emptyTasks(), ...(evolution.tasks && evolution.tasks.defaults ? { defaults: evolution.tasks.defaults } : {}) };
+    /** 额度只增不减：次数与回执留着，最近观察清掉。 */
+    evolution.learning = { ...ledger, recent: [] };
+  }
+  return { changed: true, enabled: next, epoch: config.epoch };
+}
+
+/** 自进化开关只停运行层：规则、候选、试用、证据和额度都保留，恢复时接着用。 */
 export function applyEvolution(draft, enabled) {
   const now = new Date().toISOString();
   const current = evolutionOf(draft);
@@ -114,10 +158,11 @@ export function applyEvolution(draft, enabled) {
     changedAt: now,
     /** 开与关都让上一轮锚点失效；已经确认的项目默认保留，它不属于临时作品状态。 */
     tasks: { ...emptyTasks(), ...(current.tasks && current.tasks.defaults ? { defaults: current.tasks.defaults } : {}) },
-    /** 关开不继承在途整理与旧提案；已学规则的来源与版本仍留在条目里。 */
-    learning: emptyLearning(),
+    /** 只清在途观察；已学规则的来源、版本和候选都在条目里，关开不动它们。 */
+    learning: { ...normalizeLearning(current.learning), recent: [] },
   };
   draft.experimental = { ...(draft.experimental || {}), projectEvolution: config };
+  /** 显式关闭自进化：试用转暂停待复核，不删除候选与证据；重新打开后可逐条恢复。 */
   if (!next) {
     for (const entry of draft.entries) {
       const learning = entry && entry.maintenance && entry.maintenance.learning;
@@ -128,9 +173,6 @@ export function applyEvolution(draft, enabled) {
         learning.pausedBy = 'experiment_off';
       }
     }
-    /** 未提交的候选随关闭清掉，不保留一份看不见却还能被旧提案命中的正文。 */
-    draft.entries = draft.entries.filter((entry) => !(entry && entry.maintenance && entry.maintenance.learning && entry.maintenance.learning.state === 'pending'));
-    draft.candidates = draft.candidates.filter((row) => !row || row.origin !== 'project_evolution');
   }
   return { changed: true, enabled: next, epoch: config.epoch };
 }
@@ -142,7 +184,7 @@ export const LIMITS = {
   hardEntries: 1000,
   entryBytes: 4096,
   recordBytes: 10 * 1024,
-  totalBytes: 512 * 1024,
+  totalBytes: 1024 * 1024,
   historyBytes: 512 * 1024,
   stateBytes: 2 * 1024 * 1024,
   titleChars: 60,
@@ -234,7 +276,10 @@ export function resolveRoot(cwd, options = {}) {
   const explicit = options.projectRoot ? realpathOf(path.resolve(options.projectRoot)) : '';
   if (explicit) return { root: explicit, source: 'configured', confirmed: true };
   const configured = configuredRoot();
-  if (configured) return { root: configured, source: 'configured', confirmed: true };
+  /** 覆盖根只对它所在的子树生效：别的目录不能被一个全局配置并成同一个项目。 */
+  if (configured && (requested === configured || requested.startsWith(`${configured}${path.sep}`))) {
+    return { root: configured, source: 'configured', confirmed: true };
+  }
   const cacheKey = `${options.workspaceDir || ''}\n${requested}`;
   if (rootCache.has(cacheKey)) return rootCache.get(cacheKey);
   let resolved;
@@ -272,6 +317,53 @@ export function globalScope() {
   return { key: 'global', dir: path.join(memoryRoot(), 'global'), cwd: '', rootSource: 'global', confirmed: true };
 }
 
+/**
+ * 管理面枚举：只读已有 state.json 的项目层，不迁移旧格式、不创建目录。
+ * 损坏或读不出的层跳过；列表按更新时间倒序，limit 防一次扫太多。
+ */
+export function knownProjectScopes(limit = 40) {
+  const root = memoryRoot();
+  let names;
+  try {
+    names = fs.readdirSync(root, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const rows = [];
+  for (const item of names) {
+    if (!item.isDirectory() || item.name === 'global' || item.name === 'sessions' || item.name.startsWith('.')) continue;
+    const dir = path.join(root, item.name);
+    const file = path.join(dir, 'state.json');
+    try {
+      if (!fs.statSync(file).isFile()) continue;
+    } catch {
+      continue;
+    }
+    let state;
+    try {
+      state = readEnvelope(file);
+    } catch {
+      continue;
+    }
+    if (!state) continue;
+    const entries = Array.isArray(state.entries) ? state.entries : [];
+    const active = entries.filter((entry) => entry.status !== 'archived');
+    const evolution = state.experimental && state.experimental.projectEvolution ? state.experimental.projectEvolution : {};
+    rows.push({
+      key: item.name,
+      dir,
+      cwd: typeof state.cwd === 'string' ? state.cwd : '',
+      updatedAt: state.updatedAt || '',
+      entries: active.length,
+      archived: entries.length - active.length,
+      experimental: active.filter((entry) => entry.origin === 'project_evolution' || Boolean(entry.learning)).length,
+      enabled: evolution.enabled === true,
+    });
+  }
+  rows.sort((a, b) => String(b.updatedAt).localeCompare(String(a.updatedAt)));
+  return rows.slice(0, Math.max(1, limit));
+}
+
 const stateFile = (scope) => path.join(scope.dir, 'state.json');
 const prevFile = (scope) => path.join(scope.dir, 'state.prev.json');
 const lockFile = (scope) => path.join(scope.dir, '.lock');
@@ -370,6 +462,7 @@ export function emptyState(scope) {
     candidates: [],
     receipts: [],
     suppressions: [],
+    control: { enabled: true, epoch: crypto.randomUUID(), changedAt: now },
     experimental: { projectEvolution: newEvolution() },
   };
 }
@@ -654,10 +747,12 @@ export function enforceBudget(state, scope) {
     const active = state.entries.filter((entry) => entry.status === 'active');
     const bytes = active.reduce((sum, entry) => sum + entryBytesOf(entry), 0);
     if (active.length <= LIMITS.hardEntries && bytes <= LIMITS.totalBytes) break;
-    const idle = active.filter((entry) => now - entryLastTouch(entry) >= IDLE_MS);
-    const pool = idle.length ? idle : active;
+    /** 用户固定过的规则不参与容量腾挪；只从没固定的条目里选最久没读的。 */
+    const movable = active.filter((entry) => entry.maintenance?.learning?.pinned !== true);
+    if (!movable.length) throw new StateError('budget_exhausted', '记忆库已满，固定住的规则不参与腾挪：先取消固定或精简正文');
+    const idle = movable.filter((entry) => now - entryLastTouch(entry) >= IDLE_MS);
+    const pool = idle.length ? idle : movable;
     const victim = pool.reduce((oldest, entry) => (entryLastTouch(entry) < entryLastTouch(oldest) ? entry : oldest));
-    if (!victim) throw new StateError('budget_exhausted', `记忆库已满：这一条自己就超过 ${LIMITS.totalBytes} 字节正文预算，先精简正文`);
     victim.status = 'archived';
     victim.updatedAt = new Date().toISOString();
     evicted.push({ id: victim.id, title: victim.current.title });
@@ -1350,6 +1445,12 @@ export function purge(scope, options = {}) {
       at: now,
     }];
     draft.epoch = intent.toEpoch;
+    /** 彻底删除也要作废本轮实验凭证：旧 contextId / 在途整理不能把刚删的规则带回来。 */
+    const evolution = draft.experimental && draft.experimental.projectEvolution;
+    if (evolution && evolution.enabled === true) {
+      evolution.epoch = crypto.randomUUID();
+      evolution.feedbackGeneration = (Number(evolution.feedbackGeneration) || 0) + 1;
+    }
     draft.generation = loaded.state.generation + 1;
     draft.updatedAt = now;
     validateState(draft);