@botbotgo/agent-harness 0.0.281 → 0.0.283

package/dist/knowledge/module.js

@@ -0,0 +1,594 @@
+import { createPersistentId } from "../utils/id.js";
+import { findMemoryRecordById, getMemoryRecord, listMemoryRecordsForScopes, persistStructuredMemoryRecords, removeMemoryRecord, updateMemoryRecord, } from "../runtime/harness/system/runtime-memory-records.js";
+import { consolidateStructuredMemoryScope } from "../runtime/harness/system/runtime-memory-consolidation.js";
+import { renderMemoryCandidatesMarkdown } from "../runtime/harness/system/runtime-memory-candidates.js";
+import { normalizeLangMemMemoryKind, scoreMemoryText, } from "../runtime/harness/system/runtime-memory-policy.js";
+const ALL_SCOPES = ["thread", "agent", "workspace", "user", "project"];
+const TITLE_BY_SCOPE = {
+    thread: "Thread Structured Memory",
+    agent: "Agent Structured Memory",
+    workspace: "Workspace Structured Memory",
+    user: "User Structured Memory",
+    project: "Project Structured Memory",
+};
+function normalizeRuntimeContext(context) {
+    if (typeof context.agentId !== "string" || context.agentId.trim().length === 0) {
+        throw new Error("knowledge operations require agentId in runtime context.");
+    }
+    return {
+        ...context,
+        agentId: context.agentId,
+        userId: context.userId ?? "default",
+        projectId: context.projectId ?? context.workspaceId,
+    };
+}
+function summarizeMemoryContent(content) {
+    return (content.trim().split("\n")[0] || content.trim()).slice(0, 240);
+}
+function resolveRecallScopes(input, context) {
+    if (Array.isArray(input.scopes) && input.scopes.length > 0) {
+        return Array.from(new Set(input.scopes));
+    }
+    const scopes = new Set(["thread", "agent", "workspace"]);
+    if (context.userId) {
+        scopes.add("user");
+    }
+    if (context.projectId) {
+        scopes.add("project");
+    }
+    return Array.from(scopes);
+}
+function matchesMemoryFilters(record, filters) {
+    const sessionId = String(record.provenance.sessionId ?? record.provenance.threadId ?? "");
+    if (filters.threadId && sessionId !== 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;
+}
+function matchesRecallScope(record, filters) {
+    if (record.scope === "thread") {
+        return typeof filters.threadId === "string"
+            && String(record.provenance.sessionId ?? 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;
+}
+function getMemoryScopeBoost(scope) {
+    if (scope === "thread") {
+        return 4;
+    }
+    if (scope === "agent") {
+        return 2;
+    }
+    if (scope === "workspace") {
+        return 1;
+    }
+    return 0;
+}
+function memoryFreshnessBoost(value) {
+    return Math.max(0, 1 - ((Date.now() - Date.parse(value)) / (1000 * 60 * 60 * 24 * 365)));
+}
+function scoreStructuredRecord(query, record) {
+    return (scoreMemoryText(query, `${record.summary}\n${record.content}`, getMemoryScopeBoost(record.scope)) +
+        memoryFreshnessBoost(record.lastConfirmedAt) +
+        record.confidence);
+}
+function normalizeMemoryDedupKey(record) {
+    return `${record.scope}::${record.summary.toLowerCase().replace(/\s+/g, " ").trim()}::${record.content.toLowerCase().replace(/\s+/g, " ").trim()}`;
+}
+function 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";
+}
+function 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";
+}
+function createMem0MemoryRecord(hit, filters) {
+    const scope = inferMem0MemoryScope(hit, filters);
+    const kind = 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",
+            sessionId: typeof hit.metadata.sessionId === "string"
+                ? hit.metadata.sessionId
+                : typeof hit.metadata.threadId === "string"
+                    ? hit.metadata.threadId
+                    : filters.threadId,
+            requestId: (typeof hit.metadata.requestId === "string"
+                ? hit.metadata.requestId
+                : 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: [],
+    };
+}
+export class DefaultKnowledgeModule {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async memorize(input, context) {
+        if (!Array.isArray(input.records)) {
+            throw new Error("memorize requires input.records to be an array.");
+        }
+        const normalizedContext = normalizeRuntimeContext(context);
+        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") && !normalizedContext.sessionId) {
+            throw new Error("memorize requires sessionId when storing thread-scoped memory.");
+        }
+        const recordedAt = normalizedContext.recordedAt ?? new Date().toISOString();
+        const requestId = normalizedContext.requestId ?? createPersistentId(new Date(recordedAt));
+        const sessionId = normalizedContext.sessionId ?? `memory-api-${requestId}`;
+        return this.memorizeCandidates(candidates.map((record) => ({ ...record, content: record.content.trim() })), {
+            ...normalizedContext,
+            requestId,
+            sessionId,
+            recordedAt,
+        }, { storeCandidateLog: input.storeCandidateLog !== false });
+    }
+    async recall(input, context) {
+        if (typeof input.query !== "string" || input.query.trim().length === 0) {
+            throw new Error("recall requires a non-empty query.");
+        }
+        const normalizedContext = normalizeRuntimeContext(context);
+        const scopes = resolveRecallScopes(input, normalizedContext);
+        const topK = typeof input.topK === "number" && Number.isInteger(input.topK) && input.topK > 0
+            ? input.topK
+            : (this.deps.policy?.retrieval.defaultTopK ?? 5);
+        const kinds = input.kinds?.length ? new Set(input.kinds) : null;
+        const items = (await this.rankRecallCandidates({
+            query: input.query.trim(),
+            scopes,
+            kinds,
+            topK,
+            includeStale: input.includeStale === true,
+            context: normalizedContext,
+        }))
+            .slice(0, topK)
+            .map(({ record }) => record);
+        return { items };
+    }
+    async buildPromptContext(input, context) {
+        const normalizedContext = normalizeRuntimeContext(context);
+        const ranked = (await this.rankRecallCandidates({
+            query: input.query,
+            scopes: input.scopes ?? ALL_SCOPES,
+            kinds: input.kinds?.length ? new Set(input.kinds) : null,
+            topK: input.topK ?? this.deps.policy?.retrieval.maxPromptMemories ?? 8,
+            includeStale: input.includeStale === true,
+            context: normalizedContext,
+        }))
+            .map((item) => {
+            const scopeBoost = item.record.scope === "thread"
+                ? 4
+                : item.record.scope === "agent"
+                    ? 3
+                    : item.record.scope === "user"
+                        ? 2
+                        : 1;
+            return {
+                content: [
+                    `# Durable ${item.record.scope[0].toUpperCase()}${item.record.scope.slice(1)} Memory`,
+                    "",
+                    `- summary: ${item.record.summary}`,
+                    `- kind: ${item.record.kind}`,
+                    `- scope: ${item.record.scope}`,
+                    `- confidence: ${item.record.confidence.toFixed(2)}`,
+                    "",
+                    item.record.content,
+                ].join("\n"),
+                score: scoreMemoryText(input.query, `${item.record.summary}\n${item.record.content}`, scopeBoost) +
+                    memoryFreshnessBoost(item.record.lastConfirmedAt) +
+                    item.record.confidence,
+            };
+        })
+            .sort((left, right) => right.score - left.score)
+            .slice(0, this.deps.policy?.retrieval.maxPromptMemories ?? 8);
+        if (ranked.length === 0) {
+            return undefined;
+        }
+        return ranked.map((entry) => entry.content).join("\n\n");
+    }
+    async list(input = {}, context) {
+        const normalizedContext = { ...context };
+        const scopes = Array.isArray(input.scopes) && input.scopes.length > 0
+            ? Array.from(new Set(input.scopes))
+            : ALL_SCOPES;
+        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.deps.store, scopes))
+            .filter((record) => statuses.has(record.status))
+            .filter((record) => !kinds || kinds.has(record.kind))
+            .filter((record) => matchesMemoryFilters(record, {
+            threadId: normalizedContext.sessionId,
+            agentId: normalizedContext.agentId,
+            workspaceId: normalizedContext.workspaceId,
+            userId: normalizedContext.userId,
+            projectId: normalizedContext.projectId,
+        }))
+            .sort((left, right) => right.lastConfirmedAt.localeCompare(left.lastConfirmedAt))
+            .slice(0, limit);
+        return { items };
+    }
+    async update(input, context) {
+        if (typeof input.memoryId !== "string" || input.memoryId.trim().length === 0) {
+            throw new Error("updateMemory requires a non-empty memoryId.");
+        }
+        const existing = await findMemoryRecordById(this.deps.store, 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() || summarizeMemoryContent(nextContent)
+                : (typeof input.content === "string" ? 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.deps.store, next, updatedAt);
+        await this.rebuildVectorIndex();
+        await this.refreshStructuredMemoryScope(next, context);
+        return next;
+    }
+    async remove(input, context) {
+        if (typeof input.memoryId !== "string" || input.memoryId.trim().length === 0) {
+            throw new Error("removeMemory requires a non-empty memoryId.");
+        }
+        const existing = await findMemoryRecordById(this.deps.store, input.memoryId.trim());
+        if (!existing) {
+            throw new Error(`Memory record not found: ${input.memoryId}`);
+        }
+        await removeMemoryRecord(this.deps.store, existing.scope, existing.id);
+        await this.rebuildVectorIndex();
+        await this.refreshStructuredMemoryScope(existing, context);
+        return existing;
+    }
+    async memorizeCandidates(candidates, context, options) {
+        const normalizedContext = normalizeRuntimeContext(context);
+        const validCandidates = candidates
+            .filter((candidate) => candidate.noStore !== true)
+            .filter((candidate) => typeof candidate.content === "string" && candidate.content.trim().length > 0)
+            .map((candidate) => ({ ...candidate, content: candidate.content.trim() }));
+        if (validCandidates.length === 0) {
+            return { records: [], decisions: [] };
+        }
+        const existingRecords = await listMemoryRecordsForScopes(this.deps.store, ALL_SCOPES);
+        const transformedCandidates = this.deps.transformCandidates
+            ? await this.deps.transformCandidates({ candidates: validCandidates, context: normalizedContext, existingRecords })
+            : validCandidates;
+        if (options.storeCandidateLog) {
+            await this.deps.store.put(["memories", "candidates", normalizedContext.sessionId ?? `memory-api-${normalizedContext.requestId ?? "unknown"}`], `${normalizedContext.requestId}.json`, {
+                runId: normalizedContext.requestId,
+                threadId: normalizedContext.sessionId,
+                storedAt: normalizedContext.recordedAt,
+                candidates: transformedCandidates,
+            });
+        }
+        const persisted = await persistStructuredMemoryRecords({
+            store: this.deps.store,
+            candidates: transformedCandidates,
+            threadId: normalizedContext.sessionId ?? `memory-api-${normalizedContext.requestId ?? "unknown"}`,
+            runId: normalizedContext.requestId ?? createPersistentId(new Date(normalizedContext.recordedAt ?? new Date().toISOString())),
+            agentId: normalizedContext.agentId,
+            workspaceId: normalizedContext.workspaceId,
+            userId: normalizedContext.userId ?? "default",
+            projectId: normalizedContext.projectId ?? normalizedContext.workspaceId,
+            recordedAt: normalizedContext.recordedAt ?? new Date().toISOString(),
+        });
+        await this.rebuildVectorIndex();
+        await this.refreshAfterWrite(transformedCandidates, normalizedContext);
+        return persisted;
+    }
+    async refreshAfterWrite(candidates, context) {
+        const buckets = {
+            thread: candidates.filter((candidate) => (candidate.scope ?? "thread") === "thread"),
+            agent: candidates.filter((candidate) => (candidate.scope ?? "thread") === "agent"),
+            workspace: candidates.filter((candidate) => (candidate.scope ?? "thread") === "workspace"),
+            user: candidates.filter((candidate) => (candidate.scope ?? "thread") === "user"),
+            project: candidates.filter((candidate) => (candidate.scope ?? "thread") === "project"),
+        };
+        const writes = [];
+        for (const scope of ALL_SCOPES) {
+            if (buckets[scope].length === 0) {
+                continue;
+            }
+            const maxEntries = scope === "thread" ? 12 : 20;
+            writes.push(this.appendMemoryDigest(this.deps.resolveNamespace(scope, context), "tool-memory.md", buckets[scope], maxEntries, TITLE_BY_SCOPE[scope].replace("Structured", "Tool")));
+            writes.push(consolidateStructuredMemoryScope({
+                store: this.deps.store,
+                namespace: this.deps.resolveNamespace(scope, context),
+                title: TITLE_BY_SCOPE[scope],
+                scope,
+                maxEntries,
+                config: this.deps.maintenanceConfig ?? undefined,
+            }));
+        }
+        await Promise.all(writes);
+    }
+    async appendMemoryDigest(namespace, key, candidates, maxEntries, title) {
+        const existing = await this.deps.store.get(namespace, key);
+        const existingItems = Array.isArray(existing?.value?.items)
+            ? ((existing?.value).items ?? [])
+            : [];
+        const merged = [...existingItems];
+        for (const candidate of candidates) {
+            if (merged.some((entry) => entry.content === candidate.content && (entry.scope ?? "thread") === (candidate.scope ?? "thread"))) {
+                continue;
+            }
+            merged.push(candidate);
+        }
+        const recent = merged.slice(-maxEntries);
+        const taxonomyGroups = new Map();
+        for (const candidate of recent) {
+            const kind = normalizeLangMemMemoryKind(candidate.kind);
+            const current = taxonomyGroups.get(kind) ?? [];
+            current.push({ ...candidate, kind });
+            taxonomyGroups.set(kind, current);
+        }
+        await this.deps.store.put(namespace, key, {
+            content: `${renderMemoryCandidatesMarkdown(title, recent)}\n`,
+            items: recent,
+        });
+        await Promise.all(Array.from(taxonomyGroups.entries()).map(async ([kind, items]) => {
+            await this.deps.store.put(namespace, `${kind}.md`, {
+                content: `${renderMemoryCandidatesMarkdown(`${title} (${kind})`, items)}\n`,
+                items,
+            });
+        }));
+    }
+    async refreshStructuredMemoryScope(record, context) {
+        const provenance = record.provenance;
+        const namespaceContext = {
+            sessionId: provenance.sessionId,
+            agentId: provenance.agentId ?? context.agentId,
+            workspaceId: provenance.workspaceId ?? context.workspaceId,
+            userId: provenance.userId ?? context.userId,
+            projectId: provenance.projectId ?? context.projectId,
+        };
+        const maxEntries = record.scope === "thread" ? 12 : 20;
+        await consolidateStructuredMemoryScope({
+            store: this.deps.store,
+            namespace: this.deps.resolveNamespace(record.scope, normalizeRuntimeContext(namespaceContext)),
+            title: TITLE_BY_SCOPE[record.scope],
+            scope: record.scope,
+            maxEntries,
+            config: this.deps.maintenanceConfig ?? undefined,
+        });
+    }
+    async rebuildVectorIndex() {
+        const vectorStore = await this.deps.resolveVectorStore();
+        if (!vectorStore) {
+            return;
+        }
+        const records = (await listMemoryRecordsForScopes(this.deps.store, ALL_SCOPES))
+            .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,
+                    sessionId: record.provenance.sessionId ?? 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 rankRecallCandidates(input) {
+        const structuredRecords = await listMemoryRecordsForScopes(this.deps.store, input.scopes);
+        const ranked = structuredRecords
+            .filter((record) => matchesRecallScope(record, {
+            threadId: input.context.sessionId,
+            agentId: input.context.agentId,
+            workspaceId: input.context.workspaceId,
+            userId: input.context.userId ?? "default",
+            projectId: input.context.projectId ?? input.context.workspaceId,
+        }))
+            .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: scoreStructuredRecord(input.query, record),
+        }));
+        const deduped = new Map();
+        for (const item of ranked) {
+            deduped.set(normalizeMemoryDedupKey(item.record), item);
+        }
+        const vectorStore = await this.deps.resolveVectorStore();
+        if (vectorStore) {
+            try {
+                const vectorHits = await vectorStore.similaritySearch(input.query, Math.max(input.topK, this.deps.policy?.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.deps.store, scope, recordId);
+                    if (!canonical) {
+                        continue;
+                    }
+                    if (!matchesRecallScope(canonical, {
+                        threadId: input.context.sessionId,
+                        agentId: input.context.agentId,
+                        workspaceId: input.context.workspaceId,
+                        userId: input.context.userId ?? "default",
+                        projectId: input.context.projectId ?? input.context.workspaceId,
+                    })) {
+                        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 = normalizeMemoryDedupKey(canonical);
+                    const score = 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 });
+                    }
+                }
+            }
+            catch {
+                // Fail open to lexical/runtime ranking.
+            }
+        }
+        const supportsMem0Scope = input.scopes.some((scope) => scope === "thread" || scope === "agent" || scope === "workspace");
+        const mem0SemanticRecall = this.deps.getMem0SemanticRecall?.() ?? null;
+        if (!mem0SemanticRecall || !supportsMem0Scope) {
+            return Array.from(deduped.values()).sort((left, right) => right.score - left.score);
+        }
+        try {
+            const hits = await mem0SemanticRecall.search({
+                query: input.query,
+                topK: Math.max(input.topK, this.deps.policy?.retrieval.maxPromptMemories ?? input.topK),
+                agentId: input.context.agentId,
+                threadId: input.context.sessionId,
+            });
+            for (const hit of hits) {
+                const record = createMem0MemoryRecord(hit, {
+                    threadId: input.context.sessionId,
+                    agentId: input.context.agentId,
+                    workspaceId: input.context.workspaceId,
+                    userId: input.context.userId ?? "default",
+                    projectId: input.context.projectId ?? input.context.workspaceId,
+                });
+                if (!input.scopes.includes(record.scope)) {
+                    continue;
+                }
+                if (input.kinds && !input.kinds.has(record.kind)) {
+                    continue;
+                }
+                const key = normalizeMemoryDedupKey(record);
+                if (deduped.has(key)) {
+                    continue;
+                }
+                deduped.set(key, {
+                    record,
+                    score: 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);
+        }
+    }
+}
+export function createKnowledgeModule(dependencies) {
+    return new DefaultKnowledgeModule(dependencies);
+}

package/dist/package-version.d.ts

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

package/dist/package-version.js

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

package/dist/persistence/file-store.d.ts

@@ -10,6 +10,7 @@ type RunIndexRecord = {
 export declare class FilePersistence implements RuntimePersistence {
     private readonly runRoot;
     constructor(runRoot: string);
+    private artifactsRoot;
     private threadIndexPath;
     private runIndexPath;
     private approvalIndexPath;