evolcore 0.0.22 → 0.0.24

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,13 +21,18 @@ 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;
 const MAX_SEARCH_RESULTS = 500;
 const DEFAULT_BASH_TIMEOUT_MS = 120_000;
+/**
+ * 规范化模型 ID：去掉 Claude Code SDK 专有的上下文窗口后缀 [1m]/[200k]
+ * Ecagent/OpenAI API 不认识这些后缀，必须传入标准模型 ID
+ */
+function stripContextWindowSuffix(modelId) {
+    return modelId.replace(/\[(?:1m|200k)\]$/i, '');
+}
 class AsyncEventQueue {
     values = [];
     waiters = [];
@@ -705,7 +711,6 @@ export class EcagentRunner {
     permissionGateway;
     sendPromptFn;
     onCompactStart;
-    modelCache;
     constructor(config, callbacks, runtime) {
         this.config = {
             ...config,
@@ -716,7 +721,7 @@ export class EcagentRunner {
                 configuredHeaders: config.headers,
             }),
         };
-        this.model = config.model;
+        this.model = stripContextWindowSuffix(config.model);
         this.effort = config.effort;
         this.agentAid = runtime?.agentAid;
         this.onSessionIdUpdate = callbacks?.onSessionIdUpdate;
@@ -726,7 +731,7 @@ export class EcagentRunner {
             throw new Error('ecagent requires an EvolCore Agent AID');
         return agentSessionsDir(this.agentAid);
     }
-    setModel(model) { this.model = model; }
+    setModel(model) { this.model = stripContextWindowSuffix(model); }
     getModel() { return this.model; }
     resolveModelId(model) { return model; }
     setEffort(effort) { this.effort = effort; }
@@ -745,35 +750,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) {
@@ -1016,6 +1002,13 @@ export class EcagentRunner {
         return runtime;
     }
     mapHarnessEvent(queue, event, stats, model, effort) {
+        if (event.type === 'message_update'
+            && (event.assistantMessageEvent.type === 'thinking_start'
+                || event.assistantMessageEvent.type === 'thinking_delta'
+                || event.assistantMessageEvent.type === 'thinking_end')) {
+            queue.push({ type: 'heartbeat', source: 'reasoning', turn: stats.numTurns + 1 });
+            return;
+        }
         if (event.type === 'message_update' && event.assistantMessageEvent.type === 'text_delta') {
             if (!stats.firstTextAt)
                 stats.firstTextAt = Date.now();
@@ -1223,7 +1216,7 @@ export class EcagentRunner {
                 ? cached
                 : await this.openExistingRuntime(agentSessionId, cwd);
             this.onCompactStart?.(sessionId);
-            const compactModel = modelOverride?.model || this.model;
+            const compactModel = stripContextWindowSuffix(modelOverride?.model || this.model);
             const compactEffort = modelOverride?.effortMode === 'model_default'
                 ? undefined
                 : modelOverride?.effort ?? this.effort;

package/dist/agents/gemini-runner.js

@@ -1,3 +1,4 @@
+import { getCatalog, assertCatalogSelectable } from '../core/model/model-catalog.js';
 /**
  * Gemini Agent Runner
  *
@@ -23,6 +24,7 @@ import { normalizeExecutionPermissionMode, normalizePermissionMode } from '../co
 import { workspaceContainsHClassPaths } from '../core/permission/protected-paths.js';
 import { buildBubblewrapCommand } from '../core/permission/sandbox-runtime.js';
 import { getManagedTaskTempDir } from '../cli/task-context.js';
+import { auditPermissionLifecycle } from '../core/auth/authorization-audit.js';
 // Strip ANSI escape codes from Gemini CLI text output.
 // Gemini embeds raw terminal colors from tool stdout (e.g. vitest, npm)
 // into its assistant text, unlike Claude SDK which strips them internally.
@@ -31,6 +33,13 @@ const ANSI_RE = /\x1b\[[0-9;]*[a-zA-Z]|\x1b\].*?(?:\x1b\\|\x07)/g;
 function stripAnsi(text) {
     return text.replace(ANSI_RE, '');
 }
+/**
+ * 规范化模型 ID：去掉 Claude Code SDK 专有的上下文窗口后缀 [1m]/[200k]
+ * Gemini API 不认识这些后缀，必须传入标准模型 ID
+ */
+function stripContextWindowSuffix(modelId) {
+    return modelId.replace(/\[(?:1m|200k)\]$/i, '');
+}
 // ── MIME → 扩展名映射 ──
 const MIME_EXT = {
     'image/png': '.png',
@@ -39,11 +48,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',
@@ -290,13 +294,13 @@ export class GeminiRunner {
     permissionContexts = new Map();
     constructor(config, callbacks) {
         this.resolved = resolveGoogleConfig(config);
-        this.model = this.resolved.model;
+        this.model = stripContextWindowSuffix(this.resolved.model);
         this.onSessionIdUpdate = callbacks.onSessionIdUpdate;
     }
     // ── ModelSwitcher ──
-    setModel(model) { this.model = model; }
+    setModel(model) { this.model = stripContextWindowSuffix(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; }
@@ -691,6 +695,56 @@ export class GeminiRunner {
             logger.info(`[GeminiRunner] interaction.auto_resolved kind=${normalizeGeminiToolName(toolName)} session=${sessionId}`);
             return;
         }
+        const lifecycleRequestId = requestId ?? `gemini-approval-${crypto.randomUUID()}`;
+        const auditSummary = `${toolName} runtime authorization denied by Gemini headless policy`;
+        auditPermissionLifecycle({
+            phase: 'request',
+            requestId: lifecycleRequestId,
+            sessionId,
+            toolName,
+            decision: 'pending',
+            decisionSource: 'approval',
+            permissionMode: context.permissionMode,
+            agentAid: context.selfAid,
+            agentName: context.agentName,
+            role: context.role,
+            taskId: context.taskId,
+            summary: auditSummary,
+        });
+        auditPermissionLifecycle({
+            phase: 'response',
+            requestId: lifecycleRequestId,
+            sessionId,
+            toolName,
+            decision: 'deny',
+            decisionSource: 'policy',
+            policyCode: 'permission_mode_denied',
+            reason: auditSummary,
+            permissionMode: context.permissionMode,
+            agentAid: context.selfAid,
+            agentName: context.agentName,
+            role: context.role,
+            taskId: context.taskId,
+            summary: auditSummary,
+            response: 'deny',
+        });
+        auditPermissionLifecycle({
+            phase: 'final',
+            requestId: lifecycleRequestId,
+            sessionId,
+            toolName,
+            decision: 'deny',
+            decisionSource: 'policy',
+            policyCode: 'permission_mode_denied',
+            reason: auditSummary,
+            permissionMode: context.permissionMode,
+            agentAid: context.selfAid,
+            agentName: context.agentName,
+            role: context.role,
+            taskId: context.taskId,
+            summary: auditSummary,
+            response: 'deny',
+        });
         try {
             await context.recordExecutionAnomaly?.({
                 code: 'runtime_permission_denied',

package/dist/agents/runner-types.js

@@ -63,7 +63,7 @@ export function usageForContext(usage) {
     return lastIteration ?? usage;
 }
 /** Models whose base ID uses a 1M context window when sent to the SDK with [1m]. */
-export const ONE_M_CONTEXT_MODEL_PREFIXES = ['claude-opus-4-8', 'claude-sonnet-4-6'];
+export const ONE_M_CONTEXT_MODEL_PREFIXES = ['claude-opus-5', 'claude-opus-4-8', 'claude-sonnet-4-6'];
 const ONE_M_CONTEXT_MODEL_ALIASES = ['opus', 'sonnet'];
 const CLAUDE_CONTEXT_MODEL_ALIASES = ['opus', 'sonnet', 'haiku'];
 export function isClaudeContextUsageModel(model) {

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

@@ -29,8 +29,9 @@ function parseAid(value) {
     return { ok: true, aid };
 }
 /**
- * The daemon accepts only the self-scoped AID commands exposed to managed
- * tasks. Parsing here is deliberately narrower than the standalone CLI.
+ * The daemon accepts only the narrowly scoped AID commands exposed to managed
+ * tasks. Public lookup/get may name any valid AID; local show/publish remain
+ * subject to the self-AID boundary enforced by the command handler.
  */
 export function resolveManagedAidOperation(argv) {
     const args = argv[0] === 'aid' ? argv.slice(1) : argv;
@@ -67,7 +68,21 @@ export function resolveManagedAidOperation(argv) {
     return {
         ok: false,
         code: 'NOT_ALLOWED',
-        reason: 'Managed AID operations only allow exact self-scoped show, lookup, agentmd get, or agentmd put commands with an optional --format json suffix',
+        reason: 'Managed AID operations only allow exact show, lookup, agentmd get, or agentmd put commands with an optional --format json suffix',
+    };
+}
+export function managedAidShowViewForRole(role) {
+    return role === 'owner' || role === 'admin' ? 'full' : 'redacted';
+}
+export function redactAidShowResult(value) {
+    return {
+        aid: value.aid,
+        redacted: true,
+        hasAgentMd: value.hasAgentMd,
+        certExpiresAt: value.certExpiresAt,
+        certSubject: value.certSubject,
+        certExpired: value.certExpired,
+        agentMdSignature: value.agentMdSignature,
     };
 }
 const defaultDependencies = () => ({
@@ -80,12 +95,19 @@ const defaultDependencies = () => ({
     readFileSync: fs.readFileSync,
 });
 /** Execute a validated AID operation from the daemon-owned host filesystem. */
-export async function executeManagedAidOperation(command, overrides = {}) {
+export async function executeManagedAidOperation(command, options = {}) {
+    const { showView = 'full', ...overrides } = options;
     const deps = { ...defaultDependencies(), ...overrides };
     const aunPath = deps.root;
     switch (command.kind) {
-        case 'show':
-            return { kind: command.kind, aid: command.aid, value: await deps.aidShow(command.aid, { aunPath }) };
+        case 'show': {
+            const value = await deps.aidShow(command.aid, { aunPath });
+            return {
+                kind: command.kind,
+                aid: command.aid,
+                value: showView === 'redacted' ? redactAidShowResult(value) : value,
+            };
+        }
         case 'lookup':
             return { kind: command.kind, aid: command.aid, value: await deps.aidLookup(command.aid) };
         case 'agentmd.get':

package/dist/aun/aid/store.js

@@ -7,6 +7,7 @@ import { AUN_KEYSTORE_ENCRYPTION_SEED } from './encryption-seed-policy.js';
 // pages so a large backlog is drained without monopolizing the sync loop.
 const FULL_GROUP_PULL_MAX_PAGES = 10;
 const GROUP_PULL_PAGINATION_PATCH = Symbol('evolcore.groupPullPaginationPatch');
+const RELIABLE_MESSAGE_DELIVERY_PATCH = Symbol('evolcore.reliableMessageDeliveryPatch');
 /**
  * Slot 命名约定（基于 fastaun 0.4.3 隔离键语义）。
  *
@@ -24,6 +25,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 +34,7 @@ export const SLOT = {
     daemon: 'evolcore daemon',
     cli: 'evolcore-cli',
     groupRules: 'evolcore-group-rules',
+    menuClient: 'evolcore-menu-client',
     bench: 'evolcore-bench',
     netcheck: 'evolcore-netcheck',
 };
@@ -104,6 +107,46 @@ export function enableFullGroupPullPagination(client) {
     target._pullGroupV2 = wrappedPull;
     return true;
 }
+/**
+ * Make SDK pull delivery wait until EvolCore's application handlers finish.
+ *
+ * fastaun 0.5.13 publishes message events with dispatcher.enqueue(), then
+ * advances its sequence tracker immediately.  That is a transport watermark,
+ * so a daemon restart can acknowledge a message before the application has
+ * durably claimed it.  The SDK keeps _publishAppEvent private, but the public
+ * client is intentionally adapted here in one place: preserve the SDK's
+ * normal publication path and wait for its dispatcher queue for pulled
+ * message events before the pull operation commits the sequence.
+ */
+export function enableReliableMessageDelivery(client) {
+    const target = client;
+    if (target[RELIABLE_MESSAGE_DELIVERY_PATCH])
+        return false;
+    const publish = target._publishAppEvent;
+    const dispatcher = target._dispatcher;
+    if (typeof publish !== 'function' || !dispatcher || typeof dispatcher.flush !== 'function')
+        return false;
+    const wrappedPublish = async function (event, payload, source, ...rest) {
+        const result = await publish.call(this, event, payload, source, ...rest);
+        // Pull/recovery paths must not advance SeqTracker until the application
+        // handlers have completed. Push delivery has no pull commit to gate and
+        // remains asynchronous as intended by the SDK.
+        const reliable = (event === 'message.received' || event === 'group.message_created')
+            && source !== 'push'
+            && source !== 'inline-push';
+        if (reliable)
+            await dispatcher.flush();
+        return result;
+    };
+    Object.defineProperty(target, RELIABLE_MESSAGE_DELIVERY_PATCH, {
+        configurable: false,
+        enumerable: false,
+        value: true,
+        writable: false,
+    });
+    target._publishAppEvent = wrappedPublish;
+    return true;
+}
 /** 加载本地 AID 值对象（用于离线签名/验签，无需连接）。load 失败抛 AidLoadError。 */
 export function loadAid(store, aid) {
     const r = store.load(aid);

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();
+    }
+}