@zq-silk/yui 2.2.0 → 2.4.0

package/dist/web/assets/client/views/task/delivery.js

@@ -0,0 +1,185 @@
+export const TASK_DELIVERY_SCRIPT = String.raw `
+// Task › Delivery: 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, clear } from "/assets/js/lib/dom.js";
+import { button, dot, emptyState, note } from "/assets/js/ui/primitives.js";
+import { listCard, loadedNote, moreButton, setCardCount } from "/assets/js/ui/containers.js";
+import { richText } from "/assets/js/ui/text.js";
+import { statusBadge, tone } from "/assets/js/domain/vocab.js";
+import { entriesOf, exactCache, familyState, loadFamily, summaryFields, totalOf, valuesOf } from "/assets/js/domain/context.js";
+import { exactRow, lazyRow } from "/assets/js/domain/records.js";
+import { workItemBody, workItemCard } from "/assets/js/domain/work.js";
+import { reviewCard } from "/assets/js/domain/runs.js";
+import { newest, readRemoteDelivery, resultsSection, workspacesSection } from "/assets/js/views/task/deliveryResults.js";
+import { filesCard } from "/assets/js/views/task/files.js";
+
+export function renderDelivery(panel, data, t, locale, ctx) {
+  const view = data.viewState;
+  exactCache(view);
+  view.openRows = view.openRows || {};
+  view.reports = view.reports || {};
+  view.panels = view.panels || {};
+  view.panels.delivery = panel;
+  const scope = { data: data, view: view, core: data.core, task: data.task, t: t, locale: locale, ctx: ctx, refresh: refresh };
+  const work = workSection(scope);
+  const reviews = reviewsSection(scope);
+  const results = resultsSection(scope);
+  const workspaces = workspacesSection(scope);
+  panel.append(work.element, reviews.element, results.element, filesCard(data, t, locale, ctx), workspaces.element);
+  panel.redraw = function () { work.draw(); reviews.draw(); results.draw(); workspaces.draw(); };
+  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 () {
+    readEvidence(scope);
+    readRemoteDelivery(scope);
+    const key = scope.core.coreCursor;
+    const family = familyState(view, "work-item");
+    if (family.key !== key && family.errorKey !== key && !family.pending) loadFamily(view, data.task.id, "work-item", key, ctx, { limit: 40 }).then(refresh);
+  };
+}
+
+// Original evidence (reviews, integrations, workspaces), once per cursor.
+function readEvidence(scope) {
+  const view = scope.view;
+  const key = scope.core.coreCursor;
+  const previous = view.evidence || {};
+  if (previous.key === key || previous.errorKey === key || previous.pending) return;
+  view.evidence = { key: previous.key, value: previous.value, readAt: previous.readAt, error: null, pending: true };
+  scope.ctx.evidence(scope.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(scope.refresh);
+}
+
+// --- Work items ------------------------------------------------------------
+function workSection(scope) {
+  const t = scope.t;
+  const work = listCard({ id: "detail-work", title: t("work.title"), icon: "layers", count: totalOf(scope.core, "work-item") || null, hint: t("work.openHint") });
+  return { element: work, draw: function () { drawWork(work, scope); } };
+}
+
+// Open items from the snapshot first, then open items only the family pages
+// list, then the settled ones.
+function drawWork(work, scope) {
+  const t = scope.t;
+  clear(work.list);
+  const family = familyState(scope.view, "work-item");
+  const entries = entriesOf(scope.core, "work-item");
+  const titles = workTitles(family, scope.core);
+  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); });
+  entries.forEach(function (entry) {
+    work.list.append(exactRow(entry, scope.task.id, t, scope.ctx, scope.view.exact, function (value) { return workItemCard(value, t, scope.locale, titles); }));
+  });
+  extraOpen.forEach(function (item) { work.list.append(workRow(scope, 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;
+  }
+  drawFinished(work, scope, family, titles);
+}
+
+function workTitles(family, core) {
+  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; });
+  return titles;
+}
+
+function drawFinished(work, scope, family, titles) {
+  const finished = family.items.filter(function (item) { return item.status !== "open"; });
+  const finishedTotal = Math.max(finished.length, (family.total || 0) - totalOf(scope.core, "work-item"));
+  if (!finishedTotal) return;
+  const group = h("div.row-stack.is-finished", null, h("p.row-label", null, scope.t("work.finished") + " · " + finishedTotal));
+  finished.forEach(function (item) { group.append(workRow(scope, item, titles)); });
+  work.list.append(group);
+  if (!family.nextCursor) return;
+  work.list.append(h("div.list-foot", null, loadedNote(scope.t, family.items.length, family.total), moreButton(scope.t, function () {
+    loadFamily(scope.view, scope.task.id, "work-item", family.key, scope.ctx, { more: true, limit: 40 }).then(scope.refresh);
+  })));
+}
+
+function workRow(scope, item, titles) {
+  const t = scope.t;
+  const fields = summaryFields(item.summary);
+  return lazyRow(item, scope.task.id, t, scope.ctx, {
+    cache: scope.view.exact, openRows: scope.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, scope.locale, titles); }
+  });
+}
+
+// --- Reviews ---------------------------------------------------------------
+function reviewsSection(scope) {
+  const reviews = listCard({ id: "detail-reviews", title: scope.t("reviews.title"), icon: "eye", hint: scope.t("reviews.hint") });
+  return { element: reviews, draw: function () { drawReviews(reviews, scope); } };
+}
+
+function drawReviews(reviews, scope) {
+  const view = scope.view;
+  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(scope.t("reviews.none"), "eye"));
+    rounds.forEach(function (round) { reviews.list.append(reviewRow(scope, round)); });
+    return;
+  }
+  const entries = entriesOf(scope.core, "review-round");
+  setCardCount(reviews, entries.length || null);
+  entries.forEach(function (entry) {
+    reviews.list.append(exactRow(entry, scope.task.id, scope.t, scope.ctx, view.exact, function (value) { return reviewRow(scope, value); }));
+  });
+  if (view.evidence && view.evidence.error) reviews.list.append(note(scope.t("records.unavailable") + " " + view.evidence.error, "bad"));
+  else reviews.list.append(h("p.row-label", null, scope.t("evidence.loading")));
+}
+
+function reviewRow(scope, round) {
+  const t = scope.t;
+  const element = reviewCard(round, t, scope.locale);
+  if (!round.reviewerRunId) return element;
+  const holder = h("div.stack");
+  const cached = scope.view.reports[round.id];
+  if (cached) { holder.append(richText(t("evidence.report"), cached, t, { threshold: 480 })); element.append(holder); return element; }
+  element.append(h("div.record-actions", null, reportButton(scope, round, holder)), holder);
+  return element;
+}
+
+// The reviewer's report is read from its execution record on request and
+// kept in view state for later renders.
+function reportButton(scope, round, holder) {
+  const t = scope.t;
+  const report = button(t("evidence.readReport"), { icon: "eye", variant: "link" });
+  report.addEventListener("click", async function () {
+    report.disabled = true;
+    try {
+      const source = await scope.ctx.inspect(scope.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");
+      scope.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; }
+  });
+  return report;
+}
+`;

