/assist — Universal Assistant

Automatically analyzes the current scenario, takes inventory of available ECC resources, intelligently selects and executes the optimal agent pipeline. Suitable for use when you are not sure which tool to use.

Step 1: Scenario Analysis

Collect complete information about the current working environment:

1a. Git Status

bash

git status
git diff --stat
git log --oneline -5

Are there any uncommitted changes? Which files have been modified?
What is the content of recent commits?
Current branch name and status

1b. Project Detection

bash

ls -la

Project language/framework (package.json → Node.js、go.mod → Go、requirements.txt → Python, etc.)
Whether there is a test framework configuration
Whether there is CI/CD configuration

1c. User Instructions

Analyze the task description in
```
$ARGUMENTS
```
Review requirements and context in the conversation history

1d. Build Status

If there are relevant commands (
```
npm run build
```
、
```
go build
```
、
```
python -m py_compile
```
), quickly check if the build works normally
Only execute when explicit build configuration is detected

Step 2: Inventory ECC Resources

Quickly scan available agents, skills, commands:

Available Agents (filtered by project type):

Agent	Applicable Scenario
planner	Complex tasks requiring planning
architect	Architecture design decisions
tdd-guide	New features, bug fixes
code-reviewer	Code quality review
security-reviewer	Security analysis
build-error-resolver	Build failure
e2e-runner	E2E testing
refactor-cleaner	Refactoring, dead code cleanup
doc-updater	Documentation update
go-reviewer	Exclusive for Go projects
go-build-resolver	Go build errors
python-reviewer	Exclusive for Python projects
database-reviewer	Database related tasks
harness-optimizer	Agent harness configuration optimization (hooks/evals/routing)
loop-operator	Autonomous loop operation and monitoring

ECC Resource Allocation Principles

Inventory results directly affect Step 3 routing selection
All agents in the selected pipeline must be confirmed available before making routing decisions
If the required agent is deferred, prompt the user to restore it first or select an alternative pipeline

Step 3: Intelligent Routing

Automatically select the optimal pipeline based on the scenario analysis results from Step 1:

Routing Rules

Detected Scenario	Selected Pipeline	Description
Clear new feature requirement	planner (including industry/academic solution research) -> architect -> tdd-guide -> code-reviewer	Complete feature development process; planner must attach industry standards or academic support for technical solutions
Bug description or error message exists	planner -> tdd-guide -> code-reviewer	Bug fix process
Uncommitted changes need review	code-reviewer -> security-reviewer	Quick quality review
Build failure	build-error-resolver	Directly fix build issues
Refactoring required (explicitly requested by user or code smell detected)	architect -> refactor-cleaner -> code-reviewer	Secure refactoring process
Documentation writing required	doc-updater -> code-reviewer	Documentation update process
Go project	Add go-reviewer to the pipeline	Automatically append language-specific reviewer
Python project	Add python-reviewer to the pipeline	Automatically append language-specific reviewer
Involves database schema or query	Add database-reviewer to the pipeline	Automatically append database reviewer
Need to optimize agent harness configuration	harness-optimizer	Hooks/evals/routing configuration tuning
Need to run autonomous loop tasks	loop-operator	Long-term autonomous loop monitoring
Uncertain / multiple possibilities	List recommended pipelines for user selection	Interact via AskUserQuestion

Routing Judgment Logic

Prioritize
$ARGUMENTS
: If the user has clear instructions, follow the instructions first
Then analyze Git status: Uncommitted changes → review pipeline; build failure → build-fix pipeline
Then check conversation context: Infer user intent from conversation history
Ask when unable to judge: Provide 2-4 suggested options using AskUserQuestion

Multi-scenario Conflict Handling

When multiple scenarios are detected at the same time, decide the processing order according to the following priority:

Build failure — Must be fixed first, otherwise other work cannot be verified
Security issues — Cannot be postponed
Explicit user instructions ($ARGUMENTS) — User intent takes priority
Bug fix — Fixes are more important than new features
New feature development — Standard priority
Refactoring/cleanup — Lower priority
Documentation update — Can be postponed or executed in parallel with other work

If the detected scenario conflicts with

$ARGUMENTS

(for example, user requests review but build fails), first explain the detection result and ask if the user still wants to continue the original instruction.

Interaction When Uncertain

Use AskUserQuestion to provide options:

Scenario analysis result: [Brief description of detected state]

Recommended workflows:
1. [Pipeline A] — [Applicable reason]
2. [Pipeline B] — [Applicable reason]
3. [Pipeline C] — [Applicable reason]

Step 4: Execute Pipeline

Execute agents in sequence according to the selected pipeline, use handoff protocol to pass context.

Handoff Protocol

After each agent completes, organize handover information and pass it to the next agent:

markdown

## HANDOFF: [previous-agent] -> [next-agent]

### Status: [COMPLETED | COMPLETED_WITH_ISSUES | FAILED]
<!-- COMPLETED = Continue normally | COMPLETED_WITH_ISSUES = Continue but mark issues | FAILED = Pause and ask user -->

### Context
<!-- Task background and objective -->

### Findings
<!-- Findings and outputs of the previous agent -->

### Industry & Standards Referenced
<!-- Industry standards or academic basis cited in this phase -->

### Files Modified
<!-- List of modified files -->

### Open Questions
<!-- Unresolved issues -->

### Recommendations
<!-- Recommendations for the next agent -->

Execution Principles

Each agent is executed in sequence, no skipping
If an agent finds a CRITICAL issue, pause the pipeline and ask the user using AskUserQuestion
Language-specific reviewers (go-reviewer, python-reviewer) are executed after code-reviewer
database-reviewer is executed after steps involving DB changes

Step 5: Output Report

After all agents are executed, output the final report: