---
name: sdlc-autonomous
description: Start an autonomous ("factory mode") SDLC run from a task description, external work-item reference, story path, or greenfield idea, on hosts that support skills but not custom slash commands. Trigger on "run autonomously", "factory mode", "ship this without asking", or a request for the legacy `sdlc:autonomous` command. Parses free-form intent into a structured payload and hands off to sdlc-pipeline — carries no orchestration logic of its own. Not for: human-in-the-loop runs (sdlc-start), pre-sized small tasks (sdlc-task / sdlc-light), or carrying orchestration logic of its own.
version: 0.1.0
license: Apache-2.0
discoverable: true
author: agentic-os
---

# sdlc-autonomous

Skill-based entry point for autonomous-mode SDLC runs, for hosts (for example Codex) that
expose skills but not custom slash commands. Everything this skill does is intent
normalization and delegation — it holds zero workflow, QA, review, or git logic itself. All
phase execution lives in `sdlc-pipeline`; all gate resolution lives in `decision-router`.

Treat this skill as a thin adapter in front of the legacy `sdlc:autonomous` command, mirroring
whatever human-in-the-loop entry point exists alongside it in the same skill family.

## When to invoke

- The user says "run autonomously", "factory mode", or "ship this without asking".
- The user asks for the legacy `sdlc:autonomous` command on a host that has no slash-command
  support.

## What this skill does not do

- Does not implement any SDLC phase, QA check, code review, or test logic.
- Does not create branches, commits, or open an MR/PR — autonomous mode never auto-merges and
  never opens an MR/PR by itself; the delegated pipeline halts after its branch-ready phase
  and hand-off to an MR/PR tool is a separate, manual step.
- Does not resolve judgment gates directly — every gate routes through `decision-router`.
- Does not generate missing guide files, bypass the branch-guard, or auto-stash / hard-reset /
  force-push a dirty working tree absent explicit project policy allowing it.

## When the project owns implementation

Read `.agentic/agentic-sdlc/config.json` before delegating. A configured project orchestrator stays the sole
coordinator of its fleet even here — unattended mode changes who answers the
gates, not who owns the work. Hand it one bounded implementation request, consume
only summaries and serialized gate results, and stop at every human gate the
project declares.

Running unattended never relaxes a restriction: commit, push, migration, release
and production limits apply exactly as they do with someone watching.

## Inputs

| Field | Type | Default | Notes |
|---|---|---|---|
| `raw_input` | string | — | Task text, work-item reference, story path, or greenfield idea |
| `mode_flag` | string/enum | none | Only `--greenfield` is recognized |
| `escalate_on` | string[] | `["security", "breaking-change"]` | CSV or list-style input |

Recognized CLI-style flags inside `raw_input`: `--greenfield`, `--escalate-on`.

## Operating steps

1. **Parse `--greenfield`.** If the input contains `--greenfield "<text>"`, set
   `mode_flag = "--greenfield"` and capture `<text>` as `raw_input`.
2. **Parse `--escalate-on`.** If the input contains `--escalate-on <comma-list>`, split the list
   on commas into the `escalate_on` array. If absent, use the default
   `["security", "breaking-change"]`.
3. **Capture the remainder.** Whatever text is left unconsumed by the two flags becomes
   `raw_input` (verbatim, if no `--greenfield` flag was present).
4. **Delegate.** Invoke the `sdlc-pipeline` skill with `mode: "autonomous"` plus the three
   parsed fields — see payload shape below. Do not run any pipeline phase yourself.
5. **Gate resolution.** Every judgment gate inside the delegated pipeline resolves through
   `decision-router`, in this priority order: deterministic checks first, fast-path approvals
   second, a stand-in subagent invocation only as the last resort.
6. **Escalation.** The user is interrupted only when: routing confidence is low, or a detected
   in-flight risk flag intersects the run's `escalate_on` set.
7. **Precondition gate — `repo-guides`.** If required guide files under `.agentic/guides/` are
   absent, the pipeline halts immediately and the user is redirected to run the `repo-guides`
   skill first. This skill never generates guides itself.
8. **Branch-guard gate.** Must clear before any implementation-capable phase. Checks, in order:
   current branch; configured base branch; `git status --porcelain`; upstream tracking state;
   target-branch existence; dirty-state resolution; latest-base sync.
9. **Dirty-tree rule (autonomous mode).** A dirty working tree halts the run unless project
   policy explicitly allows auto-stash. Hard-reset or force-push-forward on a dirty tree is
   disallowed regardless of any other setting.
10. **Audit.** Every routed decision is appended to `<run_dir>/decisions.jsonl` for the run,
    regardless of outcome.

## Delegation payload

Field names and literal values below are exact — do not rename or restructure when calling
`sdlc-pipeline`:

```json
{
  "mode": "autonomous",
  "raw_input": "<as captured>",
  "mode_flag": "<--greenfield or none>",
  "escalate_on": ["security", "breaking-change"]
}
```

## Outputs

- A running (or halted-at-gate) `sdlc-pipeline` invocation in `mode: "autonomous"`.
- An audit trail at `<run_dir>/decisions.jsonl` covering every routed decision for the run.
- On success, a branch left at Phase 12 (branch-ready stop point) with no MR/PR opened.
  Hand the result to `mr-creator` (or an equivalent PR tool) as a separate, explicit step.
- On a precondition failure, a redirect instructing the user to run `repo-guides` before
  retrying.

## References

This skill carries no `references/` tree of its own — it has no workflow logic to document.
All reference material for phase behavior, gate checklists, and escalation rules lives in the
skills it delegates to:

- `sdlc-pipeline` — phase execution, including the Phase 12 branch-ready stop point.
- `decision-router` — gate priority order, escalation-rule evaluation, and the
  `decisions.jsonl` / `events.jsonl` audit ledger format.
- `repo-guides` — populates `.agentic/guides/`, the prerequisite this skill checks for.
- `mr-creator` — the manual follow-on step for opening an MR/PR once Phase 12 is reached.