abstractframework 0.1.6__tar.gz → 0.1.7__tar.gz

{abstractframework-0.1.6 → abstractframework-0.1.7}/CHANGELOG.md

@@ -4,6 +4,32 @@ All notable changes to AbstractFramework will be documented in this file.
 
 ## [Unreleased]
 
+## [0.1.7] - 2026-05-31
+
+### Added
+
+- Added the `abstractframework` CLI with `doctor` checks for Python/package
+  version consistency and `manifest` commands for installer manifest generation
+  and drift checks.
+- Added a generated installer manifest and schema under `docs/installers/`,
+  derived from the root release pins and covering the Light, Apple, and GPU
+  profiles.
+- Added a public install chooser that explains Light as the remote-first full
+  framework profile, with Apple and GPU as hardware-local profiles.
+
+### Changed
+
+- Moved installer application source out of the root framework repository into
+  the standalone `AbstractInstallers` repository. The root package remains the
+  release profile, documentation hub, and manifest source of truth.
+- Updated local source helper scripts to use `--light` as the canonical
+  remote-first profile name while keeping `--base` as a compatibility alias.
+
+### Removed
+
+- Removed the tracked `abstractinstallers/` prototype source tree from the root
+  `AbstractFramework` repository and package source distribution.
+
 ## [0.1.6] - 2026-05-31
 
 ### Changed

