Artifact republished with stale data payload while template stays current (repeated 3x)

## Summary

A private Artifact (a self-contained dashboard: static HTML/CSS/JS shell + a `` block holding the current dataset) has been silently republished with a **stale data payload** three times over the course of one long interactive session, while the surrounding HTML/CSS/JS template each time matched the most recently published (correct, current) version.

## What we observed

- The publish flow for this artifact is: edit a local `.html` file → publish via the Artifact tool → the tool replaces the whole page content at a stable URL.
- Partway through the session, a `task-notification` of type `artifact-changed` fired, saying the artifact "appears to have been republished elsewhere (by another session, or by someone saving from the page itself)."
- Reading the live artifact after each notification showed: the HTML/CSS/JS structure exactly matched our own most recent publish (byte-identical, including features added moments earlier), but the embedded JSON data block had reverted to an **older snapshot** — specifically, the same computed total (to the cent, i.e. many decimal digits of precision matching) reappeared identically across all three incidents, hours apart, interleaved with several of our own successful publishes carrying the correct/updated value in between.
- This happened 3 times total during the session.

## What we ruled out

- **Not a local race condition from rapid successive publishes in this session**: if it were, the reverted value would vary depending on which of our own earlier publishes got replayed. Instead, the exact same value (down to many decimal places) reappeared every time, including on the 3rd occurrence — well after we'd stopped publishing that old value and after several newer publishes had gone out with updated numbers in between.
- **Not caused by local file state**: verified the local source file on disk matched the correct/current data at the moment of each incident (mtimes and content checked directly).
- **Not another interactive session on the same machine**: this session used `ListAgents` to enumerate 4 other local interactive Claude Code sessions plus 1 remote/cloud session, and messaged each one directly (cross-session `SendMessage`) asking if it was touching this artifact/repo. All 4 local sessions replied, each confirming a different working directory and a different artifact they were publishing to, with no matching script names in their repos. The remote session never replied.
- **Not another device**: the user confirmed they had no other Claude Code session or device open pointed at this project.
- **Never pushed to a git remote**: all local commits for this project stayed local-only during the session, so no other clone/checkout could have picked up the newer HTML template — yet the newer template kept showing up paired with the older data, which is the part that doesn't fit a simple "someone has a stale local checkout" explanation either (they'd need the *template* to be current too).

## Suspected cause

Given the template was always current but the data payload reverted to one specific frozen snapshot multiple times, this looks like a platform-side caching or version-reconciliation issue in the Artifact publish/versioning pipeline — e.g., an old cached version of the page (or of just its data block) occasionally getting served back and re-recorded as a new "version," rather than any client (session/device) actually publishing that stale content on purpose.

## Impact

Low severity for us (private artifact, caught and corrected each time via the `artifact-changed` notification + re-publish), but confusing/alarming, and could cause a viewer to see materially wrong data on the page between when it happens and when it's next noticed and fixed.

## Environment

- Claude Code (CLI), Artifact tool (`Artifact` action `publish`/`read`), private artifact on claude.ai/code/artifact/…
- Reported at the request of the artifact's owner, from an interactive Claude Code session that observed and diagnosed this in real time.

Start with the Artifact publish/read flow and the artifact-changed task notification described in the report. No repository file, test, or entry point is identified; done would require isolating why the same stale JSON snapshot can be republished while the template remains current and adding coverage for the reproduced behavior.

Scritto dal modello di indicizzazione a partire dal testo della issue.