@forwardimpact/pathway 0.1.0 → 0.2.0

package/examples/capabilities/scale.yaml

@@ -1,3 +1,5 @@
+# yaml-language-server: $schema=https://schema.forwardimpact.team/json/capability.schema.json
+
 name: Scale
 emoji: 📐
 displayOrder: 4
@@ -5,40 +7,6 @@ description: |
   Building systems that grow gracefully.
   Encompasses architecture, code quality, testing, performance,
   and technical decision-making.
-transitionChecklists:
-  plan_to_code:
-    foundational:
-      - Architectural patterns are identified
-      - Coding standards are understood
-    working:
-      - Technical approach considers scalability
-      - Design trade-offs are documented
-      - Testing strategy is defined
-    practitioner:
-      - Architecture aligns with cross-team systems
-      - Technical debt impact is assessed
-      - Performance requirements are specified
-    expert:
-      - Architecture follows enterprise patterns
-      - Strategic technical decisions are documented
-      - Long-term maintainability is considered
-  code_to_review:
-    foundational:
-      - Code follows team style guide
-      - Basic tests exist
-      - Code is readable and well-structured
-    working:
-      - Error handling is comprehensive
-      - Edge cases are tested
-      - Performance implications are considered
-    practitioner:
-      - Architectural patterns are documented
-      - Security review is completed
-      - Backward compatibility is verified
-    expert:
-      - Cross-cutting concerns are addressed
-      - Solution can scale to enterprise needs
-      - Technical decisions enable future evolution
 professionalResponsibilities:
   awareness:
     Follow established architectural patterns and coding standards with guidance
@@ -103,88 +71,91 @@ skills:
           recognized as an authority on cloud architecture.
     agent:
       name: cloud-platforms
-      description: >
+      description: |
         Guide for working with cloud infrastructure and services. Use when
-
-        deploying to cloud, selecting cloud services, configuring
-        infrastructure,
-
+        deploying to cloud, selecting cloud services, configuring infrastructure,
         or solving cloud-specific challenges.
-      body: |
-        # Cloud Platforms
-
-        ## When to use this skill
-
-        Use this skill when:
-        - Deploying applications to cloud environments
-        - Selecting appropriate cloud services
-        - Configuring cloud infrastructure
-        - Optimizing cloud costs and performance
-        - Implementing cloud security best practices
-
+      stages:
+        specify:
+          focus: |
+            Define cloud infrastructure requirements and constraints.
+            Clarify availability, security, and cost expectations.
+          activities:
+            - Document availability and reliability requirements
+            - Identify security and compliance constraints
+            - Specify cost budget and constraints
+            - Define performance requirements (latency, throughput)
+            - Mark ambiguities with [NEEDS CLARIFICATION]
+          ready:
+            - Availability requirements are documented
+            - Security requirements are specified
+            - Cost constraints are defined
+            - Performance requirements are clear
+        plan:
+          focus: Selecting and designing cloud architecture
+          activities:
+            - Evaluate service options for the use case
+            - Plan multi-AZ deployment for availability
+            - Design IAM roles with least privilege
+            - Estimate costs and plan resource sizing
+          ready:
+            - Service selection matches requirements
+            - Architecture designed for availability
+            - Security approach documented
+            - Cost estimate prepared
+        code:
+          focus: Implementing cloud infrastructure and deployments
+          activities:
+            - Define infrastructure as code (Terraform/CloudFormation)
+            - Configure security groups and network policies
+            - Set up encryption at rest and in transit
+            - Implement monitoring and alerting
+          ready:
+            - Infrastructure defined as code
+            - Security groups properly configured
+            - Encryption enabled for data
+            - Monitoring and alerting in place
+        review:
+          focus: Validating cloud configuration and security
+          activities:
+            - Verify IAM follows least privilege
+            - Check multi-AZ deployment
+            - Validate cost controls are in place
+            - Review security configuration
+          ready:
+            - IAM permissions are minimal
+            - Multi-AZ deployment confirmed
+            - Cost controls established
+            - Security review complete
+        deploy:
+          focus: |
+            Deploy cloud infrastructure and verify production readiness.
+            Confirm failover and monitoring work correctly.
+          activities:
+            - Deploy infrastructure to production
+            - Verify multi-AZ failover works
+            - Confirm monitoring and alerting are operational
+            - Validate cost tracking is in place
+          ready:
+            - Infrastructure deployed successfully
+            - Failover tested in production
+            - Monitoring is operational
+            - Cost tracking is active
+      reference: |
         ## Service Categories
 
