evolcore 0.0.32 → 0.0.34

package/dist/core/memory/index-manager.js

@@ -2,7 +2,7 @@
  * index-manager.ts — MEMORY.md 索引管理（v3）
  *
  * 负责：
- *  1. 重建索引：扫描 consolidated/，逐份验签，按 tags 筛选，截断到 indexMaxBytes
+ *  1. 重建索引：扫描 consolidated/，逐份过台账校验，按 tags 筛选，截断到 indexMaxBytes
  *  2. 追加条目：单条写入时的快速路径（写入后仍以 rebuild 为准）
  *
  * 排序与超期判断一律读**文件 mtime**；frontmatter 的 updatedAt 只作可读信息。
@@ -10,15 +10,16 @@
  * 索引行格式：`- 20261005 [slug] — 描述 [tag1,tag2]`
  *   slug 即文件名（consolidated/<slug>.md），不再重复写路径。
  *
- * 验签规则（v3 收紧）：只认 `verified`。
- *   - `invalid`（签名不符）→ 移入 archive/invalid/，不进索引
- *   - `unsigned`（没有签名块）→ 同样移入 archive/invalid/，不进索引
- * 主会话和整理会话都写不到 consolidated/（create 由程序签名），出现未签名文件
- * 说明有人绕过写入通道直接落盘。
+ * 完整性校验走 file-integrity 台账（docs/file-security/）：
+ *   - 没被动过 → 进索引
+ *   - 被带外修改 → 恢复到最后登记的版本，再进索引
+ *   - 被改动且无法恢复 → 跳过，不进索引，也不移动文件
+ * MEMORY.md 本身每次写入都会登记：它整份注入上下文，被改了同样要能恢复。
  */
 import fs from 'fs';
 import path from 'path';
 import { getMemoryArray, getMemoryString, parseMemoryDocument } from './memory-document.js';
+import { registerFile, verifyFile } from '../file-integrity/store.js';
 /** 索引容量上限（字节）。实际取值由调用方从 memory.indexMaxBytes 传入。 */
 export const DEFAULT_INDEX_MAX_BYTES = 5 * 1024;
 /** Fast metadata index for consolidation candidate scans. */
@@ -246,20 +247,19 @@ function writeIndexFile(indexPath, content) {
     const tmp = indexPath + '.tmp';
     fs.writeFileSync(tmp, content, 'utf-8');
     fs.renameSync(tmp, indexPath);
+    registerFile(indexPath);
 }
 // ── 重建索引 ────────────────────────────────────────────────────────────────
 /**
  * 从 consolidated/ 重建 MEMORY.md。
  *
- * verifyFn 可选。不传时所有文件视为通过，直接进索引，不移动任何文件。
- * 传入时验签失败的文件只跳过（不进索引），同样不移动文件——移动行为是验签门控
- * 开启后才需要的，暂未实现。排序读文件 mtime，按 tags 分级，超 indexMaxBytes
- * 从末尾截断（pinned 标签保留）。
+ * 每份文件先过台账校验（被带外修改的先恢复），被改动且无法恢复的跳过，不移动文件。
+ * 排序读文件 mtime，按 tags 分级，超 indexMaxBytes 从末尾截断（pinned 标签保留）。
  */
