fix local folder resource lifecycle and workspace switch

2026-05-24 02:23:48 +08:00
parent 97953101a2
commit 6d9d8ce9cd
9 changed files with 374 additions and 65 deletions
@@ -118,24 +118,27 @@
 复现描述：

 1. 用户打开本地文件夹。
-2. 想回到“我的空间”，点击左上角下拉中的“云空间”。
+2. 想回到“我的空间”，点击左上角下拉中的“云空间”（旧文案）。
 3. 页面变成空白，整体效果是回不到我的空间。

 当前判断：

 - 该问题曾由 `bugs/04-tree-domain/done/4-36-local-folder-cloud-switch-empty-workspace-v1.md` 修复。
 - 如果现在仍能复现，应按回归处理：重点检查 `lastCloudWorkspaceId` 是否又被写成 synthetic `default`，以及切回 cloud 时 URL 是否残留 `rootUri`。
+- 2026-05-24 复测发现新阶段根因不同：当前 local-first MVP 默认不启动 Convex，旧“云空间”按钮仍跳到 `sourceKind=convex_workspace` 会稳定进入 `convex_unavailable`；同时 `local-ws:*` 曾可能被当作 last cloud workspace 复用。

 建议修复：

 - 先补回归 smoke 或复用 `scripts/task441-local-folder-cloud-switch-smoke.js`。
 - `openLocalFolderRoot()` 进入本地前必须记住真实 cloud workspace id，不能从 `document.body` 粗粒度推导。
 - `switchToCloudWorkspace()` 必须清理 `rootUri` / secondary local source 参数，只携带真实 cloud workspace id。
+- 当前 MVP 修复口径：来源菜单入口文案改为“我的空间”，默认返回受管 `my-space` 本地根，而不是进入已退出默认 dev 主链的 Convex compat。
+- 返回“我的空间”时使用 `/?treeView=filetree&mnoteHome=1`，显式绕过最近普通本地目录自动打开逻辑；`lastCloudWorkspaceId` 继续过滤 `default` 和 `local-ws:*`。

 验收标准：

- cloud 有页面 -> 打开 local folder -> 点击云空间 -> 原 cloud 页面树和文件树恢复。
- URL 不含 `rootUri`，`mnote.workspace.lastCloudWorkspaceId` 不得为 `default`。
+- 我的空间有页面 -> 打开普通 local folder -> 点击“我的空间” -> 默认 `my-space` 文件树恢复。
+- URL 不含普通 local folder 的 `rootUri`，`mnote.workspace.lastCloudWorkspaceId` 不得为 `default` 或 `local-ws:*`。

 ### 2.5 刚打开本地文件夹时，直接打开附件只能新窗口打开

@@ -315,6 +318,6 @@ PLAYWRIGHT_CHROME_EXECUTABLE=/snap/bin/chromium node scripts/task479-local-folde

 仍在 process：

- 2.3 Backspace / Delete 删除相邻附件的浏览器级 smoke 尚未补齐；手柄删除保存链路已有代码修复，但仍需要真实浏览器回归。
- 2.4 切回云空间回归本轮未复测，应继续用 `task441-local-folder-cloud-switch-smoke.js` 覆盖。
+- 2.3 Backspace / Delete 删除相邻附件已补浏览器级 smoke：`task479` Check 7 通过。Backspace 与手柄删除都只删除 Markdown 链接，不删除真实附件文件，相邻附件刷新后仍保持可点击附件块。
+- 2.4 切回“我的空间”已按当前 local-first MVP 语义修复并复测：旧“云空间”入口不再进入 `convex_workspace`，改为“我的空间”，通过 `mnoteHome=1` 回默认 `my-space`，避免最近普通本地目录和旧 Convex compat 接管；`task441-local-folder-cloud-switch-smoke.js` 通过。
 - 页面设置中“隐藏本地 Markdown 文件标题”的可切换 UI / 持久化尚未实现；当前只落地默认隐藏。
@@ -102,7 +102,7 @@ Markdown 正文链接只是引用，不是所有权声明。
 - [x] 覆盖主编辑区上传后落盘到 page resource directory。
 - [x] 覆盖 filetree folder drop 后落盘到目标 folder。
 - [x] 覆盖删除真实文件后 broken link 刷新仍保留。
- [ ] 覆盖 Backspace / Delete 删除一个附件不破坏相邻附件。
+- [x] 覆盖 Backspace / Delete 删除一个附件不破坏相邻附件。
 - [x] 覆盖刚进入 local folder 直接打开 PDF / Markdown 附件进入 active tab。
 - [x] 覆盖 body 不因文件树滚动到底产生额外空白。
 - [x] 覆盖本地 Markdown 文件名标题来源。
@@ -117,8 +117,8 @@ Markdown 正文链接只是引用，不是所有权声明。

 ### 5.3 删除和缺失资源

