From egregore
Orchestrates manifest work items through development pipeline by delegating to specialist skills, advancing states, and enforcing token budget and context limits. Use for autonomous multi-item processing or resuming interrupted sessions.
npx claudepluginhub athola/claude-night-market --plugin egregoreThis skill uses the workspace's default tool permissions.
- [Overview](#overview)
Searches, retrieves, and installs Agent Skills from prompts.chat registry using MCP tools like search_skills and get_skill. Activates for finding skills, browsing catalogs, or extending Claude.
Searches prompts.chat for AI prompt templates by keyword or category, retrieves by ID with variable handling, and improves prompts via AI. Use for discovering or enhancing prompts.
Guides MCP server integration in Claude Code plugins via .mcp.json or plugin.json configs for stdio, SSE, HTTP types, enabling external services as tools.
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.
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.
Before launching the orchestrator, ensure the manifest has the correct run mode:
--bounded flag): set "indefinite": true
in the manifest. The egregore will scan for new work after
completing all items and run until dismissed.--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.
Follow these steps exactly. Each iteration processes one pipeline step for one work item.
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."
item = manifest.next_active_item()
If item is None, all work is done.
Save the manifest, report completion, and exit.
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.
Call Skill() or execute the mapped action.
Pass any required context (branch name, issue ref, etc.)
from the work item.
On success:
manifest.advance(item.id) to move to the next step.item.attempts to 0.On failure:
manifest.fail_current_step(item.id, reason).item.attempts < item.max_attempts, retry the same
step on the next iteration.item.status is now "failed", log the failure and
move to the next work item.Estimate context window usage. If usage exceeds 80%:
.egregore/continuation.json with the current item ID,
stage, and step.Skill(conserve:clear-context).If the last skill call returned a rate limit error:
budget.json via
budget.record_rate_limit(cooldown_minutes).budget.json.notify.py).CronCreate to schedule a one-shot resume prompt at
the cooldown expiry time. The session stays alive and
resumes automatically with context preserved.Go back to step 2. Continue until all items are completed, all items are failed, or a budget limit is reached.
| Stage | Step | Skill/Action |
|---|---|---|
| intake | parse | Parse prompt or fetch issue via gh issue view |
| intake | validate | Validate requirements are actionable |
| intake | prioritize | Order by complexity (single item = skip) |
| build | brainstorm | Skill(attune:project-brainstorming) |
| build | specify | Skill(attune:project-specification) |
| build | blueprint | Skill(attune:project-planning) |
| build | execute | Skill(attune:project-execution) |
| quality | code-review | Skill(pensive:code-refinement) |
| quality | unbloat | Skill(conserve:bloat-detector) |
| quality | code-refinement | Skill(pensive:code-refinement) |
| quality | update-tests | Skill(sanctum:test-updates) |
| quality | update-docs | Skill(sanctum:doc-updates) |
| ship | prepare-pr | Skill(sanctum:pr-prep) |
| ship | pr-review | Skill(sanctum:pr-review) |
| ship | fix-pr | Apply review fixes |
| ship | merge | gh pr merge (if auto_merge enabled) |
The intake stage steps (parse, validate, prioritize) are
handled inline by the orchestrator.
See modules/intake.md for details.
The orchestrator runs inside a finite context window. To avoid losing state when the window fills:
.egregore/continuation.json with a snapshot of
the current position.Skill(conserve:clear-context).continuation.json and resume from
the saved position. The manifest on disk is the source of
truth for pipeline progress.manifest.continuation_count each time a
context-overflow handoff occurs.This protocol ensures zero lost progress across context boundaries.
After loading state (step 1), schedule a recurring heartbeat that both reports status and recovers stalled pipelines:
CronCreate(
cron: "*/5 * * * *",
prompt: "Check .egregore/manifest.json. If there are pending or active items that are not being processed, resume the orchestration loop by invoking Skill(egregore:summon). Otherwise, report status via /egregore:status.",
recurring: true
)
This serves two purposes:
The cron task auto-expires after 7 days by default. Use
durable: true to persist across restarts, or
CronDelete to cancel early.
Egregore sessions consume API tokens across a budget window (default: 5 hours). The budget protocol prevents runaway spending:
budget.json for an
active cooldown. If is_in_cooldown(budget) returns
true, exit and let the watchdog retry later.budget.record_rate_limit(cooldown_minutes).
The cooldown duration equals the API retry-after header
plus config.budget.cooldown_padding_minutes.budget.json, alert the
overseer, and exit with code 0.budget.json before relaunching.
It will not start a new session until the cooldown
expires.See modules/budget.md for the full calculation and state
schema.
Each work item allows up to max_attempts retries per step
(default: 3, configurable in config.json).
attempts < max_attempts,
the orchestrator retries the same step on the next
iteration. The manifest is saved between retries.attempts >= max_attempts, the item
status changes to "failed" and failure_reason is set.
The orchestrator moves to the next active item.modules/decisions.md) and proceed with the best
available option.