cfsa-antigravity 2.19.0 → 2.19.2

package/template/.claude/skills/resolve-ambiguity/SKILL.md

@@ -0,0 +1,278 @@
+---
+name: resolve-ambiguity
+description: "Systematic ambiguity resolution through tiered information gathering. Use when facing unclear requirements, unknown context, uncertain implementation choices, or any situation where guessing would be risky."
+version: 1.0.0
+---
+
+# Resolve Ambiguity
+
+Resolve ambiguity through a systematic process that prioritizes accurate information over guessing. This skill determines the best source for missing information and retrieves it efficiently.
+
+**Core principle**: Rather ask than guess. Wrong assumptions waste more time than clarifying questions.
+
+**Usage**: Invoke this skill reactively — whenever an agent encounters something it doesn't know during any pipeline step.
+
+---
+
+## Quick Start
+
+When you encounter ambiguity, classify it:
+
+1. **Technical/Factual** — "How does X work?" "What is the correct syntax?" "What did the architecture doc decide?"
+   - Likely found in project or online sources
+   - Follow the tiered lookup process
+
+2. **Intent/Choice** — "Which approach should I use?" "What does the user want?" "Should we prioritize X or Y?"
+   - Requires user input
+   - Go directly to User Clarification (skip lookup)
+
+---
+
+## Tiered Lookup (for Technical/Factual ambiguity)
+
+Check sources in this order. **Stop as soon as you find authoritative information.**
+
+### Tier 1: Project Context Files
+
+**Check first — fastest and most relevant**
+
+Look for project-specific context that may already answer the question:
+- `AGENTS.md` or `GEMINI.md` — Agent instructions, tech stack, validation commands
+- `.agent/instructions/tech-stack.md` — Technology decisions
+- `.agent/instructions/patterns.md` — Code conventions
+- `.agent/instructions/structure.md` — Directory layout
+- `.agent/instructions/commands.md` — Dev, test, lint, build
+
+If these files contain `{{PLACEHOLDER}}` values, the information hasn't been decided yet — move to the next tier.
+
+### Tier 2: Upstream Spec Documents
+
+**Check second — the pipeline's own output**
+
+The answer may already exist in a document written by an earlier pipeline stage:
+- `docs/plans/ideation/ideation-index.md` + fractal domain tree (folder `*-index.md`, `*-cx.md`, and feature files) — Problem, personas, features, constraints, domain map
+- `docs/plans/*-architecture-design.md` — Tech stack, system design, security model
+- `docs/plans/ENGINEERING-STANDARDS.md` — Quality thresholds, performance budgets
+- `docs/plans/ia/*.md` — IA shards (features, data models, access control, edge cases)
+- `docs/plans/ia/deep-dives/*.md` — Detailed architectural decisions
+- `docs/plans/be/*.md` — BE specs (endpoints, contracts, schemas)
+- `docs/plans/fe/*.md` — FE specs (components, routing, state, a11y)
+
+**Read the specific section, not the entire document.** Use the IA/BE/FE index files to locate the relevant shard or spec.
+
+### Tier 3: Architectural & Config Files
+
+**Check third — project-specific patterns**
+
+Look within the codebase for answers embedded in configuration or existing code:
+- `package.json`, `tsconfig.json` — Dependencies, TypeScript config
+- `pyproject.toml`, `setup.py` — Python config
+- `Cargo.toml` — Rust config
+- `.env.example` — Environment variables
+- `README.md` — Project overview and setup
+- `ARCHITECTURE.md` or `docs/architecture.md` — Design decisions
+
+Also check existing code for established patterns:
+- Search for files matching the pattern you're trying to follow
+- Search for similar implementations in the codebase
+
+### Tier 4: MCP Documentation Tools
+
+**Check fourth — if MCP documentation tools are available**
+
+If MCP tools are available for documentation lookup, use them:
+- Context7, Firecrawl, or other documentation-specific MCP tools
+- These provide structured access to official library and framework documentation
+
+### Tier 5: Web Search Official Sources
+
+**Check fifth — for external APIs, libraries, standards**
+
+Search the web for:
+- Official documentation sites
+- GitHub repositories of libraries
+- API reference documentation
+- RFC or specification documents
+
+**Search strategy**:
+1. Search with specific query: `"{library/API name} documentation {specific topic}"`
+2. Fetch the most authoritative result (official docs preferred)
+3. Extract only the relevant information
+
+Prefer sources in this order:
+1. Official documentation (*.dev, *.io, readthedocs)
+2. GitHub repository README/docs
+3. Stack Overflow with high votes (for edge cases)
+
+### When to Stop
+
+Stop the tiered lookup when:
+- You find authoritative information that resolves the ambiguity
+- You've checked all relevant tiers without finding information
+- The information found indicates this is actually a choice/intent question
+
+If all tiers exhausted without answer, proceed to User Clarification.
+
+---
+
+## User Clarification (for Intent/Choice ambiguity)
+
+For intent/choice questions, or when tiered lookup fails, ask the user directly. **Never guess when user input is available.**
+
+### Principles
+
+1. **Explain what you need** — Tell the user what information is missing
+2. **Explain why you need it** — Describe how the answer affects the outcome
+3. **Offer smart choices** — If you can infer likely options, present them
+4. **Best practice first** — Order choices with recommended approach at top
+5. **Bad ideas last** — If including risky options, put them at the bottom
+6. **Always allow custom input** — User can always provide their own answer
+7. **When uncertain, don't guess choices** — Better to ask open-ended than offer wrong options
+
+### With Known Choices
+
+When you can confidently identify the options, present them to the user:
+- Question: Clear, specific question explaining context
+- Options ordered by preference (2-4 max):
+  1. Best practice / Most common / Recommended
+  2. Good alternative
+  3. Another valid option
+  4. Least recommended / Has drawbacks
+- Each option includes description explaining implications
+- User can always provide custom input
+
+### Without Known Choices
+
+When you cannot confidently identify the options:
+
+**DO NOT GUESS.** Ask an open-ended question instead:
+- Explain what you need to know and why
+- Keep options minimal or omit entirely
+- Allow free-form input as primary response method
+
+### Formatting Rules
+
+1. **Single question at a time** — Don't overwhelm with multiple questions
+2. **2-4 options maximum** — More becomes confusing
+3. **Descriptions are required** — Every option needs context
+4. **No yes/no when options exist** — Offer the actual choices instead
+5. **Acknowledge uncertainty** — "I'm not sure which applies, so..."
+
+---
+
+## Ambiguity Categories
+
+### Technical Implementation
+**Examples**: "How do I call this API?" "What's the correct syntax?"
+
+**Resolution path**:
+1. Check project context files → upstream specs
+2. Check architectural docs and existing code
+3. Search official documentation
+4. If still unclear → ask user for clarification
+
+### Project Conventions
+**Examples**: "What naming convention?" "Where should this file go?"
+
+**Resolution path**:
+1. Check agent instructions and patterns for explicit conventions
+2. Check existing code for patterns
+3. Check README/contributing guide
+4. If no clear pattern → ask user preference
+
+### Spec Interpretation
+**Examples**: "Does the IA shard mean X or Y?" "Is this edge case in scope?"
+
+**Resolution path**:
+1. Re-read the specific section of the upstream spec
+2. Check cross-shard references for clarification
+3. Check deep dives for architectural decisions
+4. If genuinely ambiguous → ask user (this is a spec gap that should be fixed)
+
+### User Intent
+**Examples**: "Which feature first?" "Should I also refactor X?"
+
+**Resolution path**:
+1. Skip lookup — this requires user input
+2. Ask user immediately
+3. Present inferred options if confident
+4. Allow open-ended response if uncertain
+
+### External Dependencies
+**Examples**: "Which version of X?" "What's the API for Y?"
+
+**Resolution path**:
+1. Check package.json/pyproject.toml for versions
+2. Search for current documentation
+3. Fetch official docs
+4. If version-specific behavior → confirm with user
+
+### Architectural Decisions
+**Examples**: "Monolith or microservices?" "Which pattern to use?"
+
+**Resolution path**:
+1. Check architecture-design.md for prior decisions
+2. Check ENGINEERING-STANDARDS.md for constraints
+3. This is usually a choice → ask user
+4. Present trade-offs clearly in options
+
+---
+
+## Relationship to `/audit-ambiguity`
+
+This skill and the audit workflow are complementary:
+
+| Aspect | `resolve-ambiguity` | `/audit-ambiguity` |
+|--------|---------------------|---------------------|
+| **When** | During any step, at any time | Between pipeline stages |
+| **Trigger** | Agent encounters something it doesn't know | User invokes as a gate |
+| **Scope** | Single question or decision | Entire spec layer |
+| **Output** | Answer or user decision | Scored report with punch list |
+| **Purpose** | Prevent guessing during execution | Verify completeness after writing |
+
+**Composition**: After `/audit-ambiguity` produces a punch list, it invokes this skill on each gap:
+- **Technical gaps** → tiered lookup finds the answer → **mechanical fix** with source citation
+- **Intent gaps** → no source has the answer → **judgment call** presented to user
+- This powers the audit's remediation phase with structured, source-backed resolution
+
+---
+
+## Anti-Patterns
+
+### Guessing and Hoping
+**Wrong**: Making assumptions and proceeding without verification
+**Instead**: Take 30 seconds to check or ask
+
+### Too Many Questions
+**Wrong**: Asking 5 questions before doing anything
+**Instead**: Ask only what's blocking immediate progress
+
+### Vague Questions
+**Wrong**: "How should I proceed?"
+**Instead**: "Should I use approach A (benefit) or B (benefit)?"
+
+### Assuming User Expertise
+**Wrong**: "Should I use the factory pattern or strategy pattern?"
+**Instead**: Explain the options in plain terms with trade-offs
+
+### Hiding Behind Defaults
+**Wrong**: Silently using a default without mentioning alternatives
+**Instead**: "I'll use X (the standard approach). Let me know if you'd prefer Y."
+
+### Skipping Upstream Specs
+**Wrong**: Searching the web for an answer that's already in the architecture doc
+**Instead**: Check Tier 1 and 2 (project docs and upstream specs) before going external
+
+### Not Recording the Resolution
+**Wrong**: Resolving ambiguity verbally but not updating the spec
+**Instead**: When a gap is resolved, update the relevant spec document so future readers don't hit the same ambiguity
+
+---
+
+## Process Summary
+
+1. **Detect**: Identify what information is missing
+2. **Classify**: Technical/Factual → Tiered lookup | Intent/Choice → User clarification
+3. **Resolve**: Execute the appropriate resolution path
+4. **Apply**: Use the information to proceed with the task
+5. **Record**: Update relevant documents so the resolution persists

