@team-harness/memory-algorithms 0.1.0 → 0.1.1

package/README.md

@@ -26,7 +26,7 @@ npm pack
 在你的应用目录安装生成的文件：
 
 ```sh
-npm install /path/to/memory-algorithms/team-harness-memory-algorithms-0.1.0.tgz
+npm install /path/to/memory-algorithms/team-harness-memory-algorithms-0.1.1.tgz
 ```
 
 ## 提取流程
@@ -172,6 +172,10 @@ L1 的 `update` / `merge` 会产生新的 `after.id`，不是原 ID 就地更新
 
 失败或取消时没有可提交变更，不推进分析进度。参数或依赖配置错误也可能直接抛出异常，调用层仍需捕获异常。L3 和 Skill 是候选，是否启用由应用决定。
 
+L1 提取调用使用窗口内的短编号：`N1/N2/...` 对应本批新消息，`B1/B2/...` 对应仅供理解上下文的背景消息。模型只能引用合法的 `N` 编号；Lib 校验后恢复调用方提供的完整消息 ID，再进行去重和结果构建。输入、消息正文、最终 `source_message_ids`、`evidence`、`coverage` 均不改用短编号。编号每个窗口独立生成，同窗口重试沿用同一映射；调用方无需适配。
+
+L1 模型输出引用了本批新消息以外的编号，或记忆缺少来源编号时，会在剩余预算内最多重新生成一次，并显式给出合法编号列表。额外调用计入同一次运行的耗时、调用数和 token 用量；再次校验失败仍不返回变更。不会猜测替换编号、删除错误引用或跳过失败批次。`diagnostics` 会记录纠正尝试。
+
 L1 的证据按记录关联；L2/L3/Skill 使用保守的整次运行输入依赖，不是逐句引用。`provenance.evidenceGranularity` 标明 `record` 或 `run`；token 用量无法取得时为 `null`。
 
 ## 分批、预算与取消

package/dist/runtime/l1.js

@@ -59,9 +59,19 @@ export function validateMessages(messages) {
     }
     uniqueRefs(messages.flatMap(m => m.evidence));
 }
