Orchestrator Protocol Specification

Version: 1.1.0 Status: ACTIVE Created: 2026-01-18 Updated: 2026-01-26 Author: Protocol Specification Subagent Epic: T1575 Session: session_20260118_132917_801b75 See Also: Version Guide for version relationships

RFC 2119 Conformance

The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL” in this document are to be interpreted as described in BCP 14 RFC 2119 RFC 8174 when, and only when, they appear in all capitals.

Part 1: Overview

1.1 Purpose

Vision Document: See ORCHESTRATOR-VISION.md for the foundational philosophy: “Stay high-level. Delegate everything. Read only manifests. Spawn in order.”

This specification defines the behavioral protocol for orchestrating multi-agent research workflows in CLEO. It establishes immutable rules for orchestrator behavior, subagent delegation, manifest-based coordination, and session startup procedures.

1.2 Authority

This specification is AUTHORITATIVE for:

Orchestrator behavioral constraints and delegation rules
Subagent output protocol and CLEO task integration
Manifest schema and query patterns
Session startup protocol for conversation continuity
Task linking and research-to-task cross-referencing

This specification DEFERS TO:

ORCHESTRATOR-SPEC.md for tmux-based multi-agent orchestration
IMPLEMENTATION-ORCHESTRATION-SPEC.md for 7-agent pipeline
MULTI-SESSION-SPEC.md for session scope binding
SUBAGENT_PROTOCOL.md for research output format

1.3 Scope

This protocol governs:

Orchestrator behavior - High-level coordination without implementation
Subagent delegation - Work assignment and output collection
Manifest coordination - Lightweight state passing between agents
Session continuity - Resuming work across conversation boundaries

Part 2: Orchestrator Behavior Rules

2.1 Core Constraints

The orchestrator agent is the conversation-level coordinator. It MUST adhere to these immutable constraints:

Rule ID	Constraint	Rationale
ORC-001	MUST stay high-level; MUST NOT implement code	Context preservation; delegation efficiency
ORC-002	MUST delegate ALL work to subagents	Separation of concerns; parallel execution
ORC-003	MUST NOT read full research files into context	Token efficiency; context window protection
ORC-004	MUST spawn agents in dependency order	Correctness; avoid wasted work
ORC-005	MUST use manifest for research summaries	O(1) lookup vs O(n) file reading
ORC-006	MUST verify protocol injection before spawn	Ensures subagent compliance
ORC-007	MUST check context thresholds before spawn	Prevents context overflow
ORC-008	MUST verify previous agent compliance before next spawn	Maintains protocol chain integrity
ORC-009	MUST auto-stop when context reaches critical threshold	Graceful session handoff

2.2 Delegation Decision Tree

USER REQUEST RECEIVED
        │
        ▼
┌───────────────────────────────────────┐
│ Is this a coordination/planning task? │
└───────────────────┬───────────────────┘
                    │
        ┌───────────┴───────────┐
        │ YES                   │ NO
        ▼                       ▼
┌───────────────────┐   ┌───────────────────────────┐
│ Orchestrator      │   │ Spawn subagent for task   │
│ handles directly  │   │ via Task tool             │
└───────────────────┘   └───────────────────────────┘
        │                       │
        │                       ▼
        │               ┌───────────────────────────┐
        │               │ Wait for subagent         │
        │               │ completion message        │
        │               └───────────────────────────┘
        │                       │
        └───────────┬───────────┘
                    ▼
            ┌───────────────────┐
            │ Read MANIFEST.jsonl│
            │ for results summary│
            └───────────────────┘

2.3 Permitted Orchestrator Actions

The orchestrator MAY perform these actions directly:

Action	Tool	Example
Check task state	`cleo session list`, `cleo list`, `cleo show`	`cleo session list --status active`
Query manifest	`cat MANIFEST.jsonl \| jq`	`jq -s '.[-1]' MANIFEST.jsonl`
Plan task sequence	None (internal reasoning)	Dependency analysis
Spawn subagent	Task tool	`<task>Research X</task>`
Create epic/tasks	`cleo add`	`cleo add "Epic" --type epic`

2.4 Prohibited Orchestrator Actions

The orchestrator MUST NOT perform these actions:

