evolcore 0.0.20 → 0.0.22

package/dist/agents/gemini-runner.js

@@ -14,13 +14,15 @@ import fs from 'fs';
 import path from 'path';
 import os from 'os';
 import crypto from 'crypto';
+import { hasTrustedFullAccessContext } from './runner-types.js';
 import { resolveGoogleConfig } from './baseagent.js';
 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 { normalizePermissionMode } from '../core/permission/mode.js';
-import { workspaceContainsHClassPaths } from '../core/protected-paths.js';
+import { normalizeExecutionPermissionMode, normalizePermissionMode } from '../core/permission/mode.js';
+import { workspaceContainsHClassPaths } from '../core/permission/protected-paths.js';
 import { buildBubblewrapCommand } from '../core/permission/sandbox-runtime.js';
+import { getManagedTaskTempDir } from '../cli/task-context.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.
@@ -142,6 +144,8 @@ const GEMINI_EC_COMMAND_PATTERNS = [
     String.raw `\x00"command":"[ ]*ec[ ]+(?:[^"\x00;&|$()<>\x60\r\n\\]|\\(?:\\|"))*"\x00`,
 ];
 export function resolveGeminiPermissionProfile(value, bootstrap = false) {
+    if (value === 'fullaccess')
+        return { mode: 'fullaccess', approvalMode: 'yolo' };
     const normalized = normalizePermissionMode(value);
     const profile = normalized.mode === 'auto'
         ? { mode: 'auto', approvalMode: 'auto_edit' }
@@ -238,6 +242,12 @@ export function buildGeminiAdminPolicy(profile, bootstrapAgentMdPath) {
     return lines.join('\n');
 }
 export function buildGeminiPermissionArgs(profile, policyPath, externallySandboxed = false) {
+    if (profile.mode === 'fullaccess') {
+        // Absence of --sandbox is not enough: ~/.gemini/settings.json may enable
+        // it again. An explicit CLI false keeps this per-call host profile
+        // authoritative over user/project settings.
+        return ['--sandbox=false', `--approval-mode=${profile.approvalMode}`];
+    }
     return [
         '--admin-policy', policyPath,
         ...(!externallySandboxed ? ['--sandbox'] : []),
@@ -269,7 +279,7 @@ export function hasStandardGeminiAdminPolicy() {
 // ── Gemini Runner ──
 export class GeminiRunner {
     name = 'gemini';
-    capabilities = { clear: true, compact: false, fork: false, forkAtTurn: false, askUserQuestion: false, planApproval: false, fileRewind: 'unsupported' };
+    capabilities = { fullaccess: true, clear: true, compact: false, fork: false, forkAtTurn: false, askUserQuestion: false, planApproval: false, fileRewind: 'unsupported' };
     resolved;
     model;
     activeProcesses = new Map();
@@ -329,22 +339,39 @@ export class GeminiRunner {
     }
     // ── Core: runQuery ──
     async runQuery(sessionId, prompt, projectPath, initialAgentSessionId, images, systemPromptAppend, sessionManager, modelOverride, runtimeEnv) {
-        let geminiSessionId = initialAgentSessionId || this.activeSessions.get(sessionId);
+        const topicBinding = modelOverride?.backend?.kind === 'topic';
+        if (topicBinding && (!modelOverride?.turn || modelOverride.turn.sessionId !== sessionId || !this.onSessionIdUpdate)) {
+            const error = new Error('topic backend run requires an active TurnLease and binding callback');
+            error.code = 'TOPIC_TURN_LEASE_REQUIRED';
+            throw error;
+        }
+        const topicAgentSessionId = topicBinding ? modelOverride?.backend?.agentSessionId ?? null : undefined;
+        const cachedSessionId = topicBinding
+            ? (topicAgentSessionId && this.activeSessions.get(sessionId) === topicAgentSessionId ? topicAgentSessionId : undefined)
+            : this.activeSessions.get(sessionId);
+        let geminiSessionId = topicBinding
+            ? (topicAgentSessionId || undefined)
+            : initialAgentSessionId || cachedSessionId;
         // per-call 权限模式/模型：优先 override，缺省回落实例级（多会话并发互不污染）
         const requestedPermissionMode = modelOverride?.permissionMode || this.currentMode;
+        const executionPermissionMode = normalizeExecutionPermissionMode(requestedPermissionMode);
+        if (executionPermissionMode === 'fullaccess' && !hasTrustedFullAccessContext(this.permissionContexts.get(sessionId))) {
+            throw new Error('Gemini fullaccess requires a trusted per-call execution authorization');
+        }
         const bootstrapAgentMdPath = modelOverride?.bootstrapAgentMdPath
             ? normalizeGeminiBootstrapAgentMdPath(modelOverride.bootstrapAgentMdPath).filePath
             : undefined;
         const permissionProfile = resolveGeminiPermissionProfile(requestedPermissionMode, !!bootstrapAgentMdPath);
         const callModel = modelOverride?.model || this.model;
-        const runtimeDir = runtimeEnv?.EVOLCORE_SESSION_RUNTIME_DIR;
+        const managedTaskTmpDir = getManagedTaskTempDir(runtimeEnv);
+        const runtimeDir = managedTaskTmpDir ?? runtimeEnv?.EVOLCORE_SESSION_RUNTIME_DIR;
         const managedTmpDir = runtimeDir ?? process.env.TMPDIR;
         if (!managedTmpDir || !path.isAbsolute(managedTmpDir))
             throw new Error('managed TMPDIR is unset or not absolute');
         const runtimeLockDir = runtimeEnv?.EVOLCORE_RUNTIME_LOCK_DIR;
         const geminiHome = path.join(os.homedir(), '.gemini');
         fs.mkdirSync(geminiHome, { recursive: true, mode: 0o700 });
-        const sandboxProbe = buildBubblewrapCommand(this.resolved.cliPath, [], {
+        const sandboxProbe = executionPermissionMode === 'fullaccess' ? undefined : buildBubblewrapCommand(this.resolved.cliPath, [], {
             projectPath,
             writablePaths: [
                 geminiHome,
@@ -353,7 +380,7 @@ export class GeminiRunner {
                 ...(bootstrapAgentMdPath ? [bootstrapAgentMdPath] : []),
             ],
         });
-        if (!sandboxProbe && workspaceContainsHClassPaths(projectPath)) {
+        if (executionPermissionMode !== 'fullaccess' && !sandboxProbe && workspaceContainsHClassPaths(projectPath)) {
             throw new Error('Gemini 缺少可用的路径级隔离运行时，且项目覆盖 EvolCore 受保护根；已拒绝启动本轮任务');
         }
         // Build CLI args
@@ -369,12 +396,20 @@ export class GeminiRunner {
         const tempFiles = [];
         {
             if (hasStandardGeminiAdminPolicy()) {
+                if (executionPermissionMode === 'fullaccess') {
+                    throw new Error('Gemini 系统级 admin policy 无法被本次调用可靠关闭；已拒绝以不完整的 fullaccess profile 启动');
+                }
                 throw new Error('Gemini 系统级 admin policy 会忽略 EvolCore 的临时安全策略，已拒绝启动本轮任务');
             }
-            const policyPath = path.join(managedTmpDir, `evolcore-gemini-permission-${crypto.randomUUID()}.toml`);
-            fs.writeFileSync(policyPath, buildGeminiAdminPolicy(permissionProfile, bootstrapAgentMdPath), { mode: 0o600, flag: 'wx' });
-            tempFiles.push(policyPath);
-            args.push(...buildGeminiPermissionArgs(permissionProfile, policyPath, !!sandboxProbe));
+            if (executionPermissionMode === 'fullaccess') {
+                args.push(...buildGeminiPermissionArgs(permissionProfile, '', false));
+            }
+            else {
+                const policyPath = path.join(managedTmpDir, `evolcore-gemini-permission-${crypto.randomUUID()}.toml`);
+                fs.writeFileSync(policyPath, buildGeminiAdminPolicy(permissionProfile, bootstrapAgentMdPath), { mode: 0o600, flag: 'wx' });
+                tempFiles.push(policyPath);
+                args.push(...buildGeminiPermissionArgs(permissionProfile, policyPath, !!sandboxProbe));
+            }
         }
         if (images?.length) {
             const tmpDir = managedTmpDir;
@@ -406,7 +441,7 @@ export class GeminiRunner {
         }
         // Spawn subprocess
         const env = this.buildAgentEnv(sessionId, runtimeEnv);
-        const sandboxedCommand = buildBubblewrapCommand(this.resolved.cliPath, args, {
+        const sandboxedCommand = executionPermissionMode === 'fullaccess' ? undefined : buildBubblewrapCommand(this.resolved.cliPath, args, {
             projectPath,
             writablePaths: [
                 geminiHome,
@@ -429,10 +464,10 @@ export class GeminiRunner {
             if (msg)
                 logger.debug(`[GeminiRunner:stderr] ${msg}`);
         });
-        return this.transformStream(child, sessionId, tempFiles);
+        return this.transformStream(child, sessionId, tempFiles, modelOverride?.turn);
     }
     // ── Event stream transformation ──
-    async *transformStream(child, sessionId, tempFiles) {
+    async *transformStream(child, sessionId, tempFiles, turn) {
         const pendingToolNames = new Map(); // toolId → toolName
         const recordedDeniedToolIds = new Set();
         const startTime = Date.now();
@@ -506,8 +541,19 @@ export class GeminiRunner {
                             // Extract session_id from init event
                             const geminiId = event.session_id;
                             if (geminiId) {
+                                const result = this.onSessionIdUpdate
+                                    ? (turn === undefined
+                                        ? await this.onSessionIdUpdate(sessionId, geminiId)
+                                        : await this.onSessionIdUpdate(sessionId, geminiId, { turn }))
+                                    : 'legacy_updated';
+                                const accepted = result === undefined || result === 'activated' || result === 'already_active' || result === 'legacy_updated';
+                                if (!accepted) {
+                                    child.kill('SIGTERM');
+                                    const error = new Error(`backend discovery rejected: ${result}`);
+                                    error.code = 'TOPIC_BACKEND_DISCOVERY_REJECTED';
+                                    throw error;
+                                }
                                 this.activeSessions.set(sessionId, geminiId);
-                                this.onSessionIdUpdate?.(sessionId, geminiId);
                                 yield { type: 'session_id', sessionId: geminiId };
                             }
                             break;
@@ -619,7 +665,9 @@ export class GeminiRunner {
         }
         finally {
             rl.close();
-            this.activeProcesses.delete(sessionId);
+            if (this.activeProcesses.get(sessionId) === child) {
+                this.activeProcesses.delete(sessionId);
+            }
             // Kill process if still running
             if (!child.killed && !processExited) {
                 child.kill('SIGTERM');
@@ -652,6 +700,12 @@ export class GeminiRunner {
                 toolName,
                 ...(requestId ? { requestId } : {}),
                 policy: context.approvalRouting?.approverPolicy ?? 'requester',
+                policyCode: 'permission_mode_denied',
+                decisionSource: 'policy',
+                agentAid: context.selfAid,
+                agentName: context.agentName,
+                sessionId,
+                permissionMode: context.permissionMode,
                 summary: `${toolName} runtime authorization denied by Gemini headless policy`,
                 effect: 'operation_skipped',
             });
@@ -679,19 +733,65 @@ export class GeminiRunner {
     }
     // ── Session commands ──
     updateSessionId(sessionId, agentSessionId) {
-        if (agentSessionId) {
-            this.activeSessions.set(sessionId, agentSessionId);
-        }
-        else {
-            this.activeSessions.delete(sessionId);
+        const previousId = this.activeSessions.get(sessionId);
+        const applyLocal = () => {
+            const currentId = this.activeSessions.get(sessionId);
+            if (currentId !== previousId && !(previousId === undefined && currentId === undefined))
+                return;
+            if (agentSessionId) {
+                this.activeSessions.set(sessionId, agentSessionId);
+            }
+            else if (this.activeSessions.get(sessionId) === previousId) {
+                this.activeSessions.delete(sessionId);
+            }
+        };
+        if (!this.onSessionIdUpdate) {
+            applyLocal();
+            return;
         }
-        this.onSessionIdUpdate?.(sessionId, agentSessionId);
+        void Promise.resolve(this.onSessionIdUpdate(sessionId, agentSessionId)).then(result => {
+            if (result === undefined || result === 'activated' || result === 'already_active' || result === 'legacy_updated' || !agentSessionId)
+                applyLocal();
+        }).catch(error => {
+            logger.warn(`[GeminiRunner] session binding callback failed: ${error instanceof Error ? error.message : String(error)}`);
+            if (!agentSessionId)
+                applyLocal();
+        });
     }
     async closeSession(sessionId) {
-        this.activeSessions.delete(sessionId);
-        this.activeStreams.delete(sessionId);
-        this.activeProcesses.delete(sessionId);
-        this.permissionContexts.delete(sessionId);
+        const capturedId = this.activeSessions.get(sessionId);
+        const capturedStream = this.activeStreams.get(sessionId);
+        const capturedPermissionContext = this.permissionContexts.get(sessionId);
+        const child = this.activeProcesses.get(sessionId);
+        if (child && child.exitCode === null && child.signalCode === null) {
+            await new Promise(resolve => {
+                let settled = false;
+                const finish = () => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    clearTimeout(killTimer);
+                    child.off('exit', finish);
+                    child.off('error', finish);
+                    resolve();
+                };
+                child.once('exit', finish);
+                child.once('error', finish);
+                child.kill('SIGTERM');
+                const killTimer = setTimeout(() => {
+                    if (child.exitCode === null && child.signalCode === null)
+                        child.kill('SIGKILL');
+                }, 3_000);
+            });
+        }
+        if (this.activeSessions.get(sessionId) === capturedId)
+            this.activeSessions.delete(sessionId);
+        if (this.activeStreams.get(sessionId) === capturedStream)
+            this.activeStreams.delete(sessionId);
+        if (!child || this.activeProcesses.get(sessionId) === child)
+            this.activeProcesses.delete(sessionId);
+        if (this.permissionContexts.get(sessionId) === capturedPermissionContext)
+            this.permissionContexts.delete(sessionId);
     }
     resolveSessionFile(agentSessionId, projectPath) {
         const adapter = new GeminiSessionFileAdapter();
@@ -702,12 +802,12 @@ export class GeminiRunner {
         this.activeSessions.delete(sessionId);
         return true;
     }
-    async compactSession(_sessionId, _agentSessionId, _projectPath) {
+    async compactSession(_sessionId, _agentSessionId, _projectPath, _modelOverride) {
         logger.info('[GeminiRunner] Compact not supported, Gemini CLI handles context internally');
-        return false;
+        return { ok: false, code: 'unsupported', message: 'Gemini CLI handles context internally', durationMs: 0 };
     }
-    async compact(_sessionId, _agentSessionId, _projectPath) {
-        return this.compactSession(_sessionId, _agentSessionId, _projectPath);
+    async compact(_sessionId, _agentSessionId, _projectPath, modelOverride) {
+        return this.compactSession(_sessionId, _agentSessionId, _projectPath, modelOverride);
     }
     setCompactStartCallback(_callback) { }
     // ── Cleanup ──

package/dist/agents/request-identity.js

@@ -53,3 +53,28 @@ export function buildModelRequestHeaders(input) {
 export function _resetRequestIdentityWarningsForTests() {
     warnedReservedHeaders.clear();
 }
+/** Preserve existing query parameters and replace configured names deterministically. */
+export function appendRequestQueryParams(url, queryParams) {
+    if (!queryParams || Object.keys(queryParams).length === 0)
+        return url;
+    const parsed = new URL(url);
+    for (const [name, value] of Object.entries(queryParams))
+        parsed.searchParams.set(name, value);
+    return parsed.toString();
+}
+/** Append an API resource to the URL pathname without corrupting an existing query string. */
+export function appendRequestPath(baseUrl, resourcePath, queryParams) {
+    const parsed = new URL(baseUrl);
+    const basePath = parsed.pathname.replace(/\/+$/u, '');
+    const resource = resourcePath.replace(/^\/+|\/+$/gu, '');
+    parsed.pathname = `${basePath}/${resource}`;
+    for (const [name, value] of Object.entries(queryParams ?? {}))
+        parsed.searchParams.set(name, value);
+    return parsed.toString();
+}
+/** Append a resource below /v1 unless the configured pathname already ends there. */
+export function appendV1RequestPath(baseUrl, resourcePath, queryParams) {
+    const pathname = new URL(baseUrl).pathname.replace(/\/+$/u, '');
+    const resource = resourcePath.replace(/^\/+|\/+$/gu, '').replace(/^v1\/+/, '');
+    return appendRequestPath(baseUrl, pathname.endsWith('/v1') ? resource : `v1/${resource}`, queryParams);
+}

package/dist/agents/runner-types.js

@@ -12,6 +12,25 @@ export class BaseagentRunnerUnavailableError extends Error {
         this.name = 'BaseagentRunnerUnavailableError';
     }
 }
+export function hasTrustedFullAccessContext(context) {
+    const authorization = context?.executionPermission;
+    if (!authorization
+        || authorization.permissionMode !== 'fullaccess'
+        || authorization.processRole !== 'fullaccess-run'
+        || authorization.dataScope !== 'daemon')
+        return false;
+    if (authorization.source === 'fullaccess-command') {
+        return typeof authorization.authorizedBy === 'string' && authorization.authorizedBy.length > 0;
+    }
+    return authorization.source === 'trigger'
+        && typeof authorization.authorizedBy === 'string' && authorization.authorizedBy.length > 0
+        && typeof authorization.triggerId === 'string' && authorization.triggerId.length > 0
+        && typeof authorization.runId === 'string' && authorization.runId.length > 0
+        // Trigger fullaccess is authorized for one scheduler attempt.  Requiring
+        // its stable attempt identity prevents a partial trigger envelope from
+        // being mistaken for a runnable privileged invocation.
+        && typeof authorization.attemptId === 'string' && authorization.attemptId.length > 0;
+}
 // ── 类型守卫 ──
 export function hasModelSwitcher(agent) {
     return typeof agent.setModel === 'function' && typeof agent.listModels === 'function';

package/dist/aun/aid/agentmd.js

@@ -1,7 +1,9 @@
 import fs from 'fs';
 import path from 'path';
+import { parseDocument } from 'yaml';
 import { getAidStore, loadAid, SLOT } from './store.js';
 import { agentMdPath, aidLocalDir, resolveRoot } from '../../paths.js';
+export const DEFAULT_AGENT_DESCRIPTION = 'EvolCore AI agent.';
 const displayNameCache = new Map();
 const displayNamePending = new Map();
 const displayNameRevision = new Map();
@@ -82,9 +84,10 @@ export function invalidateAgentDisplayName(aid) {
     displayNameRevision.set(normalizedAid, (displayNameRevision.get(normalizedAid) ?? 0) + 1);
 }
 export function buildInitialAgentMd(opts) {
-    const agentName = opts.aid.split('.')[0];
+    const agentName = opts.name?.trim() || opts.aid.split('.')[0];
     const agentType = opts.type || 'ai';
-    return `---\naid: "${opts.aid}"\nname: "${agentName}"\ntype: "${agentType}"\nversion: "1.0.0"\ndescription: ""\ntags:\n  - evolcore\n---\n`;
+    const description = opts.description?.trim() || DEFAULT_AGENT_DESCRIPTION;
+    return `---\naid: ${yamlDoubleQuote(opts.aid)}\nname: ${yamlDoubleQuote(agentName)}\ntype: ${yamlDoubleQuote(agentType)}\nversion: "1.0.0"\ndescription: ${yamlDoubleQuote(description)}\ntags:\n  - evolcore\n---\n`;
 }
 function ensureTrailingNewline(content) {
     return content.endsWith('\n') ? content : `${content}\n`;
@@ -98,6 +101,56 @@ function lineEnding(line, fallback) {
 function yamlDoubleQuote(value) {
     return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
 }
+/** Validate the gateway-facing agent.md frontmatter before signing or upload. */
+export function validateAgentMdFrontmatter(content, expectedAid) {
+    const errors = [];
+    const payload = stripAgentMdSignature(content);
+    if (Buffer.byteLength(payload, 'utf8') > 4 * 1024) {
+        errors.push('agent.md must not exceed 4KB before the signature block');
+    }
+    const frontmatter = payload.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/)?.[1];
+    if (!frontmatter)
+        return { valid: false, errors: [...errors, 'agent.md has no YAML frontmatter'] };
+    const document = parseDocument(frontmatter);
+    if (document.errors.length > 0) {
+        return {
+            valid: false,
+            errors: [...errors, ...document.errors.map(error => `invalid YAML frontmatter: ${error.message}`)],
+        };
+    }
+    const fields = document.toJS();
+    if (!fields || typeof fields !== 'object' || Array.isArray(fields)) {
+        return { valid: false, errors: [...errors, 'agent.md frontmatter must be a mapping'] };
+    }
+    const values = fields;
+    const requiredString = (key) => {
+        const value = values[key];
+        if (typeof value !== 'string' || !value.trim()) {
+            errors.push(`agent.md frontmatter ${key} must be a non-empty string`);
+            return undefined;
+        }
+        return value.trim();
+    };
+    const aid = requiredString('aid');
+    requiredString('name');
+    requiredString('type');
+    const version = requiredString('version');
+    const description = requiredString('description');
+    if (expectedAid && aid && aid !== expectedAid) {
+        errors.push(`agent.md frontmatter aid must match upload target ${expectedAid}`);
+    }
+    if (version && !/^\d+\.\d+\.\d+$/.test(version)) {
+        errors.push('agent.md frontmatter version must use major.minor.patch format');
+    }
+    if (description && description.length > 100) {
+        errors.push('agent.md frontmatter description must be at most 100 characters');
+    }
+    if (values.tags !== undefined && (!Array.isArray(values.tags)
+        || values.tags.some(tag => typeof tag !== 'string' || !tag.trim()))) {
+        errors.push('agent.md frontmatter tags must be an array of non-empty strings');
+    }
+    return { valid: errors.length === 0, errors };
+}
 /**
  * Remove the SDK-generated trailing signature block before modifying agent.md.
  * Only a block at EOF is stripped, so body text that mentions AUN-SIGNATURE is preserved.
@@ -217,6 +270,10 @@ export async function agentmdGet(aid, opts) {
  * its own LocalTokenStore + AuthFlow internally, so no AUNClient/authenticate needed.
  */
 export async function agentmdPut(content, opts) {
+    const validation = validateAgentMdFrontmatter(content, opts.aid);
+    if (!validation.valid) {
+        throw new Error(`invalid agent.md frontmatter: ${validation.errors.join('; ')}`);
+    }
     const aunPath = opts.aunPath ?? resolveRoot();
     const store = opts.store ?? await getAidStore({ slotId: SLOT.cli, aunPath });
     const ownStore = !opts.store;

package/dist/aun/aid/identity.js

@@ -111,7 +111,10 @@ export async function verifySignAbility(aid, opts) {
             const code = e instanceof AidLoadError ? e.code : 'LOAD_FAILED';
             return { ok: false, reason: `load failed: ${code} ${String(e?.message || e).slice(0, 100)}` };
         }
-        const probe = `# probe\naid: "${aid}"\n`;
+        // signAgentMd validates the same frontmatter contract as a published agent.md.
+        // Keep the probe minimal, but make it a valid document so self-checks do not
+        // reject otherwise healthy identities before exercising sign + verify.
+        const probe = `---\naid: "${aid}"\nname: "probe"\ntype: "ai"\nversion: "1.0.0"\ndescription: "Local signing self-check"\ntags:\n  - evolcore\n---\n`;
         const signRes = aidObj.signAgentMd(probe);
         if (!signRes.ok) {
             return { ok: false, reason: `sign failed: ${String(signRes.error?.message || signRes.error?.code).slice(0, 120)}` };

package/dist/aun/aid/index.js

@@ -1,4 +1,4 @@
 export { isValidAid, aidList, aidListVerified, aidCreate, aidShow, aidDelete, aidLookup, verifySignAbility, probePkiRecoverability, appendAidLifecycle, readAidLifecycle } from './identity.js';
-export { buildInitialAgentMd, agentmdGet, agentmdPut, agentmdSync, invalidateAgentDisplayName, parseAgentDisplayName, refreshAgentDisplayName, resolveAgentDisplayName, stripAgentMdSignature, updateAgentMdFrontmatterAvatar, updateAgentMdFrontmatterName, } from './agentmd.js';
+export { DEFAULT_AGENT_DESCRIPTION, buildInitialAgentMd, validateAgentMdFrontmatter, agentmdGet, agentmdPut, agentmdSync, invalidateAgentDisplayName, parseAgentDisplayName, refreshAgentDisplayName, resolveAgentDisplayName, stripAgentMdSignature, updateAgentMdFrontmatterAvatar, updateAgentMdFrontmatterName, } from './agentmd.js';
 export { MIN_AUN_CORE_SDK, AUN_CORE_SDK_PKG, isAunSdkVersionOk, resolveAunCoreSdkPkg, ensureAunSdk, isAunSdkReady, downloadCaRoot, suppressSdkLogs, } from './client.js';
 export { getAidStore, loadClient, loadAid, AidLoadError, SLOT } from './store.js';

package/dist/aun/msg/group.js

@@ -15,6 +15,21 @@ import { resolvePaths } from '../../paths.js';
 import { AGENT_DELEGATION_TOKEN_ENV } from '../../core/auth/agent-delegation.js';
 import { normalizeAunMentionEntries } from './mention-schema.js';
 import { downloadGroupFsBytes } from '../group-fs-download.js';
+/** Map a group directory probe failure to a stable Menu protocol code. */
+export function groupDirectoryErrorCode(rawCode, error) {
+    if (rawCode === -33001 || rawCode === -33005 || rawCode === -33006 || rawCode === '-33001' || rawCode === '-33005' || rawCode === '-33006')
+        return 'NOT_FOUND';
+    if (rawCode === -32004 || rawCode === 403 || rawCode === 4030 || rawCode === '-32004' || rawCode === '403' || rawCode === '4030')
+        return 'PERMISSION_DENIED';
+    if (rawCode === -32001 || rawCode === -32003 || rawCode === 4001 || rawCode === 4010 || rawCode === '-32001' || rawCode === '-32003' || rawCode === '4001' || rawCode === '4010')
+        return 'UNAUTHORIZED';
+    if (rawCode === 'TEMPORARILY_UNAVAILABLE')
+        return 'TEMPORARILY_UNAVAILABLE';
+    const message = String(error ?? '').toLowerCase();
+    if (message.includes('websocket connect') || message.includes('websocket disconnected') || message.includes('temporarily unavailable') || message.includes('gateway unavailable'))
+        return 'TEMPORARILY_UNAVAILABLE';
+    return 'TEMPORARILY_UNAVAILABLE';
+}
 function buildGroupPayload(body) {
     return body.mode === 'text' ? { type: 'text', text: body.text } : { ...body.payload };
 }
@@ -312,9 +327,35 @@ export async function groupCreate(args) {
         catch { }
     }
 }
+// Menu pages commonly ask for several fields from the same group at once. Keep
+// concurrent probes on one short connection so a burst does not create several
+// independent WebSocket handshakes for the same AID/group/slot.
+const groupInfoInflight = new Map();
 export async function groupInfo(args) {
-    const conn = await createShortConnection(args.from, { aunPath: args.aunPath, slotId: args.slotId });
+    const key = JSON.stringify([
+        args.from,
+        args.groupId,
+        args.aunPath ?? null,
+        args.slotId ?? SLOT.cli,
+        [...new Set(args.required ?? [])].sort(),
+    ]);
+    const existing = groupInfoInflight.get(key);
+    if (existing)
+        return existing;
+    const request = groupInfoUncached(args);
+    groupInfoInflight.set(key, request);
     try {
+        return await request;
+    }
+    finally {
+        if (groupInfoInflight.get(key) === request)
+            groupInfoInflight.delete(key);
+    }
+}
+async function groupInfoUncached(args) {
+    let conn;
+    try {
+        conn = await createShortConnection(args.from, { aunPath: args.aunPath, slotId: args.slotId });
         const params = { group_id: args.groupId };
         if (args.required?.length)
             params.required = args.required;
@@ -324,10 +365,17 @@ export async function groupInfo(args) {
         return { ok: true, found, ...(found ? { group: normalizeGroupInfo(raw) } : {}) };
     }
     catch (e) {
-        return formatRpcError(e);
+        return formatRpcError(e, { transientConnection: true });
     }
     finally {
-        await conn.close();
+        if (conn) {
+            try {
+                await conn.close();
+            }
+            catch {
+                // Cleanup failures must not replace the structured query result.
+            }
+        }
     }
 }
 export async function groupList(args) {
@@ -1258,11 +1306,29 @@ function normalizeGroupInfo(value) {
         name: String(value?.name ?? groupId),
     };
 }
-function formatRpcError(e) {
+function formatRpcError(e, options = {}) {
     if (e?.code !== undefined && e?.message !== undefined) {
-        return { ok: false, error: String(e.message), code: e.code };
+        return {
+            ok: false,
+            error: String(e.message),
+            code: options.transientConnection && isTransientRpcError(e) ? 'TEMPORARILY_UNAVAILABLE' : e.code,
+        };
     }
-    return { ok: false, error: String(e?.message ?? e) };
+    return {
+        ok: false,
+        error: String(e?.message ?? e),
+        ...(options.transientConnection && isTransientRpcError(e) ? { code: 'TEMPORARILY_UNAVAILABLE' } : {}),
+    };
+}
+function isTransientRpcError(error) {
+    const value = error;
+    const name = String(value?.name ?? '');
+    const message = String(value?.message ?? error ?? '').toLowerCase();
+    return name === 'ConnectionError'
+        || name === 'TimeoutError'
+        || message.includes('websocket connect timeout')
+        || message.includes('websocket connect failed')
+        || message.includes('websocket disconnected');
 }
 function normalizeRecord(value) {
     return value && typeof value === 'object' ? value : { value };