snow-flow 10.0.76 → 10.0.78

package/package.json

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

package/src/agent/agent.ts

@@ -11,6 +11,7 @@ import { ProviderTransform } from "../provider/transform"
 import PROMPT_GENERATE from "./generate.txt"
 import PROMPT_COMPACTION from "./prompt/compaction.txt"
 import PROMPT_EXPLORE from "./prompt/explore.txt"
+import PROMPT_REVIEW from "./prompt/review.txt"
 import PROMPT_SUMMARY from "./prompt/summary.txt"
 import PROMPT_TITLE from "./prompt/title.txt"
 import { PermissionNext } from "@/permission/next"
@@ -60,6 +61,8 @@ export namespace Agent {
       question: "deny",
       plan_enter: "deny",
       plan_exit: "deny",
+      review_enter: "deny",
+      review_exit: "deny",
       // mirrors github.com/github/gitignore Node.gitignore pattern for .env files
       read: {
         "*": "allow",
@@ -80,6 +83,7 @@ export namespace Agent {
           PermissionNext.fromConfig({
             question: "allow",
             plan_enter: "allow",
+            review_enter: "allow",
           }),
           user,
         ),
@@ -109,6 +113,33 @@ export namespace Agent {
         mode: "primary",
         native: true,
       },
+      review: {
+        name: "review",
+        description: "Code reuse review mode. Analyzes ServiceNow artifacts for reuse opportunities. Enterprise only.",
+        options: {},
+        temperature: 0.3,
+        color: "#a855f7",
+        permission: PermissionNext.merge(
+          defaults,
+          PermissionNext.fromConfig({
+            "*": "deny",
+            grep: "allow",
+            glob: "allow",
+            list: "allow",
+            read: "allow",
+            bash: { "*": "deny", "git log*": "allow", "git diff*": "allow", "git status*": "allow" },
+            webfetch: "allow",
+            websearch: "allow",
+            codesearch: "allow",
+            review_exit: "allow",
+          }),
+          user,
+        ),
+        prompt: PROMPT_REVIEW,
+        mode: "primary",
+        native: true,
+        hidden: true,
+      },
       general: {
         name: "general",
         description: `General-purpose agent for researching complex questions and executing multi-step tasks. Use this agent to execute multiple units of work in parallel.`,
@@ -227,6 +258,14 @@ export namespace Agent {
       item.permission = PermissionNext.merge(item.permission, PermissionNext.fromConfig(value.permission ?? {}))
     }
 
+    // Unhide review agent for enterprise users
+    const enterpriseAuth = await Auth.all().then((all) =>
+      Object.values(all).find((e) => e.type === "enterprise" && (e.licenseKey || e.token)),
+    )
+    if (enterpriseAuth && result.review) {
+      result.review.hidden = false
+    }
+
     // Ensure Truncate.DIR is allowed unless explicitly configured
     for (const name in result) {
       const agent = result[name]

package/src/agent/prompt/review.txt

@@ -0,0 +1,99 @@
+You are the Code Reuse Reviewer Agent for Snow-Flow. Your role is to analyze ServiceNow artifacts created or modified during development activities and identify opportunities for code reuse and standardization.
+
+IMPORTANT: You are in READ-ONLY analysis mode. You cannot and should not modify any code. Your role is purely analysis and feedback.
+
+## Review Process
+
+### Step 1: Gather Activity Context
+- Read the activity details to understand what was created/modified
+- Identify the artifacts by their sys_id and type
+- Note the Update Set associated with this activity
+
+### Step 2: Analyze Created/Modified Code
+For each artifact in the activity:
+1. Use `snow_analyze_artifact` to understand its structure and dependencies
+2. Extract key functions and patterns from the code
+3. Identify GlideRecord queries and business logic
+
+### Step 3: Search for Reuse Opportunities
+1. Use `snow_find_artifact` to find existing Script Includes with similar functionality
+2. Use `snow_comprehensive_search` to search for patterns matching the implemented functionality
+3. Check for common naming conventions: *Utils, *Helper, *Service, *API
+
+### Step 4: Code Pattern Analysis
+Look for these common reuse opportunities:
+- GlideRecord utilities: Common query patterns, field value getters
+- Validation functions: Input validation, business rule conditions
+- Transformation logic: Data mapping, format conversion
+- Integration helpers: REST calls, web service wrappers
+- Date/time utilities: Duration calculations, timezone handling
+- User/group utilities: Role checks, assignment logic
+
+### Step 5: Generate Review Report
+Structure your findings as JSON:
+
+```json
+{
+  "activityId": "string",
+  "reviewStatus": "approved" | "needs_revision",
+  "summary": "Brief summary of findings",
+  "artifactsReviewed": [
+    {
+      "sys_id": "string",
+      "type": "widget|business_rule|client_script|etc",
+      "name": "artifact name"
+    }
+  ],
+  "reuseOpportunities": [
+    {
+      "type": "existing_script_include" | "duplicate_pattern" | "refactor_suggestion",
+      "severity": "high" | "medium" | "low",
+      "description": "What was found",
+      "existingArtifact": {
+        "sys_id": "optional - sys_id of existing Script Include",
+        "name": "optional - name of existing artifact"
+      },
+      "recommendation": "Specific action to take",
+      "codeLocation": "Where in the new code this applies"
+    }
+  ],
+  "approved": true | false,
+  "feedback": "If not approved, explanation for the developer"
+}
+```
+
+## Decision Criteria
+
+### Approve when:
+- No existing Script Includes provide equivalent functionality
+- Code patterns are unique to this use case
+- Minor optimizations possible but not blocking
+- Low-severity suggestions only (informational)
+
+### Request Revision when:
+- Existing Script Include provides >80% of needed functionality
+- Duplicate code detected that should be consolidated
+- High-severity code smell or anti-pattern detected
+- Business logic should be extracted to Script Include for reuse
+
+## MCP Tools Available
+
+1. **snow_analyze_artifact** - Analyze artifact structure and dependencies
+2. **snow_find_artifact** - Find existing artifacts by name/type
+3. **snow_comprehensive_search** - Deep search across all tables
+4. **snow_query_table** - Query any ServiceNow table
+
+## Important Guidelines
+
+1. READ-ONLY: You cannot modify any code. Your role is purely analysis and feedback.
+2. ES5 Awareness: ServiceNow uses ES5. If you see ES6+ syntax, flag it as a concern.
+3. Be Constructive: When requesting revision, provide specific, actionable feedback with examples.
+4. Consider Context: Not all code needs to be in Script Includes. Consider frequency of reuse, complexity, and scope.
+5. Document Reasoning: Always explain WHY you made your decision, not just WHAT you decided.
+
+## Completing Your Review
+
+After completing your review, call `review_exit` with your JSON review report.
+
+- If APPROVED: Include any low-severity suggestions as informational notes in the report.
+- If NEEDS REVISION: Provide detailed feedback explaining what needs to change. The build agent will address the feedback.

package/src/session/prompt/anthropic.txt

@@ -68,6 +68,20 @@ You are allowed to be proactive, but only when the user asks you to do something
 - Not surprising the user with actions you take without asking
 For example, if the user asks you how to approach something, you should do your best to answer their question first, and not immediately jump into taking actions.
 
+# Plan Mode
+You have access to a plan_enter tool that switches to a read-only planning agent.
+Use this tool PROACTIVELY when the user's request is complex enough to benefit from
+planning before implementation. You do NOT need to wait for the user to ask for planning.
+
+Consider using plan mode when:
+- The task involves multiple files or architectural decisions
+- You would need significant codebase exploration before implementing
+- There are multiple valid approaches and the user should weigh in
+- The task is large enough that mistakes would be costly to undo
+
+Do NOT use plan mode for simple, straightforward tasks. When in doubt, prefer planning.
+The plan_enter tool will ask the user for confirmation, so there is no risk in suggesting it.
+
 # Professional objectivity
 Prioritize technical accuracy and truthfulness over validating the user's beliefs. Focus on facts and problem-solving, providing direct, objective technical info without any unnecessary superlatives, praise, or emotional validation. It is best for the user if Claude honestly applies the same rigorous standards to all ideas and disagrees when necessary, even if it may not be what the user wants to hear. Objective guidance and respectful correction are more valuable than false agreement. Whenever there is uncertainty, it's best to investigate to find the truth first rather than instinctively confirming the user's beliefs.
 

package/src/session/prompt/review-switch.txt

@@ -0,0 +1,6 @@
+<system-reminder>
+Your operational mode has changed from review to build.
+You are no longer in read-only analysis mode.
+The code review results have been provided. Act on the review feedback.
+If approved, proceed with activity_complete. If revision needed, address the feedback.
+</system-reminder>

package/src/session/prompt.ts

@@ -19,6 +19,7 @@ import { InstructionPrompt } from "./instruction"
 import { Plugin } from "../plugin"
 import PROMPT_PLAN from "../session/prompt/plan.txt"
 import BUILD_SWITCH from "../session/prompt/build-switch.txt"
+import REVIEW_SWITCH from "../session/prompt/review-switch.txt"
 import MAX_STEPS from "../session/prompt/max-steps.txt"
 import { defer } from "../util/defer"
 import { ToolRegistry } from "../tool/registry"
@@ -1223,33 +1224,6 @@ export namespace SessionPrompt {
     const clonedUser: MessageV2.WithParts = { info: userMessage.info, parts: [...userMessage.parts] }
     const replaceUser = () => input.messages.map((m) => (m === userMessage ? clonedUser : m))
 
-    // Original logic when experimental plan mode is disabled
-    if (!Flag.OPENCODE_EXPERIMENTAL_PLAN_MODE) {
-      if (input.agent.name === "plan") {
-        clonedUser.parts.push({
-          id: Identifier.ascending("part"),
-          messageID: userMessage.info.id,
-          sessionID: userMessage.info.sessionID,
-          type: "text",
-          text: PROMPT_PLAN,
-          synthetic: true,
-        })
-      }
-      const wasPlan = input.messages.some((msg) => msg.info.role === "assistant" && msg.info.agent === "plan")
-      if (wasPlan && input.agent.name === "build") {
-        clonedUser.parts.push({
-          id: Identifier.ascending("part"),
-          messageID: userMessage.info.id,
-          sessionID: userMessage.info.sessionID,
-          type: "text",
-          text: BUILD_SWITCH,
-          synthetic: true,
-        })
-      }
-      return replaceUser()
-    }
-
-    // New plan mode logic when flag is enabled
     const assistantMessage = input.messages.findLast((msg) => msg.info.role === "assistant")
 
     // Switching from plan mode to build mode
@@ -1356,6 +1330,33 @@ NOTE: At any point in time through this workflow you should feel free to ask the
       clonedUser.parts.push(part)
       return replaceUser()
     }
+
+    // Switching from review to build
+    if (input.agent.name === "build" && assistantMessage?.info.agent === "review") {
+      clonedUser.parts.push({
+        id: Identifier.ascending("part"),
+        messageID: userMessage.info.id,
+        sessionID: userMessage.info.sessionID,
+        type: "text",
+        text: REVIEW_SWITCH,
+        synthetic: true,
+      })
+      return replaceUser()
+    }
+
+    // Entering review mode
+    if (input.agent.name === "review" && assistantMessage?.info.agent !== "review") {
+      clonedUser.parts.push({
+        id: Identifier.ascending("part"),
+        messageID: userMessage.info.id,
+        sessionID: userMessage.info.sessionID,
+        type: "text",
+        text: `<system-reminder>\nReview mode is active. You are in READ-ONLY analysis mode.\nYour role is to analyze ServiceNow artifacts for code reuse opportunities.\nUse snow_analyze_artifact, snow_find_artifact, snow_comprehensive_search, and snow_query_table.\nCall review_exit when your review is complete with a JSON review report.\n</system-reminder>`,
+        synthetic: true,
+      })
+      return replaceUser()
+    }
+
     return replaceUser()
   }
 

package/src/tool/plan-enter.txt

@@ -1,14 +1,29 @@
-Use this tool to suggest switching to plan agent when the user's request would benefit from planning before implementation.
+Use this tool proactively when you're about to start a non-trivial implementation task.
+Getting user sign-off on your approach before writing code prevents wasted effort.
+This tool asks the user if they want to switch to plan mode.
 
-If they explicitly mention wanting to create a plan ALWAYS call this tool first.
+## When to Use This Tool
 
-This tool will ask the user if they want to switch to plan agent.
+**Prefer using plan mode** for implementation tasks unless they're simple.
+Use it when ANY of these conditions apply:
 
-Call this tool when:
-- The user's request is complex and would benefit from planning first
-- You want to research and design before making changes
-- The task involves multiple files or significant architectural decisions
+1. **New Feature Implementation**: Adding meaningful new functionality
+2. **Multiple Valid Approaches**: The task can be solved in several different ways
+3. **Multi-File Changes**: The task will likely touch more than 2-3 files
+4. **Architectural Decisions**: Choosing between patterns or technologies
+5. **Unclear Requirements**: You need to explore before understanding the full scope
+6. **Significant Refactoring**: Restructuring existing code across multiple files
 
-Do NOT call this tool:
-- For simple, straightforward tasks
-- When the user explicitly wants immediate implementation
+## When NOT to Use This Tool
+
+- Single-line or few-line fixes (typos, obvious bugs, small tweaks)
+- Adding a single function with clear requirements
+- Tasks where the user has given very specific, detailed instructions
+- The user explicitly asks to skip planning
+- Simple config changes
+
+## Important
+
+- This tool REQUIRES user approval — they must consent to entering plan mode
+- If the user explicitly requests planning, ALWAYS call this tool first
+- If unsure whether to use it, err on the side of planning

package/src/tool/registry.ts

@@ -26,6 +26,7 @@ import { Log } from "@/util/log"
 import { LspTool } from "./lsp"
 import { Truncate } from "./truncation"
 import { PlanExitTool, PlanEnterTool } from "./plan"
+import { ReviewEnterTool, ReviewExitTool } from "./review"
 import { ApplyPatchTool } from "./apply_patch"
 
 export namespace ToolRegistry {
@@ -117,7 +118,7 @@ export namespace ToolRegistry {
       ApplyPatchTool,
       ...(Flag.OPENCODE_EXPERIMENTAL_LSP_TOOL ? [LspTool] : []),
       ...(config.experimental?.batch_tool === true ? [BatchTool] : []),
-      ...(Flag.OPENCODE_EXPERIMENTAL_PLAN_MODE && Flag.OPENCODE_CLIENT === "cli" ? [PlanExitTool, PlanEnterTool] : []),
+      ...(Flag.OPENCODE_CLIENT === "cli" ? [PlanExitTool, PlanEnterTool, ReviewEnterTool, ReviewExitTool] : []),
       ...custom,
     ]
   }

package/src/tool/review-enter.txt

@@ -0,0 +1,13 @@
+Use this tool to switch to the review agent for automated code reuse review of ServiceNow artifacts.
+
+Call this tool when:
+- An activity has been set to 'review' status (activity_update response contains reviewAvailable: true)
+- The user explicitly requests a code reuse review
+- Artifacts are ready to be analyzed before completion
+
+This tool will ask the user if they want to switch to the review agent.
+
+Do NOT call this tool:
+- When there are no artifacts to review
+- When the user has not requested review and activity is not in review status
+- When already in review mode

package/src/tool/review-exit.txt

@@ -0,0 +1,13 @@
+Use this tool when you have completed the code reuse review and are ready to exit review mode.
+
+This tool will ask the user if they want to switch back to the build agent.
+
+Call this tool:
+- After you have completed the code reuse analysis
+- After you have generated a JSON review report with your findings
+- When you are confident the review is thorough and complete
+
+Do NOT call this tool:
+- Before you have analyzed all artifacts in the activity
+- If you still have pending searches or analysis to complete
+- If the user has indicated they want to continue reviewing

package/src/tool/review.ts

@@ -0,0 +1,147 @@
+import z from "zod"
+import { Tool } from "./tool"
+import { Question } from "../question"
+import { Session } from "../session"
+import { MessageV2 } from "../session/message-v2"
+import { Identifier } from "../id/id"
+import { Provider } from "../provider/provider"
+import EXIT_DESCRIPTION from "./review-exit.txt"
+import ENTER_DESCRIPTION from "./review-enter.txt"
+
+async function getLastModel(sessionID: string) {
+  for await (const item of MessageV2.stream(sessionID)) {
+    if (item.info.role === "user" && item.info.model) return item.info.model
+  }
+  return Provider.defaultModel()
+}
+
+export const ReviewExitTool = Tool.define("review_exit", {
+  description: EXIT_DESCRIPTION,
+  parameters: z.object({
+    reviewResult: z.string().optional().describe("JSON review report with findings"),
+    approved: z.boolean().optional().describe("Whether the review approved the artifacts"),
+  }),
+  async execute(params, ctx) {
+    const answers = await Question.ask({
+      sessionID: ctx.sessionID,
+      questions: [
+        {
+          question: `Code reuse review is complete. Would you like to switch back to the build agent?`,
+          header: "Build Agent",
+          custom: false,
+          options: [
+            { label: "Yes", description: "Switch to build agent and act on review feedback" },
+            { label: "No", description: "Stay with review agent to continue analysis" },
+          ],
+        },
+      ],
+      tool: ctx.callID ? { messageID: ctx.messageID, callID: ctx.callID } : undefined,
+    })
+
+    const answer = answers[0]?.[0]
+    if (answer === "No") throw new Question.RejectedError()
+
+    const model = await getLastModel(ctx.sessionID)
+
+    const userMsg: MessageV2.User = {
+      id: Identifier.ascending("message"),
+      sessionID: ctx.sessionID,
+      role: "user",
+      time: {
+        created: Date.now(),
+      },
+      agent: "build",
+      model,
+    }
+    await Session.updateMessage(userMsg)
+
+    const reviewSummary = params.reviewResult
+      ? `\n\nReview result:\n${params.reviewResult}`
+      : ""
+    const approvalStatus = params.approved !== undefined
+      ? `\nApproved: ${params.approved}`
+      : ""
+
+    await Session.updatePart({
+      id: Identifier.ascending("part"),
+      messageID: userMsg.id,
+      sessionID: ctx.sessionID,
+      type: "text",
+      text: `The code reuse review has been completed.${approvalStatus}${reviewSummary}`,
+      synthetic: true,
+    } satisfies MessageV2.TextPart)
+
+    return {
+      title: "Switching to build agent",
+      output: "User approved switching to build agent. Wait for further instructions.",
+      metadata: {},
+    }
+  },
+})
+
+export const ReviewEnterTool = Tool.define("review_enter", {
+  description: ENTER_DESCRIPTION,
+  parameters: z.object({
+    activityId: z.string().optional().describe("Activity ID from the activity_update response"),
+    artifacts: z.string().optional().describe("JSON array of artifact details to review"),
+    updateSetName: z.string().optional().describe("Name of the update set being reviewed"),
+  }),
+  async execute(params, ctx) {
+    const answers = await Question.ask({
+      sessionID: ctx.sessionID,
+      questions: [
+        {
+          question: `Activity is ready for code reuse review. Would you like to switch to the review agent?`,
+          header: "Review Mode",
+          custom: false,
+          options: [
+            { label: "Yes", description: "Switch to review agent for code reuse analysis" },
+            { label: "No", description: "Stay with build agent and skip review" },
+          ],
+        },
+      ],
+      tool: ctx.callID ? { messageID: ctx.messageID, callID: ctx.callID } : undefined,
+    })
+
+    const answer = answers[0]?.[0]
+    if (answer === "No") throw new Question.RejectedError()
+
+    const model = await getLastModel(ctx.sessionID)
+
+    const userMsg: MessageV2.User = {
+      id: Identifier.ascending("message"),
+      sessionID: ctx.sessionID,
+      role: "user",
+      time: {
+        created: Date.now(),
+      },
+      agent: "review",
+      model,
+    }
+    await Session.updateMessage(userMsg)
+
+    const context = [
+      "User has requested to enter review mode. Switch to review mode and begin code reuse analysis.",
+      params.activityId ? `Activity ID: ${params.activityId}` : "",
+      params.updateSetName ? `Update Set: ${params.updateSetName}` : "",
+      params.artifacts ? `Artifacts to review:\n${params.artifacts}` : "",
+    ]
+      .filter(Boolean)
+      .join("\n")
+
+    await Session.updatePart({
+      id: Identifier.ascending("part"),
+      messageID: userMsg.id,
+      sessionID: ctx.sessionID,
+      type: "text",
+      text: context,
+      synthetic: true,
+    } satisfies MessageV2.TextPart)
+
+    return {
+      title: "Switching to review agent",
+      output: "User confirmed to switch to review mode. A new message has been created to switch you to review mode. Begin code reuse analysis.",
+      metadata: {},
+    }
+  },
+})