ai-engineering-standard 2.2.0__py3-none-any.whl

ai_engineering_standard/__init__.py

@@ -0,0 +1,5 @@
+"""AIEngineeringStandard installable distribution."""
+
+from importlib.metadata import version
+
+__version__ = version("ai-engineering-standard")

ai_engineering_standard/cli.py

@@ -0,0 +1,66 @@
+"""Command-line interface for the AIEngineeringStandard distribution."""
+
+from __future__ import annotations
+
+import argparse
+import importlib.resources as resources
+from pathlib import Path
+from typing import Sequence
+
+from . import __version__
+from .installer import run_installer
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="ai-engineering-standard",
+        description="Install and manage AIEngineeringStandard in a project.",
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    install = sub.add_parser("install", help="Install standard resources into a project.")
+    install.add_argument("--target", default=".", help="Target project directory.")
+    install.add_argument("--language", default=None, help="Locale, e.g. en or ko.")
+    install.add_argument(
+        "--domain",
+        choices=("common", "ml", "llm", "vision", "colab", "all"),
+        default=None,
+        help="Installation domain.",
+    )
+    install.add_argument(
+        "--policy",
+        choices=("ask", "merge", "overwrite", "skip"),
+        default="ask",
+        help="Conflict policy for existing files.",
+    )
+    install.add_argument("--dry-run", action="store_true", help="Preview without writing files.")
+
+    status = sub.add_parser("status", help="Inspect the installed standard state.")
+    status.add_argument("--target", default=".", help="Target project directory.")
+    status.add_argument("--json", action="store_true", help="Emit JSON.")
+
+    update = sub.add_parser("update", help="Reconcile an existing installation with this package.")
+    update.add_argument("--target", default=".", help="Target project directory.")
+    update.add_argument("--policy", choices=("ask", "merge", "overwrite", "skip"), default="merge")
+    update.add_argument("--dry-run", action="store_true")
+
+    uninstall = sub.add_parser("uninstall", help="Remove files owned by the installation.")
+    uninstall.add_argument("--target", default=".", help="Target project directory.")
+    uninstall.add_argument("--force", action="store_true", help="Remove modified managed files too.")
+    uninstall.add_argument("--dry-run", action="store_true")
+
+    validate = sub.add_parser("validate", help="Validate the target installation state.")
+    validate.add_argument("--target", default=".", help="Target project directory.")
+
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    with resources.as_file(resources.files("ai_engineering_standard.resources")) as resource_root:
+        return run_installer(args, Path(resource_root))
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

ai_engineering_standard/installer.py

@@ -0,0 +1,48 @@
+"""Bridge the installed CLI to the repository-independent lifecycle engine."""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+from pathlib import Path
+from types import ModuleType
+
+
+def _load_engine(resource_root: Path) -> ModuleType:
+    engine_path = resource_root / "installation_engine.py"
+    if not engine_path.is_file():
+        raise RuntimeError("Packaged installation engine is missing.")
+    spec = importlib.util.spec_from_file_location(
+        "ai_engineering_standard._installer_engine",
+        engine_path,
+    )
+    if spec is None or spec.loader is None:
+        raise RuntimeError("Unable to load packaged installation engine.")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def run_installer(args: argparse.Namespace, resource_root: Path) -> int:
+    engine = _load_engine(resource_root)
+    if args.command == "install":
+        language = args.language or engine.prompt_language(resource_root)
+        domain = args.domain or engine.prompt_domain()
+        return engine.install(
+            resource_root,
+            Path(args.target).resolve(),
+            language,
+            domain,
+            args.policy,
+            args.dry_run,
+        )
+    target = Path(args.target).resolve()
+    if args.command == "status":
+        return engine.state(target, args.json)
+    if args.command == "update":
+        return engine.update(resource_root, target, args.policy, args.dry_run)
+    if args.command == "uninstall":
+        return engine.uninstall(target, args.force, args.dry_run)
+    if args.command == "validate":
+        return engine.validate(target)
+    raise RuntimeError(f"Unsupported command: {args.command}")

