@zq-silk/yui 0.15.7 → 0.15.9

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

@@ -47,9 +47,10 @@ const state = {
   detail: null,
   detailKey: null
 };
-const VALID_FILTERS = ["all", "active", "draft", "completed", "retired", "archived"];
+const VALID_FILTERS = ["all", "active", "draft", "completed", "cancelled", "archived"];
 let terminalSession = null;
 let terminalStateKey = "terminal.closed";
+const submittedRequests = new Set();
 
 const i18n = createI18n(elements.locale);
 createThemeController(elements.theme);
@@ -125,7 +126,19 @@ function syncUrlFromState(options) {
 function detailActions() {
   return {
     answerInput: answerInput,
-    openTerminal: openTerminal
+    openTerminal: openTerminal,
+    inspect: inspectRecord,
+    sendMessage: (taskId, body, requestId, intent) => submitMutation(taskId + "/messages",
+      "/api/tasks/" + encodeURIComponent(taskId) + "/messages",
+      { body, requestId, ...(intent === undefined ? {} : { intent }) }),
+    updateTask: (taskId, patch, requestId) => submitMutation(taskId + "/metadata",
+      "/api/tasks/" + encodeURIComponent(taskId) + "/metadata", { patch, requestId }),
+    panels: (taskId) => requestJson("/api/tasks/" + encodeURIComponent(taskId) + "/panels",
+      { signal: AbortSignal.timeout(3000) }),
+    readPanel: (taskId, ref, input) => requestJson("/api/tasks/" + encodeURIComponent(taskId) + "/panels", {
+      method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ ref, input }),
+      signal: AbortSignal.timeout(3000)
+    })
   };
 }
 
@@ -171,9 +184,30 @@ function detailKeyOf(detail) {
   return text.length + ":" + hash;
 }
 
