lavish-axi 0.1.82 → 0.1.83

package/README.md

@@ -211,7 +211,9 @@ pnpm link
   In the annotation card, Enter queues the annotation, Shift+Enter inserts a newline, and Ctrl+Enter (Cmd+Enter on macOS) queues it and sends all queued prompts immediately. Escape closes the card, same as Cancel, but only while it is empty (no text, no attachment); with unsent text or an attachment present, Escape does nothing rather than risk discarding it.
   While editing a queued note, Enter saves it, Shift+Enter inserts a newline, and Escape discards the edit.
   Cmd+I or Ctrl+I toggles between annotate and explore mode from either the browser chrome or the artifact iframe, including while focus is in a textarea or control.
+  In annotate mode a plain click on a link annotates it; Ctrl+click (Cmd+click on macOS) follows the link instead, opening it in a new tab as the browser normally would, without leaving annotate mode.
 - **Agent presence** - The browser shows when no agent is listening, keeps queued feedback for the next successful `lavish-axi poll` send even across reloads, and keeps human feedback actions available while the agent is working because the server queues them for the next poll. An agent reply concludes delivered work and returns presence to waiting (see the CLI Reference for reply and poll commands). A supervisor-owned process listener is shown as an external listener rather than an idle captain turn.
+- **Delivery receipts** - Every note you have sent carries three emoji under it that light up in turn: 👀 **Seen** when a `lavish-axi poll` takes the note, 🛠️ **Working** when the artifact file changes after that, and ✅ **Done** when the agent replies. A step that has not happened yet is the same emoji greyed out. All three come from what the server observes; the agent does nothing extra. Until 👀 lights, the row says why: no agent is listening, or the agent is busy and the note is delivered on its next poll. A note answered without touching the artifact goes Seen to Done with Working still grey. A reply marks every note the agent has seen as Done, not notes still waiting for a poll. Each emoji names its step and time on hover and to screen readers. Notes sent before receipts existed show no receipt row.
   In a Herdr-managed pane, set `LAVISH_AXI_HERDR_CHIME=1` to show a Herdr request notification and play its chime once an indefinite poll enters the waiting state. Immediate queued feedback and timed debug polls do not trigger a notification. The integration is off unless both `LAVISH_AXI_HERDR_CHIME` and Herdr's `HERDR_ENV` session marker equal `1`; leaving either unset or using any other value opts out. Notification delivery runs without blocking feedback: if Herdr is unavailable, rejects the notification, stalls, or fails, the poll continues unchanged.
   Closing the last review tab while a poll is active starts a 10-second reconnect grace period. A reload or quick reconnect keeps an active poll waiting; if every review stays disconnected, the poll returns `browser_disconnected` without ending the resumable session, and the agent asks whether to reopen or end it instead of acting uninvited.
   The no-timeout poll always writes an immediate stderr banner so it is visibly not hung; it adds the periodic stderr wait ticks only in an interactive terminal, so when stderr is piped (as under agent harnesses) the captured output carries no tick noise. Stdout always stays reserved for the final response; if the poll is interrupted or times out before feedback arrives, re-run it because feedback remains queued until delivery. Poll delivery consumes the response, so read the complete response before truncating or filtering it.
@@ -296,7 +298,7 @@ For flows, architecture, state, or sequence diagrams, open the diagram playbook
 | `lavish-axi share`       | `--token <t>`               | Attach an optional bearer token (`LAVISH_AXI_HTML_APP_TOKEN`) when creating a page; never required, and rejected on a republish or `--unpublish`, where the `update_key` is the credential.                                                                                                                                   |
 | `lavish-axi poll`        | `--owner <label>`           | Identify the process listening for this session; the non-empty label appears in the home session listing. `none` is reserved for sessions without a listener. A second concurrent poll is refused instead of silently returning `waiting`.                                                                                    |
 | `lavish-axi poll`        | `--takeover`                | Explicitly displace the current poll listener. The displaced poll exits with typed `LISTENER_REPLACED`; without this flag, the new poll fails with typed `LISTENER_ACTIVE`.                                                                                                                                                   |
