evolcore 0.0.28 → 0.0.29

package/dist/agents/gemini-runner.js

@@ -24,6 +24,7 @@ import { commandExists } from '../utils/cross-platform.js';
 import { GeminiSessionFileAdapter } from '../core/session/adapters/gemini-session-file-adapter.js';
 import { logger } from '../utils/logger.js';
 import { normalizeExecutionPermissionMode, normalizePermissionMode } from '../core/permission/mode.js';
+import { resolveRoot } from '../paths.js';
 import { workspaceContainsHClassPaths } from '../core/permission/protected-paths.js';
 import { buildBubblewrapCommand } from '../core/permission/sandbox-runtime.js';
 import { getManagedTaskTempDir } from '../cli/task-context.js';
@@ -103,15 +104,10 @@ function isGeminiPermissionDenial(event) {
 }
 const GEMINI_H_CLASS_PATTERNS = [
     String.raw `evolcore\.json`,
-    String.raw `agents[/\\]defaults\.json`,
-    String.raw `agents[/\\]defaults_\d+\.json`,
-    String.raw `agents[/\\][^/\\"]+[/\\]config\.json`,
-    String.raw `agents[/\\][^/\\"]+[/\\]contact\.json`,
-    String.raw `agents[/\\][^/\\"]+[/\\]relations[/\\][^/\\"]+[/\\]config\.json`,
-    String.raw `backups[/\\]config`,
+    String.raw `(?:^|[/\\"])data(?:[/\\"]|$)`,
+    String.raw `(?:^|[/\\"])(?:AIDs|aids)(?:[/\\"]|$)`,
     String.raw `\.snapshots`,
     String.raw `(?:^|[/\\"])CA(?:[/\\"]|$)`,
-    String.raw `(?:AIDs|aids)[/\\][^/\\"]+[/\\](?:cert|keys)`,
     String.raw `(?:^|[/\\"])\.device_id(?:[/\\"]|$)`,
     String.raw `(?:^|[/\\"])\.env(?:[/\\"]|$)`,
     String.raw `(?:^|[/\\"])\.seed(?:[/\\"]|$)`,
@@ -119,13 +115,13 @@ const GEMINI_H_CLASS_PATTERNS = [
     String.raw `(?:^|[/\\"])\.migrated-[^/\\"]+`,
     String.raw `(?:^|[/\\"])\.lock(?:[/\\"]|$)`,
     String.raw `(?:^|[/\\"])daemon\.pid(?:[/\\"]|$)`,
-    String.raw `\.json_`,
-    String.raw `\.json\.migrated`,
-    String.raw `agents[/\\][^/\\"]+[/\\](?:sessions|data[/\\](?:channels|handoff|outbox\.jsonl|contact-audit\.jsonl))`,
-    String.raw `data[/\\]triggers(?:[/\\]|$)`,
-    String.raw `data[/\\](?:sessions|contact-book-audit\.jsonl|feishu-seen-[^/\\"]+\.jsonl|[a-z0-9_-]+-greeted-[^/\\"]+\.jsonl|channel-state|daemon[/\\](?:control|migrations|message-queue\.json))`,
+    String.raw `agents[/\\][^/\\"]+[/\\]data[/\\]codex-tokens(?:[/\\]|$)`,
+    String.raw `agents[/\\][^/\\"]+[/\\](?:data[/\\](?:[^/\\"]+[/\\])*context-tokens\.json|(?:data[/\\](?:[^/\\"]+[/\\])*menu-tokens\.json))`,
 ];
 const GEMINI_L_CLASS_PATTERNS = [
+    String.raw `agents[/\\]defaults\.json`,
+    String.raw `agents[/\\][^/\\"]+[/\\](?:config\.json|contact\.json|contact-operations\.jsonl|relations[/\\][^/\\"]+[/\\]config\.json|roles|triggers)`,
+    String.raw `backups[/\\]config`,
     String.raw `agents[/\\][^/\\"]+[/\\]triggers(?:[/\\]|$)`,
 ];
 const GEMINI_L_CLASS_WRITE_TOOLS = [
@@ -165,6 +161,24 @@ export function resolveGeminiPermissionProfile(value, bootstrap = false) {
 function escapeGeminiArgsRegex(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
+function geminiAgentRootPattern(aid) {
+    return `agents[/\\]${escapeGeminiArgsRegex(aid)}(?:[/\\]|$)`;
+}
+function geminiHClassPatterns(options = {}) {
+    const patterns = [...GEMINI_H_CLASS_PATTERNS];
+    if (!options.selfAid)
+        return patterns;
+    try {
+        const agentsRoot = path.join(options.root ?? resolveRoot(), 'agents');
+        for (const entry of fs.readdirSync(agentsRoot, { withFileTypes: true })) {
+            if (!entry.isDirectory() || entry.name.toLowerCase() === options.selfAid.toLowerCase())
+                continue;
+            patterns.push(geminiAgentRootPattern(entry.name));
+        }
+    }
+    catch { }
+    return patterns;
+}
 function normalizeGeminiBootstrapAgentMdPath(candidate) {
     const filePath = path.resolve(candidate);
     const aidDir = path.dirname(filePath);
@@ -198,13 +212,14 @@ function appendGeminiPolicyRule(lines, toolName, decision, priority, argsPattern
     lines.push(`decision = "${decision}"`);
     lines.push(`priority = ${priority}`, '');
 }
-export function buildGeminiAdminPolicy(profile, bootstrapAgentMdPath, personalMdPath) {
+export function buildGeminiAdminPolicy(profile, bootstrapAgentMdPath, personalMdPath, scope = {}) {
     const lines = [];
+    const hClassPatterns = geminiHClassPatterns(scope);
     if (bootstrapAgentMdPath) {
         const bootstrap = normalizeGeminiBootstrapAgentMdPath(bootstrapAgentMdPath);
         // Preserve the global protected-path boundary even if a malformed internal
         // caller ever supplies a protected file as the bootstrap target.
-        for (const pattern of GEMINI_H_CLASS_PATTERNS) {
+        for (const pattern of hClassPatterns) {
             appendGeminiPolicyRule(lines, '*', 'deny', 998, pattern);
         }
         for (const pattern of GEMINI_L_CLASS_PATTERNS) {
@@ -236,7 +251,7 @@ export function buildGeminiAdminPolicy(profile, bootstrapAgentMdPath, personalMd
         appendGeminiPolicyRule(lines, 'run_shell_command', 'allow', 999, pattern);
     }
     // H-class protection is mode-independent and applies to built-in and MCP tools.
-    for (const pattern of GEMINI_H_CLASS_PATTERNS) {
+    for (const pattern of hClassPatterns) {
         appendGeminiPolicyRule(lines, '*', 'deny', 998, pattern);
     }
     for (const pattern of GEMINI_L_CLASS_PATTERNS) {
@@ -394,8 +409,10 @@ export class GeminiRunner {
         const runtimeLockDir = runtimeEnv?.EVOLCORE_RUNTIME_LOCK_DIR;
         const geminiHome = path.join(os.homedir(), '.gemini');
         fs.mkdirSync(geminiHome, { recursive: true, mode: 0o700 });
+        const selfAid = this.permissionContexts.get(sessionId)?.selfAid;
         const sandboxProbe = executionPermissionMode === 'fullaccess' ? undefined : buildBubblewrapCommand(this.resolved.cliPath, [], {
             projectPath,
+            selfAid,
             writablePaths: [
                 geminiHome,
                 ...(runtimeDir ? [runtimeDir] : []),
@@ -404,7 +421,7 @@ export class GeminiRunner {
                 ...(personalMdPath ? [personalMdPath] : []),
             ],
         });
-        if (executionPermissionMode !== 'fullaccess' && !sandboxProbe && workspaceContainsHClassPaths(projectPath)) {
+        if (executionPermissionMode !== 'fullaccess' && !sandboxProbe && workspaceContainsHClassPaths(projectPath, resolveRoot(), { selfAid })) {
             throw new Error('Gemini 缺少可用的路径级隔离运行时，且项目覆盖 EvolCore 受保护根；已拒绝启动本轮任务');
         }
         // Build CLI args
@@ -430,7 +447,7 @@ export class GeminiRunner {
             }
             else {
                 const policyPath = path.join(managedTmpDir, `evolcore-gemini-permission-${crypto.randomUUID()}.toml`);
-                fs.writeFileSync(policyPath, buildGeminiAdminPolicy(permissionProfile, bootstrapAgentMdPath, personalMdPath), { mode: 0o600, flag: 'wx' });
+                fs.writeFileSync(policyPath, buildGeminiAdminPolicy(permissionProfile, bootstrapAgentMdPath, personalMdPath, { root: resolveRoot(), selfAid }), { mode: 0o600, flag: 'wx' });
                 tempFiles.push(policyPath);
                 args.push(...buildGeminiPermissionArgs(permissionProfile, policyPath, !!sandboxProbe));
             }
@@ -467,6 +484,7 @@ export class GeminiRunner {
         const env = this.buildAgentEnv(sessionId, runtimeEnv);
         const sandboxedCommand = executionPermissionMode === 'fullaccess' ? undefined : buildBubblewrapCommand(this.resolved.cliPath, args, {
             projectPath,
+            selfAid,
             writablePaths: [
                 geminiHome,
                 ...(runtimeDir ? [runtimeDir] : []),

package/dist/aun/group/history.js

@@ -1,12 +1,11 @@
 import fs from 'fs';
-import path from 'path';
 import { createHash } from 'crypto';
 import { TextDecoder } from 'util';
 import { isValidAid } from '../aid/validation.js';
 import { normalizeGroupAid } from './identity.js';
 import { resolvePaths } from '../../paths.js';
-import { appendJsonlDurable, chatDirPath } from '../../core/session/session-fs-store.js';
-import { isTransientProtocolMessage, messageLogPath } from '../../core/message/message-log.js';
+import { chatDirPath } from '../../core/session/session-fs-store.js';
+import { isTransientProtocolMessage, messageLogPath, } from '../../core/message/message-log.js';
 export class GroupHistoryError extends Error {
     code;
     constructor(code, message) {
@@ -26,15 +25,15 @@ export function parseGroupHistoryArgs(argv) {
         fail('INVALID_ARGUMENT', 'history 需要群 AID');
     const groupId = normalizeGroupAid(args[1], from.slice(from.indexOf('.') + 1));
     const values = new Map();
-    const flags = new Set(['--unread', '--all']);
-    const named = new Set(['--limit', '--thread', '--before', '--after', '--direction', '--format', '--message', '--offset']);
+    const named = new Set([
+        '--limit', '--thread', '--before', '--before-id', '--after', '--after-id',
+        '--direction', '--format', '--message', '--offset',
+    ]);
     for (let i = 2; i < args.length; i++) {
         const flag = args[i];
         if (values.has(flag))
             fail('INVALID_ARGUMENT', flag + ' 不能重复');
-        if (flags.has(flag))
-            values.set(flag, 'true');
-        else if (named.has(flag)) {
+        if (named.has(flag)) {
             const value = args[++i];
             if (!value || value.startsWith('--'))
                 fail('INVALID_ARGUMENT', flag + ' 缺少值');
@@ -43,16 +42,8 @@ export function parseGroupHistoryArgs(argv) {
         else
             fail('INVALID_ARGUMENT', '不支持的 history 参数: ' + flag);
     }
-    if (values.has('--unread') && values.has('--all'))
-        fail('INVALID_ARGUMENT', '--unread 与 --all 互斥');
-    if (!values.has('--unread') && !values.has('--all')) {
-        fail('INVALID_ARGUMENT', 'history 必须明确指定 --unread 或 --all');
-    }
     if (values.has('--format') && !['text', 'json'].includes(values.get('--format')))
         fail('INVALID_ARGUMENT', '--format 仅支持 text|json');
-    if ((values.has('--message') || values.has('--offset')) && !values.has('--all')) {
-        fail('INVALID_ARGUMENT', '--message/--offset 仅支持 --all');
-    }
     if (values.has('--offset') && !values.has('--message'))
         fail('INVALID_ARGUMENT', '--offset 需要 --message');
     const offset = values.has('--offset') ? Number(values.get('--offset')) : undefined;
@@ -77,9 +68,22 @@ export function parseGroupHistoryArgs(argv) {
     const after = time('--after');
     if (before !== undefined && after !== undefined && after >= before)
         fail('INVALID_ARGUMENT', '--after 必须早于 --before');
+    if (values.has('--before-id') && before === undefined)
+        fail('INVALID_ARGUMENT', '--before-id 需要 --before');
+    if (values.has('--after-id') && after === undefined)
+        fail('INVALID_ARGUMENT', '--after-id 需要 --after');
+    if (values.has('--before-id') && values.has('--after-id'))
+        fail('INVALID_ARGUMENT', 'before 与 after 游标不能同时指定');
+    for (const flag of ['--before-id', '--after-id']) {
+        const cursorId = values.get(flag);
+        if (cursorId !== undefined && !/^[a-f0-9]{64}$/.test(cursorId)) {
+            fail('INVALID_ARGUMENT', `${flag} 必须是返回的 64 位游标 ID`);
+        }
+    }
     return {
-        from, groupId, unread: values.has('--unread'), thread: values.get('--thread'),
-        limit, direction, before, after, message: values.get('--message'), offset,
+        from, groupId, thread: values.get('--thread'),
+        limit, direction, before, beforeId: values.get('--before-id'),
+        after, afterId: values.get('--after-id'), message: values.get('--message'), offset,
     };
 }
 const DETAIL_BYTES = 8 * 1024;
@@ -135,24 +139,7 @@ function json(line) {
         return JSON.parse(line);
     }
     catch {
-        return fail('HISTORY_CORRUPT', '历史文件含损坏的完整 JSONL 行，未推进已读状态');
-    }
-}
-function generation(file) {
-    try {
-        const stat = fs.statSync(file);
-        // First complete record plus file identity stays stable across append, but changes on replacement.
-        let first = '';
-        for (const line of lines(file)) {
-            first = line;
-            break;
-        }
-        return digest(JSON.stringify([stat.dev, stat.ino, stat.birthtimeMs, digest(first)]));
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return 'missing';
-        throw error;
+        return fail('HISTORY_CORRUPT', '历史文件含损坏的完整 JSONL 行');
     }
 }
 function* records(file, args) {
@@ -179,25 +166,8 @@ function* records(file, args) {
         if (seen.has(identity))
             continue;
         seen.add(identity);
-        // Keep the existing read-state fingerprints compatible; redelivery seq/time do not change identity.
-        const hash = digest(JSON.stringify([identity, entry.threadId ?? null, entry.from, entry.to,
-            entry.msgType, entry.encrypt, entry.content, entry.payloadSummary, entry.groupAttention, entry.groupDelivery]));
-        yield { entry, hash };
-    }
-}
-function readState(chatDir, logGeneration) {
-    const read = new Set();
-    for (const line of lines(path.join(chatDir, 'group-history-read.jsonl'))) {
-        const event = json(line);
-        if (!event || event.version !== 1 || typeof event.generation !== 'string' || !Array.isArray(event.records)
-            || !event.records.every(value => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value))) {
-            fail('HISTORY_STATE_CORRUPT', '群历史已读状态损坏');
-        }
-        if (event.generation === logGeneration)
-            for (const value of event.records)
-                read.add(value);
+        yield { entry, cursorId: digest(identity) };
     }
-    return read;
 }
 function matchThread(entry, thread) {
     return thread === 'all' || (thread === 'main' ? !entry.threadId : entry.threadId === thread);
@@ -209,7 +179,7 @@ function utf8Prefix(content, bytes) {
         end--;
     return buffer.subarray(0, end).toString('utf8');
 }
-/** Local-only history. Unread queries record only the messages selected for this result. */
+/** Local-only, read-only group history. */
 export function groupHistory(args, context = {}) {
     if (!isValidAid(args.from))
         fail('INVALID_SELF_AID', '无效 self AID');
@@ -220,14 +190,10 @@ export function groupHistory(args, context = {}) {
     const thread = args.thread ?? context.defaultThread ?? 'all';
     if (!thread || thread.length > 512 || /[\x00-\x1f]/.test(thread))
         fail('INVALID_THREAD', '无效 thread');
-    const chatDir = chatDirPath(context.sessionsDir ?? resolvePaths().sessionsDir, 'aun', args.groupId, args.from);
+    const chatDir = chatDirPath(context.sessionsDir ?? resolvePaths().sessionsDir, 'aun', args.groupId, args.from, context.channelKey);
     const file = messageLogPath(chatDir);
     const base = { ok: true, source: 'local', self_aid: args.from, group_id: args.groupId };
-    const logGeneration = args.unread ? generation(file) : '';
-    const read = args.unread ? readState(chatDir, logGeneration) : new Set();
     if (args.message) {
-        if (args.unread)
-            fail('INVALID_ARGUMENT', '--message 仅支持 --all');
         const offset = args.offset ?? 0;
         if (!Number.isSafeInteger(offset) || offset < 0)
             fail('INVALID_ARGUMENT', '无效 offset');
@@ -246,37 +212,40 @@ export function groupHistory(args, context = {}) {
         }
         return fail('MESSAGE_NOT_FOUND', '本地当前范围内找不到该消息');
     }
+    const forward = args.after !== undefined;
     const selected = [];
-    let hasMore = false;
     let bytes = 0;
+    let hasMore = false;
     for (const record of records(file, args)) {
-        const { entry } = record;
+        const { entry, cursorId } = record;
         if (!matchThread(entry, thread)
-            || (args.direction && args.direction !== 'all' && entry.dir !== args.direction)
-            || (args.after !== undefined && entry.ts <= args.after)
-            || (args.before !== undefined && entry.ts >= args.before))
-            continue;
-        if (args.unread && (entry.dir !== 'in' || entry.groupDelivery !== 'filtered'
-            || entry.groupAttention !== 'unmentioned' || read.has(record.hash)))
+            || (args.direction && args.direction !== 'all' && entry.dir !== args.direction))
             continue;
-        const size = Buffer.byteLength(JSON.stringify(entry));
-        if (args.unread) {
-            if (selected.length >= limit || (selected.length && bytes + size > MAX_PAGE_BYTES)) {
-                hasMore = true;
-                break;
-            }
-            selected.push(record);
-            bytes += size;
+        if (args.after !== undefined) {
+            if (entry.ts < args.after || (entry.ts === args.after
+                && (args.afterId === undefined || cursorId <= args.afterId)))
+                continue;
         }
-        else {
+        if (args.before !== undefined) {
+            if (entry.ts > args.before || (entry.ts === args.before
+                && (args.beforeId === undefined || cursorId >= args.beforeId)))
+                continue;
+        }
+        const recordBytes = Buffer.byteLength(JSON.stringify(entry));
+        const insertAt = selected.findIndex(candidate => (candidate.entry.ts > entry.ts
+            || (candidate.entry.ts === entry.ts && candidate.cursorId.localeCompare(cursorId) > 0)));
+        if (insertAt < 0)
             selected.push(record);
-            bytes += size;
-            while (selected.length > limit || (selected.length > 1 && bytes > MAX_PAGE_BYTES)) {
-                bytes -= Buffer.byteLength(JSON.stringify(selected.shift().entry));
-                hasMore = true;
-            }
+        else
+            selected.splice(insertAt, 0, record);
+        bytes += recordBytes;
+        while (selected.length > limit || (selected.length > 1 && bytes > MAX_PAGE_BYTES)) {
+            const removed = forward ? selected.pop() : selected.shift();
+            bytes -= Buffer.byteLength(JSON.stringify(removed.entry));
+            hasMore = true;
         }
     }
+    const cursorRecord = forward ? selected.at(-1) : selected[0];
     const messages = selected.map(({ entry }) => {
         if (Buffer.byteLength(JSON.stringify(entry)) <= MAX_PAGE_BYTES)
             return entry;
@@ -289,15 +258,86 @@ export function groupHistory(args, context = {}) {
         };
     });
     const result = {
-        ...base, mode: args.unread ? 'unread' : 'all', thread_id: thread,
+        ...base, mode: 'history', thread_id: thread,
         count: messages.length, has_more: hasMore, messages,
+        ...(hasMore && cursorRecord ? (forward
+            ? { next_after: { ts: cursorRecord.entry.ts, id: cursorRecord.cursorId } }
+            : { next_before: { ts: cursorRecord.entry.ts, id: cursorRecord.cursorId } }) : {}),
     };
-    // Persist the exact returned selection, never an entire group/time/seq watermark.
-    // Query errors above leave state untouched; --all never writes read state.
-    if (args.unread && selected.length) {
-        appendJsonlDurable(path.join(chatDir, 'group-history-read.jsonl'), {
-            version: 1, generation: logGeneration, records: selected.map(record => record.hash), confirmedAt: Date.now(),
-        });
-    }
     return result;
 }
+/** Build the bounded, read-only background snapshot used by auto attention. */
+export function readGroupHistoryContext(input) {
+    const now = input.now ?? Date.now();
+    const maxAgeMs = input.maxAgeMs;
+    const maxMessages = input.maxMessages ?? 20;
+    const maxChars = input.maxChars ?? Number.MAX_SAFE_INTEGER;
+    const maxMessageChars = input.maxMessageChars;
+    const excluded = new Set(input.excludeMessageIds ?? []);
+    const collectAll = maxMessages >= Number.MAX_SAFE_INTEGER;
+    const args = { from: input.from, groupId: input.groupId };
+    const candidates = [];
+    const file = messageLogPath(chatDirPath(input.sessionsDir ?? resolvePaths().sessionsDir, 'aun', input.groupId, input.from, input.channelKey));
+    for (const { entry } of records(file, args)) {
+        if (excluded.has(entry.msgId || ''))
+            continue;
+        if ((maxAgeMs !== undefined && entry.ts < now - maxAgeMs) || entry.ts > now)
+            continue;
+        if (!matchThread(entry, input.thread))
+            continue;
+        if (entry.msgType === 'command' || entry.groupAttention === 'command' || /^\s*\//.test(entry.content)
+            || !['text', 'quote', 'voice', 'image', 'video', 'file', 'link'].includes(entry.msgType))
+            continue;
+        if (/\[EvolCore\.(receive|reply|agent)\]/.test(entry.content))
+            continue;
+        if (!entry.content.trim())
+            continue;
+        const content = maxMessageChars !== undefined && entry.content.length > maxMessageChars
+            ? `${entry.content.slice(0, Math.floor(maxMessageChars * 0.75))}\n[...truncated...]\n${entry.content.slice(-Math.floor(maxMessageChars * 0.25))}`
+            : entry.content;
+        const decision = entry.attentionDecision?.decision
+            ?? (entry.groupAttention === 'auto-ignore' ? 'ignore'
+                : entry.groupAttention === 'auto-defer' ? 'defer'
+                    : entry.groupAttention === 'auto-interrupt' ? 'interrupt'
+                        : entry.groupAttention === 'auto-fallback' ? 'ignore'
+                            : null);
+        const lifecycle = decision === 'defer' ? 'pending' : 'consumed';
+        const candidate = {
+            source: 'background',
+            message_id: entry.msgId,
+            ...(entry.sessionId ? { session_id: entry.sessionId } : {}),
+            sender: entry.from,
+            role: entry.permMode || 'unknown',
+            timestamp: new Date(entry.ts).toISOString(),
+            content,
+            lifecycle,
+            decision,
+            msg_type: entry.msgType,
+        };
+        if (collectAll) {
+            candidates.push(candidate);
+        }
+        else {
+            const insertAt = candidates.findIndex(previous => previous.timestamp > candidate.timestamp);
+            if (insertAt < 0)
+                candidates.push(candidate);
+            else
+                candidates.splice(insertAt, 0, candidate);
+            if (candidates.length > maxMessages)
+                candidates.shift();
+        }
+    }
+    if (collectAll)
+        candidates.sort((left, right) => (Date.parse(left.timestamp) - Date.parse(right.timestamp)));
+    const selected = [];
+    let chars = 0;
+    for (let index = candidates.length - 1; index >= 0 && selected.length < maxMessages; index--) {
+        const candidate = candidates[index];
+        const candidateChars = Buffer.byteLength(JSON.stringify(candidate));
+        if (chars + candidateChars > maxChars)
+            break;
+        selected.push(candidate);
+        chars += candidateChars;
+    }
+    return selected.reverse();
+}

package/dist/aun/group/operations.js

@@ -9,7 +9,7 @@ import { daemonTaskSendIpcTimeoutMs, resolveAunMessageEncrypt } from '../msg/p2p
 import { checkGroupIndex, getGroupIndex } from './index-rpc.js';
 import { appendMessageLog, buildOutboundEntry, classifyAunPayloadForLog } from '../../core/message/message-log.js';
 import { chatDirPath } from '../../core/session/session-fs-store.js';
-import { normalizeCodexTextPayload, readBestTaskRuntimeContext } from '../../cli/task-context.js';
+import { readBestTaskRuntimeContext } from '../../cli/task-context.js';
 import { ipcQuery, IpcTransportError } from '../../ipc.js';
 import { resolvePaths } from '../../paths.js';
 import { readDelegationCredential } from '../../core/auth/agent-delegation.js';
@@ -173,7 +173,6 @@ export async function groupSend(args) {
     const runtimeContext = await readBestTaskRuntimeContext();
     if (args.body.mode !== 'file') {
         const payload = buildGroupPayload(args.body);
-        normalizeCodexTextPayload(payload, runtimeContext);
         applyGroupRoutingPayloadFields(payload, args, runtimeContext);
         const daemonResult = await tryDaemonGroupSend(args, payload, runtimeContext);
         if (daemonResult)
@@ -215,7 +214,6 @@ export async function groupSend(args) {
                 break;
             }
         }
-        normalizeCodexTextPayload(payload, runtimeContext);
         const payloadMentions = Object.prototype.hasOwnProperty.call(payload, 'mentions')
             ? normalizeAunMentionEntries(payload.mentions)
             : undefined;

package/dist/aun/menu/transport.js

@@ -8,7 +8,9 @@ function parseSdkVersion(value) {
     return parts.every(Number.isSafeInteger) ? parts : undefined;
 }
 /** Volatile cursors and device targeting require the SDK's 0.5.17 contract. */
-export function supportsMenuVolatileTransport(value) {
+export function supportsMenuVolatileTransport(value, capability) {
+    if (capability === true || capability === '1')
+        return true;
     const version = parseSdkVersion(value);
     if (!version)
         return false;
@@ -30,9 +32,9 @@ export function menuTransportParams(method, params) {
         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;
+    const { to_device_id: target, menu_client_sdk_version: sdkVersion, menu_client_volatile_v1: capability, ...rest } = params;
     delete rest.device_id;
-    if (!supportsMenuVolatileTransport(sdkVersion ?? params.protected_headers?.sdk_version)) {
+    if (!supportsMenuVolatileTransport(sdkVersion ?? params.protected_headers?.sdk_version, capability)) {
         // Evol App versions backed by fastaun < 0.5.17 do not consume the
         // volatile cursor or understand device-targeted Menu responses.
         return rest;

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

@@ -9,6 +9,8 @@ import { isValidAid } from '../aid/validation.js';
 import { tryParseChannelKey } from '../../core/channel-loader.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';
+import { handleGroupMenu, GroupMenuError } from '../../core/command/group-menu.js';
+import { readRolesConfig } from '../../config/roles.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([
@@ -20,6 +22,7 @@ const RELATION_GROUP_READ_KINDS = new Set([
     'member-statuses',
     'rules.get',
     'rules.get-legacy',
+    'mention',
 ]);
 /** Read operations that a user role may perform against its current group relation. */
 export function isManagedGroupRelationRead(command) {
@@ -146,6 +149,31 @@ export function resolveManagedGroupOperation(argv) {
     if (!('positionals' in parsed))
         return parsed;
     const { positionals, values } = parsed;
+    if (sub === 'mention') {
+        const flagsError = onlyFlags(values, ['--clear']);
+        if (flagsError)
+            return flagsError;
+        const from = requiredAid(positionals[0], 'from AID');
+        if (typeof from !== 'string')
+            return from;
+        const groupId = requiredGroup(positionals[1], from);
+        if (typeof groupId !== 'string')
+            return groupId;
+        const mode = positionals[2];
+        if (positionals.length > 3)
+            return failGroup('INVALID_ARGUMENT', 'mention accepts <from> <group-aid> [<mode>]');
+        const clear = values.has('--clear');
+        if (mode !== undefined && clear)
+            return failGroup('INVALID_ARGUMENT', 'mention <mode> and --clear are mutually exclusive');
+        if (mode !== undefined && !['mention-only', 'disabled', 'auto'].includes(mode)) {
+            return failGroup('INVALID_ARGUMENT', `invalid mention mode: ${mode}`);
+        }
+        return command(sub, 'ec.group.mention', ['group', sub, from, groupId, ...(mode ? [mode] : []), ...(clear ? ['--clear'] : [])], from, {
+            groupId,
+            ...(mode ? { mode } : {}),
+            clear,
+        });
+    }
     if (sub === 'invites') {
         const flagsError = onlyFlags(values, ['--page', '--size']);
         if (flagsError)
@@ -297,6 +325,9 @@ export function resolveManagedGroupOperation(argv) {
             if (onlineStatus === undefined || workStatus === undefined) {
                 return failGroup('INVALID_ARGUMENT', 'report-status requires --online-status and --work-status');
             }
+            if (![onlineStatus, workStatus].every(status => /^[a-z][a-z0-9_-]{0,63}$/i.test(status))) {
+                return failGroup('INVALID_ARGUMENT', 'report-status values must be single-line status identifiers');
+            }
             Object.assign(extra, { onlineStatus, workStatus });
         }
         else if (sub === 'members') {
@@ -510,6 +541,45 @@ export async function executeManagedGroupOperation(command, rulesContent, histor
         case 'rules.get-legacy':
             result = await groupRules({ from: command.from, groupId: command.groupId, ...opts });
             break;
+        case 'mention': {
+            try {
+                const menuContext = {
+                    self: command.from,
+                    role: readRolesConfig(command.from).defaultRoles?.group ?? 'member',
+                    isDaemonOwner: false,
+                    currentGroupId: command.groupId,
+                    roleContext: {
+                        self: command.from,
+                        actorRole: readRolesConfig(command.from).defaultRoles?.group ?? 'member',
+                        aunAvailable: true,
+                    },
+                };
+                const mode = command.mode;
+                const clear = command.clear === true;
+                if (mode === undefined && !clear) {
+                    const query = await handleGroupMenu({ kind: 'query', args: { view: 'mentionMode', scope: 'relation', groupId: command.groupId } }, menuContext);
+                    result = { ok: true, ...(query && typeof query === 'object' ? query : {}) };
+                }
+                else {
+                    const current = await handleGroupMenu({ kind: 'query', args: { view: 'mentionMode', scope: 'relation', groupId: command.groupId } }, menuContext);
+                    const revision = typeof current?.revision === 'string' ? current.revision : '';
+                    if (!revision)
+                        throw new ManagedGroupOperationError('INVALID_REVISION', 'unable to resolve current mentionMode revision');
+                    const updated = await handleGroupMenu({
+                        kind: 'update',
+                        args: { resource: 'mentionMode', scope: 'relation', groupId: command.groupId, expectedRevision: revision },
+                        value: clear ? 'clear' : mode,
+                    }, menuContext);
+                    result = { ok: true, ...(updated && typeof updated === 'object' ? updated : {}) };
+                }
+            }
+            catch (error) {
+                if (error instanceof GroupMenuError)
+                    throw new ManagedGroupOperationError(error.code, error.message);
+                throw error;
+            }
+            break;
+        }
         default: throw new ManagedGroupOperationError('NOT_ALLOWED', `unsupported managed group operation: ${command.kind}`);
     }
     if (!result || result.ok !== true) {

package/dist/aun/msg/p2p.js

@@ -4,7 +4,7 @@ import { createShortConnection } from '../rpc/index.js';
 import { getAidStore, SLOT } from '../aid/store.js';
 import { uploadFileAndBuildPayload } from './upload.js';
 import { appendMessageLog, buildOutboundEntry, classifyAunPayloadForLog } from '../../core/message/message-log.js';
-import { normalizeCodexTextPayload, readBestTaskRuntimeContext, runtimeRefMessageIdForMsgSend } from '../../cli/task-context.js';
+import { readBestTaskRuntimeContext, runtimeRefMessageIdForMsgSend } from '../../cli/task-context.js';
 import { chatDirPath } from '../../core/session/session-fs-store.js';
 import { resolvePaths } from '../../paths.js';
 import { ipcQuery } from '../../ipc.js';
@@ -229,7 +229,6 @@ export async function msgSend(args) {
         let payload;
         if (args.body.mode !== 'file') {
             payload = withAunAttention(buildSimplePayload(args.body));
-            normalizeCodexTextPayload(payload, runtimeContext);
             if (Object.prototype.hasOwnProperty.call(payload, 'mentions')) {
                 payload.mentions = normalizeAunMentionEntries(payload.mentions);
             }
@@ -286,7 +285,6 @@ export async function msgSend(args) {
         // 3. 构建 payload
         if (!payload) {
             payload = buildSimplePayload(args.body);
-            normalizeCodexTextPayload(payload, runtimeContext);
         }
         // 4. 写入 payload.chatmode
         payload.chatmode = chatmode;

package/dist/aun/msg/upload.js

@@ -27,8 +27,8 @@ export function inferPayloadType(filename) {
 export function isValidPayloadType(value) {
     return value === 'image' || value === 'video' || value === 'voice' || value === 'file';
 }
-/** 单次上传最大大小（与 daemon sendFile 一致）。 */
-export const MAX_AUN_ATTACHMENT_SIZE = 10 * 1024 * 1024;
+/** 单次上传最大大小（与 daemon sendFile 和 Menu file fetch 一致）。 */
+export const MAX_AUN_ATTACHMENT_SIZE = 256 * 1024 * 1024;
 /**
  * 上传内存中的二进制内容并构造发送用的标准附件 payload。
  */