@botbotgo/agent-harness 0.0.281 → 0.0.283

package/dist/persistence/file-store.js

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { appendFile, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import { ensureDir, fileExists, readJson, writeJson } from "../utils/fs.js";
+import { resolveRuntimeArtifactsRoot } from "../runtime/support/runtime-layout.js";
 function nowIso() {
     return new Date(Date.now()).toISOString();
 }
@@ -9,39 +10,42 @@ export class FilePersistence {
     constructor(runRoot) {
         this.runRoot = runRoot;
     }
+    artifactsRoot() {
+        return resolveRuntimeArtifactsRoot(this.runRoot);
+    }
     threadIndexPath(threadId) {
-        return path.join(this.runRoot, "indexes", "threads", `${threadId}.json`);
+        return path.join(this.artifactsRoot(), "indexes", "sessions", `${threadId}.json`);
     }
     runIndexPath(runId) {
-        return path.join(this.runRoot, "indexes", "runs", `${runId}.json`);
+        return path.join(this.artifactsRoot(), "indexes", "requests", `${runId}.json`);
     }
     approvalIndexPath(approvalId) {
-        return path.join(this.runRoot, "indexes", "approvals", `${approvalId}.json`);
+        return path.join(this.artifactsRoot(), "indexes", "approvals", `${approvalId}.json`);
     }
     runQueuePath(runId) {
-        return path.join(this.runRoot, "indexes", "queue", `${runId}.json`);
+        return path.join(this.artifactsRoot(), "indexes", "requests-queue", `${runId}.json`);
     }
     runControlPath(runId) {
-        return path.join(this.runRoot, "indexes", "run-control", `${runId}.json`);
+        return path.join(this.artifactsRoot(), "indexes", "requests-control", `${runId}.json`);
     }
     traceItemsPath(threadId, runId) {
         return path.join(this.runDir(threadId, runId), "trace-items.ndjson");
     }
     async initialize() {
         await Promise.all([
-            "indexes/threads",
-            "indexes/runs",
+            "indexes/sessions",
+            "indexes/requests",
             "indexes/approvals",
-            "indexes/queue",
-            "indexes/run-control",
-            "threads",
-        ].map((segment) => ensureDir(path.join(this.runRoot, segment))));
+            "indexes/requests-queue",
+            "indexes/requests-control",
+            "sessions",
+        ].map((segment) => ensureDir(path.join(this.artifactsRoot(), segment))));
     }
     threadDir(threadId) {
-        return path.join(this.runRoot, "threads", threadId);
+        return path.join(this.artifactsRoot(), "sessions", threadId);
     }
     runDir(threadId, runId) {
-        return path.join(this.threadDir(threadId), "runs", runId);
+        return path.join(this.threadDir(threadId), "requests", runId);
     }
     async createThread(input) {
         const meta = {
@@ -58,7 +62,7 @@ export class FilePersistence {
             threadId: input.threadId,
             items: [],
         });
-        await writeJson(path.join(this.runRoot, "indexes", "threads", `${input.threadId}.json`), {
+        await writeJson(this.threadIndexPath(input.threadId), {
             threadId: input.threadId,
             status: input.status,
             latestRunId: input.runId,
@@ -118,7 +122,7 @@ export class FilePersistence {
                 hasError: false,
                 lastError: null,
             }),
-            writeJson(path.join(this.runRoot, "indexes", "runs", `${input.runId}.json`), {
+            writeJson(this.runIndexPath(input.runId), {
                 runId: input.runId,
                 threadId: input.threadId,
                 state: "running",
@@ -175,7 +179,7 @@ export class FilePersistence {
                 kind: "langgraph-checkpoint",
             });
         }
-        await writeJson(path.join(this.runRoot, "indexes", "runs", `${runId}.json`), {
+        await writeJson(this.runIndexPath(runId), {
             runId,
             threadId,
             state,
@@ -188,7 +192,7 @@ export class FilePersistence {
         threadMeta.updatedAt = now;
         threadMeta.latestRunId = runId;
         await writeJson(threadMetaPath, threadMeta);
-        await writeJson(path.join(this.runRoot, "indexes", "threads", `${threadId}.json`), {
+        await writeJson(this.threadIndexPath(threadId), {
             threadId,
             status: state,
             latestRunId: runId,
@@ -208,7 +212,7 @@ export class FilePersistence {
         ]);
     }
     async listSessions(filter = {}) {
-        const threadIndexDir = path.join(this.runRoot, "indexes", "threads");
+        const threadIndexDir = path.join(this.artifactsRoot(), "indexes", "sessions");
         if (!(await fileExists(threadIndexDir))) {
             return [];
         }
@@ -253,7 +257,7 @@ export class FilePersistence {
         return summaries.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
     }
     async listRunIndexes() {
-        const runIndexDir = path.join(this.runRoot, "indexes", "runs");
+        const runIndexDir = path.join(this.artifactsRoot(), "indexes", "requests");
         if (!(await fileExists(runIndexDir))) {
             return [];
         }
@@ -314,7 +318,7 @@ export class FilePersistence {
         return this.readRunSummary(index.threadId, index.runId);
     }
     async getSession(threadId) {
-        const filePath = path.join(this.runRoot, "indexes", "threads", `${threadId}.json`);
+        const filePath = this.threadIndexPath(threadId);
         if (!(await fileExists(filePath))) {
             return null;
         }
@@ -360,7 +364,7 @@ export class FilePersistence {
         return Promise.all(entries.map((entry) => readJson(path.join(eventsDir, entry))));
     }
     async listApprovals(filter = {}) {
-        const approvalsDir = path.join(this.runRoot, "indexes", "approvals");
+        const approvalsDir = path.join(this.artifactsRoot(), "indexes", "approvals");
         if (!(await fileExists(approvalsDir))) {
             return [];
         }
@@ -380,7 +384,7 @@ export class FilePersistence {
         });
     }
     async getApproval(approvalId) {
-        const approvalPath = path.join(this.runRoot, "indexes", "approvals", `${approvalId}.json`);
+        const approvalPath = this.approvalIndexPath(approvalId);
         if (!(await fileExists(approvalPath))) {
             return null;
         }
@@ -496,7 +500,7 @@ export class FilePersistence {
         };
         await Promise.all([
             writeJson(path.join(this.runDir(sessionId, requestId), "approvals", `${record.approvalId}.json`), normalized),
-            writeJson(path.join(this.runRoot, "indexes", "approvals", `${record.approvalId}.json`), normalized),
+            writeJson(this.approvalIndexPath(record.approvalId), normalized),
         ]);
     }
     async resolveApproval(threadId, runId, approvalId, status) {
@@ -509,7 +513,7 @@ export class FilePersistence {
         };
         await Promise.all([
             writeJson(approvalPath, updated),
-            writeJson(path.join(this.runRoot, "indexes", "approvals", `${approvalId}.json`), updated),
+            writeJson(this.approvalIndexPath(approvalId), updated),
         ]);
         return updated;
     }
@@ -668,7 +672,7 @@ export class FilePersistence {
         });
     }
     async listExpiredClaimedRuns(cutoffIso) {
-        const queueDir = path.join(this.runRoot, "indexes", "queue");
+        const queueDir = path.join(this.artifactsRoot(), "indexes", "requests-queue");
         if (!(await fileExists(queueDir))) {
             return [];
         }

package/dist/persistence/sqlite-store.js

@@ -111,7 +111,7 @@ export class SqlitePersistence {
     }
     async getClient() {
         if (!this.client) {
-            await mkdir(this.runRoot, { recursive: true });
+            await mkdir(path.dirname(this.dbPath), { recursive: true });
             this.client = createClient({ url: toSqliteUrl(this.dbPath) });
         }
         return this.client;

package/dist/runtime/harness/run/resources.js

@@ -1,6 +1,7 @@
 import { createCheckpointerForConfig, createStoreForConfig } from "../../support/runtime-factories.js";
 import { resolveCompiledEmbeddingModel, resolveCompiledEmbeddingModelRef } from "../../support/embedding-models.js";
 import { resolveCompiledVectorStore, resolveCompiledVectorStoreRef } from "../../support/vector-stores.js";
+import { resolveRuntimeCheckpointerPath } from "../../support/runtime-layout.js";
 export function resolveStoreFromConfig(stores, storeConfig, runRoot) {
     const cacheKey = storeConfig ? `${runRoot}:${JSON.stringify(storeConfig)}` : undefined;
     if (!storeConfig || !cacheKey) {
@@ -42,12 +43,13 @@ export async function resolveVectorStore(workspace, vectorStores, vectorStoreRef
     return resolved;
 }
 export function resolveCheckpointer(checkpointers, binding) {
-    const key = `${binding.harnessRuntime.runRoot}:${JSON.stringify(binding.harnessRuntime.checkpointer ?? { kind: "FileCheckpointer", path: "checkpoints.json" })}`;
+    const key = `${binding.harnessRuntime.runRoot}:${JSON.stringify(binding.harnessRuntime.checkpointer ?? { kind: "FileCheckpointer", path: resolveRuntimeCheckpointerPath(binding.harnessRuntime.runRoot, "checkpoints.json") })}`;
     const existing = checkpointers.get(key);
     if (existing) {
         return existing;
     }
-    const resolvedConfig = binding.harnessRuntime.checkpointer ?? { kind: "FileCheckpointer", path: "checkpoints.json" };
+    const resolvedConfig = binding.harnessRuntime.checkpointer ??
+        { kind: "FileCheckpointer", path: resolveRuntimeCheckpointerPath(binding.harnessRuntime.runRoot, "checkpoints.json") };
     if (typeof resolvedConfig === "boolean") {
         checkpointers.set(key, resolvedConfig);
         return resolvedConfig;

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

@@ -35,7 +35,7 @@ export function readRuntimeMemoryPolicyConfig(runtimeMemory, workspaceRoot) {
             maxPromptMemories: asPositiveInteger(retrieval?.maxPromptMemories) ?? 8,
         },
         namespaces: {
-            thread: asString(namespaces?.threads) ?? "memories/threads/{threadId}",
+            thread: asString(namespaces?.sessions) ?? "memories/sessions/{sessionId}",
             workspace: asString(namespaces?.workspaces) ?? `memories/workspaces/${workspaceId}`,
             agent: asString(namespaces?.agents) ?? "memories/agents/{agentId}",
             user: asString(namespaces?.users) ?? "memories/users/{userId}",

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

@@ -440,6 +440,10 @@ export async function persistStructuredMemoryRecords(options) {
         const evaluated = evaluateDecision(existing, incoming, options.recordedAt);
         const recordsToWrite = [evaluated.primaryRecord, ...evaluated.additionalRecords];
         for (const record of recordsToWrite) {
+            const priorRecord = existingRecords.find((item) => item.id === record.id);
+            if (priorRecord) {
+                await deleteRecordIndexes(options.store, priorRecord);
+            }
             await putRecordWithIndexes(options.store, record, options.recordedAt);
             const existingIndex = existingRecords.findIndex((item) => item.id === record.id);
             if (existingIndex >= 0) {

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

@@ -192,10 +192,10 @@ export class RuntimeMemorySync {
         await this.store.put(this.resolveThreadNamespace(threadId), "durable-summary.md", { content: `${digestMarkdown}\n` });
     }
     resolveThreadNamespace(threadId) {
-        return this.options.resolveThreadNamespace ? this.options.resolveThreadNamespace(threadId) : ["memories", "threads", threadId];
+        return this.options.resolveThreadNamespace ? this.options.resolveThreadNamespace(threadId) : ["memories", "sessions", threadId];
     }
     resolveRunNamespace(threadId) {
-        return this.options.resolveRunNamespace ? this.options.resolveRunNamespace(threadId) : ["memories", "runs", threadId];
+        return this.options.resolveRunNamespace ? this.options.resolveRunNamespace(threadId) : ["memories", "requests", threadId];
     }
     async close() {
         await Promise.allSettled(Array.from(this.pending));

package/dist/runtime/harness/system/thread-memory-sync.js

@@ -47,7 +47,7 @@ function formatOpenApprovalsSection(approvals) {
     return lines;
 }
 function resolveThreadNamespace(threadId, resolver) {
-    return resolver ? resolver(threadId) : ["memories", "threads", threadId];
+    return resolver ? resolver(threadId) : ["memories", "sessions", threadId];
 }
 const THREAD_MEMORY_EVENT_TYPES = new Set([
     "run.state.changed",

package/dist/runtime/harness.d.ts

@@ -32,6 +32,7 @@ export declare class AgentHarnessRuntime {
     private readonly mem0SemanticRecall;
     private readonly runtimeMemoryFormationConfig;
     private readonly runtimeMemoryManager;
+    private readonly knowledgeModule;
     private readonly runtimeMemoryFormationSync;
     private readonly unregisterRuntimeMemoryFormationSync;
     private readonly resolvedRuntimeAdapterOptions;
@@ -136,24 +137,8 @@ export declare class AgentHarnessRuntime {
     private invokeWithHistory;
     private resolveMemoryNamespace;
     private getWorkspaceId;
-    private summarizeMemoryContent;
-    private matchesMemoryFilters;
-    private resolveRecallScopes;
-    private matchesRecallScope;
-    private getMemoryScopeBoost;
-    private memoryFreshnessBoost;
-    private scoreStructuredRecord;
-    private normalizeMemoryDedupKey;
-    private inferMem0MemoryKind;
-    private inferMem0MemoryScope;
-    private createMem0MemoryRecord;
-    private rankRecallCandidates;
-    private rebuildRuntimeMemoryVectorIndex;
-    private refreshStructuredMemoryScope;
     private buildRuntimeMemoryContext;
     private persistRuntimeMemoryCandidates;
-    private persistStructuredMemoryCandidates;
-    private appendMemoryDigest;
     private resolvePersistedRunPriority;
     private enqueuePendingRunSlot;
     private executeQueuedRun;