fix(memory-wiki): preserve fs-safe write diagnostics (#83839)

clawsweeper[bot] · TurboTheTurtle · Takhoffman · web-flow · commit 1a242cd4f501 · 2026-05-19T01:24:54.000Z
Summary: - The branch narrows Memory Wiki imported-source `FsSafeError` wrapping, adds directory-collision bridge regressions, and adds a changelog entry crediting the source PR. - Reproducibility: yes. Source inspection shows current main catches all imported-source `FsSafeError`s with symlink wording, and the linked source PR includes live bridge-sync output for the directory-collision path. Automerge notes: - PR branch already contained follow-up commit before automerge: fix(memory-wiki): normalize source page stat guard - PR branch already contained follow-up commit before automerge: fix(memory-wiki): preserve fs-safe write diagnostics Validation: - ClawSweeper review passed for head e38ae3b. - Required merge gates passed before the squash merge. Prepared head SHA: e38ae3b Review: #83839 (comment) Co-authored-by: Andy Ye <35905412+TurboTheTurtle@users.noreply.github.com> Co-authored-by: clawsweeper <274271284+clawsweeper[bot]@users.noreply.github.com> Co-authored-by: clawsweeper[bot] <274271284+clawsweeper[bot]@users.noreply.github.com> Approved-by: takhoffman Co-authored-by: takhoffman <781889+takhoffman@users.noreply.github.com>
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -51,6 +51,7 @@ Docs: https://docs.openclaw.ai
 ### Fixes
 
 - Memory/search: scan the JS-side fallback vector path (used when the sqlite-vec index is unavailable or has a mismatched dimension) in bounded rowid batches and yield to the event loop between batches so large chunk tables can no longer pin the Node.js main thread for multi-second windows. Also keeps the SQL prepared statement rooted in a local so node:sqlite cannot finalize it mid-scan under heap pressure. Fixes #81172. Thanks @dev23xyz-oss.
+- Memory Wiki: preserve fs-safe diagnostics when bridge source page writes fail for non-symlink filesystem safety reasons, so directory collisions are reported with the underlying error code. (#83776) Thanks @TurboTheTurtle.
 - CLI/update: bypass npm freshness filters consistently during managed package and plugin installs so freshly published release plugins remain installable. Thanks @jalehman.
 - CLI/update: guide root-owned npm install EACCES recovery by stopping the managed Gateway before manual package replacement, then reinstalling and restarting the service. Fixes #83747. (#83757) Thanks @brokemac79.
 - Agents/subagents: keep collect-mode announce queues batching unresolved-origin items with compatible same-route messages and resume collection after a true cross-channel drain when a later compatible batch remains. Fixes #83577.
diff --git a/extensions/memory-wiki/src/bridge.test.ts b/extensions/memory-wiki/src/bridge.test.ts
@@ -346,6 +346,80 @@ describe("syncMemoryWikiBridgeSources", () => {
     await expect(fs.readFile(externalTarget, "utf8")).resolves.toBe("external target\n");
   });
 
+  async function createDirectoryCollisionFixture(params: {
+    workspaceName: string;
+    vaultName: string;
+    populateDirectory?: boolean;
+  }) {
+    const workspaceDir = await createBridgeWorkspace(params.workspaceName);
+    const { rootDir: vaultDir, config } = await createVault({
+      rootDir: nextCaseRoot(params.vaultName),
+      config: {
+        vaultMode: "bridge",
+        bridge: {
+          enabled: true,
+          readMemoryArtifacts: true,
+          indexMemoryRoot: true,
+        },
+      },
+    });
+    const memoryPath = path.join(workspaceDir, "MEMORY.md");
+    await fs.writeFile(memoryPath, "# Durable Memory\n", "utf8");
+    registerBridgeArtifacts([
+      {
+        kind: "memory-root",
+        workspaceDir,
+        relativePath: "MEMORY.md",
+        absolutePath: memoryPath,
+        agentIds: ["main"],
+        contentType: "markdown",
+      },
+    ]);
+    const appConfig: OpenClawConfig = {
+      agents: {
+        list: [{ id: "main", default: true, workspace: workspaceDir }],
+      },
+    };
+    const first = await syncMemoryWikiBridgeSources({ config, appConfig });
+    const pagePath = first.pagePaths[0] ?? "";
+    const pageAbsPath = path.join(vaultDir, pagePath);
+    await fs.rm(pageAbsPath);
+    await fs.mkdir(pageAbsPath);
+    if (params.populateDirectory) {
+      await fs.writeFile(path.join(pageAbsPath, "child.md"), "blocking child\n", "utf8");
+    }
+    await fs.writeFile(memoryPath, "# Updated Durable Memory\n", "utf8");
+    return { appConfig, config, pageAbsPath };
+  }
+
+  it("reports non-symlink bridge source write safety failures without symlink wording", async () => {
+    const { appConfig, config } = await createDirectoryCollisionFixture({
+      workspaceName: "not-file-workspace",
+      vaultName: "not-file-vault",
+      populateDirectory: true,
+    });
+
+    const second = syncMemoryWikiBridgeSources({ config, appConfig });
+    await expect(second).rejects.toThrow(
+      /Refusing to write imported source page \((not-empty|not-file|path-mismatch)\): sources\//u,
+    );
+    await expect(second).rejects.not.toThrow("through symlink");
+  });
+
+  it("does not remove empty directory bridge source collisions as hardlinks", async () => {
+    const { appConfig, config, pageAbsPath } = await createDirectoryCollisionFixture({
+      workspaceName: "empty-directory-workspace",
+      vaultName: "empty-directory-vault",
+    });
+
+    const second = syncMemoryWikiBridgeSources({ config, appConfig });
+    await expect(second).rejects.toThrow(
+      /Refusing to write imported source page \((not-file|path-mismatch)\): sources\//u,
+    );
+    await expect(second).rejects.not.toThrow("through symlink");
+    await expect(fs.stat(pageAbsPath)).resolves.toSatisfy((stat) => stat.isDirectory());
+  });
+
   it("replaces bridge source page hardlinks without clobbering their target", async () => {
     const workspaceDir = await createBridgeWorkspace("hardlink-workspace");
     const { rootDir: vaultDir, config } = await createVault({
diff --git a/extensions/memory-wiki/src/source-page-shared.ts b/extensions/memory-wiki/src/source-page-shared.ts
@@ -8,6 +8,23 @@ import {
 
 type ImportedSourceState = Parameters<typeof shouldSkipImportedSourceWrite>[0]["state"];
 
+type FileStatLike = {
+  isFile?: unknown;
+  nlink?: unknown;
+};
+
+function isRegularFileStat(value: unknown): value is FileStatLike & { nlink: number } {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const stat = value as FileStatLike;
+  const isFile =
+    typeof stat.isFile === "function"
+      ? (stat.isFile as () => boolean).call(stat)
+      : stat.isFile === true;
+  return isFile && typeof stat.nlink === "number";
+}
+
 export async function writeImportedSourcePage(params: {
   vaultRoot: string;
   syncKey: string;
@@ -51,12 +68,18 @@ export async function writeImportedSourcePage(params: {
   const existing = pageStat ? await vault.readText(params.pagePath).catch(() => "") : "";
   if (existing !== rendered) {
     try {
-      if (pageStat && pageStat.nlink > 1) {
+      if (isRegularFileStat(pageStat) && pageStat.nlink > 1) {
         await vault.remove(params.pagePath);
       }
       await vault.write(params.pagePath, rendered);
     } catch (error) {
       if (error instanceof FsSafeError) {
+        if (error.code !== "symlink" && error.code !== "path-alias") {
+          throw new Error(
+            `Refusing to write imported source page (${error.code}): ${params.pagePath}: ${error.message}`,
+            { cause: error },
+          );
+        }
         throw new Error(
           `Refusing to write imported source page through symlink: ${params.pagePath}`,
           { cause: error },
