daycare-cli 0.0.30 → 0.0.32

package/dist/engine/agents/agent.js

@@ -1,34 +1,26 @@
-import { promises as fs } from "node:fs";
-import os from "node:os";
 import path from "node:path";
 import { createId } from "@paralleldrive/cuid2";
-import Handlebars from "handlebars";
 import { getLogger } from "../../log.js";
-import { DEFAULT_AGENTS_PATH, DEFAULT_MEMORY_PATH, DEFAULT_SOUL_PATH, DEFAULT_TOOLS_PATH, DEFAULT_USER_PATH } from "../../paths.js";
 import { listActiveInferenceProviders } from "../../providers/catalog.js";
 import { cuid2Is } from "../../utils/cuid2Is.js";
-import { agentPromptBundledRead } from "./ops/agentPromptBundledRead.js";
+import { agentSystemPrompt } from "./ops/agentSystemPrompt.js";
 import { agentPromptFilesEnsure } from "./ops/agentPromptFilesEnsure.js";
-import { agentPromptResolve } from "./ops/agentPromptResolve.js";
+import { agentPromptPathsResolve } from "./ops/agentPromptPathsResolve.js";
 import { messageBuildUser } from "../messages/messageBuildUser.js";
 import { messageFormatIncoming } from "../messages/messageFormatIncoming.js";
 import { messageBuildSystemText } from "../messages/messageBuildSystemText.js";
 import { messageBuildSystemSilentText } from "../messages/messageBuildSystemSilentText.js";
 import { messageExtractText } from "../messages/messageExtractText.js";
 import { contextCompact } from "./ops/contextCompact.js";
-import { contextCompactionStatusBuild } from "./ops/contextCompactionStatusBuild.js";
+import { contextCompactionStatus } from "./ops/contextCompactionStatus.js";
 import { contextEstimateTokens } from "./ops/contextEstimateTokens.js";
 import { messageContextReset } from "./ops/messageContextReset.js";
 import { permissionClone } from "../permissions/permissionClone.js";
 import { permissionEnsureDefaultFile } from "../permissions/permissionEnsureDefaultFile.js";
 import { permissionMergeDefault } from "../permissions/permissionMergeDefault.js";
 import { permissionTagsApply } from "../permissions/permissionTagsApply.js";
-import { permissionWorkspaceGranted } from "../permissions/permissionWorkspaceGranted.js";
-import { skillPromptFormat } from "../skills/skillPromptFormat.js";
 import { Skills } from "../skills/skills.js";
 import { toolListContextBuild } from "../modules/tools/toolListContextBuild.js";
-import { agentPermanentList } from "./ops/agentPermanentList.js";
-import { agentPermanentPromptBuild } from "./ops/agentPermanentPromptBuild.js";
 import { agentDescriptorIsCron } from "./ops/agentDescriptorIsCron.js";
 import { agentDescriptorIsHeartbeat } from "./ops/agentDescriptorIsHeartbeat.js";
 import { agentDescriptorTargetResolve } from "./ops/agentDescriptorTargetResolve.js";
@@ -40,8 +32,17 @@ import { agentStateWrite } from "./ops/agentStateWrite.js";
 import { agentDescriptorWrite } from "./ops/agentDescriptorWrite.js";
 import { agentSystemPromptWrite } from "./ops/agentSystemPromptWrite.js";
 import { agentRestoreContextResolve } from "./ops/agentRestoreContextResolve.js";
-import { agentHistoryPendingToolResultsBuild } from "./ops/agentHistoryPendingToolResultsBuild.js";
-import { agentAppFolderPathResolve } from "./ops/agentAppFolderPathResolve.js";
+import { agentHistoryContext } from "./ops/agentHistoryContext.js";
+import { agentHistoryPendingRlmResolve } from "./ops/agentHistoryPendingRlmResolve.js";
+import { agentHistoryPendingToolResults } from "./ops/agentHistoryPendingToolResults.js";
+import { rlmErrorTextBuild } from "../modules/rlm/rlmErrorTextBuild.js";
+import { rlmHistoryCompleteErrorRecordBuild } from "../modules/rlm/rlmHistoryCompleteErrorRecordBuild.js";
+import { RLM_TOOL_NAME } from "../modules/rlm/rlmConstants.js";
+import { rlmNoToolsModeIs } from "../modules/rlm/rlmNoToolsModeIs.js";
+import { rlmToolDescriptionBuild } from "../modules/rlm/rlmToolDescriptionBuild.js";
+import { rlmRestore } from "../modules/rlm/rlmRestore.js";
+import { rlmResultTextBuild } from "../modules/rlm/rlmResultTextBuild.js";
+import { rlmToolResultBuild } from "../modules/rlm/rlmToolResultBuild.js";
 import { signalMessageBuild } from "../signals/signalMessageBuild.js";
 import { channelMessageBuild, channelSignalDataParse } from "../channels/channelMessageBuild.js";
 const logger = getLogger("engine.agent");
