@botbotgo/agent-harness 0.0.144 → 0.0.145

package/dist/config/runtime/runtime-memory.yaml

@@ -28,9 +28,11 @@ spec:
 
   # agent-harness feature: stable namespace roots used by the runtime memory policy layer.
   namespaces:
-    users: memories/users
-    projects: memories/projects
-    threads: memories/threads
+    users: memories/users/{userId}
+    projects: memories/projects/{projectId}
+    threads: memories/threads/{threadId}
+    agents: memories/agents/{agentId}
+    workspaces: memories/workspaces/{workspaceId}
 
   # agent-harness feature: retrieval defaults for selecting a bounded number of relevant memories per turn.
   retrieval:

package/dist/init-project.js

@@ -139,9 +139,11 @@ metadata:
 spec:
   enabled: true
   namespaces:
-    users: memories/users
-    projects: memories/projects
-    threads: memories/threads
+    users: memories/users/{userId}
+    projects: memories/projects/{projectId}
+    threads: memories/threads/{threadId}
+    agents: memories/agents/{agentId}
+    workspaces: memories/workspaces/{workspaceId}
   retrieval:
     defaultTopK: 5
     maxPromptMemories: 8

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.143";
+export declare const AGENT_HARNESS_VERSION = "0.0.144";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.143";
+export const AGENT_HARNESS_VERSION = "0.0.144";

package/dist/runtime/harness/system/runtime-memory-policy.d.ts

@@ -0,0 +1,18 @@
+export type ResolvedRuntimeMemoryPolicyConfig = {
+    enabled: true;
+    retrieval: {
+        defaultTopK: number;
+        maxPromptMemories: number;
+    };
+    namespaces: {
+        thread: string;
+        workspace: string;
+        agent: string;
+        user: string;
+        project: string;
+    };
+};
+export declare function normalizeLangMemMemoryKind(kind: string | undefined): "semantic" | "episodic" | "procedural";
+export declare function readRuntimeMemoryPolicyConfig(runtimeMemory: Record<string, unknown> | undefined, workspaceRoot: string): ResolvedRuntimeMemoryPolicyConfig | undefined;
+export declare function resolveMemoryNamespace(template: string, values: Record<string, string | undefined>): string[];
+export declare function scoreMemoryText(query: string, content: string, scopeBoost?: number): number;

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

@@ -0,0 +1,73 @@
+import path from "node:path";
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+}
+function asString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function asPositiveInteger(value) {
+    return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : undefined;
+}
+export function normalizeLangMemMemoryKind(kind) {
+    const normalized = kind?.trim().toLowerCase();
+    if (!normalized) {
+        return "semantic";
+    }
+    if (["episode", "episodic", "summary", "experience", "reflection"].includes(normalized)) {
+        return "episodic";
+    }
+    if (["procedural", "workflow", "procedure", "runbook", "playbook"].includes(normalized)) {
+        return "procedural";
+    }
+    return "semantic";
+}
+export function readRuntimeMemoryPolicyConfig(runtimeMemory, workspaceRoot) {
+    if (runtimeMemory?.enabled !== true) {
+        return undefined;
+    }
+    const retrieval = asRecord(runtimeMemory.retrieval);
+    const namespaces = asRecord(runtimeMemory.namespaces);
+    const workspaceId = path.basename(workspaceRoot) || "default";
+    return {
+        enabled: true,
+        retrieval: {
+            defaultTopK: asPositiveInteger(retrieval?.defaultTopK) ?? 5,
+            maxPromptMemories: asPositiveInteger(retrieval?.maxPromptMemories) ?? 8,
+        },
+        namespaces: {
+            thread: asString(namespaces?.threads) ?? "memories/threads/{threadId}",
+            workspace: asString(namespaces?.workspaces) ?? `memories/workspaces/${workspaceId}`,
+            agent: asString(namespaces?.agents) ?? "memories/agents/{agentId}",
+            user: asString(namespaces?.users) ?? "memories/users/{userId}",
+            project: asString(namespaces?.projects) ?? "memories/projects/{projectId}",
+        },
+    };
+}
+export function resolveMemoryNamespace(template, values) {
+    const rendered = template.replace(/\{([a-zA-Z0-9_]+)\}/g, (_match, key) => values[key] ?? key);
+    return rendered
+        .split("/")
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0);
+}
+function tokenize(text) {
+    return text
+        .toLowerCase()
+        .split(/[^a-z0-9_]+/i)
+        .map((token) => token.trim())
+        .filter((token) => token.length > 2);
+}
+export function scoreMemoryText(query, content, scopeBoost = 0) {
+    const queryTokens = new Set(tokenize(query));
+    if (queryTokens.size === 0) {
+        return scopeBoost;
+    }
+    const contentTokens = tokenize(content);
+    let overlap = 0;
+    for (const token of contentTokens) {
+        if (queryTokens.has(token)) {
+            overlap += 1;
+        }
+    }
+    return overlap + scopeBoost;
+}

package/dist/runtime/harness.d.ts

