evolcore 0.0.24 → 0.0.26

package/dist/agents/codex-runner.js

@@ -1,4 +1,6 @@
 import { getRunnerCatalog, catalogEfforts, assertCatalogSelectable } from '../core/model/model-catalog.js';
+// Codex/OpenAI API 不认识 Claude Code SDK 的窗口后缀，必须传入基础模型 ID。
+import { stripContextWindowSuffix } from '../core/model/context-window-suffix.js';
 import { hasTrustedFullAccessContext } from './runner-types.js';
 import { requestDangerousCommandPermission } from '../core/permission/approval-gateway.js';
 import { checkReadonly, checkDangerousCommand, evaluateToolPreflight } from '../core/permission/tool-policy.js';
@@ -9,7 +11,7 @@ import { resolveOpenaiConfig, resolveCodexCliPath } from './baseagent.js';
 import { logger } from '../utils/logger.js';
 import { summarizeToolInputForAudit } from '../utils/tool-summary.js';
 import { auditCodexApprovalDecision, auditPermissionLifecycle, auditToolPreflightDenial } from '../core/auth/authorization-audit.js';
-import { isRetryableError } from '../utils/error-utils.js';
+import { classifyError, ErrorType, isOutputTokenLimitError, isRetryableError } from '../utils/error-utils.js';
 import { renderActionAsText } from '../core/interaction-router.js';
 import { buildEnvelope, isInteractionSendAccepted, sendInteractionPayload } from '../core/message/message-utils.js';
 import { resolveCodexCapabilityThreadConfigForProject } from '../core/capability/capability-manager.js';
@@ -36,19 +38,22 @@ const MIME_EXT = {
     'image/webp': '.webp',
 };
 const APPROVAL_LOG_SUMMARY_MAX_LENGTH = 256;
+function toAgentErrorType(message) {
+    switch (classifyError(new Error(message))) {
+        case ErrorType.CONTEXT_TOO_LONG: return 'context_too_long';
+        case ErrorType.AUTH_ERROR: return 'auth';
+        case ErrorType.API_ERROR:
+        case ErrorType.STREAM_ERROR:
+        case ErrorType.SDK_TIMEOUT: return 'network';
+        default: return 'unknown';
+    }
+}
 export function formatApprovalLogSummary(summary) {
     const singleLine = summary.replace(/\s+/gu, ' ').trim();
     if (singleLine.length <= APPROVAL_LOG_SUMMARY_MAX_LENGTH)
         return singleLine;
     return singleLine.slice(0, APPROVAL_LOG_SUMMARY_MAX_LENGTH - 3).trimEnd() + '...';
 }
