project-workflow 0.9.0__tar.gz → 0.9.2__tar.gz

{project_workflow-0.9.0 → project_workflow-0.9.2}/CHANGELOG.md

@@ -4,6 +4,46 @@ All notable changes to this project are documented in this file.
 
 ## Unreleased
 
+## 0.9.2 - 2026-08-31
+
+### Added
+
+- Added public `project execution configure`, `status`, and `disable` commands so operators can
+  create and inspect exact host-neutral sealed authority without fabricating internal coordination
+  JSON or hashes. Successor envelopes retain previous controls and receipts.
+
+### Changed
+
+- Documented Codex installation as repository-local skills plus a package-owned ephemeral per-run
+  hook. A persistent marketplace-plugin listing is neither required nor treated as activation or
+  runtime proof.
+
+### Known proof boundary
+
+- Sealed runtime execution is certified for Codex only in this release. The Claude Code adapter and
+  managed assets remain packaged and fail closed, but no real authenticated Claude Code canary has
+  passed; this release makes no Claude runtime or dual-host certification claim.
+
+## 0.9.1 - 2026-08-29
+
+### Changed
+
+- Replaced the authored 25,583-line CLI monolith with cohesive, acyclic runtime domains, a bounded
+  compatibility facade, and one deterministic manifest-driven standalone runtime without changing
+  the public v0.9 command or schema contract.
+- Split the catch-all Doctor tests into product-boundary suites, centralized only shared fixtures,
+  and made locked Ruff, Ruff format, mypy, architecture, documentation, full-suite, and package
+  journey checks part of both CI and release validation.
+- Replaced the oversized README and stale release guidance with a small authority-led documentation
+  hierarchy covering architecture, use, contribution, maintenance, and release ownership.
+
+### Fixed
+
+- Kept a completed Task or Epic's retained verification campaign inspectable from terminal global
+  tracker state so Doctor and delivery projection do not lose exact-candidate proof after closeout.
+- Removed dead distribution globs and stale current-version guidance while retaining historical
+  workflow records, exact release artifacts, blocked proof obligations, and unique work.
+
 ## 0.9.0 - 2026-08-29
 
 ### Added

{project_workflow-0.9.0 → project_workflow-0.9.2}/MANIFEST.in

@@ -5,4 +5,4 @@ recursive-include scripts *.py
 recursive-include tests *.py
 recursive-include tests/fixtures *
 recursive-include evaluations/intent_integrity *.json *.md *.py
-recursive-include evaluations/coordination *.json *.md *.py
+recursive-include evaluations/coordination *.json *.md

project_workflow-0.9.2/PKG-INFO