-        ### Compute
-        - **VMs/EC2**: Full control, any workload
-        - **Containers/ECS/GKE**: Portable, scalable applications
-        - **Serverless/Lambda**: Event-driven, pay-per-use
-        - **Kubernetes**: Container orchestration at scale
-
-        ### Storage
-        - **Object Storage (S3/GCS)**: Unstructured data, backups, static assets
-        - **Block Storage (EBS)**: VM disks, databases
-        - **File Storage (EFS)**: Shared file systems
-        - **Archive (Glacier)**: Long-term, infrequent access
-
-        ### Databases
-        - **Managed SQL (RDS/Cloud SQL)**: Relational, ACID transactions
-        - **NoSQL (DynamoDB/Firestore)**: Flexible schema, high scale
-        - **Cache (ElastiCache/Memorystore)**: Low-latency data access
-        - **Data Warehouse (Redshift/BigQuery)**: Analytics at scale
-
-        ### Messaging
-        - **Queues (SQS/Cloud Tasks)**: Decoupled processing
-        - **Pub/Sub (SNS/Cloud Pub/Sub)**: Event distribution
-        - **Streaming (Kinesis/Dataflow)**: Real-time data processing
-
-        ## Cloud-Native Design
-
-        ### Principles
-        - Design for failure (everything fails eventually)
-        - Use managed services when possible
-        - Automate everything (infrastructure as code)
-        - Monitor and alert on all services
-
-        ### High Availability
-        - Deploy across multiple availability zones
-        - Use load balancers for traffic distribution
-        - Implement health checks and auto-healing
-        - Design for graceful degradation
-
-        ### Security
-        - Principle of least privilege for IAM
-        - Encrypt data at rest and in transit
-        - Use security groups and network policies
-        - Rotate credentials regularly
-
-        ## Cost Optimization
-
-        - Right-size instances based on actual usage
-        - Use reserved instances for predictable workloads
-        - Leverage spot/preemptible instances for fault-tolerant work
-        - Set up billing alerts and budgets
-        - Delete unused resources
-
-        ## Cloud Checklist
-
-        - [ ] Service selection matches requirements
-        - [ ] Multi-AZ deployment for availability
-        - [ ] Security groups properly configured
-        - [ ] IAM follows least privilege
-        - [ ] Data encrypted at rest and in transit
-        - [ ] Monitoring and alerting in place
-        - [ ] Cost controls established
-        - [ ] Infrastructure defined as code
+        | Category | Services | Use Case |
+        |----------|----------|----------|
+        | Compute | EC2, ECS, Lambda | VMs, Containers, Serverless |
+        | Storage | S3, EBS, EFS | Objects, Blocks, Files |
+        | Database | RDS, DynamoDB | SQL, NoSQL |
+        | Messaging | SQS, SNS, Kinesis | Queues, Pub/Sub, Streaming |
+
+        ## Cloud-Native Principles
+        - Design for failure
+        - Use managed services
+        - Automate everything
+        - Monitor and alert
   - id: code_quality
     name: Code Quality & Review
     human:
@@ -218,64 +189,82 @@ skills:
     agent:
       name: code-quality-review
       description: |
