@@ -2539,6 +2539,28 @@ mod tests {
         }
     }
 
+    /// #1096: an existing file with no keys at all (empty, comments only,
+    /// bare document markers) gains the root-only `packages` scaffold with
+    /// the trust key — pnpm 8.x–10.4 refuse a workspace file holding a key
+    /// but no `packages` — inside the document, every user byte intact.
+    #[test]
+    fn plan_workspace_trust_scaffolds_packages_in_a_keyless_file() {
+        const ADDED: &str = "packages:\n  - '.'\ntrustLockfile: true\n";
+        for (user, want) in [
+            ("", ADDED.to_string()),
+            ("\n", format!("{ADDED}\n")),
+            ("# settings\n", format!("# settings\n{ADDED}")),
+            ("---\n", format!("---\n{ADDED}")),
+            ("%YAML 1.2\n---\n", format!("%YAML 1.2\n---\n{ADDED}")),
+            ("---\n...\n", format!("---\n{ADDED}...\n")),
+        ] {
+            match plan_workspace_trust(Some(user)) {
+                TrustPlan::Scaffold(text) => assert_eq!(text, want, "{user:?}"),
+                _ => panic!("a keyless file must plan a Scaffold: {user:?}"),
+            }
+        }
+    }
+
     /// An existing workspace file gains exactly one line after its last
     /// non-empty line; every other byte — including a trailing blank line and
     /// comments — is preserved so a revert can remove exactly that line.
 
@@ -406,6 +406,90 @@ async fn hosted_trust_edit_reads_the_workspace_yaml_shape() {
     }
 }
 
+/// #1096: a pnpm-workspace.yaml with no keys at all (empty, comments only,
+/// bare document markers) is a "no workspace" file to pnpm, but pnpm
+/// 8.x–10.4 refuse every command once it holds a key without `packages`
+/// ("packages field missing or empty"). The trust edit therefore splices in
+/// the root-only `packages` scaffold with the trust key, and `rollback`
+/// takes both back out, restoring the user's file byte for byte. A project
+/// pinned to pnpm 9.0–10.4 gets no edit at all, as with no file (#734).
+#[tokio::test]
+#[serial]
+async fn hosted_trust_edit_scaffolds_packages_in_a_keyless_workspace_yaml() {
+    let server = MockServer::start().await;
+    mock_discovery(&server).await;
+    mock_reference(&server).await;
+
+    const ADDED: &str = "packages:\n  - '.'\ntrustLockfile: true\n";
+    for (user_ws, want) in [
+        (
+            "# pnpm settings go here\n",
+            format!("# pnpm settings go here\n{ADDED}"),
+        ),
+        ("\n", format!("{ADDED}\n")),
+        ("---\n", format!("---\n{ADDED}")),
+        ("%YAML 1.2\n---\n", format!("%YAML 1.2\n---\n{ADDED}")),
+        ("---\n...\n", format!("---\n{ADDED}...\n")),
+    ] {
+        let tmp = tempfile::tempdir().unwrap();
+        write_pnpm_project(tmp.path());
+        let ws_path = tmp.path().join("pnpm-workspace.yaml");
+        std::fs::write(&ws_path, user_ws).unwrap();
+
+        let code = run(hosted_args(tmp.path(), server.uri())).await;
+        assert_eq!(code, 0, "scan --mode hosted should succeed for {user_ws:?}");
+        assert_eq!(
+            std::fs::read_to_string(&ws_path).unwrap(),
+            want,
+            "a keyless workspace file gains the packages scaffold too ({user_ws:?})"
+        );
+
+        let code = rollback_hosted(tmp.path(), &server).await;
+        assert_eq!(
+            code, 0,
+            "rollback must restore the pnpm pin for {user_ws:?}"
+        );
+        assert_eq!(
+            std::fs::read_to_string(&ws_path).unwrap(),
+            user_ws,
+            "rollback restores the keyless workspace file byte for byte"
+        );
+    }
+
+    // An empty file reads as the created scaffold, which rollback deletes
+    // (pnpm reads an empty file and no file alike).
+    let tmp = tempfile::tempdir().unwrap();
+    write_pnpm_project(tmp.path());
+    let ws_path = tmp.path().join("pnpm-workspace.yaml");
+    std::fs::write(&ws_path, "").unwrap();
+    assert_eq!(run(hosted_args(tmp.path(), server.uri())).await, 0);
+    assert_eq!(std::fs::read_to_string(&ws_path).unwrap(), ADDED);
+    assert_eq!(rollback_hosted(tmp.path(), &server).await, 0);
+    assert!(
+        !ws_path.exists(),
+        "the scaffold-only file goes with the pin"
+    );
+
+    // Pinned to pnpm 9.15.9: the keyless file stays untouched (#734).
+    let tmp = tempfile::tempdir().unwrap();
+    write_pnpm_project(tmp.path());
+    std::fs::write(
+        tmp.path().join("package.json"),
+        format!(
+            r#"{{ "name": "consumer", "version": "0.0.0", "packageManager": "pnpm@9.15.9", "dependencies": {{ "{NAME}": "{VERSION}" }} }}"#
+        ),
+    )
+    .unwrap();
+    let ws_path = tmp.path().join("pnpm-workspace.yaml");
+    std::fs::write(&ws_path, "# pnpm settings go here\n").unwrap();
+    assert_eq!(run(hosted_args(tmp.path(), server.uri())).await, 0);
+    assert_eq!(
+        std::fs::read_to_string(&ws_path).unwrap(),
+        "# pnpm settings go here\n",
+        "a pnpm 9 project's keyless workspace file is left alone"
+    );
+}
+
 /// #903 / #904: a `pnpm-lock.yaml` and `pnpm-workspace.yaml` saved with a
 /// UTF-8 BOM read like their plain twins. The BOM lock gets the
 /// `trustLockfile: true` auto-config (it used to read as unversioned and
 
