bg

Run an acceptance pass on a running feature — you fire remarks in rapid succession while you click through the product, each one is written to a local queue the instant it lands and then pushed to Galy, then coded one at a time in the order received, one commit per remark, a single PR. Trivia is decided on the spot; a real product decision parks without stopping the queue. Ends by invoking the environment's release step on the drained pass; it merges nothing directly.

Turn the kit's generic skills into skills bound to this team's own environment — including a merge skill and a release skill written against the pipeline the delivery pass actually read — and propose them as a pull request together with an added CLAUDE.md section. Runs right after the project-management and delivery audits of the first pass, or on its own with "adapte les skills Galy à notre environnement". It opens a branch and a pull request; it never merges, never deploys, never rewrites an existing skill, and never changes an existing process.

Meta-reflection on the assistant's own behavior — force an honest analysis of WHY a choice was made, and produce concrete rule edits to the plugin's own skills or your CLAUDE.md. It does NOT fix the original task; it stops the loop and answers the meta question.

Audit this team's engineering practices against Galy's twenty recommended criteria, one criterion at a time, one line each. The same skill runs the first pass and every one after it. Fires on a plain sentence such as "audite mon projet", "démarre l'onboarding Galy", "commence la prise en main", "fais le point", "start the Galy audit", "où en sont nos pratiques ?", or whenever a session finds that nothing has ever been observed. Also fires on a question about a past audit — "où en sont les recommandations ?", "montre-moi l'audit", "what did the audit find?" — which it answers from the recorded state and ends on the address of the page, without opening a pass. It says what it is about to check, checks it, reports one line, and stops to have anything that is not green confirmed before writing it. It observes and proposes; it applies nothing, merges nothing, and triggers nothing.

Take a bug from a report to a pull request — reproduce it first, find the cause, fix the cause, prove the fix on the path the user actually took, and record the follow-up. Accepts a raw error, a stack trace, or a ticket id from whichever system holds this team's bugs. Ends at "PR ready"; it never merges and never deploys.

Connect this repository to a Galy workspace — opening one first if the user has none, without ever sending them to a page they cannot sign in to. Also diagnoses a connection that is not answering — 401, wrong address, missing token, two servers with the same name. Registers the MCP endpoint for this project without the user pasting anything into a config file, and never writes a token into a committable file.

Challenge an idea before you commit to it — spawn a fresh adversarial sub-agent that steelmans the idea, then attacks it hardest, names the single decisive test, surfaces failure modes and a cheaper alternative; then converge on a verdict you own. No Galy tools needed; it reasons about the idea, not your data.

Celebrate a verified delivery — a single, warm confirmation line with the live deep link, printed only when the change has actually been seen working in production. Simple, no scripts, no tools required.

Frame a business need into a Galy brief — problem, vision, user stories, success criteria — attached to an objective. Interactive discovery with targeted questions; writes the brief via the Galy MCP and its body via the bg CLI. This is the WHAT and WHY, never the HOW (that is feature-spec).

Run the post-delivery checks a spec or brief scheduled — replay the acceptance criteria in production, measure the outcome against the pass/fail thresholds, report the verdict, and reschedule the next horizon. Reads the checks from Galy; verification happens against your running app.

Implement a Galy spec autonomously in your own repository — claim the spec, read its phases, code phase by phase with a cron watchdog as a safety net, verify against the acceptance tests, and end at "PR ready". Never merges (that is your CI/process). Reads the spec from Galy; the code never leaves your machine.

Turn a Galy brief into a technical spec — explore your own codebase, weigh design options, then write phases, risks and acceptance tests. Writes the spec via the Galy MCP and its body via the bg CLI. Your code stays local; only the plan and its metadata go to Galy.

Read, capture, review and publish workspace knowledge through B.Galy's durable source, citation and article contract; never keep a client wiki or local memory as the canonical store.

Carry out the audit actions this workspace has ACCEPTED — one gesture per action, in the order that unblocks the most, ending at a single pull request. Fires on "mets en œuvre ce qu'on a validé", "applique les actions de l'audit", "vide la file", "carry out the accepted actions". It takes nothing on its own initiative — an action nobody accepted is never touched, and an action whose procedure is not written is skipped out loud rather than improvised. It never merges and never deploys.

The check-in ritual — go through the key results you own in one pass, record where each one really stands (value, confidence, one sentence), and say what changed and what has just tipped into risk. Writes to Galy through the MCP; every figure comes from the user, never from you.

The state of play of your objectives, read-only — the tree with its progress, and the key results that are off track or that nobody has reported on in a fortnight, at the top. Use it before a review, at the start of a quarter check, or whenever someone asks how the period is going. Reads via the Galy MCP; writes nothing.

Receive a bug report or improvement request from an agent and route it to the right ticket or brief. Triggered by "ça ne marche pas", "j'ai un bug", "il faudrait", "ce serait mieux si", "report a bug", "request an improvement", or "bg:report <text>".

End-of-run retrospective — reflect on the durable learnings from the run that just finished and post them as retro suggestions in Galy for later human review. Additive and non-blocking; it edits nothing and never fails the run. Targets the plugin's own skills or your CLAUDE.md, never your product code.

Commit your work, open a PR, and run a self-review panel (correctness / security / conventions / perf sub-agents over the diff), fix the blockers, and end at "PR ready". It does NOT merge — the merge is your own CI/process (extension point). The diff stays in your repo; nothing is sent to Galy.

Explore and reason about your Galy strategy — the objectives tree, periods, and key results — as a read-only thinking space. Use it to map a piece of work to the objective it serves, to review where a quarter stands, or to brainstorm before framing a brief. Never edits strategy; it reads via the Galy MCP.

See and change what Galy's skills do on their own and what they stop to ask you — commit and open the pull request unattended, or pause for your check first. Fires on "quels réglages Galy sont actifs ?", "arrête de committer tout seul", "demande-moi avant d'ouvrir la PR", "galy settings". Shows what your administrator decided for the whole workspace and what is left to you, and points at the page on your Galy account.