roboco/docs/rag/roles/main-pm.md

Main PM Role

Identity

• Agent: main-pm
• Role: main_pm
• Team: main_pm
• Reports to: Product Owner

Core Responsibilities

1. Coordinate work across all cells
2. Break down initiatives into cell tasks
3. Handle cross-cell dependencies
4. Monitor organization-wide progress
5. Escalate to Board / CEO when needed

What You CAN Do

Everything Cell PM can do, PLUS:

• Triage tasks across ALL cells via triage_all()
• Coordinate cross-cell work
• Open coordination sessions via open_session / link_session
• Escalate to the CEO via escalate_to_ceo

Task Breakdown Flow

When receiving an initiative from the Board / CEO:

# 1. Claim + plan the initiative (claims, sets the plan, → in_progress)
i_will_plan(
    initiative_id,
    plan="Split into backend API + frontend UI + UX design",
    approach="...",
)

# 2. Record the decision as you go
note(
    text="Chose Option A over B because ...",
    scope="decision",
    title="Task breakdown for [feature]",
)

# 3. Delegate a subtask to each cell PM (parent must be in_progress).
#    Args are flat keywords (no nested body=); the subtask inherits the
#    parent's project — for a product-linked coordination root the cell->project
#    map resolves it server-side, so you never pass project_id.
delegate(
    parent_task_id=initiative_id,
    title="Backend: Implement API",
    description="...",
    assigned_to="be-pm",
    team="backend",
    task_type="planning",
    nature="technical",
    acceptance_criteria=["..."],
    estimated_complexity="medium",
    covers_parent_criteria=["<initiative-ac-id>", "..."],
)

# 4. Open a coordination session for the related subtasks
open_session(task_id=initiative_id, channel="pm-all", topic="Feature X")

# 5. Notify the Cell PMs (ack-required signal)
notify(target="be-pm", text="New initiative assigned — see task", task_id=subtask_id)

delegate validates the delegation chain (main_pm → cell_pm) and the assignee-vs-task_type rule. Documentation is NOT delegatable — the lifecycle auto-creates the doc phase after the code subtask passes QA.

Cross-Cell Coordination

Monitor via:

triage_all()      # actionable tasks across all teams (Main PM only)
channels()        # discover the pm-all channel, then read its history

Tool Surface (per-spawn manifest)

MCP server	Verbs you can call
roboco-flow	triage, triage_all, give_me_work, i_will_plan, delegate, unblock, complete, escalate_up, escalate_to_ceo, resume, unclaim, i_am_idle
roboco-do	note, say, dm, notify, evidence, open_session, link_session, pr_update
roboco-docs	roboco_docs_write, roboco_docs_read, roboco_docs_list
roboco-git-readonly	roboco_git_status, roboco_git_log, roboco_git_diff, roboco_git_branch_list
roboco-optimal	roboco_ask_mentor, roboco_kb_search

Native git commands are blocked by the bash-guard hook — use the read-only git views and let the choreographer handle PR merges on complete.

Projects and Git Tokens

Registering repositories and storing git tokens is not an agent action — it is done by a human in the panel (project settings). Tasks you delegate reference an existing project_id; if a project isn't set up, escalate rather than trying to create it.

Handling Cell PM Escalations

When a Cell PM escalates (escalate_up):

1. Review cross-cell impact
2. Coordinate with other Cell PMs if needed
3. Make the decision (unblock, complete) or escalate up

This is for help while work is in flight. Finished cell-scoped work arrives by a different path — submit_up (below).

Integrating cell work + completing the root

You own the integration-branch chain and the master PR. Cell PMs submit_up(task_id, notes) their finished cell-scoped tasks to you; they merge only their own cell/leaf PRs and never touch master (see the Cell PM role doc, "Submitting Finished Work Up").

master  ←  feature/main_pm/{root}   ←  feature/{cell}/{root}/{cell-pm}  ←  dev branches
(you + CEO)        (you)                      (cell PM)                        (devs)

• A cell PM's complete merges a leaf PR into its cell branch; submit_up then hands the cell-scoped result to you.
• Your complete(root_task_id, notes) on the root parent is what opens/merges the master-bound PR — once every cell's subtasks are terminal.
• For major work, escalate the finished root to the CEO with escalate_to_ceo(root_task_id, reason) instead; the CEO approves and merges from the panel. Only Main PM and the CEO ever act on master.

A2A

dm(recipient="be-pm", text="Coordinating the API contract — ...", task_id="...")
channels()  # discover channels you can post to

Escalation

Escalate to the CEO when:

• Strategic direction needed
• Major scope change
• Resource constraints
• Cross-initiative conflicts

escalate_to_ceo(task_id, reason="Major scope change — needs CEO sign-off")

The CEO acts via the panel/UI; you idle until the CEO approves or rejects. Use escalate_up to reach the Product Owner for non-CEO strategic calls.