claude-code-workflow 7.2.27 → 7.2.29

package/.codex/skills/security-audit/orchestrator.md

@@ -0,0 +1,384 @@
+---
+name: security-audit
+description: OWASP Top 10 and STRIDE security auditing with supply chain analysis. Triggers on "security audit", "security scan", "cso".
+agents: security-auditor
+phases: 4
+---
+
+# Security Audit
+
+4-phase security audit covering supply chain risks, OWASP Top 10 code review, STRIDE threat modeling, and trend-tracked reporting. Produces structured JSON findings in `.workflow/.security/`.
+
+## Architecture
+
+```
++----------------------------------------------------------------------+
+|  security-audit Orchestrator                                          |
+|  -> Mode selection: quick-scan (Phase 1 only) vs comprehensive       |
++-----------------------------------+----------------------------------+
+                                    |
+              +---------------------+---------------------+
+              |                                           |
+    [quick-scan mode]                        [comprehensive mode]
+              |                                           |
+    +---------v---------+                   +------------v-----------+
+    |  Phase 1           |                   |  Phase 1               |
+    |  Supply Chain Scan |                   |  Supply Chain Scan     |
+    |  -> supply-chain-  |                   |  -> supply-chain-      |
+    |     report.json    |                   |     report.json        |
+    +---------+---------+                   +------------+-----------+
+              |                                          |
+       [score gate]                          +-----------v-----------+
+       score >= 8/10                         |  Phase 2               |
+              |                              |  OWASP Review          |
+       [DONE or                              |  -> owasp-findings.    |
+        DONE_WITH_CONCERNS]                  |     json               |
+                                             +-----------+-----------+
+                                                         |
+                                             +-----------v-----------+
+                                             |  Phase 3               |
+                                             |  Threat Modeling       |
+                                             |  (STRIDE)              |
+                                             |  -> threat-model.json  |
+                                             +-----------+-----------+
+                                                         |
+                                             +-----------v-----------+
+                                             |  Phase 4               |
+                                             |  Report & Tracking     |
+                                             |  -> audit-report-      |
+                                             |     {date}.json        |
+                                             +-----------------------+
+```
+
+---
+
+## Agent Registry
+
+| Agent | task_name | Role File | Responsibility | Pattern | fork_context |
+|-------|-----------|-----------|----------------|---------|-------------|
+| security-auditor | security-auditor | ~/.codex/agents/security-auditor.md | Execute all 4 phases: dependency audit, OWASP review, STRIDE modeling, report generation | Deep Interaction (2.3) | false |
+
+> **COMPACT PROTECTION**: Agent files are execution documents. When context compression occurs and agent instructions are reduced to summaries, **you MUST immediately `Read` the corresponding agent.md to reload before continuing execution**.
+
+---
+
+## Fork Context Strategy
+
+| Agent | task_name | fork_context | fork_from | Rationale |
+|-------|-----------|-------------|-----------|-----------|
+| security-auditor | security-auditor | false | — | Starts fresh; all context provided via assign_task phase messages |
+
+**Fork Decision Rules**:
+
+| Condition | fork_context | Reason |
+|-----------|-------------|--------|
+| security-auditor spawn | false | Self-contained pipeline; phase inputs passed via assign_task |
+
+---
+
+## Subagent Registry
+
+Utility subagents spawned by `security-auditor` (not by the orchestrator):
+
+| Subagent | Agent File | Callable By | Purpose | Model |
+|----------|-----------|-------------|---------|-------|
+| inline-owasp-analysis | ~/.codex/agents/cli-explore-agent.md | security-auditor (Phase 2) | OWASP Top 10 2021 code-level analysis | haiku |
+
+> Subagents are spawned by agents within their own execution context (Pattern 2.8), not by the orchestrator.
+
+---
+
+## Mode Selection
+
+Determine mode from user request before spawning any agent.
+
+| User Intent | Mode | Phases to Execute | Gate |
+|-------------|------|-------------------|------|
+| "quick scan", "daily check", "fast audit" | quick-scan | Phase 1 only | score >= 8/10 |
+| "full audit", "comprehensive", "security audit", "cso" | comprehensive | Phases 1 → 2 → 3 → 4 | no regression (initial: >= 2/10) |
+| Ambiguous | Prompt user: "Quick-scan (Phase 1 only) or comprehensive (all 4 phases)?" | — | — |
+
+---
+
+## Phase Execution
+
+### Phase 1: Supply Chain Scan
+
+**Objective**: Detect low-hanging security risks in dependencies, secrets, CI/CD pipelines, and LLM integrations.
+
+**Input**:
+
+| Source | Description |
+|--------|-------------|
+| Working directory | Project source to be scanned |
+| Mode | quick-scan or comprehensive |
+
+**Execution**:
+
+Spawn the security-auditor agent and assign Phase 1:
+
+```
+spawn_agent({
+  task_name: "security-auditor",
+  fork_context: false,
+  message: `### MANDATORY FIRST STEPS
+1. Read: ~/.codex/skills/security-audit/agents/security-auditor.md
+
+## TASK: Phase 1 — Supply Chain Scan
+
+Mode: <quick-scan|comprehensive>
+Work directory: .workflow/.security
+
+Execute Phase 1 per: ~/.codex/skills/security-audit/phases/01-supply-chain-scan.md
+
+Deliverables:
+- .workflow/.security/supply-chain-report.json
+- Structured output summary with finding counts by severity`
+})
+const phase1Result = wait_agent({ targets: ["security-auditor"], timeout_ms: 300000 })
+```
+
+**On timeout**:
+
+```
+assign_task({
+  target: "security-auditor",
+  items: [{ type: "text", text: "Finalize current supply chain scan and output supply-chain-report.json now." }]
+})
+const phase1Result = wait_agent({ targets: ["security-auditor"], timeout_ms: 120000 })
+```
+
+**Output**:
+
+| Artifact | Description |
+|----------|-------------|
+| `.workflow/.security/supply-chain-report.json` | Dependency, secrets, CI/CD, and LLM findings |
+
+---
+
+### Quick-Scan Gate (quick-scan mode only)
+
+After Phase 1 completes, evaluate score and close agent.
+
+| Condition | Action |
+|-----------|--------|
+| score >= 8.0 | Status: DONE. No blocking issues. |
+| 6.0 <= score < 8.0 | Status: DONE_WITH_CONCERNS. Log warning — review before deploy. |
+| score < 6.0 | Status: DONE_WITH_CONCERNS. Block deployment. Remediate critical/high findings. |
+
+```
+close_agent({ target: "security-auditor" })
+```
+
+> **If quick-scan mode**: Stop here. Output final summary with score and findings count.
+
+---
+
+### Phase 2: OWASP Review (comprehensive mode only)
+
+**Objective**: Systematic code-level review against all 10 OWASP Top 10 2021 categories.
+
+**Input**:
+
+| Source | Description |
+|--------|-------------|
+| `.workflow/.security/supply-chain-report.json` | Phase 1 findings for context |
+| Source files | All .ts/.js/.py/.go/.java excluding node_modules, dist, build |
+
+**Execution**:
+
+```
+assign_task({
+  target: "security-auditor",
+  items: [{ type: "text", text: `## Phase 2 — OWASP Review
+
+Execute Phase 2 per: ~/.codex/skills/security-audit/phases/02-owasp-review.md
+
+Context: supply-chain-report.json already written to .workflow/.security/
+Reference: ~/.codex/skills/security-audit/specs/owasp-checklist.md
+
+Deliverables:
+- .workflow/.security/owasp-findings.json
+- Coverage for all 10 OWASP categories (A01–A10)` }]
+})
+const phase2Result = wait_agent({ targets: ["security-auditor"], timeout_ms: 360000 })
+```
+
+**Output**:
+
+| Artifact | Description |
+|----------|-------------|
+| `.workflow/.security/owasp-findings.json` | OWASP findings with owasp_id, severity, file:line, evidence, remediation |
+
+---
+
+### Phase 3: Threat Modeling (comprehensive mode only)
+
+**Objective**: Apply STRIDE threat model to architecture components; assess attack surface.
+
+**Input**:
+
+| Source | Description |
+|--------|-------------|
+| `.workflow/.security/supply-chain-report.json` | Phase 1 findings |
+| `.workflow/.security/owasp-findings.json` | Phase 2 findings |
+| Source files | Route handlers, data stores, auth modules, external service clients |
+
+**Execution**:
+
+```
+assign_task({
+  target: "security-auditor",
+  items: [{ type: "text", text: `## Phase 3 — Threat Modeling (STRIDE)
+
+Execute Phase 3 per: ~/.codex/skills/security-audit/phases/03-threat-modeling.md
+
+Context: supply-chain-report.json and owasp-findings.json available in .workflow/.security/
+Cross-reference Phase 1 and Phase 2 findings when mapping STRIDE categories.
+
+Deliverables:
+- .workflow/.security/threat-model.json
+- All 6 STRIDE categories (S, T, R, I, D, E) evaluated per component
+- Trust boundaries and attack surface quantified` }]
+})
+const phase3Result = wait_agent({ targets: ["security-auditor"], timeout_ms: 360000 })
+```
+
+**Output**:
+
+| Artifact | Description |
+|----------|-------------|
+| `.workflow/.security/threat-model.json` | STRIDE threat model with components, trust boundaries, attack surface |
+
+---
+
+### Phase 4: Report & Tracking (comprehensive mode only)
+
+**Objective**: Calculate score, compare with previous audits, generate date-stamped report.
+
+**Input**:
+
+| Source | Description |
+|--------|-------------|
+| `.workflow/.security/supply-chain-report.json` | Phase 1 output |
+| `.workflow/.security/owasp-findings.json` | Phase 2 output |
+| `.workflow/.security/threat-model.json` | Phase 3 output |
+| `.workflow/.security/audit-report-*.json` | Previous audit reports (optional, for trend) |
+
+**Execution**:
+
+```
+assign_task({
+  target: "security-auditor",
+  items: [{ type: "text", text: `## Phase 4 — Report & Tracking
+
+Execute Phase 4 per: ~/.codex/skills/security-audit/phases/04-report-tracking.md
+
+Scoring reference: ~/.codex/skills/security-audit/specs/scoring-gates.md
+
+Steps:
+1. Aggregate all findings from phases 1–3
+2. Calculate score using formula: base 10.0 - (weighted_sum / normalization)
+3. Check for previous audit: ls -t .workflow/.security/audit-report-*.json | head -1
+4. Compute trend (improving/stable/regressing/baseline)
+5. Evaluate gate (initial >= 2/10; subsequent >= previous_score)
+6. Write .workflow/.security/audit-report-<YYYY-MM-DD>.json
+
+Deliverables:
+- .workflow/.security/audit-report-<YYYY-MM-DD>.json
+- Updated copies of all phase outputs in .workflow/.security/` }]
+})
+const phase4Result = wait_agent({ targets: ["security-auditor"], timeout_ms: 300000 })
+```
+
+**Output**:
+
+| Artifact | Description |
+|----------|-------------|
+| `.workflow/.security/audit-report-<date>.json` | Full scored report with trend, top risks, remediation priority |
+
+---
+
+### Comprehensive Gate (comprehensive mode only)
+
+After Phase 4 completes, evaluate gate and close agent.
+
+| Audit Type | Condition | Result | Action |
+|------------|-----------|--------|--------|
+| Initial (no prior audit) | score >= 2.0 | PASS | DONE. Baseline established. Plan remediation. |
+| Initial | score < 2.0 | FAIL | DONE_WITH_CONCERNS. Critical exposure. Immediate triage required. |
+| Subsequent | score >= previous_score | PASS | DONE. No regression. |
+| Subsequent | previous_score - 0.5 <= score < previous_score | WARN | DONE_WITH_CONCERNS. Marginal change. Review new findings. |
+| Subsequent | score < previous_score - 0.5 | FAIL | DONE_WITH_CONCERNS. Regression detected. Investigate new findings. |
+
+```
+close_agent({ target: "security-auditor" })
+```
+
+---
+
+## Lifecycle Management
+
+### Timeout Protocol
+
+| Phase | Default Timeout | On Timeout |
+|-------|-----------------|------------|
+| Phase 1: Supply Chain | 300000 ms (5 min) | assign_task "Finalize output now", re-wait 120s |
+| Phase 2: OWASP Review | 360000 ms (6 min) | assign_task "Output partial findings", re-wait 120s |
+| Phase 3: Threat Modeling | 360000 ms (6 min) | assign_task "Output partial threat model", re-wait 120s |
+| Phase 4: Report | 300000 ms (5 min) | assign_task "Write report with available data", re-wait 120s |
+
+### Cleanup Protocol
+
+Agent is closed after the final executed phase (Phase 1 for quick-scan, Phase 4 for comprehensive).
+
+```
+close_agent({ target: "security-auditor" })
+```
+
+---
+
+## Error Handling
+
+| Scenario | Resolution |
+|----------|------------|
+| Agent timeout (first) | assign_task "Finalize current work and output now" + re-wait 120000 ms |
+| Agent timeout (second) | Log error, close_agent({ target: "security-auditor" }), report partial results |
+| Phase output file missing | assign_task requesting specific file output, re-wait |
+| Audit tool not installed (npm/pip) | Phase 1 logs as INFO finding and continues — not a blocker |
+| No previous audit found | Treat as baseline — apply initial gate (>= 2/10) |
+| User cancellation | close_agent({ target: "security-auditor" }), report current state |
+
+---
+
+## Output Format
+
+```
+## Summary
+- One-sentence completion status with mode and final score
+
+## Score
+- Overall: <N>/10 (<Rating>)
+- Gate: PASS|FAIL|WARN
+- Mode: quick-scan|comprehensive
+
+## Findings
+- Critical: <N>
+- High: <N>
+- Medium: <N>
+- Low: <N>
+
+## Artifacts
+- File: .workflow/.security/supply-chain-report.json
+- File: .workflow/.security/owasp-findings.json (comprehensive only)
+- File: .workflow/.security/threat-model.json (comprehensive only)
+- File: .workflow/.security/audit-report-<date>.json (comprehensive only)
+
+## Top Risks
+1. <Most critical finding with file:line and remediation>
+2. <Second finding>
+
+## Next Steps
+1. Remediate critical findings (effort: <low|medium|high>)
+2. Re-run audit to verify fixes
+```

