Initial base layer

Author: jahooma

.agents/base2/base-layer.ts

@@ -0,0 +1,119 @@
+import { publisher } from '../constants'
+import {
+  PLACEHOLDER,
+  type SecretAgentDefinition,
+} from '../types/secret-agent-definition'
+
+const definition: SecretAgentDefinition = {
+  id: 'base-layer',
+  publisher,
+  model: 'anthropic/claude-sonnet-4.5',
+  displayName: 'Orchestrator',
+  spawnerPrompt:
+    'Advanced base agent that orchestrates planning, editing, and reviewing for complex coding tasks',
+  inputSchema: {
+    prompt: {
+      type: 'string',
+      description: 'A coding task to complete',
+    },
+    params: {
+      type: 'object',
+      properties: {
+        maxContextLength: {
+          type: 'number',
+        },
+      },
+      required: [],
+    },
+  },
+  outputMode: 'last_message',
+  includeMessageHistory: true,
+  toolNames: ['spawn_agents', 'read_files'],
+  spawnableAgents: [
+    'read-only-commander',
+    'file-picker',
+    'code-searcher',
+    'researcher-web',
+    'researcher-docs',
+    'thinker',
+    'editor',
+    'reviewer',
+    'context-pruner',
+  ],
+
+  systemPrompt: `You are Buffy, a strategic coding assistant that orchestrates complex coding tasks through specialized sub-agents.
+
+# Core Mandates
+
+- **Tone:** Adopt a professional, direct, and concise tone suitable for a CLI environment.
+- **Orchestrate only:** Coordinate between agents but do not implement code yourself.
+- **Understand first, act second:** Always gather context and read relevant files BEFORE spawning code-drafters or editors.
+- **Quality over speed:** Prioritize correctness over appearing productive. Fewer, well-informed agents are better than many rushed ones.
+- **Spawn mentioned agents:** If the user uses "@AgentName" in their message, you must spawn that agent.
+- **No final summary:** When the task is complete, inform the user in one sentence.
+- **Validate assumptions:** Use researchers, file pickers, and the read_files tool to verify assumptions about libraries and APIs before implementing.
+- **Proactiveness:** Fulfill the user's request thoroughly, including reasonable, directly implied follow-up actions.
+- **Confirm Ambiguity/Expansion:** Do not take significant actions beyond the clear scope of the request without confirming with the user. If asked *how* to do something, explain first, don't just do it.
+
+${PLACEHOLDER.FILE_TREE_PROMPT_SMALL}
+${PLACEHOLDER.KNOWLEDGE_FILES_CONTENTS}
+
+# Starting Git Changes
+
+The following is the state of the git repository at the start of the conversation. Note that it is not updated to reflect any subsequent changes made by the user or the agents.
+
+${PLACEHOLDER.GIT_CHANGES_PROMPT}
+`,
+
+  instructionsPrompt: `Orchestrate the completion of the user's request using your specialized sub-agents.
+
+You spawn agents in "layers". Each layer is one spawn_agents tool call composed of multiple agents that answer your questions, do research, think, edit, and review.
+
+In between layers, you are encouraged to use the read_files tool to read files that you think are relevant to the user's request.
+
+Continue to spawn layers of agents until have completed the user's request or require more information from the user.
+
+## Example layers
+
+The user asks you to implement a new feature. You respond in multiple steps:
+
+1. Spawn a 3 file pickers with different prompts to find relevant files; spawn 1 code searcher with a few search queries; spawn 1 docs research to find relevant docs;
+1a. Read all the relevant files using the read_files tool.
+2. Spawn 2 more file pickers with different prompts to find relevant files; spawn 1 more code searcher with a few search queries; spawn a thinker with a question on a key decision; spawn a thinker to plan a tricky step.
+2a. Read all the relevant files using the read_files tool.
+4. Spawn 2 editors to implement all the changes.
+5. Spawn a reviewer to review the changes made by the editors.
+
+
+## Guidelines
+
+- **Sequence agents properly:** Keep in mind dependencies when spawning different agents: spawn a file picker or researcher before a thinker because then the thinker can use the file picker's results to come up with a better conclusions. Reviewers should be spawned after editors.
+- **Spawn editors later** Only spawn editors after gathering all the context.
+- **Stop and ask for guidance:** You should feel free to stop and ask the user for guidance if you're stuck or don't know what to try next, or need a clarification.
+- **No need to include context:** When prompting an agent, realize that many agents can already see the entire conversation history, so you can be brief in prompting them without needing to include context.
+- **Be careful about terminal commands:** 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 file-explorer to get codebase context, the thinker to think about key decisions, and the reviewer to review code changes made by the editor.`,
+
+  handleSteps: function* ({ prompt, params }) {
+    let steps = 0
+    while (true) {
+      steps++
+      // Run context-pruner before each step
+      yield {
+        toolName: 'spawn_agent_inline',
+        input: {
+          agent_type: 'context-pruner',
+          params: params ?? {},
+        },
+        includeToolCall: false,
+      } as any
+
+      const { stepsComplete } = yield 'STEP'
+      if (stepsComplete) break
+    }
+  },
+}
+
+export default definition

.agents/file-explorer/code-searcher.ts

@@ -0,0 +1,74 @@
+import { publisher } from '../constants'
+
+import type { SecretAgentDefinition } from '../types/secret-agent-definition'
+
+interface SearchQuery {
+  pattern: string
+  flags?: string
+  cwd?: string
+  maxResults?: number
+}
+
+const paramsSchema = {
+  type: 'object' as const,
+  properties: {
+    searchQueries: {
+      type: 'array' as const,
+      items: {
+        type: 'object' as const,
+        properties: {
+          pattern: { type: 'string' as const },
+          flags: { type: 'string' as const },
+          cwd: { type: 'string' as const },
+          maxResults: { type: 'number' as const },
+        },
+        required: ['pattern'],
+      },
+      description: 'Array of code search queries to execute',
+    },
+  },
+  required: ['searchQueries'],
+}
+
+const codeSearcher: SecretAgentDefinition = {
+  id: 'code-searcher',
+  displayName: 'Code Searcher',
+  spawnerPrompt:
+    'Mechanically runs multiple code search queries and returns all results',
+  model: 'anthropic/claude-sonnet-4.5',
+  publisher,
+  outputMode: 'all_messages',
+  includeMessageHistory: false,
+  toolNames: ['code_search'],
+  spawnableAgents: [],
+  inputSchema: {
+    params: paramsSchema,
+  },
+  systemPrompt:
+    'You are a code searcher agent that executes multiple code search queries and compiles the results. Your goal is to systematically search the codebase using the provided patterns and report all findings.',
+  instructionsPrompt: `
+Execute each code search query provided in the parameters and compile all results.
+
+For each search query, run the code_search tool with the specified pattern, flags, cwd, and maxResults.
+
+After all searches complete, provide a comprehensive summary of the findings, organizing results by search query.
+`.trim(),
+
+  handleSteps: function* ({ params }) {
+    const searchQueries: SearchQuery[] = params?.searchQueries ?? []
+
+    for (const query of searchQueries) {
+      yield {
+        toolName: 'code_search',
+        input: {
+          pattern: query.pattern,
+          flags: query.flags,
+          cwd: query.cwd,
+          maxResults: query.maxResults,
+        },
+      }
+    }
+  },
+}
+
+export default codeSearcher