ai_engineering_standard/resources/.agents/skills/ai-engineering-standard/SKILL.md

@@ -0,0 +1,21 @@
+---
+name: ai-engineering-standard
+description: Apply the repository's canonical AI engineering standards before implementation, validation, and release changes.
+---
+
+# AI Engineering Standard Skill
+
+Use this Skill when a task changes engineering policy, agent behavior, AI/ML runtime behavior, validation, installation, or release behavior.
+
+## Required behavior
+
+1. Read the repository-level `AGENTS.md`.
+2. Inspect the applicable architecture and policy profiles.
+3. Prefer existing canonical contracts over introducing parallel rules.
+4. Run focused validation during development.
+5. Run the full validation gates before merge or release.
+6. Preserve explicit uncertainty states such as `UNTESTED` and `UNSUPPORTED`.
+
+## Release boundary
+
+This repository is the sole development and release source. Do not introduce or rely on a separate promotion repository.

ai_engineering_standard/resources/.aider.conf.yml

@@ -0,0 +1,3 @@
+# codingStandard Aider configuration
+read:
+  - CONVENTIONS.md

ai_engineering_standard/resources/.amazonq/rules/coding-standard.md

@@ -0,0 +1,13 @@
+# codingStandard project rules
+
+Follow the canonical project standard:
+
+- Read `AGENTS.md` and `core/common/` before environment-dependent work.
+- Detect and apply the installed relevant resources under `domains/ml/`, `domains/llm/`, `domains/vision/`, and `platform/colab/`.
+- Use shared ML Skills for data validation, experiment design, evaluation, training, inference, distributed training, HPO, and MLOps.
+- Use domain/task Skills only when applicable.
+- Detect and measure the actual OS, Python/runtime, CPU, RAM, accelerator, VRAM, and disk before selecting execution settings.
+- Validate resource settings with a representative smoke test and lock the validated configuration before long-running work.
+- Long-running training should use validation, best checkpoint, resume support, and Early Stopping where meaningful.
+- Record dataset/model revisions, seeds, metrics, runtime, peak resources, artifacts, environment profile, and Git state.
+- Never hard-code a named machine or fixed resource capacity.

ai_engineering_standard/resources/.clinerules/01-coding-standard.md

@@ -0,0 +1,14 @@
+# codingStandard
+
+Follow the canonical project instructions in `AGENTS.md` and `core/common/`. Detect and apply only the relevant installed resources:
+
+- `domains/ml/` for general ML/DL lifecycle work.
+- `domains/llm/` for LLM/NLP/RAG/fine-tuning.
+- `domains/vision/` for computer vision.
+- `platform/colab/` for ephemeral Google Colab/cloud notebook execution.
+
+Use shared ML Skills for data validation, experiment design, evaluation, training, inference, distributed training, HPO, and MLOps. Apply task-specific Skills only when relevant.
+
+Detect and measure the real environment before coding or resource-sensitive execution. Resolve conservative settings, run a smoke test before long runs, lock the validated configuration, and preserve checkpoint/resume and reproducibility metadata.
+
+Never hard-code a named machine or fixed accelerator/RAM capacity.

ai_engineering_standard/resources/.continue/rules/01-coding-standard.md

@@ -0,0 +1,18 @@
+---
+name: codingStandard
+description: Project-wide coding standard and AI development workflow
+alwaysApply: true
+---
+
+Follow the canonical project instructions in `AGENTS.md` and `core/common/`. Detect and apply only the relevant installed resources:
+
+- `domains/ml/` for general ML/DL lifecycle work.
+- `domains/llm/` for LLM/NLP/RAG/fine-tuning.
+- `domains/vision/` for computer vision.
+- `platform/colab/` for ephemeral Google Colab/cloud notebook execution.
+
+Use shared ML Skills for data validation, experiment design, evaluation, training, inference, distributed training, HPO, and MLOps. Apply task-specific Skills only when relevant.
+
+Before coding or resource-sensitive execution, measure the actual runtime, resolve conservative settings, and run a representative smoke test before long-running work. Lock validated configuration and preserve checkpoint/resume and reproducibility metadata.
+
+Never hard-code a named machine, GPU, RAM capacity, OS, or IDE.

