feat: add standards compliance and package manager detection to workflow commands

## Standards Compliance
- All workflow commands now read ALL standards from droidz/standards/**/*.md
- Added Step 0: Load Standards to /shape-spec, /write-spec, /create-tasks
- Completed missing workflow instructions in /orchestrate-tasks
- Completed 2-shape-spec.md and 2-create-tasks-list.md subagent files

## Package Manager Detection
- Commands now detect package manager from lockfiles (bun, pnpm, yarn, npm)
- Added detection to /create-tasks, /orchestrate-tasks, /implement-tasks
- Updated implementation-verifier to use detected package manager
- Updated CI/CD pipeline skill with package manager mapping table

## Files Updated
- 18 files across claude and droid_cli payloads
- install.sh version bumped to 4.11.0

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: korallis

droidz_installer/payloads/claude/default/agents/implementation-verifier.md

@@ -38,23 +38,23 @@ For each task:
 
 ### Step 3: Run All Tests
 
-Execute comprehensive test suite:
-```bash
-# Unit tests
-npm test
-
-# Integration tests
-npm run test:integration
-
-# E2E tests
-npm run test:e2e
-
-# Type checking
-npm run type-check
-
-# Linting
-npm run lint
-```
+**First, detect the project's package manager** by checking for lockfiles:
+- `bun.lockb` → Use **bun**
+- `pnpm-lock.yaml` → Use **pnpm**
+- `yarn.lock` → Use **yarn**
+- `package-lock.json` → Use **npm**
+
+Execute comprehensive test suite using the **detected package manager**:
+
+| Test Type | npm | yarn | pnpm | bun |
+|-----------|-----|------|------|-----|
+| Unit tests | `npm test` | `yarn test` | `pnpm test` | `bun test` |
+| Integration | `npm run test:integration` | `yarn test:integration` | `pnpm test:integration` | `bun run test:integration` |
+| E2E tests | `npm run test:e2e` | `yarn test:e2e` | `pnpm test:e2e` | `bun run test:e2e` |
+| Type check | `npm run type-check` | `yarn type-check` | `pnpm type-check` | `bun run type-check` |
+| Linting | `npm run lint` | `yarn lint` | `pnpm lint` | `bun run lint` |
+
+**Note**: Only run tests that are available in the project's `package.json` scripts.
 
 ### Step 4: Create Verification Report
 

droidz_installer/payloads/claude/default/commands/2-create-tasks-list.md