+function evidenceError(parsed, allowed) {
+    for (const scene of parsed.scenes) {
+        if (scene.message_ids.some(id => !allowed.has(id)))
+            return "Scene cites evidence outside new messages";
+        for (const memory of scene.memories) {
+            if (!memory.source_message_ids.length || memory.source_message_ids.some(id => !allowed.has(id)))
+                return "Memory cites evidence outside new messages";
+        }
+    }
+}
 export async function extractL1(deps, input) {
     input = { ...input, messages: structuredClone(input.messages), strategy: structuredClone(input.strategy) };
-    const inputHash = hash({ scopeKey: input.scopeKey, mode: input.mode ?? "code", messages: input.messages, strategy: input.strategy,
+    const inputHash = hash({ citationEncoding: "short-message-ids-v1", scopeKey: input.scopeKey, mode: input.mode ?? "code", messages: input.messages, strategy: input.strategy,
         maxNewMessages: input.maxNewMessages ?? 10, maxBackgroundMessages: input.maxBackgroundMessages ?? 5, conflictRecallTopK: input.conflictRecallTopK ?? 5 });
     const run = new Run(deps, input, "l1", inputHash);
     const cov = coverage(input.messages.map(m => m.id));
@@ -86,25 +96,39 @@ export async function extractL1(deps, input) {
         const extracted = [];
         let sceneNames = [];
         if (fresh.length) {
+            // Labels belong only to this window; restore validated references before dedup and persistence.
+            const sourceIds = new Map(fresh.map((message, index) => [`N${index + 1}`, message.id]));
+            const newMessages = fresh.map((message, index) => ({ ...message, id: `N${index + 1}` }));
+            const backgroundMessages = background.map((message, index) => ({ ...message, id: `B${index + 1}` }));
             const system = composeMemorySystemPrompt(getExtractMemoriesSystemPrompt(input.mode ?? "code"), input.strategy);
-            const raw = await run.model(system, formatExtractionPrompt({ newMessages: fresh, backgroundMessages: background, previousSceneName: input.continuation?.previousSceneName }));
-            const parsed = parseExtractionResult(raw);
+            const prompt = formatExtractionPrompt({ newMessages, backgroundMessages, previousSceneName: input.continuation?.previousSceneName });
+            let parsed = parseExtractionResult(await run.model(system, prompt));
             if (parsed.emptyReason && parsed.emptyReason !== "empty_scenes")
                 throw new Error(`L1 parse failed: ${parsed.emptyReason}`);
+            const allowed = new Set(sourceIds.keys());
+            const invalid = evidenceError(parsed, allowed);
+            // Regenerate once within the same run budget; never repair citations by guessing or dropping IDs.
+            if (invalid) {
+                if (run.calls >= run.limits.maxCalls)
+                    throw new Error(invalid);
+                run.diagnostics.push(`${invalid}; regenerating once with explicit allowed message IDs`);
+                const correction = `\n\nEvidence validation rejected the previous response. Regenerate the complete JSON result from the messages above. Both scene.message_ids and memory.source_message_ids must contain only exact IDs from this JSON array: ${JSON.stringify([...allowed])}. Do not use IDs mentioned inside message bodies, background IDs, altered labels, or invented IDs. Every memory must cite at least one allowed ID. Return [] only if the new messages contain no extractable memories.`;
+                parsed = parseExtractionResult(await run.model(system, prompt + correction));
+                if (parsed.emptyReason && parsed.emptyReason !== "empty_scenes")
+                    throw new Error(`L1 parse failed: ${parsed.emptyReason}`);
+                const remainingError = evidenceError(parsed, allowed);
+                if (remainingError)
+                    throw new Error(remainingError);
+            }
             sceneNames = parsed.scenes.map(s => s.scene_name);
-            const allowed = new Set(fresh.map(m => m.id));
             for (const scene of parsed.scenes) {
-                if (scene.message_ids.some(id => !allowed.has(id)))
-                    throw new Error("Scene cites evidence outside new messages");
                 for (const memory of scene.memories) {
                     const type = normalizeType(memory.type);
                     if (!type)
                         throw new Error("Invalid memory type");
-                    if (!memory.source_message_ids.length || memory.source_message_ids.some(id => !allowed.has(id)))
-                        throw new Error("Memory cites evidence outside new messages");
                     if (!Number.isFinite(memory.priority) || memory.priority < -1 || memory.priority > 100)
                         throw new Error("Invalid priority");
-                    extracted.push({ ...memory, metadata: memory.metadata, type, scene_name: scene.scene_name, record_id: run.id() });
+                    extracted.push({ ...memory, source_message_ids: memory.source_message_ids.map(id => sourceIds.get(id)), metadata: memory.metadata, type, scene_name: scene.scene_name, record_id: run.id() });
                     if (extracted.length > run.limits.maxExtractedMemories)
                         throw new Error("Extracted memory budget exhausted");
                 }

package/dist/runtime/run.d.ts

@@ -1,6 +1,6 @@
 import type { Change, Coverage, Dependencies, ExtractionResult, Limits, RunInput, Stage, VersionRef } from "../contracts.js";
 import type { LocalTool } from "./tools.js";
-export declare const ALGORITHM_VERSION = "0.1.0";
+export declare const ALGORITHM_VERSION = "0.1.1";
 export declare const UPSTREAM_COMMIT = "906b5823b5106eed8f842b62f16d23228838149a";
 export declare function hash(value: unknown): string;
 export declare function uniqueRefs<T extends {

package/dist/runtime/run.js

@@ -1,6 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
 import { Ajv } from "ajv";
-export const ALGORITHM_VERSION = "0.1.0";
+export const ALGORITHM_VERSION = "0.1.1";
 export const UPSTREAM_COMMIT = "906b5823b5106eed8f842b62f16d23228838149a";
 export function hash(value) {
     return createHash("sha256").update(JSON.stringify(value, (_key, item) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-harness/memory-algorithms",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Host-independent L1/L2/L3 and Skill extraction derived from TencentDB-Agent-Memory",
   "type": "module",
   "license": "MIT",

package/upstream/baseline.json

@@ -353,7 +353,7 @@
       "destinations": [
         "src/runtime/l1.ts"
       ],
-      "adaptation": "A01/A02/B01/B02: host-neutral orchestration; see changes.md"
+      "adaptation": "A01/A02/B01/B02/B04/B05: host-neutral orchestration; bounded evidence correction and model-side short message labels; see changes.md"
     },
     {
       "sourcePath": "MemoryCore/src/core/record/l1-writer.ts",

package/upstream/changes.md

@@ -4,6 +4,26 @@
 
 原始模块及 hash 见 baseline.json；sourceSha256 对应上游原文，copiedSha256 记录首次提取/裁切的中间内容，adaptedSha256 记录当前已登记的适配内容。Git 历史先独立提交完整上游原文副本（chore(lib): record upstream algorithm source baseline），再提交可运行适配，能够直接比较两者。通过 `git log -- Lib`（父仓库）或独立仓库 Git 历史追溯。
 
+## B05：L1 模型侧短消息编号（2026-09-16）
+
+分类：behavior-change / host-contract。位置：`src/runtime/l1.ts`；不修改复制的上游提示词和解析器。
+
+仅在 L1 提取请求中将筛选后的新消息标识替换为 N1/N2/...，背景标识替换为 B1/B2/...。映射仅保留在本次调用内，B04 重试复用同一映射。所有场景和记忆引用先按新消息编号校验；记忆来源恢复真实 ID 后才进入召回、去重和变更构建。背景编号、错误编号及非编号形式的真实 ID 均不作为回退接受。消息正文不替换，最终来源、证据版本和覆盖范围保持真实 ID。
+
+输入 hash 增加 citationEncoding 标记，拒绝旧编码模式的 continuation。外部函数签名不变；自定义模型适配器应原样传输请求和响应，不得自行替换编号。短编号不应用到 L2/L3/Skill 或去重候选的实体 ID。
+
+差分与成对回放增加显式的测试侧 citation bridge：严格核对整个原始提示词，仅重建消息标识并结构化转换提取响应的引用数组。原 cassette 保留且仍受 hash 门禁约束；正文、去重调用和解析失败原文不被替换。报告明确区分原始提示词不相等与编号转换后等价，不把编号变化当作逐字上游一致。
+
+## B04：L1 引用越界的有界纠正（2026-09-16）
+
+分类：bug-fix / behavior-change / host-contract。位置：`src/runtime/l1.ts`，来源仍为已登记的 L1 extractor。
+
+本地 Loop 的分析记录显示第一批模型调用因场景引用越界失败（892 条待处理，0 条完成，1 次调用）。未持久化原始失败响应，不能断言模型引用了正文中的 ID、缩写 ID 或背景 ID。
+
+首次调用保持上游提示词和输入格式。场景或记忆证据校验失败时，在同一个 Run 剩余预算内最多重新生成一次，附加精确的合法消息 ID 列表及引用规则。重试受原超时、调用数、输入和输出上限约束，token 和提示词 hash 均记录。上游没有此纠正步骤，这是 Lib 的显式适配；不改复制的上游源码，也不放宽 B01 的证据范围。
+
+禁止替换、过滤无效 ID 后提交，禁止失败批次推进进度。第二次仍无效、解析失败或取消时返回无变更。回归覆盖场景/记忆越界、空来源、背景及未来 ID、预算耗尽、取消、用量合计、失败覆盖范围；原成功路径继续由差分和固定响应回放验证。
+
 ## A01：算法与持久化拆分
 
 分类：dependency-adaptation / host-contract。