Source: npp-extracted/new 2 (2026-03-07)

Morphism DevOps Prompts

Purpose: Actionable DevOps prompts for the Morphism ecosystem, aligned with governance, kernelization, and template systems.

Audience: DevOps engineers, AI agents, automation systems

Scope: CI/CD automation, infrastructure, governance enforcement, MLOps, documentation, and multi-workspace orchestration

CI/CD Pipeline Automation

1. Automate Pre-Commit Governance Hooks

Category: CI/CD

Objective: Create automated pre-commit hooks that enforce Morphism governance rules (writing style SEV0-3 violations, structure compliance, policy adherence) before code reaches CI/CD pipelines.

Context: Morphism requires governance enforcement at the earliest stage. Pre-commit hooks prevent violations from entering the repository, reducing CI/CD failures and maintaining code quality. This aligns with the Morphism policy of "governance first" and prevents technical debt accumulation.

Deliverables:

Pre-commit hook configuration (.pre-commit-config.yaml) with Morphism-specific checks
Integration with tools/audit_writing_style.py for SEV0-3 violation detection
Structure validation script that enforces 7-lane directory allowlist
Policy compliance checker that validates against docs/policies/ standards
Installation script (ops/install-pre-commit-hooks.sh) for workspace setup
Documentation in docs/guides/pre-commit-setup.md

Integration Points:

References WE-WORK-HERE/docs/governance/WRITING_GOVERNANCE.md for violation definitions
Uses morphism-dev/ops/structure-validation.py patterns for structure checks
Integrates with existing tools/validate_documentation.py for documentation compliance
Aligns with Morphism writing standards (no emojis, no marketing language, evidence-based)

Success Criteria:

Pre-commit hooks block commits with SEV0 violations (emojis) 100% of the time
SEV1 violations (marketing language) generate warnings with bypass option logged
Structure violations (non-7-lane directories) are blocked at commit time
Hook installation completes in under 30 seconds
Zero false positives for legitimate code patterns

Technical Specificity:

Tool: pre-commit framework (Python)
Files: .pre-commit-config.yaml, .git/hooks/pre-commit
Commands: pre-commit install, pre-commit run --all-files
Exit codes: 0 (pass), 1 (block), 2 (warning)

2. Orchestrate Multi-Workspace CI/CD Pipelines

Category: CI/CD

Objective: Design and implement a CI/CD orchestration system that coordinates pipelines across multiple Morphism workspaces (SUMMARIES, WE-WORK-HERE, morphism-dev, Documents, Morphism_Docs_Collection) while maintaining workspace-specific configurations and shared governance rules.

Context: Morphism operates multiple workspaces with different project types but shared governance. A unified orchestration layer ensures consistent quality gates while respecting workspace-specific needs. This prevents duplication of CI/CD logic and enables cross-workspace dependency management.

Deliverables:

Centralized CI/CD configuration in GitHub/.github/workflows/morphism-orchestrator.yml
Workspace-specific workflow files that inherit from orchestrator
Dependency graph visualization showing cross-workspace build order
Shared action definitions in GitHub/.github/actions/ for reusable steps
Workspace inventory file (workspaces.toml) that defines workspace metadata
Orchestration dashboard or status page showing all workspace pipeline states
Documentation: docs/guides/multi-workspace-cicd.md

Integration Points:

Uses morphism-dev/workspace.toml patterns for workspace metadata
Integrates with SUMMARIES/docs/catalog/ for project inventory
References WE-WORK-HERE/docs/governance/ for shared policy enforcement
Aligns with 7-lane structure validation across all workspaces

Success Criteria:

All workspaces execute CI/CD checks within 10 minutes of orchestration trigger
Cross-workspace dependencies are resolved automatically
Workspace-specific failures do not block unrelated workspaces
Orchestration overhead adds less than 5% to total pipeline time
100% of workspaces report status to central dashboard

Technical Specificity:

Platform: GitHub Actions with reusable workflows
Configuration: YAML workflow files, TOML workspace inventory
Tools: gh CLI for workspace discovery, jq for JSON processing
Monitoring: GitHub Actions API, custom status aggregation script

3. Enforce 7-Lane Structure in CI/CD

Category: CI/CD

Objective: Implement automated CI/CD checks that validate all projects conform to the Morphism 7-lane structure (runtime, packages, ops, experiments, docs, identity, archive) and block merges that violate structure rules.

Context: The 7-lane structure is a core Morphism invariant. Automated enforcement in CI/CD ensures structure compliance without manual review. This prevents structural drift and maintains workspace consistency across all Morphism projects.

Deliverables:

GitHub Actions workflow (.github/workflows/structure-validation.yml) that runs on every PR
Structure validation script (ops/structure-validator.py) that checks:
- Top-level directory allowlist (only 7 lanes allowed)
- Lane-specific content rules (e.g., runtime/ contains only runnable projects)
- Prohibited directory patterns (e.g., no src/ at root level)
Validation report generation with specific violation locations
Integration with PR comments to show structure violations inline
Exemption system for archived projects in archive/ lane
Documentation: docs/guides/structure-enforcement.md

Integration Points:

Extends morphism-dev/ops/structure-validation.py patterns
References morphism-dev/README.md for 7-lane structure definition
Uses workspace.toml for project metadata and lane assignments
Aligns with WE-WORK-HERE/docs/architecture/standards/ENFORCEMENT_RULES.YAML

Success Criteria:

Structure violations are detected within 2 minutes of PR creation
100% of structure violations are reported with file path and line number
False positives rate is below 1% (legitimate exemptions handled correctly)
Validation completes in under 30 seconds for typical workspace
PR comments are posted within 5 minutes of validation completion

