@staix/agent-hub 0.30.0 → 0.31.0

package/src/rooms/wire.ts

@@ -23,7 +23,7 @@ const FP = /^[0-9a-f]{64}$/;
 export interface RoomMember extends PublicHubIdentity { label: string; exposedPeers: string[] }
 export interface FrameWire {
   v: 1; type: "frame"; room: string; epoch: string; sender: string;
-  recipients: string[]; seq: string; nonce: string; ciphertext: string; signature: string;
+  recipients: string[]; seq: string; ephemeral?: true; nonce: string; ciphertext: string; signature: string;
 }
 export interface RosterWire {
   v: 1; type: "roster"; room: string; epoch: string; owner: string;
@@ -107,8 +107,10 @@ function wrap(x: unknown): WrappedEpochKey {
   return { v: 1, owner: fingerprint(o.owner), recipient: fingerprint(o.recipient), ephemeralKey: b64(o.ephemeralKey, 32), salt: b64(o.salt, 32), nonce: b64(o.nonce, 12), ciphertext: ciphertext(o.ciphertext, 48, 48), signature: b64(o.signature, 64) };
 }
 function parseFrame(x: unknown): FrameWire {
-  const o = object(x, ["v", "type", "room", "epoch", "sender", "recipients", "seq", "nonce", "ciphertext", "signature"]); base(o, "frame");
-  return { v: 1, type: "frame", room: b64(o.room, 32), epoch: positiveU64(o.epoch), sender: fingerprint(o.sender), recipients: sorted(array(o.recipients, 64, fingerprint, true), x => x), seq: positiveU64(o.seq), nonce: b64(o.nonce, 12), ciphertext: ciphertext(o.ciphertext, 65552), signature: b64(o.signature, 64) };
+  const ephemeral = typeof x === "object" && x !== null && Object.hasOwn(x, "ephemeral");
+  const o = object(x, ["v", "type", "room", "epoch", "sender", "recipients", "seq", "nonce", "ciphertext", "signature", ...(ephemeral ? ["ephemeral"] : [])]); base(o, "frame");
+  if (ephemeral && o.ephemeral !== true) fail();
+  return { v: 1, type: "frame", room: b64(o.room, 32), epoch: positiveU64(o.epoch), sender: fingerprint(o.sender), recipients: sorted(array(o.recipients, 64, fingerprint, true), x => x), seq: positiveU64(o.seq), ...(ephemeral ? { ephemeral: true as const } : {}), nonce: b64(o.nonce, 12), ciphertext: ciphertext(o.ciphertext, 65552), signature: b64(o.signature, 64) };
 }
 function parseRoster(x: unknown): RosterWire {
   const o = object(x, ["v", "type", "room", "epoch", "owner", "members", "wraps", "privateNonce", "privateCiphertext", "signature"]); base(o, "roster");
@@ -228,6 +230,7 @@ export interface VerifiedPublicFrame {
   readonly digest: string;
   readonly rosterDigest: string;
   readonly recipients: readonly string[];
+  readonly ephemeral?: true;
 }
 interface PublicFrameState { wire: Uint8Array }
 const publicFrames = new WeakMap<VerifiedPublicFrame, PublicFrameState>();
@@ -252,7 +255,7 @@ export async function verifyPublicFrame(input: { wire: Uint8Array; roster: Verif
   await verifyFrameSignature(frame, sender);
   const frameDigest = await digest(canonicalBytes(frame));
   const proof = Object.freeze({ room: frame.room, epoch: frame.epoch, sender: frame.sender, seq: frame.seq,
-    digest: frameDigest, rosterDigest: roster.digest, recipients: Object.freeze([...frame.recipients]) });
+    digest: frameDigest, rosterDigest: roster.digest, ...(frame.ephemeral ? { ephemeral: true as const } : {}), recipients: Object.freeze([...frame.recipients]) });
   publicFrames.set(proof, { wire });
   return proof;
 }
@@ -330,9 +333,10 @@ function frameAad(frame: Pick<FrameWire, "room" | "epoch" | "sender" | "seq">):
   return enc.encode(`${frame.room}|${frame.epoch}|${frame.sender}|${frame.seq}`);
 }
 export async function sealFrame(input: {
-  epoch: VerifiedEpoch; identity: HubIdentity; recipients: string[]; plaintext: Uint8Array; sequence: SequencePort;
+  epoch: VerifiedEpoch; identity: HubIdentity; recipients: string[]; plaintext: Uint8Array; sequence: SequencePort; ephemeral?: true;
 }): Promise<Uint8Array> {
   await assertRoomCryptoReady();
+  if (input.ephemeral !== undefined && input.ephemeral !== true) fail();
   const epoch = input.epoch, identity = input.identity, sequence = input.sequence;
   const current = state(epoch), sender = identity.public.fingerprint;
   const member = current.roster.members.find(m => m.fingerprint === sender);
@@ -344,7 +348,7 @@ export async function sealFrame(input: {
   if (!sequence || typeof sequence.reserve !== "function" || typeof sequence.isCurrent !== "function") fail("state_unavailable");
   const binding = { room: epoch.room, sender, epoch: epoch.epoch, rosterDigest: epoch.digest };
   const seq = positiveU64(await portCall(() => sequence.reserve({ ...binding })));
-  const header = { v: 1 as const, type: "frame" as const, room: epoch.room, epoch: epoch.epoch, sender, recipients, seq };
+  const header = { v: 1 as const, type: "frame" as const, room: epoch.room, epoch: epoch.epoch, sender, recipients, seq, ...(input.ephemeral ? { ephemeral: true as const } : {}) };
   const nonce = randomBytes(12);
   const encrypted = await encryptEpoch({ key: current.key, purpose: "frame", context: frameContext(epoch, sender), aad: frameAad(header), nonce, plaintext });
   const body = { ...header, nonce: encodeBase64url(nonce), ciphertext: encodeBase64url(encrypted) };
@@ -354,6 +358,20 @@ export async function sealFrame(input: {
   if (fresh !== true) fail("state_changed");
   return wire;
 }
+/** Read a retained local send for resealing, never receiver admission or replay evidence. */
+export async function openOwnFrame(input: { wire: Uint8Array; identity: HubIdentity; epoch: VerifiedEpoch }): Promise<Uint8Array> {
+  await assertRoomCryptoReady();
+  const frame = decodeFrame(input.wire), current = state(input.epoch), sender = input.identity.public;
+  const member = current.roster.members.find(value => value.fingerprint === sender.fingerprint);
+  if (frame.ephemeral || frame.room !== input.epoch.room || frame.epoch !== input.epoch.epoch || frame.sender !== sender.fingerprint
+    || !member || member.signingKey !== sender.signingKey || member.agreementKey !== sender.agreementKey
+    || frame.recipients.some(recipient => !current.roster.members.some(value => value.fingerprint === recipient))) fail("untrusted");
+  await verifyFrameSignature(frame, member);
+  const plaintext = await decryptEpoch({ key: current.key, purpose: "frame", context: frameContext(input.epoch, frame.sender), aad: frameAad(frame),
+    nonce: decodeBase64url(frame.nonce, 12), ciphertext: decodeBase64url(frame.ciphertext) });
+  if (plaintext.length > ROOM_WIRE_LIMITS.plaintext) fail("limit");
+  return plaintext;
+}
 export type FrameOpenResult = { status: "accepted"; plaintext: Uint8Array; gap: string } | { status: "duplicate" | "stale" };
 export async function openFrame(input: {
   wire: Uint8Array; identity: HubIdentity; current: VerifiedEpoch;

package/src/ui/index.html

@@ -450,7 +450,7 @@ main[data-stale]>:not(#notice):not(#disconnected){opacity:.6;transition:opacity
 <section id="office-section" aria-labelledby="office-title" data-view="office" hidden><div class="section-head"><h2 id="office-title">Office</h2><div class="filters"><label for="office-view">Office mode</label><select id="office-view"><option value="off">Off</option><option value="flat">Flat</option><option value="isometric">Isometric</option></select></div></div><div id="office" class="content"></div></section>
 <section aria-labelledby="stream-title" data-view="stream" hidden><div class="section-head"><h2 id="stream-title">Live stream</h2><div class="filters"><div id="stream-filters" class="chips" role="group" aria-label="Filter events by kind"></div><label><input id="follow" type="checkbox" checked> Follow latest</label></div></div><div id="stream" class="stream" tabindex="0" aria-label="Recent hub events"><p class="empty">Waiting for hub activity...</p></div><p id="stream-empty" class="empty" hidden>No events match this filter.</p></section>
 
-<section aria-labelledby="memory-title" data-view="memory" hidden><div class="section-head"><h2 id="memory-title">Memory</h2><div class="filters"><div id="memory-tiers" class="chips" role="group" aria-label="Memory tier"></div><span id="memory-count" class="meta"></span></div></div><div class="memory-controls"><input id="memory-q" type="search" maxlength="200" placeholder="Search memory" aria-label="Search memory"><select id="memory-kind" aria-label="Filter memory by kind"><option value="">All kinds</option><option value="decision">Decisions</option><option value="contract">Contracts</option><option value="fail">Fails</option><option value="finding">Findings</option></select><select id="memory-peer" aria-label="Filter memory by peer"><option value="">All peers</option></select><select id="memory-machine" aria-label="Filter memory by machine"><option value="">All machines</option></select><select id="memory-since" aria-label="Filter memory by time"><option value="">Any time</option><option value="1">Last day</option><option value="7">Last week</option><option value="30">Last 30 days</option></select><select id="memory-hops" aria-label="Graph neighbourhood depth"><option value="1">1 hop</option><option value="2">2 hops</option></select><label class="memory-code-toggle"><input id="memory-code-neighbours" type="checkbox" aria-describedby="memory-code-help" disabled>Code neighbours (1 hop)</label><span id="memory-code-help" class="meta">Select a symbol to inspect derived code neighbours.</span></div><div id="memory-list" class="task-list" aria-label="Memory entries"></div><div id="memory-graph" class="memory-graph"></div><div id="memory-detail"></div></section>
+<section aria-labelledby="memory-title" data-view="memory" hidden><div class="section-head"><h2 id="memory-title">Memory</h2><div class="filters"><div id="memory-tiers" class="chips" role="group" aria-label="Memory tier"></div><span id="memory-count" class="meta"></span></div></div><p id="memory-sync-status" class="meta" aria-live="polite"></p><div class="memory-controls"><input id="memory-q" type="search" maxlength="200" placeholder="Search memory" aria-label="Search memory"><select id="memory-kind" aria-label="Filter memory by kind"><option value="">All kinds</option><option value="decision">Decisions</option><option value="contract">Contracts</option><option value="fail">Fails</option><option value="finding">Findings</option></select><select id="memory-peer" aria-label="Filter memory by peer"><option value="">All peers</option></select><select id="memory-machine" aria-label="Filter memory by machine"><option value="">All machines</option></select><select id="memory-since" aria-label="Filter memory by time"><option value="">Any time</option><option value="1">Last day</option><option value="7">Last week</option><option value="30">Last 30 days</option></select><select id="memory-hops" aria-label="Graph neighbourhood depth"><option value="1">1 hop</option><option value="2">2 hops</option></select><label class="memory-code-toggle"><input id="memory-code-neighbours" type="checkbox" aria-describedby="memory-code-help" disabled>Code neighbours (1 hop)</label><span id="memory-code-help" class="meta">Select a symbol to inspect derived code neighbours.</span></div><div id="memory-list" class="task-list" aria-label="Memory entries"></div><div id="memory-graph" class="memory-graph"></div><div id="memory-detail"></div></section>
 <section aria-labelledby="compose-title" data-view="message" hidden><div class="section-head"><h2 id="compose-title">Console message</h2></div><form id="send" class="content"><div class="field"><label for="recipient">Recipient</label><select id="recipient" name="recipient"><option value="">All peers</option></select></div><div class="field"><label for="message">Message</label><textarea id="message" name="body" required maxlength="8000" placeholder="Send an instruction to the team..."></textarea></div><button class="primary" data-mutation="project" type="submit">Send message</button></form></section>
 <section aria-labelledby="settings-title" data-view="settings" hidden><div class="section-head"><h2 id="settings-title">Settings</h2><span id="settings-session" class="meta" role="status"></span></div><div id="settings"><p class="empty">Waiting for the hub...</p></div></section>
 </div>
@@ -459,6 +459,7 @@ main[data-stale]>:not(#notice):not(#disconnected){opacity:.6;transition:opacity
 <section id="schedules-section" aria-labelledby="schedules-title" data-view="agents" hidden><div class="section-head"><h2 id="schedules-title">Schedules</h2><span id="schedule-count" class="meta"></span></div><div id="schedules"></div></section>
 <section id="rooms-section" aria-labelledby="rooms-title" data-view="agents" data-empty="true" hidden><div class="section-head"><h2 id="rooms-title">Rooms</h2><span id="room-count" class="meta"></span></div><div id="rooms"></div></section>
 <section aria-labelledby="peers-title" data-view="agents" hidden><div class="section-head"><h2 id="peers-title">Peers &amp; queues</h2><span id="peer-count" class="meta"></span></div><div id="peers"><div class="skeleton" aria-hidden="true"><span class="skeleton-bar skeleton-tall"></span><span class="skeleton-bar skeleton-tall"></span><span class="skeleton-bar skeleton-tall"></span></div><p class="empty">Loading peers...</p></div></section>
+<section id="results-section" aria-labelledby="results-title" data-view="agents" hidden><div class="section-head"><h2 id="results-title">Results</h2><span id="results-count" class="meta"></span></div><div id="results"></div></section>
 <section aria-labelledby="permissions-title" data-view="agents" hidden><div class="section-head"><h2 id="permissions-title">Pending approvals</h2><span id="permission-count" class="meta"></span></div><div id="permissions"></div></section>
 <section aria-labelledby="budget-title" data-view="agents" hidden><div class="section-head"><h2 id="budget-title">Usage budgets</h2></div><div id="budget"></div>
 <div id="usage-content" class="content">
@@ -574,6 +575,7 @@ function initializeDashboardNavigation() {
 let ticket = location.hash.slice(1);
 history.replaceState(null, '', location.pathname);
 const $ = (id) => document.getElementById(id);
+const reviewKit = null;
 const el = (tag, text, cls) => { const node = document.createElement(tag); if (text !== undefined) node.textContent = String(text); if (cls) node.className = cls; return node; };
 let stopped = false, cursor = 0, timer, projectsTimer, eventCount = 0;
 const setConnection = (text, state) => { const node = $('connection'); node.textContent = text; node.dataset.state = state; };
@@ -661,6 +663,10 @@ async function action(payload, button, managerAction = false) {
       return false;
     }
     if (key && pendingStarts.get(key) === pending) clearPendingStart(key);
+    if (['review_comment_put','review_comment_delete','review_comment_send'].includes(payload.action)) {
+      reviewCommentsCache.delete(reviewCommentsCacheKey(boardViewState?.snapshot.tasks?.find(task => task.id === payload.task), captured));
+      if (taskDetailId === payload.task) void refreshReviewComments(taskDetailId);
+    }
     if (!managerMode || captured.generation === viewGeneration) notice(result.text || 'Action accepted.');
     if ((payload.action === 'sdlc_queue' || payload.action === 'sdlc_release') && (stopped || captured.generation !== viewGeneration || captured.projectId !== selectedProjectId || captured.instanceId !== selectedInstanceId)) return false;
     return (payload.action === 'sdlc_queue' || payload.action === 'sdlc_release') ? result.report : true;
@@ -695,7 +701,7 @@ const firstLoad = Object.fromEntries(['tasks', 'peers'].map((name) => [name, [..
 function resetView(id, instance) {
   saveDraft();
   selectedProjectId = id || ''; selectedInstanceId = instance || ''; snapshotValid = false; cursor = 0; eventCount = 0; viewGeneration++;
-  lastSnapshot = null;
+  lastSnapshot = null; reviewCommentsCache.clear();
   officePrev = null; officeDesks.clear(); officeCards.clear(); officeScene = null;
   $('office').replaceChildren(); $('office-section').hidden = true;
   closeTaskDetail(); renderNeedsAttention(null); applyDashboardView();
@@ -1102,6 +1108,7 @@ function keyedStart(name, enter = false) {
 }
 const BOARD_FOCUS_COLUMNS = ['backlog','todo','progress','review','done'];
 let columnFocus, taskDetailId = null;
+const reviewCommentsCache = new Map();
 let planningEdit = null, releaseEdit = null;
 function isClosedTaskState(state) { return state === 'approved' || state === 'cancelled'; }
 const loadedPlanningDates = new Map();
@@ -1281,6 +1288,57 @@ function deliverablesSection(task) {
   for (const file of d.files) list.append(el('li', (file.path || 'private file') + ' [' + file.format + (file.version ? ' ' + file.version : '') + '] ' + file.bytes + ' B, sha256 ' + file.sha256.slice(0, 12), 'meta'));
   section.append(list); return section;
 }
+function reviewCommentsSection(task) {
+  const expectedReview = boardContext(), section = el('div', undefined, 'detail-group review-comments'); section.setAttribute('role', 'region'); section.setAttribute('aria-label', 'Review comments'); section.append(el('h4', 'Review comments', 'detail-heading'));
+  const view = boardViewState?.snapshot.reviewComments, current = view?.task === task.id ? view : null;
+  const counts = current?.counts || task.reviewComments;
+  section.append(el('p', counts ? ['draft','sent','resolved','dismissed'].map(key => (counts[key] || 0) + ' ' + key).join(' / ') : 'No review comments.', 'meta'));
+  const writable = !!reviewKit && boardViewState?.snapshot.reviewWritable === true;
+  const refresh = el('button', 'Refresh review comments'); refresh.type = 'button'; refresh.onclick = () => void refreshReviewComments(task.id); section.append(refresh);
+  if (current?.unavailable) section.append(el('p', 'Review comments unavailable. Refresh to try again.', 'meta warn'));
+  if (writable) for (const pkg of current?.packages || []) if (pkg.delivery === 'unconfirmed') {
+    const retry = el('button', 'Retry saved package (' + pkg.count + ' comments)'); retry.type = 'button'; retry.dataset.mutation = 'project';
+    retry.onclick = () => sameBoardContext(expectedReview) && void action({action:'review_comment_send',task:task.id,packageId:pkg.id},retry);
+    section.append(retry);
+  }
+  for (const comment of current?.comments || []) {
+    const thread = comment.thread, id = thread?.id || comment.id, item = el('article', undefined, 'detail-group');
+    const placement = comment.placement?.status || 'unavailable', range = thread && (placement === 'anchored' || placement === 'moved') ? comment.placement?.range || thread.anchor.selectors.find(selector => selector.kind === 'lineRange') : undefined;
+    item.append(el('p', (thread ? thread.anchor.path + (range ? ':' + range.startLine + '-' + range.endLine : '') : 'Comment ' + id) + ' (' + placement + ') / ' + comment.lifecycle, 'meta'));
+    if (thread) item.append(el('p', thread.body), el('p', thread.author + ' / ' + thread.at, 'meta'));
+    if (writable) {
+      if (comment.lifecycle === 'draft' && thread) {
+        const edit = el('textarea'); edit.value = thread.body; edit.maxLength = 2048; edit.setAttribute('aria-label', 'Edit review comment ' + thread.id);
+        const save = el('button', 'Save draft'); save.type='button'; save.dataset.mutation='project';
+        save.onclick = () => sameBoardContext(expectedReview) && void action({action:'review_comment_put',task:task.id,id:thread.id,revision:comment.revision,commit:comment.commit,anchor:thread.anchor,body:edit.value},save);
+        item.append(edit,save);
+      }
+      if (comment.lifecycle !== 'dismissed') item.append(boardButton(comment.lifecycle === 'draft' ? 'Delete draft' : 'Dismiss', {action:'review_comment_delete',task:task.id,id,revision:comment.revision}));
+    }
+    section.append(item);
+  }
+  if (!writable) section.append(el('p', 'Read-only here. Open this task in a current acon console to comment and send.', 'meta'));
+  else {
+    if (counts?.draft) section.append(boardButton('Send draft comments', {action:'review_comment_send',task:task.id}));
+    const label = el('label', 'File to review'), path = el('input'); path.setAttribute('aria-label','Task file path to review'); path.placeholder = 'path/to/document.md'; label.append(path);
+    const mount = el('div'), open = el('button', 'Open review file'); open.type = 'button';
+    const expected = boardContext();
+    open.addEventListener('click', async () => {
+      if (!sameBoardContext(expected)) return;
+      open.disabled = true;
+      try {
+        const result = await reviewKit.snapshot({panel:'review_blob',projectId:selectedProjectId,instanceId:selectedInstanceId,task:task.id,path:path.value,side:'head'});
+        if (!sameBoardContext(expected) || taskDetailId !== task.id) return;
+        if (result.ok === false || !result.doc) throw new Error(result.error || 'Review material unavailable.');
+        mount.replaceChildren(reviewKit.render({doc:result.doc,threads:(current?.comments || []).filter(comment => comment.thread && comment.thread.anchor.path === result.doc.path && comment.thread.anchor.side !== 'base').map(comment => comment.thread),
+          onComment: ({anchor,body}) => sameBoardContext(expected) && action({action:'review_comment_put',task:task.id,commit:result.head,anchor,body})}));
+      } catch (error) { if (sameBoardContext(expected)) notice(error.message, true); }
+      finally { open.disabled = false; }
+    });
+    section.append(label,open,mount);
+  }
+  return section;
+}
 function taskDetail(task, card, stage, ids, overdue) {
   const row = el('article', undefined, 'task-detail'), head = el('div', undefined, 'row-head');
   row.setAttribute('aria-label', '#' + task.id + ' ' + task.title + ', ' + task.state.replaceAll('_', ' ') + ', owner ' + (task.owner || 'unassigned') + ', priority P' + card.priority);
@@ -1317,6 +1375,7 @@ function taskDetail(task, card, stage, ids, overdue) {
   if (links.children.length > 1) row.append(links);
   const code = codeGroupSection(task); if (code) row.append(code);
   const delivered = deliverablesSection(task); if (delivered) row.append(delivered);
+  row.append(reviewCommentsSection(task));
   const controls = el('div', undefined, 'actions');
   if (card.pull && boardViewState?.snapshot.boardCapabilities?.backlog===true) controls.append(boardButton('Pull into To Do', {action:'backlog_pull',id:task.id}));
   if (card.pull && boardViewState?.snapshot.planningCapabilities?.wipPull===true) controls.append(boardButton('Pull within WIP', {action:'planner_pull',id:task.id,revision:task.planningRevision ?? 0,reason:'person requested a WIP-constrained pull'}));
@@ -1368,7 +1427,7 @@ function setColumnFocus(column) {
   if (boardViewState) renderBoard(boardViewState.snapshot, boardViewState.peers, boardViewState.ids);
 }
 function closeTaskDetail() {
-  taskDetailId = null; const dialog = $('task-detail-dialog'); if (dialog.open) dialog.close();
+  taskDetailId = null; reviewCommentsCache.clear(); const dialog = $('task-detail-dialog'); if (dialog.open) dialog.close();
   $('task-detail-content').replaceChildren(); signatures.delete('task-detail-content');
 }
 function refreshTaskDetail() {
@@ -1379,13 +1438,29 @@ function refreshTaskDetail() {
   const ids = boardViewState.ids.filter(id => ['idle','busy'].includes(boardViewState.peers[id]?.state) && boardViewState.peers[id]?.attached !== false && boardViewState.peers[id]?.rostered !== false);
   const overdue = task.due != null && task.due < Date.now() && !isClosedTaskState(task.state);
   $('task-detail-title').textContent = 'Task #' + task.id;
-  update('task-detail-content', [task, card, stage, ids, overdue, boardContext()], target => target.append(taskDetail(task, card, stage, ids, overdue)));
+  update('task-detail-content', [task, card, stage, ids, overdue, boardContext(), snapshot.reviewComments, snapshot.reviewWritable], target => target.append(taskDetail(task, card, stage, ids, overdue)));
 }
 function openTaskDetail(id) {
   if (stopped || !Number.isSafeInteger(id) || !snapshotValid || !boardViewState?.cards.has(id)) return;
-  switchView('board'); taskDetailId = id; refreshTaskDetail();
+  if (taskDetailId !== id) reviewCommentsCache.clear();
+  switchView('board'); taskDetailId = id; refreshTaskDetail(); void refreshReviewComments(id);
   const dialog = $('task-detail-dialog'); if (taskDetailId !== null && !dialog.open) dialog.showModal();
 }
+function reviewCommentsCacheKey(task, ctx = context()) {
+  return JSON.stringify([ctx.projectId,ctx.instanceId,ctx.generation,task?.id ?? null,task?.reviewStateKey ?? null]);
+}
+async function refreshReviewComments(id) {
+  if (stopped || taskDetailId !== id || !snapshotValid) return;
+  const captured = context(), task = lastSnapshot?.tasks?.find(row => row.id === id), cacheKey = reviewCommentsCacheKey(task, captured), input = {after:cursor, view:'board', reviewTask:id, reviewRefresh:true};
+  if (managerMode) { input.projectId = captured.projectId; input.instanceId = captured.instanceId; }
+  try {
+    const result = await post('/snapshot', input);
+    if (taskDetailId !== id || captured.generation !== viewGeneration || (managerMode && (result.projectId !== captured.projectId || result.instanceId !== captured.instanceId))
+      || reviewCommentsCacheKey(lastSnapshot?.tasks?.find(row => row.id === id), captured) !== cacheKey) return;
+    reviewCommentsCache.set(cacheKey, result.reviewComments || {task:id, unavailable:true});
+    if (lastSnapshot) { lastSnapshot = {...lastSnapshot, reviewComments:reviewCommentsCache.get(cacheKey)}; render(lastSnapshot); }
+  } catch (error) { if (taskDetailId === id) notice('Review comments unavailable: ' + error.message, true); }
+}
 function renderBoard(snapshot, peers, ids) {
   if (columnFocus === undefined) {
     columnFocus = dashboardCookie.get('agent-hub-column-focus') || null;
@@ -1855,8 +1930,9 @@ function render(snapshot) {
     }
   });
   renderBench(snapshot.bench);
+  renderResults(snapshot.results);
   renderWorktrees(snapshot.worktrees);
-  renderMemory(snapshot.memory);
+  renderMemory(snapshot.memory, snapshot.memorySync);
   renderSettings(snapshot.settings, snapshot.roster);
   renderUsage(snapshot.usage, snapshot.tasks, snapshot.budget);
   renderSchedules(snapshot.schedules);
@@ -1888,6 +1964,9 @@ async function poll() {
     const input = {after:cursor, memory:memoryInput(), view:currentView}; if (managerMode) { input.projectId = captured.projectId; input.instanceId = captured.instanceId; }
     const result = await post('/snapshot', input);
     if (!managerMode || (result.projectId === captured.projectId && result.instanceId === captured.instanceId && captured.generation === viewGeneration)) {
+      const detailTask = taskDetailId === null ? undefined : result.tasks?.find(task => task.id === taskDetailId), detailKey = reviewCommentsCacheKey(detailTask, captured);
+      if (taskDetailId !== null && reviewCommentsCache.has(detailKey)) result.reviewComments = reviewCommentsCache.get(detailKey);
+      else if (taskDetailId !== null) reviewCommentsCache.clear();
       snapshotValid = true; lastSnapshot = result; lastSnapshotAt = Date.now(); render(result); setConnection('Live / updated ' + new Date().toLocaleTimeString(), 'live'); setDisconnected(false);
     }
   }
@@ -2371,6 +2450,35 @@ let streamFilter = '';
 function applyStreamFilter(node) { node.hidden = streamFilter !== '' && node.dataset.kind !== streamFilter; }
 function refreshStreamEmpty() { const has = $('stream').querySelector('.event:not([hidden])') !== null, any = $('stream').querySelector('.event') !== null; $('stream-empty').hidden = has || !any; }
 // #251: benchmark runs on this machine and arm comparisons per suite. Every bar carries its number as text.
+/* #1054 T6: unread results, the runs a person started that settled and have not been seen. The snapshot only READS them: building this list never marks one read (a poll is not a person
+   looking). A receipt is a person's click: Mark read (one), Mark all read, or Mark last unread again (relights the result read last; it lives here and in `ahub results --unread-last`, never in
+   the acon inbox, because a read item leaves the inbox). The title is `<peer>: <outcome word>` and the detail is what the hub built at display (a stub when private, nothing when the request is no
+   longer held); text is set with textContent only. The acon seeing rule (focus, visibility, a second in view) is the shell's and is not here: this panel's marks are explicit clicks. */
+function renderResults(results) {
+  const unread = results && Array.isArray(results.unread) ? results.unread : [];
+  const more = results && Number.isSafeInteger(results.moreUnread) ? results.moreUnread : 0;
+  $('results-count').textContent = results ? unread.length + more + ' unread' : '';
+  update('results', results === undefined ? null : results, (target) => {
+    if (results === undefined) return empty(target, 'Results are shown to the person on a current snapshot.');
+    const tools = el('div', undefined, 'row-head');
+    if (unread.length) tools.append(button('Mark all read', {action: 'results_read_all'}));
+    if (results.canUnread) tools.append(button('Mark last unread again', {action: 'results_unread_last'}));
+    if (!unread.length) target.append(el('p', 'Nothing unread.', 'meta'));
+    for (const item of unread) {
+      const block = el('div', undefined, 'row'), head = el('div', undefined, 'row-head');
+      head.append(el('span', String(item.title), 'label'));
+      head.append(badge(String(item.outcome), item.outcome === 'done' ? 'ok' : item.outcome === 'failed' ? 'err' : 'warn'));
+      const stamp = el('span'); if (item.settledAt) { stamp.dataset.ts = String(item.settledAt); stamp.title = time(item.settledAt); stamp.textContent = 'settled ' + rel(item.settledAt); } else stamp.textContent = ''; head.append(stamp);
+      if (Number.isFinite(item.ms)) head.append(el('span', Math.round(item.ms / 1000) + 's', 'meta'));
+      head.append(button('Mark read', {action: 'result_seen', id: String(item.id)}));
+      block.append(head);
+      if (item.detail && (item.detail.kind === 'head' || item.detail.kind === 'stub') && typeof item.detail.text === 'string') block.append(el('p', item.detail.text, 'meta'));
+      target.append(block);
+    }
+    if (more > 0) target.append(el('p', more + ' older unread; run ahub results --unread to list them all.', 'meta'));
+    target.append(tools);
+  });
+}
 /* #1057: the worktree shelf. A panel refresh reads nothing from GitHub: the rows come from the hub's cached facts, and only the explicit 'Refresh PR states' button asks it to read PR states. Removal is never a button: the panel shows the command to run in a terminal. */
 function renderWorktrees(shelf) {
   const live = shelf && Array.isArray(shelf.live) ? shelf.live : [], settled = shelf && Array.isArray(shelf.settled) ? shelf.settled : [];
@@ -2552,7 +2660,30 @@ function layout(graph) {
   return pos;
 }
 function selectMemoryNode(node) { memoryQuery.node = memoryQuery.node === node ? '' : node; rerenderMemory(); }
-function renderMemory(memory) {
+function memorySyncLine(sync) {
+  if (!sync || typeof sync.state !== 'string') return 'Machine sync: unknown';
+  const hasTimestamp = sync.at !== undefined, validTimestamp = Number.isSafeInteger(sync.at) && Math.abs(sync.at) <= 8640000000000000;
+  const stamp = hasTimestamp ? ' / last ' + (validTimestamp ? time(sync.at) : 'unknown') : '';
+  if (sync.state === 'not-configured' || sync.state === 'stopped') {
+    const next = sync.state === 'stopped' ? 'retry after hub restart' : 'configure a private sync remote';
+    return 'Machine sync: ' + sync.state + stamp + ' / next: ' + next;
+  }
+  if (sync.state === 'ok' && Number.isSafeInteger(sync.withheldCount) && sync.withheldCount >= 0 && Number.isSafeInteger(sync.exportedCount) && sync.exportedCount >= 0)
+    return 'Machine sync: ok' + stamp + ' / ' + sync.withheldCount + ' row' + (sync.withheldCount === 1 ? '' : 's') + ' withheld locally / ' + sync.exportedCount + ' exported';
+  if (sync.state !== 'failed') return 'Machine sync: ' + (['disabled','unavailable','notrun','ok','unknown'].includes(sync.state) ? sync.state : 'unknown') + stamp;
+  const causes = ['declined','remote','binding','stopped','transport','unknown'];
+  const cause = causes.includes(sync.cause) ? sync.cause : 'unknown';
+  if (cause === 'declined' && sync.placementActive === false) {
+    const declined = Number.isSafeInteger(sync.declinedCount) && sync.declinedCount >= 0 ? String(sync.declinedCount) : 'unknown';
+    return 'machine sync blocked: ' + declined + ' declined rows; per-row placement is not active on this store (agent-mem has no activation command yet, agent-mem#281). Inspect with `ahub memory declined`.';
+  }
+  const count = Number.isSafeInteger(sync.declinedCount) && sync.declinedCount >= 0 ? ' / ' + sync.declinedCount + ' declined' : '';
+  const ids = cause === 'declined' && sync.declinedIdsKnown === false ? ' / declined ID set unknown' : '';
+  const next = cause === 'declined' ? 'ahub memory declined' : cause === 'remote' ? 'configure a private sync remote' : cause === 'binding' ? 'ahub memory profile-check' : cause === 'stopped' ? 'retry after hub restart' : 'run ahub memory sync as a person';
+  return 'Machine sync: failed (' + cause + count + ')' + stamp + ids + ' / next: ' + next;
+}
+function renderMemory(memory, sync) {
+  $('memory-sync-status').textContent = memorySyncLine(sync);
   memoryCodeToggle();
   const tiers = $('memory-tiers');
   if (!tiers.children.length) for (const [tier, label] of [['short', 'Short-term'], ['long', 'Long-term'], ['goals', 'Long-term tasks']]) {

package/src/ui/needs.ts

@@ -1,4 +1,4 @@
-export type NeedKind = "approval" | "default" | "storage" | "recovery" | "delivery" | "review" | "message" | "budget" | "offline" | "stall" | "offer";
+export type NeedKind = "approval" | "default" | "storage" | "recovery" | "delivery" | "review" | "message" | "budget" | "offline" | "stall" | "offer" | "question" | "result";
 export interface NeedItem { kind: NeedKind; level: "act" | "watch"; peer?: string; id?: string | number; until?: number; since?: number; }
 export interface NeedsInput {
   approvals?: readonly { id: string; peer?: string; expiresAt: number; since?: number }[];
@@ -10,6 +10,10 @@ export interface NeedsInput {
   facts?: readonly { kind: "review" | "offline" | "stall" | "offer"; id: number; peer?: string }[];
   messages?: readonly { id?: string; peer?: string; important: boolean; since?: number }[];
   budget?: Readonly<Record<string, { paused?: { since?: number; resetsAt?: number } }>>;
+  /** #1053: the open questions a peer asked the person: the set id, the asking peer and when it was asked, never a prompt or an option. */
+  questions?: readonly { set: string; peer?: string; since?: number }[];
+  /** #1054: unread results, a run a person started that settled and has not been seen: the completion id, the peer and when it settled, never a prompt or a reply. */
+  results?: readonly { id: string; peer?: string; since?: number }[];
 }
 export interface Needs { items: NeedItem[]; act: number; watch: number; state: "waiting" | "blocked" | "review" | "working" | "idle" | "sleeping"; }
 export interface NeedsSummary { act: number; watch: number; state: Needs["state"]; first?: NeedItem }
@@ -22,6 +26,7 @@ export function needs(input: NeedsInput, now: number): Needs {
   const add = (kind: NeedKind, level: "act" | "watch", peer?: unknown, identifier?: unknown, until?: unknown, since?: unknown) => items.push({ kind, level, ...(id(peer) ? { peer } : {}), ...(id(identifier) || typeof identifier === "number" && Number.isSafeInteger(identifier) && identifier > 0 ? { id: identifier } : {}), ...(time(until) ? { until } : {}), ...(time(since) ? { since } : {}) });
   for (const request of input.approvals ?? []) if (id(request.id) && time(request.expiresAt) && request.expiresAt > now) add("approval", "act", request.peer, request.id, request.expiresAt, request.since);
   for (const pending of input.defaults ?? []) if (id(pending.peer)) add("default", "act", pending.peer);
+  for (const question of input.questions ?? []) if (id(question.set)) add("question", "act", question.peer, question.set, undefined, question.since);
   if (input.storageBlocked === true) add("storage", "act");
   if (input.recovery) add("recovery", input.recovery.running === false ? "act" : "watch", undefined, input.recovery.id, undefined, input.recovery.since);
   for (const [peer, status] of Object.entries(input.peers ?? {})) {
@@ -44,17 +49,18 @@ export function needs(input: NeedsInput, now: number): Needs {
     else if (fact.kind === "offline" && agent(fact.peer) && !offline.has(fact.peer)) { offline.add(fact.peer); add("offline", "watch", fact.peer, fact.id); }
   }
   for (const [peer, budget] of Object.entries(input.budget ?? {})) if (budget.paused) add("budget", "watch", peer, undefined, budget.paused.resetsAt, budget.paused.since);
-  const order: Record<NeedKind, number> = { approval: 0, default: 1, storage: 2, recovery: 3, delivery: 4, review: 5, stall: 6, offer: 7, message: 8, budget: 9, offline: 10 };
+  for (const result of input.results ?? []) if (id(result.id)) add("result", "watch", result.peer, result.id, undefined, result.since);
+  const order: Record<NeedKind, number> = { approval: 0, default: 1, question: 2, storage: 3, recovery: 4, delivery: 5, review: 6, stall: 7, offer: 8, message: 9, result: 10, budget: 11, offline: 12 };
   items.sort((a,b) => (a.level === "act" ? 0 : 1) - (b.level === "act" ? 0 : 1) || order[a.kind] - order[b.kind] || (a.kind === "approval" ? (a.until ?? Infinity) - (b.until ?? Infinity) : 0) || (a.since ?? 0) - (b.since ?? 0));
   const act = items.filter(item => item.level === "act").length, watch = items.length - act;
   const peers = Object.values(input.peers ?? {}), attached = peers.some(peer => peer.attached !== false && ["idle", "busy", "paused"].includes(peer.state ?? ""));
-  const state: Needs["state"] = items.some(item => item.kind === "approval" || item.kind === "default") ? "waiting" : items.some(item => item.level === "act" && ["storage", "delivery", "recovery", "stall"].includes(item.kind)) ? "blocked" : act ? "review" : peers.some(peer => peer.attached !== false && peer.state === "busy") ? "working" : attached ? "idle" : "sleeping";
+  const state: Needs["state"] = items.some(item => item.kind === "approval" || item.kind === "default" || item.kind === "question") ? "waiting" : items.some(item => item.level === "act" && ["storage", "delivery", "recovery", "stall"].includes(item.kind)) ? "blocked" : act ? "review" : peers.some(peer => peer.attached !== false && peer.state === "busy") ? "working" : attached ? "idle" : "sleeping";
   return { items, act, watch, state };
 }
 
 /** Global status never reads console-local unread messages or source text. */
 export function summarizeNeeds(input: Omit<NeedsInput, "messages">, now: number): NeedsSummary {
   const value = needs({ approvals: input.approvals, defaults: input.defaults, peers: input.peers,
-    storageBlocked: input.storageBlocked, recovery: input.recovery, tasks: input.tasks, facts: input.facts, budget: input.budget }, now);
+    storageBlocked: input.storageBlocked, recovery: input.recovery, tasks: input.tasks, facts: input.facts, budget: input.budget, questions: input.questions, results: input.results }, now);
   return { act: value.act, watch: value.watch, state: value.state, ...(value.items[0] ? { first: value.items[0] } : {}) };
 }

package/src/ui/plugin-questions.ts

@@ -0,0 +1,56 @@
+/**
+ * #1053 T5: the acon inbox side of a question a peer asked with hub_ask. Pure: it builds the inbox item from the stored row the hub reports and checks the
+ * person evidence an answer needs; `plugin.ts` owns the transport. No text here is logged.
+ *
+ * Authority: an answer is accepted only when the console advertises `action.meta` and `action()` received the console's own `meta` (`via: "console"`, a verified
+ * `identity`), which the page cannot set (agent-console `action(input, meta?)`). An answer without it is refused before any request reaches the hub.
+ */
+
+import type { ActionMeta, InboxAnswers, InboxVerb, VerbForm } from "@staix/agent-console/contract";
+
+// The acon types come only through the generated bridge (`scripts/acon-review-types.ts`, regenerated and compared by its check), so a drift of the form or of the answer it
+// submits fails there and not at a user's console. Type-only: agent-hub keeps zero runtime dependencies.
+export type { ActionMeta, InboxAnswers };
+export interface QuestionRowView {
+  set: string; peer: string; created: number; private?: boolean;
+  questions: { id: string; prompt: string; options: { id: string; label: string; description?: string }[]; multi?: boolean; allowOther?: boolean }[];
+}
+type FormQuestion = VerbForm["questions"][number];
+export interface QuestionItem {
+  id: string; group: "decision"; kind: string; title: string; actor: string; project: string; at: string; chip: { text: string; tone: "warn" };
+  verbs: InboxVerb[];
+  link: { panel: string; params: Record<string, string> };
+}
+
+/** Both features are needed: `inbox.form` renders the form, `action.meta` gives the answer its person evidence. One alone is the plain item. */
+export const canAnswerInInbox = (features: readonly string[] | undefined): boolean => !!features?.includes("inbox.form") && features.includes("action.meta");
+
+const flat = (text: string, max: number) => Array.from(text.replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029\s]+/g, " ").trim()).slice(0, max).join("");
+export const questionItemId = (project: string, set: string) => `question:${project}:${set}`;
+export const QUESTION_ITEM = /^question:([^:]+):(qs-[a-f0-9]{12})$/;
+
+/**
+ * The inbox item. A private question (asked in a PII turn or about a PII task) gets a stub title and no detail: its text is in the form only, which is the person's
+ * own answer surface. Without the two features the item is a plain decision with an `open` verb that links to the agents panel.
+ */
+export function questionItem(row: QuestionRowView, project: { id: string; name: string }, features: readonly string[] | undefined): QuestionItem {
+  const head = row.private ? "a question" : `: ${flat(row.questions[0]?.prompt ?? "", 80)}`;
+  const title = (row.private ? `${row.peer} asks ${head}` : `${row.peer} asks${head}`).slice(0, 200);
+  const link = { panel: "agents", params: { project: project.id } };
+  const base = { id: questionItemId(project.id, row.set), group: "decision" as const, title, actor: row.peer, project: project.name, at: new Date(row.created).toISOString(), chip: { text: "question", tone: "warn" as const }, link };
+  if (!canAnswerInInbox(features)) return { ...base, kind: "decision", verbs: [{ id: "open", label: "Open Agents", primary: true }] };
+  const form = { questions: row.questions.map<FormQuestion>(question => ({ id: question.id, prompt: question.prompt, options: question.options.map(option => ({ id: option.id, label: option.label, ...(option.description ? { description: option.description } : {}) })),
+    ...(question.multi === true ? { multiple: true } : {}), ...(question.allowOther === true ? { other: { maxLength: 500 } } : {}) })) };
+  return { ...base, kind: "question", verbs: [{ id: "answer", label: "Answer", primary: true, form }, { id: "open", label: "Open Agents" }] };
+}
+
+/** The console's evidence, or the refusal that tells the person how to get it. Page-supplied fields that would stand in for it are refused too. */
+export function personEvidence(features: readonly string[] | undefined, meta: ActionMeta | undefined, input: Record<string, unknown>): { ok: true; identity: string } | { ok: false; error: string } {
+  if (!features?.includes("action.meta") || !meta || typeof meta !== "object") return { ok: false, error: "Answering needs a console with verified person identity; update acon and reopen this panel, or answer with ahub answer." };
+  const value = meta as unknown as Record<string, unknown>;
+  if (value.via !== "console" || typeof value.identity !== "string" || !value.identity.trim() || typeof value.node !== "string" || !value.node.trim())
+    return { ok: false, error: "Answering needs a console with verified person identity; update acon and reopen this panel, or answer with ahub answer." };
+  if (["author", "meta", "personMeta", "person", "identity", "surface", "questionSet", "projectId", "instanceId"].some(key => Object.hasOwn(input, key)))
+    return { ok: false, error: "The person's identity and the target come from the console; remove those fields and retry." };
+  return { ok: true, identity: value.identity.trim().slice(0, 200) };
+}

package/src/ui/plugin-results.ts

@@ -0,0 +1,81 @@
+/**
+ * #1054 T6: the acon inbox side of a result: a run a person started that settled and has not been seen. Pure: it builds the inbox item from the row the hub reports and checks the
+ * person evidence a receipt needs; `plugin.ts` owns the transport. No text here is logged.
+ *
+ * Publication: an item is published only to a console that advertises BOTH `inbox.result` (it renders the group) and `action.meta` (a receipt then has person evidence). One alone,
+ * or neither, and results stay in the ahub panel, `ahub console`, `ahub status` and `ahub results`: nothing is published that the console could not render or that the person
+ * could not mark read with evidence.
+ *
+ * Authority: `result_seen`, `results_read_all` and `results_unread_last` are accepted only when the console advertises `action.meta` and `action()` received the console's own
+ * `meta` (`via: "console"`, a verified `identity`), which the page cannot set (agent-console `action(input, meta?)`). They never go through the dashboard's forwarding list. The
+ * acon "seeing" rule (a focused, visible window, the result's end in view for a second, the latest edge) is agent-console#27 and is not decided here: this only accepts the receipt.
+ * Mark unread is NOT an inbox verb: a read item leaves the inbox, so mark-unread lives in the ahub panel (this plugin's dashboard) and in `ahub results --unread-last`.
+ */
+
+import type { ActionMeta } from "@staix/agent-console/contract";
+
+export type { ActionMeta };
+export type ResultOutcome = "done" | "failed" | "limit" | "interrupted";
+/** The detail the hub built at display (`completion-detail.ts`): a head of the request, a stub, or nothing. */
+export type ResultDetailView = { kind: "head" | "stub"; text: string } | { kind: "none" };
+/** One row of the hub's `results` snapshot field. */
+export interface ResultRowView {
+  id: string; peer: string; outcome: ResultOutcome; settledAt: number; ms?: number; private?: boolean; title?: string; detail?: ResultDetailView;
+}
+export interface ResultItem {
+  id: string; group: "result"; kind: "result"; title: string; detail?: string; actor: string; project: string; at: string; chip: { text: string; tone: "ok" | "warn" | "err" | "neutral" };
+  verbs: { id: string; label: string; primary?: boolean }[];
+  link: { panel: string; params: Record<string, string> };
+  seen: { action: "result_seen" };
+}
+
+/**
+ * The receipt actions this plugin advertises (so acon lets the page and the inbox send them), and answers itself with the console's person meta: never in the dashboard's forwarding
+ * list. `result_seen` and `results_read_all` come from the inbox (acon's seeing rule and its "Mark all read") and from the panel; `results_unread_last` only from the panel, because a
+ * read item has left the inbox: there is no inbox verb for it. All three are the person's writes, so all three need the same evidence.
+ */
+export const RESULT_ACTIONS = ["result_seen", "results_read_all", "results_unread_last"] as const;
+export type ResultAction = (typeof RESULT_ACTIONS)[number];
+
+/** Both features are needed. One alone is not enough: no group to render, or no person evidence for the receipt. */
+export const canPublishResults = (features: readonly string[] | undefined): boolean => !!features?.includes("inbox.result") && features.includes("action.meta");
+
+export const resultItemId = (project: string, id: string) => `result:${project}:${id}`;
+export const RESULT_ITEM = /^result:([^:]+):(cmp-[a-f0-9]{12})$/;
+const OUTCOME_WORD: Record<ResultOutcome, string> = { done: "finished", failed: "failed", limit: "stopped at a limit", interrupted: "interrupted" };
+const CHIP: Record<ResultOutcome, { text: string; tone: "ok" | "warn" | "err" | "neutral" }> = {
+  done: { text: "done", tone: "ok" }, failed: { text: "failed", tone: "err" }, limit: { text: "limit", tone: "warn" }, interrupted: { text: "interrupted", tone: "warn" },
+};
+const flat = (text: string, max: number) => Array.from(text.replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029\s]+/g, " ").trim()).slice(0, max).join("");
+
+/**
+ * The inbox item. The title is `<peer>: <outcome word>`, computed here from the row's peer and outcome and never taken from the row's own title text; a private result is a stub
+ * (`<peer>: a private result`) with no detail. The detail is whatever the hub built at display, or none: this never reads a prompt itself. `at` is the settle time, stable
+ * across snapshots, which is what acon's snooze and oldest-first order key on.
+ */
+export function resultItem(row: ResultRowView, project: { id: string; name: string }): ResultItem {
+  const outcome: ResultOutcome = row.outcome in OUTCOME_WORD ? row.outcome : "interrupted";
+  const title = (row.private ? `${row.peer}: a private result` : `${row.peer}: ${OUTCOME_WORD[outcome]}`).slice(0, 200);
+  const detail = !row.private && row.detail && row.detail.kind !== "none" && typeof row.detail.text === "string" ? flat(row.detail.text, 200) : row.private ? "a private request" : "";
+  return {
+    id: resultItemId(project.id, row.id), group: "result", kind: "result", title, ...(detail ? { detail } : {}), actor: row.peer, project: project.name,
+    at: new Date(row.settledAt).toISOString(), chip: CHIP[outcome], verbs: [{ id: "open", label: "Open Agents", primary: true }],
+    link: { panel: "agents", params: { project: project.id } }, seen: { action: "result_seen" },
+  };
+}
+
+const REFUSAL = "Marking a result read needs a console with verified person identity; update acon and reopen this panel, or use ahub results.";
+/**
+ * The console's evidence, or the refusal that tells the person how to get it. Page-supplied fields that would stand in for the person (`author`, `meta`, `identity`, `surface`) or
+ * name a completion by another key are refused too. `projectId` is allowed: the panel names the project it is showing, as every dashboard action does, and it only picks WHICH running
+ * project's receipt this is; the daemon instance is never taken from the page (`receiptVerb` resolves it from the running listing), and the person evidence is the console's alone.
+ */
+export function receiptEvidence(features: readonly string[] | undefined, meta: ActionMeta | undefined, input: Record<string, unknown>): { ok: true } | { ok: false; error: string } {
+  if (!features?.includes("action.meta") || !meta || typeof meta !== "object") return { ok: false, error: REFUSAL };
+  const value = meta as unknown as Record<string, unknown>;
+  if (value.via !== "console" || typeof value.identity !== "string" || !value.identity.trim() || typeof value.node !== "string" || !value.node.trim()) return { ok: false, error: REFUSAL };
+  // `seenAt` and `explicit` are acon's own (the shell sends them with the seeing rule): the hub stamps its own time, so they are accepted and ignored, never trusted.
+  if (["author", "meta", "personMeta", "person", "identity", "surface", "completion", "completionId", "seen"].some(key => Object.hasOwn(input, key)))
+    return { ok: false, error: "The person's identity and the target come from the console; remove those fields and retry." };
+  return { ok: true };
+}