Generate plan max

Author: jahooma

.agents/agent-builder.ts

@@ -23,15 +23,15 @@ const researcherGrok4FastExampleContent = readFileSync(
   'utf8',
 )
 const implementationPlannerExampleContent = readFileSync(
-  join(__dirname, 'planners', 'implementation-planner.ts'),
+  join(__dirname, 'planners', 'generate-plan.ts'),
   'utf8',
 )
 const planSelectorExampleContent = readFileSync(
   join(__dirname, 'planners', 'plan-selector.ts'),
   'utf8',
 )
 const implementationPlannerMaxExampleContent = readFileSync(
-  join(__dirname, 'planners', 'implementation-planner-max.ts'),
+  join(__dirname, 'planners', 'generate-plan-max.ts'),
   'utf8',
 )
 const examplesAgentsContent = [

.agents/planners/generate-plan-max.ts

@@ -0,0 +1,121 @@
+import { publisher } from '../constants'
+import { type SecretAgentDefinition } from '../types/secret-agent-definition'
+
+const definition: SecretAgentDefinition = {
+  id: 'generate-plan-max',
+  publisher,
+  model: 'anthropic/claude-sonnet-4.5',
+  displayName: 'Maximum Plan Generator',
+  spawnerPrompt:
+    'Generates 5 independent planning iterations, then selects the absolute best plan from all variations.',
+  inputSchema: {},
+  outputMode: 'structured_output',
+  outputSchema: {
+    type: 'object',
+    properties: {
+      plan: {
+        type: 'string',
+        description: 'The best plan selected from all variations',
+      },
+    },
+    required: ['plan'],
+  },
+  toolNames: ['spawn_agents', 'set_output'],
+  spawnableAgents: ['generate-plan', 'plan-selector'],
+
+  includeMessageHistory: true,
+  inheritParentSystemPrompt: true,
+
+  handleSteps: function* ({ logger }) {
+    // Step 1: Spawn 5 generate-plan agents in parallel
+    const { toolResult: planResults } = yield {
+      toolName: 'spawn_agents',
+      input: {
+        agents: Array.from({ length: 5 }, () => ({
+          agent_type: 'generate-plan',
+        })),
+      },
+    }
+
+    if (!Array.isArray(planResults)) {
+      yield {
+        toolName: 'set_output',
+        input: { plan: 'Failed to generate plans.' },
+      }
+      return
+    }
+
+    const plannerResult = planResults[0]
+    const plans =
+      plannerResult.type === 'json'
+        ? (plannerResult.value as { plan?: string }[])
+        : []
+
+    logger.info({ plans }, 'plans')
+
+    // Extract all the plans from the structured outputs
+    const letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+    const plansWithIds = plans.map((plan, idx) => {
+      return {
+        id: letters[idx],
+        plan: JSON.stringify(plan),
+      }
+    })
+
+    logger.info({ plansWithIds }, 'plansWithIds')
+
+    if (plansWithIds.length === 0) {
+      yield {
+        toolName: 'set_output',
+        input: { plan: 'No valid plans were generated.' },
+      }
+      return
+    }
+
+    // Step 2: Spawn plan-selector to choose the best plan
+    const { toolResult: selectedPlanResult } = yield {
+      toolName: 'spawn_agents',
+      input: {
+        agents: [
+          {
+            agent_type: 'plan-selector',
+            prompt: 'Choose the best plan from these options',
+            params: {
+              plans: plansWithIds,
+            },
+          },
+        ],
+      },
+    }
+
+    logger.info({ selectedPlanResult }, 'selectedPlanResult')
+
+    if (!Array.isArray(selectedPlanResult) || selectedPlanResult.length < 1) {
+      yield {
+        toolName: 'set_output',
+        input: { plan: 'Failed to select a plan.' },
+      }
+      return
+    }
+
+    const selectedPlan = selectedPlanResult[0]
+    const selectedPlanId =
+      selectedPlan.type === 'json' && selectedPlan.value
+        ? (selectedPlan.value as { selectedPlanId: string }).selectedPlanId
+        : null
+
+    const selectedPlanWithId = plansWithIds.find(
+      (plan) => plan.id === selectedPlanId,
+    )
+
+    // Step 3: Set the selected plan as output
+    yield {
+      toolName: 'set_output',
+      input: {
+        plan: selectedPlanWithId?.plan ?? plansWithIds[0].plan,
+      },
+    }
+  },
+}
+
+export default definition

.agents/planners/plan-selector.ts

@@ -10,8 +10,8 @@ const definition: SecretAgentDefinition = {
   model: 'anthropic/claude-sonnet-4.5',
   displayName: 'Plan Selector',
   spawnerPrompt:
-    'Expert at evaluating and selecting the best plan from multiple options based on quality, feasibility, and simplicity.',
-  toolNames: ['read_files', 'set_output'],
+    'Expert at evaluating and selecting the best high-level plan from multiple generate-plan outputs based on simplicity and correctness.',
+  toolNames: ['set_output'],
   spawnableAgents: [],
   inputSchema: {
     prompt: {
@@ -42,44 +42,44 @@ const definition: SecretAgentDefinition = {
       reasoning: {
         type: 'string',
         description:
-          "Thoughts on each plan and what's better or worse about each plan, leading up to which plan is the best choice.",
+          'Analysis of each plan and reasoning for which is the best choice',
       },
       selectedPlanId: {
         type: 'string',
-        description: 'The ID of the chosen plan.',
+        description: 'The ID of the chosen plan',
       },
     },
     required: ['reasoning', 'selectedPlanId'],
   },
+  inheritParentSystemPrompt: true,
   includeMessageHistory: true,
-  systemPrompt: `You are an expert plan evaluator with deep experience in software engineering, architecture, and project management.
+  instructionsPrompt: `For reference, here is the original user request:
+<user_message>
+${PLACEHOLDER.USER_INPUT_PROMPT}
+</user_message>
 
-We're interested in the simplest solution that will accomplish the task correctly! You got this!
+You are evaluating multiple high-level plans generated by the generate-plan agent. Each plan has already been carefully crafted (generate-plan creates 5 alternatives internally and picks the best), so your job is to select the absolute best among these already-good plans.
 
-${PLACEHOLDER.KNOWLEDGE_FILES_CONTENTS}`,
+Analyze each plan based on:
 
-  instructionsPrompt: `Analyze all the provided implementations and select the best one based on:
+1. **Simplicity** - Which plan is the cleanest and most straightforward? Avoid over-engineering.
+2. **Correctness** - Which plan most accurately addresses all user requirements without adding unnecessary features?
+3. **Minimal scope** - Which plan touches the fewest files and has the least complexity?
+4. **Clarity** - Which plan is easiest to understand and follow?
+5. **Maintainability** - Which approach will be easiest to maintain and extend?
+6. **Best practices** - Which plan best follows existing codebase patterns?
+7. **User intent** - Which plan best addresses the user's intent and would surprise them the least?
 
-1. **Simplicity** - How clean and easy to understand is the implementation? Is the code overcomplicated or over-engineered?
-2. **Correctness** - Does the implementation correctly address the requirements?
-3. **Quality** - How well does it work? How clear is the implementation?
-4. **Efficiency** - How minimal and focused are the changes? Were more files changed than necessary? Is the code verbose?
-5. **Maintainability** - How well will this approach work long-term?
-6. **Does what the user expects** - Make sure the implementation addresses all the requirements in the user's request, and does not do other stuff that the user did not ask for.
+Key principles:
+- Satisfying the user expectations is important
+- Simpler is better - we want the most straightforward solution that works
+- Fewer file changes is better
+- Reusing existing code is better than writing new code
+- Matching existing patterns and conventions is important
 
-More on **Simplicity**:
-- We don't want an over-engineered solution.
-- We're not interested in endless safety and correctness checks.
-- Modifying fewer files is better.
-- Reusing existing code is better than writing new code.
-- It's good to match existing patterns and conventions in the codebase, including naming conventions, code style, and architecture.
-
-For each implementation, evaluate:
-- Strengths and weaknesses
-- Implementation complexity
-- Alignment with the original task
-
-Use the set_output tool to return your selection.`,
+For each plan, briefly evaluate strengths and weaknesses. Then use set_output to return your selection with:
+- reasoning: Your analysis and why you chose the winner
+- selectedPlanId: The ID of the best plan`,
 }
 
 export default definition