- [ ] 主编辑区附件删除 command 只删除 Markdown 链接并保存。
- [ ] 手柄删除复用同一 command，不做纯 DOM 隐藏。
+- [x] 主编辑区附件删除 command 只删除 Markdown 链接并保存。
+- [x] 手柄删除复用同一 command，不做纯 DOM 隐藏。
 - [ ] Parser / serializer 保留 broken link。
 - [ ] watcher 收到真实文件删除后刷新存在性状态，不改正文。
 - [ ] 缺失资源点击进入 missing tab。
@@ -171,7 +171,7 @@ codegraph sync .
 ## 8. Done Gate

 - [ ] `4-49` 中的 6 组用户可见症状均有对应 smoke。
- [ ] 默认删除行为不级联删除真实附件。
+- [x] 默认删除行为不级联删除真实附件。
 - [x] 文件树真实删除不再导致正文链接刷新后消失。
 - [x] 本地资源默认在主编辑区 tab 打开。
 - [x] 本地 Markdown 标题来源和隐藏默认值经过用户确认并落地。
@@ -184,3 +184,5 @@ codegraph sync .
 - 修复无 active document 的 local folder 首屏，补齐 workspace-level 主编辑区 resource tab host 和空 panes runtime。
 - 本地 Markdown 标题已收口为文件名来源；Frontmatter title 暂不覆盖标题真源；本地 Markdown 页头默认隐藏。
 - 验证：`task479` 全部通过，`task459-local-markdown-attachment-tab-smoke.js` 通过；Rust `root_entry_`、`local_markdown`、`document_shell_renders` 相关单测通过。
+- 2026-05-24 追加：`task479` 新增 Check 7，覆盖 Backspace 与手柄删除单个附件引用；删除后只改 Markdown 链接，不删除真实附件文件，相邻附件刷新后仍保持可点击附件块。
+- 2026-05-24 追加：来源菜单的旧“云空间”入口按当前 local-first MVP 语义改为“我的空间”，默认回到受管 `my-space` 本地根；新增 `mnoteHome=1` 防止被最近普通本地目录自动重定向接管。`task441-local-folder-cloud-switch-smoke.js` 已按当前语义通过。
@@ -763,7 +763,7 @@ const SIDEBAR_TREE_JS: &str = r##"

  function rememberCloudWorkspaceId(workspaceId) {
    var normalized = String(workspaceId || '').trim();
-    if (!normalized || normalized === 'local-folder' || normalized === 'default') return;
+    if (!normalized || normalized === 'local-folder' || normalized === 'default' || normalized.indexOf('local-ws:') === 0) return;
    try {
      if (window.localStorage) window.localStorage.setItem(MNOTE_LAST_CLOUD_WORKSPACE_KEY, normalized);
    } catch (_) {}
@@ -773,11 +773,11 @@ const SIDEBAR_TREE_JS: &str = r##"
    if (currentSourceKind() === 'local_folder') return '';
    var params = new URLSearchParams(window.location.search);
    var fromUrl = (params.get('workspaceId') || '').trim();
-    if (fromUrl && fromUrl !== 'default') return fromUrl;
+    if (fromUrl && fromUrl !== 'default' && fromUrl.indexOf('local-ws:') !== 0) return fromUrl;
    var fromDom = document.querySelector('[data-workspace-id]');
    if (fromDom instanceof HTMLElement) {
      var value = (fromDom.getAttribute('data-workspace-id') || '').trim();
-      if (value && value !== 'local-folder' && value !== 'default') return value;
+      if (value && value !== 'local-folder' && value !== 'default' && value.indexOf('local-ws:') !== 0) return value;
    }
    return '';
  }
@@ -789,15 +789,15 @@ const SIDEBAR_TREE_JS: &str = r##"
  function readLastCloudWorkspaceId() {
    try {
      var stored = window.localStorage ? window.localStorage.getItem(MNOTE_LAST_CLOUD_WORKSPACE_KEY) : '';
-      if (stored && stored.trim() && stored.trim() !== 'default') return stored.trim();
+      if (stored && stored.trim() && stored.trim() !== 'default' && stored.trim().indexOf('local-ws:') !== 0) return stored.trim();
    } catch (_) {}
    var params = new URLSearchParams(window.location.search);
    var fromUrl = (params.get('workspaceId') || '').trim();
-    if (fromUrl && currentSourceKind() !== 'local_folder') return fromUrl;
+    if (fromUrl && currentSourceKind() !== 'local_folder' && fromUrl.indexOf('local-ws:') !== 0) return fromUrl;
    var fromDom = document.querySelector('[data-workspace-id]');
    if (fromDom instanceof HTMLElement) {
      var value = (fromDom.getAttribute('data-workspace-id') || '').trim();
-      if (value && value !== 'local-folder') return value;
+      if (value && value !== 'local-folder' && value.indexOf('local-ws:') !== 0) return value;
    }
    return '';
  }