@@ -258,40 +259,12 @@ export class Agent {
         const providers = listActiveInferenceProviders(this.agentSystem.config.current.settings);
         const providerId = this.resolveAgentProvider(providers);
         const connector = this.agentSystem.connectorRegistry.get(source);
-        const connectorCapabilities = connector?.capabilities ?? null;
-        const fileSendModes = connectorCapabilities?.sendFiles?.modes ?? [];
-        const cronTasks = await this.agentSystem.crons.listTasks();
-        const cronTaskIds = cronTasks.map((task) => task.id);
-        const descriptor = this.descriptor;
-        const cronTask = agentDescriptorIsCron(descriptor)
-            ? cronTasks.find((task) => task.taskUid === descriptor.id) ?? null
-            : null;
-        const descriptorContext = descriptor.type === "user"
-            ? {
-                connector: descriptor.connector,
-                channelId: descriptor.channelId,
-                userId: descriptor.userId
-            }
-            : { connector: source };
         const pluginManager = this.agentSystem.pluginManager;
-        logger.debug(`load: handleMessage loading plugin prompts agentId=${this.id}`);
-        const pluginPrompts = await pluginManager.getSystemPrompts();
-        const pluginPrompt = pluginPrompts.length > 0 ? pluginPrompts.join("\n\n") : "";
         const configSkillsRoot = path.join(this.agentSystem.config.current.configDir, "skills");
         const skills = new Skills({
             configRoot: configSkillsRoot,
             pluginManager
         });
-        logger.debug(`load: handleMessage loading available skills agentId=${this.id}`);
-        const availableSkills = await skills.list();
-        const skillsPrompt = skillPromptFormat(availableSkills);
-        const permanentAgents = await agentPermanentList(this.agentSystem.config.current);
-        const permanentAgentsPrompt = agentPermanentPromptBuild(permanentAgents);
-        const promptResolved = await agentPromptResolve(this.descriptor);
-        const agentPrompt = promptResolved.agentPrompt;
-        const replaceSystemPrompt = this.descriptor.type === "system"
-            ? promptResolved.replaceSystemPrompt
-            : false;
         const agentKind = this.resolveAgentKind();
         const allowCronTools = agentDescriptorIsCron(this.descriptor);
         const defaultPermissions = this.agentSystem.config.current.defaultPermissions;
@@ -308,49 +281,23 @@ export class Agent {
                 logger.warn({ agentId: this.id, error }, "error: Failed to apply task permissions");
             }
         }
-        logger.debug(`event: handleMessage ensuring prompt files agentId=${this.id}`);
-        await agentPromptFilesEnsure();
+        const toolResolver = item.toolResolverOverride ?? this.agentSystem.toolResolver;
         const providerSettings = providerId
             ? providers.find((provider) => provider.id === providerId)
             : providers[0];
+        const availableTools = toolResolver.listTools();
+        const noToolsModeEnabled = rlmNoToolsModeIs(this.agentSystem.config.current.features);
+        const rlmToolDescription = this.agentSystem.config.current.features.rlm && !noToolsModeEnabled
+            ? await rlmToolDescriptionBuild(availableTools)
+            : undefined;
+        await agentPromptFilesEnsure(agentPromptPathsResolve(this.agentSystem.config.current.dataDir));
         logger.debug(`event: handleMessage building system prompt agentId=${this.id}`);
