@botbotgo/agent-harness 0.0.153 → 0.0.155

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 { getMemoryRecord, listMemoryRecordsForScopes, persistStructuredMemoryRecords, } 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);
@@ -243,6 +292,75 @@ export class AgentHarnessRuntime {
     async listRuns(filter) {
         return this.persistence.listRuns(filter);
     }
+    async memorize(input) {
+        const binding = this.defaultRuntimeEntryBinding;
+        if (!binding) {
+            throw new Error("memorize requires a runtime entry binding.");
+        }
+        if (!Array.isArray(input.records)) {
+            throw new Error("memorize requires input.records to be an array.");
+        }
+        const candidates = input.records
+            .filter((record) => typeof record === "object" && record !== null)
+            .filter((record) => record.noStore !== true);
+        if (candidates.length === 0) {
+            return { records: [], decisions: [] };
+        }
+        if (candidates.some((record) => typeof record.content !== "string" || record.content.trim().length === 0)) {
+            throw new Error("memorize requires every record to include non-empty content.");
+        }
+        if (candidates.some((record) => (record.scope ?? "thread") === "thread") && !input.threadId) {
+            throw new Error("memorize requires threadId when storing thread-scoped memory.");
+        }
+        const recordedAt = input.recordedAt ?? new Date().toISOString();
+        const runId = input.runId ?? createPersistentId(new Date(recordedAt));
+        const threadId = input.threadId ?? `memory-api-${runId}`;
+        return this.persistStructuredMemoryCandidates(binding, {
+            candidates: candidates.map((record) => ({ ...record, content: record.content.trim() })),
+            threadId,
+            runId,
+            agentId: input.agentId ?? binding.agent.id,
+            userId: input.userId,
+            projectId: input.projectId,
+            recordedAt,
+            storeCandidateLog: true,
+        });
+    }
+    async recall(input) {
+        const binding = this.defaultRuntimeEntryBinding;
+        if (!binding) {
+            throw new Error("recall requires a runtime entry binding.");
+        }
+        if (typeof input.query !== "string" || input.query.trim().length === 0) {
+            throw new Error("recall requires a non-empty query.");
+        }
+        const workspaceId = this.getWorkspaceId(binding);
+        const agentId = input.agentId ?? binding.agent.id;
+        const userId = input.userId ?? "default";
+        const projectId = input.projectId ?? workspaceId;
+        const scopes = this.resolveRecallScopes(input);
+        const topK = typeof input.topK === "number" && Number.isInteger(input.topK) && input.topK > 0
+            ? 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 getRun(runId) {
         return this.persistence.getRun(runId);
     }
@@ -392,8 +510,7 @@ export class AgentHarnessRuntime {
         }
     }
     resolveMemoryNamespace(scope, binding, options = {}) {
-        const workspaceRoot = binding.harnessRuntime.workspaceRoot ?? this.workspace.workspaceRoot;
-        const workspaceId = path.basename(workspaceRoot) || "default";
+        const workspaceId = this.getWorkspaceId(binding);
         const template = this.runtimeMemoryPolicy?.namespaces[scope] ?? `memories/${scope}s/{${scope}Id}`;
         return resolveMemoryNamespace(template, {
             threadId: options.threadId,
@@ -403,36 +520,280 @@ export class AgentHarnessRuntime {
             projectId: options.projectId ?? workspaceId,
         });
     }
-    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;
+    getWorkspaceId(binding) {
+        const workspaceRoot = binding.harnessRuntime.workspaceRoot ?? this.workspace.workspaceRoot;
+        return path.basename(workspaceRoot) || "default";
+    }
+    resolveRecallScopes(input) {
+        if (Array.isArray(input.scopes) && input.scopes.length > 0) {
+            return Array.from(new Set(input.scopes));
+        }
+        const scopes = new Set(["thread", "agent", "workspace"]);
+        if (input.userId) {
+            scopes.add("user");
+        }
+        if (input.projectId) {
+            scopes.add("project");
+        }
+        return Array.from(scopes);
+    }
+    matchesRecallScope(record, filters) {
+        if (record.scope === "thread") {
+            return typeof filters.threadId === "string" && String(record.provenance.threadId ?? "") === filters.threadId;
+        }
+        if (record.scope === "agent") {
+            return String(record.provenance.agentId ?? "") === filters.agentId;
+        }
+        if (record.scope === "workspace") {
+            return String(record.provenance.workspaceId ?? filters.workspaceId) === filters.workspaceId;
+        }
+        if (record.scope === "user") {
+            return String(record.provenance.userId ?? "default") === filters.userId;
+        }
+        return String(record.provenance.projectId ?? filters.workspaceId) === filters.projectId;
+    }
+    getMemoryScopeBoost(scope) {
+        if (scope === "thread") {
+            return 4;
+        }
+        if (scope === "agent") {
+            return 2;
+        }
+        if (scope === "workspace") {
+            return 1;
+        }
+        return 0;
+    }
+    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;
             }
-            if (record.scope === "thread") {
-                return String(record.provenance.threadId ?? "") === threadId;
+        }
+        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 === "agent") {
-                return String(record.provenance.agentId ?? "") === binding.agent.id;
+            catch {
+                // Fail open to lexical/runtime ranking.
             }
-            return true;
-        })
+        }
+        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 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 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)
@@ -446,36 +807,70 @@ 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);
         if (candidates.length === 0) {
             return;
         }
