cs

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 Castalie, 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 Castalie à 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 Castalie'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 Castalie", "commence la prise en main", "fais le point", "start the Castalie 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.

Replay a delivered brief as its customer would, before it closes — each user story on the running product, each Given/When/Then criterion with a verdict written back, the gaps coded on one pull request through the acceptance queue, a disproportionate gap put to the brief's owner, and the brief accepted only when the replay conforms. Fires when a brief enters Acceptance (its last spec closed), on "recette du brief", "le brief est-il vraiment livré ?", "accept brief <id>". Never merges and never deploys; it ends on feature_brief_accept or on a question to the owner.

Take a bug from a report to a pull request — reproduce it first, settle whether it is a defect at all, find the cause and the change that brought it in, fix the cause, prove the fix on the path the user actually took, and record the follow-up. Also answers a ticket relayed by a salesperson or a customer, and motivates a "this is not a bug" verdict instead of closing it in one word. 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 Castalie 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 Castalie 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 Castalie brief — problem, vision, user stories, success criteria — attached to an objective. Interactive discovery with targeted questions; writes the brief via the Castalie MCP and its body via the cs 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 Castalie; verification happens against your running app.

Implement a Castalie 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 Castalie; the code never leaves your machine.

One deliverable, one pull request — create the brief, its single user story and a one-phase spec in a single gesture, then run the implementation loop to "PR ready". Use it when the work is one thing that takes an afternoon, or when a brief already exists and only needs building. A need carrying several user stories belongs to `cs:feature-brief`; a behaviour that used to work and no longer does belongs to `cs:bug-fix`. Never merges and never deploys.

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

Read, capture, review and publish workspace knowledge through Castalie'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. A key result measured by a report of the workspace is recalculated from it, not asked; one whose report lives elsewhere is read off that report, and its check-in cites the address. Writes to Castalie through the MCP; every figure comes from a report or from the user, never from you.

Give an objective its key result, read off a report — never typed by hand. Builds (or finds) the report that tracks the metric over time, proposes a target from the data for the user to confirm, then creates the one key result of that objective and links it to the report, so its value comes from the report and carries the report's address. Prefers a report of this workspace, falls back to the HTTPS address of a report in another system, and refuses to create a key result with neither. Use it when someone points at an objective and asks to "add a KR", "track this", "set a target", "mesure cet objectif".

Show or hide, beside the transcript, the strategy tree of what this working copy has in hand — the objective each brief serves, its specs, their phases and the checks scheduled after delivery. A toggle, not a conversation - the panel is drawn by the plugin's own hook and answers instantly. Use it whenever someone asks where the work sits in the strategy, or asks to open, close or refresh the objectives panel.

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, then the key results that read off no report. Use it before a review, at the start of a quarter check, or whenever someone asks how the period is going. Reads via the Castalie 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 "cs:report <text>".

End-of-run retrospective — reflect on the durable learnings from the run that just finished and post them as retro suggestions in Castalie 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 Castalie.

Explore and reason about your Castalie 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 Castalie MCP.

See and change what Castalie'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 Castalie sont actifs ?", "arrête de committer tout seul", "demande-moi avant d'ouvrir la PR", "castalie settings". Shows what your administrator decided for the whole workspace and what is left to you, and points at the page on your Castalie account.