Execute qualquer Skill no Manus
com um clique

Execute qualquer Skill no Manus com um clique

completely-auto

Estrelas5

Forks0

Atualizado7 de junho de 2026 às 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.

Instalação

Instalar com Codex ou Claude Copie este prompt, cole no Codex, Claude ou outro assistente e deixe que ele revise a página da skill e instale para você.

Executar no Manus

Fonte

23ag1

23ag1/completely

Abrir repositório GitHub Ver repositórios do creator

Download

Executar no Manus

Ocupações relacionadasSOC

Baseado na classificação ocupacional SOC

Outras ocupações de informáticaInformática e Matemática·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).

Mais deste repositório

mesmo repositório

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).