@botbotgo/agent-harness 0.0.151 → 0.0.152

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

@@ -66,6 +66,10 @@ spec:
     writeOnApprovalResolution: true
     writeOnRunCompletion: true
 
+  # agent-harness feature: optional thread snapshot projection for operational state and pending approvals.
+  threadMemorySync:
+    enabled: true
+
   # agent-harness feature: optional Mem0 OSS ingestion engine for automatic long-term knowledge extraction.
   mem0:
     enabled: false

package/dist/init-project.js

@@ -162,6 +162,8 @@ spec:
     backgroundConsolidation: true
     writeOnApprovalResolution: true
     writeOnRunCompletion: true
+  threadMemorySync:
+    enabled: true
   mem0:
     enabled: false
     apiKeyEnv: MEM0_API_KEY

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.150";
+export declare const AGENT_HARNESS_VERSION = "0.0.151";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.150";
+export const AGENT_HARNESS_VERSION = "0.0.151";

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

@@ -8,17 +8,25 @@ export type ResolvedRuntimeMemorySyncConfig = {
     backgroundConsolidation: boolean;
     maxMessagesPerRun: number;
 };
+type RuntimeMemorySyncOptions = {
+    resolveThreadNamespace?: (threadId: string) => string[];
+    resolveRunNamespace?: (threadId: string) => string[];
+};
 export declare function readRuntimeMemorySyncConfig(runtimeMemory: Record<string, unknown> | undefined): ResolvedRuntimeMemorySyncConfig | undefined;
 export declare class RuntimeMemorySync implements HarnessEventProjection {
     private readonly persistence;
     readonly store: StoreLike;
     private readonly config;
+    private readonly options;
     private readonly pending;
     private syncChain;
     readonly name = "runtime-memory-sync";
-    constructor(persistence: RuntimePersistence, store: StoreLike, config: ResolvedRuntimeMemorySyncConfig);
+    constructor(persistence: RuntimePersistence, store: StoreLike, config: ResolvedRuntimeMemorySyncConfig, options?: RuntimeMemorySyncOptions);
     shouldHandle(event: HarnessEvent): boolean;
     handleEvent(event: HarnessEvent): Promise<void>;
     private syncRun;
+    private resolveThreadNamespace;
+    private resolveRunNamespace;
     close(): Promise<void>;
 }
+export {};

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

