@houseofwolvesllc/claude-scrum-skill 1.0.0

package/LICENSE

@@ -0,0 +1,200 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   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 the 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 any 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
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. Please also get an in-depth
+      understanding of this license before applying it.
+
+      Copyright [yyyy] [name of copyright owner]
+
+      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
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+      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.

package/README.md

@@ -0,0 +1,256 @@
+# Claude Scrum Skill
+
+An open-source npm package of Claude Code skills that give you a complete scrum pipeline — from PRD to production release — with Claude as your scrum master. Includes project scaffolding, sprint planning, status tracking, sprint releases, and full-project emulation testing. One PR per sprint. You stay in the executive seat.
+
+```
+PRD → /project-scaffold → GitHub Project with sprints, stories, branches
+                              ↓
+                        /sprint-plan → populate the next sprint
+                              ↓
+                     Claude works stories → auto-merge to release branch
+                              ↓
+                       /sprint-status → check progress anytime
+                              ↓
+                      /sprint-release → wrap up sprint, open release PR
+                              ↓
+                     You review one PR → merge to main
+                              ↓
+                        /sprint-plan → next cycle
+```
+
+## Installation
+
+### npm (recommended)
+
+```bash
+npm install -g @houseofwolvesllc/claude-scrum-skill
+```
+
+This copies all skills into `~/.claude/skills/`. All six skills are installed as siblings so relative paths to shared conventions resolve correctly.
+
+### Claude Code Plugin Marketplace
+
+```
+/plugin marketplace add houseofwolvesllc/claudescrumskill
+```
+
+### Manual
+
+Clone the repo and copy the `skills/` contents into `~/.claude/skills/` (global) or `your-repo/.claude/skills/` (per-project). All skill directories must be siblings — `sprint-plan`, `sprint-status`, and `sprint-release` reference `../project-scaffold/references/CONVENTIONS.md` via relative path.
+
+## Quick Start
+
+### 1. Create a Fine-Grained GitHub Personal Access Token
+
+These skills use `gh` for all GitHub operations. You need a fine-grained PAT scoped to the repos you want to manage.
+
+**Step 1:** Go to [github.com/settings/personal-access-tokens](https://github.com/settings/personal-access-tokens) and click **Generate new token**.
+
+**Step 2:** Fill in the token details:
+- **Token name** — Something descriptive like `claude-code-pm`
+- **Expiration** — Set a reasonable window (90 days is a good default)
+- **Resource owner** — Your account (or your org if the repos live there)
+- **Repository access** — Select **Only select repositories**, then pick the repos these skills will manage
+
+**Step 3:** Under **Permissions → Repository permissions**, grant:
+
+| Permission | Access | Why |
+|---|---|---|
+| Contents | Read & Write | Create branches, push commits |
+| Issues | Read & Write | Create and update stories on the project board |
+| Metadata | Read | Required by GitHub for all fine-grained PATs |
+| Pull requests | Read & Write | Open PRs for story branches and releases |
+
+**Step 4:** Under **Permissions → Account permissions**, grant:
+
+| Permission | Access | Why |
+|---|---|---|
+| Projects | Read & Write | Create project boards, custom fields, and views |
+
+**Step 5:** Click **Generate token** and copy it immediately — you won't see it again.
+
+**Step 6:** Authenticate the GitHub CLI with your new token:
+
+```bash
+echo "YOUR_TOKEN" | gh auth login --with-token
+```
+
+Verify it worked:
+
+```bash
+gh auth status
+```
+
+**Security tip:** Do not grant write access to your `main` branch via the token. Set up branch protection rules so merges to `main` always require your manual review. This is the gate that keeps you in control.
+
+### 2. Write a PRD
+
+Create a markdown file with your project requirements. The more structured, the better the scaffold. At minimum, include:
+- Project name and description
+- Phases or milestones with clear boundaries
+- User stories or features per phase
+- Acceptance criteria for each story
+
+### 3. Scaffold the Project
+
+Open Claude Code in your repo and run:
+
+```
+/project-scaffold path/to/your-prd.md
+```
+
+This creates:
+- A GitHub Project board with custom fields (Status, Sprint, Priority, Executor, Story Points, Phase)
+- Board views: Current Sprint, Claude Queue, My Tasks, Backlog, Phase Overview
+- Issues for every story, labeled with type, priority, phase, and executor
+- Milestones for each phase
+- A release branch for the first phase
+- Branch protection on main
+
+### 4. Plan a Sprint
+
+```
+/sprint-plan owner/repo
+```
+
+The skill pulls stories from the backlog, assigns them to the next sprint iteration, and sets up the release branch. It respects your velocity target (default: 20 story points) and prioritizes by the Priority field.
+
+### 5. Assign an Executor
+
+Label stories to tell Claude what's its responsibility:
+
+```bash
+# Assign all Phase 1 stories to Claude
+gh issue list --label "phase:1" --json number -q '.[].number' | \
+  xargs -I {} gh issue edit {} --add-label "executor:claude"
+```
+
+Three executor labels:
+
+| Label | Who | When |
+|---|---|---|
+| `executor:claude` | Claude Code | Clear implementation path, no human judgment needed |
+| `executor:human` | You | Business decisions, credentials, external approvals |
+| `executor:cowork` | Cowork agent | Research, drafting, web-based tasks |
+
+### 6. Hand Off to Claude Code
+
+In Claude Code, tell it to work the sprint:
+
+> "Pick up the current sprint. Work through all stories labeled executor:claude in priority order. For each story, create a feature branch off the release branch, implement, open a PR back to the release branch, and move the issue to Done."
+
+Claude works autonomously — branching, committing, opening PRs with auto-merge to the release branch.
+
+### 7. Check Progress
+
+```
+/sprint-status owner/repo
+```
+
+Get a progress report: stories completed vs. remaining, burndown, blockers, and what Claude is working on.
+
+### 8. Release the Sprint
+
+```
+/sprint-release owner/repo
+```
+
+This closes the sprint, opens a release PR from the release branch into main, and summarizes everything that shipped. You review one PR, merge it, and you're done.
+
+### 9. Emulate the Project
+
+```
+/project-emulate
+```
+
+Claude reads the entire codebase, discovers every role, every action, and every permission boundary, then walks through the full lifecycle — from infrastructure deployment through normal operations to teardown. Outputs a coverage report with a permission matrix and categorized issues.
+
+### 10. Repeat
+
+```
+/sprint-plan owner/repo
+```
+
+Start the next sprint. The cycle continues until the project is complete.
+
+## How It Works
+
+### Branch Strategy
+
+```
+main (protected — requires your review)
+ └── release/phase-1-core-api
+      ├── story/1-init-project → auto-merge ✓
+      ├── story/2-database-schema → auto-merge ✓
+      └── story/3-auth-endpoints → auto-merge ✓
+```
+
+Story branches auto-merge into the release branch when CI passes. You only review the release PR to `main`. This keeps Claude unblocked while giving you a single approval gate per sprint.
+
+### GitHub Project Board
+
+The scaffold creates a GitHub Project (the newer Projects experience, not classic project boards) with these custom fields:
+
+| Field | Type | Purpose |
+|---|---|---|
+| Status | Single select | Workflow state: Backlog → Ready → In Progress → In Review → Done |
+| Sprint | Iteration (2-week) | Time-boxed sprint assignment. Filter views by Milestone to scope to a sprint |
+| Priority | Single select | P0-Critical through P3-Low |
+| Executor | Single select | Who works this: `claude`, `human`, or `cowork` |
+| Story Points | Number | Fibonacci estimation (1, 2, 3, 5, 8, 13) |
+| Phase | Single select | Maps back to PRD phases/milestones |
+
+**Board views** use GitHub's view system:
+
+- **Current Sprint** — Board layout, filtered by Milestone to the active sprint, columns by Status
+- **Claude Queue** — Table layout, filtered to `Executor = claude` and `Status = Ready`, sorted by Priority
+- **By Sprint** — Board layout, grouped by Sprint (creates swimlanes per sprint)
+- **Phase Overview** — Table layout, grouped by Phase, with field sums on Story Points
+- **Backlog** — Table layout, filtered to `Status = Backlog`, sorted by Priority
+
+You can also use **Slice by** on any field to quickly filter the current view from a side panel — useful for slicing a sprint view by Executor or Priority.
+
+### Shared Conventions
+
+All skills reference a single `CONVENTIONS.md` file that defines labels, branch naming, custom fields, executor guidelines, and story point standards. Edit it once and every skill inherits the changes.
+
+Located at: `project-scaffold/references/CONVENTIONS.md`
+
+## Skills Reference
+
+| Skill | Command | What It Does |
+|---|---|---|
+| `project-scaffold` | `/project-scaffold <prd-path>` | Full project setup from PRD |
+| `sprint-plan` | `/sprint-plan [owner/repo]` | Plan and populate the next sprint |
+| `sprint-status` | `/sprint-status [owner/repo]` | Progress report and burndown |
+| `sprint-release` | `/sprint-release [owner/repo]` | Close sprint, open release PR |
+| `project-emulate` | `/project-emulate` | Full walkthrough coverage of all roles, actions, and lifecycle stages |
+
+## Customization
+
+### Sprint Length
+Edit `CONVENTIONS.md` → "Sprint Cadence" section. Default is 2 weeks.
+
+### Velocity Target
+The `sprint-plan` skill asks for velocity or defaults to 20 story points. Adjust as you calibrate.
+
+### Label Colors
+All label hex colors are defined in the `project-scaffold` skill. Modify to match your preferences.
+
+### Executor Criteria
+Edit `CONVENTIONS.md` → "Executor Assignment Guidelines" to tune what gets assigned to Claude vs. you vs. Cowork.
+
+### Adding Phases
+Phases map to your PRD structure. If you add new phases later, create a new milestone and add the corresponding value to the Phase custom field.
+
+## Tips
+
+- **Chunk large phases** into multiple sprints for natural review gates. If Phase 1 has 30 stories, split it into 2-3 sprints rather than one massive batch.
+- **Filter views by Milestone** to scope board views to the active sprint. Update the filter when you move to the next sprint.
+- **Start small.** Scaffold a real but small project first to calibrate your conventions before relying on it for bigger work.
+- **Branch protection is your safety net.** The PAT should not have write access to main. Merges to main always go through your review.
+- **Run `/project-emulate` before releases** to catch permission gaps, missing flows, and dead code before shipping.
+
+## License
+
+Apache 2.0 — See [LICENSE](LICENSE) for details.

package/bin/install.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const HOME = process.env.HOME || process.env.USERPROFILE;
+const SKILLS_DIR = path.join(HOME, '.claude', 'skills');
+const SOURCE_DIR = path.join(__dirname, '..', 'skills');
+
+const skills = [
+  'project-scaffold',
+  'sprint-plan',
+  'sprint-status',
+  'sprint-release',
+  'project-emulate'
+];
+
+function copyRecursive(src, dest) {
+  if (!fs.existsSync(src)) return;
+
+  if (fs.statSync(src).isDirectory()) {
+    fs.mkdirSync(dest, { recursive: true });
+    for (const item of fs.readdirSync(src)) {
+      copyRecursive(path.join(src, item), path.join(dest, item));
+    }
+  } else {
+    fs.copyFileSync(src, dest);
+  }
+}
+
+console.log('\n📋 Installing claude-scrum-skill...\n');
+
+// Ensure ~/.claude/skills exists
+fs.mkdirSync(SKILLS_DIR, { recursive: true });
+
+let installed = 0;
+for (const skill of skills) {
+  const src = path.join(SOURCE_DIR, skill);
+  const dest = path.join(SKILLS_DIR, skill);
+
+  if (fs.existsSync(src)) {
+    copyRecursive(src, dest);
+    console.log(`  ✅ ${skill}`);
+    installed++;
+  } else {
+    console.log(`  ⚠️  ${skill} — source not found, skipping`);
+  }
+}
+
+console.log(`\n✨ Installed ${installed} skills to ${SKILLS_DIR}`);
+console.log('   Skills are available in Claude Code immediately.\n');
+console.log('   Run /project-scaffold <prd-path> to get started.\n');

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@houseofwolvesllc/claude-scrum-skill",
+  "version": "1.0.0",
+  "description": "Claude Code skills for scrum project management — PRD to production release pipeline with project scaffolding, sprint planning, status tracking, sprint releases, and full-project emulation testing.",
+  "bin": {},
+  "scripts": {
+    "postinstall": "node bin/install.js"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "skills",
+    "scrum",
+    "sprint",
+    "project-management",
+    "agile",
+    "github-projects"
+  ],
+  "author": "House of Wolves LLC",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/houseofwolvesllc/claudescrumskill.git"
+  },
+  "homepage": "https://github.com/houseofwolvesllc/claudescrumskill#readme",
+  "bugs": {
+    "url": "https://github.com/houseofwolvesllc/claudescrumskill/issues"
+  },
+  "files": [
+    "skills/",
+    "bin/"
+  ]
+}