Prohibited Action	Why	Delegate To
Read full research files	Token explosion	Subagent with targeted Read
Implement code changes	Context pollution	Coder subagent
Run tests	Specialized knowledge	Testing subagent
Write documentation	Detailed work	Docs subagent
Merge/commit code	HITL gate	Human or authorized agent

Part 3: Subagent Protocol

3.1 Subagent Injection Block

Every research subagent prompt MUST include this instruction block:

## SUBAGENT PROTOCOL (RFC 2119 - MANDATORY)

OUTPUT REQUIREMENTS:
1. MUST write findings to: claudedocs/agent-outputs/YYYY-MM-DD_{topic-slug}.md
2. MUST append ONE line to: claudedocs/agent-outputs/MANIFEST.jsonl
3. MUST return ONLY: "Research complete. See MANIFEST.jsonl for summary."
4. MUST NOT return research content in response.

CLEO INTEGRATION:
1. MUST read task details: `cleo show <task-id>`
2. MUST set focus: `cleo focus set <task-id>`
3. MUST complete task when done: `cleo complete <task-id>`
4. SHOULD link research: `cleo research link <task-id> <research-id>`

Manifest entry format (single JSON line):
{"id":"topic-YYYY-MM-DD","file":"YYYY-MM-DD_topic.md","title":"Title","date":"YYYY-MM-DD","status":"complete|partial|blocked","topics":["t1"],"key_findings":["Finding 1"],"actionable":true,"needs_followup":["T1234"]}

3.2 Subagent Workflow

SUBAGENT SPAWNED
        │
        ▼
┌───────────────────────────────────────┐
│ 1. Read task: cleo show <task-id>     │
└───────────────────────────────────────┘
        │
        ▼
┌───────────────────────────────────────┐
│ 2. Set focus: cleo focus set <task-id>│
└───────────────────────────────────────┘
        │
        ▼
┌───────────────────────────────────────┐
│ 3. Execute research/implementation    │
│    Write findings to output file      │
└───────────────────────────────────────┘
        │
        ▼
┌───────────────────────────────────────┐
│ 4. Append manifest entry              │
│    Set needs_followup to next tasks   │
└───────────────────────────────────────┘
        │
        ▼
┌───────────────────────────────────────┐
│ 5. Complete task: cleo complete <id>  │
└───────────────────────────────────────┘
        │
        ▼
┌───────────────────────────────────────┐
│ 6. Return: "Research complete. See    │
│    MANIFEST.jsonl for summary."       │
└───────────────────────────────────────┘

3.3 Subagent Return Contract

Requirement	Rule Level	Validation
Output file exists	MUST	`test -f <path>`
Manifest entry appended	MUST	`grep <id> MANIFEST.jsonl`
Response is completion message only	MUST	String match
Task completed in CLEO	SHOULD	`cleo show <id>` status=done
Research linked to task	SHOULD	Task notes contain research ID

Part 4: Session Startup Protocol

4.1 Every New Conversation

When a new conversation starts, the orchestrator MUST execute this startup sequence:

# Step 1: Check for active sessions
cleo session list --status active

# Step 2: Check manifest for pending work
cat claudedocs/agent-outputs/MANIFEST.jsonl | jq -s '[.[] | select(.needs_followup | length > 0)]'

# Step 3: Check focused task
cleo focus show

# Step 4: Review epic status
cleo dash --compact

4.2 Decision Matrix

Based on startup checks, orchestrator MUST take one of these actions:

Condition	Action
Active session exists with focus	Resume session; continue from focused task
Active session exists, no focus	Query manifest for needs_followup; spawn next agent
No active session, manifest has followup	Create session; spawn agent for first followup task
No active session, no manifest followup	Ask user for direction

4.3 Session Resume Flow

CONVERSATION STARTS
        │
        ▼
┌───────────────────────────────────────┐
│ cleo session list --status active     │
└───────────────────────────────────────┘
        │
        ├──── No active sessions ────▶ CREATE NEW SESSION
        │
        ▼ Active session found
┌───────────────────────────────────────┐
│ cleo session resume <session-id>      │
│   OR                                  │
│ cleo session resume --last            │
└───────────────────────────────────────┘
        │
        ▼
┌───────────────────────────────────────┐
│ cleo focus show                       │
└───────────────────────────────────────┘
        │
        ├──── Focus exists ────▶ CONTINUE FOCUSED TASK
        │
        ▼ No focus
