berry-agent 0.1.0-alpha.1

package/dist/memory/pollution.js

@@ -0,0 +1,59 @@
+/**
+ * polluted 会话资格件（06 §4.1 + 批 18c-5 落码定形注——外部源内容不做记忆
+ * 提取源的资格检查；两路入口〔即时路编排首步/周期路 fire 首步〕同一检查）。
+ *
+ * **判据通配条目机制**：通配形 '*__*'（'*' → 任意子串，无 '*' = 精确名）；
+ * 起草值 `['fetch', 'mcp', '*__*']`——'fetch'/'mcp' 精确名（web fetch 工具与
+ * MCP 目录工具）+ '*__*' = MCP 复合键全族（`server__tool`——服务器键无
+ * 下划线，'__' 子串即复合键指纹）。清单常量可注入（判据演进不改机制）。
+ *
+ * **标记位 = tool/call 事件**（载荷携 name——周期路编排件消费 durable 事件
+ * 流时逐条喂 markIfPolluted；即时路不标记只查态）。**会话资格态 v1 = 进程
+ * 内存 Map**（重启回退 eligible——pollution 判定是会话进行时的护栏不是终审，
+ * 回退代价 = 至多一轮提取，不违背「durable 之外零新真值」红线：判据事件
+ * durable 而资格态是派生缓存）。**单向转移幂等**：eligible → polluted 一路，
+ * 无回退（污染不可逆——会话内外部源内容已混入，宁弃一轮不可误提）。
+ */
+import { MEMORY_POLLUTION_DEFAULT_PATTERNS } from './types.js';
+/** 正则元字符转义（通配拆段后逐段转义——'*' 之外的元字符按字面量） */
+function escapeRe(segment) {
+    return segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * 通配判据匹配（'*' → 任意子串）：无 '*' = 精确名比对；含 '*' 按 `^…$` 全串
+ * 锚定（'*__*' = 含 '__' 子串的任意名——MCP 复合键全族）。
+ */
+export function matchesToolPattern(toolName, pattern) {
+    if (!pattern.includes('*'))
+        return toolName === pattern;
+    const re = new RegExp(`^${pattern.split('*').map(escapeRe).join('.*')}$`);
+    return re.test(toolName);
+}
+/** 工具名是否命中 polluted 判据（缺省表 = 起草值；patterns 注入可覆盖） */
+export function isPollutingToolName(toolName, patterns = MEMORY_POLLUTION_DEFAULT_PATTERNS) {
+    return patterns.some((p) => matchesToolPattern(toolName, p));
+}
+/** 建会话资格追踪器（进程单例——周期路编排件内建，装配面亦可外置注入） */
+export function createPollutionTracker(deps = {}) {
+    const patterns = deps.patterns ?? MEMORY_POLLUTION_DEFAULT_PATTERNS;
+    const states = new Map();
+    return {
+        classify(sessionId) {
+            return states.get(sessionId) ?? 'eligible';
+        },
+        isPolluted(sessionId) {
+            return (states.get(sessionId) ?? 'eligible') === 'polluted';
+        },
+        markIfPolluted(sessionId, toolName) {
+            if ((states.get(sessionId) ?? 'eligible') === 'polluted')
+                return false; // 幂等——已污染零动作
+            if (!isPollutingToolName(toolName, patterns))
+                return false;
+            states.set(sessionId, 'polluted'); // 单向转移——无回退
+            return true;
+        },
+        pollutedSessions() {
+            return [...states.entries()].filter(([, s]) => s === 'polluted').map(([id]) => id);
+        },
+    };
+}

package/dist/memory/port.js

@@ -0,0 +1,385 @@
+/**
+ * memory 导入导出件（批 18c-8——06 §3 文件导入导出条 + 落码定形注）。
+ *
+ * **格式**：JSONL + 首行 header meta（magic 串 `berry-agent-memory`、
+ * formatVersion 2——批 ev-1 版本链随包升版；v1 旧件按版本判读收〔无
+ * versions/valid_from 键〕——判读靠 formatVersion 字段正是「第一天定死
+ * 不留旧格式匹配兼容层」的机制用途）；数据行 = 蛇列名全列（与 DDL 同源的
+ * 持久互操作词面），全状态现行值按 id 升序确定性排列（可 diff）。
+ *
+ * **导入 = 恢复式语义**：按 id 幂等（无此 id 直插；有则跳过零合并零覆写）；
+ * 行级尽力而为四账（inserted/skippedExisting/rejectedSecret/
+ * rejectedMalformed——坏形行不弃批，整文件拒只留给 header 坏形
+ * MEMORY_IMPORT_FORMAT_INVALID）。secret 扫描与三写事务在 DAO
+ * importInsert 单点执法（导入面即写入面）。
+ *
+ * 可写根判定 isWithinRoots **同律复用引证**：函数体拷贝自 skills/manage.ts
+ * 先例（memory 与 skills 无 DAG 边不引 import——漂移由对拍测试互证；
+ * SKILLS_WRITE_ROOT_DENIED / FS_OUTSIDE_WRITABLE_ROOTS 同律先例）。
+ */
+import { resolve, sep } from 'node:path';
+import { BaseError } from '../contracts/index.js';
+import { MEMORY_EXPORT_FORMAT_VERSION, MEMORY_EXPORT_MAGIC, MEMORY_KINDS, MEMORY_STATUSES, } from './types.js';
+/**
+ * 可写根判定（导出落盘路径越界拒——resolve 归一 + 边界分隔符守卫）。
+ * 同律复用引证：拷贝自 skills/manage.ts isWithinRoots，语义钉死同款——
+ * 根本体等于路径或以 `<root>/` 开头才算界内（`/root-x` 不在 `/root` 内）。
+ */
+export function isWithinRoots(path, roots) {
+    const abs = resolve(path);
+    return roots.some((root) => {
+        const base = resolve(root);
+        return abs === base || abs.startsWith(base + sep);
+    });
+}
+/** 驼峰行 → 蛇列 JSONL 行（词面与 DDL 同源；值形取解析形——source_refs 数组、frozen 布尔；versions 批 ev-1 随包） */
+export function exportRowOf(row, versions) {
+    return {
+        id: row.id,
+        owner_key: row.ownerKey,
+        kind: row.kind,
+        summary: row.summary,
+        content: row.content,
+        confidence: row.confidence,
+        evidence_count: row.evidenceCount,
+        status: row.status,
+        superseded_by: row.supersededBy,
+        source_refs: row.sourceRefs,
+        created_at: row.createdAt,
+        updated_at: row.updatedAt,
+        usage_count: row.usageCount,
+        last_used_at: row.lastUsedAt,
+        corrected_count: row.correctedCount,
+        frozen: row.frozen,
+        ttl_days: row.ttlDays,
+        expires_at: row.expiresAt,
+        valid_from: row.validFrom,
+        ...(versions !== undefined
+            ? {
+                versions: versions.map((v) => ({
+                    id: v.id,
+                    revision: v.revision,
+                    cause: v.cause,
+                    reason: v.reason,
+                    owner_key: v.ownerKey,
+                    kind: v.kind,
+                    summary: v.summary,
+                    content: v.content,
+                    confidence: v.confidence,
+                    evidence_count: v.evidenceCount,
+                    created_at: v.createdAt,
+                })),
+            }
+            : {}),
+    };
+}
+/**
+ * 导出序列化纯函数（header + 行按入参序确定性输出——同库两次导出文本
+ * 恒等除 exportedAt；行已由 DAO 按 id 升序取数）。尾行换行收口（POSIX 文本件惯例）。
+ * versionsOf 注入位（批 ev-1——装配面恒接 dao.versions；缺省行不带 versions 键）。
+ */
+export function serializeMemoryExport(meta, rows, versionsOf) {
+    const header = {
+        format: MEMORY_EXPORT_MAGIC,
+        formatVersion: MEMORY_EXPORT_FORMAT_VERSION,
+        ...meta,
+    };
+    return ([JSON.stringify(header), ...rows.map((row) => JSON.stringify(exportRowOf(row, versionsOf?.(row.id))))].join('\n') +
+        '\n');
+}
+/** header 坏形整文件拒（唯一 MEMORY_IMPORT_FORMAT_INVALID 抛点——判据：magic 不符或 formatVersion ∉ {1,2} 或 meta 字段坏形） */
+function invalidHeader(detail) {
+    return new BaseError('MEMORY_IMPORT_FORMAT_INVALID', `导入文件 header 坏形整文件拒（${detail}）`);
+}
+/** formatVersion 可收值（批 ev-1——v1 旧件判读收；双收判定单源） */
+const FORMAT_VERSIONS = [1, 2];
+/** 首行 header 解析（magic/formatVersion/exportedAt/ownerScope/ownerRoots 五字段全检） */
+export function parseMemoryImportHeader(line) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        throw invalidHeader('首行非 JSON');
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw invalidHeader('首行非对象');
+    }
+    const o = parsed;
+    if (o['format'] !== MEMORY_EXPORT_MAGIC)
+        throw invalidHeader(`magic 串不符：${String(o['format'])}`);
+    if (!FORMAT_VERSIONS.includes(o['formatVersion'])) {
+        throw invalidHeader(`formatVersion ∉ {1,2}：${String(o['formatVersion'])}`);
+    }
+    if (!Number.isInteger(o['exportedAt']) || o['exportedAt'] < 0) {
+        throw invalidHeader(`exportedAt 坏形（非负整数）：${String(o['exportedAt'])}`);
+    }
+    if (typeof o['ownerScope'] !== 'string' || o['ownerScope'] === '') {
+        throw invalidHeader(`ownerScope 坏形：${String(o['ownerScope'])}`);
+    }
+    const roots = o['ownerRoots'];
+    if (roots === null || typeof roots !== 'object' || Array.isArray(roots)) {
+        throw invalidHeader('ownerRoots 坏形（对象形）');
+    }
+    for (const [key, value] of Object.entries(roots)) {
+        if (typeof value !== 'string')
+            throw invalidHeader(`ownerRoots[${key}] 坏形（字符串值）：${String(value)}`);
+    }
+    return {
+        format: MEMORY_EXPORT_MAGIC,
+        formatVersion: o['formatVersion'],
+        exportedAt: o['exportedAt'],
+        ownerScope: o['ownerScope'],
+        ownerRoots: roots,
+    };
+}
+/** 行坏形（MEMORY_ENTRY_INVALID——行级宽容分账 rejectedMalformed，不弃批） */
+function invalidRow(lineNo, problems) {
+    return new BaseError('MEMORY_ENTRY_INVALID', `导入行坏形（第 ${lineNo} 行）：${problems}`);
+}
+/** 非负整数判定（时间戳/计数字段共用） */
+function isNonNegInt(v) {
+    return typeof v === 'number' && Number.isInteger(v) && v >= 0;
+}
+/**
+ * 数据行解析（词法判定全清单——18 列在场〔corrected_count 为**容错位**：旧 17 列
+ * 文件缺席按 DEFAULT 0 收、不折坏形；在场须非负整数〕+ 类型 + 闭集 + 区间）。
+ * 行级坏形抛 MEMORY_ENTRY_INVALID（与 ingest 坏形同码——runMemoryImport
+ * 折 rejectedMalformed 分账）。
+ */
+export function parseMemoryImportRow(line, lineNo) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        throw invalidRow(lineNo, '非 JSON');
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw invalidRow(lineNo, '非对象');
+    }
+    const o = parsed;
+    const problems = [];
+    const str = (key) => {
+        const v = o[key];
+        if (typeof v !== 'string' || v === '') {
+            problems.push(`${key} 坏形（非空字符串）`);
+            return undefined;
+        }
+        return v;
+    };
+    const id = str('id');
+    const ownerKey = str('owner_key');
+    const summary = str('summary');
+    const content = str('content');
+    const kind = o['kind'];
+    if (typeof kind !== 'string' || !MEMORY_KINDS.includes(kind)) {
+        problems.push(`kind 非七值闭集：${String(kind)}`);
+    }
+    const status = o['status'];
+    if (typeof status !== 'string' || !MEMORY_STATUSES.includes(status)) {
+        problems.push(`status 非三值闭集：${String(status)}`);
+    }
+    const confidence = o['confidence'];
+    if (typeof confidence !== 'number' || !Number.isFinite(confidence) || confidence < 0 || confidence > 1) {
+        problems.push(`confidence 越界 [0,1]：${String(confidence)}`);
+    }
+    const evidence = o['evidence_count'];
+    if (!isNonNegInt(evidence) || evidence < 1)
+        problems.push(`evidence_count 坏形（≥1 整数）：${String(evidence)}`);
+    const supersededBy = o['superseded_by'];
+    if (supersededBy !== null && typeof supersededBy !== 'string') {
+        problems.push('superseded_by 坏形（字符串或 null）');
+    }
+    const refs = o['source_refs'];
+    let sourceRefs = [];
+    if (!Array.isArray(refs)) {
+        problems.push('source_refs 坏形（数组）');
+    }
+    else {
+        for (const [i, ref] of refs.entries()) {
+            if (ref === null ||
+                typeof ref !== 'object' ||
+                typeof ref['sessionId'] !== 'string' ||
+                ref['sessionId'] === '' ||
+                !isNonNegInt(ref['seq'])) {
+                problems.push(`source_refs[${i}] 坏形（{sessionId, seq} 形外）`);
+                break;
+            }
+        }
+        sourceRefs = refs;
+    }
+    if (!isNonNegInt(o['created_at']))
+        problems.push(`created_at 坏形（非负整数）：${String(o['created_at'])}`);
+    if (!isNonNegInt(o['updated_at']))
+        problems.push(`updated_at 坏形（非负整数）：${String(o['updated_at'])}`);
+    const usage = o['usage_count'];
+    if (!isNonNegInt(usage))
+        problems.push(`usage_count 坏形（非负整数）：${String(usage)}`);
+    const lastUsed = o['last_used_at'];
+    if (lastUsed !== null && !isNonNegInt(lastUsed))
+        problems.push(`last_used_at 坏形（非负整数或 null）：${String(lastUsed)}`);
+    // corrected_count 容错位（2026-09-08 消化批——冷读闸 major 销账）：缺席 = 旧
+    // 17 列文件按 DEFAULT 0 收（缺席不折坏形）；在场须非负整数
+    const corrected = o['corrected_count'];
+    if (corrected !== undefined && corrected !== null && !isNonNegInt(corrected)) {
+        problems.push(`corrected_count 坏形（非负整数）：${String(corrected)}`);
+    }
+    const frozen = o['frozen'];
+    if (typeof frozen !== 'boolean')
+        problems.push(`frozen 坏形（布尔）：${String(frozen)}`);
+    const ttlDays = o['ttl_days'];
+    if (ttlDays !== null && (!Number.isInteger(ttlDays) || ttlDays < 1)) {
+        problems.push(`ttl_days 坏形（正整数或 null）：${String(ttlDays)}`);
+    }
+    const expiresAt = o['expires_at'];
+    if (expiresAt !== null && !isNonNegInt(expiresAt)) {
+        problems.push(`expires_at 坏形（非负整数或 null）：${String(expiresAt)}`);
+    }
+    // valid_from 容错位（批 ev-1——v1/早期 v2 旧件缺席按 NULL 收、不折坏形；在场须非负整数或 null）
+    const validFrom = o['valid_from'];
+    if (validFrom !== undefined && validFrom !== null && !isNonNegInt(validFrom)) {
+        problems.push(`valid_from 坏形（非负整数或 null）：${String(validFrom)}`);
+    }
+    // versions 随包链（批 ev-1——v1 旧件无此键缺席收；在场须数组且逐行词法全检）
+    const rawVersions = o['versions'];
+    let versions;
+    if (rawVersions !== undefined) {
+        if (!Array.isArray(rawVersions)) {
+            problems.push('versions 坏形（数组）');
+        }
+        else {
+            const parsedVersions = [];
+            const seenRevisions = new Set();
+            for (const [i, raw] of rawVersions.entries()) {
+                if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+                    problems.push(`versions[${i}] 坏形（对象形）`);
+                    break;
+                }
+                const v = raw;
+                const vProblems = [];
+                if (typeof v['id'] !== 'string' || v['id'] === '')
+                    vProblems.push('id 坏形（非空字符串）');
+                if (!Number.isInteger(v['revision']) || v['revision'] < 1) {
+                    vProblems.push(`revision 坏形（正整数）：${String(v['revision'])}`);
+                }
+                else if (seenRevisions.has(v['revision'])) {
+                    vProblems.push(`revision 重复：${String(v['revision'])}`);
+                }
+                else {
+                    seenRevisions.add(v['revision']);
+                }
+                if (v['cause'] !== 'insert' && v['cause'] !== 'merge' && v['cause'] !== 'decay' && v['cause'] !== 'rollback') {
+                    vProblems.push(`cause 非四值闭集：${String(v['cause'])}`);
+                }
+                if (v['reason'] !== null && v['reason'] !== undefined && typeof v['reason'] !== 'string') {
+                    vProblems.push(`reason 坏形（字符串或 null）：${String(v['reason'])}`);
+                }
+                if (typeof v['owner_key'] !== 'string' || v['owner_key'] === '')
+                    vProblems.push('owner_key 坏形（非空字符串）');
+                if (typeof v['kind'] !== 'string' || !MEMORY_KINDS.includes(v['kind'])) {
+                    vProblems.push(`kind 非七值闭集：${String(v['kind'])}`);
+                }
+                if (typeof v['summary'] !== 'string' || v['summary'] === '')
+                    vProblems.push('summary 坏形（非空字符串）');
+                if (typeof v['content'] !== 'string' || v['content'] === '')
+                    vProblems.push('content 坏形（非空字符串）');
+                if (typeof v['confidence'] !== 'number' ||
+                    !Number.isFinite(v['confidence']) ||
+                    v['confidence'] < 0 ||
+                    v['confidence'] > 1) {
+                    vProblems.push(`confidence 越界 [0,1]：${String(v['confidence'])}`);
+                }
+                if (!isNonNegInt(v['evidence_count']) || v['evidence_count'] < 1) {
+                    vProblems.push(`evidence_count 坏形（≥1 整数）：${String(v['evidence_count'])}`);
+                }
+                if (!isNonNegInt(v['created_at']))
+                    vProblems.push(`created_at 坏形（非负整数）：${String(v['created_at'])}`);
+                if (vProblems.length > 0) {
+                    problems.push(`versions[${i}]：${vProblems.join('；')}`);
+                    break;
+                }
+                parsedVersions.push({
+                    id: v['id'],
+                    revision: v['revision'],
+                    cause: v['cause'],
+                    reason: v['reason'] ?? null,
+                    owner_key: v['owner_key'],
+                    kind: v['kind'],
+                    summary: v['summary'],
+                    content: v['content'],
+                    confidence: v['confidence'],
+                    evidence_count: v['evidence_count'],
+                    created_at: v['created_at'],
+                });
+            }
+            if (parsedVersions.length === rawVersions.length)
+                versions = parsedVersions;
+        }
+    }
+    if (problems.length > 0)
+        throw invalidRow(lineNo, problems.join('；'));
+    return {
+        id: id,
+        owner_key: ownerKey,
+        kind: kind,
+        summary: summary,
+        content: content,
+        confidence: confidence,
+        evidence_count: evidence,
+        status: status,
+        superseded_by: supersededBy ?? null,
+        source_refs: sourceRefs,
+        created_at: o['created_at'],
+        updated_at: o['updated_at'],
+        usage_count: usage,
+        last_used_at: lastUsed ?? null,
+        ...(isNonNegInt(corrected) ? { corrected_count: corrected } : {}),
+        frozen: frozen,
+        ttl_days: ttlDays ?? null,
+        expires_at: expiresAt ?? null,
+        ...(validFrom !== undefined ? { valid_from: validFrom ?? null } : {}),
+        ...(versions !== undefined ? { versions } : {}),
+    };
+}
+/**
+ * 恢复式导入编排（行级尽力而为四账）：首行 header 坏形整文件拒
+ * （MEMORY_IMPORT_FORMAT_INVALID 唯一外抛位）；数据行逐条「解析 →
+ * DAO importInsert（secret 扫描 + 三写事务单点执法）」——secret 命中折
+ * rejectedSecret、行坏形折 rejectedMalformed、id 已在折 skippedExisting、
+ * 落库成功计 inserted。空行宽容跳过（尾行换行/编辑器空行不折坏形）。
+ */
+export function runMemoryImport(text, dao) {
+    const lines = text.split('\n').filter((line) => line.trim() !== '');
+    if (lines.length === 0) {
+        throw invalidHeader('文件空（首行 header 缺席）');
+    }
+    parseMemoryImportHeader(lines[0]);
+    const outcome = { inserted: 0, skippedExisting: 0, rejectedSecret: 0, rejectedMalformed: 0 };
+    for (const [index, line] of lines.slice(1).entries()) {
+        const lineNo = index + 2; // 文件行号（1 起）——header 占首行
+        try {
+            const row = parseMemoryImportRow(line, lineNo);
+            if (dao.importInsert(row))
+                outcome.inserted += 1;
+            else
+                outcome.skippedExisting += 1;
+        }
+        catch (err) {
+            if (err instanceof BaseError && err.code === 'MEMORY_SECRET_DETECTED')
+                outcome.rejectedSecret += 1;
+            else if (err instanceof BaseError && err.code === 'MEMORY_ENTRY_INVALID')
+                outcome.rejectedMalformed += 1;
+            else
+                throw err; // 非词法面异常照常外炸（DB/IO 错误不吞）
+        }
+    }
+    return outcome;
+}
+/** 导出编排（取数 → 序列化——ownerKey 缺省 = 全 owner；ownerRoots 由命令 deps 装配闭包注入） */
+export function buildMemoryExport(dao, opts) {
+    const rows = dao.listForExport(opts.ownerKey);
+    return serializeMemoryExport({ exportedAt: opts.now, ownerScope: opts.ownerKey ?? 'all', ownerRoots: opts.ownerRoots }, rows, 
+    // 批 ev-1——版本链随包导出（跨机往返后 restore revision 回滚面的前提）
+    (id) => dao.versions(id));
+}