-| `lavish-axi poll`        | `--agent-reply "..."`       | Show a concise agent reply in the existing browser chat, conclude delivered work, and return presence to waiting before polling again. Keep replies concise by default.                                                                                                                                                       |
+| `lavish-axi poll`        | `--agent-reply "..."`       | Show a concise agent reply in the existing browser chat, conclude delivered work (every note the agent has seen is marked Done), and return presence to waiting before polling again. Keep replies concise by default.                                                                                                        |
 | `lavish-axi poll`        | `--agent-reply-file <path>` | When a longer reply is genuinely necessary, read Markdown from a file (`-` for stdin) so newlines survive quoting. Use blank-line paragraphs, `- ` / `1. ` lists, and `## ` headings so the Conversation panel renders it scannably. The Markdown subset is under Feedback controls. Cannot be combined with `--agent-reply`. |
 | `lavish-axi poll`        | `--timeout-ms <ms>`         | Test/debug escape hatch only; agents should normally omit it and leave the long poll running.                                                                                                                                                                                                                                 |
 | `lavish-axi reply`       | `--agent-reply "..."`       | Concise reply text. Required unless `--agent-reply-file` is set. The command exits 0 only after the server accepts it. Empty text is refused. Prefer this over `poll --agent-reply` when you are not about to long-poll.                                                                                                      |

package/dist/chrome-client.js

@@ -912,10 +912,75 @@ function chatBubbleHtml(entry) {
     "<small>You</small>" +
     anchorHtml(entry.anchor) +
     userBubbleTextHtml(entry, entry.text) +
-    bubbleAttachmentsHtml(entry)
+    bubbleAttachmentsHtml(entry) +
+    receiptHtml(entry)
   );
 }
 
