# Ring:managing Dev Cycle

> Managing an in-progress development cycle without driving it: status reports phase, epic/gate progress, assertiveness, and elapsed time from current-cycle.json; cancel confirms, marks the cycle cancelled, and writes a partial feedback report. Use when checking the status of, or cancelling, a running dev cycle. Skip when no cycle is active or the question is general project status, not cycle-speci…

- **Type:** Skill
- **Install:** `agentstack add skill-lerianstudio-ring-managing-dev-cycle`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [LerianStudio](https://agentstack.voostack.com/s/lerianstudio)
- **Installs:** 0
- **Category:** [Cloud & Infrastructure](https://agentstack.voostack.com/c/cloud-infrastructure)
- **Latest version:** 0.1.0
- **License:** Apache-2.0
- **Upstream author:** [LerianStudio](https://github.com/LerianStudio)
- **Source:** https://github.com/LerianStudio/ring/tree/main/dev-team/skills/managing-dev-cycle
- **Website:** https://lerian.studio

## Install

```sh
agentstack add skill-lerianstudio-ring-managing-dev-cycle
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Cycle Management

## When to use
- User wants to check the status of a running development cycle
- User wants to cancel an active development cycle
- Invoked with mode=status or mode=cancel

## Skip when
- No development cycle is active or was recently started
- User is asking about general project status (not cycle-specific)

Unified skill for managing development cycle state. Provides two modes: **status** (read-only inspection) and **cancel** (state mutation with confirmation).

## Mode Selection

This skill provides two modes selected by the `mode` parameter:

| Mode | Purpose |
|------|---------|
| `status` | Read-only — display cycle metrics |
| `cancel` | Mutating — cancel the active cycle |

If no mode is provided, default to `status`.

---

## Shared: State File Discovery

Both modes read from the same state files. Check for an active cycle in this order:

1. `docs/ring:running-dev-cycle/current-cycle.json`
2. `docs/ring:planning-backend-refactor/current-cycle.json`

If neither file exists or both contain a terminal status (`completed`, `cancelled`), report that no cycle is active and exit with the appropriate "no cycle" message for the current mode.

---

## Mode: Status

Display the current development cycle status.

### Output

Displays:
- Current cycle ID and start time
- Current phase (if `phases[]` is present in state)
- Task source (`plan_file` / `plan_file_synced` / `lerian_map`; absent in older state files → infer `plan_file_synced` when `lerian_map_sync.enabled == true`, else `plan_file`). For `lerian_map`, also show the board identity — `lerian_map_sync.board.featureId` + `lerian_map_sync.board.dev_milestone_name` (the feature's `Desenvolvimento` milestone, read from persisted state — not looked up fresh) + `lerian_map_source`
- Map sync (only when `lerian_map_sync.enabled`): synced counts from `lerian_map_sync.epic_matches[]` (epic card status) and `lerian_map_sync.task_matches[]` (checklist `done` flips). For the epic↔card / task↔checklist mapping mechanics, see ring:running-dev-cycle `## Lerian Map Sync (optional)` (canonical — not restated here)
- Epics: total, completed, in progress, pending
- Current epic and gate being executed
- Assertiveness score (if epics completed)
- Elapsed time

### Example Output

```
Development Cycle Status

Cycle ID: 2024-01-15-143000
Started: 2024-01-15 14:30:00
Status: in_progress
Phase: Phase 2 - Core flows
Task source: lerian_map — product 13 / team 5, feature 77, milestone Desenvolvimento (433)
Map sync: epics→cards 2/5 synced, tasks→checklist 7/12 done

Epics:
  Completed: 2/5
  In Progress: 1/5 (Epic 2.3)
  Pending: 2/5

Current:
  Epic: Epic 2.3 - Implementar refresh token
  Gate 0→8→9 lean flow (ring:implementing-tasks)
  Iterations: 1

Metrics (completed epics):
  Average Assertiveness: 89%
  Total Duration: 1h 45m

State file: docs/ring:running-dev-cycle/current-cycle.json (or docs/ring:planning-backend-refactor/current-cycle.json)
```

### When No Cycle is Running (Status Mode)

```
No development cycle in progress.

Start a new cycle with:
  /ring:running-dev-cycle docs/pre-dev/{feature}/plan.md

Or resume an interrupted cycle:
  /ring:running-dev-cycle --resume
```

### Execution Steps (Status)

1. **Discover state file** — check both paths per "Shared: State File Discovery" above
2. **Read JSON** — parse `current-cycle.json`
3. **Extract fields** — cycle ID, start time, status (incl. `paused_for_epic_approval`, `paused_for_phase_review`), `current_phase` and `phases[]` (if present), `task_source` (with the inference fallback above) plus `lerian_map_sync.board`/`lerian_map_source` and the `lerian_map_sync.epic_matches[]` (epic→card) / `lerian_map_sync.task_matches[]` (task→checklist) sync counts when `lerian_map_sync.enabled` (both `plan_file_synced` and `lerian_map` — counts are populated whenever sync is on), `epics[]` list, `current_epic_index`/gate, iterations
4. **Compute metrics** — count completed/in-progress/pending epics from `epics[]`, calculate elapsed time, average assertiveness score across completed epics
5. **Display** — format and present the output as shown above

---

## Mode: Cancel

Cancel the current development cycle with state preservation.

### Options

| Option | Description |
|--------|-------------|
| `--force` | Cancel without confirmation |

### Behavior

1. **Confirmation**: Asks for confirmation before canceling (unless `--force`)
2. **State preservation**: Saves current state for potential resume
3. **Cleanup**: Marks cycle as `cancelled` in state file
4. **Report**: Generates partial feedback report with completed tasks

### Confirmation Prompt

Unless `--force` is specified, display:

```
Cancel Development Cycle?

Cycle ID: 2024-01-15-143000
Progress: 3/5 epics completed

This will:
- Stop the current cycle
- Save state for potential resume
- Generate partial feedback report

[Confirm Cancel] [Keep Running]
```

### After Confirmation (or --force)

```
Cycle Cancelled

Cycle ID: 2024-01-15-143000
Status: cancelled
Completed: 3/5 epics

State saved to: docs/ring:running-dev-cycle/current-cycle.json (or docs/ring:planning-backend-refactor/current-cycle.json)
Partial report: docs/dev-team/feedback/cycle-2024-01-15-partial.md

To resume later:
  /ring:running-dev-cycle --resume
```

### When No Cycle is Running (Cancel Mode)

```
No development cycle to cancel.

Check status with:
  ring:managing-dev-cycle (mode=status)
```

### Execution Steps (Cancel)

1. **Discover state file** — check both paths per "Shared: State File Discovery" above
2. **Read JSON** — parse `current-cycle.json`
3. **Validate** — confirm the cycle is in a non-terminal status (`in_progress`, `paused_for_epic_approval`, `paused_for_phase_review`, or similar)
4. **Confirm** — unless `--force`, use AskUserQuestion to get explicit user confirmation; if declined, abort
5. **Preserve state** — the existing JSON already contains the full state for potential resume
6. **Mark cancelled** — update the `status` field in `current-cycle.json` to `cancelled` and write back
7. **Generate partial report** — create a feedback file at `docs/dev-team/feedback/cycle-{id}-partial.md` summarizing completed epics, current progress, and reason (user-cancelled)
8. **Display** — format and present the cancellation confirmation as shown above

---

## Related Skills

| Skill | Description |
|-------|-------------|
| `ring:running-dev-cycle` | Start or resume cycle |
| `ring:managing-dev-cycle` (mode=cancel) | Cancel running cycle |
| `ring:managing-dev-cycle` (mode=status) | Check current status |
| `ring:writing-dev-reports` | View feedback report |

---

Now executing the requested mode...

Read state from: `docs/ring:running-dev-cycle/current-cycle.json` or `docs/ring:planning-backend-refactor/current-cycle.json`

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [LerianStudio](https://github.com/LerianStudio)
- **Source:** [LerianStudio/ring](https://github.com/LerianStudio/ring)
- **License:** Apache-2.0
- **Homepage:** https://lerian.studio

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-lerianstudio-ring-managing-dev-cycle
- Seller: https://agentstack.voostack.com/s/lerianstudio
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.