ai_engineering_standard/resources/.cursor/rules/coding-standard.mdc

@@ -0,0 +1,19 @@
+---
+description: Project-wide coding standard and AI development workflow
+alwaysApply: true
+---
+
+# codingStandard
+
+Follow the canonical project instructions in `AGENTS.md` and `core/common/`. Detect and apply only the relevant installed domain/platform resources:
+
+- `domains/ml/` for general machine learning and deep learning.
+- `domains/llm/` for LLM/NLP/RAG/fine-tuning.
+- `domains/vision/` for computer vision.
+- `platform/colab/` for Google Colab or other ephemeral hosted notebook runtimes.
+
+Use shared ML Skills for data validation, experiment design, evaluation, training, inference, distributed training, HPO, and MLOps. Apply task-specific Skills only when relevant.
+
+Before implementation or resource-sensitive execution, inspect and measure the actual runtime, resolve conservative settings, and run the smallest meaningful smoke test. Before long-running training, lock the validated configuration and ensure checkpoint/resume and reproducibility metadata are available.
+
+Never hard-code a named machine, GPU, RAM capacity, OS, or IDE. Keep train/validation/test boundaries explicit and record model/dataset revisions and resource usage.

ai_engineering_standard/resources/.github/copilot-instructions.md

@@ -0,0 +1,19 @@
+# Repository-wide Copilot Instructions
+
+This is the repository-wide GitHub Copilot entrypoint.
+
+@../AGENTS.md
+
+Apply the common rules first, then use only the installed and relevant resources:
+
+- `core/common/` for shared policy and environment validation.
+- `domains/ml/` for general machine learning and deep learning.
+- `domains/llm/` for language-model, NLP, RAG, and LLM fine-tuning work.
+- `domains/vision/` for computer-vision work.
+- `platform/colab/` for Google Colab or other ephemeral hosted notebook runtimes.
+
+Prefer shared ML Skills for cross-domain data validation, evaluation, experiment design, training, inference, distributed training, hyperparameter optimization, and MLOps. Apply domain/task Skills only when they add task-specific constraints.
+
+Before resource-sensitive work, detect and measure the real execution environment, resolve a conservative runtime configuration, run the appropriate smoke test, and lock the validated configuration before long-running execution.
+
+Do not hard-code a named machine, GPU, RAM size, OS, or IDE. Preserve explicit data/evaluation boundaries, reproducibility metadata, checkpoint/resume support, and resource tracking.

ai_engineering_standard/resources/.github/instructions/colab.instructions.md

@@ -0,0 +1,12 @@
+---
+applyTo: "**/*.ipynb"
+---
+# Notebook Runtime Instructions
+
+@../../AGENTS.md
+
+When the executing Python runtime is Google Colab or another ephemeral hosted notebook runtime, also apply `platform/colab/AGENT.md` and `platform/colab/SKILL.md`.
+
+Detect the runtime from Python/kernel state rather than the client OS. For Colab work, assume interruption and runtime reset are possible: use reproducible dependency bootstrap, measured resource resolution, representative smoke tests, durable checkpoints/artifacts, and validated resume behavior for long-running jobs.
+
+For non-Colab Jupyter work, keep the common ML/Jupyter rules and do not assume Colab-specific persistence constraints.

ai_engineering_standard/resources/.github/instructions/llm.instructions.md

