evolcore 0.0.25 → 0.0.27

package/dist/aun/{menu-client.js → menu/client.js}

@@ -1,12 +1,13 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
-import { createShortConnection } from './rpc/client.js';
-import { SLOT } from './aid/store.js';
-import { isValidAid } from './aid/validation.js';
-import { resolveRoot } from '../paths.js';
-import { readInstalledEvolcoreVersion } from '../utils/evolcore-version.js';
-import { buildMenuClientProtectedHeaders, parseMenuResponse, validateMenuRequest, } from '../core/command/menu-protocol.js';
+import { createShortConnection } from '../rpc/client.js';
+import { MENU_MESSAGE_TTL_SECONDS } from './transport.js';
+import { SLOT } from '../aid/store.js';
+import { isValidAid } from '../aid/validation.js';
+import { resolveRoot } from '../../paths.js';
+import { readInstalledEvolcoreVersion } from '../../utils/evolcore-version.js';
+import { buildMenuClientProtectedHeaders, parseMenuResponse, validateMenuRequest, } from '../../core/command/menu-protocol.js';
 const DEFAULT_TIMEOUT_MS = 15_000;
 const MAX_TIMEOUT_MS = 120_000;
 const POLL_INTERVAL_MS = 200;
@@ -22,6 +23,83 @@ export class MenuClientError extends Error {
         this.name = 'MenuClientError';
     }
 }
