@botbotgo/agent-harness 0.0.283 → 0.0.284

package/dist/config/agents/direct.yaml

@@ -10,9 +10,6 @@ metadata:
   description: Manual low-latency host for direct answers and lightweight inventory lookup. Do not use it as the default executor for tool-heavy or delegation-heavy tasks.
 spec:
   runtime:
-    # agent-harness feature: host-level run data placement override.
-    # This matches the workspace default and keeps the default config shape explicit.
-    runRoot: ./.agent
     # agent-harness feature: workspace-level durable long-term memory defaults for this host profile.
     runtimeMemory: default
   # =====================

package/dist/config/agents/orchestra.yaml

@@ -10,9 +10,6 @@ metadata:
   description: Default execution host. Answer directly when possible, use local tools and skills first, and delegate only when a subagent is a better fit. Not a reflex delegation-only orchestrator.
 spec:
   runtime:
-    # agent-harness feature: host-level run data placement override.
-    # This matches the workspace default and keeps the default config shape explicit.
-    runRoot: ./.agent
     # agent-harness feature: workspace-level durable long-term memory defaults for this host profile.
     runtimeMemory: default
   # =====================

package/dist/config/catalogs/stores.yaml

@@ -15,4 +15,4 @@ spec:
     name: default
     description: Default file-backed checkpointer preset for durable local graph state without native sqlite bindings.
     checkpointerKind: FileCheckpointer
-    path: checkpoints.json
+    path: runtime/checkpoints.json

package/dist/config/catalogs/vector-stores.yaml

@@ -13,7 +13,7 @@ spec:
     storeKind: LibSQLVectorStore
     # LangChain aligned feature: libSQL connection URL.
     # Local SQLite files use the `file:` prefix.
-    url: file:.agent/knowledge/vectors.sqlite
+    url: file:knowledge/vectors.sqlite
     # LangChain aligned feature: target table and embedding column.
     table: rag_chunks
     column: embedding

package/dist/config/runtime/workspace.yaml

@@ -12,15 +12,22 @@ spec:
   # ======================
   # agent-harness Features
   # ======================
-  # agent-harness feature: filesystem root where the harness stores local run artifacts by default.
-  # This affects file-backed persistence such as:
-  # - session / thread / run indexes
-  # - approval and delegation records
-  # - default file-backed store paths
-  # - default file-backed checkpointer paths
-  # Agents inherit this value unless they override `spec.runRoot` locally.
-  # Value options: relative workspace path like `./.agent`, or an absolute filesystem path.
-  runRoot: ./.agent
+  # agent-harness feature: read-only application folder that contains the shared workspace assembly.
+  # This is where the runtime loads config catalogs and packaged resources such as:
+  # - config/
+  # - resources/
+  # Downstream applications can point multiple runtime profiles at the same application folder.
+  applicationRoot: .
+
+  # agent-harness feature: writable data folder for one runtime profile.
+  # Runtime-owned persistence stays under this root, split by function:
+  # - runtime/ for requests, approvals, checkpoints, and artifacts
+  # - knowledge/ for durable knowledge and vector indexes
+  # Different runtime profiles can use different data folders while sharing the same application folder.
+  dataRoot: ./.agent
+
+  # agent-harness feature: stable runtime profile identifier for this data folder.
+  profile: default
 
   # agent-harness feature: runtime-level task queue and maximum number of concurrent runs.
   # Additional runs wait in the harness queue until a slot becomes available.

package/dist/contracts/workspace.d.ts