package/.codex/skills/security-audit/phases/01-supply-chain-scan.md

@@ -0,0 +1,226 @@
+# Phase 1: Supply Chain Scan
+
+> **COMPACT PROTECTION**: This is a core execution phase. If context compression has occurred and this file is only a summary, **MUST `Read` this file again before executing any Step**. Do not execute from memory.
+
+Detect low-hanging security risks in third-party dependencies, hardcoded secrets, CI/CD pipelines, and LLM/AI integrations.
+
+## Objective
+
+- Audit third-party dependencies for known vulnerabilities
+- Scan source code for leaked secrets and credentials
+- Review CI/CD configuration for injection risks
+- Check for LLM/AI prompt injection vulnerabilities
+
+## Input
+
+| Source | Required | Description |
+|--------|----------|-------------|
+| Project root | Yes | Working directory containing source files and dependency manifests |
+| WORK_DIR | Yes | `.workflow/.security` — output directory (create if not exists) |
+
+## Execution Steps
+
+### Step 1: Dependency Audit
+
+Detect package manager and run appropriate audit tool.
+
+**Decision Table**:
+
+| Condition | Action |
+|-----------|--------|
+| `package-lock.json` or `yarn.lock` present | Run `npm audit --json` |
+| `requirements.txt` or `pyproject.toml` present | Run `pip-audit --format json`; fallback `safety check --json` |
+| `go.sum` present | Run `govulncheck ./...` |
+| No manifest files found | Log INFO finding: "No dependency manifests detected"; continue |
+| Audit tool not installed | Log INFO finding: "<tool> not installed — manual review needed"; continue |
+
+**Execution**:
+
+```bash
+# Ensure output directory exists
+mkdir -p .workflow/.security
+WORK_DIR=".workflow/.security"
+
+# Node.js projects
+if [ -f package-lock.json ] || [ -f yarn.lock ]; then
+  npm audit --json > "${WORK_DIR}/npm-audit-raw.json" 2>&1 || true
+fi
+
+# Python projects
+if [ -f requirements.txt ] || [ -f pyproject.toml ]; then
+  pip-audit --format json --output "${WORK_DIR}/pip-audit-raw.json" 2>&1 || true
+  # Fallback: safety check
+  safety check --json > "${WORK_DIR}/safety-raw.json" 2>&1 || true
+fi
+
+# Go projects
+if [ -f go.sum ]; then
+  govulncheck ./... 2>&1 | tee "${WORK_DIR}/govulncheck-raw.txt" || true
+fi
+```
+
+---
+
+### Step 2: Secrets Detection
+
+Scan source files for hardcoded secrets using regex patterns. Exclude generated, compiled, and dependency directories.
+
+**Decision Table**:
+
+| Match Type | Severity | Category |
+|------------|----------|----------|
+| API key / token with 16+ chars | Critical | secret |
+| AWS AKIA key pattern | Critical | secret |
+| Private key PEM block | Critical | secret |
+| DB connection string with embedded password | Critical | secret |
+| Hardcoded JWT token | High | secret |
+| No matches | — | No finding |
+
+**Execution**:
+
+```bash
+# High-confidence patterns (case-insensitive)
+grep -rniE \
+  '(api[_-]?key|api[_-]?secret|access[_-]?token|auth[_-]?token|secret[_-]?key)\s*[:=]\s*["\x27][A-Za-z0-9+/=_-]{16,}' \
+  --include='*.ts' --include='*.js' --include='*.py' --include='*.go' \
+  --include='*.java' --include='*.rb' --include='*.env' --include='*.yml' \
+  --include='*.yaml' --include='*.json' --include='*.toml' --include='*.cfg' \
+  . || true
+
+# AWS patterns
+grep -rniE '(AKIA[0-9A-Z]{16}|aws[_-]?secret[_-]?access[_-]?key)' . || true
+
+# Private keys
+grep -rniE '-----BEGIN (RSA |EC |DSA )?PRIVATE KEY-----' . || true
+
+# Connection strings with passwords
+grep -rniE '(mongodb|postgres|mysql|redis)://[^:]+:[^@]+@' . || true
+
+# JWT tokens (hardcoded)
+grep -rniE 'eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}' . || true
+```
+
+Exclude from scan: `node_modules/`, `.git/`, `dist/`, `build/`, `__pycache__/`, `*.lock`, `*.min.js`.
+
+Redact actual matched secret values in findings — use `[REDACTED]` in evidence field.
+
+---
+
+### Step 3: CI/CD Config Review
+
+Check GitHub Actions and other CI/CD configurations for injection risks.
+
+**Decision Table**:
+
+| Pattern Found | Severity | Finding |
+|---------------|----------|---------|
+| `${{ github.event.` in `run:` block | High | Expression injection in workflow run step |
+| `pull_request_target` with checkout of PR code | High | Privileged workflow triggered by untrusted code |
+| `actions/checkout@v1` or `@v2` | Medium | Deprecated action version with known issues |
+| `secrets.` passed to untrusted context | High | Secret exposure risk |
+| No `.github/workflows/` directory | — | Not applicable; skip |
+
+**Execution**:
+
+```bash
+# Find workflow files
+find .github/workflows -name '*.yml' -o -name '*.yaml' 2>/dev/null
+
+# Check for expression injection in run: blocks
+# Dangerous: ${{ github.event.pull_request.title }} in run:
+grep -rn '\${{.*github\.event\.' .github/workflows/ 2>/dev/null || true
+
+# Check for pull_request_target with checkout of PR code
+grep -rn 'pull_request_target' .github/workflows/ 2>/dev/null || true
+
+# Check for use of deprecated/vulnerable actions
+grep -rn 'actions/checkout@v1\|actions/checkout@v2' .github/workflows/ 2>/dev/null || true
+
+# Check for secrets passed to untrusted contexts
+grep -rn 'secrets\.' .github/workflows/ 2>/dev/null || true
+```
+
+---
+
+### Step 4: LLM/AI Prompt Injection Check
+
+Scan for patterns indicating prompt injection risk in LLM integrations.
+
+**Decision Table**:
+
+| Pattern Found | Severity | Finding |
+|---------------|----------|---------|
+| User input directly concatenated into prompt/system_message | High | LLM prompt injection vector |
+| User input in template string passed to LLM call | High | LLM prompt injection via template |
+| f-string with user data in `.complete`/`.generate` call | High | Python LLM prompt injection |
+| LLM API call detected, no injection pattern | Low | LLM integration present — review for sanitization |
+
+**Execution**:
+
+```bash
+# User input concatenated directly into prompts
+grep -rniE '(prompt|system_message|messages)\s*[+=].*\b(user_input|request\.(body|query|params)|req\.)' \
+  --include='*.ts' --include='*.js' --include='*.py' . || true
+
+# Template strings with user data in LLM calls
+grep -rniE '(openai|anthropic|llm|chat|completion)\.' \
+  --include='*.ts' --include='*.js' --include='*.py' . || true
+
+# Check for missing input sanitization before LLM calls
+grep -rniE 'f".*{.*}.*".*\.(chat|complete|generate)' \
+  --include='*.py' . || true
+```
+
+---
+
+## Output
+
+| Artifact | Format | Description |
+|----------|--------|-------------|
+| `.workflow/.security/supply-chain-report.json` | JSON | All supply chain findings with severity classifications |
+
+```json
+{
+  "phase": "supply-chain-scan",
+  "timestamp": "ISO-8601",
+  "findings": [
+    {
+      "category": "dependency|secret|cicd|llm",
+      "severity": "critical|high|medium|low",
+      "title": "Finding title",
+      "description": "Detailed description",
+      "file": "path/to/file",
+      "line": 42,
+      "evidence": "matched text or context",
+      "remediation": "How to fix"
+    }
+  ],
+  "summary": {
+    "total": 0,
+    "by_severity": { "critical": 0, "high": 0, "medium": 0, "low": 0 },
+    "by_category": { "dependency": 0, "secret": 0, "cicd": 0, "llm": 0 }
+  }
+}
+```
+
+## Success Criteria
+
+| Criterion | Validation Method |
+|-----------|-------------------|
+| All 4 scan steps executed or explicitly skipped with reason | Review step execution log |
+| `supply-chain-report.json` written to `.workflow/.security/` | File exists and is valid JSON |
+| All findings have category, severity, file, evidence, remediation | JSON schema check |
+| Secret values redacted in evidence field | No raw credential values in output |
+
+## Error Handling
+
+| Scenario | Resolution |
+|----------|------------|
+| Audit tool not installed | Log INFO finding; continue with remaining steps |
+| `grep` finds no matches | No finding generated for that pattern; continue |
+| `.github/workflows/` does not exist | Mark CI/CD step as not_applicable; continue |
+| Write to WORK_DIR fails | Attempt `mkdir -p .workflow/.security` and retry once |
+
+## Next Phase
+
+-> [Phase 2: OWASP Review](02-owasp-review.md)