-        const appFolderPath = agentAppFolderPathResolve(this.descriptor, this.agentSystem.config.current.workspaceDir);
-        const workspacePermissionGranted = permissionWorkspaceGranted(this.state.permissions);
-        const systemPrompt = await this.buildSystemPrompt({
+        const systemPrompt = await agentSystemPrompt({
             provider: providerSettings?.id,
             model: providerSettings?.model,
-            workspace: this.state.permissions.workingDir,
-            appFolderPath: appFolderPath ?? "",
-            workspacePermissionGranted,
-            writeDirs: this.state.permissions.writeDirs,
-            network: this.state.permissions.network,
-            events: this.state.permissions.events,
-            connector: descriptorContext.connector,
-            canSendFiles: fileSendModes.length > 0,
-            fileSendModes: fileSendModes.length > 0 ? fileSendModes.join(", ") : "",
-            messageFormatPrompt: connectorCapabilities?.messageFormatPrompt ?? "",
-            channelId: descriptorContext.channelId,
-            userId: descriptorContext.userId,
-            cronTaskId: cronTask?.id,
-            cronTaskName: cronTask?.name,
-            cronMemoryPath: cronTask?.memoryPath,
-            cronFilesPath: cronTask?.filesPath,
-            cronTaskIds: cronTaskIds.length > 0 ? cronTaskIds.join(", ") : "",
-            soulPath: DEFAULT_SOUL_PATH,
-            userPath: DEFAULT_USER_PATH,
-            agentsPath: DEFAULT_AGENTS_PATH,
-            toolsPath: DEFAULT_TOOLS_PATH,
-            memoryPath: DEFAULT_MEMORY_PATH,
-            pluginPrompt,
-            skillsPrompt,
-            permanentAgentsPrompt,
-            agentPrompt,
-            replaceSystemPrompt,
-            agentKind,
-            parentAgentId: this.descriptor.type === "subagent" || this.descriptor.type === "app"
-                ? this.descriptor.parentAgentId ?? ""
-                : "",
-            configDir: this.agentSystem.config.current.configDir
+            permissions: this.state.permissions,
+            descriptor: this.descriptor,
+            agentSystem: this.agentSystem
         });
         try {
             const wrote = await agentSystemPromptWrite(this.agentSystem.config.current, this.id, systemPrompt);
@@ -361,14 +308,13 @@ export class Agent {
         catch (error) {
             logger.warn({ agentId: this.id, error }, "error: Failed to write system prompt snapshot");
         }
-        const toolResolver = item.toolResolverOverride ?? this.agentSystem.toolResolver;
         const history = await agentHistoryLoad(this.agentSystem.config.current, this.id);
-        const contextTools = this.listContextTools(toolResolver, source, {
+        const contextTools = await this.listContextTools(toolResolver, source, {
             agentKind,
             allowCronTools,
-            skills: availableSkills
+            rlmToolDescription
         });
-        const compactionStatus = contextCompactionStatusBuild(history, this.agentSystem.config.current.settings.agents.emergencyContextLimit, {
+        const compactionStatus = contextCompactionStatus(history, this.agentSystem.config.current.settings.agents.emergencyContextLimit, {
             extras: {
                 systemPrompt,
                 tools: contextTools,
@@ -771,18 +717,99 @@ export class Agent {
      */
     async completePendingToolCalls(reason) {
         const records = await agentHistoryLoadAll(this.agentSystem.config.current, this.id);
-        const completionRecords = agentHistoryPendingToolResultsBuild(records, reason, Date.now());
-        if (completionRecords.length === 0) {
-            return;
-        }
+        const pendingRlm = reason === "session_crashed" ? agentHistoryPendingRlmResolve(records) : null;
+        const pendingRlmToolCallId = pendingRlm?.start.toolCallId ?? null;
+        const completionRecords = agentHistoryPendingToolResults(records, reason, Date.now()).filter((record) => !(pendingRlmToolCallId &&
+            record.type === "tool_result" &&
+            record.toolCallId === pendingRlmToolCallId));
+        let completedToolCalls = 0;
         for (const record of completionRecords) {
             await agentHistoryAppend(this.agentSystem.config.current, this.id, record);
+            records.push(record);
+            completedToolCalls += 1;
         }
-        logger.warn({
-            agentId: this.id,
-            reason,
-            completedToolCalls: completionRecords.length
-        }, "event: Completed pending tool calls in history");
+        if (pendingRlm) {
+            const appendRecord = async (record) => {
+                await agentHistoryAppend(this.agentSystem.config.current, this.id, record);
+                records.push(record);
+            };
+            const toolCall = pendingRlm.start.toolCallId;
+            let toolResultText = "";
+            let toolResultIsError = false;
+            let restoreMessage = "RLM execution completed after restart. Output: (empty)";
+            if (!pendingRlm.lastSnapshot) {
+                const message = "Process was restarted before any tool call";
+                await appendRecord(rlmHistoryCompleteErrorRecordBuild(toolCall, message));
+                toolResultText = rlmErrorTextBuild(new Error(message));
+                toolResultIsError = true;
+                restoreMessage = `RLM execution failed after restart. ${message}`;
+            }
+            else {
+                const source = this.descriptor.type === "user"
+                    ? this.descriptor.connector
+                    : this.descriptor.type === "system"
+                        ? this.descriptor.tag
+                        : this.descriptor.type;
+                try {
+                    const restored = await rlmRestore(pendingRlm.lastSnapshot, pendingRlm.start, this.agentSystem.toolResolver, this.rlmRestoreContextBuild(source), appendRecord);
+                    toolResultText = rlmResultTextBuild(restored);
+                    restoreMessage = `RLM execution completed after restart. Output: ${restored.output.length > 0 ? restored.output : "(empty)"}`;
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    await appendRecord(rlmHistoryCompleteErrorRecordBuild(toolCall, message, pendingRlm.lastSnapshot.printOutput, pendingRlm.lastSnapshot.toolCallCount));
+                    toolResultText = rlmErrorTextBuild(error);
+                    toolResultIsError = true;
+                    restoreMessage = `RLM execution failed after restart. ${message}`;
+                }
+            }
+            const result = rlmToolResultBuild({ id: toolCall, name: RLM_TOOL_NAME }, toolResultText, toolResultIsError);
+            await appendRecord({
+                type: "tool_result",
+                at: Date.now(),
+                toolCallId: toolCall,
+                output: result
+            });
+            await appendRecord({
+                type: "user_message",
+                at: Date.now(),
+                text: messageBuildSystemText(restoreMessage, "rlm_restore"),
+                files: []
+            });
+            completedToolCalls += 1;
+        }
+        if (completedToolCalls > 0) {
+            const history = await agentHistoryLoad(this.agentSystem.config.current, this.id);
+            const historyMessages = await this.buildHistoryContext(history);
+            this.state.context = {
+                messages: agentRestoreContextResolve(this.state.context.messages ?? [], historyMessages)
+            };
+            this.state.updatedAt = Date.now();
+            await agentStateWrite(this.agentSystem.config.current, this.id, this.state);
+            logger.warn({
+                agentId: this.id,
+                reason,
+                completedToolCalls
+            }, "event: Completed pending tool calls in history");
+        }
+    }
+    rlmRestoreContextBuild(source) {
+        return {
+            connectorRegistry: this.agentSystem.connectorRegistry,
+            fileStore: this.agentSystem.fileStore,
+            auth: this.agentSystem.authStore,
+            logger,
+            assistant: this.agentSystem.config.current.settings.assistant ?? null,
+            permissions: this.state.permissions,
+            agent: this,
+            source,
+            messageContext: {},
+            agentSystem: this.agentSystem,
+            heartbeats: this.agentSystem.heartbeats,
+            toolResolver: this.agentSystem.toolResolver,
+            skills: [],
+            permissionRequestRegistry: this.agentSystem.permissionRequestRegistry
+        };
     }
     /**
      * Notifies a parent agent when a child background agent fails.
@@ -825,14 +852,21 @@ export class Agent {
         const task = tasks.find((entry) => entry.taskUid === descriptor.id) ?? null;
         return task?.id ?? null;
     }
-    listContextTools(toolResolver, source, options) {
+    async listContextTools(toolResolver, source, options) {
+        const tools = toolResolver.listTools();
+        const noToolsModeEnabled = rlmNoToolsModeIs(this.agentSystem.config.current.features);
+        let rlmToolDescription = options?.rlmToolDescription;
+        if (!rlmToolDescription && this.agentSystem.config.current.features.rlm && !noToolsModeEnabled) {
+            rlmToolDescription = await rlmToolDescriptionBuild(tools);
+        }
         return toolListContextBuild({
-            tools: toolResolver.listTools(),
-            skills: options?.skills,
+            tools,
             source,
             agentKind: options?.agentKind,
             allowCronTools: options?.allowCronTools,
+            noTools: noToolsModeEnabled,
             rlm: this.agentSystem.config.current.features.rlm,
+            rlmToolDescription,
             connectorRegistry: this.agentSystem.connectorRegistry,
             imageRegistry: this.agentSystem.imageRegistry
         });
@@ -870,62 +904,7 @@ export class Agent {
         return connector?.startTyping?.(target.targetId) ?? null;
     }
     async buildHistoryContext(records) {
-        const messages = [];
-        for (const record of records) {
-            if (record.type === "reset" && record.message && record.message.trim().length > 0) {
-                messages.push(buildResetSystemMessage(record.message, record.at, this.id));
-            }
-            if (record.type === "user_message") {
-                const context = {};
-                const message = messageFormatIncoming({
-                    text: record.text,
-                    files: record.files.map((file) => ({ ...file }))
-                }, context, new Date(record.at));
-                const userEntry = {
-                    id: createId(),
-                    message,
-                    context,
-                    receivedAt: record.at
-                };
-                messages.push(await messageBuildUser(userEntry));
-            }
-            if (record.type === "assistant_message") {
-                const content = [];
-                if (record.text.length > 0) {
-                    content.push({ type: "text", text: record.text });
-                }
-                for (const toolCall of record.toolCalls) {
-                    content.push(toolCall);
-                }
-                messages.push({
-                    role: "assistant",
-                    content,
-                    api: "history",
-                    provider: "history",
-                    model: "history",
-                    usage: {
-                        input: 0,
-                        output: 0,
-                        cacheRead: 0,
-                        cacheWrite: 0,
-                        totalTokens: 0,
-                        cost: {
-                            input: 0,
-                            output: 0,
-                            cacheRead: 0,
-                            cacheWrite: 0,
-                            total: 0
-                        }
-                    },
-                    stopReason: "stop",
-                    timestamp: record.at
-                });
-            }
-            if (record.type === "tool_result") {
-                messages.push(record.output.toolMessage);
-            }
-        }
-        return messages;
+        return agentHistoryContext(records, this.id);
     }
     async applyCompactionSummary(summaryText) {
         const summaryWithContinue = `${summaryText}\n\nPlease continue with the user's latest request.`;
@@ -955,132 +934,10 @@ export class Agent {
         });
         return compactionAt;
     }
-    /**
-     * Builds the system prompt text for the current agent.
-     * Expects: prompt templates exist under engine/prompts.
-     */
-    async buildSystemPrompt(context = {}) {
-        if (context.replaceSystemPrompt) {
-            const replaced = (context.agentPrompt ?? "").trim();
-            if (!replaced) {
-                throw new Error("System prompt replacement requires a non-empty agent prompt.");
-            }
-            return replaced;
-        }
-        const soulPath = context.soulPath ?? DEFAULT_SOUL_PATH;
-        const userPath = context.userPath ?? DEFAULT_USER_PATH;
-        const agentsPath = context.agentsPath ?? DEFAULT_AGENTS_PATH;
-        const toolsPath = context.toolsPath ?? DEFAULT_TOOLS_PATH;
-        const memoryPath = context.memoryPath ?? DEFAULT_MEMORY_PATH;
-        logger.debug(`event: buildSystemPrompt reading soul prompt path=${soulPath}`);
-        const soul = await promptFileRead(soulPath, "SOUL.md");
-        logger.debug(`event: buildSystemPrompt reading user prompt path=${userPath}`);
-        const user = await promptFileRead(userPath, "USER.md");
-        logger.debug(`event: buildSystemPrompt reading agents prompt path=${agentsPath}`);
-        const agents = await promptFileRead(agentsPath, "AGENTS.md");
-        logger.debug(`event: buildSystemPrompt reading tools prompt path=${toolsPath}`);
-        const tools = await promptFileRead(toolsPath, "TOOLS.md");
-        logger.debug(`event: buildSystemPrompt reading memory prompt path=${memoryPath}`);
-        const memory = await promptFileRead(memoryPath, "MEMORY.md");
-        logger.debug("event: buildSystemPrompt reading system template");
-        const systemTemplate = await agentPromptBundledRead("SYSTEM.md");
-        logger.debug("event: buildSystemPrompt reading permissions template");
-        const permissionsTemplate = (await agentPromptBundledRead("PERMISSIONS.md")).trim();
-        logger.debug("event: buildSystemPrompt reading agentic template");
-        const agenticTemplate = (await agentPromptBundledRead("AGENTIC.md")).trim();
-        const additionalWriteDirs = resolveAdditionalWriteDirs(context.writeDirs ?? [], context.workspace ?? "", soulPath, userPath, agentsPath, toolsPath, memoryPath);
-        const isForeground = context.agentKind !== "background";
-        const skillsPath = context.skillsPath ?? (context.configDir ? `${context.configDir}/skills` : "");
-        // Build shared context for both permissions and main templates
-        const templateContext = {
-            date: new Date().toISOString().split("T")[0],
-            os: `${os.type()} ${os.release()}`,
-            arch: os.arch(),
-            model: context.model ?? "unknown",
-            provider: context.provider ?? "unknown",
-            workspace: context.workspace ?? "unknown",
-            network: context.network ?? false,
-            events: context.events ?? false,
-            connector: context.connector ?? "unknown",
-            canSendFiles: context.canSendFiles ?? false,
-            fileSendModes: context.fileSendModes ?? "",
-            messageFormatPrompt: context.messageFormatPrompt ?? "",
-            channelId: context.channelId ?? "unknown",
-            userId: context.userId ?? "unknown",
-            cronTaskId: context.cronTaskId ?? "",
-            cronTaskName: context.cronTaskName ?? "",
-            cronMemoryPath: context.cronMemoryPath ?? "",
-            cronFilesPath: context.cronFilesPath ?? "",
-            cronTaskIds: context.cronTaskIds ?? "",
-            appFolderPath: context.appFolderPath ?? "",
-            workspacePermissionGranted: context.workspacePermissionGranted ?? false,
-            soulPath,
-            userPath,
-            agentsPath,
-            toolsPath,
-            memoryPath,
-            pluginPrompt: context.pluginPrompt ?? "",
-            skillsPrompt: context.skillsPrompt ?? "",
-            parentAgentId: context.parentAgentId ?? "",
-            configDir: context.configDir ?? "",
-            skillsPath,
-            isForeground,
-            soul,
-            user,
-            agents,
-            tools,
-            memory,
-            additionalWriteDirs,
-            permanentAgentsPrompt: context.permanentAgentsPrompt ?? "",
-            agentPrompt: context.agentPrompt ?? "",
-            features: this.agentSystem.config.current.features
-        };
-        // Render permissions template first (it contains Handlebars expressions)
-        logger.debug("event: buildSystemPrompt compiling permissions template");
-        const permissions = Handlebars.compile(permissionsTemplate)(templateContext);
-        logger.debug("event: buildSystemPrompt compiling agentic template");
-        const agentic = Handlebars.compile(agenticTemplate)(templateContext);
-        logger.debug("event: buildSystemPrompt compiling main template");
-        const template = Handlebars.compile(systemTemplate);
-        logger.debug("event: buildSystemPrompt rendering template");
-        const rendered = template({
-            ...templateContext,
-            permissions,
-            agentic
-        });
-        return rendered.trim();
-    }
 }
 function isChannelSignalType(type) {
     return type.startsWith("channel.") && type.endsWith(":message");
 }
-function resolveAdditionalWriteDirs(writeDirs, workspace, soulPath, userPath, agentsPath, toolsPath, memoryPath) {
-    const excluded = new Set([workspace, soulPath, userPath, agentsPath, toolsPath, memoryPath]
-        .filter((entry) => entry && entry.trim().length > 0)
-        .map((entry) => path.resolve(entry)));
-    const filtered = writeDirs
-        .filter((entry) => typeof entry === "string" && entry.trim().length > 0)
-        .map((entry) => path.resolve(entry))
-        .filter((entry) => !excluded.has(entry));
-    return Array.from(new Set(filtered)).sort();
-}
-async function promptFileRead(filePath, fallbackPrompt) {
-    const resolvedPath = path.resolve(filePath);
-    try {
-        const content = await fs.readFile(resolvedPath, "utf8");
-        const trimmed = content.trim();
-        if (trimmed.length > 0) {
-            return trimmed;
-        }
-    }
-    catch (error) {
-        if (error.code !== "ENOENT") {
-            throw error;
-        }
-    }
-    const defaultContent = await agentPromptBundledRead(fallbackPrompt);
-    return defaultContent.trim();
-}
 function toFileReferences(files) {
     return files.map((file) => ({
         id: file.id,