@zq-silk/yui 2.2.0 → 2.3.0

package/dist/web/assets/client/dock.js

@@ -8,7 +8,7 @@ import { FitAddon } from "/assets/vendor/addon-fit.mjs";
 import { h, icon, clear } from "/assets/js/dom.js";
 import { formatShort } from "/assets/js/format.js";
 import { label, chip, emptyState, richText, dot } from "/assets/js/components.js";
-import { entriesOf, recordCard, recordReader } from "/assets/js/records.js";
+import { entriesOf, totalOf, readExact, recordCard } from "/assets/js/records.js";
 import { messageComposer } from "/assets/js/forms.js";
 import { pageToken } from "/assets/js/api.js";
 
@@ -31,6 +31,7 @@ export function renderDiscussion(host, data, t, locale, actions) {
     feed = host.querySelector(".feed");
   }
   host.dataset.taskId = task.id;
+  latest.set(task.id, { data: data, t: t, locale: locale, actions: actions });
   if (!feed.querySelector('[data-reading="true"]')) drawFeed(feed, data, t, locale, actions);
   feed.scrollTop = atEnd ? feed.scrollHeight : previousScroll;
   if (!keepComposer) {
@@ -44,21 +45,92 @@ export function discussionHasUnsent(host) {
   return !!host.querySelector('[data-unsent="true"]');
 }
 
+// The Context read carries the newest messages as summaries; each is read
+// exactly once per digest (kept in the Task's view state) and drawn in full,
+// so a message needs no separate raw-record reader.
+// Older messages are listed on request, newest first, and read the same way.
+const older = new Map();
+const failedReads = new Set();
+const latest = new Map();
+
+function readKey(entry) { return entry.ref.refId + "@" + entry.ref.digest; }
+
+function exactValue(entry, cache) {
+  if (!entry.omitted) return entry.value;
+  const hit = cache[entry.ref.store + "/" + entry.ref.refId];
+  return hit && hit.digest === entry.ref.digest && hit.result ? hit.result.value : null;
+}
+
+function loadOlder(data, actions, state, shownIds) {
+  state.pending = true;
+  state.error = null;
+  let rounds = 0;
+  function next() {
+    return actions.list(data.task.id, "task-message", { limit: 20, cursor: state.cursor }).then(function (page) {
+      const known = new Set(state.items.map(function (item) { return item.ref.refId; }));
+      const fresh = page.items.filter(function (item) { return !known.has(item.ref.refId) && !shownIds.has(item.ref.refId); });
+      state.items = state.items.concat(fresh);
+      state.cursor = page.nextCursor;
+      state.done = !page.nextCursor;
+      rounds += 1;
+      if (!fresh.length && page.nextCursor && rounds < 10) return next();
+    });
+  }
+  // A listing that moved invalidates its continuation; the next request
+  // starts again from the newest page and skips what is already shown.
+  return next().catch(function (error) { state.error = error.message; state.cursor = null; })
+    .then(function () { state.pending = false; });
+}
+
 function drawFeed(feed, data, t, locale, actions) {
   clear(feed);
-  const core = data.core;
-  const entries = entriesOf(core, "task-message").slice().sort(function (a, b) {
-    return Date.parse((a.value && a.value.createdAt) || 0) - Date.parse((b.value && b.value.createdAt) || 0);
+  const task = data.task;
+  const cache = data.viewState.exact = data.viewState.exact || {};
+  const contextEntries = entriesOf(data.core, "task-message");
+  const shownIds = new Set(contextEntries.map(function (entry) { return entry.ref.refId; }));
+  if (!older.has(task.id)) older.set(task.id, { items: [], cursor: null, done: false, pending: false, error: null });
+  const state = older.get(task.id);
+  const olderItems = state.items.filter(function (item) { return !shownIds.has(item.ref.refId); })
+    .sort(function (a, b) { return Date.parse(a.createdAt || 0) - Date.parse(b.createdAt || 0); });
+  // Context lists messages newest first; the feed reads oldest first.
+  const rows = olderItems.map(function (item) { return { entry: { ref: item.ref, summary: item.summary, omitted: true }, at: item.createdAt }; })
+    .concat(contextEntries.slice().reverse().map(function (entry) { return { entry: entry, at: null }; }));
+  const reads = [];
+  rows.forEach(function (row) {
+    row.value = exactValue(row.entry, cache);
+    if (!row.value && !failedReads.has(readKey(row.entry))) {
+      row.reading = true;
+      reads.push(readExact(row.entry, task.id, actions, cache).catch(function () { failedReads.add(readKey(row.entry)); }));
+    }
+    row.at = (row.value && row.value.createdAt) || row.at;
   });
-  if (core.omitted.records) feed.append(h("p.feed-note", null, t("discussion.omitted")));
-  if (!entries.length) {
+  if (rows.every(function (row) { return row.at; })) rows.sort(function (a, b) { return Date.parse(a.at) - Date.parse(b.at); });
+
+  const remaining = totalOf(data.core, "task-message") - shownIds.size - olderItems.length;
+  if (actions.list && remaining > 0 && !state.done) {
+    const more = h("button.show-more.feed-older", { type: "button", disabled: state.pending },
+      state.pending ? t("discussion.olderLoading") : t("discussion.older").replace("{count}", String(remaining)));
+    more.addEventListener("click", function () {
+      more.disabled = true;
+      more.textContent = t("discussion.olderLoading");
+      loadOlder(data, actions, state, shownIds).then(function () { redraw(feed, task.id, true); });
+    });
+    feed.append(more);
+  }
+  if (state.error) feed.append(h("p.feed-note", null, t("records.unavailable") + " " + state.error));
+  if (!rows.length) {
     feed.append(emptyState(t("discussion.empty"), "chat"));
     return;
   }
   let lastDay = "";
-  entries.forEach(function (entry) {
-    if (entry.omitted) { feed.append(recordCard(entry, data.task.id, t, actions, { compact: true })); return; }
-    const value = entry.value;
+  rows.forEach(function (row) {
+    if (!row.value) {
+      const placeholder = recordCard(row.entry, task.id, t, actions, { compact: true });
+      if (row.reading) placeholder.dataset.reading = "true";
+      feed.append(placeholder);
+      return;
+    }
+    const value = row.value;
     const day = value.createdAt ? new Intl.DateTimeFormat(locale, { dateStyle: "medium" }).format(new Date(value.createdAt)) : "";
     if (day && day !== lastDay) { feed.append(h("div.feed-day", null, h("span", null, day))); lastDay = day; }
     const type = (value.author && value.author.type) || "system";
@@ -69,12 +141,24 @@ function drawFeed(feed, data, t, locale, actions) {
       h("header.msg-head", null, h("strong", null, author),
         value.intent ? chip(label(t, "intent", value.intent)) : null,
         value.kind === "role-result" ? chip(label(t, "messageKind", value.kind)) : null,
-        h("time", { dateTime: value.createdAt || "" }, formatShort(value.createdAt, locale))),
+        h("time", { dateTime: value.createdAt || "", title: row.entry.ref.refId }, formatShort(value.createdAt, locale))),
       h("div.msg-bubble", null, richText(null, value.body || "", t, { threshold: 900 })));
-    main.append(recordReader(entry, data.task.id, t, actions));
     message.append(main);
     feed.append(message);
   });
+  if (reads.length) Promise.all(reads).then(function () { redraw(feed, task.id, false); });
+}
+
+// Redraw after a read without losing the reader's place: the bottom stays
+// pinned, and prepended older messages keep the current message in view.
+function redraw(feed, taskId, prepend) {
+  const host = feed.closest("[data-task-id]");
+  const current = latest.get(taskId);
+  if (!feed.isConnected || !host || host.dataset.taskId !== taskId || !current) return;
+  const atEnd = feed.scrollHeight - feed.clientHeight - feed.scrollTop < 40;
+  const fromBottom = feed.scrollHeight - feed.scrollTop;
+  drawFeed(feed, current.data, current.t, current.locale, current.actions);
+  feed.scrollTop = atEnd && !prepend ? feed.scrollHeight : feed.scrollHeight - fromBottom;
 }
 
 // --- Live native Session ----------------------------------------------------------

package/dist/web/assets/client/evidence.js

@@ -1,18 +1,290 @@
 export const EVIDENCE_SCRIPT = String.raw `
-// Results and evidence. Files are read on request at a fixed revision; the
-// selected revision survives refreshes. Reading never accepts, publishes or
-// executes a result.
+// The Delivery tab: work items, reviews, integration and remote delivery,
+// saved files and retained workspaces. Opening the tab reads the original
+// evidence once per Context cursor; reading never accepts, publishes,
+// executes or cleans anything.
 import { h, icon, clear } from "/assets/js/dom.js";
-import { formatBytes } from "/assets/js/format.js";
-import { card, button, note, mono, emptyState, richText, badge, observabilityMetricCard } from "/assets/js/components.js";
+import { formatBytes, formatClock } from "/assets/js/format.js";
+import {
+  card, listCard, setCardCount, button, note, mono, chip, emptyState, richText, badge, statusBadge, label, tone, dot,
+  timeTag, disclosure, workItemCard, workItemBody, reviewCard
+} from "/assets/js/components.js";
+import { entriesOf, valuesOf, totalOf, summaryFields, readExact, exactRow, lazyRow, familyState, loadFamily } from "/assets/js/records.js";
 
-export function renderEvidence(container, data, t, locale, actions) {
+const DELIVERY_TONES = { merged: "ok", partial: "warn", unverified: "warn", uncovered: "warn", pending: "info", none: "idle", unavailable: "idle" };
+
+function newest(left, right) {
+  return Date.parse(right.createdAt || 0) - Date.parse(left.createdAt || 0);
+}
+
+// Only http(s) links without credentials leave the page.
+function safeUrl(value) {
+  try {
+    const url = new URL(value);
+    return ["http:", "https:"].includes(url.protocol) && !url.username && !url.password ? url.href : null;
+  } catch { return null; }
+}
+
+export function renderDelivery(panel, data, t, locale, ctx) {
+  const view = data.viewState;
+  const core = data.core;
+  const task = data.task;
+  view.exact = view.exact || {};
+  view.openRows = view.openRows || {};
+  view.reports = view.reports || {};
+  view.panels = view.panels || {};
+  view.panels.delivery = panel;
+
+  // --- Work items ------------------------------------------------------------
+  const work = listCard({ id: "detail-work", title: t("work.title"), icon: "layers", count: totalOf(core, "work-item") || null, hint: t("work.openHint") });
+  function drawWork() {
+    clear(work.list);
+    const family = familyState(view, "work-item");
+    const entries = entriesOf(core, "work-item");
+    const titles = {};
+    family.items.forEach(function (item) { const fields = summaryFields(item.summary); if (fields.title) titles[item.ref.refId] = fields.title; });
+    valuesOf(core, "work-item").forEach(function (item) { titles[item.id] = item.title; });
+    const shown = new Set(entries.map(function (entry) { return entry.ref.refId; }));
+    const extraOpen = family.items.filter(function (item) { return item.status === "open" && !shown.has(item.ref.refId); });
+    const finished = family.items.filter(function (item) { return item.status !== "open"; });
+    entries.forEach(function (entry) {
+      work.list.append(exactRow(entry, task.id, t, ctx, view.exact, function (value) { return workItemCard(value, t, locale, titles); }));
+    });
+    extraOpen.forEach(function (item) { work.list.append(workRow(item, titles)); });
+    const loaded = family.key && family.pages;
+    if (loaded) setCardCount(work, family.total || null);
+    if (!entries.length && !extraOpen.length) {
+      work.list.append(emptyState(loaded && family.total === 0 ? t("work.none") : t("work.noneOpen"), "layers"));
+    }
+    if (family.error) work.list.append(note(t("records.unavailable") + " " + family.error, "bad"));
+    if (!loaded) {
+      if (family.pending) work.list.append(h("p.row-label", null, t("work.reading")));
+      return;
+    }
+    const finishedTotal = Math.max(finished.length, (family.total || 0) - totalOf(core, "work-item"));
+    if (!finishedTotal) return;
+    const group = h("div.row-stack.is-finished", null, h("p.row-label", null, t("work.finished") + " · " + finishedTotal));
+    finished.forEach(function (item) { group.append(workRow(item, titles)); });
+    work.list.append(group);
+    if (family.nextCursor) work.list.append(listFoot(family, function () {
+      return loadFamily(view, task.id, "work-item", family.key, ctx, { more: true, limit: 40 });
+    }));
+  }
+  function workRow(item, titles) {
+    const fields = summaryFields(item.summary);
+    return lazyRow(item, task.id, t, ctx, {
+      cache: view.exact, openRows: view.openRows,
+      head: [dot(tone("work", item.status)), h("span.lazy-title", null, fields.title || item.ref.refId),
+        item.assignee ? h("span.faint.small.lazy-meta", null, item.assignee) : null,
+        statusBadge(t, "work", "work", item.status)],
+      render: function (value) { return workItemBody(value, t, locale, titles); }
+    });
+  }
+  function listFoot(family, more) {
+    const next = button(t("history.more"), { icon: "chevron", variant: "ghost" });
+    next.addEventListener("click", function () {
+      next.disabled = true;
+      more().then(refresh);
+    });
+    return h("div.list-foot", null,
+      h("span.faint.small", null, t("history.loaded").replace("{shown}", String(family.items.length)).replace("{total}", String(family.total))),
+      next);
+  }
+
+  // --- Reviews ---------------------------------------------------------------
+  const reviews = listCard({ id: "detail-reviews", title: t("reviews.title"), icon: "eye", hint: t("reviews.hint") });
+  function drawReviews() {
+    clear(reviews.list);
+    const evidence = view.evidence && view.evidence.key && view.evidence.value;
+    if (evidence) {
+      const rounds = evidence.reviews.slice().sort(newest);
+      setCardCount(reviews, rounds.length || null);
+      if (!rounds.length) reviews.list.append(emptyState(t("reviews.none"), "eye"));
+      rounds.forEach(function (round) { reviews.list.append(reviewRow(round)); });
+      return;
+    }
+    const entries = entriesOf(core, "review-round");
+    setCardCount(reviews, entries.length || null);
+    entries.forEach(function (entry) {
+      reviews.list.append(exactRow(entry, task.id, t, ctx, view.exact, function (value) { return reviewRow(value); }));
+    });
+    if (view.evidence && view.evidence.error) reviews.list.append(note(t("records.unavailable") + " " + view.evidence.error, "bad"));
+    else reviews.list.append(h("p.row-label", null, t("evidence.loading")));
+  }
+  function reviewRow(round) {
+    const element = reviewCard(round, t, locale);
+    if (!round.reviewerRunId) return element;
+    const holder = h("div.stack");
+    const cached = view.reports[round.id];
+    if (cached) { holder.append(richText(t("evidence.report"), cached, t, { threshold: 480 })); element.append(holder); return element; }
+    const report = button(t("evidence.readReport"), { icon: "eye", variant: "link" });
+    report.addEventListener("click", async function () {
+      report.disabled = true;
+      try {
+        const source = await ctx.inspect(task.id, { store: "run", refId: round.reviewerRunId });
+        const output = (source.result && source.result.output) || (source.value && source.value.result && source.value.result.output) || t("evidence.noReport");
+        view.reports[round.id] = output;
+        holder.append(richText(t("evidence.report"), output, t, { threshold: 480 }));
+        report.remove();
+      } catch (error) { holder.append(note(error.message, "bad")); report.disabled = false; }
+    });
+    element.append(h("div.record-actions", null, report), holder);
+    return element;
+  }
+
+  // --- Integration and remote delivery ------------------------------------------
+  const delivery = card({ id: "detail-results", title: t("delivery.title"), icon: "merge", hint: t("delivery.hint") });
+  const deliveryBody = h("div.stack.delivery-stack");
+  delivery.body.append(deliveryBody);
+  function remoteDelivery() {
+    const entry = entriesOf(core, "remote-delivery")[0];
+    if (entry && !entry.omitted) return entry.value;
+    const cached = entry && view.exact["remote-delivery/" + entry.ref.refId];
+    if (cached && cached.digest === entry.ref.digest && cached.result) return cached.result.value;
+    return (data.runtime && data.runtime.remoteDelivery) || null;
+  }
+  function drawDelivery() {
+    clear(deliveryBody);
+    const remote = remoteDelivery();
+    if (remote) {
+      deliveryBody.append(h("h4.sub-head", null, icon("package", "icon-sm"), h("span", null, t("evidence.remote")),
+        badge(t("remoteDelivery." + remote.status, remote.status), DELIVERY_TONES[remote.status] || "idle", { dot: true })));
+      if (remote.codeProjectCount) {
+        deliveryBody.append(h("p.faint.small", null, t("delivery.counts")
+          .replace("{merged}", String(remote.mergedProjectCount)).replace("{verified}", String(remote.verifiedProjectCount))
+          .split("{total}").join(String(remote.codeProjectCount))));
+      }
+      (remote.projects || []).forEach(function (project) { deliveryBody.append(projectRow(project)); });
+      if (!(remote.projects || []).length) deliveryBody.append(note(t("delivery.noProjects")));
+    } else deliveryBody.append(note(t("evidence.observationUnavailable")));
+
+    const state = view.evidence || {};
+    const evidence = state.key && state.value;
+    deliveryBody.append(h("h4.sub-head", null, icon("merge", "icon-sm"), h("span", null, t("evidence.integrations")),
+      evidence ? h("span.count", null, String(evidence.integrations.length)) : null));
+    if (!evidence) {
+      deliveryBody.append(state.error ? note(t("evidence.originalUnavailable") + " " + state.error, "bad") : h("p.faint.small", null, t("evidence.loading")));
+      return;
+    }
+    if (!evidence.integrations.length) deliveryBody.append(note(t("evidence.noIntegrations")));
+    const rows = h("div.row-stack.boxed");
+    evidence.integrations.slice().sort(newest).forEach(function (attempt) { rows.append(integrationRow(attempt)); });
+    if (rows.childNodes.length) deliveryBody.append(rows);
+    deliveryBody.append(h("p.faint.small", null, t("delivery.readAt") + " " + formatClock(state.readAt, locale)
+      + (state.pending ? " · " + t("evidence.loading") : "")));
+  }
+  function projectRow(project) {
+    const publication = project.publication;
+    const href = publication && publication.externalUrl && safeUrl(publication.externalUrl);
+    const element = h("article.record.delivery-project");
+    element.append(h("header.record-head", null, icon("folder", "icon-sm"), h("strong", null, project.directory || project.projectId),
+      project.coverage ? chip(label(t, "coverage", project.coverage)) : null,
+      h("span.spacer"),
+      publication ? (href
+        ? h("a.link", { href: href, rel: "noopener noreferrer", target: "_blank" }, label(t, "publication", publication.externalKind) + " #" + publication.externalId)
+        : mono(publication.externalKind + " " + publication.externalId)) : null));
+    if (publication && publication.title) element.append(h("p.small", null, publication.title));
+    if (project.reason) element.append(h("p.faint.small", null, project.reason));
+    element.append(h("div.meta-line", null,
+      h("span", null, t("evidence.expectedCommit") + " "), mono(project.expectedLocalCommit ? project.expectedLocalCommit.slice(0, 12) : t("common.unknown")),
+      project.state ? chip(label(t, "publicationState", project.state)) : null,
+      project.verification ? chip(t("evidence.verification") + " · " + label(t, "verification", project.verification)) : null,
+      project.adoption ? h("span", null, t("evidence.adoption") + " ", mono(project.adoption.id)) : null));
+    return element;
+  }
+  function integrationRow(attempt) {
+    const source = attempt.source || {};
+    const element = h("article.record.integration-row");
+    element.dataset.status = attempt.status;
+    element.append(h("header.record-head", null, dot(tone("integration", attempt.status)), mono(attempt.id),
+      chip(label(t, "integration.source", source.kind) + (source.workItemId ? " · " + source.workItemId : "")),
+      source.strategy ? chip(source.strategy) : null,
+      h("span.spacer"),
+      statusBadge(t, "integration", "integration", attempt.status)));
+    if (attempt.summary) element.append(h("p.small", null, attempt.summary));
+    element.append(h("div.meta-line", null,
+      attempt.projectId ? h("span", null, attempt.projectId) : null,
+      attempt.targetRef ? mono(attempt.targetRef) : null,
+      h("span", null, t("evidence.candidate") + " "), mono(attempt.candidateCommit ? attempt.candidateCommit.slice(0, 12) : t("evidence.noCandidate")),
+      timeTag(attempt.createdAt, locale, t)));
+    if (attempt.checks && attempt.checks.length) {
+      element.append(h("ul.check-list", null, attempt.checks.map(function (check) {
+        return h("li", null, dot(check.outcome === "passed" ? "ok" : check.outcome === "failed" ? "bad" : "idle"),
+          h("span.mono-line", null, check.name), h("span.faint", null, label(t, "check", check.outcome)),
+          check.details ? h("span.faint.small.check-details", null, check.details) : null);
+      })));
+    } else element.append(h("p.faint.small", null, t("evidence.noChecks")));
+    return element;
+  }
+
+  // --- Workspaces and cleanup --------------------------------------------------
+  const workspaces = disclosure(t("workspaces.title"), "workspaces", { className: "card-disclosure", meta: String(totalOf(core, "managed-workspace")) });
+  workspaces.id = "detail-workspaces";
+  function drawWorkspaces() {
+    clear(workspaces.body);
+    const evidence = view.evidence && view.evidence.key && view.evidence.value;
+    const list = evidence ? evidence.workspaces : valuesOf(core, "managed-workspace");
+    if (!list.length) workspaces.body.append(note(t("evidence.noWorkspaces")));
+    const rows = h("div.row-stack.boxed");
+    list.forEach(function (workspace) {
+      const owner = workspace.owner || {};
+      const ownerId = owner.workItemId || owner.reviewRoundId || owner.integrationAttemptId
+        || (owner.executionGroupId ? owner.executionGroupId + (owner.executionLaneId ? "/" + owner.executionLaneId : "") : "") || owner.taskId || "";
+      rows.append(h("article.record.is-compact", null,
+        h("header.record-head", null, chip(label(t, "workspace.owner", owner.type)), mono(ownerId), h("span.spacer"), timeTag(workspace.updatedAt, locale, t)),
+        h("p.small.mono-line", null, workspace.root),
+        (workspace.entries || []).length ? h("div.meta-line", null, workspace.entries.map(function (entry) {
+          return h("span", null, entry.directory + " · ", mono(entry.branch || entry.baseRef || ""));
+        })) : null));
+    });
+    if (rows.childNodes.length) workspaces.body.append(rows);
+    workspaces.body.append(note(t("evidence.cleanupNote")), h("pre.code-block", null, "yui task archive-preflight " + task.id + " --integrated"));
+  }
+
+  panel.append(work, reviews, delivery, filesCard(data, t, locale, ctx), workspaces);
+  panel.redraw = function () { drawWork(); drawReviews(); drawDelivery(); drawWorkspaces(); };
+  panel.redraw();
+
+  // Reads outlive one render: they redraw whichever Delivery panel is current
+  // and re-read when the Context cursor moved while they were in flight.
+  function refresh() {
+    const current = view.panels.delivery;
+    if (!current || !current.isConnected) return;
+    current.redraw();
+    if (!current.hidden) current.onShow();
+  }
+  panel.onShow = function () {
+    const key = core.coreCursor;
+    const previous = view.evidence || {};
+    if (previous.key !== key && previous.errorKey !== key && !previous.pending) {
+      view.evidence = { key: previous.key, value: previous.value, readAt: previous.readAt, error: null, pending: true };
+      ctx.evidence(task.id).then(function (value) {
+        view.evidence = { key: key, value: value, readAt: new Date().toISOString(), error: null, pending: false };
+      }, function (error) {
+        view.evidence = { key: previous.key, value: previous.value, readAt: previous.readAt, error: error.message, errorKey: key, pending: false };
+      }).then(refresh);
+    }
+    const entry = entriesOf(core, "remote-delivery")[0];
+    if (entry && entry.omitted && !(data.runtime && data.runtime.remoteDelivery)) {
+      const hit = view.exact["remote-delivery/" + entry.ref.refId];
+      if (!(hit && hit.digest === entry.ref.digest && hit.result)) {
+        readExact(entry, task.id, ctx, view.exact).then(refresh, function () {});
+      }
+    }
+    const family = familyState(view, "work-item");
+    if (family.key !== key && family.errorKey !== key && !family.pending) loadFamily(view, task.id, "work-item", key, ctx, { limit: 40 }).then(refresh);
+  };
+}
+
+// --- Saved files ------------------------------------------------------------------
+// Files are read on request at a fixed revision; the selected revision
+// survives refreshes.
+function filesCard(data, t, locale, actions) {
   const state = data.viewState;
-  const files = card({ title: t("evidence.files"), icon: "file", hint: t("evidence.filesHint") });
+  const load = button(state.artifactList ? t("evidence.reload") : t("evidence.load"), { icon: "refresh", variant: "ghost" });
+  const files = card({ id: "detail-files", title: t("evidence.files"), icon: "file", hint: t("evidence.filesHint"), actions: load });
   const list = h("div.file-list");
   const viewer = h("div.file-viewer");
-  const load = button(state.artifactList ? t("evidence.reload") : t("evidence.load"), { icon: "refresh", variant: "ghost" });
-  files.querySelector(".card-head").append(h("div.card-actions", null, load));
   let readSequence = 0;
   async function read(path, commit) {
     const sequence = ++readSequence;
@@ -41,8 +313,7 @@ export function renderEvidence(container, data, t, locale, actions) {
     viewer.append(h("header.viewer-head", null, icon("file"), h("strong", null, value.relativePath), h("span.spacer"), copy));
     viewer.append(h("p.viewer-ref", null, mono(ref)));
     viewer.append(h("p.faint.small", null, t("evidence.fixedNote")));
-    const content = h("pre.code-block.artifact-text", { tabIndex: 0, "aria-label": t("evidence.fixedText") }, value.content);
-    viewer.append(content);
+    viewer.append(h("pre.code-block.artifact-text", { tabIndex: 0, "aria-label": t("evidence.fixedText") }, value.content));
   }
   function drawList() {
     clear(list);
@@ -63,6 +334,7 @@ export function renderEvidence(container, data, t, locale, actions) {
     list.dataset.reading = "true";
     try {
       state.artifactList = await actions.artifacts(data.task.id);
+      if (placeholder) { placeholder.remove(); placeholder = null; }
       drawList();
     } catch (error) {
       clear(list);
@@ -82,91 +354,11 @@ export function renderEvidence(container, data, t, locale, actions) {
     referenced.append(h("button.file-row", { type: "button", onclick: function () { read(match[2], match[1]); } },
       icon("flag", "icon-sm"), h("span.file-name", null, match[2]), badge(t("evidence.referenced"), "accent")));
   });
-  if (!state.artifactList && !seen.size) files.body.append(emptyState(t("evidence.notLoaded"), "file"));
+  let placeholder = !state.artifactList && !seen.size ? emptyState(t("evidence.notLoaded"), "file") : null;
+  if (placeholder) files.body.append(placeholder);
   files.body.append(referenced, list, viewer);
   drawList();
   drawViewer();
-  container.append(files);
-
-  const delivery = card({ title: t("evidence.delivery"), icon: "layers", hint: t("evidence.deliveryHint") });
-  const output = h("div.stack");
-  const open = button(t("evidence.readDelivery"), { icon: "eye", variant: "ghost" });
-  delivery.querySelector(".card-head").append(h("div.card-actions", null, open));
-  delivery.body.append(output);
-  open.addEventListener("click", function () {
-    open.disabled = true;
-    drawDelivery(output, data, t, actions).finally(function () { open.disabled = false; });
-  });
-  container.append(delivery);
-}
-
-async function drawDelivery(output, data, t, actions) {
-  clear(output);
-  const runtime = data.runtimeStatus === "available" ? data.runtime : null;
-  if (!runtime) output.append(note(t("evidence.observationUnavailable")));
-  const remote = runtime && runtime.remoteDelivery;
-  if (remote) {
-    output.append(h("h4.sub-head", null, t("evidence.remote"), badge(t("remoteDelivery." + remote.status, remote.status), remote.status === "merged" ? "ok" : "idle")));
-    remote.projects.forEach(function (project) {
-      output.append(h("article.record", null,
-        h("header.record-head", null, h("strong", null, project.directory), h("span.faint.small", null, project.coverage)),
-        h("p.small", null, project.reason),
-        h("p.faint.small", null, t("evidence.expectedCommit") + " ", mono(project.expectedLocalCommit || t("common.unknown"))),
-        h("p.faint.small", null, "PR/MR · " + (project.state || "none") + " · " + t("evidence.verification") + " " + (project.verification || "unverified")),
-        project.adoption ? h("p.faint.small", null, t("evidence.adoption") + " ", mono(project.adoption.id)) : null));
-    });
-  }
-  const original = h("div.stack", null, h("p.faint", null, t("evidence.readingOriginal")));
-  output.append(original);
-  try {
-    const evidence = await actions.evidence(data.task.id);
-    clear(original);
-    original.append(h("h4.sub-head", null, t("evidence.integrations")));
-    if (!evidence.integrations.length) original.append(note(t("evidence.noIntegrations")));
-    evidence.integrations.forEach(function (attempt) {
-      const element = h("article.record", null,
-        h("header.record-head", null, mono(attempt.id), h("span.spacer"), badge(attempt.status, attempt.status === "succeeded" ? "ok" : "idle")),
-        h("p.faint.small", null, t("evidence.candidate") + " ", mono(attempt.candidateCommit || t("evidence.noCandidate"))));
-      if (!attempt.checks || !attempt.checks.length) element.append(h("p.faint.small", null, t("evidence.noChecks")));
-      (attempt.checks || []).forEach(function (check) {
-        element.append(h("p.small", null, check.name + " · " + check.outcome));
-        if (check.details) element.append(h("p.faint.small", null, check.details));
-      });
-      original.append(element);
-    });
-    original.append(h("h4.sub-head", null, t("evidence.reviews")));
-    if (!evidence.reviews.length) original.append(note(t("evidence.noReviews")));
-    evidence.reviews.forEach(function (round) {
-      const element = h("article.record", null,
-        h("header.record-head", null, mono(round.id), h("span.spacer"), badge(round.status, round.status === "completed" ? "ok" : "idle")),
-        h("p.faint.small.mono-line", null, round.taskCandidate
-          ? round.taskCandidate.projects.map(function (p) { return p.projectId + " · " + p.commit; }).join("  ")
-          : [round.workItemId, round.candidateId, round.reviewBaseCommit].filter(Boolean).join(" · ")));
-      if (round.reviewerRunId) {
-        const report = button(t("evidence.readReport"), { icon: "eye", variant: "link" });
-        report.addEventListener("click", async function () {
-          report.disabled = true;
-          try {
-            const source = await actions.inspect(data.task.id, { store: "run", refId: round.reviewerRunId });
-            element.append(richText(round.reviewerRunId, (source.value.result && source.value.result.output) || t("evidence.noReport"), t));
-            report.remove();
-          } catch (error) { element.append(note(error.message, "bad")); report.disabled = false; }
-        });
-        element.append(report);
-      }
-      original.append(element);
-    });
-    original.append(h("h4.sub-head", null, t("evidence.workspaces")));
-    if (!evidence.workspaces.length) original.append(note(t("evidence.noWorkspaces")));
-    evidence.workspaces.forEach(function (workspace) {
-      original.append(h("p.small.mono-line", null, workspace.owner.type + " · " + workspace.root));
-    });
-    original.append(note(t("evidence.cleanupNote")), h("pre.code-block", null, "yui task archive-preflight " + data.task.id + " --integrated"));
-  } catch (error) {
-    clear(original);
-    original.append(note(t("evidence.originalUnavailable") + " " + error.message, "bad"));
-  }
-  const metrics = runtime && observabilityMetricCard(runtime.observability, t);
-  if (metrics) output.append(h("h4.sub-head", null, t("evidence.usage")), metrics);
+  return files;
 }
 `;