Run any Skill in Manus with one click

completely-auto

Stars5

Forks0

UpdatedJune 7, 2026 at 06:50

Run completely AUTONOMOUSLY — loop the FULL task engine over the Beads queue, a fresh `claude -p` per task, until the queue is empty. Same complete recipe as /completely:control. Backed by `cmpl auto`. Run it in the FOREGROUND (blocking) — nested workers only run while the launching session is active; it is idempotent/resumable.

Installation

Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.

Run Skill in Manus

Source

23ag1

23ag1/completely

View GitHub Repository View Creator Repositories

Download

Run Skill in Manus

Related occupationsSOC

Based on SOC occupation classification

Computer Occupations, All OtherComputer and Mathematical Occupations·SOC 15-1299

SKILL.md

readonly

name	completely:auto
description	Run completely AUTONOMOUSLY — loop the FULL task engine over the Beads queue, a fresh `claude -p` per task, until the queue is empty. Same complete recipe as /completely:control. Backed by `cmpl auto`. Run it in the FOREGROUND (blocking) — nested workers only run while the launching session is active; it is idempotent/resumable.
version	0.7.0
user-invocable	true
argument-hint	[--max N]

Run cmpl auto --max N from the repo root to grind the Beads queue with the full task engine (core/task-engine.md): each task gets a fresh claude -p running the COMPLETE recipe (understand → plan-check → parallel subagents → TDD → checks → reviewers → verifier → evaluator → debug-on-fail → commit → close), then the next, until bd ready is empty.

CRITICAL — how to run it so it actually progresses:

Run it in the FOREGROUND. Do NOT background it. The nested claude -p workers only make progress while the launching session is active. If you background it (& / run_in_background) and yield your turn, the workers PAUSE. Block on the single cmpl auto call until it exits.
It is bounded by the foreground/session limits. A long run can be cut off (session limit). Because the engine commits BEFORE closing a bead, completed tasks are durable (committed work
- closed beads) and never leave a closed bead with uncommitted code.
Resuming after an interruption. The task that was IN FLIGHT when the run died is left in_progress (claimed), NOT open — and bd ready excludes in_progress, so a bare re-run would silently skip it. cmpl auto therefore auto-reaps orphaned claims at startup: any in_progress bead whose holding run is gone/stale (heartbeat) is reopened with an audit comment, then re-dispatched. So just re-run cmpl auto and it genuinely continues. To inspect/clean manually: cmpl orphans (list) / cmpl orphans --reap (reopen). An interrupted worker may also leave uncommitted WIP in the tree — the run-report flags it; salvage or revert it before the next run.
Always pass --max N to bound the run; --dry-run previews the queue.

Use when the spec is frozen, tasks are atomic, write-zones disjoint, verification automated. Otherwise use /completely:control (one observed task at a time).

More from this repository

same repository

completely-plan

23ag1/completely

Plan a phase or feature DIRECTLY into Beads — no PLAN.md, no markdown bridge. Runs GSD-style socratic discovery + decomposition + a goal-backward self-check, then emits a structured plan that `cmpl plan-apply` materializes as a Beads epic + worker-contract tasks + dependency waves + human checkpoints. One source of truth from the first planning act. Use to turn an idea or phase into ready Beads work.

2026-06-115

security-review

23ag1/completely

Use this skill when adding authentication, handling user input, working with secrets, creating API endpoints, or implementing payment/sensitive features. Provides comprehensive security checklist and patterns.

2026-06-065

completely-control

23ag1/completely

Run completely UNDER CONTROL — execute the SINGLE next Beads task through the FULL task engine (understand → map → plan-check → parallel subagents → TDD → checks → reviewers → verifier → evaluator → debug-on-fail → commit → close), in this session, showing every step and pausing at human gates. One task done excellently, then stop. control = one observed step of auto, same engine, no cuts.

2026-06-065

completely-sync

23ag1/completely

MIGRATION (one-time). Import existing markdown task state (Ralph IMPLEMENTATION_PLAN.md, checkbox task lists) into Beads, idempotently. Use when adopting completely in a repo that has markdown plans, or after an upstream update, to keep Beads the single source of truth. Backed by `cmpl sync`.

2026-06-045

completely-init

23ag1/completely

Scaffold the completely thin layer into the current repository — Definition of Done, the harness rules snippet in CLAUDE.md, and an optional project-specific quality command. Use when setting up claude-harness in a new project, or when the user says "harness init", "set up the harness", or "wire up the quality gates here".

2026-06-045

completely-check

23ag1/completely

Run all configured quality checks (lint, types, tests) in one pass with terse output — reports "clean" when green, and only the failing check's output when not. Token-frugal; configured via completely.toml [check] or auto-detected per stack (front+back). Use before committing or to verify a change. Backed by `cmpl check`.

2026-06-045

name	completely:auto
description	Run completely AUTONOMOUSLY — loop the FULL task engine over the Beads queue, a fresh `claude -p` per task, until the queue is empty. Same complete recipe as /completely:control. Backed by `cmpl auto`. Run it in the FOREGROUND (blocking) — nested workers only run while the launching session is active; it is idempotent/resumable.
version	0.7.0
user-invocable	true
argument-hint	[--max N]

CRITICAL — how to run it so it actually progresses:

Run it in the FOREGROUND. Do NOT background it. The nested claude -p workers only make progress while the launching session is active. If you background it (& / run_in_background) and yield your turn, the workers PAUSE. Block on the single cmpl auto call until it exits.
It is bounded by the foreground/session limits. A long run can be cut off (session limit). Because the engine commits BEFORE closing a bead, completed tasks are durable (committed work
- closed beads) and never leave a closed bead with uncommitted code.
Resuming after an interruption. The task that was IN FLIGHT when the run died is left in_progress (claimed), NOT open — and bd ready excludes in_progress, so a bare re-run would silently skip it. cmpl auto therefore auto-reaps orphaned claims at startup: any in_progress bead whose holding run is gone/stale (heartbeat) is reopened with an audit comment, then re-dispatched. So just re-run cmpl auto and it genuinely continues. To inspect/clean manually: cmpl orphans (list) / cmpl orphans --reap (reopen). An interrupted worker may also leave uncommitted WIP in the tree — the run-report flags it; salvage or revert it before the next run.
Always pass --max N to bound the run; --dry-run previews the queue.

Use when the spec is frozen, tasks are atomic, write-zones disjoint, verification automated. Otherwise use /completely:control (one observed task at a time).