agi-app-multi-dag 2026.5.30__tar.gz

agi_app_multi_dag-2026.5.30/LICENSE

@@ -0,0 +1,22 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, Jean-Pierre Morard, THALES SIX GTS France SAS
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
+disclaimer in the documentation and/or other materials provided with the distribution.
+3. Neither the name of Jean-Pierre MORARD nor the names of its contributors, or THALES SIX GTS France SAS, may be used
+to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

agi_app_multi_dag-2026.5.30/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: agi-app-multi-dag
+Version: 2026.5.30
+Summary: AGILAB cross-app DAG preview showing artifact handoffs between demo projects
+Author: Jean-Pierre Morard
+Maintainer: Jean-Pierre Morard
+License-Expression: BSD-3-Clause
+Project-URL: Documentation, https://thalesgroup.github.io/agilab
+Project-URL: Source, https://github.com/ThalesGroup/agilab/tree/main/src/agilab/lib/agi-app-multi-dag
+Project-URL: Issues, https://github.com/ThalesGroup/agilab/issues
+Project-URL: Homepage, https://github.com/ThalesGroup/agilab
+Project-URL: Repository, https://github.com/ThalesGroup/agilab
+Project-URL: Discussions, https://github.com/ThalesGroup/agilab/discussions
+Project-URL: Changelog, https://github.com/ThalesGroup/agilab/releases
+Keywords: agilab,apps,reproducibility,workflow-orchestration
+Classifier: Intended Audience :: Developers
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: agi-core<2027.0,>=2026.05.13
+Dynamic: license-file
+
+# agi-app-multi-dag
+
+[![PyPI version](https://img.shields.io/pypi/v/agi-app-multi-dag.svg?cacheSeconds=300)](https://pypi.org/project/agi-app-multi-dag/)
+[![Python versions](https://img.shields.io/pypi/pyversions/agi-app-multi-dag.svg)](https://pypi.org/project/agi-app-multi-dag/)
+[![License: BSD 3-Clause](https://img.shields.io/pypi/l/agi-app-multi-dag)](https://opensource.org/licenses/BSD-3-Clause)
+
+`agi-app-multi-dag` publishes the `multi_app_dag_project` AGILAB app as a
+self-contained PyPI payload. It is a read-only workflow-contract example rather
+than a domain worker benchmark.
+
+## Purpose
+
+Use this package to understand how AGILAB can connect several app projects with
+explicit artifact handoffs. The bundled DAG shows a flight stage producing a
+summary artifact that a weather stage can consume.
+
+## Installed Project
+
+The distribution name is `agi-app-multi-dag`; the AGILAB project name is
+`multi_app_dag_project`. The package exposes both `multi_app_dag` and
+`multi_app_dag_project` through the `agilab.apps` entry point group, so
+`AgiEnv(app="multi_app_dag_project")` resolves the project without a monorepo
+checkout.
+
+## Install
+
+```bash
+pip install agi-app-multi-dag
+```
+
+Most users get this package through `agi-apps`, `agilab[ui]`, or
+`agilab[examples]`; direct installation is useful when validating one app
+package in isolation.
+
+## Run In AGILAB
+
+Select `multi_app_dag_project`, open `WORKFLOW`, choose the multi-app DAG template,
+and inspect the runner-state preview. This package is primarily for workflow
+review; use `flight_telemetry_project` or `weather_forecast_project` when you
+want to execute concrete worker code.
+
+## Expected Inputs
+
+The package ships a DAG template that names the producer and consumer projects.
+No private data, cluster, service mode, or live external service is required for
+the default preview.
+
+## Expected Outputs
+
+The preview writes a runner-state JSON file under the AGILAB execution logs and
+renders the runnable versus blocked stages. It does not create a domain reducer
+artifact because it demonstrates cross-app orchestration, not a worker merge.
+
+## Change One Thing
+
+Edit a handoff name in a copied DAG template and reload the preview. The blocked
+stage should make the missing artifact contract obvious before any downstream
+execution is attempted.
+
+## Scope
+
+This package teaches multi-app DAG contracts. It is not a scheduler replacement,
+an Airflow/Kubeflow clone, or a production workflow governance layer.

agi_app_multi_dag-2026.5.30/README.md

@@ -0,0 +1,63 @@
+# agi-app-multi-dag
+
+[![PyPI version](https://img.shields.io/pypi/v/agi-app-multi-dag.svg?cacheSeconds=300)](https://pypi.org/project/agi-app-multi-dag/)
+[![Python versions](https://img.shields.io/pypi/pyversions/agi-app-multi-dag.svg)](https://pypi.org/project/agi-app-multi-dag/)
+[![License: BSD 3-Clause](https://img.shields.io/pypi/l/agi-app-multi-dag)](https://opensource.org/licenses/BSD-3-Clause)
+
+`agi-app-multi-dag` publishes the `multi_app_dag_project` AGILAB app as a
+self-contained PyPI payload. It is a read-only workflow-contract example rather
+than a domain worker benchmark.
+
+## Purpose
+
+Use this package to understand how AGILAB can connect several app projects with
+explicit artifact handoffs. The bundled DAG shows a flight stage producing a
+summary artifact that a weather stage can consume.
+
+## Installed Project
+
+The distribution name is `agi-app-multi-dag`; the AGILAB project name is
+`multi_app_dag_project`. The package exposes both `multi_app_dag` and
+`multi_app_dag_project` through the `agilab.apps` entry point group, so
+`AgiEnv(app="multi_app_dag_project")` resolves the project without a monorepo
+checkout.
+
+## Install
+
+```bash
+pip install agi-app-multi-dag
+```
+
+Most users get this package through `agi-apps`, `agilab[ui]`, or
+`agilab[examples]`; direct installation is useful when validating one app
+package in isolation.
+
+## Run In AGILAB
+
+Select `multi_app_dag_project`, open `WORKFLOW`, choose the multi-app DAG template,
+and inspect the runner-state preview. This package is primarily for workflow
+review; use `flight_telemetry_project` or `weather_forecast_project` when you
+want to execute concrete worker code.
+
+## Expected Inputs
+
+The package ships a DAG template that names the producer and consumer projects.
+No private data, cluster, service mode, or live external service is required for
+the default preview.
+
+## Expected Outputs
+
+The preview writes a runner-state JSON file under the AGILAB execution logs and
+renders the runnable versus blocked stages. It does not create a domain reducer
+artifact because it demonstrates cross-app orchestration, not a worker merge.
+
+## Change One Thing
+
+Edit a handoff name in a copied DAG template and reload the preview. The blocked
+stage should make the missing artifact contract obvious before any downstream
+execution is attempted.
+
+## Scope
+
+This package teaches multi-app DAG contracts. It is not a scheduler replacement,
+an Airflow/Kubeflow clone, or a production workflow governance layer.

agi_app_multi_dag-2026.5.30/pyproject.toml

@@ -0,0 +1,94 @@
+[project]
+version = "2026.05.30"
+name = "agi-app-multi-dag"
+description = "AGILAB cross-app DAG preview showing artifact handoffs between demo projects"
+requires-python = ">=3.11"
+readme = "README.md"
+authors = [
+    { name = "Jean-Pierre Morard" }
+]
+maintainers = [{ name = "Jean-Pierre Morard" }]
+license = "BSD-3-Clause"
+license-files = ["LICENSE"]
+
+classifiers = [
+    "Intended Audience :: Developers",
+    "Development Status :: 4 - Beta",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Operating System :: MacOS",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+]
+
+keywords = [
+    "agilab",
+    "apps",
+    "reproducibility",
+    "workflow-orchestration",
+]
+
+dependencies = ["agi-core>=2026.05.13,<2027.0"]
+
+[project.urls]
+Documentation = "https://thalesgroup.github.io/agilab"
+Source = "https://github.com/ThalesGroup/agilab/tree/main/src/agilab/lib/agi-app-multi-dag"
+Issues = "https://github.com/ThalesGroup/agilab/issues"
+Homepage = "https://github.com/ThalesGroup/agilab"
+Repository = "https://github.com/ThalesGroup/agilab"
+Discussions = "https://github.com/ThalesGroup/agilab/discussions"
+Changelog = "https://github.com/ThalesGroup/agilab/releases"
+
+[project.entry-points."agilab.apps"]
+multi_app_dag = "agi_app_multi_dag:project_root"
+multi_app_dag_project = "agi_app_multi_dag:project_root"
+
+
+
+
+
+
+
+
+
+
+
+[dependency-groups]
+dev = [
+    "pytest",
+]
+
+[tool.uv.sources.agi-core]
+    path = "../../core/agi-core"
+    editable = true
+
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+include-package-data = false
+package-dir = {"" = "src"}
+packages = ["agi_app_multi_dag"]
+
+[tool.setuptools.package-data]
+"agi_app_multi_dag" = [
+    "project/**/*",
+]
+
+[tool.setuptools.exclude-package-data]
+"agi_app_multi_dag" = [
+    "project/**/.venv/**",
+    "project/**/__pycache__/**",
+    "project/**/*.pyc",
+    "project/**/*.pyo",
+    "project/**/*.pyx",
+    "project/**/*.c",
+    "project/**/*.so",
+    "project/**/uv.lock",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["test"]

agi_app_multi_dag-2026.5.30/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

agi_app_multi_dag-2026.5.30/setup.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+
+from setuptools import setup
+from setuptools.command.build_py import build_py as _build_py
+from setuptools.command.sdist import sdist as _sdist
+
+APP_PROJECT = 'multi_app_dag_project'
+PACKAGE_IMPORT = 'agi_app_multi_dag'
+
+
+def _load_build_support():
+    module_path = Path(__file__).resolve().parents[4] / "src" / "agilab" / "lib" / "app_project_build_support.py"
+    if not module_path.exists():
+        return None
+    spec = importlib.util.spec_from_file_location("agilab_app_project_build_support", module_path)
+    if spec is None or spec.loader is None:
+        raise RuntimeError(f"Unable to load app project build support from {module_path}")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def _copy_payload(target_root: Path) -> None:
+    support = _load_build_support()
+    if support is None:
+        return
+    changed = support.copy_app_project_payload(APP_PROJECT, target_root)
+    for pyproject_path in changed:
+        print(f"[{PACKAGE_IMPORT}] sanitized packaged app manifest: {pyproject_path}")
+
+
+class build_py(_build_py):
+    def run(self):
+        super().run()
+        _copy_payload(Path(self.build_lib) / PACKAGE_IMPORT / "project")
+
+
+class sdist(_sdist):
+    def make_release_tree(self, base_dir, files):
+        super().make_release_tree(base_dir, files)
+        _copy_payload(Path(base_dir) / "src" / PACKAGE_IMPORT / "project")
+
+
+setup(cmdclass={"build_py": build_py, "sdist": sdist})

agi_app_multi_dag-2026.5.30/src/agi_app_multi_dag/__init__.py

@@ -0,0 +1,32 @@
+"""Installed AGILAB app project provider for multi_app_dag_project."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+APP_SLUG = 'multi_app_dag'
+PROJECT_NAME = 'multi_app_dag_project'
+PACKAGE_NAME = 'agi-app-multi-dag'
+
+
+def package_root() -> Path:
+    return Path(__file__).resolve().parent
+
+
+def project_root() -> Path:
+    source_root = Path(__file__).resolve().parents[4] / "apps" / "builtin" / PROJECT_NAME
+    if source_root.exists():
+        return source_root
+    return package_root() / "project" / PROJECT_NAME
+
+
+def metadata() -> dict[str, str]:
+    return {
+        "slug": APP_SLUG,
+        "project": PROJECT_NAME,
+        "package": PACKAGE_NAME,
+        "project_root": str(project_root()),
+    }
+
+
+__all__ = ["APP_SLUG", "PACKAGE_NAME", "PROJECT_NAME", "metadata", "package_root", "project_root"]

agi_app_multi_dag-2026.5.30/src/agi_app_multi_dag/project/multi_app_dag_project/README.md

@@ -0,0 +1,52 @@
+# Multi-app DAG Project
+
+`multi_app_dag_project` is the built-in read-only example for cross-app DAG
+contracts.
+
+## Purpose
+
+Use this project to inspect how independent AGILAB apps can be connected through
+explicit artifact handoffs before any app is executed.
+
+## What You Learn
+
+- How a DAG template can live with the app that teaches it.
+- How `flight_telemetry_project` can produce a handoff consumed by a weather
+  stage.
+- How runner-state previews expose runnable and blocked units.
+- Why cross-app orchestration should keep artifact contracts explicit.
+
+## Run In AGILAB
+
+1. Select `multi_app_dag_project` in `WORKFLOW`.
+2. Open `Workflow graph`.
+3. Choose `Multi-app DAG`.
+4. Select the bundled flight-to-weather DAG template.
+5. Inspect stage readiness and handoffs.
+
+## Expected Inputs
+
+The project ships DAG templates under `dag_templates/`. No live app execution is
+required for the preview.
+
+## Expected Outputs
+
+The preview writes runner-state JSON under `~/log/execute/multi_app_dag/` and
+reports app stages, artifact dependencies, and dispatch readiness.
+
+## Change One Thing
+
+After the default preview works, edit a copy of the DAG template and change one
+artifact handoff. The preview should make the affected downstream stage blocked
+or runnable based on that contract.
+
+## Troubleshooting
+
+If the preview cannot find built-in apps, run AGILAB once from the source or
+installed checkout so `.agilab-path` points at the package. If packaged preview
+layout setup fails, inspect `~/.cache/agilab/multi_app_dag_layout`.
+
+## Scope
+
+This is a DAG-contract preview. It intentionally does not ship a reducer
+contract because it does not execute a concrete worker merge output.

agi_app_multi_dag-2026.5.30/src/agi_app_multi_dag/project/multi_app_dag_project/dag_templates/flight_to_weather_legacy_multi_app_dag.json

@@ -0,0 +1,51 @@
+{
+  "schema": "agilab.multi_app_dag.v1",
+  "dag_id": "flight-to-meteo-multi-app-dag-example",
+  "label": "Flight to meteo multi-app DAG handoff",
+  "description": "Two public AGILAB projects connected through an explicit multi-app DAG artifact contract. The preview plans the DAG and runner state; it does not execute either app.",
+  "execution": {
+    "mode": "sequential_dependency_order",
+    "runner_status": "contract_only"
+  },
+  "nodes": [
+    {
+      "id": "flight_context",
+      "app": "flight_telemetry_project",
+      "purpose": "Run the flight scenario and produce trajectory summary context for downstream review.",
+      "produces": [
+        {
+          "id": "flight_reduce_summary",
+          "kind": "reduce_summary",
+          "path": "flight_analysis/reduce_summary_worker_0.json"
+        }
+      ]
+    },
+    {
+      "id": "weather_forecast_legacy_review",
+      "app": "weather_forecast_legacy_project",
+      "purpose": "Consume the flight summary context and produce forecast quality metrics.",
+      "consumes": [
+        {
+          "id": "flight_reduce_summary",
+          "kind": "reduce_summary",
+          "path": "flight_analysis/reduce_summary_worker_0.json"
+        }
+      ],
+      "produces": [
+        {
+          "id": "forecast_metrics",
+          "kind": "summary_metrics",
+          "path": "forecast_analysis/forecast_metrics.json"
+        }
+      ]
+    }
+  ],
+  "edges": [
+    {
+      "from": "flight_context",
+      "to": "weather_forecast_legacy_review",
+      "artifact": "flight_reduce_summary",
+      "handoff": "Use flight trajectory reduce summary as the forecast-review context."
+    }
+  ]
+}

agi_app_multi_dag-2026.5.30/src/agi_app_multi_dag/project/multi_app_dag_project/dag_templates/flight_to_weather_multi_app_dag.json

@@ -0,0 +1,51 @@
+{
+  "schema": "agilab.multi_app_dag.v1",
+  "dag_id": "flight-to-weather-multi-app-dag-example",
+  "label": "Flight to weather multi-app DAG handoff",
+  "description": "Two public AGILAB projects connected through an explicit multi-app DAG artifact contract. The preview plans the DAG and runner state; it does not execute either app.",
+  "execution": {
+    "mode": "sequential_dependency_order",
+    "runner_status": "contract_only"
+  },
+  "nodes": [
+    {
+      "id": "flight_context",
+      "app": "flight_telemetry_project",
+      "purpose": "Run the flight scenario and produce trajectory summary context for downstream review.",
+      "produces": [
+        {
+          "id": "flight_reduce_summary",
+          "kind": "reduce_summary",
+          "path": "flight_analysis/reduce_summary_worker_0.json"
+        }
+      ]
+    },
+    {
+      "id": "weather_forecast_review",
+      "app": "weather_forecast_project",
+      "purpose": "Consume the flight summary context and produce forecast quality metrics.",
+      "consumes": [
+        {
+          "id": "flight_reduce_summary",
+          "kind": "reduce_summary",
+          "path": "flight_analysis/reduce_summary_worker_0.json"
+        }
+      ],
+      "produces": [
+        {
+          "id": "forecast_metrics",
+          "kind": "summary_metrics",
+          "path": "forecast_analysis/forecast_metrics.json"
+        }
+      ]
+    }
+  ],
+  "edges": [
+    {
+      "from": "flight_context",
+      "to": "weather_forecast_review",
+      "artifact": "flight_reduce_summary",
+      "handoff": "Use flight trajectory reduce summary as the forecast-review context."
+    }
+  ]
+}

agi_app_multi_dag-2026.5.30/src/agi_app_multi_dag/project/multi_app_dag_project/lab_stages.toml

@@ -0,0 +1,13 @@
+[[steps]]
+D = "Inspect the multi-app DAG contract"
+Q = "Open the bundled flight-to-meteo DAG and identify stages, artifacts, and handoffs."
+M = ""
+C = "from pathlib import Path\nimport json\npath = Path('dag_templates/flight_to_weather_legacy_multi_app_dag.json')\npayload = json.loads(path.read_text(encoding='utf-8'))\n[(node['id'], node['app']) for node in payload['nodes']]"
+R = "runpy"
+
+[[steps]]
+D = "Preview runner state"
+Q = "Build a read-only runner-state preview without executing either app."
+M = ""
+C = "from pathlib import Path\nfrom multi_app_dag.preview_multi_app_dag import build_preview, planning_repo_root\nsummary = build_preview(repo_root=planning_repo_root(None), output_path=Path.home() / 'log/execute/multi_app_dag/runner_state.json')\nsummary['runner_state']['summary']"
+R = "runpy"

agi_app_multi_dag-2026.5.30/src/agi_app_multi_dag/project/multi_app_dag_project/pyproject.toml

@@ -0,0 +1,10 @@
+[project]
+name = "multi_app_dag_project"
+version = "2026.05.30"
+description = "Built-in AGILAB multi-app DAG example project"
+requires-python = ">=3.11"
+dependencies = ["agi-env>=2026.05.30", "agi-node>=2026.05.30", "agi-cluster>=2026.05.30", "polars>=1.35,<2", "pydantic>=2.11,<2.13", "streamlit>=1.56,<1.57"]
+
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"

agi_app_multi_dag-2026.5.30/src/agi_app_multi_dag/project/multi_app_dag_project/src/app_args_form.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+from pathlib import Path
+import sys
+from typing import Any
+
+import streamlit as st
+from pydantic import ValidationError
+
+_HERE = Path(__file__).resolve().parent
+
+
+def _ensure_project_src_import_precedence() -> None:
+    """Keep the project src ahead of the package directory for Streamlit form imports."""
+
+    project_src = str(_HERE)
+    sys.path[:] = [entry for entry in sys.path if entry != project_src]
+    sys.path.insert(0, project_src)
+
+    module = sys.modules.get("multi_app_dag")
+    if module is None or getattr(module, "__path__", None):
+        return
+    for loaded_name in list(sys.modules):
+        if loaded_name == "multi_app_dag" or loaded_name.startswith("multi_app_dag."):
+            sys.modules.pop(loaded_name, None)
+
+
+_ensure_project_src_import_precedence()
+
+from multi_app_dag.app_args import MultiAppDagArgs, dump_args, load_args  # noqa: E402
+
+
+PAGE_ID = "multi_app_dag_project:app_args_form"
+
+
+def _k(name: str) -> str:
+    return f"{PAGE_ID}:{name}"
+
+
+def _get_env():
+    env = st.session_state.get("env") or st.session_state.get("_env")
+    if env is None:
+        st.error("AGILAB environment is not initialised yet. Return to the main page and try again.")
+        st.stop()
+    return env
+
+
+def _load_current_args(settings_path: Path) -> MultiAppDagArgs:
+    try:
+        return load_args(settings_path)
+    except Exception as exc:
+        st.warning(f"Unable to load Multi-app DAG args from `{settings_path}`: {exc}")
+        return MultiAppDagArgs()
+
+
+env = _get_env()
+settings_path = Path(env.app_settings_file)
+current_args = _load_current_args(settings_path)
+current_payload = current_args.model_dump(mode="json")
+
+st.caption(
+    "Multi-app DAG is a planning project: edit the template path and preview output, "
+    "then use WORKFLOW to inspect the cross-app DAG."
+)
+
+for key, default in (
+    ("dag_path", str(current_payload.get("dag_path", "dag_templates/flight_to_weather_legacy_multi_app_dag.json"))),
+    ("output_path", str(current_payload.get("output_path", "~/log/execute/multi_app_dag/runner_state.json"))),
+    ("reset_target", bool(current_payload.get("reset_target", False))),
+):
+    st.session_state.setdefault(_k(key), default)
+
+c1, c2 = st.columns([2, 2])
+with c1:
+    st.text_input("DAG template", key=_k("dag_path"))
+with c2:
+    st.text_input("Preview output", key=_k("output_path"))
+
+c3, _ = st.columns([1.2, 2.8])
+with c3:
+    st.checkbox("Reset preview output", key=_k("reset_target"))
+
+candidate: dict[str, Any] = {
+    "dag_path": (st.session_state.get(_k("dag_path")) or "").strip(),
+    "output_path": (st.session_state.get(_k("output_path")) or "").strip(),
+    "reset_target": bool(st.session_state.get(_k("reset_target"), False)),
+}
+
+try:
+    validated = MultiAppDagArgs(**candidate)
+except ValidationError as exc:
+    st.error("Invalid Multi-app DAG parameters:")
+    if hasattr(env, "humanize_validation_errors"):
+        for msg in env.humanize_validation_errors(exc):
+            st.markdown(msg)
+    else:
+        st.code(str(exc))
+else:
+    validated_payload = validated.model_dump(mode="json")
+    if validated_payload != current_payload:
+        dump_args(validated, settings_path)
+        app_settings = st.session_state.get("app_settings")
+        if not isinstance(app_settings, dict):
+            app_settings = {}
+        app_settings.setdefault("cluster", {})
+        app_settings["args"] = validated_payload
+        st.session_state["app_settings"] = app_settings
+        st.session_state["is_args_from_ui"] = True
+        st.success(f"Saved to `{settings_path}`.")
+    else:
+        st.info("No changes to save.")
+
+    st.caption(
+        f"Template `{validated.dag_path}` will write preview state to `{validated.output_path}`."
+    )

agi_app_multi_dag-2026.5.30/src/agi_app_multi_dag/project/multi_app_dag_project/src/app_settings.toml

@@ -0,0 +1,21 @@
+[args]
+dag_path = "dag_templates/flight_to_weather_legacy_multi_app_dag.json"
+output_path = "~/log/execute/multi_app_dag/runner_state.json"
+reset_target = false
+
+[cluster]
+verbose = 1
+cython = false
+pool = false
+rapids = false
+cluster_enabled = false
+scheduler = "127.0.0.1:8786"
+workers_data_path = ""
+
+[cluster.workers]
+"127.0.0.1" = 2
+
+[cluster.service_health]
+allow_idle = false
+max_unhealthy = 0
+max_restart_rate = 0.25

agi_app_multi_dag-2026.5.30/src/agi_app_multi_dag/project/multi_app_dag_project/src/multi_app_dag/__init__.py

@@ -0,0 +1,11 @@
+from .app_args import ArgsModel, MultiAppDagArgs, dump_args, load_args
+
+__all__ = ["ArgsModel", "MultiAppDag", "MultiAppDagApp", "MultiAppDagArgs", "dump_args", "load_args"]
+
+
+def __getattr__(name: str):
+    if name in {"MultiAppDag", "MultiAppDagApp"}:
+        from .multi_app_dag import MultiAppDag, MultiAppDagApp
+
+        return {"MultiAppDag": MultiAppDag, "MultiAppDagApp": MultiAppDagApp}[name]
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

agi_app_multi_dag-2026.5.30/src/agi_app_multi_dag/project/multi_app_dag_project/src/multi_app_dag/app_args.py

@@ -0,0 +1,64 @@
+"""Argument helpers for the built-in multi-app DAG project."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, TypedDict
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from agi_env.app_args import dump_model_to_toml, load_model_from_toml, merge_model_data
+
+
+class MultiAppDagArgs(BaseModel):
+    """Runtime parameters for the multi-app DAG preview project."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    dag_path: Path = Field(default_factory=lambda: Path("dag_templates/flight_to_weather_legacy_multi_app_dag.json"))
+    output_path: Path = Field(default_factory=lambda: Path("~/log/execute/multi_app_dag/runner_state.json"))
+    reset_target: bool = False
+
+
+class MultiAppDagArgsTD(TypedDict, total=False):
+    dag_path: str
+    output_path: str
+    reset_target: bool
+
+
+ArgsModel = MultiAppDagArgs
+ArgsOverrides = MultiAppDagArgsTD
+
+
+def load_args(settings_path: str | Path, *, section: str = "args") -> MultiAppDagArgs:
+    return load_model_from_toml(MultiAppDagArgs, settings_path, section=section)
+
+
+def merge_args(base: MultiAppDagArgs, overrides: MultiAppDagArgsTD | None = None) -> MultiAppDagArgs:
+    return merge_model_data(base, overrides)
+
+
+def dump_args(
+    args: MultiAppDagArgs,
+    settings_path: str | Path,
+    *,
+    section: str = "args",
+    create_missing: bool = True,
+) -> None:
+    dump_model_to_toml(args, settings_path, section=section, create_missing=create_missing)
+
+
+def ensure_defaults(args: MultiAppDagArgs, **_: Any) -> MultiAppDagArgs:
+    return args
+
+
+__all__ = [
+    "ArgsModel",
+    "ArgsOverrides",
+    "MultiAppDagArgs",
+    "MultiAppDagArgsTD",
+    "dump_args",
+    "ensure_defaults",
+    "load_args",
+    "merge_args",
+]

agi_app_multi_dag-2026.5.30/src/agi_app_multi_dag/project/multi_app_dag_project/src/multi_app_dag/multi_app_dag.py

@@ -0,0 +1,79 @@
+"""Manager surface for the built-in multi-app DAG project."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from pydantic import ValidationError
+
+from agi_node.agi_dispatcher import BaseWorker, WorkDispatcher
+
+from .app_args import ArgsOverrides, MultiAppDagArgs, dump_args, ensure_defaults, load_args, merge_args
+from .preview_multi_app_dag import PROJECT_ROOT, build_preview, planning_repo_root
+
+
+class MultiAppDag(BaseWorker):
+    """Planning-only manager for built-in multi-app DAG templates."""
+
+    worker_vars: dict[str, Any] = {}
+
+    def __init__(
+        self,
+        env,
+        args: MultiAppDagArgs | None = None,
+        **kwargs: ArgsOverrides,
+    ) -> None:
+        self.env = env
+        self.verbose = int(kwargs.pop("verbose", getattr(env, "verbose", 0) or 0))
+        if args is None:
+            try:
+                args = MultiAppDagArgs(**kwargs)
+            except ValidationError as exc:
+                raise ValueError(f"Invalid Multi-app DAG arguments: {exc}") from exc
+        self.args = ensure_defaults(args, env=env)
+    @classmethod
+    def from_toml(
+        cls,
+        env,
+        settings_path: str | Path = "app_settings.toml",
+        section: str = "args",
+        **overrides: ArgsOverrides,
+    ) -> "MultiAppDag":
+        base = load_args(settings_path, section=section)
+        merged = ensure_defaults(merge_args(base, overrides or None), env=env)
+        return cls(env, args=merged)
+
+    def to_toml(
+        self,
+        settings_path: str | Path = "app_settings.toml",
+        section: str = "args",
+        create_missing: bool = True,
+    ) -> None:
+        dump_args(self.args, settings_path, section=section, create_missing=create_missing)
+
+    def preview(self) -> dict[str, Any]:
+        dag_path = self.args.dag_path.expanduser()
+        if not dag_path.is_absolute():
+            dag_path = PROJECT_ROOT / dag_path
+        return build_preview(
+            repo_root=planning_repo_root(None),
+            dag_path=dag_path,
+            output_path=self.args.output_path.expanduser(),
+        )
+
+    def as_dict(self) -> dict[str, Any]:
+        return self.args.model_dump(mode="json")
+
+    def build_distribution(self, _workers: dict | None = None):
+        return [], [], "stage", "weight", ""
+
+    def stop(self) -> None:
+        super().stop()
+
+
+class MultiAppDagApp(MultiAppDag):
+    """Compatibility alias retaining the app suffix."""
+
+
+__all__ = ["MultiAppDag", "MultiAppDagApp"]

agi_app_multi_dag-2026.5.30/src/agi_app_multi_dag/project/multi_app_dag_project/src/multi_app_dag/multi_app_dag_args.py

@@ -0,0 +1,23 @@
+"""Compatibility import surface for the PROJECT page argument editor."""
+
+from .app_args import (
+    ArgsModel,
+    ArgsOverrides,
+    MultiAppDagArgs,
+    MultiAppDagArgsTD,
+    dump_args,
+    ensure_defaults,
+    load_args,
+    merge_args,
+)
+
+__all__ = [
+    "ArgsModel",
+    "ArgsOverrides",
+    "MultiAppDagArgs",
+    "MultiAppDagArgsTD",
+    "dump_args",
+    "ensure_defaults",
+    "load_args",
+    "merge_args",
+]

agi_app_multi_dag-2026.5.30/src/agi_app_multi_dag/project/multi_app_dag_project/src/multi_app_dag/preview_multi_app_dag.py

@@ -0,0 +1,213 @@
+"""Read-only preview for the built-in multi-app DAG project."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import shutil
+import sys
+from pathlib import Path
+from typing import Any, Sequence
+
+
+def _repo_root_from_file() -> Path | None:
+    for parent in Path(__file__).resolve().parents:
+        if (parent / "src" / "agilab" / "apps" / "builtin").is_dir():
+            return parent
+    return None
+
+
+_SOURCE_ROOT = _repo_root_from_file()
+if _SOURCE_ROOT is not None:
+    source_path = str(_SOURCE_ROOT / "src")
+    if source_path not in sys.path:
+        sys.path.insert(0, source_path)
+
+from agilab.global_pipeline_execution_plan import build_execution_plan
+from agilab.global_pipeline_runner_state import dispatch_next_runnable, persist_runner_state
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[2]
+DAG_PATH = PROJECT_ROOT / "dag_templates" / "flight_to_weather_legacy_multi_app_dag.json"
+DEFAULT_OUTPUT_PATH = Path.home() / "log" / "execute" / "multi_app_dag" / "runner_state.json"
+RUN_ID = "multi-app-dag-preview"
+
+
+def agilab_package_path() -> Path:
+    marker = Path.home() / ".local/share/agilab/.agilab-path"
+    if not marker.is_file():
+        raise SystemExit(
+            "AGILAB is not initialized. Run the AGILAB installer or "
+            "`agilab first-proof --json` before this example."
+        )
+    path = Path(marker.read_text(encoding="utf-8").strip()).expanduser()
+    if not path.is_dir():
+        raise SystemExit(f"AGILAB package path from {marker} does not exist: {path}")
+    return path
+
+
+def _source_checkout_root_from_package(package_path: Path) -> Path | None:
+    parents = package_path.parents
+    if len(parents) < 2:
+        return None
+    repo_root = parents[1]
+    if (repo_root / "src" / "agilab" / "apps" / "builtin").is_dir():
+        return repo_root
+    return None
+
+
+def _ensure_packaged_layout_adapter(package_path: Path) -> Path:
+    apps_path = package_path / "apps"
+    if not (apps_path / "builtin").is_dir():
+        raise SystemExit(f"AGILAB built-in apps are not available under {apps_path}")
+
+    repo_root = Path.home() / ".cache" / "agilab" / "multi_app_dag_layout"
+    adapter_package = repo_root / "src" / "agilab"
+    adapter_apps = adapter_package / "apps"
+    adapter_package.mkdir(parents=True, exist_ok=True)
+
+    if adapter_apps.is_symlink() and adapter_apps.resolve() != apps_path.resolve():
+        adapter_apps.unlink()
+    if not adapter_apps.exists():
+        try:
+            adapter_apps.symlink_to(apps_path, target_is_directory=True)
+        except OSError:
+            shutil.copytree(apps_path, adapter_apps, dirs_exist_ok=True)
+    if not (repo_root / "src" / "agilab" / "apps" / "builtin").is_dir():
+        raise SystemExit(f"Could not prepare a planning layout under {repo_root}")
+    return repo_root
+
+
+def planning_repo_root(explicit_repo_root: Path | None = None) -> Path:
+    if explicit_repo_root is not None:
+        return explicit_repo_root.expanduser().resolve()
+    if _SOURCE_ROOT is not None:
+        return _SOURCE_ROOT.resolve()
+    package_path = agilab_package_path()
+    source_root = _source_checkout_root_from_package(package_path)
+    if source_root is not None:
+        return source_root.resolve()
+    return _ensure_packaged_layout_adapter(package_path).resolve()
+
+
+def _unit_preview(unit: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "id": unit["id"],
+        "app": unit["app"],
+        "dispatch_status": "runnable" if unit.get("ready") is True else "blocked",
+        "depends_on": list(unit.get("depends_on", [])),
+        "produces": [
+            artifact["artifact"]
+            for artifact in unit.get("produces", [])
+            if isinstance(artifact, dict) and artifact.get("artifact")
+        ],
+    }
+
+
+def _artifact_handoffs(units: Sequence[dict[str, Any]]) -> list[dict[str, str]]:
+    handoffs: list[dict[str, str]] = []
+    units_by_id = {str(unit.get("id", "")): unit for unit in units}
+    for unit in units:
+        for dependency in unit.get("artifact_dependencies", []):
+            if not isinstance(dependency, dict):
+                continue
+            source_id = str(dependency.get("from", ""))
+            source_unit = units_by_id.get(source_id, {})
+            handoffs.append(
+                {
+                    "artifact": str(dependency.get("artifact", "")),
+                    "from": source_id,
+                    "from_app": str(dependency.get("from_app", "")),
+                    "source_path": str(dependency.get("source_path", "")),
+                    "to": str(unit.get("id", "")),
+                    "to_app": str(unit.get("app", "")),
+                    "handoff": str(dependency.get("handoff", "")),
+                    "producer_status": "runnable" if source_unit.get("ready") is True else "blocked",
+                }
+            )
+    return handoffs
+
+
+def build_preview(
+    *,
+    repo_root: Path,
+    dag_path: Path = DAG_PATH,
+    output_path: Path = DEFAULT_OUTPUT_PATH,
+    now: str = "2026-04-29T00:00:00Z",
+) -> dict[str, Any]:
+    plan = build_execution_plan(repo_root=repo_root, dag_path=dag_path)
+    proof = persist_runner_state(
+        repo_root=repo_root,
+        dag_path=dag_path,
+        output_path=output_path,
+        run_id=RUN_ID,
+        now=now,
+    )
+    dispatch = dispatch_next_runnable(proof.runner_state, now=now)
+    units = list(plan.runnable_units)
+
+    return {
+        "example": "multi_app_dag_project",
+        "goal": "Preview a built-in multi-app DAG that coordinates multiple AGILAB apps through artifact contracts.",
+        "dag": {
+            "path": plan.dag_path,
+            "ok": plan.ok,
+            "issues": [issue.as_dict() for issue in plan.issues],
+            "execution_order": list(plan.execution_order),
+        },
+        "units": [_unit_preview(unit) for unit in units],
+        "artifact_handoffs": _artifact_handoffs(units),
+        "runner_state": {
+            "path": proof.path,
+            "round_trip_ok": proof.round_trip_ok,
+            "run_status": proof.runner_state["run_status"],
+            "summary": proof.runner_state["summary"],
+        },
+        "after_first_dispatch": {
+            "ok": dispatch.ok,
+            "dispatched_unit_id": dispatch.dispatched_unit_id,
+            "run_status": dispatch.state["run_status"],
+            "summary": dispatch.state["summary"],
+        },
+        "real_app_execution": False,
+    }
+
+
+def _parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Preview the built-in AGILAB multi-app DAG without executing app stages."
+    )
+    parser.add_argument(
+        "--repo-root",
+        type=Path,
+        default=None,
+        help="Optional source checkout root. If omitted, the preview uses the local source layout or AGILAB marker.",
+    )
+    parser.add_argument(
+        "--dag-path",
+        type=Path,
+        default=DAG_PATH,
+        help="Path to an agilab.multi_app_dag.v1 JSON contract.",
+    )
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=DEFAULT_OUTPUT_PATH,
+        help="Where to write the read-only runner-state preview JSON.",
+    )
+    return parser.parse_args(argv)
+
+
+def main(argv: Sequence[str] | None = None) -> dict[str, Any]:
+    args = _parse_args(argv)
+    summary = build_preview(
+        repo_root=planning_repo_root(args.repo_root),
+        dag_path=args.dag_path.expanduser(),
+        output_path=args.output.expanduser(),
+    )
+    print(json.dumps(summary, indent=2, sort_keys=True))
+    return summary
+
+
+if __name__ == "__main__":
+    main()

agi_app_multi_dag-2026.5.30/src/agi_app_multi_dag/project/multi_app_dag_project/src/multi_app_dag_worker/__init__.py

@@ -0,0 +1,3 @@
+from .multi_app_dag_worker import MultiAppDagWorker
+
+__all__ = ["MultiAppDagWorker"]

agi_app_multi_dag-2026.5.30/src/agi_app_multi_dag/project/multi_app_dag_project/src/multi_app_dag_worker/multi_app_dag_worker.py

@@ -0,0 +1,9 @@
+"""No-op worker for the planning-only multi-app DAG project."""
+
+from agi_node.polars_worker.polars_worker import PolarsWorker
+
+
+class MultiAppDagWorker(PolarsWorker):
+    """Worker placeholder so the built-in project follows AGILAB app layout."""
+
+    pass

agi_app_multi_dag-2026.5.30/src/agi_app_multi_dag/project/multi_app_dag_project/src/multi_app_dag_worker/pyproject.toml

@@ -0,0 +1,9 @@
+[project]
+name = "multi_app_dag_worker"
+version = "2026.05.30"
+requires-python = ">=3.11"
+dependencies = ["agi-env>=2026.05.30", "agi-node>=2026.05.30", "polars>=1.35,<2"]
+
+[build-system]
+requires = ["setuptools", "cython"]
+build-backend = "setuptools.build_meta"

agi_app_multi_dag-2026.5.30/src/agi_app_multi_dag/project/multi_app_dag_project/src/pre_prompt.json

@@ -0,0 +1,10 @@
+[
+  {
+    "role": "system",
+    "content": "You are operating the Multi-app DAG AGILAB demo. Keep examples read-only unless the operator explicitly starts a controlled DAG run, and preserve explicit artifact handoff names when adapting the bundled template."
+  },
+  {
+    "role": "user",
+    "content": "Explain or adapt the multi-app DAG orchestration plan with explicit artifact contracts and do not imply apps have executed when only a preview was produced."
+  }
+]

agi_app_multi_dag-2026.5.30/src/agi_app_multi_dag.egg-info/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: agi-app-multi-dag
+Version: 2026.5.30
+Summary: AGILAB cross-app DAG preview showing artifact handoffs between demo projects
+Author: Jean-Pierre Morard
+Maintainer: Jean-Pierre Morard
+License-Expression: BSD-3-Clause
+Project-URL: Documentation, https://thalesgroup.github.io/agilab
+Project-URL: Source, https://github.com/ThalesGroup/agilab/tree/main/src/agilab/lib/agi-app-multi-dag
+Project-URL: Issues, https://github.com/ThalesGroup/agilab/issues
+Project-URL: Homepage, https://github.com/ThalesGroup/agilab
+Project-URL: Repository, https://github.com/ThalesGroup/agilab
+Project-URL: Discussions, https://github.com/ThalesGroup/agilab/discussions
+Project-URL: Changelog, https://github.com/ThalesGroup/agilab/releases
+Keywords: agilab,apps,reproducibility,workflow-orchestration
+Classifier: Intended Audience :: Developers
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: agi-core<2027.0,>=2026.05.13
+Dynamic: license-file
+
+# agi-app-multi-dag
+
+[![PyPI version](https://img.shields.io/pypi/v/agi-app-multi-dag.svg?cacheSeconds=300)](https://pypi.org/project/agi-app-multi-dag/)
+[![Python versions](https://img.shields.io/pypi/pyversions/agi-app-multi-dag.svg)](https://pypi.org/project/agi-app-multi-dag/)
+[![License: BSD 3-Clause](https://img.shields.io/pypi/l/agi-app-multi-dag)](https://opensource.org/licenses/BSD-3-Clause)
+
+`agi-app-multi-dag` publishes the `multi_app_dag_project` AGILAB app as a
+self-contained PyPI payload. It is a read-only workflow-contract example rather
+than a domain worker benchmark.
+
+## Purpose
+
+Use this package to understand how AGILAB can connect several app projects with
+explicit artifact handoffs. The bundled DAG shows a flight stage producing a
+summary artifact that a weather stage can consume.
+
+## Installed Project
+
+The distribution name is `agi-app-multi-dag`; the AGILAB project name is
+`multi_app_dag_project`. The package exposes both `multi_app_dag` and
+`multi_app_dag_project` through the `agilab.apps` entry point group, so
+`AgiEnv(app="multi_app_dag_project")` resolves the project without a monorepo
+checkout.
+
+## Install
+
+```bash
+pip install agi-app-multi-dag
+```
+
+Most users get this package through `agi-apps`, `agilab[ui]`, or
+`agilab[examples]`; direct installation is useful when validating one app
+package in isolation.
+
+## Run In AGILAB
+
+Select `multi_app_dag_project`, open `WORKFLOW`, choose the multi-app DAG template,
+and inspect the runner-state preview. This package is primarily for workflow
+review; use `flight_telemetry_project` or `weather_forecast_project` when you
+want to execute concrete worker code.
+
+## Expected Inputs
+
+The package ships a DAG template that names the producer and consumer projects.
+No private data, cluster, service mode, or live external service is required for
+the default preview.
+
+## Expected Outputs
+
+The preview writes a runner-state JSON file under the AGILAB execution logs and
+renders the runnable versus blocked stages. It does not create a domain reducer
+artifact because it demonstrates cross-app orchestration, not a worker merge.
+
+## Change One Thing
+
+Edit a handoff name in a copied DAG template and reload the preview. The blocked
+stage should make the missing artifact contract obvious before any downstream
+execution is attempted.
+
+## Scope
+
+This package teaches multi-app DAG contracts. It is not a scheduler replacement,
+an Airflow/Kubeflow clone, or a production workflow governance layer.

agi_app_multi_dag-2026.5.30/src/agi_app_multi_dag.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+src/agi_app_multi_dag/__init__.py
+src/agi_app_multi_dag.egg-info/PKG-INFO
+src/agi_app_multi_dag.egg-info/SOURCES.txt
+src/agi_app_multi_dag.egg-info/dependency_links.txt
+src/agi_app_multi_dag.egg-info/entry_points.txt
+src/agi_app_multi_dag.egg-info/requires.txt
+src/agi_app_multi_dag.egg-info/top_level.txt

agi_app_multi_dag-2026.5.30/src/agi_app_multi_dag.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agi_app_multi_dag-2026.5.30/src/agi_app_multi_dag.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[agilab.apps]
+multi_app_dag = agi_app_multi_dag:project_root
+multi_app_dag_project = agi_app_multi_dag:project_root

agi_app_multi_dag-2026.5.30/src/agi_app_multi_dag.egg-info/requires.txt

@@ -0,0 +1 @@
+agi-core<2027.0,>=2026.05.13

agi_app_multi_dag-2026.5.30/src/agi_app_multi_dag.egg-info/top_level.txt

@@ -0,0 +1 @@
+agi_app_multi_dag