-        Guide for reviewing code quality, identifying issues, and suggesting
-        improvements. Use when asked to review code, check for best practices,
-        or conduct code reviews.
-      body: |
-        # Code Quality & Review
-
-        ## When to use this skill
-
-        Use this skill when:
-        - Reviewing code for quality issues
-        - Checking code against best practices
-        - Conducting or assisting with code reviews
-        - Verifying AI-generated code before committing
-
-        ## Review Process
-
-        ### 1. Correctness First
-
-        Before anything else, verify the code does what it claims:
-        - Does it implement the intended behavior?
-        - Are there logic errors or off-by-one bugs?
-        - Does it handle all specified requirements?
-        - Are error conditions handled appropriately?
-
-        ### 2. Test Coverage
-
-        Check that changes are properly tested:
-        - Unit tests for new functionality
-        - Edge cases and error conditions
-        - Integration tests where appropriate
-        - Tests are readable and maintainable
-
-        ### 3. Maintainability
-
-        Evaluate long-term code health:
-        - Clear naming (variables, functions, classes)
-        - Appropriate abstraction levels
-        - No unnecessary duplication (DRY)
-        - Single responsibility principle applied
-
-        ### 4. Code Style
-
-        Verify consistency with project standards:
-        - Follows project coding conventions
-        - Consistent formatting and indentation
-        - Appropriate comments for non-obvious logic
-        - Documentation updated if needed
-
-        ## Quality Checklist
-
-        - [ ] Code compiles and passes all tests
-        - [ ] Changes are covered by tests
-        - [ ] No obvious security vulnerabilities
-        - [ ] Error handling is appropriate
-        - [ ] Code follows project conventions
-        - [ ] No unnecessary complexity
-        - [ ] Documentation updated if needed
-        - [ ] No code you don't fully understand
+        Guide for writing quality code and conducting code reviews. Use when
+        reviewing code, checking for best practices, or verifying AI-generated
+        code before committing.
+      stages:
+        specify:
+          focus: |
+            Define code quality requirements and review criteria.
+            Clarify standards and acceptance criteria for the change.
+          activities:
+            - Identify applicable coding standards
+            - Document quality acceptance criteria
+            - Specify test coverage requirements
+            - Define review depth based on risk level
+            - Mark ambiguities with [NEEDS CLARIFICATION]
+          ready:
+            - Coding standards are identified
+            - Quality criteria are documented
+            - Test requirements are specified
+            - Review approach matches risk level
+        plan:
+          focus: Planning for quality before implementation
+          activities:
+            - Review project coding conventions
+            - Plan testing strategy for the feature
+            - Identify edge cases to handle
+            - Consider error handling approach
+          ready:
+            - Coding conventions understood
+            - Testing strategy defined
+            - Edge cases identified
+            - Error handling planned
+        code:
+          focus: Writing and testing quality code
+          activities:
+            - Follow project coding conventions
+            - Write tests alongside implementation
+            - Handle error conditions appropriately
+            - Self-review before requesting review
+          ready:
+            - Code follows project conventions
+            - Changes are covered by tests
+            - Error handling is appropriate
+            - Self-review completed
+        review:
+          focus: Verifying code quality and correctness
+          activities:
+            - Verify code does what it claims
+            - Check test coverage is adequate
+            - Evaluate maintainability
+            - Ensure no code you don't understand
+          ready:
+            - Code compiles and passes all tests
+            - No obvious security vulnerabilities
+            - No unnecessary complexity
+            - Documentation updated if needed
+        deploy:
+          focus: |
+            Merge and deploy reviewed code. Verify quality checks pass
+            in production pipeline.
+          activities:
+            - Merge approved changes
+            - Verify CI pipeline passes
+            - Monitor for issues after deployment
+            - Document any lessons learned
+          ready:
+            - Code merged successfully
+            - CI pipeline passes all checks
+            - No regressions detected
+            - Deployment verified
+      reference: |
+        ## Review Checklist
+
+        1. **Correctness**: Does it work as intended?
+        2. **Tests**: Is it properly tested?
+        3. **Maintainability**: Will it be easy to change?
+        4. **Style**: Does it follow conventions?
   - id: data_modeling
     name: Data Modeling
     human:
