@botbotgo/agent-harness 0.0.154 → 0.0.156

package/dist/runtime/harness.js

@@ -21,16 +21,17 @@ import { cancelRunOperation, executeQueuedRunOperation, resumeRun } from "./harn
 import { acquireRunSlot as acquireHarnessRunSlot } from "./harness/run/run-slot-acquisition.js";
 import { dropPendingRunSlot, enqueuePendingRunSlot } from "./harness/run/run-queue.js";
 import { getDefaultRuntimeEntryAgentId, resolveSelectedAgentId, routeAgentId } from "./harness/run/routing.js";
-import { resolveStoreFromConfig, } from "./harness/run/resources.js";
+import { resolveStoreFromConfig, resolveVectorStore, } from "./harness/run/resources.js";
 import { createToolMcpServerFromTools, serveToolsOverStdioFromHarness } from "../mcp.js";
 import { closeMcpClientsForWorkspace } from "../resource/mcp-tool-support.js";
 import { getBindingRuntimeExecutionMode, } from "./support/compiled-binding.js";
 import { bindingSupportsRunningReplay, getWorkspaceBinding, resolveWorkspaceAgentTools, } from "./harness/bindings.js";
 import { describeWorkspaceInventory, getAgentInventoryRecord, listAgentSkills as listWorkspaceAgentSkills, } from "./harness/system/inventory.js";
 import { createDefaultHealthSnapshot, isInventoryEnabled, isThreadMemorySyncEnabled, } from "./harness/runtime-defaults.js";
-import { Mem0IngestionSync, readMem0RuntimeConfig } from "./harness/system/mem0-ingestion-sync.js";
+import { Mem0IngestionSync, Mem0SemanticRecall, readMem0RuntimeConfig, } from "./harness/system/mem0-ingestion-sync.js";
+import { createRuntimeMemoryManager, RuntimeMemoryFormationSync, readRuntimeMemoryFormationConfig, } from "./harness/system/runtime-memory-manager.js";
 import { renderMemoryCandidatesMarkdown } from "./harness/system/runtime-memory-candidates.js";
-import { listMemoryRecordsForScopes, persistStructuredMemoryRecords, } from "./harness/system/runtime-memory-records.js";
+import { findMemoryRecordById, getMemoryRecord, listMemoryRecordsForScopes, persistStructuredMemoryRecords, removeMemoryRecord, updateMemoryRecord, } from "./harness/system/runtime-memory-records.js";
 import { consolidateStructuredMemoryScope } from "./harness/system/runtime-memory-consolidation.js";
 import { normalizeLangMemMemoryKind, readRuntimeMemoryMaintenanceConfig, readRuntimeMemoryPolicyConfig, resolveMemoryNamespace, scoreMemoryText, } from "./harness/system/runtime-memory-policy.js";
 import { resolveRuntimeAdapterOptions } from "./support/runtime-adapter-options.js";
