@dreki-gg/pi-subagent 0.2.0 → 0.3.0

package/extensions/subagent/workflows.ts

@@ -0,0 +1,150 @@
+import type { WorkflowDefinition, WorkflowId } from './delegate-types';
+
+export const WORKFLOWS: WorkflowDefinition[] = [
+  {
+    id: 'scout-only',
+    label: 'Scout only',
+    description: 'Parallel scouts for exploration — no plan, no implementation',
+    phases: [
+      {
+        kind: 'parallel',
+        name: 'Scouts',
+        agents: ['scout', 'docs-scout'],
+        taskTemplate: '{synthesis}',
+      },
+    ],
+  },
+  {
+    id: 'scout-and-plan',
+    label: 'Scout and plan',
+    description: 'Parallel scouts → planner — produces a plan without implementing',
+    phases: [
+      {
+        kind: 'parallel',
+        name: 'Scouts',
+        agents: ['scout', 'docs-scout'],
+        taskTemplate: '{synthesis}',
+      },
+      {
+        kind: 'single',
+        name: 'Planner',
+        agents: ['planner'],
+        taskTemplate:
+          'Create an implementation plan based on the following context.\n\n## Task\n{synthesis}\n\n## Scout findings\n{previous}',
+      },
+    ],
+  },
+  {
+    id: 'implement',
+    label: 'Implement',
+    description: 'Parallel scouts → planner → worker — full implementation',
+    phases: [
+      {
+        kind: 'parallel',
+        name: 'Scouts',
+        agents: ['scout', 'docs-scout'],
+        taskTemplate: '{synthesis}',
+      },
+      {
+        kind: 'single',
+        name: 'Planner',
+        agents: ['planner'],
+        requiresConfirmation: true,
+        taskTemplate:
+          'Create an implementation plan based on the following context.\n\n## Task\n{synthesis}\n\n## Scout findings\n{previous}',
+      },
+      {
+        kind: 'single',
+        name: 'Worker',
+        agents: ['worker'],
+        taskTemplate:
+          'Implement the following plan.\n\n## Task\n{synthesis}\n\n## Plan\n{previous}',
+      },
+    ],
+  },
+  {
+    id: 'implement-and-review',
+    label: 'Implement and review',
+    description:
+      'Parallel scouts → planner → worker → reviewer — full implementation with code review',
+    phases: [
+      {
+        kind: 'parallel',
+        name: 'Scouts',
+        agents: ['scout', 'docs-scout'],
+        taskTemplate: '{synthesis}',
+      },
+      {
+        kind: 'single',
+        name: 'Planner',
+        agents: ['planner'],
+        requiresConfirmation: true,
+        taskTemplate:
+          'Create an implementation plan based on the following context.\n\n## Task\n{synthesis}\n\n## Scout findings\n{previous}',
+      },
+      {
+        kind: 'single',
+        name: 'Worker',
+        agents: ['worker'],
+        taskTemplate:
+          'Implement the following plan.\n\n## Task\n{synthesis}\n\n## Plan\n{previous}',
+      },
+      {
+        kind: 'single',
+        name: 'Reviewer',
+        agents: ['reviewer'],
+        taskTemplate:
+          'Review the implementation described below.\n\n## Task\n{synthesis}\n\n## Implementation output\n{previous}',
+      },
+    ],
+  },
+  {
+    id: 'quick-fix',
+    label: 'Quick fix',
+    description: 'Worker only — fast, no scouts or planning',
+    phases: [
+      {
+        kind: 'single',
+        name: 'Worker',
+        agents: ['worker'],
+        taskTemplate: '{synthesis}',
+      },
+    ],
+  },
+  {
+    id: 'review',
+    label: 'Review',
+    description: 'Reviewer only — code review of recent changes',
+    phases: [
+      {
+        kind: 'single',
+        name: 'Reviewer',
+        agents: ['reviewer'],
+        taskTemplate: '{synthesis}',
+      },
+    ],
+  },
+];
+
+export function getWorkflow(id: WorkflowId): WorkflowDefinition {
+  const wf = WORKFLOWS.find((w) => w.id === id);
+  if (!wf) throw new Error(`Unknown workflow: ${id}`);
+  return wf;
+}
+
+export function suggestWorkflow(synthesis: string): WorkflowId {
+  const lower = synthesis.toLowerCase();
+
+  const hasReview = /review|audit|check quality|security/.test(lower);
+  const hasFix = /fix|bug|patch|hotfix|quick/.test(lower);
+  const hasImplement = /implement|build|create|add|refactor|migrate/.test(lower);
+  const hasDesign = /design|plan|architect|explore|investigate|scout/.test(lower);
+
+  if (hasFix && !hasImplement && !hasDesign) return 'quick-fix';
+  if (hasReview && !hasImplement && !hasDesign) return 'review';
+  if (hasDesign && !hasImplement) return 'scout-and-plan';
+  if (hasImplement && hasReview) return 'implement-and-review';
+  if (hasImplement) return 'implement';
+
+  return 'implement';
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dreki-gg/pi-subagent",
-  "version": "0.2.0",
-  "description": "Subagent tool for pi — delegate tasks to specialized agents with isolated context windows",
+  "version": "0.3.0",
+  "description": "Subagent tool and delegate orchestration for pi — isolated agents, parallel scouts, planning gates, and workflow presets",
   "keywords": [
     "pi-package"
   ],
@@ -22,6 +22,12 @@
   "pi": {
     "extensions": [
       "./extensions/subagent"
+    ],
+    "skills": [
+      "./skills"
+    ],
+    "prompts": [
+      "./prompts"
     ]
   },
   "devDependencies": {

package/prompts/implement-and-review.md

@@ -0,0 +1,10 @@
+---
+description: Worker implements, reviewer reviews, worker applies feedback
+---
+Use the subagent tool with the chain parameter to execute this workflow:
+
+1. First, use the "worker" agent to implement: $@
+2. Then, use the "reviewer" agent to review the implementation from the previous step (use {previous} placeholder)
+3. Finally, use the "worker" agent to apply the feedback from the review (use {previous} placeholder)
+
+Execute this as a chain, passing output between steps via {previous}.

package/prompts/implement.md

@@ -0,0 +1,10 @@
+---
+description: Full implementation workflow - scout gathers context, planner creates plan, worker implements
+---
+Use the subagent tool with the chain parameter to execute this workflow:
+
+1. First, use the "scout" agent to find all code relevant to: $@
+2. Then, use the "planner" agent to create an implementation plan for "$@" using the context from the previous step (use {previous} placeholder)
+3. Finally, use the "worker" agent to implement the plan from the previous step (use {previous} placeholder)
+
+Execute this as a chain, passing output between steps via {previous}.

package/prompts/scout-and-plan.md

@@ -0,0 +1,9 @@
+---
+description: Scout gathers context, planner creates implementation plan (no implementation)
+---
+Use the subagent tool with the chain parameter to execute this workflow:
+
+1. First, use the "scout" agent to find all code relevant to: $@
+2. Then, use the "planner" agent to create an implementation plan for "$@" using the context from the previous step (use {previous} placeholder)
+
+Execute this as a chain, passing output between steps via {previous}. Do NOT implement - just return the plan.

package/skills/subagent-workflows/SKILL.md

@@ -0,0 +1,52 @@
+---
+name: subagent-workflows
+description: Use explicit subagent workflows for planning or implementation after a grill/design session. Runs parallel scouts, then planner, then optional worker/reviewer.
+---
+
+Use this skill when the user wants to execute a plan with subagents, parallelize discovery intelligently, or asks to hand work off after a design/grill session.
+
+Principles:
+- Use the `subagent` tool explicitly; do not improvise ad hoc parallelism.
+- Parallelize reconnaissance, not conflicting edits.
+- Prefer one planner synthesis step after parallel scouts.
+- Prefer one worker unless file ownership can be partitioned safely.
+- Use `docs-scout` whenever library/framework docs matter.
+
+Recommended workflows:
+
+## 1. Scout and plan
+Use when the user wants a concrete implementation plan before coding.
+
+Run `subagent` in parallel mode with two tasks:
+- `scout` for codebase reconnaissance
+- `docs-scout` for library/framework docs if docs are relevant
+
+Then run `subagent` in chain or single mode with `planner`, feeding it the scout outputs.
+
+## 2. Implement from a grilled plan
+Use when the design is already clarified and the user wants execution.
+
+Recommended sequence:
+1. Parallel scouts (`scout` + optionally `docs-scout`)
+2. `planner` synthesis
+3. `worker` implementation
+4. Optional `reviewer`
+
+## 3. Review-oriented loop
+Use when the user wants implementation with a final quality pass.
+
+Recommended sequence:
+1. `worker`
+2. `reviewer`
+3. Main agent decides whether to apply fixes directly or run another `worker`
+
+Execution guidance:
+- Keep parallel scouts focused on different concerns.
+- Do not run multiple workers against the same file set unless boundaries are explicit.
+- If docs are required, use `docs-scout` instead of relying on memory.
+- When handing off between subagents, pass the previous output verbatim or clearly summarized.
+
+When reporting back to the user:
+- Say which subagents ran
+- Summarize what each contributed
+- Present the synthesized plan or implementation result clearly