@@ -215,6 +215,64 @@ describe("safeWriteJson lock key under a peer commit", () => {
 		expect(JSON.parse(await fs.readFile(referentB, "utf8"))).toEqual({ id: "task-1" })
 		expect(JSON.parse(await fs.readFile(referentA, "utf8"))).toEqual({ id: "a" })
 	})
+	it("refuses to publish when the captured target sits under a different lock than the one held", async () => {
+		const order: string[] = []
+		const dir = await makeDir("captured-")
+		const referentA = path.join(dir, "history_item_a.json")
+		const referentB = path.join(dir, "history_item_b.json")
+		currentLink = path.join(dir, "link.json")
+		await fs.writeFile(referentA, JSON.stringify({ id: "a" }), "utf8")
+		await fs.writeFile(referentB, JSON.stringify({ id: "b" }), "utf8")
+
+		// A peer retargets the alias from A to B while this writer is taking A's lock, and moves it back
+		// to A before the flow recomputes the key under that lock. The recomputation therefore agrees
+		// with the key held, the loop that would move the lock to the current referent breaks on its
+		// first pass, and the only thing standing between this write and the commit rename is the
+		// target it captured while the alias pointed at B. A check that re-derives that target from a
+		// second lookup of the alias sees A, agrees with the key it holds, and renames B's contents
+		// away while still holding A's lock. A check that canonicalizes the captured target sees B,
+		// disagrees with the key A, and refuses. The alias lookups below record the A to B to A rather
+		// than narrating it, so the row shows the sequence it depends on.
+		const aliasLookups: string[] = []
+		mockedRealpath.mockImplementation(async (target) => {
+			const spelling = String(target)
+			if (spelling !== currentLink) {
+				return spelling
+			}
+			const referent = aliasLookups.length === 1 ? referentB : referentA
+			aliasLookups.push(referent)
+			return referent
+		})
+		mockedLstat.mockImplementation(async (target) => symlinkStat(target))
+		mockedReadlink.mockImplementation(async (target) =>
+			target === currentLink ? referentA : Promise.reject(new Error("not a link")),
+		)
+		mockedAcquireFileLock.mockImplementation(async (key) => {
+			order.push(key === referentA ? "acquire:A" : "acquire:other")
+			return async () => {
+				order.push(key === referentA ? "release:A" : "release:other")
+			}
+		})
+
+		await expect(safeWriteJson(currentLink, { id: "task-1" })).rejects.toThrow(
+			"the resolved target kept changing while acquiring the lock",
+		)
+
+		// The alias moved A to B while the lock was taken and back to A before the key recomputation.
+		// The mismatch belongs to the captured target, not to the alias, which is why the guard has to
+		// read the target this write is about to rename onto instead of looking the alias up again.
+		expect(aliasLookups).toEqual([referentA, referentB, referentA])
+		// The recomputation agreed with the held key, so no lock was moved: A is the only lock this
+		// write acquired, and it is the lock the finally released.
+		expect(order).toEqual(["acquire:A", "release:A"])
+		expect(mockedAcquireFileLock.mock.calls.map((call) => call[0])).toEqual([referentA])
+		// Refused before the merge read and before staging, so nothing was written beside either target.
+		const left = await fs.readdir(dir)
+		expect(left.filter((entry) => entry.includes(".new_") || entry.includes(".bak_"))).toEqual([])
+		// Both targets still hold the bytes they had before this write tried.
+		expect(JSON.parse(await fs.readFile(referentA, "utf8"))).toEqual({ id: "a" })
+		expect(JSON.parse(await fs.readFile(referentB, "utf8"))).toEqual({ id: "b" })
+	})
 })
 
 it("does not log a cleanup error when the safety net finds the temp file already gone", async () => {