package/skills/project-emulate/SKILL.md

@@ -0,0 +1,155 @@
+---
+name: project-emulate
+description: Systematically walk through every user-facing workflow in a project by reading the codebase, discovering all roles and functionality, then emulating each role through the complete lifecycle from deployment to teardown. Claude Code figures out the roles, permissions, actions, and permutations itself — no manifests or configuration needed.
+allowed-tools: Bash, Read, Grep, Glob, Write
+---
+
+# Project Emulate
+
+Claude Code reads the codebase, discovers everything, and walks through it all. No config files. No role manifests. No manual setup. Claude is smart enough to figure out what exists and what every role can do.
+
+## The Job
+
+1. **Read the project** — understand what it is, what it does, how it's structured
+2. **Discover every role** — find all user types, service accounts, admin levels, anonymous access
+3. **Discover every action** — find all routes, commands, workflows, infrastructure operations
+4. **Map permissions** — determine what each role can and cannot do
+5. **Walk through everything** — emulate each role executing each action across the full lifecycle
+6. **Report coverage** — what works, what's broken, what's missing, what's unreachable
+
+## Phase 1: Discovery
+
+Read the entire project. Build a complete mental model. Scan for:
+
+**Roles** — Look everywhere roles are defined or referenced:
+- Auth middleware, RBAC configs, policy files, guard decorators
+- Role enums, permission constants, user type definitions
+- Database seeds/fixtures/migrations that create default roles
+- IAM policies, service account definitions, API key scopes
+- Environment-specific roles (dev vs staging vs prod)
+- Don't forget: anonymous/unauthenticated users, system/cron jobs, CI/CD service accounts
+
+**Actions** — Find every thing a user or system can do:
+- Route files, controllers, API handlers (REST, GraphQL, gRPC, WebSocket)
+- CLI commands and subcommands
+- UI pages, forms, buttons, workflows
+- Background jobs, scheduled tasks, event handlers
+- Infrastructure operations (deploy, scale, configure, destroy)
+- Database operations (migrate, seed, backup, restore)
+- Admin-only operations (user management, config changes, feature flags)
+
+**Permission Boundaries** — Map which roles can do which actions:
+- Route-level guards and middleware chains
+- Field-level permissions (what data each role can see/edit)
+- Resource ownership rules (users can edit their own, admins can edit all)
+- State-dependent permissions (e.g., only draft posts can be deleted by authors)
+- Rate limits or quotas that differ by role
+
+**Lifecycle Stages** — Identify the natural ordering of operations:
+- Infrastructure provisioning and deployment
+- Initial setup and configuration
+- User/account creation and onboarding
+- Normal CRUD operations
+- Advanced/power-user workflows
+- Administrative operations
+- Maintenance and migration
+- Teardown and destruction
+
+## Phase 2: Build the Permutation Matrix
+
+After discovery, construct the complete matrix:
+
+```
+Roles × Actions × Lifecycle Stages = Total Permutations
+```
+
+Organize this as a structured walkthrough plan:
+
+For each **lifecycle stage** (in order):
+  For each **role** (from most privileged to least):
+    For each **action available at this stage**:
+      - What should happen (success path)
+      - What should be denied (permission boundary)
+      - What edge cases exist (empty states, conflicts, limits)
+
+**Critical**: Include negative cases. For every action a role CAN do, verify that less-privileged roles CANNOT. Permission boundaries are as important as happy paths.
+
+## Phase 3: Walkthrough
+
+Execute the walkthrough by narrating through every cell in the matrix. For each action:
+
+1. **State the context**: "As [role], during [lifecycle stage], attempting to [action]"
+2. **Trace the code path**: Follow the request through middleware → handler → service → database
+3. **Identify the outcome**: Success, permission denied, validation error, or missing implementation
+4. **Note edge cases**: What happens with empty data, concurrent access, invalid input
+5. **Flag issues**: Anything that looks broken, missing, inconsistent, or insecure
+
+### Walkthrough Order
+
+Follow the natural lifecycle:
+
+```
+1. INFRASTRUCTURE — Deploy, configure, verify (health checks, smoke tests)
+2. BOOTSTRAP — Database migration, seed data, initial admin creation
+3. ADMIN OPERATIONS — User/role management, system settings, feature flags
+4. USER ONBOARDING — Registration, authentication, profile setup
+5. CORE FUNCTIONALITY — All CRUD operations, search, relationships, file handling
+6. ADVANCED WORKFLOWS — Multi-step processes, integrations, batch operations, notifications
+7. EDGE CASES & BOUNDARIES — Empty states, limits, concurrent access, error handling
+8. MAINTENANCE — Backup/restore, data migration, upgrades, cleanup jobs
+9. TEARDOWN — Account deletion, resource cleanup, infrastructure destruction, data export
+```
+
+Not every project will have all stages. Skip what doesn't apply. Add stages unique to the project.
+
+## Phase 4: Coverage Report
+
+After the walkthrough, produce a structured report:
+
+### Summary
+- Total roles discovered
+- Total actions discovered
+- Total permutations walked
+- Coverage percentage (walked / total possible)
+
+### Issues Found
+Categorize by severity:
+- **Critical**: Permission escalation paths, missing auth checks, broken core flows
+- **Warning**: Inconsistent behavior, missing error handling, undocumented features
+- **Info**: Dead code, unreachable features, minor edge cases
+
+### Missing Coverage
+- Actions that exist in code but aren't reachable by any role
+- Roles referenced in code but never fully defined
+- Lifecycle stages with no corresponding implementation
+- Permission checks that reference non-existent roles or actions
+
+### Permission Matrix
+A clean table: Roles as rows, Actions as columns, cells showing allowed / denied / ambiguous / not applicable
+
+## Output
+
+Save results to:
+
+```
+emulation-report/
+├── SUMMARY.md              # High-level findings and coverage stats
+├── DISCOVERY.md            # All roles, actions, and permissions found
+├── WALKTHROUGH.md          # The complete narrated walkthrough
+├── PERMISSION-MATRIX.md    # Role × Action matrix table
+└── ISSUES.md               # All issues found, categorized by severity
+```
+
+For large projects, split the walkthrough by lifecycle stage into a `walkthrough/` subdirectory.
+
+## Execution Notes
+
+**Be exhaustive but structured.** The whole point is 100% coverage. Don't skip actions because they seem trivial. Walk through everything.
+
+**Follow the code, not the docs.** The code is the source of truth. If docs say one thing and code does another, report the discrepancy.
+
+**Think like each role.** Including things they shouldn't be able to do.
+
+**Track state across the walkthrough.** Walk in lifecycle order so dependencies are naturally satisfied.
+
+**Report, don't fix.** Discover and document. Flag everything clearly for separate prioritization.