@@ -19,6 +19,7 @@ export declare class AgentHarnessRuntime {
     private readonly defaultRunRootValue;
     private readonly defaultStore;
     private readonly runtimeMemoryStore;
+    private readonly runtimeMemoryPolicy;
     private readonly routingRules;
     private readonly routingDefaultAgentId?;
     private readonly threadMemorySync;
@@ -90,7 +91,7 @@ export declare class AgentHarnessRuntime {
     private getRunCancellation;
     private finalizeCancelledRun;
     private invokeWithHistory;
-    private getWorkspaceMemoryNamespace;
+    private resolveMemoryNamespace;
     private buildRuntimeMemoryContext;
     private persistRuntimeMemoryCandidates;
     private appendMemoryDigest;

package/dist/runtime/harness.js

@@ -30,6 +30,7 @@ import { describeWorkspaceInventory, getAgentInventoryRecord, listAgentSkills as
 import { createDefaultHealthSnapshot, isInventoryEnabled, isThreadMemorySyncEnabled, } from "./harness/runtime-defaults.js";
 import { Mem0IngestionSync, readMem0RuntimeConfig } from "./harness/system/mem0-ingestion-sync.js";
 import { renderMemoryCandidatesMarkdown } from "./harness/system/runtime-memory-candidates.js";
+import { normalizeLangMemMemoryKind, readRuntimeMemoryPolicyConfig, resolveMemoryNamespace, scoreMemoryText, } from "./harness/system/runtime-memory-policy.js";
 import { resolveRuntimeAdapterOptions } from "./support/runtime-adapter-options.js";
 import { initializeHarnessRuntime, reclaimExpiredClaimedRuns as reclaimHarnessExpiredClaimedRuns, recoverStartupRuns as recoverHarnessStartupRuns, isStaleRunningRun as isHarnessStaleRunningRun, } from "./harness/run/startup-runtime.js";
 import { streamHarnessRun } from "./harness/run/stream-run.js";
@@ -57,6 +58,7 @@ export class AgentHarnessRuntime {
     defaultRunRootValue;
     defaultStore;
     runtimeMemoryStore;
+    runtimeMemoryPolicy;
     routingRules;
     routingDefaultAgentId;
     threadMemorySync;
@@ -120,6 +122,7 @@ export class AgentHarnessRuntime {
             ? this.defaultRuntimeEntryBinding.harnessRuntime.runtimeMemory.store
             : undefined;
         this.runtimeMemoryStore = resolveStoreFromConfig(this.stores, runtimeMemoryStoreConfig, runRoot) ?? this.defaultStore;
+        this.runtimeMemoryPolicy = readRuntimeMemoryPolicyConfig(this.defaultRuntimeEntryBinding?.harnessRuntime.runtimeMemory, this.workspace.workspaceRoot) ?? null;
         this.resolvedRuntimeAdapterOptions = resolveRuntimeAdapterOptions({
             workspace,
             runtimeAdapterOptions,
@@ -351,7 +354,7 @@ export class AgentHarnessRuntime {
     }
     async invokeWithHistory(binding, input, threadId, runId, resumePayload, priorHistory, options = {}) {
         const history = priorHistory ?? await this.loadPriorHistory(threadId, runId);
-        const memoryContext = options.memoryContext ?? await this.buildRuntimeMemoryContext(binding, threadId);
+        const memoryContext = options.memoryContext ?? await this.buildRuntimeMemoryContext(binding, threadId, input);
         const startedAt = Date.now();
         try {
             const result = await this.runtimeAdapter.invoke(binding, input, threadId, runId, resumePayload, history, {
@@ -367,24 +370,52 @@ export class AgentHarnessRuntime {
             throw error;
         }
     }
-    getWorkspaceMemoryNamespace(binding) {
+    resolveMemoryNamespace(scope, binding, options = {}) {
         const workspaceRoot = binding.harnessRuntime.workspaceRoot ?? this.workspace.workspaceRoot;
-        return ["memories", "workspaces", path.basename(workspaceRoot) || "default"];
+        const workspaceId = path.basename(workspaceRoot) || "default";
+        const template = this.runtimeMemoryPolicy?.namespaces[scope] ?? `memories/${scope}s/{${scope}Id}`;
+        return resolveMemoryNamespace(template, {
+            threadId: options.threadId,
+            agentId: binding.agent.id,
+            workspaceId,
+            userId: options.userId ?? "default",
+            projectId: options.projectId ?? workspaceId,
+        });
     }
-    async buildRuntimeMemoryContext(binding, threadId) {
+    async buildRuntimeMemoryContext(binding, threadId, input) {
+        const threadNamespace = this.resolveMemoryNamespace("thread", binding, { threadId });
+        const agentNamespace = this.resolveMemoryNamespace("agent", binding);
+        const workspaceNamespace = this.resolveMemoryNamespace("workspace", binding);
         const docs = await Promise.all([
-            this.runtimeMemoryStore.get(["memories", "threads", threadId], "durable-summary.md"),
-            this.runtimeMemoryStore.get(["memories", "threads", threadId], "tool-memory.md"),
-            this.runtimeMemoryStore.get(this.getWorkspaceMemoryNamespace(binding), "tool-memory.md"),
+            this.runtimeMemoryStore.get(threadNamespace, "durable-summary.md"),
+            this.runtimeMemoryStore.get(threadNamespace, "tool-memory.md"),
+            this.runtimeMemoryStore.get(threadNamespace, "semantic.md"),
+            this.runtimeMemoryStore.get(threadNamespace, "episodic.md"),
+            this.runtimeMemoryStore.get(threadNamespace, "procedural.md"),
+            this.runtimeMemoryStore.get(agentNamespace, "procedural.md"),
+            this.runtimeMemoryStore.get(workspaceNamespace, "semantic.md"),
+            this.runtimeMemoryStore.get(workspaceNamespace, "procedural.md"),
         ]);
-        const parts = docs
-            .map((doc) => doc?.value)
-            .map((value) => (typeof value?.content === "string" ? value.content.trim() : ""))
-            .filter((value) => value.length > 0);
-        if (parts.length === 0) {
+        const query = typeof input === "string" ? input : JSON.stringify(input ?? "");
+        const ranked = docs
+            .map((doc, index) => {
+            const content = doc?.value?.content;
+            if (typeof content !== "string" || content.trim().length === 0) {
+                return null;
+            }
+            const scopeBoost = index < 5 ? 4 : index === 5 ? 2 : 1;
+            return {
+                content: content.trim(),
+                score: scoreMemoryText(query, content, scopeBoost),
+            };
+        })
+            .filter((value) => Boolean(value))
+            .sort((left, right) => right.score - left.score)
+            .slice(0, this.runtimeMemoryPolicy?.retrieval.maxPromptMemories ?? 8);
+        if (ranked.length === 0) {
             return undefined;
         }
-        return parts.join("\n\n");
+        return ranked.map((entry) => entry.content).join("\n\n");
     }
     async persistRuntimeMemoryCandidates(binding, threadId, runId, value) {
         if (!Array.isArray(value) || value.length === 0) {
@@ -407,13 +438,13 @@ export class AgentHarnessRuntime {
         });
         const writes = [];
         if (threadCandidates.length > 0) {
-            writes.push(this.appendMemoryDigest(["memories", "threads", threadId], "tool-memory.md", threadCandidates, 12, "Thread Tool Memory"));
+            writes.push(this.appendMemoryDigest(this.resolveMemoryNamespace("thread", binding, { threadId }), "tool-memory.md", threadCandidates, 12, "Thread Tool Memory"));
         }
         if (workspaceCandidates.length > 0) {
-            writes.push(this.appendMemoryDigest(this.getWorkspaceMemoryNamespace(binding), "tool-memory.md", workspaceCandidates, 20, "Workspace Tool Memory"));
+            writes.push(this.appendMemoryDigest(this.resolveMemoryNamespace("workspace", binding), "tool-memory.md", workspaceCandidates, 20, "Workspace Tool Memory"));
         }
         if (agentCandidates.length > 0) {
-            writes.push(this.appendMemoryDigest(["memories", "agents", binding.agent.id], "tool-memory.md", agentCandidates, 20, "Agent Tool Memory"));
+            writes.push(this.appendMemoryDigest(this.resolveMemoryNamespace("agent", binding), "tool-memory.md", agentCandidates, 20, "Agent Tool Memory"));
         }
         await Promise.all(writes);
     }
@@ -430,10 +461,23 @@ export class AgentHarnessRuntime {
             merged.push(candidate);
         }
         const recent = merged.slice(-maxEntries);
+        const taxonomyGroups = new Map();
+        for (const candidate of recent) {
+            const kind = normalizeLangMemMemoryKind(candidate.kind);
+            const existing = taxonomyGroups.get(kind) ?? [];
+            existing.push({ ...candidate, kind });
+            taxonomyGroups.set(kind, existing);
+        }
         await this.runtimeMemoryStore.put(namespace, key, {
             content: `${renderMemoryCandidatesMarkdown(title, recent)}\n`,
             items: recent,
         });
+        await Promise.all(Array.from(taxonomyGroups.entries()).map(async ([kind, items]) => {
+            await this.runtimeMemoryStore.put(namespace, `${kind}.md`, {
+                content: `${renderMemoryCandidatesMarkdown(`${title} (${kind})`, items)}\n`,
+                items,
+            });
+        }));
     }
     async resolvePersistedRunPriority(threadId, runId) {
         const persisted = await this.persistence.getRunRequest(threadId, runId);
@@ -591,7 +635,7 @@ export class AgentHarnessRuntime {
             input: options.input,
             invocation: {
                 ...invocation,
-                memoryContext: await this.buildRuntimeMemoryContext(binding, threadId),
+                memoryContext: await this.buildRuntimeMemoryContext(binding, threadId, options.input),
             },
             threadId,
             runId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.144",
+  "version": "0.0.145",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",