@@ -310,85 +299,78 @@ skills:
         Guide for designing database schemas, data structures, and data
         architectures. Use when designing tables, optimizing queries, or
         making decisions about data storage technologies.
-      body: |
-        # Data Modeling
-
-        ## When to use this skill
-
-        Use this skill when:
-        - Designing database schemas
-        - Optimizing query performance
-        - Choosing storage technologies
-        - Planning schema migrations
-        - Balancing normalization with performance
-
-        ## Schema Design
-
-        ### Normalization
-        - **1NF**: Atomic values, no repeating groups
-        - **2NF**: No partial dependencies
-        - **3NF**: No transitive dependencies
-        - Normalize first, then denormalize strategically
-
-        ### Denormalization Trade-offs
-        - Improves read performance
-        - Complicates writes and updates
-        - Risk of data inconsistency
-        - Use for read-heavy workloads
-
-        ## Data Store Selection
-
-        ### Relational (SQL)
-        - Strong consistency requirements
-        - Complex queries and joins
-        - ACID transactions needed
-        - Well-defined schema
-
-        ### Document (NoSQL)
-        - Flexible, evolving schemas
-        - Hierarchical data
-        - Horizontal scaling priority
-        - Read-heavy workloads
-
-        ### Key-Value
-        - Simple lookup patterns
-        - Extreme performance needs
-        - Caching layer
-        - Session storage
-
-        ### Time Series
-        - Temporal data patterns
-        - High write throughput
-        - Time-based queries
-        - Sensor and metrics data
-
-        ## Indexing Strategy
-
-        ### When to Index
-        - Columns in WHERE clauses
-        - Join columns
-        - ORDER BY columns
-        - High-cardinality columns
-
-        ### Index Trade-offs
-        - Faster reads, slower writes
-        - Storage overhead
-        - Maintenance cost
-        - Query planner complexity
-
-        ## Schema Migrations
-
-        ### Safe Migration Practices
-        - Make changes backward compatible
-        - Add columns before using them
-        - Migrate data before dropping columns
-        - Test migrations on production-like data
-
-        ## Data Modeling Checklist
-
-        - [ ] Requirements understood
-        - [ ] Appropriate storage technology selected
-        - [ ] Schema normalized appropriately
-        - [ ] Indexes support query patterns
-        - [ ] Migration plan is safe
-        - [ ] Backward compatibility maintained
+      stages:
+        specify:
+          focus: |
+            Define data requirements and access patterns.
+            Clarify schema requirements before designing.
+          activities:
+            - Document data entities and relationships
+            - Identify query patterns and access requirements
+            - Specify consistency and performance requirements
+            - Define data retention and compliance needs
+            - Mark ambiguities with [NEEDS CLARIFICATION]
+          ready:
+            - Data entities are documented
+            - Query patterns are identified
+            - Performance requirements are specified
+            - Compliance needs are clear
+        plan:
+          focus: Understanding data requirements and designing schema
+          activities:
+            - Gather data requirements and access patterns
+            - Choose appropriate storage technology
+            - Design normalized schema
+            - Plan indexing strategy
+          ready:
+            - Requirements understood
+            - Storage technology selected
+            - Schema design documented
+            - Index strategy planned
+        code:
+          focus: Implementing schema and migrations
+          activities:
+            - Create database migrations
+            - Implement schema changes
+            - Add indexes for query patterns
+            - Write efficient queries
+          ready:
+            - Schema implemented correctly
+            - Indexes support query patterns
+            - Migrations are reversible
+            - Queries are optimized
+        review:
+          focus: Validating schema design and performance
+          activities:
+            - Verify schema matches requirements
+            - Check migration safety
+            - Validate query performance
+            - Review backward compatibility
+          ready:
+            - Schema meets requirements
+            - Migrations tested on production-like data
+            - Query performance acceptable
+            - Backward compatibility maintained
+        deploy:
+          focus: |
+            Deploy schema changes to production safely.
+            Verify data integrity and query performance.
+          activities:
+            - Run migrations in production
+            - Verify data integrity after migration
+            - Monitor query performance
+            - Confirm rollback plan works
+          ready:
+            - Migration completed successfully
+            - Data integrity verified
+            - Performance meets requirements
+            - Rollback procedure tested
+      reference: |
+        ## Storage Selection Guide
+
+        | Type | Use When | Examples |
+        |------|----------|----------|
+        | Relational | ACID needed, complex queries | PostgreSQL, MySQL |
+        | Document | Flexible schema, hierarchical | MongoDB, Firestore |
+        | Key-Value | Simple lookups, caching | Redis, DynamoDB |
+        | Time Series | Temporal data, metrics | InfluxDB, TimescaleDB |