package/skills/project-scaffold/SKILL.md

@@ -0,0 +1,173 @@
+---
+name: project-scaffold
+description: Scaffold a complete GitHub Project from PRD or spec documents. Creates the project board with custom fields and views, milestones for each phase, issues for every story with proper labels and dependencies, and sets up the branch strategy. Use when starting a new project, onboarding a new PRD, or bootstrapping a GitHub Project structure from requirements documents.
+allowed-tools: Bash, Read, Write, Glob, Grep
+argument-hint: <path-to-prd-or-spec-files>
+---
+
+# Project Scaffold
+
+Scaffold a complete GitHub Project from one or more PRD or spec documents.
+
+## Before You Start
+
+1. Read `references/CONVENTIONS.md` in this skill's directory for all project management standards including label taxonomy, branch strategy, issue templates, custom fields, and executor assignment guidelines. Follow these conventions exactly.
+2. Confirm the `gh` CLI is authenticated by running `gh auth status`.
+3. Identify the target repository. If the user doesn't specify, ask which repo to use.
+
+## Input
+
+The user provides `$ARGUMENTS` which should be one or more file paths to PRD or spec documents (markdown, text, or similar). If no arguments are provided, ask the user to specify the PRD location.
+
+Read all provided documents thoroughly before proceeding.
+
+## Scaffolding Procedure
+
+### Step 1: Parse the PRD
+
+Extract from the documents:
+- Project name and description
+- Phases/milestones (ordered)
+- User stories per phase with acceptance criteria
+- Dependencies between stories
+- Any technical architecture notes
+
+### Step 2: Create Labels
+
+Create all labels defined in CONVENTIONS.md on the target repo:
+
+```bash
+# Executor labels
+gh label create "executor:claude" --color 0E8A16 --description "Claude Code handles this" --repo <owner/repo>
+gh label create "executor:human" --color 1D76DB --description "Requires human judgment" --repo <owner/repo>
+gh label create "executor:cowork" --color D4C5F9 --description "Cowork agent task" --repo <owner/repo>
+
+# Status signal labels
+gh label create "ready-for-work" --color 0E8A16 --repo <owner/repo>
+gh label create "needs-context" --color FBCA04 --repo <owner/repo>
+gh label create "blocked" --color B60205 --repo <owner/repo>
+gh label create "deferred" --color D93F0B --repo <owner/repo>
+gh label create "rolled-over" --color E99695 --repo <owner/repo>
+
+# Type labels
+gh label create "type:story" --color C2E0C6 --repo <owner/repo>
+gh label create "type:bug" --color D73A4A --repo <owner/repo>
+gh label create "type:spike" --color D4C5F9 --repo <owner/repo>
+gh label create "type:infra" --color 0075CA --repo <owner/repo>
+gh label create "type:chore" --color FEF2C0 --repo <owner/repo>
+
+# Priority labels
+gh label create "P0-critical" --color B60205 --repo <owner/repo>
+gh label create "P1-high" --color D93F0B --repo <owner/repo>
+gh label create "P2-medium" --color FBCA04 --repo <owner/repo>
+gh label create "P3-low" --color 0E8A16 --repo <owner/repo>
+
+# Phase labels (one per PRD phase)
+# gh label create "phase:<N>" --color <color> --repo <owner/repo>
+```
+
+### Step 3: Create Milestones
+
+For each phase in the PRD:
+
+```bash
+gh api repos/<owner/repo>/milestones -f title="Phase N: <Phase Name>" -f description="<Phase summary from PRD>" -f state="open"
+```
+
+### Step 4: Create the GitHub Project
+
+```bash
+# Create the project (org-level or user-level depending on repo ownership)
+gh project create --owner <owner> --title "<Project Name>"
+```
+
+Note the project number returned. Then configure custom fields as defined in CONVENTIONS.md. Use the GraphQL API via `gh api graphql` to add:
+- Status (single select with values: Backlog, Ready, In Progress, In Review, Done)
+- Priority (single select with values: P0-Critical, P1-High, P2-Medium, P3-Low)
+- Executor (single select with values: claude, human, cowork)
+- Story Points (number field)
+- Phase (single select with values derived from PRD phases)
+- Sprint (iteration field with 2-week cycles)
+
+### Step 5: Create Issues
+
+For each story extracted from the PRD, create an issue following the template in CONVENTIONS.md:
+
+```bash
+gh issue create \
+  --repo <owner/repo> \
+  --title "<Story title>" \
+  --body "<Issue body from template>" \
+  --label "type:story,executor:<type>,<priority>,ready-for-work" \
+  --milestone "<Phase N: Phase Name>"
+```
+
+For each issue:
+- Assign executor label based on the executor assignment guidelines in CONVENTIONS.md
+- Assign priority based on PRD emphasis and dependencies
+- Assign to the correct milestone
+- Estimate story points based on the guidelines in CONVENTIONS.md
+- Note dependencies in the issue body
+
+After creating issues, add them to the GitHub Project and set their custom field values.
+
+### Step 6: Link Dependencies
+
+For any stories with dependencies, add cross-references:
+- Edit blocking issues to mention "Blocks #<number>" in the body
+- Edit blocked issues to mention "Blocked by #<number>" in the body
+
+### Step 7: Create Branch Structure
+
+```bash
+# Ensure main is up to date
+git checkout main && git pull
+
+# Create release branch for the first phase/sprint
+git checkout -b release/<first-milestone-slug>
+git push -u origin release/<first-milestone-slug>
+```
+
+### Step 8: Configure Branch Protection
+
+Attempt to set branch protection rules as defined in CONVENTIONS.md. If permissions are insufficient, output the recommended settings for the user to configure manually.
+
+### Step 9: Generate Summary
+
+Output a complete summary:
+
+```
+## Project Scaffold Complete
+
+**Project:** <name>
+**Repository:** <owner/repo>
+**Project Board:** <link to GitHub Project>
+
+### Milestones
+- Phase 1: <name> — <N> stories, <total points> points
+- Phase 2: <name> — <N> stories, <total points> points
+...
+
+### Story Breakdown by Executor
+- executor:claude — <N> stories (<points> points)
+- executor:human — <N> stories (<points> points)
+- executor:cowork — <N> stories (<points> points)
+
+### Branch Structure
+- Release branch: release/<slug> (created)
+- Branch protection: <configured/manual setup needed>
+
+### Next Steps
+1. Review the project board: <link>
+2. Adjust priorities and sprint assignments as needed
+3. Run `/sprint-plan` to plan the first sprint iteration
+4. Start work with `/sprint-status` to monitor progress
+```
+
+## Error Handling
+
+- If `gh` is not authenticated, provide instructions: `gh auth login`
+- If the repo doesn't exist, ask the user to create it or specify the correct repo
+- If label creation fails (label exists), skip silently
+- If project creation fails, check if user has appropriate permissions
+- Always capture and report issue numbers for cross-referencing

