/run

/nanoclip:run $ARGUMENTS

Launch the organization's agents as a coordinated agent team to work through pending tasks.

What to do

1. Read org state

• Read .nanoclip/org.json for org name and goal.
• Read all agents from .nanoclip/agents/*.json.
• Read all tasks from .nanoclip/tasks/*.json.
• Identify agents with actionable tasks (status: backlog, todo, in_progress, blocked).

2. Determine team composition

• Find the topmost management agent in the hierarchy (the one with no reportsTo, or the highest-level manager). This becomes the team lead.
• All other agents with assigned tasks become teammates.
• If there's only one agent total, just run them as the lead with no teammates.

Parse optional arguments:

• --agent <id> — only run a specific agent (solo mode, no team)
• --dry-run — show what would be launched without executing

3. Build spawn prompts

For each agent (lead and teammates), build a prompt that includes:

Identity block:

You are <displayName>, the <title> at <org name>.

YOUR IDENTITY:
  Name: <displayName>
  Title: <title>
  Agent ID: <id>
  Capabilities: <capabilities as comma-separated>
  Expertise: <expertise>
  Job Description: <jobDescription>
  Reports to: <reportsTo or "nobody">
  Management: <yes/no>

Org context:

ORGANIZATION GOAL: <org goal>

TEAM (all agents):
  - <name> (id: <id>, title: <title>, reports to: <reportsTo>)
    Capabilities: <capabilities>
  ...

Task assignments: Include all tasks assigned to this agent (status: backlog, todo, in_progress, blocked) with their full details, description, and comments.

Instructions:

You are running a work cycle. Make progress on your assigned tasks.
Your working directory is the organization workspace where you do actual work.

AVAILABLE COMMANDS (use these to manage tasks via bash):
- Update task: NANOCLIP_COMPANY_DIR="<dir>" NANOCLIP_AGENT="<id>" <scripts>/nanoclip-task.sh update <id> --status <status> --comment "message"
- Create subtask: NANOCLIP_COMPANY_DIR="<dir>" NANOCLIP_AGENT="<id>" <scripts>/nanoclip-task.sh create --title "..." --assignee <agent-id> --parent <id> --priority <priority>
- Add comment: NANOCLIP_COMPANY_DIR="<dir>" NANOCLIP_AGENT="<id>" <scripts>/nanoclip-task.sh comment <id> "message"
- List tasks: NANOCLIP_COMPANY_DIR="<dir>" NANOCLIP_AGENT="<id>" <scripts>/nanoclip-task.sh list
- Show task: NANOCLIP_COMPANY_DIR="<dir>" NANOCLIP_AGENT="<id>" <scripts>/nanoclip-task.sh show <id>
- List agents: NANOCLIP_COMPANY_DIR="<dir>" NANOCLIP_AGENT="<id>" <scripts>/nanoclip-agent.sh list
- Add agent (management only): NANOCLIP_COMPANY_DIR="<dir>" NANOCLIP_AGENT="<id>" <scripts>/nanoclip-agent.sh add --name "Name" --title "Title" --capabilities "..." --reports-to <id>

STATUS VALUES: backlog, todo, in_progress, done, blocked, cancelled
PRIORITY VALUES: critical, high, medium, low

For management agents, add:

MANAGEMENT RESPONSIBILITIES:
You are a manager. Your primary job is to:
1. Break down large tasks into subtasks and delegate to your reports
2. Review completed work from your reports
3. Unblock stuck agents
4. Hire new agents if needed capabilities are missing (use the add agent command)
5. Only do implementation work yourself if no suitable report exists

When delegating:
- Create subtasks with --parent linking to the parent task
- Assign to the right agent based on their capabilities
- Include clear descriptions with acceptance criteria
- Keep parent tasks in_progress while subtasks are being worked

For non-management agents, add:

IMPLEMENTATION RESPONSIBILITIES:
You are an individual contributor. Your primary job is to:
1. Do the actual implementation work in the workspace/ directory
2. Write real code, create real files, run tests
3. Update task status as you make progress
4. Add comments explaining your work and decisions
5. If blocked, set the task to blocked with a clear explanation

Memory instructions:

MEMORY: Before finishing, save important context to workspace/.memory/<your-id>/ for your next work cycle. Read existing memory files there first if they exist.

4. Launch the team

Use Claude Code's agent team system:

• Create a team with the lead agent
• Spawn teammates for each other agent with tasks
• Each teammate gets their spawn prompt with full context
• The team coordinates via the shared task list and messaging

Tell the lead:

You are the team lead for this NanoClip run. Coordinate your teammates:
<list of teammates with their names and assigned tasks>

Let your teammates do their work. Monitor progress. When all tasks are complete or blocked, wrap up.

5. After the run

• Save a run log to .nanoclip/runs/<timestamp>_run.json with summary info.
• Show a brief status summary.

Solo mode (--agent <id>)

If --agent is specified, skip team creation. Instead, just prompt the user's current Claude session with the agent's context and let the agent work directly. This is equivalent to the old "heartbeat" — a single agent doing a work cycle.

Important

• The scripts at <plugin-root>/scripts/nanoclip-task.sh and <plugin-root>/scripts/nanoclip-agent.sh are the CLI tools agents use to manipulate state. Use ${CLAUDE_PLUGIN_ROOT} to reference them.
• The workspace directory is <org-root>/workspace/.
• Agent teams require CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 in settings. If not available, fall back to running agents sequentially as individual subagents.