@botbotgo/agent-harness 0.0.142 → 0.0.145

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

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

package/dist/contracts/runtime.d.ts

@@ -97,6 +97,20 @@ export type RuntimeSnapshot = {
     skills: RuntimeSnapshotSkill[];
     memory: string[];
 };
+export type MemoryCandidate = {
+    content: string;
+    summary?: string;
+    kind?: string;
+    scope?: string;
+    confidence?: number;
+    tags?: string[];
+    sourceType?: string;
+    sourceRef?: string;
+    observedAt?: string;
+    sensitivity?: string;
+    noStore?: boolean;
+    provenance?: Record<string, unknown>;
+};
 /**
  * Operator-facing projection of tool execution policy already compiled into a binding.
  * This summarizes existing timeout, retry, validation, and retry-safety hints without

package/dist/init-project.js

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

package/dist/package-version.d.ts

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

package/dist/package-version.js

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

package/dist/runtime/adapter/flow/invocation-flow.d.ts

@@ -12,6 +12,7 @@ export declare function executeRuntimeInvocation(options: {
         context?: Record<string, unknown>;
         state?: Record<string, unknown>;
         files?: Record<string, unknown>;
+        memoryContext?: string;
     };
     resolveTools: (tools: CompiledTool[], binding?: CompiledAgentBinding) => unknown[];
     getToolNameMapping: (binding: CompiledAgentBinding) => ToolNameMapping;
@@ -19,6 +20,7 @@ export declare function executeRuntimeInvocation(options: {
         context?: Record<string, unknown>;
         state?: Record<string, unknown>;
         files?: Record<string, unknown>;
+        memoryContext?: string;
     }) => Promise<Map<string, ExecutableTool>>;
     callRuntimeWithToolParseRecovery: (request: unknown) => Promise<Record<string, unknown>>;
 }): Promise<RunResult>;

package/dist/runtime/adapter/flow/stream-runtime.d.ts

@@ -15,6 +15,7 @@ export declare function streamRuntimeExecution(options: {
         state?: Record<string, unknown>;
         files?: Record<string, unknown>;
         runId?: string;
+        memoryContext?: string;
     };
     primaryTools: CompiledTool[];
     toolNameMapping: ToolNameMapping;
@@ -33,6 +34,7 @@ export declare function streamRuntimeExecution(options: {
         context?: Record<string, unknown>;
         state?: Record<string, unknown>;
         files?: Record<string, unknown>;
+        memoryContext?: string;
     }) => Promise<{
         output: string;
         metadata?: Record<string, unknown>;

package/dist/runtime/adapter/flow/stream-runtime.js

@@ -8,7 +8,7 @@ export async function* streamRuntimeExecution(options) {
     const request = buildInvocationRequest(options.binding, options.history, options.input, options.runtimeOptions);
     try {
         if (options.isLangChainBinding(options.binding) && options.canUseDirectModelStream && options.langChainStreamModel?.stream) {
-            const stream = await options.withTimeout(() => options.langChainStreamModel.stream(buildRawModelMessages(options.binding, options.getSystemPrompt(options.binding), options.history, options.input)), computeRemainingTimeoutMs(options.streamDeadlineAt, options.invokeTimeoutMs), "model stream start", "stream");
+            const stream = await options.withTimeout(() => options.langChainStreamModel.stream(buildRawModelMessages(options.binding, options.getSystemPrompt(options.binding), options.history, options.input, options.runtimeOptions.memoryContext)), computeRemainingTimeoutMs(options.streamDeadlineAt, options.invokeTimeoutMs), "model stream start", "stream");
             let emitted = false;
             const projected = projectTextStreamChunks(options.iterateWithTimeout(stream, options.streamIdleTimeoutMs, "model stream", options.streamDeadlineAt, options.invokeTimeoutMs));
             let nextChunk = await projected.next();

package/dist/runtime/adapter/invocation-result.d.ts

@@ -1,8 +1,9 @@
-import type { RunResult } from "../../contracts/types.js";
+import type { MemoryCandidate, RunResult } from "../../contracts/types.js";
 export type ExecutedToolResult = {
     toolName: string;
     output: unknown;
     isError?: boolean;
+    memoryCandidates?: MemoryCandidate[];
 };
 export declare function finalizeInvocationResult(params: {
     bindingAgentId: string;

package/dist/runtime/adapter/invocation-result.js

@@ -18,6 +18,7 @@ export function finalizeInvocationResult(params) {
     const structuredResponse = result.structuredResponse;
     const files = asRecord(result.files);
     const stateSnapshot = buildStateSnapshot(result);
+    const memoryCandidates = executedToolResults.flatMap((toolResult) => toolResult.memoryCandidates ?? []);
     return {
         threadId,
         runId,
@@ -31,6 +32,7 @@ export function finalizeInvocationResult(params) {
         ...(structuredResponse !== undefined ? { structuredResponse } : {}),
         metadata: {
             ...(executedToolResults.length > 0 ? { executedToolResults } : {}),
+            ...(memoryCandidates.length > 0 ? { memoryCandidates } : {}),
             ...(structuredResponse !== undefined ? { structuredResponse } : {}),
             ...(outputContent !== undefined ? { outputContent } : {}),
             ...(contentBlocks.length > 0 ? { contentBlocks } : {}),

package/dist/runtime/adapter/local-tool-invocation.js

@@ -2,6 +2,7 @@ import { ToolMessage } from "@langchain/core/messages";
 import { createModelFacingToolNameLookupCandidates, resolveModelFacingToolName } from "./tool/tool-name-mapping.js";
 import { canReplayToolCallsLocally } from "./tool/tool-replay.js";
 import { extractToolCallsFromResult, normalizeToolArgsForSchema, stringifyToolOutput } from "./tool/tool-arguments.js";
+import { extractMemoryCandidatesFromToolOutput } from "../harness/system/runtime-memory-candidates.js";
 export async function runLocalToolInvocationLoop({ binding, request, primaryTools, toolNameMapping, executableTools, builtinExecutableTools, callRuntimeWithToolParseRecovery, }) {
     const executedToolResults = [];
     let activeRequest = request;
@@ -9,6 +10,14 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
     const maxToolIterations = 8;
     let pendingResult;
     let result;
+    const toolCatalog = new Map();
+    for (const tool of primaryTools) {
+        toolCatalog.set(tool.name, tool);
+        const modelFacingName = toolNameMapping.originalToModelFacing.get(tool.name);
+        if (modelFacingName) {
+            toolCatalog.set(modelFacingName, tool);
+        }
+    }
     for (let iteration = 0; iteration < maxToolIterations; iteration += 1) {
         result = pendingResult ?? await callRuntimeWithToolParseRecovery(activeRequest);
         pendingResult = undefined;
@@ -39,11 +48,14 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
             if (!activeExecutable) {
                 throw new Error(`Tool ${toolCall.name} is not configured for this agent.`);
             }
+            const compiledTool = toolCatalog.get(toolCall.name) ?? toolCatalog.get(resolvedToolName);
             const normalizedArgs = normalizeToolArgsForSchema(toolCall.args, activeExecutable.schema);
             const toolResult = await activeExecutable.invoke(normalizedArgs);
+            const memoryCandidates = compiledTool ? extractMemoryCandidatesFromToolOutput(compiledTool, toolResult) : [];
             executedToolResults.push({
                 toolName: activeExecutable.name,
                 output: toolResult,
+                ...(memoryCandidates.length > 0 ? { memoryCandidates } : {}),
             });
             nextMessages.push(new ToolMessage({
                 name: activeExecutable.name,

package/dist/runtime/adapter/model/invocation-request.d.ts

@@ -7,4 +7,5 @@ export declare function buildSlashCommandSkillInstruction(binding: CompiledAgent
 export declare function buildInvocationRequest(binding: CompiledAgentBinding, history: TranscriptMessage[], input: MessageContent, options?: {
     state?: Record<string, unknown>;
     files?: Record<string, unknown>;
+    memoryContext?: string;
 }): Record<string, unknown>;

package/dist/runtime/adapter/model/invocation-request.js

@@ -37,11 +37,21 @@ export function buildSlashCommandSkillInstruction(binding, input) {
 export function buildInvocationRequest(binding, history, input, options = {}) {
     const userInvocableInstruction = buildSlashCommandSkillInstruction(binding, input);
     const messages = buildAgentMessages(history, input);
+    const memoryInstruction = typeof options.memoryContext === "string" && options.memoryContext.trim().length > 0
+        ? [
+            "Relevant durable memory was retrieved for this run.",
+            "Use it when it is still applicable, but prefer fresher direct evidence if there is any conflict.",
+            "",
+            options.memoryContext.trim(),
+        ].join("\n")
+        : undefined;
     return {
         ...(options.state ?? {}),
         ...(options.files ? { files: options.files } : {}),
-        messages: userInvocableInstruction
-            ? [{ role: "system", content: userInvocableInstruction }, ...messages]
-            : messages,
+        messages: [
+            ...(memoryInstruction ? [{ role: "system", content: memoryInstruction }] : []),
+            ...(userInvocableInstruction ? [{ role: "system", content: userInvocableInstruction }] : []),
+            ...messages,
+        ],
     };
 }

package/dist/runtime/adapter/model/message-assembly.d.ts

@@ -1,6 +1,6 @@
 import type { CompiledAgentBinding, MessageContent, TranscriptMessage } from "../../../contracts/types.js";
 export declare function buildStateSnapshot(result: Record<string, unknown>): Record<string, unknown> | undefined;
-export declare function buildRawModelMessages(binding: CompiledAgentBinding, systemPrompt: string | undefined, history: TranscriptMessage[], input: MessageContent): Array<{
+export declare function buildRawModelMessages(binding: CompiledAgentBinding, systemPrompt: string | undefined, history: TranscriptMessage[], input: MessageContent, memoryContext?: string): Array<{
     role: string;
     content: MessageContent;
 }>;

package/dist/runtime/adapter/model/message-assembly.js

@@ -7,11 +7,22 @@ export function buildStateSnapshot(result) {
     delete snapshot.files;
     return Object.keys(snapshot).length > 0 ? snapshot : undefined;
 }
-export function buildRawModelMessages(binding, systemPrompt, history, input) {
+export function buildRawModelMessages(binding, systemPrompt, history, input, memoryContext) {
     const messages = [];
     if (systemPrompt) {
         messages.push({ role: "system", content: systemPrompt });
     }
+    if (memoryContext?.trim()) {
+        messages.push({
+            role: "system",
+            content: [
+                "Relevant durable memory was retrieved for this run.",
+                "Use it when it still applies, but prefer fresher direct evidence if there is any conflict.",
+                "",
+                memoryContext.trim(),
+            ].join("\n"),
+        });
+    }
     const userInvocableInstruction = buildSlashCommandSkillInstruction(binding, input);
     if (userInvocableInstruction) {
         messages.push({ role: "system", content: userInvocableInstruction });

package/dist/runtime/agent-runtime-adapter.d.ts

@@ -80,12 +80,14 @@ export declare class AgentRuntimeAdapter {
         context?: Record<string, unknown>;
         state?: Record<string, unknown>;
         files?: Record<string, unknown>;
+        memoryContext?: string;
     }): Promise<RunResult>;
     stream(binding: CompiledAgentBinding, input: MessageContent, threadId: string, history?: TranscriptMessage[], options?: {
         context?: Record<string, unknown>;
         state?: Record<string, unknown>;
         files?: Record<string, unknown>;
         runId?: string;
+        memoryContext?: string;
     }): AsyncGenerator<RuntimeStreamChunk | string>;
 }
 export { AgentRuntimeAdapter as RuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX, AGENT_INTERRUPT_SENTINEL_PREFIX as INTERRUPT_SENTINEL_PREFIX, RuntimeOperationTimeoutError, };

package/dist/runtime/harness/run/stream-run.d.ts

@@ -15,6 +15,7 @@ type StreamRunOptions = {
         context?: Record<string, unknown>;
         state?: Record<string, unknown>;
         files?: Record<string, unknown>;
+        memoryContext?: string;
     };
     threadId: string;
     runId: string;
@@ -28,6 +29,7 @@ type StreamRunOptions = {
         state?: Record<string, unknown>;
         files?: Record<string, unknown>;
         runId: string;
+        memoryContext?: string;
     }) => AsyncIterable<RuntimeStreamChunk>;
     invokeWithHistory: (binding: CompiledAgentBinding, input: MessageContent, threadId: string, runId: string) => Promise<RunResult>;
     emit: (threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>) => Promise<HarnessEvent>;

package/dist/runtime/harness/run/stream-run.js

@@ -60,6 +60,7 @@ export async function* streamHarnessRun(options) {
             state: options.invocation.state,
             files: options.invocation.files,
             runId: options.runId,
+            memoryContext: options.invocation.memoryContext,
         })) {
             if (!rawChunk) {
                 continue;

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

@@ -0,0 +1,3 @@
+import type { CompiledTool, MemoryCandidate } from "../../../contracts/types.js";
+export declare function extractMemoryCandidatesFromToolOutput(tool: CompiledTool, output: unknown): MemoryCandidate[];
+export declare function renderMemoryCandidatesMarkdown(title: string, candidates: MemoryCandidate[]): string;

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

@@ -0,0 +1,110 @@
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+}
+function asString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function asNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function asStringArray(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const items = value
+        .filter((item) => typeof item === "string" && item.trim().length > 0)
+        .map((item) => item.trim());
+    return items.length > 0 ? items : undefined;
+}
+function stringifyCandidateContent(output) {
+    if (typeof output === "string") {
+        return output.trim();
+    }
+    if (typeof output === "number" || typeof output === "boolean") {
+        return String(output);
+    }
+    if (typeof output === "object" && output !== null) {
+        try {
+            return JSON.stringify(output, null, 2);
+        }
+        catch {
+            return "";
+        }
+    }
+    return "";
+}
+function normalizeCandidate(value, fallback) {
+    const record = asRecord(value);
+    if (!record) {
+        return null;
+    }
+    const content = asString(record.content);
+    if (!content) {
+        return null;
+    }
+    return {
+        content,
+        ...(asString(record.summary) ? { summary: asString(record.summary) } : {}),
+        ...(asString(record.kind) ?? fallback.kind ? { kind: asString(record.kind) ?? fallback.kind } : {}),
+        ...(asString(record.scope) ?? fallback.scope ? { scope: asString(record.scope) ?? fallback.scope } : {}),
+        ...(asNumber(record.confidence) !== undefined ? { confidence: asNumber(record.confidence) } : {}),
+        ...(asStringArray(record.tags) ?? fallback.tags ? { tags: asStringArray(record.tags) ?? fallback.tags } : {}),
+        ...(asString(record.sourceType) ?? fallback.sourceType ? { sourceType: asString(record.sourceType) ?? fallback.sourceType } : {}),
+        ...(asString(record.sourceRef) ? { sourceRef: asString(record.sourceRef) } : {}),
+        ...(asString(record.observedAt) ? { observedAt: asString(record.observedAt) } : {}),
+        ...(asString(record.sensitivity) ? { sensitivity: asString(record.sensitivity) } : {}),
+        ...(typeof record.noStore === "boolean" ? { noStore: record.noStore } : {}),
+        ...(asRecord(record.provenance) ? { provenance: asRecord(record.provenance) } : {}),
+    };
+}
+export function extractMemoryCandidatesFromToolOutput(tool, output) {
+    const memoryConfig = asRecord(tool.config?.memory);
+    if (memoryConfig?.enabled !== true) {
+        return [];
+    }
+    const fallback = {
+        sourceType: "tool-output",
+        kind: asString(memoryConfig.kind),
+        scope: asString(memoryConfig.scope) ?? "thread",
+        tags: asStringArray(memoryConfig.tags),
+    };
+    const explicitCandidates = asRecord(output)?.memoryCandidates;
+    if (Array.isArray(explicitCandidates)) {
+        const maxCandidates = asNumber(memoryConfig.maxCandidates) ?? explicitCandidates.length;
+        return explicitCandidates
+            .map((candidate) => normalizeCandidate(candidate, fallback))
+            .filter((candidate) => Boolean(candidate))
+            .slice(0, maxCandidates);
+    }
+    const content = stringifyCandidateContent(output);
+    if (!content) {
+        return [];
+    }
+    return [{
+            content,
+            ...(fallback.kind ? { kind: fallback.kind } : {}),
+            ...(fallback.scope ? { scope: fallback.scope } : {}),
+            ...(fallback.tags ? { tags: fallback.tags } : {}),
+            sourceType: fallback.sourceType,
+        }];
+}
+export function renderMemoryCandidatesMarkdown(title, candidates) {
+    const lines = [`# ${title}`, ""];
+    if (candidates.length === 0) {
+        lines.push("(none)", "");
+        return lines.join("\n");
+    }
+    for (const candidate of candidates) {
+        lines.push(`## ${(candidate.summary ?? candidate.content).split("\n")[0].slice(0, 120)}`);
+        lines.push(`- kind: ${candidate.kind ?? "summary"}`);
+        lines.push(`- scope: ${candidate.scope ?? "thread"}`);
+        lines.push(`- source_type: ${candidate.sourceType ?? "tool-output"}`);
+        if (candidate.tags && candidate.tags.length > 0) {
+            lines.push(`- tags: ${candidate.tags.join(", ")}`);
+        }
+        lines.push("");
+        lines.push(candidate.summary ?? candidate.content);
+        lines.push("");
+    }
+    return lines.join("\n");
+}

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

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

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

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

package/dist/runtime/harness.d.ts

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

package/dist/runtime/harness.js

@@ -1,3 +1,4 @@
+import path from "node:path";
 import { SqlitePersistence } from "../persistence/sqlite-store.js";
 import { createPersistentId } from "../utils/id.js";
 import { AgentRuntimeAdapter } from "./agent-runtime-adapter.js";
@@ -28,6 +29,8 @@ import { bindingSupportsRunningReplay, getWorkspaceBinding, resolveWorkspaceAgen
 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 { renderMemoryCandidatesMarkdown } from "./harness/system/runtime-memory-candidates.js";
+import { normalizeLangMemMemoryKind, readRuntimeMemoryPolicyConfig, resolveMemoryNamespace, scoreMemoryText, } from "./harness/system/runtime-memory-policy.js";
 import { resolveRuntimeAdapterOptions } from "./support/runtime-adapter-options.js";
 import { initializeHarnessRuntime, reclaimExpiredClaimedRuns as reclaimHarnessExpiredClaimedRuns, recoverStartupRuns as recoverHarnessStartupRuns, isStaleRunningRun as isHarnessStaleRunningRun, } from "./harness/run/startup-runtime.js";
 import { streamHarnessRun } from "./harness/run/stream-run.js";
@@ -55,6 +58,7 @@ export class AgentHarnessRuntime {
     defaultRunRootValue;
     defaultStore;
     runtimeMemoryStore;
+    runtimeMemoryPolicy;
     routingRules;
     routingDefaultAgentId;
     threadMemorySync;
@@ -118,6 +122,7 @@ export class AgentHarnessRuntime {
             ? this.defaultRuntimeEntryBinding.harnessRuntime.runtimeMemory.store
             : undefined;
         this.runtimeMemoryStore = resolveStoreFromConfig(this.stores, runtimeMemoryStoreConfig, runRoot) ?? this.defaultStore;
+        this.runtimeMemoryPolicy = readRuntimeMemoryPolicyConfig(this.defaultRuntimeEntryBinding?.harnessRuntime.runtimeMemory, this.workspace.workspaceRoot) ?? null;
         this.resolvedRuntimeAdapterOptions = resolveRuntimeAdapterOptions({
             workspace,
             runtimeAdapterOptions,
@@ -349,9 +354,14 @@ export class AgentHarnessRuntime {
     }
     async invokeWithHistory(binding, input, threadId, runId, resumePayload, priorHistory, options = {}) {
         const history = priorHistory ?? await this.loadPriorHistory(threadId, runId);
+        const memoryContext = options.memoryContext ?? await this.buildRuntimeMemoryContext(binding, threadId, input);
         const startedAt = Date.now();
         try {
-            const result = await this.runtimeAdapter.invoke(binding, input, threadId, runId, resumePayload, history, options);
+            const result = await this.runtimeAdapter.invoke(binding, input, threadId, runId, resumePayload, history, {
+                ...options,
+                ...(memoryContext ? { memoryContext } : {}),
+            });
+            await this.persistRuntimeMemoryCandidates(binding, threadId, runId, result.metadata?.memoryCandidates);
             this.recordLlmSuccess(startedAt);
             return result;
         }
@@ -360,6 +370,115 @@ export class AgentHarnessRuntime {
             throw error;
         }
     }
+    resolveMemoryNamespace(scope, binding, options = {}) {
+        const workspaceRoot = binding.harnessRuntime.workspaceRoot ?? this.workspace.workspaceRoot;
+        const workspaceId = path.basename(workspaceRoot) || "default";
+        const template = this.runtimeMemoryPolicy?.namespaces[scope] ?? `memories/${scope}s/{${scope}Id}`;
+        return resolveMemoryNamespace(template, {
+            threadId: options.threadId,
+            agentId: binding.agent.id,
+            workspaceId,
+            userId: options.userId ?? "default",
+            projectId: options.projectId ?? workspaceId,
+        });
+    }
+    async buildRuntimeMemoryContext(binding, threadId, input) {
+        const threadNamespace = this.resolveMemoryNamespace("thread", binding, { threadId });
+        const agentNamespace = this.resolveMemoryNamespace("agent", binding);
+        const workspaceNamespace = this.resolveMemoryNamespace("workspace", binding);
+        const docs = await Promise.all([
+            this.runtimeMemoryStore.get(threadNamespace, "durable-summary.md"),
+            this.runtimeMemoryStore.get(threadNamespace, "tool-memory.md"),
+            this.runtimeMemoryStore.get(threadNamespace, "semantic.md"),
+            this.runtimeMemoryStore.get(threadNamespace, "episodic.md"),
+            this.runtimeMemoryStore.get(threadNamespace, "procedural.md"),
+            this.runtimeMemoryStore.get(agentNamespace, "procedural.md"),
+            this.runtimeMemoryStore.get(workspaceNamespace, "semantic.md"),
+            this.runtimeMemoryStore.get(workspaceNamespace, "procedural.md"),
+        ]);
+        const query = typeof input === "string" ? input : JSON.stringify(input ?? "");
+        const ranked = docs
+            .map((doc, index) => {
+            const content = doc?.value?.content;
+            if (typeof content !== "string" || content.trim().length === 0) {
+                return null;
+            }
+            const scopeBoost = index < 5 ? 4 : index === 5 ? 2 : 1;
+            return {
+                content: content.trim(),
+                score: scoreMemoryText(query, content, scopeBoost),
+            };
+        })
+            .filter((value) => Boolean(value))
+            .sort((left, right) => right.score - left.score)
+            .slice(0, this.runtimeMemoryPolicy?.retrieval.maxPromptMemories ?? 8);
+        if (ranked.length === 0) {
+            return undefined;
+        }
+        return ranked.map((entry) => entry.content).join("\n\n");
+    }
+    async persistRuntimeMemoryCandidates(binding, threadId, runId, value) {
+        if (!Array.isArray(value) || value.length === 0) {
+            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");
+        await this.runtimeMemoryStore.put(["memories", "candidates", threadId], `${runId}.json`, {
+            runId,
+            threadId,
+            storedAt: new Date().toISOString(),
+            candidates,
+        });
+        const writes = [];
+        if (threadCandidates.length > 0) {
+            writes.push(this.appendMemoryDigest(this.resolveMemoryNamespace("thread", binding, { threadId }), "tool-memory.md", threadCandidates, 12, "Thread Tool Memory"));
+        }
+        if (workspaceCandidates.length > 0) {
+            writes.push(this.appendMemoryDigest(this.resolveMemoryNamespace("workspace", binding), "tool-memory.md", workspaceCandidates, 20, "Workspace Tool Memory"));
+        }
+        if (agentCandidates.length > 0) {
+            writes.push(this.appendMemoryDigest(this.resolveMemoryNamespace("agent", binding), "tool-memory.md", agentCandidates, 20, "Agent Tool Memory"));
+        }
+        await Promise.all(writes);
+    }
+    async appendMemoryDigest(namespace, key, candidates, maxEntries, title) {
+        const existing = await this.runtimeMemoryStore.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 existing = taxonomyGroups.get(kind) ?? [];
+            existing.push({ ...candidate, kind });
+            taxonomyGroups.set(kind, existing);
+        }
+        await this.runtimeMemoryStore.put(namespace, key, {
+            content: `${renderMemoryCandidatesMarkdown(title, recent)}\n`,
+            items: recent,
+        });
+        await Promise.all(Array.from(taxonomyGroups.entries()).map(async ([kind, items]) => {
+            await this.runtimeMemoryStore.put(namespace, `${kind}.md`, {
+                content: `${renderMemoryCandidatesMarkdown(`${title} (${kind})`, items)}\n`,
+                items,
+            });
+        }));
+    }
     async resolvePersistedRunPriority(threadId, runId) {
         const persisted = await this.persistence.getRunRequest(threadId, runId);
         return normalizeRunPriority(persisted?.priority);
@@ -514,7 +633,10 @@ export class AgentHarnessRuntime {
         const stream = streamHarnessRun({
             binding,
             input: options.input,
-            invocation,
+            invocation: {
+                ...invocation,
+                memoryContext: await this.buildRuntimeMemoryContext(binding, threadId, options.input),
+            },
             threadId,
             runId,
             selectedAgentId,

package/dist/tool-modules.d.ts

@@ -6,6 +6,13 @@ export type LoadedToolModule = {
     schema: ReturnType<typeof normalizeToolSchema>;
     description: string;
     retryable?: boolean;
+    memory?: {
+        enabled: boolean;
+        kind?: string;
+        scope?: string;
+        maxCandidates?: number;
+        tags?: string[];
+    };
 };
 export type LoadedSkillModule = {
     name: string;

package/dist/tool-modules.js

@@ -22,6 +22,7 @@ function loadToolObjectDefinition(imported, exportName) {
         schema: normalizeToolSchema(definition.schema),
         description: definition.description.trim(),
         retryable: definition.retryable === true,
+        ...(definition.memory ? { memory: { ...definition.memory } } : {}),
     };
 }
 export function isSupportedToolModulePath(filePath) {

package/dist/tools.d.ts

@@ -6,6 +6,13 @@ export type ToolDefinitionObject = {
     description: string;
     schema: SchemaInput;
     retryable?: boolean;
+    memory?: {
+        enabled: boolean;
+        kind?: string;
+        scope?: string;
+        maxCandidates?: number;
+        tags?: string[];
+    };
     invoke: (input: unknown, context?: Record<string, unknown>) => Promise<unknown> | unknown;
     [TOOL_DEFINITION_MARKER]: true;
 };
@@ -17,6 +24,13 @@ export declare function tool(definition: {
     description: string;
     schema: SchemaInput;
     retryable?: boolean;
+    memory?: {
+        enabled: boolean;
+        kind?: string;
+        scope?: string;
+        maxCandidates?: number;
+        tags?: string[];
+    };
     invoke: (input: unknown, context?: Record<string, unknown>) => Promise<unknown> | unknown;
 }): ToolDefinitionObject;
 export {};

package/dist/workspace/object-loader.js

@@ -762,6 +762,7 @@ export async function readToolModuleItems(root) {
                     description: definition.description,
                     implementationName: definition.implementationName,
                     ...(definition.retryable !== undefined ? { retryable: definition.retryable } : {}),
+                    ...(definition.memory ? { config: { memory: definition.memory } } : {}),
                 },
                 sourcePath: filePath,
             });

package/package.json

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