@@ -0,0 +1,19 @@
+---
+applyTo: "**/domains/llm/**,**/llm/**,**/training/**,**/train/**,**/nlp/**,**/rag/**,**/*.ipynb"
+---
+# LLM Task Instructions
+
+@../../AGENTS.md
+
+For LLM/NLP tasks, apply the installed `domains/ml/` lifecycle rules plus `domains/llm/AGENT.md`, `domains/llm/SKILL.md`, and `domains/llm/ENVIRONMENT.md`.
+
+Select relevant shared ML Skills for data validation, experiment design, evaluation, training, inference, distributed training, HPO, and MLOps. Apply LLM task Skills such as fine-tuning, PEFT, quantization, RAG, or other installed capabilities when applicable.
+
+Before resource-sensitive work:
+
+- measure the actual Python/runtime, CPU, RAM, accelerator, VRAM, and disk when available;
+- resolve a conservative runtime configuration;
+- run a representative Memory Smoke Test;
+- lock the validated configuration before long-running work.
+
+Do not hard-code a specific machine or fixed resource capacity. Training should use explicit validation metrics, checkpoint/resume, controlled experiments, and reproducibility/resource tracking.

ai_engineering_standard/resources/.github/instructions/ml.instructions.md

@@ -0,0 +1,14 @@
+---
+applyTo: "**/domains/ml/**,**/ml/**,**/dataset/**,**/datasets/**,**/training/**,**/train/**,**/evaluation/**,**/eval/**,**/experiments/**,**/experiment/**"
+---
+# General ML / Deep Learning Task Instructions
+
+@../../AGENTS.md
+
+Apply `domains/ml/AGENT.md`, `domains/ml/SKILL.md`, and `domains/ml/ENVIRONMENT.md`, then only the relevant task Skills.
+
+Prefer shared Skills for data validation, experiment design, evaluation, training, inference, distributed training, hyperparameter optimization, and MLOps. Do not duplicate these rules in project-specific notebooks or scripts.
+
+Before long-running execution, validate the data contract, define a baseline and primary metric, measure the runtime, run a representative smoke test, lock the validated configuration, and persist reproducibility/resource metadata.
+
+Keep train/validation/test boundaries explicit and never hard-code a named machine or fixed accelerator capacity.

ai_engineering_standard/resources/.github/instructions/vision.instructions.md

@@ -0,0 +1,19 @@
+---
+applyTo: "**/domains/vision/**,**/vision/**,**/cv/**,**/ocr/**,**/detection/**,**/segmentation/**"
+---
+# Vision Task Instructions
+
+@../../AGENTS.md
+
+For Vision tasks, apply the installed `domains/ml/` lifecycle rules plus `domains/vision/AGENT.md`, `domains/vision/SKILL.md`, and `domains/vision/ENVIRONMENT.md`.
+
+Select relevant shared ML Skills for data validation, experiment design, evaluation, training, inference, distributed training, HPO, and MLOps. Apply vision task Skills such as classification, detection, segmentation, OCR, pose estimation, image generation, or VLM when applicable.
+
+Before resource-sensitive work:
+
+- measure the actual Python/runtime, CPU, RAM, accelerator, VRAM, and disk when available;
+- account for image resolution, channels, batch size, activation/feature-map memory, workers, cache, and prefetch;
+- run a representative Vision Memory Smoke Test;
+- lock the validated configuration before long-running training.
+
+Do not hard-code a specific machine or fixed resource capacity. Training should use validation, best checkpoints, Resume, controlled experiments, and reproducibility/resource tracking.

ai_engineering_standard/resources/.github/workflows/ci.yml