┌───────────────────────────────────────┐
│ Query MANIFEST.jsonl for              │
│ needs_followup arrays                 │
└───────────────────────────────────────┘
        │
        ├──── Followup tasks found ────▶ SPAWN NEXT AGENT
        │
        ▼ No followup
┌───────────────────────────────────────┐
│ cleo analyze --parent <epic-id>       │
│ Find next unblocked task              │
└───────────────────────────────────────┘

Part 5: Manifest Schema

5.1 Required Fields

Field	Type	Required	Constraint	Purpose
`id`	string	MUST	Unique slug with date	Lookup key
`file`	string	MUST	Matches output filename	File reference
`title`	string	MUST	Human-readable	Display name
`date`	string	MUST	ISO 8601 (YYYY-MM-DD)	Temporal ordering
`status`	enum	MUST	`complete\|partial\|blocked`	Progress tracking
`topics`	array	MUST	1+ string items	Categorization
`key_findings`	array	MUST	3-7 string items	Executive summary
`actionable`	boolean	MUST	true/false	Requires action?
`needs_followup`	array	MUST	Task IDs or empty	Handoff coordination

5.2 Optional Fields

Field	Type	Purpose
`timestamp`	string	ISO 8601 datetime for precise ordering
`linked_tasks`	array	CLEO task IDs this research relates to
`agent_type`	string	Subagent role identifier (see 5.2.1)
`tokens_spent`	number	Token usage estimate (informational only)

5.2.1 agent_type Field

The agent_type field categorizes subagent output by role, enabling filtering and analysis of research by agent specialization.

Value	Description	Use Case
`research`	Default. Investigative/exploratory work	Topic research, competitive analysis
`implementation`	Code implementation tasks	Feature development, bug fixes
`validation`	Testing and verification	Test writing, compliance checks
`documentation`	Documentation creation	Docs writing, README updates
`analysis`	Technical analysis	Architecture review, code review

Validation Rule: When present, agent_type MUST be one of the above values. If not present, defaults to "research". Filtering by agent_type:

# CLI filter
cleo research list --type implementation

# jq pattern
jq -s '[.[] | select((.agent_type // "research") == "implementation")]' MANIFEST.jsonl

Subagent Integration: Subagents SHOULD set agent_type in their manifest entries to enable orchestrators and users to filter research by work type.

5.3 needs_followup Semantics

The needs_followup array is the primary handoff mechanism:

{
  "needs_followup": ["T1578", "T1580"]
}

Value	Meaning	Orchestrator Action
Empty array `[]`	No downstream work	Move to next independent task
Task IDs `["T1234"]`	Specific tasks ready	Spawn agents for listed tasks
`["BLOCKED:<reason>"]`	Work blocked	Flag for human review

5.4 Manifest Query Patterns

Orchestrator SHOULD use these jq patterns for manifest queries:

# Get latest entry
jq -s '.[-1]' MANIFEST.jsonl

# Find entries with pending followup
jq -s '[.[] | select(.needs_followup | length > 0)]' MANIFEST.jsonl

# Filter by topic
jq -s '[.[] | select(.topics | contains(["orchestrator"]))]' MANIFEST.jsonl

# Get all key_findings for an epic's research
jq -s '[.[] | select(.linked_tasks | contains(["T1575"])) | .key_findings] | flatten' MANIFEST.jsonl

# List actionable items
jq -s '[.[] | select(.actionable == true) | {id, title, needs_followup}]' MANIFEST.jsonl

Part 6: Task Linking Protocol

6.1 Research-to-Task Linking

When research relates to a CLEO task, subagents SHOULD establish the link: Method 1: CLEO research link command

cleo research link <task-id> <research-id>

Method 2: Direct task note

cleo update <task-id> --notes "Linked research: <research-id> - <brief context>"

Method 3: Manifest field

{
  "linked_tasks": ["T1575", "T1576"]
}

6.2 Bidirectional Traceability

Direction	Storage	Query
Task → Research	Task notes field	`cleo show <task-id>`
Research → Task	Manifest `linked_tasks`	`jq 'select(.linked_tasks)' MANIFEST.jsonl`

6.3 Link Timing

Event	Link Action
Subagent starts task	Focus task; no link yet
Research complete	Add task to manifest `linked_tasks`
Task complete	Add research ID to task notes

