Exécutez n'importe quel Skill dans Manus
en un clic

Exécutez n'importe quel Skill dans Manus en un clic

cicd

Étoiles1

Forks0

Mis à jour25 mai 2026 à 06:15

guildmaster's CI/CD lane, layered on `agex pr`. Delegates lint / open / read / reply / delta to agex; adds two extensions — `status` (SonarCloud quality gate + hotspots + unresolved-thread tally) and `await` (read --wait + status with non-zero exit on Sonar ERROR or unresolved threads). Use when: creating PRs in guildmaster, handling review feedback, polling CI status, or the user says "create PR", "review comments", "address feedback", "resolve threads". Renamed from `pr-review` in steward 0.7.0; rebased on agex in 0.12.0.

Installation

Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.

Exécuter dans Manus

Source

agentculture

agentculture/devague

Ouvrir le dépôt GitHub Voir les dépôts du créateur

Téléchargement

Exécuter dans Manus

Métiers associésSOC

Basé sur la classification professionnelle SOC

Développeurs de logicielsProfessions informatiques et mathématiques·SOC 15-1252

Explorateur de fichiers

6 fichiers

SKILL.md

readonly

Plus depuis ce dépôt

même dépôt

assign-to-workforce

agentculture/devague

Fan out a converged devague plan's dependency waves to parallel agents in isolated git worktrees, one agent per task per wave, with TDD-gated merges by the main agent. Human gates: the exported spec, the implementation split plan (task map + per-task agent/model proposal + go/no-go), and the final PR. The devague CLI stays deterministic and non-orchestrating (#20) — it only *describes* the graph via `devague plan waves`; the operator (main agent) performs the fan-out. Use when the user says "assign to workforce", "fan out the plan", "parallel subagents", or after /spec-to-plan exports a plan. Authored and maintained in agentculture/devague (origin = devague); guildmaster pulls this skill from here and broadcasts it to the AgentCulture mesh — it is NOT vendored from guildmaster like the other skills here.

2026-07-141

deviate

agentculture/devague

Stop an in-flight assign-to-workforce run the moment execution must diverge from the confirmed plan, get explicit human approval for the divergence, and record it as a first-class, append-only deviation record via `devague deviate` before resuming — never fold a deviation silently into drift after the fact. Use when the user says "deviate from the plan", "we need to change the plan mid-run", "record a deviation", "this isn't matching the plan anymore", or when a task agent discovers the confirmed plan no longer matches reality partway through a workforce run. Authored and maintained in agentculture/devague (origin = devague); guildmaster pulls this skill from here and broadcasts it to the AgentCulture mesh — it is NOT vendored from guildmaster like the other skills here.

2026-07-141

summarize-delivery

agentculture/devague

Close the loop after an assign-to-workforce run by turning what actually happened into an accountability artifact — planned versus actual delivery, mid-work decisions, plan drift, evidence-backed delivery claims, and remaining work. The plan the user confirmed is the contract; this skill records where execution obeyed it, where it changed, and what is genuinely safe to claim as delivered. Runs on complete, partial, AND failed runs — failure is reported faithfully, never smoothed over. Use when the user says "summarize delivery", "delivery summary", "wrap up", "close the loop", "what did we actually ship", or "plan versus actual", or after assign-to-workforce merges (or fails to merge) a plan's waves. Authored and maintained in agentculture/devague (origin = devague); guildmaster pulls this skill from here and broadcasts it to the AgentCulture mesh — it is NOT vendored from guildmaster like the inbound skills here.

2026-07-141

scope

agentculture/devague

Explore the scope of a vague idea BEFORE framing it into a spec (the idea→scope leg; the optional opening move ahead of /think). Survey the surfaces the idea touches — code, docs, skills, CI, sibling repos — and seed the coming Announcement Frame with boundary, non-goal, and assumption claims that cite what was actually explored (provenance, not generic disclaimers). Use when the user says "explore scope", "scope this idea", "what does this touch", "map the scope", "scope exploration", or when an idea touches an existing codebase and speccing it cold would mean guessing its boundaries. Hand off to the sibling /think skill to build the frame. Authored and maintained in agentculture/devague (origin = devague); guildmaster pulls this skill from here and broadcasts it to the AgentCulture mesh — it is NOT vendored from guildmaster like the inbound skills here.

2026-07-071

spec-to-plan

agentculture/devague