+// Delivery receipt (docs/delivery-acks.md): the per-note view of what the server observed. Seen,
+// Working, and Done are stamps on the entry, so the row is derived from it on every render and
+// never tracked here. Before Seen, the row says why, from the presence the live stream reports.
+// The three steps are the emoji of the Telegram ack protocol the receipt mirrors (seen, working,
+// done); a step that has not happened is the same glyph dimmed, and every step carries its label
+// and time as `title` and `aria-label`, so hover and screen readers both say the word.
+const RECEIPT_EMOJI = { Seen: "\u{1F440}", Working: "\u{1F6E0}️", Done: "✅" };
+
+function receiptTime(at) {
+  const date = new Date(String(at));
+  return Number.isNaN(date.getTime())
+    ? String(at)
+    : date.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+}
+
+function receiptStepHtml(label, at) {
+  const ticked = Boolean(at);
+  const text = ticked ? label + " " + receiptTime(at) : label + ": not yet";
+  return (
+    '<span class="receipt-step' +
+    (ticked ? " is-done" : "") +
+    '" role="img" aria-label="' +
+    escapeHtml(text) +
+    '" title="' +
+    escapeHtml(text) +
+    '">' +
+    RECEIPT_EMOJI[label] +
+    "</span>"
+  );
+}
+
+// Every branch must be true where it is shown: `waiting` is no poll at all, `listening` is a poll
+// that will take the note within milliseconds, and `working` or an external listener is an agent
+// whose next poll will take it.
+function receiptNoteText() {
+  if (agentPresence === "waiting") return "No agent is listening";
+  if (agentPresence === "listening") return "Delivering";
+  return "Agent is busy; delivered on its next poll";
+}
+
+// A transcript entry from before receipts existed (`receipt: "none"`, marked by the server once at
+// load) gets no row: nothing was ever observed about it, and an empty row would read as "never seen".
+function hasReceipt(entry) {
+  return Boolean(entry) && entry.receipt !== "none";
+}
+
+function receiptHtml(entry) {
+  if (!hasReceipt(entry)) return "";
+  return (
+    '<div class="receipt">' +
+    receiptStepHtml("Seen", entry.delivered_at) +
+    receiptStepHtml("Working", entry.working_at) +
+    receiptStepHtml("Done", entry.done_at) +
+    (entry.delivered_at ? "" : '<span class="receipt-note">' + escapeHtml(receiptNoteText()) + "</span>") +
+    "</div>"
+  );
+}
+
+// Only the pre-Seen line names the live presence, so a presence change rewrites that line alone.
+// Rebuilding the bubble would also rebuild its thumbnails and undo an "Image expired" placeholder.
+function refreshUnseenReceipts() {
+  for (const note of chatLog.querySelectorAll(".receipt-note")) note.textContent = receiptNoteText();
+}
+
 function addChat(entry, shouldScroll = true) {
   if (!entry || typeof entry !== "object") return;
   const role = entry.role === "agent" ? "agent" : "user";
@@ -1067,6 +1132,7 @@ function setAgentPresence(state) {
   agentPresence = state === "listening" || state === "external" || state === "working" ? state : "waiting";
   updateSendState();
   renderSheetSummary();
+  refreshUnseenReceipts();
   if (presenceBanner) presenceBanner.hidden = ended || agentPresence !== "waiting";
 
   // A supervisor-owned process-only listener is busy on the agent's behalf. It must not make the

package/dist/chrome.css

@@ -1301,6 +1301,38 @@ body.lavish {
   border-radius: 3px;
   padding: 0 3px;
 }
+/* Delivery receipt: the per-note view of agent presence (docs/delivery-acks.md). Three emoji
+   (seen, working, done) that light up as the server observes each step; a step that has not
+   happened is the same glyph greyed and dimmed, so the row always shows what is still to come. */
+.receipt {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  justify-content: flex-end;
+  gap: 4px 8px;
+  margin-top: 6px;
+  font-size: 13px;
+  line-height: 1.3;
+  color: var(--fg-faint);
+}
+.receipt-step {
+  display: inline-block;
+  filter: grayscale(1);
+  opacity: 0.3;
+  transition:
+    opacity 0.3s ease,
+    filter 0.3s ease;
+}
+.receipt-step.is-done {
+  filter: none;
+  opacity: 1;
+}
+.receipt-note {
+  font-size: 11px;
+  flex-basis: 100%;
+  text-align: right;
+  font-style: italic;
+}
 .bubble-attachments {
   display: flex;
   flex-wrap: wrap;

package/dist/cli.mjs

@@ -7146,6 +7146,11 @@ function createArtifactSdk(deriveQueueKey, isNativeInteractive = isNativeInterac
     (event) => {
       if (!annotationMode || isLavishUi(event.target) || isLavishAction(event.target) || isInteractiveControl(event.target))
         return;
+      if ((event.ctrlKey || event.metaKey) && /** @type {Element} */
+      event.target?.closest?.("a[href]")) {
+        ignoreNextClick = false;
+        return;
+      }
       event.preventDefault();
       event.stopPropagation();
       if (ignoreNextClick) {
@@ -8276,6 +8281,62 @@ function serializeChatSync(session) {
     chat_revision: Number.isSafeInteger(revision) && revision >= 0 ? revision : 0
   };
 }
+var RECEIPT_NONE = "none";
+function isUserEntry(entry) {
+  return Boolean(entry) && typeof entry === "object" && entry.role === "user" && entry.receipt !== RECEIPT_NONE;
+}
+function markPreReceipt(chat) {
+  let changed = false;
+  for (const entry of Array.isArray(chat) ? chat : []) {
+    if (!entry || typeof entry !== "object" || entry.role !== "user" || entry.receipt === RECEIPT_NONE) continue;
+    entry.receipt = RECEIPT_NONE;
+    changed = true;
+  }
+  return changed;
+}
+function stampDelivered(chat, seq, at) {
+  let changed = false;
+  for (const entry of Array.isArray(chat) ? chat : []) {
+    if (!isUserEntry(entry) || entry.delivered_at) continue;
+    entry.delivered_at = String(at);
+    entry.delivered_seq = seq;
+    changed = true;
+  }
+  return changed;
+}
+function unstampDelivery(chat, seq) {
+  let changed = false;
+  for (const entry of Array.isArray(chat) ? chat : []) {
+    if (!isUserEntry(entry) || entry.delivered_seq !== seq) continue;
+    delete entry.delivered_at;
+    delete entry.delivered_seq;
+    delete entry.working_at;
+    delete entry.done_at;
+    changed = true;
+  }
+  return changed;
+}
+function isOpenDelivery(entry, closedSeq) {
+  return isUserEntry(entry) && Boolean(entry.delivered_at) && !entry.done_at && entry.delivered_seq > closedSeq;
+}
+function stampWorking(chat, at, closedSeq = 0) {
+  let changed = false;
+  for (const entry of Array.isArray(chat) ? chat : []) {
+    if (!isOpenDelivery(entry, closedSeq) || entry.working_at) continue;
+    entry.working_at = String(at);
+    changed = true;
+  }
+  return changed;
+}
+function stampDone(chat, at, closedSeq = 0) {
+  let changed = false;
+  for (const entry of Array.isArray(chat) ? chat : []) {
+    if (!isOpenDelivery(entry, closedSeq)) continue;
+    entry.done_at = String(at);
+    changed = true;
+  }
+  return changed;
+}
 
 // src/server-log.js
 function formatServerLogLine(line, now = /* @__PURE__ */ new Date()) {
@@ -8504,6 +8565,14 @@ var SessionStore = class {
       // Compact prompt_id acks for bubbles evicted by the stored-chat byte bound. Reopening
       // must keep them: they are the settlement/dedup source once the visible entry is gone.
       chat_ack_ids: Array.isArray(existing.chat_ack_ids) ? existing.chat_ack_ids : [],
+      // Counts the takes that stamped Seen on chat entries (docs/delivery-acks.md). Reset on reopen
+      // and a later restore could un-stamp an older take's entries, so it is carried like chat.
+      delivery_seq: normalizeRevision(existing.delivery_seq),
+      // The last take of the rounds that have ended. Reopening starts a new round: a note an ended
+      // round left at Seen stays Seen, because a later round's edit or reply is not about it.
+      closed_delivery_seq: normalizeRevision(
+        existing.status === "ended" ? existing.delivery_seq : existing.closed_delivery_seq
+      ),
       updated_at: (/* @__PURE__ */ new Date()).toISOString()
     };
     state.sessions[key] = session;
@@ -8558,7 +8627,11 @@ var SessionStore = class {
         else delete prompt.attachments;
       }
     }
+    const deliverySeq = restoring ? normalizeRevision(payload.delivery_seq) : 0;
+    const unstamped = deliverySeq > 0 && unstampDelivery(session.chat, deliverySeq);
+    if (unstamped) session.chat_revision = normalizeRevision(session.chat_revision) + 1;
     if (rejected.length) {
+      if (unstamped) await this.writeState(state);
       return {
         rejected: rejected.slice(0, MAX_REPORTED_ATTACHMENT_REJECTIONS),
         caps: {
@@ -8885,12 +8958,14 @@ var SessionStore = class {
       if (prompts.length === 0 && artifactFailures.length === 0) {
         return alreadyEnded ? { status: "ended", ended_by: session.ended_by } : { status: "waiting" };
       }
+      const deliverySeq = normalizeRevision(session.delivery_seq) + 1;
       const result = {
         status: "feedback",
         dom_snapshot: session.dom_snapshot || "",
         prompts,
         ...artifactFailures.length > 0 ? { artifact_failures: artifactFailures } : {},
-        ...alreadyEnded ? { session_ended: true, ended_by: session.ended_by } : {}
+        ...alreadyEnded ? { session_ended: true, ended_by: session.ended_by } : {},
+        ...prompts.length > 0 ? { delivery_seq: deliverySeq } : {}
       };
       const deliveredNow = Date.now();
       const deliveredIds = /* @__PURE__ */ new Set();
@@ -8905,6 +8980,12 @@ var SessionStore = class {
       const current = [...deliveredIds].map((id) => ({ id, at: deliveredNow }));
       const historyRoom = Math.max(0, MAX_DELIVERED_ATTACHMENTS - current.length);
       session.delivered_attachments = [...carried.slice(-historyRoom), ...current];
+      if (prompts.length > 0) {
+        session.delivery_seq = deliverySeq;
+        if (stampDelivered(session.chat, deliverySeq, new Date(deliveredNow).toISOString())) {
+          session.chat_revision = normalizeRevision(session.chat_revision) + 1;
+        }
+      }
       session.prompts = [];
       session.artifact_failures = [];
       session.pending_prompts = 0;
@@ -8945,6 +9026,7 @@ var SessionStore = class {
       }
       if (requireOpen && session.status === "ended") return session;
       const at = (/* @__PURE__ */ new Date()).toISOString();
+      stampDone(session.chat, at, normalizeRevision(session.closed_delivery_seq));
       session.chat = [...session.chat || [], { role: "agent", text: String(text || ""), at }];
       applyTranscriptBound(session);
       session.chat_revision = normalizeRevision(session.chat_revision) + 1;
@@ -8953,6 +9035,22 @@ var SessionStore = class {
       return session;
     });
   }
+  // Working (docs/delivery-acks.md): the artifact changed after a delivery, so the agent is acting on
+  // what it was handed. Returns the session when a stamp landed and null when there was nothing to
+  // stamp, in which case state.json is not rewritten - the watcher fires on every save.
+  async markWorking(key) {
+    return this.runExclusive(async () => {
+      const state = await this.readState();
+      const session = state.sessions[key];
+      if (!session) return null;
+      const at = (/* @__PURE__ */ new Date()).toISOString();
+      if (!stampWorking(session.chat, at, normalizeRevision(session.closed_delivery_seq))) return null;
+      session.chat_revision = normalizeRevision(session.chat_revision) + 1;
+      session.updated_at = at;
+      await this.writeState(state);
+      return session;
+    });
+  }
   /**
    * @template T
    * @param {() => Promise<T>} operation
@@ -8995,7 +9093,13 @@ var SessionStore = class {
       const state = { sessions: parsed.sessions || {} };
       let changed = false;
       for (const session of Object.values(state.sessions)) {
-        if (!session || typeof session !== "object" || !applyTranscriptBound(session)) continue;
+        if (!session || typeof session !== "object") continue;
+        if (!("delivery_seq" in session)) {
+          session.delivery_seq = 0;
+          markPreReceipt(session.chat);
+          changed = true;
+        }
+        if (!applyTranscriptBound(session)) continue;
         session.chat_revision = normalizeRevision(session.chat_revision) + 1;
         changed = true;
       }
@@ -9950,7 +10054,12 @@ async function serve({
       if (clientKey === key) client.sendEvent(type, data);
     }
   }
-  events.on("reload", (key) => broadcastLiveEvent("reload", key));
+  events.on("reload", (key) => {
+    broadcastLiveEvent("reload", key);
+    store.markWorking(key).then((session) => {
+      if (session) events.emit("chat-sync", key, session);
+    }).catch((error) => writeLog(`[lavish] working stamp after reload failed: ${error?.message || error}`));
+  });
   events.on("agent-reply", (key, entry) => broadcastLiveEvent("agent-reply", key, entry));
   events.on("chat-sync", (key, session) => broadcastLiveEvent("chat-sync", key, serializeChatSync(session)));
   events.on(
@@ -10064,6 +10173,21 @@ async function serve({
   function finishFeedbackDelivery(key, result) {
     if (result.status !== "feedback") return;
     markFeedbackDelivered(key, activePolls, deliveredFeedback, events);
+    void publishChatSync(key);
+  }
+  async function publishChatSync(key) {
+    try {
+      const session = await store.findByKey(key);
+      if (session) events.emit("chat-sync", key, session);
+    } catch (error) {
+      writeLog(`[lavish] chat-sync after delivery failed: ${error?.message || error}`);
+    }
+  }
+  function agentFacingFeedback(result) {
+    if (!result || result.status !== "feedback" || !("delivery_seq" in result)) return result;
+    const rest = { ...result };
+    delete rest.delivery_seq;
+    return rest;
   }
   async function restoreClosedFeedback(key, result) {
     if (result.status !== "feedback") return;
@@ -10076,7 +10200,9 @@ async function serve({
         {
           dom_snapshot: result.dom_snapshot || "",
           prompts,
-          ...Array.isArray(result.artifact_failures) ? { artifact_failures: result.artifact_failures } : {}
+          ...Array.isArray(result.artifact_failures) ? { artifact_failures: result.artifact_failures } : {},
+          // Lets the store take this take's Seen stamps off again (docs/delivery-acks.md).
+          ...Number.isInteger(result.delivery_seq) ? { delivery_seq: result.delivery_seq } : {}
         },
         {
           restore: true,
@@ -10099,12 +10225,13 @@ async function serve({
         `[lavish] closed poll feedback restore failed; the batch was lost: ${restoreError?.message || restoreError}`
       );
     } else if (persistedNothing) {
-      writeLog("[lavish] closed poll feedback restore was refused; nothing was persisted and the batch was lost");
+      writeLog("[lavish] closed poll feedback restore was refused; nothing was re-queued and the batch was lost");
     } else if (!restoredPrompts || JSON.stringify(restoredPrompts) !== JSON.stringify(prompts) || !failuresRestored) {
       writeLog("[lavish] closed poll feedback restore was incomplete; delivery was not marked");
     }
     const pendingAfterRestore = Array.isArray(restoredPrompts) && restoredPrompts.length > 0 || Array.isArray(restoredFailures) && restoredFailures.length > 0;
     if (pendingAfterRestore) events.emit("feedback", key);
+    await publishChatSync(key);
   }
   const whiteboardStateRoot = path7.dirname(stateFile2);
   const allowedHostnames = buildAllowedHostnames({
@@ -10374,7 +10501,7 @@ async function serve({
         releasePollListener(holder, activePolls, deliveredFeedback, events);
         if (immediate.session_ended) clearFeedbackDelivery(key, activePolls, deliveredFeedback, events);
         detachRequestClose();
-        res.json(immediate);
+        res.json(agentFacingFeedback(immediate));
         return;
       }
       if (holder.replaced) {
@@ -10453,10 +10580,11 @@ async function serve({
             return;
           }
           finishFeedbackDelivery(key, responseResult);
+          const agentResponse = agentFacingFeedback(responseResult);
           if (streamHeartbeat) {
-            res.end(JSON.stringify(responseResult));
+            res.end(JSON.stringify(agentResponse));
           } else {
-            res.json(responseResult);
+            res.json(agentResponse);
           }
         } finally {
           cleanup();
@@ -12340,7 +12468,7 @@ var AGENT_REPLY_INPUT_LIMIT_BYTES = AGENT_REPLY_JSON_LIMIT_BYTES - AGENT_REPLY_J
 var AGENT_REPLY_LIMIT_LABEL = "2 MB JSON request limit";
 var POLL_STATE_HEADER = "lavish-poll-state";
 var CODEX_POLL_WAKE_PATH_GUIDANCE = "Codex detected: completed background tasks may not resume Codex automatically, so keep the poll attached to the active turn.";
-var VERSION = "0.1.82";
+var VERSION = "0.1.83";
 function detectInvokingAgent(env = process.env) {
   return ["CODEX_SANDBOX", "CODEX_THREAD_ID"].some((key) => Object.hasOwn(env, key)) ? "codex" : "generic";
 }
@@ -14269,7 +14397,7 @@ ${POLL_SEND_AND_END_RULE}
 `,
     reply: `Usage: lavish-axi reply <html-file> (--agent-reply "..." | --agent-reply-file <path>)
 
-Post an agent reply to the open Lavish Editor session and exit once the server confirms it was accepted. Exit 0 only when the server answers that the reply was sent, which is when the board stops showing Working. If that answer does not arrive within ${AGENT_REPLY_RECEIPT_TIMEOUT_MS / 1e3} seconds, exit non-zero with a timeout error. Use this when you are handing a result back and are not about to wait for more feedback.
+Post an agent reply to the open Lavish Editor session and exit once the server confirms it was accepted. Exit 0 only when the server answers that the reply was sent, which is when the board stops showing Working. If that answer does not arrive within ${AGENT_REPLY_RECEIPT_TIMEOUT_MS / 1e3} seconds, exit non-zero with a timeout error. Use this when you are handing a result back and are not about to wait for more feedback. A reply also marks every note the poll delivered to you as Done in the reviewer's panel, so reply once you have handled them.
 
 Use \`lavish-axi poll <html-file> --agent-reply "..."\` instead when the reply should be followed by a long-poll. That command posts the reply and then keeps waiting, so it does not exit when the reply is accepted.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lavish-axi",
-  "version": "0.1.82",
+  "version": "0.1.83",
   "packageManager": "pnpm@11.1.1",
   "description": "HTML is the new markdown. Lavish is the new editor for your HTML artifacts.",
   "type": "module",

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "lavish-axi",
-  "version": "0.1.82",
+  "version": "0.1.83",
   "description": "HTML is the new markdown. Lavish is the new editor for your HTML artifacts.",
   "author": {
     "name": "Kun Chen",