Part 7: Dependency Resolution

7.1 Dependency Order Enforcement

Orchestrator MUST spawn agents in dependency order:

EPIC T1575
    │
    ├── T1576 (no deps) ────────────────▶ WAVE 0 (spawn first)
    │
    ├── T1578 (deps: T1576) ────────────▶ WAVE 1 (after T1576 complete)
    ├── T1580 (deps: T1576) ────────────▶ WAVE 1 (parallel with T1578)
    │
    ├── T1582 (deps: T1576) ────────────▶ WAVE 1
    ├── T1584 (deps: T1576) ────────────▶ WAVE 1
    ├── T1588 (deps: T1576) ────────────▶ WAVE 1
    │
    ├── T1586 (deps: T1582,T1584,T1588) ─▶ WAVE 2 (wait for all wave 1)
    ├── T1590 (deps: T1584) ────────────▶ WAVE 2
    │
    ├── T1592 (deps: T1586,T1590) ──────▶ WAVE 3
    │
    └── T1594 (deps: T1592) ────────────▶ WAVE 4

7.2 Parallel Spawn Rules

Rule	Constraint
Parallel OK	Tasks in same wave with no inter-dependencies
Serial REQUIRED	Task depends on another in same or later wave
Overlap PROHIBITED	Same task claimed by multiple agents

7.3 Spawn Decision

def should_spawn(task_id, completed_tasks):
    task = cleo_show(task_id)
    deps = task.get('depends', [])

    # All dependencies must be completed
    for dep in deps:
        if dep not in completed_tasks:
            return False

    return True

Part 8: Error Handling

8.1 Subagent Failure Modes

Failure	Detection	Recovery
No output file	`test -f <path>` fails	Re-spawn with clearer instructions
No manifest entry	`grep <id>` fails	Manual entry or rebuild
Wrong return message	String mismatch	Accept but log warning
Task not completed	Status != done	Orchestrator completes manually
Partial status	`status: partial`	Spawn continuation agent
Blocked status	`status: blocked`	Flag for human review

8.2 Orchestrator Recovery

