@botbotgo/agent-harness 0.0.298 → 0.0.300

package/dist/runtime/support/runtime-prompts.js

@@ -0,0 +1,55 @@
+import { readBundledText, renderBundledTemplate, renderTemplateText } from "../../utils/bundled-text.js";
+function readRuntimePrompt(name) {
+    return readBundledText(`prompts/runtime/${name}.md`).trim();
+}
+export const WORKSPACE_BOUNDARY_GUIDANCE = readRuntimePrompt("workspace-boundary-guidance");
+export const DEFAULT_SUBAGENT_PROMPT = readRuntimePrompt("default-subagent");
+export const STRICT_TOOL_JSON_INSTRUCTION = readRuntimePrompt("strict-tool-json");
+export const BROWSER_CAPABILITY_DISCLAIMER_RECOVERY_INSTRUCTION = readRuntimePrompt("browser-capability-disclaimer-recovery");
+export const INVALID_TOOL_SELECTION_RECOVERY_INSTRUCTION = readRuntimePrompt("invalid-tool-selection-recovery");
+export const WRITE_TODOS_FULL_ENTRY_INSTRUCTION = readRuntimePrompt("write-todos-full-entry");
+export const WRITE_TODOS_NON_EMPTY_INITIAL_LIST_INSTRUCTION = readRuntimePrompt("write-todos-non-empty-initial-list");
+export const WRITE_TODOS_DESCRIPTIVE_CONTENT_INSTRUCTION = readRuntimePrompt("write-todos-descriptive-content");
+export const EXECUTION_WITH_TOOL_EVIDENCE_INSTRUCTION = readRuntimePrompt("execution-with-tool-evidence");
+export const EXECUTION_WITH_TOOL_EVIDENCE_RETRY_INSTRUCTION = readRuntimePrompt("execution-with-tool-evidence-retry");
+export const WORKSPACE_RELATIVE_PATH_INSTRUCTION = readRuntimePrompt("workspace-relative-path");
+export function renderDurableMemoryContextPrompt(memoryContext) {
+    return renderBundledTemplate("prompts/runtime/durable-memory-context.md", {
+        memoryContext: memoryContext.trim(),
+    });
+}
+export function renderSlashCommandSkillInstruction(input) {
+    return renderBundledTemplate("prompts/runtime/slash-command-skill.md", {
+        skillQualifier: input.skillQualifier,
+        skillName: input.skillName,
+        argumentText: JSON.stringify(input.argumentText),
+        dryRunHint: input.dryRunHint,
+    });
+}
+export function renderRuntimeMemoryManagerPrompt(input) {
+    const existing = input.existingRecords.length === 0
+        ? "(none)"
+        : input.existingRecords
+            .map((record) => `- scope=${record.scope}; kind=${record.kind}; summary=${record.summary}; status=${record.status};${record.knowledgeIdentity ? ` knowledge_identity=${record.knowledgeIdentity}; knowledge_operation=${record.knowledgeOperation ?? "create"};` : ""}${record.operationalRule ? ` operational_rule=${record.operationalRule.trigger}->${record.operationalRule.action}(${record.operationalRule.target})[${record.operationalRule.effect ?? "apply"}];` : ""} content=${record.content.replace(/\s+/g, " ").slice(0, 220)}`)
+            .join("\n");
+    const values = {
+        sessionId: input.sessionId,
+        requestId: input.requestId,
+        candidateJson: JSON.stringify(input.candidate, null, 2),
+        existingRecords: existing,
+    };
+    return input.template
+        ? renderTemplateText(input.template, values)
+        : renderBundledTemplate("prompts/runtime/memory-manager.md", values);
+}
+export function renderRuntimeMemoryMutationReconciliationPrompt(input) {
+    const existing = input.existingRecords.length === 0
+        ? "(none)"
+        : input.existingRecords
+            .map((record) => `- knowledge_identity=${record.knowledgeIdentity ?? "(none)"}; scope=${record.scope}; kind=${record.kind}; status=${record.status}; summary=${record.summary};${record.operationalRule ? ` operational_rule=${record.operationalRule.trigger}->${record.operationalRule.action}(${record.operationalRule.target})[${record.operationalRule.effect ?? "apply"}];` : ""} content=${record.content.replace(/\s+/g, " ").slice(0, 220)}`)
+            .join("\n");
+    return renderBundledTemplate("prompts/runtime/memory-mutation-reconciliation.md", {
+        candidateJson: JSON.stringify(input.candidate, null, 2),
+        existingRecords: existing,
+    });
+}

