@supen-ai/cli 0.1.6

package/daemon/dist/core/cortex.js

@@ -0,0 +1,1690 @@
+import fs from 'fs';
+import path from 'path';
+import Anthropic from '@anthropic-ai/sdk';
+import { logger } from './logger.js';
+import { getGatewayInstance, getLlmToken, getLlmTokenOrWait } from './gateway.js';
+import { AGENT_MIND_FILES, ASSISTANT_NAME, agentPaths, getAgentModelConfig, } from './config.js';
+import { cleanupTaskFolderWithoutMeaningfulArtifacts, ensureTaskArtifactLayout, resolveSessionTaskArtifactPaths, } from './task-artifacts.js';
+import { getUsageStats, appendGlobalUsage, clearSessionSdkId, ensureSession, updateSessionStatus, updateSessionSdkId, updateSessionUsage, getSessionForAgent, storeSessionUiEvent, } from './store.js';
+import { usesAnthropicMessagesApi } from '../http/thread-title.js';
+import { LoopGuard } from './loop-guard.js';
+import { convertSdkEventToUiMessageChunks, enrichUiMessageChunksWithDocumentRefs, serializeUiMessageChunks, } from './protocol-adapter.js';
+import { resolveMcpServers } from '../mcp/default-servers.js';
+import { getMcpEnvOverrides } from '../mcp/settings.js';
+import { customServersToMcpMap, fetchGlobalMcpConfig } from '../mcp/gateway-client.js';
+import { resolveInstalledPluginMcpServers } from '../plugins/hub.js';
+import { resolveEnabledSkillMcpServers } from '../skills/mcp-config.js';
+import { getRuntimeSpaceEnvVars, withRuntimeSpaceEnv } from './space-env.js';
+import { buildAssistantOutputExcerpt, buildObservableToolDetail, buildTaskContextExcerpt, excerptText, } from './observable-logging.js';
+import { shouldWaitForGatewayToken } from './sdk-wrapper.js';
+import { classifySessionInsight } from '../agent-sdk/session-events.js';
+import { SessionManager } from '../agent-sdk/session-manager.js';
+import { convertDriverOutputsToUiMessageChunks } from '../agent-sdk/driver-output-ui.js';
+import { createSession, createTurn } from '../agent-sdk/session-events.js';
+import { createFileMemorySubsystem } from '../agent-sdk/memory/filesystem.js';
+function isVisualRuntimeAttachment(attachment) {
+    const type = typeof attachment?.type === 'string' ? attachment.type : '';
+    const mimeType = typeof attachment?.mimeType === 'string'
+        ? attachment.mimeType
+        : typeof attachment?.mime_type === 'string'
+            ? attachment.mime_type
+            : '';
+    return type === 'image' || mimeType.startsWith('image/');
+}
+function resolveRuntimeAttachmentPath(rawPath, artifacts) {
+    if (!rawPath)
+        return null;
+    if (path.isAbsolute(rawPath))
+        return fs.existsSync(rawPath) ? rawPath : null;
+    const normalized = rawPath.replace(/\\/g, '/').replace(/^\/+/, '');
+    const candidates = [];
+    if (normalized === artifacts.taskFolderName || normalized.startsWith(`${artifacts.taskFolderName}/`)) {
+        candidates.push(path.join(artifacts.artifactRoot, normalized));
+    }
+    candidates.push(path.resolve(artifacts.taskRoot, normalized));
+    candidates.push(path.resolve(artifacts.cwd, normalized));
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+function resolveRuntimeAttachments(message, artifacts) {
+    const attachments = Array.isArray(message?.attachments) ? message.attachments : [];
+    return attachments
+        .map((attachment) => {
+        if (!attachment || typeof attachment !== 'object')
+            return null;
+        if (!isVisualRuntimeAttachment(attachment))
+            return null;
+        const rawPaths = [
+            typeof attachment.taskPath === 'string' ? attachment.taskPath.trim() : '',
+            typeof attachment.path === 'string' ? attachment.path.trim() : '',
+        ].filter(Boolean);
+        const resolvedPath = rawPaths
+            .map((rawPath) => resolveRuntimeAttachmentPath(rawPath, artifacts))
+            .find((candidate) => Boolean(candidate));
+        if (!resolvedPath)
+            return null;
+        return {
+            type: 'image',
+            name: typeof attachment.name === 'string'
+                ? attachment.name
+                : typeof attachment.filename === 'string'
+                    ? attachment.filename
+                    : path.basename(resolvedPath),
+            filename: typeof attachment.filename === 'string'
+                ? attachment.filename
+                : typeof attachment.name === 'string'
+                    ? attachment.name
+                    : path.basename(resolvedPath),
+            path: resolvedPath,
+            mimeType: typeof attachment.mimeType === 'string'
+                ? attachment.mimeType
+                : typeof attachment.mime_type === 'string'
+                    ? attachment.mime_type
+                    : undefined,
+        };
+    })
+        .filter((attachment) => Boolean(attachment));
+}
+const APP_SERVER_REASONING_DELTA_METHODS = new Set([
+    'item/reasoningSummary/delta',
+    'item/reasoning/delta',
+    'item/reasoning/summaryTextDelta',
+    'item/reasoning/textDelta',
+    'item/plan/delta',
+    'item/reasoning/summaryPartAdded',
+]);
+function shouldPersistUiChunkToChat(chunk) {
+    return true;
+}
+const NATIVE_SESSION_PREWARM_TTL_MS = 30_000;
+const nativeSessionPrewarmCache = new Map();
+function appendNormalizedOutputToFinalText(normalizedOutputs, current) {
+    let next = current;
+    let receivedText = false;
+    for (const output of normalizedOutputs) {
+        if (output.kind === 'session-event' && output.event?.type === 'text.delta') {
+            const payload = output.event.payload;
+            const text = typeof payload?.text === 'string' ? payload.text : '';
+            if (text) {
+                next += text;
+                receivedText = true;
+            }
+            continue;
+        }
+        if (output.kind === 'turn-item' && output.item?.type === 'message') {
+            const payload = output.item.payload;
+            const text = typeof payload?.text === 'string' ? payload.text : '';
+            if (text) {
+                next = text;
+                receivedText = true;
+            }
+            continue;
+        }
+        if (output.kind === 'app-server-event') {
+            const event = output.event;
+            const params = event?.params;
+            if (event?.method === 'item/agentMessage/delta') {
+                continue;
+            }
+            if (event?.method === 'item/completed') {
+                const item = params?.item && typeof params.item === 'object'
+                    ? params.item
+                    : {};
+                const phase = typeof item.phase === 'string' ? item.phase : '';
+                if (phase && phase !== 'final_answer') {
+                    continue;
+                }
+                const text = item.type === 'agentMessage' && typeof item.text === 'string' ? item.text : '';
+                if (text) {
+                    next = text;
+                    receivedText = true;
+                }
+            }
+        }
+    }
+    return { next, receivedText };
+}
+function extractTerminalResultText(normalizedOutputs) {
+    for (const output of normalizedOutputs) {
+        if (output.kind === 'app-server-event') {
+            const event = output.event;
+            if (event?.method !== 'turn/completed')
+                continue;
+            const params = event.params;
+            const turn = params?.turn && typeof params.turn === 'object'
+                ? params.turn
+                : {};
+            if (turn.status && turn.status !== 'completed')
+                continue;
+            const result = typeof turn.result === 'string' ? turn.result : '';
+            if (result.trim())
+                return result;
+            continue;
+        }
+        if (output.kind !== 'session-event')
+            continue;
+        if (output.event?.type !== 'turn.completed')
+            continue;
+        const payload = output.event.payload;
+        const result = typeof payload?.result === 'string' ? payload.result : '';
+        if (result.trim())
+            return result;
+    }
+    return '';
+}
+function extractTerminalFailureText(normalizedOutputs) {
+    for (const output of normalizedOutputs) {
+        if (output.kind === 'app-server-event') {
+            const event = output.event;
+            if (event?.method !== 'turn/completed' && event?.method !== 'turn/failed' && event?.method !== 'turn/cancelled') {
+                continue;
+            }
+            const params = event.params;
+            const turn = params?.turn && typeof params.turn === 'object'
+                ? params.turn
+                : {};
+            const status = typeof turn.status === 'string' ? turn.status : '';
+            if (event.method === 'turn/completed' && status !== 'failed' && status !== 'cancelled') {
+                continue;
+            }
+            const error = turn.error && typeof turn.error === 'object'
+                ? turn.error
+                : {};
+            const candidates = [error.message, turn.error, params?.error, params?.message];
+            for (const candidate of candidates) {
+                if (typeof candidate === 'string' && candidate.trim())
+                    return candidate.trim();
+            }
+            return status === 'cancelled' || event.method === 'turn/cancelled'
+                ? 'Agent turn was cancelled.'
+                : 'Agent turn failed before producing a result.';
+        }
+        if (output.kind !== 'session-event')
+            continue;
+        if (output.event?.type !== 'turn.failed' && output.event?.type !== 'turn.cancelled')
+            continue;
+        const payload = output.event.payload;
+        const candidates = [payload?.error, payload?.message, payload?.result, payload?.stopReason];
+        for (const candidate of candidates) {
+            if (typeof candidate === 'string' && candidate.trim())
+                return candidate.trim();
+        }
+        return output.event.type === 'turn.cancelled'
+            ? 'Agent turn was cancelled.'
+            : 'Agent turn failed before producing a result.';
+    }
+    return '';
+}
+function chunksContainTextDelta(chunks) {
+    return chunks.some((chunk) => {
+        return chunk.type === 'text-delta' && typeof chunk.delta === 'string' && chunk.delta.length > 0;
+    });
+}
+function chunksContainAppServerAgentMessage(chunks) {
+    return chunks.some((chunk) => isAppServerAgentMessageChunk(chunk));
+}
+function isAppServerAgentMessageChunk(chunk) {
+    if (chunk.type !== 'data-supen-event')
+        return false;
+    const data = chunk.data && typeof chunk.data === 'object'
+        ? chunk.data
+        : null;
+    const raw = data?.raw && typeof data.raw === 'object'
+        ? data.raw
+        : null;
+    const method = typeof raw?.method === 'string' ? raw.method : '';
+    if (method === 'item/agentMessage/delta')
+        return true;
+    if (method !== 'item/completed')
+        return false;
+    const params = raw?.params && typeof raw.params === 'object'
+        ? raw.params
+        : null;
+    const item = params?.item && typeof params.item === 'object'
+        ? params.item
+        : null;
+    return item?.type === 'agentMessage';
+}
+function isAppServerAgentMessageDeltaChunk(chunk) {
+    if (chunk.type !== 'data-supen-event')
+        return false;
+    const data = chunk.data && typeof chunk.data === 'object'
+        ? chunk.data
+        : null;
+    const raw = data?.raw && typeof data.raw === 'object'
+        ? data.raw
+        : null;
+    return raw?.method === 'item/agentMessage/delta';
+}
+function extractUiErrorText(chunks) {
+    for (const chunk of chunks) {
+        if (chunk.type !== 'error')
+            continue;
+        if (typeof chunk.errorText === 'string' && chunk.errorText.trim()) {
+            return chunk.errorText.trim();
+        }
+    }
+    return '';
+}
+function truncateText(text, maxChars) {
+    if (maxChars <= 0)
+        return '';
+    const chars = Array.from(text);
+    if (chars.length <= maxChars)
+        return text;
+    return `${chars.slice(0, maxChars).join('').trimEnd()}\n...[truncated]`;
+}
+// Memory constraints
+const RECENT_JOURNAL_COUNT = 3;
+const RECENT_JOURNAL_MAX_CHARS = 2_000;
+const RECENT_JOURNAL_TOTAL_MAX_CHARS = 6_000;
+function resolveAgentRuntimePaths(agentId) {
+    return agentPaths(agentId);
+}
+function nativeSessionPrewarmKey(agentId, sessionId, driverId, options) {
+    return [
+        agentId,
+        sessionId,
+        driverId,
+        options?.model || '',
+        options?.effort || '',
+        options?.permissionMode || '',
+        options?.networkAccess ? 'network' : '',
+        (options?.trustedDataHosts || []).join(','),
+    ].join(':');
+}
+function pruneNativeSessionPrewarmCache(now = Date.now()) {
+    for (const [key, entry] of nativeSessionPrewarmCache.entries()) {
+        if (entry.expiresAt > now)
+            continue;
+        nativeSessionPrewarmCache.delete(key);
+        entry.promise
+            .then((session) => session.close())
+            .catch(() => { });
+    }
+}
+function extractUsageTotals(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const obj = raw;
+    const candidatesIn = [
+        obj.tokensIn,
+        obj.inputTokens,
+        obj.input_tokens,
+        obj.promptTokens,
+        obj.prompt_tokens,
+        obj.total_input_tokens,
+    ];
+    const candidatesOut = [
+        obj.tokensOut,
+        obj.outputTokens,
+        obj.output_tokens,
+        obj.completionTokens,
+        obj.completion_tokens,
+        obj.total_output_tokens,
+    ];
+    const tokensIn = candidatesIn.find((value) => Number.isFinite(Number(value)));
+    const tokensOut = candidatesOut.find((value) => Number.isFinite(Number(value)));
+    const input = Number(tokensIn || 0);
+    const output = Number(tokensOut || 0);
+    if (input <= 0 && output <= 0)
+        return null;
+    return { tokensIn: input, tokensOut: output };
+}
+function reportUsageToGateway(agentId, sessionId, tokensIn, tokensOut) {
+    const gateway = getGatewayInstance();
+    if (!gateway || !gateway.isConnected())
+        return;
+    const selectedModel = getAgentModelConfig(agentId, true)[0];
+    const usage = getUsageStats({
+        agent_id: agentId,
+        tokens_in: tokensIn,
+        tokens_out: tokensOut,
+    });
+    gateway.reportUsage({
+        token: getLlmToken(),
+        agent_id: agentId,
+        thread_id: sessionId,
+        provider: selectedModel?.provider_id,
+        model: selectedModel?.model,
+        input_tokens: tokensIn,
+        output_tokens: tokensOut,
+        cost_usd: usage.estimated_cost_usd,
+        timestamp: new Date().toISOString(),
+    });
+}
+export class AgentCortex {
+    state;
+    controller = null;
+    events;
+    lastInputTokens = 0;
+    lastOutputTokens = 0;
+    loopGuard;
+    sessionManager = new SessionManager();
+    memorySubsystem;
+    sessionRecord;
+    constructor(agentId, sessionId, events = {}) {
+        this.events = events;
+        const sessionRecord = getSessionForAgent(agentId, sessionId) ||
+            ensureSession({
+                agent_id: agentId,
+                session_id: sessionId,
+                channel: 'daemon',
+                agent_name: agentId,
+            });
+        this.sessionRecord = sessionRecord;
+        this.state = {
+            status: 'idle',
+            agent_id: agentId,
+            session_id: sessionId,
+            sdk_session_id: sessionRecord?.sdk_session_id,
+            backend_driver_id: sessionRecord?.backend_driver_id,
+            activity: { phase: 'idle' },
+            recent_logs: [],
+            last_activity_at: Date.now(),
+        };
+        this.loopGuard = new LoopGuard();
+        this.memorySubsystem = createFileMemorySubsystem(resolveAgentRuntimePaths(agentId).base);
+    }
+    getState() {
+        return { ...this.state };
+    }
+    resolveBackendDriverId(explicitDriverId) {
+        const driverId = this.sessionManager.resolveDriverId(explicitDriverId || this.state.backend_driver_id);
+        if (this.state.backend_driver_id !== driverId) {
+            this.state.backend_driver_id = driverId;
+        }
+        return driverId;
+    }
+    /**
+     * Build mcpServers config for the SDK from the MCP manager.
+     * Converts internal McpServerConfig format to SDK's expected format.
+     */
+    async buildMcpServersConfig() {
+        // The user's global MCP config (own custom servers, catalog toggles, env
+        // overrides) is owned by the gateway. Fetch with a short TTL so every
+        // session pick-up reflects recent toggles without a per-session
+        // round-trip penalty.
+        const globalConfig = await fetchGlobalMcpConfig();
+        const localEnvOverrides = getMcpEnvOverrides();
+        const mergedEnv = {
+            ...localEnvOverrides,
+            ...globalConfig.mcp_server_env,
+        };
+        const disabledIds = new Set(globalConfig.disabled_mcp_server_ids);
+        const pluginMcpServers = await resolveInstalledPluginMcpServers();
+        // Preload built-in catalog MCP servers for every session, skipping ids
+        // the user disabled globally. Skills/manager declarations may override by
+        // id below.
+        const runtimeEnv = withRuntimeSpaceEnv(process.env);
+        const runtimeSpaceEnv = getRuntimeSpaceEnvVars();
+        const mergeMcpServerEnv = (config) => {
+            const merged = {
+                ...runtimeSpaceEnv,
+                ...(config.env || {}),
+            };
+            return Object.keys(merged).length > 0 ? merged : undefined;
+        };
+        const mcpServers = {
+            ...resolveMcpServers(runtimeEnv, mergedEnv, disabledIds),
+            ...customServersToMcpMap(globalConfig.mcp_servers),
+            ...pluginMcpServers,
+        };
+        for (const [serverId, config] of Object.entries(mcpServers)) {
+            mcpServers[serverId] = {
+                ...config,
+                env: mergeMcpServerEnv(config),
+            };
+        }
+        const skillDeclaredServers = resolveEnabledSkillMcpServers(this.state.agent_id);
+        for (const [serverId, config] of Object.entries(skillDeclaredServers)) {
+            mcpServers[serverId] = {
+                type: config.type,
+                command: config.command,
+                args: config.args,
+                env: mergeMcpServerEnv(config),
+            };
+        }
+        if (!this.events.mcpManager) {
+            return Object.keys(mcpServers).length > 0 ? mcpServers : undefined;
+        }
+        const configs = this.events.mcpManager.configs || [];
+        if (!Array.isArray(configs) || configs.length === 0) {
+            return Object.keys(mcpServers).length > 0 ? mcpServers : undefined;
+        }
+        for (const config of configs) {
+            if (!config.enabled || !config.command)
+                continue;
+            // Convert env array to Record
+            const env = {};
+            if (config.env && Array.isArray(config.env)) {
+                for (const { key, value } of config.env) {
+                    env[key] = value;
+                }
+            }
+            mcpServers[config.id] = {
+                type: config.type === 'stdio' ? 'stdio' : undefined,
+                command: config.command,
+                args: config.args,
+                env: mergeMcpServerEnv({ env }),
+            };
+        }
+        return Object.keys(mcpServers).length > 0 ? mcpServers : undefined;
+    }
+    async createNativeSdkSession(options) {
+        const paths = resolveAgentRuntimePaths(this.state.agent_id);
+        const artifacts = resolveSessionTaskArtifactPaths(this.sessionRecord, this.state.task_id);
+        const sessionKey = `${this.state.agent_id}:${this.state.session_id}`;
+        const driverId = this.resolveBackendDriverId();
+        const sdkSession = createSession({ id: this.state.session_id });
+        const sdkTurn = createTurn({ sessionId: sdkSession.id });
+        this.initBrain(paths.base, artifacts.cwd);
+        ensureTaskArtifactLayout(artifacts);
+        if (shouldWaitForGatewayToken(this.state.agent_id)) {
+            // Best-effort token prefetch to reduce first-turn auth churn for backends
+            // that depend on gateway-issued provider credentials.
+            try {
+                await getLlmTokenOrWait(options?.waitForTokenTimeoutMs ?? 5_000);
+            }
+            catch {
+                logger.debug('runNativeStream: No LLM token from gateway yet; continuing with local auth path');
+            }
+        }
+        const mcpServers = await this.buildMcpServersConfig();
+        return this.sessionManager.createSessionForTurn({
+            driverId,
+            agentId: this.state.agent_id,
+            session: sdkSession,
+            turn: sdkTurn,
+            cwd: artifacts.cwd,
+            writableRoots: artifacts.writableRoots,
+            model: options?.model,
+            effort: options?.effort,
+            permissionMode: options?.permissionMode,
+            networkAccess: options?.networkAccess,
+            trustedDataHosts: options?.trustedDataHosts,
+            env: this.sessionRecord.environment_snapshot?.environment_variables,
+            resume: options?.resume === false ? undefined : this.state.sdk_session_id,
+            mcpServers,
+            systemPromptAppend: this.preparePrompt(paths.base, artifacts),
+        });
+    }
+    async ensureNativeSdkSession(options) {
+        const now = Date.now();
+        pruneNativeSessionPrewarmCache(now);
+        const driverId = this.resolveBackendDriverId();
+        const key = nativeSessionPrewarmKey(this.state.agent_id, this.state.session_id, driverId, options);
+        const prewarmed = nativeSessionPrewarmCache.get(key);
+        if (prewarmed && prewarmed.expiresAt > now) {
+            nativeSessionPrewarmCache.delete(key);
+            try {
+                return await prewarmed.promise;
+            }
+            catch (err) {
+                logger.debug({ err, agent_id: this.state.agent_id, session_id: this.state.session_id }, 'Native session prewarm was unavailable; creating a fresh session');
+            }
+        }
+        return this.createNativeSdkSession(options);
+    }
+    async prewarmNativeSession(options) {
+        const now = Date.now();
+        pruneNativeSessionPrewarmCache(now);
+        const driverId = this.resolveBackendDriverId();
+        const key = nativeSessionPrewarmKey(this.state.agent_id, this.state.session_id, driverId, options);
+        const existing = nativeSessionPrewarmCache.get(key);
+        if (existing && existing.expiresAt > now) {
+            try {
+                await existing.promise;
+                return;
+            }
+            catch {
+                if (nativeSessionPrewarmCache.get(key) === existing) {
+                    nativeSessionPrewarmCache.delete(key);
+                }
+            }
+        }
+        const entry = {
+            expiresAt: now + NATIVE_SESSION_PREWARM_TTL_MS,
+            promise: this.createNativeSdkSession({
+                model: options?.model,
+                effort: options?.effort,
+                permissionMode: options?.permissionMode,
+                networkAccess: options?.networkAccess,
+                trustedDataHosts: options?.trustedDataHosts,
+                waitForTokenTimeoutMs: 1_500,
+            }).then(async (session) => {
+                await session.prepare?.();
+                return session;
+            }),
+        };
+        nativeSessionPrewarmCache.set(key, entry);
+        const timeout = setTimeout(() => {
+            if (nativeSessionPrewarmCache.get(key) !== entry)
+                return;
+            nativeSessionPrewarmCache.delete(key);
+            entry.promise
+                .then((session) => session.close())
+                .catch(() => { });
+        }, NATIVE_SESSION_PREWARM_TTL_MS);
+        timeout.unref?.();
+        try {
+            await entry.promise;
+        }
+        catch (err) {
+            if (nativeSessionPrewarmCache.get(key) === entry) {
+                nativeSessionPrewarmCache.delete(key);
+            }
+            logger.debug({ err, agent_id: this.state.agent_id, session_id: this.state.session_id }, 'Native session prewarm failed');
+        }
+    }
+    async run(taskId, prompt, options) {
+        if (this.state.status === 'busy') {
+            throw new Error(`Cortex ${this.state.agent_id}:${this.state.session_id} is already busy.`);
+        }
+        this.state.task_id = taskId || `task-${Date.now()}`;
+        this.state.status = 'busy';
+        this.state.recent_logs = [];
+        this.lastInputTokens = 0;
+        this.lastOutputTokens = 0;
+        this.controller = new AbortController();
+        this.loopGuard.reset();
+        if (options?.resume === false && this.state.sdk_session_id) {
+            this.state.sdk_session_id = undefined;
+            clearSessionSdkId(this.state.agent_id, this.state.session_id);
+        }
+        updateSessionStatus(this.state.agent_id, this.state.session_id, 'running');
+        const paths = resolveAgentRuntimePaths(this.state.agent_id);
+        const artifacts = resolveSessionTaskArtifactPaths(this.sessionRecord, this.state.task_id);
+        this.initBrain(paths.base, artifacts.cwd);
+        ensureTaskArtifactLayout(artifacts);
+        logger.info({
+            agent_id: this.state.agent_id,
+            task_id: this.state.task_id,
+            prompt_excerpt: excerptText(prompt, 180),
+        }, 'Task started');
+        await this.notifyState();
+        let runtimeTimeout = null;
+        let runtimeTimedOut = false;
+        let activeSession = null;
+        const runtimeTimeoutMs = typeof options?.timeoutMs === 'number' && Number.isFinite(options.timeoutMs)
+            ? Math.max(0, options.timeoutMs)
+            : 0;
+        const runtimeTimeoutMessage = runtimeTimeoutMs > 0
+            ? `Task timed out after ${Math.round(runtimeTimeoutMs / 1000)}s.`
+            : '';
+        try {
+            if (shouldWaitForGatewayToken(this.state.agent_id)) {
+                try {
+                    await getLlmTokenOrWait(options?.waitForTokenTimeoutMs ?? 5_000);
+                }
+                catch {
+                    logger.debug('run: No LLM token from gateway yet; continuing with local auth path');
+                }
+            }
+            const systemPrompt = [
+                this.preparePrompt(paths.base, artifacts),
+                options?.systemPromptAppend?.trim(),
+            ]
+                .filter(Boolean)
+                .join('\n\n');
+            const mcpServers = await this.buildMcpServersConfig();
+            const driverId = this.resolveBackendDriverId();
+            const sdkSession = createSession({ id: this.state.session_id });
+            const sdkTurn = createTurn({ sessionId: sdkSession.id });
+            const session = await this.sessionManager.createSessionForTurn({
+                driverId,
+                agentId: this.state.agent_id,
+                session: sdkSession,
+                turn: sdkTurn,
+                cwd: artifacts.cwd,
+                writableRoots: artifacts.writableRoots,
+                model: options?.model,
+                effort: options?.effort,
+                permissionMode: options?.permissionMode,
+                networkAccess: options?.networkAccess,
+                trustedDataHosts: options?.trustedDataHosts,
+                env: this.sessionRecord.environment_snapshot?.environment_variables,
+                resume: options?.resume === false ? undefined : this.state.sdk_session_id,
+                mcpServers,
+                systemPromptAppend: systemPrompt,
+            });
+            activeSession = session;
+            if (runtimeTimeoutMs > 0) {
+                runtimeTimeout = setTimeout(() => {
+                    runtimeTimedOut = true;
+                    this.controller?.abort();
+                    try {
+                        activeSession?.close();
+                    }
+                    catch {
+                        // Closing is best-effort; the loop below will surface the timeout.
+                    }
+                }, runtimeTimeoutMs);
+                runtimeTimeout.unref?.();
+            }
+            this.state.activity.action = 'thinking';
+            await this.notifyState();
+            // Send the prompt to the SDK session
+            await session.send(prompt);
+            let finalText = '';
+            let receivedStreamedText = false;
+            const stream = session.stream();
+            for await (const message of stream) {
+                if (runtimeTimedOut) {
+                    throw new Error(runtimeTimeoutMessage);
+                }
+                if (this.controller?.signal.aborted) {
+                    session.close();
+                    throw new Error('Aborted');
+                }
+                const msg = message;
+                if (msg.session_id && !this.state.sdk_session_id) {
+                    this.state.sdk_session_id = msg.session_id;
+                    updateSessionSdkId(this.state.agent_id, this.state.session_id, msg.session_id);
+                }
+                const normalizedOutputs = this.sessionManager.normalizeOutput({
+                    driverId: this.state.backend_driver_id,
+                    sessionId: this.state.session_id,
+                    turnId: sdkTurn.id,
+                    output: msg,
+                });
+                const normalizedText = appendNormalizedOutputToFinalText(normalizedOutputs, finalText);
+                finalText = normalizedText.next;
+                if (normalizedText.receivedText) {
+                    receivedStreamedText = true;
+                }
+                if (msg.type === 'stream_event') {
+                    const event = msg.event;
+                    if (event.type === 'content_block_delta' && event.delta?.type === 'text_delta') {
+                        const delta = event.delta.text;
+                        if (!normalizedText.receivedText) {
+                            finalText += delta;
+                        }
+                        if (delta.length > 0 || normalizedText.receivedText) {
+                            receivedStreamedText = true;
+                        }
+                        this.state.activity.action = 'speaking';
+                        this.state.activity.target = delta;
+                        logger.info({
+                            agent_id: this.state.agent_id,
+                            task_id: this.state.task_id,
+                            output_excerpt: buildAssistantOutputExcerpt(delta),
+                        }, 'Task assistant output');
+                        await this.notifyState();
+                    }
+                }
+                else if (msg.type === 'result') {
+                    if (msg.subtype === 'success') {
+                        if (!receivedStreamedText || finalText.trim().length === 0) {
+                            finalText = msg.result;
+                        }
+                    }
+                }
+                else if (msg.type === 'tool_use') {
+                    this.state.activity.action = `executing_${msg.name}`;
+                    logger.info({
+                        agent_id: this.state.agent_id,
+                        task_id: this.state.task_id,
+                        ...buildObservableToolDetail({
+                            tool: msg.name,
+                            target: msg.input?.path ?? msg.input?.file_path ?? msg.input?.url,
+                            args: msg.input,
+                        }),
+                    }, 'Task tool call');
+                    await this.notifyState();
+                }
+            }
+            if (runtimeTimedOut) {
+                throw new Error(runtimeTimeoutMessage);
+            }
+            // Resolve workspace links for frontend
+            const wsEscaped = artifacts.artifactRoot.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const wsPathRegex = new RegExp(`${wsEscaped}/([^\\s)"\']+)`, 'g');
+            finalText = finalText.replace(wsPathRegex, (_match, relPath) => {
+                const absPath = path.join(artifacts.artifactRoot, relPath);
+                if (fs.existsSync(absPath)) {
+                    return `supen://workspace/${this.state.agent_id}/${relPath}`;
+                }
+                return _match;
+            });
+            await this.events.onReply?.(finalText);
+            await this.consolidateMemory(paths.base, finalText);
+            try {
+                const usage = extractUsageTotals(await session.getContextUsage?.());
+                if (usage) {
+                    reportUsageToGateway(this.state.agent_id, this.state.session_id, usage.tokensIn, usage.tokensOut);
+                    try {
+                        updateSessionUsage(this.state.agent_id, this.state.session_id, usage.tokensIn, usage.tokensOut);
+                    }
+                    catch {
+                        appendGlobalUsage(this.state.agent_id, this.state.session_id, usage.tokensIn, usage.tokensOut);
+                    }
+                }
+            }
+            catch (usageErr) {
+                logger.warn({
+                    usageErr,
+                    message: usageErr instanceof Error ? usageErr.message : String(usageErr),
+                    stack: usageErr instanceof Error ? usageErr.stack : undefined,
+                    agent_id: this.state.agent_id,
+                    session_id: this.state.session_id,
+                }, 'Failed to persist session usage after run');
+            }
+            this.state.status = 'idle';
+            this.state.last_activity_at = Date.now();
+            this.state.activity = { phase: 'done' };
+            updateSessionStatus(this.state.agent_id, this.state.session_id, 'idle');
+        }
+        catch (err) {
+            if (runtimeTimedOut) {
+                this.state.status = 'error';
+                this.state.activity = { phase: 'error', action: runtimeTimeoutMessage };
+                updateSessionStatus(this.state.agent_id, this.state.session_id, 'error');
+                logger.error({ err, agent_id: this.state.agent_id, task_id: this.state.task_id }, 'Cortex: Task timed out');
+                try {
+                    await this.events.onError?.(runtimeTimeoutMessage, new Error(runtimeTimeoutMessage));
+                }
+                catch (e) { }
+            }
+            else if (this.controller?.signal.aborted) {
+                this.state.status = 'interrupted';
+                this.state.activity = { phase: 'interrupted' };
+                updateSessionStatus(this.state.agent_id, this.state.session_id, 'idle');
+            }
+            else {
+                this.state.status = 'error';
+                this.state.activity = { phase: 'error', action: err.message };
+                updateSessionStatus(this.state.agent_id, this.state.session_id, 'error');
+                logger.error({ err, agent_id: this.state.agent_id }, 'Cortex: Loop failed');
+                const displayError = `> 🚨 **Agent Pipeline Halted:**\n> ${err.message}`;
+                try {
+                    if (this.events.onError) {
+                        await this.events.onError(displayError, err);
+                    }
+                    else {
+                        await this.events.onReply?.(displayError);
+                    }
+                }
+                catch (e) { }
+            }
+        }
+        finally {
+            if (runtimeTimeout)
+                clearTimeout(runtimeTimeout);
+            this.controller = null;
+            await this.notifyState();
+        }
+    }
+    interrupt() {
+        if (this.controller && this.state.status === 'busy') {
+            this.controller.abort();
+        }
+    }
+    async runNativeStream(taskId, messages, options) {
+        if (this.state.status === 'busy') {
+            throw new Error(`Cortex ${this.state.agent_id}:${this.state.session_id} is already busy.`);
+        }
+        this.state.task_id = taskId || `task-${Date.now()}`;
+        this.state.status = 'busy';
+        this.controller = new AbortController();
+        updateSessionStatus(this.state.agent_id, this.state.session_id, 'running');
+        const paths = resolveAgentRuntimePaths(this.state.agent_id);
+        const artifacts = resolveSessionTaskArtifactPaths(this.sessionRecord, this.state.task_id);
+        ensureTaskArtifactLayout(artifacts);
+        logger.info({
+            agent_id: this.state.agent_id,
+            task_id: this.state.task_id,
+            workspace: paths.workspace,
+            runtime_cwd: artifacts.cwd,
+            writable_artifact_root: artifacts.artifactRoot,
+            task_folder: artifacts.taskRoot,
+        }, 'Task stream setup');
+        const latestMessage = messages[messages.length - 1];
+        const prompt = typeof latestMessage.content === 'string'
+            ? latestMessage.content
+            : Array.isArray(latestMessage.parts)
+                ? latestMessage.parts.filter((p) => p.type === 'text').map((p) => p.text).join('')
+                : '';
+        const promptExcerpt = excerptText(prompt, 180);
+        const contextExcerpt = buildTaskContextExcerpt(messages.map((message) => ({
+            content: typeof message.content === 'string'
+                ? message.content
+                : Array.isArray(message.parts)
+                    ? message.parts
+                        .filter((part) => part.type === 'text')
+                        .map((part) => part.text)
+                        .join(' ')
+                    : undefined,
+        })));
+        logger.info({
+            agent_id: this.state.agent_id,
+            task_id: this.state.task_id,
+            prompt_excerpt: promptExcerpt,
+            context_excerpt: contextExcerpt,
+        }, 'Task stream context');
+        storeSessionUiEvent(this.state.agent_id, this.state.session_id, {
+            id: `${this.state.task_id}:task-started:${Date.now()}`,
+            timestamp: new Date().toISOString(),
+            task_id: this.state.task_id,
+            chunk: {
+                type: 'data-supen-event',
+                data: {
+                    eventType: 'system',
+                    subtype: 'status',
+                    raw: {
+                        status: 'started',
+                        message: 'Task started',
+                        prompt_excerpt: promptExcerpt,
+                    },
+                },
+            },
+        });
+        const encoder = new TextEncoder();
+        const agentId = this.state.agent_id;
+        const sessionId = this.state.session_id;
+        const self = this;
+        return new ReadableStream({
+            async start(controller) {
+                logger.info('runNativeStream: ReadableStream starting');
+                let finalText = '';
+                let streamError = null;
+                let streamErrorNotified = false;
+                let sdkSession = null;
+                let messageStarted = false;
+                let stepStarted = false;
+                let textStarted = false;
+                let reasoningStarted = false;
+                let textPartIndex = 0;
+                let currentTextPartId = null;
+                let reasoningPartIndex = 0;
+                let currentReasoningPartId = null;
+                let emittedTextToUi = false;
+                let receivedIncrementalText = false;
+                let receivedIncrementalReasoning = false;
+                const appServerDeltaReasoningItemIds = new Set();
+                const appServerCommandOutputByItemId = new Map();
+                const assistantMessageId = `${taskId}-assistant`;
+                const sdkSessionRecord = createSession({ id: self.state.session_id });
+                const sdkTurn = createTurn({ sessionId: sdkSessionRecord.id });
+                const isAborted = () => self.controller?.signal.aborted === true;
+                const abortSdkSession = () => {
+                    try {
+                        sdkSession?.close();
+                    }
+                    catch (err) {
+                        logger.debug({ err }, 'runNativeStream: failed to close SDK session during abort');
+                    }
+                };
+                self.controller?.signal.addEventListener('abort', abortSdkSession, { once: true });
+                const persistUiChunks = (chunks) => {
+                    const timestamp = new Date().toISOString();
+                    for (const chunk of chunks) {
+                        storeSessionUiEvent(self.state.agent_id, self.state.session_id, {
+                            id: `${taskId}:${timestamp}:${Math.random().toString(36).slice(2, 8)}`,
+                            timestamp,
+                            task_id: taskId,
+                            chunk,
+                        });
+                    }
+                };
+                const nextTextPartId = () => {
+                    textPartIndex += 1;
+                    return String(textPartIndex);
+                };
+                const nextReasoningPartId = () => {
+                    reasoningPartIndex += 1;
+                    return `reasoning-${reasoningPartIndex}`;
+                };
+                const isToolChunk = (chunk) => {
+                    return typeof chunk.type === 'string' && chunk.type.startsWith('tool-');
+                };
+                const enqueueUiMessageChunks = (chunks) => {
+                    if (chunks.length === 0)
+                        return;
+                    const normalizedChunks = [];
+                    if (!messageStarted) {
+                        normalizedChunks.push({ type: 'start', messageId: assistantMessageId });
+                        messageStarted = true;
+                    }
+                    if (!stepStarted) {
+                        normalizedChunks.push({ type: 'start-step' });
+                        stepStarted = true;
+                    }
+                    for (const chunk of chunks) {
+                        if (chunk.type === 'text-start') {
+                            if (textStarted && currentTextPartId) {
+                                normalizedChunks.push({ type: 'text-end', id: currentTextPartId });
+                            }
+                            currentTextPartId = typeof chunk.id === 'string' && chunk.id.trim()
+                                ? chunk.id
+                                : nextTextPartId();
+                            textStarted = true;
+                            normalizedChunks.push({ ...chunk, id: currentTextPartId });
+                            continue;
+                        }
+                        if (chunk.type === 'text-delta') {
+                            if (!textStarted || !currentTextPartId) {
+                                currentTextPartId = nextTextPartId();
+                                normalizedChunks.push({ type: 'text-start', id: currentTextPartId });
+                                textStarted = true;
+                            }
+                            normalizedChunks.push({ ...chunk, id: currentTextPartId });
+                            continue;
+                        }
+                        if (chunk.type === 'text-end') {
+                            const id = currentTextPartId || (typeof chunk.id === 'string' ? chunk.id : undefined);
+                            if (textStarted && id) {
+                                normalizedChunks.push({ ...chunk, id });
+                            }
+                            textStarted = false;
+                            currentTextPartId = null;
+                            continue;
+                        }
+                        if (chunk.type === 'reasoning-start') {
+                            if (reasoningStarted && currentReasoningPartId) {
+                                normalizedChunks.push({ type: 'reasoning-end', id: currentReasoningPartId });
+                            }
+                            currentReasoningPartId = typeof chunk.id === 'string' && chunk.id.trim()
+                                ? chunk.id
+                                : nextReasoningPartId();
+                            reasoningStarted = true;
+                            normalizedChunks.push({ ...chunk, id: currentReasoningPartId });
+                            continue;
+                        }
+                        if (chunk.type === 'reasoning-delta') {
+                            if (!reasoningStarted || !currentReasoningPartId) {
+                                currentReasoningPartId = nextReasoningPartId();
+                                normalizedChunks.push({ type: 'reasoning-start', id: currentReasoningPartId });
+                                reasoningStarted = true;
+                            }
+                            normalizedChunks.push({ ...chunk, id: currentReasoningPartId });
+                            continue;
+                        }
+                        if (chunk.type === 'reasoning-end') {
+                            const id = currentReasoningPartId || (typeof chunk.id === 'string' ? chunk.id : undefined);
+                            if (reasoningStarted && id) {
+                                normalizedChunks.push({ ...chunk, id });
+                            }
+                            reasoningStarted = false;
+                            currentReasoningPartId = null;
+                            continue;
+                        }
+                        if (isToolChunk(chunk) && textStarted && currentTextPartId) {
+                            normalizedChunks.push({ type: 'text-end', id: currentTextPartId });
+                            textStarted = false;
+                            currentTextPartId = null;
+                        }
+                        normalizedChunks.push(chunk);
+                    }
+                    if (chunksContainTextDelta(normalizedChunks)) {
+                        emittedTextToUi = true;
+                    }
+                    if (chunksContainAppServerAgentMessage(normalizedChunks)) {
+                        emittedTextToUi = true;
+                    }
+                    persistUiChunks(normalizedChunks);
+                    const persistedChunks = normalizedChunks.filter(shouldPersistUiChunkToChat);
+                    const payload = serializeUiMessageChunks(persistedChunks);
+                    if (payload) {
+                        controller.enqueue(encoder.encode(payload));
+                    }
+                };
+                const finishUiMessage = (finishReason = 'stop') => {
+                    if (!messageStarted)
+                        return;
+                    const chunks = [];
+                    if (textStarted && currentTextPartId) {
+                        chunks.push({ type: 'text-end', id: currentTextPartId });
+                        textStarted = false;
+                        currentTextPartId = null;
+                    }
+                    if (reasoningStarted && currentReasoningPartId) {
+                        chunks.push({ type: 'reasoning-end', id: currentReasoningPartId });
+                        reasoningStarted = false;
+                        currentReasoningPartId = null;
+                    }
+                    if (stepStarted) {
+                        chunks.push({ type: 'finish-step' });
+                        stepStarted = false;
+                    }
+                    chunks.push({ type: 'finish', finishReason });
+                    messageStarted = false;
+                    persistUiChunks(chunks);
+                    const payload = serializeUiMessageChunks(chunks);
+                    if (payload) {
+                        controller.enqueue(encoder.encode(payload));
+                    }
+                };
+                const emitStreamError = (errorText) => {
+                    const chunks = [];
+                    if (textStarted && currentTextPartId) {
+                        chunks.push({ type: 'text-end', id: currentTextPartId });
+                        textStarted = false;
+                        currentTextPartId = null;
+                    }
+                    if (reasoningStarted && currentReasoningPartId) {
+                        chunks.push({ type: 'reasoning-end', id: currentReasoningPartId });
+                        reasoningStarted = false;
+                        currentReasoningPartId = null;
+                    }
+                    if (stepStarted) {
+                        chunks.push({ type: 'finish-step' });
+                        stepStarted = false;
+                    }
+                    chunks.push({ type: 'error', errorText });
+                    persistUiChunks(chunks);
+                    const payload = serializeUiMessageChunks(chunks);
+                    if (payload) {
+                        controller.enqueue(encoder.encode(payload));
+                    }
+                };
+                const notifyStreamError = async (error) => {
+                    if (streamErrorNotified)
+                        return;
+                    streamErrorNotified = true;
+                    try {
+                        await self.events.onError?.(`> 🚨 **Agent Pipeline Halted:**\n> ${error.message || 'Stream execution failed'}`, error);
+                    }
+                    catch (callbackError) {
+                        logger.error({ err: callbackError }, 'runNativeStream: onError failed');
+                    }
+                };
+                enqueueUiMessageChunks([
+                    {
+                        type: 'data-supen-event',
+                        data: {
+                            eventType: 'system',
+                            subtype: 'status',
+                            raw: {
+                                type: 'system',
+                                subtype: 'status',
+                                status: 'requesting',
+                                message: 'Thinking',
+                            },
+                        },
+                    },
+                ]);
+                try {
+                    sdkSession = await self.ensureNativeSdkSession({
+                        model: options?.model,
+                        effort: options?.effort,
+                        permissionMode: options?.permissionMode,
+                        networkAccess: options?.networkAccess,
+                        trustedDataHosts: options?.trustedDataHosts,
+                        waitForTokenTimeoutMs: 5_000,
+                    });
+                    logger.info({
+                        agent_id: agentId,
+                        task_id: self.state.task_id,
+                        prompt_excerpt: excerptText(prompt, 180),
+                    }, 'Task prompt sent');
+                    if (isAborted()) {
+                        abortSdkSession();
+                        throw new Error('Aborted');
+                    }
+                    const visualAttachments = resolveRuntimeAttachments(latestMessage, artifacts);
+                    const runtimeInput = visualAttachments.length > 0
+                        ? { text: prompt, attachments: visualAttachments }
+                        : prompt;
+                    await sdkSession.send(runtimeInput);
+                    const stream = sdkSession.stream();
+                    logger.debug('runNativeStream: stream object obtained, starting manual iteration');
+                    const iterator = stream[Symbol.asyncIterator]();
+                    while (true) {
+                        if (isAborted()) {
+                            abortSdkSession();
+                            throw new Error('Aborted');
+                        }
+                        logger.debug('runNativeStream: waiting for next stream message...');
+                        const nextResult = await iterator.next();
+                        if (isAborted()) {
+                            abortSdkSession();
+                            throw new Error('Aborted');
+                        }
+                        if (nextResult.done) {
+                            logger.debug('runNativeStream: stream done');
+                            break;
+                        }
+                        const message = nextResult.value;
+                        if (!message) {
+                            logger.debug('runNativeStream: empty SDK message, ending stream');
+                            break;
+                        }
+                        logger.debug({
+                            agent_id: agentId,
+                            task_id: self.state.task_id,
+                            type: message.type,
+                            method: typeof message.method === 'string' ? message.method : undefined,
+                        }, 'Task stream event');
+                        if (message.session_id && !self.state.sdk_session_id) {
+                            self.state.sdk_session_id = message.session_id;
+                            updateSessionSdkId(self.state.agent_id, self.state.session_id, message.session_id);
+                        }
+                        if (message.type === 'assistant') {
+                            const phase = typeof message.phase === 'string' ? message.phase : '';
+                            if (!phase && Array.isArray(message.message?.content)) {
+                                for (const block of message.message.content) {
+                                    if (block.type === 'text') {
+                                        if (!receivedIncrementalText && typeof block.text === 'string' && block.text.length > 0) {
+                                            finalText += block.text;
+                                            logger.info({
+                                                agent_id: agentId,
+                                                task_id: self.state.task_id,
+                                                output_excerpt: buildAssistantOutputExcerpt(block.text),
+                                            }, 'Task assistant output');
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        else if (message.type === 'stream_event') {
+                            const inner = message.event;
+                            if (inner.type === 'content_block_delta' && inner.delta?.type === 'text_delta') {
+                                if (typeof inner.delta.text === 'string' && inner.delta.text.length > 0) {
+                                    finalText += inner.delta.text;
+                                    receivedIncrementalText = true;
+                                }
+                            }
+                            else if (inner.type === 'content_block_delta' &&
+                                inner.delta?.type === 'thinking_delta' &&
+                                typeof inner.delta.thinking === 'string' &&
+                                inner.delta.thinking.length > 0) {
+                                receivedIncrementalReasoning = true;
+                            }
+                        }
+                        const normalizedOutputs = self.sessionManager.normalizeOutput({
+                            driverId: self.state.backend_driver_id,
+                            sessionId: self.state.session_id,
+                            turnId: sdkTurn.id,
+                            output: message,
+                        });
+                        if (normalizedOutputs.length > 0) {
+                            logger.debug({
+                                agent_id: agentId,
+                                task_id: self.state.task_id,
+                                normalized_output_count: normalizedOutputs.length,
+                                normalized_output_kinds: normalizedOutputs.map((entry) => entry.kind),
+                            }, 'Task normalized backend outputs');
+                        }
+                        if (normalizedOutputs.some((output) => output.kind === 'app-server-event')) {
+                            const normalizedText = appendNormalizedOutputToFinalText(normalizedOutputs, finalText);
+                            if (normalizedText.receivedText) {
+                                finalText = normalizedText.next;
+                                receivedIncrementalText = true;
+                            }
+                        }
+                        const completedReasoningSnapshotIdsWithPriorDeltas = new Set();
+                        for (const output of normalizedOutputs) {
+                            if (output.kind !== 'app-server-event')
+                                continue;
+                            const event = output.event;
+                            const params = event.params && typeof event.params === 'object'
+                                ? event.params
+                                : {};
+                            if (APP_SERVER_REASONING_DELTA_METHODS.has(event.method)) {
+                                const itemId = typeof params.itemId === 'string' ? params.itemId : '';
+                                if (itemId) {
+                                    appServerDeltaReasoningItemIds.add(itemId);
+                                }
+                                continue;
+                            }
+                            if (event.method === 'item/agentMessage/delta') {
+                                continue;
+                            }
+                            if (event.method !== 'item/completed')
+                                continue;
+                            const item = params.item && typeof params.item === 'object'
+                                ? params.item
+                                : {};
+                            const itemId = typeof item.id === 'string' ? item.id : '';
+                            if (item.type === 'reasoning' && itemId && appServerDeltaReasoningItemIds.has(itemId)) {
+                                completedReasoningSnapshotIdsWithPriorDeltas.add(itemId);
+                            }
+                        }
+                        const normalizedChunksBaseRaw = convertDriverOutputsToUiMessageChunks(normalizedOutputs, {
+                            commandOutputByItemId: appServerCommandOutputByItemId,
+                        });
+                        const normalizedChunksBase = normalizedChunksBaseRaw.filter((chunk) => {
+                            if (chunk.type === 'reasoning-delta' &&
+                                typeof chunk.id === 'string' &&
+                                completedReasoningSnapshotIdsWithPriorDeltas.has(chunk.id)) {
+                                return false;
+                            }
+                            return true;
+                        });
+                        const fallbackChunksBase = convertSdkEventToUiMessageChunks(message);
+                        const baseChunksSource = normalizedChunksBase.length > 0
+                            ? normalizedChunksBase
+                            : fallbackChunksBase;
+                        const hasAppServerAgentMessageEvent = normalizedOutputs.some((output) => output.kind === 'app-server-event');
+                        const baseChunks = baseChunksSource.filter((chunk) => {
+                            if (receivedIncrementalText &&
+                                hasAppServerAgentMessageEvent &&
+                                isAppServerAgentMessageDeltaChunk(chunk)) {
+                                return false;
+                            }
+                            if (receivedIncrementalText &&
+                                message.type === 'assistant' &&
+                                normalizedChunksBase.length === 0 &&
+                                chunk.type === 'text-delta') {
+                                return false;
+                            }
+                            if (receivedIncrementalReasoning &&
+                                message.type === 'assistant' &&
+                                (chunk.type === 'reasoning-start' ||
+                                    chunk.type === 'reasoning-delta' ||
+                                    chunk.type === 'reasoning-end')) {
+                                return false;
+                            }
+                            return true;
+                        });
+                        const chunks = enrichUiMessageChunksWithDocumentRefs(baseChunks, {
+                            agentId,
+                            workspaceRoot: artifacts.artifactRoot,
+                        });
+                        const emittedErrorChunk = chunks.some((chunk) => chunk.type === 'error');
+                        const uiErrorText = extractUiErrorText(chunks);
+                        if (uiErrorText && !streamError) {
+                            streamError = new Error(uiErrorText);
+                        }
+                        if (chunks.length > 0) {
+                            logger.debug({
+                                agent_id: agentId,
+                                task_id: self.state.task_id,
+                                output_excerpt: buildAssistantOutputExcerpt(serializeUiMessageChunks(chunks)?.trim() ?? ''),
+                            }, 'Task stream chunk');
+                            enqueueUiMessageChunks(chunks);
+                        }
+                        const terminalResultText = extractTerminalResultText(normalizedOutputs);
+                        if (terminalResultText && !finalText.trim()) {
+                            finalText = terminalResultText;
+                        }
+                        if (terminalResultText && !emittedTextToUi) {
+                            enqueueUiMessageChunks([
+                                { type: 'text-delta', id: '1', delta: terminalResultText },
+                            ]);
+                        }
+                        const terminalFailureText = extractTerminalFailureText(normalizedOutputs);
+                        if (terminalFailureText && !streamError) {
+                            streamError = new Error(terminalFailureText);
+                            clearSessionSdkId(self.state.agent_id, self.state.session_id);
+                            self.state.sdk_session_id = undefined;
+                        }
+                        if (message.type === 'result') {
+                            logger.info({
+                                agent_id: agentId,
+                                task_id: self.state.task_id,
+                                ...buildObservableToolDetail({
+                                    result: message.result ?? message,
+                                }),
+                            }, 'Task completed');
+                            if (message.subtype === 'success' &&
+                                typeof message.result === 'string' &&
+                                message.result.length > 0 &&
+                                !emittedTextToUi) {
+                                finalText = message.result;
+                                emittedTextToUi = true;
+                                enqueueUiMessageChunks([
+                                    { type: 'text-delta', id: '1', delta: message.result },
+                                ]);
+                            }
+                            if (message.subtype === 'success' && message.result) {
+                                // Background process, no need to await in stream loop
+                                self.consolidateMemory(paths.base, message.result).catch(err => {
+                                    logger.error({ err }, 'runNativeStream: memory consolidation failed');
+                                });
+                            }
+                            if (message.subtype !== 'success' && !streamError) {
+                                const resultText = typeof message.result === 'string' && message.result.trim()
+                                    ? message.result.trim()
+                                    : 'Agent turn failed before producing a result.';
+                                streamError = new Error(resultText);
+                            }
+                            if (!emittedErrorChunk) {
+                                finishUiMessage(message.subtype === 'success' ? 'stop' : 'error');
+                            }
+                            break;
+                        }
+                    }
+                    if (messageStarted) {
+                        if (!emittedTextToUi) {
+                            const errorText = streamError?.message || 'Agent stream ended before producing a visible response.';
+                            emitStreamError(errorText);
+                            streamError = streamError || new Error(errorText);
+                        }
+                        else {
+                            finishUiMessage('stop');
+                        }
+                    }
+                }
+                catch (err) {
+                    if (isAborted()) {
+                        logger.info({ agent_id: agentId, task_id: self.state.task_id }, 'runNativeStream: stream aborted');
+                        finishUiMessage('stop');
+                        return;
+                    }
+                    logger.error({ err, agent_id: taskId }, 'runNativeStream: error in stream');
+                    streamError = err instanceof Error ? err : new Error(String(err || 'Stream execution failed'));
+                    emitStreamError(streamError.message || 'Stream execution failed');
+                    await notifyStreamError(streamError);
+                }
+                finally {
+                    const wasAborted = isAborted();
+                    self.controller?.signal.removeEventListener('abort', abortSdkSession);
+                    self.state.status = 'idle';
+                    self.state.last_activity_at = Date.now();
+                    updateSessionStatus(self.state.agent_id, self.state.session_id, 'idle');
+                    await self.notifyState();
+                    self.controller = null;
+                    if (streamError && !wasAborted) {
+                        await notifyStreamError(streamError);
+                    }
+                    if (!streamError && !wasAborted) {
+                        try {
+                            if (finalText) {
+                                await self.events.onReply?.(finalText);
+                            }
+                        }
+                        catch (err) {
+                            logger.error({ err }, 'runNativeStream: onReply failed');
+                        }
+                        try {
+                            const usage = extractUsageTotals(await sdkSession?.getContextUsage?.());
+                            if (usage) {
+                                reportUsageToGateway(self.state.agent_id, self.state.session_id, usage.tokensIn, usage.tokensOut);
+                                try {
+                                    updateSessionUsage(self.state.agent_id, self.state.session_id, usage.tokensIn, usage.tokensOut);
+                                }
+                                catch {
+                                    appendGlobalUsage(self.state.agent_id, self.state.session_id, usage.tokensIn, usage.tokensOut);
+                                }
+                            }
+                        }
+                        catch (usageErr) {
+                            logger.warn({
+                                usageErr,
+                                message: usageErr instanceof Error ? usageErr.message : String(usageErr),
+                                stack: usageErr instanceof Error ? usageErr.stack : undefined,
+                                agent_id: self.state.agent_id,
+                                session_id: self.state.session_id,
+                            }, 'Failed to persist session usage after native stream run');
+                        }
+                        try {
+                            const taskFolderRemoved = cleanupTaskFolderWithoutMeaningfulArtifacts(self.state.session_id, self.state.task_id);
+                            if (taskFolderRemoved) {
+                                logger.info({
+                                    agent_id: self.state.agent_id,
+                                    session_id: self.state.session_id,
+                                    task_id: self.state.task_id,
+                                }, 'Removed completed task folder without meaningful artifacts');
+                            }
+                        }
+                        catch (cleanupErr) {
+                            logger.warn({
+                                cleanupErr,
+                                agent_id: self.state.agent_id,
+                                session_id: self.state.session_id,
+                                task_id: self.state.task_id,
+                            }, 'Failed to remove completed task folder without meaningful artifacts');
+                        }
+                    }
+                    sdkSession?.close?.();
+                    controller.close();
+                }
+            }
+        });
+    }
+    initBrain(baseDir, workspaceDir) {
+        if (!fs.existsSync(baseDir))
+            fs.mkdirSync(baseDir, { recursive: true });
+        if (!fs.existsSync(workspaceDir))
+            fs.mkdirSync(workspaceDir, { recursive: true });
+        const memoryDir = path.join(baseDir, 'memory');
+        if (!fs.existsSync(memoryDir))
+            fs.mkdirSync(memoryDir, { recursive: true });
+    }
+    preparePrompt(baseDir, artifacts) {
+        const automationContract = [
+            'Automation contract:',
+            'Use `create_automation` to create schedules, `update_automation` to edit/pause/resume, `list_my_automations` to inspect, and `delete_automation` to remove.',
+            'Do not call removed schedule tool names such as `CronCreate`.',
+            'If the user asks for a reminder phrase, infer an RRULE and pass `name`, `prompt`, `rrule`, and `timezone` to `create_automation`.',
+            'If the user asks to enable, resume, start, pause, disable, or change an automation, call `update_automation` with `id` and the right `status` or fields.',
+            'If scheduling details are ambiguous, ask one clarifying question before creating automation.',
+        ];
+        const parts = [
+            artifacts?.source === 'local_folder'
+                ? `You are ${ASSISTANT_NAME}. The current working directory is the selected task local folder.`
+                : `You are ${ASSISTANT_NAME}. The current working directory is the Supen task folder.`,
+            artifacts
+                ? 'Uploaded task files are already in this folder. Keep generated files here and create subfolders only when the task actually needs them.'
+                : `Use the configured Supen artifact workspace for generated files.`,
+            artifacts
+                ? 'When executing a skill, treat this task folder as the artifact workspace. Do not assume or create a standard skill folder structure unless the task or skill explicitly needs one.'
+                : 'When executing a skill, keep generated files in the configured Supen artifact workspace.',
+            artifacts
+                ? 'Durable knowledge roots are writable separately from this task folder; modify them only when the user explicitly asks for persistent knowledge, memory, skill, or plugin improvements.'
+                : `Do not write generated files into the knowledge/source workspace.`,
+            artifacts
+                ? 'Write generated and intermediate files in the current task folder unless the user or skill asks for a more specific path.'
+                : `Treat task inputs and knowledge/source files as read-only unless explicitly requested otherwise.`,
+            artifacts?.source === 'local_folder'
+                ? `Do not create, modify, or interact with files outside the selected local folder unless specifically requested by the user, WITH ONE EXCEPTION:`
+                : `Do not create, modify, or interact with files outside the current task folder unless specifically requested by the user, WITH ONE EXCEPTION:`,
+            `Your core persona, identity, and memory are permanently stored in Markdown files located in your mind directory: ${baseDir}`,
+            `Prefer relative paths from the current working directory over absolute paths in user-facing responses.`,
+            automationContract.join('\n'),
+        ];
+        // 1. Inject AGENT_MIND_FILES
+        for (const filename of AGENT_MIND_FILES) {
+            const p = path.join(baseDir, filename);
+            if (fs.existsSync(p)) {
+                const content = fs.readFileSync(p, 'utf-8').trim();
+                if (content)
+                    parts.push(`### ${filename}\n${content}`);
+            }
+        }
+        // 2. Inject Recent Chronological Journal
+        const memoryDir = path.join(baseDir, 'memory');
+        if (fs.existsSync(memoryDir)) {
+            const journals = fs
+                .readdirSync(memoryDir)
+                .filter((f) => f.endsWith('.md'))
+                .sort()
+                .slice(-RECENT_JOURNAL_COUNT);
+            if (journals.length > 0) {
+                parts.push('## Recent Journal (Chronological Memory)');
+                let remainingJournalChars = RECENT_JOURNAL_TOTAL_MAX_CHARS;
+                for (const j of journals) {
+                    if (remainingJournalChars <= 0)
+                        break;
+                    const raw = fs.readFileSync(path.join(memoryDir, j), 'utf-8').trim();
+                    if (!raw)
+                        continue;
+                    const perJournal = truncateText(raw, RECENT_JOURNAL_MAX_CHARS);
+                    const clipped = truncateText(perJournal, remainingJournalChars);
+                    if (!clipped)
+                        continue;
+                    parts.push(`### Date: ${j.replace('.md', '')}\n${clipped}`);
+                    remainingJournalChars -= clipped.length;
+                }
+            }
+        }
+        return parts.join('\n\n');
+    }
+    async consolidateMemory(baseDir, result) {
+        try {
+            if (!result || result.trim().length < 50)
+                return;
+            const now = new Date();
+            const today = now.toISOString().split('T')[0];
+            const journalPath = path.join(baseDir, 'memory', `${today}.md`);
+            const summaryPrompt = `Analyze the following task result and extract any new information worth remembering.
+Classify each fact into one of these categories:
+- [CORE]: Permanent facts about the user, project rules, or fundamental environment settings.
+- [JOURNAL]: Task-specific progress, transient context, or intermediate status updates.
+
+Format your output as a bulleted list:
+- [CATEGORY] Fact description...
+
+If nothing is worth remembering, output ONLY 'No new facts'.
+Result:
+${result}`;
+            const selectedModel = getAgentModelConfig(this.state.agent_id, true)[0];
+            const providerId = String(selectedModel?.provider_id || '').toLowerCase();
+            const gatewayToken = getLlmToken();
+            const configuredApiKey = process.env.ANTHROPIC_API_KEY ||
+                process.env.OPENROUTER_API_KEY ||
+                selectedModel?.api_key ||
+                '';
+            const isGatewayBackedProvider = providerId === 'supen' || providerId === 'babelark';
+            const llmToken = isGatewayBackedProvider
+                ? (gatewayToken || configuredApiKey)
+                : (configuredApiKey || gatewayToken);
+            const authSource = llmToken && llmToken === configuredApiKey
+                ? (process.env.ANTHROPIC_API_KEY
+                    ? 'env:ANTHROPIC_API_KEY'
+                    : process.env.OPENROUTER_API_KEY
+                        ? 'env:OPENROUTER_API_KEY'
+                        : selectedModel?.api_key
+                            ? 'model:api_key'
+                            : 'unknown')
+                : llmToken && llmToken === gatewayToken
+                    ? 'gateway:llm_token'
+                    : 'none';
+            const headers = {
+                'Content-Type': 'application/json',
+            };
+            if (llmToken) {
+                headers['Authorization'] = `Bearer ${llmToken}`;
+            }
+            let summary;
+            const modelForApiDetection = selectedModel
+                ? { ...selectedModel, api_key: llmToken || selectedModel.api_key }
+                : null;
+            if (usesAnthropicMessagesApi(modelForApiDetection)) {
+                const client = new Anthropic({
+                    apiKey: llmToken,
+                    baseURL: process.env.TEST_ANTHROPIC_BASE_URL || selectedModel?.base_url || undefined,
+                });
+                const response = await client.messages.create({
+                    model: selectedModel?.model || 'claude-3-5-sonnet-latest',
+                    max_tokens: 400,
+                    messages: [{ role: 'user', content: summaryPrompt }],
+                });
+                summary = response.content
+                    .filter((block) => block.type === 'text')
+                    .map((block) => block.text)
+                    .join('\n')
+                    .trim();
+            }
+            else {
+                const baseUrl = process.env.TEST_ANTHROPIC_BASE_URL ||
+                    selectedModel?.base_url ||
+                    'http://127.0.0.1:2755/api/llm/openrouter';
+                const endpoint = baseUrl.endsWith('/v1')
+                    ? `${baseUrl}/chat/completions`
+                    : `${baseUrl}/v1/chat/completions`;
+                const response = await fetch(endpoint, {
+                    method: 'POST',
+                    headers,
+                    body: JSON.stringify({
+                        model: selectedModel?.model || 'google/gemini-2.5-flash',
+                        messages: [{ role: 'user', content: summaryPrompt }],
+                    })
+                });
+                if (!response.ok) {
+                    throw new Error(`Failed to call LLM: ${response.status} ${response.statusText}`);
+                }
+                const data = await response.json();
+                summary = data.choices?.[0]?.message?.content?.trim();
+            }
+            if (summary && !summary.toLowerCase().includes('no new facts')) {
+                await this.memorySubsystem.writeEphemeral({
+                    scope: 'session',
+                    content: summary,
+                    tags: ['consolidated', 'task-result'],
+                });
+                const classification = classifySessionInsight({
+                    summary,
+                    successfulOutcomeCount: 0,
+                    repetitionCount: 0,
+                });
+                logger.info({ classification, agent_id: this.state.agent_id }, 'Classified extracted session insight');
+                const entry = `\n- [${now.toISOString()}] Task: ${this.state.task_id}\n  Facts: ${summary.replace(/\n/g, '\n    ')}\n`;
+                fs.mkdirSync(path.dirname(journalPath), { recursive: true });
+                fs.appendFileSync(journalPath, entry, 'utf-8');
+                if (summary.includes('[CORE]')) {
+                    const coreFacts = summary
+                        .split('\n')
+                        .filter((line) => line.includes('[CORE]'))
+                        .map((line) => line.replace(/^-?\s*\[CORE\]/, '').trim())
+                        .filter(Boolean)
+                        .join('\n');
+                    if (coreFacts) {
+                        const durable = await this.memorySubsystem.requestDurableWrite({
+                            scope: 'agent',
+                            content: coreFacts,
+                            tags: ['core-candidate'],
+                        });
+                        if (durable.status === 'denied') {
+                            logger.info({ agent_id: this.state.agent_id }, 'Durable memory write candidate requires explicit approval; skipped automatic escalation');
+                        }
+                    }
+                }
+            }
+        }
+        catch (err) {
+            const selectedModel = getAgentModelConfig(this.state.agent_id, true)[0];
+            const providerId = String(selectedModel?.provider_id || '').toLowerCase();
+            const gatewayToken = getLlmToken();
+            const configuredApiKey = process.env.ANTHROPIC_API_KEY ||
+                process.env.OPENROUTER_API_KEY ||
+                selectedModel?.api_key ||
+                '';
+            const isGatewayBackedProvider = providerId === 'supen' || providerId === 'babelark';
+            const llmToken = isGatewayBackedProvider
+                ? (gatewayToken || configuredApiKey)
+                : (configuredApiKey || gatewayToken);
+            const authSource = llmToken && llmToken === configuredApiKey
+                ? (process.env.ANTHROPIC_API_KEY
+                    ? 'env:ANTHROPIC_API_KEY'
+                    : process.env.OPENROUTER_API_KEY
+                        ? 'env:OPENROUTER_API_KEY'
+                        : selectedModel?.api_key
+                            ? 'model:api_key'
+                            : 'unknown')
+                : llmToken && llmToken === gatewayToken
+                    ? 'gateway:llm_token'
+                    : 'none';
+            logger.warn({
+                err: err.message,
+                agent_id: this.state.agent_id,
+                model_id: selectedModel?.id,
+                model_provider: selectedModel?.provider_id,
+                model_name: selectedModel?.model,
+                auth_source: authSource,
+                has_auth_token: Boolean(llmToken),
+            }, 'Failed to consolidate memory');
+        }
+    }
+    async notifyState() {
+        if (this.events.onStateChange)
+            await this.events.onStateChange(this.getState());
+    }
+    async escalateToCoreMemory(baseDir, newFacts) {
+        const memoryPath = path.join(baseDir, 'MEMORY.md');
+        try {
+            const currentMemory = fs.existsSync(memoryPath) ? fs.readFileSync(memoryPath, 'utf-8') : '';
+            const updatedContent = currentMemory + '\n' + newFacts;
+            fs.writeFileSync(memoryPath, updatedContent, 'utf-8');
+        }
+        catch (err) {
+            logger.warn({ err: err.message }, 'Failed to escalate facts');
+        }
+    }
+}
+//# sourceMappingURL=cortex.js.map