ワンクリックで
ワンクリックで
| name | rp-build-v2 |
| description | Build with RepoPrompt MCP tools context builder plan → implement |
| repoprompt_managed | true |
| repoprompt_skills_version | 61 |
| repoprompt_variant | mcp |
Task: $ARGUMENTS
Build deep context via context_builder to get a plan, then implement directly. Use follow-up reasoning only when navigating the selected code proves difficult or the plan leaves a concrete gap.
context_builder with a clear prompt to get deep context + an architectural planoracle_send – Use it when navigating the selected code is difficult or the plan leaves a concrete unresolved gapWork through the phases in order:
context_builder and received its planThe quick scan is orientation only — context_builder does the deep exploration and produces the plan. Skipping it tends to produce shallow implementations that miss architectural patterns and edge cases.
Before any exploration, bind to the target codebase using its working directory:
{"tool":"bind_context","args":{"op":"bind","working_dirs":["/absolute/path/to/project"]}}
This auto-resolves to the window containing your project. No need to list windows first.
If binding succeeds → proceed to Phase 1 If no match → the codebase isn't loaded. Find and open the workspace:
{"tool":"manage_workspaces","args":{"action":"list"}}
{"tool":"manage_workspaces","args":{"action":"switch","workspace":"<workspace_name>","open_in_new_window":true}}
Then retry the working_dirs bind.
Keep this phase brief — context_builder handles the deep exploration.
Start by getting a lay of the land with the file tree:
{"tool":"get_file_tree","args":{"type":"files","mode":"auto"}}
Then use targeted searches to understand how the task maps to the codebase:
{"tool":"file_search","args":{"pattern":"<key term from task>","mode":"path"}}
{"tool":"get_code_structure","args":{"paths":["RootName/likely/relevant/area"]}}
Use what you learn to reformulate the user's prompt with added clarity—reference specific modules, patterns, or terminology from the codebase.
Your goal is orientation, not deep understanding — context_builder does the heavy lifting.
Call context_builder with your informed prompt. Use response_type: "plan" to get an actionable architectural plan.
{"tool":"context_builder","args":{
"instructions":"<reformulated prompt with codebase context>",
"response_type":"plan"
}}
What you get back:
chat_id for follow-up conversationTrust context_builder – it explores deeply, aggregates the relevant context, and selects intelligently. Default to trusting the plan it returns. The oracle_send follow-up only reasons over that selected context; it cannot fill coverage gaps on its own.
oracle_send only if neededoracle_send deep-reasons over the files selected by context_builder. It sees those selected files completely (full content, not summaries), but it only sees what's in the selection — nothing else.
This phase is optional. If the builder's plan is already clear and navigation through the selected code is straightforward, proceed straight to Phase 4.
Bring a follow-up to oracle_send only when:
If the answer depends on files outside the current selection, oracle_send cannot answer it from thin air. Do not turn this workflow into manual selection management by default — if coverage is materially wrong, prefer rerunning context_builder with a better prompt.
{"tool":"oracle_send","args":{
"chat_id":"<from context_builder>",
"message":"The plan points me to X and Y, but I'm still having trouble tracing how they connect across these selected files. What am I missing, and what edge cases should I watch for?",
"mode":"plan",
"new_chat":false
}}
oracle_send excels at:
Don't expect:
context_builder's jobBefore implementing, verify you have:
chat_id if follow-up is needed)If a specific point is still unclear, use oracle_send to clarify before proceeding.
Implement the plan directly. Don't use oracle_send with mode:"edit" — you implement directly.
Primary tools:
// Modify existing files (search/replace)
{"tool":"apply_edits","args":{"path":"Root/File.swift","search":"old","replace":"new","verbose":true}}
// Create new files (auto-added to selection)
{"tool":"file_actions","args":{"action":"create","path":"Root/NewFile.swift","content":"..."}}
// Read specific sections during implementation
{"tool":"read_file","args":{"path":"Root/File.swift","start_line":50,"limit":30}}
Ask oracle_send only when navigation or cross-file reasoning is the bottleneck:
{"tool":"oracle_send","args":{
"chat_id":"<same chat_id>",
"message":"I'm implementing X. The plan does not fully explain Y, and reading the selected files still leaves a gap. What pattern or connection am I missing here?",
"mode":"chat",
"new_chat":false
}}
Token limit: Stay under ~160k tokens. Check with manage_selection(op:"get") if unsure. Context builder manages this, but be aware if you add files.
Selection coverage:
context_builder should already have selected the files needed for the planoracle_send can reason only over that selected context; it cannot discover missing files on its owncontext_builder with a better prompt over hand-curating selectionmanage_selection only as a last resort for a very small, targeted additionoracle_send sees only the selection: If the answer depends on files outside the selection, oracle_send cannot provide it until coverage changes — and in this workflow, coverage changes should usually come from context_builder, not from manual curation.
oracle_send with mode:"edit" – implement directly with editing toolsoracle_send about files it cannot see in the current selectionmanage_selection work to patch coverage gaps that should be handled by context_buildercontext_builder and going straight to implementation – you'll miss contextmanage_selection with op:"clear" – this undoes context_builder's work; only use small targeted additions if absolutely necessarycontext_builder – a quick skim is fine; let the builder do the heavy liftingcontext_builder builds contextcontext_builder – you don'tYour job: Get a solid plan from context_builder, trust it by default, use oracle_send only when navigating the selected code proves difficult or the plan leaves a concrete unresolved gap, then implement directly and completely.
Use for Codex multi_agent_v2 subagent orchestration: delegation decisions, spawn_agent prompts, custom agent_type roles, reasoning_effort choices, safe parallelism, wait/list/send/followup/close handling, commit discipline, receipts, and root-thread coordination.
Deep planning workflow using RepoPrompt MCP tools: map seams, draft, critique, polish — produces a ready-to-execute plan document
Deep investigation with RepoPrompt MCP tools: tools gather evidence, follow-up reasoning synthesizes selected context
Iterative performance optimization loop using RepoPrompt MCP tools: instrument with debug-only metrics, establish a baseline, then plan → delegate one optimize+harden cycle → re-measure → ask oracle for next plan, looping until the oracle is satisfied or the target metric is met
Export a ChatGPT-ready Question / Plan / Review prompt using RepoPrompt MCP tools
Plan, decompose, and delegate complex tasks across multiple agents using RepoPrompt MCP tools