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

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.694",
   "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/agents-template.txt

@@ -590,23 +590,23 @@ You have **direct access** to MCP tools in your environment. They are **already
 - Call the MCP tool directly once discovered
 - Tools work like built-in functions - just call them
 
-### Anti-Pattern 2: Using Scheduled Scripts / Background Scripts
+### Anti-Pattern 2: Using Script Execution for CRUD Operations
 
-**🚨 CRITICAL: `snow_schedule_script_job` and `snow_trigger_scheduled_job` are UNRELIABLE!**
+**`snow_execute_script` executes scripts reliably (~1-3s via sync REST API), but prefer dedicated tools for CRUD operations.**
 
-These tools **CANNOT execute scripts directly**. They create scheduled jobs that depend on the ServiceNow scheduler — which frequently times out, returns `executed=false`, or simply never runs the script. **Do NOT use these tools to verify, test, or validate anything.**
+`snow_execute_script` now uses synchronous REST API execution (with scheduler fallback), so it IS reliable for script execution. However, you should still prefer dedicated tools over raw GlideRecord scripts.
 
-**NEVER use `snow_schedule_script_job` or `snow_trigger_scheduled_job` for:**
-- ❌ Verifying if something was created correctly (use `snow_query_table` instead)
-- ❌ Testing GlideRecord queries (use `snow_query_table` instead)
-- ❌ Checking table/field existence (use `snow_query_table` with limit=1 instead)
-- ❌ Creating/updating artifacts (use dedicated tools!)
-- ❌ Any operation where you need reliable results
+**Prefer dedicated tools over `snow_execute_script` for:**
+- Querying records → use `snow_query_table`
+- Creating/updating artifacts → use dedicated tools (snow_deploy, snow_update, etc.)
+- Flow operations → use `snow_manage_flow`
+- Checking table/field existence → use `snow_query_table` with limit=1
 
-**What to use instead:**
-- `snow_query_table` — for querying records, checking existence, verifying data
-- `snow_manage_flow` — for flow operations
-- Dedicated tools — always prefer a specific tool over a generic script execution
+**`snow_execute_script` IS appropriate for:**
+- ✅ Custom verification scripts that need server-side logic
+- ✅ Complex operations not covered by dedicated tools
+- ✅ Debugging and testing with gs.info output
+- ✅ One-off data operations
 
 ### Anti-Pattern 3: No Mock Data, No Placeholders
 

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/servicenow/servicenow-automation-mcp.ts