{abstractframework-0.1.6/abstractframework.egg-info → abstractframework-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstractframework
-Version: 0.1.6
+Version: 0.1.7
 Summary: Unified installer and documentation hub for the AbstractFramework ecosystem
 Author-email: Laurent-Philippe Albou <contact@abstractcore.ai>
 License: MIT
@@ -177,6 +177,9 @@ pip install "abstractframework[apple]"
 pip install "abstractframework[gpu]"
 ```
 
+See [docs/install.md](docs/install.md) for the full install chooser, `uv`/venv guidance,
+`abstractframework doctor`, and the generated installer manifest contract.
+
 ---
 
 ## Documentation
@@ -184,6 +187,7 @@ pip install "abstractframework[gpu]"
 | Page | What it covers |
 |---|---|
 | [docs/README.md](docs/README.md) | Documentation hub — pick your starting point |
+| [docs/install.md](docs/install.md) | Light / Apple / GPU install chooser and first checks |
 | [docs/getting-started.md](docs/getting-started.md) | Two entry points + first end-to-end run |
 | [docs/architecture.md](docs/architecture.md) | Layered model, durable execution primitives, comparisons |
 | [docs/configuration.md](docs/configuration.md) | Minimal config, where defaults live, Core vs Gateway |

{abstractframework-0.1.6 → abstractframework-0.1.7}/README.md

@@ -131,6 +131,9 @@ pip install "abstractframework[apple]"
 pip install "abstractframework[gpu]"
 ```
 
+See [docs/install.md](docs/install.md) for the full install chooser, `uv`/venv guidance,
+`abstractframework doctor`, and the generated installer manifest contract.
+
 ---
 
 ## Documentation
@@ -138,6 +141,7 @@ pip install "abstractframework[gpu]"
 | Page | What it covers |
 |---|---|
 | [docs/README.md](docs/README.md) | Documentation hub — pick your starting point |
+| [docs/install.md](docs/install.md) | Light / Apple / GPU install chooser and first checks |
 | [docs/getting-started.md](docs/getting-started.md) | Two entry points + first end-to-end run |
 | [docs/architecture.md](docs/architecture.md) | Layered model, durable execution primitives, comparisons |
 | [docs/configuration.md](docs/configuration.md) | Minimal config, where defaults live, Core vs Gateway |

{abstractframework-0.1.6 → abstractframework-0.1.7}/abstractframework/__init__.py

@@ -10,7 +10,7 @@ Most implementation functionality still lives in component projects.
 
 from __future__ import annotations
 
-__version__ = "0.1.6"
+__version__ = "0.1.7"
 __author__ = "Laurent-Philippe Albou"
 __license__ = "MIT"
 
@@ -29,6 +29,27 @@ RELEASE_VERSIONS: dict[str, str] = {
     "abstractassistant": "0.4.8",
 }
 
+PACKAGE_DISTRIBUTIONS: dict[str, str] = {
+    "abstractcore": "abstractcore",
+    "abstractruntime": "AbstractRuntime",
+    "abstractagent": "abstractagent",
+    "abstractflow": "abstractflow",
+    "abstractcode": "abstractcode",
+    "abstractgateway": "abstractgateway",
+    "abstractmemory": "AbstractMemory",
+    "abstractsemantics": "abstractsemantics",
+    "abstractvoice": "abstractvoice",
+    "abstractvision": "abstractvision",
+    "abstractmusic": "abstractmusic",
+    "abstractassistant": "abstractassistant",
+}
+
+NPM_RELEASE_VERSIONS: dict[str, str] = {
+    "@abstractframework/flow": "0.3.17",
+    "@abstractframework/code": "0.3.8",
+    "@abstractframework/observer": "0.1.10",
+}
+
 CORE_DEFAULT_EXTRAS = [
     "remote",
     "tools",
@@ -69,9 +90,11 @@ def get_release_profile() -> dict[str, object]:
     return {
         "abstractframework": __version__,
         "packages": RELEASE_VERSIONS.copy(),
+        "distributions": PACKAGE_DISTRIBUTIONS.copy(),
+        "npm_packages": NPM_RELEASE_VERSIONS.copy(),
         "core_extras": list(CORE_DEFAULT_EXTRAS),
         "install_profiles": {
-            "base": "pip install abstractframework",
+            "light": "pip install abstractframework",
             "apple": 'pip install "abstractframework[apple]"',
             "gpu": 'pip install "abstractframework[gpu]"',
         },
@@ -90,20 +113,7 @@ def get_installed_packages() -> dict[str, str]:
         except Exception:
             return
 
-    for name in [
-        "abstractcore",
-        "abstractruntime",
-        "abstractagent",
-        "abstractflow",
-        "abstractcode",
-        "abstractgateway",
-        "abstractmemory",
-        "abstractsemantics",
-        "abstractvoice",
-        "abstractvision",
-        "abstractmusic",
-        "abstractassistant",
-    ]:
+    for name in PACKAGE_DISTRIBUTIONS:
         _maybe_add(name)
 
     return packages
@@ -113,20 +123,7 @@ def print_status() -> None:
     """Print installation status of the main AbstractFramework Python packages."""
 
     installed = get_installed_packages()
-    all_packages = [
-        "abstractcore",
-        "abstractruntime",
-        "abstractagent",
-        "abstractflow",
-        "abstractcode",
-        "abstractgateway",
-        "abstractmemory",
-        "abstractsemantics",
-        "abstractvoice",
-        "abstractvision",
-        "abstractmusic",
-        "abstractassistant",
-    ]
+    all_packages = list(PACKAGE_DISTRIBUTIONS)
 
     print("AbstractFramework installation status")
     print("=" * 40)

abstractframework-0.1.7/abstractframework/__main__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from .cli import main
+
+raise SystemExit(main())

abstractframework-0.1.7/abstractframework/cli.py

@@ -0,0 +1,214 @@
+"""Command line helpers for the AbstractFramework meta-package."""
+
+from __future__ import annotations
+
+import argparse
+import importlib.metadata
+import json
+import platform
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Sequence
+
+from . import PACKAGE_DISTRIBUTIONS, RELEASE_VERSIONS, __version__
+from .install_manifest import check_install_manifest, manifest_json, write_install_manifest
+
+
+@dataclass(frozen=True)
+class Check:
+    id: str
+    status: str
+    message: str
+    detail: str | None = None
+
+    def as_dict(self) -> dict[str, str]:
+        data = {"id": self.id, "status": self.status, "message": self.message}
+        if self.detail:
+            data["detail"] = self.detail
+        return data
+
+
+def _distribution_version(distribution: str) -> str | None:
+    try:
+        return importlib.metadata.version(distribution)
+    except importlib.metadata.PackageNotFoundError:
+        return None
+
+
+def _command_version(command: str) -> str | None:
+    executable = shutil.which(command)
+    if not executable:
+        return None
+    try:
+        result = subprocess.run(
+            [executable, "--version"],
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+    except Exception:
+        return "available"
+    text = (result.stdout or result.stderr).strip().splitlines()
+    return text[0] if text else "available"
+
+
+def build_doctor_report(include_environment: bool = True) -> dict[str, object]:
+    """Return a doctor report without importing heavy local inference stacks."""
+
+    checks: list[Check] = []
+
+    python_version = ".".join(str(part) for part in sys.version_info[:3])
+    if sys.version_info >= (3, 10):
+        checks.append(Check("python", "ok", f"Python {python_version} satisfies >=3.10"))
+    else:
+        checks.append(Check("python", "error", f"Python {python_version} is below required >=3.10"))
+
+    installed_framework = _distribution_version("abstractframework")
+    if installed_framework in {None, __version__}:
+        status = "ok" if installed_framework == __version__ else "warn"
+        message = (
+            f"abstractframework {installed_framework} matches release profile"
+            if installed_framework
+            else "abstractframework distribution metadata is not installed"
+        )
+        checks.append(Check("abstractframework", status, message))
+    else:
+        checks.append(
+            Check(
+                "abstractframework",
+                "error",
+                f"abstractframework {installed_framework} does not match {__version__}",
+            )
+        )
+
+    for package_id, expected in RELEASE_VERSIONS.items():
+        distribution = PACKAGE_DISTRIBUTIONS[package_id]
+        actual = _distribution_version(distribution)
+        if actual is None:
+            checks.append(
+                Check(
+                    f"package:{package_id}",
+                    "error",
+                    f"{distribution} is not installed",
+                    f"Expected {distribution}=={expected}",
+                )
+            )
+        elif actual == expected:
+            checks.append(Check(f"package:{package_id}", "ok", f"{distribution}=={actual}"))
+        else:
+            checks.append(
+                Check(
+                    f"package:{package_id}",
+                    "error",
+                    f"{distribution}=={actual} does not match pinned {expected}",
+                )
+            )
+
+    if include_environment:
+        node_version = _command_version("node")
+        npm_version = _command_version("npm")
+        if node_version:
+            checks.append(Check("node", "ok", f"Node is available: {node_version}"))
+        else:
+            checks.append(Check("node", "warn", "Node is not available; browser UIs need Node/npm"))
+        if npm_version:
+            checks.append(Check("npm", "ok", f"npm is available: {npm_version}"))
+        else:
+            checks.append(Check("npm", "warn", "npm is not available; browser UIs need npm/npx"))
+
+        system = platform.system()
+        machine = platform.machine().lower()
+        if system == "Darwin" and machine in {"arm64", "aarch64"}:
+            checks.append(Check("hardware:apple", "ok", "Apple Silicon local profile can be used"))
+        elif system == "Darwin":
+            checks.append(
+                Check("hardware:apple", "warn", "Apple local profile expects Apple Silicon")
+            )
+        else:
+            checks.append(Check("hardware:apple", "warn", "Apple local profile is macOS-only"))
+
+        if shutil.which("nvidia-smi"):
+            checks.append(Check("hardware:gpu", "ok", "nvidia-smi is available"))
+        else:
+            checks.append(
+                Check(
+                    "hardware:gpu",
+                    "warn",
+                    "No nvidia-smi found; GPU profile may still work with another supported stack",
+                )
+            )
+
+    status_rank = {"error": 2, "warn": 1, "ok": 0}
+    worst = max((status_rank[check.status] for check in checks), default=0)
+    status = "error" if worst == 2 else "warn" if worst == 1 else "ok"
+    return {
+        "abstractframework": __version__,
+        "status": status,
+        "checks": [check.as_dict() for check in checks],
+    }
+
+
+def _print_doctor(report: dict[str, object]) -> None:
+    print(f"AbstractFramework doctor ({report['status']})")
+    print("=" * 40)
+    for raw in report["checks"]:  # type: ignore[index]
+        check = raw  # type: ignore[assignment]
+        marker = {"ok": "OK", "warn": "WARN", "error": "ERROR"}[check["status"]]
+        print(f"[{marker}] {check['message']}")
+        if check.get("detail"):
+            print(f"       {check['detail']}")
+
+
+def _doctor(args: argparse.Namespace) -> int:
+    report = build_doctor_report(include_environment=not args.no_environment)
+    if args.json:
+        print(json.dumps(report, indent=2, sort_keys=True))
+    else:
+        _print_doctor(report)
+    return 1 if report["status"] == "error" else 0
+
+
+def _manifest(args: argparse.Namespace) -> int:
+    if args.write:
+        write_install_manifest(args.write)
+        print(f"Wrote {args.write}")
+        return 0
+    if args.check:
+        ok, message = check_install_manifest(args.check)
+        print(message)
+        return 0 if ok else 1
+    print(manifest_json(), end="")
+    return 0
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="abstractframework")
+    subparsers = parser.add_subparsers(dest="command")
+
+    doctor = subparsers.add_parser("doctor", help="Check install health and profile consistency")
+    doctor.add_argument("--json", action="store_true", help="Emit machine-readable JSON")
+    doctor.add_argument(
+        "--no-environment",
+        action="store_true",
+        help="Skip Node/npm/hardware probes and only check Python package profile consistency",
+    )
+    doctor.set_defaults(func=_doctor)
+
+    manifest = subparsers.add_parser("manifest", help="Print or validate the install manifest")
+    manifest.add_argument("--write", type=Path, help="Write the generated manifest to a path")
+    manifest.add_argument("--check", type=Path, help="Check a manifest file against the generator")
+    manifest.set_defaults(func=_manifest)
+
+    args = parser.parse_args(argv)
+    if not hasattr(args, "func"):
+        parser.print_help()
+        return 0
+    return args.func(args)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

abstractframework-0.1.7/abstractframework/install_manifest.py

@@ -0,0 +1,145 @@
+"""Generated install manifest helpers for AbstractFramework."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from . import NPM_RELEASE_VERSIONS, PACKAGE_DISTRIBUTIONS, RELEASE_VERSIONS, __version__
+
+MANIFEST_SCHEMA_VERSION = 1
+MINIMUM_INSTALLER_VERSION = "0.1.0"
+
+
+def _python_packages() -> list[dict[str, str]]:
+    return [
+        {
+            "id": package_id,
+            "distribution": PACKAGE_DISTRIBUTIONS[package_id],
+            "version": version,
+            "registry": "pypi",
+        }
+        for package_id, version in RELEASE_VERSIONS.items()
+    ]
+
+
+def _npm_apps() -> list[dict[str, str]]:
+    return [
+        {
+            "id": package_name.rsplit("/", 1)[-1],
+            "package": package_name,
+            "version": version,
+            "registry": "npm",
+            "command": f"npx {package_name}",
+        }
+        for package_name, version in NPM_RELEASE_VERSIONS.items()
+    ]
+
+
+def build_install_manifest() -> dict[str, Any]:
+    """Build the installer-consumable manifest from root release pins."""
+
+    return {
+        "schema_version": MANIFEST_SCHEMA_VERSION,
+        "minimum_installer_version": MINIMUM_INSTALLER_VERSION,
+        "framework": {
+            "id": "abstractframework",
+            "name": "AbstractFramework",
+            "distribution": "abstractframework",
+            "version": __version__,
+            "registry": "pypi",
+            "python_requires": ">=3.10",
+        },
+        "source": {
+            "repository": "https://github.com/lpalbou/AbstractFramework",
+            "release_profile": "abstractframework.RELEASE_VERSIONS",
+        },
+        "profiles": [
+            {
+                "id": "light",
+                "name": "Light",
+                "summary": (
+                    "Remote-first install. Full framework functionality is available through "
+                    "remote or OpenAI-compatible endpoints; no local MLX, CUDA, Diffusers, or "
+                    "model-runtime stacks are installed by this profile."
+                ),
+                "pip_requirements": [f"abstractframework=={__version__}"],
+                "local_inference": False,
+                "platforms": ["macos", "linux", "windows"],
+                "prerequisites": ["python>=3.10", "network"],
+                "best_for": [
+                    "cloud APIs",
+                    "LM Studio, Ollama, vLLM, llama.cpp, or other endpoint servers",
+                    "lowest-friction install",
+                ],
+                "excludes": ["local MLX engines", "local CUDA/ROCm engines"],
+            },
+            {
+                "id": "apple",
+                "name": "Apple",
+                "summary": (
+                    "Native Apple Silicon profile. Adds local MLX/Metal-capable stacks on top "
+                    "of the same framework interfaces and endpoint providers."
+                ),
+                "pip_requirements": [f"abstractframework[apple]=={__version__}"],
+                "local_inference": True,
+                "platforms": ["macos"],
+                "prerequisites": ["python>=3.10", "apple-silicon", "network"],
+                "best_for": ["Mac users who want local Apple Silicon inferencers"],
+                "excludes": ["CUDA/ROCm engines"],
+            },
+            {
+                "id": "gpu",
+                "name": "GPU",
+                "summary": (
+                    "Native GPU profile. Adds CUDA/ROCm-oriented local stacks on top of the "
+                    "same framework interfaces and endpoint providers."
+                ),
+                "pip_requirements": [f"abstractframework[gpu]=={__version__}"],
+                "local_inference": True,
+                "platforms": ["linux", "windows"],
+                "prerequisites": ["python>=3.10", "gpu-driver", "network"],
+                "best_for": ["workstations or servers with supported discrete GPUs"],
+                "excludes": ["Apple MLX-only engines"],
+            },
+        ],
+        "python_packages": _python_packages(),
+        "npm_apps": _npm_apps(),
+        "post_install": {
+            "doctor": ["abstractframework", "doctor"],
+            "core_config": ["abstractcore", "--config"],
+            "gateway_flow": {
+                "gateway": ["abstractgateway", "serve"],
+                "flow": ["npx", "@abstractframework/flow"],
+            },
+        },
+        "security": {
+            "secrets_in_manifest": False,
+            "native_artifacts_signed": False,
+            "notes": "Prototype manifest; production installer artifacts must add signatures.",
+        },
+    }
+
+
+def manifest_json(indent: int = 2) -> str:
+    """Return the install manifest as stable JSON."""
+
+    return json.dumps(build_install_manifest(), indent=indent, sort_keys=True) + "\n"
+
+
+def write_install_manifest(path: str | Path) -> None:
+    """Write the generated install manifest to a path."""
+
+    Path(path).write_text(manifest_json(), encoding="utf-8")
+
+
+def check_install_manifest(path: str | Path) -> tuple[bool, str]:
+    """Compare a checked-in manifest file with the generated manifest."""
+
+    manifest_path = Path(path)
+    expected = manifest_json()
+    actual = manifest_path.read_text(encoding="utf-8")
+    if actual == expected:
+        return True, f"{manifest_path} is up to date"
+    return False, f"{manifest_path} differs from generated AbstractFramework install manifest"

{abstractframework-0.1.6 → abstractframework-0.1.7/abstractframework.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstractframework
-Version: 0.1.6
+Version: 0.1.7
 Summary: Unified installer and documentation hub for the AbstractFramework ecosystem
 Author-email: Laurent-Philippe Albou <contact@abstractcore.ai>
 License: MIT
@@ -177,6 +177,9 @@ pip install "abstractframework[apple]"
 pip install "abstractframework[gpu]"
 ```
 
+See [docs/install.md](docs/install.md) for the full install chooser, `uv`/venv guidance,
+`abstractframework doctor`, and the generated installer manifest contract.
+
 ---
 
 ## Documentation
@@ -184,6 +187,7 @@ pip install "abstractframework[gpu]"
 | Page | What it covers |
 |---|---|
 | [docs/README.md](docs/README.md) | Documentation hub — pick your starting point |
+| [docs/install.md](docs/install.md) | Light / Apple / GPU install chooser and first checks |
 | [docs/getting-started.md](docs/getting-started.md) | Two entry points + first end-to-end run |
 | [docs/architecture.md](docs/architecture.md) | Layered model, durable execution primitives, comparisons |
 | [docs/configuration.md](docs/configuration.md) | Minimal config, where defaults live, Core vs Gateway |

{abstractframework-0.1.6 → abstractframework-0.1.7}/abstractframework.egg-info/SOURCES.txt

@@ -6,10 +6,14 @@ llms-full.txt
 llms.txt
 pyproject.toml
 abstractframework/__init__.py
+abstractframework/__main__.py
+abstractframework/cli.py
+abstractframework/install_manifest.py
 abstractframework/py.typed
 abstractframework.egg-info/PKG-INFO
 abstractframework.egg-info/SOURCES.txt
 abstractframework.egg-info/dependency_links.txt
+abstractframework.egg-info/entry_points.txt
 abstractframework.egg-info/requires.txt
 abstractframework.egg-info/top_level.txt
 docs/README.md
@@ -19,6 +23,7 @@ docs/configuration.md
 docs/faq.md
 docs/getting-started.md
 docs/glossary.md
+docs/install.md
 docs/adr/0001-layered-architecture.md
 docs/adr/0002-effect-system-design.md
 docs/adr/0003-tool-system-architecture.md
@@ -85,7 +90,11 @@ docs/backlog/completed/014_abstractmusic_acestep_vendor_hf_transformers_code_no_
 docs/backlog/completed/0154_multi_user_security_release_blockers.md
 docs/backlog/completed/0156_retained_runtime_admin_lifecycle.md
 docs/backlog/completed/0157_gateway_provider_endpoint_profiles.md
+docs/backlog/completed/0158_installer_repository_extraction.md
+docs/backlog/completed/0159_generated_install_manifest_contract.md
 docs/backlog/completed/015_abstractmusic_acestep_v15_meta_tensor_load_fix_and_vendor_quantizer.md
+docs/backlog/completed/0160_framework_doctor_and_launch_cli.md
+docs/backlog/completed/0161_three_path_public_install_guide.md
 docs/backlog/completed/016_abstractmusic_acestep_mps_memory_budget_and_fp16_defaults.md
 docs/backlog/completed/017_abstractmusic_acestep_mps_dtype_alignment_fix.md
 docs/backlog/completed/018_abstractmusic_acestep_audio_quality_dc_offset_and_lyrics_null_handling.md
@@ -298,6 +307,9 @@ docs/backlog/proposed/gateway-control-plane/0151_runtime_explorer_contract.md
 docs/backlog/proposed/gateway-control-plane/0152_abstractmanager_package_extraction.md
 docs/backlog/proposed/gateway-control-plane/0155_hosted_proxy_shared_helper_extraction.md
 docs/backlog/proposed/gateway-control-plane/README.md
+docs/backlog/proposed/installers/0162_signed_installer_ci_and_distribution.md
+docs/backlog/proposed/installers/0163_cpu_local_inference_install_profile.md
+docs/backlog/proposed/installers/README.md
 docs/claude/README.md
 docs/claude/abstractframework-fit.md
 docs/claude/claude-skills-overview.md

abstractframework-0.1.7/abstractframework.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+abstractframework = abstractframework.cli:main

{abstractframework-0.1.6 → abstractframework-0.1.7}/docs/README.md

@@ -76,6 +76,7 @@ Authoring                                Operations
 
 | Page | What it covers |
 |---|---|
+| **[Install](install.md)** | Light / Apple / GPU install chooser, `abstractframework doctor`, and installer manifest contract |
 | **[Getting Started](getting-started.md)** | The two entry points + first end-to-end run |
 | **[Architecture](architecture.md)** | Layered model, durable execution primitives, honest comparisons |
 | **[Configuration](configuration.md)** | Minimal config, where defaults live, Core vs Gateway |
@@ -102,5 +103,5 @@ Authoring                                Operations
 |---|---|
 | [docs/guide/](guide/) | Focused "how it works" notes |
 | [docs/scenarios/](scenarios/) | End-to-end walkthroughs by use case |
-| [docs/installers/](installers/) | Installer strategy and prototypes |
+| [docs/installers/](installers/) | Installer strategy, manifest contract, and prototype history |
 | [docs/comparisons/](comparisons/) | Trade-offs vs other frameworks |

{abstractframework-0.1.6 → abstractframework-0.1.7}/docs/api.md

@@ -27,6 +27,8 @@ pip install "abstractframework[apple]"       # Apple Silicon native stack (MLX/M
 pip install "abstractframework[gpu]"         # GPU native stack (CUDA/ROCm)
 ```
 
+See [Install AbstractFramework](install.md) for the profile chooser and first health checks.
+
 ---
 
 ## Convenience re-exports
@@ -89,6 +91,25 @@ from abstractframework import print_status
 print_status()
 ```
 
+### `abstractframework doctor`
+
+Checks Python version, pinned package versions, Node/npm availability for browser UIs, and local
+hardware indicators for Apple/GPU profiles. It does not import heavy local inference stacks.
+
+```bash
+abstractframework doctor
+abstractframework doctor --json
+```
+
+### `abstractframework manifest`
+
+Prints or validates the installer-facing manifest generated from the root release profile.
+
+```bash
+abstractframework manifest
+abstractframework manifest --check docs/installers/install-manifest.json
+```
+
 ---
 
 ## Where to find the functional APIs