@@ -1396,6 +1396,7 @@ Every `--json` invocation emits a single JSON object that follows the **unified
 | `redirect_vlt_lock_unsupported` | `redirect.warnings[]` (warning) | scan/get `--mode hosted` (vlt): `vlt-lock.json` has a `lockfileVersion` other than absent, `0` or `1` (decided on the raw JSON token), is not a JSON object, starts with a UTF-8 BOM, or its `nodes` section is not vlt's one-node-per-line layout. Nothing rewritten; also refuses a vendored → hosted takeover of a `flavor: "vlt"` entry before its revert (`redirect.skipped[].reason`). Exit 0. |
 | `redirect_takeover_kept_vendored` | `redirect.warnings[]` (warning) | scan/get `--mode hosted`: a vendored → hosted takeover the hosted rewrite would not pin was retracted (see **Staged takeover**): the package keeps its vendored wiring, ledger entry and artifact byte-identical and stays patched. The detail names the cause code, which is also the purl's `redirect.skipped[].reason`. Exit 0. Replaces v5.0-pre `redirect_takeover_unpatched`, which reported a package left unpatched in both modes and is no longer emitted. |
 | `redirect_takeover_not_pinned` | `redirect.skipped[].reason` | scan/get `--mode hosted`: the skip reason of a retracted takeover when no rewriter warning names the cause. |