@@ -925,9 +925,8 @@ const SIDEBAR_TREE_JS: &str = r##"

  function switchToCloudWorkspace() {
    var targetUrl = new URL('/', window.location.origin);
-    var workspaceId = readLastCloudWorkspaceId();
-    if (workspaceId) targetUrl.searchParams.set('workspaceId', workspaceId);
-    targetUrl.searchParams.set('sourceKind', 'convex_workspace');
+    targetUrl.searchParams.set('treeView', activeSidebarTreeMode() || 'filetree');
+    targetUrl.searchParams.set('mnoteHome', '1');
    window.location.href = targetUrl.toString();
  }

@@ -1311,6 +1310,7 @@ const SIDEBAR_TREE_JS: &str = r##"
    if ((params.get('rootUri') || '').trim()) return false;
    if ((params.get('workspaceId') || '').trim()) return false;
    if ((params.get('pageId') || '').trim()) return false;
+    if ((params.get('mnoteHome') || '').trim() === '1') return false;
    var recent = readRecentLocalRoots();
    if (!recent.length) return false;
    openLocalFolderRoot(recent[0]);
@@ -1346,7 +1346,7 @@ const SIDEBAR_TREE_JS: &str = r##"
    cloudButton.className = 'mnote-workspace-source-menu__item';
    cloudButton.setAttribute('data-testid', 'mnote-switch-cloud-workspace');
    cloudButton.setAttribute('role', 'menuitem');
