@marifold/core 0.60.0

package/dist/runtime/MarifoldRuntime.js

@@ -0,0 +1,1099 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarifoldRuntime = void 0;
+const core_1 = require("@priest-ai/core");
+const path = __importStar(require("path"));
+const AgentRunner_1 = require("../agent/AgentRunner");
+const AgentHistory_1 = require("../agent/AgentHistory");
+const ApprovalPolicy_1 = require("../agent/ApprovalPolicy");
+const DelegateTool_1 = require("../agent/tools/DelegateTool");
+const PythonPackageTool_1 = require("../agent/tools/PythonPackageTool");
+const ReadFileTool_1 = require("../agent/tools/ReadFileTool");
+const ShellExecTool_1 = require("../agent/tools/ShellExecTool");
+const WebSearchTool_1 = require("../agent/tools/WebSearchTool");
+const AskUserTool_1 = require("../agent/tools/AskUserTool");
+const InspectAttachmentTool_1 = require("../agent/tools/InspectAttachmentTool");
+const WriteFileTool_1 = require("../agent/tools/WriteFileTool");
+const ToolRegistry_1 = require("../agent/ToolRegistry");
+const ChatGptTokenRefresh_1 = require("../config/ChatGptTokenRefresh");
+const XaiTokenRefresh_1 = require("../config/XaiTokenRefresh");
+const ConfigManager_1 = require("../config/ConfigManager");
+const ConfigSchema_1 = require("../config/ConfigSchema");
+const ProviderInspector_1 = require("../config/ProviderInspector");
+const GitHubCopilotAuth_1 = require("../config/GitHubCopilotAuth");
+const createSearchBackend_1 = require("../search/createSearchBackend");
+const SearchBackend_1 = require("../search/SearchBackend");
+const ProviderFactory_1 = require("../config/ProviderFactory");
+const ProviderRegistry_1 = require("../config/ProviderRegistry");
+const MarifoldError_1 = require("../errors/MarifoldError");
+const ImageOptimizer_1 = require("../images/ImageOptimizer");
+const MemoryStore_1 = require("../memory/MemoryStore");
+const MemoryControls_1 = require("../memory/MemoryControls");
+const ProfileResolver_1 = require("../profiles/ProfileResolver");
+const ProfileManager_1 = require("../profiles/ProfileManager");
+const Scheduler_1 = require("../schedule/Scheduler");
+const RunRegistry_1 = require("../runs/RunRegistry");
+const TelegramBridge_1 = require("../channels/TelegramBridge");
+const ScheduleStore_1 = require("../schedule/ScheduleStore");
+const SessionResolver_1 = require("../sessions/SessionResolver");
+const SkillStore_1 = require("../skill/SkillStore");
+const SkillInvocation_1 = require("../skill/SkillInvocation");
+const BuiltInSkillManager_1 = require("../skill/BuiltInSkillManager");
+const AppStore_1 = require("../app/AppStore");
+const SkillAppResolver_1 = require("../app/SkillAppResolver");
+const SkillAppInstanceRegistry_1 = require("../app/SkillAppInstanceRegistry");
+const TaskStore_1 = require("../tasks/TaskStore");
+const WorkspacePaths_1 = require("../workspace/WorkspacePaths");
+// Older OpenAI-compatible gateways still take a raw `{think}` body option.
+// Priest 2.8 owns neutral reasoning for Ollama, Anthropic, and Responses.
+const LEGACY_THINK_PROVIDER_NAMES = new Set(['bailian', 'alibaba_cloud']);
+const CHAT_TOOL_MAX_ITERATIONS = 3;
+const EDIT_HISTORY_BUDGET_DEFAULT_CHARS = 16_000;
+class MarifoldRuntime {
+    options;
+    profileResolver;
+    profileManager;
+    sessionResolver;
+    providerFactory;
+    memoryStore;
+    taskStore;
+    searchBackend;
+    scheduleStore;
+    constructor(options) {
+        this.options = options;
+        const { config, configPath } = options.loadedConfig;
+        this.profileResolver = new ProfileResolver_1.ProfileResolver(config.paths.profilesDir);
+        this.profileManager = new ProfileManager_1.ProfileManager(config.paths.profilesDir);
+        this.sessionResolver = new SessionResolver_1.SessionResolver(config.paths.sessionsDb);
+        this.providerFactory = new ProviderFactory_1.ProviderFactory(config, configPath);
+        this.memoryStore = new MemoryStore_1.MemoryStore(config.paths.profilesDir);
+        this.taskStore = new TaskStore_1.TaskStore(config.paths.tasksDir);
+        this.searchBackend = options.searchBackend
+            ?? (0, createSearchBackend_1.createSearchBackend)((0, ConfigSchema_1.resolveWebSearchConfig)(config.webSearch));
+        this.scheduleStore = new ScheduleStore_1.ScheduleStore(config.paths.schedulesDir ?? (0, WorkspacePaths_1.defaultSchedulesDir)());
+    }
+    resolveSettings(request) {
+        const { config, configPath } = this.options.loadedConfig;
+        const profile = request.profile ?? config.default.profile;
+        const profileSettings = this.profileResolver.loadSettings(profile);
+        const provider = request.provider ?? profileSettings.provider ?? config.default.provider;
+        const model = request.model ?? profileSettings.model ?? config.default.model;
+        const think = request.think ?? profileSettings.think ?? config.default.think;
+        const mode = profileSettings.mode ?? 'agent';
+        if (!provider || !model)
+            throw MarifoldError_1.MarifoldError.missingProviderModel(configPath);
+        return {
+            profile, provider, model, think, mode,
+            maxContextTokens: request.maxContextTokens ?? profileSettings.maxContextTokens,
+            sessionContextTurns: profileSettings.sessionContextTurns,
+        };
+    }
+    async ask(request) {
+        const startedAtMs = Date.now();
+        const startedAt = new Date(startedAtMs).toISOString();
+        const settings = this.resolveSettings(request);
+        const preparedImages = await (0, ImageOptimizer_1.prepareImageInputs)(request.images, { optimize: request.originalImages !== true });
+        await this.refreshProviderCredentialsIfNeeded(settings.provider);
+        const replacing = request.replaceUserTurnIndex !== undefined;
+        const isolated = request.isolated === true;
+        const engine = this.createEngine(settings.provider, Boolean(request.sessionId) && !replacing && !isolated, request.profileContext !== false);
+        const memoryOn = this.memoryEnabled(settings.profile, request.memories);
+        const memory = this.memoryForRequest(settings.profile, request.memories, request.prompt, settings.think);
+        const response = await engine.run({
+            config: this.toPriestConfig(settings),
+            profile: settings.profile,
+            prompt: request.prompt,
+            session: request.sessionId && !replacing && !isolated
+                ? { id: request.sessionId, createIfMissing: true }
+                : undefined,
+            context: [
+                ...this.runtimeContext(memory, request.prompt, memoryOn),
+                ...this.editHistoryContext(request, settings),
+                ...(request.instructions ?? []),
+            ],
+            memory,
+            images: preparedImages.images.length > 0 ? preparedImages.images : undefined,
+            userContext: request.userContext,
+        });
+        const stripped = (0, MemoryControls_1.stripMemoryControls)(response.text ?? '');
+        const userTurn = request.userTurn ?? request.prompt;
+        const responseMetrics = completedResponseMetrics('chat', settings, startedAt, startedAtMs, response.usage);
+        if (response.ok && request.sessionId) {
+            if (request.replaceUserTurnIndex !== undefined) {
+                this.replaceEditedExchange(request.sessionId, request.replaceUserTurnIndex, userTurn, stripped.text, preparedImages.images, responseMetrics);
+            }
+            else if (isolated) {
+                await this.sessionResolver.appendExchange(request.sessionId, settings.profile, userTurn, stripped.text, preparedImages.images, responseMetrics);
+            }
+            else {
+                if (request.userTurn)
+                    this.sessionResolver.replaceLastUserTurn(request.sessionId, request.userTurn);
+                this.sessionResolver.replaceLastAssistantTurn(request.sessionId, stripped.text);
+                this.sessionResolver.saveLastUserTurnAttachments(request.sessionId, preparedImages.images);
+                this.sessionResolver.saveLastResponseMetrics(request.sessionId, responseMetrics);
+            }
+        }
+        if (response.ok && memoryOn) {
+            this.applyTurnMemory(settings.profile, request.prompt, stripped, request.sessionId);
+        }
+        return {
+            ok: response.ok,
+            text: stripped.text,
+            settings,
+            latencyMs: response.ok ? responseMetrics.latencyMs : response.execution.latencyMs,
+            session: response.session,
+            error: response.error ? { code: response.error.code, message: response.error.message } : undefined,
+        };
+    }
+    async *stream(request, onComplete, onReasoningSummary) {
+        const startedAtMs = Date.now();
+        const startedAt = new Date(startedAtMs).toISOString();
+        const settings = this.resolveSettings(request);
+        const preparedImages = await (0, ImageOptimizer_1.prepareImageInputs)(request.images, { optimize: request.originalImages !== true });
+        await this.refreshProviderCredentialsIfNeeded(settings.provider);
+        let aggregateUsage;
+        const replacing = request.replaceUserTurnIndex !== undefined;
+        const isolated = request.isolated === true;
+        const enginePersistsSession = Boolean(request.sessionId) && !replacing && !isolated;
+        const sessionWasMissing = enginePersistsSession
+            ? this.sessionResolver.get(request.sessionId) === undefined
+            : false;
+        const engine = this.createEngine(settings.provider, enginePersistsSession, request.profileContext !== false);
+        const memoryOn = this.memoryEnabled(settings.profile, request.memories);
+        const memory = this.memoryForRequest(settings.profile, request.memories, request.prompt, settings.think);
+        const chatTools = this.chatTools(request);
+        const baseRequest = {
+            config: this.toPriestConfig(settings),
+            profile: settings.profile,
+            prompt: request.prompt,
+            session: request.sessionId && !replacing && !isolated
+                ? { id: request.sessionId, createIfMissing: true }
+                : undefined,
+            context: [
+                ...this.runtimeContext(memory, request.prompt, memoryOn),
+                ...this.editHistoryContext(request, settings),
+                ...(request.instructions ?? []),
+            ],
+            memory,
+            images: preparedImages.images.length > 0 ? preparedImages.images : undefined,
+            userContext: request.userContext,
+        };
+        // Model-initiated tool loop (web_search/read_file) when [web_search].enabled.
+        // Intermediate tool-call turns are turn-local; the engine persists the
+        // session only on the loop's final response, and memory payloads are
+        // applied only from that final response.
+        const exchange = [];
+        const maxIterations = chatTools ? CHAT_TOOL_MAX_ITERATIONS : 1;
+        for (let iteration = 0; iteration < maxIterations; iteration += 1) {
+            const stripper = new MemoryControls_1.MemoryControlStripper();
+            const visibleParts = [];
+            let done;
+            const lastIteration = iteration === maxIterations - 1;
+            for await (const event of engine.streamEvents({
+                ...baseRequest,
+                ...(chatTools && !lastIteration ? { tools: chatTools.definitions } : {}),
+                ...(exchange.length > 0 ? { toolExchange: exchange } : {}),
+            }, request.signal ? { signal: request.signal } : undefined)) {
+                if (event.type === 'text_delta') {
+                    const visible = stripper.feed(event.text);
+                    if (visible) {
+                        visibleParts.push(visible);
+                        yield visible;
+                    }
+                }
+                else if (event.type === 'reasoning_summary_delta') {
+                    onReasoningSummary?.(event.text);
+                }
+                else if (event.type === 'done') {
+                    done = event.response;
+                }
+            }
+            const tail = stripper.flush();
+            if (tail) {
+                visibleParts.push(tail);
+                yield tail;
+            }
+            aggregateUsage = sumUsage(aggregateUsage, done?.usage);
+            if (done?.error) {
+                this.discardFailedNewSession(request.sessionId, sessionWasMissing);
+                throw MarifoldError_1.MarifoldError.providerError(done.error.message, settings.provider, settings.model, done.error.code);
+            }
+            const toolCalls = done?.toolCalls ?? [];
+            if (!chatTools || toolCalls.length === 0) {
+                const streamedText = visibleParts.join('');
+                const fallbackControls = streamedText.length === 0
+                    ? (0, MemoryControls_1.stripMemoryControls)(done?.text ?? '')
+                    : undefined;
+                const finalText = streamedText || fallbackControls?.text || '';
+                if (done?.text === undefined && finalText.length === 0) {
+                    this.discardFailedNewSession(request.sessionId, sessionWasMissing);
+                    throw MarifoldError_1.MarifoldError.providerError(`Provider '${settings.provider}' returned no text for model '${settings.model}'.`, settings.provider, settings.model, 'EMPTY_RESPONSE');
+                }
+                if (streamedText.length === 0 && finalText)
+                    yield finalText;
+                const userTurn = request.userTurn ?? request.prompt;
+                const responseMetrics = completedResponseMetrics('chat', settings, startedAt, startedAtMs, aggregateUsage);
+                if (request.sessionId) {
+                    if (request.replaceUserTurnIndex !== undefined) {
+                        this.replaceEditedExchange(request.sessionId, request.replaceUserTurnIndex, userTurn, finalText, preparedImages.images, responseMetrics);
+                    }
+                    else if (isolated) {
+                        await this.sessionResolver.appendExchange(request.sessionId, settings.profile, userTurn, finalText, preparedImages.images, responseMetrics);
+                    }
+                    else {
+                        if (request.userTurn)
+                            this.sessionResolver.replaceLastUserTurn(request.sessionId, request.userTurn);
+                        this.sessionResolver.replaceLastAssistantTurn(request.sessionId, finalText);
+                        this.sessionResolver.saveLastUserTurnAttachments(request.sessionId, preparedImages.images);
+                        this.sessionResolver.saveLastResponseMetrics(request.sessionId, responseMetrics);
+                    }
+                }
+                if (memoryOn) {
+                    this.applyTurnMemory(settings.profile, request.prompt, fallbackControls ?? stripper, request.sessionId);
+                }
+                onComplete?.({ usage: aggregateUsage, latencyMs: responseMetrics.latencyMs });
+                return;
+            }
+            exchange.push({
+                kind: 'assistant',
+                text: done?.text,
+                toolCalls,
+                ...(done?.reasoning ? { reasoning: done.reasoning } : {}),
+            });
+            for (const call of toolCalls) {
+                const result = await chatTools.execute(call.name, call.arguments);
+                exchange.push({
+                    kind: 'tool_result',
+                    toolCallId: call.id,
+                    name: call.name,
+                    content: result.content,
+                    isError: result.isError,
+                });
+            }
+        }
+    }
+    /** Run the web search backend directly (the /search chat command). */
+    async searchWeb(query, maxResults) {
+        const config = (0, ConfigSchema_1.resolveWebSearchConfig)(this.options.loadedConfig.config.webSearch);
+        const results = await this.searchBackend.search(query, maxResults ?? config.maxResults);
+        return (0, SearchBackend_1.formatSearchResults)(query, results);
+    }
+    rememberMemory(profile, kind, text, sessionId) {
+        return this.memoryStore.remember(profile, kind, text, { sessionId });
+    }
+    forgetMemories(profile, query) {
+        return this.memoryStore.forget(profile, query);
+    }
+    deleteMemories(profile, query) {
+        return this.memoryStore.delete(profile, query);
+    }
+    listMemories(profile, includeSuperseded = false) {
+        const entries = this.memoryStore.listEntries(profile);
+        return includeSuperseded ? entries : entries.filter(entry => entry.status === 'active');
+    }
+    ensureProfileMemoryFiles(profile) {
+        this.profileResolver.load(profile);
+        return this.memoryStore.ensureProfile(profile);
+    }
+    memoryEnabled(profile, requestMemories = true) {
+        return requestMemories && this.profileResolver.loadSettings(profile).memories;
+    }
+    listProfiles() {
+        const activity = new Map(this.sessionResolver.profileActivity().map(item => [item.profileName, item]));
+        return this.profileResolver.list()
+            .map(profile => {
+            const recent = activity.get(profile.name);
+            return recent ? {
+                ...profile,
+                ...(recent.pinned ? { pinned: true } : {}),
+                ...(recent.updatedAt ? { updatedAt: recent.updatedAt } : {}),
+                ...(recent.preview ? { preview: recent.preview } : {}),
+            } : profile;
+        })
+            .sort((a, b) => {
+            const pinOrder = Number(Boolean(b.pinned)) - Number(Boolean(a.pinned));
+            if (pinOrder !== 0)
+                return pinOrder;
+            const activityOrder = (b.updatedAt ?? '').localeCompare(a.updatedAt ?? '');
+            return activityOrder !== 0 ? activityOrder : a.name.localeCompare(b.name);
+        });
+    }
+    getProfile(name) {
+        return this.profileResolver.detail(name);
+    }
+    setProfilePinned(name, pinned) {
+        this.getProfile(name);
+        this.sessionResolver.setProfilePinned(name, pinned);
+        return this.listProfiles();
+    }
+    /** Persist (or clear) a profile's human-readable label. */
+    setProfileDisplayName(name, displayName) {
+        this.profileManager.setDisplayName(name, displayName);
+    }
+    /** Persist a profile's default TUI mode to its profile.toml. Returns the
+     * mode that was written. */
+    setProfileMode(name, mode) {
+        return this.profileManager.setMode(name, mode).mode;
+    }
+    /** Persist (or clear) a profile's conversation-context budget in profile.toml. */
+    setProfileMaxContextTokens(name, tokens) {
+        return this.profileManager.setMaxContextTokens(name, tokens).maxContextTokens;
+    }
+    /** Persist a per-profile approval decision into the profile's profile.toml
+     * `[agent.approval]` (e.g. the TUI's "always allow"). `undefined` clears the
+     * override so the kind inherits the global default again. */
+    setProfileAgentApproval(name, kind, mode) {
+        this.profileManager.setAgentApproval(name, kind, mode);
+    }
+    /** Add a trusted folder capability to a profile. External folders still
+     * require approval per action. Returns the resolved absolute folder. */
+    addProfileTrustedFolder(name, folder) {
+        return this.profileManager.addTrustedFolder(name, folder).folder;
+    }
+    /** Remove a trusted folder from a profile. Returns whether it was present. */
+    removeProfileTrustedFolder(name, folder) {
+        return this.profileManager.removeTrustedFolder(name, folder).removed;
+    }
+    /** Set (or clear with both undefined) a profile's provider/model override. */
+    setProfileModelOverride(name, provider, model) {
+        if (provider === undefined && model === undefined) {
+            this.profileManager.clearModelOverride(name);
+            return;
+        }
+        if (!provider || !model) {
+            throw MarifoldError_1.MarifoldError.profileInvalid('Profile model overrides require both provider and model (or neither to clear).', name);
+        }
+        this.profileManager.setModelOverride(name, provider, model);
+    }
+    /** Persist (or clear) whether a profile loads its memory. */
+    setProfileMemories(name, memories) {
+        this.profileManager.setMemories(name, memories);
+    }
+    /** Persist (or clear) a profile's thinking-mode default. */
+    setProfileThink(name, think) {
+        this.profileManager.setThink(name, think);
+    }
+    /** Persist a profile's recent-turn window ('all'/undefined clears the key). */
+    setProfileSessionContextTurns(name, turns) {
+        this.profileManager.setSessionContextTurns(name, turns);
+    }
+    /** Overwrite one of a profile's markdown files (PROFILE/RULES/CUSTOM.md). */
+    writeProfileFile(name, file, content) {
+        this.profileManager.writeProfileFile(name, file, content);
+    }
+    /** Scaffold a new profile directory (same layout as `profile init`) and
+     * return its detail. Duplicate or invalid names throw PROFILE_INVALID. */
+    initProfile(name) {
+        this.profileManager.init(name);
+        return this.getProfile(name);
+    }
+    /** Delete stored profile files while retaining session history. The current
+     * configured default must be changed first, matching the CLI guard. */
+    deleteProfile(name) {
+        if (this.options.loadedConfig.config.default.profile === name) {
+            throw MarifoldError_1.MarifoldError.profileInvalid(`Cannot delete the current default profile '${name}'. Set another default profile first.`, name);
+        }
+        this.profileManager.delete(name);
+        this.sessionResolver.deleteProfileDisplay(name);
+    }
+    /** The profile's stored avatar image (path + media type), if any. */
+    getProfileAvatar(name) {
+        return this.profileManager.avatar(name);
+    }
+    /** Store a profile's avatar (PNG/JPEG/WebP, ≤1 MB), replacing any previous one. */
+    setProfileAvatar(name, image, mediaType) {
+        this.profileManager.setAvatar(name, image, mediaType);
+    }
+    /** Remove a profile's avatar. Returns whether one existed. */
+    deleteProfileAvatar(name) {
+        return this.profileManager.deleteAvatar(name).removed;
+    }
+    /** Set a config value by dotted key and persist — the same routing and
+     * validation as the CLI's `config set` (see ConfigManager.setValue). */
+    setConfigValue(key, value) {
+        new ConfigManager_1.ConfigManager(this.options.loadedConfig).setValue(key, value);
+    }
+    /** Read a config value by dotted key (CLI `config get`). */
+    getConfigValue(key) {
+        return new ConfigManager_1.ConfigManager(this.options.loadedConfig).getValue(key);
+    }
+    /** Reachability + sanitized config for every provider (CLI `provider status`). */
+    providerStatus() {
+        return new ProviderInspector_1.ProviderInspector(this.options.loadedConfig).status();
+    }
+    /** Models a provider actually serves right now (CLI `model list --live`). */
+    listProviderModels(provider) {
+        return new ProviderInspector_1.ProviderInspector(this.options.loadedConfig).listModels(provider);
+    }
+    /** Add a saved provider/model option (creating/updating the provider entry;
+     * secrets are not part of this surface — CLI/file only). */
+    addModelOption(provider, model, options = {}) {
+        new ConfigManager_1.ConfigManager(this.options.loadedConfig).addModel(provider, model, options);
+    }
+    /** Remove a saved provider/model option. Returns whether it was present and
+     * whether it was the current default (left untouched either way). */
+    removeModelOption(provider, model) {
+        const result = new ConfigManager_1.ConfigManager(this.options.loadedConfig).removeModel(provider, model);
+        return { removed: result.removed, wasDefault: result.wasDefault };
+    }
+    /** Remove local provider configuration and model options. Profile overrides
+     * are guarded here because they live outside the global config file. */
+    removeProvider(provider) {
+        const profileNames = this.listProfiles()
+            .filter(profile => this.getProfile(profile.name).settings.provider === provider)
+            .map(profile => profile.name);
+        if (profileNames.length > 0) {
+            throw MarifoldError_1.MarifoldError.configInvalid(`Cannot remove provider '${provider}' because ${profileNames.length === 1 ? 'profile' : 'profiles'} `
+                + `${profileNames.map(name => `'${name}'`).join(', ')} use it. Clear those model overrides first.`);
+        }
+        const result = new ConfigManager_1.ConfigManager(this.options.loadedConfig).removeProvider(provider);
+        return { removed: result.removed, removedModels: result.removedModels };
+    }
+    /** Set the global default provider/model (also registers the option). */
+    setDefaultModel(provider, model) {
+        new ConfigManager_1.ConfigManager(this.options.loadedConfig).setDefaultModel(model, provider);
+    }
+    /** Supersede exactly one memory entry by id (per-row Forget — recoverable). */
+    forgetMemoryById(profile, id) {
+        return this.memoryStore.forgetById(profile, id);
+    }
+    /** Permanently remove exactly one memory entry by id (per-row Delete). */
+    deleteMemoryById(profile, id) {
+        return this.memoryStore.deleteById(profile, id);
+    }
+    /** Manually compact a session now (the /compact command). Returns whether anything was folded. */
+    async compactSession(sessionId, request) {
+        const settings = this.resolveSettings(request);
+        await this.refreshProviderCredentialsIfNeeded(settings.provider);
+        const engine = this.createEngine(settings.provider, true);
+        const result = await engine.compactSession(sessionId, this.toPriestConfig(settings));
+        return { compacted: result.compacted };
+    }
+    listSessions(limit, profileName, options) {
+        return this.sessionResolver.list(limit, profileName, options);
+    }
+    /** Read-only integrity check of the session DB (for `marifold doctor`). Never throws. */
+    checkSessionDb() {
+        return this.sessionResolver.checkIntegrity();
+    }
+    /** Filesystem path of the session DB, for diagnostics. */
+    get sessionDbPath() {
+        return this.options.loadedConfig.config.paths.sessionsDb;
+    }
+    latestSession(profileName) {
+        return this.sessionResolver.latest(profileName);
+    }
+    getSession(sessionId) {
+        return this.sessionResolver.get(sessionId);
+    }
+    getSessionAttachment(sessionId, userTurnIndex, attachmentIndex) {
+        return this.sessionResolver.getAttachment(sessionId, userTurnIndex, attachmentIndex);
+    }
+    deleteSession(sessionId) {
+        return this.sessionResolver.delete(sessionId);
+    }
+    updateSessionDisplay(sessionId, update) {
+        return this.sessionResolver.updateDisplay(sessionId, update);
+    }
+    truncateSessionFromUserTurn(sessionId, userTurnIndex) {
+        return this.sessionResolver.truncateFromUserTurn(sessionId, userTurnIndex);
+    }
+    clearSessions(options = {}) {
+        return this.sessionResolver.clear(options);
+    }
+    renameSession(fromSessionId, toSessionId) {
+        return this.sessionResolver.rename(fromSessionId, toSessionId);
+    }
+    /**
+     * Build an approval-aware agent runner over this runtime's engine wiring,
+     * TaskStore, and config policy. Pass a custom registry to replace the
+     * default file/shell/delegate tool set.
+     */
+    /**
+     * Effective agent config for a profile: the global `[agent]` with the
+     * profile's `[agent]` overrides (profile.toml) merged on top. Unset profile
+     * keys inherit global/defaults; `undefined` profile → global only.
+     */
+    resolveAgentConfigForProfile(profile) {
+        const global = (0, ApprovalPolicy_1.resolveAgentConfig)(this.options.loadedConfig.config.agent);
+        const name = profile ?? this.options.loadedConfig.config.default.profile;
+        const override = this.profileResolver.loadSettings(name).agent;
+        if (!override)
+            return global;
+        const unattended = { ...(global.unattended ?? {}), ...(override.unattended ?? {}) };
+        return {
+            approval: { ...global.approval, ...(override.approval ?? {}) },
+            ...(Object.keys(unattended).length > 0 ? { unattended } : {}),
+            // Trusted folders are additive: a profile adds to any global ones.
+            trustedFolders: [...new Set([...global.trustedFolders, ...(override.trustedFolders ?? [])])],
+            maxIterations: override.maxIterations ?? global.maxIterations,
+            toolOutputLimit: override.toolOutputLimit ?? global.toolOutputLimit,
+            toolMode: override.toolMode ?? global.toolMode,
+        };
+    }
+    createAgentRunner(profile, registry) {
+        return new AgentRunner_1.AgentRunner({
+            taskStore: this.taskStore,
+            registry: registry ?? this.createDefaultToolRegistry(profile),
+            agentConfig: this.resolveAgentConfigForProfile(profile),
+            resolveSettings: request => this.resolveSettings(request),
+            prepareEngine: async (settings) => {
+                await this.refreshProviderCredentialsIfNeeded(settings.provider);
+                return {
+                    // No engine-level session store: priest would otherwise persist the
+                    // raw per-iteration `Objective:`/tool framing (and duplicates). The
+                    // runner instead persists one clean turn pair via `persistTurn` below.
+                    engine: this.createEngine(settings.provider, false),
+                    config: this.toPriestConfig(settings),
+                };
+            },
+            prepareImages: async (images, optimize) => (await (0, ImageOptimizer_1.prepareImageInputs)(images, { optimize })).images,
+            // Record the run as a single tidy user→assistant exchange so resuming the
+            // session shows the result, not the agent's internal framing.
+            persistTurn: async (sessionId, profile, userText, assistantText, images, replaceUserTurnIndex, responseMetrics) => {
+                if (replaceUserTurnIndex !== undefined) {
+                    this.replaceEditedExchange(sessionId, replaceUserTurnIndex, userText, assistantText, images, responseMetrics);
+                    return;
+                }
+                await this.sessionResolver.appendExchange(sessionId, profile, userText, assistantText, images, responseMetrics);
+            },
+            // Bounded cross-objective memory for non-lean tasks: replay the clean
+            // pairs (objective → answer) that persistTurn wrote, never raw framing.
+            loadRecentTurns: (sessionId, beforeUserTurnIndex) => (beforeUserTurnIndex === undefined
+                ? (this.sessionResolver.get(sessionId)?.turns ?? [])
+                : (this.sessionResolver.turnsBeforeUserTurn(sessionId, beforeUserTurnIndex)
+                    ?? this.missingEditedTurn(sessionId, beforeUserTurnIndex)))
+                .filter(t => t.role === 'user' || t.role === 'assistant')
+                .map(t => ({ role: t.role, content: t.content })),
+            resolveBuiltInInstructions: (objective, resolvedProfile) => {
+                if (!(0, BuiltInSkillManager_1.mentionsSkills)(objective))
+                    return [];
+                const { config } = this.options.loadedConfig;
+                return [(0, BuiltInSkillManager_1.buildSkillManagerGuide)({
+                        profile: resolvedProfile,
+                        profilesDir: config.paths.profilesDir,
+                        globalSkillsDir: config.paths.skillsDir ?? (0, WorkspacePaths_1.defaultSkillsDir)(),
+                    })];
+            },
+            resolveReadOnlyFolders: resolvedProfile => {
+                const { config } = this.options.loadedConfig;
+                return [
+                    path.join(config.paths.profilesDir, resolvedProfile, 'skills'),
+                    config.paths.skillsDir ?? (0, WorkspacePaths_1.defaultSkillsDir)(),
+                ];
+            },
+        });
+    }
+    createDefaultToolRegistry(profile) {
+        const registry = new ToolRegistry_1.ToolRegistry();
+        registry.register(new AskUserTool_1.AskUserTool());
+        registry.register(new InspectAttachmentTool_1.InspectAttachmentTool());
+        registry.register(new ReadFileTool_1.ReadFileTool());
+        registry.register(new WriteFileTool_1.WriteFileTool());
+        registry.register(new ShellExecTool_1.ShellExecTool());
+        registry.register(new PythonPackageTool_1.PythonPackageTool());
+        // web_search joins the agent's toolset when search is enabled and the
+        // network isn't denied — so the model can look things up on its own.
+        const webSearch = (0, ConfigSchema_1.resolveWebSearchConfig)(this.options.loadedConfig.config.webSearch);
+        const approval = this.resolveAgentConfigForProfile(profile).approval;
+        if (webSearch.enabled && approval.network !== 'deny') {
+            registry.register(new WebSearchTool_1.WebSearchTool(this.searchBackend, webSearch.maxResults));
+        }
+        registry.register(new DelegateTool_1.DelegateTool({
+            ask: async (request) => {
+                const response = await this.ask({ prompt: request.prompt, profile: request.profile });
+                return { ok: response.ok, text: response.text, error: response.error };
+            },
+            listProfileNames: () => this.profileResolver.list().map(profile => profile.name),
+        }));
+        return registry;
+    }
+    /**
+     * Skill store over the shared skills dir ([paths].skills_dir) and the given
+     * profile's skills/ dir (profile skills shadow global ones). Defaults to the
+     * configured default profile.
+     */
+    createSkillStore(profile) {
+        const { config } = this.options.loadedConfig;
+        const resolvedProfile = profile ?? config.default.profile;
+        return new SkillStore_1.SkillStore({
+            globalDir: config.paths.skillsDir ?? (0, WorkspacePaths_1.defaultSkillsDir)(),
+            profileDir: path.join(config.paths.profilesDir, resolvedProfile, 'skills'),
+        });
+    }
+    listSkills(profile, scope) {
+        return this.createSkillStore(profile).list(scope);
+    }
+    getSkill(name, profile) {
+        return this.createSkillStore(profile).get(name);
+    }
+    resolveSkillInvocation(input, profile) {
+        const parsed = (0, SkillInvocation_1.parseSkillInvocation)(input);
+        if (!parsed)
+            throw MarifoldError_1.MarifoldError.skillInvalid('Expected an invocation beginning with $.');
+        const resolvedProfile = profile ?? this.options.loadedConfig.config.default.profile;
+        this.profileResolver.loadSettings(resolvedProfile);
+        const skill = this.createSkillStore(resolvedProfile).require(parsed.name);
+        return (0, SkillInvocation_1.resolveSkillInvocation)(skill, parsed);
+    }
+    installSkillFromText(text, scope = 'global', profile) {
+        return this.createSkillStore(profile).installFromText(text, scope);
+    }
+    installSkillFromFile(filePath, scope = 'global', profile) {
+        return this.createSkillStore(profile).installFromFile(filePath, scope);
+    }
+    removeSkill(name, profile, scope) {
+        return this.createSkillStore(profile).remove(name, scope);
+    }
+    createAppStore() {
+        const { config } = this.options.loadedConfig;
+        return new AppStore_1.AppStore(config.paths.appsDir ?? (0, WorkspacePaths_1.defaultAppsDir)());
+    }
+    listApps() {
+        return this.createAppStore().list();
+    }
+    getApp(name) {
+        return this.createAppStore().get(name);
+    }
+    /** Execute one profile-free v1 operation and normalize provider output to
+     * the Skill's declared result contract. No session, memory, tools, profile
+     * context, or transcript is created. */
+    async runSkillAppOperation(appName, operationName, state, signal) {
+        const startedAt = Date.now();
+        try {
+            const store = this.createAppStore();
+            const definition = store.require(appName);
+            const operation = (0, SkillAppResolver_1.resolveSkillAppOperation)(store, definition, operationName, state);
+            await this.refreshProviderCredentialsIfNeeded(operation.model.provider);
+            const settings = {
+                profile: `skillapp-${appName}`,
+                provider: operation.model.provider,
+                model: operation.model.model,
+                think: operation.model.think,
+                mode: 'chat',
+            };
+            const response = await this.createEngine(settings.provider, false, false).run({
+                config: this.toPriestConfig(settings),
+                profile: settings.profile,
+                prompt: operation.prompt,
+                context: operation.instructions,
+            }, signal ? { signal } : undefined);
+            if (response.error) {
+                throw MarifoldError_1.MarifoldError.providerError(response.error.message, settings.provider, settings.model, response.error.code);
+            }
+            if (response.text === undefined) {
+                throw MarifoldError_1.MarifoldError.providerError(`Provider '${settings.provider}' returned no text for model '${settings.model}'.`, settings.provider, settings.model, 'EMPTY_RESPONSE');
+            }
+            const text = operation.result.trim ? response.text.trim() : response.text;
+            return {
+                status: 'ok',
+                data: { text },
+                meta: {
+                    engine: settings.provider,
+                    model: settings.model,
+                    durationMs: Date.now() - startedAt,
+                    ...(response.usage ? { usage: response.usage } : {}),
+                },
+            };
+        }
+        catch (error) {
+            if (signal?.aborted)
+                throw error;
+            return {
+                status: 'error',
+                error: {
+                    code: error instanceof MarifoldError_1.MarifoldError ? error.code : 'APP_INVALID',
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            };
+        }
+    }
+    createSkillAppInstanceRegistry() {
+        return new SkillAppInstanceRegistry_1.SkillAppInstanceRegistry(this);
+    }
+    createSchedule(input) {
+        return this.scheduleStore.create(input);
+    }
+    listSchedules() {
+        return this.scheduleStore.list();
+    }
+    getSchedule(scheduleId) {
+        return this.scheduleStore.get(scheduleId);
+    }
+    updateSchedule(scheduleId, input) {
+        return this.scheduleStore.update(scheduleId, input);
+    }
+    deleteSchedule(scheduleId) {
+        return this.scheduleStore.delete(scheduleId);
+    }
+    /**
+     * Execute one schedule unattended: [agent.unattended] approval overrides
+     * apply and 'ask' degrades to deny. Records lastRunAt/lastTaskId.
+     */
+    async runScheduleUnattended(scheduleId) {
+        const schedule = this.scheduleStore.require(scheduleId);
+        const result = await this.runScheduledAgent(schedule);
+        this.scheduleStore.update(schedule.id, {
+            lastRunAt: new Date().toISOString(),
+            ...(result.taskId ? { lastTaskId: result.taskId } : {}),
+            lastResultSeen: false,
+        });
+        return result;
+    }
+    /** Scheduler for the long-running service process. Call start()/stop(). */
+    createScheduler(log) {
+        return new Scheduler_1.Scheduler({
+            store: this.scheduleStore,
+            runSchedule: schedule => this.runScheduledAgent(schedule),
+            log,
+        });
+    }
+    /** Telegram bridge for the service process, or undefined when not configured,
+     * disabled, or missing a resolvable token. Call start()/stop(). */
+    createTelegramBridge(log) {
+        const config = this.options.loadedConfig.config.channels?.telegram;
+        if (!config || config.enabled === false)
+            return undefined;
+        const token = config.botTokenEnv ? process.env[config.botTokenEnv] : config.botToken;
+        if (!token) {
+            log?.(`Telegram channel configured but no bot token resolved${config.botTokenEnv ? ` (env ${config.botTokenEnv} unset)` : ''} — bridge not started.`);
+            return undefined;
+        }
+        return new TelegramBridge_1.TelegramBridge({
+            runtime: this,
+            token,
+            config,
+            log,
+            profilesDir: this.options.loadedConfig.config.paths.profilesDir,
+        });
+    }
+    /** Live run-session registry for the service process: start/attach/approve/
+     * steer/cancel agent runs across separate requests. Call close() on shutdown. */
+    createRunRegistry(log) {
+        return new RunRegistry_1.RunRegistry({
+            runtime: {
+                createAgentRunner: profile => this.createAgentRunner(profile),
+                setProfileAgentApproval: (profile, kind, mode) => {
+                    this.setProfileAgentApproval(profile, kind, mode);
+                },
+                addProfileTrustedFolder: (profile, folder) => this.addProfileTrustedFolder(profile, folder),
+                defaultProfile: () => this.options.loadedConfig.config.default.profile,
+            },
+            log,
+        });
+    }
+    async runScheduledAgent(schedule) {
+        const runner = this.createAgentRunner(schedule.profile);
+        let taskId;
+        let status = 'failed';
+        for await (const event of runner.run({
+            objective: schedule.objective,
+            profile: schedule.profile,
+            tags: ['scheduled'],
+            unattended: true,
+        })) {
+            if (event.type === 'done') {
+                taskId = event.taskId;
+                status = event.status;
+            }
+        }
+        return { taskId, status };
+    }
+    createTask(input) {
+        return this.taskStore.create(input);
+    }
+    listTasks(options = {}) {
+        return this.taskStore.list(options);
+    }
+    getTask(taskId) {
+        return this.taskStore.get(taskId);
+    }
+    updateTask(taskId, input) {
+        return this.taskStore.update(taskId, input);
+    }
+    appendTaskEvent(taskId, input) {
+        return this.taskStore.appendEvent(taskId, input);
+    }
+    deleteTask(taskId) {
+        return this.taskStore.delete(taskId);
+    }
+    close() {
+        this.sessionResolver.close();
+    }
+    discardFailedNewSession(sessionId, sessionWasMissing) {
+        if (!sessionId || !sessionWasMissing)
+            return;
+        const session = this.sessionResolver.get(sessionId);
+        if (session?.turnCount === 0)
+            this.sessionResolver.delete(sessionId);
+    }
+    createEngine(providerName, useSession, profileContext = true) {
+        const adapter = this.providerFactory.create(providerName);
+        const profileLoader = profileContext
+            ? this.profileResolver
+            : {
+                load: (name) => ({
+                    name,
+                    identity: '',
+                    rules: '',
+                    custom: '',
+                    memories: [],
+                }),
+            };
+        return new core_1.PriestEngine(profileLoader, useSession ? this.sessionResolver.openStore() : undefined, { [providerName]: adapter });
+    }
+    async refreshProviderCredentialsIfNeeded(providerName) {
+        if (providerName !== 'github_copilot' && providerName !== 'chatgpt' && providerName !== 'xai')
+            return;
+        const provider = this.options.loadedConfig.config.providers[providerName];
+        if (!provider?.oauthToken)
+            return;
+        if (provider.apiKeyEnv && process.env[provider.apiKeyEnv])
+            return;
+        const refreshWindowSeconds = 60;
+        const nowSeconds = Math.floor(Date.now() / 1000);
+        if (provider.apiKey
+            && provider.apiKeyExpiresAt !== undefined
+            && provider.apiKeyExpiresAt > nowSeconds + refreshWindowSeconds) {
+            return;
+        }
+        if (providerName === 'github_copilot') {
+            try {
+                const refreshed = await (0, GitHubCopilotAuth_1.exchangeGitHubTokenForCopilotToken)(provider.oauthToken);
+                provider.apiKey = refreshed.token;
+                provider.baseUrl = refreshed.baseUrl;
+                provider.apiKeyExpiresAt = refreshed.expiresAt;
+                new ConfigManager_1.ConfigManager(this.options.loadedConfig).save();
+            }
+            catch (error) {
+                throw MarifoldError_1.MarifoldError.configInvalid(`GitHub Copilot authorization could not be refreshed: ${error instanceof Error ? error.message : String(error)}. Run marifold provider reauth github_copilot to authorize again.`);
+            }
+            return;
+        }
+        if (providerName === 'xai') {
+            try {
+                const refreshed = await (0, XaiTokenRefresh_1.refreshXaiAccessToken)(provider.oauthToken, provider.proxy);
+                provider.apiKey = refreshed.apiKey;
+                provider.oauthToken = refreshed.refreshToken;
+                provider.apiKeyExpiresAt = refreshed.expiresAt;
+                new ConfigManager_1.ConfigManager(this.options.loadedConfig).save();
+            }
+            catch (error) {
+                throw MarifoldError_1.MarifoldError.configInvalid(`xAI authorization could not be refreshed: ${error instanceof Error ? error.message : String(error)}. Run marifold provider reauth xai to sign in again.`);
+            }
+            return;
+        }
+        // chatgpt: refresh the API credential from the stored OAuth refresh token.
+        // ChatGPT credentials without an apiKeyExpiresAt were issued before
+        // refresh support and may still be valid — only refresh when expiry is
+        // known or the key is missing.
+        if (provider.apiKey && provider.apiKeyExpiresAt === undefined)
+            return;
+        try {
+            const refreshed = await (0, ChatGptTokenRefresh_1.refreshChatGptAccessToken)(provider.oauthToken);
+            provider.apiKey = refreshed.apiKey;
+            provider.oauthToken = refreshed.refreshToken;
+            provider.apiKeyExpiresAt = refreshed.expiresAt;
+            if (refreshed.accountId)
+                provider.accountId = refreshed.accountId;
+            new ConfigManager_1.ConfigManager(this.options.loadedConfig).save();
+        }
+        catch (error) {
+            throw MarifoldError_1.MarifoldError.configInvalid(`ChatGPT authorization could not be refreshed: ${error instanceof Error ? error.message : String(error)}. Run marifold provider reauth chatgpt to sign in again.`);
+        }
+    }
+    /**
+     * Model-initiated tools for chat turns. Opt-in via [web_search].enabled;
+     * web_search joins unless network policy is deny, read_file joins only when
+     * read policy is allow.
+     */
+    chatTools(request) {
+        const webSearch = (0, ConfigSchema_1.resolveWebSearchConfig)(this.options.loadedConfig.config.webSearch);
+        if (!webSearch.enabled || request.chatTools === false)
+            return undefined;
+        const agentConfig = this.resolveAgentConfigForProfile(request.profile);
+        const approval = agentConfig.approval;
+        const tools = [];
+        if (approval.network !== 'deny')
+            tools.push(new WebSearchTool_1.WebSearchTool(this.searchBackend, webSearch.maxResults));
+        if (approval.read === 'allow')
+            tools.push(new ReadFileTool_1.ReadFileTool());
+        if (tools.length === 0)
+            return undefined;
+        const outputLimit = agentConfig.toolOutputLimit;
+        return {
+            definitions: tools.map(tool => tool.definition),
+            execute: async (name, args) => {
+                const tool = tools.find(t => t.definition.name === name);
+                if (!tool)
+                    return { content: `Unknown tool '${name}'.`, isError: true };
+                try {
+                    const result = await tool.execute(args, { cwd: process.cwd(), outputLimit });
+                    return { content: result.content, isError: result.isError };
+                }
+                catch (error) {
+                    return { content: `Tool '${name}' failed: ${error instanceof Error ? error.message : String(error)}`, isError: true };
+                }
+            },
+        };
+    }
+    toPriestConfig(settings) {
+        const { config } = this.options.loadedConfig;
+        const provider = config.providers[settings.provider];
+        const neutralReasoning = this.supportsNeutralReasoning(settings.provider, settings.model);
+        return {
+            provider: settings.provider,
+            model: settings.model,
+            timeoutSeconds: config.default.timeoutSeconds,
+            maxOutputTokens: config.default.maxOutputTokens,
+            maxSystemChars: config.default.maxSystemChars,
+            maxContextTokens: settings.maxContextTokens ?? config.default.maxContextTokens,
+            compactionKeepTurns: config.default.compactionKeepTurns,
+            sessionContextTurns: settings.sessionContextTurns ?? config.default.sessionContextTurns,
+            reasoning: provider?.type === 'ollama'
+                ? {
+                    enabled: settings.think,
+                    ...(settings.think ? { effort: 'high', summary: 'auto' } : {}),
+                }
+                : neutralReasoning && settings.think
+                    ? { enabled: true, effort: 'high', summary: 'auto' }
+                    : undefined,
+            providerOptions: LEGACY_THINK_PROVIDER_NAMES.has(settings.provider)
+                ? { think: settings.think }
+                : undefined,
+        };
+    }
+    supportsNeutralReasoning(providerName, model) {
+        const provider = this.options.loadedConfig.config.providers[providerName];
+        return provider?.type === 'ollama'
+            || provider?.type === 'anthropic'
+            || providerName === 'chatgpt'
+            || (providerName === 'github_copilot' && (0, ProviderRegistry_1.isGitHubCopilotResponsesModelId)(model));
+    }
+    supportsThink(providerName, model) {
+        return LEGACY_THINK_PROVIDER_NAMES.has(providerName)
+            || this.supportsNeutralReasoning(providerName, model);
+    }
+    /** Whether the profile's resolved provider honors thinking mode — so a channel
+     * can tell the user when `/think` would have no effect. */
+    profileSupportsThink(profile) {
+        const settings = this.resolveSettings({ profile });
+        return this.supportsThink(settings.provider, settings.model);
+    }
+    memoryForRequest(profile, requestMemories = true, prompt = '', thinking = false) {
+        const { config } = this.options.loadedConfig;
+        if (!this.memoryEnabled(profile, requestMemories))
+            return [];
+        this.ensureProfileMemoryFiles(profile);
+        return this.memoryStore.listPromptMemory(profile, {
+            contextLimit: config.memory.contextLimit,
+            prompt,
+            thinking,
+        });
+    }
+    runtimeContext(memory, prompt, memoryOn) {
+        const context = ['Running inside Marifold.'];
+        if (memoryOn) {
+            context.push('Profile memory is app-owned context. Current user messages and profile rules outrank memory.');
+            if ((0, MemoryControls_1.shouldInjectMemoryInstructions)(prompt))
+                context.push((0, MemoryControls_1.buildMemoryInstructions)());
+        }
+        else if (memory.length > 0) {
+            context.push('Profile memory is app-owned context. Current user messages and profile rules outrank memory.');
+        }
+        return context;
+    }
+    editHistoryContext(request, settings) {
+        if (request.replaceUserTurnIndex === undefined)
+            return [];
+        if (!request.sessionId) {
+            throw MarifoldError_1.MarifoldError.configInvalid('replaceUserTurnIndex requires sessionId.');
+        }
+        const turns = this.sessionResolver.turnsBeforeUserTurn(request.sessionId, request.replaceUserTurnIndex)
+            ?? this.missingEditedTurn(request.sessionId, request.replaceUserTurnIndex);
+        const history = (0, AgentHistory_1.buildHistoryContext)(turns.map(turn => ({ role: turn.role, content: turn.content })), settings.maxContextTokens ?? EDIT_HISTORY_BUDGET_DEFAULT_CHARS);
+        return history ? [history] : [];
+    }
+    replaceEditedExchange(sessionId, userTurnIndex, userText, assistantText, images, responseMetrics) {
+        const result = this.sessionResolver.replaceExchange(sessionId, userTurnIndex, userText, assistantText, images, responseMetrics);
+        if (!result.replaced)
+            this.missingEditedTurn(sessionId, userTurnIndex);
+    }
+    missingEditedTurn(sessionId, userTurnIndex) {
+        throw MarifoldError_1.MarifoldError.configInvalid(`Cannot edit user turn ${userTurnIndex} because it is missing from session '${sessionId}'.`);
+    }
+    applyTurnMemory(profile, prompt, controls, sessionId) {
+        this.memoryStore.applySavePayloads(profile, controls.savePayloads, { sessionId });
+        this.memoryStore.applyForgetPayloads(profile, controls.forgetPayloads);
+        for (const query of (0, MemoryControls_1.extractPromptForgetQueries)(prompt)) {
+            this.memoryStore.forget(profile, query);
+        }
+        this.memoryStore.save(profile, (0, MemoryControls_1.extractPromptMemoryInputs)(prompt), { sessionId });
+        this.memoryStore.trimShortTerm(profile, this.options.loadedConfig.config.memory.sizeLimit);
+    }
+}
+exports.MarifoldRuntime = MarifoldRuntime;
+function completedResponseMetrics(mode, settings, startedAt, startedAtMs, usage) {
+    const finishedAtMs = Date.now();
+    return {
+        mode,
+        provider: settings.provider,
+        model: settings.model,
+        think: settings.think,
+        startedAt,
+        finishedAt: new Date(finishedAtMs).toISOString(),
+        latencyMs: Math.max(0, finishedAtMs - startedAtMs),
+        ...(usage && Object.values(usage).some(value => value !== undefined) ? { usage: { ...usage } } : {}),
+    };
+}
+/** Sum two provider usage reports, preserving undefined when neither side has
+ * a given field (so absent token data stays absent rather than showing 0). */
+function sumUsage(a, b) {
+    if (!a)
+        return b;
+    if (!b)
+        return a;
+    const add = (x, y) => x == null && y == null ? undefined : (x ?? 0) + (y ?? 0);
+    return {
+        inputTokens: add(a.inputTokens, b.inputTokens),
+        outputTokens: add(a.outputTokens, b.outputTokens),
+        totalTokens: add(a.totalTokens, b.totalTokens),
+        cachedInputTokens: add(a.cachedInputTokens, b.cachedInputTokens),
+        reasoningTokens: add(a.reasoningTokens, b.reasoningTokens),
+        estimatedCostUSD: add(a.estimatedCostUSD, b.estimatedCostUSD),
+    };
+}
+//# sourceMappingURL=MarifoldRuntime.js.map