package/dist/memory/review.js

@@ -0,0 +1,201 @@
+import { isEligibleUserSource, userTextOf } from './extract.js';
+import { MEMORY_CONTENT_MAX_CHARS, MEMORY_REVIEW_CONFIDENCE, MEMORY_SUMMARY_MAX_CHARS, REVIEW_KINDS, llmTextOf, } from './types.js';
+import { Type } from 'typebox';
+import { Value } from 'typebox/value';
+/* ---------------- JSON 三试（共享纯函数——consolidate 复用） ---------------- */
+/** 代码围栏剥取（```json … ``` / ``` … ```——内层再入三试链） */
+function stripFence(text) {
+    const m = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+    return m !== null ? m[1] : null;
+}
+/** 首平衡段扫描（首 '{'/'[' 起配平到对应闭括——字符串字面量与转义跳越） */
+function balancedSegment(text) {
+    const open = text.search(/[{[]/);
+    if (open < 0)
+        return null;
+    const openCh = text[open];
+    const closeCh = openCh === '{' ? '}' : ']';
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let i = open; i < text.length; i++) {
+        const ch = text[i];
+        if (inString) {
+            if (escaped)
+                escaped = false;
+            else if (ch === '\\')
+                escaped = true;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"')
+            inString = true;
+        else if (ch === openCh)
+            depth++;
+        else if (ch === closeCh) {
+            depth--;
+            if (depth === 0)
+                return text.slice(open, i + 1);
+        }
+    }
+    return null;
+}
+/**
+ * JSON 载荷三试解析（定形注：直取/剥围栏/平衡段）：任一试 JSON.parse 成功即
+ * 返回该值（不校验形状——形状校验归调用方 TypeBox 面）；三试皆败返回 null。
+ */
+export function parseJsonPayload(text) {
+    // 试一：直取
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        /* 落试二 */
+    }
+    // 试二：剥代码围栏
+    const fenced = stripFence(text);
+    if (fenced !== null) {
+        try {
+            return JSON.parse(fenced);
+        }
+        catch {
+            /* 落试三 */
+        }
+    }
+    // 试三：首平衡段（模型前后缀闲话包裹的载荷）
+    const segment = balancedSegment(text);
+    if (segment !== null) {
+        try {
+            return JSON.parse(segment);
+        }
+        catch {
+            /* 三试皆败 */
+        }
+    }
+    return null;
+}
+/** user/message 载荷窄读（结构兼容 durable 载荷 {content, source?}——词面独立律零 session import） */
+function userMessageData(event) {
+    const data = event.data;
+    if (data === null || typeof data !== 'object' || data.content === undefined)
+        return null;
+    const content = data.content;
+    return { content, ...(typeof data.source === 'string' ? { source: data.source } : {}) };
+}
+/** assistant/message 载荷窄读（content 块数组——text 块拼接复用 userTextOf） */
+function assistantText(event) {
+    const data = event.data;
+    if (data === null || typeof data !== 'object' || !Array.isArray(data.content))
+        return null;
+    return userTextOf(data.content);
+}
+/**
+ * 审阅窗转录（06 §4 周期路——只转录文本面两腿）：user/message 过机器源滤除
+ * 与文本提取；assistant/message 拼 text 块；其余事件类型（tool 面/turn 面/
+ * 未知类型）一律不转录。anchorSeq = 首转录行 seq（候选缺省溯源位）。
+ */
+export function transcribeForReview(events) {
+    const items = [];
+    for (const event of events) {
+        if (event.type === 'user/message') {
+            const data = userMessageData(event);
+            if (data === null)
+                continue;
+            if (!isEligibleUserSource(data.source))
+                continue; // 机器载体不入审阅面
+            const text = userTextOf(data.content);
+            if (text === null)
+                continue;
+            items.push({ seq: event.seq, role: 'user', text });
+        }
+        else if (event.type === 'assistant/message') {
+            const text = assistantText(event);
+            if (text === null || text === '')
+                continue;
+            items.push({ seq: event.seq, role: 'assistant', text });
+        }
+        // 其余类型不转录（转录纪律——tool 面不进 LLM prompt）
+    }
+    return {
+        items,
+        anchorSeq: items.length > 0 ? items[0].seq : null,
+        seqs: new Set(items.map((i) => i.seq)),
+    };
+}
+/* ---------------- 周期路编排（LLM 拍 + 按条校验入库） ---------------- */
+/** review 候选条 schema（TypeBox 深校验——未知字段拒收；单条坏形按条丢弃） */
+const REVIEW_ITEM = Type.Object({
+    kind: Type.Union(REVIEW_KINDS.map((k) => Type.Literal(k))),
+    summary: Type.String({ minLength: 1, maxLength: MEMORY_SUMMARY_MAX_CHARS }),
+    content: Type.String({ minLength: 1, maxLength: MEMORY_CONTENT_MAX_CHARS }),
+    confidence: Type.Optional(Type.Number({ minimum: 0, maximum: 1 })),
+    sourceSeq: Type.Optional(Type.Integer({ minimum: 0 })),
+}, { additionalProperties: false });
+/** review 系统提示词（只出 JSON 数组——五类闭集 + sourceSeq 指认） */
+const REVIEW_SYSTEM_PROMPT = [
+    '你是记忆审阅器：从会话转录中提取值得长期保留的记忆候选。',
+    '只输出一个 JSON 数组（无其他文本），每项形如',
+    '{"kind":"preference|fact|convention|failure|insight","summary":"一句话摘要","content":"全文","confidence":0.0到1.0,"sourceSeq":对应转录行的 seq}',
+    '规则：只提取明确可复用的知识（用户偏好/事实/约定/失败教训/洞见）；不提取一次性细节、猜测或任何敏感信息；',
+    'summary 与 content 使用转录原语言；同一知识只提取一条；无值得提取的内容输出 []。',
+].join('\n');
+/**
+ * 跑一轮周期路 review（06 §4——候选逐条经 ingest 合并管线入库，不直接 insert）：
+ * 转录 → 预算闸 → LLM 拍 → JSON 三试 → TypeBox 按条校验（按条丢弃不弃批）→
+ * 逐条 ingest（owner 恒 global；置信度缺省 0.6；溯源 sourceSeq 越窗回落锚）。
+ */
+export async function runMemoryReview(deps, sessionId, events) {
+    const warn = deps.warn ?? (() => { });
+    const transcript = transcribeForReview(events);
+    if (transcript.items.length === 0)
+        return { outcome: 'skipped-empty', extracted: 0, discarded: 0 };
+    // 预算闸（06 §4 字面：预算不足跳过本轮——下个周期再试）
+    if (!deps.llm.canAfford('background'))
+        return { outcome: 'skipped-budget', extracted: 0, discarded: 0 };
+    const lines = transcript.items.map((i) => `[seq=${i.seq} ${i.role}] ${i.text}`).join('\n');
+    let parsed;
+    try {
+        const completion = await deps.llm.complete({
+            systemPrompt: REVIEW_SYSTEM_PROMPT,
+            messages: [{ role: 'user', content: `会话 ${sessionId} 审阅窗转录：\n${lines}` }],
+            priority: 'background',
+        });
+        parsed = parseJsonPayload(llmTextOf(completion.message.content));
+    }
+    catch (error) {
+        warn(`memory 周期路 review 拍失败（跳过本轮）：${error instanceof Error ? error.message : String(error)}`);
+        return { outcome: 'skipped-error', extracted: 0, discarded: 0 };
+    }
+    if (!Array.isArray(parsed))
+        return { outcome: 'skipped-parse', extracted: 0, discarded: 0 };
+    let extracted = 0;
+    let discarded = 0;
+    const anchor = transcript.anchorSeq ?? 0; // 无转录行已早退——恒非 null 到此
+    for (const raw of parsed) {
+        // 按条校验（TypeBox 深校验未知字段拒收——坏形只丢该条不弃批）
+        if (typeof raw !== 'object' || raw === null || !Value.Check(REVIEW_ITEM, raw)) {
+            discarded++;
+            continue;
+        }
+        const item = raw;
+        // 溯源：sourceSeq ∈ 窗内转录行取该行；缺席/越窗（幻觉）回落审阅窗锚
+        const seq = item.sourceSeq !== undefined && transcript.seqs.has(item.sourceSeq) ? item.sourceSeq : anchor;
+        try {
+            deps.dao.ingest({
+                ownerKey: 'global',
+                kind: item.kind,
+                summary: item.summary,
+                content: item.content,
+                confidence: item.confidence ?? MEMORY_REVIEW_CONFIDENCE,
+                sourceRefs: [{ sessionId, seq }],
+            });
+            extracted++;
+        }
+        catch {
+            // 入库拒（写前 secret 扫描命中/坏形——Value.Check 已挡形面，此处余 secret 面）
+            discarded++;
+        }
+    }
+    return { outcome: 'ran', extracted, discarded };
+}