@@ -116,10 +116,48 @@ pub(crate) fn block_insert_point(lines: &[String]) -> Result<usize, String> {
     Ok(match (last, end_marker) {
         (Some(i), _) => i + 1,
         (None, Some(end)) => end,
-        (None, None) => lines.len(),
+        // Blank lines only: the new key opens the file, so its trailing
+        // newlines stay where they are.
+        (None, None) => 0,
     })
 }
 
+/// The root-only `packages:` list a splice writes into a workspace file
+/// that has none (pnpm 8.x–10.4 refuse a workspace file holding any key but
+/// no `packages`), in the vendor and hosted scaffold spelling.
+pub(crate) const PACKAGES_SCAFFOLD: [&str; 2] = ["packages:", "  - '.'"];
+
+/// Whether a pnpm-workspace.yaml holds no key at all: every line is blank,
+/// a comment, a `%` directive or a bare `---` / `...` marker. pnpm parses
+/// such a file to an empty document and installs as if it did not exist,
+/// but pnpm 8.x–10.4 refuse every command once it holds a key without a
+/// `packages` field ("packages field missing or empty", #1096), so a splice
+/// that gives it its first key must give it [`PACKAGES_SCAFFOLD`] too.
+pub(crate) fn is_keyless(text: &str) -> bool {
+    strip_bom(text).split('\n').all(|raw| {
+        let line = raw.strip_suffix('\r').unwrap_or(raw);
+        let trimmed = line.trim();
+        trimmed.is_empty()
+            || trimmed.starts_with('#')
+            || line.starts_with('%')
+            || ((is_marker(line, "---") || is_marker(line, "..."))
+                && strip_comment(&line[3..]).trim().is_empty())
+    })
+}
+
+/// `text` with the contiguous run of lines `block` removed, when that
+/// leaves a [`is_keyless`] document: the inverse of a splice that gave a
+/// keyless file its first keys. `None` when the run is absent or the rest
+/// of the file holds keys (the lines are then not provably the splice).
+pub(crate) fn strip_keyless_splice(text: &str, block: &[&str]) -> Option<String> {
+    let lines: Vec<&str> = text.split('\n').collect();
+    let at = lines.windows(block.len()).position(|w| w == block)?;
+    let mut rest = lines;
+    rest.drain(at..at + block.len());
+    let rest = rest.join("\n");
+    is_keyless(&rest).then_some(rest)
+}
+
 /// The top-level `name:` section holding a block mapping: `(header, end)`,
 /// `end` being the next column-0 line that is not a comment (exclusive) — a
 /// `#` comment at column 0 does not close a YAML block mapping. Unlike