Turn a converged devague spec into a buildable plan by working forwards (the spec→plan leg; drives the `devague plan` CLI group). Seed a plan from a converged frame, add tasks that collectively cover every coverage target (the frame's confirmed claims + honesty conditions), give each task acceptance criteria and an honest dependency order, park genuine unknowns as first-class risks, and export a plan only once it *converges*. Use when the user says "spec to plan", "stp", "turn this spec into a plan", "plan this spec", "make a build plan", or after the /think skill exports a spec. Authored and maintained in agentculture/devague (origin = devague); guildmaster pulls this skill from here and broadcasts it to the AgentCulture mesh — it is NOT vendored from guildmaster like the other skills here.

2026-07-071

think

agentculture/devague

Think a vague feature idea into a buildable spec by working backwards (the idea→spec leg; drives the `devague` CLI). Start from the announcement ("pretend it shipped"), capture and classify claims, interrogate them with honesty conditions and hard questions, park open vagueness as a first-class object, and export a spec only once the frame *converges*. Use when the user says "think this through", "spec this", "work backwards", "turn this idea into a spec", "announcement frame", or "devague", or when a feature request is too vague to build yet. Once a spec exports, hand off to the sibling /spec-to-plan skill to turn it into a plan. Authored and maintained in agentculture/devague (origin = devague); guildmaster pulls this skill from here and broadcasts it to the AgentCulture mesh — it is NOT vendored from guildmaster like the other skills here.

2026-07-071

name

cicd

description

CI/CD — guildmaster edition

agex pr (in agentculture/agex-cli) is the upstream for the five core PR-lifecycle verbs — lint, open, read, reply, delta. Steward used to vendor parallel scripts for each; in 0.12.0 those vendored copies were dropped in favor of delegating to agex. What's left in this skill is the steward-specific gating layer:

status — SonarCloud quality gate, OPEN issues, hotspots, deploy preview URL, unresolved-inline-thread tally.
await — composes agex pr read --wait with status and gates on Sonar ERROR / unresolved threads. The single command to run after pushing a fix when you want "wake me when this PR is triage-able."

Those two are the steward unique surface today. The await combo verb landed natively in agex (agex-cli#41, now closed); the gate extras that aren't yet native — SonarCloud hotspots, deploy-preview URL, an explicit resolved/unresolved thread tally — are tracked upstream in agex-cli#52 and migrate out of this skill once they land.

The workflow is encapsulated in scripts/workflow.sh — follow that (or call agex pr directly).

The agex-cli inversion (upstream-as-consumer)

One consumer is special: agex-cli itself, the repo that owns agex pr. Vendoring this skill there verbatim would re-vendor bash that just wraps the Python agex-cli already ships, so agex-cli vendors it adapted-thin (agex-cli#53): workflow.sh is the only script and it forwards lint | open | read | reply | delta | await straight to the native agex pr <verb> — including the native agex pr await combo verb (agex-cli 0.21.0). The steward status / await shell extensions and the vendored helpers (pr-reply.sh, _resolve-nick.sh, portability-lint.sh) are all redundant there, each superseded by a native verb. For that one consumer the skill collapses to a pure delegate.

The only gate bits not yet native are SonarCloud hotspots, the deploy-preview URL, and an explicit resolved/unresolved thread tally — tracked upstream in agex-cli#52. Once those land, steward retires pr-status.sh too and workflow.sh status/await delegates to native agex pr everywhere.

For broadcasts: a skill-update brief to agex-cli should expect this thin workflow.sh-only shape, not steward's five-file layout. (Ref: steward#53.)

Prerequisites

Hard requirements: agex (>=0.1), gh (GitHub CLI), jq, bash, python3 (stdlib only), curl (used by pr-status.sh).

Install agex once:

uv tool install agex-cli   # or: pip install --user agex-cli

Soft requirement: PyYAML is needed only for suffix mode of the sibling agent-config skill, where it parses Culture's server manifest. Every cicd script works without it; suffix mode prints a clear install hint when invoked without it.

Per-machine paths (sibling-project layout) live in .claude/skills.local.yaml; see the committed .example for the schema. agex pr delta reads the same file.

How to run

scripts/workflow.sh is the entry point. Subcommands:

Command	What it does
`workflow.sh lint`	`agex pr lint --exit-on-violation` — portability + alignment-trigger check.
`workflow.sh open [gh-flags]`	`agex pr open --delayed-read`. Creates the PR, then polls 180s for an initial briefing. `--title TITLE` required; body via `--body-file PATH` or stdin.
`workflow.sh read [PR] [--wait N]`	`agex pr read`. One-shot briefing (CI checks, SonarCloud gate + new issues, all comments, next-step footer). Pass `--wait N` to poll up to N seconds for required reviewers.
`workflow.sh reply <PR>`	`agex pr reply <PR>` — batch JSONL replies (stdin) + thread resolve. agex auto-signs from `culture.yaml`.
`workflow.sh delta`	`agex pr delta` — sibling alignment dump.
`workflow.sh status <PR>`	Steward extension. `pr-status.sh` — Sonar gate, OPEN issues, hotspots, unresolved-thread breakdown, deploy preview URL. Authoritative gate for `await`.
`workflow.sh await <PR>`	Steward extension. `agex pr read --wait` then `status`. Exits non-zero on Sonar ERROR or unresolved threads. Tunables: `STEWARD_PR_AWAIT_WAIT` (default 1800s passed to `--wait`), `STEWARD_PR_AWAIT_SECONDS` (legacy fixed pre-sleep, deprecated).
`workflow.sh help`	Print the list.

You can also call agex pr <verb> directly — workflow.sh is a typing-saver around the same verbs. The steward status and await extensions only have shell entry points.

The vendored single-comment helper pr-reply.sh (plus its _resolve-nick.sh dependency) is still shipped — pinned by tests/test_pr_reply_signature.py and tests/test_resolve_nick.py, and useful when a one-off reply doesn't merit batch JSONL. It is not called by workflow.sh anymore. The vendored portability-lint.sh is also still shipped — steward doctor's portability check runs it directly against target repos. Both are scheduled for follow-up migration to agex.

Long waits (background polling)

agex pr read --wait N polls in-session for up to N seconds. The Anthropic prompt cache has a 5-minute TTL; sleeping past it burns context every cache miss. Two ways to drive the wait:

Synchronous — workflow.sh await <PR> after gh pr create / workflow.sh open. Fine when readiness is expected within ~5 minutes.
Asynchronous — for longer waits, run agex pr read --wait NNN inside a background subagent (Agent tool, run_in_background: true) so the main session only pays the cache cost when readiness fires. The subagent's only job is to invoke agex pr read --wait and echo its headline back. The parent triages with workflow.sh await when the notification arrives. The user can interrupt with TaskStop.

This pattern was originally borrowed from sibling repo agentculture/cfafi's poll skill. The async guidance is also filed upstream (agex-cli#41).

Conventions

agex pr emits a "Next step:" footer at the end of every command that names the right next verb (the same chain agex learn cicd documents) — follow that rather than memorizing an order. workflow.sh help mirrors the verb table when you need the steward-flavored extensions (status, await) on top.

Branch naming: fix/<desc>, feat/<desc>, docs/<desc>, skill/<name>. PR / comment signature: - <nick> (Claude), where <nick> is resolved by agex from the agent's own culture.yaml (first agent's suffix), falling back to the git-repo basename. agex auto-appends the signature on pr open and pr reply only when the body isn't already signed.

Finishing a branch

When implementation on a branch is complete and tests pass, go straight to workflow.sh open (push the branch + open the PR). Do not stop to present a merge / PR / keep / discard menu and wait for a choice — in AgentCulture the standing default is always "push and create a Pull Request." This overrides the Superpowers finishing-a-development-branch skill's interactive menu, which otherwise pauses the flow at the moment work is ready to integrate. Merge-locally, keep-as-is, and discard happen only when the user explicitly asks for one of them.

Triage rules

For every comment, decide FIX or PUSHBACK with reasoning.

Default to FIX for: portability complaints (always valid for Steward — recurring bug class), test or doc requests, style nits aligned with workspace conventions.

Default to PUSHBACK for: architecture opinions that conflict with workspace CLAUDE.md or the all-backends rule; greenfield false-positives (e.g. "add tests" before there's any source — defer to a later PR, don't refuse).

Alignment-delta rule

If the PR touches CLAUDE.md, culture.yaml, or anything under .claude/skills/, run workflow.sh delta before declaring FIX or PUSHBACK on each comment. Note any sibling that needs a follow-up PR and mention it in your reply.

Greenfield-aware steps

The lint and the workflow script are always-on. Stack-specific steps are conditional and currently no-op (greenfield repo):

[ -d tests ] && [ -f pyproject.toml ] && uv run pytest tests/ -x -q
[ -f pyproject.toml ] && bump_version_per_project_convention   # see project README
[ -f .markdownlint-cli2.yaml ] && markdownlint-cli2 "$(git diff --name-only --cached '*.md')"

Revisit each line as the corresponding stack element actually lands. A pr lint --extra=tests,version,markdown ask is filed upstream (agex-cli#41).

Reply etiquette

Every comment must get a reply — no silent fixes. agex pr reply includes thread-resolve by default. Reference the review-comment IDs in the fix-up commit message.

The status extension queries SonarCloud directly (it predates the upstream Sonar integration in agex pr read). Both surfaces are trustworthy — agex pr read for display in the briefing, status for the gate. Steward isn't yet a registered mesh agent, so the post-merge IRC ping that Culture's pr-review includes is still skipped — that returns when Steward joins the mesh.