@@ -371,7 +371,7 @@ class ServiceNowAutomationMCP {
         {
           name: "snow_schedule_script_with_output",
           description:
-            "⚠️ DEPRECATED - Use snow_schedule_script_job instead. SCHEDULES (not executes directly) a script via scheduled job. May return executed=false. ES5 only!",
+            "⚠️ DEPRECATED - Use snow_execute_script instead. SCHEDULES (not executes directly) a script via scheduled job. May return executed=false. ES5 only!",
           inputSchema: {
             type: "object",
             properties: {
@@ -400,7 +400,7 @@ class ServiceNowAutomationMCP {
         {
           name: "snow_schedule_script_sync",
           description:
-            '⚠️ DEPRECATED - Use snow_schedule_script_job instead. SCHEDULES (not sync executes) a script via scheduled job. The "sync" name is misleading - this still uses async scheduling. ES5 only!',
+            '⚠️ DEPRECATED - Use snow_execute_script instead. SCHEDULES (not sync executes) a script via scheduled job. The "sync" name is misleading - this still uses async scheduling. ES5 only!',
           inputSchema: {
             type: "object",
             properties: {

package/src/servicenow/servicenow-mcp-server.ts

@@ -220,9 +220,9 @@ class ServiceNowMCPServer {
             },
           },
           {
-            name: "snow_schedule_script_job",
+            name: "snow_execute_script",
             description:
-              "⚠️ SCHEDULES (not executes directly) server-side JavaScript via Scheduled Script Job. Creates sysauto_script + sys_trigger. May return executed=false if scheduler doesn't pick it up - check System Scheduler > Scheduled Jobs.",
+              "Execute server-side JavaScript on ServiceNow. Primary: synchronous execution via Scripted REST API (~1-3s). Fallback: scheduled job if endpoint unavailable. ES5 only (Rhino engine)!",
             inputSchema: {
               type: "object",
               properties: {
@@ -287,7 +287,7 @@ class ServiceNowMCPServer {
           case "snow_create_workflow":
             return await this.handleCreateWorkflow(args)
 
-          case "snow_schedule_script_job":
+          case "snow_execute_script":
             return await this.handleExecuteScript(args)
 
           case "snow_test_connection":

package/src/servicenow/servicenow-mcp-unified/README.md

@@ -51,7 +51,7 @@ servicenow-mcp-unified/
 │   │   ├── snow_add_uib_page_element.ts
 │   │   └── index.ts
 │   ├── automation/              # Script execution, jobs
-│   │   ├── snow_schedule_script_job.ts    # Schedule script jobs (NOT direct execution!)
+│   │   ├── snow_execute_script.ts          # Execute scripts (sync REST API + scheduler fallback)
 │   │   ├── snow_schedule_job.ts
 │   │   └── index.ts
 │   ├── advanced/                # Analytics
@@ -110,10 +110,10 @@ Tools are organized by **domain** (functional area), not by original server:
 
 ### 4. Automation Tools (automation/)
 
-**Purpose:** Script scheduling and job management
+**Purpose:** Script execution and job management
 
-- `snow_schedule_script_job` - ⚠️ SCHEDULES scripts (NOT direct execution!) via sysauto_script + sys_trigger
-- `snow_confirm_script_execution` - Confirm scripts requiring approval (also uses scheduling)
+- `snow_execute_script` - Execute scripts via synchronous REST API (~1-3s), with scheduler fallback
+- `snow_confirm_script_execution` - Confirm scripts requiring approval
 - `snow_schedule_job` - Create scheduled jobs
 - `snow_get_logs` - Access system logs
 - `snow_trace_execution` - Set up execution tracing configuration

package/src/servicenow/servicenow-mcp-unified/tools/automation/index.ts

@@ -34,11 +34,11 @@ export {
   toolDefinition as snow_discover_schedules_def,
   execute as snow_discover_schedules_exec,
 } from "./snow_discover_schedules.js"
-// Scheduled script job tool - schedules scripts via sysauto_script + sys_trigger (does NOT execute directly!)
+// Script execution tool - synchronous REST API execution with scheduler fallback
 export {
-  toolDefinition as snow_schedule_script_job_def,
-  execute as snow_schedule_script_job_exec,
-} from "./snow_schedule_script_job.js"
+  toolDefinition as snow_execute_script_def,
+  execute as snow_execute_script_exec,
+} from "./snow_execute_script.js"
 export { toolDefinition as snow_get_logs_def, execute as snow_get_logs_exec } from "./snow_get_logs.js"
 export {
   toolDefinition as snow_get_email_logs_def,

package/src/servicenow/servicenow-mcp-unified/tools/automation/snow_confirm_script_execution.ts

@@ -2,7 +2,7 @@
  * snow_confirm_script_execution - Confirm and execute approved script
  *
  * Executes a script after user approval. Only call this after user
- * explicitly approves script execution from snow_schedule_script_job with requireConfirmation=true.
+ * explicitly approves script execution from snow_execute_script with requireConfirmation=true.
  *
  * Uses sysauto_script + sys_trigger approach for reliable execution.
  *
@@ -16,7 +16,7 @@ import { createSuccessResult, createErrorResult, SnowFlowError, ErrorType } from
 export const toolDefinition: MCPToolDefinition = {
   name: "snow_confirm_script_execution",
   description:
-    "⚡ Confirms and schedules script after user approval (use after snow_schedule_script_job with requireConfirmation=true). Note: Uses same scheduled job approach.",
+    "⚡ Confirms and schedules script after user approval (use after snow_execute_script with requireConfirmation=true). Note: Uses same scheduled job approach.",
   // Metadata for tool discovery (not sent to LLM)
   category: "automation",
   subcategory: "script-execution",

package/src/servicenow/servicenow-mcp-unified/tools/automation/{snow_schedule_script_job.ts → snow_execute_script.ts}

@@ -1,5 +1,5 @@
 /**
- * snow_schedule_script_job - Execute server-side JavaScript on ServiceNow
+ * snow_execute_script - Execute server-side JavaScript on ServiceNow
  *
  * Primary: synchronous execution via Scripted REST API (~1-3s)
  * Fallback: scheduled job if endpoint unavailable
@@ -87,11 +87,11 @@ const OPERATION_SCRIPT = `(function process(request, response) {
 })(request, response);`
 
 export const toolDefinition: MCPToolDefinition = {
-  name: "snow_schedule_script_job",
+  name: "snow_execute_script",
   description:
     "Execute server-side JavaScript on ServiceNow. Primary: synchronous execution via Scripted REST API (~1-3s). Fallback: scheduled job if endpoint unavailable. Auto-deploys the executor endpoint on first use. ES5 only (Rhino engine)!",
   category: "automation",
-  subcategory: "scheduled-jobs",
+  subcategory: "script-execution",
   use_cases: ["automation", "scripts", "scheduled-jobs", "debugging", "verification"],
   complexity: "advanced",
   frequency: "high",
@@ -150,7 +150,7 @@ export const toolDefinition: MCPToolDefinition = {
 
 export async function execute(args: Record<string, unknown>, context: ServiceNowContext): Promise<ToolResult> {
   const script = args.script as string
-  const description = (args.description as string) || "Script scheduled via snow_schedule_script_job"
+  const description = (args.description as string) || "Script executed via snow_execute_script"
   const timeout = (args.timeout as number) || 30000
   const validate = args.validate_es5 !== false
   const confirmation = args.requireConfirmation === true

package/src/servicenow/servicenow-mcp-unified/tools/automation/snow_get_script_output.ts

@@ -46,7 +46,7 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
     const client = await getAuthenticatedClient(context)
 
     // Try to find the output in sys_properties
-    // snow_schedule_script_job stores output as: SNOW_FLOW_EXEC_${executionId}
+    // snow_execute_script stores output as: SNOW_FLOW_EXEC_${executionId}
     const outputMarker = `SNOW_FLOW_EXEC_${execution_id}`
 
     const outputResponse = await client.get(
@@ -62,7 +62,7 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
         await client.delete(`/api/now/table/sys_properties/${property.sys_id}`)
       }
 
-      // Organize output by level (matches snow_schedule_script_job format)
+      // Organize output by level (matches snow_execute_script format)
       const organizedOutput = {
         print: (scriptOutput.output || []).filter((o: any) => o.level === "print").map((o: any) => o.message),
         info: (scriptOutput.output || []).filter((o: any) => o.level === "info").map((o: any) => o.message),

package/src/servicenow/servicenow-mcp-unified/tools/integration/snow_rest_message_manage.ts

@@ -27,7 +27,7 @@ export const toolDefinition: MCPToolDefinition = {
 • Message-level Headers - apply to ALL methods (list_message_headers, create_message_header, delete_message_header)
 • Method-level Headers - apply to specific method (list_method_headers, create_method_header, delete_method_header)
 • Query Parameters (list_parameters, create_parameter, delete_parameter)
-• Testing (test) - generates ES5-compatible test script for snow_schedule_script_job`,
+• Testing (test) - generates ES5-compatible test script for snow_execute_script`,
   // Metadata for tool discovery (not sent to LLM)
   category: "integration",
   subcategory: "rest",
@@ -1448,11 +1448,11 @@ ${paramLines.length > 0 ? "    " + paramLines.join("\n    ") : "    // No parame
         test_params_provided: test_params,
         test_script: testScript,
         usage: {
-          description: "Use snow_schedule_script_job to execute this test script",
-          example: `snow_schedule_script_job({ script: <test_script>, description: 'Test REST: ${restMessageName}' })`,
+          description: "Use snow_execute_script to execute this test script",
+          example: `snow_execute_script({ script: <test_script>, description: 'Test REST: ${restMessageName}' })`,
           manual_test: `In ServiceNow: System Web Services > Outbound > REST Message > ${restMessageName} > ${method.name} > Test`,
         },
-        note: "Direct REST message testing requires ServiceNow script execution. Copy the test_script and run it via snow_schedule_script_job.",
+        note: "Direct REST message testing requires ServiceNow script execution. Copy the test_script and run it via snow_execute_script.",
       },
       { operation: "test_rest_message" },
     )

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 =