evolcore 0.0.21 → 0.0.22

package/dist/config/contact-book-store.js

@@ -14,6 +14,7 @@ const LOCK_NAME = '.contact-book-mutation.lock';
 const JOURNAL_NAME = '.contact-book-mutation.json';
 const LOCK_WAIT_MS = 5_000;
 const LOCK_RETRY_MS = 20;
+const CORRUPT_LOCK_STALE_MS = LOCK_WAIT_MS;
 export const EMPTY_CONTACT_REVISION = crypto.createHash('sha256').update('').digest('hex');
 export class ContactMutationError extends Error {
     code;
@@ -454,7 +455,10 @@ function acquireAgentLock(selfAid) {
                 return () => releaseAgentLock(lockDir, ownerFile, lockToken);
             }
             catch (error) {
-                if (error?.code !== 'EEXIST' && error?.code !== 'ENOTEMPTY')
+                const lockMayAlreadyExist = error?.code === 'EEXIST'
+                    || error?.code === 'ENOTEMPTY'
+                    || (process.platform === 'win32' && error?.code === 'EPERM' && fs.existsSync(lockDir));
+                if (!lockMayAlreadyExist)
                     throw error;
                 if (removeStaleLock(lockDir, ownerFile))
                     continue;
@@ -478,10 +482,10 @@ function removeStaleLock(lockDir, ownerFile) {
         pid = Number(JSON.parse(rawOwner).pid);
     }
     catch {
-        return false;
+        return reclaimCorruptLock(lockDir);
     }
     if (!Number.isInteger(pid) || pid <= 0)
-        return false;
+        return reclaimCorruptLock(lockDir);
     try {
         process.kill(pid, 0);
         return false;
@@ -503,6 +507,24 @@ function removeStaleLock(lockDir, ownerFile) {
         }
     }
 }
+function reclaimCorruptLock(lockDir) {
+    try {
+        const stat = fs.statSync(lockDir);
+        if (Date.now() - stat.mtimeMs < CORRUPT_LOCK_STALE_MS)
+            return false;
+        const staleClaim = `${lockDir}.reclaimed-corrupt-${crypto.randomBytes(8).toString('hex')}`;
+        fs.renameSync(lockDir, staleClaim);
+        fs.rmSync(staleClaim, { recursive: true, force: true });
+        return true;
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT')
+            return true;
+        if (error?.code === 'EEXIST' || error?.code === 'ENOTEMPTY' || error?.code === 'EPERM')
+            return false;
+        throw error;
+    }
+}
 function releaseAgentLock(lockDir, ownerFile, lockToken) {
     try {
         const owner = JSON.parse(fs.readFileSync(ownerFile, 'utf8'));

package/dist/core/auth/agent-delegation.js

@@ -4,9 +4,13 @@ import { formatPeerKey, parsePeerKey } from '../relation/peer-identity.js';
 export const AGENT_DELEGATION_TOKEN_ENV = 'EVOLCORE_DELEGATION_TOKEN';
 export const AGENT_DELEGATION_COMMAND_TTL_MS = 5 * 60_000;
 export class AgentDelegationRegistry {
+    runtimeEpoch = crypto.randomBytes(16).toString('hex');
     grantsByHash = new Map();
     activeHashBySession = new Map();
     approvedCommands = new Map();
+    getRuntimeEpoch() {
+        return this.runtimeEpoch;
+    }
     issue(input) {
         if (input.executionIdentity && !isValidFullAccessExecutionIdentity(input.executionIdentity)) {
             throw new Error('invalid fullaccess task execution identity');
@@ -24,6 +28,7 @@ export class AgentDelegationRegistry {
                 ok: false,
                 code: 'DELEGATION_REQUIRED',
                 reason: 'An active task delegation token is required',
+                diagnosticCause: 'missing_token',
             };
         }
         const tokenHash = hashDelegationToken(token);
@@ -42,6 +47,13 @@ export class AgentDelegationRegistry {
             ok: false,
             code: 'INVALID_DELEGATION',
             reason: 'The task delegation token is invalid, revoked, or belongs to another session',
+            diagnosticCause: grant
+                ? grant.sessionId !== sessionId
+                    ? 'session_mismatch'
+                    : 'task_replaced'
+                : commandHash
+                    ? 'approved_command_unavailable'
+                    : 'unknown_token',
         };
     }
     armApprovedCommand(input) {

package/dist/core/auth/auth-gateway.js

@@ -192,6 +192,14 @@ function auditDecision(params, decision) {
         permissionMode: params.auditMetadata?.permissionMode
             ?? (decision.allow ? decision.permissionMode ?? params.subject.permissionMode : params.subject.permissionMode),
         toolName: params.auditMetadata?.toolName,
+        errorCode: params.auditMetadata?.errorCode
+            ?? (decision.allow
+                ? undefined
+                : params.auditMetadata?.decisionSource === 'approval'
+                    ? 'USER_DENIED'
+                    : params.auditMetadata?.decisionSource === 'infrastructure'
+                        ? 'EXECUTION_FAILED'
+                        : 'POLICY_DENIED'),
         policyCode: params.auditMetadata?.policyCode ?? (decision.allow ? undefined : decision.code),
         decisionSource: params.auditMetadata?.decisionSource ?? (decision.allow ? 'command' : 'policy'),
         source: params.source,

package/dist/core/auth/authorization-audit.js

@@ -2,7 +2,7 @@ import { logger } from '../../utils/logger.js';
 import { LogWriter } from '../../utils/log-writer.js';
 import { resolvePaths } from '../../paths.js';
 import crypto from 'node:crypto';
-import { buildAuthorizationEventKey } from '../audit/event-key.js';
+import { buildAuthorizationEventKey, buildToolLifecycleEventKey } from '../audit/event-key.js';
 import { normalizeExecutionPermissionMode } from '../permission/mode.js';
 export function auditCommandAuthorization(event) {
     const shouldAudit = event.source === 'menu.cli' ||
@@ -95,10 +95,20 @@ export function auditFullAccessEvent(input) {
  * denials otherwise only reach `logger.warn` and `TriggerExecutionAnomaly`.
  */
 export function auditToolPreflightDenial(input) {
+    const lifecycleId = input.callId ?? input.correlationId ?? input.requestId;
     auditCommandAuthorization({
         ts: Date.now(),
-        callId: input.requestId,
-        correlationId: input.requestId,
+        ...(lifecycleId ? {
+            eventKey: buildToolLifecycleEventKey({
+                sessionId: input.sessionId,
+                callId: input.callId,
+                correlationId: input.correlationId,
+                requestId: input.requestId,
+            }),
+            eventPhase: 'preflight',
+        } : {}),
+        callId: input.callId ?? input.requestId,
+        correlationId: input.correlationId ?? input.callId ?? input.requestId,
         source: 'agent-tool',
         operation: 'tool.preflight.deny',
         scope: 'filesystem',
@@ -107,6 +117,7 @@ export function auditToolPreflightDenial(input) {
         executed: false,
         executionState: 'blocked',
         decisionSource: 'policy',
+        errorCode: 'POLICY_DENIED',
         toolName: input.toolName,
         policyCode: input.policyCode,
         protectionClass: input.protectionClass ?? protectionClassForPolicy(input.policyCode),
@@ -135,9 +146,19 @@ export function auditToolPreflightDenial(input) {
  * decision source make policy, user, and infrastructure denials distinct.
  */
 export function auditCodexApprovalDecision(input) {
+    const lifecycleId = input.callId ?? input.correlationId ?? input.requestId;
     auditCommandAuthorization({
         ts: Date.now(),
-        callId: input.correlationId ?? input.requestId,
+        ...(lifecycleId ? {
+            eventKey: buildToolLifecycleEventKey({
+                sessionId: input.sessionId,
+                callId: input.callId,
+                correlationId: input.correlationId,
+                requestId: input.requestId,
+            }),
+            eventPhase: 'approval',
+        } : {}),
+        callId: input.callId ?? input.correlationId ?? input.requestId,
         source: 'agent-tool',
         operation: 'codex.approval',
         scope: input.toolName === 'PermissionGrant' ? 'agent' : 'filesystem',
@@ -146,8 +167,11 @@ export function auditCodexApprovalDecision(input) {
         executed: false,
         executionState: input.decision === 'allow' ? 'authorized' : 'blocked',
         decisionSource: input.decisionSource,
+        errorCode: input.decision === 'deny'
+            ? input.decisionSource === 'approval' ? 'USER_DENIED' : input.decisionSource === 'policy' ? 'POLICY_DENIED' : infrastructureErrorCode(input.policyCode)
+            : undefined,
         requestId: input.requestId,
-        correlationId: input.correlationId ?? input.requestId,
+        correlationId: input.correlationId ?? input.callId ?? input.requestId,
         sessionId: input.sessionId ?? 'unknown',
         agentAid: input.agentAid ?? 'unknown',
         agentName: input.agentName,
@@ -183,6 +207,11 @@ export function auditPermissionDecision(input) {
         toolName: input.toolName,
         policyCode: input.policyCode,
         decisionSource: input.decisionSource,
+        errorCode: input.decisionSource === 'approval'
+            ? 'USER_DENIED'
+            : input.decisionSource === 'policy'
+                ? 'POLICY_DENIED'
+                : infrastructureErrorCode(input.policyCode),
         source: 'agent-tool',
         operation: 'permission.runtime',
         scope: 'filesystem',
@@ -205,6 +234,7 @@ export function auditToolInfrastructureFailure(input) {
         dangerous: false,
         decision: 'deny',
         decisionSource: 'infrastructure',
+        errorCode: infrastructureErrorCode(input.policyCode),
         executed: false,
         executionState: 'blocked',
         callId: input.callId,
@@ -224,8 +254,26 @@ export function auditToolInfrastructureFailure(input) {
             : undefined,
     });
 }
+function infrastructureErrorCode(policyCode) {
+    const code = String(policyCode ?? '').toLowerCase();
+    if (/delegat|carrier|not.?armed/.test(code))
+        return 'DELEGATION_FAILED';
+    if (/capability|sandbox|unavailable|workspace_unknown/.test(code))
+        return 'CAPABILITY_UNAVAILABLE';
+    if (/argument|canonical|quote|shell|parse|invalid/.test(code))
+        return 'INVALID_ARGUMENT';
+    return 'EXECUTION_FAILED';
+}
 function buildAuditRecord(event) {
     const executed = event.executed ?? false;
+    const decisionSource = event.decisionSource ?? (event.decision === 'deny' ? 'policy' : 'command');
+    const errorCode = event.errorCode ?? (event.decision === 'deny'
+        ? decisionSource === 'approval'
+            ? 'USER_DENIED'
+            : decisionSource === 'policy'
+                ? 'POLICY_DENIED'
+                : 'EXECUTION_FAILED'
+        : undefined);
     const executionState = event.executionState
         ?? (event.decision === 'deny'
             ? 'blocked'
@@ -244,6 +292,7 @@ function buildAuditRecord(event) {
                 operation: event.operation,
             })
             : undefined),
+        eventPhase: event.eventPhase,
         callId: event.callId,
         correlationId: event.correlationId ?? event.requestId,
         requestId: event.requestId,
@@ -253,10 +302,15 @@ function buildAuditRecord(event) {
         permissionMode: normalizeAuditPermissionMode(event.permissionMode),
         toolName: event.toolName,
         approvalMethod: event.approvalMethod,
+        errorCode,
         policyCode: event.policyCode ?? event.code,
         protectionClass: event.protectionClass,
         matchedPath: event.matchedPath,
-        decisionSource: event.decisionSource,
+        decisionSource,
+        ecwebRequestId: event.ecwebRequestId,
+        targetAgentAid: redactIdentifier(event.targetAgentAid),
+        endpoint: event.endpoint,
+        logicalToolName: event.logicalToolName,
         source: event.source,
         operation: event.operation,
         scope: event.scope,
@@ -343,11 +397,17 @@ function logAuditEvent(record) {
         record.callId ? `call=${record.callId}` : null,
         record.correlationId ? `correlation=${record.correlationId}` : null,
         record.eventKey ? `eventKey=${record.eventKey}` : null,
+        record.eventPhase ? `eventPhase=${record.eventPhase}` : null,
         record.sessionId ? `session=${record.sessionId}` : null,
         record.agentName ? `agentName=${JSON.stringify(record.agentName)}` : null,
         record.agentAid ? `agent=${record.agentAid}` : null,
         record.permissionMode ? `permissionMode=${record.permissionMode}` : null,
         record.toolName ? `tool=${record.toolName}` : null,
+        record.errorCode ? `errorCode=${record.errorCode}` : null,
+        record.ecwebRequestId ? `ecwebRequest=${record.ecwebRequestId}` : null,
+        record.targetAgentAid ? `targetAgent=${record.targetAgentAid}` : null,
+        record.endpoint ? `endpoint=${JSON.stringify(record.endpoint)}` : null,
+        record.logicalToolName ? `logicalTool=${record.logicalToolName}` : null,
         record.policyCode ? `policy=${record.policyCode}` : null,
         record.protectionClass ? `protectionClass=${record.protectionClass}` : null,
         record.matchedPath ? `matchedPath=${JSON.stringify(record.matchedPath)}` : null,

package/dist/core/bootstrap-messages.js

@@ -7,9 +7,17 @@ import { chatDirPath } from './session/session-fs-store.js';
 import { hasMessageLogOperation } from './message/message-log.js';
 import { isDeliveryTarget, sameDeliveryTarget } from './message/message-utils.js';
 export const BOOTSTRAP_MESSAGE_TTL_MS = 30 * 24 * 60 * 60 * 1000;
+export const BOOTSTRAP_NOTIFICATION_WINDOW_MS = 24 * 60 * 60 * 1000;
 export function bootstrapInitialMessageOperationId(aid) {
     return `bootstrap-initial:v1:${aid}`;
 }
+export function bootstrapInitialMessageOperationPrefix(aid) {
+    return `bootstrap-initial:v1:${aid}`;
+}
+/** A new operation ID is required after the notification window expires. */
+export function bootstrapInitialRetryOperationId(aid, at = Date.now()) {
+    return `${bootstrapInitialMessageOperationPrefix(aid)}:${at}`;
+}
 export function postBootstrapWelcomeOperationId(aid) {
     return `bootstrap-complete:v1:${aid}`;
 }

package/dist/core/bootstrap-service.js

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import { randomBytes } from 'crypto';
-import { kitsTemplatesDir, agentMdPath } from '../paths.js';
+import { kitsTemplatesDir, agentMdPath, resolvePaths } from '../paths.js';
 import { buildInitialAgentMd, resolveAgentDisplayName } from '../aun/aid/agentmd.js';
 import { logger } from '../utils/logger.js';
 import { loadAgent, saveAgent } from '../config-store.js';
@@ -9,7 +9,10 @@ import { resolveAgentLifecycle, withLifecycleForWrite } from '../config/lifecycl
 import { renderTemplate } from '../eck/manifest-engine.js';
 import { activeBaseagent } from './model/config-scope.js';
 import { buildEnvelope } from './message/message-utils.js';
-import { BOOTSTRAP_MESSAGE_TTL_MS, bootstrapInitialMessageOperationId } from './bootstrap-messages.js';
+import { BOOTSTRAP_MESSAGE_TTL_MS, BOOTSTRAP_NOTIFICATION_WINDOW_MS, bootstrapInitialMessageOperationId, bootstrapInitialMessageOperationPrefix, bootstrapInitialRetryOperationId, } from './bootstrap-messages.js';
+import { findLatestMessageLogOperation } from './message/message-log.js';
+import * as outbox from '../aun/outbox.js';
+import { chatDirPath } from './session/session-fs-store.js';
 /** Coordinate the write-ahead completion welcome with the lifecycle commit. */
 export async function completeBootstrapWithWelcome(service, aid, welcome, sessions) {
     const lifecycle = service.lifecycleOf(aid);
@@ -102,6 +105,7 @@ export class BootstrapService {
     agentRegistry;
     eventBus;
     inFlight = new Set();
+    notifiedInProcess = new Map();
     constructor(agentRegistry, eventBus) {
         this.agentRegistry = agentRegistry;
         this.eventBus = eventBus;
@@ -161,41 +165,58 @@ export class BootstrapService {
         try {
             const agentName = this.resolveAgentDisplayName(aid);
             const baseagent = this.resolveBaseagent(agent, aid);
+            const notificationState = this.bootstrapNotificationState({
+                aid,
+                channelType,
+                channelId,
+                channelKey: ctx.channelKey,
+            });
+            const operationId = starting && !notificationState.hasCompletedHistory
+                ? bootstrapInitialMessageOperationId(aid)
+                : bootstrapInitialRetryOperationId(aid);
+            const shouldSend = !notificationState.recentlyNotified;
             if (starting) {
                 await this.publishAgentMdIfSupported(ctx.adapter, aid, agentName);
                 this.setLifecycle(agent, aid, 'bootstrapping');
                 lifecycleStarted = true;
             }
-            const text = this.renderWelcome({
-                agentAid: aid,
-                agentName,
-                ownerName: ctx.recipientName || recipientId,
-                channel: channelType || ctx.channelKey,
-                baseagent,
-            });
-            await ctx.adapter.send(buildEnvelope({
-                taskId: `bootstrap-${randomBytes(5).toString('hex')}`,
-                channel: ctx.adapter.channelKey || ctx.adapter.channelName,
-                channelId,
-                agentName: aid,
-                replyContext: {
-                    delivery,
-                    metadata: {
-                        source: 'daemon',
-                        persistRequired: true,
-                        operationId: bootstrapInitialMessageOperationId(aid),
-                        outboxTtl: BOOTSTRAP_MESSAGE_TTL_MS,
-                        criticalDelivery: true,
+            if (shouldSend) {
+                const text = this.renderWelcome({
+                    agentAid: aid,
+                    agentName,
+                    ownerName: ctx.recipientName || recipientId,
+                    channel: channelType || ctx.channelKey,
+                    baseagent,
+                });
+                await ctx.adapter.send(buildEnvelope({
+                    taskId: `bootstrap-${randomBytes(5).toString('hex')}`,
+                    operationId,
+                    channel: ctx.adapter.channelKey || ctx.adapter.channelName,
+                    channelId,
+                    agentName: aid,
+                    replyContext: {
+                        delivery,
+                        metadata: {
+                            source: 'daemon',
+                            persistRequired: true,
+                            operationId,
+                            outboxTtl: BOOTSTRAP_MESSAGE_TTL_MS,
+                            criticalDelivery: true,
+                        },
                     },
-                },
-            }), { kind: 'result.text', text, isFinal: true });
+                }), { kind: 'result.text', text, isFinal: true });
+                this.notifiedInProcess.set(aid, Date.now());
+            }
             if (starting) {
                 this.eventBus.publish({ type: 'agent:bootstrap-started', aid, channel: channelType || ctx.channelKey, timestamp: Date.now() });
                 logger.info(`[Bootstrap] Started for ${aid} via ${ctx.channelKey} (${ctx.source})`);
             }
-            else {
+            else if (shouldSend) {
                 logger.info(`[Bootstrap] Reconciled initial message for ${aid} via ${ctx.channelKey} (${ctx.source})`);
             }
+            else {
+                logger.debug(`[Bootstrap] Initial message already sent within the notification window for ${aid}`);
+            }
             return true;
         }
         catch (e) {
@@ -288,6 +309,53 @@ export class BootstrapService {
             return 'unknown';
         }
     }
+    bootstrapNotificationState(input) {
+        const prefix = bootstrapInitialMessageOperationPrefix(input.aid);
+        const now = Date.now();
+        const cutoff = now - BOOTSTRAP_NOTIFICATION_WINDOW_MS;
+        let latestTs = this.notifiedInProcess.get(input.aid) ?? 0;
+        let latestLoggedOperationId;
+        try {
+            const chatDir = chatDirPath(resolvePaths().sessionsDir, input.channelType || 'aun', input.channelId, input.aid, input.channelKey);
+            let latestLogged = findLatestMessageLogOperation(chatDir, prefix);
+            // Releases before the stable envelope operation ID fix persisted the
+            // random bootstrap task ID instead. Recognize that exact legacy shape
+            // so an upgrade/restart does not immediately resend the welcome.
+            if (!latestLogged) {
+                const legacyLogged = findLatestMessageLogOperation(chatDir, 'bootstrap-');
+                if (legacyLogged && /^bootstrap-[a-f0-9]{10}$/u.test(legacyLogged.operationId)) {
+                    latestLogged = legacyLogged;
+                }
+            }
+            if (latestLogged) {
+                latestTs = Math.max(latestTs, latestLogged.ts);
+                latestLoggedOperationId = latestLogged.operationId;
+            }
+        }
+        catch {
+            // A missing or malformed session path must not prevent bootstrap.
+        }
+        for (const entry of outbox.findByDedupePrefix(input.aid, prefix, { includeTerminal: true })) {
+            // A completed operation no longer needs its queued duplicate. Entries
+            // older than the notification window must not be delivered alongside
+            // the newly generated reminder operation.
+            if (entry.terminal) {
+                outbox.remove(input.aid, entry.id);
+                continue;
+            }
+            if (entry.dedupeKey === latestLoggedOperationId || entry.ts < cutoff) {
+                outbox.remove(input.aid, entry.id);
+                continue;
+            }
+            latestTs = Math.max(latestTs, entry.ts || 0);
+        }
+        const recentlyNotified = latestTs >= cutoff;
+        if (recentlyNotified)
+            this.notifiedInProcess.set(input.aid, latestTs);
+        else
+            this.notifiedInProcess.delete(input.aid);
+        return { recentlyNotified, hasCompletedHistory: !!latestLoggedOperationId };
+    }
     async publishAgentMdIfSupported(adapter, aid, fallbackName) {
         if (typeof adapter.uploadAgentMd !== 'function')
             return;

package/dist/core/command/command-handler.js

@@ -1119,6 +1119,27 @@ export class CommandHandler {
     async handle(content, channel, channelId, sendMessage, userId, threadId, chatType, source, messageId, selfAID, overrideIdentity, authSubject, replyContext) {
         try {
             const result = await this._handleInternal(content, channel, channelId, sendMessage, userId, threadId, chatType, source, messageId, selfAID, overrideIdentity, authSubject, replyContext);
+            // Lifecycle commands are control-plane operations. Their replies must
+            // use notification payloads so other agents in a group do not treat the
+            // text as ordinary model input. Normalize guard-path replies here too,
+            // since those return before slash-handler command-specific branches.
+            if (/^\/(?:new|renew)(?:\s|$)/i.test(content.trim())
+                && result && typeof result === 'object'
+                && (result.kind === 'command.result' || result.kind === 'command.error')) {
+                const isError = result.kind === 'command.error';
+                return isError
+                    ? {
+                        kind: 'system.error',
+                        text: result.text,
+                        subtype: `session.${content.trim().toLowerCase().startsWith('/new') ? 'new' : 'renew'}.error`,
+                        recoverable: true,
+                    }
+                    : {
+                        kind: 'system.notice',
+                        text: result.text,
+                        subtype: `session.${content.trim().toLowerCase().startsWith('/new') ? 'new' : 'renew'}.result`,
+                    };
+            }
             return result;
         }
         catch (error) {

package/dist/core/command/menu-handler.js

@@ -6,6 +6,7 @@ import { hasModelSwitcher } from '../../agents/runner-types.js';
 import { getCodexEfforts } from '../../agents/codex-runner.js';
 import { execCodexCliSync, resolveCodexCliPath } from '../../utils/codex-cli.js';
 import { resolvePaths, getPackageRoot, daemonControlDir } from '../../paths.js';
+import { inspectDataMigrationRequirement } from '../data-migration.js';
 import { buildEnvelope, isDeliveryTarget, isDeliveryTargetForChannel, replyContextFromSession } from '../message/message-utils.js';
 import path from 'path';
 import fs from 'fs';
@@ -3563,6 +3564,14 @@ export async function execMenuAction(cmd, action, args, channel, channelId, user
                         : 'AUN_OUTBOUND_ROUTE_REQUIRED',
                 };
             }
+            const migrationRequirement = inspectDataMigrationRequirement(resolvePaths().root);
+            if (migrationRequirement.required) {
+                return {
+                    error: `待处理的用户数据迁移（${migrationRequirement.operationCount} 项）阻止重启。请先运行 ec data migrate --dry-run，然后运行 ec data migrate --apply。`,
+                    code: 'DATA_MIGRATION_REQUIRED',
+                    data: { reasonCode: 'DATA_MIGRATION_REQUIRED', operationCount: migrationRequirement.operationCount },
+                };
+            }
             if (!suppressRealRestart) {
                 const restartInfo = {
                     channel,

package/dist/core/command/menu-protocol.js

@@ -272,7 +272,7 @@ const STABLE_CODES = new Set([
     'TEMPORARILY_UNAVAILABLE', 'INTERNAL_ERROR', 'MISSING_SCOPE', 'UPGRADE_REQUIRED',
     'MENU_TOKEN_REQUIRED', 'MENU_TOKEN_REJECTED', 'MENU_TOKEN_ENCRYPTION_REQUIRED',
     'INVALID_CONTEXT', 'SCHEMA_VERSION_UNSUPPORTED', 'DEPENDENCY_UNAVAILABLE',
-    'RATE_LIMITED', 'CATALOG_STALE',
+    'RATE_LIMITED', 'CATALOG_STALE', 'DATA_MIGRATION_REQUIRED',
 ]);
 export function normalizeMenuError(error) {
     const source = error && typeof error === 'object' ? error : {};