@@ -70,6 +71,11 @@ export class AgentHarnessRuntime {
     unregisterRuntimeMemorySync;
     mem0IngestionSync;
     unregisterMem0IngestionSync;
+    mem0SemanticRecall;
+    runtimeMemoryFormationConfig;
+    runtimeMemoryManager;
+    runtimeMemoryFormationSync;
+    unregisterRuntimeMemoryFormationSync;
     resolvedRuntimeAdapterOptions;
     healthMonitor;
     recoveryConfig;
@@ -84,6 +90,19 @@ export class AgentHarnessRuntime {
     closed = false;
     backgroundEventRuntime;
     runtimeEventOperations;
+    async resolveRuntimeMemoryVectorStore() {
+        const vectorStoreConfig = typeof this.defaultRuntimeEntryBinding?.harnessRuntime.runtimeMemory?.vectorStore === "object" &&
+            this.defaultRuntimeEntryBinding?.harnessRuntime.runtimeMemory?.vectorStore
+            ? this.defaultRuntimeEntryBinding.harnessRuntime.runtimeMemory.vectorStore
+            : undefined;
+        const vectorStoreRef = typeof vectorStoreConfig?.ref === "string" && vectorStoreConfig.ref.trim().length > 0 ? vectorStoreConfig.ref : undefined;
+        try {
+            return await resolveVectorStore(this.workspace, this.vectorStores, vectorStoreRef, this.resolvedRuntimeAdapterOptions);
+        }
+        catch {
+            return null;
+        }
+    }
     defaultRunRoot() {
         return this.defaultRunRootValue;
     }
@@ -185,10 +204,40 @@ export class AgentHarnessRuntime {
         if (mem0RuntimeConfig) {
             this.mem0IngestionSync = new Mem0IngestionSync(this.persistence, mem0RuntimeConfig, runRoot);
             this.unregisterMem0IngestionSync = this.eventBus.registerProjection(this.mem0IngestionSync);
+            this.mem0SemanticRecall = new Mem0SemanticRecall(mem0RuntimeConfig);
         }
         else {
             this.mem0IngestionSync = null;
             this.unregisterMem0IngestionSync = () => { };
+            this.mem0SemanticRecall = null;
+        }
+        const runtimeMemoryFormationConfig = readRuntimeMemoryFormationConfig(this.defaultRuntimeEntryBinding?.harnessRuntime.runtimeMemory, this.workspace.workspaceRoot);
+        this.runtimeMemoryFormationConfig = runtimeMemoryFormationConfig ?? null;
+        this.runtimeMemoryManager =
+            this.defaultRuntimeEntryBinding && runtimeMemoryFormationConfig
+                ? createRuntimeMemoryManager({
+                    workspace: this.workspace,
+                    binding: this.defaultRuntimeEntryBinding,
+                    config: runtimeMemoryFormationConfig,
+                    modelResolver: this.resolvedRuntimeAdapterOptions.modelResolver,
+                })
+                : null;
+        if (runtimeMemoryFormationConfig) {
+            this.runtimeMemoryFormationSync = new RuntimeMemoryFormationSync(this.persistence, runtimeMemoryFormationConfig, (input) => this.persistStructuredMemoryCandidates(this.defaultRuntimeEntryBinding, {
+                candidates: input.candidates,
+                threadId: input.threadId,
+                runId: input.runId,
+                agentId: input.agentId,
+                userId: input.userId,
+                projectId: input.projectId,
+                recordedAt: input.recordedAt,
+                storeCandidateLog: false,
+            }).then(() => undefined), runRoot);
+            this.unregisterRuntimeMemoryFormationSync = this.eventBus.registerProjection(this.runtimeMemoryFormationSync);
+        }
+        else {
+            this.runtimeMemoryFormationSync = null;
+            this.unregisterRuntimeMemoryFormationSync = () => { };
         }
         this.recoveryConfig = getRecoveryConfig(workspace.refs);
         this.concurrencyConfig = getConcurrencyConfig(workspace.refs);
@@ -294,27 +343,116 @@ export class AgentHarnessRuntime {
             ? input.topK
             : (this.runtimeMemoryPolicy?.retrieval.defaultTopK ?? 5);
         const kinds = input.kinds?.length ? new Set(input.kinds) : null;
+        const items = (await this.rankRecallCandidates(binding, {
+            query: input.query.trim(),
+            scopes,
+            kinds,
+            topK,
+            includeStale: input.includeStale === true,
+            filters: {
+                threadId: input.threadId,
+                agentId,
+                workspaceId: input.workspaceId ?? workspaceId,
+                userId,
+                projectId,
+            },
+        }))
+            .slice(0, topK)
+            .map(({ record }) => record);
+        return { items };
+    }
+    async listMemories(input = {}) {
+        const binding = this.defaultRuntimeEntryBinding;
+        if (!binding) {
+            throw new Error("listMemories requires a runtime entry binding.");
+        }
+        const workspaceId = this.getWorkspaceId(binding);
+        const scopes = Array.isArray(input.scopes) && input.scopes.length > 0
+            ? Array.from(new Set(input.scopes))
+            : ["thread", "agent", "workspace", "user", "project"];
+        const kinds = input.kinds?.length ? new Set(input.kinds) : null;
+        const statuses = input.status?.length ? new Set(input.status) : new Set(["active"]);
+        const limit = typeof input.limit === "number" && Number.isInteger(input.limit) && input.limit > 0
+            ? input.limit
+            : Number.POSITIVE_INFINITY;
         const items = (await listMemoryRecordsForScopes(this.runtimeMemoryStore, scopes))
-            .filter((record) => this.matchesRecallScope(record, {
+            .filter((record) => statuses.has(record.status))
+            .filter((record) => !kinds || kinds.has(record.kind))
+            .filter((record) => this.matchesMemoryFilters(record, {
             threadId: input.threadId,
-            agentId,
+            agentId: input.agentId,
             workspaceId: input.workspaceId ?? workspaceId,
-            userId,
-            projectId,
-        }))
-            .filter((record) => (input.includeStale ? record.status === "active" || record.status === "stale" : record.status === "active"))
-            .filter((record) => (kinds ? kinds.has(record.kind) : true))
-            .map((record) => ({
-            record,
-            score: scoreMemoryText(input.query.trim(), `${record.summary}\n${record.content}`, this.getMemoryScopeBoost(record.scope)) +
-                Math.max(0, 1 - ((Date.now() - Date.parse(record.lastConfirmedAt)) / (1000 * 60 * 60 * 24 * 365))) +
-                record.confidence,
+            userId: input.userId,
+            projectId: input.projectId,
         }))
-            .sort((left, right) => right.score - left.score)
-            .slice(0, topK)
-            .map(({ record }) => record);
+            .sort((left, right) => right.lastConfirmedAt.localeCompare(left.lastConfirmedAt))
+            .slice(0, limit);
         return { items };
     }
+    async updateMemory(input) {
+        const binding = this.defaultRuntimeEntryBinding;
+        if (!binding) {
+            throw new Error("updateMemory requires a runtime entry binding.");
+        }
+        if (typeof input.memoryId !== "string" || input.memoryId.trim().length === 0) {
+            throw new Error("updateMemory requires a non-empty memoryId.");
+        }
+        const existing = await findMemoryRecordById(this.runtimeMemoryStore, input.memoryId.trim());
+        if (!existing) {
+            throw new Error(`Memory record not found: ${input.memoryId}`);
+        }
+        const updatedAt = new Date().toISOString();
+        const nextContent = typeof input.content === "string"
+            ? input.content.trim()
+            : existing.content;
+        if (nextContent.length === 0) {
+            throw new Error("updateMemory requires content to remain non-empty.");
+        }
+        const next = {
+            ...existing,
+            content: nextContent,
+            summary: typeof input.summary === "string"
+                ? input.summary.trim() || this.summarizeMemoryContent(nextContent)
+                : (typeof input.content === "string" ? this.summarizeMemoryContent(nextContent) : existing.summary),
+            status: input.status ?? existing.status,
+            confidence: typeof input.confidence === "number" ? Math.max(0, Math.min(1, input.confidence)) : existing.confidence,
+            expiresAt: input.expiresAt === undefined ? existing.expiresAt : (input.expiresAt ?? undefined),
+            sourceType: typeof input.sourceType === "string" && input.sourceType.trim().length > 0 ? input.sourceType.trim() : existing.sourceType,
+            sourceRefs: Array.isArray(input.sourceRefs)
+                ? Array.from(new Set(input.sourceRefs.map((item) => item.trim()).filter((item) => item.length > 0)))
+                : existing.sourceRefs,
+            tags: Array.isArray(input.tags)
+                ? Array.from(new Set(input.tags.map((item) => item.trim()).filter((item) => item.length > 0)))
+                : existing.tags,
+            observedAt: typeof input.observedAt === "string" && input.observedAt.trim().length > 0 ? input.observedAt : existing.observedAt,
+            lastConfirmedAt: typeof input.lastConfirmedAt === "string" && input.lastConfirmedAt.trim().length > 0
+                ? input.lastConfirmedAt
+                : updatedAt,
+            provenance: input.provenance ? { ...existing.provenance, ...input.provenance } : existing.provenance,
+            revision: existing.revision + 1,
+        };
+        await updateMemoryRecord(this.runtimeMemoryStore, next, updatedAt);
+        await this.rebuildRuntimeMemoryVectorIndex();
+        await this.refreshStructuredMemoryScope(binding, next);
+        return next;
+    }
+    async removeMemory(input) {
+        const binding = this.defaultRuntimeEntryBinding;
+        if (!binding) {
+            throw new Error("removeMemory requires a runtime entry binding.");
+        }
+        if (typeof input.memoryId !== "string" || input.memoryId.trim().length === 0) {
+            throw new Error("removeMemory requires a non-empty memoryId.");
+        }
+        const existing = await findMemoryRecordById(this.runtimeMemoryStore, input.memoryId.trim());
+        if (!existing) {
+            throw new Error(`Memory record not found: ${input.memoryId}`);
+        }
+        await removeMemoryRecord(this.runtimeMemoryStore, existing.scope, existing.id);
+        await this.rebuildRuntimeMemoryVectorIndex();
+        await this.refreshStructuredMemoryScope(binding, existing);
+        return existing;
+    }
     async getRun(runId) {
         return this.persistence.getRun(runId);
     }
@@ -468,7 +606,7 @@ export class AgentHarnessRuntime {
         const template = this.runtimeMemoryPolicy?.namespaces[scope] ?? `memories/${scope}s/{${scope}Id}`;
         return resolveMemoryNamespace(template, {
             threadId: options.threadId,
-            agentId: binding.agent.id,
+            agentId: options.agentId ?? binding.agent.id,
             workspaceId,
             userId: options.userId ?? "default",
             projectId: options.projectId ?? workspaceId,
@@ -478,6 +616,27 @@ export class AgentHarnessRuntime {
         const workspaceRoot = binding.harnessRuntime.workspaceRoot ?? this.workspace.workspaceRoot;
         return path.basename(workspaceRoot) || "default";
     }
+    summarizeMemoryContent(content) {
+        return (content.trim().split("\n")[0] || content.trim()).slice(0, 240);
+    }
+    matchesMemoryFilters(record, filters) {
+        if (filters.threadId && record.provenance.threadId !== filters.threadId) {
+            return false;
+        }
+        if (filters.agentId && record.provenance.agentId !== filters.agentId) {
+            return false;
+        }
+        if (filters.workspaceId && record.provenance.workspaceId !== filters.workspaceId) {
+            return false;
+        }
+        if (filters.userId && record.provenance.userId !== filters.userId) {
+            return false;
+        }
+        if (filters.projectId && record.provenance.projectId !== filters.projectId) {
+            return false;
+        }
+        return true;
+    }
     resolveRecallScopes(input) {
         if (Array.isArray(input.scopes) && input.scopes.length > 0) {
             return Array.from(new Set(input.scopes));
@@ -518,36 +677,260 @@ export class AgentHarnessRuntime {
         }
         return 0;
     }
-    async buildRuntimeMemoryContext(binding, threadId, input) {
-        const query = typeof input === "string" ? input : JSON.stringify(input ?? "");
-        const ranked = (await listMemoryRecordsForScopes(this.runtimeMemoryStore, ["thread", "agent", "workspace"]))
-            .filter((record) => {
-            if (record.status !== "active") {
-                return false;
+    memoryFreshnessBoost(value) {
+        return Math.max(0, 1 - ((Date.now() - Date.parse(value)) / (1000 * 60 * 60 * 24 * 365)));
+    }
+    scoreStructuredRecord(query, record) {
+        return (scoreMemoryText(query, `${record.summary}\n${record.content}`, this.getMemoryScopeBoost(record.scope)) +
+            this.memoryFreshnessBoost(record.lastConfirmedAt) +
+            record.confidence);
+    }
+    normalizeMemoryDedupKey(record) {
+        return `${record.scope}::${record.summary.toLowerCase().replace(/\s+/g, " ").trim()}::${record.content.toLowerCase().replace(/\s+/g, " ").trim()}`;
+    }
+    inferMem0MemoryKind(hit) {
+        const candidates = [
+            ...hit.categories,
+            typeof hit.metadata.kind === "string" ? hit.metadata.kind : undefined,
+            typeof hit.metadata.memoryType === "string" ? hit.metadata.memoryType : undefined,
+        ].filter((value) => typeof value === "string" && value.trim().length > 0);
+        for (const candidate of candidates) {
+            const kind = normalizeLangMemMemoryKind(candidate);
+            if (kind === "semantic" || kind === "episodic" || kind === "procedural") {
+                return kind;
+            }
+        }
+        return "semantic";
+    }
+    inferMem0MemoryScope(hit, filters) {
+        const metadataScope = typeof hit.metadata.scope === "string" ? hit.metadata.scope : undefined;
+        if (metadataScope === "thread" || metadataScope === "agent" || metadataScope === "workspace" || metadataScope === "user" || metadataScope === "project") {
+            return metadataScope;
+        }
+        if (typeof hit.metadata.threadId === "string" && filters.threadId && hit.metadata.threadId === filters.threadId) {
+            return "thread";
+        }
+        if (hit.agentId === filters.agentId || hit.metadata.agentId === filters.agentId) {
+            return "agent";
+        }
+        return "workspace";
+    }
+    createMem0MemoryRecord(hit, filters) {
+        const scope = this.inferMem0MemoryScope(hit, filters);
+        const kind = this.inferMem0MemoryKind(hit);
+        const summary = hit.memory.split("\n")[0]?.trim() || hit.memory;
+        return {
+            id: `mem0:${hit.id}`,
+            canonicalKey: `mem0:${hit.id}`,
+            kind,
+            scope,
+            content: hit.memory,
+            summary: summary.slice(0, 240),
+            status: "active",
+            confidence: Math.max(0, Math.min(1, hit.score || 0.5)),
+            createdAt: hit.createdAt,
+            observedAt: hit.createdAt,
+            lastConfirmedAt: hit.updatedAt,
+            sourceType: "mem0-search",
+            sourceRefs: [`mem0:${hit.id}`],
+            tags: hit.categories,
+            provenance: {
+                source: "mem0",
+                threadId: typeof hit.metadata.threadId === "string" ? hit.metadata.threadId : filters.threadId,
+                runId: hit.runId ?? (typeof hit.metadata.runId === "string" ? hit.metadata.runId : undefined),
+                agentId: hit.agentId ?? (typeof hit.metadata.agentId === "string" ? hit.metadata.agentId : filters.agentId),
+                workspaceId: filters.workspaceId,
+                userId: filters.userId,
+                projectId: filters.projectId,
+                ...hit.metadata,
+            },
+            revision: 1,
+            supersedes: [],
+            conflictsWith: [],
+        };
+    }
+    async rankRecallCandidates(binding, input) {
+        const structuredRecords = await listMemoryRecordsForScopes(this.runtimeMemoryStore, input.scopes);
+        const ranked = structuredRecords
+            .filter((record) => this.matchesRecallScope(record, input.filters))
+            .filter((record) => (input.includeStale ? record.status === "active" || record.status === "stale" : record.status === "active"))
+            .filter((record) => (input.kinds ? input.kinds.has(record.kind) : true))
+            .map((record) => ({
+            record,
+            score: this.scoreStructuredRecord(input.query, record),
+        }));
+        const deduped = new Map();
+        for (const item of ranked) {
+            deduped.set(this.normalizeMemoryDedupKey(item.record), item);
+        }
+        const vectorStore = await this.resolveRuntimeMemoryVectorStore();
+        if (vectorStore) {
+            try {
+                const vectorHits = await vectorStore.similaritySearch(input.query, Math.max(input.topK, this.runtimeMemoryPolicy?.retrieval.maxPromptMemories ?? input.topK));
+                for (const hit of vectorHits) {
+                    const metadata = typeof hit.metadata === "object" && hit.metadata && !Array.isArray(hit.metadata)
+                        ? hit.metadata
+                        : {};
+                    const recordId = typeof metadata.recordId === "string" ? metadata.recordId : undefined;
+                    const scope = metadata.scope;
+                    if (!recordId || (scope !== "thread" && scope !== "agent" && scope !== "workspace" && scope !== "user" && scope !== "project")) {
+                        continue;
+                    }
+                    const canonical = await getMemoryRecord(this.runtimeMemoryStore, scope, recordId);
+                    if (!canonical) {
+                        continue;
+                    }
+                    if (!this.matchesRecallScope(canonical, input.filters)) {
+                        continue;
+                    }
+                    if (input.includeStale ? canonical.status !== "active" && canonical.status !== "stale" : canonical.status !== "active") {
+                        continue;
+                    }
+                    if (input.kinds && !input.kinds.has(canonical.kind)) {
+                        continue;
+                    }
+                    const key = this.normalizeMemoryDedupKey(canonical);
+                    const score = this.scoreStructuredRecord(input.query, canonical) + (typeof hit.score === "number" ? hit.score : 0);
+                    const existing = deduped.get(key);
+                    if (!existing || score > existing.score) {
+                        deduped.set(key, { record: canonical, score });
+                    }
+                }
             }
-            if (record.scope === "thread") {
-                return String(record.provenance.threadId ?? "") === threadId;
+            catch {
+                // Fail open to lexical/runtime ranking.
             }
-            if (record.scope === "agent") {
-                return String(record.provenance.agentId ?? "") === binding.agent.id;
+        }
+        const supportsMem0Scope = input.scopes.some((scope) => scope === "thread" || scope === "agent" || scope === "workspace");
+        if (!this.mem0SemanticRecall || !supportsMem0Scope) {
+            return Array.from(deduped.values()).sort((left, right) => right.score - left.score);
+        }
+        try {
+            const hits = await this.mem0SemanticRecall.search({
+                query: input.query,
+                topK: Math.max(input.topK, this.runtimeMemoryPolicy?.retrieval.maxPromptMemories ?? input.topK),
+                agentId: input.filters.agentId,
+                threadId: input.filters.threadId,
+            });
+            for (const hit of hits) {
+                const record = this.createMem0MemoryRecord(hit, input.filters);
+                if (!input.scopes.includes(record.scope)) {
+                    continue;
+                }
+                if (input.kinds && !input.kinds.has(record.kind)) {
+                    continue;
+                }
+                const key = this.normalizeMemoryDedupKey(record);
+                if (deduped.has(key)) {
+                    continue;
+                }
+                deduped.set(key, {
+                    record,
+                    score: this.scoreStructuredRecord(input.query, record) + Math.max(0, Math.min(1, hit.score)) * 4,
+                });
             }
-            return true;
-        })
+            return Array.from(deduped.values()).sort((left, right) => right.score - left.score);
+        }
+        catch {
+            return Array.from(deduped.values()).sort((left, right) => right.score - left.score);
+        }
+    }
+    async rebuildRuntimeMemoryVectorIndex() {
+        const vectorStore = await this.resolveRuntimeMemoryVectorStore();
+        if (!vectorStore) {
+            return;
+        }
+        const records = (await listMemoryRecordsForScopes(this.runtimeMemoryStore, ["thread", "agent", "workspace", "user", "project"]))
+            .filter((record) => record.status === "active");
+        try {
+            await vectorStore.delete({ deleteAll: true });
+            if (records.length === 0) {
+                return;
+            }
+            await vectorStore.addDocuments(records.map((record) => ({
+                pageContent: `${record.summary}\n${record.content}`,
+                metadata: {
+                    recordId: record.id,
+                    scope: record.scope,
+                    kind: record.kind,
+                    status: record.status,
+                    threadId: record.provenance.threadId,
+                    agentId: record.provenance.agentId,
+                    workspaceId: record.provenance.workspaceId,
+                    userId: record.provenance.userId,
+                    projectId: record.provenance.projectId,
+                    confidence: record.confidence,
+                    lastConfirmedAt: record.lastConfirmedAt,
+                },
+            })));
+        }
+        catch {
+            // Fail open: vector indexing must not break durable memory writes.
+        }
+    }
+    async refreshStructuredMemoryScope(binding, record) {
+        const provenance = record.provenance;
+        const maxEntries = record.scope === "thread" ? 12 : 20;
+        const titleByScope = {
+            thread: "Thread Structured Memory",
+            agent: "Agent Structured Memory",
+            workspace: "Workspace Structured Memory",
+            user: "User Structured Memory",
+            project: "Project Structured Memory",
+        };
+        await consolidateStructuredMemoryScope({
+            store: this.runtimeMemoryStore,
+            namespace: this.resolveMemoryNamespace(record.scope, binding, {
+                threadId: provenance.threadId,
+                agentId: provenance.agentId,
+                userId: provenance.userId,
+                projectId: provenance.projectId,
+            }),
+            title: titleByScope[record.scope],
+            scope: record.scope,
+            maxEntries,
+            config: this.runtimeMemoryMaintenanceConfig ?? undefined,
+        });
+    }
+    async buildRuntimeMemoryContext(binding, threadId, input) {
+        const query = typeof input === "string" ? input : JSON.stringify(input ?? "");
+        const workspaceId = this.getWorkspaceId(binding);
+        const ranked = (await this.rankRecallCandidates(binding, {
+            query,
+            scopes: ["thread", "agent", "workspace", "user", "project"],
+            kinds: null,
+            topK: this.runtimeMemoryPolicy?.retrieval.maxPromptMemories ?? 8,
+            includeStale: false,
+            filters: {
+                threadId,
+                agentId: binding.agent.id,
+                workspaceId,
+                userId: "default",
+                projectId: workspaceId,
+            },
+        }))
             .map((record) => {
-            const scopeBoost = record.scope === "thread" ? 4 : record.scope === "agent" ? 2 : 1;
-            const freshnessBoost = Math.max(0, 1 - ((Date.now() - Date.parse(record.lastConfirmedAt)) / (1000 * 60 * 60 * 24 * 365)));
+            const scopeBoost = record.record.scope === "thread"
+                ? 4
+                : record.record.scope === "agent"
+                    ? 3
+                    : record.record.scope === "user"
+                        ? 2
+                        : 1;
             return {
                 content: [
-                    `# Durable ${record.scope[0].toUpperCase()}${record.scope.slice(1)} Memory`,
+                    `# Durable ${record.record.scope[0].toUpperCase()}${record.record.scope.slice(1)} Memory`,
                     "",
-                    `- summary: ${record.summary}`,
-                    `- kind: ${record.kind}`,
-                    `- scope: ${record.scope}`,
-                    `- confidence: ${record.confidence.toFixed(2)}`,
+                    `- summary: ${record.record.summary}`,
+                    `- kind: ${record.record.kind}`,
+                    `- scope: ${record.record.scope}`,
+                    `- confidence: ${record.record.confidence.toFixed(2)}`,
                     "",
-                    record.content,
+                    record.record.content,
                 ].join("\n"),
-                score: scoreMemoryText(query, `${record.summary}\n${record.content}`, scopeBoost) + freshnessBoost + record.confidence,
+                score: scoreMemoryText(query, `${record.record.summary}\n${record.record.content}`, scopeBoost) +
+                    this.memoryFreshnessBoost(record.record.lastConfirmedAt) +
+                    record.record.confidence,
             };
         })
             .sort((left, right) => right.score - left.score)
@@ -561,6 +944,9 @@ export class AgentHarnessRuntime {
         if (!Array.isArray(value) || value.length === 0) {
             return;
         }
+        if (this.runtimeMemoryFormationConfig?.hotPath.enabled === false) {
+            return;
+        }
         const candidates = value
             .filter((candidate) => typeof candidate === "object" && candidate !== null)
             .filter((candidate) => candidate.noStore !== true && typeof candidate.content === "string" && candidate.content.trim().length > 0);
@@ -580,20 +966,33 @@ export class AgentHarnessRuntime {
         const workspaceId = this.getWorkspaceId(binding);
         const userId = input.userId ?? "default";
         const projectId = input.projectId ?? workspaceId;
-        const threadCandidates = input.candidates.filter((candidate) => (candidate.scope ?? "thread") === "thread");
-        const workspaceCandidates = input.candidates.filter((candidate) => (candidate.scope ?? "thread") === "workspace");
-        const agentCandidates = input.candidates.filter((candidate) => (candidate.scope ?? "thread") === "agent");
+        const existingRecords = await listMemoryRecordsForScopes(this.runtimeMemoryStore, ["thread", "agent", "workspace", "user", "project"]);
+        const transformedCandidates = this.runtimeMemoryManager
+            ? await this.runtimeMemoryManager.transform({
+                candidates: input.candidates,
+                binding,
+                threadId: input.threadId,
+                runId: input.runId,
+                recordedAt: input.recordedAt,
+                existingRecords,
+            })
+            : input.candidates;
+        const threadCandidates = transformedCandidates.filter((candidate) => (candidate.scope ?? "thread") === "thread");
+        const workspaceCandidates = transformedCandidates.filter((candidate) => (candidate.scope ?? "thread") === "workspace");
+        const agentCandidates = transformedCandidates.filter((candidate) => (candidate.scope ?? "thread") === "agent");
+        const userCandidates = transformedCandidates.filter((candidate) => (candidate.scope ?? "thread") === "user");
+        const projectCandidates = transformedCandidates.filter((candidate) => (candidate.scope ?? "thread") === "project");
         if (input.storeCandidateLog) {
             await this.runtimeMemoryStore.put(["memories", "candidates", input.threadId], `${input.runId}.json`, {
                 runId: input.runId,
                 threadId: input.threadId,
                 storedAt: input.recordedAt,
-                candidates: input.candidates,
+                candidates: transformedCandidates,
             });
         }
         const persisted = await persistStructuredMemoryRecords({
             store: this.runtimeMemoryStore,
-            candidates: input.candidates,
+            candidates: transformedCandidates,
             threadId: input.threadId,
             runId: input.runId,
             agentId: input.agentId,
@@ -602,6 +1001,7 @@ export class AgentHarnessRuntime {
             projectId,
             recordedAt: input.recordedAt,
         });
+        await this.rebuildRuntimeMemoryVectorIndex();
         const writes = [];
         if (threadCandidates.length > 0) {
             writes.push(this.appendMemoryDigest(this.resolveMemoryNamespace("thread", binding, { threadId: input.threadId }), "tool-memory.md", threadCandidates, 12, "Thread Tool Memory"));
@@ -636,6 +1036,28 @@ export class AgentHarnessRuntime {
                 config: this.runtimeMemoryMaintenanceConfig ?? undefined,
             }));
         }
+        if (userCandidates.length > 0) {
+            writes.push(this.appendMemoryDigest(this.resolveMemoryNamespace("user", binding, { userId }), "tool-memory.md", userCandidates, 20, "User Tool Memory"));
+            writes.push(consolidateStructuredMemoryScope({
+                store: this.runtimeMemoryStore,
+                namespace: this.resolveMemoryNamespace("user", binding, { userId }),
+                title: "User Structured Memory",
+                scope: "user",
+                maxEntries: 20,
+                config: this.runtimeMemoryMaintenanceConfig ?? undefined,
+            }));
+        }
+        if (projectCandidates.length > 0) {
+            writes.push(this.appendMemoryDigest(this.resolveMemoryNamespace("project", binding, { projectId }), "tool-memory.md", projectCandidates, 20, "Project Tool Memory"));
+            writes.push(consolidateStructuredMemoryScope({
+                store: this.runtimeMemoryStore,
+                namespace: this.resolveMemoryNamespace("project", binding, { projectId }),
+                title: "Project Structured Memory",
+                scope: "project",
+                maxEntries: 20,
+                config: this.runtimeMemoryMaintenanceConfig ?? undefined,
+            }));
+        }
         await Promise.all(writes);
         return persisted;
     }
@@ -909,10 +1331,12 @@ export class AgentHarnessRuntime {
         this.unregisterThreadMemorySync();
         this.unregisterRuntimeMemorySync();
         this.unregisterMem0IngestionSync();
+        this.unregisterRuntimeMemoryFormationSync();
         await Promise.allSettled(Array.from(this.backgroundTasks));
         await this.threadMemorySync?.close();
         await this.runtimeMemorySync?.close();
         await this.mem0IngestionSync?.close();
+        await this.runtimeMemoryFormationSync?.close();
         await closeMcpClientsForWorkspace(this.workspace);
         this.initialized = false;
     }

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

@@ -3,7 +3,7 @@ import { MemorySaver } from "@langchain/langgraph";
 import { SqliteSaver } from "@langchain/langgraph-checkpoint-sqlite";
 import { FileCheckpointSaver } from "../maintenance/file-checkpoint-saver.js";
 import { ManagedSqliteSaver } from "../maintenance/sqlite-maintained-checkpoint-saver.js";
-import { createInMemoryStore, FileBackedStore } from "../harness/system/store.js";
+import { createInMemoryStore, FileBackedStore, SqliteBackedStore } from "../harness/system/store.js";
 export function createStoreForConfig(storeConfig, runRoot) {
     const kind = typeof storeConfig.kind === "string" ? storeConfig.kind : "FileStore";
     switch (kind) {
@@ -11,6 +11,10 @@ export function createStoreForConfig(storeConfig, runRoot) {
             const configuredPath = typeof storeConfig.path === "string" ? storeConfig.path : "store.json";
             return new FileBackedStore(path.isAbsolute(configuredPath) ? configuredPath : path.join(runRoot, configuredPath));
         }
+        case "SqliteStore": {
+            const configuredPath = typeof storeConfig.path === "string" ? storeConfig.path : "store.sqlite";
+            return new SqliteBackedStore(path.isAbsolute(configuredPath) ? configuredPath : path.join(runRoot, configuredPath));
+        }
         case "InMemoryStore":
             return createInMemoryStore();
         case "RedisStore":