@@ -16,3 +16,24 @@ NEXT STEP 👉 Run `/implement-tasks` (simple, effective) or `/orchestrate-tasks
 
 IMPORTANT: Ensure that the tasks list is ALIGNED and DOES NOT CONFLICT with the user's preferences and standards as detailed in the following files:
 
+### Standards Loading Instructions
+
+Before creating the tasks list, check for and load project standards:
+
+1. **Check if standards exist**: Look for `droidz/standards/` directory
+2. **If standards exist**, **read ALL standards files recursively**:
+   - Use glob pattern `droidz/standards/**/*.md` to find all markdown files
+   - This includes all subdirectories (global, frontend, backend, infrastructure, and any custom directories the user has created)
+   - Read every `.md` file found in the standards directory tree
+
+3. **Apply ALL loaded standards to task creation** by ensuring:
+   - Tasks follow documented coding principles and patterns
+   - Task groupings align with documented architectural boundaries
+   - Sub-tasks include necessary standards compliance (e.g., testing requirements)
+   - Tasks don't propose approaches that conflict with established conventions
+   - Error handling, security, and other concerns from standards are reflected in relevant tasks
+
+If no standards directory exists, proceed normally but note to the user:
+```
+ℹ️ No project standards found. Consider running /shape-standards to establish conventions.
+```

droidz_installer/payloads/claude/default/commands/2-shape-spec.md

@@ -28,3 +28,23 @@ Spec initialized successfully!
 
 IMPORTANT: Ensure that your research questions and insights are ALIGNED and DOES NOT CONFLICT with the user's preferences and standards as detailed in the following files:
 
+### Standards Loading Instructions
+
+Before proceeding, check for and load project standards:
+
+1. **Check if standards exist**: Look for `droidz/standards/` directory
+2. **If standards exist**, **read ALL standards files recursively**:
+   - Use glob pattern `droidz/standards/**/*.md` to find all markdown files
+   - This includes all subdirectories (global, frontend, backend, infrastructure, and any custom directories the user has created)
+   - Read every `.md` file found in the standards directory tree
+
+3. **Apply ALL loaded standards to your research** by ensuring:
+   - Questions align with established architectural patterns
+   - Proposed approaches don't conflict with documented conventions
+   - Requirements gathering considers existing coding principles
+   - Design decisions follow documented best practices
+
+If no standards directory exists, proceed normally but note to the user:
+```
+ℹ️ No project standards found. Consider running /shape-standards to establish conventions.
+```

droidz_installer/payloads/claude/default/commands/create-tasks.md

@@ -2,6 +2,57 @@
 
 You are creating a tasks breakdown from a given spec and requirements for a new feature.
 
+## User Standards & Preferences Compliance
+
+**IMPORTANT**: Before creating tasks, you MUST check for and adhere to the user's project standards.
+
+### Step 0: Load Standards & Detect Project Configuration
+
+#### 0a. Load Standards
+
+Check if standards exist and load them:
+
+1. Check for standards directory: `droidz/standards/`
+2. If it exists, **read ALL standards files recursively**:
+   - Use glob pattern `droidz/standards/**/*.md` to find all markdown files
+   - This includes all subdirectories (global, frontend, backend, infrastructure, and any custom directories the user has created)
+   - Read every `.md` file found in the standards directory tree
+
+3. When creating the tasks list, ensure adherence to ALL loaded standards:
+   - Tasks follow documented coding principles and patterns
+   - Task groupings align with documented architectural boundaries
+   - Sub-tasks include necessary standards compliance (e.g., testing requirements)
+   - Tasks don't propose approaches that conflict with established conventions
+
+If no standards directory exists, proceed without standards constraints but inform the user:
+```
+ℹ️ No project standards found at droidz/standards/
+   Consider running /shape-standards to establish project conventions.
+```
+
+#### 0b. Detect Package Manager
+
+**IMPORTANT**: Detect the project's package manager by checking for lockfiles. Use the detected package manager for ALL tasks involving package installation, script running, or dependency management.
+
+**Detection Order** (first match wins):
+1. `bun.lockb` → Use **bun** (`bun install`, `bun run`, `bunx`)
+2. `pnpm-lock.yaml` → Use **pnpm** (`pnpm install`, `pnpm run`, `pnpm dlx`)
+3. `yarn.lock` → Use **yarn** (`yarn install`, `yarn run`, `yarn dlx`)
+4. `package-lock.json` → Use **npm** (`npm install`, `npm run`, `npx`)
+5. No lockfile found → Default to **npm** but note in tasks that the user should verify their preferred package manager
+
+**Command Mapping**:
+| Action | npm | yarn | pnpm | bun |
+|--------|-----|------|------|-----|
+| Install deps | `npm install` | `yarn install` | `pnpm install` | `bun install` |
+| Add package | `npm install <pkg>` | `yarn add <pkg>` | `pnpm add <pkg>` | `bun add <pkg>` |
+| Run script | `npm run <script>` | `yarn <script>` | `pnpm <script>` | `bun run <script>` |
+| Execute bin | `npx <cmd>` | `yarn dlx <cmd>` | `pnpm dlx <cmd>` | `bunx <cmd>` |
+
+When creating tasks, **always use the detected package manager commands** instead of hardcoding npm/npx.
+
+---
+
 ## PHASE 1: Get and read the spec.md and/or requirements document(s)
 
 You will need ONE OR BOTH of these files to inform your tasks breakdown:

droidz_installer/payloads/claude/default/commands/implement-tasks.md

@@ -8,6 +8,35 @@ PHASE 3: After ALL task groups have been implemented, delegate to implementation
 
 Follow each of these phases and their individual workflows IN SEQUENCE:
 
+## Pre-Requisite: Detect Project Configuration
+
+### Detect Package Manager
+
+**IMPORTANT**: Before implementing any tasks, detect the project's package manager by checking for lockfiles. Use the detected package manager for ALL implementation commands.
+
+**Detection Order** (first match wins):
+1. `bun.lockb` → Use **bun** (`bun install`, `bun run`, `bunx`)
+2. `pnpm-lock.yaml` → Use **pnpm** (`pnpm install`, `pnpm run`, `pnpm dlx`)
+3. `yarn.lock` → Use **yarn** (`yarn install`, `yarn run`, `yarn dlx`)
+4. `package-lock.json` → Use **npm** (`npm install`, `npm run`, `npx`)
+5. No lockfile found → Default to **npm** but note that the user should verify their preferred package manager
+
+**Command Mapping**:
+| Action | npm | yarn | pnpm | bun |
+|--------|-----|------|------|-----|
+| Install deps | `npm install` | `yarn install` | `pnpm install` | `bun install` |
+| Add package | `npm install <pkg>` | `yarn add <pkg>` | `pnpm add <pkg>` | `bun add <pkg>` |
+| Run script | `npm run <script>` | `yarn <script>` | `pnpm <script>` | `bun run <script>` |
+| Execute bin | `npx <cmd>` | `yarn dlx <cmd>` | `pnpm dlx <cmd>` | `bunx <cmd>` |
+
+Store the detected package manager and use it when:
+- Running tests, builds, or dev servers
+- Installing new dependencies
+- Executing CLI tools
+- Generating any bash scripts
+
+---
+
 ## Multi-Phase Process
 
 ### PHASE 1: Determine which task group(s) to implement

droidz_installer/payloads/claude/default/commands/orchestrate-tasks.md

@@ -4,6 +4,34 @@ Now that we have a spec and tasks list ready for implementation, we will proceed
 
 Follow each of these phases and their individual workflows IN SEQUENCE:
 
+## Pre-Requisite: Detect Project Configuration
+
+### Detect Package Manager
+
+**IMPORTANT**: Before orchestrating any tasks, detect the project's package manager by checking for lockfiles. Use the detected package manager for ALL implementation prompts and commands.
+
+**Detection Order** (first match wins):
+1. `bun.lockb` → Use **bun** (`bun install`, `bun run`, `bunx`)
+2. `pnpm-lock.yaml` → Use **pnpm** (`pnpm install`, `pnpm run`, `pnpm dlx`)
+3. `yarn.lock` → Use **yarn** (`yarn install`, `yarn run`, `yarn dlx`)
+4. `package-lock.json` → Use **npm** (`npm install`, `npm run`, `npx`)
+5. No lockfile found → Default to **npm** but note that the user should verify their preferred package manager
+
+**Command Mapping**:
+| Action | npm | yarn | pnpm | bun |
+|--------|-----|------|------|-----|
+| Install deps | `npm install` | `yarn install` | `pnpm install` | `bun install` |
+| Add package | `npm install <pkg>` | `yarn add <pkg>` | `pnpm add <pkg>` | `bun add <pkg>` |
+| Run script | `npm run <script>` | `yarn <script>` | `pnpm <script>` | `bun run <script>` |
+| Execute bin | `npx <cmd>` | `yarn dlx <cmd>` | `pnpm dlx <cmd>` | `bunx <cmd>` |
+
+Store the detected package manager and use it when:
+- Generating implementation prompts
+- Writing orchestration.yml
+- Creating any bash scripts or commands for specialists
+
+---
+
 ## Multi-Phase Process
 
 ### FIRST: Get tasks.md for this spec
@@ -149,6 +177,34 @@ For each delegation, provide the specialist with:
 
 In addition to the above items, also instruct the specialist to closely adhere to the user's standards & preferences as specified in the following files.  To build the list of file references to give to the specialist, follow these instructions:
 
+#### Building the Standards File List for a Task Group
+
+For each task group, look up its `standards` entry in `orchestration.yml` and resolve it to actual file paths:
+
+1. **If `standards` contains "all"**:
+   - Include all files from `droidz/standards/global/*.md`
+   - Include all files from `droidz/standards/frontend/*.md`
+   - Include all files from `droidz/standards/backend/*.md`
+   - Include all files from `droidz/standards/infrastructure/*.md`
+
+2. **If `standards` contains a wildcard pattern** (e.g., "global/*", "frontend/*"):
+   - Include all `.md` files from `droidz/standards/[pattern]/`
+   - Example: "backend/*" → all files in `droidz/standards/backend/`
+
+3. **If `standards` contains a specific file path** (e.g., "frontend/components.md"):
+   - Include that specific file: `droidz/standards/[path]`
+   - Example: "frontend/components.md" → `droidz/standards/frontend/components.md`
+
+4. **If `standards` is missing or contains "none"**:
+   - Do not include any standards files for this task group
+
+5. **Format the file list** for the specialist as markdown file references:
+   ```
+   - @droidz/standards/global/coding-principles.md
+   - @droidz/standards/global/error-handling.md
+   - @droidz/standards/frontend/components.md
+   ```
+
 Provide all of the above to the specialist when delegating tasks for it to implement.
 
 ### NEXT: Generate prompts
@@ -176,6 +232,38 @@ In the content template below, replace "[spec-title]" and "[this-spec]" with the
 
 To replace "[orchestrated-standards]", use the following workflow:
 
+1. **Look up this task group in `orchestration.yml`** to find its `standards` entries
+2. **Resolve each standards entry to actual file paths** using the same logic from "Building the Standards File List for a Task Group" above:
+   - "all" → list all files from all standards subdirectories
+   - "global/*" → list all files from `droidz/standards/global/`
+   - "frontend/components.md" → `droidz/standards/frontend/components.md`
+   - "none" or missing → leave [orchestrated-standards] empty or write "No specific standards assigned."
+
+3. **Format as markdown file references**:
+   ```
+   - @droidz/standards/global/coding-principles.md
+   - @droidz/standards/global/error-handling.md
+   - @droidz/standards/frontend/components.md
+   ```
+
+4. **Replace [orchestrated-standards]** in the prompt template with the formatted list
+
+**Example**: If `orchestration.yml` has:
+```yaml
+- name: user-dashboard
+  standards:
+    - global/*
+    - frontend/components.md
+```
+
+Then [orchestrated-standards] becomes:
+```
+- @droidz/standards/global/coding-principles.md
+- @droidz/standards/global/error-handling.md
+- @droidz/standards/global/testing.md
+- @droidz/standards/global/security.md
+- @droidz/standards/frontend/components.md
+```
 
 #### Prompt file content template:
 

droidz_installer/payloads/claude/default/commands/shape-spec.md

@@ -2,6 +2,33 @@
 
 You are helping me shape and plan the scope for a new feature.  The following process is aimed at documenting our key decisions regarding scope, design and architecture approach.  We will use our findings from this process later when we write the formal spec document (but we are NOT writing the formal spec yet).
 
+## User Standards & Preferences Compliance
+
+**IMPORTANT**: Before proceeding with spec shaping, you MUST check for and adhere to the user's project standards.
+
+### Step 0: Load Standards
+
+Check if standards exist and load them:
+
+1. Check for standards directory: `droidz/standards/`
+2. If it exists, **read ALL standards files recursively**:
+   - Use glob pattern `droidz/standards/**/*.md` to find all markdown files
+   - This includes all subdirectories (global, frontend, backend, infrastructure, and any custom directories the user has created)
+   - Read every `.md` file found in the standards directory tree
+
+3. Keep ALL standards in mind throughout the spec shaping process to ensure:
+   - Research questions align with established patterns
+   - Proposed approaches don't conflict with existing standards
+   - Architecture decisions follow documented conventions
+
+If no standards directory exists, proceed without standards constraints but inform the user:
+```
+ℹ️ No project standards found at droidz/standards/
+   Consider running /shape-standards to establish project conventions.
+```
+
+---
+
 This process will follow 3 main phases, each with their own workflow steps:
 
 Process overview (details to follow)

droidz_installer/payloads/claude/default/commands/write-spec.md

@@ -2,6 +2,34 @@
 
 You are creating a comprehensive specification for a new feature.
 
+## User Standards & Preferences Compliance
+
+**IMPORTANT**: Before writing the spec, you MUST check for and adhere to the user's project standards.
+
+### Step 0: Load Standards
+
+Check if standards exist and load them:
+
+1. Check for standards directory: `droidz/standards/`
+2. If it exists, **read ALL standards files recursively**:
+   - Use glob pattern `droidz/standards/**/*.md` to find all markdown files
+   - This includes all subdirectories (global, frontend, backend, infrastructure, and any custom directories the user has created)
+   - Read every `.md` file found in the standards directory tree
+
+3. Ensure the specification document adheres to ALL loaded standards:
+   - Follows documented coding principles and patterns
+   - References appropriate standards where relevant
+   - Does not propose approaches that conflict with established conventions
+   - Aligns technical decisions with documented best practices
+
+If no standards directory exists, proceed without standards constraints but inform the user:
+```
+ℹ️ No project standards found at droidz/standards/
+   Consider running /shape-standards to establish project conventions.
+```
+
+---
+
 Use the **spec-writer** subagent to create the specification document for this spec:
 
 Provide the spec-writer with:

droidz_installer/payloads/claude/default/skills/ci-cd-pipeline/SKILL.md

@@ -5,6 +5,30 @@ description: Set up and maintain continuous integration and continuous deploymen
 
 # CI/CD Pipeline - Automating Build, Test, and Deployment
 
+## Package Manager Detection
+
+**IMPORTANT**: Before creating CI/CD configurations, detect the project's package manager by checking for lockfiles and adapt all commands accordingly.
+
+**Detection Order** (first match wins):
+1. `bun.lockb` → Use **bun**
+2. `pnpm-lock.yaml` → Use **pnpm**
+3. `yarn.lock` → Use **yarn**
+4. `package-lock.json` → Use **npm**
+
+**Command Mapping** - Adapt examples in this skill to use the detected package manager:
+
+| Action | npm | yarn | pnpm | bun |
+|--------|-----|------|------|-----|
+| Install (CI) | `npm ci` | `yarn install --frozen-lockfile` | `pnpm install --frozen-lockfile` | `bun install --frozen-lockfile` |
+| Run script | `npm run <script>` | `yarn <script>` | `pnpm <script>` | `bun run <script>` |
+| Execute bin | `npx <cmd>` | `yarn dlx <cmd>` | `pnpm dlx <cmd>` | `bunx <cmd>` |
+| Cache key | `package-lock.json` | `yarn.lock` | `pnpm-lock.yaml` | `bun.lockb` |
+| Cache path | `~/.npm` | `~/.yarn/cache` | `~/.pnpm-store` | `~/.bun/install/cache` |
+
+**Note**: The examples below use npm by default. When implementing, replace with the appropriate commands for your detected package manager.
+
+---
+
 ## When to use this skill
 
 - Setting up GitHub Actions or GitLab CI workflows