package/examples/copilot-setup-steps.yaml

@@ -0,0 +1,25 @@
+# Copilot Coding Agent setup steps workflow
+# This workflow is executed when a Copilot Coding Agent starts
+# to prepare the environment for the agent session.
+#
+# Reference: https://docs.github.com/en/copilot/customizing-copilot/customizing-the-development-environment-for-copilot-coding-agent
+
+name: Copilot Setup Steps
+
+on: copilot_setup_steps
+
+jobs:
+  setup:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+          cache: npm
+
+      - name: Install dependencies
+        run: npm ci

package/examples/devcontainer.yaml

@@ -0,0 +1,21 @@
+# Dev Container configuration template
+# Settings are dynamically populated at generation time
+
+# Base image for Node.js development
+image: mcr.microsoft.com/devcontainers/javascript-node:22-bookworm
+
+# VS Code customizations are populated dynamically from vscode-settings.yaml
+# customizations:
+#   vscode:
+#     settings: { ... dynamically injected ... }
+
+# Features to add to the dev container
+features:
+  ghcr.io/devcontainers/features/github-cli:1: {}
+
+# Lifecycle commands
+postCreateCommand: npm install
+
+# Forward ports from the container (e.g., for dev server)
+forwardPorts:
+  - 3000

package/examples/disciplines/_index.yaml

@@ -2,4 +2,5 @@
 # Do not edit manually - regenerate with: npx pathway --generate-index
 files:
   - data_engineering
+  - engineering_management
   - software_engineering

package/examples/disciplines/data_engineering.yaml

@@ -1,8 +1,13 @@
-# Discipline: Data Engineering
-# Designs and builds data infrastructure
+# yaml-language-server: $schema=https://schema.forwardimpact.team/json/discipline.schema.json
 
 specialization: Data Engineering
 roleTitle: Data Engineer
+isProfessional: true
+# null = allow trackless (generalist)
+validTracks:
+  - null
+  - platform
+  - sre
 
 # Shared content (human and agent)
 description:
@@ -47,21 +52,18 @@ human:
 
 # Agent-specific content
 agent:
-  coreInstructions: |
+  identity: |
     You are a {roleTitle} agent. Your focus is designing and building
     data integration, storage systems, and data infrastructure that enables
     analytics and AI capabilities.
-
-    Before making changes:
-    1. Understand the data sources and their quality characteristics
-    2. Map data lineage and dependencies
-    3. Consider performance implications for downstream consumers
-
+  priority: |
     Data quality is paramount. Always validate data at ingestion points and
     document schema assumptions. Treat undocumented schemas with suspicion.
-
-    ## Delegation
-
+  beforeMakingChanges:
+    - Understand the data sources and their quality characteristics
+    - Map data lineage and dependencies
+    - Consider performance implications for downstream consumers
+  delegation: |
     When facing tasks outside your expertise, use `runSubagent` to delegate:
     - Statistical analysis or model validation → data science subagent
     - Application code changes → software engineering subagent