evolcore 0.0.20 → 0.0.22

package/dist/agents/ecagent-runner.js

@@ -6,13 +6,16 @@ import { AssistantMessageEventStream } from '../../ecagent/dist/runtime/utils/ev
 import { DEFAULT_PERMISSION_MODE } from '../types.js';
 import { agentSessionsDir, resolveRoot } from '../paths.js';
 import { requestDangerousCommandPermission } from '../core/permission/approval-gateway.js';
-import { normalizePermissionMode } from '../core/permission/mode.js';
+import { normalizeExecutionPermissionMode, normalizePermissionMode } from '../core/permission/mode.js';
 import { checkDangerousCommand, checkReadonly, evaluateToolPreflight } from '../core/permission/tool-policy.js';
 import { logger } from '../utils/logger.js';
 import { summarizeToolInputForAudit } from '../utils/tool-summary.js';
 import { auditToolPreflightDenial } from '../core/auth/authorization-audit.js';
 import { resolveEcagentConfig } from './baseagent.js';
 import { buildModelRequestHeaders } from './request-identity.js';
+import { appendRequestPath } from './request-identity.js';
+import { getManagedTaskTempDir } from '../cli/task-context.js';
+import { hasTrustedFullAccessContext } from './runner-types.js';
 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.
@@ -248,7 +251,7 @@ function createOpenAiTransport(config) {
                     const replacement = await options?.onPayload?.(payload, model);
                     if (replacement !== undefined)
                         payload = replacement;
-                    response = await fetch(`${model.baseUrl.replace(/\/+$/, '')}/chat/completions`, {
+                    response = await fetch(appendRequestPath(model.baseUrl, 'chat/completions', config.queryParams), {
                         method: 'POST',
                         headers: {
                             accept: 'text/event-stream',
@@ -459,14 +462,14 @@ 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) {
+export function resolveEcagentToolPath(projectPath, candidate, forWrite = false, bootstrapAgentMdPath, fullaccess = false) {
     const root = fs.realpathSync(projectPath);
     const resolved = path.resolve(root, candidate || '.');
     const allowedBootstrapFile = bootstrapAgentMdPath
         ? path.resolve(bootstrapAgentMdPath)
         : undefined;
     const isBootstrapAgentMd = allowedBootstrapFile === resolved;
-    if (!isWithin(root, resolved) && !isBootstrapAgentMd) {
+    if (!fullaccess && !isWithin(root, resolved) && !isBootstrapAgentMd) {
         throw new Error(`Path is outside the project: ${candidate}`);
     }
     if (isBootstrapAgentMd) {
@@ -488,7 +491,7 @@ export function resolveEcagentToolPath(projectPath, candidate, forWrite = false,
     while (!fs.existsSync(cursor) && cursor !== path.dirname(cursor))
         cursor = path.dirname(cursor);
     const canonical = fs.realpathSync(cursor);
-    if (!isWithin(root, canonical))
+    if (!fullaccess && !isWithin(root, canonical))
         throw new Error(`Path resolves outside the project: ${candidate}`);
     return resolved;
 }
@@ -541,7 +544,7 @@ async function walkFiles(root, signal) {
 function textResult(text, details = {}) {
     return { content: [{ type: 'text', text: truncate(text) }], details };
 }
-function createTools(env, projectPath, runtimeEnv, bootstrapAgentMdPath) {
+function createTools(env, projectPath, runtimeEnv, bootstrapAgentMdPath, fullaccess = false) {
     const read = {
         name: 'Read', label: 'Read', description: 'Read a UTF-8 text file from the project.',
         parameters: Type.Object({
@@ -550,7 +553,7 @@ function createTools(env, projectPath, runtimeEnv, bootstrapAgentMdPath) {
             limit: Type.Optional(Type.Number({ minimum: 1 })),
         }),
         async execute(_id, params, signal) {
-            const file = resolveEcagentToolPath(projectPath, params.file_path, false, bootstrapAgentMdPath);
+            const file = resolveEcagentToolPath(projectPath, params.file_path, false, bootstrapAgentMdPath, fullaccess);
             const stat = await fs.promises.stat(file);
             if (stat.size > MAX_READ_BYTES)
                 throw new Error(`File exceeds ${MAX_READ_BYTES} byte read limit`);
@@ -567,7 +570,7 @@ function createTools(env, projectPath, runtimeEnv, bootstrapAgentMdPath) {
         name: 'Glob', label: 'Glob', description: 'Find project files matching a glob pattern.',
         parameters: Type.Object({ pattern: Type.String(), path: Type.Optional(Type.String()) }),
         async execute(_id, params, signal) {
-            const root = resolveEcagentToolPath(projectPath, params.path ?? '.');
+            const root = resolveEcagentToolPath(projectPath, params.path ?? '.', false, undefined, fullaccess);
             const matcher = globRegex(params.pattern.replaceAll('\\', '/'));
             const files = (await walkFiles(root, signal))
                 .map(file => path.relative(root, file).replaceAll(path.sep, '/'))
@@ -583,7 +586,7 @@ function createTools(env, projectPath, runtimeEnv, bootstrapAgentMdPath) {
             case_insensitive: Type.Optional(Type.Boolean()), literal: Type.Optional(Type.Boolean()),
         }),
         async execute(_id, params, signal) {
-            const root = resolveEcagentToolPath(projectPath, params.path ?? '.');
+            const root = resolveEcagentToolPath(projectPath, params.path ?? '.', false, undefined, fullaccess);
             const files = (await fs.promises.stat(root)).isFile() ? [root] : await walkFiles(root, signal);
             const fileMatcher = params.glob ? globRegex(params.glob.replaceAll('\\', '/')) : undefined;
             const flags = params.case_insensitive ? 'i' : '';
@@ -616,7 +619,7 @@ function createTools(env, projectPath, runtimeEnv, bootstrapAgentMdPath) {
         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);
+            const file = resolveEcagentToolPath(projectPath, params.file_path, true, bootstrapAgentMdPath, fullaccess);
             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 });
@@ -629,7 +632,7 @@ function createTools(env, projectPath, runtimeEnv, bootstrapAgentMdPath) {
             replace_all: Type.Optional(Type.Boolean()),
         }), executionMode: 'sequential',
         async execute(_id, params, signal) {
-            const file = resolveEcagentToolPath(projectPath, params.file_path, false, bootstrapAgentMdPath);
+            const file = resolveEcagentToolPath(projectPath, params.file_path, false, bootstrapAgentMdPath, fullaccess);
             const value = await fs.promises.readFile(file, { encoding: 'utf8', signal });
             if (!params.old_string)
                 throw new Error('old_string must not be empty');
@@ -685,39 +688,43 @@ function errorType(message) {
 export class EcagentRunner {
     name = 'ecagent';
     capabilities = {
+        fullaccess: true,
         clear: true, compact: true, fork: true, askUserQuestion: false, planApproval: false, fileRewind: 'unsupported',
     };
     config;
+    agentAid;
     onSessionIdUpdate;
     model;
     effort;
     permissionMode = DEFAULT_PERMISSION_MODE;
     runtimes = new Map();
     activeStreams = new Map();
-    pendingInterrupts = new Set();
+    /** Queue identity prevents an old run's finally from consuming a new run's interrupt. */
+    pendingInterrupts = new Map();
     permissionContexts = new Map();
     permissionGateway;
     sendPromptFn;
     onCompactStart;
     modelCache;
-    constructor(config, callbacks) {
+    constructor(config, callbacks, runtime) {
         this.config = {
             ...config,
             headers: buildModelRequestHeaders({
                 baseagent: 'ecagent',
                 baseUrl: config.baseUrl,
-                agentAid: config.evolcoreAgentAid,
+                agentAid: runtime?.agentAid,
                 configuredHeaders: config.headers,
             }),
         };
         this.model = config.model;
         this.effort = config.effort;
+        this.agentAid = runtime?.agentAid;
         this.onSessionIdUpdate = callbacks?.onSessionIdUpdate;
     }
     sessionsRoot() {
-        if (!this.config.evolcoreAgentAid)
+        if (!this.agentAid)
             throw new Error('ecagent requires an EvolCore Agent AID');
-        return agentSessionsDir(this.config.evolcoreAgentAid);
+        return agentSessionsDir(this.agentAid);
     }
     setModel(model) { this.model = model; }
     getModel() { return this.model; }
@@ -744,7 +751,7 @@ export class EcagentRunner {
         const stale = this.modelCache?.ids;
         try {
             const signal = AbortSignal.timeout(MODEL_LIST_TIMEOUT_MS);
-            const response = await fetch(`${this.config.baseUrl.replace(/\/+$/, '')}/models`, {
+            const response = await fetch(appendRequestPath(this.config.baseUrl, 'models', this.config.queryParams), {
                 headers: {
                     authorization: `Bearer ${this.config.apiKey}`,
                     ...this.config.headers,
@@ -769,20 +776,53 @@ export class EcagentRunner {
         }
     }
     registerStream(key, stream) { this.activeStreams.set(key, stream); }
-    cleanupStream(key) { this.activeStreams.delete(key); }
+    cleanupStream(key) {
+        const stream = this.activeStreams.get(key);
+        if (!stream)
+            return;
+        this.activeStreams.delete(key);
+        if (this.pendingInterrupts.get(key) === stream)
+            this.pendingInterrupts.delete(key);
+    }
     hasActiveStream(key) { return this.activeStreams.has(key) || !!this.runtimes.get(key)?.harness; }
     updateSessionId(sessionId, agentSessionId) {
-        if (!agentSessionId) {
-            this.runtimes.delete(sessionId);
-        }
-        else {
-            const runtime = this.runtimes.get(sessionId);
-            if (runtime)
-                runtime.agentSessionId = agentSessionId;
+        const previousRuntime = this.runtimes.get(sessionId);
+        const applyLocal = () => {
+            if (!agentSessionId) {
+                if (this.runtimes.get(sessionId) === previousRuntime)
+                    this.runtimes.delete(sessionId);
+            }
+            else if (previousRuntime && this.runtimes.get(sessionId) === previousRuntime) {
+                previousRuntime.agentSessionId = agentSessionId;
+            }
+        };
+        if (!this.onSessionIdUpdate) {
+            applyLocal();
+            return;
         }
-        void this.onSessionIdUpdate?.(sessionId, agentSessionId);
+        // A discovered non-empty ID is not published to the shared runtime until
+        // the authoritative Session activation accepts it. Empty callbacks are
+        // local detach notifications and are safe to apply after completion.
+        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(`[EcagentRunner] session binding callback failed: ${error instanceof Error ? error.message : String(error)}`);
+            if (!agentSessionId)
+                applyLocal();
+        });
     }
     async runQuery(sessionId, prompt, projectPath, initialAgentSessionId, images, systemPromptAppend, _sessionManager, modelOverride, runtimeEnv = {}) {
+        // Keep managed tasks from silently inheriting the daemon-wide TMPDIR when
+        // their session-owned runtime directory is unavailable.
+        getManagedTaskTempDir(runtimeEnv);
+        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 queue = new AsyncEventQueue();
         this.activeStreams.set(sessionId, queue);
         void this.executeRun(queue, {
@@ -797,15 +837,19 @@ export class EcagentRunner {
         try {
             await fs.promises.mkdir(request.projectPath, { recursive: true });
             const previousRuntime = this.runtimes.get(request.sessionId);
-            const runtime = await this.getOrCreateRuntime(request.sessionId, request.projectPath, request.initialAgentSessionId);
-            if (!previousRuntime || request.initialAgentSessionId !== runtime.agentSessionId) {
+            const runtime = await this.getOrCreateRuntime(request.sessionId, request.projectPath, request.initialAgentSessionId, request.modelOverride);
+            if (previousRuntime !== runtime) {
                 queue.push({ type: 'session_id', sessionId: runtime.agentSessionId });
             }
             const modelId = request.modelOverride?.model || this.model;
             const effort = request.modelOverride?.effortMode === 'model_default'
                 ? undefined
                 : request.modelOverride?.effort ?? this.effort;
-            const permissionMode = normalizePermissionMode(request.modelOverride?.permissionMode || this.permissionMode).mode;
+            const permissionMode = normalizeExecutionPermissionMode(request.modelOverride?.permissionMode || this.permissionMode);
+            const fullaccess = permissionMode === 'fullaccess';
+            if (fullaccess && !hasTrustedFullAccessContext(this.permissionContexts.get(request.sessionId))) {
+                throw new Error('Ecagent fullaccess requires a trusted per-call execution authorization');
+            }
             const model = createModel(modelId, this.config.baseUrl);
             const nodeEnv = new NodeExecutionEnv({ cwd: request.projectPath, shellEnv: { ...process.env, ...request.runtimeEnv, EVOLCORE_SESSION_ID: request.sessionId, EVOLCORE_HOME: resolveRoot() } });
             const models = createModels();
@@ -828,7 +872,7 @@ export class EcagentRunner {
                 models,
                 model,
                 thinkingLevel: normalizeThinkingLevel(effort),
-                tools: createTools(nodeEnv, request.projectPath, request.runtimeEnv, request.modelOverride?.bootstrapAgentMdPath),
+                tools: createTools(nodeEnv, request.projectPath, request.runtimeEnv, request.modelOverride?.bootstrapAgentMdPath, fullaccess),
                 systemPrompt: [DEFAULT_SYSTEM_PROMPT, request.systemPromptAppend].filter(Boolean).join('\n\n'),
                 streamOptions: {
                     timeoutMs: this.config.timeoutMs,
@@ -837,7 +881,8 @@ export class EcagentRunner {
                 },
             });
             runtime.harness = harness;
-            if (this.pendingInterrupts.delete(request.sessionId)) {
+            if (this.pendingInterrupts.get(request.sessionId) === queue) {
+                this.pendingInterrupts.delete(request.sessionId);
                 await harness.abort();
                 runtime.harness = undefined;
                 throw new Error('ecagent run interrupted');
@@ -903,15 +948,28 @@ export class EcagentRunner {
         finally {
             if (!completeSent)
                 queue.push({ type: 'complete', isError: true, terminalReason: 'error', durationMs: Date.now() - stats.startedAt });
-            this.pendingInterrupts.delete(request.sessionId);
-            this.activeStreams.delete(request.sessionId);
+            if (this.activeStreams.get(request.sessionId) === queue) {
+                this.activeStreams.delete(request.sessionId);
+                if (this.pendingInterrupts.get(request.sessionId) === queue) {
+                    this.pendingInterrupts.delete(request.sessionId);
+                }
+            }
             queue.end();
         }
     }
-    async getOrCreateRuntime(sessionId, projectPath, requestedId) {
+    async getOrCreateRuntime(sessionId, projectPath, requestedId, modelOverride) {
         const current = this.runtimes.get(sessionId);
-        const targetId = requestedId || current?.agentSessionId;
-        if (current && current.projectPath === projectPath && (!targetId || current.agentSessionId === targetId))
+        const topicBinding = modelOverride?.backend?.kind === 'topic';
+        const requestedTopicAgentSessionId = topicBinding
+            ? modelOverride?.backend?.agentSessionId ?? null
+            : undefined;
+        const targetId = topicBinding
+            ? (requestedTopicAgentSessionId || undefined)
+            : requestedId || current?.agentSessionId;
+        if (current
+            && current.projectPath === projectPath
+            && (!targetId || current.agentSessionId === targetId)
+            && (!topicBinding || (!!targetId && current.agentSessionId === targetId)))
             return current;
         const env = new NodeExecutionEnv({ cwd: projectPath });
         const repo = new JsonlSessionRepo({ fs: env, sessionsRoot: this.sessionsRoot() });
@@ -919,21 +977,42 @@ export class EcagentRunner {
         if (targetId) {
             const metadata = (await repo.list({ cwd: projectPath })).find(item => item.id === targetId);
             if (!metadata) {
+                if (topicBinding) {
+                    const error = new Error(`bound topic backend is unavailable: ${targetId}`);
+                    error.code = 'TOPIC_BACKEND_UNAVAILABLE';
+                    throw error;
+                }
                 logger.warn(`[EcagentRunner] backing session ${targetId} was not found; creating a new session`);
                 session = await repo.create({ cwd: projectPath });
             }
             else
                 session = await repo.open(metadata);
         }
-        else
-            session = await repo.create({ cwd: projectPath, id: sessionId });
+        else {
+            // Topic UNBOUND is an explicit backend boundary. Let ecagent allocate a
+            // fresh provider ID; reusing the EvolCore Session ID would make every
+            // /renew cycle reopen the same provider session under a new filename.
+            session = topicBinding
+                ? await repo.create({ cwd: projectPath })
+                : await repo.create({ cwd: projectPath, id: sessionId });
+        }
         const metadata = await session.getMetadata();
         const runtime = { agentSessionId: metadata.id, projectPath, repo, session };
-        this.runtimes.set(sessionId, runtime);
-        if (metadata.id !== targetId) {
-            await this.onSessionIdUpdate?.(sessionId, metadata.id);
+        if ((topicBinding && metadata.id !== requestedTopicAgentSessionId) || metadata.id !== targetId) {
+            const turn = modelOverride?.turn;
+            const result = this.onSessionIdUpdate
+                ? (turn === undefined
+                    ? await this.onSessionIdUpdate(sessionId, metadata.id)
+                    : await this.onSessionIdUpdate(sessionId, metadata.id, { turn }))
+                : 'legacy_updated';
+            if (result !== undefined && result !== 'activated' && result !== 'already_active' && result !== 'legacy_updated') {
+                const error = new Error(`backend discovery rejected: ${result}`);
+                error.code = 'TOPIC_BACKEND_DISCOVERY_REJECTED';
+                throw error;
+            }
             // The public event is emitted by the active query immediately after creation.
         }
+        this.runtimes.set(sessionId, runtime);
         return runtime;
     }
     mapHarnessEvent(queue, event, stats, model, effort) {
@@ -987,6 +1066,11 @@ export class EcagentRunner {
     }
     async authorizeTool(sessionId, projectPath, mode, toolName, input) {
         const permissionContext = this.permissionContexts.get(sessionId);
+        if (mode === 'fullaccess') {
+            return hasTrustedFullAccessContext(permissionContext)
+                ? {}
+                : { block: true, reason: 'Untrusted fullaccess execution context' };
+        }
         const recordBlockedOperation = async (policyCode, operationInput = input, matchedPath) => {
             const summary = summarizeToolInputForAudit(toolName, operationInput).slice(0, 512);
             auditToolPreflightDenial({
@@ -996,6 +1080,7 @@ export class EcagentRunner {
                 summary,
                 sessionId,
                 agentAid: permissionContext?.selfAid,
+                agentName: permissionContext?.agentName,
                 permissionMode: mode,
                 channel: permissionContext?.channel,
                 actorId: permissionContext?.userId,
@@ -1014,6 +1099,7 @@ export class EcagentRunner {
                     policyCode,
                     decisionSource: 'policy',
                     agentAid: permissionContext?.selfAid,
+                    agentName: permissionContext?.agentName,
                     permissionMode: mode,
                     summary,
                     effect: 'operation_skipped',
@@ -1030,6 +1116,7 @@ export class EcagentRunner {
         }
         const preflight = evaluateToolPreflight(toolName, input, {
             sessionId,
+            managedTempDir: permissionContext?.managedTempDir,
             selfAid: permissionContext?.selfAid,
             channel: permissionContext?.channel,
             userId: permissionContext?.userId,
@@ -1049,7 +1136,7 @@ export class EcagentRunner {
         const checkedInput = preflight.input;
         if (mode === 'readonly') {
             const decision = checkReadonly(toolName, checkedInput, projectPath, {
-                sessionId, channel: permissionContext?.channel, peerId: permissionContext?.userId, role: permissionContext?.role,
+                sessionId, managedTempDir: permissionContext?.managedTempDir, channel: permissionContext?.channel, peerId: permissionContext?.userId, role: permissionContext?.role,
                 allowReadonlySourceDiagnostics: permissionContext?.allowReadonlySourceDiagnostics === true,
             });
             if (decision.behavior === 'deny') {
@@ -1078,8 +1165,9 @@ export class EcagentRunner {
             await harness.abort();
             return;
         }
-        if (this.activeStreams.has(sessionKey))
-            this.pendingInterrupts.add(sessionKey);
+        const stream = this.activeStreams.get(sessionKey);
+        if (stream)
+            this.pendingInterrupts.set(sessionKey, stream);
     }
     injectUserMessage(sessionId, text) {
         const harness = this.runtimes.get(sessionId)?.harness;
@@ -1087,22 +1175,33 @@ export class EcagentRunner {
             void harness.steer(text).catch(error => logger.warn('[EcagentRunner] Failed to steer active run:', error));
     }
     async closeSession(sessionId) {
+        const capturedPermissionContext = this.permissionContexts.get(sessionId);
         this.permissionContexts.get(sessionId)?.pauseController?.cancel();
+        const runtime = this.runtimes.get(sessionId);
+        const stream = this.activeStreams.get(sessionId);
         await this.interrupt(sessionId).catch(() => { });
-        this.runtimes.delete(sessionId);
-        this.activeStreams.delete(sessionId);
-        this.pendingInterrupts.delete(sessionId);
-        this.permissionContexts.delete(sessionId);
+        if (runtime && this.runtimes.get(sessionId) === runtime)
+            this.runtimes.delete(sessionId);
+        if (stream && this.activeStreams.get(sessionId) === stream) {
+            this.activeStreams.delete(sessionId);
+            if (this.pendingInterrupts.get(sessionId) === stream)
+                this.pendingInterrupts.delete(sessionId);
+        }
+        if (this.permissionContexts.get(sessionId) === capturedPermissionContext)
+            this.permissionContexts.delete(sessionId);
     }
     async clearSession(sessionId, agentSessionId, projectPath) {
         try {
+            const currentRuntime = this.runtimes.get(sessionId);
             await this.interrupt(sessionId);
             const env = new NodeExecutionEnv({ cwd: projectPath });
             const repo = new JsonlSessionRepo({ fs: env, sessionsRoot: this.sessionsRoot() });
             const metadata = (await repo.list({ cwd: path.resolve(projectPath) })).find(item => item.id === agentSessionId);
             if (metadata)
                 await repo.delete(metadata);
-            this.runtimes.delete(sessionId);
+            if (currentRuntime?.agentSessionId === agentSessionId
+                && this.runtimes.get(sessionId) === currentRuntime)
+                this.runtimes.delete(sessionId);
             await this.onSessionIdUpdate?.(sessionId, '');
             return !!metadata;
         }
@@ -1111,11 +1210,12 @@ export class EcagentRunner {
             return false;
         }
     }
-    async compactSession(sessionId, agentSessionId, projectPath) {
+    async compactSession(sessionId, agentSessionId, projectPath, modelOverride) {
+        const startedAt = Date.now();
         try {
             if (this.activeStreams.has(sessionId) || this.runtimes.get(sessionId)?.harness) {
                 logger.warn(`[EcagentRunner] compact skipped while session ${sessionId} is active`);
-                return false;
+                return { ok: false, code: 'invalid_state', message: 'Session is active', durationMs: Date.now() - startedAt };
             }
             const cwd = path.resolve(projectPath);
             const cached = this.runtimes.get(sessionId);
@@ -1123,7 +1223,11 @@ export class EcagentRunner {
                 ? cached
                 : await this.openExistingRuntime(agentSessionId, cwd);
             this.onCompactStart?.(sessionId);
-            const model = createModel(this.model, this.config.baseUrl);
+            const compactModel = modelOverride?.model || this.model;
+            const compactEffort = modelOverride?.effortMode === 'model_default'
+                ? undefined
+                : modelOverride?.effort ?? this.effort;
+            const model = createModel(compactModel, this.config.baseUrl);
             const env = new NodeExecutionEnv({ cwd: runtime.projectPath });
             const models = createModels();
             const transport = createOpenAiTransport(this.config);
@@ -1131,7 +1235,7 @@ export class EcagentRunner {
                 id: PROVIDER_ID, auth: { apiKey: { name: 'EvolCore gateway', login: async () => ({ type: 'api_key', key: this.config.apiKey }), resolve: async () => ({ auth: { apiKey: this.config.apiKey } }) } },
                 models: [model], api: transport,
             }));
-            const harness = new AgentHarness({ env, session: runtime.session, models, model, thinkingLevel: normalizeThinkingLevel(this.effort), tools: [] });
+            const harness = new AgentHarness({ env, session: runtime.session, models, model, thinkingLevel: normalizeThinkingLevel(compactEffort), tools: [] });
             runtime.harness = harness;
             try {
                 await harness.compact();
@@ -1139,16 +1243,22 @@ export class EcagentRunner {
             finally {
                 runtime.harness = undefined;
             }
-            this.runtimes.set(sessionId, runtime);
-            return true;
+            // Do not let an older compact operation overwrite a runtime that was
+            // published by a later topic turn.
+            if (this.runtimes.get(sessionId) === cached) {
+                this.runtimes.set(sessionId, runtime);
+            }
+            return { ok: true, durationMs: Date.now() - startedAt };
         }
         catch (error) {
-            logger.error('[EcagentRunner] compact failed:', error);
-            return false;
+            const message = error instanceof Error ? error.message : String(error);
+            const code = /aborted/i.test(message) ? 'aborted' : /invalid_state/i.test(message) ? 'invalid_state' : 'sdk_error';
+            logger.error(`[EcagentRunner] compact failed: session=${sessionId} agent=${agentSessionId} code=${code} durationMs=${Date.now() - startedAt} error=${message}`);
+            return { ok: false, code, message, durationMs: Date.now() - startedAt };
         }
     }
-    compact(sessionId, agentSessionId, projectPath) {
-        return this.compactSession(sessionId, agentSessionId, projectPath);
+    compact(sessionId, agentSessionId, projectPath, modelOverride) {
+        return this.compactSession(sessionId, agentSessionId, projectPath, modelOverride);
     }
     resolveSessionFile(agentSessionId, projectPath) {
         const dir = path.join(this.sessionsRoot(), `--${path.resolve(projectPath).replace(/^[/\\]/, '').replace(/[/\\:]/g, '-')}--`);
@@ -1251,8 +1361,8 @@ export class EcagentAgentPlugin {
         const override = agent.config.baseagents?.ecagent;
         if (!override)
             return null;
-        const configured = { ...override, evolcoreAgentAid: agent.aid, evolcoreAgentConfig: agent.config };
+        const configured = { ...override };
         const resolved = resolveEcagentConfig({ agents: { ecagent: configured } }, configured);
-        return { evolagentName: agent.name, baseagent: 'ecagent', agent: new EcagentRunner(resolved, callbacks) };
+        return { evolagentName: agent.name, baseagent: 'ecagent', agent: new EcagentRunner(resolved, callbacks, { agentAid: agent.aid }) };
     }
 }