@@ -421,6 +459,46 @@ mod tests {
         }
     }
 
+    #[test]
+    fn keyless_documents_and_their_splices() {
+        for text in [
+            "",
+            "\n",
+            "# c\n\n  # indented\n",
+            "---\n",
+            "--- # start\n",
+            "%YAML 1.2\n---\n",
+            "---\n...\n",
+            "\u{feff}# bom\r\n",
+        ] {
+            assert!(is_keyless(text), "{text:?}");
+        }
+        for text in ["a: 1\n", "# c\npackages: []\n", "--- {}\n", "- a\n", "~\n"] {
+            assert!(!is_keyless(text), "{text:?}");
+        }
+        let block = ["packages:", "  - '.'", "trustLockfile: true"];
+        assert_eq!(
+            strip_keyless_splice("# c\npackages:\n  - '.'\ntrustLockfile: true\n", &block),
+            Some("# c\n".to_string())
+        );
+        assert_eq!(
+            strip_keyless_splice(
+                "---\npackages:\n  - '.'\ntrustLockfile: true\n...\n",
+                &block
+            ),
+            Some("---\n...\n".to_string())
+        );
+        assert_eq!(
+            strip_keyless_splice(
+                "packages:\n  - '.'\ntrustLockfile: true\ncatalog: {}\n",
+                &block
+            ),
+            None,
+            "other keys: not provably the splice"
+        );
+        assert_eq!(strip_keyless_splice("# c\n", &block), None);
+    }
+
     #[test]
     fn block_insert_point_follows_the_document() {
         assert_eq!(block_insert_point(&lines("a: 1\nb:\n  - c\n")), Ok(3));
@@ -429,7 +507,8 @@ mod tests {
         assert_eq!(block_insert_point(&lines("a: 1\n\n...\n# done\n")), Ok(1));
         assert_eq!(block_insert_point(&lines("%YAML 1.2\n---\na: 1\n")), Ok(3));
         assert_eq!(block_insert_point(&lines("# only a comment\n")), Ok(1));
-        assert_eq!(block_insert_point(&lines("")), Ok(1));
+        assert_eq!(block_insert_point(&lines("")), Ok(0));
+        assert_eq!(block_insert_point(&lines("\n\n")), Ok(0));
         for text in [
             "{a: 1}\n",
             "[a]\n",
 
@@ -49,10 +49,11 @@ use super::guidance::{
     plan_workspace_trust, pnpm_heal_root, pnpm_is_shrinkwrap_lock, pnpm_lock_may_need_store_flag,
     pnpm_lock_version_major, pnpm_root_only_workspace_breaks_add, pnpm_trust_configured_detail,
     pnpm_trust_legacy_detail, pnpm_trust_manual_guidance, pnpm_trust_not_needed_detail,
-    pnpm_trust_policy_preamble, pnpm_trust_rush_detail, pnpm_trust_workspace_unreadable_detail,
-    pnpm_trust_workspace_unsupported_detail, read_npmrc_for_allow_remote, read_workspace_for_trust,
-    url_host, TrustPlan, NPM_LOCKS, NPM_REPLACE_REGISTRY_HOST_CODE, PNPM_TRUST_RUSH_MIXED_NOTE,
-    PNPM_TRUST_TRADEOFF_AND_CAUTION, PNPM_WORKSPACE_REL, REDIRECT_PNPM_WORKSPACE_TRUST_EDIT_KIND,
+    pnpm_trust_policy_preamble, pnpm_trust_rush_detail, pnpm_trust_scaffolded_detail,
+    pnpm_trust_workspace_unreadable_detail, pnpm_trust_workspace_unsupported_detail,
+    read_npmrc_for_allow_remote, read_workspace_for_trust, url_host, TrustPlan, NPM_LOCKS,
+    NPM_REPLACE_REGISTRY_HOST_CODE, PNPM_TRUST_RUSH_MIXED_NOTE, PNPM_TRUST_TRADEOFF_AND_CAUTION,
+    PNPM_WORKSPACE_REL, REDIRECT_PNPM_WORKSPACE_TRUST_EDIT_KIND,
 };
 use super::vlt::bun_lockb_present;
 
@@ -2116,15 +2117,23 @@ fn pnpm_trust(
             original: None,
             new: Some(serde_json::json!("true")),
         };
-        // No workspace file and a project pinned to pnpm 9.0–10.4: creating
-        // one would make it a root-only workspace those releases refuse
-        // `pnpm add` in, for a key they never read (#734).
+        // No workspace file (or one with no keys, which pnpm reads the
+        // same) and a project pinned to pnpm 9.0–10.4: creating one would
+        // make it a root-only workspace those releases refuse `pnpm add`
+        // in, for a key they never read (#734, #1096).
         let pinned_pre_10_5 = match &workspace {
-            Ok(None) if !symlinked => root_only_workspace_breaks_add(view),
+            Ok(text)
+                if !symlinked
+                    && text
+                        .as_deref()
+                        .is_none_or(crate::formats::pnpm::workspace::is_keyless) =>
+            {
+                root_only_workspace_breaks_add(view)
+            }
             _ => None,
         };
         match workspace {
-            Ok(None) if pinned_pre_10_5.is_some() => pnpm_trust_not_needed_detail(
+            Ok(_) if pinned_pre_10_5.is_some() => pnpm_trust_not_needed_detail(
                 &server,
                 pinned_pre_10_5.as_deref().unwrap_or_default(),
                 options.dry_run,
@@ -2142,6 +2151,10 @@ fn pnpm_trust(
                     trust_config_write = Some((text, trust_edit("added")));
                     pnpm_trust_configured_detail(&server, false, options.dry_run)
                 }
+                TrustPlan::Scaffold(text) => {
+                    trust_config_write = Some((text, trust_edit("added")));
+                    pnpm_trust_scaffolded_detail(&server, options.dry_run)
+                }
                 TrustPlan::AlreadyTrue => {
                     pnpm_rerun_only = spliced_pnpm_locks == 0;
                     let detail = pnpm_trust_already_true_detail(&server, PNPM_WORKSPACE_REL);
 
@@ -257,15 +257,39 @@ pub fn pnpm_trust_configured_detail(server: &str, created: bool, dry_run: bool)
         (true, true) => "`trustLockfile: true` would be written to a new",
         (false, true) => "`trustLockfile: true` would be merged into the existing",
     };
+    let undo = format!("delete {PNPM_WORKSPACE_REL}");
+    trust_configured_detail(server, how, created.then_some(undo.as_str()), dry_run)
+}
+
+/// The auto-config variant for an existing pnpm-workspace.yaml with no keys
+/// ([`TrustPlan::Scaffold`]): the trust key went in with the root-only
+/// `packages` field, which makes the project a root-only workspace just as
+/// a created file does.
+pub fn pnpm_trust_scaffolded_detail(server: &str, dry_run: bool) -> String {
+    let how = if dry_run {
+        "`trustLockfile: true` (with the root-only `packages: ['.']` that pnpm \
+         8–10.4 require once the file holds a key) would be merged into the existing"
+    } else {
+        "`trustLockfile: true` (with the root-only `packages: ['.']` that pnpm \
+         8–10.4 require once the file holds a key) was merged into the existing"
+    };
+    let undo =
+        format!("remove the added `packages` and `trustLockfile` lines from {PNPM_WORKSPACE_REL}");
+    trust_configured_detail(server, how, Some(&undo), dry_run)
+}
+
+/// `undo` (set when the edit made the project a root-only workspace) names
+/// how to take the edit back.
+fn trust_configured_detail(server: &str, how: &str, undo: Option<&str>, dry_run: bool) -> String {
     // A created file makes the project a root-only workspace, where pnpm
     // 9.0–10.4 refuse `pnpm add` without `-w` (#734); a project pinned to
     // those releases never gets one, so the note names the pin as the way
     // out for an unpinned project with no install record.
-    let root_only = if created {
+    let root_only = if let Some(undo) = undo {
         let then = if dry_run {
             "before the real run".to_string()
         } else {
-            format!("then delete {PNPM_WORKSPACE_REL} and re-run")
+            format!("then {undo} and re-run")
         };
         format!(
             " On pnpm 9.0–10.4 a root-only workspace needs `pnpm add -w <pkg>` \
@@ -318,6 +342,13 @@ pub enum TrustPlan {
     /// Workspace file exists without a `trustLockfile:` key: append exactly
     /// one line after the last non-empty line, every other byte preserved.
     Append(String),
+    /// Workspace file exists but holds no key at all (empty, comments only,
+    /// bare document markers — "no workspace" to pnpm): the root-only
+    /// `packages` scaffold goes in with the trust key, since pnpm 8.x–10.4
+    /// refuse a workspace file holding a key but no `packages` (#1096).
+    /// Every user byte is preserved, so rollback can take both back out
+    /// ([`TRUST_SCAFFOLD_LINES`]).
+    Scaffold(String),
     /// Already `trustLockfile: true` — nothing to write.
     AlreadyTrue,
     /// The user explicitly set `trustLockfile: <value>` (non-true). Their
@@ -330,6 +361,15 @@ pub enum TrustPlan {
     Unsupported(String),
 }
 
+/// The lines the trust auto-config writes into a file with no keys (and,
+/// newline-terminated, the whole file it creates): the root-only `packages`
+/// scaffold and the trust key.
+pub const TRUST_SCAFFOLD_LINES: [&str; 3] = [
+    crate::formats::pnpm::workspace::PACKAGES_SCAFFOLD[0],
+    crate::formats::pnpm::workspace::PACKAGES_SCAFFOLD[1],
+    "trustLockfile: true",
+];
+
 /// Decide how to ensure `trustLockfile: true` in pnpm-workspace.yaml.
 /// Line splices only (never a YAML library), mirroring the vendor backend's
 /// workspace surgery: untouched lines stay byte-identical, so a revert can
@@ -340,6 +380,11 @@ pub fn plan_workspace_trust(existing: Option<&str>) -> TrustPlan {
         return TrustPlan::Create("packages:\n  - '.'\ntrustLockfile: true\n".to_string());
     };
     let mut lines: Vec<String> = text.split('\n').map(str::to_string).collect();
+    if crate::formats::pnpm::workspace::is_keyless(text) {
+        let anchor = block_insert_point(&lines).unwrap_or(lines.len());
+        lines.splice(anchor..anchor, TRUST_SCAFFOLD_LINES.map(str::to_string));
+        return TrustPlan::Scaffold(lines.join("\n"));
+    }
     // Where the key would go — refused when the document is not a single
     // block mapping, so the scan for an existing key below is meaningful.
     let anchor = match block_insert_point(&lines) {
 
@@ -2081,8 +2081,15 @@ pub(crate) async fn cleanup_side_config(
     if restored_pnpm && !still_hosted(view, &["pnpm-lock.yaml"], ctx).await {
         const WORKSPACE: &str = "pnpm-workspace.yaml";
         if let Ok(Some(ws)) = view.read(WORKSPACE).await {
-            if ws == "packages:\n  - '.'\ntrustLockfile: true\n" {
+            let lines = crate::hosted::guidance::TRUST_SCAFFOLD_LINES;
+            if ws == format!("{}\n", lines.join("\n")) {
                 view.remove(WORKSPACE);
+            } else if let Some(original) =
+                crate::formats::pnpm::workspace::strip_keyless_splice(&ws, &lines)
+            {
+                // The scaffold hosted mode splices into a file with no keys
+                // (#1096): taking it back out restores the user's file.
+                view.write(WORKSPACE, original);
             } else if ws.lines().any(|l| {
                 crate::formats::pnpm::workspace::top_level_key(l).is_some_and(|(key, value)| {
                     key == "trustLockfile" && value.trim_matches(['\'', '"']) == "true"