package/skills/project-scaffold/references/CONVENTIONS.md

@@ -0,0 +1,170 @@
+# Project Management Conventions
+
+This document defines the shared standards used across all project management skills.
+All PM skills reference this file — update it here and changes propagate everywhere.
+
+## GitHub Project Structure
+
+### Project Board Custom Fields
+
+Every GitHub Project board MUST include these custom fields:
+
+| Field | Type | Values | Purpose |
+|-------|------|--------|---------|
+| Status | Single select | `Backlog`, `Ready`, `In Progress`, `In Review`, `Done` | Kanban workflow state |
+| Sprint | Iteration | 2-week cycles (configurable) | Sprint assignment |
+| Priority | Single select | `P0-Critical`, `P1-High`, `P2-Medium`, `P3-Low` | Triage priority |
+| Executor | Single select | `claude`, `human`, `cowork` | Who works this story |
+| Story Points | Number | 1, 2, 3, 5, 8, 13 | Fibonacci estimation |
+| Phase | Single select | Derived from PRD phases | Maps back to PRD structure |
+
+### Project Board Views
+
+Create these views on every project board:
+
+1. **Current Sprint** — Board layout, filtered by Milestone to the active sprint, columns by Status
+2. **Claude Queue** — Table layout, filtered to `Executor = claude` AND `Status = Ready`, sorted by Priority
+3. **My Tasks** — Table layout, filtered to `Executor = human`, grouped by Sprint
+4. **By Sprint** — Board layout, grouped by Sprint (creates swimlanes per sprint)
+5. **Phase Overview** — Table layout, grouped by Phase, with field sums on Story Points
+6. **Backlog** — Table layout, filtered to `Status = Backlog`, sorted by Priority
+
+## Label Taxonomy
+
+### Executor Labels (REQUIRED on every story)
+
+- `executor:claude` — Claude Code handles implementation autonomously
+- `executor:human` — Requires human judgment, decision-making, or external action
+- `executor:cowork` — Lighter tasks suitable for Cowork/Chrome agent (research, drafts, web tasks)
+
+### Status Signal Labels
+
+- `ready-for-work` — Fully specced, unblocked, ready to pick up
+- `needs-context` — Missing information; cannot begin until resolved
+- `blocked` — Dependent on another issue (MUST link blocking issue)
+- `deferred` — Intentionally pushed to a future sprint
+- `rolled-over` — Incomplete from previous sprint, gets priority in next planning
+
+### Type Labels
+
+- `type:story` — A user-facing feature or capability
+- `type:bug` — Defect in existing functionality
+- `type:spike` — Research/exploration task with defined timebox
+- `type:infra` — Infrastructure, CI/CD, tooling, DevOps
+- `type:chore` — Maintenance, cleanup, refactoring, documentation
+
+### Priority Labels
+
+- `P0-critical` — Blocking release, security issue, or data loss risk
+- `P1-high` — Core functionality for the current phase
+- `P2-medium` — Important but not blocking
+- `P3-low` — Nice-to-have, polish, optimization
+
+## Branch Strategy
+
+### Branch Naming
+
+- **Release branches:** `release/<milestone-slug>` (e.g., `release/phase-1-core-api`)
+- **Story branches:** `story/<issue-number>-<short-slug>` (e.g., `story/42-user-auth-endpoint`)
+- **Spike branches:** `spike/<issue-number>-<short-slug>`
+- **Bug fix branches:** `fix/<issue-number>-<short-slug>`
+
+### Merge Strategy
+
+```
+main (protected)
+ └── release/phase-1-core-api (sprint release branch)
+      ├── story/1-init-project-structure
+      ├── story/2-database-schema
+      ├── story/3-auth-endpoints
+      └── story/4-user-crud
+```
+
+- **Story → Release branch:** Auto-merge when CI passes. No human review required.
+- **Release → main:** Human review required. This is the executive approval gate.
+- Story PRs target the release branch, NOT main.
+- Release PR to main includes a sprint summary (auto-generated by sprint-release skill).
+
+### Branch Protection Rules
+
+For the release branch:
+- Require status checks to pass (CI/tests)
+- Allow auto-merge when checks pass
+- No required reviewers
+
+For main:
+- Require status checks to pass
+- Require at least 1 reviewer (the human executive)
+- No force pushes
+- No deletions
+
+## Issue Template
+
+Use this template for every story/task issue:
+
+```markdown
+## Objective
+[What this accomplishes — one clear sentence]
+
+## Acceptance Criteria
+- [ ] [Specific, testable criterion]
+- [ ] [Specific, testable criterion]
+- [ ] [Specific, testable criterion]
+
+## Technical Context
+[Architecture notes, relevant files, API contracts, approach guidance.
+For executor:claude — be specific about code paths, patterns, and test expectations.
+For executor:human — explain why this needs human judgment and what decisions are needed.]
+
+## Dependencies
+- **Blocked by:** [#issue or "none"]
+- **Blocks:** [#issue or "none"]
+```
+
+## Milestone Structure
+
+- Each PRD **phase** becomes a GitHub **milestone**
+- Milestone title format: `Phase N: <Phase Name>` (e.g., `Phase 1: Core API`)
+- Milestone description: Copy the phase summary from the PRD
+- Milestone due date: Derived from sprint cadence and story point estimates
+- Stories are assigned to milestones based on their phase
+
+## Sprint Cadence
+
+- Default sprint length: **2 weeks** (configurable per project)
+- Sprint naming: `Sprint <N>` within the project's iteration field
+- A phase may span multiple sprints if the work exceeds one cycle
+- At sprint boundaries, incomplete stories roll to the next sprint with a `rolled-over` label
+
+## Story Point Guidelines
+
+| Points | Meaning | Example |
+|--------|---------|---------|
+| 1 | Trivial — config change, copy update | Update an env variable |
+| 2 | Small — single file, clear implementation | Add a validation rule |
+| 3 | Medium — multiple files, straightforward | New API endpoint with tests |
+| 5 | Large — cross-cutting, some unknowns | Auth system with middleware |
+| 8 | Very large — significant complexity | Database migration with data transform |
+| 13 | Epic-sized — should probably be split | Full feature module end-to-end |
+
+If a story estimates at 13, consider splitting it into smaller stories.
+
+## Executor Assignment Guidelines
+
+### Assign `executor:claude` when:
+- Implementation path is clear from acceptance criteria
+- Work is primarily code: new features, endpoints, tests, refactoring
+- No external approvals, account access, or human judgment needed
+- Dependencies are resolved (status is `ready-for-work`)
+
+### Assign `executor:human` when:
+- Requires external service signup, credentials, or account configuration
+- Involves business decisions, UX judgment calls, or stakeholder input
+- Needs access to systems Claude cannot reach (vendor portals, billing, etc.)
+- Requires physical-world action (hardware, meetings, approvals)
+
+### Assign `executor:cowork` when:
+- Research tasks: competitive analysis, documentation review
+- Content drafting: blog posts, documentation, emails
+- Web-based tasks: form submissions, data gathering from websites
+- File organization and cleanup tasks

