evolcore 0.0.3 → 0.0.4

package/dist/config/contact-bind-code.js

@@ -0,0 +1,274 @@
+import { randomInt } from 'crypto';
+import { isValidAid } from '../aun/aid/validation.js';
+import { isAcceptedContact, resolveContactView } from './contact-book.js';
+import { formatContactAlias, normalizeContactChannelKey } from './contact-alias.js';
+import { mutateContactBookSync } from './contact-book-store.js';
+export const CONTACT_BIND_CODE_TTL_MS = 10 * 60 * 1000;
+export const CONTACT_BIND_MAX_FAILED_ATTEMPTS = 5;
+export const CONTACT_BIND_MAX_PENDING_PER_CHANNEL = 100;
+export const CONTACT_BIND_MAX_PENDING_TOTAL = 5_000;
+export const CONTACT_BIND_MAX_INVALID_ACTORS = 1_000;
+/** In-memory, one-time channel identity proof used before writing a Contact alias. */
+export class ContactBindCodeRegistry {
+    options;
+    /** `selfAid + channelName + primaryId` -> pending request. */
+    pendingByPrimary = new Map();
+    /** `selfAid + channelName + code` -> pending request key. */
+    pendingByCode = new Map();
+    /** Scope -> pending request keys, used for bounded cleanup and capacity checks. */
+    pendingKeysByScope = new Map();
+    /** Unknown-code throttling is deliberately separate from any pending request. */
+    invalidAttemptsByActor = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    register(req) {
+        const selfAid = String(req.selfAid || '').trim();
+        const primaryId = String(req.primaryId || '').trim();
+        const now = req.now ?? Date.now();
+        const requestedCode = req.code ? String(req.code).trim() : undefined;
+        if (!isValidAid(selfAid))
+            return { ok: false, error: `invalid selfAid: ${req.selfAid}` };
+        const channelName = normalizeContactChannelKey(selfAid, this.options.channelType, req.channelName);
+        if (!channelName)
+            return { ok: false, error: `invalid channelName: ${req.channelName}` };
+        if (!isValidAid(primaryId))
+            return { ok: false, error: `invalid primaryId: ${req.primaryId}` };
+        const contact = resolveContactView(selfAid, primaryId);
+        if (!contact.isOwner && !isAcceptedContact(selfAid, primaryId)) {
+            return { ok: false, error: `only an active contact or Agent owner can bind an identity: ${primaryId}` };
+        }
+        if (requestedCode && !/^\d{6}$/.test(requestedCode))
+            return { ok: false, error: 'binding code must be 6 digits' };
+        const scope = pendingScopeKey(selfAid, channelName);
+        this.purgeExpiredAll(now);
+        const key = pendingBindKey(selfAid, channelName, primaryId);
+        const replaced = this.pendingByPrimary.has(key);
+        const code = requestedCode ?? this.generateUniqueCode(scope);
+        if (!code)
+            return { ok: false, error: 'unable to allocate a unique binding code' };
+        const codeKey = pendingCodeKey(scope, code);
+        const existingCodeOwner = this.pendingByCode.get(codeKey);
+        if (existingCodeOwner && existingCodeOwner !== key) {
+            return { ok: false, error: 'binding code is already active for this channel instance' };
+        }
+        const pendingInScope = this.pendingKeysByScope.get(scope)?.size ?? 0;
+        if (!replaced && pendingInScope >= CONTACT_BIND_MAX_PENDING_PER_CHANNEL) {
+            return { ok: false, error: 'too many pending binding requests for this channel instance' };
+        }
+        if (!replaced && this.pendingByPrimary.size >= CONTACT_BIND_MAX_PENDING_TOTAL) {
+            return { ok: false, error: 'too many pending binding requests in this process' };
+        }
+        if (replaced)
+            this.removePending(key);
+        const item = {
+            selfAid,
+            channelName,
+            primaryId,
+            code,
+            createdAt: now,
+            expiresAt: now + CONTACT_BIND_CODE_TTL_MS,
+        };
+        this.pendingByPrimary.set(key, item);
+        this.pendingByCode.set(codeKey, key);
+        const scopeKeys = this.pendingKeysByScope.get(scope) ?? new Set();
+        scopeKeys.add(key);
+        this.pendingKeysByScope.set(scope, scopeKeys);
+        return { ok: true, code, expiresAt: item.expiresAt, replaced };
+    }
+    handle(ctx) {
+        if (ctx.channelType !== this.options.channelType)
+            return { handled: false };
+        const selfAid = String(ctx.selfAid || '').trim();
+        const channelName = normalizeContactChannelKey(selfAid, this.options.channelType, ctx.channelName);
+        if (!channelName)
+            return { handled: false };
+        const now = ctx.now ?? Date.now();
+        if (ctx.chatType !== 'private')
+            return { handled: false };
+        const input = String(ctx.content ?? '').trim();
+        const scope = pendingScopeKey(selfAid, channelName);
+        const codeKey = /^\d{6}$/.test(input) ? pendingCodeKey(scope, input) : undefined;
+        const pendingKey = codeKey ? this.pendingByCode.get(codeKey) : undefined;
+        const matchingItem = pendingKey ? this.pendingByPrimary.get(pendingKey) : undefined;
+        if (matchingItem && now >= matchingItem.expiresAt) {
+            this.removePending(pendingKey);
+            return {
+                handled: true,
+                status: 'expired',
+                remainingAttempts: 0,
+                reply: this.expiredReply(),
+            };
+        }
+        this.purgeExpiredAll(now);
+        const hasPending = (this.pendingKeysByScope.get(scope)?.size ?? 0) > 0;
+        if (!hasPending)
+            return { handled: false };
+        if (!/^\d{6}$/.test(input)) {
+            return {
+                handled: true,
+                status: 'format',
+                reply: '请发送 /bind <6 位数字绑定码>。',
+                remainingAttempts: CONTACT_BIND_MAX_FAILED_ATTEMPTS,
+            };
+        }
+        if (!matchingItem) {
+            const invalidAttempt = this.recordInvalidAttempt(scope, String(ctx.actorId || '').trim(), now);
+            if (invalidAttempt.remaining > 0) {
+                return {
+                    handled: true,
+                    status: 'wrong-code',
+                    remainingAttempts: invalidAttempt.remaining,
+                    reply: '绑定码错误，请重新发送 /bind <6 位数字绑定码>。',
+                };
+            }
+            return {
+                handled: true,
+                status: 'rate-limited',
+                remainingAttempts: 0,
+                reply: '绑定码错误次数过多，请稍后再试。有效绑定码仍可直接提交。',
+            };
+        }
+        const actorId = String(ctx.actorId || '').trim();
+        if (!actorId) {
+            return {
+                handled: true,
+                status: 'missing-actor',
+                remainingAttempts: CONTACT_BIND_MAX_FAILED_ATTEMPTS,
+                reply: `无法识别当前${this.options.displayName}发送者身份，未建立绑定。请重新发送绑定码或重新执行绑定流程。`,
+            };
+        }
+        // Claim first. A matching one-time code is never reusable, including when the
+        // final Contact Book validation or write fails.
+        this.removePending(pendingKey);
+        try {
+            const alias = formatContactAlias(matchingItem.channelName, actorId);
+            mutateContactBookSync({
+                selfAid: matchingItem.selfAid,
+                actor: actorId,
+                mutation: { type: 'bind-alias-eligible', primaryId: matchingItem.primaryId, alias },
+            });
+            return {
+                handled: true,
+                status: 'bound',
+                reply: `${this.options.displayName}身份绑定成功：${matchingItem.channelName}:${encodeURIComponent(actorId)} -> ${matchingItem.primaryId}`,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                handled: true,
+                status: 'write-failed',
+                remainingAttempts: CONTACT_BIND_MAX_FAILED_ATTEMPTS,
+                reply: `${this.options.displayName}身份绑定写入失败：${message}`,
+            };
+        }
+    }
+    get(selfAid, channelName, primaryId) {
+        const normalizedSelfAid = String(selfAid || '').trim();
+        const normalizedChannelName = normalizeContactChannelKey(normalizedSelfAid, this.options.channelType, channelName);
+        if (!normalizedChannelName)
+            return null;
+        const scope = pendingScopeKey(normalizedSelfAid, normalizedChannelName);
+        const key = primaryId
+            ? pendingBindKey(normalizedSelfAid, normalizedChannelName, primaryId)
+            : this.pendingKeysByScope.get(scope)?.values().next().value;
+        const item = key ? this.pendingByPrimary.get(key) : undefined;
+        return item ? { ...item } : null;
+    }
+    clear() {
+        this.pendingByPrimary.clear();
+        this.pendingByCode.clear();
+        this.pendingKeysByScope.clear();
+        this.invalidAttemptsByActor.clear();
+    }
+    noPendingReply() {
+        return `当前没有待验证的${this.options.displayName}身份绑定码。请先在目标 Agent 的 AUN 私聊发送 /bind ${this.options.channelType}，或执行 ${this.options.initCommand} 生成新的绑定码。`;
+    }
+    generateUniqueCode(scope) {
+        for (let attempt = 0; attempt < 100; attempt += 1) {
+            const code = generateBindCode();
+            if (!this.pendingByCode.has(pendingCodeKey(scope, code)))
+                return code;
+        }
+        return null;
+    }
+    purgeExpiredAll(now) {
+        for (const [key, item] of this.pendingByPrimary) {
+            if (!item || now >= item.expiresAt)
+                this.removePending(key);
+        }
+    }
+    removePending(key) {
+        const item = this.pendingByPrimary.get(key);
+        if (!item)
+            return;
+        const scope = pendingScopeKey(item.selfAid, item.channelName);
+        this.pendingByPrimary.delete(key);
+        this.pendingByCode.delete(pendingCodeKey(scope, item.code));
+        const scopeKeys = this.pendingKeysByScope.get(scope);
+        scopeKeys?.delete(key);
+        if (scopeKeys?.size === 0)
+            this.pendingKeysByScope.delete(scope);
+    }
+    recordInvalidAttempt(scope, actorId, now) {
+        const key = `${scope}\u0000${actorId || '<unknown>'}`;
+        this.purgeExpiredInvalidAttempts(now);
+        const current = this.invalidAttemptsByActor.get(key);
+        const attempts = current && now < current.expiresAt ? current.attempts + 1 : 1;
+        this.invalidAttemptsByActor.delete(key);
+        if (this.invalidAttemptsByActor.size >= CONTACT_BIND_MAX_INVALID_ACTORS) {
+            const oldestKey = this.invalidAttemptsByActor.keys().next().value;
+            if (oldestKey)
+                this.invalidAttemptsByActor.delete(oldestKey);
+        }
+        this.invalidAttemptsByActor.set(key, { attempts, expiresAt: now + CONTACT_BIND_CODE_TTL_MS });
+        return { remaining: Math.max(0, CONTACT_BIND_MAX_FAILED_ATTEMPTS - attempts) };
+    }
+    purgeExpiredInvalidAttempts(now) {
+        for (const [key, value] of this.invalidAttemptsByActor) {
+            if (now >= value.expiresAt)
+                this.invalidAttemptsByActor.delete(key);
+        }
+    }
+    expiredReply() {
+        return `${this.options.displayName}身份绑定码已超时。请重新在 AUN 私聊目标 Agent 发送 /bind ${this.options.channelType}，或执行 ${this.options.initCommand} 并再次绑定。`;
+    }
+}
+/**
+ * Reserve `/bind` for channel identity binding so it is never treated as an
+ * ordinary chat message. A pending request determines whether the command can
+ * complete a binding; otherwise the user receives setup guidance.
+ */
+export function handleExplicitContactBindCommand(registry, ctx) {
+    const match = /^\s*\/bind(?:\s+(.+?))?\s*$/i.exec(String(ctx.content ?? ''));
+    if (!match)
+        return { handled: false };
+    if (ctx.chatType !== 'private') {
+        return {
+            handled: true,
+            status: 'private-only',
+            reply: '身份绑定仅支持私聊机器人。请在私聊中发送 /bind <6 位数字绑定码>。',
+        };
+    }
+    const result = registry.handle({ ...ctx, content: match[1] ?? '' });
+    if (result.handled)
+        return result;
+    return {
+        handled: true,
+        status: 'no-pending',
+        reply: registry.noPendingReply(),
+    };
+}
+function generateBindCode() {
+    return String(randomInt(0, 1_000_000)).padStart(6, '0');
+}
+function pendingScopeKey(selfAid, channelName) {
+    return `${String(selfAid || '').trim()}\u0000${String(channelName || '').trim()}`;
+}
+function pendingBindKey(selfAid, channelName, primaryId) {
+    return `${pendingScopeKey(selfAid, channelName)}\u0000${String(primaryId || '').trim()}`;
+}
+function pendingCodeKey(scope, code) {
+    return `${scope}\u0000${code}`;
+}