package/template/.claude/skills/security-scanning-security-hardening/SKILL.md

@@ -0,0 +1,231 @@
+---
+name: security-scanning-security-hardening
+description: "Coordinate multi-layer security scanning and hardening across application, infrastructure, and compliance controls."
+---
+
+Implement comprehensive security hardening with defense-in-depth strategy through coordinated multi-agent orchestration:
+
+[Extended thinking: This workflow implements a defense-in-depth security strategy across all application layers. It coordinates specialized security agents to perform comprehensive assessments, implement layered security controls, and establish continuous security monitoring. The approach follows modern DevSecOps principles with shift-left security, automated scanning, and compliance validation. Each phase builds upon previous findings to create a resilient security posture that addresses both current vulnerabilities and future threats.]
+
+## Use this skill when
+
+- Running a coordinated security hardening program
+- Establishing defense-in-depth controls across app, infra, and CI/CD
+- Prioritizing remediation from scans and threat modeling
+
+## Do not use this skill when
+
+- You only need a quick scan without remediation work
+- You lack authorization for security testing or changes
+- The environment cannot tolerate invasive security controls
+
+## Instructions
+
+1. Execute Phase 1 to establish a security baseline.
+2. Apply Phase 2 remediations for high-risk issues.
+3. Implement Phase 3 controls and validate defenses.
+4. Complete Phase 4 validation and compliance checks.
+
+## Safety
+
+- Avoid intrusive testing in production without approval.
+- Ensure rollback plans exist before hardening changes.
+
+## Phase 1: Comprehensive Security Assessment
+
+### 1. Initial Vulnerability Scanning
+- Use Task tool with subagent_type="security-auditor"
+- Prompt: "Perform comprehensive security assessment on: $ARGUMENTS. Execute SAST analysis with Semgrep/SonarQube, DAST scanning with OWASP ZAP, dependency audit with Snyk/Trivy, secrets detection with GitLeaks/TruffleHog. Generate SBOM for supply chain analysis. Identify OWASP Top 10 vulnerabilities, CWE weaknesses, and CVE exposures."
+- Output: Detailed vulnerability report with CVSS scores, exploitability analysis, attack surface mapping, secrets exposure report, SBOM inventory
+- Context: Initial baseline for all remediation efforts
+
+### 2. Threat Modeling and Risk Analysis
+- Use Task tool with subagent_type="security-auditor"
+- Prompt: "Conduct threat modeling using STRIDE methodology for: $ARGUMENTS. Analyze attack vectors, create attack trees, assess business impact of identified vulnerabilities. Map threats to MITRE ATT&CK framework. Prioritize risks based on likelihood and impact."
+- Output: Threat model diagrams, risk matrix with prioritized vulnerabilities, attack scenario documentation, business impact analysis
+- Context: Uses vulnerability scan results to inform threat priorities
+
+### 3. Architecture Security Review
+- Use Task tool with subagent_type="backend-api-security::backend-architect"
+- Prompt: "Review architecture for security weaknesses in: $ARGUMENTS. Evaluate service boundaries, data flow security, authentication/authorization architecture, encryption implementation, network segmentation. Design zero-trust architecture patterns. Reference threat model and vulnerability findings."
+- Output: Security architecture assessment, zero-trust design recommendations, service mesh security requirements, data classification matrix
+- Context: Incorporates threat model to address architectural vulnerabilities
+
+## Phase 2: Vulnerability Remediation
+
+### 4. Critical Vulnerability Fixes
+- Use Task tool with subagent_type="security-auditor"
+- Prompt: "Coordinate immediate remediation of critical vulnerabilities (CVSS 7+) in: $ARGUMENTS. Fix SQL injections with parameterized queries, XSS with output encoding, authentication bypasses with secure session management, insecure deserialization with input validation. Apply security patches for CVEs."
+- Output: Patched code with vulnerability fixes, security patch documentation, regression test requirements
+- Context: Addresses high-priority items from vulnerability assessment
+
+### 5. Backend Security Hardening
+- Use Task tool with subagent_type="backend-api-security::backend-security-coder"
+- Prompt: "Implement comprehensive backend security controls for: $ARGUMENTS. Add input validation with OWASP ESAPI, implement rate limiting and DDoS protection, secure API endpoints with OAuth2/JWT validation, add encryption for data at rest/transit using AES-256/TLS 1.3. Implement secure logging without PII exposure."
+- Output: Hardened API endpoints, validation middleware, encryption implementation, secure configuration templates
+- Context: Builds upon vulnerability fixes with preventive controls
+
+### 6. Frontend Security Implementation
+- Use Task tool with subagent_type="frontend-mobile-security::frontend-security-coder"
+- Prompt: "Implement frontend security measures for: $ARGUMENTS. Configure CSP headers with nonce-based policies, implement XSS prevention with DOMPurify, secure authentication flows with PKCE OAuth2, add SRI for external resources, implement secure cookie handling with SameSite/HttpOnly/Secure flags."
+- Output: Secure frontend components, CSP policy configuration, authentication flow implementation, security headers configuration
+- Context: Complements backend security with client-side protections
+
+### 7. Mobile Security Hardening
+- Use Task tool with subagent_type="frontend-mobile-security::mobile-security-coder"
+- Prompt: "Implement mobile app security for: $ARGUMENTS. Add certificate pinning, implement biometric authentication, secure local storage with encryption, obfuscate code with ProGuard/R8, implement anti-tampering and root/jailbreak detection, secure IPC communications."
+- Output: Hardened mobile application, security configuration files, obfuscation rules, certificate pinning implementation
+- Context: Extends security to mobile platforms if applicable
+
+## Phase 3: Security Controls Implementation
+
+### 8. Authentication and Authorization Enhancement
+- Use Task tool with subagent_type="security-auditor"
+- Prompt: "Implement modern authentication system for: $ARGUMENTS. Deploy OAuth2/OIDC with PKCE, implement MFA with TOTP/WebAuthn/FIDO2, add risk-based authentication, implement RBAC/ABAC with principle of least privilege, add session management with secure token rotation."
+- Output: Authentication service configuration, MFA implementation, authorization policies, session management system
+- Context: Strengthens access controls based on architecture review
+
+### 9. Infrastructure Security Controls
+- Use Task tool with subagent_type="deployment-strategies::deployment-engineer"
+- Prompt: "Deploy infrastructure security controls for: $ARGUMENTS. Configure WAF rules for OWASP protection, implement network segmentation with micro-segmentation, deploy IDS/IPS systems, configure cloud security groups and NACLs, implement DDoS protection with rate limiting and geo-blocking."
+- Output: WAF configuration, network security policies, IDS/IPS rules, cloud security configurations
+- Context: Implements network-level defenses
+
+### 10. Secrets Management Implementation
+- Use Task tool with subagent_type="deployment-strategies::deployment-engineer"
+- Prompt: "Implement enterprise secrets management for: $ARGUMENTS. Deploy HashiCorp Vault or AWS Secrets Manager, implement secret rotation policies, remove hardcoded secrets, configure least-privilege IAM roles, implement encryption key management with HSM support."
+- Output: Secrets management configuration, rotation policies, IAM role definitions, key management procedures
+- Context: Eliminates secrets exposure vulnerabilities
+
+## Phase 4: Validation and Compliance
+
+### 11. Penetration Testing and Validation
+- Use Task tool with subagent_type="security-auditor"
+- Prompt: "Execute comprehensive penetration testing for: $ARGUMENTS. Perform authenticated and unauthenticated testing, API security testing, business logic testing, privilege escalation attempts. Use Burp Suite, Metasploit, and custom exploits. Validate all security controls effectiveness."
+- Output: Penetration test report, proof-of-concept exploits, remediation validation, security control effectiveness metrics
+- Context: Validates all implemented security measures
+
+### 12. Compliance and Standards Verification
+- Use Task tool with subagent_type="security-auditor"
+- Prompt: "Verify compliance with security frameworks for: $ARGUMENTS. Validate against OWASP ASVS Level 2, CIS Benchmarks, SOC2 Type II requirements, GDPR/CCPA privacy controls, HIPAA/PCI-DSS if applicable. Generate compliance attestation reports."
+- Output: Compliance assessment report, gap analysis, remediation requirements, audit evidence collection
+- Context: Ensures regulatory and industry standard compliance
+
+### 13. Security Monitoring and SIEM Integration
+- Use Task tool with subagent_type="incident-response::devops-troubleshooter"
+- Prompt: "Implement security monitoring and SIEM for: $ARGUMENTS. Deploy Splunk/ELK/Sentinel integration, configure security event correlation, implement behavioral analytics for anomaly detection, set up automated incident response playbooks, create security dashboards and alerting."
+- Output: SIEM configuration, correlation rules, incident response playbooks, security dashboards, alert definitions
+- Context: Establishes continuous security monitoring
+
+## Configuration Options
+- scanning_depth: "quick" | "standard" | "comprehensive" (default: comprehensive)
+- compliance_frameworks: ["OWASP", "CIS", "SOC2", "GDPR", "HIPAA", "PCI-DSS"]
+- remediation_priority: "cvss_score" | "exploitability" | "business_impact"
+- monitoring_integration: "splunk" | "elastic" | "sentinel" | "custom"
+- authentication_methods: ["oauth2", "saml", "mfa", "biometric", "passwordless"]
+
+## Success Criteria
+- All critical vulnerabilities (CVSS 7+) remediated
+- OWASP Top 10 vulnerabilities addressed
+- Zero high-risk findings in penetration testing
+- Compliance frameworks validation passed
+- Security monitoring detecting and alerting on threats
+- Incident response time < 15 minutes for critical alerts
+- SBOM generated and vulnerabilities tracked
+- All secrets managed through secure vault
+- Authentication implements MFA and secure session management
+- Security tests integrated into CI/CD pipeline
+
+## Coordination Notes
+- Each phase provides detailed findings that inform subsequent phases
+- Security-auditor agent coordinates with domain-specific agents for fixes
+- All code changes undergo security review before implementation
+- Continuous feedback loop between assessment and remediation
+- Security findings tracked in centralized vulnerability management system
+- Regular security reviews scheduled post-implementation
+
+Security hardening target: $ARGUMENTS
+
+## Attack Surface Review Protocol
+
+This protocol runs during `/create-prd-security`. Universal checks apply to all projects. Surface-specific checks are conditional — they run only if the corresponding surface has been confirmed during `/create-prd-stack`.
+
+### Universal Checks (All Projects)
+
+#### 1. Secret Management
+
+Where secrets are stored (env vars, vault, cloud secret manager), access policy, rotation cadence, CI injection method (environment variables, OIDC, sealed secrets).
+
+Document under `## Security — Attack Surface > Secret Management`.
+
+#### 2. Dependency Audit Cadence
+
+Scan frequency; CI gate behavior on critical CVE (block merge, warn, ignore); triage policy for high-severity CVEs (patch within N days) and medium-severity CVEs (patch within N days or accept-with-justification).
+
+Document under `## Security — Attack Surface > Dependency Auditing`.
+
+### Web Surface Checks (If Web Surface Confirmed)
+
+#### 1. OWASP Top 10 Review
+
+For each of the 10 categories, name the specific mechanism that mitigates it.
+
+**Rule:** "Handled by framework" is not acceptable — name the framework feature, the configuration, and the fallback if the framework is bypassed.
+
+Document under `## Security — Attack Surface > Web > OWASP Top 10`.
+
+#### 2. Security Headers
+
+Configured values for each of the following headers:
+
+- `Content-Security-Policy`
+- `Strict-Transport-Security`
+- `X-Content-Type-Options`
+- `X-Frame-Options`
+- `Referrer-Policy`
+- `Permissions-Policy`
+
+**Rule:** Each header must have a specific value, not just "enabled".
+
+Document under `## Security — Attack Surface > Web > Security Headers`.
+
+### API Surface Checks (If API Surface Confirmed)
+
+#### 1. OWASP API Security Top 10
+
+For each category, name the mechanism that mitigates it.
+
+**Special emphasis:** BOLA/IDOR requires a per-endpoint ownership check strategy — name how each endpoint verifies the requesting user owns the requested resource.
+
+Document under `## Security — Attack Surface > API > OWASP API Top 10`.
+
+### Desktop Surface Checks (If Desktop Surface Confirmed)
+
+#### 1. Sandboxing Model
+
+Sandboxing strategy, IPC security boundaries, auto-update verification, code signing chain.
+
+#### 2. Notarization
+
+Notarization workflow (macOS notarization, Windows SmartScreen signing), signing certificate source, CI step that performs notarization.
+
+#### 3. Local Data Encryption
+
+Strategy for encrypting sensitive data at rest (encryption library, key storage mechanism, what data is encrypted).
+
+Document all three under `## Security — Attack Surface > Desktop`.
+
+### Mobile Surface Checks (If Mobile Surface Confirmed)
+
+#### 1. Mobile-Specific Threats
+
+Certificate pinning strategy, secure storage approach, jailbreak/root detection policy, deep link validation.
+
+Document under `## Security — Attack Surface > Mobile`.
+
+### User Presentation Prompts
+
+Present these two questions to the user for confirmation:
+
+1. "Are there any attack vectors I've missed for your specific domain?"
+2. "Do the OWASP mechanisms look correct, or are any of them actually handled differently?"