@@ -0,0 +1,170 @@
+Metadata-Version: 2.4
+Name: project-workflow
+Version: 0.9.2
+Summary: Spec-driven development with GitHub Copilot, Claude Code, OpenAI Codex, and Cursor: workflow scaffolding, QA review, retro, and task management CLI
+Author-email: John Detlefs <john@example.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/johndetlefs/project-workflow
+Project-URL: Repository, https://github.com/johndetlefs/project-workflow.git
+Project-URL: Issues, https://github.com/johndetlefs/project-workflow/issues
+Keywords: workflow,spec-driven,ai,github-copilot,claude-code,codex,cursor,task-management
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: mypy>=1.15; extra == "dev"
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: ruff>=0.11; extra == "dev"
+Requires-Dist: setuptools>=65.0; extra == "dev"
+Dynamic: license-file
+
+# project-workflow
+
+Project Workflow is a repository-native delivery system for turning owner intent into planned,
+implemented, evidenced, reviewed work. Its state is plain Markdown and JSON beside the code, so
+people and coding agents can inspect the same requirements, status, decisions, and proof.
+
+Its repository guidance supports GitHub Copilot, Claude Code, OpenAI Codex, and Cursor. Sealed
+runtime enforcement has a narrower, versioned proof boundary: v0.9.2 is runtime-certified for
+Codex only. The packaged Claude Code adapter remains fail-closed and uncertified until its real
+authenticated host canary passes; Cursor and GitHub Copilot are not sealed-runtime targets. Project
+Workflow complements issue trackers, Git hosts, CI, registries, and deployment platforms; it does
+not replace their authority.
+
+## Quick Start
+
+From the root of an existing Git repository:
+
+```bash
+uvx --from project-workflow==0.9.2 project init --agent codex
+```
+
+Choose `github-copilot`, `claude-code`, `codex`, or `cursor` to match the agent that will operate
+the repository. For an existing installation, use upgrade—not init:
+
+```bash
+uvx --from project-workflow==0.9.2 project upgrade --agent codex
+```
+
+Then describe the outcome in ordinary language. The installed guidance routes it to the smallest
+sufficient record:
+
+| Route | Use it for | Durable record |
+| --- | --- | --- |
+| Backlog | Optional future intent not ready for execution | `BL-*` row in `BACKLOG.md` |
+| Fix | One bounded correction to a delivered or accepted baseline | `FIX-*` folder and global tracker row |
+| Task | One new independently reviewable outcome | `TASK-*` requirements and implementation |
+| Epic | Coordinated workstreams with shared parent outcomes | `EPIC-*` contract, decomposition, children, audit, and retro |
+
+An in-scope correction stays in its active work item. Completed history is not rewritten to make a
+later defect look original.
+
+## See What Is True
+
+Start with the read-only status projection:
+
+```bash
+./.project-workflow/cli/workflow status
+./.project-workflow/cli/workflow status --id TASK-001
+./.project-workflow/cli/workflow status --strict
+./.project-workflow/cli/workflow status --format json
+```
+
+Status reports sourced lifecycle, proof, blockers, delivery state, and the next safe action. It
+does not execute that action. Use Doctor for workflow diagnosis:
+
+```bash
+./.project-workflow/cli/workflow doctor
+./.project-workflow/cli/workflow doctor --strict
+```
+
+Tests, a passing Doctor, `Complete`, merge, release, deployment, adoption, and owner acceptance are
+separate evidence layers. Project Workflow reports the strongest layer actually proved.
+
+## How Work Moves
+
+The owner confirms the plain-language Intent and outcome boundary once. The Coordinator then plans,
+clarifies, implements, validates, and commissions QA autonomously inside that approved envelope.
+Material drift, missing authority, or a changed proof obligation returns to the owner.
+
+The normal Task path is:
+
+```text
+Analysing -> Ready -> In Progress -> Testing -> Review -> Complete
+```
+
+Epics use the same outcome discipline plus a contract, authoritative decomposition, child tracker,
+intent audit, parent acceptance map, closeout audit, and retro. Fixes stay deliberately lighter.
+
+For detailed commands and examples, read [Using Project Workflow](docs/using-project-workflow.md)
+or run `./.project-workflow/cli/workflow --help`.
+
+Approved material work can optionally use [Sealed Host Execution](docs/execution-control.md). Codex
+uses repository-local skills plus an ephemeral per-run hook; a permanent marketplace-plugin entry
+is neither required nor accepted as activation proof.
+
+## What Is Installed
+
+Initialization creates:
+
+- `.project-workflow/` configuration, manifest, backlog, trackers, tasks, guidance, and a
+  dependency-free local CLI;
+- host-specific agent guidance for the selected mode;
+- managed instruction blocks that point the agent at repository-local workflow truth.
+
+Tracked requirements, plans, approvals, evidence, and local guidance remain repository-owned.
+Managed helpers and installed host assets are generated derivatives; update their canonical source
+or use the supported generator/upgrade path instead of editing copies.
+
+See [Documentation and Source Authority](docs/authority.md) for the complete hierarchy and
+[Compatibility](COMPATIBILITY.md) for versioned repository support.
+
+## Contributing
+
+Project Workflow is one Python package, one public `project` command, and one generated
+dependency-free helper. Canonical runtime code is split by domain under `src/project_workflow/`;
+`src/project_workflow/templates/workflow.py` and `.project-workflow/cli/workflow.py` are generated.
+
+```bash
+uv sync --locked --extra dev
+uv run --locked ruff check src/project_workflow/*.py scripts tests
+uv run --locked ruff format --check src/project_workflow/*.py scripts tests
+uv run --locked mypy src/project_workflow/*.py
+PATH="/opt/homebrew/bin:$PATH" uv run --locked pytest -q
+```
+
+Read [Contributing](docs/contributing.md) before changing source and
+[Architecture](docs/architecture.md) before moving responsibilities. Maintainers should also read
+[Maintenance](docs/maintenance.md); public release authority is isolated in
+[RELEASING.md](RELEASING.md).
+
+## Documentation Map
+
+| Need | Authority |
+| --- | --- |
+| Product mission and stable outcomes | [Constitution](.project-workflow/CONSTITUTION.md) |
+| Repository operating rules | [AGENTS.md](AGENTS.md) and [local guidance](.project-workflow/guidance.md) |
+| Orientation and first commands | This README |
+| Work-item operation | [Using Project Workflow](docs/using-project-workflow.md) |
+| Codex-certified sealed execution and Claude Code limitations | [Sealed Host Execution](docs/execution-control.md) |
+| Source boundaries and generated ownership | [Architecture](docs/architecture.md) |
+| Development and validation | [Contributing](docs/contributing.md) |
+| Upgrade, hygiene, and generated assets | [Maintenance](docs/maintenance.md) |
+| Compatibility policy | [COMPATIBILITY.md](COMPATIBILITY.md) |
+| Public release procedure | [RELEASING.md](RELEASING.md) |
+| Current command syntax | `project --help` and the [local CLI guide](.project-workflow/cli/README.md) |
+
+Workflow task folders are durable state and audit history, not competing current product
+instructions.
+
+## License And Support
+
+Project Workflow is available under the [MIT License](LICENSE). Report defects and proposals through
+[GitHub Issues](https://github.com/johndetlefs/project-workflow/issues).

project_workflow-0.9.2/README.md

@@ -0,0 +1,143 @@
+# project-workflow
+
+Project Workflow is a repository-native delivery system for turning owner intent into planned,
+implemented, evidenced, reviewed work. Its state is plain Markdown and JSON beside the code, so
+people and coding agents can inspect the same requirements, status, decisions, and proof.
+
+Its repository guidance supports GitHub Copilot, Claude Code, OpenAI Codex, and Cursor. Sealed
+runtime enforcement has a narrower, versioned proof boundary: v0.9.2 is runtime-certified for
+Codex only. The packaged Claude Code adapter remains fail-closed and uncertified until its real
+authenticated host canary passes; Cursor and GitHub Copilot are not sealed-runtime targets. Project
+Workflow complements issue trackers, Git hosts, CI, registries, and deployment platforms; it does
+not replace their authority.
+
+## Quick Start
+
+From the root of an existing Git repository:
+
+```bash
+uvx --from project-workflow==0.9.2 project init --agent codex
+```
+
+Choose `github-copilot`, `claude-code`, `codex`, or `cursor` to match the agent that will operate
+the repository. For an existing installation, use upgrade—not init:
+
+```bash
+uvx --from project-workflow==0.9.2 project upgrade --agent codex
+```
+
+Then describe the outcome in ordinary language. The installed guidance routes it to the smallest
+sufficient record:
+
+| Route | Use it for | Durable record |
+| --- | --- | --- |
+| Backlog | Optional future intent not ready for execution | `BL-*` row in `BACKLOG.md` |
+| Fix | One bounded correction to a delivered or accepted baseline | `FIX-*` folder and global tracker row |
+| Task | One new independently reviewable outcome | `TASK-*` requirements and implementation |
+| Epic | Coordinated workstreams with shared parent outcomes | `EPIC-*` contract, decomposition, children, audit, and retro |
+
+An in-scope correction stays in its active work item. Completed history is not rewritten to make a
+later defect look original.
+
+## See What Is True
+
+Start with the read-only status projection:
+
+```bash
+./.project-workflow/cli/workflow status
+./.project-workflow/cli/workflow status --id TASK-001
+./.project-workflow/cli/workflow status --strict
+./.project-workflow/cli/workflow status --format json
+```
+
+Status reports sourced lifecycle, proof, blockers, delivery state, and the next safe action. It
+does not execute that action. Use Doctor for workflow diagnosis:
+
+```bash
+./.project-workflow/cli/workflow doctor
+./.project-workflow/cli/workflow doctor --strict
+```
+
+Tests, a passing Doctor, `Complete`, merge, release, deployment, adoption, and owner acceptance are
+separate evidence layers. Project Workflow reports the strongest layer actually proved.
+
+## How Work Moves
+
+The owner confirms the plain-language Intent and outcome boundary once. The Coordinator then plans,
+clarifies, implements, validates, and commissions QA autonomously inside that approved envelope.
+Material drift, missing authority, or a changed proof obligation returns to the owner.
+
+The normal Task path is:
+
+```text
+Analysing -> Ready -> In Progress -> Testing -> Review -> Complete
+```
+
+Epics use the same outcome discipline plus a contract, authoritative decomposition, child tracker,
+intent audit, parent acceptance map, closeout audit, and retro. Fixes stay deliberately lighter.
+
+For detailed commands and examples, read [Using Project Workflow](docs/using-project-workflow.md)
+or run `./.project-workflow/cli/workflow --help`.
+
+Approved material work can optionally use [Sealed Host Execution](docs/execution-control.md). Codex
+uses repository-local skills plus an ephemeral per-run hook; a permanent marketplace-plugin entry
+is neither required nor accepted as activation proof.
+
+## What Is Installed
+
+Initialization creates:
+
+- `.project-workflow/` configuration, manifest, backlog, trackers, tasks, guidance, and a
+  dependency-free local CLI;
+- host-specific agent guidance for the selected mode;
+- managed instruction blocks that point the agent at repository-local workflow truth.
+
+Tracked requirements, plans, approvals, evidence, and local guidance remain repository-owned.
+Managed helpers and installed host assets are generated derivatives; update their canonical source
+or use the supported generator/upgrade path instead of editing copies.
+
+See [Documentation and Source Authority](docs/authority.md) for the complete hierarchy and
+[Compatibility](COMPATIBILITY.md) for versioned repository support.
+
+## Contributing
+
+Project Workflow is one Python package, one public `project` command, and one generated
+dependency-free helper. Canonical runtime code is split by domain under `src/project_workflow/`;
+`src/project_workflow/templates/workflow.py` and `.project-workflow/cli/workflow.py` are generated.
+
+```bash
+uv sync --locked --extra dev
+uv run --locked ruff check src/project_workflow/*.py scripts tests
+uv run --locked ruff format --check src/project_workflow/*.py scripts tests
+uv run --locked mypy src/project_workflow/*.py
+PATH="/opt/homebrew/bin:$PATH" uv run --locked pytest -q
+```
+
+Read [Contributing](docs/contributing.md) before changing source and
+[Architecture](docs/architecture.md) before moving responsibilities. Maintainers should also read
+[Maintenance](docs/maintenance.md); public release authority is isolated in
+[RELEASING.md](RELEASING.md).
+
+## Documentation Map
+
+| Need | Authority |
+| --- | --- |
+| Product mission and stable outcomes | [Constitution](.project-workflow/CONSTITUTION.md) |
+| Repository operating rules | [AGENTS.md](AGENTS.md) and [local guidance](.project-workflow/guidance.md) |
+| Orientation and first commands | This README |
+| Work-item operation | [Using Project Workflow](docs/using-project-workflow.md) |
+| Codex-certified sealed execution and Claude Code limitations | [Sealed Host Execution](docs/execution-control.md) |
+| Source boundaries and generated ownership | [Architecture](docs/architecture.md) |
+| Development and validation | [Contributing](docs/contributing.md) |
+| Upgrade, hygiene, and generated assets | [Maintenance](docs/maintenance.md) |
+| Compatibility policy | [COMPATIBILITY.md](COMPATIBILITY.md) |
+| Public release procedure | [RELEASING.md](RELEASING.md) |
+| Current command syntax | `project --help` and the [local CLI guide](.project-workflow/cli/README.md) |
+
+Workflow task folders are durable state and audit history, not competing current product
+instructions.
+
+## License And Support
+
+Project Workflow is available under the [MIT License](LICENSE). Report defects and proposals through
+[GitHub Issues](https://github.com/johndetlefs/project-workflow/issues).

{project_workflow-0.9.0 → project_workflow-0.9.2}/pyproject.toml

@@ -30,7 +30,9 @@ Issues = "https://github.com/johndetlefs/project-workflow/issues"
 [project.optional-dependencies]
 dev = [
     "build>=1.2",
+    "mypy>=1.15",
     "pytest>=7.0",
+    "ruff>=0.11",
     "setuptools>=65.0",
 ]
 
@@ -64,15 +66,14 @@ project_workflow = [
     "cursor/rules/*.mdc",
 ]
 
-[tool.black]
-line-length = 100
-target-version = ["py310"]
-
 [tool.ruff]
 line-length = 100
 target-version = "py310"
 
 [tool.ruff.lint]
+ignore = [
+    "E501",  # The formatter is the line-layout authority; exact fixture strings may exceed it.
+]
 select = [
     "E",    # pycodestyle errors
     "W",    # pycodestyle warnings
@@ -86,6 +87,7 @@ python_version = "3.10"
 warn_return_any = true
 warn_unused_configs = true
 disallow_untyped_defs = false
+exclude = ["src/project_workflow/templates/"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

project_workflow-0.9.2/scripts/build_runtime_bundle.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+"""Build the dependency-free repository-local workflow runtime deterministically."""
+
+from __future__ import annotations
+
+import argparse
+import ast
+import hashlib
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+MANIFEST = ROOT / "scripts/runtime-modules.txt"
+TEMPLATE = ROOT / "src/project_workflow/templates/workflow.py"
+SOURCE_MIRROR = ROOT / ".project-workflow/cli/workflow.py"
+GENERATED_MARKER = "# project-workflow:generated"
+PROVENANCE = "# source-manifest: scripts/runtime-modules.txt"
+
+
+def manifest_paths() -> tuple[Path, ...]:
+    entries = []
+    for raw in MANIFEST.read_text(encoding="utf-8").splitlines():
+        value = raw.strip()
+        if not value or value.startswith("#"):
+            continue
+        path = ROOT / value
+        if not path.is_file():
+            raise ValueError(f"Runtime manifest entry does not exist: {value}")
+        entries.append(path)
+    if not entries:
+        raise ValueError("Runtime manifest must contain at least one source module.")
+    return tuple(entries)
+
+
+def _top_level_removals(source: str) -> set[int]:
+    tree = ast.parse(source)
+    removals: set[int] = set()
+    for index, node in enumerate(tree.body):
+        remove = False
+        if (
+            index == 0
+            and isinstance(node, ast.Expr)
+            and isinstance(node.value, ast.Constant)
+            and isinstance(node.value.value, str)
+        ):
+            remove = True
+        elif isinstance(node, ast.ImportFrom) and node.module == "__future__":
+            remove = True
+        elif isinstance(node, ast.ImportFrom) and (
+            node.level > 0 or (node.module or "").startswith("project_workflow")
+        ):
+            remove = True
+        if remove:
+            removals.update(range(node.lineno, node.end_lineno + 1))
+    return removals
+
+
+def canonical_module_text(path: Path) -> str:
+    source = path.read_text(encoding="utf-8")
+    removals = _top_level_removals(source)
+    lines = source.splitlines()
+    kept = [
+        line
+        for number, line in enumerate(lines, start=1)
+        if number not in removals and not (number == 1 and line.startswith("#!"))
+    ]
+    while kept and not kept[0].strip():
+        kept.pop(0)
+    while kept and not kept[-1].strip():
+        kept.pop()
+    return "\n".join(kept) + "\n"
+
+
+def build_bundle() -> str:
+    paths = manifest_paths()
+    manifest_hash = hashlib.sha256(MANIFEST.read_bytes()).hexdigest()
+    sections = [
+        "#!/usr/bin/env python3\n",
+        '"""Generated dependency-free Project Workflow runtime. Do not edit directly."""\n',
+        "from __future__ import annotations\n\n",
+        f"{GENERATED_MARKER}\n",
+        f"{PROVENANCE}\n",
+        f"# manifest-sha256: {manifest_hash}\n\n",
+    ]
+    for path in paths:
+        relative = path.relative_to(ROOT).as_posix()
+        sections.append(f"# --- begin {relative} ---\n")
+        sections.append(canonical_module_text(path))
+        sections.append(f"# --- end {relative} ---\n\n")
+    return "".join(sections).rstrip("\n") + "\n"
+
+
+def expected_outputs() -> tuple[Path, Path]:
+    return TEMPLATE, SOURCE_MIRROR
+
+
+def check() -> int:
+    expected = build_bundle()
+    stale = [
+        path.relative_to(ROOT).as_posix()
+        for path in expected_outputs()
+        if not path.is_file() or path.read_text(encoding="utf-8") != expected
+    ]
+    if stale:
+        print("Generated runtime is stale:")
+        for path in stale:
+            print(f"- {path}")
+        return 1
+    print("Generated runtime is current.")
+    return 0
+
+
+def write() -> int:
+    content = build_bundle()
+    for path in expected_outputs():
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(content, encoding="utf-8")
+    SOURCE_MIRROR.chmod(SOURCE_MIRROR.stat().st_mode | 0o111)
+    print(f"Wrote {TEMPLATE.relative_to(ROOT)}")
+    print(f"Wrote {SOURCE_MIRROR.relative_to(ROOT)}")
+    return 0
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    mode = parser.add_mutually_exclusive_group(required=True)
+    mode.add_argument("--check", action="store_true")
+    mode.add_argument("--write", action="store_true")
+    args = parser.parse_args()
+    return check() if args.check else write()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

project_workflow-0.9.2/scripts/capture_architecture_snapshot.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+"""Capture canonical module and adapter ownership evidence as deterministic JSON."""
+
+from __future__ import annotations
+
+import argparse
+import ast
+import hashlib
+import json
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+MANIFEST = ROOT / "scripts/runtime-modules.txt"
+
+
+def sha256(path: Path) -> str:
+    return "sha256:" + hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def runtime_paths() -> list[Path]:
+    return [
+        ROOT / line.strip()
+        for line in MANIFEST.read_text(encoding="utf-8").splitlines()
+        if line.strip() and not line.lstrip().startswith("#")
+    ]
+
+
+def internal_dependencies(path: Path, names: set[str]) -> list[str]:
+    dependencies: set[str] = set()
+    for node in ast.walk(ast.parse(path.read_text(encoding="utf-8"))):
+        if isinstance(node, ast.ImportFrom):
+            if node.level and node.module:
+                dependency = node.module.split(".", 1)[0]
+                if dependency in names:
+                    dependencies.add(dependency)
+            elif (node.module or "").startswith("project_workflow."):
+                dependency = (node.module or "").split(".")[1]
+                if dependency in names:
+                    dependencies.add(dependency)
+        elif isinstance(node, ast.Import):
+            for alias in node.names:
+                if alias.name.startswith("project_workflow."):
+                    dependency = alias.name.split(".")[1]
+                    if dependency in names:
+                        dependencies.add(dependency)
+    return sorted(dependencies)
+
+
+def top_level_definitions(path: Path) -> list[str]:
+    return sorted(
+        node.name
+        for node in ast.parse(path.read_text(encoding="utf-8")).body
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef))
+    )
+
+
+def adapter_common_imports(path: Path) -> list[str]:
+    imported = []
+    for node in ast.walk(ast.parse(path.read_text(encoding="utf-8"))):
+        if isinstance(node, ast.ImportFrom) and (node.module or "").endswith("adapter_common"):
+            imported.extend(alias.name for alias in node.names)
+    return sorted(set(imported))
+
+
+def payload() -> dict[str, object]:
+    paths = runtime_paths()
+    names = {path.stem for path in paths}
+    order = {path.stem: index for index, path in enumerate(paths)}
+    modules = []
+    definition_owners: dict[str, list[str]] = {}
+    for path in paths:
+        definitions = top_level_definitions(path)
+        for name in definitions:
+            definition_owners.setdefault(name, []).append(path.stem)
+        dependencies = internal_dependencies(path, names)
+        modules.append(
+            {
+                "name": path.stem,
+                "path": path.relative_to(ROOT).as_posix(),
+                "line_count": len(path.read_text(encoding="utf-8").splitlines()),
+                "top_level_definition_count": len(definitions),
+                "dependencies": dependencies,
+                "dependencies_precede_module": all(
+                    order[dependency] < order[path.stem] for dependency in dependencies
+                ),
+                "sha256": sha256(path),
+            }
+        )
+    duplicates = {name: owners for name, owners in definition_owners.items() if len(owners) > 1}
+    package = ROOT / "src/project_workflow"
+    common = package / "adapter_common.py"
+    codex = package / "codex_adapter.py"
+    claude = package / "claude_adapter.py"
+    template = package / "templates/workflow.py"
+    helper = ROOT / ".project-workflow/cli/workflow.py"
+    adapter_records = []
+    for path in (common, codex, claude):
+        installed = ROOT / ".project-workflow/cli" / path.name
+        adapter_records.append(
+            {
+                "name": path.stem,
+                "line_count": len(path.read_text(encoding="utf-8").splitlines()),
+                "sha256": sha256(path),
+                "installed_sha256": sha256(installed),
+                "installed_matches_source": path.read_bytes() == installed.read_bytes(),
+                "common_imports": adapter_common_imports(path),
+            }
+        )
+    return {
+        "schema_version": 1,
+        "runtime_manifest": MANIFEST.relative_to(ROOT).as_posix(),
+        "runtime_module_count": len(modules),
+        "runtime_modules": modules,
+        "duplicate_top_level_definitions": duplicates,
+        "dependency_order_valid": all(record["dependencies_precede_module"] for record in modules),
+        "entry_module_under_2000_lines": modules[-1]["line_count"] < 2_000,
+        "domain_modules_under_5000_lines": all(
+            record["line_count"] < 5_000 for record in modules[:-1]
+        ),
+        "generated_runtime": {
+            "template_sha256": sha256(template),
+            "installed_helper_sha256": sha256(helper),
+            "byte_identical": template.read_bytes() == helper.read_bytes(),
+        },
+        "adapters": adapter_records,
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--output", type=Path, required=True)
+    args = parser.parse_args()
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(
+        json.dumps(payload(), indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+    print(args.output)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())