package/dist/web/assets/client/views/task/deliveryResults.js

@@ -0,0 +1,159 @@
+export const TASK_DELIVERY_RESULTS_SCRIPT = String.raw `
+// Task › Delivery results: remote delivery per project, integration attempts
+// with their checks, and retained workspaces with the cleanup command. The
+// original evidence (view.evidence) replaces snapshot samples once read.
+import { h, icon, clear } from "/assets/js/lib/dom.js";
+import { fill, formatClock } from "/assets/js/lib/format.js";
+import { badge, chip, codeBlock, dot, externalLink, mono, note, safeUrl, timeTag } from "/assets/js/ui/primitives.js";
+import { card, cardDisclosure } from "/assets/js/ui/containers.js";
+import { label, statusBadge, tone } from "/assets/js/domain/vocab.js";
+import { cachedExact, entriesOf, readExact, totalOf, valuesOf } from "/assets/js/domain/context.js";
+
+const DELIVERY_TONES = { merged: "ok", partial: "warn", unverified: "warn", uncovered: "warn", pending: "info", none: "idle", unavailable: "idle" };
+
+export function newest(left, right) {
+  return Date.parse(right.createdAt || 0) - Date.parse(left.createdAt || 0);
+}
+
+// --- Integration and remote delivery ------------------------------------------
+export function resultsSection(scope) {
+  const t = scope.t;
+  const delivery = card({ id: "detail-results", title: t("delivery.title"), icon: "merge", hint: t("delivery.hint") });
+  const body = h("div.stack.delivery-stack");
+  delivery.body.append(body);
+  return { element: delivery, draw: function () { drawResults(body, scope); } };
+}
+
+// The remote delivery fact: the snapshot value, its exact read, or else the
+// runtime observation.
+function remoteDelivery(scope) {
+  const entry = entriesOf(scope.core, "remote-delivery")[0];
+  if (entry && !entry.omitted) return entry.value;
+  const hit = entry && cachedExact(scope.view.exact, entry);
+  if (hit) return hit.value;
+  return (scope.data.runtime && scope.data.runtime.remoteDelivery) || null;
+}
+
+// Read a withheld remote delivery value once per digest, unless the
+// observation already reports it.
+export function readRemoteDelivery(scope) {
+  const entry = entriesOf(scope.core, "remote-delivery")[0];
+  if (!entry || !entry.omitted || (scope.data.runtime && scope.data.runtime.remoteDelivery)) return;
+  if (!cachedExact(scope.view.exact, entry)) readExact(entry, scope.task.id, scope.ctx, scope.view.exact).then(scope.refresh, function () {});
+}
+
+function drawResults(body, scope) {
+  clear(body);
+  const remote = remoteDelivery(scope);
+  if (remote) drawRemote(body, remote, scope.t);
+  else body.append(note(scope.t("evidence.observationUnavailable")));
+  drawIntegrations(body, scope);
+}
+
+function drawRemote(body, remote, t) {
+  body.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) {
+    body.append(h("p.faint.small", null, fill(t("delivery.counts"), {
+      merged: remote.mergedProjectCount, verified: remote.verifiedProjectCount, total: remote.codeProjectCount
+    })));
+  }
+  (remote.projects || []).forEach(function (project) { body.append(projectRow(project, t)); });
+  if (!(remote.projects || []).length) body.append(note(t("delivery.noProjects")));
+}
+
+function drawIntegrations(body, scope) {
+  const t = scope.t;
+  const state = scope.view.evidence || {};
+  const evidence = state.key && state.value;
+  body.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) {
+    body.append(state.error ? note(t("evidence.originalUnavailable") + " " + state.error, "bad") : h("p.faint.small", null, t("evidence.loading")));
+    return;
+  }
+  if (!evidence.integrations.length) body.append(note(t("evidence.noIntegrations")));
+  const rows = h("div.row-stack.boxed");
+  evidence.integrations.slice().sort(newest).forEach(function (attempt) { rows.append(integrationRow(attempt, t, scope.locale)); });
+  if (rows.childNodes.length) body.append(rows);
+  body.append(h("p.faint.small", null, t("delivery.readAt") + " " + formatClock(state.readAt, scope.locale)
+    + (state.pending ? " · " + t("evidence.loading") : "")));
+}
+
+function projectRow(project, t) {
+  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
+      ? externalLink(href, 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, t, locale) {
+  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)));
+  element.append(attempt.checks && attempt.checks.length ? checkList(attempt.checks, t) : h("p.faint.small", null, t("evidence.noChecks")));
+  return element;
+}
+
+function checkList(checks, t) {
+  return h("ul.check-list", null, 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);
+  }));
+}
+
+// --- Workspaces and cleanup --------------------------------------------------
+export function workspacesSection(scope) {
+  const workspaces = cardDisclosure("detail-workspaces", scope.t("workspaces.title"), "workspaces", String(totalOf(scope.core, "managed-workspace")));
+  return { element: workspaces, draw: function () { drawWorkspaces(workspaces, scope); } };
+}
+
+function drawWorkspaces(workspaces, scope) {
+  const t = scope.t;
+  clear(workspaces.body);
+  const evidence = scope.view.evidence && scope.view.evidence.key && scope.view.evidence.value;
+  const list = evidence ? evidence.workspaces : valuesOf(scope.core, "managed-workspace");
+  if (!list.length) workspaces.body.append(note(t("evidence.noWorkspaces")));
+  const rows = h("div.row-stack.boxed");
+  list.forEach(function (workspace) { rows.append(workspaceRow(workspace, t, scope.locale)); });
+  if (rows.childNodes.length) workspaces.body.append(rows);
+  workspaces.body.append(note(t("evidence.cleanupNote")), codeBlock("yui task archive-preflight " + scope.task.id + " --integrated"));
+}
+
+function workspaceRow(workspace, t, locale) {
+  const owner = workspace.owner || {};
+  const ownerId = owner.workItemId || owner.reviewRoundId || owner.integrationAttemptId
+    || (owner.executionGroupId ? owner.executionGroupId + (owner.executionLaneId ? "/" + owner.executionLaneId : "") : "") || owner.taskId || "";
+  return 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);
+}
+`;

