--- name: build-coordinator-25a0d63e512f description: "Use when coordinating a full gobby build run for an epic or task, especially when the user assigns the current session as coordinator, asks for a coordination epic, wants build agents/worktrees monitored, or wants gobby build bugs fixed so future runs work unattended." version: "1.0.3" category: core triggers: gobby build coordinator, epic coordinator, coordination epic, unattended build, build bugs metadata: gobby: audience: all depth: 0 format_overrides: autonomous: full --- # Build Coordinator Use this skill when the user gives a target task or epic and says the current session is the build coordinator. The coordinator's job is broader than finishing the target: make `gobby build` capable of running the same shape of work unattended. This skill is operating instructions for the current coordinator session. Do not create or switch to a separate agent definition unless the user explicitly asks for that. When writing a prompt for another coordinator session, include an explicit load directive such as `$gobby build-coordinator ` for Codex sessions. Use `/gobby build-coordinator ` where the slash router is supported. ## Core Contract Treat coordinator intervention as evidence. If `gobby build` needed the coordinator for something it should handle itself, file a build-system bug under the coordination epic. Keep two work streams separate: - Target task or epic: the user's product work. - Coordination epic: build coordination, build-system bugs, and coordinator fixes discovered during the run. Do not close the target task or epic while known `gobby build` bugs from the run remain open. The coordination epic is the active goal record for the run. Do not close, unclaim, or move work out of it just to satisfy a stop hook, context limit, or handoff pressure. If the goal is not complete, keep the coordination epic claimed and continue, compact the session, or ask the user to explicitly cancel or pause the goal. ## Startup 1. Load relevant local skills before acting: `task-creation`, `task-transitions`, and `source-control`. Load `build` when launch semantics or CLI flags are in scope. 2. Identify the target task or epic and the user's non-default constraints. Ask only when the target is missing or a decision cannot be inferred safely. 3. Create and claim a separate coordination epic outside the target task tree. Put all coordinator work and all discovered build-system bugs under it. 4. Inspect the target dependency tree and stage manifests before dispatch. Normalize leaf task stages to the user's required stage. For implementation build epics, default leaf tasks to `development` unless the user says otherwise. 5. Check current build state and dispatch eligibility with supported MCP tools before launching. 6. Launch `gobby build ` without `--quick` unless the user explicitly requested a one-step smoke run. ## During The Build Use supported MCP surfaces first: - `gobby-tasks` for task state, stage manifests, build status, dispatch explanation, and build history. - `gobby-agents` for running agents and agent results. - `gobby-sessions` for session metadata, terminal capture, handoff context, and coordinator compaction. - `gobby-worktrees` or `gobby-clones` when workspace state is part of the failure. Monitor dispatch directly with the supported MCP surfaces above. The coordinator loop is: 1. Check target build state, dispatch eligibility, stage state, active agents, build history, and workspace health. 2. Check the coordination epic's child tasks for open build bugs, claims, escalations, and validation failures. 3. Work the highest-priority actionable coordination bug yourself, or coordinate the owning session when a child bug is already claimed. 4. Resume or launch build automation only after known blocking bugs for the immediate dispatch path are fixed or explicitly documented as non-blocking. 5. When agents are running and there are no actionable coordination bugs, check context health. Use `gobby-sessions:compact_self` when context pressure or handoff risk is high. Use `gobby-agents:wait_for_agent` only as a bounded wait for a specific run result. Do not keep the build moving by repeatedly manual-ticking the dispatcher. A normal build is daemon-owned automation. Use resume or explicit ticks only after recording evidence that they are diagnostics or recovery for a build bug. If a stop hook fires while the coordination epic is still claimed, continue the coordinator loop above. A claimed coordination epic means the build goal is still active; finish actionable child work, monitor agents, or hand off with saved context. Resolve escalations yourself whenever possible. Leave a task escalated only when a user decision is genuinely required. ## Compaction Compact at handoff boundaries and before context size starts degrading decisions. Use progressive discovery, then call `gobby-sessions:compact_self`: 1. `list_mcp_servers()` 2. `list_tools(server_name="gobby-sessions")` 3. `get_tool_schema(server_name="gobby-sessions", tool_name="compact_self")` 4. `call_tool("gobby-sessions", "compact_self", {})` Pass the current Gobby session ref as the top-level `call_tool.session_id`, not inside `arguments`. Set `rule_name` only when a workflow or rule specifically requires attribution. Before compacting, leave enough state in the conversation or task notes for the continuation to resume without rediscovery. ## Build Bug Policy File every discovered `gobby build` bug under the coordination epic. Examples: - dispatch stalls, missing cron resume, or daemon-owned automation stops - bad stage routing, incorrect stage manifests, or impossible stage transitions - wrong target branch, integration branch, worktree, or clone setup - agent launch missing required startup context, skills, task links, or claims - merge, validation, close, or cleanup behavior that requires manual repair - missing build history or status visibility that prevents safe unattended operation Fix blocking bugs immediately. Fix non-blocking bugs when agents are running or other coordinator work is idle. All discovered unattended-build bugs must be fixed, committed, linked, and closed before the target task or epic is closed. Product-task failures are different from build-system bugs. Let assigned agents own product work unless the failure exposes broken build automation or the user explicitly asks the coordinator to take over. ## Context And Handoff When context gets large, compact before degradation affects decisions. Include: - target task or epic ref - coordination epic ref - exact build command and important flags - current build status and active agent runs - discovered build bugs, fixed commits, and remaining work - escalations that still need user decisions - validation already run ## Completion Gates These gates apply to the coordination epic itself as well as the target. A stop hook is a reminder to finish or hand off the goal; it is not evidence that the goal is complete. Before closing the target task or epic, verify: - target product work is merged or otherwise completed according to its stages - no target leaf remains in the wrong stage - no agents for the build are still running - no task remains claimed accidentally - all discovered `gobby build` bugs from the run are closed with linked commits - required focused validation has run; do not run the full pytest suite unless explicitly requested - stale worktrees or clones are cleaned up, or any intentionally preserved workspace is documented Close the coordination epic only after the target is complete and every discovered build bug from the run is fixed or explicitly blocked on a user decision. Keep discovered build bugs under the coordination epic while they are open; do not detach or reparent them to make the coordinator task closable. ## Goal Prompt Template When the user asks for a reusable `/goal` prompt, adapt this: ```text $gobby build-coordinator /goal Act as the Gobby build coordinator for . Create a separate coordination epic outside . Use it for coordinator work and every gobby build bug discovered during this run. Run gobby build for without --quick. Coordinate agents and worktrees, but treat coordinator intervention as evidence of unattended-build gaps. File every discovered build bug under the coordination epic. Fix blocking build bugs immediately, fix non-blocking build bugs when opportunity arises, and fix all discovered build bugs before closing . Before dispatch, inspect the target task tree and normalize leaf task stages to the required stage. Default implementation leaves to development unless the user specified another stage. Monitor dispatch and the coordination epic every loop: build status, stage state, active agents, build history, workspace health, and open child bugs. Work actionable build bugs under the coordination epic before waiting. When agents are running and no actionable coordinator work remains, check context health, then use gobby-sessions:compact_self for context pressure or a bounded gobby-agents:wait_for_agent for a specific run result. Resolve escalations yourself unless a genuine user decision is required. Completion requires the target work complete, all discovered build bugs fixed and closed with linked commits, required validation run, no unexpected running agents or claimed tasks, and final status covering build state, validation, bug fixes, escalations, and task states. Do not close the coordination epic to clear a stop hook while any completion requirement remains unmet; compact or continue the session instead. ``` --- Source attribution: GobbyAI Original project: https://github.com/GobbyAI/gobby/blob/45b0ea0e6a1d93bc9815269c94ada8b4ed743476/src/gobby/install/shared/skills/build-coordinator/SKILL.md License: Apache-2.0 License information: https://www.apache.org/licenses/LICENSE-2.0 Original upstream instructions; downloaded from Mega AI Hub. ## Upstream license notice # Apache License Version 2.0, January 2004 TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1\. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to the Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2\. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3\. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4\. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5\. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6\. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7\. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8\. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9\. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Copyright 2026 GobbyAI SPDX-License-Identifier: Apache-2.0 # Mega AI Hub resource metadata Creator / publisher: GobbyAI Original project: https://github.com/GobbyAI/gobby/blob/45b0ea0e6a1d93bc9815269c94ada8b4ed743476/src/gobby/install/shared/skills/build-coordinator/SKILL.md Attribution basis: Source repository record Fields of work: Operations, Product Management, Project & Program Management Roles: Operations Manager, Project Manager, Technical Product Manager Specialties: Backend Tools: Gobby Country applicability: Country not specified Classification basis: Source catalog labels Instruction SHA-256: 9d9d2f337b1397638279adf0ec3e9673b950a2836cdac911ea6ebc9aefa77431