package/dist/config/contact-book-store.js

@@ -36,9 +36,32 @@ export function readContactRevision(selfAid) {
 export function mutateContactBook(request) {
     return enqueueContactMutation(request, []);
 }
+/**
+ * Prepare a mutation while holding the same cross-process lock used by every Contact Book write.
+ * The callback must stay synchronous so the lock is never retained across an await boundary.
+ */
+export function mutateContactBookPrepared(selfAid, prepare) {
+    const normalizedAid = normalizeAid(selfAid, 'self AID');
+    const previous = mutationTails.get(normalizedAid) ?? Promise.resolve();
+    let release;
+    const tail = new Promise(resolve => { release = resolve; });
+    mutationTails.set(normalizedAid, tail);
+    return previous
+        .catch(() => { })
+        .then(() => mutateContactBookPreparedSyncInternal(normalizedAid, prepare))
+        .finally(() => {
+        release();
+        if (mutationTails.get(normalizedAid) === tail)
+            mutationTails.delete(normalizedAid);
+    });
+}
 export function mutateContactBookTransaction(request, changes) {
     return enqueueContactMutation(request, changes);
 }
+/** Synchronous transaction variant for configuration writes that must commit atomically with contacts. */
+export function mutateContactBookTransactionSync(request, changes) {
+    return mutateContactBookSyncInternal(request, changes);
+}
 function enqueueContactMutation(request, changes) {
     const selfAid = normalizeAid(request.selfAid, 'self AID');
     const previous = mutationTails.get(selfAid) ?? Promise.resolve();
@@ -139,8 +162,79 @@ function mutateContactBookSyncInternal(request, transactionChanges) {
         release();
     }
 }
+function mutateContactBookPreparedSyncInternal(selfAid, prepare) {
+    const release = acquireAgentLock(selfAid);
+    try {
+        recoverMutation(selfAid);
+        const file = agentContactConfig(selfAid);
+        const current = readContactBookFromDisk(selfAid);
+        const previousRevision = contactRevision(current);
+        const next = cloneBook(current);
+        const prepared = prepare({ contact: next, contactRevision: previousRevision });
+        if (prepared.mutation)
+            applyMutation(next, prepared.mutation, selfAid);
+        validateContactBook(next, selfAid);
+        const nextRevision = contactRevision(next);
+        if (nextRevision === previousRevision) {
+            return {
+                changed: false,
+                contactRevision: previousRevision,
+                previousContactRevision: previousRevision,
+                contact: next,
+                value: prepared.value,
+            };
+        }
+        prepared.beforeCommit?.({
+            contact: next,
+            previousContactRevision: previousRevision,
+            contactRevision: nextRevision,
+        });
+        const before = readTextOrNull(file);
+        const after = `${JSON.stringify(next, null, 2)}\n`;
+        const changes = [{ file, before, after }];
+        writeJournal(selfAid, { schemaVersion: 1, state: 'prepared', selfAid, changes });
+        try {
+            applyTransactionChange(changes[0]);
+            writeJournal(selfAid, { schemaVersion: 1, state: 'committed', selfAid, changes });
+            removeJournal(selfAid);
+        }
+        catch (error) {
+            recoverMutation(selfAid);
+            throw error;
+        }
+        notifyConfigWrite(ConfigTarget.Contact, { self: selfAid });
+        appendAudit(selfAid, {
+            selfAid,
+            actor: prepared.actor,
+            mutation: prepared.mutation,
+        }, previousRevision, nextRevision);
+        return {
+            changed: true,
+            contactRevision: nextRevision,
+            previousContactRevision: previousRevision,
+            contact: next,
+            value: prepared.value,
+        };
+    }
+    finally {
+        release();
+    }
+}
 function applyMutation(book, mutation, selfAid) {
     const contacts = book.contacts;
+    if (mutation.type === 'batch') {
+        for (const item of mutation.mutations)
+            applyMutation(book, item, selfAid);
+        return;
+    }
+    if (mutation.type === 'ensure-contacts') {
+        for (const rawPrimaryId of mutation.primaryIds) {
+            const primaryId = normalizeContactAid(rawPrimaryId);
+            if (!contacts[primaryId])
+                contacts[primaryId] = {};
+        }
+        return;
+    }
     const primaryId = normalizeContactAid(mutation.primaryId);
     const existing = contacts[primaryId];
     if (mutation.type === 'set-status') {
@@ -150,6 +244,53 @@ function applyMutation(book, mutation, selfAid) {
         contacts[primaryId] = compactEntry({
             ...existing,
             status: mutation.status === 'active' ? undefined : mutation.status,
+            pendingRequest: undefined,
+            declinedAt: mutation.status === 'declined' ? existing?.declinedAt ?? new Date().toISOString() : undefined,
+        });
+        return;
+    }
+    if (mutation.type === 'set-request') {
+        if (isOwner(selfAid, primaryId)) {
+            throw new ContactMutationError('OWNER_PROTECTED', 'An Agent owner cannot submit a contact request');
+        }
+        contacts[primaryId] = compactEntry({
+            ...existing,
+            status: 'pending',
+            pendingRequest: { ...mutation.request },
+            declinedAt: undefined,
+        });
+        return;
+    }
+    if (mutation.type === 'review-request') {
+        if (!existing || existing.status !== 'pending' || existing.pendingRequest?.id !== mutation.requestId) {
+            throw new ContactMutationError('REQUEST_STALE', 'The contact request has changed or was already handled');
+        }
+        if (Date.parse(existing.pendingRequest.expiresAt) <= Date.parse(mutation.now)) {
+            throw new ContactMutationError('REQUEST_EXPIRED', 'The contact request has expired');
+        }
+        if (mutation.decision === 'reject') {
+            delete contacts[primaryId];
+        }
+        else {
+            contacts[primaryId] = compactEntry({
+                ...existing,
+                status: mutation.decision === 'block' ? 'blocked' : undefined,
+                pendingRequest: undefined,
+                declinedAt: undefined,
+            });
+        }
+        return;
+    }
+    if (mutation.type === 'expire-request') {
+        if (!existing || existing.status !== 'pending' || existing.pendingRequest?.id !== mutation.requestId)
+            return;
+        if (Date.parse(existing.pendingRequest.expiresAt) > Date.parse(mutation.now))
+            return;
+        contacts[primaryId] = compactEntry({
+            ...existing,
+            status: 'declined',
+            pendingRequest: undefined,
+            declinedAt: existing.pendingRequest.expiresAt,
         });
         return;
     }
@@ -157,7 +298,14 @@ function applyMutation(book, mutation, selfAid) {
         contacts[primaryId] = compactEntry({ ...existing, displayName: mutation.displayName ?? undefined });
         return;
     }
-    if (mutation.type === 'bind-alias') {
+    if (mutation.type === 'bind-alias' || mutation.type === 'bind-alias-eligible') {
+        if (mutation.type === 'bind-alias-eligible') {
+            const eligible = isOwner(selfAid, primaryId)
+                || (!!existing && (existing.status === undefined || existing.status === 'active'));
+            if (!eligible) {
+                throw new ContactMutationError('CONTACT_NOT_ACTIVE', 'Only an active contact or Agent owner can bind an alias');
+            }
+        }
         for (const [owner, entry] of Object.entries(contacts)) {
             if (owner !== primaryId && entry.aliases?.includes(mutation.alias)) {
                 throw new ContactMutationError('ALIAS_CONFLICT', `Alias ${mutation.alias} is already bound to ${owner}`);
@@ -186,8 +334,24 @@ function validateContactBook(book, selfAid) {
         if (!isValidAid(primaryId) || isExplicitGroupId(primaryId)) {
             throw new ContactMutationError('INVALID_CONTACT_BOOK', `Invalid contact AID: ${primaryId}`);
         }
-        if (entry.status === 'blocked' && isOwner(selfAid, primaryId)) {
-            throw new ContactMutationError('OWNER_PROTECTED', 'An Agent owner cannot be blocked');
+        if (entry.status && isOwner(selfAid, primaryId)) {
+            throw new ContactMutationError('OWNER_PROTECTED', 'An Agent owner must remain active');
+        }
+        if (entry.status === 'pending') {
+            if (!entry.pendingRequest || !Number.isFinite(Date.parse(entry.pendingRequest.submittedAt))
+                || !Number.isFinite(Date.parse(entry.pendingRequest.expiresAt))
+                || Date.parse(entry.pendingRequest.expiresAt) <= Date.parse(entry.pendingRequest.submittedAt)) {
+                throw new ContactMutationError('INVALID_CONTACT_BOOK', `Invalid pending request for ${primaryId}`);
+            }
+        }
+        else if (entry.pendingRequest) {
+            throw new ContactMutationError('INVALID_CONTACT_BOOK', `pendingRequest requires pending status for ${primaryId}`);
+        }
+        if (entry.status === 'declined' && !Number.isFinite(Date.parse(entry.declinedAt ?? ''))) {
+            throw new ContactMutationError('INVALID_CONTACT_BOOK', `declinedAt is required for ${primaryId}`);
+        }
+        if (entry.status !== 'declined' && entry.declinedAt) {
+            throw new ContactMutationError('INVALID_CONTACT_BOOK', `declinedAt requires declined status for ${primaryId}`);
         }
         for (const alias of entry.aliases ?? []) {
             const parsed = parseContactAlias(alias, selfAid);
@@ -225,9 +389,13 @@ function readConfiguredContactChannelKeys(selfAid) {
 function cloneBook(book) {
     const contacts = {};
     for (const [primaryId, entry] of Object.entries(book?.contacts ?? {})) {
-        contacts[primaryId] = { ...entry, ...(entry.aliases ? { aliases: [...entry.aliases] } : {}) };
+        contacts[primaryId] = {
+            ...entry,
+            ...(entry.aliases ? { aliases: [...entry.aliases] } : {}),
+            ...(entry.pendingRequest ? { pendingRequest: { ...entry.pendingRequest } } : {}),
+        };
     }
-    return { $schema_version: 2, contacts };
+    return { $schema_version: 3, contacts };
 }
 function compactEntry(entry) {
     return Object.fromEntries(Object.entries(entry).filter(([, value]) => value !== undefined));

package/dist/config/contact-book.js

@@ -70,6 +70,9 @@ export function bindContactAlias(selfAid, primaryId, channelType, actorId, chann
     if (!canonicalChannelKey || !actor) {
         throw new ContactBookError('INVALID_ALIAS', `Invalid contact alias: ${String(channelKey)}:${String(actorId)}`);
     }
+    if (!getContactSnapshot(selfAid).contacts.has(primary)) {
+        throw new ContactBookError('NOT_FOUND', `Contact was not found: ${primary}`);
+    }
     const alias = formatContactAlias(canonicalChannelKey, actor);
     try {
         return mutateContactBookSync({
@@ -143,6 +146,35 @@ export function resolveContactView(selfAid, primaryId) {
 export function isBlockedContact(selfAid, primaryId) {
     return resolveContactView(selfAid, primaryId).blocked;
 }
+export function isAcceptedContact(selfAid, primaryId) {
+    const id = String(primaryId || '').trim();
+    const snapshot = getContactSnapshot(selfAid);
+    const entry = snapshot.contacts.get(id);
+    return !!entry && (entry.status === undefined || entry.status === 'active');
+}
+/**
+ * 对端展示名：联系人簿 displayName → principalId。仅用于展示（预览行/日志），
+ * 关系键始终用原生 peerId，不受此影响。
+ *
+ * 非 AUN 渠道的 actorId 是渠道原生 ID（飞书 open_id 等），直接展示不可读；
+ * 联系人簿已把它 alias 到主体 AID 上，取其 displayName 即可。
+ * 未绑定/联系人簿损坏时返回 undefined，由调用方按自己的兜底链继续。
+ */
+export function resolvePeerDisplayLabel(selfAid, channelType, actorId, channelKey) {
+    const actor = String(actorId || '').trim();
+    if (!String(selfAid || '').trim() || !actor)
+        return undefined;
+    try {
+        const { principalId } = resolvePrincipal(selfAid, channelType, actor, channelKey);
+        if (!principalId)
+            return undefined;
+        return resolveContactView(selfAid, principalId).displayName || principalId;
+    }
+    catch {
+        // 联系人簿损坏（校验失败/alias 冲突）不应影响消息处理
+        return undefined;
+    }
+}
 function buildSnapshot(book, selfAid, aliases) {
     const contacts = new Map();
     const blockedIndex = new Set();

package/dist/config/contact-operation-service.js

@@ -3,7 +3,8 @@ import { isValidAid } from '../aun/aid/validation.js';
 import { isExplicitGroupId } from '../aun/group-identity.js';
 import { agentConfig } from '../paths.js';
 import { getContactSnapshot, resolveContactView } from './contact-book.js';
-import { ContactMutationError, mutateContactBook } from './contact-book-store.js';
+import { ContactMutationError } from './contact-book-store.js';
+import { mutateContactWithOperation } from './contact-request-service.js';
 export function resolveContactCommand(argv) {
     const args = argv[0] === 'contact' ? argv.slice(1) : [...argv];
     const selfAid = String(argValue(args, '--self') || '').trim();
@@ -56,9 +57,14 @@ export async function executeResolvedContactCommand(command, actor = 'local-cli'
             };
         }
         if (command.kind === 'set-blocked') {
-            const result = await mutateContactBook({
+            if (!getContactSnapshot(command.selfAid).contacts.has(command.primaryId)) {
+                return { ok: false, code: 'NOT_FOUND', error: `Contact was not found: ${command.primaryId}` };
+            }
+            const result = await mutateContactWithOperation({
                 selfAid: command.selfAid,
-                actor,
+                actorId: actor,
+                operation: command.blocked ? 'block' : 'unblock',
+                primaryId: command.primaryId,
                 mutation: {
                     type: 'set-status',
                     primaryId: command.primaryId,