docs: adopt issue-first contribution workflow

.github/ISSUE_TEMPLATE/bug_report.md

@@ -48,3 +48,5 @@ If applicable, add screenshots to help explain your problem.
 
 **Additional context**
 Add any other context about the problem here.
+
+Do not begin implementation until the issue reaches **Ready** on the [Goose Issues board](https://github.com/orgs/aaif-goose/projects/1).

.github/ISSUE_TEMPLATE/feature_request.md

@@ -7,19 +7,18 @@ assignees: ''
 
 ---
 
-**Before opening a feature request**
-Please start a discussion in the [goose-eng Discord channel](https://discord.com/channels/1287729918100246654/1514412780504088677) before creating a feature request or beginning implementation. This helps align on direction before anyone spends time building.
+**What problem would this solve?**
+Describe the problem, who it affects, and the use cases it prevents or makes difficult.
 
-**Please explain the motivation behind the feature request.**
-Does this feature solve a particular problem you have been experiencing? What opportunities or use cases would be unlocked with this feature?
+**What would a good outcome look like?**
+Describe the outcome rather than a particular implementation.
 
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
+**Possible approaches**
+Share any approaches, constraints, or trade-offs the design discussion should consider.
 
 **Additional context**
 Add any other context or screenshots about the feature request here.
 
 - [x] I have verified this does not duplicate an existing feature request
+
+Do not begin implementation until the issue reaches **Ready** on the [Goose Issues board](https://github.com/orgs/aaif-goose/projects/1).

AGENTS.md

@@ -2,6 +2,19 @@
 
 goose is an AI agent framework in Rust with CLI and Electron desktop interfaces.
 
+## Contribution Workflow
+
+The issue is the source of truth for work intended for an upstream pull request. Track issue status on the [Goose Issues board](https://github.com/orgs/aaif-goose/projects/1).
+
+- Before implementing an issue for a pull request, confirm that it is on the board with Status **Ready**.
+- Do not implement issues in **Inbox**, **Needs info**, or **Accepted / design**. Help resolve the issue discussion instead.
+- Read the agreed design, constraints, non-goals, and verification plan before changing code.
+- Keep the implementation within the issue's agreed scope.
+- If implementation reveals a material design change, return to the issue before continuing.
+- Every external pull request must link the Ready issue it implements and explain how the verification plan was performed.
+
+Maintainer-directed work, urgent security fixes, release automation, and local or exploratory changes do not require a Ready issue.
+
 ## Setup
 ```bash
 source bin/activate-hermit

CONTRIBUTING.md

@@ -1,64 +1,56 @@
 # Contribution Guide
 
-goose is open source!
+goose is open source, and code is only one way to contribute. Reporting a problem, reproducing it, sharing domain knowledge, shaping the design, implementing the solution, and verifying the result are all valuable work.
 
-We welcome pull requests for general contributions! In these days of AI it is easier than ever to contribute, but
-there are some pitfalls to avoid. This document describes the best practices for new and experienced contributors
-to get work landed as smoothly as possible.
+We organize this work on the public [Goose Issues board](https://github.com/orgs/aaif-goose/projects/1). The issue is the main record of a contribution, from the first report through design, implementation, and verification.
 
 > [!TIP]
 > Beyond code, check out [other ways to contribute](#other-ways-to-contribute)
 
 ---
 
-## Getting Started
+## Issue Workflow
 
-Your first contribution to goose should probably be a small bug fix. The goose maintainers have a lot of incoming
-PRs to review, and the reputation of the author is an important signal. While contributions to goose are generally
-of remarkably high quality, we do get our fair share of AI slop. When a first-time contributor opens a
-3k line PR touching 20 files, we have no easy way to tell whether it’s thoughtful work or
-blindly AI-generated without doing a deep dive.
+Every open issue is tracked on the [Goose Issues board](https://github.com/orgs/aaif-goose/projects/1):
 
-So please start small to establish trust and work your way up from there. A small bug fix or performance improvement
-is a good start. Linking your fix to an existing issue shows that you are responding to a community need.
+- **Inbox**: The issue is waiting for triage.
+- **Needs info**: More information is needed before the issue can progress.
+- **Accepted / design**: We want to solve the problem and are working out the design, constraints, and verification plan.
+- **Ready**: The intended solution is settled and implementation can begin.
+- **In progress**: Implementation is underway.
+- **Verification**: The implementation is ready for a human to confirm that it works.
+- **Done**: The result has been verified and the issue is closed.
 
-If your first PR gets closed with a link to this section, please don’t take it personally. 
-It just means the change was too large for a first contribution. Start with something smaller and try again.
+Issues we do not plan to pursue are closed with an explanation. We do not use rejection labels.
 
-## Discussions, Issues and PRs
+Feature requests should describe a broadly useful problem rather than only a preferred implementation. Adding features is easy; maintaining them is a long-term cost, so we may decline features that add complexity without enough general benefit.
 
-### Issues
+Discord and GitHub Discussions remain useful for informal conversation, but decisions that affect an implementation should be captured in the issue.
 
-If you spot a bug, please open an issue. This shows the community and the maintainers the direction of your
-thinking.
+## How to Contribute
 
-For bugs, describe how to reproduce the problem as clearly as possible. If the issue involves an interaction
-with an LLM, include a diagnostics report if possible.
+If you find a bug or want a new feature, [open an issue](https://github.com/aaif-goose/goose/issues/new/choose). A good issue explains the problem, who it affects, and why it matters. For bugs, include clear reproduction steps and a diagnostics report when possible.
+Please write the issue yourself. Your agent can do the research and help you explore, but you should understand the issue. You can
+suggest a solution direction, but refrain from a detailed solution especially code.
 
-### Discussions
+The best place to contribute is the discussion between **Accepted / design** and **Ready**. This is where the engineering happens: turning a worthwhile problem into a specific solution that an agent can implement. Take part in the issue discussion by bringing context and domain knowledge, challenging assumptions, comparing approaches, identifying constraints and trade-offs, and agreeing on how the result will be verified.
 
-Before opening a feature request or beginning implementation, please start with a discussion in the
-[goose-eng Discord channel](https://discord.com/channels/1287729918100246654/1514412780504088677). Discussions
-are a good place to explore design questions, alternatives, and whether something fits the goals of the project.
+Substantial contributors at any stage may be recognized as co-authors. The unit of contribution is taking a problem to a verified solution, not writing the patch.
 
-If a change is large or touches multiple parts of the codebase, please start with a discussion before opening a PR.
-This helps us align on direction before you spend time implementing something.
+## From Issue to Pull Request
 
-### Pull Requests
+Do not begin implementation or open a pull request until the issue has reached **Ready** on the Goose Issues board.
 
-Open a PR when you have a concrete change ready. For first contributions we strongly recommend starting small
-(see [Getting Started](#getting-started)). Don't open many PRs in quick succession. Submit them in order of 
-your preference and wait for them to land before opening more. 
+Every external pull request must:
 
-If the code is still evolving but useful for discussion, open the PR in draft mode. Draft PRs are for discussion, 
-not just unfinished work. If it’s not ready yet, keep the branch local.
+- link the Ready issue it implements;
+- stay within the design and scope agreed in the issue;
+- explain how the issue's verification plan was carried out; and
+- return material design changes to the issue for discussion.
 
-### Feature Requests
-
-Before proposing a new feature, consider whether it is something broadly useful or mainly a personal preference.
-Adding features is easy; maintaining them is a long-term cost, so we may decline features that add complexity
-without clear general benefit.
+Pull requests that do not implement a Ready issue will be closed. Automated dependency and release pull requests, urgent security fixes, and work explicitly directed by the core team are exempt.
 
+Don't open many pull requests in quick succession. Submit them in order of preference and wait for them to land before opening more.
 
 ## AI Code Reviews
 
@@ -120,7 +112,7 @@ sudo apt install build-essential  # build-essential is a package that installs a
 sudo apt install libxcb1-dev      # libxcb1-dev is the development package for the X C Binding (XCB) library on Linux
 ```
 
-## Getting Started
+## Development Setup
 
 ### Rust
 

documentation/blog/2025-08-25-goose-became-its-own-watchdog/index.md

@@ -7,6 +7,8 @@ authors:
 
 ![Goose Recipe Safety](goose-security-scanner.png)
 
+> **Update:** This post is preserved for historical reference. The public Recipe Cookbook submission program has ended, and we are no longer accepting new recipe submissions.
+
 Remember when people shared recipes by passing handwritten cards between neighbors? You trusted Grandma's apple pie recipe because you knew Grandma. But what happens when strangers start sharing recipes online? You need someone to taste-test them first.
 
 That's exactly the challenge we face with Goose recipes. We're building a community cookbook where you can try Goose recipes from other users with confidence that they're safe. But we needed a way to make sure every recipe was safe to run.
@@ -33,9 +35,9 @@ In the end I crafted a series of recipes that were safe, some that were maybe a
 
 The process at a glance seems surprisingly simple but it's pretty complex -- picture the graceful goose swimming on the water but under the water the feet are thrashing around doing lots of work!
 
-When someone submits a recipe via our GitHub issue template, it will start an automated scan. Goose spins up in an isolated Docker container, analyzes the recipe using its own security expertise plus some of our guidance, scores it for risk, and posts the results right back to the GitHub issue.
-
-The whole process takes minutes instead of days, and the submitter gets immediate, transparent feedback about their recipe's safety. If something looks off, our team can review what's going on, and take appropriate action.
+When someone submitted a recipe via our GitHub issue template, it started an automated scan. goose ran in an isolated Docker container, analyzed the recipe using its own security expertise plus some of our guidance, scored it for risk, and posted the results back to the GitHub issue.
+
+The whole process took minutes instead of days, and the submitter received immediate, transparent feedback about their recipe's safety. If something looked off, our team could review what was going on and take appropriate action.
 
 ## Goose in Headless Mode
 
@@ -82,7 +84,7 @@ Goose catches edge cases that humans might miss, like subtle obfuscation techniq
 
 Sometimes the best way to solve a potential AI problem is with more AI. Goose understands Goose behavior patterns better than any human reviewer could. It knows the legitimate ways to automate tasks and can spot when something deviates from those patterns. Using Goose to build this scanner wasn't just a time-saver for making the tool, it's a productivity win for our team from manually review every recipe ourselves.
 
-Anyone can submit a recipe knowing it'll get a fair, thorough review. And when you see a recipe get a security approval, remember: it was approved by Goose itself.
+At the time, anyone could submit a recipe knowing it would get a fair, thorough review. And when a recipe received security approval, it was approved by goose itself.
 
 <iframe class="aspect-ratio" src="https://www.youtube.com/embed/Jtw_FxF3Iug" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
 

documentation/blog/2025-09-15-subrecipes-in-goose/index.md

@@ -7,6 +7,8 @@ authors:
 
 ![goose Subrecipes](goose-subrecipes.png)
 
+> **Update:** This post is preserved for historical reference. The public Recipe Cookbook submission program has ended, and we are no longer accepting new recipe submissions.
+
 Remember when you first learned to cook? You probably started with simple recipes like scrambled eggs or toast. But eventually you wanted to make something more complex, like a full dinner with multiple dishes. That's how subrecipes work in goose: each recipe can run stand-alone for a dedicated task, and a main recipe can orchestrate how they run.
 
 Let's explore [goose subrecipes](/docs/tutorials/subrecipes-in-parallel) together! You're about to learn know how to orchestrate multiple AI models, coordinate tasks, and build workflows that will turn you into a "head chef" user with goose.
@@ -377,14 +379,9 @@ Each recipe becomes a reusable component that you can mix and match. Build a lib
 
 Ready to start building your own subrecipe workflows? The kitchen is open, and all the ingredients are waiting for you.
 
-## Share Your Recipes with Us!
+## Recipe Submissions Are Closed
 
-Do you have a recipe you'd like to share with the community? We'd love to feature them in our [Recipe Cookbook](https://goose-docs.ai/recipes/)! 
-**How to contribute:**
-1. [Fork the goose repository](https://github.com/aaif-goose/goose/fork)
-2. Add your recipe YAML file to the [`documentation/src/pages/recipes/data/recipes/`](https://github.com/aaif-goose/goose/tree/main/documentation/src/pages/recipes/data/recipes) directory
-3. Create a pull request following our [Recipe Contribution Guide](https://github.com/aaif-goose/goose/blob/main/CONTRIBUTING_RECIPES.md)
-Browse [existing recipes](https://github.com/aaif-goose/goose/tree/main/documentation/src/pages/recipes/data/recipes) for inspiration and formatting examples.
+The Recipe Cookbook remains available to browse, but we are no longer accepting new community recipe submissions.
 
 
 <head>