+| `redirect_hatch_lock_regenerated` | `redirect.warnings[]` (warning) | scan/get `--mode hosted` (pypi / Hatch 1.17+): the project's Hatch environments are locked (`lock-envs = true`, an environment's `locked = true` or `lock-filename`), so its `pylock*.toml` is derived from pyproject and Hatch regenerates it on the next sync. The package is wired in the Hatch declarations as well as in the lock (rewriting only the lock was discarded by Hatch, #479); run `hatch dep lock` to refresh the lock (`hatch dep lock --check` reports it stale until then). Vendored routes such a project to the Hatch lane and its pip-installer refusal. |
 | `redirect_requirements_takeover_unreachable` | `redirect.warnings[]` (warning) | scan/get `--mode hosted` (pypi / requirements.txt): a vendored → hosted takeover of a package that vendored mode wired through a pin in a `-r` include, or through a `(transitive)` line it appended to the root `requirements.txt`. Hosted mode only rewrites an existing pin in the root `requirements.txt`, so the staged takeover is retracted (wet and `--dry-run`): the vendored wiring, ledger entry and wheel stay byte-identical, the purl is skipped with this code as `redirect.skipped[].reason`, and nothing is redirected for it. Exit 0. The detail names the remedy and its reach: run `socket-patch vendor --revert` (it reverts EVERY vendored package in the project, not just this one), move the pin from the include into the root `requirements.txt` and delete it from the include (or, for a `(transitive)` line, add an exact `==` pin to the root file), then re-run `scan --mode hosted`. |
 | `redirect_uv_takeover_version_unreachable` | `redirect.warnings[]` (warning) | scan/get `--mode hosted` (pypi / uv): a vendored → hosted takeover of a package whose recorded pre-vendor `uv.lock` entry is at another version than the patch (vendored uv pins the lock entry down to the patch's version, for example when the lock resolved a newer release). Reverting would bring the lock's own version back, and hosted mode only pins the version the lock resolves, so the staged takeover is retracted (wet and `--dry-run`): the vendored wiring, ledger entry and wheel stay byte-identical, the purl is skipped with this code as `redirect.skipped[].reason`, and nothing is redirected for it. Exit 0. The detail names the remedy and its reach: run `socket-patch vendor --revert` (it reverts EVERY vendored package in the project, not just this one), make the project resolve the patch's version (for example an exact `==` requirement) and re-lock, then re-run `scan --mode hosted`. |
 | `redirect_vlt_missing_sha512` / `redirect_vlt_entry_not_found` / `redirect_vlt_entry_vendored` / `redirect_vlt_unsupported_lock_key` | `redirect.warnings[]` (warning) | scan/get `--mode hosted` (vlt): the grant has no sha512 / the lock has no default-registry node for `name@version` / the only match is a vendored `file` node under `.socket/vendor/npm/<uuid>/` / a default-registry instance is outside vlt's node-line grammar or still unpatched after the splice. Per dep; none of the dep's instances is written. `redirect_vlt_missing_sha512` and `redirect_vlt_unsupported_lock_key` refuse the dep: it is never confirmed, whichever lock drives (a sibling lock may still carry its rewritten URL). `redirect_vlt_entry_not_found` and `redirect_vlt_entry_vendored` only say `vlt-lock.json` does not wire it: while vlt drives it is not confirmed; otherwise a sibling lock's rules may confirm it. Exit 0. |
 
@@ -2002,3 +2002,61 @@ async fn pipenv_hosted_to_vendored_names_the_unpatched_requirements() {
         "the takeover names requirements.txt as an unpatched install source: {env:#}"
     );
 }
+
+// ── #479: a Hatch-derived pylock.toml ────────────────────────────────────
+
+/// The pylock `hatch lock` writes for a locked environment (uv locker),
+/// pinning six from PyPI.
+const HATCH_PYLOCK: &str = "lock-version = \"1.0\"\ncreated-by = \"uv\"\nrequires-python = \">=3.9\"\n\n[[packages]]\nname = \"six\"\nversion = \"1.16.0\"\nindex = \"https://pypi.org/simple\"\nsdist = { url = \"https://files.pythonhosted.org/packages/71/39/six-1.16.0.tar.gz\", upload-time = 2021-05-05T14:18:18Z, size = 34041, hashes = { sha256 = \"SDIST_SHA\" } }\nwheels = [{ url = \"https://files.pythonhosted.org/packages/d9/5a/six-1.16.0-py2.py3-none-any.whl\", upload-time = 2021-05-05T14:18:17Z, size = 11053, hashes = { sha256 = \"WHEEL_SHA\" } }]\n";
+
+const HATCH_LOCKED_PYPROJECT: &str = "[build-system]\nrequires = [\"hatchling\"]\nbuild-backend = \"hatchling.build\"\n\n[project]\nname = \"app\"\nversion = \"0.1.0\"\ndependencies = [\"six==1.16.0\"]\n\n[tool.hatch.envs.default]\nlocked = true\ninstaller = \"uv\"\n";
+
+/// #479: Hatch 1.17+ derives `pylock.toml` from pyproject for a locked
+/// environment and regenerates it on the next sync, so a scan that rewrote
+/// only the lock (success, no warning) never patched a Hatch environment.
+/// Hosted must wire pyproject too (with a warning to re-lock); vendored must route to the Hatch lane,
+/// whose uv-installer refusal applies, and write nothing.
+#[tokio::test]
+async fn hatch_locked_env_pylock_wires_pyproject() {
+    let pylock = HATCH_PYLOCK
+        .replace("SDIST_SHA", SDIST_SHA)
+        .replace("WHEEL_SHA", WHEEL_SHA);
+    let server = MockServer::start().await;
+    let hosted_url = mount_hosted_api(&server, true).await;
+
+    let (_tmp, root) = project();
+    std::fs::write(root.join("pyproject.toml"), HATCH_LOCKED_PYPROJECT).unwrap();
+    std::fs::write(root.join("pylock.toml"), &pylock).unwrap();
+    let (code, env) = hosted_scan(&root, &server);
+    assert_eq!(code, 0, "hosted: {env:#}");
+    assert_eq!(env["redirect"]["redirected"], 1, "{env:#}");
+    let pyproject = std::fs::read_to_string(root.join("pyproject.toml")).unwrap();
+    assert!(
+        pyproject.contains(&format!("six @ {hosted_url}")),
+        "pyproject is wired:\n{pyproject}"
+    );
+    let lock = std::fs::read_to_string(root.join("pylock.toml")).unwrap();
+    assert!(
+        lock.contains(&hosted_url),
+        "the lock stays consistent with pyproject until Hatch regenerates it:\n{lock}"
+    );
+    assert!(
+        env.to_string().contains("redirect_hatch_lock_regenerated"),
+        "{env:#}"
+    );
+    let (_tmp, root) = project();
+    std::fs::write(root.join("pyproject.toml"), HATCH_LOCKED_PYPROJECT).unwrap();
+    std::fs::write(root.join("pylock.toml"), &pylock).unwrap();
+    stage_manifest(&root);
+    let (code, env) = run_cli(&root, &["vendor"], &[]);
+    assert_ne!(code, 0, "vendored: {env:#}");
+    assert!(env.to_string().contains("pip installer"), "{env:#}");
+    assert_eq!(
+        std::fs::read_to_string(root.join("pyproject.toml")).unwrap(),
+        HATCH_LOCKED_PYPROJECT
+    );
+    assert_eq!(
+        std::fs::read_to_string(root.join("pylock.toml")).unwrap(),
+        pylock
+    );
+}
@@ -1021,14 +1021,25 @@ fn rewrite_hatch(
             .filter(|dep| dep.ecosystem == "pypi")
             .map(|dep| dep.patch_uuid.clone()),
     );
+    // A pylock Hatch derives from pyproject (locked environments, #479) is
+    // not an install source of its own: Hatch regenerates it from the
+    // pyproject, so this lane wires pyproject too (the python-lock lane
+    // still rewrites the lock, keeping the two consistent until Hatch
+    // regenerates it from the wired pyproject).
     if files.keys().any(|file| {
         matches!(
             file.as_str(),
             "uv.lock" | "poetry.lock" | "pdm.lock" | "Pipfile.lock"
-        ) || crate::utils::python_lock::is_python_lock_name(file)
+        ) || (crate::utils::python_lock::is_python_lock_name(file)
+            && !crate::utils::hatch::is_hatch_lock(files, file))
     }) {
         return;
     }