+/** Uses the daemon's existing authenticated AUN channel and its normal ACK path. */
+export class ManagedMenuClient {
+    send;
+    pending = new Map();
+    constructor(send) {
+        this.send = send;
+    }
+    accept(fromAid, payload, encrypted) {
+        if (!payload || typeof payload !== 'object' || payload.type !== 'menu.response')
+            return false;
+        if (!encrypted)
+            return true;
+        try {
+            const response = parseMenuResponse(payload);
+            this.pending.get(this.key(fromAid, response.id))?.resolve(response);
+        }
+        catch { /* Invalid responses cannot complete a pending request. */ }
+        return true;
+    }
+    close() {
+        for (const pending of this.pending.values())
+            pending.reject(new MenuClientError('AUN_DISCONNECTED', 'AUN channel disconnected'));
+        this.pending.clear();
+    }
+    async request(options) {
+        if (!isValidAid(options.fromAid) || !isValidAid(options.targetAid))
+            throw new MenuClientError('INVALID_ARGUMENT', 'Valid sender and target AIDs are required');
+        if (options.aunPath !== undefined || options.slotId !== undefined || options.encrypt === false)
+            throw new MenuClientError('INVALID_ARGUMENT', 'Managed Menu uses the daemon connection with E2EE; connection overrides are forbidden');
+        const request = { ...options.request, id: options.request.id || crypto.randomUUID() };
+        const validation = validateMenuRequest(request);
+        if (validation)
+            throw new MenuClientError(validation.code, validation.message);
+        const timeout = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        if (!Number.isFinite(timeout) || timeout < 1000 || timeout > MAX_TIMEOUT_MS)
+            throw new MenuClientError('INVALID_ARGUMENT', 'timeout must be between 1s and 120s');
+        const key = this.key(options.targetAid, request.id);
+        if (this.pending.has(key))
+            throw new MenuClientError('CLIENT_BUSY', 'Request ID is already in flight for this daemon');
+        const headers = buildMenuClientProtectedHeaders({ clientName: 'ec-menu-client', clientVersion: readInstalledEvolcoreVersion(), remoteAccessToken: options.remoteAccessToken ?? options.ecwebToken });
+        const attempts = request.type === 'menu.query' || request.type === 'menu.options' ? 2 : 1;
+        let timer;
+        try {
+            for (let attempt = 0; attempt < attempts; attempt++) {
+                const response = new Promise((resolve, reject) => {
+                    this.pending.set(key, { resolve, reject });
+                    timer = setTimeout(() => reject(new MenuClientError('TIMEOUT', 'Remote Menu response timed out')), timeout);
+                });
+                const sent = this.send({
+                    to: options.targetAid, payload: request, encrypt: true,
+                    ttl: MENU_MESSAGE_TTL_SECONDS, protected_headers: headers,
+                })
+                    .then(result => {
+                    if (!(result?.message_id ?? result?.message?.message_id))
+                        throw new MenuClientError('SEND_FAILED', 'message.send returned no message_id');
+                });
+                try {
+                    const [, value] = await Promise.all([sent, response]);
+                    return value;
+                }
+                catch (error) {
+                    if (!(error instanceof MenuClientError) || error.code !== 'TIMEOUT' || attempt + 1 === attempts)
+                        throw error;
+                }
+                finally {
+                    clearTimeout(timer);
+                }
+            }
+            throw new MenuClientError('TIMEOUT', 'Remote Menu response timed out');
+        }
+        finally {
+            clearTimeout(timer);
+            this.pending.delete(key);
+        }
+    }
+    key(target, id) { return JSON.stringify([target, id]); }
+}
 async function callClient(conn, method, params) {
     try {
         return await conn.call(method, params);
@@ -220,6 +298,7 @@ async function sendOnce(options, request, timeoutMs) {
                 to: options.targetAid,
                 payload: request,
                 encrypt,
+                ttl: MENU_MESSAGE_TTL_SECONDS,
                 ...(encrypt ? { protected_headers: headers } : {}),
             });
             const messageId = sent?.message_id ?? sent?.message?.message_id;

package/dist/aun/menu/index.js

@@ -0,0 +1,2 @@
+export { ManagedMenuClient, MenuClientError, executeMenuClientRequest } from './client.js';
+export { MENU_MESSAGE_TTL_SECONDS, MENU_VOLATILE_SDK_VERSION, menuSenderDeviceId, menuTransportParams, supportsMenuVolatileTransport, } from './transport.js';

package/dist/aun/menu/transport.js

@@ -0,0 +1,49 @@
+/** Message Service TTL in seconds; unrelated to Menu execution/client timeouts. */
+export const MENU_MESSAGE_TTL_SECONDS = 60;
+export const MENU_VOLATILE_SDK_VERSION = '0.5.17';
+function parseSdkVersion(value) {
+    if (typeof value !== 'string' || !/^\d+\.\d+\.\d+$/.test(value.trim()))
+        return undefined;
+    const parts = value.trim().split('.').map(Number);
+    return parts.every(Number.isSafeInteger) ? parts : undefined;
+}
+/** Volatile cursors and device targeting require the SDK's 0.5.17 contract. */
+export function supportsMenuVolatileTransport(value) {
+    const version = parseSdkVersion(value);
+    if (!version)
+        return false;
+    const minimum = parseSdkVersion(MENU_VOLATILE_SDK_VERSION);
+    return version[0] > minimum[0]
+        || (version[0] === minimum[0] && (version[1] > minimum[1]
+            || (version[1] === minimum[1] && version[2] >= minimum[2])));
+}
+/** Read only the SDK's public sender_device_id, never a payload/recipient device. */
+export function menuSenderDeviceId(value) {
+    if (typeof value !== 'string' || value.length > 256 || /[\u0000-\u001f\u007f]/.test(value))
+        return undefined;
+    return value.trim() || undefined;
+}
+/** Enforce the Menu wire policy at the final P2P send boundary, including retries. */
+export function menuTransportParams(method, params) {
+    if (method !== 'message.send' || typeof params.payload?.type !== 'string'
+        || !params.payload.type.startsWith('menu.'))
+        return params;
+    if (params.payload.type !== 'menu.response')
+        return { ...params, ttl: MENU_MESSAGE_TTL_SECONDS };
+    const { to_device_id: target, menu_client_sdk_version: sdkVersion, ...rest } = params;
+    delete rest.device_id;
+    if (!supportsMenuVolatileTransport(sdkVersion ?? params.protected_headers?.sdk_version)) {
+        // Evol App versions backed by fastaun < 0.5.17 do not consume the
+        // volatile cursor or understand device-targeted Menu responses.
+        return rest;
+    }
+    if (target === undefined)
+        return { ...rest, ttl: MENU_MESSAGE_TTL_SECONDS };
+    const deviceId = menuSenderDeviceId(target);
+    if (!deviceId) {
+        throw Object.assign(new Error('Invalid Menu reply device'), { code: 'INVALID_MENU_REPLY_DEVICE', retryable: false });
+    }
+    // device_id takes precedence in the SDK; do not let it override the captured
+    // request sender. A rejected target is never retried as an AID broadcast.
+    return { ...rest, ttl: MENU_MESSAGE_TTL_SECONDS, to_device_id: deviceId };
+}

package/dist/aun/msg/index.js

@@ -1,4 +1,5 @@
 export { msgSend, msgPull, msgAck, msgRecall, msgOnline, } from './p2p.js';
 export { msgHistory, MAX_MSG_HISTORY_LIMIT } from './history.js';
-export { groupSend, groupPull, groupAck, groupCreate, groupInfo, groupList, groupUpdate, groupDissolve, groupSuspend, groupResume, groupJoin, groupLeave, groupInvite, groupInvites, groupAcceptInvite, groupRejectInvite, groupRevokeInvite, groupKick, groupMembers, groupOnline, groupSetRole, groupTransferOwner, groupBan, groupUnban, groupBanlist, groupRules, groupUpdateRules, groupRulesFileGet, groupRulesFileSet, groupRulesFilePublish, } from './group.js';
+export { groupHistory, parseGroupHistoryArgs, GroupHistoryError } from '../group/index.js';
+export { groupSend, groupPull, groupAck, groupCreate, groupInfo, groupList, groupUpdate, groupDissolve, groupSuspend, groupResume, groupJoin, groupLeave, groupInvite, groupInvites, groupAcceptInvite, groupRejectInvite, groupRevokeInvite, groupKick, groupMembers, groupOnline, groupSetRole, groupTransferOwner, groupBan, groupUnban, groupBanlist, groupBlock, groupUnblock, groupBlocklist, groupReportStatus, groupMemberStatuses, groupRules, groupUpdateRules, groupRulesFileGet, groupRulesFileSet, groupRulesFilePublish, } from '../group/index.js';
 export { uploadFileAndBuildPayload, inferPayloadType, isValidPayloadType } from './upload.js';

package/dist/aun/msg/managed-operation.js

@@ -1,20 +1,23 @@
 import { TextDecoder } from 'util';
 import { getAidStore, loadClient, SLOT } from '../aid/index.js';
 import { msgHistory } from './history.js';
+import { groupHistory, parseGroupHistoryArgs, GroupHistoryError } from '../group/history.js';
 import { msgOnline } from './p2p.js';
 import { resolveRoot } from '../../paths.js';
-import { isExplicitGroupId } from '../group-identity.js';
+import { normalizeGroupAid } from '../group/identity.js';
 import { isValidAid } from '../aid/validation.js';
 import { tryParseChannelKey } from '../../core/channel-loader.js';
-import { downloadGroupFsBytes } from '../group-fs-download.js';
-import { groupBan, groupBanlist, groupCreate, groupDissolve, groupInfo, groupInvite, groupJoin, groupKick, groupLeave, groupList, groupMembers, groupOnline, groupPull, groupAck, groupAcceptInvite, groupInvites, groupRejectInvite, groupRevokeInvite, groupResume, groupRules, groupRulesFileGet, groupRulesFilePublish, groupRulesFileSet, groupSetRole, groupSuspend, groupTransferOwner, groupUnban, groupUpdate, groupUpdateRules, } from './group.js';
+import { downloadGroupFsBytes } from '../group/fs-download.js';
+import { groupBan, groupBanlist, groupBlock, groupUnblock, groupBlocklist, groupReportStatus, groupMemberStatuses, groupCreate, groupDissolve, groupInfo, groupInvite, groupJoin, groupKick, groupLeave, groupList, groupMembers, groupOnline, groupPull, groupAck, groupAcceptInvite, groupInvites, groupRejectInvite, groupRevokeInvite, groupResume, groupRules, groupRulesFileGet, groupRulesFilePublish, groupRulesFileSet, groupSetRole, groupSuspend, groupTransferOwner, groupUnban, groupUpdate, groupUpdateRules, } from '../group/operations.js';
 /** Rules uploaded by a managed task are carried as bounded UTF-8 content. */
 export const MAX_MANAGED_GROUP_RULES_BYTES = 4 * 1024;
 const RELATION_GROUP_READ_KINDS = new Set([
     'info',
     'pull',
+    'history',
     'members',
     'online',
+    'member-statuses',
     'rules.get',
     'rules.get-legacy',
 ]);
@@ -22,6 +25,11 @@ const RELATION_GROUP_READ_KINDS = new Set([
 export function isManagedGroupRelationRead(command) {
     return RELATION_GROUP_READ_KINDS.has(command.kind);
 }
+/** Members may change only the current Agent's own reception and reported status. */
+export function isManagedGroupRelationWrite(command) {
+    return command.kind === 'report-status'
+        || ((command.kind === 'block' || command.kind === 'unblock') && command.memberAid === command.from);
+}
 export class ManagedGroupOperationError extends Error {
     code;
     constructor(code, message) {
@@ -33,6 +41,7 @@ export class ManagedGroupOperationError extends Error {
 const GROUP_VALUE_FLAGS = new Set([
     '--format', '--after-seq', '--limit', '--visibility', '--description', '--join-mode', '--group-id',
     '--name', '--page', '--size', '--mode', '--question', '--max-pending', '--message', '--answer', '--duration', '--member-type',
+    '--reason', '--online-status', '--work-status',
 ]);
 function failGroup(code, reason) {
     return { ok: false, code, reason };
@@ -73,13 +82,16 @@ function requiredAid(value, label) {
         return failGroup('INVALID_AID', `invalid ${label}: ${aid}`);
     return aid;
 }
-function requiredGroup(value) {
+function requiredGroup(value, from) {
     const groupId = String(value || '').trim();
     if (!groupId)
         return failGroup('INVALID_ARGUMENT', 'missing group AID');
-    if (!isExplicitGroupId(groupId))
-        return failGroup('INVALID_GROUP', `invalid group AID: ${groupId}`);
-    return groupId;
+    try {
+        return normalizeGroupAid(groupId, from?.slice(from.indexOf('.') + 1));
+    }
+    catch (error) {
+        return failGroup('INVALID_GROUP', `invalid group AID: ${groupId}: ${error.message}`);
+    }
 }
 function numberFlag(flags, name) {
     const raw = flags.get(name);
@@ -108,7 +120,7 @@ function withFromAndGroup(sub, parsed, operationId, groupRequired = true) {
         return from;
     let groupId;
     if (groupRequired) {
-        const parsedGroup = requiredGroup(parsed.positionals[1]);
+        const parsedGroup = requiredGroup(parsed.positionals[1], from);
         if (typeof parsedGroup !== 'string')
             return parsedGroup;
         groupId = parsedGroup;
@@ -121,6 +133,15 @@ export function resolveManagedGroupOperation(argv) {
     const sub = raw[0];
     if (!sub || sub === 'send')
         return failGroup('NOT_ALLOWED', 'managed group operations do not allow send; use the group send daemon route');
+    if (sub === 'history') {
+        try {
+            const history = parseGroupHistoryArgs(raw);
+            return command('history', 'ec.group.history', ['group', ...raw], history.from, { groupId: history.groupId, history });
+        }
+        catch (error) {
+            return failGroup('INVALID_ARGUMENT', error instanceof Error ? error.message : String(error));
+        }
+    }
     const parsed = parseFlags(raw.slice(1));
     if (!('positionals' in parsed))
         return parsed;
@@ -186,9 +207,10 @@ export function resolveManagedGroupOperation(argv) {
             return failGroup('INVALID_ARGUMENT', 'invalid --visibility');
         if (joinMode !== undefined && !['open', 'approval', 'invite_only', 'closed'].includes(joinMode))
             return failGroup('INVALID_ARGUMENT', 'invalid --join-mode');
-        const groupId = values.get('--group-id');
-        if (groupId !== undefined && !isExplicitGroupId(groupId))
-            return failGroup('INVALID_GROUP', `invalid --group-id: ${groupId}`);
+        const rawGroupId = values.get('--group-id');
+        const groupId = rawGroupId === undefined ? undefined : requiredGroup(rawGroupId, from);
+        if (groupId !== undefined && typeof groupId !== 'string')
+            return groupId;
         return command(sub, 'ec.group.create', ['group', sub, from, name], from, { name, visibility, description: values.get('--description'), joinMode, groupId });
     }
     const simple = new Map([
@@ -197,12 +219,16 @@ export function resolveManagedGroupOperation(argv) {
         ['join', 'ec.group.join'], ['leave', 'ec.group.leave'], ['invite', 'ec.group.invite'], ['kick', 'ec.group.kick'],
         ['members', 'ec.group.members'], ['online', 'ec.group.online'], ['role', 'ec.group.role'], ['owner', 'ec.group.owner'],
         ['ban', 'ec.group.ban'], ['unban', 'ec.group.unban'],
+        ['block', 'ec.group.block'], ['unblock', 'ec.group.unblock'], ['blocklist', 'ec.group.blocklist'],
+        ['report-status', 'ec.group.report-status'], ['member-statuses', 'ec.group.member-statuses'],
     ]);
     if (simple.has(sub)) {
         const allowedFlags = {
             pull: ['--after-seq', '--limit'], ack: [], info: [], update: ['--name', '--description'], dissolve: [],
             suspend: [], resume: [], join: ['--message', '--answer'], leave: [], invite: ['--member-type'], kick: [],
             members: ['--page', '--size'], online: [], role: [], owner: [], ban: ['--duration'], unban: [],
+            block: ['--reason'], unblock: [], blocklist: [],
+            'report-status': ['--online-status', '--work-status'], 'member-statuses': [],
         };
         const flagsError = onlyFlags(values, allowedFlags[sub] ?? []);
         if (flagsError)
@@ -248,18 +274,30 @@ export function resolveManagedGroupOperation(argv) {
                     return checked;
             }
             const memberType = values.get('--member-type');
-            if (memberType !== undefined && memberType !== 'human' && memberType !== 'ai')
+            if (memberType !== undefined && memberType !== 'human' && memberType !== 'agent')
                 return failGroup('INVALID_ARGUMENT', 'invalid --member-type');
             extra.members = members;
             extra.memberType = memberType;
         }
-        else if (sub === 'kick' || sub === 'unban') {
+        else if (sub === 'kick' || sub === 'unban' || sub === 'block' || sub === 'unblock') {
             if (positionals.length !== 3)
                 return failGroup('INVALID_ARGUMENT', `${sub} requires a member AID`);
             const memberAid = requiredAid(positionals[2], 'member AID');
             if (typeof memberAid !== 'string')
                 return memberAid;
             extra.memberAid = memberAid;
+            if (sub === 'block')
+                extra.reason = values.get('--reason');
+        }
+        else if (sub === 'report-status') {
+            if (positionals.length !== 2)
+                return failGroup('INVALID_ARGUMENT', 'report-status accepts exactly <from> <group-aid>');
+            const onlineStatus = values.get('--online-status');
+            const workStatus = values.get('--work-status');
+            if (onlineStatus === undefined || workStatus === undefined) {
+                return failGroup('INVALID_ARGUMENT', 'report-status requires --online-status and --work-status');
+            }
+            Object.assign(extra, { onlineStatus, workStatus });
         }
         else if (sub === 'members') {
             if (positionals.length !== 2)
@@ -305,7 +343,7 @@ export function resolveManagedGroupOperation(argv) {
             extra.durationSeconds = durationSeconds;
             extra.list = positionals.length === 2;
         }
-        else if (sub === 'info' || sub === 'dissolve' || sub === 'suspend' || sub === 'resume' || sub === 'leave' || sub === 'online') {
+        else if (sub === 'info' || sub === 'dissolve' || sub === 'suspend' || sub === 'resume' || sub === 'leave' || sub === 'online' || sub === 'blocklist' || sub === 'member-statuses') {
             if (positionals.length !== 2)
                 return failGroup('INVALID_ARGUMENT', `${sub} accepts exactly <from> <group-aid>`);
         }
@@ -318,7 +356,7 @@ export function resolveManagedGroupOperation(argv) {
         const from = requiredAid(positionals[0], 'from AID');
         if (typeof from !== 'string')
             return from;
-        const groupId = requiredGroup(positionals[1]);
+        const groupId = requiredGroup(positionals[1], from);
         if (typeof groupId !== 'string')
             return groupId;
         const rest = positionals.slice(2);
@@ -354,7 +392,17 @@ export function resolveManagedGroupOperation(argv) {
     return failGroup('NOT_ALLOWED', `unsupported managed group command: ${sub}`);
 }
 /** Execute a parsed command using daemon-owned AUN credentials and root. */
-export async function executeManagedGroupOperation(command, rulesContent) {
+export async function executeManagedGroupOperation(command, rulesContent, historyContext = {}) {
+    if (command.kind === 'history') {
+        try {
+            return groupHistory(command.history, historyContext);
+        }
+        catch (error) {
+            if (error instanceof GroupHistoryError)
+                throw new ManagedGroupOperationError(error.code, error.message);
+            throw error;
+        }
+    }
     const opts = { aunPath: resolveRoot() };
     let result;
     switch (command.kind) {
@@ -427,6 +475,21 @@ export async function executeManagedGroupOperation(command, rulesContent) {
         case 'unban':
             result = await groupUnban({ from: command.from, groupId: command.groupId, memberAid: command.memberAid, ...opts });
             break;
+        case 'block':
+            result = await groupBlock({ from: command.from, groupId: command.groupId, memberAid: command.memberAid, reason: command.reason, ...opts });
+            break;
+        case 'unblock':
+            result = await groupUnblock({ from: command.from, groupId: command.groupId, memberAid: command.memberAid, ...opts });
+            break;
+        case 'blocklist':
+            result = await groupBlocklist({ from: command.from, groupId: command.groupId, ...opts });
+            break;
+        case 'report-status':
+            result = await groupReportStatus({ from: command.from, groupId: command.groupId, onlineStatus: command.onlineStatus, workStatus: command.workStatus, ...opts });
+            break;
+        case 'member-statuses':
+            result = await groupMemberStatuses({ from: command.from, groupId: command.groupId, ...opts });
+            break;
         case 'rules.get':
             result = await groupRulesFileGet({ from: command.from, groupId: command.groupId, ...opts });
             break;
@@ -678,10 +741,13 @@ function parseRemote(value, allowEmpty) {
     const separator = value.indexOf(':');
     if (separator <= 0)
         return failFs('INVALID_PATH', 'remote path must use <group-aid>:<absolute-path>');
-    const groupId = value.slice(0, separator).trim();
+    let groupId;
     const remotePath = value.slice(separator + 1);
-    if (!isValidAid(groupId) || !isExplicitGroupId(groupId)) {
-        return failFs('INVALID_GROUP', `invalid group AID: ${groupId}`);
+    try {
+        groupId = normalizeGroupAid(value.slice(0, separator).trim());
+    }
+    catch (error) {
+        return failFs('INVALID_GROUP', `invalid group AID: ${error.message}`);
     }
     if (remotePath === '' && allowEmpty)
         return { groupId, remotePath: '' };

package/dist/aun/msg/mention-schema.js

@@ -18,3 +18,54 @@ export function normalizeAunMentionEntries(raw) {
     }
     return entries;
 }
+/** Reject unsupported attention values before normalizing the outbound payload. */
+export function parseAunAttention(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === 'completed' || value === 'failed' || value === 'required' || value === 'interrupted')
+        return value;
+    throw Object.assign(new Error('attention must be completed, failed, required, or interrupted'), {
+        code: 'INVALID_ATTENTION',
+    });
+}
+/**
+ * Project runner state as a pair, using the structured status as the authority.
+ * Action cards always require action. All other business payloads omit both
+ * fields, including explicit/custom payloads and entries retried from outbox.
+ */
+export function withAunAttention(payload, fallback) {
+    parseAunAttention(payload.attention);
+    parseAunAttention(fallback);
+    const attention = payload.type === 'action_card'
+        ? 'required'
+        : payload.type === 'task.status' && typeof payload.status === 'string'
+            ? aunStatusAttention(payload.status)
+            : undefined;
+    const normalized = { ...payload };
+    delete normalized.terminal;
+    delete normalized.attention;
+    return attention === undefined
+        ? normalized
+        : { ...normalized, terminal: attention !== 'required', attention };
+}
+export function aunStatusAttention(status) {
+    switch (status) {
+        case 'done':
+        case 'completed': return 'completed';
+        case 'error':
+        case 'timeout': return 'failed';
+        case 'interrupted': return 'interrupted';
+        case 'requires_action': return 'required';
+        default: return undefined;
+    }
+}
+/** Business messages and command feedback never inherit runner attention. */
+export function aunOutboundAttention(payload) {
+    parseAunAttention(payload.attention);
+    switch (payload.kind) {
+        case 'interaction': return 'required';
+        default: return payload.kind.startsWith('status.')
+            ? aunStatusAttention(payload.kind.slice(7))
+            : undefined;
+    }
+}

package/dist/aun/msg/p2p.js

@@ -8,9 +8,9 @@ import { normalizeCodexTextPayload, readBestTaskRuntimeContext, runtimeRefMessag
 import { chatDirPath } from '../../core/session/session-fs-store.js';
 import { resolvePaths } from '../../paths.js';
 import { ipcQuery } from '../../ipc.js';
-import { AGENT_DELEGATION_TOKEN_ENV } from '../../core/auth/agent-delegation.js';
+import { readDelegationCredential } from '../../core/auth/agent-delegation.js';
 import { loadDaemonConfig } from '../../config-store.js';
-import { normalizeAunMentionEntries } from './mention-schema.js';
+import { normalizeAunMentionEntries, withAunAttention } from './mention-schema.js';
 const DAEMON_SEND_TIMEOUT_GRACE_MS = 10_000;
 const DEFAULT_IDLE_TIMEOUT_MS = 120_000;
 const MAX_TIMER_MS = 2_147_483_647;
@@ -67,7 +67,7 @@ function messageLogContent(body) {
 }
 function applyRoutingPayloadFields(payload, args, runtimeContext, includeRuntimeRef = true) {
     const threadId = msgSendThreadId(args, payload, runtimeContext);
-    if (threadId && !payload.thread_id)
+    if (threadId)
         payload.thread_id = threadId;
     if (!includeRuntimeRef)
         return;
@@ -110,7 +110,7 @@ function msgSendLogMetadata(args, payload, runtimeContext) {
 }
 async function tryDaemonMsgSend(args, payload, runtimeContext, file) {
     const delegatedTask = !!process.env.EVOLCORE_SESSION_ID
-        || !!process.env[AGENT_DELEGATION_TOKEN_ENV];
+        || !!readDelegationCredential();
     if (!runtimeContext) {
         return delegatedTask
             ? { ok: false, code: 'DELEGATION_REQUIRED', error: 'Task runtime context is unavailable' }
@@ -135,11 +135,12 @@ async function tryDaemonMsgSend(args, payload, runtimeContext, file) {
         encrypt: args.encrypt,
         thread,
         returnPolicy: args.returnPolicy,
+        handoffContext: args.handoffContext,
         originSessionId: runtimeContext.sessionId,
         originMessageId: runtimeContext.messageId,
-        delegationToken: process.env[AGENT_DELEGATION_TOKEN_ENV],
+        delegationToken: readDelegationCredential(),
         log: msgSendLogMetadata(args, payload, runtimeContext),
-    }, daemonTaskSendIpcTimeoutMs(!!file));
+    }, daemonTaskSendIpcTimeoutMs(!!file), { throwOnError: true });
     return response ?? {
         ok: false,
         code: 'AUN_DAEMON_UNAVAILABLE',
@@ -213,6 +214,10 @@ async function appendMsgSendOutboundLog(args, result, opts) {
     catch { /* daemon 不在或 IPC 失败都忽略 */ }
 }
 export async function msgSend(args) {
+    if (args.handoffContext !== undefined && (!process.env.EVOLCORE_SESSION_ID
+        || !args.handoffContext.trim() || args.handoffContext.length > 64 * 1024)) {
+        return { ok: false, code: 'INVALID_HANDOFF_CONTEXT', error: 'handoff context requires a managed session and 1–65536 characters' };
+    }
     const runtimeContext = await readBestTaskRuntimeContext();
     // Contact admission is a daemon-owned policy for managed Agent tasks. A
     // non-managed CLI caller may use any valid AUN sender identity and must not
@@ -223,7 +228,7 @@ export async function msgSend(args) {
     try {
         let payload;
         if (args.body.mode !== 'file') {
-            payload = buildSimplePayload(args.body);
+            payload = withAunAttention(buildSimplePayload(args.body));
             normalizeCodexTextPayload(payload, runtimeContext);
             if (Object.prototype.hasOwnProperty.call(payload, 'mentions')) {
                 payload.mentions = normalizeAunMentionEntries(payload.mentions);
@@ -267,7 +272,7 @@ export async function msgSend(args) {
         const idStore = await getAidStore({ slotId: args.slotId ?? SLOT.cli, aunPath: args.aunPath });
         let peerIdentity;
         try {
-            peerIdentity = await PeerIdentityCache.resolve('aun', args.to, selfAgentDir, idStore, false);
+            peerIdentity = await PeerIdentityCache.resolve('aun', args.to, selfAgentDir, idStore, false, args.aunPath);
         }
         finally {
             try {
@@ -292,6 +297,7 @@ export async function msgSend(args) {
             payload.mentions = normalizeAunMentionEntries(payload.mentions);
         }
         const encrypt = resolveAunMessageEncrypt(args.encrypt);
+        payload = withAunAttention(payload);
         const sendParams = { to: args.to, payload, encrypt };
         const result = await conn.call('message.send', sendParams);
         const messageId = typeof result?.message_id === 'string' && result.message_id.trim()
@@ -348,11 +354,15 @@ export async function msgPull(args) {
         return {
             ok: true,
             messages: result?.messages ?? [],
-            count: result?.count ?? 0,
+            count: result?.count ?? result?.messages?.length ?? 0,
             latest_seq: result?.latest_seq ?? 0,
             earliest_available_seq: result?.earliest_available_seq ?? null,
             ephemeral_earliest_available_seq: result?.ephemeral_earliest_available_seq ?? null,
             ephemeral_dropped_count: result?.ephemeral_dropped_count ?? 0,
+            ...(typeof result?.latest_volatile_cursor === 'string' ? { latest_volatile_cursor: result.latest_volatile_cursor } : {}),
+            ...(typeof result?.volatile_earliest_cursor === 'string' ? { volatile_earliest_cursor: result.volatile_earliest_cursor } : {}),
+            ...(typeof result?.volatile_dropped_count === 'number' ? { volatile_dropped_count: result.volatile_dropped_count } : {}),
+            ...(typeof result?.volatile_has_more === 'boolean' ? { volatile_has_more: result.volatile_has_more } : {}),
         };
     }
     catch (e) {