Improve delegate (#377)

* Improve delegate

* fix stale log regexes in delegate tests and add test-coupling comments

Co-authored-by: Cursor <cursoragent@cursor.com>

---------

Co-authored-by: Cursor <cursoragent@cursor.com>

mcp/askQuestion.ts

@@ -3,7 +3,7 @@ import { ghPullfrogMcpName } from "../external.ts";
 import { log } from "../utils/cli.ts";
 import type { ToolContext } from "./server.ts";
 import { execute, tool } from "./shared.ts";
-import { createSubagentState, runSubagent } from "./subagent.ts";
+import { createSubagentState, hasRunningSubagents, runSubagent } from "./subagent.ts";
 
 export const AskQuestionParams = type({
   question: type.string.describe(
@@ -12,9 +12,9 @@ export const AskQuestionParams = type({
 });
 
 function buildQuestionPrompt(question: string): string {
-  return `You are a focused research subagent. Answer the following question by exploring the codebase using the available MCP tools (${ghPullfrogMcpName}/file_read, ${ghPullfrogMcpName}/list_directory, etc.).
+  return `Answer the following question by exploring the codebase using the available MCP tools (${ghPullfrogMcpName}/file_read, ${ghPullfrogMcpName}/list_directory, etc.).
 
-Be thorough in your investigation but concise in your answer. When done, call ${ghPullfrogMcpName}/set_output with a maximally concise answer — key facts only, no filler, no preamble.
+Be thorough in your investigation but concise in your answer. Key facts only, no filler, no preamble.
 
 Question: ${question}`;
 }
@@ -26,12 +26,18 @@ export function AskQuestionTool(ctx: ToolContext) {
       "Ask a question about the codebase and get a concise answer from a lightweight research subagent. The intermediate exploration context stays in the subagent — only the concise answer returns to you.",
     parameters: AskQuestionParams,
     execute: execute(async (params) => {
-      if (ctx.toolState.activeSubagentId) {
-        return { error: "cannot ask questions while a subagent is already running" };
+      if (hasRunningSubagents(ctx)) {
+        return { error: "cannot ask questions while subagents are running" };
       }
 
-      const subagent = createSubagentState({ ctx, mode: "ask_question" });
-      log.info(`» ask_question subagent=${subagent.id}: ${params.question.slice(0, 100)}`);
+      const label = `ask-${params.question
+        .slice(0, 40)
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-|-$/g, "")}`;
+      const subagent = createSubagentState({ ctx, mode: "ask_question", label });
+      // matched by delegateAskQuestion test validator — update tests if changed
+      log.info(`» ask_question "${label}": ${params.question.slice(0, 100)}`);
 
       const result = await runSubagent({
         ctx,

mcp/delegate.ts

@@ -1,60 +1,115 @@
 import { type } from "arktype";
 import { Effort } from "../external.ts";
 import { log } from "../utils/cli.ts";
-import type { ToolContext } from "./server.ts";
+import type { SubagentState, ToolContext } from "./server.ts";
 import { execute, tool } from "./shared.ts";
-import { createSubagentState, runSubagent } from "./subagent.ts";
+import { createSubagentState, hasRunningSubagents, runSubagent } from "./subagent.ts";
 
-export const DelegateParams = type({
+const DelegateTask = type({
+  label: type.string.describe(
+    "short label identifying this task (e.g. 'frontend-review', 'schema-check'). returned in results for easy matching."
+  ),
   instructions: type.string.describe(
-    "the complete prompt for the subagent. the subagent receives ONLY this text — include all context it needs (file paths, constraints, conventions, tool usage instructions). craft a focused, self-contained task description."
+    "the complete prompt for the subagent. the subagent receives ONLY this text (plus a system preamble) — include all context it needs (file paths, constraints, conventions, tool usage instructions). specify exactly what information to return. craft a focused, self-contained task description."
   ),
   "effort?": Effort.describe(
-    'effort level for the subagent: "mini" (low-effort and fast, only for simple tasks), "auto" (medium-effort, good for typical tasks that don\'t require significant reasoning), or "max" (high-effort, good for PR reviews and complex coding tasks)'
+    'effort level for the subagent: "mini" (low-effort and fast, only for simple tasks), "auto" (medium-effort, good for typical tasks that don\'t require significant reasoning), or "max" (high-effort, good for PR reviews and complex coding tasks). defaults to "auto".'
   ),
 });
 
+export const DelegateParams = type({
+  tasks: DelegateTask.array()
+    .atLeastLength(1)
+    .describe(
+      "array of tasks to delegate. all tasks run as parallel subagents and results are returned together."
+    ),
+});
+
+type DelegateTaskResult = {
+  label: string;
+  success: boolean;
+  effort: string;
+  summary: string;
+  stdoutFile: string;
+  error: string | undefined;
+};
+
+function buildTaskResult(
+  label: string,
+  effort: string,
+  subagent: SubagentState,
+  error: string | undefined
+): DelegateTaskResult {
+  return {
+    label,
+    success: subagent.status === "completed",
+    effort,
+    summary:
+      subagent.output ??
+      error ??
+      "no output produced — the subagent may not have called set_output. check stdoutFile for full logs.",
+    stdoutFile: subagent.stdoutFilePath,
+    error,
+  };
+}
+
 export function DelegateTool(ctx: ToolContext) {
   return tool({
     name: "delegate",
     description:
-      "Delegate a task to a subagent. The subagent receives ONLY the instructions you provide — no other context is added. Use select_mode first to get guidance on how to craft the instructions for a given mode. Subagents have access to file operations, local git, bash, commenting, and review tools. They do NOT have push_branch, create_pull_request, update_pull_request_body, delete_branch, push_tags, delegate, ask_question, or select_mode — remote-mutating operations are your responsibility as orchestrator.",
+      "Delegate research, local coding tasks, and codebase investigations to subagents. Accepts an array of tasks that run in parallel — use this to fan out work (e.g. reviewing different areas of a PR simultaneously). Each subagent receives ONLY the instructions you provide (plus a system preamble enforcing set_output). Use select_mode first to get guidance on how to craft instructions. Subagents have file operations, bash, read-only GitHub tools (PR/issue info, review comments, check suite logs), and upload_file. They have NO git/checkout tools (would conflict between parallel subagents), NO dependency tools, and NO GitHub-write tools (commenting, reviews, labels, issues). All state-mutating and user-facing operations are your responsibility as orchestrator.",
     parameters: DelegateParams,
     execute: execute(async (params) => {
-      if (ctx.toolState.activeSubagentId) {
+      if (ctx.toolState.selfSubagentId) {
         return {
           error:
             "delegation is not available inside a subagent. you are already running as a delegated subagent. complete the task directly using the available tools.",
         };
       }
 
-      const effort = params.effort ?? "auto";
+      if (hasRunningSubagents(ctx)) {
+        return { error: "delegation is already in progress" };
+      }
+
       const mode = ctx.toolState.selectedMode ?? "unknown";
       if (!ctx.toolState.selectedMode) {
         log.info(`» warning: delegating without calling select_mode first (mode=${mode})`);
       }
-      const subagent = createSubagentState({ ctx, mode });
 
-      log.info(`» delegating subagent=${subagent.id} (mode=${mode}, effort=${effort})`);
-      const result = await runSubagent({
-        ctx,
-        subagent,
-        effort,
-        instructions: params.instructions,
+      // matched by delegate test validators — update tests if changed
+      log.info(`» delegating ${params.tasks.length} task(s) in parallel (mode=${mode})`);
+
+      const taskEntries = params.tasks.map((task) => {
+        const effort = task.effort ?? "auto";
+        const subagent = createSubagentState({ ctx, mode, label: task.label });
+        log.info(`» task "${task.label}" (effort=${effort})`);
+        return { task, effort, subagent };
       });
-      log.info(`» delegation completed (mode=${mode}, success=${result.success})`);
 
-      return {
-        success: result.success,
-        mode,
-        effort,
-        summary:
-          subagent.output ??
-          result.error ??
-          "no output produced — the subagent may not have called set_output. check stdoutFile for full logs.",
-        stdoutFile: subagent.stdoutFilePath,
-        error: result.error,
-      };
+      const settled = await Promise.allSettled(
+        taskEntries.map((entry) =>
+          runSubagent({
+            ctx,
+            subagent: entry.subagent,
+            effort: entry.effort,
+            instructions: entry.task.instructions,
+          })
+        )
+      );
+
+      const results: DelegateTaskResult[] = taskEntries.map((entry, i) => {
+        const outcome = settled[i];
+        const error = outcome.status === "rejected" ? String(outcome.reason) : outcome.value.error;
+        log.debug(
+          `» task "${entry.task.label}" result: output=${entry.subagent.output !== undefined}, status=${entry.subagent.status}`
+        );
+        return buildTaskResult(entry.task.label, entry.effort, entry.subagent, error);
+      });
+
+      const succeeded = results.filter((r) => r.success).length;
+      log.info(`» delegation completed: ${succeeded}/${results.length} succeeded (mode=${mode})`);
+
+      return { mode, results };
     }),
   });
 }

mcp/file.ts

@@ -7,7 +7,7 @@ import {
   unlinkSync,
   writeFileSync,
 } from "node:fs";
-import { dirname, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { type } from "arktype";
 import type { ShellPermission } from "../external.ts";
 import type { ToolContext } from "./server.ts";
@@ -59,6 +59,15 @@ function resolveReadPath(filePath: string): string {
     return resolved;
   }
 
+  // allow reads from Cursor's project directory (internal agent coordination files)
+  const home = process.env.HOME;
+  if (home) {
+    const cursorProjectsDir = join(home, ".cursor", "projects");
+    if (resolved.startsWith(cursorProjectsDir + "/")) {
+      return resolved;
+    }
+  }
+
   // allow reads from the repo with symlink protection.
   // threat model: a malicious PR plants symlinks (e.g. `secrets -> /etc/shadow`).
   // git materializes symlinks on linux, so after checkout the working tree contains

mcp/output.ts

@@ -14,15 +14,18 @@ export function SetOutputTool(ctx: ToolContext) {
       "Set the action output. When called by a subagent, returns a summary result to the orchestrator. When called in standalone mode, exposes the value as the 'result' GitHub Action output.",
     parameters: SetOutputParams,
     execute: execute(async (params) => {
-      const activeId = ctx.toolState.activeSubagentId;
-      if (activeId) {
-        const subagent = ctx.toolState.subagents.get(activeId);
+      const selfId = ctx.toolState.selfSubagentId;
+      if (selfId) {
+        const subagent = ctx.toolState.subagents.get(selfId);
         if (subagent) {
           subagent.output = params.value;
+          log.debug(
+            `set_output: routed to subagent ${selfId} (value=${params.value.slice(0, 80)})`
+          );
           return { success: true, routed: "subagent" };
         }
         log.warning(
-          `set_output: activeSubagentId=${activeId} but subagent not found in map — routing to action output`
+          `set_output: selfSubagentId=${selfId} but subagent not found in map — routing to action output`
         );
       }
       ctx.toolState.output = params.value;

mcp/selectMode.ts

@@ -6,7 +6,7 @@ import { execute, tool } from "./shared.ts";
 
 export const SelectModeParams = type({
   mode: type.string.describe(
-    "the name of the mode to select (e.g., 'Build', 'Plan', 'Review', 'Fix', 'AddressReviews', 'Prompt')"
+    "the name of the mode to select (e.g., 'Build', 'Plan', 'Review', 'Fix', 'AddressReviews', 'Task')"
   ),
 });
 
@@ -15,7 +15,7 @@ function resolveMode(modes: Mode[], modeName: string): Mode | null {
 }
 
 function defaultGuidance(mode: Mode): string {
-  return `Delegate a single subagent for this "${mode.name}" task. Craft a self-contained prompt that includes all context the subagent needs. Include \`${ghPullfrogMcpName}/report_progress\` for user-facing updates and \`${ghPullfrogMcpName}/set_output\` to return results back to you. Subagents do NOT have push or PR creation tools — if the task involves code changes, you must push and create the PR yourself after the subagent completes.`;
+  return `Delegate a subagent for this "${mode.name}" task via the \`tasks\` array. Craft a self-contained prompt that includes all context the subagent needs. Subagents have file ops, bash, and read-only GitHub tools — but NO git/checkout, dependency, GitHub-write, or remote-mutating tools. All state-mutating and user-facing operations are your responsibility as orchestrator.`;
 }
 
 const modeGuidance: Record<string, string> = {
@@ -23,58 +23,77 @@ const modeGuidance: Record<string, string> = {
 
 1. **plan phase** (optional, for complex tasks): delegate a subagent to analyze the requirements, read AGENTS.md and relevant code, and produce a step-by-step implementation plan. Include \`${ghPullfrogMcpName}/set_output\` with the plan so it returns to you. Use mini or auto effort. You can also use \`ask_question\` for codebase questions/investigations.
 
-2. **build phase**: delegate a subagent with the implementation task. Include in its prompt:
+2. **setup** (your responsibility as orchestrator): before the build phase, checkout or create the branch:
+   - **PR event, modifying the existing PR**: call \`${ghPullfrogMcpName}/checkout_pr\`
+   - **new branch**: use \`${ghPullfrogMcpName}/git\` to create a branch (\`git checkout -b pullfrog/branch-name\`)
+   Subagents have no git/checkout tools — the working tree must be ready before delegation.
+
+3. **build phase**: delegate a subagent with the implementation task. Include in its prompt:
    - the plan (if you ran a plan phase)
    - specific files to modify and why
-   - branch naming: \`pullfrog/<issue-number>-<description>\`
    - instruct the subagent to plan its approach before writing code: identify which files need to change, key design decisions, and edge cases. for non-trivial changes, consider whether there's a more elegant approach before committing to implementation.
    - testing expectations: run relevant tests/lints before committing
    - pre-commit quality check: instruct the subagent to review its own diff before committing — verify only intended changes are present, no debug artifacts or commented-out code remain, and no unrelated files were modified. the change should be clean enough that a senior engineer would approve it without hesitation. for non-trivial changes, ask whether there's a simpler way to achieve the same result.
-   - for multi-file changes, call \`${ghPullfrogMcpName}/report_progress\` with a summary of progress before the final commit
-   - commit changes locally (do NOT instruct to push or create a PR — subagents cannot do that)
+   - commit locally via bash (\`git add . && git commit -m "..."\`)
    - call \`${ghPullfrogMcpName}/set_output\` with a concise summary including the branch name (this is how results get back to you)
 
-3. **review phase** (optional, for non-trivial changes): before pushing, delegate a review subagent to check the pending diff. Use \`ask_question\` for quick spot-checks, or delegate a full Review subagent for high-stakes changes. This catches issues before they're public.
+4. **review phase** (optional, for non-trivial changes): before pushing, delegate a review subagent to check the pending diff. Use \`ask_question\` for quick spot-checks, or delegate a full Review subagent for high-stakes changes. This catches issues before they're public.
 
-4. **finalize** (your responsibility as orchestrator): after the build (and optional review) completes:
+5. **finalize** (your responsibility as orchestrator): after the build (and optional review) completes:
    - push the branch via \`${ghPullfrogMcpName}/push_branch\`
    - create a PR via \`${ghPullfrogMcpName}/create_pull_request\`
    - call \`${ghPullfrogMcpName}/report_progress\` with the final summary including PR link
 
 For simple, well-defined tasks, a single build subagent is sufficient — skip the plan and review phases.
 
-Your subagent receives ONLY what you write. Include file paths, constraints, conventions, and any context from AGENTS.md or the codebase directly in the prompt. Subagents do NOT have push_branch, create_pull_request, or other remote-mutating tools.`,
+Your subagent receives ONLY what you write. Include file paths, constraints, conventions, and any context from AGENTS.md or the codebase directly in the prompt. Subagents have file ops, bash, and read-only GitHub tools — but NO git/checkout, dependency, GitHub-write, or remote-mutating tools.`,
 
-  AddressReviews: `Delegate a single subagent to address PR review feedback:
+  AddressReviews: `Delegate a single subagent to address PR review feedback.
+
+Before delegating, checkout the PR branch yourself via \`${ghPullfrogMcpName}/checkout_pr\` — subagents have no git/checkout tools.
 
 Include in its prompt:
-- the PR number to checkout via \`${ghPullfrogMcpName}/checkout_pr\`
-- instruct it to fetch review comments via \`${ghPullfrogMcpName}/get_review_comments\`
-- reply to EACH comment individually via \`${ghPullfrogMcpName}/reply_to_review_comment\`
-- resolve threads via \`${ghPullfrogMcpName}/resolve_review_thread\` after addressing them
+- instruct it to fetch review comments via \`${ghPullfrogMcpName}/get_review_comments\` (subagents have read-only GitHub tools)
+- for each comment: understand the feedback, make the code change, and record what was done
 - test changes, then review the diff before committing — verify only intended changes are present, no debug artifacts remain, and the changes are clean enough that a senior engineer would approve without hesitation
-- commit locally (do NOT instruct to push — subagents cannot do that)
-- call \`${ghPullfrogMcpName}/report_progress\` with a brief summary
-- call \`${ghPullfrogMcpName}/set_output\` with a concise summary of what was addressed (this is how results get back to you)
+- commit locally via bash (\`git add . && git commit -m "..."\`)
+- call \`${ghPullfrogMcpName}/set_output\` with a JSON object: \`{ "summary": "...", "replies": [{ "comment_id": 123, "thread_id": "...", "reply": "Fixed by ..." }, ...] }\` — this is how results get back to you
 
-After the subagent completes, push the changes via \`${ghPullfrogMcpName}/push_branch\`.
+After the subagent completes:
+- push changes via \`${ghPullfrogMcpName}/push_branch\`
+- reply to each comment using \`${ghPullfrogMcpName}/reply_to_review_comment\` with the subagent's suggested replies
+- resolve addressed threads via \`${ghPullfrogMcpName}/resolve_review_thread\`
+- call \`${ghPullfrogMcpName}/report_progress\` with a brief summary
 
 Use auto or max effort depending on review complexity.`,
 
-  Review: `Before delegating, use \`ask_question\` to understand unfamiliar parts of the codebase the PR touches. This gives you context to craft a more focused review prompt (e.g., "pay special attention to how X interacts with Y"). For complex or high-stakes PRs, consider a two-phase approach: delegate a Plan subagent to analyze the PR and identify high-risk areas, then delegate a Review subagent with those focus areas as instructions.
+  Review: `For reviews, delegate multiple focused subagents in parallel — each investigating a different area or aspect of the PR.
 
-Delegate a review subagent with:
+### Approach
 
-Include in its prompt:
-- the PR number to checkout via \`${ghPullfrogMcpName}/checkout_pr\`
-- what aspects to focus on (if any specific concerns exist, or high-risk areas you identified)
-- instruct it to plan its investigation before diving in: after reading the diff, identify the highest-risk areas (tricky state transitions, boundary crossings, assumption chains) and prioritize depth over breadth
-- instruct it to read the diff, trace data flow, check boundaries, and verify assumptions
+1. Checkout the PR via \`${ghPullfrogMcpName}/checkout_pr\` — this returns PR metadata and a \`diffPath\`. Read the diff to identify the major areas of change.
+2. Delegate multiple subagents in a single \`${ghPullfrogMcpName}/delegate\` call, each focused on a specific area. For example, a PR touching action/, components/, and prisma/ might get three subagents: "action-review", "frontend-review", "schema-review".
+3. After all subagents return, consolidate their findings into a single review.
+
+### Crafting each task
+
+Each task in the \`tasks\` array should include:
+- the diff file path so the subagent can read it
+- what specific area/aspect to focus on (e.g., "review the database migration and schema changes in prisma/")
+- instruct it to read the diff, trace data flow, check boundaries, and verify assumptions within its area. subagents have read-only GitHub tools (\`${ghPullfrogMcpName}/get_pull_request\`, etc.) for fetching additional context.
+- instruct it to plan its investigation before diving in: identify the highest-risk areas (tricky state transitions, boundary crossings, assumption chains) and prioritize depth over breadth
 - draft inline comments with NEW line numbers from the diff — every comment must be actionable (2-3 sentences max)
-- after drafting, instruct it to critique its own comments: drop any that are praise, style preferences, speculative/unverified claims, about pre-existing code unrelated to the PR, or not actionable. if no comments survive, do not submit a review — use \`report_progress\` instead.
-- submit surviving comments via \`${ghPullfrogMcpName}/create_pull_request_review\`
+- after drafting, instruct it to critique its own comments: drop any that are praise, style preferences, speculative/unverified claims, about pre-existing code unrelated to the PR, or not actionable
 - use GitHub permalink format for code references
-- call \`${ghPullfrogMcpName}/set_output\` with a concise review summary (this is how results get back to you)
+- call \`${ghPullfrogMcpName}/set_output\` with a JSON object: \`{ "summary": "...", "comments": [{ "path": "file.ts", "line": 42, "body": "..." }, ...] }\` — this is how findings get back to you
+
+### Post-delegation
+
+After all tasks complete, consolidate into a **single** review:
+- merge the \`comments\` arrays from all subagent outputs
+- submit one \`${ghPullfrogMcpName}/create_pull_request_review\` with the merged comments and a unified summary body
+- call \`${ghPullfrogMcpName}/report_progress\` with the summary
+- if no subagent found actionable issues, skip the review — just call \`report_progress\` noting the PR was reviewed
 
 Use max effort for thorough reviews.`,
 
@@ -84,40 +103,54 @@ Include in its prompt:
 - the task to plan for
 - relevant codebase context (file paths, architecture notes from AGENTS.md)
 - instruct it to produce a structured, actionable plan with clear milestones
-- call \`${ghPullfrogMcpName}/report_progress\` with the plan
 - call \`${ghPullfrogMcpName}/set_output\` with the plan (this is how results get back to you — you'll need the plan to craft the next subagent's prompt)
 
+After the subagent completes, call \`${ghPullfrogMcpName}/report_progress\` with the plan.
+
 Use mini or auto effort. After receiving the plan, you may delegate a Build subagent to implement it.`,
 
-  Fix: `For CI fix tasks, consider a focused single-phase approach:
+  Fix: `For CI fix tasks, consider a focused single-phase approach.
+
+Before delegating, checkout the PR branch yourself via \`${ghPullfrogMcpName}/checkout_pr\` — subagents have no git/checkout tools.
 
 Delegate a single fix subagent with:
-- the check_suite_id to fetch logs via \`${ghPullfrogMcpName}/get_check_suite_logs\`
-- the PR number to checkout via \`${ghPullfrogMcpName}/checkout_pr\`
+- the check_suite_id to fetch logs via \`${ghPullfrogMcpName}/get_check_suite_logs\` (subagents have read-only GitHub tools)
+- the PR diff file path (from checkout_pr result) so it can understand what the PR changed
 - CRITICAL: instruct it to verify the failure was INTRODUCED BY THIS PR before fixing. If unrelated, abort and report.
 - instruct it to read the workflow file, reproduce locally with the EXACT same commands CI runs
-- after analyzing the failure, call \`${ghPullfrogMcpName}/report_progress\` with the diagnosis: what failed, why, and the planned fix — this gives the PR author visibility before code changes begin
 - fix the issue, then verify the fix by re-running the exact CI command
 - pre-commit quality check: review the diff before committing — verify only the fix is present, no debug artifacts, no unrelated changes. the fix should be clean enough that a senior engineer would approve it without hesitation.
-- commit locally (do NOT instruct to push — subagents cannot do that)
-- call \`${ghPullfrogMcpName}/set_output\` with a concise summary of the fix (this is how results get back to you)
+- commit locally via bash (\`git add . && git commit -m "..."\`)
+- call \`${ghPullfrogMcpName}/set_output\` with a concise summary: what failed, why, and the fix applied (this is how results get back to you)
 
-After the subagent completes, push the changes via \`${ghPullfrogMcpName}/push_branch\`.
+After the subagent completes:
+- push changes via \`${ghPullfrogMcpName}/push_branch\`
+- call \`${ghPullfrogMcpName}/report_progress\` with the diagnosis and fix summary
 
 Use auto effort.`,
 
-  Prompt: `Delegate a single subagent for this general-purpose task:
+  Task: `Handle this general-purpose task. For simple operations (labeling, commenting, answering questions, running a single command), you can often handle it directly without delegation.
 
-Include in its prompt:
-- the full task description with all relevant context
+When the task involves **substantial work** — code changes across multiple files, multi-step investigations, or tasks that benefit from focused context — use \`delegate\` and \`ask_question\` liberally:
+
+- \`ask_question\`: quick codebase research, finding files, understanding architecture. Use freely — multiple calls in sequence is fine.
+- \`delegate\`: research, local coding tasks, and codebase investigations. Each subagent gets dedicated context, so break complex work into focused subtasks and delegate each one. For independent subtasks, batch them in a single \`${ghPullfrogMcpName}/delegate\` call to run in parallel.
+
+### When delegating
+
+Include in each task's prompt:
+- the full subtask description with all relevant context
+- exactly what information to return. the subagent's output is your only way to get results back — be precise about what you need.
 - if code changes are needed: branch naming, testing, commit instructions (do NOT instruct to push or create PR)
 - if code changes are needed: instruct it to review its own diff before committing — verify only intended changes are present, no debug artifacts remain, and the changes are clean enough that a senior engineer would approve without hesitation
+
+### Post-delegation
+
 - call \`${ghPullfrogMcpName}/report_progress\` with results
-- call \`${ghPullfrogMcpName}/set_output\` with a concise summary (this is how results get back to you)
+- if the task involved code changes, push via \`${ghPullfrogMcpName}/push_branch\` and create a PR via \`${ghPullfrogMcpName}/create_pull_request\`
+- if the task involved labeling, commenting, or other GitHub operations, perform those directly
 
-If the task involved code changes, push via \`${ghPullfrogMcpName}/push_branch\` and create a PR via \`${ghPullfrogMcpName}/create_pull_request\` after the subagent completes.
-
-Use mini effort for simple tasks (labeling, commenting), auto for typical tasks.`,
+Use mini effort for simple research tasks, auto for typical tasks, max for complex multi-file changes.`,
 };
 
 type OrchestratorGuidance = {

mcp/server.ts

@@ -25,6 +25,7 @@ export type SubagentStatus = "running" | "completed" | "failed";
 
 export type SubagentState = {
   id: string;
+  label: string;
   status: SubagentStatus;
   mode: string;
   stdoutFilePath: string;
@@ -46,8 +47,9 @@ export interface ToolState {
   selectedMode?: string;
   // per-subagent lifecycle tracking (keyed by subagent uuid)
   subagents: Map<string, SubagentState>;
-  // set while a subagent is running — routes set_output to the correct subagent and prevents nesting
-  activeSubagentId: string | undefined;
+  // only set on subagent shallow copies — routes set_output to the owning subagent.
+  // never set on the orchestrator's shared state.
+  selfSubagentId: string | undefined;
   backgroundProcesses: Map<string, BackgroundProcess>;
   review?: {
     id: number;
@@ -81,7 +83,7 @@ export function initToolState(params: InitToolStateParams): ToolState {
   return {
     progressCommentId: resolvedId,
     subagents: new Map(),
-    activeSubagentId: undefined,
+    selfSubagentId: undefined,
     backgroundProcesses: new Map(),
     usageEntries: [],
   };
@@ -105,24 +107,6 @@ export interface ToolContext {
   tmpdir: string;
 }
 
-/**
- * tool names that are only available to the orchestrator.
- * subagent MCP servers are started with these tools excluded.
- *
- * - delegation tools: only the orchestrator can spawn/manage subagents
- * - remote-mutating tools: subagents work locally; the orchestrator pushes and creates PRs
- */
-export const ORCHESTRATOR_ONLY_TOOLS = [
-  "select_mode",
-  "delegate",
-  "ask_question",
-  "push_branch",
-  "push_tags",
-  "delete_branch",
-  "create_pull_request",
-  "update_pull_request_body",
-] as const;
-
 import { log } from "../utils/cli.ts";
 import type { RunContextData } from "../utils/runContextData.ts";
 import { AskQuestionTool } from "./askQuestion.ts";
@@ -204,27 +188,50 @@ function isAddressInUse(error: unknown): boolean {
   return message.includes("eaddrinuse") || message.includes("address already in use");
 }
 
-// tools shared by both orchestrator and subagent servers
-function buildCommonTools(ctx: ToolContext): Tool<any, any>[] {
+// subagent tools: file ops, bash, read-only GitHub, upload, set_output.
+// no git/checkout (mutates shared state), no dependencies (shared state),
+// no GitHub-write (user-facing side effects), no delegation/remote-mutating.
+function buildSubagentTools(ctx: ToolContext): Tool<any, any>[] {
   const tools: Tool<any, any>[] = [
-    StartDependencyInstallationTool(ctx),
-    AwaitDependencyInstallationTool(ctx),
-    CreateCommentTool(ctx),
-    EditCommentTool(ctx),
-    ReplyToReviewCommentTool(ctx),
-    IssueTool(ctx),
     IssueInfoTool(ctx),
     GetIssueCommentsTool(ctx),
     GetIssueEventsTool(ctx),
-    CreatePullRequestReviewTool(ctx),
+    PullRequestInfoTool(ctx),
+    CommitInfoTool(ctx),
+    GetReviewCommentsTool(ctx),
+    ListPullRequestReviewsTool(ctx),
+    GetCheckSuiteLogsTool(ctx),
+    UploadFileTool(ctx),
+    SetOutputTool(ctx),
+    FileReadTool(ctx),
+    FileWriteTool(ctx),
+    FileEditTool(ctx),
+    FileDeleteTool(ctx),
+    ListDirectoryTool(ctx),
+  ];
+
+  if (ctx.payload.bash === "restricted") {
+    tools.push(BashTool(ctx));
+    tools.push(KillBackgroundTool(ctx));
+  }
+
+  return tools;
+}
+
+// orchestrator gets everything: file ops, bash, git, GitHub, delegation, remote-mutating
+function buildOrchestratorTools(ctx: ToolContext): Tool<any, any>[] {
+  const tools: Tool<any, any>[] = [
+    StartDependencyInstallationTool(ctx),
+    AwaitDependencyInstallationTool(ctx),
+    IssueInfoTool(ctx),
+    GetIssueCommentsTool(ctx),
+    GetIssueEventsTool(ctx),
     PullRequestInfoTool(ctx),
     CommitInfoTool(ctx),
     CheckoutPrTool(ctx),
     GetReviewCommentsTool(ctx),
     ListPullRequestReviewsTool(ctx),
-    ResolveReviewThreadTool(ctx),
     GetCheckSuiteLogsTool(ctx),
-    AddLabelsTool(ctx),
     GitTool(ctx),
     GitFetchTool(ctx),
     UploadFileTool(ctx),
@@ -234,7 +241,22 @@ function buildCommonTools(ctx: ToolContext): Tool<any, any>[] {
     FileEditTool(ctx),
     FileDeleteTool(ctx),
     ListDirectoryTool(ctx),
+    CreateCommentTool(ctx),
+    EditCommentTool(ctx),
+    ReplyToReviewCommentTool(ctx),
+    CreatePullRequestReviewTool(ctx),
+    ResolveReviewThreadTool(ctx),
+    IssueTool(ctx),
+    AddLabelsTool(ctx),
     ReportProgressTool(ctx),
+    SelectModeTool(ctx),
+    DelegateTool(ctx),
+    AskQuestionTool(ctx),
+    PushBranchTool(ctx),
+    PushTagsTool(ctx),
+    DeleteBranchTool(ctx),
+    CreatePullRequestTool(ctx),
+    UpdatePullRequestBodyTool(ctx),
   ];
 
   // only add ShellTool when shell is "restricted"
@@ -249,26 +271,6 @@ function buildCommonTools(ctx: ToolContext): Tool<any, any>[] {
   return tools;
 }
 
-// orchestrator gets common tools + delegation + remote-mutating tools
-function buildOrchestratorTools(ctx: ToolContext): Tool<any, any>[] {
-  return [
-    ...buildCommonTools(ctx),
-    SelectModeTool(ctx),
-    DelegateTool(ctx),
-    AskQuestionTool(ctx),
-    PushBranchTool(ctx),
-    PushTagsTool(ctx),
-    DeleteBranchTool(ctx),
-    CreatePullRequestTool(ctx),
-    UpdatePullRequestBodyTool(ctx),
-  ];
-}
-
-// subagent gets only common tools (no delegation, no remote mutation)
-function buildSubagentTools(ctx: ToolContext): Tool<any, any>[] {
-  return buildCommonTools(ctx);
-}
-
 type McpStartResult = {
   server: FastMCP;
   url: string;
@@ -391,21 +393,30 @@ export type ManagedMcpServer = {
   stop: () => Promise<void>;
 };
 
+type StartSubagentMcpServerParams = {
+  ctx: ToolContext;
+  subagentId: string;
+};
+
 /**
  * Start a per-subagent MCP server (common tools only — no push/PR/delegation).
  * Each subagent gets its own server; call stop() when the subagent completes.
  *
  * The subagent gets its own shallow copy of toolState so scalar writes
  * (pushUrl, pushDest, selectedMode, etc.) don't mutate the orchestrator's state.
+ * selfSubagentId is set on the copy so set_output routes to the correct subagent.
  * Shared references (subagents Map, usageEntries array, dependencyInstallation)
  * are intentionally shared for coordination (set_output routing, usage tracking).
  */
-export async function startSubagentMcpServer(ctx: ToolContext): Promise<ManagedMcpServer> {
+export async function startSubagentMcpServer(
+  params: StartSubagentMcpServerParams
+): Promise<ManagedMcpServer> {
   const subagentToolState: ToolState = {
-    ...ctx.toolState,
+    ...params.ctx.toolState,
+    selfSubagentId: params.subagentId,
     backgroundProcesses: new Map(),
   };
-  const subagentCtx: ToolContext = { ...ctx, toolState: subagentToolState };
+  const subagentCtx: ToolContext = { ...params.ctx, toolState: subagentToolState };
   const tools = buildSubagentTools(subagentCtx);
   const startResult = await selectMcpPort(subagentCtx, tools);
   return { url: startResult.url, stop: () => startResult.server.stop() };

mcp/subagent.ts

@@ -1,7 +1,9 @@
+import { execSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { writeFileSync } from "node:fs";
+import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import type { Effort } from "../external.ts";
+import { ghPullfrogMcpName } from "../external.ts";
 import { markActivity } from "../utils/activity.ts";
 import type { ResolvedInstructions } from "../utils/instructions.ts";
 import { type SubagentState, startSubagentMcpServer, type ToolContext } from "./server.ts";
@@ -9,13 +11,24 @@ import { type SubagentState, startSubagentMcpServer, type ToolContext } from "./
 type CreateSubagentParams = {
   ctx: ToolContext;
   mode: string;
+  label: string;
 };
 
+function slugify(text: string): string {
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "")
+    .slice(0, 60);
+}
+
 export function createSubagentState(params: CreateSubagentParams): SubagentState {
   const id = randomUUID();
-  const stdoutFilePath = join(params.ctx.tmpdir, `subagent-${id}.log`);
+  const slug = slugify(params.label);
+  const stdoutFilePath = join(params.ctx.tmpdir, `subagent-${slug || id}.log`);
   const state: SubagentState = {
     id,
+    label: params.label,
     status: "running",
     mode: params.mode,
     stdoutFilePath,
@@ -25,7 +38,6 @@ export function createSubagentState(params: CreateSubagentParams): SubagentState
     keepAliveInterval: undefined,
   };
   params.ctx.toolState.subagents.set(id, state);
-  params.ctx.toolState.activeSubagentId = id;
   return state;
 }
 
@@ -44,15 +56,62 @@ function completeSubagent(params: CompleteSubagentParams): void {
   if (params.subagent.usage) {
     params.ctx.toolState.usageEntries.push(params.subagent.usage);
   }
-  params.ctx.toolState.activeSubagentId = undefined;
-  // keep completed subagents in the map for post-completion inspection
 }
 
-export function buildSubagentInstructions(orchestratorPrompt: string): ResolvedInstructions {
+export function hasRunningSubagents(ctx: ToolContext): boolean {
+  for (const s of ctx.toolState.subagents.values()) {
+    if (s.status === "running") return true;
+  }
+  return false;
+}
+
+const subagentSystemPreamble = `You are a focused subagent. Complete the task autonomously — no follow-up questions. Minimize token usage.
+
+## Tools
+
+Your tools are limited to:
+- **File operations**: \`${ghPullfrogMcpName}/file_read\`, \`file_write\`, \`file_edit\`, \`file_delete\`, \`list_directory\`. Native file tools (Read, Write, StrReplace, etc.) are disabled — use the MCP versions.
+- **Shell**: \`${ghPullfrogMcpName}/bash\` (if available). Use this for local git operations (\`git add\`, \`git commit\`, \`git diff\`, \`git log\`, \`git status\`), running tests, builds, and linters.
+- **Read-only GitHub**: \`get_pull_request\`, \`get_issue\`, \`get_issue_comments\`, \`get_issue_events\`, \`get_review_comments\`, \`list_pull_request_reviews\`, \`get_check_suite_logs\`, \`get_commit_info\`.
+- **Output**: \`${ghPullfrogMcpName}/upload_file\`, \`${ghPullfrogMcpName}/set_output\`.
+
+## Output
+
+When you finish, you MUST call \`${ghPullfrogMcpName}/set_output\` with your results. This is how your work gets back to the orchestrator — if you don't call it, your output is lost. Structure output as the instructions request. For research tasks, use well-organized markdown.`;
+
+type BuildSubagentInstructionsParams = {
+  ctx: ToolContext;
+  label: string;
+  instructions: string;
+};
+
+function buildResolvedContext(params: BuildSubagentInstructionsParams): string {
+  let branch = "unknown";
+  try {
+    branch = execSync("git branch --show-current", { encoding: "utf-8", stdio: "pipe" }).trim();
+  } catch {
+    // git not available
+  }
+
+  const lines = [
+    `repo: ${params.ctx.repo.owner}/${params.ctx.repo.name}`,
+    `branch: ${branch}`,
+    `working_directory: ${process.cwd()}`,
+    `subagent_label: ${params.label}`,
+  ];
+
+  return `[CONTEXT]\n${lines.join("\n")}`;
+}
+
+export function buildSubagentInstructions(
+  params: BuildSubagentInstructionsParams
+): ResolvedInstructions {
+  const resolvedContext = buildResolvedContext(params);
+  const full = `${resolvedContext}\n\n${subagentSystemPreamble}\n\n---\n\n${params.instructions}`;
   return {
-    full: orchestratorPrompt,
-    system: "",
-    user: orchestratorPrompt,
+    full,
+    system: subagentSystemPreamble,
+    user: params.instructions,
     eventInstructions: "",
     repo: "",
     event: "",
@@ -74,14 +133,24 @@ type RunSubagentResult = {
 
 export async function runSubagent(params: RunSubagentParams): Promise<RunSubagentResult> {
   params.subagent.keepAliveInterval = setInterval(markActivity, 30_000);
-  const mcpServer = await startSubagentMcpServer(params.ctx);
+  const mcpServer = await startSubagentMcpServer({
+    ctx: params.ctx,
+    subagentId: params.subagent.id,
+  });
+  // each subagent gets its own tmpdir so parallel agents don't clobber config files
+  const subagentTmpdir = join(params.ctx.tmpdir, params.subagent.id);
+  mkdirSync(subagentTmpdir, { recursive: true });
   try {
     const subagentPayload = { ...params.ctx.payload, effort: params.effort };
-    const subagentInstructions = buildSubagentInstructions(params.instructions);
+    const subagentInstructions = buildSubagentInstructions({
+      ctx: params.ctx,
+      label: params.subagent.label,
+      instructions: params.instructions,
+    });
     const result = await params.ctx.agent.run({
       payload: subagentPayload,
       mcpServerUrl: mcpServer.url,
-      tmpdir: params.ctx.tmpdir,
+      tmpdir: subagentTmpdir,
       instructions: subagentInstructions,
     });
     params.subagent.usage = result.usage;

mcp/toolFiltering.test.ts

@@ -4,41 +4,26 @@ import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/
 import { type } from "arktype";
 import { FastMCP } from "fastmcp";
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import { ORCHESTRATOR_ONLY_TOOLS } from "./server.ts";
 import { execute, tool } from "./shared.ts";
 import { buildSubagentInstructions } from "./subagent.ts";
 
-// ─── unit tests for pure exported functions ─────────────────────────────
-
-describe("ORCHESTRATOR_ONLY_TOOLS", () => {
-  it("includes delegation tools", () => {
-    expect(ORCHESTRATOR_ONLY_TOOLS).toContain("select_mode");
-    expect(ORCHESTRATOR_ONLY_TOOLS).toContain("delegate");
-    expect(ORCHESTRATOR_ONLY_TOOLS).toContain("ask_question");
-  });
-
-  it("includes remote-mutating tools", () => {
-    expect(ORCHESTRATOR_ONLY_TOOLS).toContain("push_branch");
-    expect(ORCHESTRATOR_ONLY_TOOLS).toContain("push_tags");
-    expect(ORCHESTRATOR_ONLY_TOOLS).toContain("delete_branch");
-    expect(ORCHESTRATOR_ONLY_TOOLS).toContain("create_pull_request");
-    expect(ORCHESTRATOR_ONLY_TOOLS).toContain("update_pull_request_body");
-  });
-});
-
 describe("buildSubagentInstructions", () => {
-  it("returns clean-room instructions with only the orchestrator prompt", () => {
+  it("includes system preamble, resolved context, and orchestrator prompt", () => {
     const prompt = "Read file.ts and fix the type error.";
-    const instructions = buildSubagentInstructions(prompt);
-    expect(instructions).toEqual({
-      full: prompt,
-      system: "",
-      user: prompt,
-      eventInstructions: "",
-      repo: "",
-      event: "",
-      runtime: "",
+    const ctx = {
+      repo: { owner: "test-owner", name: "test-repo" },
+    } as any;
+    const instructions = buildSubagentInstructions({
+      ctx,
+      label: "test-task",
+      instructions: prompt,
     });
+    expect(instructions.user).toBe(prompt);
+    expect(instructions.full).toContain("[CONTEXT]");
+    expect(instructions.full).toContain("test-owner/test-repo");
+    expect(instructions.full).toContain("subagent_label: test-task");
+    expect(instructions.full).toContain("set_output");
+    expect(instructions.full).toContain(prompt);
   });
 });
 
@@ -97,10 +82,9 @@ describe("per-server tool isolation - integration", () => {
     orchestratorServer.addTool(mockTool("push_branch", "push branch"));
     orchestratorServer.addTool(mockTool("create_pull_request", "create PR"));
 
-    // subagent gets ONLY common tools (no delegation, no remote mutation)
+    // subagent gets ONLY file ops, bash, read-only GitHub, upload, set_output
     subagentServer = new FastMCP({ name: "subagent", version: "0.0.1" });
     subagentServer.addTool(mockTool("file_read", "read a file"));
-    subagentServer.addTool(mockTool("git", "run git commands"));
     subagentServer.addTool(mockTool("set_output", "set output"));
 
     await Promise.all([
@@ -142,7 +126,7 @@ describe("per-server tool isolation - integration", () => {
     expect(names.length).toBe(8);
   });
 
-  it("subagent cannot see delegation or mutation tools", async () => {
+  it("subagent cannot see orchestrator-only tools", async () => {
     const client = await connectMcpClient(subagentUrl);
     clients.push(client);
     const result = await client.listTools();
@@ -152,16 +136,16 @@ describe("per-server tool isolation - integration", () => {
     expect(names).not.toContain("ask_question");
     expect(names).not.toContain("push_branch");
     expect(names).not.toContain("create_pull_request");
+    expect(names).not.toContain("git");
   });
 
-  it("subagent sees only common tools", async () => {
+  it("subagent sees only file ops, read-only tools, and set_output", async () => {
     const client = await connectMcpClient(subagentUrl);
     clients.push(client);
     const result = await client.listTools();
     const names = result.tools.map((t) => t.name);
     expect(names).toContain("file_read");
-    expect(names).toContain("git");
     expect(names).toContain("set_output");
-    expect(names.length).toBe(3);
+    expect(names.length).toBe(2);
   });
 });