daycare-cli 0.0.0-canary.00a24ac

package/dist/engine/agents/agent.js

@@ -0,0 +1,1341 @@
+import os from "node:os";
+import path from "node:path";
+import { createId } from "@paralleldrive/cuid2";
+import { getLogger } from "../../log.js";
+import { listActiveInferenceProviders } from "../../providers/catalog.js";
+import { modelRoleApply } from "../../providers/modelRoleApply.js";
+import { Sandbox } from "../../sandbox/sandbox.js";
+import { cuid2Is } from "../../utils/cuid2Is.js";
+import { channelMessageBuild, channelSignalDataParse } from "../channels/channelMessageBuild.js";
+import { messageBuildSystemSilentText } from "../messages/messageBuildSystemSilentText.js";
+import { messageBuildSystemText } from "../messages/messageBuildSystemText.js";
+import { messageBuildUser } from "../messages/messageBuildUser.js";
+import { messageExtractText } from "../messages/messageExtractText.js";
+import { messageFormatIncoming } from "../messages/messageFormatIncoming.js";
+import { rlmHistoryCompleteErrorRecordBuild } from "../modules/rlm/rlmHistoryCompleteErrorRecordBuild.js";
+import { permissionBuildUser } from "../permissions/permissionBuildUser.js";
+import { signalMessageBuild } from "../signals/signalMessageBuild.js";
+import { Skills } from "../skills/skills.js";
+import { userHomeEnsure } from "../users/userHomeEnsure.js";
+import { agentHistoryAppend } from "./ops/agentHistoryAppend.js";
+import { agentHistoryContext } from "./ops/agentHistoryContext.js";
+import { agentHistoryLoad } from "./ops/agentHistoryLoad.js";
+import { agentLoopPendingPhaseResolve } from "./ops/agentLoopPendingPhaseResolve.js";
+import { agentLoopRun } from "./ops/agentLoopRun.js";
+import { agentModelOverrideApply } from "./ops/agentModelOverrideApply.js";
+import { agentPathTargetResolve } from "./ops/agentPathTargetResolve.js";
+import { agentPromptFilesEnsure } from "./ops/agentPromptFilesEnsure.js";
+import { agentPromptPathsResolve } from "./ops/agentPromptPathsResolve.js";
+import { agentStateWrite } from "./ops/agentStateWrite.js";
+import { agentSystemPrompt } from "./ops/agentSystemPrompt.js";
+import { agentSystemPromptWrite } from "./ops/agentSystemPromptWrite.js";
+import { agentTokenPromptUsedFromUsage } from "./ops/agentTokenPromptUsedFromUsage.js";
+import { agentWrite } from "./ops/agentWrite.js";
+import { bundledExamplesDirResolve } from "./ops/bundledExamplesDirResolve.js";
+import { contextCompact } from "./ops/contextCompact.js";
+import { contextCompactionStatus } from "./ops/contextCompactionStatus.js";
+import { contextEstimateTokens } from "./ops/contextEstimateTokens.js";
+import { messageContextReset } from "./ops/messageContextReset.js";
+import { systemPromptResolve } from "./ops/systemPromptResolve.js";
+const logger = getLogger("engine.agent");
+const RESTORE_FAILURE_RESET_MESSAGE = "Session restore failed - starting from scratch.";
+export class Agent {
+    ctx;
+    path;
+    config;
+    inbox;
+    state;
+    agentSystem;
+    providerId = null;
+    processing = false;
+    started = false;
+    inferenceAbortController = null;
+    userHome;
+    sandbox;
+    endTurnCount = 0;
+    documentLastReadVersions = new Map();
+    constructor(ctx, path, config, state, inbox, agentSystem, userHome) {
+        if (!userHome) {
+            throw new Error("Agent user home is required.");
+        }
+        this.ctx = ctx;
+        this.path = path;
+        this.config = config;
+        this.state = state;
+        this.inbox = inbox;
+        this.agentSystem = agentSystem;
+        this.userHome = userHome;
+        this.sandbox = this.sandboxBuild();
+    }
+    /**
+     * Creates a new agent and persists path/config + state + initial session row.
+     * Expects: ctx.agentId is a cuid2 value and path/config are validated.
+     */
+    static async create(ctx, path, config, inbox, agentSystem, userHome) {
+        if (!cuid2Is(ctx.agentId)) {
+            throw new Error("Agent id must be a cuid2 value.");
+        }
+        await userHomeEnsure(userHome);
+        const now = Date.now();
+        const basePermissions = permissionBuildUser(userHome);
+        const state = {
+            context: { messages: [] },
+            activeSessionId: null,
+            inferenceSessionId: createId(),
+            permissions: basePermissions,
+            createdAt: now,
+            updatedAt: now,
+            state: "active"
+        };
+        const permissions = config.workspaceDir && config.workspaceDir.trim().length > 0
+            ? { ...basePermissions, workingDir: config.workspaceDir }
+            : basePermissions;
+        state.permissions = permissions;
+        const agent = new Agent(ctx, path, config, state, inbox, agentSystem, userHome);
+        await agentWrite(agentSystem.storage, ctx, path, config, basePermissions);
+        await agentStateWrite(agentSystem.storage, ctx, state);
+        state.activeSessionId = await agentSystem.storage.sessions.create({
+            agentId: ctx.agentId,
+            inferenceSessionId: state.inferenceSessionId,
+            createdAt: now
+        });
+        await agentStateWrite(agentSystem.storage, ctx, state);
+        agent.agentSystem.eventBus.emit("agent.created", {
+            agentId: ctx.agentId,
+            source: "agent",
+            context: {}
+        });
+        return agent;
+    }
+    /**
+     * Rehydrates an agent from persisted path/config + state.
+     * Rebuilds permissions from userHome to avoid stale legacy paths.
+     * Expects: state, path, and config already validated.
+     */
+    static restore(ctx, path, config, state, inbox, agentSystem, userHome) {
+        const basePermissions = permissionBuildUser(userHome);
+        const permissions = config.workspaceDir && config.workspaceDir.trim().length > 0
+            ? { ...basePermissions, workingDir: config.workspaceDir }
+            : basePermissions;
+        const refreshedState = { ...state, permissions };
+        return new Agent(ctx, path, config, refreshedState, inbox, agentSystem, userHome);
+    }
+    get id() {
+        return this.ctx.agentId;
+    }
+    get userId() {
+        return this.ctx.userId;
+    }
+    /**
+     * Remembers the latest read version for each document in the active session.
+     * Expects: entries are from a resolved root-to-target chain.
+     */
+    documentChainReadMark(entries) {
+        for (const entry of entries) {
+            const id = entry.id.trim();
+            if (!id) {
+                continue;
+            }
+            this.documentLastReadVersions.set(id, entry.version);
+        }
+    }
+    /**
+     * Returns the last read version for a document in this session.
+     * Expects: documentId belongs to the same user scope as this agent.
+     */
+    documentVersionLastRead(documentId) {
+        const id = documentId.trim();
+        if (!id) {
+            return null;
+        }
+        return this.documentLastReadVersions.get(id) ?? null;
+    }
+    start() {
+        if (this.started) {
+            return;
+        }
+        this.started = true;
+        logger.debug(`start: Agent loop starting agentId=${this.id} kind=${this.agentKindResolve()}`);
+        void this.runLoop().catch((error) => {
+            this.started = false;
+            this.agentSystem.markStopped(this.id, error);
+            logger.warn({ agentId: this.id, error }, "event: Agent loop exited unexpectedly");
+        });
+    }
+    isProcessing() {
+        return this.processing;
+    }
+    /**
+     * Aborts the currently running inference call for this agent.
+     * Returns false when no active inference is in flight.
+     */
+    abortInference() {
+        const controller = this.inferenceAbortController;
+        if (!controller || controller.signal.aborted) {
+            return false;
+        }
+        controller.abort();
+        return true;
+    }
+    /**
+     * Rebuilds the sandbox to pick up updated mounts for this user.
+     * Expects: external mount providers are already refreshed.
+     */
+    sandboxRefresh() {
+        this.sandbox = this.sandboxBuild();
+    }
+    async runLoop() {
+        this.inbox.attach();
+        try {
+            for (;;) {
+                const entry = await this.inbox.next();
+                logger.debug(`event: Agent inbox item dequeued agentId=${this.id} type=${entry.item.type}`);
+                this.processing = true;
+                try {
+                    const result = await this.agentSystem.inReadLock(async () => this.handleInboxItem(entry.item));
+                    await this.sleepAfterItem(entry.item);
+                    entry.completion?.resolve(result);
+                }
+                catch (error) {
+                    const failure = error instanceof Error ? error : new Error(String(error));
+                    logger.error({
+                        agentId: this.id,
+                        itemType: entry.item.type,
+                        errorName: failure.name,
+                        errorMessage: failure.message,
+                        errorStack: failure.stack
+                    }, `error: Agent inbox item failed: ${failure.message}`);
+                    entry.completion?.reject(failure);
+                    if (entry.item.type === "message") {
+                        await this.sendUnexpectedError(entry.item);
+                    }
+                }
+                finally {
+                    try {
+                        await this.agentSystem.deleteInboxItem(entry.id);
+                    }
+                    catch (error) {
+                        logger.warn({ agentId: this.id, inboxItemId: entry.id, error }, "error: Failed to delete inbox item");
+                    }
+                    this.processing = false;
+                }
+            }
+        }
+        finally {
+            this.inbox.detach();
+        }
+    }
+    /**
+     * Attempts to put the agent to sleep after processing a message or reset.
+     * Expects: inbox item handled successfully.
+     */
+    async sleepAfterItem(item) {
+        if (item.type !== "message" &&
+            item.type !== "system_message" &&
+            item.type !== "signal" &&
+            item.type !== "reset" &&
+            item.type !== "compact" &&
+            item.type !== "restore") {
+            return;
+        }
+        await this.agentSystem.sleepIfIdle(this.id, item.type);
+    }
+    /**
+     * Increments end turn counter and invalidates the session when threshold exceeded.
+     * Runtime-only — no persistence needed for the counter.
+     */
+    async invalidateSessionIfNeeded() {
+        this.endTurnCount += 1;
+        if (this.endTurnCount <= 5) {
+            return;
+        }
+        // Memory-agents and memory-search agents must never trigger the memory worker
+        const kind = this.agentKindResolve();
+        if (kind === "memory" || kind === "search") {
+            return;
+        }
+        const sessionId = this.state.activeSessionId;
+        if (!sessionId) {
+            return;
+        }
+        const maxHistoryId = await this.agentSystem.storage.history.maxId(sessionId);
+        if (maxHistoryId !== null) {
+            await this.agentSystem.storage.sessions.invalidate(sessionId, maxHistoryId);
+            logger.debug(`event: Session invalidated after ${this.endTurnCount} end turns sessionId=${sessionId}`);
+        }
+    }
+    async handleInboxItem(item) {
+        switch (item.type) {
+            case "message": {
+                const responseText = await this.handleMessage(item);
+                return { type: "message", responseText };
+            }
+            case "system_message": {
+                const systemResult = await this.handleSystemMessage(item);
+                return {
+                    type: "system_message",
+                    responseText: systemResult.responseText,
+                    responseError: systemResult.responseError,
+                    ...(systemResult.executionErrorText ? { executionErrorText: systemResult.executionErrorText } : {})
+                };
+            }
+            case "signal": {
+                const signalResult = await this.handleSignal(item);
+                return { type: "signal", ...signalResult };
+            }
+            case "reset": {
+                const ok = await this.handleReset(item);
+                return { type: "reset", ok };
+            }
+            case "compact": {
+                const ok = await this.handleCompaction(item);
+                return { type: "compact", ok };
+            }
+            case "restore": {
+                const ok = await this.handleRestore(item);
+                return { type: "restore", ok };
+            }
+            default:
+                return { type: "restore", ok: false };
+        }
+    }
+    async sendUnexpectedError(item) {
+        if (!this.config.foreground) {
+            return;
+        }
+        const target = await agentPathTargetResolve(this.agentSystem.storage, this.ctx.userId, this.config, this.path);
+        if (!target) {
+            return;
+        }
+        const connector = this.agentSystem.connectorRegistry.get(target.connector);
+        if (!connector?.capabilities.sendText) {
+            return;
+        }
+        try {
+            await connector.sendMessage(target.targetId, {
+                text: "Unexpected error",
+                replyToMessageId: item.context.messageId
+            });
+        }
+        catch (error) {
+            const failure = error instanceof Error ? error : new Error(String(error));
+            logger.warn({ agentId: this.id, error: failure }, "error: Failed to send unexpected error message");
+        }
+    }
+    async handleMessage(item) {
+        const receivedAt = Date.now();
+        const messageId = createId();
+        const context = { ...item.context };
+        const entry = {
+            id: messageId,
+            message: messageFormatIncoming(item.message, context, new Date(receivedAt)),
+            context,
+            receivedAt
+        };
+        const source = this.sourceResolve();
+        logger.debug(`start: handleMessage start agentId=${this.id} source=${source} textLength=${entry.message.text?.length ?? 0} fileCount=${entry.message.files?.length ?? 0}`);
+        this.state.updatedAt = receivedAt;
+        const rawText = entry.message.rawText ?? entry.message.text ?? "";
+        const files = toFileReferences(entry.message.files ?? []);
+        entry.message.files = files;
+        let compactionAt = null;
+        let pendingUserRecord = {
+            type: "user_message",
+            at: receivedAt,
+            text: rawText,
+            files,
+            ...(context.enrichments ? { enrichments: context.enrichments.map((item) => ({ ...item })) } : {})
+        };
+        const { providers, providerId } = this.inferenceProvidersResolve();
+        const connector = this.agentSystem.connectorRegistry.get(source);
+        const skills = this.skillsResolve();
+        const agentKind = this.resolveAgentKind();
+        const pluginManager = this.agentSystem.pluginManager;
+        const toolResolver = this.agentSystem.toolResolver;
+        const providerSettings = providerId
+            ? (providers.find((provider) => provider.id === providerId) ?? providers[0])
+            : providers[0];
+        const history = await agentHistoryLoad(this.agentSystem.storage, this.ctx);
+        const isFirstMessage = history.length === 0;
+        // Resolve configured system prompts (global, per-user, conditional)
+        const resolvedPrompts = await systemPromptResolve(this.agentSystem.storage, this.ctx.userId, isFirstMessage);
+        // First-message prompts are user-facing guidance and should not alter
+        // internal/background agent inputs (memory-agent, cron, subagent, app, etc.).
+        const shouldPrependFirstMessagePrompt = this.config.foreground;
+        if (shouldPrependFirstMessagePrompt && resolvedPrompts.firstMessagePrompt && entry.message.text !== null) {
+            entry.message.text = `${resolvedPrompts.firstMessagePrompt}\n\n${entry.message.text}`;
+            pendingUserRecord = {
+                ...pendingUserRecord,
+                text: entry.message.rawText ?? entry.message.text,
+                firstMessagePrepended: true,
+                firstMessagePrompt: resolvedPrompts.firstMessagePrompt
+            };
+        }
+        await agentPromptFilesEnsure(agentPromptPathsResolve(this.userHome));
+        logger.debug(`event: handleMessage building system prompt agentId=${this.id}`);
+        const connectorTargetId = (await agentPathTargetResolve(this.agentSystem.storage, this.ctx.userId, this.config, this.path))?.targetId;
+        const pluginPrompts = typeof pluginManager.getSystemPrompts === "function"
+            ? await pluginManager.getSystemPrompts({
+                ctx: this.ctx,
+                path: this.path,
+                config: this.config,
+                connectorTargetId,
+                userDownloadsDir: this.userHome.downloads
+            })
+            : [];
+        const extraSections = [...resolvedPrompts.systemPromptSections];
+        if (this.agentSystem.psqlService) {
+            try {
+                const psqlSection = (await this.agentSystem.psqlService.systemPromptSection(this.ctx)).trim();
+                if (psqlSection.length > 0) {
+                    extraSections.push(psqlSection);
+                }
+            }
+            catch (error) {
+                logger.warn({ agentId: this.id, error }, "error: Failed to build psql system prompt section");
+            }
+        }
+        const systemPromptContext = {
+            provider: providerSettings?.id,
+            model: providerSettings?.model,
+            permissions: this.state.permissions,
+            path: this.path,
+            config: this.config,
+            ctx: this.ctx,
+            agentSystem: this.agentSystem,
+            userHome: this.userHome,
+            pluginPrompts,
+            extraSections
+        };
+        const systemPrompt = await agentSystemPrompt(systemPromptContext);
+        try {
+            const wrote = await agentSystemPromptWrite(this.agentSystem.config.current, this.ctx, systemPrompt);
+            if (wrote) {
+                logger.debug(`event: System prompt snapshot written agentId=${this.id}`);
+            }
+        }
+        catch (error) {
+            logger.warn({ agentId: this.id, error }, "error: Failed to write system prompt snapshot");
+        }
+        const contextTools = [];
+        const lastAssistantRecord = [...history].reverse().find((record) => record.type === "assistant_message");
+        const usagePromptTokens = lastAssistantRecord && lastAssistantRecord.type === "assistant_message"
+            ? agentTokenPromptUsedFromUsage(lastAssistantRecord.tokens)
+            : null;
+        const compactionStatus = contextCompactionStatus(history, this.agentSystem.config.current.settings.agents.emergencyContextLimit, {
+            minimumTokens: usagePromptTokens ?? undefined,
+            extras: {
+                systemPrompt,
+                tools: contextTools,
+                extraText: [rawText]
+            }
+        });
+        if (compactionStatus.severity !== "ok") {
+            const targetId = (await agentPathTargetResolve(this.agentSystem.storage, this.ctx.userId, this.config, this.path))
+                ?.targetId ?? null;
+            if (agentKind === "foreground" && connector?.capabilities.sendText && targetId) {
+                await connector.sendMessage(targetId, {
+                    text: messageContextReset({ kind: "compaction" }),
+                    replyToMessageId: entry.context.messageId
+                });
+            }
+            const stopCompactionTyping = await this.startCompactionTypingIndicator();
+            const compactionAbortController = new AbortController();
+            this.inferenceAbortController = compactionAbortController;
+            let compactionAborted = false;
+            try {
+                const compacted = await contextCompact({
+                    context: this.state.context,
+                    inferenceRouter: this.agentSystem.inferenceRouter,
+                    providers,
+                    providerId: providerId ?? undefined,
+                    inferenceSessionId: this.state.inferenceSessionId ?? this.id,
+                    signal: compactionAbortController.signal,
+                    compactionLog: {
+                        agentsDir: this.agentSystem.config.current.agentsDir,
+                        agentId: this.id
+                    }
+                });
+                const summaryMessage = compacted.messages?.[0];
+                const summaryText = summaryMessage ? (messageExtractText(summaryMessage)?.trim() ?? "") : "";
+                if (summaryText) {
+                    compactionAt = await this.applyCompactionSummary(summaryText);
+                }
+                else {
+                    logger.info({ agentId: this.id }, "event: Compaction produced empty summary; using full context");
+                }
+            }
+            catch (error) {
+                if (isAbortError(error, compactionAbortController.signal)) {
+                    compactionAborted = true;
+                    logger.info({ agentId: this.id }, "event: Compaction aborted");
+                }
+                else {
+                    logger.warn({ agentId: this.id, error }, "error: Context compaction failed; continuing with full context");
+                }
+            }
+            finally {
+                stopCompactionTyping?.();
+                if (this.inferenceAbortController === compactionAbortController) {
+                    this.inferenceAbortController = null;
+                }
+            }
+            if (compactionAborted) {
+                return null;
+            }
+        }
+        if (pendingUserRecord) {
+            if (compactionAt !== null) {
+                pendingUserRecord = { ...pendingUserRecord, at: compactionAt + 1 };
+            }
+            await agentHistoryAppend(this.agentSystem.storage, this.ctx, pendingUserRecord);
+        }
+        const ctx = this.state.context;
+        const contextForRun = {
+            ...ctx,
+            tools: contextTools,
+            systemPrompt
+        };
+        if (systemPromptContext.systemPromptImages && systemPromptContext.systemPromptImages.length > 0) {
+            contextForRun.systemPromptImages = systemPromptContext.systemPromptImages;
+        }
+        if (!contextForRun.messages) {
+            contextForRun.messages = [];
+        }
+        logger.debug(`event: handleMessage building user message agentId=${this.id}`);
+        const userMessage = await messageBuildUser(entry);
+        contextForRun.messages.push(userMessage);
+        const providersForAgent = providersForAgentResolve(providers, providerId);
+        logger.debug(`event: handleMessage invoking inference loop agentId=${this.id}`);
+        const inferenceAbortController = new AbortController();
+        this.inferenceAbortController = inferenceAbortController;
+        const result = await (async () => {
+            try {
+                return await agentLoopRun({
+                    entry,
+                    agent: this,
+                    source,
+                    context: contextForRun,
+                    connector,
+                    connectorRegistry: this.agentSystem.connectorRegistry,
+                    inferenceRouter: this.agentSystem.inferenceRouter,
+                    toolResolver,
+                    authStore: this.agentSystem.authStore,
+                    eventBus: this.agentSystem.eventBus,
+                    assistant: this.agentSystem.config.current.settings.assistant ?? null,
+                    agentSystem: this.agentSystem,
+                    webhooks: this.agentSystem.webhooks,
+                    skills,
+                    skillsActiveRoot: this.userHome.skillsActive,
+                    skillsPersonalRoot: this.userHome.skillsPersonal,
+                    providersForAgent,
+                    logger,
+                    abortSignal: inferenceAbortController.signal,
+                    appendHistoryRecord: (record) => agentHistoryAppend(this.agentSystem.storage, this.ctx, record),
+                    notifySubagentFailure: (reason, error) => this.notifySubagentFailure(reason, error)
+                });
+            }
+            finally {
+                if (this.inferenceAbortController === inferenceAbortController) {
+                    this.inferenceAbortController = null;
+                }
+            }
+        })();
+        if (result.contextOverflow) {
+            logger.warn({ agentId: this.id }, "event: Inference context overflow; resetting session");
+            await this.handleEmergencyReset(entry, source, result.contextOverflowTokens);
+            return null;
+        }
+        if (result.tokenStatsUpdates.length > 0) {
+            for (const update of result.tokenStatsUpdates) {
+                await this.agentSystem.storage.tokenStats.increment(this.ctx, {
+                    at: update.at,
+                    model: `${update.provider}/${update.model}`,
+                    input: update.size.input,
+                    output: update.size.output,
+                    cacheRead: update.size.cacheRead,
+                    cacheWrite: update.size.cacheWrite,
+                    cost: update.cost
+                });
+            }
+        }
+        this.state.context = { messages: contextForRun.messages };
+        this.state.updatedAt = Date.now();
+        await agentStateWrite(this.agentSystem.storage, this.ctx, this.state);
+        await this.invalidateSessionIfNeeded();
+        return result.responseText ?? null;
+    }
+    async executableBlocksRun(input) {
+        const now = Date.now();
+        const source = input.source.trim().length > 0 ? input.source : "system";
+        const toolCallId = createId();
+        const connector = this.agentSystem.connectorRegistry.get(source);
+        const { providers, providerId } = this.inferenceProvidersResolve();
+        const providersForAgent = providersForAgentResolve(providers, providerId);
+        const skills = this.skillsResolve();
+        const context = { messages: [] };
+        const entry = {
+            id: createId(),
+            receivedAt: now,
+            context: input.messageContext,
+            message: {
+                text: "",
+                rawText: "",
+                files: []
+            }
+        };
+        await agentLoopRun({
+            entry,
+            agent: this,
+            source,
+            context,
+            connector,
+            connectorRegistry: this.agentSystem.connectorRegistry,
+            inferenceRouter: this.agentSystem.inferenceRouter,
+            toolResolver: this.agentSystem.toolResolver,
+            authStore: this.agentSystem.authStore,
+            eventBus: this.agentSystem.eventBus,
+            assistant: this.agentSystem.config.current.settings.assistant ?? null,
+            agentSystem: this.agentSystem,
+            webhooks: this.agentSystem.webhooks,
+            skills,
+            skillsActiveRoot: this.userHome.skillsActive,
+            skillsPersonalRoot: this.userHome.skillsPersonal,
+            providersForAgent,
+            logger,
+            appendHistoryRecord: (record) => agentHistoryAppend(this.agentSystem.storage, this.ctx, record),
+            notifySubagentFailure: (reason, error) => this.notifySubagentFailure(reason, error),
+            initialPhase: {
+                type: "vm_start",
+                blocks: [input.code],
+                blockToolCallIds: [toolCallId],
+                ...(input.inputValues !== undefined ? { blockInputs: [input.inputValues] } : {}),
+                ...(input.inputSchema !== undefined ? { blockInputSchemas: [input.inputSchema] } : {}),
+                blockIndex: 0,
+                assistantAt: now,
+                historyResponseText: ""
+            },
+            stopAfterPendingPhase: true,
+            continueAfterRunPythonError: true
+        });
+        const persistedHistory = await agentHistoryLoad(this.agentSystem.storage, this.ctx);
+        let completion = null;
+        for (const record of persistedHistory) {
+            if (record.type !== "rlm_complete" || record.toolCallId !== toolCallId) {
+                continue;
+            }
+            completion = record;
+        }
+        if (!completion) {
+            const missing = "Python execution failed before completion.";
+            return { output: `<exec_error>${missing}</exec_error>`, errorMessage: missing, skipTurn: false };
+        }
+        if (!completion.isError && completion.output === "Turn skipped") {
+            return { output: "", errorMessage: null, skipTurn: true };
+        }
+        if (completion.isError) {
+            const message = completion.error?.trim() ?? "";
+            const errorText = message.length > 0 ? message : "Python execution failed.";
+            return { output: `<exec_error>${errorText}</exec_error>`, errorMessage: errorText, skipTurn: false };
+        }
+        const output = completion.printOutput.length > 0 ? completion.printOutput.join("\n") : completion.output;
+        return { output, errorMessage: null, skipTurn: false };
+    }
+    async handleSystemMessage(item) {
+        let systemText = item.text;
+        let executionHasError = false;
+        let executionErrorText = null;
+        let executableCode = null;
+        let inputSchema = item.inputSchemas;
+        const rawCode = item.code;
+        const taskReference = item.task;
+        if (taskReference !== undefined && rawCode !== undefined) {
+            const errorText = "Executable system_message must include either code or task reference, not both.";
+            logger.warn({ agentId: this.id, origin: item.origin ?? "system", errorText }, "error: Invalid code payload");
+            return {
+                responseText: item.sync ? `<exec_error>${errorText}</exec_error>` : null,
+                responseError: true,
+                executionErrorText: errorText
+            };
+        }
+        if (rawCode !== undefined && typeof rawCode !== "string") {
+            const errorText = Array.isArray(rawCode)
+                ? `Executable system_message requires exactly one code block, got ${rawCode.length}.`
+                : "Executable system_message code must be a string.";
+            logger.warn({ agentId: this.id, origin: item.origin ?? "system", errorText }, "error: Invalid code payload");
+            return {
+                responseText: item.sync ? `<exec_error>${errorText}</exec_error>` : null,
+                responseError: true,
+                executionErrorText: errorText
+            };
+        }
+        if (typeof rawCode === "string") {
+            executableCode = rawCode;
+        }
+        else if (taskReference) {
+            const taskId = taskReference.id.trim();
+            if (!taskId) {
+                const errorText = "Executable system_message task.id is required.";
+                logger.warn({ agentId: this.id, origin: item.origin ?? "system", errorText }, "error: Invalid task reference payload");
+                return {
+                    responseText: item.sync ? `<exec_error>${errorText}</exec_error>` : null,
+                    responseError: true,
+                    executionErrorText: errorText
+                };
+            }
+            const requestedVersion = taskReference.version;
+            const taskRecord = typeof requestedVersion === "number" && Number.isFinite(requestedVersion)
+                ? await this.agentSystem.storage.tasks.findByVersion(this.ctx, taskId, requestedVersion)
+                : await this.agentSystem.storage.tasks.findById(this.ctx, taskId);
+            if (!taskRecord) {
+                const errorText = typeof requestedVersion === "number" && Number.isFinite(requestedVersion)
+                    ? `Task not found: ${taskId}@${Math.trunc(requestedVersion)}`
+                    : `Task not found: ${taskId}`;
+                logger.warn({
+                    agentId: this.id,
+                    origin: item.origin ?? "system",
+                    taskId,
+                    taskVersion: requestedVersion,
+                    errorText
+                }, "error: Task reference lookup failed");
+                return {
+                    responseText: item.sync ? `<exec_error>${errorText}</exec_error>` : null,
+                    responseError: true,
+                    executionErrorText: errorText
+                };
+            }
+            executableCode = taskRecord.code;
+            if ((!inputSchema || inputSchema.length === 0) && taskRecord.parameters?.length) {
+                inputSchema = taskRecord.parameters;
+            }
+        }
+        if (typeof executableCode === "string") {
+            const startedAt = Date.now();
+            const run = await this.executableBlocksRun({
+                code: executableCode,
+                source: item.origin ?? "system",
+                messageContext: item.context ?? {},
+                inputValues: item.inputs,
+                inputSchema
+            });
+            if (run.skipTurn) {
+                logger.info({
+                    agentId: this.id,
+                    origin: item.origin ?? "system",
+                    codeBlockCount: 1,
+                    durationMs: Date.now() - startedAt
+                }, "event: Code execution skipped via skip()");
+                return { responseText: null };
+            }
+            executionHasError = run.errorMessage !== null;
+            if (run.errorMessage) {
+                executionErrorText = run.errorMessage;
+            }
+            // Sync mode: return code output directly without LLM inference
+            if (item.sync) {
+                logger.info({
+                    agentId: this.id,
+                    origin: item.origin ?? "system",
+                    codeBlockCount: 1,
+                    outputCount: 1,
+                    hasError: executionHasError,
+                    durationMs: Date.now() - startedAt
+                }, "event: Sync code execution completed");
+                return {
+                    responseText: run.output,
+                    responseError: executionHasError,
+                    ...(executionHasError ? { executionErrorText: executionErrorText ?? undefined } : {})
+                };
+            }
+            systemText = [systemText, run.output].filter((s) => s.trim().length > 0).join("\n\n");
+            logger.info({
+                agentId: this.id,
+                origin: item.origin ?? "system",
+                codeBlockCount: 1,
+                outputCount: 1,
+                durationMs: Date.now() - startedAt
+            }, "event: Code block executed");
+        }
+        const text = item.silent
+            ? messageBuildSystemSilentText(systemText, item.origin)
+            : messageBuildSystemText(systemText, item.origin);
+        if (item.silent) {
+            const receivedAt = Date.now();
+            await agentHistoryAppend(this.agentSystem.storage, this.ctx, {
+                type: "user_message",
+                at: receivedAt,
+                text,
+                files: []
+            });
+            const context = {};
+            const message = messageFormatIncoming({ text, files: [] }, context, new Date(receivedAt));
+            const entry = {
+                id: createId(),
+                message,
+                context,
+                receivedAt
+            };
+            const userMessage = await messageBuildUser(entry);
+            if (!this.state.context.messages) {
+                this.state.context.messages = [];
+            }
+            this.state.context.messages.push(userMessage);
+            this.state.updatedAt = receivedAt;
+            await agentStateWrite(this.agentSystem.storage, this.ctx, this.state);
+            return {
+                responseText: null,
+                ...(executionHasError
+                    ? { responseError: true, executionErrorText: executionErrorText ?? undefined }
+                    : {})
+            };
+        }
+        const messageItem = {
+            type: "message",
+            message: { text },
+            context: item.context ?? {}
+        };
+        const responseText = await this.handleMessage(messageItem);
+        return {
+            responseText,
+            ...(executionHasError ? { responseError: true, executionErrorText: executionErrorText ?? undefined } : {})
+        };
+    }
+    async handleSignal(item) {
+        const isInternalSignal = item.subscriptionPattern.startsWith("internal.");
+        const subscription = isInternalSignal
+            ? null
+            : await this.agentSystem.signals.subscriptionGet({
+                ctx: this.ctx,
+                pattern: item.subscriptionPattern
+            });
+        if (!isInternalSignal && !subscription) {
+            return { delivered: false, responseText: null };
+        }
+        const channelSignalData = channelSignalDataParse(item.signal.data);
+        const text = isChannelSignalType(item.signal.type) && channelSignalData
+            ? channelMessageBuild(channelSignalData)
+            : signalMessageBuild(item.signal);
+        const systemResult = await this.handleSystemMessage({
+            type: "system_message",
+            text,
+            origin: `signal:${item.signal.id}`,
+            silent: isInternalSignal ? false : (subscription?.silent ?? false),
+            context: {}
+        });
+        return { delivered: true, responseText: systemResult.responseText };
+    }
+    async handleReset(item) {
+        const now = Date.now();
+        this.endTurnCount = 0;
+        // End and invalidate old session before creating new one
+        const oldSessionId = this.state.activeSessionId;
+        if (oldSessionId) {
+            await this.agentSystem.storage.sessions.endSession(oldSessionId, now);
+            // Memory-agents must never trigger the memory worker
+            if (this.agentKindResolve() !== "memory") {
+                const maxHistoryId = await this.agentSystem.storage.history.maxId(oldSessionId);
+                if (maxHistoryId !== null) {
+                    await this.agentSystem.storage.sessions.invalidate(oldSessionId, maxHistoryId);
+                }
+            }
+        }
+        const resetMessage = item.message?.trim() ?? "";
+        if (resetMessage.length > 0) {
+            this.state.context = {
+                messages: [buildResetSystemMessage(resetMessage, now, this.id)]
+            };
+        }
+        else {
+            this.state.context = { messages: [] };
+        }
+        this.state.inferenceSessionId = createId();
+        this.state.activeSessionId = await this.agentSystem.storage.sessions.create({
+            agentId: this.id,
+            inferenceSessionId: this.state.inferenceSessionId,
+            createdAt: now,
+            resetMessage: resetMessage.length > 0 ? resetMessage : null
+        });
+        this.state.updatedAt = now;
+        this.documentLastReadVersions.clear();
+        await agentStateWrite(this.agentSystem.storage, this.ctx, this.state);
+        this.agentSystem.eventBus.emit("agent.reset", {
+            agentId: this.id,
+            context: item.context ?? {}
+        });
+        if (!this.config.foreground) {
+            return true;
+        }
+        if (!item.context) {
+            return true;
+        }
+        const target = await agentPathTargetResolve(this.agentSystem.storage, this.ctx.userId, this.config, this.path);
+        if (!target) {
+            return true;
+        }
+        const connector = this.agentSystem.connectorRegistry.get(target.connector);
+        if (!connector?.capabilities.sendText) {
+            return true;
+        }
+        try {
+            await connector.sendMessage(target.targetId, {
+                text: messageContextReset({ kind: "manual" }),
+                replyToMessageId: item.context?.messageId
+            });
+        }
+        catch (error) {
+            logger.warn({ agentId: this.id, error }, "error: Reset confirmation send failed");
+        }
+        return true;
+    }
+    async handleCompaction(item) {
+        const result = await this.runManualCompaction();
+        if (!this.config.foreground) {
+            return result.ok;
+        }
+        const target = await agentPathTargetResolve(this.agentSystem.storage, this.ctx.userId, this.config, this.path);
+        if (!target) {
+            return result.ok;
+        }
+        const connector = this.agentSystem.connectorRegistry.get(target.connector);
+        if (!connector?.capabilities.sendText) {
+            return result.ok;
+        }
+        const text = this.compactionResultText(result);
+        try {
+            await connector.sendMessage(target.targetId, {
+                text,
+                replyToMessageId: item.context?.messageId
+            });
+        }
+        catch (error) {
+            logger.warn({ agentId: this.id, error }, "error: Compaction command response failed");
+        }
+        return result.ok;
+    }
+    /**
+     * Resets the session when the emergency context limit is exceeded.
+     * Expects: reset record written and state persisted before notifying users.
+     */
+    async handleEmergencyReset(entry, source, contextOverflowTokens) {
+        const estimatedTokens = typeof contextOverflowTokens === "number" && contextOverflowTokens > 0
+            ? contextOverflowTokens
+            : contextEstimateTokens(await agentHistoryLoad(this.agentSystem.storage, this.ctx));
+        const reset = {
+            type: "reset",
+            message: "Emergency reset: context overflow detected. Previous session context was cleared."
+        };
+        await this.handleReset(reset);
+        if (this.resolveAgentKind() !== "foreground") {
+            return;
+        }
+        const target = await agentPathTargetResolve(this.agentSystem.storage, this.ctx.userId, this.config, this.path);
+        if (!target) {
+            return;
+        }
+        const connector = this.agentSystem.connectorRegistry.get(source || target.connector);
+        if (!connector?.capabilities.sendText) {
+            return;
+        }
+        try {
+            await connector.sendMessage(target.targetId, {
+                text: messageContextReset({ kind: "overflow", estimatedTokens }),
+                replyToMessageId: entry.context.messageId
+            });
+        }
+        catch (error) {
+            logger.warn({ agentId: this.id, error }, "error: Failed to notify user about emergency reset");
+        }
+    }
+    async handleRestore(_item) {
+        try {
+            await this.completePendingToolCalls("session_crashed");
+            const history = await agentHistoryLoad(this.agentSystem.storage, this.ctx);
+            const historyMessages = await this.buildHistoryContext(history);
+            this.state.context = {
+                messages: historyMessages
+            };
+            this.state.updatedAt = Date.now();
+            await agentStateWrite(this.agentSystem.storage, this.ctx, this.state);
+        }
+        catch (error) {
+            logger.warn({ agentId: this.id, error }, "restore: History restore failed; starting from scratch");
+            await this.handleReset({
+                type: "reset",
+                message: RESTORE_FAILURE_RESET_MESSAGE
+            });
+            await this.restoreFailureNotificationSend(RESTORE_FAILURE_RESET_MESSAGE);
+        }
+        this.agentSystem.eventBus.emit("agent.restored", { agentId: this.id });
+        return true;
+    }
+    async restoreFailureNotificationSend(text) {
+        if (this.resolveAgentKind() !== "foreground") {
+            return;
+        }
+        const target = await agentPathTargetResolve(this.agentSystem.storage, this.ctx.userId, this.config, this.path);
+        if (!target) {
+            return;
+        }
+        const connector = this.agentSystem.connectorRegistry.get(target.connector);
+        if (!connector?.capabilities.sendText) {
+            return;
+        }
+        try {
+            await connector.sendMessage(target.targetId, { text });
+        }
+        catch (error) {
+            logger.warn({ agentId: this.id, error }, "error: Failed to send restore failure notification");
+        }
+    }
+    async runManualCompaction() {
+        const messages = this.state.context.messages ?? [];
+        if (messages.length === 0) {
+            return { ok: false, reason: "empty" };
+        }
+        const { providers, providerId } = this.inferenceProvidersResolve();
+        if (providers.length === 0) {
+            return { ok: false, reason: "no_provider" };
+        }
+        const stopCompactionTyping = await this.startCompactionTypingIndicator();
+        const compactionAbortController = new AbortController();
+        this.inferenceAbortController = compactionAbortController;
+        try {
+            const compacted = await contextCompact({
+                context: this.state.context,
+                inferenceRouter: this.agentSystem.inferenceRouter,
+                providers,
+                providerId: providerId ?? undefined,
+                inferenceSessionId: this.state.inferenceSessionId ?? this.id,
+                signal: compactionAbortController.signal,
+                compactionLog: {
+                    agentsDir: this.agentSystem.config.current.agentsDir,
+                    agentId: this.id
+                }
+            });
+            const summaryMessage = compacted.messages?.[0];
+            const summaryText = summaryMessage ? (messageExtractText(summaryMessage)?.trim() ?? "") : "";
+            if (!summaryText) {
+                return { ok: false, reason: "empty_summary" };
+            }
+            const compactionAt = await this.applyCompactionSummary(summaryText);
+            this.state.updatedAt = compactionAt;
+            await agentStateWrite(this.agentSystem.storage, this.ctx, this.state);
+            return { ok: true };
+        }
+        catch (error) {
+            if (isAbortError(error, compactionAbortController.signal)) {
+                logger.info({ agentId: this.id }, "event: Manual compaction aborted");
+                return { ok: false, reason: "aborted" };
+            }
+            logger.warn({ agentId: this.id, error }, "error: Manual compaction failed");
+            return { ok: false, reason: "failed" };
+        }
+        finally {
+            stopCompactionTyping?.();
+            if (this.inferenceAbortController === compactionAbortController) {
+                this.inferenceAbortController = null;
+            }
+        }
+    }
+    compactionResultText(result) {
+        if (result.ok) {
+            return "Session compacted.";
+        }
+        switch (result.reason) {
+            case "empty":
+                return "Nothing to compact yet.";
+            case "empty_summary":
+                return "Compaction produced an empty summary; context unchanged.";
+            case "no_provider":
+                return "Compaction unavailable: no inference provider configured.";
+            case "aborted":
+                return "Compaction aborted.";
+            default:
+                return "Compaction failed.";
+        }
+    }
+    /**
+     * Completes dangling tool calls from persisted history with a synthetic result.
+     * Expects: called before rebuilding context or starting a new inference loop.
+     */
+    async completePendingToolCalls(reason) {
+        const records = await agentHistoryLoad(this.agentSystem.storage, this.ctx);
+        const pendingPhase = reason === "session_crashed" ? agentLoopPendingPhaseResolve(records) : null;
+        if (!pendingPhase) {
+            return;
+        }
+        const appendRecord = async (record) => {
+            await agentHistoryAppend(this.agentSystem.storage, this.ctx, record);
+            records.push(record);
+        };
+        const initialPhase = pendingPhase.type === "error" ? undefined : pendingPhase;
+        if (pendingPhase.type === "error") {
+            const completionMessage = pendingPhase.message;
+            await appendRecord(rlmHistoryCompleteErrorRecordBuild(pendingPhase.start.toolCallId, completionMessage, [], 0));
+        }
+        const source = this.sourceResolve();
+        const connector = this.agentSystem.connectorRegistry.get(source);
+        const { providers, providerId } = this.inferenceProvidersResolve();
+        const providersForAgent = providersForAgentResolve(providers, providerId);
+        const skills = this.skillsResolve();
+        const pendingContext = {
+            messages: await this.buildHistoryContext(records)
+        };
+        const entry = {
+            id: createId(),
+            receivedAt: Date.now(),
+            context: {},
+            message: {
+                text: "",
+                rawText: "",
+                files: []
+            }
+        };
+        await agentLoopRun({
+            entry,
+            agent: this,
+            source,
+            context: pendingContext,
+            connector,
+            connectorRegistry: this.agentSystem.connectorRegistry,
+            inferenceRouter: this.agentSystem.inferenceRouter,
+            toolResolver: this.agentSystem.toolResolver,
+            authStore: this.agentSystem.authStore,
+            eventBus: this.agentSystem.eventBus,
+            assistant: this.agentSystem.config.current.settings.assistant ?? null,
+            agentSystem: this.agentSystem,
+            webhooks: this.agentSystem.webhooks,
+            skills,
+            skillsActiveRoot: this.userHome.skillsActive,
+            skillsPersonalRoot: this.userHome.skillsPersonal,
+            providersForAgent,
+            logger,
+            appendHistoryRecord: (record) => agentHistoryAppend(this.agentSystem.storage, this.ctx, record),
+            notifySubagentFailure: (failureReason, error) => this.notifySubagentFailure(failureReason, error),
+            initialPhase,
+            stopAfterPendingPhase: false
+        });
+        const history = await agentHistoryLoad(this.agentSystem.storage, this.ctx);
+        const historyMessages = await this.buildHistoryContext(history);
+        this.state.context = {
+            messages: historyMessages
+        };
+        this.state.updatedAt = Date.now();
+        await agentStateWrite(this.agentSystem.storage, this.ctx, this.state);
+        logger.warn({
+            agentId: this.id,
+            reason,
+            phase: pendingPhase.type
+        }, "event: Completed pending loop phase in history");
+    }
+    /**
+     * Notifies a parent agent when a child background agent fails.
+     * Expects: parent agent exists.
+     */
+    async notifySubagentFailure(reason, error) {
+        if (this.agentKindResolve() !== "sub") {
+            return;
+        }
+        const parentAgentId = this.config.parentAgentId ?? null;
+        if (!parentAgentId) {
+            logger.warn({ agentId: this.id }, "event: Child agent missing parent agent");
+            return;
+        }
+        const kind = this.agentKindResolve();
+        const name = this.config.name ?? kind;
+        const pathKind = kind;
+        const errorText = error instanceof Error ? error.message : error ? String(error) : "";
+        const detail = errorText ? `${reason} (${errorText})` : reason;
+        try {
+            await this.agentSystem.post(this.ctx, { agentId: parentAgentId }, {
+                type: "system_message",
+                text: `${pathKind} ${name} (${this.id}) failed: ${detail}.`,
+                origin: this.id
+            });
+        }
+        catch (sendError) {
+            logger.warn({ agentId: this.id, parentAgentId, error: sendError }, "error: Child agent failure notification failed");
+        }
+    }
+    resolveAgentKind() {
+        return this.config.foreground ? "foreground" : "background";
+    }
+    agentKindResolve() {
+        return this.config.kind ?? "agent";
+    }
+    sourceResolve() {
+        const connector = this.config.connectorName?.trim() ?? "";
+        if (connector) {
+            return connector;
+        }
+        return this.agentKindResolve();
+    }
+    sandboxBuild() {
+        const dockerSettings = this.agentSystem.config?.current?.settings?.docker;
+        const examplesDir = bundledExamplesDirResolve();
+        const extraMounts = this.agentSystem.extraMountsForUserId(this.ctx.userId);
+        return new Sandbox({
+            homeDir: this.userHome.home,
+            permissions: this.state.permissions,
+            mounts: [
+                { hostPath: this.userHome.skillsActive, mappedPath: "/shared/skills" },
+                ...(examplesDir ? [{ hostPath: examplesDir, mappedPath: "/shared/examples" }] : []),
+                ...extraMounts
+            ],
+            docker: dockerSettings?.enabled
+                ? {
+                    enabled: true,
+                    image: dockerSettings.image,
+                    tag: dockerSettings.tag,
+                    socketPath: dockerSettings.socketPath,
+                    runtime: dockerSettings.runtime,
+                    enableWeakerNestedSandbox: dockerSettings.enableWeakerNestedSandbox,
+                    readOnly: dockerSettings.readOnly,
+                    unconfinedSecurity: dockerSettings.unconfinedSecurity,
+                    capAdd: dockerSettings.capAdd,
+                    capDrop: dockerSettings.capDrop,
+                    allowLocalNetworkingForUsers: dockerSettings.allowLocalNetworkingForUsers,
+                    isolatedDnsServers: dockerSettings.isolatedDnsServers,
+                    localDnsServers: dockerSettings.localDnsServers,
+                    userId: this.ctx.userId
+                }
+                : undefined
+        });
+    }
+    inferenceProvidersResolve() {
+        const rawProviders = listActiveInferenceProviders(this.agentSystem.config.current.settings);
+        const roleKey = this.config.modelRole ?? null;
+        // Resolve model via rule-based matching first, then fall back to settings config
+        const ruleModel = this.agentSystem.modelRoles?.resolve({
+            role: roleKey,
+            kind: this.config.kind ?? null,
+            userId: this.ctx.userId,
+            agentId: this.id
+        });
+        const roleConfig = ruleModel ?? (roleKey ? this.agentSystem.config.current.settings.models?.[roleKey] : undefined);
+        const roleApplied = modelRoleApply(rawProviders, roleConfig);
+        const roleProviders = roleApplied.providers;
+        const providerId = roleApplied.providerId ?? this.resolveAgentProvider(roleProviders);
+        const providers = agentModelOverrideApply(roleProviders, this.state.modelOverride, providerId, this.agentSystem.config.current.settings.modelFlavors);
+        return { providers, providerId };
+    }
+    skillsResolve() {
+        const configSkillsRoot = path.join(this.agentSystem.config.current.configDir, "skills");
+        return new Skills({
+            configRoot: configSkillsRoot,
+            pluginManager: this.agentSystem.pluginManager,
+            userPersonalRoot: this.userHome.skillsPersonal,
+            userActiveRoot: this.userHome.skillsActive,
+            agentsRoot: path.join(os.homedir(), ".agents", "skills")
+        });
+    }
+    resolveAgentProvider(providers) {
+        const activeIds = new Set(providers.map((provider) => provider.id));
+        let providerId = this.providerId ?? null;
+        if (!providerId || !activeIds.has(providerId)) {
+            providerId = providers[0]?.id ?? null;
+        }
+        if (providerId && this.providerId !== providerId) {
+            this.providerId = providerId;
+        }
+        return providerId;
+    }
+    /**
+     * Starts typing indication for foreground user agents during long compaction operations.
+     * Expects: connector supports startTyping for the active target.
+     */
+    async startCompactionTypingIndicator() {
+        if (!this.config.foreground) {
+            return null;
+        }
+        const target = await agentPathTargetResolve(this.agentSystem.storage, this.ctx.userId, this.config, this.path);
+        if (!target) {
+            return null;
+        }
+        const connector = this.agentSystem.connectorRegistry.get(target.connector);
+        return connector?.startTyping?.(target.targetId) ?? null;
+    }
+    async buildHistoryContext(records) {
+        return agentHistoryContext(records, this.id);
+    }
+    async applyCompactionSummary(summaryText) {
+        const summaryWithContinue = `${summaryText}\n\nPlease continue with the user's latest request.`;
+        const compactionAt = Date.now();
+        const resetMessage = "Session context compacted.";
+        this.endTurnCount = 0;
+        // End and invalidate old session before creating new one
+        const oldSessionId = this.state.activeSessionId;
+        if (oldSessionId) {
+            await this.agentSystem.storage.sessions.endSession(oldSessionId, compactionAt);
+            // Memory-agents must never trigger the memory worker
+            if (this.agentKindResolve() !== "memory") {
+                const maxHistoryId = await this.agentSystem.storage.history.maxId(oldSessionId);
+                if (maxHistoryId !== null) {
+                    await this.agentSystem.storage.sessions.invalidate(oldSessionId, maxHistoryId);
+                }
+            }
+        }
+        this.state.context = {
+            messages: [
+                buildResetSystemMessage(resetMessage, compactionAt, this.id),
+                {
+                    role: "user",
+                    content: summaryWithContinue,
+                    timestamp: compactionAt
+                }
+            ]
+        };
+        this.state.inferenceSessionId = createId();
+        this.state.activeSessionId = await this.agentSystem.storage.sessions.create({
+            agentId: this.id,
+            inferenceSessionId: this.state.inferenceSessionId,
+            createdAt: compactionAt,
+            resetMessage
+        });
+        this.documentLastReadVersions.clear();
+        await agentStateWrite(this.agentSystem.storage, this.ctx, this.state);
+        await agentHistoryAppend(this.agentSystem.storage, this.ctx, {
+            type: "user_message",
+            at: compactionAt,
+            text: summaryWithContinue,
+            files: []
+        });
+        return compactionAt;
+    }
+}
+function isChannelSignalType(type) {
+    return type.startsWith("channel.") && type.endsWith(":message");
+}
+function toFileReferences(files) {
+    return files.map((file) => ({
+        id: file.id,
+        name: file.name,
+        path: file.path,
+        mimeType: file.mimeType,
+        size: file.size
+    }));
+}
+function buildResetSystemMessage(text, at, origin) {
+    return {
+        role: "user",
+        content: messageBuildSystemText(text, origin),
+        timestamp: at
+    };
+}
+function providersForAgentResolve(providers, providerId) {
+    const selected = providerId ? providers.filter((provider) => provider.id === providerId) : providers;
+    if (selected.length > 0) {
+        return selected;
+    }
+    return providers;
+}
+function isAbortError(error, signal) {
+    if (signal?.aborted) {
+        return true;
+    }
+    if (error instanceof Error) {
+        return error.name === "AbortError" || error.message.toLowerCase().includes("abort");
+    }
+    return false;
+}
+//# sourceMappingURL=agent.js.map