# Rebuild manifest from files (disaster recovery)
for f in claudedocs/agent-outputs/*.md; do
  # Extract metadata and append to manifest
  cleo research show --file "$f" --format jsonl >> MANIFEST.jsonl.new
done
mv MANIFEST.jsonl.new MANIFEST.jsonl

8.3 Session Recovery

# Find orphaned work
cleo session list --status suspended

# Resume specific session
cleo session resume <session-id>

# Clean stale sessions
cleo session close <session-id> --force

Part 9: Context Protection

9.1 Token Budget Allocation

Component	Max Tokens	Strategy
Orchestrator context	10K	Manifest summaries only
Subagent prompt	4K	Task description + injection block
Subagent research	50K	Full file reading permitted
Return message	100	Fixed completion message

9.2 Context Protection Rules

Rule ID	Constraint
CTX-001	Orchestrator MUST NOT read research files > 100 lines
CTX-002	Orchestrator MUST use `cleo research list` over raw manifest read
CTX-003	Orchestrator MUST use `cleo show --brief` for task summaries
CTX-004	Subagent MUST NOT return content in response message
CTX-005	Manifest key_findings MUST be 3-7 items, one sentence each

9.3 Context-Driven Pause Protocol

The orchestrator MUST implement context-driven pausing to prevent context overflow and ensure graceful session handoffs.

9.3.1 Context Thresholds

Threshold	Percentage	Status	Action
OK	0-69%	`ok`	Continue orchestration
Warning	70-79%	`warning`	Wrap up current work, spawn final subagents
Critical	80-100%	`critical`	STOP immediately, generate HITL summary

Configuration (config.json):

{
  "orchestrator": {
    "contextThresholds": {
      "warning": 70,
      "critical": 80
    },
    "autoStopOnCritical": true,
    "hitlSummaryOnPause": true
  }
}

9.3.2 Pre-Spawn Context Check

Before spawning any subagent, orchestrator MUST call orchestrator_should_pause():

# Check if should pause before spawning
result=$(cleo orchestrator should-pause)
pause_status=$(echo "$result" | jq -r '.result.pauseStatus')

case "$pause_status" in
    ok)
        # Safe to spawn
        ;;
    warning)
        # Spawn final agents, prepare to wrap up
        ;;
    critical)
        # STOP - do not spawn, generate HITL summary
        ;;
esac

9.3.3 Pre-Spawn Compliance Check

Before spawning the next agent, orchestrator MUST verify the previous agent’s compliance:

# Verify previous agent before spawning next
result=$(cleo orchestrator pre-spawn-check --task T1235 --previous T1234)
can_spawn=$(echo "$result" | jq -r '.result.canSpawn')

if [[ "$can_spawn" != "true" ]]; then
    # Block spawn, handle violations
    echo "$result" | jq '.result.reasons'
fi

The pre-spawn check validates:

Context threshold: Not at critical level
Task status: Target task is pending
Previous compliance: Previous agent created manifest entry (if previous_task_id provided)

9.3.4 Protocol Injection Validation

All spawn prompts MUST contain the SUBAGENT PROTOCOL injection block. The orchestrator validates this via orchestrator_verify_protocol_injection():

# Validation function used by spawn commands
if ! orchestrator_verify_protocol_injection "$prompt"; then
    echo "PROTOCOL VIOLATION: Missing SUBAGENT PROTOCOL marker"
    echo "FIX: cleo research inject"
    return 60  # EXIT_PROTOCOL_MISSING
fi

Enforcement Rules:

ORC-006: MUST verify protocol injection before spawn
E_PROTOCOL_MISSING (exit 60): Returned when marker not found
Auto-fix available: cleo research inject provides the protocol block

9.3.5 Auto-Stop Procedure

When context reaches critical threshold with autoStopOnCritical: true:

Generate HITL Summary: Progress, remaining tasks, resume command
End Session: Clean session end with summary note
Return Handoff: JSON with complete resume instructions

# Auto-stop function
result=$(cleo orchestrator check-and-stop --epic T1575)
action=$(echo "$result" | jq -r '.result.action')

if [[ "$action" == "stopped" ]]; then
    echo "Orchestrator auto-stopped. Resume with:"
    echo "$result" | jq -r '.result.autoStop.resumeCommand'
fi

9.3.6 HITL Summary Format

Human-in-the-Loop summary provides complete context for resumption:

{
  "timestamp": "2026-01-26T12:00:00Z",
  "stopReason": "context-limit",
  "session": {
    "id": "session_20260126_...",
    "epicId": "T1575",
    "focusedTask": "T1580",
    "progressNote": "Completed wave 1 tasks"
  },
  "progress": {
    "completed": 5,
    "pending": 8,
    "active": 1,
    "blocked": 0,
    "percentComplete": 36
  },
  "readyToSpawn": [
    {"id": "T1582", "title": "...", "priority": "high"}
  ],
  "handoff": {
    "resumeCommand": "cleo session resume session_20260126_...",
    "nextSteps": [
      "Run: cleo session resume session_20260126_...",
      "Check progress: cleo list --parent T1575",
      "Review dashboard: cleo dash"
    ]
  }
}

Part 10: Integration Points

10.1 CLEO Commands for Orchestration

Command	Purpose	When Used
`cleo session start --scope epic:T1575`	Begin orchestration	First agent spawn
`cleo focus set <id>`	Mark active work	Subagent start
`cleo complete <id>`	Mark task done	Subagent finish
`cleo research link <tid> <rid>`	Link research to task	After research complete
`cleo analyze --parent <epic>`	Find next work	Orchestrator planning
`cleo deps <id>`	Check dependencies	Before spawn decision
`cleo research list`	List research entries (context-efficient)	Manifest query
`cleo research list --type <type>`	Filter by agent_type	Find specific research types
`cleo research show <id>`	Get research entry details	Deep-dive on specific research
`cleo research pending`	Get entries with needs_followup	Find next agent work
`cleo research links <task-id>`	Get research linked to task	Traceability check
`cleo orchestrator should-pause`	Check context threshold	Before each spawn
`cleo orchestrator pre-spawn-check`	Combined pre-spawn validation	Before spawning next agent
`cleo orchestrator check-and-stop`	Check and auto-stop if critical	Spawn decision point
`cleo research inject`	Get protocol injection block	Building subagent prompts

10.2 File Locations

File	Purpose	Created By
`claudedocs/agent-outputs/`	Research output directory	`cleo research init`
`MANIFEST.jsonl`	Research index	Subagents (append)
`SUBAGENT_PROTOCOL.md`	Protocol reference	`cleo research init`
`INJECT.md`	Copy-paste injection block	`cleo research init`

Spec	Relationship
ORCHESTRATOR-SPEC.md	tmux-based multi-agent spawning
IMPLEMENTATION-ORCHESTRATION-SPEC.md	7-agent implementation pipeline
MULTI-SESSION-SPEC.md	Session scope isolation
SUBAGENT_PROTOCOL.md	Research output format

Part 11: Compliance Checklist

11.1 Orchestrator Compliance

Core Behavior (ORC-001 to ORC-005):

Never reads full research files (ORC-003)
Always spawns in dependency order (ORC-004)
Uses manifest for summaries (ORC-005)
Delegates all implementation work (ORC-002)
Executes session startup protocol

Pre-Spawn Verification (ORC-006 to ORC-009):

Verifies protocol injection in spawn prompt (ORC-006)
Checks context thresholds before spawn (ORC-007)
Verifies previous agent compliance (ORC-008)
Auto-stops at critical threshold (ORC-009)

Verification Functions:

Function	Rule	Purpose
`orchestrator_verify_protocol_injection()`	ORC-006	Validates SUBAGENT PROTOCOL marker in prompt
`orchestrator_should_pause()`	ORC-007, ORC-009	Checks context percentage against thresholds
`orchestrator_verify_compliance()`	ORC-008	Verifies previous agent created manifest entry
`orchestrator_pre_spawn_check()`	All	Combined validation before spawn

11.2 Subagent Compliance

Writes output file to correct path
Appends manifest entry with all required fields
Returns only completion message (no content in response)
Sets focus before work (cleo focus set <id>)
Completes task when done (cleo complete <id>)
Sets needs_followup for handoff
Sets agent_type appropriately (research|implementation|validation|documentation|analysis)

11.3 Manifest Compliance

All required fields present (id, file, title, date, status, topics, key_findings, actionable, needs_followup)
Status is valid enum value (complete|partial|blocked)
key_findings is 3-7 items, one sentence each
Date is ISO 8601 format (YYYY-MM-DD)
needs_followup contains valid task IDs or BLOCKED: entries
agent_type (if present) is valid enum value

11.4 Compliance Verification Gates

Pre-spawn compliance verification ensures the orchestration chain maintains integrity:

┌─────────────────────────────────────────────────────────────────────────┐
│                     PRE-SPAWN COMPLIANCE GATES                          │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│  GATE 1: Protocol Injection                                             │
│  ├── Check: Prompt contains "SUBAGENT PROTOCOL" marker                  │
│  ├── Function: orchestrator_verify_protocol_injection()                 │
│  └── Exit Code: 60 (E_PROTOCOL_MISSING) if failed                       │
│                                                                         │
│  GATE 2: Context Threshold                                              │
│  ├── Check: Context percentage < critical threshold (80%)               │
│  ├── Function: orchestrator_should_pause()                              │
│  └── Exit Code: 2 if critical, 1 if warning, 0 if OK                    │
│                                                                         │
│  GATE 3: Previous Agent Compliance                                      │
│  ├── Check: Previous agent created valid manifest entry                 │
│  ├── Function: orchestrator_verify_compliance()                         │
│  └── Exit Code: 62 (E_MANIFEST_ENTRY_MISSING) or 6 (E_VALIDATION)       │
│                                                                         │
│  GATE 4: Task Status                                                    │
│  ├── Check: Target task exists and has status "pending"                 │
│  ├── Function: orchestrator_pre_spawn_check()                           │
│  └── Exit Code: 4 (E_NOT_FOUND) if task missing or wrong status         │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

Combined Check Pattern:

# Use pre_spawn_check for all gates in one call
result=$(orchestrator_pre_spawn_check "$task_id" "$epic_id" "$previous_task_id")
can_spawn=$(echo "$result" | jq -r '.result.canSpawn')

if [[ "$can_spawn" != "true" ]]; then
    # Log violations and halt
    echo "$result" | jq -r '.result.reasons[] | .code + ": " + .message'
    exit 1
fi

# All gates passed - safe to spawn
orchestrator_spawn "$task_id"

Appendix A: Quick Reference

A.1 Orchestrator Mantra

Stay high-level. Delegate everything. Read only manifests. Spawn in order.

A.2 Subagent Mantra

Focus. Execute. Write file. Append manifest. Complete task. Return message.

A.3 Manifest Query Cheatsheet

# Latest entry
jq -s '.[-1]' MANIFEST.jsonl

# Pending followups
jq -s '[.[] | select(.needs_followup | length > 0)]' MANIFEST.jsonl

# By topic
jq -s '[.[] | select(.topics | contains(["X"]))]' MANIFEST.jsonl

# Actionable items
jq -s '[.[] | select(.actionable)]' MANIFEST.jsonl

# By agent_type (defaults to "research" if missing)
jq -s '[.[] | select((.agent_type // "research") == "implementation")]' MANIFEST.jsonl

# All implementation entries (CLI preferred)
cleo research list --type implementation

A.4 Pre-Spawn Check Cheatsheet

# Check if should pause before spawn
cleo orchestrator should-pause | jq '.result.pauseStatus'

# Combined pre-spawn validation
cleo orchestrator pre-spawn-check --task T1235 --previous T1234

# Check and auto-stop if critical
cleo orchestrator check-and-stop --epic T1575

# Verify protocol injection in prompt
orchestrator_verify_protocol_injection "$prompt" "true"

Appendix B: Revision History

Version	Date	Changes
1.0.0	2026-01-18	Initial specification
1.1.0	2026-01-26	Added ORC-006 to ORC-009 enforcement rules; Context-driven pause protocol (9.3); agent_type field documentation (5.2.1); Compliance verification gates (11.4); Pre-spawn check functions

Specification v1.1.0 - Orchestrator Protocol Epic: T1575 - Orchestrator Protocol Implementation Task: T2379 - Update Specification Documents

Overview

System Architecture

RCSD-IVTR Protocol Stack

Protocol Definitions

Agent Protocols

Core Specifications

Strategic

MCP Server

Metrics & Validation

Protocol Enforcement

System Specifications

Feature Specifications

Release & Changelog

Schemas

Development Guides

Troubleshooting

​Orchestrator Protocol Specification

​RFC 2119 Conformance

​Part 1: Overview

​1.1 Purpose

​1.2 Authority

​1.3 Scope

​Part 2: Orchestrator Behavior Rules

​2.1 Core Constraints

​2.2 Delegation Decision Tree

​2.3 Permitted Orchestrator Actions

​2.4 Prohibited Orchestrator Actions

​Part 3: Subagent Protocol

​3.1 Subagent Injection Block

​3.2 Subagent Workflow

​3.3 Subagent Return Contract

​Part 4: Session Startup Protocol

​4.1 Every New Conversation

​4.2 Decision Matrix

​4.3 Session Resume Flow

​Part 5: Manifest Schema

​5.1 Required Fields

​5.2 Optional Fields

​5.2.1 agent_type Field

​5.3 needs_followup Semantics

​5.4 Manifest Query Patterns

​Part 6: Task Linking Protocol

​6.1 Research-to-Task Linking

​6.2 Bidirectional Traceability

​6.3 Link Timing

​Part 7: Dependency Resolution

​7.1 Dependency Order Enforcement

​7.2 Parallel Spawn Rules

​7.3 Spawn Decision

​Part 8: Error Handling

​8.1 Subagent Failure Modes

​8.2 Orchestrator Recovery

​8.3 Session Recovery

​Part 9: Context Protection

​9.1 Token Budget Allocation

​9.2 Context Protection Rules

​9.3 Context-Driven Pause Protocol

​9.3.1 Context Thresholds

​9.3.2 Pre-Spawn Context Check

​9.3.3 Pre-Spawn Compliance Check

​9.3.4 Protocol Injection Validation

​9.3.5 Auto-Stop Procedure

​9.3.6 HITL Summary Format

​Part 10: Integration Points

​10.1 CLEO Commands for Orchestration

​10.2 File Locations

​10.3 Related Specifications

​Part 11: Compliance Checklist

​11.1 Orchestrator Compliance

​11.2 Subagent Compliance

​11.3 Manifest Compliance

​11.4 Compliance Verification Gates

​Appendix A: Quick Reference

​A.1 Orchestrator Mantra

​A.2 Subagent Mantra

​A.3 Manifest Query Cheatsheet

​A.4 Pre-Spawn Check Cheatsheet

​Appendix B: Revision History