/summon

name: summon
description: Autonomous orchestrator for manifest work items through the development lifecycle. Use when running egregore to process a backlog automatically.
alwaysApply: false
category: orchestration
tags:
  - autonomous
  - pipeline
  - orchestrator
  - mission
dependencies:
  - attune:project-brainstorming
  - attune:project-specification
  - attune:project-planning
  - attune:project-execution
  - pensive:code-refinement
  - conserve:bloat-detector
  - sanctum:pr-prep
  - sanctum:pr-review
  - sanctum:commit-messages
  - conserve:clear-context
tools: []
progressive_loading: true
modules:
  - modules/pipeline.md
  - modules/budget.md
  - modules/intake.md
  - modules/decisions.md
  - modules/model-routing.md
role: entrypoint

Summon

Overview

Summon is the egregore orchestration loop. It reads the manifest (`.egregore/manifest.json`), selects the next active work item, maps the current pipeline step to a specialist skill, and invokes that skill. After each step it advances the pipeline, checks context and token budgets, and repeats until all items are completed or the budget is exhausted.

The orchestrator never re-implements phase logic. Each pipeline step delegates to an existing skill via `Skill()` calls. Summon only manages state transitions, retries, and budget guards.

When To Use

• Processing one or more work items through the full

intake-build-quality-ship pipeline.

• Resuming an interrupted egregore session (manifest already

exists with active items).

• Running autonomously under a watchdog that relaunches on

exit.

When NOT To Use

• Running a single skill in isolation (call the skill

directly instead).

• Exploratory work where the pipeline does not apply.
• When human review is needed before every step (use manual

skill invocations).

Launching the Orchestrator

**Always launch the orchestrator agent in the FOREGROUND.** Do not use `run_in_background: true`. The main session becomes the egregore: it blocks on the orchestrator agent until the egregore finishes or is dismissed.

Agent(
  subagent_type: "egregore:orchestrator",
  prompt: "<context about work items and current state>",
  run_in_background: false   // Required
)

If you launch the orchestrator in the background, the main session will have nothing to do and will stop. This defeats the entire purpose of the egregore. The stop hook cannot prevent this because background agents are detached.

The unattended night run

The orchestrator above is an agent inside a session. The night run is the other entry point: a plain process a watchdog can restart, for hours no session is guaranteed to last. It walks one handed-off item (gate, walk, proof). It exits with the gate's own code (1 to 4) when the item is refused and nothing ran, and with 5 when the walk broke after it started:

python3 "${CLAUDE_PLUGIN_ROOT}/scripts/night_run.py" \
  --item-dir .egregore/handoff/<item> --root .

Nothing inside a session starts it. Run it by hand or from a scheduler you configure. The watchdog from `/egregore:install-watchdog` does not start it: that watchdog relaunches a `claude -p` session that invokes this skill. See `modules/budget.md` for why the cooldown path differs.

Manifest Mode

Before launching the orchestrator, ensure the manifest has the correct run mode:

• **Default (no `--bounded` flag)**: set `"indefinite": true`

in the manifest. The egregore will scan for new work after completing all items and run until dismissed.

• **With `--bounded` flag**: set `"mode": "bounded"` in the

manifest. The egregore stops after all items are completed or failed.

If the manifest already exists and has `"mode": "bounded"` but the user did NOT pass `--bounded`, update the manifest to `"indefinite": true` before launching.

After launching, do NOT produce any summary, status table, or "what's happening" output. The orchestrator IS the session now. Let it run.

Orchestration Loop

Follow these steps exactly. Each iteration processes one pipeline step for one work item.

1. Load state

manifest  = Read(".egregore/manifest.json")
config    = Read(".egregore/config.json")
budget    = Read(".egregore/budget.json")

If `manifest.json` does not exist, stop with an error: "No manifest found. Run `egregore init` first."

2. Pick the next work item

item = manifest.next_active_item()

If `item` is `None`, all work is done. Save the manifest, report completion, and exit.

3. Map current step to a skill

Look up `item.pipeline_stage` and `item.pipeline_step` in the Pipeline-to-Skill Mapping table below. Determine the skill name or action to invoke.

4. Invoke the skill

Call `Skill()` or execute the mapped action. Pass any required context (branch name, issue ref, etc.) from the work item.

5. Handle the result

**On success:**

• Call `manifest.advance(item.id)` to move to the next step.
• Reset `item.attempts` to 0.
• Save the manifest.

**On failure:**

• Call `manifest.fail_current_step(item.id, reason)`.
• If `item.attempts < item.max_attempts`, retry the same

step on the next iteration.

• If `item.status` is now `"failed"`, log the failure and

move to the next work item.

• Save the manifest.

6. Check context budget

Estimate context window usage. If usage exceeds 80%:

1. Save the manifest to disk. 2. Write a continuation note to `.egregore/continuation.json` with the current item ID, stage, and step. 3. Invoke `Skill(conserve:clear-context)`. 4. The watchdog or caller will relaunch a fresh session that resumes from the saved state.

7. Check token budget

If the last skill call returned a rate limit error:

1. Record the rate limit in `budget.json` via `budget.record_rate_limit(cooldown_minutes)`. 2. Save `budget.json`. 3. Alert the overseer (see `notify.py`). 4. **Schedule in-session recovery** (attended sessions only): use `CronCreate` for a one-shot resume at the cooldown expiry. Its jobs live o