+// The optional observation arrives after the core snapshot has already been
+// rendered, so the render key has to cover the observed facts the detail
+// actually draws or they would stay stale until the core snapshot changed.
+// Only the rendered identity is included: observation timestamps advance on
+// every poll and would re-render the detail continuously.
+function runtimeSignatureOf(detail) {
+  const roles = (detail.runtime && detail.runtime.roles) || [];
+  return detail.runtimeStatus + "|" + roles.map(function (role) {
+    const session = role.runtimeSession;
+    return role.name + ":" + (session
+      ? session.nativeSessionId + "/" + session.status
+      : "-");
+  }).join(",");
+}
+
 function renderCurrentDetail(force) {
   if (state.detail) {
-    const key = i18n.getLocale() + "|" + state.detailKey;
+    // Polling must not replace an unsent draft or an in-flight form, including
+    // after the user has moved focus. This is view state, never Task state.
+    if (elements.detail.dataset.taskId === state.detail.task.id
+      && (elements.detail.querySelector('[data-unsent="true"]')
+        || elements.detail.contains(document.activeElement))) return;
+    const key = i18n.getLocale() + "|" + state.detailKey
+      + "|" + runtimeSignatureOf(state.detail);
     if (!force && key === renderedDetailKey) return;
     renderTaskDetail(
       elements.detail,
@@ -275,31 +309,76 @@ async function requestJson(path, options) {
     ...options,
     headers: {
       accept: "application/json",
+      "x-yui-web-token": token,
       ...(options && options.headers ? options.headers : {})
     }
   });
   if (!response.ok) {
     let message = "HTTP " + response.status;
+    let disposition = "unknown";
     try {
       const body = await response.json();
       if (body && body.error) message = body.error;
+      if (body && body.disposition === "not-submitted") disposition = "not-submitted";
     } catch {}
-    throw new Error(message);
+    throw Object.assign(new Error(message), { disposition });
   }
   return response.json();
 }
 
+async function submitMutation(key, path, body) {
+  if (submittedRequests.has(key)) throw new Error("An earlier submission is unresolved; read current facts.");
+  submittedRequests.add(key);
+  try {
+    const receipt = await requestJson(path, {
+      method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body)
+    });
+    submittedRequests.delete(key);
+    return receipt;
+  } catch (error) {
+    if (error.disposition === "not-submitted") submittedRequests.delete(key);
+    throw error;
+  }
+}
+
 async function loadTaskDetail(taskId, showLoading) {
   if (showLoading) {
     renderLoading(elements.detail, i18n.t, "loading.detail");
     elements.mainCol.scrollTop = 0;
   }
   const savedScrollTop = showLoading ? 0 : elements.mainCol.scrollTop;
-  const detail = await requestJson("/api/tasks/" + encodeURIComponent(taskId));
+  const base = "/api/tasks/" + encodeURIComponent(taskId);
+  // Rendering consumes the current snapshot, not event pages. Reconnect uses
+  // this same read; the independent delta API retains its fixed-bound contract.
+  const core = await requestJson(base + "/context");
+  const taskEntry = core.records.find(function (entry) { return entry.ref.store === "task"; });
+  if (!taskEntry) throw new Error("Task reference unavailable.");
+  const task = taskEntry.omitted ? (await inspectRecord(taskId, taskEntry.ref)).value : taskEntry.value;
+  const previous = state.detail && state.detail.task.id === taskId ? state.detail : null;
+  const detail = {
+    task, core,
+    runtime: previous && previous.runtime,
+    runtimeStatus: previous ? previous.runtimeStatus : "waiting",
+    runtimeObservedAt: previous ? previous.runtimeObservedAt : new Date().toISOString()
+  };
   if (state.selected !== taskId) return;
   state.detail = detail;
-  state.detailKey = detailKeyOf(detail);
-  renderCurrentDetail(true);
+  state.detailKey = detailKeyOf(core);
+  renderCurrentDetail();
+  // Optional observation does not participate in core readiness or cursor.
+  void requestJson(base, { signal: AbortSignal.timeout(1000) }).then(function (runtime) {
+    if (state.detail !== detail) return;
+    detail.runtime = runtime;
+    detail.runtimeStatus = "available";
+    detail.runtimeObservedAt = new Date().toISOString();
+    updateRuntimePanel(detail);
+  }).catch(function () {
+    if (state.detail !== detail) return;
+    detail.runtime = null;
+    detail.runtimeStatus = "unavailable";
+    detail.runtimeObservedAt = new Date().toISOString();
+    updateRuntimePanel(detail);
+  });
   // Reveal the tab bar before measuring/scroll so anchors land correctly.
   setDetailActive(true);
   updateStickyOffsets();
@@ -314,6 +393,25 @@ async function loadTaskDetail(taskId, showLoading) {
   syncTabHighlight();
 }
 
+function updateRuntimePanel(detail) {
+  const status = elements.detail.querySelector("[data-runtime-status]");
+  const value = elements.detail.querySelector("[data-runtime-value]");
+  if (status) status.textContent = detail.runtimeStatus + " · " + detail.runtimeObservedAt;
+  if (value) value.textContent = detail.runtime
+    ? JSON.stringify({ roles: detail.runtime.roles, runtimeHealth: detail.runtime.runtimeHealth }, null, 2)
+    : "";
+  // Patching the panel in place is not enough: the observation also feeds facts
+  // the detail rendered before it arrived. Re-render when the observed identity
+  // has actually changed — renderCurrentDetail still compares the render key,
+  // so an unchanged observation costs nothing and an unsent form is preserved.
+  if (state.detail === detail) renderCurrentDetail();
+}
+
+async function inspectRecord(taskId, ref) {
+  const query = new URLSearchParams({ store: ref.store, ref: ref.refId, digest: ref.digest });
+  return requestJson("/api/tasks/" + encodeURIComponent(taskId) + "/inspect?" + query);
+}
+
 async function selectTask(taskId) {
   // Switching tasks drops the previous section; staying on the same task
   // (URL-driven loads, popstate) keeps it.
@@ -345,27 +443,27 @@ async function selectTask(taskId) {
 async function answerInput(input, answer) {
   if (!state.detail) return;
   const taskId = state.detail.task.id;
+  const key = taskId + "/input/" + input.id;
   try {
-    await requestJson(
+    await submitMutation(key,
       "/api/tasks/" + encodeURIComponent(taskId)
         + "/inputs/" + encodeURIComponent(input.id) + "/answer",
-      {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          "x-yui-web-token": token
-        },
-        body: JSON.stringify(answer)
-      }
+      answer
     );
     showToast(i18n.t("input.answered"));
+    submittedRequests.delete(key);
     await refreshDashboard({ quiet: true });
-  } catch {
-    showToast(i18n.t("errors.answer"));
+  } catch (error) {
+    showToast(error.disposition === "not-submitted" ? error.message : i18n.getLocale().startsWith("zh")
+      ? "回答结果未知；请刷新检查原问题，不要盲目重发。"
+      : "Answer outcome unknown; refresh the original question before resubmitting.");
   }
 }
 
+let refreshing = false;
 async function refreshDashboard(options) {
+  if (refreshing) return;
+  refreshing = true;
   const quiet = options && options.quiet;
   if (!quiet) {
     elements.refresh.disabled = true;
@@ -386,8 +484,10 @@ async function refreshDashboard(options) {
     if (previousInputs !== null && dashboard.counts.openInputs > previousInputs) {
       showToast(i18n.t("input.new"));
     }
-    if (state.selected && !quiet) {
-      try { await loadTaskDetail(state.selected, false); } catch {}
+    if (state.selected) {
+      try { await loadTaskDetail(state.selected, false); } catch {
+        showToast(i18n.getLocale().startsWith("zh") ? "连接不可用；保留上次读取。" : "Disconnected; showing the last read.");
+      }
     }
   } catch {
     if (!quiet) {
@@ -395,6 +495,7 @@ async function refreshDashboard(options) {
       showToast(i18n.t("errors.dashboard"));
     }
   } finally {
+    refreshing = false;
     if (!quiet) elements.refresh.disabled = false;
   }
 }

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

@@ -1,3 +1,5 @@
+import { AGENT_ADAPTER_CATALOG } from "../../../agent/adapterCatalog.js";
+import { AGENT_EXECUTION_COMPONENT_CATALOG } from "../../../agent/executionComponents.js";
 export const COMPONENTS_SCRIPT = `
 // Reusable widgets and record cards. Everything here is a pure builder:
 // data + i18n in, DOM out. Page composition lives in view.js.
@@ -5,15 +7,19 @@ import { node } from "/assets/js/dom.js";
 import { formatDateTime, relativeTime } from "/assets/js/format.js";
 import { escapeHtml, inlineMarkdown, renderMarkdown } from "/assets/js/markdown.js";
 
-export function translatedStatus(t, prefix, status) {
-  return t(prefix + "." + status);
-}
-
-// Mirrors src/agent/adapterCatalog.ts to avoid a runtime import loop.
-const adapterLabels = { codex: "Codex", claude: "Claude" };
+// Generated from the server catalogs, not a second product registry.
+const adapterLabels = ${JSON.stringify(Object.fromEntries(AGENT_ADAPTER_CATALOG.map(({ id, label }) => [id, label])))};
+const componentLabels = ${JSON.stringify(Object.fromEntries(AGENT_EXECUTION_COMPONENT_CATALOG.map(({ id, label }) => [id, label])))};
 function adapterLabel(adapterId) {
   return adapterLabels[adapterId] || adapterId;
 }
+function componentLabel(component, adapterId) {
+  return component ? componentLabels[component] || component : adapterLabel(adapterId);
+}
+
+export function translatedStatus(t, prefix, status) {
+  return t(prefix + "." + status);
+}
 
 // --- Small widgets -----------------------------------------------------------
 export function metaItem(label, value) {
@@ -37,7 +43,9 @@ export function chip(text, extraClass) {
 export function agentBadge(agent) {
   if (!agent) return null;
   const badge = node("span", "agent-badge");
-  if (agent.adapterId) badge.append(chip(adapterLabel(agent.adapterId), "is-adapter"));
+  if (agent.adapterId || agent.component) {
+    badge.append(chip(componentLabel(agent.component, agent.adapterId), "is-adapter"));
+  }
   if (agent.model) badge.append(chip(agent.model));
   if (agent.effort) badge.append(chip(agent.effort));
   return badge.childNodes.length ? badge : null;
@@ -102,6 +110,9 @@ const EXEC_STATUS_TONE = {
   "working": "is-active",
   "completed": "is-muted",
   "retired": "is-muted",
+  "cancelled": "is-muted",
+  "accepted": "is-muted",
+  "open": "is-active",
   "archived": "is-muted"
 };
 
@@ -114,9 +125,9 @@ export function executionBand(projection, t, locale) {
   head.append(pill(t, "exec.status", projection.status));
   head.append(node("span", "exec-band-owner",
     t("exec.owner." + projection.owner) + " · " + t("exec.action." + projection.action)));
-  if (projection.activeTurns && projection.activeTurns.length > 0) {
+  if (projection.activeRuns && projection.activeRuns.length > 0) {
     head.append(node("span", "exec-band-executors",
-      projection.activeTurns.length + " " + t("exec.executors")));
+      projection.activeRuns.length + " " + t("exec.executors")));
   }
   if (projection.monitoring === "stopped") {
     head.append(node("span", "exec-band-stopped", t("exec.monitoring.stopped")));
@@ -176,9 +187,10 @@ export function workItemExecutionCard(projection, t) {
       row.append(statusDot(lane.status));
       row.append(node("span", "lane-role", lane.roleName));
       row.append(node("span", "lane-status", t("workExec.lane." + lane.status)));
-      row.append(node("span", "mono", lane.currentTurnId || t("detail.unobserved")));
-      if (lane.retryTurnId) row.append(chip(t("workExec.retry") + " · " + lane.retryTurnId, "is-danger"));
-      if (lane.settleTurnId) row.append(chip(t("workExec.settle") + " · " + lane.settleTurnId));
+      if (lane.delivery) row.append(chip(t("run.delivery." + lane.delivery)));
+      row.append(node("span", "mono", lane.currentRunId || t("detail.unobserved")));
+      if (lane.retryRunId) row.append(chip(t("workExec.retry") + " · " + lane.retryRunId, "is-danger"));
+      if (lane.settleRunId) row.append(chip(t("workExec.settle") + " · " + lane.settleRunId));
       if (lane.session === "unobserved") row.append(chip(t("detail.unobserved")));
       lanes.append(row);
     });
@@ -187,18 +199,18 @@ export function workItemExecutionCard(projection, t) {
 
   const facts = node("div", "record-meta execution-resource-meta");
   facts.append(node("span", "", t("workExec.main") + " · "
-    + (projection.mainTurn.turnId || t("detail.unobserved"))
-    + " [" + t("workExec.mainStatus." + projection.mainTurn.status) + "]"));
+    + (projection.mainRun.runId || t("detail.unobserved"))
+    + " [" + t("workExec.mainStatus." + projection.mainRun.status) + "]"));
   facts.append(node("span", "", t("workExec.candidate") + " · "
     + (projection.candidate.candidateId || t("workExec.none"))
     + " [" + t("workExec.candidateStatus." + projection.candidate.status) + "]"));
   card.append(facts);
 
   if (projection.candidate.sourceExecutionGroupId) {
-    const provenance = projection.candidate.successfulLaneTurns.map(function (lane) {
-      return lane.laneId + " → " + lane.successfulTurnId;
+    const provenance = projection.candidate.successfulLaneRuns.map(function (lane) {
+      return lane.laneId + " → " + lane.successfulRunId;
     }).join(", ") || t("detail.unobserved");
-    card.append(node("p", "muted mono", (projection.candidate.mainTurnId || t("detail.unobserved"))
+    card.append(node("p", "muted mono", (projection.candidate.mainRunId || t("detail.unobserved"))
       + " → " + projection.candidate.sourceExecutionGroupId + " → " + provenance));
   }
 
@@ -279,7 +291,7 @@ export function candidateList(candidates, t, locale) {
       row.append(node("span", "candidate-summary", candidate.summary));
       const source = candidate.source.type === "direct"
         ? t("candidate.source.direct")
-        : t("candidate.source.turn") + " " + candidate.source.turnId;
+        : t("candidate.source.run") + " " + candidate.source.runId;
       row.append(node("span", "candidate-source", source));
       row.append(node("time", "", formatDateTime(candidate.createdAt, locale)));
       list.append(row);
@@ -444,7 +456,7 @@ export function inputCard(input, _options, t, locale, actions) {
   }
   if (input.requester) {
     top.append(node("span", "input-requester",
-      t("detail.requester") + " · " + input.requester.roleName + " / " + input.requester.turnId));
+      t("detail.requester") + " · " + input.requester.roleName + " / " + (input.requester.runId ?? input.requester.nativeSessionId)));
   }
   card.append(top);
   card.append(answerActions(input, actions, t));
@@ -455,13 +467,13 @@ export function inputCard(input, _options, t, locale, actions) {
 export function conclusionMeta(task, t, locale, kind) {
   const meta = node("div", "conclusion-meta");
   const actor = kind === "archived" ? task.archivedBy
-    : kind === "retired" ? task.retiredBy
+    : kind === "cancelled" ? task.retiredBy
     : task.completedBy;
   const at = kind === "archived" ? task.archivedAt
-    : kind === "retired" ? task.retiredAt
+    : kind === "cancelled" ? task.retiredAt
     : task.completedAt;
   const label = kind === "archived" ? t("detail.archivedBy")
-    : kind === "retired" ? t("detail.retiredBy")
+    : kind === "cancelled" ? t("detail.cancelledBy")
     : t("detail.completedBy");
   if (actor) meta.append(node("span", "", label + " · " + authorName(t, actor)));
   if (at) meta.append(node("time", "", formatDateTime(at, locale)));
@@ -471,7 +483,7 @@ export function conclusionMeta(task, t, locale, kind) {
 // --- Record cards -----------------------------------------------------------------
 // WorkItems that no longer need action render collapsed; everything actionable
 // (pending, running, awaiting acceptance, failed) stays expanded.
-const WORK_ITEM_OPEN_STATUSES = ["pending", "running", "awaiting_acceptance", "failed"];
+const WORK_ITEM_OPEN_STATUSES = ["open"];
 
 export function workItemCard(item, titles, t, locale, actions, taskId) {
   const collapsible = WORK_ITEM_OPEN_STATUSES.indexOf(item.status) === -1;
@@ -561,46 +573,51 @@ export function workItemCard(item, titles, t, locale, actions, taskId) {
   return card;
 }
 
-export function turnCard(turn, t, locale) {
+export function runCard(run, t, locale) {
   const card = node("article", "execute-card");
-  card.dataset.status = turn.status;
+  card.dataset.status = run.status;
 
   const idRow = node("div", "execute-id");
-  idRow.append(statusDot(turn.status));
-  idRow.append(node("span", "role", turn.roleName));
-  idRow.append(node("span", "", turn.id));
-  if (turn.workItemId) idRow.append(node("span", "", t("detail.workItem") + " · " + turn.workItemId));
-  if (turn.purpose) idRow.append(chip(t("turn.purpose." + turn.purpose)));
-  idRow.append(node("time", "", formatDateTime(turn.result?.completedAt || turn.updatedAt, locale)));
+  idRow.append(statusDot(run.status));
+  idRow.append(node("span", "role", run.roleName));
+  idRow.append(node("span", "", run.id));
+  if (run.workItemId) idRow.append(node("span", "", t("detail.workItem") + " · " + run.workItemId));
+  if (run.purpose) idRow.append(chip(t("run.purpose." + run.purpose)));
+  idRow.append(node("time", "", formatDateTime(run.result?.completedAt || run.updatedAt, locale)));
   card.append(idRow);
+  const observation = node("div", "record-meta");
+  observation.append(node("span", "", t("run.recordState") + " · " + t("status." + run.status)));
+  observation.append(node("span", "", t("run.delivery") + " · "
+    + t("run.delivery." + (run.execution?.delivery || "unobserved"))));
+  card.append(observation);
 
-  const visibleInput = turn.inputs && turn.inputs.length ? turn.inputs[0].input : null;
+  const visibleInput = run.inputs && run.inputs.length ? run.inputs[0].input : null;
   card.append(richText(t("detail.instruction"), visibleInput?.directive || visibleInput?.action || "-", t, { className: "execute-io", threshold: 320 }));
-  if (turn.result?.output) {
-    card.append(richText(t("detail.outcome"), turn.result.output, t, { className: "execute-io outcome", threshold: 320 }));
+  if (run.result?.output) {
+    card.append(richText(t("detail.outcome"), run.result.output, t, { className: "execute-io outcome", threshold: 320 }));
   }
-  if (turn.result?.diagnostic) {
-    card.append(richText(t("detail.failure"), turn.result.diagnostic, t, { className: "execute-io outcome", threshold: 320 }));
+  if (run.result?.diagnostic) {
+    card.append(richText(t("detail.failure"), run.result.diagnostic, t, { className: "execute-io outcome", threshold: 320 }));
   }
 
   const foot = node("div", "execute-foot");
   const tags = node("div", "execute-tags");
-  tags.append(chip(t("mode." + turn.mode)));
-  if (turn.executionGroupId) {
-    tags.append(chip(t("detail.lineage") + " · " + turn.executionGroupId
-      + (turn.executionLaneId ? "/" + turn.executionLaneId : "")));
+  tags.append(chip(t("mode." + run.mode)));
+  if (run.executionGroupId) {
+    tags.append(chip(t("detail.lineage") + " · " + run.executionGroupId
+      + (run.executionLaneId ? "/" + run.executionLaneId : "")));
   }
-  const badge = turn.effective ? agentBadge(turn.effective) : (turn.agentId ? agentBadge(turn) : null);
+  const badge = run.effective ? agentBadge(run.effective) : (run.agentId ? agentBadge(run) : null);
   if (badge) tags.append(badge);
   foot.append(tags);
-  foot.append(pill(t, "turn", turn.status));
+  foot.append(pill(t, "run", run.status));
   card.append(foot);
 
-  if (turn.effective) {
+  if (run.effective) {
     const eff = node("div", "record-meta");
-    eff.append(node("span", "", t("detail.effective") + " · r" + turn.effective.sourceDesiredRevision));
-    eff.append(node("span", "", t("detail.profileIntent") + " · " + turn.effective.profileAccess));
-    eff.append(node("span", "", t("detail.permission") + " · " + turn.effective.permission.strategy));
+    eff.append(node("span", "", t("detail.effective") + " · r" + run.effective.sourceDesiredRevision));
+    eff.append(node("span", "", t("detail.profileIntent") + " · " + run.effective.profileAccess));
+    eff.append(node("span", "", t("detail.permission") + " · " + run.effective.permission.strategy));
     card.append(eff);
   }
 
@@ -631,8 +648,8 @@ export function reviewCard(round, t, locale) {
   if (round.workspace && round.workspace.root) {
     meta.append(pathMetaItem(t("detail.workspace"), round.workspace.root));
   }
-  if (round.reviewerTurnId) {
-    meta.append(node("span", "mono", t("detail.reviewerTurn") + " · " + round.reviewerTurnId));
+  if (round.reviewerRunId) {
+    meta.append(node("span", "mono", t("detail.reviewerRun") + " · " + round.reviewerRunId));
   }
   if (round.workspaceDisposition) {
     meta.append(node("span", "", t("detail.workspaceDisposition") + " · "
@@ -647,7 +664,7 @@ export function reviewCard(round, t, locale) {
     groupMeta.append(node("span", "", t("reviewExec.assignment") + " · "
       + group.assignment.contextSnapshotRef.id));
     groupMeta.append(node("span", "", t("reviewExec.main") + " · "
-      + (round.reviewerTurnId || t("detail.unobserved"))));
+      + (round.reviewerRunId || t("detail.unobserved"))));
     execution.append(groupMeta);
     const lanes = node("div", "lane-list");
     group.lanes.forEach(function (lane) {
@@ -656,7 +673,7 @@ export function reviewCard(round, t, locale) {
       row.append(node("span", "lane-role", t("reviewExec.producer") + " " + lane.ordinal
         + " · " + lane.roleName));
       row.append(node("span", "lane-status", t("reviewExec.status." + lane.disposition)));
-      row.append(node("span", "mono", lane.currentTurnId || t("detail.unobserved")));
+      row.append(node("span", "mono", lane.currentRunId || t("detail.unobserved")));
       lanes.append(row);
     });
     execution.append(lanes);
@@ -694,6 +711,7 @@ export function roleCard(role, task, t, locale, actions) {
   if (activeBinding) {
     const badge = agentBadge({
       adapterId: activeBinding.adapterId,
+      component: activeBinding.component,
       model: activeBinding.config && activeBinding.config.model,
       effort: activeBinding.config && activeBinding.config.effort
     });
@@ -745,10 +763,10 @@ export function roleCard(role, task, t, locale, actions) {
     const bindings = bindingIds.map(function (id) {
       const binding = role.agentBindings[id];
       const model = binding.config && binding.config.model;
-      return adapterLabel(binding.adapterId) + (model ? " · " + model : "");
+      return componentLabel(binding.component, binding.adapterId) + (model ? " · " + model : "");
     });
     const activeBindingLabel = activeBinding
-      ? adapterLabel(activeBinding.adapterId) + (activeBinding.config && activeBinding.config.model ? " · " + activeBinding.config.model : "")
+      ? componentLabel(activeBinding.component, activeBinding.adapterId) + (activeBinding.config && activeBinding.config.model ? " · " + activeBinding.config.model : "")
       : undefined;
     cols.append(chipRow(t("detail.agents"), bindings, activeBindingLabel));
   }
@@ -801,7 +819,7 @@ export function historyEventRow(event, t, locale) {
   return card;
 }
 
-export function messageCard(message, t, locale) {
+export function messageCard(message, t, locale, result) {
   const card = node("article", "record-card");
   const head = node("div", "record-head");
   const titleRow = node("div", "record-title-row");
@@ -814,10 +832,25 @@ export function messageCard(message, t, locale) {
   const meta = node("div", "record-meta");
   meta.append(node("span", "mono", message.id));
   meta.append(node("time", "", formatDateTime(message.createdAt, locale)));
-  if (message.turnId) meta.append(node("span", "mono", message.turnId + (message.workItemId ? " · " + message.workItemId : "")));
+  if (message.runId) meta.append(node("span", "mono", message.runId + (message.workItemId ? " · " + message.workItemId : "")));
+  if (message.recipient) {
+    meta.append(node("span", "mono", "→ " + message.recipient.roleName + " · "
+      + (message.recipient.reviewRoundId || message.recipient.workItemId)));
+    meta.append(node("span", "mono", !message.recipient.ownerRunId ? t("messageDelivery.notification") : message.continuation?.runId
+      ? t("messageDelivery.run") + " " + message.continuation.runId
+      : message.continuation?.notDeliveredReason
+        ? t("messageDelivery.blocked") + " " + message.continuation.notDeliveredReason
+        : t("messageDelivery.pending")));
+  }
   card.append(meta);
 
   card.append(richText(null, message.body, t));
+  if (message.resultRef) {
+    card.append(node("small", "mono", message.resultRef.runId));
+    if (result?.output) card.append(richText(t("detail.outcome"), result.output, t));
+    if (result?.diagnostic) card.append(richText(t("detail.failure"), result.diagnostic, t));
+    if (!result) card.append(node("p", "muted", t("detail.unobserved")));
+  }
   return card;
 }