@@ -100,13 +100,15 @@ export class RuntimeMemorySync {
     persistence;
     store;
     config;
+    options;
     pending = new Set();
     syncChain = Promise.resolve();
     name = "runtime-memory-sync";
-    constructor(persistence, store, config) {
+    constructor(persistence, store, config, options = {}) {
         this.persistence = persistence;
         this.store = store;
         this.config = config;
+        this.options = options;
     }
     shouldHandle(event) {
         if (!RUNTIME_MEMORY_EVENT_TYPES.has(event.eventType)) {
@@ -161,8 +163,8 @@ export class RuntimeMemorySync {
             approvals,
         });
         await Promise.all([
-            this.store.put(["memories", "runs", threadId], `${runId}.summary.md`, { content: `${summaryMarkdown}\n` }),
-            this.store.put(["memories", "runs", threadId], `${runId}.record.json`, {
+            this.store.put(this.resolveRunNamespace(threadId), `${runId}.summary.md`, { content: `${summaryMarkdown}\n` }),
+            this.store.put(this.resolveRunNamespace(threadId), `${runId}.record.json`, {
                 kind: "summary",
                 scope: "thread",
                 threadId,
@@ -185,7 +187,13 @@ export class RuntimeMemorySync {
             capturedAt,
             messages,
         });
-        await this.store.put(["memories", "threads", threadId], "durable-summary.md", { content: `${digestMarkdown}\n` });
+        await this.store.put(this.resolveThreadNamespace(threadId), "durable-summary.md", { content: `${digestMarkdown}\n` });
+    }
+    resolveThreadNamespace(threadId) {
+        return this.options.resolveThreadNamespace ? this.options.resolveThreadNamespace(threadId) : ["memories", "threads", threadId];
+    }
+    resolveRunNamespace(threadId) {
+        return this.options.resolveRunNamespace ? this.options.resolveRunNamespace(threadId) : ["memories", "runs", threadId];
     }
     async close() {
         await Promise.allSettled(Array.from(this.pending));

package/dist/runtime/harness/system/thread-memory-sync.d.ts

@@ -1,14 +1,18 @@
 import type { HarnessEvent, HarnessEventProjection } from "../../../contracts/types.js";
 import type { RuntimePersistence } from "../../../persistence/types.js";
+type ThreadMemorySyncOptions = {
+    resolveThreadNamespace?: (threadId: string) => string[];
+};
 export declare class ThreadMemorySync implements HarnessEventProjection {
     private readonly persistence;
     private readonly store?;
+    private readonly options;
     private readonly pending;
     private syncChain;
     readonly name = "thread-memory-sync";
     constructor(persistence: RuntimePersistence, store?: {
         put: (namespace: string[], key: string, value: Record<string, any>) => Promise<void>;
-    } | undefined);
+    } | undefined, options?: ThreadMemorySyncOptions);
     shouldHandle(event: HarnessEvent): boolean;
     handleEvent(event: HarnessEvent): Promise<void>;
     private syncThread;

package/dist/runtime/harness/system/thread-memory-sync.js

@@ -6,11 +6,11 @@ function excerpt(message) {
     const normalized = extractMessageText(message.content).replace(/\s+/g, " ").trim();
     return normalized.length > 240 ? `${normalized.slice(0, 237)}...` : normalized;
 }
-function renderStatusMarkdown(thread, messages) {
+function renderThreadSnapshotMarkdown(thread, messages, approvals) {
     const userMessages = messages.filter((message) => message.role === "user");
     const assistantMessages = messages.filter((message) => message.role === "assistant");
     return [
-        "# Thread Status",
+        "# Thread Snapshot",
         "",
         `- thread_id: ${thread.threadId}`,
         `- latest_run_id: ${thread.latestRunId}`,
@@ -24,15 +24,17 @@ function renderStatusMarkdown(thread, messages) {
         "## Recent Assistant Message",
         excerpt(assistantMessages.at(-1)),
         "",
+        ...formatOpenApprovalsSection(approvals),
     ].join("\n");
 }
-function renderOpenApprovalsMarkdown(approvals) {
+function formatOpenApprovalsSection(approvals) {
+    const lines = ["## Open Approvals", ""];
     if (approvals.length === 0) {
-        return ["# Open Approvals", "", "(none)", ""].join("\n");
+        lines.push("(none)", "");
+        return lines;
     }
-    const lines = ["# Open Approvals", ""];
     for (const approval of approvals) {
-        lines.push(`## ${approval.approvalId}`);
+        lines.push(`### ${approval.approvalId}`);
         lines.push(`- pending_action_id: ${approval.pendingActionId}`);
         lines.push(`- tool: ${approval.toolName}`);
         lines.push(`- run_id: ${approval.runId}`);
@@ -40,7 +42,10 @@ function renderOpenApprovalsMarkdown(approvals) {
         lines.push(`- allowed: ${approval.allowedDecisions.join(", ")}`);
         lines.push("");
     }
-    return lines.join("\n");
+    return lines;
+}
+function resolveThreadNamespace(threadId, resolver) {
+    return resolver ? resolver(threadId) : ["memories", "threads", threadId];
 }
 const THREAD_MEMORY_EVENT_TYPES = new Set([
     "run.state.changed",
@@ -52,12 +57,14 @@ const THREAD_MEMORY_EVENT_TYPES = new Set([
 export class ThreadMemorySync {
     persistence;
     store;
+    options;
     pending = new Set();
     syncChain = Promise.resolve();
     name = "thread-memory-sync";
-    constructor(persistence, store) {
+    constructor(persistence, store, options = {}) {
         this.persistence = persistence;
         this.store = store;
+        this.options = options;
     }
     shouldHandle(event) {
         return THREAD_MEMORY_EVENT_TYPES.has(event.eventType);
@@ -93,10 +100,9 @@ export class ThreadMemorySync {
         if (!this.store) {
             return;
         }
-        await Promise.all([
-            this.store.put(["memories", "threads", threadId], "status.md", { content: `${renderStatusMarkdown(thread, messages)}\n` }),
-            this.store.put(["memories", "threads", threadId], "open-approvals.md", { content: `${renderOpenApprovalsMarkdown(pendingApprovals)}\n` }),
-        ]);
+        await this.store.put(resolveThreadNamespace(threadId, this.options.resolveThreadNamespace), "snapshot.md", {
+            content: `${renderThreadSnapshotMarkdown(thread, messages, pendingApprovals)}\n`,
+        });
     }
     async close() {
         await Promise.allSettled(Array.from(this.pending));

package/dist/runtime/harness.js

@@ -144,7 +144,15 @@ export class AgentHarnessRuntime {
         this.routingRules = getRoutingRules(workspace.refs);
         this.routingDefaultAgentId = getRoutingDefaultAgentId(workspace.refs);
         if (isThreadMemorySyncEnabled(workspace)) {
-            this.threadMemorySync = new ThreadMemorySync(this.persistence, this.runtimeMemoryStore);
+            this.threadMemorySync = new ThreadMemorySync(this.persistence, this.runtimeMemoryStore, {
+                resolveThreadNamespace: (threadId) => {
+                    const binding = this.defaultRuntimeEntryBinding;
+                    if (!binding) {
+                        return ["memories", "threads", threadId];
+                    }
+                    return this.resolveMemoryNamespace("thread", binding, { threadId });
+                },
+            });
             this.unregisterThreadMemorySync = this.eventBus.registerProjection(this.threadMemorySync);
         }
         else {
@@ -153,7 +161,15 @@ export class AgentHarnessRuntime {
         }
         const runtimeMemorySyncConfig = readRuntimeMemorySyncConfig(this.defaultRuntimeEntryBinding?.harnessRuntime.runtimeMemory);
         if (runtimeMemorySyncConfig) {
-            this.runtimeMemorySync = new RuntimeMemorySync(this.persistence, this.runtimeMemoryStore, runtimeMemorySyncConfig);
+            this.runtimeMemorySync = new RuntimeMemorySync(this.persistence, this.runtimeMemoryStore, runtimeMemorySyncConfig, {
+                resolveThreadNamespace: (threadId) => {
+                    const binding = this.defaultRuntimeEntryBinding;
+                    if (!binding) {
+                        return ["memories", "threads", threadId];
+                    }
+                    return this.resolveMemoryNamespace("thread", binding, { threadId });
+                },
+            });
             this.unregisterRuntimeMemorySync = this.eventBus.registerProjection(this.runtimeMemorySync);
         }
         else {

package/package.json

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