-/**
- * 规范化模型 ID：去掉 Claude Code SDK 专有的上下文窗口后缀 [1m]/[200k]
- * Codex/OpenAI API 不认识这些后缀，必须传入标准模型 ID
- */
-function stripContextWindowSuffix(modelId) {
-    return modelId.replace(/\[(?:1m|200k)\]$/i, '');
-}
 // ── Codex 模型目录（动态获取，含 effort） ──
 class AsyncEventQueue {
     queue = [];
@@ -198,11 +203,13 @@ function parseManagedPreToolUseDenial(value) {
         .trim();
     if (!reason)
         reason = 'EvolCore PreToolUse policy denied this tool call';
-    const policyCode = /工具调用已达到\s*\d+\s*次/.test(reason)
-        ? 'proactive_tool_report_required'
-        : /请先用\s+ec\s+(?:group\s+send|msg\s+send)/.test(reason)
-            ? 'proactive_first_send_required'
-            : 'managed_pre_tool_use_denied';
+    const policyCode = /当前汇报命令(?:未通过规范解析|不符合当前会话)/.test(reason)
+        ? 'proactive_send_invalid'
+        : /工具调用已达到\s*\d+\s*次/.test(reason)
+            ? 'proactive_tool_report_required'
+            : /请先用\s+ec\s+(?:group\s+send|msg\s+send)/.test(reason)
+                ? 'proactive_first_send_required'
+                : 'managed_pre_tool_use_denied';
     return { policyCode, reason };
 }
 function outputTextForManagedHook(value) {
@@ -442,6 +449,7 @@ export class CodexRunner {
             return existing;
         const client = new CodexAppServerClient({
             apiKey: this.resolvedConfig.apiKey,
+            authType: this.resolvedConfig.authType,
             baseUrl: this.resolvedConfig.baseUrl,
             provider: this.resolvedConfig.provider,
             headers: this.resolvedConfig.headers,
@@ -1298,7 +1306,7 @@ export class CodexRunner {
         }
         return Object.fromEntries([...paths].map(candidate => [candidate, 'write']));
     }
-    buildPermissionProfileConfig(sessionId, mode, projectPath, bootstrapAgentMdPath) {
+    buildPermissionProfileConfig(sessionId, mode, projectPath, bootstrapAgentMdPath, personalMdPath) {
         const profileName = this.permissionProfileName(sessionId);
         const managedTempDir = this.ensureSessionTempDir(sessionId);
         const network = {
@@ -1324,6 +1332,9 @@ export class CodexRunner {
                         ...(bootstrapAgentMdPath ? {
                             [path.resolve(bootstrapAgentMdPath)]: mode === 'readonly' ? 'read' : 'write',
                         } : {}),
+                        ...(personalMdPath ? {
+                            [path.resolve(personalMdPath)]: mode === 'readonly' ? 'read' : 'write',
+                        } : {}),
                         ...(mode !== 'readonly' && managedTempDir ? {
                             [managedTempDir]: 'write',
                             [managedTempDir + '/**']: 'write',
@@ -1336,12 +1347,12 @@ export class CodexRunner {
             },
         };
     }
-    buildExecutionSandboxOptions(sessionId, mode, projectPath, bootstrapAgentMdPath) {
+    buildExecutionSandboxOptions(sessionId, mode, projectPath, bootstrapAgentMdPath, personalMdPath) {
         const decision = resolvePhaseOneExecutionSandbox(mode, this.permissionContexts.get(sessionId)?.role);
         return {
             decision,
             permissionProfileConfig: decision.state === 'active'
-                ? this.buildPermissionProfileConfig(sessionId, decision.permissionMode, projectPath, bootstrapAgentMdPath)
+                ? this.buildPermissionProfileConfig(sessionId, decision.permissionMode, projectPath, bootstrapAgentMdPath, personalMdPath)
                 : undefined,
             sandbox: decision.state === 'off' ? 'danger-full-access' : undefined,
         };
@@ -1758,7 +1769,7 @@ export class CodexRunner {
         }
         this.chatModes.set(sessionId, callMode);
         const callApprovalPolicy = this.toApprovalPolicy(callMode);
-        const executionSandbox = this.buildExecutionSandboxOptions(sessionId, callMode, projectPath, modelOverride?.bootstrapAgentMdPath);
+        const executionSandbox = this.buildExecutionSandboxOptions(sessionId, callMode, projectPath, modelOverride?.bootstrapAgentMdPath, modelOverride?.personalMdPath);
         const appServer = this.getAppServerClient(callMode === 'fullaccess');
         this.dropExpiredPendingInterrupt(sessionId);
         const effectiveApprovalPolicy = callApprovalPolicy;
@@ -2604,7 +2615,7 @@ export class CodexRunner {
             release();
         }
     }
-    async forkSessionLocked(agentSessionId, projectPath, title) {
+    async forkSessionLocked(agentSessionId, projectPath, title, lastTurnId) {
         const sessionKey = this.findSessionKeyByThread(agentSessionId);
         const mode = this.chatModes.get(sessionKey) ?? this.currentMode;
         const executionSandbox = this.buildExecutionSandboxOptions(sessionKey, mode, projectPath);
@@ -2622,6 +2633,7 @@ export class CodexRunner {
             approvalsReviewer: 'user',
             ...(executionSandbox.sandbox ? { sandbox: executionSandbox.sandbox } : {}),
             config: this.sanitizeThreadEnvironmentConfig(this.mergeThreadConfig(executionSandbox.permissionProfileConfig, capabilityConfig, externalToolConfig, this.buildEvolcoreShellEnvironmentConfig(sessionKey, delegationCarrier), this.buildLifecycleLockdownConfig(mode)), mode),
+            ...(lastTurnId ? { lastTurnId } : {}),
         });
         const forkedThreadId = response.thread?.id;
         if (!forkedThreadId)
@@ -2636,29 +2648,80 @@ export class CodexRunner {
     async forkSessionAt(agentSessionId, projectPath, assistantMessageId, title) {
         const release = await this.acquireThreadOperation(this.threadOperationKey(agentSessionId), 'forkAt');
         try {
-            const turns = buildSessionTurnList(await this.getSessionMessages(agentSessionId, projectPath));
+            const appServer = this.getAppServerClientForThread(agentSessionId);
+            const history = await this.readForkHistory(appServer, agentSessionId);
+            const messages = this.mapThreadToSessionMessages(history, agentSessionId);
+            const turns = buildSessionTurnList(messages);
             const targetIndex = turns.findIndex(turn => turn.assistantUuid === assistantMessageId);
             if (targetIndex < 0)
                 throw new Error('fork point not found');
-            const forkedThreadId = await this.forkSessionLocked(agentSessionId, projectPath, title);
-            const turnsToDiscard = turns.length - targetIndex - 1;
-            if (turnsToDiscard > 0) {
-                const rollbackRelease = await this.acquireThreadOperation(this.threadOperationKey(forkedThreadId), 'rollback');
-                try {
-                    const rolledBack = await this.rollbackSessionTurnsLocked(forkedThreadId, turnsToDiscard);
-                    if (!rolledBack)
-                        throw new Error('forked thread rollback failed');
-                }
-                finally {
-                    rollbackRelease();
-                }
-            }
-            return forkedThreadId;
+            const targetTurnId = this.findTurnIdForAssistantMessage(history, assistantMessageId);
+            if (!targetTurnId)
+                throw new Error('fork point turn not found');
+            return await this.forkSessionLocked(agentSessionId, projectPath, title, targetTurnId);
         }
         finally {
             release();
         }
     }
+    findTurnIdForAssistantMessage(response, assistantMessageId) {
+        for (const turn of response.thread?.turns ?? []) {
+            if (typeof turn.id !== 'string' || !turn.id)
+                continue;
+            for (const item of this.getTurnItems(turn)) {
+                if (item.type === 'agentMessage' && item.id === assistantMessageId)
+                    return turn.id;
+            }
+            // Older app-server histories may omit item ids; the mapper then uses the
+            // turn id as the assistant message id fallback.
+            if (turn.id === assistantMessageId)
+                return turn.id;
+        }
+        return undefined;
+    }
+    async readForkHistory(appServer, threadId) {
+        let directRead;
+        let directReadError;
+        try {
+            directRead = await appServer.threadRead(threadId, true);
+            if ((directRead.thread?.turns?.length ?? 0) > 0)
+                return directRead;
+        }
+        catch (error) {
+            directReadError = error;
+        }
+        // Paginated threads reject full-history thread/read. Hydrate turns through
+        // the experimental paging RPC, retaining full items so assistant message
+        // IDs can be mapped to their containing turn.
+        const turns = [];
+        let cursor;
+        const seenCursors = new Set();
+        try {
+            do {
+                const page = await appServer.threadTurnsList(threadId, 100, cursor);
+                if (Array.isArray(page.data)) {
+                    turns.push(...page.data.filter((turn) => !!turn && typeof turn === 'object'));
+                }
+                const nextCursor = typeof page.nextCursor === 'string' && page.nextCursor ? page.nextCursor : undefined;
+                if (!nextCursor || seenCursors.has(nextCursor))
+                    break;
+                seenCursors.add(nextCursor);
+                cursor = nextCursor;
+            } while (true);
+        }
+        catch (error) {
+            if (directReadError)
+                throw directReadError;
+            throw error;
+        }
+        // Pages are returned newest-first when following `nextCursor`; restore
+        // chronological order before mapping turns to session messages.
+        if (turns.length > 0)
+            return { thread: { ...(directRead?.thread ?? {}), id: threadId, turns: turns.reverse() } };
+        if (directRead)
+            return directRead;
+        throw directReadError instanceof Error ? directReadError : new Error('Codex thread history unavailable');
+    }
     async setSessionName(agentSessionId, name) {
         return this.getAppServerClientForThread(agentSessionId).threadSetName(agentSessionId, name);
     }
@@ -4412,24 +4475,46 @@ export class CodexRunner {
                 this.clearPendingToolDenialsForTurn(state.threadId, turnId);
                 yield* this.reconcileOpenAppServerToolCalls(state, turnId);
                 if (turn.status === 'failed' && turn.error?.message) {
+                    logger.warn(`[CodexRunner] turn failed: ${JSON.stringify({
+                        sessionId, threadId: state.threadId, turnId, model: state.model,
+                        errorType: classifyError(new Error(turn.error.message)),
+                        message: formatApprovalLogSummary(turn.error.message),
+                        lastReportedUsage: state.tokenUsage?.last,
+                    })}`);
                     if (isRetryableError(new Error(turn.error.message))) {
                         throw new Error(turn.error.message);
                     }
-                    yield { type: 'error', error: turn.error.message, errorType: 'unknown' };
+                    yield { type: 'error', error: turn.error.message, errorType: toAgentErrorType(turn.error.message) };
                 }
                 yield this.mapAppServerTurnComplete(turn, state);
                 break;
             }
             case 'error': {
-                if (!params.message) {
-                    // SSE idle timeout reconnect — not a real task error, suppress
-                    logger.debug(`[CodexRunner] app-server SSE reconnect (no message)`);
+                // Current app-server uses error.message; older builds used message.
+                const message = typeof params.error?.message === 'string' ? params.error.message : params.message;
+                if (typeof message !== 'string' || !message.trim()) {
+                    logger.debug('[CodexRunner] app-server error notification without a diagnostic message');
                     break;
                 }
-                if (isRetryableError(new Error(params.message))) {
-                    throw new Error(params.message);
+                logger.warn(`[CodexRunner] error notification: ${JSON.stringify({
+                    sessionId, threadId: state.threadId, turnId: state.turnId, model: state.model,
+                    willRetry: params.willRetry ?? null,
+                    errorType: classifyError(new Error(message)), message: formatApprovalLogSummary(message),
+                })}`);
+                // Codex owns retries within this turn. Throwing here closes our subscription
+                // before its recovery can finish; runQuery must not submit the input again.
+                if (params.willRetry === true) {
+                    yield {
+                        type: 'notice', severity: 'warn', subtype: 'codex-model-retry',
+                        message: isOutputTokenLimitError(new Error(message))
+                            ? '模型响应达到输出上限，Codex 正在当前轮内重试。'
+                            : 'Codex 正在当前轮内重试模型请求。',
+                    };
+                    break;
                 }
-                yield { type: 'error', error: params.message, errorType: 'unknown' };
+                if (isRetryableError(new Error(message)))
+                    throw new Error(message);
+                yield { type: 'error', error: message, errorType: toAgentErrorType(message) };
                 break;
             }
         }
@@ -4860,16 +4945,17 @@ export class CodexRunner {
     }
     mapAppServerTurnComplete(turn, state) {
         const status = turn.status || 'completed';
+        const outputLimit = status === 'failed' && isOutputTokenLimitError(new Error(turn.error?.message ?? ''));
         const tokenUsage = this.mapCodexTokenUsage(state.tokenUsage?.last ?? turn.tokenUsage ?? turn.usage);
         const contextUsage = this.mapCodexContextUsage(turn.contextUsage ?? state.tokenUsage?.contextUsage ?? state.tokenUsage?.context);
         const terminalReason = status === 'completed'
             ? undefined
             : status === 'interrupted'
                 ? 'aborted_streaming'
-                : status;
+                : outputLimit ? 'max_output_tokens' : status;
         return {
             type: 'complete',
-            subtype: status === 'completed' ? 'success' : status,
+            subtype: status === 'completed' ? 'success' : outputLimit ? 'max_output_tokens' : status,
             isError: status === 'failed',
             errors: turn.error?.message ? [turn.error.message] : undefined,
             terminalReason,

package/dist/agents/ecagent-runner.js

@@ -1,4 +1,6 @@
 import { getRunnerCatalog, catalogEfforts, assertCatalogSelectable } from '../core/model/model-catalog.js';
+// Ecagent/OpenAI API 不认识 Claude Code SDK 的窗口后缀，必须传入基础模型 ID。
+import { stripContextWindowSuffix } from '../core/model/context-window-suffix.js';
 import fs from 'fs';
 import path from 'path';
 import { AgentHarness, JsonlSessionRepo, NodeExecutionEnv, } from '../../ecagent/dist/node.js';
@@ -26,13 +28,6 @@ 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 = [];
@@ -468,26 +463,27 @@ function isWithin(root, candidate) {
     const relative = path.relative(root, candidate);
     return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
 }
-export function resolveEcagentToolPath(projectPath, candidate, forWrite = false, bootstrapAgentMdPath, fullaccess = false) {
+export function resolveEcagentToolPath(projectPath, candidate, forWrite = false, bootstrapAgentMdPath, fullaccess = false, personalMdPath) {
     const root = fs.realpathSync(projectPath);
     const resolved = path.resolve(root, candidate || '.');
     const allowedBootstrapFile = bootstrapAgentMdPath
         ? path.resolve(bootstrapAgentMdPath)
         : undefined;
-    const isBootstrapAgentMd = allowedBootstrapFile === resolved;
-    if (!fullaccess && !isWithin(root, resolved) && !isBootstrapAgentMd) {
+    const allowedPersonalFile = personalMdPath ? path.resolve(personalMdPath) : undefined;
+    const isManagedIdentityFile = resolved === allowedBootstrapFile || resolved === allowedPersonalFile;
+    if (!fullaccess && !isWithin(root, resolved) && !isManagedIdentityFile) {
         throw new Error(`Path is outside the project: ${candidate}`);
     }
-    if (isBootstrapAgentMd) {
+    if (isManagedIdentityFile) {
         const parent = path.dirname(resolved);
         const canonicalParent = fs.realpathSync(parent);
         if (!isWithin(parent, canonicalParent) || !isWithin(canonicalParent, parent)) {
-            throw new Error(`Bootstrap agent.md parent resolves outside its declared path: ${candidate}`);
+            throw new Error(`Managed identity file parent resolves outside its declared path: ${candidate}`);
         }
         if (fs.existsSync(resolved)) {
             const canonicalFile = fs.realpathSync(resolved);
             if (!isWithin(resolved, canonicalFile) || !isWithin(canonicalFile, resolved)) {
-                throw new Error(`Bootstrap agent.md resolves outside its declared path: ${candidate}`);
+                throw new Error(`Managed identity file resolves outside its declared path: ${candidate}`);
             }
         }
         return resolved;
@@ -550,7 +546,7 @@ async function walkFiles(root, signal) {
 function textResult(text, details = {}) {
     return { content: [{ type: 'text', text: truncate(text) }], details };
 }
-function createTools(env, projectPath, runtimeEnv, bootstrapAgentMdPath, fullaccess = false) {
+function createTools(env, projectPath, runtimeEnv, bootstrapAgentMdPath, fullaccess = false, personalMdPath) {
     const read = {
         name: 'Read', label: 'Read', description: 'Read a UTF-8 text file from the project.',
         parameters: Type.Object({
@@ -559,7 +555,7 @@ function createTools(env, projectPath, runtimeEnv, bootstrapAgentMdPath, fullacc
             limit: Type.Optional(Type.Number({ minimum: 1 })),
         }),
         async execute(_id, params, signal) {
-            const file = resolveEcagentToolPath(projectPath, params.file_path, false, bootstrapAgentMdPath, fullaccess);
+            const file = resolveEcagentToolPath(projectPath, params.file_path, false, bootstrapAgentMdPath, fullaccess, personalMdPath);
             const stat = await fs.promises.stat(file);
             if (stat.size > MAX_READ_BYTES)
                 throw new Error(`File exceeds ${MAX_READ_BYTES} byte read limit`);
@@ -625,7 +621,7 @@ function createTools(env, projectPath, runtimeEnv, bootstrapAgentMdPath, fullacc
         name: 'Write', label: 'Write', description: 'Create or completely overwrite a project file.',
         parameters: Type.Object({ file_path: Type.String(), content: Type.String() }), executionMode: 'sequential',
         async execute(_id, params, signal) {
-            const file = resolveEcagentToolPath(projectPath, params.file_path, true, bootstrapAgentMdPath, fullaccess);
+            const file = resolveEcagentToolPath(projectPath, params.file_path, true, bootstrapAgentMdPath, fullaccess, personalMdPath);
             await fs.promises.mkdir(path.dirname(file), { recursive: true });
             await fs.promises.writeFile(file, params.content, { encoding: 'utf8', signal });
             return textResult(`Wrote ${Buffer.byteLength(params.content)} bytes to ${path.relative(projectPath, file)}`, { file });
@@ -638,7 +634,7 @@ function createTools(env, projectPath, runtimeEnv, bootstrapAgentMdPath, fullacc
             replace_all: Type.Optional(Type.Boolean()),
         }), executionMode: 'sequential',
         async execute(_id, params, signal) {
-            const file = resolveEcagentToolPath(projectPath, params.file_path, false, bootstrapAgentMdPath, fullaccess);
+            const file = resolveEcagentToolPath(projectPath, params.file_path, false, bootstrapAgentMdPath, fullaccess, personalMdPath);
             const value = await fs.promises.readFile(file, { encoding: 'utf8', signal });
             if (!params.old_string)
                 throw new Error('old_string must not be empty');
@@ -858,7 +854,7 @@ export class EcagentRunner {
                 models,
                 model,
                 thinkingLevel: normalizeThinkingLevel(effort),
-                tools: createTools(nodeEnv, request.projectPath, request.runtimeEnv, request.modelOverride?.bootstrapAgentMdPath, fullaccess),
+                tools: createTools(nodeEnv, request.projectPath, request.runtimeEnv, request.modelOverride?.bootstrapAgentMdPath, fullaccess, request.modelOverride?.personalMdPath),
                 systemPrompt: [DEFAULT_SYSTEM_PROMPT, request.systemPromptAppend].filter(Boolean).join('\n\n'),
                 streamOptions: {
                     timeoutMs: this.config.timeoutMs,

package/dist/agents/gemini-runner.js

@@ -1,4 +1,6 @@
 import { getCatalog, assertCatalogSelectable } from '../core/model/model-catalog.js';
+// Gemini API 不认识 Claude Code SDK 的窗口后缀，必须传入基础模型 ID。
+import { stripContextWindowSuffix } from '../core/model/context-window-suffix.js';
 /**
  * Gemini Agent Runner
  *
@@ -33,13 +35,6 @@ 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',
@@ -147,6 +142,7 @@ const GEMINI_EC_COMMAND_PATTERNS = [
     // quoted arguments.
     String.raw `\x00"command":"[ ]*ec[ ]+(?:[^"\x00;&|$()<>\x60\r\n\\]|\\(?:\\|"))*"\x00`,
 ];
+const GEMINI_BOOTSTRAP_PERSONA_COMMAND_PATTERN = String.raw `^\{\x00"command":"[ ]*ec[ ]+agent[ ]+persona(?:[ ]+show|[ ]+--(?:text|file)[ ]+(?:[^"\x00;&|$()<>\x60\r\n\\]|\\(?:\\|"))+)[ ]*"\x00\}$`;
 export function resolveGeminiPermissionProfile(value, bootstrap = false) {
     if (value === 'fullaccess')
         return { mode: 'fullaccess', approvalMode: 'yolo' };
@@ -186,6 +182,9 @@ function geminiExactShellCommandPattern(command) {
     // is_background or additional_permissions during bootstrap.
     return `^\\{\\x00"command":"[ ]*${escapeGeminiArgsRegex(command)}[ ]*"\\x00\\}$`;
 }
+function geminiManagedIdentityPathPattern(filePath) {
+    return geminiJsonFieldEqualsPattern(['file_path'], path.resolve(filePath));
+}
 function appendGeminiPolicyRule(lines, toolName, decision, priority, argsPattern) {
     lines.push('[[rule]]');
     lines.push(`toolName = ${Array.isArray(toolName) ? JSON.stringify(toolName) : JSON.stringify(toolName)}`);
@@ -194,7 +193,7 @@ function appendGeminiPolicyRule(lines, toolName, decision, priority, argsPattern
     lines.push(`decision = "${decision}"`);
     lines.push(`priority = ${priority}`, '');
 }
-export function buildGeminiAdminPolicy(profile, bootstrapAgentMdPath) {
+export function buildGeminiAdminPolicy(profile, bootstrapAgentMdPath, personalMdPath) {
     const lines = [];
     if (bootstrapAgentMdPath) {
         const bootstrap = normalizeGeminiBootstrapAgentMdPath(bootstrapAgentMdPath);
@@ -212,6 +211,12 @@ export function buildGeminiAdminPolicy(profile, bootstrapAgentMdPath) {
         appendGeminiPolicyRule(lines, GEMINI_BOOTSTRAP_FILE_TOOLS, 'allow', 990, writePathPattern);
         appendGeminiPolicyRule(lines, 'run_shell_command', 'allow', 990, geminiExactShellCommandPattern(`ec aid agentmd put ${bootstrap.aid}`));
         appendGeminiPolicyRule(lines, 'run_shell_command', 'allow', 990, geminiExactShellCommandPattern(`ec agent ready ${bootstrap.aid}`));
+        appendGeminiPolicyRule(lines, 'run_shell_command', 'allow', 990, GEMINI_BOOTSTRAP_PERSONA_COMMAND_PATTERN);
+        if (personalMdPath) {
+            const personalPathPattern = geminiManagedIdentityPathPattern(personalMdPath);
+            appendGeminiPolicyRule(lines, 'read_file', 'allow', 989, personalPathPattern);
+            appendGeminiPolicyRule(lines, GEMINI_BOOTSTRAP_FILE_TOOLS, 'allow', 989, personalPathPattern);
+        }
         // These are Gemini's non-I/O task bookkeeping tools. They do not expose
         // project files, shell, network, MCP, or user-interaction capabilities.
         appendGeminiPolicyRule(lines, GEMINI_BOOTSTRAP_LIFECYCLE_TOOLS, 'allow', 950);
@@ -231,6 +236,11 @@ export function buildGeminiAdminPolicy(profile, bootstrapAgentMdPath) {
     for (const pattern of GEMINI_L_CLASS_PATTERNS) {
         appendGeminiPolicyRule(lines, GEMINI_L_CLASS_WRITE_TOOLS, 'deny', 997, pattern);
     }
+    if (personalMdPath) {
+        const personalPathPattern = geminiManagedIdentityPathPattern(personalMdPath);
+        appendGeminiPolicyRule(lines, 'read_file', 'allow', 989, personalPathPattern);
+        appendGeminiPolicyRule(lines, GEMINI_BOOTSTRAP_FILE_TOOLS, 'allow', 989, personalPathPattern);
+    }
     if (profile.mode === 'readonly') {
         appendGeminiPolicyRule(lines, GEMINI_READONLY_TOOLS, 'allow', 950);
         appendGeminiPolicyRule(lines, '*', 'deny', 900);
@@ -365,6 +375,9 @@ export class GeminiRunner {
         const bootstrapAgentMdPath = modelOverride?.bootstrapAgentMdPath
             ? normalizeGeminiBootstrapAgentMdPath(modelOverride.bootstrapAgentMdPath).filePath
             : undefined;
+        const personalMdPath = modelOverride?.personalMdPath
+            ? path.resolve(modelOverride.personalMdPath)
+            : undefined;
         const permissionProfile = resolveGeminiPermissionProfile(requestedPermissionMode, !!bootstrapAgentMdPath);
         const callModel = modelOverride?.model || this.model;
         const managedTaskTmpDir = getManagedTaskTempDir(runtimeEnv);
@@ -382,6 +395,7 @@ export class GeminiRunner {
                 ...(runtimeDir ? [runtimeDir] : []),
                 ...(runtimeLockDir ? [runtimeLockDir] : []),
                 ...(bootstrapAgentMdPath ? [bootstrapAgentMdPath] : []),
+                ...(personalMdPath ? [personalMdPath] : []),
             ],
         });
         if (executionPermissionMode !== 'fullaccess' && !sandboxProbe && workspaceContainsHClassPaths(projectPath)) {
@@ -410,7 +424,7 @@ export class GeminiRunner {
             }
             else {
                 const policyPath = path.join(managedTmpDir, `evolcore-gemini-permission-${crypto.randomUUID()}.toml`);
-                fs.writeFileSync(policyPath, buildGeminiAdminPolicy(permissionProfile, bootstrapAgentMdPath), { mode: 0o600, flag: 'wx' });
+                fs.writeFileSync(policyPath, buildGeminiAdminPolicy(permissionProfile, bootstrapAgentMdPath, personalMdPath), { mode: 0o600, flag: 'wx' });
                 tempFiles.push(policyPath);
                 args.push(...buildGeminiPermissionArgs(permissionProfile, policyPath, !!sandboxProbe));
             }
@@ -452,6 +466,7 @@ export class GeminiRunner {
                 ...(runtimeDir ? [runtimeDir] : []),
                 ...(runtimeLockDir ? [runtimeLockDir] : []),
                 ...(bootstrapAgentMdPath ? [bootstrapAgentMdPath] : []),
+                ...(personalMdPath ? [personalMdPath] : []),
             ],
             readonlyPaths: tempFiles,
         });

package/dist/agents/runner-types.js

@@ -1,3 +1,4 @@
+import { parseModelId, stripContextWindowSuffix } from '../core/model/context-window-suffix.js';
 export const BASEAGENT_RUNNER_UNAVAILABLE = 'BASEAGENT_RUNNER_UNAVAILABLE';
 export class BaseagentRunnerUnavailableError extends Error {
     evolagentName;
@@ -69,20 +70,22 @@ const CLAUDE_CONTEXT_MODEL_ALIASES = ['opus', 'sonnet', 'haiku'];
 export function isClaudeContextUsageModel(model) {
     if (!model)
         return false;
-    const baseModel = model.replace(/\[1m\]$/i, '');
+    const baseModel = stripContextWindowSuffix(model);
     return /^claude-/i.test(baseModel) || CLAUDE_CONTEXT_MODEL_ALIASES.includes(baseModel);
 }
 export function isOneMillionContextModel(model) {
     if (!model)
         return false;
+    // 显式后缀是网关给出的权威窗口，优先于本地前缀表：`claude-opus-5[200k]`
+    // 即使基础 ID 在 1M 名单里，也必须按 200k 处理。
+    const { base, contextWindow } = parseModelId(model);
+    if (contextWindow !== undefined)
+        return contextWindow >= 1_000_000;
     if (ONE_M_CONTEXT_MODEL_ALIASES.includes(model))
         return true;
-    if (/\[1m\]$/i.test(model))
+    if (/deepseek-v4/i.test(base))
         return true;
-    if (/deepseek-v4/i.test(model))
-        return true;
-    const baseModel = model.replace(/\[1m\]$/i, '');
-    return ONE_M_CONTEXT_MODEL_PREFIXES.some(prefix => baseModel === prefix || baseModel.startsWith(`${prefix}-`));
+    return ONE_M_CONTEXT_MODEL_PREFIXES.some(prefix => base === prefix || base.startsWith(`${prefix}-`));
 }
 /**
  * EvolCore's conservative local context-window catalog: 1M models = 1,000,000;
@@ -94,17 +97,22 @@ export function realContextWindowForModel(model) {
     return isOneMillionContextModel(model) ? 1000000 : 200000;
 }
 /**
- * The SDK's compaction threshold must leave room for the next model turn and
- * its tool results. Keep a 10k reserve for 200k-class windows and retain the
- * historical 350k cap for large-context models.
+ * EvolCore auto-compact threshold: fixed at 650k tokens regardless of model
+ * context window. Large-window models (1M) compress at 650k; small-window
+ * models (200k/128k) never reach this threshold and rely on the SDK's own
+ * built-in compaction instead.
  */
-export function autoCompactWindowForContextWindow(contextWindow) {
-    if (!contextWindow || contextWindow <= 0)
-        return undefined;
-    const reserve = Math.min(10_000, Math.floor(contextWindow * 0.05));
-    return Math.min(350_000, Math.max(1, contextWindow - reserve));
+export function autoCompactWindowForModel(_model) {
+    return 650_000;
 }
-/** Auto-compact threshold derived from the configured model context window. */
-export function autoCompactWindowForModel(model) {
-    return autoCompactWindowForContextWindow(realContextWindowForModel(model)) ?? 350_000;
+/**
+ * Threshold passed to the Claude Code SDK's autoCompactWindow option.
+ * Kept window-aware so the SDK's own built-in compaction continues to fire
+ * at the right point for small-context models (200k/128k), where EvolCore's
+ * fixed 650k threshold would never trigger.
+ */
+export function sdkAutoCompactWindowForModel(model) {
+    const contextWindow = realContextWindowForModel(model);
+    const reserve = Math.min(10_000, Math.floor(contextWindow * 0.05));
+    return Math.min(650_000, Math.max(1, contextWindow - reserve));
 }