@@ -7,6 +7,9 @@ export type ParsedAgentObject = {
     description: string;
     modelRef: string;
     runRoot?: string;
+    applicationRoot?: string;
+    dataRoot?: string;
+    runtimeProfile?: string;
     toolRefs: string[];
     toolBindings?: ParsedAgentToolBinding[];
     inlineTools?: ParsedToolObject[];
@@ -260,6 +263,9 @@ export type CompiledAgentBinding = {
      */
     deepAgentParams?: LegacyDeepAgentParams;
     harnessRuntime: {
+        applicationRoot?: string;
+        dataRoot?: string;
+        runtimeProfile?: string;
         runRoot: string;
         workspaceRoot?: string;
         capabilities?: RuntimeCapabilities;

package/dist/init-project.js

@@ -93,7 +93,9 @@ kind: Runtime
 metadata:
   name: default
 spec:
-  runRoot: ./.agent
+  applicationRoot: .
+  dataRoot: ./.agent
+  profile: default
 `;
 }
 function renderAgentContext(options) {

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.282";
+export declare const AGENT_HARNESS_VERSION = "0.0.283";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.282";
+export const AGENT_HARNESS_VERSION = "0.0.283";

package/dist/persistence/sqlite-store.js

@@ -2,6 +2,7 @@ import path from "node:path";
 import { mkdir, rm } from "node:fs/promises";
 import { createClient } from "@libsql/client";
 import { fileExists, readJson, writeJson } from "../utils/fs.js";
+import { resolveRuntimeRoot, resolveRuntimeSqlitePath } from "../runtime/support/runtime-layout.js";
 import { SqliteRunContextStore } from "./sqlite-run-context-store.js";
 import { SqliteRunQueueStore } from "./sqlite-run-queue-store.js";
 const RUNTIME_SQLITE_SCHEMA_VERSION = 6;
@@ -97,7 +98,9 @@ export class SqlitePersistence {
     initialization = null;
     constructor(runRoot, dbFile = "runtime.sqlite") {
         this.runRoot = runRoot;
-        this.dbPath = path.join(runRoot, dbFile);
+        this.dbPath = dbFile === "runtime.sqlite"
+            ? resolveRuntimeSqlitePath(runRoot)
+            : path.join(resolveRuntimeRoot(runRoot), dbFile);
         this.runContextStore = new SqliteRunContextStore({
             execute: (sql, args) => this.execute(sql, args),
             selectOne: (sql, args) => this.selectOne(sql, args),
@@ -148,7 +151,7 @@ export class SqlitePersistence {
             return;
         }
         this.initialization = (async () => {
-            await mkdir(this.runRoot, { recursive: true });
+            await mkdir(resolveRuntimeRoot(this.runRoot), { recursive: true });
             await this.getClient();
             await this.rawExecute("PRAGMA journal_mode=WAL");
             await this.rawExecute("PRAGMA foreign_keys=ON");

package/dist/runtime/harness/system/mem0-ingestion-sync.js

@@ -62,7 +62,7 @@ export function readMem0RuntimeConfig(runtimeMemory, workspaceRoot) {
         projectId: asNonEmptyString(mem0.projectId),
         appId: asNonEmptyString(mem0.appId) ?? workspaceBaseName,
         userIdPrefix: asNonEmptyString(mem0.userIdPrefix),
-        stateStorePath: asNonEmptyString(mem0.stateStorePath) ?? "mem0-sync-state.json",
+        stateStorePath: asNonEmptyString(mem0.stateStorePath) ?? "knowledge/mem0-sync-state.json",
         maxMessagesPerRun: asPositiveInteger(mem0.maxMessagesPerRun) ?? 200,
         writeOnApprovalResolution: asBoolean(mem0.writeOnApprovalResolution) ?? asBoolean(ingestion?.writeOnApprovalResolution) ?? true,
         writeOnRunCompletion: asBoolean(mem0.writeOnRunCompletion) ?? asBoolean(ingestion?.writeOnRunCompletion) ?? true,

package/dist/runtime/harness/system/runtime-memory-manager.js

@@ -57,7 +57,7 @@ export function readRuntimeMemoryFormationConfig(runtimeMemory, workspaceRoot) {
             enabled: asBoolean(background?.enabled) ?? true,
             maxMessagesPerRun: asPositiveInteger(background?.maxMessagesPerRun) ?? asPositiveInteger(ingestion?.maxMessagesPerRun) ?? 40,
             scopes: normalizeScopeList(asMemoryScopes(background?.scopes) ?? ["thread"]),
-            stateStorePath: asNonEmptyString(background?.stateStorePath) ?? `${workspaceBaseName}-memory-formation-state.json`,
+            stateStorePath: asNonEmptyString(background?.stateStorePath) ?? `knowledge/${workspaceBaseName}-memory-formation-state.json`,
             writeOnApprovalResolution: asBoolean(background?.writeOnApprovalResolution) ?? asBoolean(ingestion?.writeOnApprovalResolution) ?? true,
             writeOnRunCompletion: asBoolean(background?.writeOnRunCompletion) ?? asBoolean(ingestion?.writeOnRunCompletion) ?? true,
         },

package/dist/runtime/support/llamaindex.d.ts

@@ -21,4 +21,4 @@ export type VectorStoreRuntimeLike = {
     }) => Promise<void>;
 };
 export declare function createLlamaIndexEmbeddingModel(embeddingModel: CompiledEmbeddingModel): EmbeddingRuntimeLike;
-export declare function createLlamaIndexVectorStore(workspaceRoot: string, vectorStore: CompiledVectorStore, embeddings: EmbeddingRuntimeLike): Promise<VectorStoreRuntimeLike>;
+export declare function createLlamaIndexVectorStore(dataRoot: string, vectorStore: CompiledVectorStore, embeddings: EmbeddingRuntimeLike): Promise<VectorStoreRuntimeLike>;

package/dist/runtime/support/llamaindex.js

@@ -41,8 +41,8 @@ export function createLlamaIndexEmbeddingModel(embeddingModel) {
         },
     };
 }
-export async function createLlamaIndexVectorStore(workspaceRoot, vectorStore, embeddings) {
-    const persistPath = resolveFilePath(vectorStore.url ?? ".agent/knowledge/vectors.json", workspaceRoot);
+export async function createLlamaIndexVectorStore(dataRoot, vectorStore, embeddings) {
+    const persistPath = resolveFilePath(vectorStore.url ?? "knowledge/vectors.json", dataRoot);
     await mkdir(path.dirname(persistPath), { recursive: true });
     const emptyStore = () => SimpleVectorStore.fromDict({
         embeddingDict: {},

package/dist/runtime/support/runtime-layout.d.ts

@@ -1,6 +1,7 @@
-export declare function resolveRuntimeArtifactsRoot(runRoot: string): string;
-export declare function resolveRuntimeSqlitePath(runRoot: string): string;
-export declare function resolveRuntimeCheckpointerPath(runRoot: string, fileName?: string): string;
-export declare function resolveKnowledgeRoot(runRoot: string): string;
-export declare function resolveKnowledgeStorePath(runRoot: string, fileName?: string): string;
-export declare function resolveKnowledgeFileStorePath(runRoot: string, fileName?: string): string;
+export declare function resolveRuntimeRoot(dataRoot: string): string;
+export declare function resolveRuntimeArtifactsRoot(dataRoot: string): string;
+export declare function resolveRuntimeSqlitePath(dataRoot: string): string;
+export declare function resolveRuntimeCheckpointerPath(dataRoot: string, fileName?: string): string;
+export declare function resolveKnowledgeRoot(dataRoot: string): string;
+export declare function resolveKnowledgeStorePath(dataRoot: string, fileName?: string): string;
+export declare function resolveKnowledgeFileStorePath(dataRoot: string, fileName?: string): string;

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

@@ -1,19 +1,22 @@
 import path from "node:path";
-export function resolveRuntimeArtifactsRoot(runRoot) {
-    return path.join(runRoot, "artifacts");
+export function resolveRuntimeRoot(dataRoot) {
+    return path.join(dataRoot, "runtime");
 }
-export function resolveRuntimeSqlitePath(runRoot) {
-    return path.join(runRoot, "runtime.sqlite");
+export function resolveRuntimeArtifactsRoot(dataRoot) {
+    return path.join(resolveRuntimeRoot(dataRoot), "artifacts");
 }
-export function resolveRuntimeCheckpointerPath(runRoot, fileName = "checkpoints.json") {
-    return path.join(runRoot, fileName);
+export function resolveRuntimeSqlitePath(dataRoot) {
+    return path.join(resolveRuntimeRoot(dataRoot), "runtime.sqlite");
 }
-export function resolveKnowledgeRoot(runRoot) {
-    return path.join(runRoot, "knowledge");
+export function resolveRuntimeCheckpointerPath(dataRoot, fileName = "checkpoints.json") {
+    return path.join(resolveRuntimeRoot(dataRoot), fileName);
 }
-export function resolveKnowledgeStorePath(runRoot, fileName = "records.sqlite") {
-    return path.join(resolveKnowledgeRoot(runRoot), fileName);
+export function resolveKnowledgeRoot(dataRoot) {
+    return path.join(dataRoot, "knowledge");
 }
-export function resolveKnowledgeFileStorePath(runRoot, fileName = "records.json") {
-    return path.join(resolveKnowledgeRoot(runRoot), fileName);
+export function resolveKnowledgeStorePath(dataRoot, fileName = "records.sqlite") {
+    return path.join(resolveKnowledgeRoot(dataRoot), fileName);
+}
+export function resolveKnowledgeFileStorePath(dataRoot, fileName = "records.json") {
+    return path.join(resolveKnowledgeRoot(dataRoot), fileName);
 }

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

@@ -5,7 +5,7 @@ import { createClient } from "@libsql/client";
 import { LibSQLVectorStore } from "@langchain/community/vectorstores/libsql";
 import { QdrantClient } from "@qdrant/js-client-rest";
 import { compileVectorStore } from "../../workspace/resource-compilers.js";
-import { resolveRefId } from "../../workspace/support/workspace-ref-utils.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) {
@@ -92,10 +92,11 @@ export async function resolveCompiledVectorStore(workspace, vectorStore, options
     if (options.vectorStoreResolver) {
         return options.vectorStoreResolver(vectorStore.id);
     }
+    const { dataRoot } = getRuntimeStorageRoots(workspace.refs, workspace.workspaceRoot);
     if (vectorStore.kind === "LlamaIndexSimpleVectorStore") {
         const embeddingModel = resolveCompiledEmbeddingModelRef(workspace, vectorStore.embeddingModelRef);
         const embeddings = await resolveCompiledEmbeddingModel(embeddingModel, options.embeddingModelResolver);
-        return createLlamaIndexVectorStore(workspace.workspaceRoot, vectorStore, embeddings);
+        return createLlamaIndexVectorStore(dataRoot, vectorStore, embeddings);
     }
     if (vectorStore.kind === "QdrantVectorStore") {
         const embeddingModel = resolveCompiledEmbeddingModelRef(workspace, vectorStore.embeddingModelRef);
@@ -178,7 +179,7 @@ export async function resolveCompiledVectorStore(workspace, vectorStore, options
     const embeddingModel = resolveCompiledEmbeddingModelRef(workspace, vectorStore.embeddingModelRef);
     const embeddings = await resolveCompiledEmbeddingModel(embeddingModel, options.embeddingModelResolver);
     const db = createClient({
-        url: await ensureFileUrlDirectory(vectorStore.url ?? "", workspace.workspaceRoot),
+        url: await ensureFileUrlDirectory(vectorStore.url ?? "", dataRoot),
         ...(vectorStore.authToken ? { authToken: vectorStore.authToken } : {}),
     });
     const table = vectorStore.table ?? "vectors";

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

@@ -5,7 +5,7 @@ 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, getWorkspaceObject, resolvePromptValue, resolveRefId } from "./support/workspace-ref-utils.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.";
@@ -339,6 +339,7 @@ function resolveRuntimeMemoryConfig(agent, refs) {
 export function compileBinding(workspaceRoot, agent, agents, referencedSubagentIds, refs, models, tools) {
     const internalSubagent = referencedSubagentIds.has(agent.id);
     const runtimeDefaults = getRuntimeDefaults(refs);
+    const runtimeStorage = getRuntimeStorageRoots(refs, workspaceRoot);
     const resilience = getResilienceConfig(refs);
     const compiledAgentSkills = compileAgentSkills(workspaceRoot, agent);
     const compiledAgentMemory = compileAgentMemories(workspaceRoot, agent.memorySources);
@@ -361,15 +362,16 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
         ? mergeConfigObjects(runtimeFilesystemDefaults, getAgentExecutionObject(agent, "filesystem", { executionMode: "langchain-v1" }))
         : undefined;
     const runRoot = typeof agent.runRoot === "string" && agent.runRoot.trim().length > 0
-        ? path.resolve(workspaceRoot, agent.runRoot)
-        : typeof runtimeDefaults?.runRoot === "string" && runtimeDefaults.runRoot.trim().length > 0
-            ? path.resolve(workspaceRoot, runtimeDefaults.runRoot)
-            : path.join(workspaceRoot, "run-data");
+        ? (path.isAbsolute(agent.runRoot) ? agent.runRoot : path.resolve(runtimeStorage.dataRoot, agent.runRoot))
+        : runtimeStorage.dataRoot;
     const base = {
         agent,
         harnessRuntime: {
+            applicationRoot: runtimeStorage.applicationRoot,
+            dataRoot: runtimeStorage.dataRoot,
+            runtimeProfile: runtimeStorage.runtimeProfile,
             runRoot,
-            workspaceRoot,
+            workspaceRoot: runtimeStorage.applicationRoot,
             capabilities: inferAgentCapabilities(agent),
             resilience,
             ...(runtimeGovernanceDefaults ? { governance: runtimeGovernanceDefaults } : {}),

package/dist/workspace/compile.js

@@ -10,7 +10,7 @@ import { validateAgent, validateTopology } from "./validate.js";
 import { compileBinding } from "./agent-binding-compiler.js";
 import { discoverSubagents, ensureDiscoverySources } from "./support/discovery.js";
 import { collectAgentDiscoverySourceRefs, collectToolSourceRefs } from "./support/source-collectors.js";
-import { getRoutingDefaultAgentId, getRuntimeResources, getToolModuleDiscoveryConfig, getRoutingRules, resolveRefId, } from "./support/workspace-ref-utils.js";
+import { getRoutingDefaultAgentId, getRuntimeResources, getRuntimeStorageRoots, getToolModuleDiscoveryConfig, getRoutingRules, resolveRefId, } from "./support/workspace-ref-utils.js";
 import { hydrateAgentMcpTools, hydrateResourceAndExternalTools } from "./tool-hydration.js";
 import { traceStartupStage } from "../runtime/startup-tracing.js";
 import { shouldSkipScanDirectory } from "../utils/fs.js";
@@ -209,6 +209,11 @@ export async function loadWorkspace(workspaceRoot, options = {}) {
     const loaded = await traceStartupStage("workspace.load.objects", () => loadWorkspaceObjects(workspaceRoot, options), {
         workspaceRoot,
     });
+    const runtimeStorage = getRuntimeStorageRoots(loaded.refs, workspaceRoot);
+    if (path.resolve(runtimeStorage.applicationRoot) !== path.resolve(workspaceRoot)) {
+        throw new Error(`Runtime applicationRoot ${runtimeStorage.applicationRoot} must resolve to the loaded workspace root ${workspaceRoot}. ` +
+            "Load the shared application folder as the workspace root and use Runtime.dataRoot for writable profile data.");
+    }
     loaded.agents = await traceStartupStage("workspace.discover.subagents", () => discoverSubagents(loaded.agents, workspaceRoot), {
         workspaceRoot,
     });

package/dist/workspace/object-loader.js

@@ -516,6 +516,9 @@ export function parseAgentItem(item, sourcePath) {
         description: String(normalizedItem.description ?? ""),
         modelRef: readExecutionValue(normalizedItem, "modelRef", readSingleRef) ?? "",
         runRoot: typeof runtime?.runRoot === "string" ? runtime.runRoot : undefined,
+        applicationRoot: typeof runtime?.applicationRoot === "string" ? runtime.applicationRoot : undefined,
+        dataRoot: typeof runtime?.dataRoot === "string" ? runtime.dataRoot : undefined,
+        runtimeProfile: typeof runtime?.profile === "string" ? runtime.profile : undefined,
         toolRefs: toolBindings.map((binding) => binding.ref),
         toolBindings,
         inlineTools: undefined,

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

@@ -37,6 +37,12 @@ export type ToolModuleDiscoveryConfig = {
 };
 export declare function getWorkspaceObject(refs: Map<string, WorkspaceObject | ParsedAgentObject>, ref: string | undefined): WorkspaceObject | undefined;
 export declare function getRuntimeDefaults(refs: Map<string, WorkspaceObject | ParsedAgentObject>): Record<string, unknown> | undefined;
+export type RuntimeStorageRoots = {
+    applicationRoot: string;
+    dataRoot: string;
+    runtimeProfile: string;
+};
+export declare function getRuntimeStorageRoots(refs: Map<string, WorkspaceObject | ParsedAgentObject>, workspaceRoot: string): RuntimeStorageRoots;
 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;

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

@@ -26,6 +26,31 @@ export function getRuntimeDefaults(refs) {
     }
     return runtimes[0].value;
 }
+function asNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+export function getRuntimeStorageRoots(refs, workspaceRoot) {
+    const runtimeDefaults = getRuntimeDefaults(refs);
+    const configuredApplicationRoot = asNonEmptyString(runtimeDefaults?.applicationRoot);
+    const configuredDataRoot = asNonEmptyString(runtimeDefaults?.dataRoot);
+    const configuredProfile = asNonEmptyString(runtimeDefaults?.profile);
+    const applicationRoot = configuredApplicationRoot
+        ? (path.isAbsolute(configuredApplicationRoot)
+            ? configuredApplicationRoot
+            : path.resolve(workspaceRoot, configuredApplicationRoot))
+        : workspaceRoot;
+    const dataRoot = configuredDataRoot
+        ? (path.isAbsolute(configuredDataRoot)
+            ? configuredDataRoot
+            : path.resolve(applicationRoot, configuredDataRoot))
+        : path.join(applicationRoot, ".agent");
+    const runtimeProfile = configuredProfile ?? "default";
+    return {
+        applicationRoot,
+        dataRoot,
+        runtimeProfile,
+    };
+}
 export function getRuntimeResources(refs) {
     const runtimeDefaults = getRuntimeDefaults(refs);
     if (!Array.isArray(runtimeDefaults?.resources)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.283",
+  "version": "0.0.284",
   "description": "Workspace runtime for multi-agent applications",
   "license": "MIT",
   "type": "module",