snow-flow 10.0.186-dev.682 → 10.0.186-dev.683

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "10.0.186-dev.682",
+  "version": "10.0.186-dev.683",
   "name": "snow-flow",
   "description": "Snow-Flow - ServiceNow Multi-Agent Development Framework powered by AI",
   "license": "Elastic-2.0",

package/src/cli/cmd/tui/routes/session/index.tsx

@@ -7,6 +7,7 @@ import {
   For,
   Match,
   on,
+  onCleanup,
   onMount,
   Show,
   Switch,
@@ -202,7 +203,7 @@ export function Session() {
   })
 
   let lastSwitch: string | undefined = undefined
-  sdk.event.on("message.part.updated", (evt) => {
+  const unsubPartUpdated = sdk.event.on("message.part.updated", (evt) => {
     const part = evt.properties.part
     if (part.type !== "tool") return
     if (part.sessionID !== route.sessionID) return
@@ -217,6 +218,7 @@ export function Session() {
       lastSwitch = part.id
     }
   })
+  onCleanup(() => unsubPartUpdated())
 
   let scroll: ScrollBoxRenderable
   let prompt: PromptRef

package/src/format/index.ts

@@ -100,9 +100,11 @@ export namespace Format {
     return result
   }
 
+  let formatUnsub: (() => void) | undefined
   export function init() {
     log.info("init")
-    Bus.subscribe(File.Event.Edited, async (payload) => {
+    formatUnsub?.()
+    formatUnsub = Bus.subscribe(File.Event.Edited, async (payload) => {
       const file = payload.properties.file
       log.info("formatting", { file })
       const ext = path.extname(file)

package/src/plugin/index.ts

@@ -116,6 +116,7 @@ export namespace Plugin {
     return state().then((x) => x.hooks)
   }
 
+  let busUnsub: (() => void) | undefined
   export async function init() {
     const hooks = await state().then((x) => x.hooks)
     const config = await Config.get()
@@ -123,7 +124,9 @@ export namespace Plugin {
       // @ts-expect-error this is because we haven't moved plugin to sdk v2
       await hook.config?.(config)
     }
-    Bus.subscribeAll(async (input) => {
+    // Clean up previous subscription to prevent accumulation on re-init
+    busUnsub?.()
+    busUnsub = Bus.subscribeAll(async (input) => {
       const hooks = await state().then((x) => x.hooks)
       for (const hook of hooks) {
         hook["event"]?.({

package/src/project/bootstrap.ts

@@ -75,9 +75,11 @@ export async function InstanceBootstrap() {
   await ensureAgentsMd()
   await ensureInstanceMd()
 
-  Bus.subscribe(Command.Event.Executed, async (payload) => {
+  bootstrapUnsub?.()
+  bootstrapUnsub = Bus.subscribe(Command.Event.Executed, async (payload) => {
     if (payload.properties.name === Command.Default.INIT) {
       await Project.setInitialized(Instance.project.id)
     }
   })
 }
+let bootstrapUnsub: (() => void) | undefined

package/src/session/message-v2.ts

@@ -447,6 +447,8 @@ export namespace MessageV2 {
 
   // In-memory message cache: avoids re-reading all messages from disk on every loop iteration.
   // Uses Instance.state for per-instance isolation and Bus events for cache invalidation.
+  // LRU eviction: only the most recently accessed sessions are kept in memory.
+  const MAX_CACHED_SESSIONS = 3
   const messageCache = Instance.state(
     () => {
       const sessions = new Map<string, MessageV2.WithParts[]>()
@@ -508,7 +510,12 @@ export namespace MessageV2 {
   export async function streamCached(sessionID: string): Promise<WithParts[]> {
     const { sessions } = messageCache()
     const existing = sessions.get(sessionID)
-    if (existing) return existing
+    if (existing) {
+      // LRU: move to end (most recently used)
+      sessions.delete(sessionID)
+      sessions.set(sessionID, existing)
+      return existing
+    }
 
     // Cold start: load from disk and populate cache
     const result: WithParts[] = []
@@ -517,6 +524,13 @@ export namespace MessageV2 {
     }
     result.reverse() // stream yields newest first, we want chronological order
     sessions.set(sessionID, result)
+
+    // LRU eviction: remove oldest sessions if over limit
+    while (sessions.size > MAX_CACHED_SESSIONS) {
+      const oldest = sessions.keys().next().value
+      if (oldest) sessions.delete(oldest)
+    }
+
     return result
   }
 

package/src/share/share-next.ts

@@ -17,52 +17,57 @@ export namespace ShareNext {
 
   const disabled = process.env["OPENCODE_DISABLE_SHARE"] === "true" || process.env["OPENCODE_DISABLE_SHARE"] === "1"
 
+  const shareNextUnsubs: (() => void)[] = []
   export async function init() {
     if (disabled) return
-    Bus.subscribe(Session.Event.Updated, async (evt) => {
-      await sync(evt.properties.info.id, [
-        {
-          type: "session",
-          data: evt.properties.info,
-        },
-      ])
-    })
-    Bus.subscribe(MessageV2.Event.Updated, async (evt) => {
-      await sync(evt.properties.info.sessionID, [
-        {
-          type: "message",
-          data: evt.properties.info as any,
-        },
-      ])
-      if (evt.properties.info.role === "user") {
+    for (const unsub of shareNextUnsubs) unsub()
+    shareNextUnsubs.length = 0
+    shareNextUnsubs.push(
+      Bus.subscribe(Session.Event.Updated, async (evt) => {
+        await sync(evt.properties.info.id, [
+          {
+            type: "session",
+            data: evt.properties.info,
+          },
+        ])
+      }),
+      Bus.subscribe(MessageV2.Event.Updated, async (evt) => {
         await sync(evt.properties.info.sessionID, [
           {
-            type: "model",
-            data: [
-              await Provider.getModel(evt.properties.info.model.providerID, evt.properties.info.model.modelID).then(
-                (m) => m,
-              ),
-            ],
+            type: "message",
+            data: evt.properties.info as any,
           },
         ])
-      }
-    })
-    Bus.subscribe(MessageV2.Event.PartUpdated, async (evt) => {
-      await sync(evt.properties.part.sessionID, [
-        {
-          type: "part",
-          data: evt.properties.part,
-        },
-      ])
-    })
-    Bus.subscribe(Session.Event.Diff, async (evt) => {
-      await sync(evt.properties.sessionID, [
-        {
-          type: "session_diff",
-          data: evt.properties.diff,
-        },
-      ])
-    })
+        if (evt.properties.info.role === "user") {
+          await sync(evt.properties.info.sessionID, [
+            {
+              type: "model",
+              data: [
+                await Provider.getModel(evt.properties.info.model.providerID, evt.properties.info.model.modelID).then(
+                  (m) => m,
+                ),
+              ],
+            },
+          ])
+        }
+      }),
+      Bus.subscribe(MessageV2.Event.PartUpdated, async (evt) => {
+        await sync(evt.properties.part.sessionID, [
+          {
+            type: "part",
+            data: evt.properties.part,
+          },
+        ])
+      }),
+      Bus.subscribe(Session.Event.Diff, async (evt) => {
+        await sync(evt.properties.sessionID, [
+          {
+            type: "session_diff",
+            data: evt.properties.diff,
+          },
+        ])
+      }),
+    )
   }
 
   export async function create(sessionID: string) {

package/src/share/share.ts

@@ -46,24 +46,29 @@ export namespace Share {
       })
   }
 
+  const shareUnsubs: (() => void)[] = []
   export function init() {
-    Bus.subscribe(Session.Event.Updated, async (evt) => {
-      await sync("session/info/" + evt.properties.info.id, evt.properties.info)
-    })
-    Bus.subscribe(MessageV2.Event.Updated, async (evt) => {
-      await sync("session/message/" + evt.properties.info.sessionID + "/" + evt.properties.info.id, evt.properties.info)
-    })
-    Bus.subscribe(MessageV2.Event.PartUpdated, async (evt) => {
-      await sync(
-        "session/part/" +
-          evt.properties.part.sessionID +
-          "/" +
-          evt.properties.part.messageID +
-          "/" +
-          evt.properties.part.id,
-        evt.properties.part,
-      )
-    })
+    for (const unsub of shareUnsubs) unsub()
+    shareUnsubs.length = 0
+    shareUnsubs.push(
+      Bus.subscribe(Session.Event.Updated, async (evt) => {
+        await sync("session/info/" + evt.properties.info.id, evt.properties.info)
+      }),
+      Bus.subscribe(MessageV2.Event.Updated, async (evt) => {
+        await sync("session/message/" + evt.properties.info.sessionID + "/" + evt.properties.info.id, evt.properties.info)
+      }),
+      Bus.subscribe(MessageV2.Event.PartUpdated, async (evt) => {
+        await sync(
+          "session/part/" +
+            evt.properties.part.sessionID +
+            "/" +
+            evt.properties.part.messageID +
+            "/" +
+            evt.properties.part.id,
+          evt.properties.part,
+        )
+      }),
+    )
   }
 
   export const URL =