evolcore 0.0.21 → 0.0.23

package/dist/agents/ecagent-runner.js

@@ -1,3 +1,4 @@
+import { getRunnerCatalog, catalogEfforts, assertCatalogSelectable } from '../core/model/model-catalog.js';
 import fs from 'fs';
 import path from 'path';
 import { AgentHarness, JsonlSessionRepo, NodeExecutionEnv, } from '../../ecagent/dist/node.js';
@@ -20,8 +21,6 @@ const PROVIDER_ID = 'evolcore-gateway';
 const DEFAULT_SYSTEM_PROMPT = `You are ecagent, the coding agent built into EvolCore.
 Work directly in the current project. Inspect relevant files before changing them, keep edits scoped, and verify the result.
 Use the provided tools for filesystem and shell work. Never claim a tool action succeeded unless its result confirms success.`;
-const MODEL_CACHE_TTL_MS = 5 * 60 * 1000;
-const MODEL_LIST_TIMEOUT_MS = 8_000;
 const MAX_READ_BYTES = 1024 * 1024;
 const MAX_TOOL_OUTPUT = 200_000;
 const MAX_SCAN_FILES = 5_000;
@@ -705,7 +704,6 @@ export class EcagentRunner {
     permissionGateway;
     sendPromptFn;
     onCompactStart;
-    modelCache;
     constructor(config, callbacks, runtime) {
         this.config = {
             ...config,
@@ -745,35 +743,16 @@ export class EcagentRunner {
             { key: 'bypass', nameZh: '放行', description: '普通审批清单自动执行，强危险操作仍需审批', available: true },
         ];
     }
+    getModelCatalog() {
+        return getRunnerCatalog('ecagent', this.agentAid, this.config);
+    }
     async listModels() {
-        if (this.modelCache && Date.now() - this.modelCache.fetchedAt < MODEL_CACHE_TTL_MS)
-            return [...this.modelCache.ids];
-        const stale = this.modelCache?.ids;
-        try {
-            const signal = AbortSignal.timeout(MODEL_LIST_TIMEOUT_MS);
-            const response = await fetch(appendRequestPath(this.config.baseUrl, 'models', this.config.queryParams), {
-                headers: {
-                    authorization: `Bearer ${this.config.apiKey}`,
-                    ...this.config.headers,
-                },
-                signal,
-            });
-            if (!response.ok)
-                throw new Error(`Failed to list ecagent models: HTTP ${response.status}`);
-            const payload = await response.json();
-            const ids = [...new Set((payload.data ?? [])
-                    .map(item => typeof item.id === 'string' ? item.id : '')
-                    .filter(id => id.startsWith('claude-') || (id.startsWith('gpt-') && !id.startsWith('gpt-image-'))))];
-            if (ids.length === 0)
-                throw new Error('Gateway returned no supported Claude or GPT models');
-            this.modelCache = { ids, fetchedAt: Date.now() };
-            return [...ids];
-        }
-        catch (error) {
-            if (stale && stale.length > 0)
-                return [...stale];
-            throw error;
-        }
+        const catalog = await this.getModelCatalog();
+        assertCatalogSelectable(catalog);
+        return catalog.models.map(m => m.id);
+    }
+    async getAvailableEfforts(model) {
+        return catalogEfforts(await this.getModelCatalog(), model, 'ecagent');
     }
     registerStream(key, stream) { this.activeStreams.set(key, stream); }
     cleanupStream(key) {

package/dist/agents/gemini-runner.js

@@ -1,3 +1,4 @@
+import { getCatalog, assertCatalogSelectable } from '../core/model/model-catalog.js';
 /**
  * Gemini Agent Runner
  *
@@ -39,11 +40,6 @@ const MIME_EXT = {
     'image/webp': '.webp',
 };
 // ── Gemini 模型列表 ──
-const GEMINI_MODELS = [
-    'gemini-2.5-pro',
-    'gemini-2.5-flash',
-    'gemini-2.5-flash-lite',
-];
 const GEMINI_READONLY_TOOLS = [
     'read_file', 'list_directory', 'glob', 'grep_search', 'google_web_search',
     'codebase_investigator', 'cli_help', 'get_internal_docs', 'update_topic', 'complete_task',
@@ -296,7 +292,7 @@ export class GeminiRunner {
     // ── ModelSwitcher ──
     setModel(model) { this.model = model; }
     getModel() { return this.model; }
-    listModels() { return GEMINI_MODELS; }
+    async listModels() { const catalog = await getCatalog(undefined, 'gemini'); assertCatalogSelectable(catalog); return catalog.models.map(m => m.id); }
     // ── Effort (not applicable) ──
     setEffort(_effort) { }
     getEffort() { return undefined; }

package/dist/aun/aid/store.js

@@ -24,6 +24,7 @@ const GROUP_PULL_PAGINATION_PATCH = Symbol('evolcore.groupPullPaginationPatch');
  *  - CLI / ecweb 查询使用新的独立 slot，不能共享 daemon 的 token 或 seq 游标。
  *  - netcheck 使用独立消费者，不得因诊断连接影响 daemon 的入站顺序。
  *  - 群规则同步是短连接 RPC，也必须使用独立 slot，避免触碰 daemon 消费游标。
+ *  - menu-client 是远程 Control AID 的短连接请求器，使用独立 slot，避免触碰 daemon 消费游标。
  *  - bench 各并发单元用 evolcore-bench-<N>，各自独立隔离键，互不干扰
  */
 export const SLOT = {
@@ -32,6 +33,7 @@ export const SLOT = {
     daemon: 'evolcore daemon',
     cli: 'evolcore-cli',
     groupRules: 'evolcore-group-rules',
+    menuClient: 'evolcore-menu-client',
     bench: 'evolcore-bench',
     netcheck: 'evolcore-netcheck',
 };

package/dist/aun/menu-client.js

@@ -0,0 +1,272 @@
+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';
+const DEFAULT_TIMEOUT_MS = 15_000;
+const MAX_TIMEOUT_MS = 120_000;
+const POLL_INTERVAL_MS = 200;
+const PULL_LIMIT = 50;
+const LOCK_STALE_MS = 5 * 60_000;
+export class MenuClientError extends Error {
+    code;
+    data;
+    constructor(code, message, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+        this.name = 'MenuClientError';
+    }
+}
+async function callClient(conn, method, params) {
+    try {
+        return await conn.call(method, params);
+    }
+    catch (error) {
+        if (error instanceof MenuClientError)
+            throw error;
+        const code = String(error?.code ?? '').toLowerCase();
+        const message = error?.message ?? String(error);
+        const timedOut = code.includes('timeout') || code.includes('timed_out') || /timed?\s*out|timeout/i.test(String(message));
+        throw new MenuClientError(timedOut ? 'TIMEOUT' : 'RPC_FAILED', String(message));
+    }
+}
+function normalizeTimeout(value) {
+    const timeout = value ?? DEFAULT_TIMEOUT_MS;
+    if (!Number.isFinite(timeout) || timeout < 1_000 || timeout > MAX_TIMEOUT_MS) {
+        throw new MenuClientError('INVALID_ARGUMENT', `timeout must be between 1s and ${MAX_TIMEOUT_MS / 1000}s`);
+    }
+    return Math.round(timeout);
+}
+function lockPath(aunPath, fromAid) {
+    const identity = crypto.createHash('sha256').update(fromAid).digest('hex').slice(0, 16);
+    return path.join(aunPath ?? resolveRoot(), 'data', 'instance', `menu-client-${identity}.lock`);
+}
+function acquireClientLock(aunPath, fromAid) {
+    const file = lockPath(aunPath, fromAid);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const token = `${process.pid}:${crypto.randomUUID()}`;
+    try {
+        const stat = fs.statSync(file);
+        if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
+            try {
+                fs.unlinkSync(file);
+            }
+            catch { }
+        }
+    }
+    catch { }
+    let fd;
+    try {
+        fd = fs.openSync(file, 'wx', 0o600);
+        fs.writeFileSync(fd, token, 'utf8');
+    }
+    catch (error) {
+        try {
+            if (fd !== undefined)
+                fs.closeSync(fd);
+        }
+        catch { }
+        try {
+            if (fs.existsSync(file))
+                fs.unlinkSync(file);
+        }
+        catch { }
+        if (error?.code === 'EEXIST')
+            throw new MenuClientError('CLIENT_BUSY', 'Another ec menu-client request is using the configured slot');
+        throw new MenuClientError('CLIENT_LOCK_FAILED', `Unable to acquire menu-client lock: ${error?.message ?? String(error)}`);
+    }
+    return () => {
+        try {
+            const current = fs.readFileSync(file, 'utf8');
+            if (current === token)
+                fs.unlinkSync(file);
+        }
+        catch { }
+        if (fd !== undefined) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch { }
+        }
+    };
+}
+function normalizeRequest(value) {
+    const request = { ...value };
+    if (typeof request.id !== 'string' || !request.id.trim())
+        request.id = crypto.randomUUID();
+    const error = validateMenuRequest(request);
+    if (error)
+        throw new MenuClientError(error.code, error.message, error.data);
+    return request;
+}
+function responseFromMessage(message) {
+    const from = typeof message?.from === 'string'
+        ? message.from.trim()
+        : typeof message?.envelope?.from === 'string' ? message.envelope.from.trim() : '';
+    let payload = message?.payload;
+    if (typeof payload === 'string') {
+        try {
+            payload = JSON.parse(payload);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload))
+        return undefined;
+    if (from && typeof payload.type === 'string' && payload.type === 'menu.response') {
+        try {
+            return parseMenuResponse(payload);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return undefined;
+}
+async function pollResponse(conn, targetAid, requestId, timeoutMs, initialAfterSeq) {
+    const deadline = Date.now() + timeoutMs;
+    let afterSeq = initialAfterSeq;
+    while (Date.now() < deadline) {
+        const result = await callClient(conn, 'message.pull', { after_seq: afterSeq, limit: PULL_LIMIT });
+        const messages = Array.isArray(result?.messages) ? result.messages : [];
+        let maxSeq = afterSeq;
+        for (const message of messages) {
+            const seq = Number(message?.seq);
+            if (Number.isSafeInteger(seq) && seq > maxSeq)
+                maxSeq = seq;
+            const response = responseFromMessage(message);
+            const messageFrom = typeof message?.from === 'string'
+                ? message.from.trim()
+                : typeof message?.envelope?.from === 'string' ? message.envelope.from.trim() : '';
+            if (response && messageFrom === targetAid && response.id === requestId) {
+                if (Number.isSafeInteger(maxSeq) && maxSeq > afterSeq) {
+                    try {
+                        await callClient(conn, 'message.ack', { seq: maxSeq });
+                    }
+                    catch (error) {
+                        throw new MenuClientError('ACK_FAILED', error?.message ?? String(error));
+                    }
+                }
+                return response;
+            }
+        }
+        if (Number.isSafeInteger(maxSeq) && maxSeq > afterSeq) {
+            afterSeq = maxSeq;
+            try {
+                await callClient(conn, 'message.ack', { seq: afterSeq });
+            }
+            catch (error) {
+                throw new MenuClientError('ACK_FAILED', error?.message ?? String(error));
+            }
+        }
+        const waitMs = Math.min(POLL_INTERVAL_MS, Math.max(1, deadline - Date.now()));
+        await new Promise(resolve => setTimeout(resolve, waitMs));
+    }
+    throw new MenuClientError('TIMEOUT', `Timed out waiting for Menu response ${requestId}`);
+}
+async function drainBaseline(conn) {
+    let afterSeq = 0;
+    for (let page = 0; page < 200; page += 1) {
+        const result = await callClient(conn, 'message.pull', { after_seq: afterSeq, limit: PULL_LIMIT });
+        const messages = Array.isArray(result?.messages) ? result.messages : [];
+        let maxSeq = Math.max(afterSeq, Number(result?.server_ack_seq) || 0);
+        for (const message of messages) {
+            const seq = Number(message?.seq);
+            if (Number.isSafeInteger(seq) && seq > maxSeq)
+                maxSeq = seq;
+        }
+        if (maxSeq > afterSeq) {
+            try {
+                await callClient(conn, 'message.ack', { seq: maxSeq });
+            }
+            catch (error) {
+                throw new MenuClientError('ACK_FAILED', error?.message ?? String(error));
+            }
+            afterSeq = maxSeq;
+        }
+        if (messages.length < PULL_LIMIT)
+            return afterSeq;
+    }
+    throw new MenuClientError('BASELINE_TOO_LARGE', 'menu-client backlog exceeds the bounded baseline drain');
+}
+async function sendOnce(options, request, timeoutMs) {
+    const slotId = options.slotId ?? SLOT.menuClient;
+    const encrypt = options.encrypt ?? true;
+    if (!encrypt) {
+        throw new MenuClientError('INVALID_CLIENT', 'ec-menu-client requires E2EE protected headers; remove --no-encrypt');
+    }
+    const headers = buildMenuClientProtectedHeaders({
+        clientName: 'ec-menu-client',
+        clientVersion: readInstalledEvolcoreVersion(),
+        remoteAccessToken: options.remoteAccessToken ?? options.ecwebToken,
+    });
+    const conn = await createShortConnection(options.fromAid, {
+        aunPath: options.aunPath,
+        slotId,
+        shortTtlMs: timeoutMs * (request.type === 'menu.query' || request.type === 'menu.options' ? 2 : 1) + 10_000,
+    });
+    try {
+        let baselineSeq = await drainBaseline(conn);
+        const attempts = request.type === 'menu.query' || request.type === 'menu.options' ? 2 : 1;
+        let lastError;
+        for (let attempt = 0; attempt < attempts; attempt += 1) {
+            const sent = await callClient(conn, 'message.send', {
+                to: options.targetAid,
+                payload: request,
+                encrypt,
+                ...(encrypt ? { protected_headers: headers } : {}),
+            });
+            const messageId = sent?.message_id ?? sent?.message?.message_id;
+            if (typeof messageId !== 'string' || !messageId.trim()) {
+                throw new MenuClientError('SEND_FAILED', 'message.send returned no message_id');
+            }
+            try {
+                return await pollResponse(conn, options.targetAid, request.id, timeoutMs, baselineSeq);
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt + 1 < attempts && error instanceof MenuClientError && error.code === 'TIMEOUT') {
+                    baselineSeq = await drainBaseline(conn);
+                    continue;
+                }
+                throw error;
+            }
+        }
+        throw lastError ?? new MenuClientError('INTERNAL_ERROR', 'Menu request failed');
+    }
+    finally {
+        await conn.close();
+    }
+}
+export async function executeMenuClientRequest(options) {
+    if (!isValidAid(options.fromAid) || !isValidAid(options.targetAid)) {
+        throw new MenuClientError('INVALID_ARGUMENT', 'fromAid and targetAid must be valid AIDs');
+    }
+    if (options.slotId !== undefined && (typeof options.slotId !== 'string' || !options.slotId.trim())) {
+        throw new MenuClientError('INVALID_ARGUMENT', 'slotId must be a non-empty string');
+    }
+    const slotId = options.slotId ?? SLOT.menuClient;
+    if (slotId.length > 128 || !/^[A-Za-z0-9._-][A-Za-z0-9._/ :\-]*$/.test(slotId)) {
+        throw new MenuClientError('INVALID_ARGUMENT', 'slotId contains unsupported characters');
+    }
+    if (options.aunPath !== undefined && (typeof options.aunPath !== 'string' || !options.aunPath.trim())) {
+        throw new MenuClientError('INVALID_ARGUMENT', 'aunPath must be a non-empty path');
+    }
+    const request = normalizeRequest(options.request);
+    const timeoutMs = normalizeTimeout(options.timeoutMs);
+    const release = options.slotId && options.slotId !== SLOT.menuClient
+        ? () => { }
+        : acquireClientLock(options.aunPath, options.fromAid);
+    try {
+        return await sendOnce(options, request, timeoutMs);
+    }
+    finally {
+        release();
+    }
+}

package/dist/aun/msg/group.js

@@ -297,8 +297,16 @@ export async function groupAck(args) {
     }
 }
 export async function groupCreate(args) {
-    const store = await getAidStore({ slotId: args.slotId ?? SLOT.cli, aunPath: args.aunPath });
-    const conn = await loadClient(store, args.from);
+    return groupCreateWithDependencies(args, { getAidStore, loadClient });
+}
+/**
+ * Injectable boundary for the lifecycle call. Keeping the store/client
+ * construction outside the RPC makes the aidStore contract regression-testable
+ * without opening a real gateway connection.
+ */
+export async function groupCreateWithDependencies(args, dependencies) {
+    const store = await dependencies.getAidStore({ slotId: args.slotId ?? SLOT.cli, aunPath: args.aunPath });
+    const conn = await dependencies.loadClient(store, args.from);
     try {
         await conn.connect({ connection_kind: 'short', short_ttl_ms: 30000, auto_reconnect: false });
         const params = { name: args.name };
@@ -313,7 +321,7 @@ export async function groupCreate(args) {
             params.description = args.description;
         if (args.joinMode)
             params.join_mode = args.joinMode;
-        const result = await conn.createGroup(params);
+        const result = await conn.createGroup(params, { aidStore: store });
         return { ok: true, group: result?.group ?? result };
     }
     catch (e) {
@@ -510,7 +518,16 @@ export async function groupInvite(args) {
     try {
         for (const memberAid of args.members) {
             try {
-                await conn.call('group.add_member', { group_id: args.groupId, aid: memberAid });
+                // fastaun 0.5.12 introduced targeted invitations. The current gateway
+                // supports this lifecycle directly; do not bypass invitee consent with
+                // the immediate-membership group.add_member operation.
+                const inviteParams = {
+                    group_id: args.groupId,
+                    aid: memberAid,
+                };
+                if (args.memberType !== undefined)
+                    inviteParams.member_type = args.memberType;
+                await conn.call('group.invite_member', inviteParams);
                 added.push(memberAid);
             }
             catch (e) {
@@ -523,6 +540,50 @@ export async function groupInvite(args) {
         await conn.close();
     }
 }
+/** List pending targeted invitations for the authenticated AID. */
+export async function groupInvites(args) {
+    const conn = await createShortConnection(args.from, { aunPath: args.aunPath, slotId: args.slotId });
+    try {
+        const params = {};
+        if (args.page !== undefined)
+            params.page = args.page;
+        if (args.size !== undefined)
+            params.size = args.size;
+        const result = await conn.call('group.list_my_invites', params);
+        const invites = Array.isArray(result) ? result : Array.isArray(result?.invites)
+            ? result.invites
+            : Array.isArray(result?.items) ? result.items : [];
+        return {
+            ok: true,
+            invites,
+            page: typeof result?.page === 'number' ? result.page : args.page,
+            size: typeof result?.size === 'number' ? result.size : args.size,
+            nextCursor: typeof result?.next_cursor === 'string' ? result.next_cursor : null,
+        };
+    }
+    catch (e) {
+        return formatRpcError(e);
+    }
+    finally {
+        await conn.close();
+    }
+}
+async function groupInviteAction(args, method) {
+    const conn = await createShortConnection(args.from, { aunPath: args.aunPath, slotId: args.slotId });
+    try {
+        const result = await conn.call(method, { invite_id: args.inviteId });
+        return { ok: true, group_id: result?.group_id ?? '', data: result };
+    }
+    catch (e) {
+        return formatRpcError(e);
+    }
+    finally {
+        await conn.close();
+    }
+}
+export const groupAcceptInvite = (args) => groupInviteAction(args, 'group.accept_invite');
+export const groupRejectInvite = (args) => groupInviteAction(args, 'group.reject_invite');
+export const groupRevokeInvite = (args) => groupInviteAction(args, 'group.revoke_invite');
 export async function groupKick(args) {
     const conn = await createShortConnection(args.from, { aunPath: args.aunPath, slotId: args.slotId });
     try {

package/dist/aun/msg/index.js

@@ -1,4 +1,4 @@
 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, groupKick, groupMembers, groupOnline, groupSetRole, groupTransferOwner, groupBan, groupUnban, groupBanlist, groupRules, groupUpdateRules, groupRulesFileGet, groupRulesFileSet, groupRulesFilePublish, } from './group.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 { uploadFileAndBuildPayload, inferPayloadType, isValidPayloadType } from './upload.js';

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

@@ -7,7 +7,7 @@ import { isExplicitGroupId } 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, groupResume, groupRules, groupRulesFileGet, groupRulesFilePublish, groupRulesFileSet, groupSetRole, groupSuspend, groupTransferOwner, groupUnban, groupUpdate, groupUpdateRules, } from './group.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';
 /** 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([
@@ -32,7 +32,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',
+    '--name', '--page', '--size', '--mode', '--question', '--max-pending', '--message', '--answer', '--duration', '--member-type',
 ]);
 function failGroup(code, reason) {
     return { ok: false, code, reason };
@@ -125,6 +125,37 @@ export function resolveManagedGroupOperation(argv) {
     if (!('positionals' in parsed))
         return parsed;
     const { positionals, values } = parsed;
+    if (sub === 'invites') {
+        const flagsError = onlyFlags(values, ['--page', '--size']);
+        if (flagsError)
+            return flagsError;
+        if (positionals.length !== 1)
+            return failGroup('INVALID_ARGUMENT', 'invites accepts exactly <from>');
+        const from = requiredAid(positionals[0], 'from AID');
+        if (typeof from !== 'string')
+            return from;
+        const page = numberFlag(values, '--page');
+        const size = numberFlag(values, '--size');
+        if (typeof page !== 'number' && page !== undefined)
+            return page;
+        if (typeof size !== 'number' && size !== undefined)
+            return size;
+        return command(sub, 'ec.group.invites', ['group', sub, from], from, { page, size });
+    }
+    if (sub === 'accept-invite' || sub === 'reject-invite' || sub === 'revoke-invite') {
+        const flagsError = onlyFlags(values, []);
+        if (flagsError)
+            return flagsError;
+        if (positionals.length !== 2)
+            return failGroup('INVALID_ARGUMENT', `${sub} accepts exactly <from> <invite-id>`);
+        const from = requiredAid(positionals[0], 'from AID');
+        if (typeof from !== 'string')
+            return from;
+        const inviteId = String(positionals[1]).trim();
+        if (!inviteId)
+            return failGroup('INVALID_ARGUMENT', 'missing invite-id');
+        return command(sub, `ec.group.${sub}`, ['group', sub, from, inviteId], from, { inviteId });
+    }
     if (sub === 'list') {
         const flagsError = onlyFlags(values, ['--size']);
         if (flagsError)
@@ -170,7 +201,7 @@ export function resolveManagedGroupOperation(argv) {
     if (simple.has(sub)) {
         const allowedFlags = {
             pull: ['--after-seq', '--limit'], ack: [], info: [], update: ['--name', '--description'], dissolve: [],
-            suspend: [], resume: [], join: ['--message', '--answer'], leave: [], invite: [], kick: [],
+            suspend: [], resume: [], join: ['--message', '--answer'], leave: [], invite: ['--member-type'], kick: [],
             members: ['--page', '--size'], online: [], role: [], owner: [], ban: ['--duration'], unban: [],
         };
         const flagsError = onlyFlags(values, allowedFlags[sub] ?? []);
@@ -216,7 +247,11 @@ export function resolveManagedGroupOperation(argv) {
                 if (typeof checked !== 'string')
                     return checked;
             }
+            const memberType = values.get('--member-type');
+            if (memberType !== undefined && memberType !== 'human' && memberType !== 'ai')
+                return failGroup('INVALID_ARGUMENT', 'invalid --member-type');
             extra.members = members;
+            extra.memberType = memberType;
         }
         else if (sub === 'kick' || sub === 'unban') {
             if (positionals.length !== 3)
@@ -357,7 +392,19 @@ export async function executeManagedGroupOperation(command, rulesContent) {
             result = await groupLeave({ from: command.from, groupId: command.groupId, ...opts });
             break;
         case 'invite':
-            result = await groupInvite({ from: command.from, groupId: command.groupId, members: command.members, ...opts });
+            result = await groupInvite({ from: command.from, groupId: command.groupId, members: command.members, memberType: command.memberType, ...opts });
+            break;
+        case 'invites':
+            result = await groupInvites({ from: command.from, page: command.page, size: command.size, ...opts });
+            break;
+        case 'accept-invite':
+            result = await groupAcceptInvite({ from: command.from, inviteId: command.inviteId, ...opts });
+            break;
+        case 'reject-invite':
+            result = await groupRejectInvite({ from: command.from, inviteId: command.inviteId, ...opts });
+            break;
+        case 'revoke-invite':
+            result = await groupRevokeInvite({ from: command.from, inviteId: command.inviteId, ...opts });
             break;
         case 'kick':
             result = await groupKick({ from: command.from, groupId: command.groupId, memberAid: command.memberAid, ...opts });

package/dist/aun/outbox.js

@@ -215,6 +215,13 @@ export function findByDedupeKey(aid, dedupeKey, opts = {}, queue = 'default') {
         : load(aid, queue);
     return entries.find(entry => entry.dedupeKey === dedupeKey);
 }
+/** Find all durable entries belonging to an operation family. */
+export function findByDedupePrefix(aid, dedupePrefix, opts = {}, queue = 'default') {
+    const entries = opts.includeTerminal
+        ? readEntries(aid, queue).filter(entry => !isExpired(entry))
+        : load(aid, queue);
+    return entries.filter(entry => typeof entry.dedupeKey === 'string' && entry.dedupeKey.startsWith(dedupePrefix));
+}
 export function cleanup(aid, queue = 'default') {
     const all = readEntries(aid, queue);
     let expired = 0;

package/dist/aun/rpc/client.js

@@ -3,11 +3,18 @@ export async function createShortConnection(aid, opts) {
     const store = await getAidStore({ slotId: opts?.slotId ?? SLOT.cli, aunPath: opts?.aunPath });
     try {
         const client = await loadClient(store, aid);
-        await client.connect({ connection_kind: 'short', short_ttl_ms: 30000, auto_reconnect: false });
+        await client.connect({ connection_kind: 'short', short_ttl_ms: opts?.shortTtlMs ?? 30000, auto_reconnect: false });
         return {
             async call(method, params) {
                 return client.call(method, params);
             },
+            group: {
+                inviteMember: (params) => client.group.inviteMember(params),
+                listMyInvites: (params) => client.group.listMyInvites(params),
+                acceptInvite: (params) => client.group.acceptInvite(params),
+                rejectInvite: (params) => client.group.rejectInvite(params),
+                revokeInvite: (params) => client.group.revokeInvite(params),
+            },
             async close() {
                 try {
                     await client.close();