bunch of stuff

Author: jahooma

.agents/base2/base2.ts

@@ -35,7 +35,7 @@ const definition: SecretAgentDefinition = {
     'researcher-web',
     'researcher-docs',
     'decomposing-thinker',
-    'decomposing-planner',
+    'requirements-planner',
     'editor',
     'reviewer-max',
     'context-pruner',
@@ -74,7 +74,7 @@ Use this workflow to solve a medium or complex coding task:
 1. Spawn relevant researchers in parallel (researcher-file-explorer, researcher-web, researcher-docs)
 2. Read all the relevant files using the read_files tool.
 3. Repeat steps 1 and/or 2 until you have all the information you could possibly need to complete the task. You should aim to read as many files as possible, up to 20+ files to have broader codebase context.
-4. Spawn a decomposing planner to come up with a plan.
+4. Spawn a requirements-planner to come up with a plan.
 5. Spawn an editor to implement the plan. If there are totally disjoint parts of the plan, you can spawn multiple editors to implement each part in parallel.
 6. Spawn a reviewer to review the changes made by the editor. If more changes are needed, go back to step 5, but no more than once.
 7. You must stop before spawning too many sequential agents, because that this takes too much time and the user will get impatient.
@@ -91,7 +91,7 @@ Feel free to modify this workflow as needed. It's good to spawn different agents
 - Be careful about instructing subagents to run terminal commands that could be destructive or have effects that are hard to undo (e.g. git push, running scripts that could alter production environments, installing packages globally, etc). Don't do any of these unless the user explicitly asks you to.
 `,
 
-  stepPrompt: `Don't forget to spawn agents that could help, especially: the researcher-file-explorer to get codebase context, the decomposing-planner to craft a great plan, and the reviewer-max to review code changes made by the editor.`,
+  stepPrompt: `Don't forget to spawn agents that could help, especially: the researcher-file-explorer to get codebase context, the requirements-planner to craft a great plan, and the reviewer-max to review code changes made by the editor.`,
 
   handleSteps: function* ({ prompt, params }) {
     let steps = 0

.agents/file-explorer.ts .agents/file-explorer/file-explorer.ts.agents/file-explorer.ts renamed to .agents/file-explorer/file-explorer.ts

@@ -1,8 +1,8 @@
 import { AgentTemplateTypes } from '@codebuff/common/types/session-state'
 
-import { publisher } from './constants'
+import { publisher } from '../constants'
 
-import type { SecretAgentDefinition } from './types/secret-agent-definition'
+import type { SecretAgentDefinition } from '../types/secret-agent-definition'
 
 const paramsSchema = {
   type: 'object' as const,

.agents/file-explorer/file-picker.ts

@@ -0,0 +1,12 @@
+import { publisher } from '../constants'
+import { filePicker } from '../factory/file-picker'
+
+import type { SecretAgentDefinition } from '../types/secret-agent-definition'
+
+const definition: SecretAgentDefinition = {
+  id: 'file-picker',
+  publisher,
+  ...filePicker('google/gemini-2.5-flash'),
+}
+
+export default definition

.agents/file-explorer/inline-file-explorer.ts

@@ -0,0 +1,60 @@
+import { publisher } from '../constants'
+import type { SecretAgentDefinition } from '../types/secret-agent-definition'
+
+const paramsSchema = {
+  type: 'object' as const,
+  properties: {
+    prompts: {
+      type: 'array' as const,
+      items: { type: 'string' },
+      description:
+        'List of 1-4 different parts of the codebase that could be useful to explore',
+    },
+  },
+  required: ['prompts'],
+}
+
+const inlineFileExplorer: SecretAgentDefinition = {
+  id: 'inline-file-explorer',
+  displayName: 'Inline File Explorer',
+  spawnerPrompt:
+    'Explores the codebase by spawning file pickers and reading all found files inline',
+  model: 'anthropic/claude-sonnet-4.5',
+  publisher,
+  outputMode: 'last_message',
+  toolNames: ['spawn_agents', 'read_files'],
+  spawnableAgents: ['researcher-file-picker'],
+  inputSchema: {
+    prompt: {
+      type: 'string',
+      description: 'What you need to accomplish by exploring the codebase',
+    },
+    params: paramsSchema,
+  },
+  includeMessageHistory: true,
+  inheritParentSystemPrompt: true,
+  instructionsPrompt:
+    'Please use the read_files tool to read all the files found by the file-picker agents in a single step, except for any files that are obviously not relevant.',
+
+  handleSteps: function* ({ prompt, params }) {
+    const prompts: string[] = params?.prompts ?? []
+    const filePickerPrompts = prompts.map(
+      (focusPrompt) =>
+        `Based on the overall goal "${prompt}", find files related to this specific area: ${focusPrompt}`,
+    )
+
+    yield {
+      toolName: 'spawn_agents',
+      input: {
+        agents: filePickerPrompts.map((promptText) => ({
+          agent_type: 'researcher-file-picker',
+          prompt: promptText,
+        })),
+      },
+    }
+
+    yield 'STEP'
+  },
+}
+
+export default inlineFileExplorer

.agents/file-picker.ts

@@ -18,19 +18,15 @@ const definition: SecretAgentDefinition = {
   outputMode: 'last_message',
   includeMessageHistory: true,
   inheritParentSystemPrompt: true,
-  toolNames: ['spawn_agents', 'read_files'],
-  spawnableAgents: ['file-explorer', 'web-researcher', 'docs-researcher'],
 
-  instructionsPrompt: `You are an expert programmer, architect, researcher, and general problem solver.
-You spawn agents to help you gather information, and then describe a full change to the codebase that will accomplish the task.
+  instructionsPrompt: `You are an expert programmer, architect, and general problem solver.
+You describe a full change to the codebase that will accomplish the task.
 
 You do not have access to tools to modify files (e.g. the write_file or str_replace tools). You are describing all the code changes that should be made as a full implementation.
 
 Instructions:
-- Spawn file-explorer twice to find all the relevant parts of the codebase. Use different prompts for each file-explorer to ensure you get all the relevant parts of the codebase. In parallel as part of the same spawn_agents tool call, you may also spawn a web-researcher or docs-researcher to search the web or technical documentation for relevant information.
-- Read any relevant files that have not already been read.
 - Think about the best way to accomplish the task.
-- Finally, describe the full change to the codebase that will accomplish the task (or other steps, e.g. terminal commands to run). Use markdown code blocks to describe the changes for each file.
+- Describe the full change to the codebase that will accomplish the task (or other steps, e.g. terminal commands to run). Use markdown code blocks to describe the changes for each file.
 
 Note that you are not allowed to use tools to modify files. You are instead describing a full implementation of the changes that should be made with all the code changes using markdown code blocks.
 

.agents/planners/implementation-planner.ts

@@ -0,0 +1,63 @@
+import { publisher } from '../constants'
+import { type SecretAgentDefinition } from '../types/secret-agent-definition'
+
+const definition: SecretAgentDefinition = {
+  id: 'requirements-planner',
+  publisher,
+  model: 'anthropic/claude-sonnet-4.5',
+  displayName: 'Requirements Planner',
+  spawnerPrompt:
+    'Come up with a list of requirements for a user request, and plan how to implement them.',
+  inputSchema: {
+    prompt: {
+      type: 'string',
+      description: 'The user request to plan for',
+    },
+  },
+  outputMode: 'structured_output',
+  toolNames: ['spawn_agents', 'set_output', 'end_turn'],
+  spawnableAgents: [
+    'researcher-file-explorer',
+    'researcher-web',
+    'researcher-docs',
+    'two-wave-planner',
+  ],
+
+  includeMessageHistory: true,
+  inheritParentSystemPrompt: true,
+
+  instructionsPrompt: `You are an expert requirements planner with deep experience in software engineering, architecture, and project management.
+
+Instructions:
+1. Spawn a researcher-file-explorer agent to get more context about the codebase. Optionally, in parallel, spawn a researcher-web and/or researcher-docs agent to get context about the web and docs.
+2. Read any new files that have not already been read that could possibly be relevant to the user request or could help with planning.
+3. Analyze the user request in "<analysis>" tags. Explain the key steps and components that will be needed to accomplish the task.
+4. Come up with 2-8 explicit requirements. Try to keep the requirements disjoint, cover the whole task, and focus on the important and challenging parts of the task.
+5. Spawn a two-wave-planner agent with the requirements as input.
+6. End turn.
+`,
+
+  handleSteps: function* () {
+    const { agentState } = yield 'STEP_ALL'
+    const toolResults = agentState.messageHistory.filter(
+      (message) =>
+        message.role === 'tool' && message.content.toolName === 'spawn_agents',
+    )
+    const lastToolResult = toolResults[toolResults.length - 1]
+    const lastToolResultJson =
+      lastToolResult &&
+      lastToolResult.role === 'tool' &&
+      lastToolResult.content.output[0]?.type === 'json'
+        ? lastToolResult.content.output[0].value
+        : 'No results'
+
+    yield {
+      toolName: 'set_output',
+      input: {
+        plans: lastToolResultJson,
+      },
+    }
+  },
+}
+
+export default definition

.agents/planners/requirements-planner.ts

@@ -0,0 +1,76 @@
+import { publisher } from '../constants'
+import { type SecretAgentDefinition } from '../types/secret-agent-definition'
+
+const definition: SecretAgentDefinition = {
+  id: 'two-wave-planner',
+  publisher,
+  model: 'anthropic/claude-sonnet-4.5',
+  displayName: 'Two Wave Planner',
+  spawnerPrompt:
+    'Plans how to implement a list of requirements for a user request across two waves for deep refinement.',
+  inputSchema: {
+    params: {
+      type: 'object',
+      properties: {
+        requirements: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'A list of explicit requirements to plan for, in the order they should be implemented',
+        },
+      },
+      required: ['requirements'],
+    },
+  },
+  outputMode: 'structured_output',
+  toolNames: ['spawn_agents', 'set_output'],
+  spawnableAgents: ['implementation-planner'],
+
+  includeMessageHistory: true,
+  inheritParentSystemPrompt: true,
+
+  handleSteps: function* ({ params }) {
+    const requirements: string[] = params?.requirements ?? []
+
+    yield {
+      toolName: 'spawn_agents',
+      input: {
+        agents: requirements.map((requirement) => ({
+          agent_type: 'implementation-planner',
+          prompt: `Research and give insights and proposals for this requirement: ${requirement}`,
+        })),
+      },
+    }
+
+    const { toolResult: planResults } = yield {
+      toolName: 'spawn_agents',
+      input: {
+        agents: requirements.map((requirement, idx) => ({
+          agent_type: 'implementation-planner',
+          prompt: `Create a new plan for the following requirement: <requirement>${requirement}</requirement>
+
+You can see the previous plans for the list of requirements in the message history above, including the previous plan for this requirement. Review them to:
+- Simplify your plan based on the broader context
+- Identify overlaps or conflicts with other plans
+- Find opportunities for code reuse across requirements
+- Ensure your plan integrates well with other requirements
+- Make your plan as concise as possible! A good plan is short and sweet.`,
+        })),
+      },
+    }
+
+    const plans = planResults
+      ? planResults.map((result) =>
+          result.type === 'json' ? result.value : '',
+        )
+      : []
+
+    yield {
+      toolName: 'set_output',
+      input: {
+        plans,
+      },
+    }
+  },
+}
+
+export default definition