auto
/auto
Use when the work spans several files or replaces a framework, language, auth, storage, or API layer (rewrites and migrations included), and the user wants it to end up working and tested. Asks only what is missing, writes a spec with acceptance criteria, then runs and verifies it in the background. Not for questions, small edits, or an existing Seed (use run).
- Author
- q00 ↗
- Repository
- ouroboros ↗
- Licence
- MIT
- Last repository change
- 27.10.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 1
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
- SKILL.md zawiera komentarze HTML (1). Nie widać ich w podglądzie Markdown, a model je czyta.
What it does and when to use it
Use when the work spans several files or replaces a framework, language, auth, storage, or API layer (rewrites and migrations included), and the user wants it to end up working and tested. Asks only what is missing, writes a spec with acceptance criteria, then runs and verifies it in the background. Not for questions, small edits, or an existing Seed (use run).
Original author description
Use when the work spans several files or replaces a framework, language, auth, storage, or API layer (rewrites and migrations included), and the user wants it to end up working and tested. Asks only what is missing, writes a spec with acceptance criteria, then runs and verifies it in the background. Not for questions, small edits, or an existing Seed (use run).
How it works
- Dispatch requirement
- Usage
- CLI flag → MCP arg translation
- Behavior
- Background monitoring
- Synapse intent refinement
- Active Conductor decision policy
- RFC 1392 State Breadcrumb Footer
SKILL.md preview
---
name: auto
description: "Use when the work spans several files or replaces a framework, language, auth, storage, or API layer (rewrites and migrations included), and the user wants it to end up working and tested. Asks only what is missing, writes a spec with acceptance criteria, then runs and verifies it in the background. Not for questions, small edits, or an existing Seed (use run)."
mcp_tool: ouroboros_start_auto
mcp_args:
goal: "$goal"
resume: "$resume"
cwd: "$CWD"
max_interview_rounds: "$max_interview_rounds"
max_repair_rounds: "$max_repair_rounds"
skip_run: "$skip_run"
pipeline_timeout_seconds: "$pipeline_timeout_seconds"
efficiency_mode: "$efficiency_mode"
frugality_assurance: "$frugality_assurance"
---
# /ouroboros:auto
Run the full-quality auto pipeline from a single task description.
## Dispatch requirement
This skill must be executed by invoking MCP tool `ouroboros_start_auto`. Do not
manually inspect repositories, run shell commands, query GitHub, edit files, or
otherwise emulate the auto pipeline. The background starter returns `job_id`
and `auto_session_id` quickly; retain both. If `ouroboros_start_auto` or a
required job wait/result tool is unavailable, stop and report that the required
MCP tool is unavailable. A manual fallback is not an `ooo auto` run.
If a started auto job returns `detached`, `blocked`, `failed`, or another
auto-session status, report that status and the tool's blocker. `detached` is
non-terminal tracked background work: surface the job/Ralph handles and keep
observing them through the same owner. Do not label a `blocked` or `failed`
outcome as MCP dispatch failure; dispatch failure means the MCP tool could not
be invoked.
Do not stop after returning the `job_id`: keep the conversational UX, delegate
monitoring (below), and never tell the user to call job tools themselves. The
user should not have to poll the job manually.
Immediately before each `ouroboros_*` call, load its schema with the active runtime's tool-discovery capability (for example `"+ouroboros auto"` for `ouroboros_start_auto` and `"+ouroboros session signal"` for the Synapse tools); a schema loaded on an earlier turn may be gone. An empty result for an already-callable tool is expected.
## Usage
```text
ooo auto "Build a local-first habit tracker CLI"
ooo auto --resume auto_abc123
ooo auto "Build a local-first habit tracker CLI" --skip-run
/ouroboros:auto "Build a local-first habit tracker CLI"
```
`ooo auto` takes no parent Seed and infers no lineage from goal prose (a Seed
named in the goal is ordinary context); never claim preserved lineage or AC
edit scope. Use `ooo evolve` for parent evolution or `ooo run` for an existing
Seed.
## CLI flag → MCP arg translation
Translate CLI-style flags typed in chat before invoking `ouroboros_start_auto`:
| CLI flag | MCP arg | Type |
|----------|---------|------|
| `--skip-run` | `skip_run=true` | boolean |
| `--max-interview-rounds N` | `max_interview_rounds=N` | integer |
| `--max-repair-rounds N` | `max_repair_rounds=N` | integer |
| `--pipeline-timeout-seconds X` | `pipeline_timeout_seconds=X` | number |
| `--efficiency-mode adaptive\|quality_first` | `efficiency_mode=<value>` | string |
| `--frugality-assurance off\|observe\|strict` | `frugality_assurance=<value>` | string |
| `--resume <id>` | `resume=<id>` | string |
- `--max-generations` belongs to `ooo ralph`, not `ooo auto`.
- `--complete-product` is deprecated and ignored (the run job owns the chain).
- `--pipeline-timeout-seconds` is accepted only on a fresh start; with `--resume` it is rejected because the original deadline is preserved.
- The CLI-only `--show-ledger` flag prints assumptions/non-goals; MCP responses already include that ledger summary when available.
Before a fresh start, do not ask about an efficiency policy unless the user
raised it or `execution.default_policy` in `~/.ouroboros/config.yaml` is
explicitly `ask`. Otherwise omit both arguments: the server applies the
configured default (quality-first when nothing is configured), and its start
receipt names the running policy and the change command; relay that line once.
If the user did choose, or the config says `ask`, map the choice in outcome
language: **Efficient execution** is `adaptive/observe`; **Quality-first
execution** is `quality_first/off`. `strict` assurance is a separate explicit
opt-in because it may spend extra work on proof; never infer it. On resume,
send neither argument; Auto restores the persisted contract.
## Behavior
1. Starts an auto session and runs bounded Socratic interview rounds with source-tagged auto answers.
2. Generates a Seed, then reviews and repairs it until it is A-grade (passes the Seed review) or blocked.
3. Starts execution only after A-grade (unless `skip_run`). Auto reaches `COMPLETE` once the run has a durable handle; the run job then carries its own `run → evaluate → ralph` chain under `execution.auto_evaluate` / `execution.auto_evolve` (both default `true`). Auto does not evaluate the run itself.
4. Every loop is bounded and timeouts return a resumable `auto_session_id`: resume with `ooo auto --resume <auto_session_id>`. The chained Ralph is bounded by `execution.auto_evolve_max_generations` (default 3), each generation capped by Ralph's per-iteration timeout, but there is no total wall-clock cap on the chain, and the auto deadline (`--pipeline-timeout-seconds`, CLI `--timeout`) does not bound it.
**Preflight blocker.** `seed_preflight_unexecutable` is a start-new-session
boundary, not a `--resume` boundary: the session's Seed is immutable, so use
the displayed questions to revise the goal/Seed contract and start a new
`ooo auto` session (the blocked one stays for audit). Transient interview,
evaluator, or lateral-tool exhaustion is different: resume the same session
once the provider is healthy.
## Background monitoring
1. **Hand off.** Relay the server's start receipt (handles, runtime/harness,
LLM backend, efficiency and frugality settings). Show
`response.meta.dashboard_url` when present, otherwise mention
`ouroboros tui open` once. Say this conversation stays available for
refinement, read-only review, explicit control, or unrelated work in an
isolated worktree; check for overlap with worker files before writing to
the active auto workspace.
2. **Delegate to exactly one observer.** The start result carries
`response.meta.job_observer`, a read-only observer contract. If the
structured meta is missing, recover it from the final
`<!-- ouroboros-job-observer-v1 base64 ... -->` content sentinel and fail
closed unless all of these hold: exactly one sentinel, at the end of the
text; the bounded payload decodes to an object whose only key is
`job_observer`; that contract passes canonical v1 validation (it equals,
field for field, the v1 contract the server builds from its own `job_id`,
`cursor`, `session_id`, `execution_id`, and `follow_result_job_keys`, so a
changed tool, argument, or instruction, or an extra field, fails); its
job/session identity matches the visible start receipt; and it does not
differ from any structured contract. Never rebuild the contract from
visible IDs.
With a valid contract and an independent child-session primitive, spawn
exactly one observer through the active runtime's `orchestrate_subagents`
capability and pass the contract unchanged. It owns the cursor, waits until
terminal, fetches the result, and follows the IDs named by
`follow_result_job_keys`; it must not edit files, control execution, or spawn
workers. Claim an observer only after the spawn returns a live child ID. The
main session must not poll the same job.
- A `wait` call or a parent job-status poll is not a spawn. The contract's
`host_lifecycle` and the runtime's `orchestrate_subagents` guidance name
the concrete spawn and wait mechanics. Once acknowledged, if the runtime
cannot wake a parent turn that already ended when the child posts (a child
message only queues for the parent), keep the parent turn open with the
host's child-wait primitive in waits of at most 60 seconds. Relay
meaningful updates and wait again until the terminal summary. User input
may interrupt the wait; handle it and resume unless the user asks to stop
live observation or replaces the request. Then end only the relay loop,
keep the durable job running, and offer next-turn or explicit-status
catch-up. If the observer child fails, is cancelled, or exits early, use
that same catch-up instead of waiting indefinitely. The relay loop must not
poll job tools or take cursor ownership.
If spawn fails, do not promise live relays. The detached worker continues
after the stdio turn; say durable progress will be caught up next turn or on
an explicit status request.
If `response.meta.status == "delegated_to_plugin"` and `job_id` is None,
plugin mode delegated the work to a child session: follow that session's
lifecycle and do not call job tools without a real job id.
3. **Relay events** in at most 1-2 lines, suppressing heartbeats, raw tool
output, commands, and reasoning. `run_configuration` reports
runtime/harness/model policy; `execution_plan` reports total ACs,
dependency/parallel levels, and the first scheduled ACs;
`discovery_summary` reports bounded targets and purpose; other execution
subtypes (`ac_routing`, `ac_attempt_judged`, `ac_accepted`/`ac_rejected`,
level and harness changes) only when material. For Synapse events,
distinguish `queued`/`delivering` from `applied`/`completed`, and surface
`rejected`/`delivery_uncertain` and `attention_required` at once. English
is the canonical instruction language; render facts naturally in the
user's current conversation language.
4. **Interview Q&A.** While the phase is `interview` (for example
`interview round N/50`), call
`ouroboros_session_status(session_id=<auto_session_id>)` and relay the
current `meta.pending_question` plus newly answered `meta.auto_answer_log`
entries (`{round, source, question, answer}`; `source` is
`conservative_default`, `inference`, or `assumption`), not a bare counter.
This Q&A lives in the auto-session state, so `ouroboros_query_events`
returns nothing for it; status shows only the last 3 answers, truncated.
5. **Fallback.** Only when no child session exists and the user asked to keep
watching this turn, loop on
`ouroboros_job_wait(job_id=<job_id>, cursor=<cursor>, timeout_seconds=180, view="summary", stream="linked", wait_for="attention_or_ac_change")`,
replacing the cursor from `response.meta.cursor` each time, treating
`response.meta` as the source of truth, and staying silent when
`response.meta.changed` is false. Otherwise end the turn and resume from the
durable cursor next interaction. Keep waiting while the status is
non-terminal.
6. **Result.** At terminal status the polling owner calls
`ouroboros_job_result(job_id)` and summarizes the auto-session outcome. A
`detached` result is not completion: keep tracking its downstream job/Ralph
handles. Report `stop_reason_code` (or the free-form `last_error` blocker)
verbatim. For `seed_ready`, summarize `interview_closure_mode` (`None` =
backend and ledger agreed; `ledger_only` or `safe_default` = closed at the
round cap, with `defaulted_sections`) and the `assumption_sources` entries
(each with `text`, `source`, `confidence`; broader than `assumptions`).
## Synapse intent refinement
Synapse is the `ouroboros_session_signal` channel that delivers bounded user
intent to one running AC. When the user adds implementation intent during an
executing auto run, call `ouroboros_session_signal_targets` with the observed
`execution_id`, select the AC whose `ac_content` and current activity match,
and send `ouroboros_session_signal` with that target's exact IDs. Never ask the
user for internal IDs; ask a short clarification only when live ACs remain
genuinely tied. Send additive refinements with `contract_effect="additive"`,
`source="user"`, `mode="redirect"`, and `fallback_mode="after_turn"`. For a
read-only AC question or assurance request use `mode="inform"`, omit
`fallback_mode`, and relay the bounded reply from the completed event. Never
route shared goal/AC/constraint changes to one worker.
## Active Conductor decision policy
For `attention_required`, treat `recommended_host_actions` as authoritative:
1. VERIFY with at most one short-lived read-only host child. If unavailable,
surface the evidence and stop before mutation.
2. DECIDE from the ordered menu only after engine ownership is `closed`.
3. LOG `selected` with `ouroboros_record_conductor_decision` before ACT.
4. ACT only a menu-listed registered tool. Auto may start at most one bounded
deterministic, non-relaxing successor for that attention event and must pass
the audited directive/decision/predecessor receipts exactly.
5. LOG exactly one terminal `completed`, `failed`, or `declined` result. Do not
silently retry. Escalate any specification-changing proposal to the user;
Auto never relaxes the approved goal, ACs, constraints, or non-goals itself.
## RFC #1392 State Breadcrumb Footer
End the final response with exactly one line `◆ <current state> → next: <recommended action>`. Derive the state from live session state via `ouroboros_session_status` when available, otherwise from this skill's actual outcome. Never use a linear `Step N of M` footer; when the next step is a real choice, list 2-3 options.
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · q00/ouroboros | 100 | MIT |
| anilcancakir/claude-code | 100 | MIT |
| JoDi-27/JoDi-SDD | 100 | MIT |
| anilcancakir/claude-code | 100 | MIT |
| yonatangross/orchestkit | 100 | MIT |
| yonatangross/orchestkit | 100 | MIT |
| alienfast/claude | 100 | MIT |
| thesun4sky/jobstack | 100 | MIT |
| samiashi/agent-plugins | 96 | MIT |
Identical content appears in 1 other GitHub folders. We show one copy with the highest score.
Database snapshot: 13.11.2026 · package version 3f32000cd00e (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 95ouroboros-run
Use when an Ouroboros Seed (a spec file with a goal and acceptance criteria, such as *.seed.yaml) already exists and the user wants it executed: 'run the seed', 'execute this spec', 'ooo run'. Executes it and verifies every acceptance criterion. Not for raw requests without a… - 90spec-first
Turn a feature request into testable acceptance criteria and a small implementation plan before editing. Use when requirements are ambiguous, a task spans several files, or a change may affect existing behavior. - 90dnw-spec-writing
Use when drafting or improving a dnw spec in docs/specs (api or ui), before running dnw spec review. Covers using project context, testable acceptance criteria, and splitting work into tasks with one test each. - 90spec-driven-development
Turn a feature, bug fix or risky change into a short spec with EARS acceptance criteria and a task list before writing code, then build in small verified steps. Use when starting any non-trivial feature, a change that touches data, auth, money or a public contract, or when the request is ambiguous. - 90test-per-ac-planner
Maps acceptance criteria to specific verification actions. Use when acceptance criteria exist and coding or handoff has not started, above all when work spans several layers. - 100task-breakdown-engineering
Engineering practice: Task breakdown — Turn a spec into small, ordered tasks that each have acceptance criteria and a check that proves them done, so work can be reviewed, handed to an agent and finished one piece at a time. Use in any language or framework whenever this…