package/dist/runtime/support/vector-stores.d.ts

@@ -1,5 +1,5 @@
 import type { CompiledVectorStore, RuntimeEmbeddingModelResolver, RuntimeVectorStoreResolver, WorkspaceBundle } from "../../contracts/types.js";
-import { type VectorStoreRuntimeLike } from "./llamaindex.js";
+import type { VectorStoreRuntimeLike } from "./llamaindex.js";
 export declare function resolveCompiledVectorStoreRef(workspace: WorkspaceBundle, vectorStoreRef?: string): CompiledVectorStore;
 export declare function resolveCompiledVectorStore(workspace: WorkspaceBundle, vectorStore: CompiledVectorStore, options?: {
     embeddingModelResolver?: RuntimeEmbeddingModelResolver;

package/dist/runtime/support/vector-stores.js

@@ -7,7 +7,6 @@ import { QdrantClient } from "@qdrant/js-client-rest";
 import { compileVectorStore } from "../../workspace/resource-compilers.js";
 import { getRuntimeStorageRoots, resolveRefId } from "../../workspace/support/workspace-ref-utils.js";
 import { resolveCompiledEmbeddingModel, resolveCompiledEmbeddingModelRef } from "./embedding-models.js";
-import { createLlamaIndexVectorStore } from "./llamaindex.js";
 function resolveFileUrl(rawUrl, workspaceRoot) {
     if (!rawUrl.startsWith("file:")) {
         return rawUrl;
@@ -74,6 +73,10 @@ async function ensureQdrantCollection(client, collection, dimensions) {
         },
     });
 }
+async function createLazyLlamaIndexVectorStore(dataRoot, vectorStore, embeddings) {
+    const { createLlamaIndexVectorStore } = await import("./llamaindex.js");
+    return createLlamaIndexVectorStore(dataRoot, vectorStore, embeddings);
+}
 export function resolveCompiledVectorStoreRef(workspace, vectorStoreRef) {
     const resolvedId = vectorStoreRef ? resolveRefId(vectorStoreRef) : "default";
     const vectorStore = workspace.vectorStores.get(resolvedId);
@@ -96,7 +99,7 @@ export async function resolveCompiledVectorStore(workspace, vectorStore, options
     if (vectorStore.kind === "LlamaIndexSimpleVectorStore") {
         const embeddingModel = resolveCompiledEmbeddingModelRef(workspace, vectorStore.embeddingModelRef);
         const embeddings = await resolveCompiledEmbeddingModel(embeddingModel, options.embeddingModelResolver);
-        return createLlamaIndexVectorStore(dataRoot, vectorStore, embeddings);
+        return createLazyLlamaIndexVectorStore(dataRoot, vectorStore, embeddings);
     }
     if (vectorStore.kind === "QdrantVectorStore") {
         const embeddingModel = resolveCompiledEmbeddingModelRef(workspace, vectorStore.embeddingModelRef);

package/dist/upstream-events.js

@@ -28,9 +28,6 @@ function readEventContext(event) {
         ns: readStringArray(typed?.ns),
     };
 }
-function containsSemanticHint(values, hint) {
-    return values.some((value) => hint.test(value));
-}
 function normalizeSemanticHint(value) {
     return value
         .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
@@ -40,14 +37,18 @@ function normalizeSemanticHint(value) {
         .trim()
         .toLowerCase();
 }
+function isExactSemanticHint(values, expected) {
+    return values.includes(expected);
+}
 function classifyStepCategory(context) {
     const hints = [context.name, context.runType, ...context.tags, ...context.ns].map(normalizeSemanticHint);
-    if (containsSemanticHint(hints, /\b(skill|skills)\b/)) {
-        return "skill";
-    }
-    if (containsSemanticHint(hints, /\b(memory|recall|store|checkpoint)\b/)) {
+    if (context.runType === "memory"
+        || isExactSemanticHint(hints, "memory")) {
         return "memory";
     }
+    if (isExactSemanticHint(hints, "skill")) {
+        return "skill";
+    }
     if (context.eventName.startsWith("on_tool_") || context.runType === "tool") {
         return "tool";
     }

package/dist/utils/bundled-text.d.ts

@@ -0,0 +1,3 @@
+export declare function readBundledText(relativePath: string): string;
+export declare function renderTemplateText(template: string, values: Record<string, string | number | boolean | undefined>): string;
+export declare function renderBundledTemplate(relativePath: string, values: Record<string, string | number | boolean | undefined>): string;

package/dist/utils/bundled-text.js

@@ -0,0 +1,25 @@
+import { readFileSync } from "node:fs";
+const bundledTextCache = new Map();
+export function readBundledText(relativePath) {
+    const normalized = relativePath.replace(/^\.?\//, "");
+    const cached = bundledTextCache.get(normalized);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const value = readFileSync(new URL(`../../resources/${normalized}`, import.meta.url), "utf8");
+    bundledTextCache.set(normalized, value);
+    return value;
+}
+export function renderTemplateText(template, values) {
+    return template
+        .replace(/\{\{([a-zA-Z0-9_]+)\}\}/g, (_match, key) => {
+        const value = values[key];
+        return value === undefined ? "" : String(value);
+    })
+        .replace(/[ \t]+\n/g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+export function renderBundledTemplate(relativePath, values) {
+    return renderTemplateText(readBundledText(relativePath), values);
+}

package/dist/utils/id.js

@@ -1,8 +1,9 @@
-import { randomUUID } from "node:crypto";
+import { randomBytes } from "node:crypto";
 export function createPersistentId(now = new Date()) {
     const iso = now.toISOString();
     const compact = iso.replace(/[-:]/g, "").replace(/\./g, "").replace("Z", "");
     const [date, time] = compact.split("T");
     const hhmmss = time.slice(0, 9);
-    return `${date}T${hhmmss}-${randomUUID()}`;
+    const suffix = randomBytes(6).toString("hex");
+    return `${date}T${hhmmss}-${suffix}`;
 }

package/dist/workspace/agent-binding-compiler.js

@@ -5,10 +5,8 @@ import { compileModel, compileTool } from "./resource-compilers.js";
 import { inferAgentCapabilities } from "./support/agent-capabilities.js";
 import { getAgentExecutionConfigValue, getAgentExecutionObject, getAgentExecutionString } from "./support/agent-execution-config.js";
 import { discoverSkillPaths } from "./support/discovery.js";
-import { compileAgentMemories, getResilienceConfig, getRuntimeDefaults, getRuntimeMemoryDefaults, getRuntimeStorageRoots, getWorkspaceObject, resolvePromptValue, resolveRefId, } from "./support/workspace-ref-utils.js";
-const WORKSPACE_BOUNDARY_GUIDANCE = "Keep repository and file exploration bounded to the current workspace root unless the user explicitly asks for broader host or filesystem access. " +
-    "Do not inspect absolute paths outside the workspace, system directories, or unrelated repos by default. " +
-    "Prefer workspace-local tools, relative paths, and the current repository checkout when analyzing code.";
+import { compileAgentMemories, getProceduralMemoryDefaults, getResilienceConfig, getRuntimeDefaults, getRuntimeMemoryDefaults, getRuntimeStorageRoots, getWorkspaceObject, resolvePromptValue, resolveRefId, } from "./support/workspace-ref-utils.js";
+import { WORKSPACE_BOUNDARY_GUIDANCE } from "../runtime/support/runtime-prompts.js";
 function requireSkills(pathEntries, workspaceRoot) {
     return Array.from(new Set(discoverSkillPaths(pathEntries, workspaceRoot)));
 }
@@ -169,7 +167,7 @@ export function requireTools(tools, bindings, ownerId) {
     return Array.from(deduped.values());
 }
 function buildSubagent(agent, workspaceRoot, models, tools, parentSkills, parentModel) {
-    const execution = compileExecutionCore(agent, models, tools);
+    const execution = compileExecutionCore(agent, workspaceRoot, models, tools);
     return {
         name: resolveAgentRuntimeName(agent),
         description: agent.description,
@@ -182,8 +180,9 @@ function buildSubagent(agent, workspaceRoot, models, tools, parentSkills, parent
         middleware: execution.middleware,
     };
 }
-function resolveSystemPrompt(agent) {
-    const prompt = resolvePromptValue(getAgentExecutionConfigValue(agent, "systemPrompt"));
+function resolveSystemPrompt(agent, workspaceRoot) {
+    const promptBaseDir = path.dirname(agent.sourcePath || workspaceRoot);
+    const prompt = resolvePromptValue(getAgentExecutionConfigValue(agent, "systemPrompt"), promptBaseDir);
     if (agent.executionMode !== "deepagent") {
         return prompt;
     }
@@ -230,11 +229,11 @@ function compileDeepAgentSubagents(agent, agents, workspaceRoot, models, tools,
         ...compileAsyncSubagents(agent),
     ];
 }
-function compileExecutionCore(agent, models, tools) {
+function compileExecutionCore(agent, workspaceRoot, models, tools) {
     return {
         model: requireModel(models, agent.modelRef, agent.id),
         tools: requireTools(tools, getAgentToolBindings(agent), agent.id),
-        systemPrompt: resolveSystemPrompt(agent),
+        systemPrompt: resolveSystemPrompt(agent, workspaceRoot),
         responseFormat: resolveResponseFormat(agent),
         contextSchema: resolveContextSchema(agent),
         middleware: resolveCompiledMiddleware(agent, models),
@@ -296,6 +295,30 @@ function materializeWorkspaceObjectConfig(refs, ref, allowedKinds, ownerLabel) {
     }
     return config;
 }
+function materializeRuntimeMemoryConfig(refs, config, ownerLabel) {
+    const runtimeMemory = { ...config };
+    const nestedStore = asObject(runtimeMemory.store);
+    if (nestedStore && isRefConfig(nestedStore)) {
+        runtimeMemory.store = materializeWorkspaceObjectConfig(refs, nestedStore.ref, ["store"], `${ownerLabel} runtimeMemory.store`);
+    }
+    return runtimeMemory;
+}
+function materializeProceduralMemoryConfig(refs, config, ownerLabel) {
+    const proceduralMemory = { ...config };
+    const nestedStore = asObject(proceduralMemory.store);
+    if (nestedStore && isRefConfig(nestedStore)) {
+        proceduralMemory.store = materializeWorkspaceObjectConfig(refs, nestedStore.ref, ["store"], `${ownerLabel} proceduralMemory.store`);
+    }
+    const nestedVectorStore = asObject(proceduralMemory.vectorStore);
+    if (nestedVectorStore && isRefConfig(nestedVectorStore)) {
+        proceduralMemory.vectorStore = materializeWorkspaceObjectConfig(refs, nestedVectorStore.ref, ["vector-store"], `${ownerLabel} proceduralMemory.vectorStore`);
+    }
+    const nestedEmbeddingModel = asObject(proceduralMemory.embeddingModel);
+    if (nestedEmbeddingModel && isRefConfig(nestedEmbeddingModel)) {
+        proceduralMemory.embeddingModel = materializeWorkspaceObjectConfig(refs, nestedEmbeddingModel.ref, ["embedding-model"], `${ownerLabel} proceduralMemory.embeddingModel`);
+    }
+    return proceduralMemory;
+}
 function resolveStoreConfig(agent, refs) {
     const inlineStore = getAgentExecutionObject(agent, "store");
     if (!inlineStore) {
@@ -328,13 +351,28 @@ function resolveRuntimeMemoryConfig(agent, refs) {
     if (inlineRuntimeMemory) {
         if (isRefConfig(inlineRuntimeMemory)) {
             return {
-                config: materializeWorkspaceObjectConfig(refs, inlineRuntimeMemory.ref, ["runtime-memory"], `Agent ${agent.id} runtimeMemory`),
+                config: materializeRuntimeMemoryConfig(refs, materializeWorkspaceObjectConfig(refs, inlineRuntimeMemory.ref, ["runtime-memory"], `Agent ${agent.id} runtimeMemory`), `Agent ${agent.id}`),
             };
         }
-        return { config: inlineRuntimeMemory };
+        return { config: materializeRuntimeMemoryConfig(refs, inlineRuntimeMemory, `Agent ${agent.id}`) };
     }
     const runtimeMemoryDefaults = getRuntimeMemoryDefaults(refs);
-    return runtimeMemoryDefaults ? { config: runtimeMemoryDefaults } : undefined;
+    return runtimeMemoryDefaults ? { config: materializeRuntimeMemoryConfig(refs, runtimeMemoryDefaults, `Agent ${agent.id}`) } : undefined;
+}
+function resolveProceduralMemoryConfig(agent, refs) {
+    const inlineProceduralMemory = agent.proceduralMemory ?? getAgentExecutionObject(agent, "proceduralMemory");
+    if (inlineProceduralMemory) {
+        if (isRefConfig(inlineProceduralMemory)) {
+            return {
+                config: materializeProceduralMemoryConfig(refs, materializeWorkspaceObjectConfig(refs, inlineProceduralMemory.ref, ["procedural-memory"], `Agent ${agent.id} proceduralMemory`), `Agent ${agent.id}`),
+            };
+        }
+        return { config: materializeProceduralMemoryConfig(refs, inlineProceduralMemory, `Agent ${agent.id}`) };
+    }
+    const proceduralMemoryDefaults = getProceduralMemoryDefaults(refs);
+    return proceduralMemoryDefaults
+        ? { config: materializeProceduralMemoryConfig(refs, proceduralMemoryDefaults, `Agent ${agent.id}`) }
+        : undefined;
 }
 export function compileBinding(workspaceRoot, agent, agents, referencedSubagentIds, refs, models, tools) {
     const internalSubagent = referencedSubagentIds.has(agent.id);
@@ -346,13 +384,14 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
     const executionCore = compileExecutionCore({
         ...agent,
         modelRef: agent.modelRef || (internalSubagent ? "model/default" : ""),
-    }, models, tools);
+    }, workspaceRoot, models, tools);
     const passthrough = resolvePassthrough(agent);
     const compiledAgentModel = executionCore.model;
     const backend = resolveBackendConfig(agent, refs);
     const store = resolveStoreConfig(agent, refs);
     const checkpointer = resolveCheckpointerConfig(agent, refs);
     const runtimeMemory = resolveRuntimeMemoryConfig(agent, refs);
+    const proceduralMemory = resolveProceduralMemoryConfig(agent, refs);
     const runtimeFilesystemDefaults = agent.executionMode === "langchain-v1"
         ? asObject(runtimeDefaults?.filesystem)
         : undefined;
@@ -401,6 +440,7 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
             ...(checkpointer ? { checkpointer: checkpointer.config } : {}),
             ...(store ? { store: store.config } : {}),
             ...(runtimeMemory ? { runtimeMemory: runtimeMemory.config } : {}),
+            ...(proceduralMemory ? { proceduralMemory: proceduralMemory.config } : {}),
         },
     };
     if (agent.executionMode !== "deepagent") {

package/dist/workspace/object-loader.js

@@ -258,6 +258,7 @@ const CONSUMED_AGENT_CONFIG_KEYS = [
     "backend",
     "store",
     "runtimeMemory",
+    "proceduralMemory",
     "taskDescription",
     "generalPurposeAgent",
     "filesystem",
@@ -317,6 +318,12 @@ function normalizeAgentItemForMerge(item) {
             normalized.runtime = nextRuntime;
             delete config.runtimeMemory;
         }
+        if (config.proceduralMemory !== undefined && runtime?.proceduralMemory === undefined) {
+            const nextRuntime = asMutableObject(normalized.runtime) ?? runtime ?? {};
+            nextRuntime.proceduralMemory = cloneConfigValue(config.proceduralMemory);
+            normalized.runtime = nextRuntime;
+            delete config.proceduralMemory;
+        }
     }
     if (config && Object.keys(config).length > 0) {
         normalized.config = config;
@@ -367,6 +374,32 @@ function readRuntimeMemoryConfig(item, runtime) {
     }
     return undefined;
 }
+function readProceduralMemoryConfig(item, runtime) {
+    if (typeof runtime?.proceduralMemory === "string" && runtime.proceduralMemory.trim()) {
+        return {
+            ref: runtime.proceduralMemory.startsWith("procedural-memory/")
+                ? runtime.proceduralMemory
+                : `procedural-memory/${runtime.proceduralMemory.trim()}`,
+        };
+    }
+    if (typeof runtime?.proceduralMemory === "object" && runtime.proceduralMemory && !Array.isArray(runtime.proceduralMemory)) {
+        return cloneConfigValue(runtime.proceduralMemory);
+    }
+    const legacyExecutionConfig = readExecutionAgentConfig(item);
+    if (typeof legacyExecutionConfig.proceduralMemory === "string" && legacyExecutionConfig.proceduralMemory.trim()) {
+        return {
+            ref: legacyExecutionConfig.proceduralMemory.startsWith("procedural-memory/")
+                ? legacyExecutionConfig.proceduralMemory
+                : `procedural-memory/${legacyExecutionConfig.proceduralMemory.trim()}`,
+        };
+    }
+    if (typeof legacyExecutionConfig.proceduralMemory === "object" &&
+        legacyExecutionConfig.proceduralMemory &&
+        !Array.isArray(legacyExecutionConfig.proceduralMemory)) {
+        return cloneConfigValue(legacyExecutionConfig.proceduralMemory);
+    }
+    return undefined;
+}
 function cloneConfigValue(value) {
     if (Array.isArray(value)) {
         return value.map((item) => cloneConfigValue(item));
@@ -510,6 +543,7 @@ export function parseAgentItem(item, sourcePath) {
         id: String(normalizedItem.id),
         executionMode: executionMode,
         runtimeMemory: readRuntimeMemoryConfig(normalizedItem, runtime),
+        proceduralMemory: readProceduralMemoryConfig(normalizedItem, runtime),
         capabilities: readCapabilities(normalizedItem.capabilities) ?? (executionMode === "deepagent"
             ? { delegation: true, memory: true }
             : { delegation: true, memory: true }),
@@ -594,6 +628,31 @@ function mergeAgentRecord(records, item, sourcePath) {
     if (!id) {
         return null;
     }
+    const current = records.get(id);
+    const incomingHasSystemPrompt = normalizedItem.systemPrompt !== undefined;
+    const currentSystemPrompt = current?.item.systemPrompt;
+    const currentCarriesRelativePromptPath = typeof currentSystemPrompt === "object"
+        && currentSystemPrompt !== null
+        && !Array.isArray(currentSystemPrompt)
+        && typeof currentSystemPrompt.path === "string"
+        && !!currentSystemPrompt.path.trim()
+        && !path.isAbsolute(currentSystemPrompt.path);
+    if (current && currentCarriesRelativePromptPath && !incomingHasSystemPrompt) {
+        const currentPromptConfig = currentSystemPrompt;
+        const absolutizedCurrent = {
+            ...current.item,
+            systemPrompt: {
+                ...currentPromptConfig,
+                path: path.resolve(path.dirname(current.sourcePath), currentPromptConfig.path),
+            },
+        };
+        const mergedRecord = {
+            item: mergeValues(absolutizedCurrent, normalizedItem),
+            sourcePath,
+        };
+        records.set(id, mergedRecord);
+        return mergedRecord;
+    }
     return mergeRawItemRecord(records, id, normalizedItem, sourcePath);
 }
 function mergeWorkspaceObjectRecord(records, workspaceObject, item, sourcePath) {
@@ -892,12 +951,15 @@ export async function loadWorkspaceObjects(workspaceRoot, options = {}) {
     const refs = new Map();
     const mergedAgents = new Map();
     const mergedObjects = new Map();
-    const roots = [frameworkWorkspaceRoot(), ...(options.overlayRoots ?? []), workspaceRoot];
+    const defaultRoot = frameworkWorkspaceRoot();
+    const roots = [defaultRoot, ...(options.overlayRoots ?? []), workspaceRoot];
     for (const root of roots) {
         const configRoot = conventionalConfigRoot(root) ?? root;
         await loadConfigYamlForRoot(root, configRoot, mergedAgents, mergedObjects);
         await loadModuleAgentsForRoot(root, mergedAgents);
-        await loadConventionalObjectsForRoot(root, mergedObjects, getMergedToolModuleDiscoveryScope(mergedObjects));
+        if (root !== defaultRoot) {
+            await loadConventionalObjectsForRoot(root, mergedObjects, getMergedToolModuleDiscoveryScope(mergedObjects));
+        }
         await loadModuleObjectsForRoot(root, mergedObjects);
         await loadRootObjects(root, mergedObjects);
     }

package/dist/workspace/support/workspace-ref-utils.d.ts

@@ -46,6 +46,7 @@ export declare function getRuntimeStorageRoots(refs: Map<string, WorkspaceObject
 export declare function getRuntimeResources(refs: Map<string, WorkspaceObject | ParsedAgentObject>): string[];
 export declare function getToolModuleDiscoveryConfig(refs: Map<string, WorkspaceObject | ParsedAgentObject>): ToolModuleDiscoveryConfig;
 export declare function getRuntimeMemoryDefaults(refs: Map<string, WorkspaceObject | ParsedAgentObject>): Record<string, unknown> | undefined;
+export declare function getProceduralMemoryDefaults(refs: Map<string, WorkspaceObject | ParsedAgentObject>): Record<string, unknown> | undefined;
 export declare function getRecoveryConfig(refs: Map<string, WorkspaceObject | ParsedAgentObject>): RecoveryConfig;
 export declare function getConcurrencyConfig(refs: Map<string, WorkspaceObject | ParsedAgentObject>): ConcurrencyConfig;
 export declare function getResilienceConfig(refs: Map<string, WorkspaceObject | ParsedAgentObject>): ResilienceConfig;
@@ -55,7 +56,7 @@ export declare function matchRoutingRule(input: string, rule: RoutingRule, optio
     sessionId?: string;
     legacySessionId?: string;
 }): boolean;
-export declare function resolvePromptValue(promptConfig: unknown): string | undefined;
+export declare function resolvePromptValue(promptConfig: unknown, baseDir?: string): string | undefined;
 export declare function resolveRefId(ref: string): string;
 export declare function resolvePathList(refs: Map<string, WorkspaceObject | ParsedAgentObject>, workspaceRoot: string, refList: string[]): string[];
 export declare function compileAgentMemories(workspaceRoot: string, sources: string[]): string[];

package/dist/workspace/support/workspace-ref-utils.js

@@ -43,7 +43,7 @@ export function getRuntimeStorageRoots(refs, workspaceRoot) {
         ? (path.isAbsolute(configuredDataRoot)
             ? configuredDataRoot
             : path.resolve(applicationRoot, configuredDataRoot))
-        : path.join(applicationRoot, ".agent");
+        : path.join(applicationRoot, ".botbotgo");
     const runtimeProfile = configuredProfile ?? "default";
     return {
         applicationRoot,
@@ -72,13 +72,31 @@ export function getToolModuleDiscoveryConfig(refs) {
 export function getRuntimeMemoryDefaults(refs) {
     const runtimeMemories = Array.from(refs.values()).filter((object) => !("executionMode" in object) && object.kind === "runtime-memory");
     if (runtimeMemories.length === 0) {
-        return undefined;
+        const runtimeDefaults = getRuntimeDefaults(refs);
+        return typeof runtimeDefaults?.runtimeMemory === "object" && runtimeDefaults.runtimeMemory && !Array.isArray(runtimeDefaults.runtimeMemory)
+            ? runtimeDefaults.runtimeMemory
+            : undefined;
     }
     if (runtimeMemories.length > 1) {
         throw new Error(`Expected at most one RuntimeMemory object, found ${runtimeMemories.length}`);
     }
     return runtimeMemories[0].value;
 }
+export function getProceduralMemoryDefaults(refs) {
+    const proceduralMemories = Array.from(refs.values()).filter((object) => !("executionMode" in object) && object.kind === "procedural-memory");
+    if (proceduralMemories.length === 0) {
+        const runtimeDefaults = getRuntimeDefaults(refs);
+        return typeof runtimeDefaults?.proceduralMemory === "object" &&
+            runtimeDefaults.proceduralMemory &&
+            !Array.isArray(runtimeDefaults.proceduralMemory)
+            ? runtimeDefaults.proceduralMemory
+            : undefined;
+    }
+    if (proceduralMemories.length > 1) {
+        throw new Error(`Expected at most one ProceduralMemoryRuntime object, found ${proceduralMemories.length}`);
+    }
+    return proceduralMemories[0].value;
+}
 export function getRecoveryConfig(refs) {
     const runtimeDefaults = getRuntimeDefaults(refs);
     const recovery = typeof runtimeDefaults?.recovery === "object" && runtimeDefaults.recovery
@@ -263,7 +281,7 @@ export function matchRoutingRule(input, rule, options = {}) {
     }
     return true;
 }
-export function resolvePromptValue(promptConfig) {
+export function resolvePromptValue(promptConfig, baseDir) {
     if (typeof promptConfig === "string" && promptConfig.trim()) {
         return promptConfig;
     }
@@ -272,7 +290,8 @@ export function resolvePromptValue(promptConfig) {
             ? promptConfig.path
             : undefined;
         if (promptPath?.trim()) {
-            return readFileSync(promptPath, "utf8");
+            const resolvedPath = baseDir && !path.isAbsolute(promptPath) ? path.resolve(baseDir, promptPath) : promptPath;
+            return readFileSync(resolvedPath, "utf8");
         }
     }
     return undefined;
@@ -282,7 +301,7 @@ export function resolveRefId(ref) {
     if (rest.length === 0) {
         return ref;
     }
-    if (["agent", "embedding-model", "mcp", "model", "object", "prompt", "runtime", "runtime-memory", "tool", "vector-store"].includes(namespace)) {
+    if (["agent", "embedding-model", "mcp", "model", "object", "procedural-memory", "prompt", "runtime", "runtime-memory", "tool", "vector-store"].includes(namespace)) {
         return rest.join("/");
     }
     return ref;

package/dist/workspace/yaml-object-reader.d.ts

@@ -1,3 +1,4 @@
+export declare function interpolateEnvPlaceholders(value: unknown, sourcePath: string, envOverrides?: Record<string, string | undefined>): unknown;
 export declare function normalizeYamlItem(item: Record<string, unknown>): Record<string, unknown>;
 export declare function readYamlItems(root: string, relativeDir?: string, options?: {
     recursive?: boolean;