Technical Specificity:

Language: Python 3.10+
Libraries: pathlib, toml for workspace.toml parsing
CI Platform: GitHub Actions
Output: JSON validation report, PR comment via GitHub API
Exit codes: 0 (valid), 1 (invalid structure)

4. Automate Writing Style Validation in Pipelines

Category: CI/CD

Objective: Integrate Morphism writing style enforcement (SEV0-3 violations) into CI/CD pipelines to automatically block PRs that violate writing standards, with detailed violation reports and remediation guidance.

Context: Morphism enforces strict writing standards (no emojis, no marketing language, evidence-based prose). Automated pipeline validation ensures documentation and code comments maintain these standards without manual review. This reduces technical debt and maintains professional documentation quality.

Deliverables:

GitHub Actions workflow (.github/workflows/writing-style.yml) that scans all markdown files in PRs
Integration with tools/audit_writing_style.py for violation detection
Violation report generation with severity classification (SEV0-3)
PR comment automation that posts violation summaries with file links
Blocking logic: SEV0 and SEV1 violations block merge, SEV2 warnings allow merge
Exception handling for policy files that define rules (exempt from marketing language checks)
Remediation script (tools/rewrite_markdown.py) integration for automated fixes
Documentation: docs/guides/writing-style-ci.md

Integration Points:

Uses WE-WORK-HERE/docs/governance/WRITING_GOVERNANCE.md for violation definitions
References WE-WORK-HERE/docs/standards/MORPHISM_WRITING_GUIDE.md for style rules
Integrates with tools/audit_writing_style.py and tools/rewrite_markdown.py
Aligns with pre-commit hook enforcement (Prompt #1) for consistency

Success Criteria:

All markdown files in PRs are scanned within 5 minutes
SEV0 violations (emojis) block PR merge 100% of the time
SEV1 violations (marketing language) block PR merge 100% of the time
Violation reports include file path, line number, violation type, and suggested fix
False positive rate is below 2% (legitimate exemptions handled)
Automated remediation fixes 80%+ of SEV2 violations without manual intervention

Technical Specificity:

Tool: tools/audit_writing_style.py (Python)
CI Platform: GitHub Actions
File patterns: **/*.md, **/*.mdx, **/README.md
Output: JSON violation report, PR comment via GitHub API
Severity mapping: SEV0=block, SEV1=block, SEV2=warn, SEV3=log

5. Generate Template-Driven CI/CD Pipelines

Category: CI/CD

Objective: Create a template system that generates CI/CD pipeline configurations from Morphism stack templates (STACK_PYTHON_TOOL.md, STACK_WEB_APP_TS.md, etc.) to ensure consistent pipeline structure across projects of the same type.

Context: Morphism uses stack templates to standardize project structure. Extending this to CI/CD pipelines ensures consistent build, test, and deployment processes. This reduces configuration drift and enables rapid project scaffolding with complete CI/CD setup.

Deliverables:

Template engine (ops/pipeline-generator.py) that reads stack templates and generates GitHub Actions workflows
Template library in docs/templates/pipelines/ with templates for:
- Python tool pipelines (testing, linting, type checking)
- TypeScript web app pipelines (build, test, deploy)
- MLOps pipelines (model training, validation, deployment)
- Research computing pipelines (experiment tracking, reproducibility)
Integration with stack template system (docs/templates/STACK_*.md)
Generated workflow validation to ensure syntactically correct YAML
Documentation: docs/guides/pipeline-templates.md
CLI tool (ops/cli/generate-pipeline.sh) for manual pipeline generation

Integration Points:

Reads from SUMMARIES/docs/templates/STACK_*.md templates
Generates workflows compatible with morphism-dev/.github/workflows/ structure
Uses kernel patterns (WE-WORK-HERE/workspace/docs/guides/KERNEL_*.md) for language-specific steps
Aligns with 7-lane structure validation (Prompt #3)

Success Criteria:

Pipeline generation completes in under 10 seconds
Generated workflows are syntactically valid YAML (100% validation rate)
Generated pipelines pass structure validation (Prompt #3) on first run
Template coverage: 90%+ of Morphism project types have corresponding pipeline templates
Generated pipelines include all required steps: test, lint, type-check, security scan

Technical Specificity:

Language: Python 3.10+ with jinja2 for templating
Input: Stack template markdown files
Output: GitHub Actions workflow YAML files
Validation: yamllint, custom YAML schema validation
CLI: ops/cli/generate-pipeline.sh --stack python-tool --output .github/workflows/ci.yml

Infrastructure as Code & Containerization

6. Containerize 7-Lane Structure Projects

Category: Infrastructure

Objective: Design containerization patterns that respect the Morphism 7-lane structure, enabling containerized deployment of runtime projects while maintaining workspace organization and governance compliance.

Context: Morphism projects in the runtime/ lane need containerization for deployment, but containers must not break the 7-lane structure or violate governance rules. This ensures consistent deployment patterns while maintaining workspace invariants.

Deliverables:

Dockerfile template (docs/templates/Dockerfile.morphism) that follows 7-lane structure
Multi-stage build patterns for different project types (Python, TypeScript, Go, Rust)
Docker Compose templates for local development that mirror production structure
Container naming convention: morphism-{workspace}-{project}:{version}
Health check patterns that validate containerized services
Documentation: docs/guides/containerization.md
Build script (ops/build-containers.sh) that respects workspace boundaries

Integration Points:

References morphism-dev/README.md for 7-lane structure definition
Uses kernel patterns (KERNEL_PYTHON.md, KERNEL_TS.md) for language-specific build steps
Aligns with docs/templates/STACK_*.md for project-type-specific configurations
Integrates with CI/CD pipelines (Prompt #5) for automated container builds

Success Criteria:

Container builds complete in under 5 minutes for typical project
Containers maintain 7-lane structure (mounted volumes or copied structure)
100% of runtime projects can be containerized using provided templates
Container images are tagged with Morphism versioning scheme
Health checks pass within 30 seconds of container start

Technical Specificity:

Base images: Official language images (python:3.11, node:20, etc.)
Build tool: Docker BuildKit for multi-stage builds
Registry: Container registry URL pattern: registry.morphism.systems/{workspace}/{project}
Labels: org.morphism.workspace, org.morphism.lane, org.morphism.project

7. Scaffold Infrastructure from Kernel Templates

Category: Infrastructure

Objective: Create infrastructure scaffolding system that generates IaC (Terraform, Pulumi, or CloudFormation) from Morphism kernel templates, ensuring infrastructure matches project structure and language requirements.

Context: Morphism kernel templates define project structure and dependencies. Extending this to infrastructure ensures infrastructure code aligns with project needs and follows Morphism patterns. This reduces infrastructure configuration errors and accelerates project setup.

Deliverables:

Infrastructure generator (ops/infra-generator.py) that reads kernel templates and generates IaC
Terraform module templates for common Morphism project types:
- Python tool infrastructure (Lambda, ECS, EC2)
- TypeScript web app infrastructure (Vercel, AWS Amplify, Kubernetes)
- MLOps infrastructure (SageMaker, EKS for training, S3 for models)
Pulumi program templates as alternative to Terraform
Infrastructure validation that checks alignment with kernel requirements
Documentation: docs/guides/infrastructure-scaffolding.md
CLI tool (ops/cli/generate-infra.sh) for infrastructure generation

Integration Points:

Reads from WE-WORK-HERE/workspace/docs/guides/KERNEL_*.md templates
Generates infrastructure compatible with Morphism cloud patterns
Uses stack templates (docs/templates/STACK_*.md) for project-type-specific infrastructure
Aligns with containerization patterns (Prompt #6) for deployment targets

Success Criteria:

Infrastructure generation completes in under 30 seconds
Generated IaC is syntactically valid (Terraform validate passes)
Generated infrastructure includes required resources (compute, storage, networking)
Infrastructure follows Morphism naming conventions
90%+ of kernel-defined projects can generate infrastructure automatically

Technical Specificity:

IaC Tools: Terraform 1.5+, Pulumi (Python/TypeScript)
Template engine: Jinja2 for Terraform, native Pulumi templates
Output: Terraform modules in infrastructure/terraform/modules/ or Pulumi programs
Validation: terraform validate, terraform fmt --check

8. Implement Multi-Environment IaC with Governance

Category: Infrastructure

Objective: Design infrastructure as code patterns that support multiple environments (development, staging, production) while enforcing Morphism governance rules (secrets management, access controls, compliance checks) across all environments.

Context: Morphism requires consistent governance across environments. IaC must enforce policy compliance, secrets management, and access controls without duplicating configuration. This ensures security and compliance while maintaining infrastructure agility.

Deliverables:

Terraform/Pulumi workspace pattern for environment separation
Governance module (infrastructure/governance/) that enforces:
- Secrets management (AWS Secrets Manager, HashiCorp Vault integration)
- IAM role patterns with least-privilege principles
- Resource tagging requirements (Morphism metadata tags)
- Compliance checks (SOC 2, GDPR alignment)
Environment-specific configuration files (environments/dev.tfvars, environments/prod.tfvars)
Policy enforcement via OPA (Open Policy Agent) or similar
Documentation: docs/guides/multi-environment-iac.md
Validation script (ops/validate-infra-governance.sh) that checks compliance before apply

Integration Points:

References SUMMARIES/docs/enterprise/POLICY_ENFORCEMENT.md for governance rules
Uses WE-WORK-HERE/docs/governance/ patterns for policy definitions
Integrates with secrets management systems (AWS Secrets Manager, Vault)
Aligns with CI/CD pipelines (Prompt #2) for environment-specific deployments

Success Criteria:

Governance checks run before every infrastructure change
100% of infrastructure resources have required Morphism tags
Secrets are never stored in IaC code (100% externalized)
Environment separation is enforced (dev cannot access prod resources)
Compliance validation passes for all environments

Technical Specificity:

IaC: Terraform with workspaces or Pulumi stacks
Policy engine: OPA (Open Policy Agent) with Rego policies
Secrets: AWS Secrets Manager, HashiCorp Vault
Validation: terraform plan with policy checks, opa test for policy validation
Tags: MorphismWorkspace, MorphismEnvironment, MorphismProject, MorphismLane

9. Manage Container Registry for Morphism Projects

Category: Infrastructure

Objective: Establish and automate container registry management for Morphism projects, including image versioning, security scanning, lifecycle policies, and cross-workspace image sharing.

Context: Morphism projects across multiple workspaces need containerized deployments. A centralized registry with governance ensures image security, version consistency, and efficient image sharing. This reduces duplication and maintains security standards.

Deliverables:

Container registry setup (Docker Hub organization, AWS ECR, or self-hosted)
Image naming convention: morphism/{workspace}/{project}:{version}
Automated image scanning integration (Trivy, Snyk, or AWS ECR scanning)
Lifecycle policies that automatically clean up old images (keep last 10 versions, delete images older than 90 days)
Cross-workspace image sharing rules and access controls
CI/CD integration for automated image pushes (Prompt #2, #5)
Documentation: docs/guides/container-registry.md
Management script (ops/manage-registry.sh) for registry operations

Integration Points:

Integrates with CI/CD pipelines (Prompt #2, #5) for automated builds
Uses containerization patterns (Prompt #6) for image structure
References governance policies (docs/governance/) for security requirements
Aligns with 7-lane structure for workspace organization

Success Criteria:

Image push completes in under 2 minutes for typical project
Security scans complete within 5 minutes of image push
100% of images are scanned before being marked as production-ready
Lifecycle policies automatically clean up 90%+ of eligible images
Cross-workspace image sharing works without manual intervention

Technical Specificity:

Registry: Docker Hub (morphism organization) or AWS ECR
Scanning: Trivy, Snyk, or AWS ECR native scanning
Versioning: Semantic versioning (major.minor.patch) or git commit SHA
Lifecycle: AWS ECR lifecycle policies or Docker Hub retention rules
Access: IAM roles (AWS) or Docker Hub team permissions

Governance Enforcement & Policy Automation

10. Automate Policy Compliance Checking

Category: Governance

Objective: Build automated system that validates all Morphism projects against policy definitions in docs/policies/, generating compliance reports and blocking non-compliant changes in CI/CD.

Context: Morphism maintains policy definitions for code quality, security, and governance. Automated compliance checking ensures policies are enforced consistently without manual review. This prevents policy violations from entering the codebase and maintains governance standards.

Deliverables:

Policy compliance engine (ops/policy-checker.py) that reads policy definitions and validates projects
Policy definition format (YAML or TOML) that defines:
- Policy name, description, severity
- Validation rules (file patterns, content checks, structure requirements)
- Remediation guidance
Integration with CI/CD (GitHub Actions workflow) that runs on every PR
Compliance report generation (JSON, markdown) with violation details
PR comment automation that posts compliance status
Policy exemption system for legitimate exceptions
Documentation: docs/guides/policy-compliance.md

Integration Points:

Reads from SUMMARIES/docs/policies/ and WE-WORK-HERE/docs/policies/
Integrates with CI/CD pipelines (Prompt #2) for automated checking
Uses structure validation (Prompt #3) for structure-related policies
Aligns with writing style enforcement (Prompt #4) for documentation policies

Success Criteria:

Policy checks complete in under 3 minutes for typical workspace
100% of defined policies are checked on every PR
Compliance reports include policy name, violation location, and remediation steps
False positive rate is below 3% (exemptions handled correctly)
Policy violations block PR merge when severity is "blocking"

Technical Specificity:

Language: Python 3.10+
Policy format: YAML with schema validation
Validation: Custom rule engine, regex patterns, file system checks
Output: JSON compliance report, PR comment via GitHub API
Exit codes: 0 (compliant), 1 (non-compliant), 2 (exemptions applied)

11. Enforce Writing Standards in CI/CD

Category: Governance

Objective: Extend writing style enforcement (Prompt #4) to cover all documentation types (API docs, architecture docs, README files) and integrate with governance workflows to ensure consistent documentation quality across Morphism projects.

Context: Morphism writing standards apply to all documentation, not just markdown files. Extending enforcement to API docs, code comments, and other documentation types ensures consistent quality. This maintains professional documentation standards across the entire ecosystem.

Deliverables:

Extended writing style validator that checks:
- API documentation (OpenAPI/Swagger specs)
- Code comments (Python docstrings, TypeScript JSDoc)
- Architecture documentation (ADRs, design docs)
- README files (all variants: README.md, README_*.md)
Integration with documentation generators (Sphinx, TypeDoc) to validate generated docs
Custom rules for different documentation types (API docs allow technical jargon, READMEs require plain language)
Documentation quality metrics (readability scores, completeness checks)
Documentation: docs/guides/writing-enforcement-comprehensive.md
Remediation tool (tools/fix-documentation.py) that applies writing standard fixes

Integration Points:

Extends tools/audit_writing_style.py from Prompt #4
References WE-WORK-HERE/docs/standards/MORPHISM_WRITING_GUIDE.md for rules
Integrates with CI/CD pipelines (Prompt #2, #4) for automated checking
Uses template system (docs/templates/) for documentation structure validation

Success Criteria:

All documentation types are validated within 5 minutes of PR creation
Writing standard violations are detected with 95%+ accuracy
Documentation quality metrics are reported for every PR
Automated remediation fixes 70%+ of violations without manual intervention
False positive rate is below 2% (technical documentation exemptions handled)

Technical Specificity:

Tools: Custom Python validator, integration with Sphinx, TypeDoc
File patterns: **/*.md, **/*.rst, **/README*.md, **/*.py (docstrings), **/*.ts (JSDoc)
Validation: Regex patterns, readability scores (Flesch-Kincaid), completeness checks
Output: JSON violation report, PR comment, documentation quality dashboard

12. Validate Kernel Compliance Automatically

Category: Governance

Objective: Create automated validation system that ensures all projects follow their designated kernel templates (KERNEL_PYTHON.md, KERNEL_TS.md, etc.), checking structure, dependencies, and configuration against kernel requirements.

Context: Morphism kernel templates define project standards. Automated validation ensures projects maintain kernel compliance as they evolve. This prevents structural drift and maintains consistency across projects of the same type.

Deliverables:

Kernel compliance validator (ops/kernel-validator.py) that:
- Detects project type from stack template or project structure
- Loads corresponding kernel template (KERNEL_*.md)
- Validates project structure against kernel requirements
- Checks dependencies match kernel specifications
- Validates configuration files (pyproject.toml, package.json, etc.)
Integration with CI/CD (GitHub Actions workflow) that runs on every PR
Compliance report with specific violations and remediation guidance
Kernel version tracking (projects declare which kernel version they follow)
Documentation: docs/guides/kernel-compliance.md

Integration Points:

Reads from WE-WORK-HERE/workspace/docs/guides/KERNEL_*.md templates
Uses stack templates (docs/templates/STACK_*.md) for project type detection
Integrates with structure validation (Prompt #3) for directory structure checks
Aligns with template system for project scaffolding validation

Success Criteria:

Kernel validation completes in under 2 minutes for typical project
100% of kernel-defined requirements are checked
Violations are reported with kernel section reference and remediation steps
Kernel version mismatches are detected and reported
False positive rate is below 2% (legitimate project-specific deviations handled)

Technical Specificity:

Language: Python 3.10+
Kernel format: Markdown with structured sections (parsed via custom parser)
Validation: File structure checks, dependency parsing (requirements.txt, package.json), config file validation
Output: JSON compliance report, PR comment via GitHub API
Kernel version: Declared in workspace.toml or project metadata file

13. Verify Template Compliance Across Workspaces

Category: Governance

Objective: Build system that validates template usage across all Morphism workspaces, ensuring projects created from templates maintain template compliance and identifying template drift.

Context: Morphism uses templates (STACK_, POLICY_, README_*) to standardize projects. Automated compliance checking ensures templates are used correctly and projects don't drift from template standards. This maintains consistency and enables template evolution.

Deliverables:

Template compliance checker (ops/template-validator.py) that:
- Scans all workspaces for template usage (detects template markers in files)
- Validates projects against their source templates
- Identifies template drift (projects that no longer match templates)
- Tracks template version usage across workspaces
Template registry (docs/templates/registry.json) that catalogs all templates and their usage
Compliance report showing template usage statistics and drift detection
Integration with CI/CD for automated checking
Documentation: docs/guides/template-compliance.md

Integration Points:

Reads from SUMMARIES/docs/templates/ and workspace-specific template directories
Uses template markers (comments, frontmatter) to identify template usage
Integrates with multi-workspace orchestration (Prompt #19) for cross-workspace scanning
Aligns with template inventory system (Prompt #16) for template cataloging

Success Criteria:

Template compliance check completes in under 5 minutes for all workspaces
90%+ of template-created projects are correctly identified
Template drift is detected with 95%+ accuracy
Template usage statistics are accurate (which templates are used where)
Compliance reports include template version and drift remediation steps

Technical Specificity:

Language: Python 3.10+
Template detection: Frontmatter markers, file structure patterns, template comments
Validation: File diff against template, structure comparison, content pattern matching
Output: JSON compliance report, template usage dashboard
Registry: JSON file with template metadata and usage tracking

MLOps & Model Deployment

14. Deploy Agentic AI Workflow Pipelines

Category: MLOps

Objective: Design and implement MLOps pipelines for agentic AI workflows in Morphism projects, including model training, validation, deployment, and monitoring with governance compliance.

Context: Morphism includes agentic AI projects that require specialized MLOps workflows. These pipelines must integrate with Morphism governance (model versioning, experiment tracking, compliance) while supporting research and production deployments. This ensures reproducible AI workflows and maintains research integrity.

Deliverables:

MLOps pipeline template (docs/templates/pipelines/mlops-agentic-ai.yml) for GitHub Actions
Model versioning system that integrates with Morphism versioning scheme
Experiment tracking integration (MLflow, Weights & Biases) with Morphism metadata
Model validation gates (accuracy thresholds, bias detection, performance benchmarks)
Deployment automation for agentic AI models (containerized inference, API endpoints)
Monitoring and alerting for model performance degradation
Documentation: docs/guides/mlops-agentic-ai.md

Integration Points:

Uses containerization patterns (Prompt #6) for model deployment
Integrates with CI/CD pipelines (Prompt #2, #5) for automated training and deployment
References governance policies (docs/governance/) for model compliance requirements
Aligns with research computing infrastructure (Prompt #15) for training resources

Success Criteria:

Model training pipelines complete end-to-end without manual intervention
Model versions are tracked with 100% accuracy (no unversioned models in production)
Model validation gates block deployments that don't meet thresholds
Experiment tracking captures all required Morphism metadata
Model monitoring alerts trigger within 5 minutes of performance degradation

Technical Specificity:

Tools: MLflow for experiment tracking, Docker for containerization, Kubernetes for orchestration
Model registry: MLflow Model Registry or custom solution with Morphism metadata
Validation: Custom validation scripts, bias detection tools (Fairness Indicators)
Deployment: Kubernetes deployments, serverless functions (AWS Lambda, Google Cloud Functions)
Monitoring: Prometheus metrics, custom alerting rules

15. Provision Research Computing Infrastructure

Category: MLOps

Objective: Create infrastructure provisioning system for research/science computing projects in Morphism, supporting HPC workloads, GPU clusters, and experiment reproducibility with governance compliance.

Context: Morphism includes research projects that require specialized computing infrastructure (GPUs, HPC clusters, distributed computing). Automated provisioning ensures researchers have consistent, compliant infrastructure while maintaining cost controls and governance.

Deliverables:

Infrastructure templates for research computing:
- GPU cluster provisioning (AWS EC2 P3/P4 instances, Google Cloud TPUs)
- HPC cluster setup (Slurm, Kubernetes with GPU support)
- Distributed computing infrastructure (Ray, Dask clusters)
Experiment reproducibility system (container images, dependency pinning, seed management)
Cost monitoring and alerts for research infrastructure usage
Governance integration (resource quotas, access controls, data compliance)
Documentation: docs/guides/research-computing-infrastructure.md
Provisioning scripts (ops/provision-research-infra.sh) for automated setup

Integration Points:

Uses infrastructure scaffolding (Prompt #7) for base infrastructure
Integrates with multi-environment IaC (Prompt #8) for environment separation
References governance policies (docs/governance/) for research data compliance
Aligns with MLOps pipelines (Prompt #14) for model training infrastructure

Success Criteria:

Infrastructure provisioning completes in under 15 minutes for typical research cluster
100% of research infrastructure follows Morphism governance policies
Experiment reproducibility is maintained (container images, dependency versions tracked)
Cost monitoring alerts trigger when research infrastructure exceeds budget thresholds
Research data compliance is validated before infrastructure access is granted

Technical Specificity:

Cloud providers: AWS (EC2 P3/P4, SageMaker), Google Cloud (TPUs, GKE with GPUs)
Orchestration: Kubernetes with GPU operators, Slurm for HPC
Containers: Docker images with pinned dependencies, reproducibility metadata
Cost monitoring: CloudWatch (AWS), Cloud Billing API (GCP), custom cost tracking
Governance: IAM roles, resource quotas, data classification tags

Documentation & Template Management

16. Generate Automated Template Inventory

Category: Documentation

Objective: Build automated system that scans all Morphism workspaces, identifies all templates (STACK_, POLICY_, README_, KERNEL_), and generates a comprehensive template inventory with usage statistics and version tracking.

Context: Morphism uses templates across multiple workspaces. An automated inventory ensures all templates are cataloged, tracked, and maintained. This prevents template duplication, identifies unused templates, and enables template evolution planning.

Deliverables:

Template scanner (ops/template-scanner.py) that:
- Scans all workspaces for template files (pattern matching: *TEMPLATE*.md, STACK_*.md, KERNEL_*.md)
- Extracts template metadata (name, version, description, category)
- Identifies template usage across projects
- Tracks template versions and evolution
Template inventory database (JSON or SQLite) with template metadata
Inventory report generation (markdown, JSON) with:
- Template catalog (all templates with metadata)
- Usage statistics (which templates are used where)
- Version tracking (template evolution over time)
- Unused template identification
Integration with CI/CD for automated inventory updates
Documentation: docs/guides/template-inventory.md

Integration Points:

Scans SUMMARIES/docs/templates/, WE-WORK-HERE/docs/templates/, and workspace-specific template directories
Uses template compliance system (Prompt #13) for usage detection
Integrates with multi-workspace orchestration (Prompt #19) for cross-workspace scanning
Aligns with documentation sync (Prompt #18) for template distribution tracking

Success Criteria:

Template scan completes in under 10 minutes for all workspaces
100% of templates are identified and cataloged
Template usage statistics are accurate (which projects use which templates)
Template version tracking captures all template changes
Inventory reports are generated automatically on schedule (daily or weekly)

Technical Specificity:

Language: Python 3.10+
Template detection: File pattern matching, frontmatter parsing, content analysis
Storage: JSON file (docs/templates/inventory.json) or SQLite database
Output: Markdown inventory report, JSON API for programmatic access
Scheduling: GitHub Actions cron job or similar automation

17. Automate Documentation Compliance Checks

Category: Documentation

Objective: Create automated system that validates documentation completeness and compliance across Morphism projects, checking for required files (README.md, CONTRIBUTING.md), structure compliance, and writing standard adherence.

Context: Morphism requires consistent documentation across projects. Automated compliance checking ensures all projects have required documentation, follow structure standards, and maintain writing quality. This reduces documentation debt and improves developer onboarding.

Deliverables:

Documentation compliance checker (ops/docs-validator.py) that validates:
- Required files exist (README.md, CONTRIBUTING.md for projects, CLAUDE.md for agent projects)
- Documentation structure follows Morphism templates
- Writing standards compliance (SEV0-3 violations, no marketing language)
- Link validation (internal and external links are valid)
- Documentation completeness (all required sections present)
Integration with CI/CD for automated checking on every PR
Compliance report with specific violations and remediation guidance
Documentation: docs/guides/documentation-compliance.md

Integration Points:

Uses writing style enforcement (Prompt #4, #11) for writing standard checks
References template system (docs/templates/) for structure validation
Integrates with structure validation (Prompt #3) for directory structure checks
Aligns with template compliance (Prompt #13) for template usage validation

Success Criteria:

Documentation compliance check completes in under 3 minutes for typical workspace
100% of required documentation files are validated
Link validation accuracy is 95%+ (false positives from temporary outages handled)
Documentation completeness scores are calculated and reported
Compliance violations block PR merge when severity is "blocking"

Technical Specificity:

Language: Python 3.10+
Validation: File existence checks, structure validation, link checking (HTTP requests), writing standard checks
Output: JSON compliance report, PR comment via GitHub API
Required files: README.md, CONTRIBUTING.md, CLAUDE.md (for agent projects)
Exit codes: 0 (compliant), 1 (non-compliant)

18. Synchronize Multi-Workspace Documentation

Category: Documentation

Objective: Design and implement system that synchronizes shared documentation (governance policies, templates, standards) across Morphism workspaces, ensuring consistency while allowing workspace-specific customizations.

Context: Morphism maintains shared documentation (governance, templates, standards) that should be consistent across workspaces. Automated synchronization ensures updates propagate correctly while respecting workspace-specific overrides. This maintains documentation consistency without manual copying.

Deliverables:

Documentation sync system (ops/docs-sync.py) that:
- Identifies shared documentation files (governance policies, templates, standards)
- Syncs updates from source workspace to target workspaces
- Handles workspace-specific overrides (files that should not be synced)
- Detects sync conflicts and generates conflict reports
Sync configuration file (docs-sync.toml) that defines:
- Source and target workspaces
- Files to sync (patterns and exclusions)
- Override rules (workspace-specific files that should not be synced)
Integration with CI/CD for automated sync on documentation updates
Conflict resolution workflow for manual review of sync conflicts
Documentation: docs/guides/documentation-sync.md

Integration Points:

Syncs from SUMMARIES/docs/ (source of truth) to other workspaces
Uses template inventory (Prompt #16) to identify templates to sync
Integrates with multi-workspace orchestration (Prompt #19) for workspace coordination
Aligns with documentation compliance (Prompt #17) for validation after sync

Success Criteria:

Documentation sync completes in under 5 minutes for all workspaces
100% of shared documentation files are synced correctly
Workspace-specific overrides are respected (no accidental overwrites)
Sync conflicts are detected and reported with resolution guidance
Sync operations are logged and auditable

Technical Specificity:

Language: Python 3.10+
Sync method: File copying with conflict detection (content comparison)
Configuration: TOML file (docs-sync.toml) with sync rules
Conflict detection: Content diff, timestamp comparison, checksum validation
Logging: Sync operation logs with timestamps and file changes

Multi-Workspace Orchestration

19. Automate Workspace Consolidation

Category: Orchestration

Objective: Build automated system that consolidates multiple Morphism workspaces into a unified structure, handling project migration, dependency resolution, duplicate detection, and governance compliance validation.

Context: Morphism operates multiple workspaces that need periodic consolidation. Automated consolidation ensures projects are migrated correctly, dependencies are resolved, and governance is maintained. This reduces manual effort and prevents consolidation errors.

Deliverables:

Consolidation engine (ops/consolidate-workspaces.py) that:
- Scans source workspaces for projects and dependencies
- Detects duplicates across workspaces (name matching, content similarity)
- Resolves dependencies (cross-workspace project references)
- Migrates projects to target workspace following 7-lane structure
- Validates governance compliance after migration
Consolidation plan generation (markdown report) with:
- Projects to migrate (source, target, lane assignment)
- Duplicate detection results (projects that exist in multiple workspaces)
- Dependency resolution (cross-workspace dependencies)
- Risk assessment (potential issues with migration)
Dry-run mode for consolidation planning without execution
Rollback capability for failed consolidations
Documentation: docs/guides/workspace-consolidation.md

Integration Points:

Uses structure validation (Prompt #3) for target workspace validation
References governance policies (docs/governance/) for compliance checking
Uses template system for project structure validation
Integrates with inventory management (Prompt #20) for project cataloging

Success Criteria:

Consolidation planning completes in under 30 minutes for typical workspace set
100% of projects are correctly identified and categorized
Duplicate detection accuracy is 95%+ (false positives from legitimate forks handled)
Dependency resolution maintains 100% of cross-workspace dependencies
Governance compliance is validated for all migrated projects

Technical Specificity:

Language: Python 3.10+
Duplicate detection: Content similarity (fuzzy matching), file structure comparison
Dependency resolution: Graph analysis, topological sorting for migration order
Validation: Structure checks, governance compliance, dependency verification
Output: Consolidation plan (markdown), migration logs, rollback scripts

20. Manage Cross-Workspace Inventory

Category: Orchestration

Objective: Create centralized inventory management system that tracks all projects, dependencies, and resources across Morphism workspaces, providing unified view and enabling cross-workspace operations.

Context: Morphism operates multiple workspaces with interconnected projects. A centralized inventory enables dependency tracking, resource discovery, and cross-workspace operations. This reduces duplication and enables efficient workspace management.

Deliverables:

Inventory scanner (ops/inventory-scanner.py) that:
- Scans all workspaces for projects, dependencies, and resources
- Extracts project metadata (name, type, stack, dependencies, location)
- Builds dependency graph across workspaces
- Tracks resource usage (containers, infrastructure, documentation)
Centralized inventory database (JSON or SQLite) with project and dependency metadata
Inventory API or CLI for querying inventory (find projects, list dependencies, check resource usage)
Inventory reports (markdown, JSON) with:
- Project catalog (all projects across workspaces)
- Dependency graph visualization
- Resource usage statistics
- Cross-workspace relationship mapping
Integration with CI/CD for automated inventory updates
Documentation: docs/guides/cross-workspace-inventory.md

Integration Points:

Scans all Morphism workspaces (SUMMARIES, WE-WORK-HERE, morphism-dev, Documents, Morphism_Docs_Collection)
Uses template inventory (Prompt #16) for template usage tracking
Integrates with workspace consolidation (Prompt #19) for migration planning
Aligns with multi-workspace CI/CD (Prompt #2) for dependency resolution

Success Criteria:

Inventory scan completes in under 15 minutes for all workspaces
100% of projects are cataloged with accurate metadata
Dependency graph accurately represents cross-workspace dependencies
Inventory queries complete in under 2 seconds for typical queries
Inventory updates automatically on workspace changes (via CI/CD integration)

Technical Specificity:

Language: Python 3.10+
Storage: JSON file (docs/inventory/workspaces.json) or SQLite database
Graph: NetworkX for dependency graph construction and analysis
API: REST API or CLI (ops/cli/inventory.sh) for querying
Output: JSON inventory data, markdown reports, dependency graph visualization (Mermaid or Graphviz)

Usage Guidelines

How to Use These Prompts

Select a Prompt: Choose a prompt that matches your DevOps need (CI/CD, infrastructure, governance, etc.)
Review Context: Read the "Context" section to understand why this prompt matters for Morphism
Check Integration Points: Review "Integration Points" to understand how this prompt connects with other Morphism systems
Execute Deliverables: Implement the deliverables listed, following the technical specificity guidelines
Validate Success: Use the "Success Criteria" to validate that your implementation meets requirements
Document Integration: Update Morphism documentation to reflect new systems or processes

Prompt Combinations

Some prompts work together:

CI/CD Pipeline (Prompts #1-5): Use together for complete CI/CD automation
Infrastructure (Prompts #6-9): Combine for full infrastructure automation
Governance (Prompts #10-13): Use together for comprehensive governance enforcement
Documentation (Prompts #16-18): Combine for complete documentation automation
Orchestration (Prompts #19-20): Use together for multi-workspace management

Customization

These prompts are templates. Customize them for:

Specific project requirements
Workspace-specific needs
Tool preferences (e.g., GitLab CI instead of GitHub Actions)
Cloud provider choices (AWS, GCP, Azure)

Integration Guide

How Prompts Integrate with Morphism Workflows

7-Lane Structure: All prompts respect the Morphism 7-lane structure (runtime, packages, ops, experiments, docs, identity, archive). Infrastructure and CI/CD prompts validate structure compliance.

Governance First: Governance prompts (#10-13) integrate with all other prompts. CI/CD, infrastructure, and documentation prompts include governance validation steps.

Kernelization: Kernel templates (KERNEL_*.md) are referenced in infrastructure (#7), governance (#12), and CI/CD (#5) prompts. Projects should follow kernel patterns.

Template System: Template-related prompts (#5, #13, #16) work together to maintain template consistency. CI/CD and infrastructure prompts generate from templates.

Multi-Workspace: Orchestration prompts (#19-20) enable cross-workspace operations. Other prompts can be applied per-workspace or across workspaces.

Integration Checklist

When implementing prompts, ensure:

[ ] Structure validation is integrated (7-lane compliance)
[ ] Governance checks are included (policy compliance, writing standards)
[ ] Templates are used where applicable (stack templates, kernel templates)
[ ] Multi-workspace considerations are addressed (if applicable)
[ ] Documentation is updated (guides, README files)
[ ] CI/CD integration is complete (automated validation)

Maintenance

How to Update These Prompts

Review Schedule: Review prompts quarterly (aligned with Morphism review cycle)
Update Triggers: Update prompts when:
- Morphism patterns evolve (new structure requirements, governance changes)
- Tools change (new CI/CD platforms, infrastructure tools)
- New use cases emerge (new project types, new workflows)
Version Control: Track prompt versions in document frontmatter. Update version number when making significant changes.
Feedback Loop: Collect feedback from DevOps engineers and AI agents using these prompts. Incorporate improvements.
Documentation Updates: Update related documentation when prompts change (integration guides, usage guidelines)

Version History

v1.0.0 (2026-01-20): Initial release with 20 DevOps prompts covering CI/CD, infrastructure, governance, MLOps, documentation, and orchestration

References

Morphism Documentation

7-Lane Structure: morphism-dev/README.md
Writing Standards: WE-WORK-HERE/docs/standards/MORPHISM_WRITING_GUIDE.md
Governance: WE-WORK-HERE/docs/governance/WRITING_GOVERNANCE.md
Kernel Templates: WE-WORK-HERE/workspace/docs/guides/KERNEL_*.md
Stack Templates: SUMMARIES/docs/templates/STACK_*.md

Related Prompts

See individual prompt "Integration Points" sections for related prompts
Governance prompts (#10-13) integrate with all other prompt categories
Orchestration prompts (#19-20) enable cross-workspace operations

Document Status: Current
Last Updated: 2026-01-20
Next Review: 2026-04-20 (quarterly)

Morphism DevOps Prompt Catalog

Morphism DevOps Prompts

Table of Contents

CI/CD Pipeline Automation

Infrastructure as Code & Containerization

Governance Enforcement & Policy Automation

MLOps & Model Deployment

Documentation & Template Management

Multi-Workspace Orchestration

CI/CD Pipeline Automation

1. Automate Pre-Commit Governance Hooks

2. Orchestrate Multi-Workspace CI/CD Pipelines

3. Enforce 7-Lane Structure in CI/CD

4. Automate Writing Style Validation in Pipelines

5. Generate Template-Driven CI/CD Pipelines

Infrastructure as Code & Containerization

6. Containerize 7-Lane Structure Projects

7. Scaffold Infrastructure from Kernel Templates

8. Implement Multi-Environment IaC with Governance

9. Manage Container Registry for Morphism Projects

Governance Enforcement & Policy Automation

10. Automate Policy Compliance Checking

11. Enforce Writing Standards in CI/CD

12. Validate Kernel Compliance Automatically

13. Verify Template Compliance Across Workspaces

MLOps & Model Deployment

14. Deploy Agentic AI Workflow Pipelines

15. Provision Research Computing Infrastructure

Documentation & Template Management

16. Generate Automated Template Inventory

17. Automate Documentation Compliance Checks

18. Synchronize Multi-Workspace Documentation

Multi-Workspace Orchestration

19. Automate Workspace Consolidation

20. Manage Cross-Workspace Inventory

Usage Guidelines

How to Use These Prompts

Prompt Combinations

Customization

Integration Guide

How Prompts Integrate with Morphism Workflows

Integration Checklist

Maintenance

How to Update These Prompts

Version History

References

Morphism Documentation

Related Prompts