-        const threadCandidates = candidates.filter((candidate) => (candidate.scope ?? "thread") === "thread");
-        const workspaceCandidates = candidates.filter((candidate) => (candidate.scope ?? "thread") === "workspace");
-        const agentCandidates = candidates.filter((candidate) => (candidate.scope ?? "thread") === "agent");
-        const recordedAt = new Date().toISOString();
-        await this.runtimeMemoryStore.put(["memories", "candidates", threadId], `${runId}.json`, {
-            runId,
-            threadId,
-            storedAt: recordedAt,
-            candidates,
-        });
-        await persistStructuredMemoryRecords({
-            store: this.runtimeMemoryStore,
+        await this.persistStructuredMemoryCandidates(binding, {
             candidates,
             threadId,
             runId,
             agentId: binding.agent.id,
-            recordedAt,
+            recordedAt: new Date().toISOString(),
+            storeCandidateLog: true,
+        });
+    }
+    async persistStructuredMemoryCandidates(binding, input) {
+        const workspaceId = this.getWorkspaceId(binding);
+        const userId = input.userId ?? "default";
+        const projectId = input.projectId ?? workspaceId;
+        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: transformedCandidates,
+            });
+        }
+        const persisted = await persistStructuredMemoryRecords({
+            store: this.runtimeMemoryStore,
+            candidates: transformedCandidates,
+            threadId: input.threadId,
+            runId: input.runId,
+            agentId: input.agentId,
+            workspaceId,
+            userId,
+            projectId,
+            recordedAt: input.recordedAt,
         });
+        await this.rebuildRuntimeMemoryVectorIndex();
         const writes = [];
         if (threadCandidates.length > 0) {
-            writes.push(this.appendMemoryDigest(this.resolveMemoryNamespace("thread", binding, { threadId }), "tool-memory.md", threadCandidates, 12, "Thread Tool Memory"));
+            writes.push(this.appendMemoryDigest(this.resolveMemoryNamespace("thread", binding, { threadId: input.threadId }), "tool-memory.md", threadCandidates, 12, "Thread Tool Memory"));
             writes.push(consolidateStructuredMemoryScope({
                 store: this.runtimeMemoryStore,
-                namespace: this.resolveMemoryNamespace("thread", binding, { threadId }),
+                namespace: this.resolveMemoryNamespace("thread", binding, { threadId: input.threadId }),
                 title: "Thread Structured Memory",
                 scope: "thread",
                 maxEntries: 12,
@@ -504,7 +899,30 @@ 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;
     }
     async appendMemoryDigest(namespace, key, candidates, maxEntries, title) {
         const existing = await this.runtimeMemoryStore.get(namespace, key);
@@ -776,10 +1194,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":