@sulhadin/orchestrator 4.0.0-beta → 4.0.0

package/README.md

@@ -122,7 +122,7 @@ PM challenges scope, creates M1-user-auth with 3 phases
 
 **Role boundaries** — Enforced via `.claude/rules/`. PM cannot write code. Engineers cannot modify system files. Orchestrator cannot write features. Boundaries checked by file path, not by words.
 
-**Milestone isolation** — `inline` mode stops after each milestone (user compacts manually). `agent` mode spawns each milestone in its own sub-agent — context freed automatically, enabling 20+ milestones in a single `--auto` session.
+**Milestone isolation** — Every milestone runs in its own sub-agent — context freed automatically, enabling 20+ milestones in a single session. Normal mode asks before continuing; `--auto` chains milestones automatically.
 
 **Stuck detection** — Detects repeated failures, circular fixes, over-engineering. Tries different approach once, then escalates. Auto mode skips to next phase.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sulhadin/orchestrator",
-  "version": "4.0.0-beta",
+  "version": "4.0.0",
   "description": "AI Team Orchestration System — multi-role coordination for Claude Code",
   "bin": "bin/index.js",
   "scripts": {

package/template/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "orchestra",
   "description": "AI Team Orchestration — multi-role coordination with milestones, phases, and quality gates for Claude Code",
-  "version": "4.0.0-beta",
+  "version": "4.0.0",
   "author": {
     "name": "Sulhadin Öney"
   },

package/template/.orchestra/README.md

@@ -50,9 +50,9 @@ You can plan new milestones while the lead is executing another one.
 ### Terminal 2: `/orchestra start` (Execution)
 
 Lead reads milestones, derives the right team member identity from phase content, and delegates each phase to a sub-agent.
-Sub-agents implement + verify; lead commits. After milestone completion, behavior
-depends on `milestone_isolation` config: stops (inline) or continues to next (agent).
-Maintains `context.md` for resume capability.
+Sub-agents implement + verify; lead commits. Each milestone runs in its own sub-agent
+for context isolation. After completion, `--auto` continues to next milestone automatically;
+normal mode asks user before continuing. Maintains `context.md` for resume capability.
 
 ```
 /orchestra start
@@ -86,7 +86,7 @@ Hotfix (production bugs):
 ### Milestone Lock
 
 Lead claims a milestone by writing `Locked-By: {timestamp}` to milestone.md before execution.
-Other leads skip locked milestones. Lock expires after config.yml `thresholds.milestone_lock_timeout` minutes (default 120).
+Other leads skip locked milestones. Lock expires after 60 minutes.
 
 ### Pipeline Modes (Complexity)
 
@@ -101,25 +101,22 @@ PM sets `Complexity` on milestone (pipeline) and `complexity` on each phase (mod
 
 Defaults: config.yml `pipeline.default_pipeline` and `pipeline.default_complexity`.
 
-### Milestone Isolation
+### Milestone Execution
 
-Config `pipeline.milestone_isolation` controls how the lead handles multiple milestones:
-
-| Mode | Behavior | Best for |
-|------|----------|----------|
-| `inline` (default) | Lead runs milestone directly, **stops** after completion. User runs `/compact` then `/orchestra start` for next milestone. | Manual sessions, PC-based work |
-| `agent` | Lead spawns a sub-agent per milestone. Context freed automatically after each. Loops to next milestone. | `--auto` overnight batch runs |
+Every milestone runs in its own sub-agent for context isolation. After completion:
+- **Normal mode:** Lead asks "Continue to next milestone?" — user decides
+- **`--auto` mode:** Lead continues to next milestone automatically
 
 ```
-Inline mode:                          Agent mode:
-  /orchestra start                      /orchestra start --auto
-  → M1 executes → done → STOP          → Spawn Agent(M1) → done → freed
-  user: /compact                        → Spawn Agent(M2) → done → freed
-  /orchestra start                      → Spawn Agent(M3) → done → freed
-  → M2 executes → done → STOP          → All done
+/orchestra start                      /orchestra start --auto
+  → Spawn Agent(M1) → done             → Spawn Agent(M1) → done → freed
+  → "Continue to M2?" → yes            → Spawn Agent(M2) → done → freed
+  → Spawn Agent(M2) → done             → Spawn Agent(M3) → done → freed
+  → "Continue to M3?" → yes            → All done
+  → Spawn Agent(M3) → done
 ```
 
-In agent mode, the delegation is two-tier:
+Delegation is two-tier:
 ```
 Lead (lean dispatcher)
   └── Milestone Agent (fresh context)
@@ -210,7 +207,7 @@ Push is automatic after review passes. All other transitions are automatic.
 ### Rejection Handling
 
 If the user says **no** at any gate:
-- **RFC rejected** → Lead revises based on feedback, re-submits (max config `pipeline.max_rfc_rounds`)
+- **RFC rejected** → Lead revises based on feedback, re-submits (max 3 rounds)
 - **Milestone rejected** → PM revises in PM terminal
 
 Rejections are normal. The system does not stall — it loops back with feedback.
@@ -234,7 +231,7 @@ Lead calls reviewer agent
 **If approved-with-comments** → push immediately. Comments are logged in context.md.
 
 **If changes-requested** → Lead continues the phase's sub-agent via SendMessage with
-reviewer findings. Re-review triggered if fix >= config `re_review_lines` threshold.
+reviewer findings. Re-review triggered if fix >= 50 lines.
 
 ---
 
@@ -344,34 +341,16 @@ sequenceDiagram
 
     C->>C: git push → milestone done
 
-    alt Inline mode (default)
-        C->>C: STOP — user compacts and restarts
-    else Agent mode
-        C->>C: Next milestone? → loop or done
+    alt --auto mode
+        C->>C: Next milestone → loop or done
+    else Normal mode
+        C->>C: Ask user: "Continue to next?"
     end
 
     Note over PM: PM is free the entire time<br/>Can plan M2 while M1 executes
 ```
 
-### 2. Lead Execution Loop (Inline Mode)
-
-```mermaid
-sequenceDiagram
-    participant C as Lead
-
-    C->>C: Scan milestones/
-    Note over C: M1: in-progress<br/>M2: planning<br/>M3: done
-
-    C->>C: Resume M1 (read context.md)
-    C->>C: backend phase-2 (resuming)
-    C->>C: backend phase-3
-    C->>C: reviewer → approved
-    C->>C: Push → M1 done
-
-    Note over C: STOP. "Run /compact or /clear then /orchestra start"
-```
-
-### 3. Lead Execution Loop (Agent Mode)
+### 2. Lead Execution Loop
 
 ```mermaid
 sequenceDiagram
@@ -383,12 +362,16 @@ sequenceDiagram
     C->>MA: Spawn Agent(M1)
     MA->>MA: phase-1 → phase-2 → review → push
     MA-->>C: {status: done, retro: ...}
-    Note over C: Write retro, ~1-2k tokens retained
+    Note over C: ~1-2k tokens retained
 
-    C->>MA: Spawn Agent(M2)
+    alt --auto mode
+        C->>MA: Spawn Agent(M2) automatically
+    else Normal mode
+        C->>C: "Continue to M2?" → user says yes
+        C->>MA: Spawn Agent(M2)
+    end
     MA->>MA: phase-1 → phase-2 → review → push
     MA-->>C: {status: done, retro: ...}
-    Note over C: Write retro, ~1-2k tokens retained
 
     C->>C: No more milestones
     Note over C: "All done. Waiting for new work."

package/template/.orchestra/config.yml

@@ -22,36 +22,13 @@ pipeline:
   # When enabled, phases with depends_on: [] run in parallel
   parallel: disabled
 
-  # Milestone isolation mode: inline | agent
-  # inline: lead runs milestones directly, stops after each. User compacts manually. (default)
-  # agent: each milestone runs in its own sub-agent. Context freed automatically. Best for --auto.
-  milestone_isolation: inline
-
   # Default pipeline when milestone Complexity is missing
   default_pipeline: full  # quick | standard | full
 
   # Default phase complexity when not set by PM
   default_complexity: standard  # trivial | quick | standard | complex
 
-  # Max RFC rejection rounds before escalating to user
-  max_rfc_rounds: 3
-
-  # Max milestone review rounds before proceeding anyway with warnings
-  max_milestone_review_rounds: 3
-
 thresholds:
-  # Milestone lock timeout in minutes (stale locks are ignored)
-  milestone_lock_timeout: 120
-
-  # Fix cycle: re-review if fix exceeds this many lines
-  re_review_lines: 30
-
-  # Phase time limit in minutes (pause and report if exceeded)
-  phase_time_limit: 15
-
-  # Phase tool call limit (pause if exceeded without commit)
-  phase_tool_limit: 40
-
   # Stuck detection: max retries before escalation
   stuck_retry_limit: 3
 

package/template/.orchestra/roles/product-manager.md

@@ -16,6 +16,9 @@ one commit at a time. Push back and say no when it doesn't make sense.
 Can write: `.orchestra/milestones/*` (prd.md, milestone.md, grooming.md, phases)
 Cannot write: feature code, RFCs, architecture docs, review findings, system files
 
+Do NOT ask for approval to write milestone files — they are your ownership scope.
+Write directly, then inform the user what you changed.
+
 ## On Activation
 
 1. Read `.orchestra/config.yml` for pipeline settings
@@ -41,7 +44,7 @@ Cannot write: feature code, RFCs, architecture docs, review findings, system fil
 After creating milestone files, launch a milestone-reviewer sub-agent before
 marking the milestone as ready. This catches planning errors before lead executes.
 
-**Flow:** PM creates → reviewer sub-agent → PM fixes → reviewer again → max `pipeline.max_milestone_review_rounds`
+**Flow:** PM creates → reviewer sub-agent → PM fixes → reviewer again → max 3 rounds
 
 Launch sub-agent (general-purpose, model: sonnet) with this prompt:
 

package/template/agents/lead.md

@@ -21,8 +21,6 @@ When started:
 
 1. If `--auto`: print `Warning: Auto mode — RFC gate skipped, fully autonomous.` and proceed.
 2. Read `.orchestra/config.yml` for pipeline settings and thresholds.
-   - Read `pipeline.milestone_isolation` (default: `inline`).
-   - If `--auto` and `milestone_isolation: inline`: warn once: "Inline mode with --auto: lead stops after each milestone. Consider `milestone_isolation: agent` for batch runs."
 3. Read `.orchestra/README.md` for orchestration rules.
 4. Scan milestones:
    - Glob `.orchestra/milestones/*/milestone.md`
@@ -51,7 +49,7 @@ Default: config.yml `pipeline.default_pipeline` (default `full`).
 
 Before starting a milestone:
 1. Check milestone.md for `Locked-By` field
-2. If locked and < config.yml `thresholds.milestone_lock_timeout` minutes → skip this milestone
+2. If locked and < 60 minutes old → skip this milestone
 3. If no lock or stale → write `Locked-By: {timestamp}`
 4. On completion or failure → remove `Locked-By`
 
@@ -83,12 +81,9 @@ phases with the same skills.
 6. Read `rfc.md` from milestone directory → rfc_content (read once per milestone, cache; skip if not exists)
 7. Derive team member identity from phase content:
    - Read the phase's `## Objective`, `## Scope`, and `skills:` list
-   - Determine the right specialist identity for the job:
-     - Scope targets `api/`, `server/`, `db/`, `migrations/`, `services/` + backend skills → **backend engineer**
-     - Scope targets `app/`, `components/`, `pages/`, `styles/`, `ui/` + frontend skills → **frontend engineer**
-     - Scope targets `infra/`, `.github/`, `docker`, `ci/`, `terraform/` + devops skills → **devops engineer**
-     - Scope targets `rfc.md`, `architecture.md`, `adrs/` → **software architect**
-     - Mixed or unclear → **fullstack engineer**
+   - Determine the right specialist identity for the job
+     (backend, frontend, devops, architect, or fullstack engineer)
+     based on the phase content — no hardcoded directory rules
    - Generate an identity block: who they are + domain priorities + the golden rule
 
 ### 3. Delegate to Phase Sub-Agent
@@ -234,8 +229,8 @@ After all implementation phases (unless config says `review: skip`):
 5. **changes-requested** → fix cycle:
    - Use SendMessage to continue the last phase's sub-agent with reviewer findings
      (if sub-agent no longer available, launch new sub-agent with findings + identity)
-   - If fix < config `re_review_lines` → proceed
-   - If fix >= config `re_review_lines` → abbreviated re-review
+   - If fix < 50 lines → proceed
+   - If fix >= 50 lines → abbreviated re-review
 
 ## Approval Gates
 
@@ -245,49 +240,31 @@ Read gate behavior from config.yml:
 
 ## Rejection Flow
 
-- **RFC Rejected:** Ask feedback → architect sub-agent revises → re-submit (max config.yml `pipeline.max_rfc_rounds`).
+- **RFC Rejected:** Ask feedback → architect sub-agent revises → re-submit (max 3 rounds).
 
 ## Milestone Completion
 
-### Inline Mode (default)
-
-After push:
-1. Update milestone.md `status: done`, remove `Locked-By`.
-2. Proceed to "Next Milestone — Mode-Dependent Behavior" → Inline Mode.
-
-### Agent Mode
-
 Milestone agent handles push and returns structured result (see Milestone Agent Delegation).
 Lead processes the return:
 1. Update milestone.md `status: done`, remove `Locked-By`.
-2. Proceed to "Next Milestone — Mode-Dependent Behavior" → Agent Mode.
-
-## Next Milestone — Mode-Dependent Behavior
+2. Proceed to next milestone.
 
-Behavior after milestone completion depends on `pipeline.milestone_isolation`:
-
-### Inline Mode (default)
-
-After push:
-1. **STOP.** Print: "Milestone {id} complete and pushed."
-2. Do NOT loop to next milestone.
-
-### Agent Mode
+## Next Milestone
 
 After milestone agent returns:
 1. Re-scan `.orchestra/milestones/` using Glob (PM may have created new ones)
-3. If pending → spawn next milestone agent
-4. If none → "All milestones complete. Waiting for new work from PM."
+2. If pending milestones exist:
+   - `--auto` mode → spawn next milestone agent immediately
+   - Normal mode → ask user: "Milestone {id} complete. Continue to {next-id}?" → yes: spawn next, no: stop
+3. If none → "All milestones complete. Waiting for new work from PM."
 
 Context stays lean because all phase-level context lived in the (now ended)
 milestone agent. Lead only accumulates ~1-2k tokens per milestone
 (prompt + structured result).
 
-## Milestone Agent Delegation (Agent Mode Only)
+## Milestone Agent Delegation
 
-This section applies ONLY when config `pipeline.milestone_isolation: agent`.
-
-In agent mode, the lead becomes a two-tier dispatcher:
+Every milestone runs as a separate sub-agent. Lead is a two-tier dispatcher:
 - Lead spawns one milestone agent per milestone
 - Milestone agent spawns phase sub-agents (same as current phase delegation)
 - When milestone agent completes, its context is freed entirely
@@ -321,6 +298,12 @@ Sections: `## Status` (milestone state), `## Phases` (per-phase status — skip
 **Skills (unique, one per skill used in phases):**
 {skill file contents — deduplicated}
 
+## Git Rules (non-negotiable)
+- Do NOT create branches. Commit directly on the current branch.
+- Do NOT switch branches. Work on whatever branch is checked out.
+- Each phase completion → one conventional commit.
+- Push to origin only after review passes.
+
 ## Your Task
 Execute this milestone using the Phase Execution protocol:
 1. For each phase: pre-flight → derive identity → compose prompt → delegate to phase sub-agent → process result
@@ -404,7 +387,7 @@ Read context.md → skip phases marked `done` → resume from first non-done pha
 
 ## Hotfix Pipeline
 
-Hotfix always runs inline regardless of `milestone_isolation` setting — single-phase fast path, sub-agent isolation adds no value.
+Hotfix runs as a single-phase fast path — no milestone agent needed.
 
 When user types `/orchestra hotfix {description}`:
 1. Auto-create hotfix milestone + single phase

package/template/commands/start.md

@@ -8,10 +8,8 @@ The lead will:
 3. Delegate phases to sub-agents, load skills, implement code
 4. Trigger code review via reviewer agent
 5. Push automatically after review passes
-6. Behavior after milestone: stop (inline mode) or continue to next (agent mode)
+6. After milestone: `--auto` continues to next automatically, normal mode asks user
 
-Config `pipeline.milestone_isolation` controls post-milestone behavior:
-- `inline` (default): stops after each milestone. User compacts and restarts.
-- `agent`: spawns each milestone in sub-agent. Loops automatically. Best with `--auto`.
+Each milestone runs in its own sub-agent for context isolation.
 
 Pass `--auto` flag for fully autonomous mode (warns once, then skips all gates).

package/template/rules/phase-limits.orchestra.md

@@ -1,10 +1,3 @@
 # Phase Limits
 
-Read thresholds from `.orchestra/config.yml` (`phase_time_limit`, `phase_tool_limit`).
-
-**Time limit:** Phase exceeds limit → pause: "Phase-{N} exceeded {limit}min. Continue or stop?"
-In `--auto` mode: continue, log overage in context.md.
-
 **Scope guard:** Working on something NOT in phase acceptance criteria → STOP. Note in context.md, don't implement.
-
-**Tool call guard:** More tool calls than limit without committing → pause, assess: commit what you have or escalate.