package/dist/web/assets/client/views/task/files.js

@@ -0,0 +1,272 @@
+export const TASK_FILES_SCRIPT = String.raw `
+// Task › Delivery › Saved files. Files are read on request at a fixed
+// revision and the selected revision survives refreshes; explicit frozen
+// references (git:<commit>:<path>) stay attached to their original revision.
+import { h, icon, clear } from "/assets/js/lib/dom.js";
+import { formatBytes } from "/assets/js/lib/format.js";
+import { badge, button, emptyState, mono, note } from "/assets/js/ui/primitives.js";
+import { card } from "/assets/js/ui/containers.js";
+import { renderMarkdown, resolveMarkdownImage, escapeHtml } from "/assets/js/lib/markdown.js";
+
+export function filesCard(data, t, locale, actions) {
+  const state = data.viewState;
+  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 = artifactViewer(h("div.file-viewer"), data, t, actions);
+  const referenced = referencedFiles(data, t, viewer.read);
+  const pathInput = h("input", { placeholder: t("materials.path"), "aria-label": t("materials.path"), maxLength: 512 });
+  const commitInput = h("input", { placeholder: t("materials.commit"), "aria-label": t("materials.commit"), maxLength: 64 });
+  const open = button(t("materials.open"), { variant: "ghost" });
+  open.addEventListener("click", function () { viewer.read(pathInput.value, commitInput.value); });
+  const more = button(t("materials.moreFiles"), { variant: "ghost" });
+  more.hidden = !state.artifactList?.nextOffset;
+  more.addEventListener("click", async function () {
+    more.disabled = true; load.disabled = true;
+    try {
+      const previous = state.artifactList;
+      const page = await actions.artifacts(data.task.id, previous.commit, previous.nextOffset);
+      state.artifactList = { ...page, entries: previous.entries.concat(page.entries) };
+      drawFileList(list, state, t, viewer.read); more.hidden = page.nextOffset === null;
+    } catch (error) { list.append(note(error.message, "bad")); }
+    finally { more.disabled = false; load.disabled = false; }
+  });
+  let placeholder = !state.artifactList && !referenced.childNodes.length ? emptyState(t("evidence.notLoaded"), "file") : null;
+  load.addEventListener("click", async function () {
+    load.disabled = true; more.disabled = true;
+    list.dataset.reading = "true";
+    try {
+      state.artifactList = await actions.artifacts(data.task.id);
+      if (placeholder) { placeholder.remove(); placeholder = null; }
+      drawFileList(list, state, t, viewer.read);
+      more.hidden = state.artifactList.nextOffset === null;
+    } catch (error) {
+      clear(list);
+      list.append(note(t("evidence.listUnavailable") + " " + error.message, "bad"));
+    } finally { load.disabled = false; more.disabled = false; list.dataset.reading = "false"; }
+  });
+  if (placeholder) files.body.append(placeholder);
+  files.body.append(h("div.record-actions", null, pathInput, commitInput, open), referenced, list, more, viewer.element);
+  drawFileList(list, state, t, viewer.read);
+  viewer.draw();
+  return files;
+}
+
+// One viewer per card; a newer read supersedes one still in flight.
+function artifactViewer(viewer, data, t, actions) {
+  const state = data.viewState;
+  let readSequence = 0;
+  function draw() { drawArtifact(viewer, state.artifact, data.task.id, t, actions, read, state); }
+  async function read(path, commit, offset, before) {
+    const sequence = ++readSequence;
+    viewer.dataset.reading = "true";
+    clear(viewer);
+    viewer.append(h("p.faint", null, t("evidence.reading")));
+    try {
+      const result = await actions.readArtifact(data.task.id, path, commit, offset, before);
+      if (sequence !== readSequence) return;
+      state.artifact = result;
+      draw();
+    } catch (error) {
+      if (sequence === readSequence) { clear(viewer); viewer.append(note(t("evidence.unavailable") + " " + error.message, "bad")); }
+    } finally { if (sequence === readSequence) viewer.dataset.reading = "false"; }
+  }
+  return { element: viewer, read: read, draw: draw };
+}
+
+function drawArtifact(viewer, value, taskId, t, actions, read, state = {}) {
+  clear(viewer);
+  if (!value) return;
+  const selected = value.after || value;
+  const previewKey = JSON.stringify([taskId, selected.commit, selected.relativePath, selected.digest, value.before?.commit]);
+  if (state.artifactPreview?.key !== previewKey) {
+    // Only the selected fixed version owns cached bytes; changing it releases the old bounded cache.
+    state.artifactPreview = { key: previewKey, images: [], pending: 0, totalBytes: 0, totalPixels: 0 };
+  }
+  const preview = state.artifactPreview;
+  const ref = "git:" + selected.commit + ":" + selected.relativePath;
+  const copy = button(t("evidence.copy"), { icon: "copy", variant: "ghost" });
+  copy.addEventListener("click", async function () {
+    try { await navigator.clipboard.writeText(taskId + " " + ref); copy.lastChild.textContent = t("evidence.copied"); }
+    catch { copy.lastChild.textContent = t("evidence.copyManual"); }
+  });
+  const copyText = button(t("materials.copyPage"), { variant: "ghost" });
+  copyText.addEventListener("click", async function () {
+    try { await navigator.clipboard.writeText(value.content); copyText.textContent = t("evidence.copied"); }
+    catch { copyText.textContent = t("evidence.copyManual"); }
+  });
+  const feedback = button(t("materials.feedback"), { variant: "ghost" });
+  feedback.addEventListener("click", function () {
+    actions.openConversation((value.before ? [value.before, value.after] : [selected]).map(artifactRef));
+  });
+  const download = button(t("materials.download"), { variant: "ghost" });
+  download.addEventListener("click", async function () {
+    download.disabled = true;
+    try {
+      if (value.kind === "image") { downloadImage(value); return; }
+      const parts = [];
+      let offset = 0, page;
+      do {
+        page = await actions.readArtifact(taskId, selected.relativePath, selected.commit, offset, value.before?.commit);
+        parts.push(page.content); offset = page.nextOffset;
+      } while (offset !== null);
+      const url = URL.createObjectURL(new Blob(parts, { type: "text/plain;charset=utf-8" }));
+      const link = h("a", { href: url, download: selected.relativePath.split("/").pop() + (value.before ? ".diff" : "") });
+      link.click(); window.setTimeout(function () { URL.revokeObjectURL(url); }, 1000);
+    } catch (error) { viewer.append(note(error.message, "bad")); }
+    finally { download.disabled = false; }
+  });
+  viewer.append(h("header.viewer-head", null, icon("file"), h("strong", null, selected.relativePath), h("span.spacer"), copy));
+  viewer.append(h("p.viewer-ref", null, mono(ref)));
+  viewer.append(h("p.viewer-ref", null, mono("sha256:" + selected.digest)));
+  if (value.before) viewer.append(h("p.viewer-ref", null, mono("← git:" + value.before.commit + ":" + value.before.relativePath + " · sha256:" + value.before.digest)));
+  viewer.append(h("p.faint.small", null, t("evidence.fixedNote")));
+  viewer.append(h("div.record-actions", null, value.kind === "image" ? null : copyText, download, feedback));
+  if (value.kind === "image") { viewer.append(imagePreview(value, t, undefined, preview)); return; }
+  const before = h("input", { placeholder: t("materials.before"), "aria-label": t("materials.before"), maxLength: 64 });
+  const compare = button(t("materials.compare"), { variant: "ghost" });
+  compare.addEventListener("click", function () { read(selected.relativePath, selected.commit, 0, before.value); });
+  viewer.append(h("div.record-actions", null, before, compare));
+  const source = h("pre.code-block.artifact-text", { tabIndex: 0, "aria-label": t("evidence.fixedText") }, value.content);
+  if (!value.before && /\.md$|\.markdown$/i.test(selected.relativePath)) {
+    viewer.append(markdownPreview(value, taskId, t, actions, preview));
+    viewer.append(h("details", null, h("summary", null, t("materials.source")), source));
+  } else viewer.append(source);
+  viewer.append(note((value.content.length ? value.offset + 1 : 0) + "–" + (value.offset + value.content.length) + " / " + value.totalCharacters));
+  const first = button(t("materials.firstPage"), { variant: "ghost" });
+  first.disabled = value.offset === 0;
+  first.addEventListener("click", function () { read(selected.relativePath, selected.commit, 0, value.before?.commit); });
+  const next = button(t("materials.nextPage"), { variant: "ghost" });
+  next.disabled = value.nextOffset === null;
+  next.addEventListener("click", function () { read(selected.relativePath, selected.commit, value.nextOffset, value.before?.commit); });
+  viewer.append(h("div.record-actions", null, first, next));
+}
+
+function artifactRef(value) {
+  return { taskId: value.taskId, commit: value.commit, relativePath: value.relativePath, digest: value.digest };
+}
+
+function downloadImage(value) {
+  const bytes = Uint8Array.from(atob(value.base64), function (char) { return char.charCodeAt(0); });
+  const url = URL.createObjectURL(new Blob([bytes], { type: value.mime }));
+  h("a", { href: url, download: value.relativePath.split("/").pop() }).click();
+  window.setTimeout(function () { URL.revokeObjectURL(url); }, 1000);
+}
+
+function imagePreview(value, t, alt, state = {}) {
+  const image = h("img.artifact-image", { alt: alt || value.relativePath, decoding: "async" });
+  const viewport = h("span.image-viewport", { tabIndex: 0, "aria-label": t("materials.image") }, image);
+  const status = h("span.feed-note", { role: "status" }, value.width + " × " + value.height + " · " + formatBytes(value.byteSize));
+  const scale = h("select", { "aria-label": t("materials.zoom") },
+    h("option", { value: "fit" }, t("materials.fit")),
+    ...[50, 100, 200, 400].map(function (percent) { return h("option", { value: String(percent) }, percent + "%"); }));
+  function applyScale() {
+    image.classList.toggle("is-zoomed", scale.value !== "fit");
+    if (scale.value === "fit") image.removeAttribute("width");
+    else image.width = Math.round((image.naturalWidth || value.width) * Number(scale.value) / 100);
+  }
+  scale.value = state.zoom || "fit";
+  applyScale();
+  scale.addEventListener("change", function () {
+    state.zoom = scale.value;
+    applyScale();
+  });
+  image.addEventListener("error", function () {
+    image.removeAttribute("src"); image.hidden = true; scale.disabled = true;
+    status.textContent = t("materials.imageError");
+  }, { once: true });
+  image.src = "data:" + value.mime + ";base64," + value.base64;
+  return h("span.image-preview", null, h("span.record-actions", null, scale, status), viewport);
+}
+
+function markdownPreview(value, taskId, t, actions, preview) {
+  const body = h("div.md.artifact-markdown");
+  const images = [];
+  body.innerHTML = renderMarkdown(value.content, { image: function (alt, target) {
+    if (images.length >= 12) return '<span class="feed-note">' + escapeHtml(t("materials.imageLimit")) + "</span>";
+    const index = images.push({ alt, target }) - 1;
+    return '<span class="md-image-slot" data-image-index="' + index + '"></span>';
+  } });
+  body.querySelectorAll("[data-image-index]").forEach(function (slot) {
+    const index = Number(slot.dataset.imageIndex);
+    const entry = images[index];
+    const saved = preview.images[index] || (preview.images[index] = {});
+    let path;
+    try { path = resolveMarkdownImage(value.relativePath, entry.target); }
+    catch (error) { slot.append(note(entry.alt + ": " + error.message, "bad")); return; }
+    const load = button(t("materials.loadImage") + " · " + (entry.alt || path), { variant: "ghost" });
+    const status = h("span.feed-note", { role: "status" });
+    slot.append(load, status);
+    function showImage() {
+      if (slot.isConnected === false) return;
+      const image = saved.image;
+      clear(slot);
+      const download = button(t("materials.download"), { variant: "ghost" });
+      download.addEventListener("click", function () { downloadImage(image); });
+      const feedback = button(t("materials.feedback"), { variant: "ghost" });
+      feedback.addEventListener("click", function () { actions.openConversation([artifactRef(value), artifactRef(image)]); });
+      slot.append(imagePreview(image, t, entry.alt, saved), h("span.viewer-ref", null,
+        path + " · git:" + image.commit + " · sha256:" + image.digest),
+        h("span.record-actions", null, download, feedback));
+    }
+    async function observeRead() {
+      load.disabled = true; body.dataset.reading = "true"; status.textContent = t("evidence.reading");
+      try { await saved.pending; showImage(); }
+      catch (error) { status.textContent = error.message; load.disabled = false; }
+      finally { body.dataset.reading = String(preview.pending > 0); }
+    }
+    load.addEventListener("click", function () {
+      if (saved.pending) return saved.pending;
+      if (preview.pending >= 2) { status.textContent = t("materials.imageBusy"); return; }
+      if (preview.totalBytes >= 16 * 1024 * 1024 || preview.totalPixels >= 32_000_000) { status.textContent = t("materials.imageLimit"); return; }
+      preview.pending++;
+      saved.pending = (async function () {
+        const image = await actions.readArtifact(taskId, path, value.commit, 0);
+        if (image.kind !== "image") throw new Error(t("materials.imageUnsupported"));
+        if (preview.totalBytes + image.byteSize > 16 * 1024 * 1024 || preview.totalPixels + image.width * image.height > 32_000_000) {
+          throw new Error(t("materials.imageLimit"));
+        }
+        preview.totalBytes += image.byteSize; preview.totalPixels += image.width * image.height;
+        saved.image = image;
+      })().finally(function () { preview.pending--; delete saved.pending; });
+      return observeRead();
+    });
+    if (saved.image) showImage();
+    else if (saved.pending) void observeRead();
+  });
+  return body;
+}
+
+function drawFileList(list, state, t, read) {
+  clear(list);
+  const current = state.artifactList;
+  if (!current) return;
+  const selected = state.artifact && (state.artifact.after || state.artifact);
+  if (selected && current.commit !== selected.commit) list.append(note(t("evidence.differentRevision")));
+  if (!current.entries.length) { list.append(emptyState(t("evidence.noFiles"), "file")); return; }
+  current.entries.forEach(function (entry) {
+    list.append(h("button.file-row", {
+      type: "button",
+      "aria-current": String(!!selected && selected.relativePath === entry.relativePath && selected.commit === current.commit),
+      onclick: function () { read(entry.relativePath, current.commit); }
+    }, icon("file", "icon-sm"), h("span.file-name", null, entry.relativePath), h("span.faint.small", null, formatBytes(entry.size))));
+  });
+}
+
+// Frozen references named by the completion, the Brief or a decision.
+function referencedFiles(data, t, read) {
+  const sources = [data.task.completionArtifactRefs || [],
+    data.core.records.filter(function (entry) { return !entry.omitted && ["task-brief", "task-decision"].includes(entry.ref.store); })
+      .map(function (entry) { return JSON.stringify(entry.value); })].flat().join(" ");
+  const refs = Array.from(sources.matchAll(/git:([0-9a-f]{40}):([^\s"\\]+?)(?=[\s"\\]|$)/g));
+  const seen = new Set();
+  const referenced = h("div.file-list");
+  refs.forEach(function (match) {
+    if (seen.has(match[0])) return;
+    seen.add(match[0]);
+    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")));
+  });
+  return referenced;
+}
+`;