@@ -0,0 +1,141 @@
+name: AI Engineering Standard CI
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+    inputs:
+      source_sha:
+        description: Immutable commit SHA to validate
+        required: true
+        type: string
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ai-engineering-standard-ci-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  repository-gate:
+    name: Repository validation gate
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      - name: Resolve source identity
+        id: source
+        shell: bash
+        run: |
+          set -euo pipefail
+          source_sha="${{ inputs.source_sha || github.event.pull_request.head.sha || github.sha }}"
+          if [[ ! "$source_sha" =~ ^[0-9a-f]{40}$ ]]; then
+            echo "Invalid source SHA: $source_sha" >&2
+            exit 1
+          fi
+          echo "sha=$source_sha" >> "$GITHUB_OUTPUT"
+
+      - name: Checkout exact source
+        uses: actions/checkout@v6
+        with:
+          ref: ${{ steps.source.outputs.sha }}
+          fetch-depth: 1
+
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.12"
+
+      - name: Install test runner
+        run: python -m pip install --upgrade pip pytest
+
+      - name: Run repository validation
+        run: python scripts/validation/validate.py
+
+      - name: Run installer lifecycle tests
+        run: python scripts/installers/test_installers.py
+
+      - name: Run validation test suite
+        run: python -m pytest -q tests/validation
+
+  source-integrity:
+    name: Source integrity
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - name: Resolve source identity
+        id: source
+        shell: bash
+        run: |
+          set -euo pipefail
+          source_sha="${{ inputs.source_sha || github.event.pull_request.head.sha || github.sha }}"
+          if [[ ! "$source_sha" =~ ^[0-9a-f]{40}$ ]]; then
+            echo "Invalid source SHA: $source_sha" >&2
+            exit 1
+          fi
+          echo "sha=$source_sha" >> "$GITHUB_OUTPUT"
+
+      - name: Checkout exact source
+        uses: actions/checkout@v6
+        with:
+          ref: ${{ steps.source.outputs.sha }}
+          fetch-depth: 1
+
+      - name: Verify checked-out commit
+        shell: bash
+        run: |
+          set -euo pipefail
+          actual="$(git rev-parse HEAD)"
+          expected="${{ steps.source.outputs.sha }}"
+          test "$actual" = "$expected"
+          echo "verified source SHA: $actual"
+  package-distribution:
+    name: Installable package validation
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    needs: repository-gate
+    steps:
+      - name: Resolve source identity
+        id: source
+        shell: bash
+        run: |
+          set -euo pipefail
+          source_sha="${{ inputs.source_sha || github.event.pull_request.head.sha || github.sha }}"
+          if [[ ! "$source_sha" =~ ^[0-9a-f]{40}$ ]]; then
+            echo "Invalid source SHA: $source_sha" >&2
+            exit 1
+          fi
+          echo "sha=$source_sha" >> "$GITHUB_OUTPUT"
+
+      - name: Checkout exact source
+        uses: actions/checkout@v6
+        with:
+          ref: ${{ steps.source.outputs.sha }}
+          fetch-depth: 1
+
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.12"
+
+      - name: Build distributions
+        run: |
+          python -m pip install --upgrade pip build twine
+          python -m build
+          python -m twine check dist/*
+
+      - name: Install wheel without repository checkout dependency
+        shell: bash
+        run: |
+          set -euo pipefail
+          python -m pip install dist/*.whl
+          test "$(ai-engineering-standard --version)" = "ai-engineering-standard 2.2.0"
+          mkdir -p /tmp/aes-consumer
+          cd /tmp/aes-consumer
+          ai-engineering-standard install --language en --domain common --policy overwrite
+          ai-engineering-standard status --json
+          ai-engineering-standard validate
+          test -f AGENTS.md
+          test -f .codingstandard/installation.json

ai_engineering_standard/resources/.github/workflows/publish-package.yml

@@ -0,0 +1,51 @@
+name: Publish AIEngineeringStandard package
+
+on:
+  push:
+    tags:
+      - "v*.*.*"
+
+permissions:
+  contents: write
+  id-token: write
+
+jobs:
+  publish:
+    name: Build and publish release
+    runs-on: ubuntu-latest
+    environment: pypi
+    steps:
+      - name: Checkout tagged source
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 1
+
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.12"
+
+      - name: Verify tag matches VERSION
+        shell: bash
+        run: |
+          set -euo pipefail
+          tag="${GITHUB_REF_NAME#v}"
+          version="$(cat VERSION)"
+          test "$tag" = "$version"
+
+      - name: Build distributions
+        run: |
+          python -m pip install --upgrade pip build twine
+          python -m build
+          python -m twine check dist/*
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist/
+
+      - name: Create GitHub Release
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          gh release create "$GITHUB_REF_NAME" dist/*             --title "AIEngineeringStandard $GITHUB_REF_NAME"             --generate-notes

ai_engineering_standard/resources/.junie/AGENTS.md

@@ -0,0 +1,7 @@
+# AI Engineering Standard
+
+Use the repository-level `AGENTS.md` as the canonical engineering contract.
+
+Before implementation, inspect the applicable profiles under `profiles/`. Run focused validation during development and the full repository validation before merge or release.
+
+This file is a JetBrains Junie adapter; it must not introduce policy that conflicts with `AGENTS.md`.

ai_engineering_standard/resources/.windsurf/rules/coding-standard.md

@@ -0,0 +1,14 @@
+# codingStandard
+
+Follow the canonical project instructions in `AGENTS.md` and `core/common/`. Detect and apply only the relevant installed resources:
+
+- `domains/ml/` for general ML/DL lifecycle work.
+- `domains/llm/` for LLM/NLP/RAG/fine-tuning.
+- `domains/vision/` for computer vision.
+- `platform/colab/` for ephemeral Google Colab/cloud notebook execution.
+
+Use shared ML Skills for data validation, experiment design, evaluation, training, inference, distributed training, HPO, and MLOps. Apply task-specific Skills only when relevant.
+
+Measure the real runtime before resource-sensitive work. Resolve conservative settings, run a representative smoke test, lock the configuration, and preserve checkpoint/resume and reproducibility metadata for long-running training.
+
+Never hard-code a named machine, GPU, RAM capacity, OS, or IDE. Keep train/validation/test boundaries explicit.

ai_engineering_standard/resources/AGENTS.md

@@ -0,0 +1,54 @@
+# AIEngineeringStandard Agent Contract
+
+## Repository role
+
+This repository is the canonical development, validation, and release source for AI Engineering Standard. Do not assume or reference a separate private, development, staging, promotion, or export repository.
+
+## Before changing code
+
+1. Read `README.md` and the applicable files under `docs/development/` and `docs/releases/`.
+2. Inspect `profiles/project.json` and the relevant architecture/policy profiles.
+3. Preserve the canonical directory layout.
+4. Run the narrowest relevant validation while developing, then the full validation before merge or release.
+5. For v2.1 contract changes, preserve the canonical Agent → Role → Contract → Work Unit → Handoff → Evidence → Evaluation → Acceptance model.
+
+## Source of truth
+
+- `VERSION` is the release version.
+- `core/common/environment.py` must agree with `VERSION`.
+- `i18n/languages.json` is the locale catalog.
+- `compatibility/agents.json` is the agent compatibility catalog.
+- Git history, tags, and GitHub Releases are the release provenance.
+
+## Development rules
+
+- Work in a feature/fix/docs branch; keep `main` releasable. The repository may temporarily use a development branch, but the final remote branch set remains `main` only.
+- Do not commit secrets, credentials, local runtime state, generated caches, or machine-specific paths.
+- Do not weaken validation to make a release pass.
+- Keep unavailable runtime evidence explicitly `UNTESTED`, `UNSUPPORTED`, `SKIPPED`, or `BLOCKED`.
+- Prefer small, auditable commits.
+- Update tests and documentation when a contract changes.
+
+## CI and execution
+
+- GitHub Actions is part of the repository validation architecture.
+- `.github/workflows/ci.yml` is the canonical automated CI entry point.
+- Repository execution follows `core/runtime/execution/OPERATING_POLICY.md` and `core/runtime/execution/mission.schema.json`.
+- CI uses least-privilege read permissions and immutable repository state.
+- Prefer sandbox/local execution for iterative development; use Actions for bounded automated validation or remote execution when appropriate.
+- A green workflow is not by itself acceptance evidence; relevant outputs and source identity must be verified.
+- Do not add project secrets to workflow source, logs, artifacts, or mission payloads.
+- Temporary Actions state must be task-owned and cleaned up after terminal use.
+- When execution is lost or context is reset, recover from durable Git/Actions state before conversation reconstruction.
+
+## v2.1 architecture contract
+
+The canonical multi-agent model is defined by `core/contracts/2.1/`. Runtime adapters must map their native concepts into these contracts and must not redefine their semantics. A Work Unit owns the trace boundary; Handoffs carry explicit provenance; Evaluation cannot silently convert unavailable evidence into PASS; Acceptance is downstream of Evaluation.
+
+## Release rules
+
+A release is created from this repository only. Run `python3 scripts/release/check_release.py` from an exact, clean `main` checkout, then use `python3 scripts/release/publish_release.py` to create the annotated tag and GitHub Release. Never promote source from another repository.
+
+## Agent/tool adapters
+
+Root and tool-specific instruction files are adapters to this contract. They must not introduce a conflicting canonical policy.

ai_engineering_standard/resources/CLAUDE.md

@@ -0,0 +1,22 @@
+# Claude Code Project Instructions
+
+This file is the Claude Code project entrypoint.
+
+Apply rules in this order:
+
+@AGENTS.md
+@core/common/AGENT.md
+@core/common/SKILL.md
+@core/common/ENVIRONMENT.md
+
+Then detect and apply the installed, relevant domain resources:
+
+- `domains/ml/` for general ML/DL work.
+- `domains/llm/` for language-model, NLP, RAG, and LLM fine-tuning work.
+- `domains/vision/` for image/video/OCR/detection/segmentation/generation/VLM work.
+
+For Google Colab or another ephemeral hosted notebook runtime, also apply `platform/colab/AGENT.md` and `platform/colab/SKILL.md`.
+
+Apply only relevant task Skills. Shared ML Skills own cross-domain data, evaluation, experiment, training, inference, distributed training, HPO, and MLOps policy.
+
+Before resource-sensitive work, inspect the actual runtime and use the available profiler. Before long-running training, run an appropriate Memory Smoke Test, lock the validated configuration, and record reproducibility/resource metadata.

ai_engineering_standard/resources/GEMINI.md

@@ -0,0 +1,22 @@
+# Gemini CLI Project Context
+
+This file is the Gemini CLI project entrypoint.
+
+Apply:
+
+@AGENTS.md
+@core/common/AGENT.md
+@core/common/SKILL.md
+@core/common/ENVIRONMENT.md
+
+Then detect and apply the installed, relevant domain resources:
+
+- `domains/ml/` for general ML/DL work.
+- `domains/llm/` for language-model, NLP, RAG, and LLM fine-tuning work.
+- `domains/vision/` for image/video/OCR/detection/segmentation/generation/VLM work.
+
+For Google Colab or another ephemeral hosted notebook runtime, also apply `platform/colab/AGENT.md` and `platform/colab/SKILL.md`.
+
+Use only relevant task Skills. Shared ML Skills own cross-domain data, evaluation, experiment, training, inference, distributed training, HPO, and MLOps policy.
+
+Before resource-sensitive work, inspect the actual runtime and use the environment profiler when available. Before long-running training, run a Memory Smoke Test, lock the validated configuration, and record reproducibility/resource metadata.

ai_engineering_standard/resources/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 eaglesjo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ai_engineering_standard/resources/VERSION

@@ -0,0 +1 @@
+2.2.0