package/skills/sprint-plan/SKILL.md

@@ -0,0 +1,116 @@
+---
+name: sprint-plan
+description: Plan the next sprint iteration for a GitHub Project. Pulls stories from the backlog, assigns them to the upcoming sprint based on priority and capacity, and prepares the sprint for execution. Use when starting a new sprint cycle or when re-planning mid-sprint.
+allowed-tools: Bash, Read, Write, Glob, Grep
+argument-hint: [owner/repo] [project-number]
+---
+
+# Sprint Plan
+
+Plan and populate the next sprint iteration for an existing GitHub Project.
+
+## Before You Start
+
+1. Read `../project-scaffold/references/CONVENTIONS.md` for all project management standards. Follow these conventions exactly.
+2. Confirm the `gh` CLI is authenticated by running `gh auth status`.
+
+## Input
+
+`$ARGUMENTS` should be the repo identifier and optionally the project number.
+If not provided, detect from the current git remote or ask the user.
+
+## Planning Procedure
+
+### Step 1: Assess Current State
+
+```bash
+# Get open milestones
+gh api repos/<owner/repo>/milestones --jq '.[] | select(.state=="open") | {number, title, open_issues, closed_issues}'
+
+# Get the project's current sprint iteration
+# Use GraphQL to query the project's iteration field and find the current/next sprint
+
+# Get backlog items (issues not assigned to a sprint, sorted by priority)
+gh issue list --repo <owner/repo> --state open --label "type:story" --json number,title,labels,milestone --jq 'sort_by(.labels)'
+```
+
+Gather:
+- How many stories are in the current sprint and their status
+- What's in the backlog, grouped by milestone/phase
+- Any `rolled-over` items from the previous sprint (these get priority)
+
+### Step 2: Calculate Capacity
+
+Ask the user (or use defaults):
+- Sprint length (default: 2 weeks per CONVENTIONS.md)
+- Velocity estimate (story points per sprint — use previous sprint actuals if available)
+- Any known unavailability or constraints
+
+Default starting velocity if no history: **20 points** per sprint.
+
+### Step 3: Select Stories for Sprint
+
+Fill the sprint in this priority order:
+
+1. **Rolled-over stories** from previous sprint (label: `rolled-over`)
+2. **Blocked items that are now unblocked** (remove `blocked` label, add `ready-for-work`)
+3. **P0-Critical stories** from the active milestone/phase
+4. **P1-High stories** from the active milestone/phase
+5. **P2-Medium and P3-Low** to fill remaining capacity
+
+Stop when the total story points reach the velocity target. Present the proposed sprint to the user for approval before assigning.
+
+### Step 4: Assign Sprint
+
+After confirmation, update issues:
+
+```bash
+# Add sprint iteration assignment via GraphQL
+# Update status to "Ready" for all sprint stories
+# Ensure "ready-for-work" label is on unblocked items
+# Ensure release branch exists for the target milestone
+```
+
+For each story in the sprint:
+- Set the Sprint iteration field to the new sprint
+- Set Status to "Ready" (or "Backlog" if dependencies aren't met yet)
+- Verify labels are correct
+
+### Step 5: Ensure Branch Exists
+
+```bash
+# Check if release branch exists for the active milestone
+git ls-remote --heads origin release/<milestone-slug>
+
+# If not, create it
+git checkout main && git pull
+git checkout -b release/<milestone-slug>
+git push -u origin release/<milestone-slug>
+```
+
+### Step 6: Generate Sprint Kickoff Summary
+
+```
+## Sprint <N> Planned
+
+**Sprint:** <N> | **Dates:** <start> — <end>
+**Target:** <points> points across <count> stories
+**Release Branch:** release/<milestone-slug>
+
+### By Executor
+- Claude: <N> stories (<points> pts) — ready for autonomous execution
+- Human: <N> stories (<points> pts) — requires your attention
+- Cowork: <N> stories (<points> pts) — delegatable via Cowork
+
+### Sprint Goals
+<2-3 sentence summary of what this sprint accomplishes in the context of the overall project>
+
+### Blockers/Risks
+<Any known risks, unresolved dependencies, or open questions>
+
+### Next Steps
+- Claude can begin picking up `executor:claude` + `ready-for-work` stories
+- Review `executor:human` stories for your personal task list
+- Run `/sprint-status` anytime to check progress
+- Run `/sprint-release` when the sprint is complete
+```

package/skills/sprint-release/SKILL.md

@@ -0,0 +1,100 @@
+---
+name: sprint-release
+description: Close out the current sprint and prepare a release. Generates a sprint summary, opens a release PR from the release branch into main, and transitions incomplete stories. Use when a sprint is complete or at the sprint boundary.
+allowed-tools: Bash, Read, Write, Glob, Grep
+argument-hint: [owner/repo] [project-number]
+---
+
+# Sprint Release
+
+Close the current sprint and open a release PR.
+
+## Before You Start
+
+1. Read `../project-scaffold/references/CONVENTIONS.md` for project management standards.
+2. Confirm the `gh` CLI is authenticated.
+
+## Input
+
+`$ARGUMENTS` should be the repo identifier and optionally the project number.
+If not provided, detect from the current git remote or ask the user.
+
+## Release Procedure
+
+### Step 1: Verify Sprint State
+
+```bash
+# Check for any stories still "In Progress" — warn before proceeding
+# Count completed vs incomplete stories
+# Get the release branch name for the current milestone
+```
+
+If stories are still in progress, warn the user and ask whether to:
+- Wait for completion
+- Roll incomplete stories to next sprint
+- Proceed anyway (mark as rolled-over)
+
+### Step 2: Handle Incomplete Stories
+
+For any stories not marked Done:
+- Add the `rolled-over` label
+- Remove from current sprint iteration
+- Note them in the release summary
+
+### Step 3: Generate Release Summary
+
+Build a comprehensive changelog from the sprint:
+
+```bash
+# Get all merged PRs on the release branch
+gh pr list --repo <owner/repo> --base release/<slug> --state merged --json number,title,labels,mergedAt,body
+
+# Get all closed issues from this sprint
+gh issue list --repo <owner/repo> --state closed --label "type:story" --json number,title,labels,closedAt
+```
+
+### Step 4: Open Release PR
+
+```bash
+gh pr create \
+  --repo <owner/repo> \
+  --base main \
+  --head release/<milestone-slug> \
+  --title "Release: Sprint <N> — <Phase Name>" \
+  --body "<Release summary markdown>"
+```
+
+The PR body should include:
+- Sprint summary (stories completed, points delivered)
+- Full changelog (each story with brief description)
+- Rolled-over items (if any)
+- Notable technical changes
+- Any known issues or follow-ups
+
+### Step 5: Close Sprint Iteration
+
+- Mark the sprint iteration as complete (via GraphQL)
+- Update milestone progress
+
+### Step 6: Output Release Summary
+
+```
+## Sprint <N> Release
+
+**Release PR:** #<pr-number> — <link>
+**Branch:** release/<slug> → main
+**Stories Delivered:** <count> (<points> points)
+
+### Changelog
+- #12 User auth endpoint (5 pts)
+- #13 Database schema migration (3 pts)
+- #14 API key provisioning (2 pts)
+...
+
+### Rolled Over
+- #18 Rate limiting (3 pts) — moved to next sprint
+
+### Next Steps
+1. Review and merge the release PR: <link>
+2. Run `/sprint-plan` to start the next sprint
+```

package/skills/sprint-status/SKILL.md

@@ -0,0 +1,95 @@
+---
+name: sprint-status
+description: Generate a status report for the current sprint. Shows progress by story, executor breakdown, burndown, blockers, and items needing attention. Use for daily standups, mid-sprint check-ins, or when asked about project progress.
+allowed-tools: Bash, Read, Grep
+argument-hint: [owner/repo] [project-number]
+---
+
+# Sprint Status
+
+Generate a comprehensive status report for the active sprint.
+
+## Before You Start
+
+1. Read `../project-scaffold/references/CONVENTIONS.md` for project management standards.
+2. Confirm the `gh` CLI is authenticated.
+
+## Input
+
+`$ARGUMENTS` should be the repo identifier and optionally the project number.
+If not provided, detect from the current git remote or ask the user.
+
+## Status Report Procedure
+
+### Step 1: Gather Data
+
+```bash
+# Get all issues in the current sprint iteration (via GraphQL project query)
+# Get issue states, labels, assignees
+# Get recent PRs targeting the release branch
+# Get CI status on the release branch
+
+# Open issues with sprint assignment
+gh issue list --repo <owner/repo> --state open --json number,title,labels,state,createdAt,updatedAt
+
+# Closed issues (completed this sprint)
+gh issue list --repo <owner/repo> --state closed --json number,title,labels,closedAt
+
+# PRs targeting the release branch
+gh pr list --repo <owner/repo> --base release/<milestone-slug> --json number,title,state,mergedAt,labels
+```
+
+### Step 2: Categorize Stories
+
+Group all sprint stories into:
+
+- **Done** — Issue closed, PR merged to release branch
+- **In Progress** — PR open or issue actively being worked
+- **Ready** — Not started but unblocked
+- **Blocked** — Has `blocked` label or unresolved dependency
+- **Needs Context** — Has `needs-context` label
+
+### Step 3: Generate Report
+
+```
+## Sprint <N> Status — <date>
+
+**Progress:** <done>/<total> stories | <done_points>/<total_points> points (<percentage>%)
+**Days Remaining:** <N> of <total> days
+
+### Burndown
+<done_points> / <total_points> points completed
+[████████░░░░░░░░] 50%
+
+### Completed
+| # | Title | Executor | Points | Closed |
+|---|-------|----------|--------|--------|
+| 12 | User auth endpoint | claude | 5 | 2h ago |
+...
+
+### In Progress
+| # | Title | Executor | Points | Status |
+|---|-------|----------|--------|--------|
+| 14 | API key provisioning | human | 2 | PR open |
+...
+
+### Ready (Not Started)
+| # | Title | Executor | Points | Priority |
+|---|-------|----------|--------|----------|
+| 18 | Rate limiting | claude | 3 | P2 |
+...
+
+### Blocked / Needs Attention
+| # | Title | Blocker | Action Needed |
+|---|-------|---------|---------------|
+| 16 | OAuth integration | Waiting on #15 | Complete #15 first |
+...
+
+### Executor Summary
+- Claude: <done>/<total> stories (<points> pts done)
+- Human: <done>/<total> stories (<points> pts done)
+- Cowork: <done>/<total> stories (<points> pts done)
+
+### Recommendations
+<Actionable suggestions: unblock items, re-prioritize, adjust scope if behind>
+```