+    let hatch_locks: Vec<&str> = files
+        .keys()
+        .filter(|file| crate::utils::hatch::is_hatch_lock(files, file))
+        .map(String::as_str)
+        .collect();
     if files.contains_key("requirements.txt") {
         result
             .confirmed_hatch_uuids
@@ -1058,6 +1069,20 @@ fn rewrite_hatch(
         match crate::utils::hatch::rewrite(&current, &dep.name, &dep.version, &url) {
             Ok(edits) => {
                 result.confirmed_hatch_uuids.insert(dep.patch_uuid.clone());
+                if !edits.is_empty() && !hatch_locks.is_empty() {
+                    result.warnings.push(RewriteWarning {
+                        code: "redirect_hatch_lock_regenerated".into(),
+                        detail: format!(
+                            "{}@{}: wired in the Hatch configuration as well as in {}, which \
+                             Hatch derives from it (locked environments) and regenerates on \
+                             the next environment sync; run `hatch dep lock` to refresh it \
+                             now (`hatch dep lock --check` reports it stale until then)",
+                            dep.name,
+                            dep.version,
+                            hatch_locks.join(", ")
+                        ),
+                    });
+                }
                 for (path, new) in edits {
                     result.edits.push(FileEdit {
                         path: path.clone(),
@@ -23686,6 +23711,77 @@ mod hatch_tests {
         }
     }
 
+    /// The pylock `hatch lock` (Hatch 1.17+, `created-by = "uv"`) writes for
+    /// a locked environment, pinning urllib3 from PyPI.
+    const HATCH_PYLOCK: &str = "lock-version = \"1.0\"\ncreated-by = \"uv\"\nrequires-python = \">=3.9\"\n\n[[packages]]\nname = \"urllib3\"\nversion = \"1.26.18\"\nindex = \"https://pypi.org/simple\"\nwheels = [{ url = \"https://files.pythonhosted.org/packages/b0/urllib3-1.26.18-py2.py3-none-any.whl\", upload-time = 2023-10-17T17:46:21Z, size = 143835, hashes = { sha256 = \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\" } }]\n";
+
+    /// #479: a Hatch project whose environments are locked carries a
+    /// `pylock*.toml` Hatch DERIVES from pyproject (and regenerates on the
+    /// next sync), so hosted mode wires pyproject — the declaration Hatch
+    /// locks and installs from — beside the lock, with a warning, instead
+    /// of rewriting only the lock (which Hatch then threw away).
+    #[test]
+    fn hatch_locked_env_pylock_also_wires_pyproject() {
+        let head = "[build-system]\nrequires = [\"hatchling\"]\nbuild-backend = \"hatchling.build\"\n\n[project]\nname = \"app\"\nversion = \"0.1.0\"\ndependencies = [\"urllib3==1.26.18\"]\n";
+        for (config, lock) in [
+            (
+                "\n[tool.hatch.envs.default]\nlocked = true\ninstaller = \"uv\"\n",
+                "pylock.toml",
+            ),
+            ("\n[tool.hatch]\nlock-envs = true\n", "pylock.toml"),
+            (
+                "\n[tool.hatch.envs.test]\nlocked = true\n",
+                "pylock.test.toml",
+            ),
+        ] {
+            let files: BTreeMap<String, String> = [
+                ("pyproject.toml".to_string(), format!("{head}{config}")),
+                (lock.to_string(), HATCH_PYLOCK.to_string()),
+            ]
+            .into_iter()
+            .collect();
+            let result = rewrite_registry_redirect(&files, &[patch()]);
+            assert!(
+                result.confirmed_hatch_uuids.contains("test-uuid"),
+                "{config}: {:?}",
+                result.warnings
+            );
+            assert!(
+                result.files["pyproject.toml"].contains(&format!(
+                    "urllib3 @ {}#sha256={}",
+                    patch().artifact_url,
+                    "a".repeat(64)
+                )),
+                "{config}"
+            );
+            // The lock stays consistent with pyproject until Hatch
+            // regenerates it from the wired declaration.
+            assert!(
+                result.files[lock].contains(&patch().artifact_url),
+                "{config}"
+            );
+            assert!(
+                result
+                    .warnings
+                    .iter()
+                    .any(|w| w.code == "redirect_hatch_lock_regenerated" && w.detail.contains(lock)),
+                "{config}: {:?}",
+                result.warnings
+            );
+        }
+        // Without locked environments a pylock is its own install source
+        // (`uv export`, `pip lock`): the lock lane keeps it, pyproject stays.
+        let files: BTreeMap<String, String> = [
+            ("pyproject.toml".to_string(), head.to_string()),
+            ("pylock.toml".to_string(), HATCH_PYLOCK.to_string()),
+        ]
+        .into_iter()
+        .collect();
+        let result = rewrite_registry_redirect(&files, &[patch()]);
+        assert!(!result.files.contains_key("pyproject.toml"));
+        assert!(result.confirmed_hatch_uuids.is_empty());
+    }
+
     #[test]
     fn hatch_confirmation_ignores_inactive_sources_and_comments() {
         let dep = patch();
 
@@ -28,6 +28,47 @@ pub fn is_hatch(files: &BTreeMap<String, String>) -> bool {
         })
 }
 
+/// Whether the project's Hatch configuration locks environments (Hatch
+/// 1.17+: `lock-envs = true`, or an environment with `locked = true` or a
+/// `lock-filename`), in pyproject's `[tool.hatch]` or hatch.toml.
+fn locks_environments(files: &BTreeMap<String, String>) -> bool {
+    HATCH_FILES.into_iter().any(|file| {
+        let Some(document) = parsed(files, file) else {
+            return false;
+        };
+        let hatch = if file == HATCH_FILES[1] {
+            Some(document.as_item())
+        } else {
+            document.get("tool").and_then(|tool| tool.get("hatch"))
+        };
+        let Some(hatch) = hatch else {
+            return false;
+        };
+        hatch.get("lock-envs").and_then(Item::as_bool) == Some(true)
+            || hatch
+                .get("envs")
+                .and_then(Item::as_table_like)
+                .is_some_and(|envs| {
+                    envs.iter().any(|(_, env)| {
+                        env.get("locked").and_then(Item::as_bool) == Some(true)
+                            || env.get("lock-filename").is_some()
+                    })
+                })
+    })
+}
+
+/// Whether `path` is a PEP 751 lock Hatch derives from pyproject (#479):
+/// a `pylock.toml` / `pylock.<name>.toml` in a Hatch project whose
+/// environments are locked. Hatch regenerates it from pyproject whenever
+/// the dependency hash changes, so it is not an independent install
+/// source: the Hatch wiring (pyproject) is what must be rewritten, and a
+/// rewrite of only the lock is thrown away by the next environment sync.
+pub fn is_hatch_lock(files: &BTreeMap<String, String>, path: &str) -> bool {
+    crate::utils::python_lock::is_pep751_lock_name(path)
+        && is_hatch(files)
+        && locks_environments(files)
+}
+
 /// One PEP 508 dependency string Hatch installs.
 pub(crate) struct HatchSpec<'d> {
     /// `pyproject.toml` or `hatch.toml` (a [`HATCH_FILES`] entry).
 
@@ -301,10 +301,20 @@ async fn detect_pypi_flavor(
             tool_locks.contains(&lock)
         }));
     }
+    // #479: a pylock Hatch derives from pyproject (locked environments) is
+    // regenerated by Hatch on the next sync, so it is not a lock to wire on
+    // its own; the project routes to the Hatch lane (and its guards).
+    let mut hatch_files = std::collections::BTreeMap::new();
+    for file in crate::utils::hatch::HATCH_FILES {
+        if let Ok(text) = read_regular_to_string(&project_root.join(file)).await {
+            hatch_files.insert(file.to_string(), text);
+        }
+    }
     let additional_locks: Vec<String> = crate::utils::python_lock::python_lock_paths(project_root)
         .map_err(|error| ("pypi_lock_read_failed", error.to_string()))?
         .into_iter()
         .filter(|path| path != "uv.lock")
+        .filter(|path| !crate::utils::hatch::is_hatch_lock(&hatch_files, path))
         .collect();
     // #912 / #1122: a pylock beside a `Pipfile` belongs to Pipenv, not to a
     // PEP 751 installer. With a `Pipfile.lock` Pipenv installs from that
@@ -2865,6 +2875,42 @@ mod tests {
         }
     }
 
+    /// #479: in a Hatch project with locked environments, the pylock is
+    /// Hatch's own derived lock: it routes to the Hatch flavor (whose guards
+    /// refuse the uv installer locked environments use) instead of the
+    /// python-lock lane, which wired only the lock Hatch then regenerated.
+    /// Without locked environments the same pylock still routes to it.
+    #[tokio::test]
+    async fn hatch_locked_env_pylock_routes_to_hatch() {
+        let head = "[build-system]\nrequires = [\"hatchling\"]\nbuild-backend = \"hatchling.build\"\n\n[project]\nname = \"app\"\nversion = \"0.1.0\"\ndependencies = [\"six==1.16.0\"]\n";
+        for (lock, config) in [
+            (
+                "pylock.toml",
+                "\n[tool.hatch.envs.default]\nlocked = true\ninstaller = \"uv\"\n",
+            ),
+            ("pylock.test.toml", "\n[tool.hatch]\nlock-envs = true\n"),
+        ] {
+            let tmp = tempfile::tempdir().unwrap();
+            touch(tmp.path(), lock, PIPENV_PYLOCK).await;
+            touch(tmp.path(), "pyproject.toml", head).await;
+            let (selected, _) = detect_pypi_flavor(tmp.path(), Some(("six", "1.16.0")))
+                .await
+                .unwrap();
+            assert_eq!(selected, PypiFlavor::PythonLocks, "{lock}: no locked envs");
+            touch(tmp.path(), "pyproject.toml", &format!("{head}{config}")).await;
+            let (selected, warnings) = detect_pypi_flavor(tmp.path(), Some(("six", "1.16.0")))
+                .await
+                .unwrap();
+            assert_eq!(selected, PypiFlavor::Hatch, "{lock}");
+            assert!(
+                warnings
+                    .iter()
+                    .all(|w| w.code != "pypi_unmatched_lockfiles"),
+                "{lock}: {warnings:?}"
+            );
+        }
+    }
+
     /// #1120: a `requirements.txt` exported beside the governing lock in
     /// UTF-16 (`uv export > requirements.txt` in Windows PowerShell 5.1)
     /// is installed by pip and uv like its UTF-8 twin, so it is a loud