-export async function rebuildIndex(consolidatedDir, indexPath, scope, invalidDir, verifyFn, indexMaxBytes = DEFAULT_INDEX_MAX_BYTES) {
+export async function rebuildIndex(consolidatedDir, indexPath, scope, indexMaxBytes = DEFAULT_INDEX_MAX_BYTES) {
     if (!fs.existsSync(consolidatedDir)) {
         writeIndexFile(indexPath, serializeIndex(scope, []));
-        return { indexed: 0, invalidMoved: 0, verifiedFiles: [] };
+        return { indexed: 0, verifiedFiles: [] };
     }
     const files = fs.readdirSync(consolidatedDir).filter(f => f.endsWith('.md')).sort();
     const entries = [];
@@ -269,26 +269,17 @@ export async function rebuildIndex(consolidatedDir, indexPath, scope, invalidDir
         let content;
         let mtimeMs;
         try {
-            content = fs.readFileSync(filePath, 'utf-8');
+            const checked = verifyFile(filePath, { restoreOnFail: true });
+            if (!checked.bytes)
+                continue; // missing / 无法恢复：不进索引
+            content = checked.bytes.toString('utf-8');
+            // 恢复会把 mtime 还原成登记时的值，所以在校验之后再取
             mtimeMs = fs.statSync(filePath).mtimeMs;
         }
         catch {
             continue;
         }
-        if (verifyFn) {
-            const verifyResult = await verifyFn(content);
-            if (verifyResult.status === 'verified') {
-                verifiedFiles.push(file);
-            }
-            else {
-                // 验签失败：跳过，不进索引，不移动文件（门控开启后的移动逻辑暂未实现）
-                continue;
-            }
-        }
-        else {
-            // 未开启验签：所有文件视为通过
-            verifiedFiles.push(file);
-        }
+        verifiedFiles.push(file);
         const document = parseMemoryDocument(content);
         const description = getMemoryString(document, 'description') ?? file.replace(/\.md$/, '');
         const tags = getMemoryArray(document, 'tags');
@@ -304,5 +295,5 @@ export async function rebuildIndex(consolidatedDir, indexPath, scope, invalidDir
     sortEntries(entries);
     const kept = truncateToLimit(scope, entries, indexMaxBytes);
     writeIndexFile(indexPath, serializeIndex(scope, kept));
-    return { indexed: kept.length, invalidMoved: 0, verifiedFiles };
+    return { indexed: kept.length, verifiedFiles };
 }

package/dist/core/memory/memory-admin.js

@@ -12,7 +12,8 @@ import path from 'path';
 import { resolveScopeDirs, archiveMemory, dropMemoryNote, listMemoryNotes } from './memory-writer.js';
 import { rebuildIndex, DEFAULT_INDEX_MAX_BYTES } from './index-manager.js';
 import { refreshMemoryMeta, readMemoryMeta } from './index-manager.js';
-import { parseSignatureBlock, verifyMemoryFile } from './memory-signature.js';
+import { stripLegacySignature } from './memory-document.js';
+import { moveRecord, verifyFile } from '../file-integrity/store.js';
 import { readFmArray, readFmValue, readUpdatedAtMs, reviewWindowDays, DEFAULT_FORGET_AFTER_DAYS } from './staleness.js';
 export const MEMORY_SCOPES = ['relation', 'agent', 'owner'];
 const SLUG_RE = /^[a-zA-Z0-9][a-zA-Z0-9-]{0,63}$/;
@@ -45,10 +46,6 @@ function fmtDate(ms) {
         return '-';
     return new Date(ms).toISOString().slice(0, 16).replace('T', ' ');
 }
-/** 去掉签名块，只留正文（含 frontmatter） */
-function stripSignature(content) {
-    return parseSignatureBlock(content).payload.trimEnd();
-}
 // ── 查看 ────────────────────────────────────────────────────────────────────
 /** 概览：各作用域条数、pending 数、索引大小、最近更新时间。 */
 export function memoryOverview(target, scopes) {
@@ -120,7 +117,6 @@ export function listMemoryFiles(target, scope, archived = false, now = Date.now(
             tags,
             mtimeMs,
             updatedAtMs,
-            signed: !!parseSignatureBlock(content).fields,
             reviewInDays: Math.floor((updatedAtMs + windowMs - now) / DAY_MS),
         });
     }
@@ -135,7 +131,7 @@ export function formatMemoryFiles(scope, files, archived = false) {
     for (const f of files) {
         const tags = f.tags.length ? ` [${f.tags.join(',')}]` : '';
         const review = archived ? '' : f.reviewInDays < 0 ? '  ⏳待审查' : `  ${f.reviewInDays}天后审查`;
-        lines.push(`- ${f.slug}${tags}${f.signed ? '' : '  ⚠️未签名'}${review}`);
+        lines.push(`- ${f.slug}${tags}${review}`);
         if (f.description)
             lines.push(`  ${f.description}`);
         lines.push(`  更新于 ${fmtDate(f.updatedAtMs)}`);
@@ -158,16 +154,21 @@ export async function showMemoryFile(target, scope, slug, archived = false) {
     const fp = path.join(dir, `${slug}.md`);
     if (!fs.existsSync(fp))
         throw new Error(`找不到记忆: ${scope}/${archived ? 'archive/' : ''}${slug}`);
-    const content = fs.readFileSync(fp, 'utf-8');
     let verify;
+    let content;
     try {
-        const r = await verifyMemoryFile(content, target.selfAid);
-        verify = r.status === 'verified' ? '✅ 签名有效' : r.status === 'unsigned' ? '⚠️ 未签名' : `❌ 签名无效（${r.reason ?? 'unknown'}）`;
+        const r = verifyFile(fp, { restoreOnFail: true });
+        verify = r.status === 'verified' ? '✅ 校验通过'
+            : r.status === 'restored' ? '♻️ 检测到带外修改，已恢复到最后登记版本'
+                : '❌ 被改动且无法恢复';
+        // tampered 时没有校验过的字节，显示磁盘现状供排查
+        content = r.bytes ? r.bytes.toString('utf-8') : fs.readFileSync(fp, 'utf-8');
     }
     catch (e) {
-        verify = `⚠️ 无法验签（${e?.message || String(e)}）`;
+        verify = `⚠️ 无法校验（${e?.message || String(e)}）`;
+        content = fs.readFileSync(fp, 'utf-8');
     }
-    let body = stripSignature(content);
+    let body = stripLegacySignature(content).trimEnd();
     if (body.length > MAX_SHOW_CHARS)
         body = `${body.slice(0, MAX_SHOW_CHARS)}\n…（已截断）`;
     return `📄 ${scope}/${archived ? 'archive/' : ''}${slug}  ${verify}\n${body}`;
@@ -201,8 +202,7 @@ export function showPendingNote(target, slug) {
 /** 重建某作用域的 MEMORY.md 并刷新 _meta.json。 */
 export async function reindexScope(target, scope) {
     const dirs = scopeDirs(target, scope);
-    const r = await rebuildIndex(dirs.consolidatedDir, path.join(dirs.memoryDir, 'MEMORY.md'), scope, path.join(dirs.memoryDir, 'archive', 'invalid'), undefined, // 与 ipc 一致：验签门控尚未开启
-    target.memoryConfig?.indexMaxBytes ?? DEFAULT_INDEX_MAX_BYTES);
+    const r = await rebuildIndex(dirs.consolidatedDir, path.join(dirs.memoryDir, 'MEMORY.md'), scope, target.memoryConfig?.indexMaxBytes ?? DEFAULT_INDEX_MAX_BYTES);
     refreshMemoryMeta(dirs.memoryDir);
     return { indexed: r.indexed };
 }
@@ -228,7 +228,12 @@ export async function restoreMemoryFile(target, scope, slug) {
         throw new Error(`找不到已归档记忆: ${scope}/${slug}`);
     if (fs.existsSync(dest))
         throw new Error(`正式记忆中已存在同名文件: ${scope}/${slug}，未恢复`);
+    // 归档期间被改过的话先恢复；恢复不了就拒绝，不把篡改内容放回正式记忆
+    const checked = verifyFile(src, { restoreOnFail: true });
+    if (!checked.bytes)
+        throw new Error(`MEMORY_TAMPERED: 已归档记忆被改动且无法恢复，未恢复: ${scope}/${slug}`);
     fs.mkdirSync(dirs.consolidatedDir, { recursive: true });
     fs.renameSync(src, dest);
+    moveRecord(src, dest);
     await reindexScope(target, scope);
 }

package/dist/core/memory/memory-document.js

@@ -2,10 +2,58 @@
  * Shared representation for memory Markdown documents.
  *
  * Memory files have two mutable blocks: YAML-like frontmatter and Markdown
- * body. AUN signature blocks are stripped while parsing and are never exposed
- * as a document block; consolidated writers sign the serialized result again.
+ * body. 新记忆不再签名（完整性改由 file-integrity 台账保证）；磁盘上的老记忆
+ * 可能还带尾部 AUN 签名块，解析时剥掉，重写时不再写回。
  */
-import { parseSignatureBlock } from './memory-signature.js';
+// ── 老签名块兼容剥离 ──────────────────────────────────────────────────────────
+// 规则与原 memory-signature.ts 的 parseSignatureBlock 一致：只有格式完全合法的
+// 签名块才剥；格式不对的标记可能就是正文，原样保留每个字节。
+const LEGACY_SIGNATURE_MARKER = '<!-- AUN-SIGNATURE';
+const LEGACY_SIGNATURE_RE = /^<!-- AUN-SIGNATURE(?:\r\n|\n|\r)(?<body>[\s\S]*?)(?:\r\n|\n|\r)-->\s*$/;
+const LEGACY_REQUIRED_FIELDS = ['cert_fingerprint', 'timestamp', 'signature'];
+const LEGACY_ALLOWED_FIELDS = [...LEGACY_REQUIRED_FIELDS, 'public_key_fingerprint'];
+const SHA256_FP_RE = /^sha256:[0-9a-f]{64}$/i;
+function isStrictBase64(value) {
+    if (!value || value.length % 4 !== 0 || !/^[A-Za-z0-9+/]+={0,2}$/.test(value))
+        return false;
+    return Buffer.from(value, 'base64').toString('base64') === value;
+}
+function isValidLegacySignatureBlock(tail) {
+    const match = tail.match(LEGACY_SIGNATURE_RE);
+    if (!match)
+        return false;
+    const fields = {};
+    for (const rawLine of (match.groups?.body ?? '').split(/\r\n|\n|\r/)) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        const colon = line.indexOf(':');
+        if (colon < 0)
+            return false;
+        const key = line.slice(0, colon).trim().toLowerCase();
+        if (Object.prototype.hasOwnProperty.call(fields, key))
+            return false;
+        fields[key] = line.slice(colon + 1).trim();
+    }
+    if (LEGACY_REQUIRED_FIELDS.some(k => !fields[k]))
+        return false;
+    if (Object.keys(fields).some(k => !LEGACY_ALLOWED_FIELDS.includes(k)))
+        return false;
+    if (!SHA256_FP_RE.test(fields.cert_fingerprint))
+        return false;
+    if (fields.public_key_fingerprint && !SHA256_FP_RE.test(fields.public_key_fingerprint))
+        return false;
+    return /^\d+$/.test(fields.timestamp) && isStrictBase64(fields.signature);
+}
+/** 去掉老记忆尾部合法的 AUN 签名块；没有或不合法时原样返回。 */
+export function stripLegacySignature(content) {
+    const idx = content.lastIndexOf(LEGACY_SIGNATURE_MARKER);
+    if (idx < 0 || content.indexOf(LEGACY_SIGNATURE_MARKER) !== idx)
+        return content;
+    if (idx > 0 && content[idx - 1] !== '\n' && content[idx - 1] !== '\r')
+        return content;
+    return isValidLegacySignatureBlock(content.slice(idx)) ? content.slice(0, idx) : content;
+}
 function parseArray(raw) {
     const value = raw.match(/^\[([^\]]*)\]$/)?.[1] ?? raw;
     return value
@@ -29,13 +77,9 @@ function splitDocument(content) {
         hasFrontmatter: true,
     };
 }
-/** Parse frontmatter and body; an existing AUN signature is ignored. */
+/** Parse frontmatter and body; a legacy AUN signature block is ignored. */
 export function parseMemoryDocument(content) {
-    const signature = parseSignatureBlock(content);
-    // A malformed marker may be ordinary body text. Only strip a signature when
-    // the signature parser accepted the block; otherwise preserve every byte.
-    const unsigned = signature.fields ? signature.payload : content;
-    const parts = splitDocument(unsigned);
+    const parts = splitDocument(stripLegacySignature(content));
     const fields = {};
     const fieldOrder = [];
     const extraFrontmatterLines = [];

package/dist/core/memory/memory-writer.js

@@ -4,21 +4,22 @@
  * 只有整理会话（sessionType=memory）能调用这三个操作，由 ipc.ts 做会话类型与
  * 模式↔作用域的双重校验后委托到这里。本模块只负责文件层面的动作：
  *
- *   - createMemory  新建正式记忆：写 consolidated/、签名、归档 --replaces 的旧文件
- *   - updateMemory  改标签或续期（--touch），改完重新签名
+ *   - createMemory  新建正式记忆：写 consolidated/、归档 --replaces 的旧文件
+ *   - updateMemory  改标签或续期（--touch）
  *   - archiveMemory 归档（唯一的下线方式，没有删除）
  *
- * 签名基础设施已就绪（signMemoryFile），但验签门控尚未开启——
- * 门控设计已存档，待后续按需启用。
+ * 正式记忆的完整性由 file-integrity 台账保证（docs/file-security/）：
+ * 落盘后 registerFile，rename 后 moveRecord，读改写之前先 verifyFile。
+ * pending note 是草稿，不进台账。
  */
 import fs from 'fs';
 import path from 'path';
 import { resolveRoot } from '../../paths.js';
-import { signMemoryFile } from './memory-signature.js';
+import { moveRecord, registerFile, verifyFile } from '../file-integrity/store.js';
 import { refreshMemoryMeta } from './index-manager.js';
 import { getMemoryArray, getMemoryString, parseMemoryDocument, serializeMemoryDocument, setMemoryField, } from './memory-document.js';
 const SLUG_RE = /^[a-zA-Z0-9][a-zA-Z0-9-]{0,63}$/;
-/** 与 memory-signature.ts 的 MAX_MEMORY_BYTES 保持一致（10KB）。 */
+/** 一条记忆应是一句话能说清的结论，10KB 足够；超过通常意味着该拆成多条。 */
 const MAX_CONTENT_BYTES = 10 * 1024;
 /** 解析某个作用域的记忆目录。 */
 export function resolveScopeDirs(scope, taskCtx, ownerAid, peerKeyOverride) {
@@ -76,8 +77,18 @@ function assertSlug(slug) {
 function readMemory(content) {
     return parseMemoryDocument(content);
 }
-function writeSignedMemory(document, selfAid) {
-    return signMemoryFile(serializeMemoryDocument(document), selfAid).then(result => result.signed);
+/**
+ * 读 → 改 → 重写之前先过台账：被带外改过就先恢复，用校验过的内容做修改基础。
+ * 直接读盘的话，篡改内容改一下就会被重新登记成新基线。
+ */
+function readVerifiedMemory(filePath) {
+    const r = verifyFile(filePath, { restoreOnFail: true });
+    if (r.status === 'missing')
+        throw new Error(`找不到记忆文件: ${filePath}`);
+    if (!r.bytes) {
+        throw new Error(`MEMORY_TAMPERED: 记忆文件被改动且无法恢复，已拒绝操作: ${filePath}`);
+    }
+    return r.bytes.toString('utf-8');
 }
 export async function createMemory(req) {
     assertSlug(req.slug);
@@ -134,10 +145,10 @@ export async function createMemory(req) {
     if (replacePaths.length > 0)
         setMemoryField(document, 'replaces', replacePaths.map(p => path.relative(dirs.memoryDir, p)));
     document.body = req.content.trimEnd();
-    const signed = await writeSignedMemory(document, req.taskCtx.selfAid);
     const tmp = targetPath + '.tmp';
-    fs.writeFileSync(tmp, signed, 'utf-8');
+    fs.writeFileSync(tmp, serializeMemoryDocument(document), 'utf-8');
     fs.renameSync(tmp, targetPath);
+    registerFile(targetPath, req.taskCtx.selfAid);
     // 归档被替换的旧文件（在写入成功之后做，失败不影响新文件）
     const archived = [];
     for (const p of replacePaths) {
@@ -150,6 +161,7 @@ export async function createMemory(req) {
         try {
             fs.renameSync(p, dest);
             archived.push(dest);
+            moveRecord(p, dest);
         }
         catch { /* 归档失败不影响主流程，由下次整理清理 */ }
     }
@@ -206,7 +218,8 @@ export async function demoteMemory(req) {
     const srcPath = path.join(srcDirs.consolidatedDir, `${req.slug}.md`);
     if (!fs.existsSync(srcPath))
         throw new Error(`找不到记忆文件: ${srcPath}`);
-    const content = fs.readFileSync(srcPath, 'utf-8');
+    // 降级目标由 frontmatter 决定，必须读校验过的内容，否则改一下来源字段就能把记忆搬去别处
+    const content = readVerifiedMemory(srcPath);
     const fromRelPath = getMemoryString(readMemory(content), req.scope === 'agent' ? 'generalizedFrom' : 'promotedFrom');
     if (!fromRelPath) {
         throw new Error(`DEMOTE_NO_SOURCE: 记忆文件缺少来源字段（${req.scope === 'agent' ? 'generalizedFrom' : 'promotedFrom'}），` +
@@ -229,12 +242,14 @@ export async function demoteMemory(req) {
         const archiveDest = archivePath(srcDirs.memoryDir, srcPath);
         fs.mkdirSync(path.dirname(archiveDest), { recursive: true });
         fs.renameSync(srcPath, archiveDest);
+        moveRecord(srcPath, archiveDest);
         finalDestPath = archiveDest;
         conflictArchived = true;
     }
     else {
         fs.mkdirSync(path.dirname(destPath), { recursive: true });
         fs.renameSync(srcPath, destPath);
+        moveRecord(srcPath, destPath);
     }
     // 跨作用域搬运，源与目标两个目录都要刷新元数据
     refreshMemoryMeta(srcDirs.memoryDir);
@@ -252,18 +267,17 @@ export async function updateMemory(req) {
     const filePath = resolveConsolidatedPath(dirs, req.target);
     if (!fs.existsSync(filePath))
         throw new Error(`找不到记忆文件: ${filePath}`);
-    const raw = fs.readFileSync(filePath, 'utf-8');
-    const document = readMemory(raw);
+    const document = readMemory(readVerifiedMemory(filePath));
     const prevTags = getMemoryArray(document, 'tags');
     if (req.tags !== undefined)
         setMemoryField(document, 'tags', req.tags.length > 0 ? req.tags : undefined);
     // 刷新 updatedAt（--touch 的续期语义就是刷新这里 + 文件 mtime）
     const now = new Date().toISOString();
     setMemoryField(document, 'updatedAt', now);
-    const signed = await writeSignedMemory(document, req.taskCtx.selfAid);
     const tmp = filePath + '.tmp';
-    fs.writeFileSync(tmp, signed, 'utf-8');
+    fs.writeFileSync(tmp, serializeMemoryDocument(document), 'utf-8');
     fs.renameSync(tmp, filePath);
+    registerFile(filePath, req.taskCtx.selfAid);
     refreshMemoryMeta(dirs.memoryDir);
     return { ok: true, filePath, prevTags, scopeDirs: dirs };
 }
@@ -278,6 +292,7 @@ export async function archiveMemory(req) {
         const dest = archivePath(dirs.memoryDir, p);
         fs.mkdirSync(path.dirname(dest), { recursive: true });
         fs.renameSync(p, dest);
+        moveRecord(p, dest);
         archived.push(dest);
     }
     refreshMemoryMeta(dirs.memoryDir);

package/dist/core/message/aun-ipc-sender.js

@@ -1,14 +1,17 @@
+import crypto from 'crypto';
 import { authorizeDelegatedAunMsgSend, } from '../auth/agent-delegation.js';
-import { tryParseChannelKey } from '../channel-loader.js';
+import { formatChannelKey, tryParseChannelKey } from '../channel-loader.js';
 import { AUN_HANDOFF_MARKER_FIELD } from '../../channels/aun.js';
 import { classifyAunPayloadForLog } from './message-log.js';
 import { isValidAunDeliveryForChannel } from './outbound.js';
 import { isHClassPath } from '../permission/protected-paths.js';
 import { evaluateOutboundContactAdmission } from './message-admission.js';
 import { normalizeAunMentionEntries, withAunAttention } from '../../aun/msg/mention-schema.js';
-import { resolveManagedSendArgv } from '../../cli/aun-commands.js';
+import { buildThreadCheckTrigger, resolveManagedSendArgv } from '../../cli/aun-commands.js';
 import { readTriggerLocalFile, resolveTriggerLocalPath } from '../../trigger/local-files.js';
 import { sameGroupAid } from '../../aun/group/identity.js';
+import { resolveThreadRouteTarget } from '../thread/thread-route.js';
+import { ThreadService } from '../thread/thread-service.js';
 export function createAunHandoffSender(sessionManager, channelInstances) {
     return async (handoff) => {
         const targetSession = await sessionManager.getSessionById(handoff.target_session_id);
@@ -58,7 +61,92 @@ export function createAunHandoffSender(sessionManager, channelInstances) {
         return { ok: result.ok, message_id: result.message_id, error: result.error };
     };
 }
-export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegationRegistry, responseEngine, handoffRuntime, }) {
+async function applyManagedCrossThreadSendEffects(input) {
+    const originSessionId = input.runtime?.sessionId;
+    if (!originSessionId)
+        return undefined;
+    const originThreadId = input.runtime?.threadId || 'main';
+    const originPeer = input.runtime?.channelId || input.targetChannelId;
+    const originChatType = input.runtime?.chatType === 'group' ? 'group' : 'private';
+    const originChannelKey = input.runtime?.channelKey;
+    const originChannelId = input.runtime?.channelId;
+    const originPeerId = input.runtime?.peerId || (originChatType === 'private' ? originChannelId : undefined);
+    const origin = originChannelKey && originChannelId && originPeerId
+        ? {
+            channelKey: originChannelKey,
+            channelType: input.runtime?.channel || 'aun',
+            channelId: originChannelId,
+            session: input.runtime?.threadId ? 'thread' : 'main',
+            ...(input.runtime?.threadId ? { threadId: input.runtime.threadId } : {}),
+            peerId: originPeerId,
+            delivery: originChatType === 'group'
+                ? { chatType: 'group', groupId: originChannelId }
+                : { chatType: 'private' },
+        }
+        : undefined;
+    const triggerSeed = `${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
+    const triggerId = `trig_${triggerSeed}`;
+    const triggerName = `check-${input.targetThreadId}-from-${originThreadId}-${triggerSeed.split('_')[1]}`;
+    const prompt = [
+        `【Trigger 复查】话题 ${input.targetThreadId}（对端 ${input.targetChannelId}）`,
+        `这是周期复查：每 ${input.checkEveryLabel} 唤醒一次，直到你显式结束它。`,
+        '',
+        input.triggerPromptExtra
+            || `请检查该话题的最新进度，根据情况：继续等待、调整周期（ec trigger update ${triggerId} --every <时长>）或结束复查（ec trigger cancel ${triggerId}）。`,
+        '',
+        '参考命令：',
+        `  ec thread history ${input.targetChannelId}/${input.targetThreadId} --limit 10`,
+        `  ec thread history ${originPeer}/${originThreadId} --after ${Date.now()}`,
+        `  ec trigger cancel ${triggerId}`,
+        `  ec trigger update ${triggerId} --every <时长>`,
+        `Trigger id：${triggerId}`,
+        `Trigger 名称：${triggerName}`,
+    ].join('\n');
+    let createdTriggerId;
+    try {
+        if (!origin)
+            throw new Error('managed task runtime context is missing a trusted Trigger origin');
+        const scheduler = input.triggerSchedulers.get(input.selfAid);
+        if (!scheduler)
+            throw new Error(`trigger scheduler not found for agent: ${input.selfAid}`);
+        const definition = buildThreadCheckTrigger({
+            agentAid: input.selfAid,
+            id: triggerId,
+            name: triggerName,
+            prompt,
+            everyMs: input.durationMs,
+            checkEvery: input.checkEveryLabel,
+            channelKey: formatChannelKey({ type: 'aun', selfAID: input.selfAid, name: 'main' }),
+            targetChannelId: input.targetChannelId,
+            targetThreadId: input.targetThreadId,
+            originThreadId,
+            originPeer,
+            origin,
+            feedbackChatType: input.feedbackChatType,
+        });
+        createdTriggerId = scheduler.create(definition, [], { enable: true }).id;
+    }
+    catch (error) {
+        console.warn(`⚠ Trigger 创建失败: ${error instanceof Error ? error.message : String(error)}（inbox 仍会写入）`);
+    }
+    try {
+        ThreadService.appendInbox(input.selfAid, {
+            messageId: input.messageId,
+            content: input.contentSummary,
+            timestamp: input.timestamp,
+            originThreadId,
+            originPeer,
+            originSessionId,
+            targetSessionId: input.targetSessionId,
+            ...(createdTriggerId ? { triggerId: createdTriggerId } : {}),
+        });
+    }
+    catch (error) {
+        console.warn(`⚠ 话题 inbox 写入失败: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return createdTriggerId;
+}
+export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegationRegistry, responseEngine, handoffRuntime, triggerSchedulers, }) {
     const sender = async (params) => {
         let textFile;
         try {
@@ -76,6 +164,12 @@ export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegat
         }
         const runtime = params.originSessionId ? responseEngine.getTaskRuntimeContext(params.originSessionId) : undefined;
         const runtimeCausation = runtime?.causation;
+        const threadRoute = params.thread
+            ? resolveThreadRouteTarget(params.aid, params.thread, params.scope, params.to)
+            : undefined;
+        if (params.thread && !threadRoute) {
+            return { ok: false, code: 'TOPIC_NOT_FOUND', error: `话题不存在或不属于目标对端: ${params.thread}` };
+        }
         if (params.argv !== undefined && !params.delegationCommandHash) {
             return { ok: false, code: 'INVALID_DELEGATION', error: 'Managed AUN sends require an approved command hash' };
         }
@@ -88,6 +182,7 @@ export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegat
             to: params.to,
             scope: params.scope,
             action: params.file ? 'file' : 'send',
+            threadRouted: !!threadRoute,
         });
         if (!delegation.ok) {
             return { ok: false, error: delegation.reason, code: delegation.code };
@@ -219,13 +314,33 @@ export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegat
                 });
                 targetSessionId = created.targetSession.id;
                 if (created.crossSession && created.handoff) {
-                    return {
+                    const response = {
                         ok: true,
                         status: created.handoff.state === 'target_sent' ? 'delivered' : 'queued',
                         message_id: created.handoff.target_message_id ?? undefined,
                         handoff_id: created.handoff.handoff_id,
                         target_session_id: created.targetSession.id,
                     };
+                    if (params.thread && params.checkEveryMs !== undefined && response.message_id && threadRoute) {
+                        const triggerId = await applyManagedCrossThreadSendEffects({
+                            triggerSchedulers,
+                            runtime,
+                            selfAid: params.aid,
+                            targetThreadId: params.thread,
+                            targetSessionId: threadRoute.sessionId,
+                            targetChannelId: params.to,
+                            feedbackChatType: params.scope === 'group' ? 'group' : 'private',
+                            messageId: response.message_id,
+                            contentSummary: params.log?.content ?? classifyAunPayloadForLog(payload).content,
+                            timestamp: response.timestamp ?? Date.now(),
+                            durationMs: params.checkEveryMs,
+                            checkEveryLabel: params.checkEvery ?? '5m',
+                            triggerPromptExtra: params.triggerPromptExtra,
+                        });
+                        if (triggerId)
+                            response.trigger_id = triggerId;
+                    }
+                    return response;
                 }
                 if (params.scope === 'msg' && !payload.ref_message_id) {
                     payload.ref_message_id = params.originMessageId;
@@ -247,24 +362,64 @@ export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegat
             if (typeof ch.sendDaemonGroupMsg !== 'function') {
                 return { ok: false, error: 'AUN channel does not support daemon group sends', code: 'AUN_GROUP_UNSUPPORTED' };
             }
-            return await ch.sendDaemonGroupMsg({
+            const sent = await ch.sendDaemonGroupMsg({
                 groupId: params.to,
                 payload,
                 mentions: params.mentions,
                 encrypt,
                 log: params.log ? { ...params.log, sessionId: targetSessionId ?? params.log.sessionId } : undefined,
             });
+            if (params.thread && params.checkEveryMs !== undefined && sent.ok && sent.message_id && threadRoute) {
+                const triggerId = await applyManagedCrossThreadSendEffects({
+                    triggerSchedulers,
+                    runtime,
+                    selfAid: params.aid,
+                    targetThreadId: params.thread,
+                    targetSessionId: threadRoute.sessionId,
+                    targetChannelId: params.to,
+                    feedbackChatType: 'group',
+                    messageId: sent.message_id,
+                    contentSummary: params.log?.content ?? classifyAunPayloadForLog(payload).content,
+                    timestamp: sent.timestamp ?? Date.now(),
+                    durationMs: params.checkEveryMs,
+                    checkEveryLabel: params.checkEvery ?? '5m',
+                    triggerPromptExtra: params.triggerPromptExtra,
+                });
+                if (triggerId)
+                    sent.trigger_id = triggerId;
+            }
+            return sent;
         }
         if (typeof ch.sendDaemonMsg !== 'function') {
             return { ok: false, error: 'AUN channel does not support daemon private sends', code: 'AUN_MSG_UNSUPPORTED' };
         }
-        return await ch.sendDaemonMsg({
+        const sent = await ch.sendDaemonMsg({
             to: params.to,
             payload,
             encrypt,
             causation: runtimeCausation,
             log: params.log ? { ...params.log, sessionId: targetSessionId ?? params.log.sessionId } : undefined,
         });
+        if (params.thread && params.checkEveryMs !== undefined && sent.ok && sent.message_id && threadRoute) {
+            const triggerId = await applyManagedCrossThreadSendEffects({
+                triggerSchedulers,
+                runtime,
+                selfAid: params.aid,
+                targetThreadId: params.thread,
+                targetSessionId: threadRoute.sessionId,
+                targetChannelId: params.to,
+                feedbackChatType: 'private',
+                messageId: sent.message_id,
+                contentSummary: params.log?.content ?? classifyAunPayloadForLog(payload).content,
+                timestamp: sent.timestamp ?? Date.now(),
+                durationMs: params.checkEveryMs,
+                checkEveryLabel: params.checkEvery ?? '5m',
+                triggerPromptExtra: params.triggerPromptExtra,
+            });
+            if (triggerId)
+                sent.trigger_id = triggerId;
+        }
+        return sent;
     };
     ipcServer.setAunMsgSender(sender);
 }