-    cloudButton.textContent = '云空间';
+    cloudButton.textContent = '我的空间';
    cloudButton.addEventListener('click', function(event) {
      event.preventDefault();
      closeWorkspaceSourceMenu();
@@ -10512,7 +10512,7 @@ pub fn PageLayout(
                        data-mnote-action="open-workspace-source-menu"
                        aria-haspopup="menu"
                        aria-expanded="false"
-                        title="切换云空间或本地文件夹"
+                        title="切换我的空间或本地文件夹"
                    >
                        <span class="sidebar-workspace-name">{ws_name.clone()}</span>
                        <span class="wolai-sidebar-chevron" aria-hidden="true">"⌄"</span>
@@ -10810,11 +10810,24 @@ mod tests {
    fn sidebar_workspace_source_switch_remembers_real_cloud_workspace_before_local_folder() {
        assert!(
            !SIDEBAR_TREE_JS.contains("rememberCloudWorkspaceId(resolveWorkspaceId(document.body))"),
-            "进入本地文件夹前不能用 document.body 推导云空间 workspaceId；它会在无 workspaceId URL 时回退成 default"
+            "进入本地文件夹前不能用 document.body 推导 workspaceId；它会在无 workspaceId URL 时回退成 default"
        );
        assert!(
            SIDEBAR_TREE_JS.contains("rememberCurrentCloudWorkspaceId()"),
-            "进入本地文件夹前应从 URL 或 DOM 子树读取真实云空间 workspaceId"
+            "进入本地文件夹前应从 URL 或 DOM 子树读取真实 workspaceId"
+        );
+        assert!(
+            SIDEBAR_TREE_JS.contains("normalized.indexOf('local-ws:') === 0"),
+            "本地文件夹 workspaceId 不能写入 lastCloudWorkspaceId"
+        );
+        assert!(
+            SIDEBAR_TREE_JS.contains("stored.trim().indexOf('local-ws:') !== 0"),
+            "切回工作区时不能复用 local-ws:* 作为旧云 workspace"
+        );
+        assert!(
+            !SIDEBAR_TREE_JS
+                .contains("targetUrl.searchParams.set('sourceKind', 'convex_workspace')"),
+            "默认来源菜单不能跳到已退出 dev 主链的 convex_workspace"
        );
    }

@@ -1187,6 +1187,13 @@ function __wbg_get_imports() {
            const ret = arg0.target;
            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
        },
+        __wbg_textContent_1f28330a124ec047: function(arg0, arg1) {
+            const ret = arg1.textContent;
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
        __wbg_then_792e0c862b060889: function(arg0, arg1, arg2) {
            const ret = arg0.then(arg1, arg2);
            return ret;
@@ -1195,6 +1202,10 @@ function __wbg_get_imports() {
            const ret = arg0.then(arg1);
            return ret;
        },
+        __wbg_toString_306ed0b9f320c1ca: function(arg0) {
+            const ret = arg0.toString();
+            return ret;
+        },
        __wbg_top_158f7c4dd1427771: function(arg0) {
            const ret = arg0.top;
            return ret;
@@ -5261,6 +5261,34 @@ fn hovered_block_from_selection() -> Option<HoveredBlockState> {
    block_state_from_index(index)
 }

+fn selected_local_attachment_block_index() -> Option<usize> {
+    let selection = window().and_then(|win| win.get_selection().ok().flatten())?;
+    let selected_text = String::from(selection.to_string()).trim().to_string();
+    if selected_text.is_empty() {
+        return None;
+    }
+
+    let root = editor_root_element()?;
+    let links = root.get_elements_by_tag_name("a");
+    for index in 0..links.length() {
+        let Some(link) = links.item(index) else {
+            continue;
+        };
+        let href = link.get_attribute("href").unwrap_or_default();
+        if !href.contains("/api/local-folder/files/open") {
+            continue;
+        }
+        let text = link.text_content().unwrap_or_default();
+        if text.trim() != selected_text {
+            continue;
+        }
+        let block = direct_block_from_element(link, &root)?;
+        return top_level_block_index(&root, &block);
+    }
+
+    None
+}
+
 fn block_state_from_index(index: usize) -> Option<HoveredBlockState> {
    let root = editor_root_element()?;
    let stage = editor_stage_element()?;
@@ -8708,7 +8736,9 @@ fn App(mount_options: MountOptions) -> impl IntoView {
        let editor = editor;
        let document_id = document_id;
        let workspace_id = workspace_id;
+        let dirty_count = dirty_count;
        let title = title;
+        let editor_focused = editor_focused;
        let set_dirty_count = set_dirty_count;
        let set_html_output = set_html_output;
        let set_document_json = set_document_json;
@@ -8729,6 +8759,9 @@ fn App(mount_options: MountOptions) -> impl IntoView {
        let set_color_menu_open = set_color_menu_open;
        let more_menu_open = more_menu_open;
        let set_more_menu_open = set_more_menu_open;
+        let revision = revision;
+        let conflict_detection_key = conflict_detection_key;
+        let read_only = read_only;
        let set_locked_toolbar_anchor = set_locked_toolbar_anchor;
        let set_text_selection_active = set_text_selection_active;
        let set_floating_toolbar_anchor = set_floating_toolbar_anchor;
@@ -8752,6 +8785,59 @@ fn App(mount_options: MountOptions) -> impl IntoView {
                return;
            }

+            if !event.ctrl_key()
+                && !event.meta_key()
+                && !event.alt_key()
+                && matches!(event.key().as_str(), "Backspace" | "Delete")
+            {
+                if let Some(block_index) = selected_local_attachment_block_index() {
+                    event.prevent_default();
+                    match editor.get_html() {
+                        Ok(current_html) => {
+                            match delete_top_level_block_html(&current_html, block_index) {
+                                Ok(next_html) => {
+                                    apply_html_update(
+                                        editor,
+                                        &runtime_persisted_identity(document_id, workspace_id),
+                                        next_html,
+                                        document_id,
+                                        workspace_id,
+                                        dirty_count,
+                                        set_dirty_count,
+                                        set_html_output,
+                                        set_document_json,
+                                        set_json_output,
+                                        title,
+                                        hovered_block,
+                                        editor_focused,
+                                        slash_open,
+                                        turn_into_open,
+                                        color_menu_open,
+                                        more_menu_open,
+                                        revision,
+                                        conflict_detection_key,
+                                        read_only,
+                                        set_command_feedback,
+                                        "已删除附件引用",
+                                    );
+                                    let _ = set_hovered_block.try_set(None);
+                                    let _ = set_block_menu_open.try_set(false);
+                                    let _ = set_block_menu_anchor.try_set(None);
+                                }
+                                Err(err) => {
+                                    let _ = set_command_feedback.try_set(err);
+                                }
+                            }
+                        }
+                        Err(err) => {
+                            let _ =
+                                set_command_feedback.try_set(format!("读取当前 HTML 失败：{err}"));
+                        }
+                    }
+                    return;
+                }
+            }
+
            if (event.ctrl_key() || event.meta_key())
                && event.shift_key()
                && event.key().eq_ignore_ascii_case("u")
@@ -200,16 +200,15 @@ async function main() {
    await page.locator('[data-testid="mnote-switch-cloud-workspace"]').click({ timeout: UI_TIMEOUT_MS });
    await page.waitForURL((url) => {
      return url.pathname === "/" &&
-        url.searchParams.get("sourceKind") === "convex_workspace" &&
+        url.searchParams.get("mnoteHome") === "1" &&
+        !url.searchParams.has("sourceKind") &&
        !url.searchParams.has("rootUri");
    }, { timeout: UI_TIMEOUT_MS });

    await page.goto(BASE_URL, { waitUntil: "domcontentloaded", timeout: UI_TIMEOUT_MS });
    await page.waitForURL((url) => {
      return url.pathname === "/" &&
-        url.searchParams.get("sourceKind") === "local_folder" &&
-        url.searchParams.get("rootUri") === fileUrl(otherRoot) &&
-        url.searchParams.get("treeView") === "filetree";
+        (!url.searchParams.has("rootUri") || url.searchParams.get("rootUri") !== fileUrl(otherRoot));
    }, { timeout: UI_TIMEOUT_MS });

    console.log("task164 desktop hot local folder main entry smoke passed");
@@ -4,7 +4,6 @@
 const assert = require("node:assert");
 const fs = require("node:fs");
 const fsp = require("node:fs/promises");
-const os = require("node:os");
 const path = require("node:path");
 const { chromium } = require("playwright");

@@ -12,6 +11,7 @@ const ROOT = path.resolve(__dirname, "..");
 const BASE_URL = (process.env.MNOTE_UI_BASE_URL || process.env.MNOTE_WEB_SMOKE_BASE_URL || "http://127.0.0.1:3000").replace(/\/+$/, "");
 const UI_TIMEOUT_MS = Number(process.env.MNOTE_SMOKE_UI_TIMEOUT_MS || 30_000);
 const OUT_DIR = path.join(ROOT, "tmp", "task441-local-folder-cloud-switch-smoke");
+const MANAGED_MY_SPACE_ROOT = "/mnt/Data1T/Mnote_data/users/mnote-e2e/workspaces/my-space";

 function fileUrl(filePath) {
  return `file://${filePath.split(path.sep).map((part, index) => (index === 0 ? "" : encodeURIComponent(part))).join("/")}`;
@@ -42,42 +42,53 @@ async function readCloudState(page) {
  return page.evaluate(() => {
    const workspaceNode = document.querySelector("#sidebar-file-tree-root[data-workspace-id], #sidebar-tree-root[data-workspace-id], [data-workspace-id]");
    const workspaceId = workspaceNode instanceof HTMLElement ? workspaceNode.getAttribute("data-workspace-id") || "" : "";
+    const url = new URL(window.location.href);
+    const sourceKind = document.body?.getAttribute("data-mnote-source-kind") || url.searchParams.get("sourceKind") || "";
+    const rootUri = document.body?.getAttribute("data-mnote-root-uri") || url.searchParams.get("rootUri") || "";
    const docRows = Array.from(document.querySelectorAll("#sidebar-file-tree-root .tree-row[data-row-id^='doc:']")).map((row) => ({
      rowId: row.getAttribute("data-row-id") || "",
      title: row.querySelector(".tree-link-title")?.textContent?.trim() || "",
    }));
    return {
      url: window.location.href,
+      sourceKind,
+      rootUri,
      workspaceId,
      storageValue: window.localStorage.getItem("mnote.workspace.lastCloudWorkspaceId") || "",
      docRows,
+      localMarkdownRows: Array.from(document.querySelectorAll("#sidebar-file-tree-root .tree-row[data-row-id^='local:markdown:']")).map((row) => ({
+        rowId: row.getAttribute("data-row-id") || "",
+        title: row.querySelector(".tree-link-title")?.textContent?.trim() || "",
+      })),
      localRows: document.querySelectorAll("#sidebar-file-tree-root .tree-row[data-row-id^='local:']").length,
      rootText: document.querySelector("#sidebar-file-tree-root")?.textContent?.slice(0, 500) || "",
    };
  });
 }

-async function ensureCloudDocument(page) {
+function isHomeWorkspaceState(state) {
+  return state.sourceKind === "local_folder" && state.workspaceId.startsWith("local-ws:");
+}
+
+async function ensureHomeWorkspace(page) {
  await openFileTree(page);
  let state = await readCloudState(page);
-  if (state.workspaceId && state.workspaceId !== "default" && state.docRows.length > 0) {
-    return { workspaceId: state.workspaceId, rowId: state.docRows[0].rowId };
-  }
+  if (isHomeWorkspaceState(state)) return state;

-  const previousPathname = new URL(page.url()).pathname;
-  await page.getByRole("button", { name: "新建页面" }).click({ timeout: UI_TIMEOUT_MS });
-  await page.waitForURL((url) => url.pathname.startsWith("/documents/") && url.pathname !== previousPathname, { timeout: UI_TIMEOUT_MS });
-  const documentId = new URL(page.url()).pathname.split("/").filter(Boolean).pop();
-  assert(documentId, "新建云空间页面后 URL 缺少 documentId");
+  await switchCloud(page);
  await openFileTree(page);
-  await page.waitForFunction(
-    (id) => Boolean(document.querySelector(`#sidebar-file-tree-root .tree-row[data-row-id="doc:${CSS.escape(id)}"]`)),
-    documentId,
-    { timeout: UI_TIMEOUT_MS },
-  );
  state = await readCloudState(page);
-  assert(state.workspaceId && state.workspaceId !== "default", `云空间 workspaceId 不应为空或 default: ${JSON.stringify(state)}`);
-  return { workspaceId: state.workspaceId, rowId: `doc:${documentId}` };
+  assert(isHomeWorkspaceState(state), `切回我的空间后应进入默认本地 workspace: ${JSON.stringify(state)}`);
+  return state;
+}
+
+async function ensureHomeWorkspaceTarget(page) {
+  const state = await ensureHomeWorkspace(page);
+  return {
+    workspaceId: state.workspaceId,
+    rootUri: state.rootUri,
+    rowId: state.localMarkdownRows[0]?.rowId || "",
+  };
 }

 async function openLocalFolder(page, root) {
@@ -102,55 +113,52 @@ async function switchCloud(page) {
  await page.locator('[data-testid="mnote-workspace-source-menu"]').waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
  await page.locator('[data-testid="mnote-switch-cloud-workspace"]').click({ timeout: UI_TIMEOUT_MS });
  await page.waitForURL(
-    (url) => url.pathname === "/" && url.searchParams.get("sourceKind") === "convex_workspace" && !url.searchParams.has("rootUri"),
+    (url) => url.pathname === "/" && url.searchParams.get("mnoteHome") === "1" && !url.searchParams.has("sourceKind") && !url.searchParams.has("rootUri"),
    { timeout: UI_TIMEOUT_MS },
  );
 }

 async function main() {
  await fsp.mkdir(OUT_DIR, { recursive: true });
-  const localRoot = fs.mkdtempSync(path.join(os.tmpdir(), "mnote-cloud-switch-local-"));
-  fs.writeFileSync(path.join(localRoot, "README.md"), "# Local README\n", "utf8");
+  fs.mkdirSync(MANAGED_MY_SPACE_ROOT, { recursive: true });
+  let localRoot = "";

  const browser = await chromium.launch({ headless: process.env.HEADFUL !== "1" });
  const context = await browser.newContext({ viewport: { width: 1440, height: 960 } });
  const page = await context.newPage();
-  const result = { ok: false, baseUrl: BASE_URL, localRoot, cloudTarget: null, localState: null, returnedState: null };
+  const result = { ok: false, baseUrl: BASE_URL, localRoot, homeTarget: null, localState: null, returnedState: null };

  try {
    await quickLogin(page);
    await page.goto(BASE_URL, { waitUntil: "domcontentloaded", timeout: UI_TIMEOUT_MS });
-    result.cloudTarget = await ensureCloudDocument(page);
+    result.homeTarget = await ensureHomeWorkspaceTarget(page);
+    localRoot = fs.mkdtempSync(path.join(MANAGED_MY_SPACE_ROOT, "task441-local-"));
+    result.localRoot = localRoot;
+    fs.writeFileSync(path.join(localRoot, "README.md"), "# Local README\n", "utf8");
    await openLocalFolder(page, localRoot);
    result.localState = await readCloudState(page);
-    assert(result.localState.storageValue === result.cloudTarget.workspaceId, `进入本地文件夹前应记住真实云空间 workspaceId: ${JSON.stringify(result)}`);
+    assert(
+      !result.localState.storageValue || !result.localState.storageValue.startsWith("local-ws:"),
+      `进入普通本地文件夹不应把我的空间 local-ws 写成云 workspace: ${JSON.stringify(result)}`,
+    );

    await switchCloud(page);
-    await page.waitForURL((url) => url.searchParams.get("workspaceId") === result.cloudTarget.workspaceId, {
-      timeout: UI_TIMEOUT_MS,
-    });
    await openFileTree(page);
-    await page.waitForFunction(
-      (rowId) => Boolean(document.querySelector(`#sidebar-file-tree-root .tree-row[data-row-id="${CSS.escape(rowId)}"]`)),
-      result.cloudTarget.rowId,
-      { timeout: UI_TIMEOUT_MS },
-    );
    result.returnedState = await readCloudState(page);

-    assert.equal(result.returnedState.workspaceId, result.cloudTarget.workspaceId, "切回云空间后应恢复原 workspaceId");
-    assert.equal(result.returnedState.storageValue, result.cloudTarget.workspaceId, "lastCloudWorkspaceId 不应被 default 污染");
+    assert.equal(result.returnedState.workspaceId, result.homeTarget.workspaceId, "切回我的空间后应恢复默认本地 workspaceId");
+    assert.equal(result.returnedState.sourceKind, "local_folder", "切回我的空间后仍应走 local_folder 主链");
+    assert.equal(result.returnedState.rootUri, result.homeTarget.rootUri, "切回我的空间后应恢复默认 my-space rootUri");
+    assert.notEqual(result.returnedState.rootUri, fileUrl(localRoot), "切回我的空间后不能继续停留在刚打开的普通本地文件夹");
    assert.notEqual(result.returnedState.storageValue, "default", "lastCloudWorkspaceId 不能是 synthetic default");
-    assert.equal(result.returnedState.localRows, 0, "切回云空间后不应保留本地文件夹 row");
-    assert(
-      result.returnedState.docRows.some((row) => row.rowId === result.cloudTarget.rowId),
-      `切回云空间后原云空间页面 row 应恢复: ${JSON.stringify(result.returnedState)}`,
-    );
+    assert(!result.returnedState.storageValue.startsWith("local-ws:"), "lastCloudWorkspaceId 不能是 local-ws:*");
+    assert(result.returnedState.localRows > 0, `切回我的空间后 File Tree 应恢复本地 row: ${JSON.stringify(result.returnedState)}`);

    result.ok = true;
  } finally {
    await fsp.writeFile(path.join(OUT_DIR, "result.json"), `${JSON.stringify(result, null, 2)}\n`, "utf8");
    await browser.close().catch(() => {});
-    fs.rmSync(localRoot, { recursive: true, force: true });
+    if (localRoot) fs.rmSync(localRoot, { recursive: true, force: true });
  }

  console.log(JSON.stringify(result, null, 2));
@@ -109,6 +109,96 @@ async function waitForFileExists(filePath, timeoutMs) {
  return fs.existsSync(filePath);
 }

+async function waitForFileContent(filePath, predicate, timeoutMs) {
+  const startedAt = Date.now();
+  let lastContent = "";
+  while (Date.now() - startedAt < timeoutMs) {
+    if (fs.existsSync(filePath)) {
+      lastContent = fs.readFileSync(filePath, "utf8");
+      if (predicate(lastContent)) return { ok: true, content: lastContent };
+    }
+    await new Promise((resolve) => setTimeout(resolve, 150));
+  }
+  return { ok: false, content: lastContent };
+}
+
+async function waitForPrimaryAttachment(page, fileName) {
+  const link = page
+    .locator('.document-pane[data-pane-role="primary"] .editor-surface .ProseMirror a[href*="/api/local-folder/files/open"]', {
+      hasText: fileName,
+    })
+    .first();
+  await link.waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
+  await page.waitForFunction(
+    (name) => {
+      const editor = document.querySelector('.document-pane[data-pane-role="primary"] .editor-surface .ProseMirror');
+      const link = Array.from(editor?.querySelectorAll('a[href*="/api/local-folder/files/open"]') || [])
+        .find((node) => node instanceof HTMLAnchorElement && (node.textContent || "").includes(name));
+      return link instanceof HTMLAnchorElement
+        && (link.classList.contains("mnote-uploaded-attachment-row") || getComputedStyle(link).display === "inline-flex");
+    },
+    fileName,
+    { timeout: UI_TIMEOUT_MS },
+  );
+  return link;
+}
+
+async function selectPrimaryAttachmentLink(page, fileName) {
+  await page.evaluate((name) => {
+    const editor = document.querySelector('.document-pane[data-pane-role="primary"] .editor-surface .ProseMirror');
+    if (!(editor instanceof HTMLElement)) throw new Error("editor_missing");
+    const link = Array.from(editor.querySelectorAll("a")).find((node) => (
+      node instanceof HTMLAnchorElement && (node.textContent || "").includes(name)
+    ));
+    if (!(link instanceof HTMLAnchorElement)) throw new Error(`attachment_link_missing:${name}`);
+    const range = document.createRange();
+    range.selectNode(link);
+    const selection = window.getSelection();
+    if (!selection) throw new Error("selection_missing");
+    selection.removeAllRanges();
+    selection.addRange(range);
+    editor.focus();
+  }, fileName);
+}
+
+async function deleteAttachmentByKeyboard(page, fileName) {
+  await waitForPrimaryAttachment(page, fileName);
+  await selectPrimaryAttachmentLink(page, fileName);
+  await page.keyboard.press("Backspace");
+}
+
+async function deleteAttachmentByBlockHandle(page, fileName) {
+  const link = await waitForPrimaryAttachment(page, fileName);
+  const box = await link.boundingBox();
+  assert(box, `附件 ${fileName} 缺少可点击区域`);
+  await page.mouse.move(box.x + Math.min(12, box.width / 2), box.y + box.height / 2, { steps: 8 });
+  const trigger = page.locator('[data-testid="block-drag-handle-trigger"]').first();
+  await trigger.waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
+  await trigger.click({ timeout: UI_TIMEOUT_MS });
+  const menu = page.locator('[data-testid="block-drag-menu"]').first();
+  await menu.waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
+  await page.locator('[data-testid="block-drag-menu-item-delete"]').first().click({ timeout: UI_TIMEOUT_MS });
+}
+
+function writeTwoAttachmentPage(root, relativePath, resourceDirName, heading) {
+  const resourceDir = path.join(root, resourceDirName);
+  fs.mkdirSync(resourceDir, { recursive: true });
+  fs.writeFileSync(path.join(resourceDir, "first.md"), "# First\n\n第一个附件\n", "utf8");
+  fs.writeFileSync(path.join(resourceDir, "second.md"), "# Second\n\n第二个附件\n", "utf8");
+  fs.writeFileSync(
+    path.join(root, relativePath),
+    [
+      `# ${heading}`,
+      "",
+      `[first.md](${resourceDirName}/first.md)`,
+      "",
+      `[second.md](${resourceDirName}/second.md)`,
+      "",
+    ].join("\n"),
+    "utf8",
+  );
+}
+
 // ─── main ────────────────────────────────────────────────────────────────────

 async function main() {
@@ -141,6 +231,10 @@ async function main() {
  // 为 Check 6 准备一个带 H1 的文件（文件名不含空格，避免空格编码干扰测试）
  fs.writeFileSync(path.join(root, "MyNotes.md"), "# Body Heading\n\n正文内容\n", "utf8");

+  // 为 Check 7 准备两个删除附件引用的独立页面，避免不同删除路径互相污染。
+  writeTwoAttachmentPage(root, "DeleteKeyboard.md", "DeleteKeyboard", "Delete Keyboard");
+  writeTwoAttachmentPage(root, "DeleteHandle.md", "DeleteHandle", "Delete Handle");
+
  // 为 Check 5 准备足够的文件树条目来产生可滚动区域
  fs.mkdirSync(path.join(root, "docs"), { recursive: true });
  for (let i = 0; i < 30; i++) {
@@ -586,6 +680,99 @@ async function main() {
      }
    }

+    // ──────────────────────────────────────────────────────────────────────────
+    // Check 7: 主编辑区删除一个附件引用时，只删除正文链接，不级联删除真实文件；
+    //          相邻附件仍保持可点击附件块，手柄删除刷新后不回来。
+    // ──────────────────────────────────────────────────────────────────────────
+    {
+      const checkId = "editor-delete-one-attachment-preserves-adjacent";
+      try {
+        const keyboardPath = "DeleteKeyboard.md";
+        const keyboardFile = path.join(root, keyboardPath);
+        await page.goto(documentUrl(root, keyboardPath), {
+          waitUntil: "domcontentloaded",
+          timeout: UI_TIMEOUT_MS,
+        });
+        await page.locator('.document-pane[data-pane-role="primary"] .editor-surface .ProseMirror').first().waitFor({
+          state: "visible",
+          timeout: UI_TIMEOUT_MS,
+        });
+        await waitForPrimaryAttachment(page, "first.md");
+        await waitForPrimaryAttachment(page, "second.md");
+        await deleteAttachmentByKeyboard(page, "second.md");
+
+        const keyboardPersisted = await waitForFileContent(
+          keyboardFile,
+          (content) => content.includes("[first.md](DeleteKeyboard/first.md)") && !content.includes("second.md"),
+          UI_TIMEOUT_MS,
+        );
+        assert(
+          keyboardPersisted.ok,
+          `Backspace 删除第二个附件后，Markdown 应保留 first 链接且移除 second。实际内容:\n${keyboardPersisted.content}`,
+        );
+        assert(fs.existsSync(path.join(root, "DeleteKeyboard", "first.md")), "Backspace 删除引用不应删除 first.md 真实文件");
+        assert(fs.existsSync(path.join(root, "DeleteKeyboard", "second.md")), "Backspace 删除引用不应删除 second.md 真实文件");
+
+        await page.reload({ waitUntil: "domcontentloaded", timeout: UI_TIMEOUT_MS });
+        await waitForPrimaryAttachment(page, "first.md");
+        const keyboardSecondVisible = await page
+          .locator('.document-pane[data-pane-role="primary"] .editor-surface .ProseMirror a', { hasText: "second.md" })
+          .first()
+          .isVisible()
+          .catch(() => false);
+        assert(!keyboardSecondVisible, "Backspace 删除后刷新，second.md 引用不应回来");
+
+        const handlePath = "DeleteHandle.md";
+        const handleFile = path.join(root, handlePath);
+        await page.goto(documentUrl(root, handlePath), {
+          waitUntil: "domcontentloaded",
+          timeout: UI_TIMEOUT_MS,
+        });
+        await page.locator('.document-pane[data-pane-role="primary"] .editor-surface .ProseMirror').first().waitFor({
+          state: "visible",
+          timeout: UI_TIMEOUT_MS,
+        });
+        await waitForPrimaryAttachment(page, "first.md");
+        await waitForPrimaryAttachment(page, "second.md");
+        await deleteAttachmentByBlockHandle(page, "second.md");
+
+        const handlePersisted = await waitForFileContent(
+          handleFile,
+          (content) => content.includes("[first.md](DeleteHandle/first.md)") && !content.includes("second.md"),
+          UI_TIMEOUT_MS,
+        );
+        assert(
+          handlePersisted.ok,
+          `手柄删除第二个附件后，Markdown 应保留 first 链接且移除 second。实际内容:\n${handlePersisted.content}`,
+        );
+        assert(fs.existsSync(path.join(root, "DeleteHandle", "first.md")), "手柄删除引用不应删除 first.md 真实文件");
+        assert(fs.existsSync(path.join(root, "DeleteHandle", "second.md")), "手柄删除引用不应删除 second.md 真实文件");
+
+        await page.reload({ waitUntil: "domcontentloaded", timeout: UI_TIMEOUT_MS });
+        await waitForPrimaryAttachment(page, "first.md");
+        const handleSecondVisible = await page
+          .locator('.document-pane[data-pane-role="primary"] .editor-surface .ProseMirror a', { hasText: "second.md" })
+          .first()
+          .isVisible()
+          .catch(() => false);
+        assert(!handleSecondVisible, "手柄删除后刷新，second.md 引用不应回来");
+
+        checks[checkId] = {
+          ok: true,
+          message: "Backspace 与手柄删除单个附件引用后，相邻附件仍是可点击附件块，真实文件保留，刷新后被删引用不回来",
+          keyboardContent: keyboardPersisted.content,
+          handleContent: handlePersisted.content,
+        };
+      } catch (err) {
+        overallOk = false;
+        checks[checkId] = {
+          ok: false,
+          message: `删除单个附件引用检查失败: ${err.message}`,
+          error: err.stack,
+        };
+      }
+    }
+
    // ── 截图 ──
    {
      const shotTimestamp = Date.now();