create-agdf 0.30.0 → 0.32.0

package/generated/plugins/agdf/companion/register.mjs

@@ -1,13 +1,18 @@
-// AGDF Companion host adapter (SDD-07 to SDD-10; follow-up SDD-05 to SDD-12): the `/agdf-companion`
-// command, the persisted choices, main-loop turn observation, the refresh cadence, the own pane, the
-// status line and toasts. Observation only: no gating hook, every hook passes its event on through a
-// catch path, and nothing is written under .agdf/control. Session state lives in this module and is
+// AGDF Companion host adapter (SDD-07 to SDD-10; follow-up SDD-05 to SDD-12; companion core SDD-007, SDD-010):
+// the `/agdf-companion` command, the persisted choices, main-loop turn observation, the refresh cadence,
+// the own pane, the status line and toasts. Run state comes only from the plugin runtime's read-only
+// `run-view` command through `$.process`, called on a changed run-file fingerprint, a new journal event
+// of this root or a changed language; the companion imports no Core module. Observation only: no
+// gating hook, every hook passes its event on through a catch path, and nothing is written under
+// .agdf/control. Session state lives in this module and is
 // redrawn through `$.ui.invalidate`. Elements come from the surface table and are built with the
 // host's global `h`.
 
 import { assignRun, namedRun, openRuns, stepSelection } from './assignment.mjs';
-import { figureSvg } from './figure.mjs';
-import { chatLocale, label } from './localization.mjs';
+import { EVENT_POLL_MS, JOURNAL_FILE, JOURNAL_READ_LIMIT, JOURNAL_ROTATED_FILE, PANE_EVENTS, STICKY_KINDS, TOAST_KINDS, eventText,
+  isConfirmed, isStillUncertain, journalDirectory, namedEventText, parseJournal, unseenEvents } from './events.mjs';
+import { figureSvg, observeFigure } from './figure.mjs';
+import { chatLocale, companionLabels, gateTitle, label } from './localization.mjs';
 import { CHIME, chimeClip, noticeText, observeNotice, observedRun, statusText } from './notice.mjs';
 import { STATE_FILE, defaultCompanionState, parseCompanionState, pluginDataDir, serializeCompanionState } from './persistence.mjs';
 import { readSnapshot, settleSnapshot } from './run-state.mjs';
@@ -34,12 +39,21 @@ const BODY_RESERVE = 0;
 // stay beside the widest bar (owner request of 2026-10-28); a narrower pane lists the ids alone.
 const ID_ROOM = 18;
 const COLOR = Object.freeze({ laeuft: 'suggestion', baut: 'suggestion', wartet: 'warning', blockiert: 'error', fertig: 'success' });
+// The colour of the "whose move" line: yours, the agent's, or a block.
+const TURN_COLOR = Object.freeze({ you: 'warning', claude: 'suggestion', halt: 'error', next: undefined });
 
 function createSession() {
-  return { startedAt: 0, root: '', registry: null, labels: null, locale: 'en', statePath: null, version: null, icon: null,
-    choices: defaultCompanionState(), isHidden: false, snapshot: null, isTurnActive: false, isObjectiveExpanded: false,
-    isAboutShown: false, isMenuOpen: false, timer: null, reads: 0, appliedRead: 0, observation: null,
-    chatMention: null, isBrowsing: false, conversation: null };
+  return { startedAt: 0, root: '', registry: null, labels: null, locale: 'en', statePath: null, dataDir: null, version: null, icon: null,
+    choices: defaultCompanionState(), isHidden: false, snapshot: null, isTurnActive: false, isInfoExpanded: false,
+    isPreviewExpanded: false, isAboutShown: false, isMenuOpen: false, timer: null, eventTimer: null, reads: 0, appliedRead: 0,
+    observation: null, figureObservation: null, chatMention: null, isBrowsing: false, conversation: null,
+    // Companion core SDD-007: the run-file fingerprint of the last run-view call, the journal cursor and
+    // stamp, this root's events since the last main-loop turn and the drift warnings already announced.
+    fingerprint: null, journalCursor: null, journalStamp: null, eventsAvailable: null, events: [], driftSeen: null,
+    // Durable events of this root waiting for a fresh run view to confirm them (CR delta review RV-1).
+    unconfirmed: [],
+    // The start's first read, running beside the host (CR finding B5).
+    background: null };
 }
 
 // One companion per session: the module is loaded once per session.
@@ -47,8 +61,15 @@ const session = createSession();
 const t = (path, params) => label(session.labels, session.locale, path, params);
 const selection = () => session.choices.selections[session.root] ?? null;
 const redraw = $ => $.ui.invalidate('ui.render');
-// File access for the host-independent reader, each call spelled on `$` (read-only).
-const files = $ => ({ exists: path => $.fs.exists(path), list: path => $.fs.list(path), read: path => $.fs.read(path) });
+// Event toasts name a run only when it is not the run the status line and toasts follow; another run
+// is named by its objective (owner request of 2026-11-06, T-013).
+const eventNaming = () => ({
+  shownRunId: observedRun({ snapshot: session.snapshot, sessionStartedAt: session.startedAt, selection: selection(), mention: session.chatMention }).runId ?? null,
+  runs: session.snapshot?.status === 'ok' ? session.snapshot.runs : [] });
+// The host loads a hooks module only when every use of `$` is spelled `$.noun.member(...)` at the call
+// site; passing `$.process` itself refuses the whole module (T-013 native check). The run-view reader
+// receives this call-site wrapper instead.
+const processes = $ => ({ run: (argv, init) => $.process.run(argv, init) });
 
 // Applies one change to this session's choices and, where the AGDF plugin data directory already
 // exists, to the freshly read state file, so choices another session stored meanwhile survive.
@@ -67,7 +88,7 @@ async function persist($, change) {
 // The status line and toasts follow the run-derived state of the run the panel shows without browsing,
 // so browsing never changes them (follow-up SDD-05 to SDD-07; chat-run navigation SDD-06). A stale snapshot keeps the last observation, so a failed read never
 // announces anything. Each host call has its own catch path: a missing channel stays silent (SDD-12).
-function announce($) {
+function announce($, { quiet = new Set() } = {}) {
   const observed = observedRun({ snapshot: session.snapshot, sessionStartedAt: session.startedAt, selection: selection(),
     mention: session.chatMention });
   // Every applied read sets the line again, unchanged text included: the desktop dropped the one set
@@ -76,16 +97,33 @@ function announce($) {
   if (session.snapshot?.stale) return;
   const { observation, notice } = observeNotice(session.observation, observed);
   session.observation = observation;
-  if (!notice || !session.choices.notice) return;
-  try {
-    $.ui.toast(noticeText(observed.runId, notice, { registry: session.registry, labels: session.labels, locale: session.locale }));
-  } catch {
-    return; // no toast on this host, and so no chime either (CR-F01)
-  }
+  // A run whose own event raises a toast in the same read gets no second state toast (decision P1).
+  if (notice && !quiet.has(observed.runId)) toast($, noticeText(notice, { registry: session.registry, labels: session.labels, locale: session.locale }));
+  announceDrift($);
+}
+
+// One toast, with the chime only when it was shown; a missing channel stays silent (SDD-12, CR-F01).
+function toast($, text) {
+  if (!session.choices.notice) return false;
+  try { $.ui.toast(text); } catch { return false; }
   // The chime plays only with a shown toast; a host without a player skips it, a failure stays silent.
   if (session.choices.sound) {
     try { $.audio.play(chimeClip(), { gain: CHIME.gain }).catch(() => {}); } catch { /* no audio on this host */ }
   }
+  return true;
+}
+
+// A bound document changed after recording raises one toast per change (decision P1, PRD AC-008); the
+// pane keeps the warning while the run view reports it. The first read is a baseline.
+function announceDrift($) {
+  if (session.snapshot?.status !== 'ok') return;
+  const warnings = session.snapshot.runs.flatMap(run => (run.drift ?? []).map(item => ({ run: run.id, document: item.document,
+    key: `${run.id}|${item.path}|${item.current_digest}` })));
+  const seen = session.driftSeen;
+  session.driftSeen = new Set(warnings.map(item => item.key));
+  if (!seen) return;
+  const naming = eventNaming();
+  for (const item of warnings.filter(warning => !seen.has(warning.key))) toast($, namedEventText(t('events.drift', { document: item.document }), item.run, t, naming));
 }
 
 // Switching off clears the status line, forgets the observation and discards reads still running, so
@@ -96,19 +134,46 @@ function silence($) {
   try { $.ui.status(undefined); } catch { /* no status line on this host */ }
 }
 
-// Reads the run states of the current project root, which `/cd` or a worktree move can change.
+// Reads the run view of the current project root, which `/cd` or a worktree move can change; a
+// remembered selection is requested by id, so a selected completed run is shown in full.
 // Only the newest of overlapping reads is applied. A snapshot without any runs, as during a branch
 // switch, never drops the remembered selection.
-async function refresh($) {
+async function refresh($, { quiet } = {}) {
   const read = ++session.reads;
   try {
     const root = await $.session.root();
     await followConversation($);
-    const next = await readSnapshot(files($), root, { now: await $.clock.now() });
+    const remembered = session.choices.selections[root];
+    // Keep evaluating the run already followed in this project when it leaves the active list;
+    // its completed state must be confirmed before the companion celebrates.
+    const observed = root === session.root ? observedRun({ snapshot: session.snapshot, sessionStartedAt: session.startedAt,
+      selection: remembered, mention: session.chatMention }).runId : null;
+    const runIds = [...new Set([remembered, observed].filter(Boolean))];
+    // Taken before the call: a change during the call shows up at the next check.
+    const ids = fingerprintIds(root);
+    const print = await fingerprint($, root, ids);
+    const next = await readSnapshot(processes($), { pluginRoot: $.plugin.root, root, language: session.locale,
+      runIds, now: await $.clock.now(), clock: () => $.clock.now() });
     if (read < session.appliedRead) return;
     session.appliedRead = read;
+    if (root !== session.root) {
+      // Another project root: its drift baseline, pane entries and preview start over (CR finding B3).
+      session.driftSeen = null;
+      session.snapshot = null;
+      session.figureObservation = null;
+      session.events = [];
+      session.unconfirmed = [];
+      session.isPreviewExpanded = false;
+    }
     session.root = root;
     session.snapshot = settleSnapshot(session.snapshot, next);
+    if (next.status === 'ok') session.events = session.events.filter(event => !STICKY_KINDS.includes(event.kind) || isStillUncertain(event, next.runs));
+    // A changed set of open runs is listed again, so the next check compares like with like. A failed
+    // read keeps no fingerprint, so the next check reads again (CR finding B1); so does a view with a
+    // run that ran into the read budget, which may read on the next attempt.
+    const after = fingerprintIds(root);
+    session.fingerprint = next.status === 'failed' || next.retry ? null
+      : `${session.locale}|${after.join() === ids.join() ? print : await fingerprint($, root, after)}`;
     const chosen = selection();
     if (chosen && next.status === 'ok' && next.runs.length) {
       const { dropSelection } = assignRun({ runs: next.runs, sessionStartedAt: session.startedAt, selection: chosen });
@@ -117,12 +182,105 @@ async function refresh($) {
   } catch (error) {
     if (read < session.appliedRead) return;
     session.appliedRead = read;
-    session.snapshot = settleSnapshot(session.snapshot, { status: 'failed', runs: [], unreadable: [], readAt: Date.now(), error: String(error?.message ?? error) });
+    session.fingerprint = null;
+    session.snapshot = settleSnapshot(session.snapshot, { status: 'failed', runs: [], unreadable: [], readAt: Date.now(), error: 'unavailable' });
   }
-  if (session.choices.enabled) announce($);
+  if (session.choices.enabled) announce($, { quiet });
   redraw($);
 }
 
+// The run-file fingerprint (SDD-007): the run folders, `config.json` and, for each open or selected
+// run, its RUN_STATE, documents and evidence entries with size and modification time from `$.fs.list`:
+// the files the run view compares for drift (bound documents and evidence reports). It reads listings
+// only, never a run file.
+const fingerprintIds = root => [...new Set([...(session.snapshot?.runs ?? []).filter(run => run.lifecycle === 'active').map(run => run.id),
+  session.choices.selections[root]].filter(Boolean))].sort();
+
+async function fingerprint($, root, ids = fingerprintIds(root)) {
+  const list = async path => { try { return await $.fs.list(path); } catch { return null; } };
+  const files = entries => (entries ?? []).filter(entry => entry.kind === 'file').map(entry => `${entry.name}:${entry.size}:${entry.mtimeMs}`).sort().join(',');
+  const control = `${root}/.agdf/control`;
+  const runs = await list(`${control}/runs`);
+  const parts = [`config:${files((await list(control))?.filter(entry => entry.name === 'config.json'))}`,
+    `runs:${(runs ?? []).map(entry => entry.name).sort().join(',')}`];
+  for (const id of ids) {
+    const folders = [];
+    for (const folder of ['', '/documents', '/evidence']) folders.push(files(await list(`${control}/runs/${id}${folder}`)));
+    parts.push(`${id}:${folders.join('|')}`);
+  }
+  return parts.join(';');
+}
+
+// The 30-second check and the check after a main-loop turn (SDD-007): the run view is read again only
+// when the conversation, the root, the language or the run-file fingerprint changed.
+async function check($) {
+  try {
+    const root = await $.session.root();
+    session.locale = await readLocale($, root);
+    const conversationChanged = await followConversation($);
+    if (!conversationChanged && root === session.root && `${session.locale}|${await fingerprint($, root)}` === session.fingerprint) return false;
+    await refresh($);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Reads the journal (SDD-007): a bounded read of its own file in the plugin data directory, only when
+// its size or time changed. New events of this root are kept for the pane, read the run view once and
+// raise the toasts of decision P1. A missing or unreadable journal shows "events unavailable".
+async function pollEvents($) {
+  const available = value => { if (session.eventsAvailable !== value) { session.eventsAvailable = value; redraw($); } };
+  try {
+    if (!session.dataDir) { available(false); return; }
+    // The current root, which `/cd` or a worktree move can change since the last read (CR finding B3).
+    const root = await $.session.root();
+    if (root !== session.root) await refresh($);
+    const directory = journalDirectory(session.dataDir);
+    const listing = await $.fs.list(directory);
+    const entry = listing.find(item => item.name === JOURNAL_FILE && item.kind === 'file');
+    if (!entry || entry.size > JOURNAL_READ_LIMIT) { available(false); return; }
+    const stamp = `${entry.size}:${entry.mtimeMs}`;
+    let fresh = [];
+    if (stamp !== session.journalStamp) {
+      let events = parseJournal(await $.fs.read(`${directory}/${JOURNAL_FILE}`));
+      // Lines written after the last read but before a rotation sit in the rotation file (CR finding B6).
+      const cursorId = session.journalCursor?.id;
+      const rotated = listing.find(item => item.name === JOURNAL_ROTATED_FILE && item.kind === 'file');
+      if (cursorId && !events.some(event => event.id === cursorId) && rotated && rotated.size <= JOURNAL_READ_LIMIT) {
+        events = parseJournal(await $.fs.read(`${directory}/${JOURNAL_ROTATED_FILE}`)).concat(events);
+      }
+      session.journalStamp = stamp;
+      const unseen = unseenEvents(events, { root, cursor: session.journalCursor });
+      fresh = unseen.fresh;
+      session.journalCursor = unseen.cursor;
+    }
+    available(true);
+    if (!fresh.length && !session.unconfirmed.length) return;
+    if (fresh.length) {
+      const toasts = fresh.filter(event => TOAST_KINDS.includes(event.kind));
+      await refresh($, { quiet: new Set(toasts.map(event => event.run_id)) });
+    }
+    // A durable fact is shown, in the pane and as a toast, only once the run view confirms it (SD 2,
+    // CR finding B4). Without a fresh view it waits for one instead of being dropped (CR delta review
+    // RV-1); a fresh view that does not confirm it drops it.
+    const current = session.snapshot?.status === 'ok' && !session.snapshot.stale;
+    const runs = current ? session.snapshot.runs : [];
+    const candidates = session.unconfirmed.concat(fresh);
+    const shown = candidates.filter(event => isConfirmed(event, runs));
+    session.unconfirmed = current ? [] : candidates.filter(event => !shown.includes(event)).slice(-PANE_EVENTS);
+    if (!shown.length) return;
+    session.events = [...shown].reverse().concat(session.events).slice(0, PANE_EVENTS);
+    if (!session.choices.enabled) { redraw($); return; }
+    const gate = value => gateTitle(session.registry, session.locale, value);
+    const naming = eventNaming();
+    for (const event of shown.filter(item => TOAST_KINDS.includes(item.kind))) toast($, eventText(event, t, { gateTitle: gate, ...naming }));
+    redraw($);
+  } catch {
+    available(false);
+  }
+}
+
 // Takes the last open run a main-loop text names as the chat's run at host time `at` (chat-run navigation
 // SDD-01, SDD-02). Returns whether a mention was recorded: a repeated name can still move the chat's run
 // back from a later change, so every recorded mention is announced (CR-F02).
@@ -139,43 +297,50 @@ function noteMention(text, at) {
 async function followConversation($) {
   let conversation = session.conversation;
   try { conversation = await $.session.id(); } catch { /* no conversation id on this host */ }
-  if (session.conversation && conversation !== session.conversation) {
+  const changed = Boolean(session.conversation) && conversation !== session.conversation;
+  if (changed) {
     session.chatMention = null;
     session.isBrowsing = false;
     session.observation = null;
     session.startedAt = await $.clock.now();
   }
   session.conversation = conversation;
+  return changed;
 }
 
 function stopRefreshing() {
   session.timer?.cancel();
+  session.eventTimer?.cancel();
   session.timer = null;
+  session.eventTimer = null;
 }
 
-// The timer is replaced before the first read, so overlapping starts never leave a second timer.
+// The timers are replaced before the first read, so overlapping starts never leave a second one: the
+// journal is read every 2 seconds, the run files are checked every 30 seconds (SDD-007). Events written
+// before the start are history, never announced.
 async function startRefreshing($) {
   stopRefreshing();
-  session.timer = $.clock.every(REFRESH_MS, () => { void refresh($); });
-  await refresh($);
+  session.journalCursor = { id: null, at: new Date(await $.clock.now()).toISOString() };
+  session.journalStamp = null;
+  session.eventTimer = $.clock.every(EVENT_POLL_MS, () => { void pollEvents($); });
+  session.timer = $.clock.every(REFRESH_MS, () => { void check($); });
+  // The first read runs beside the host: session start and the command never wait for the run-view
+  // process (CR finding B5); the pane draws "reading" until it lands.
+  session.background = (async () => { await refresh($); await pollEvents($); })().catch(() => {});
   return $.ui.open({ id: PANE, title: t('title') });
 }
 
+// Settles once the latest background read finished (for the adapter test).
+export const whenIdle = () => session.background ?? Promise.resolve();
+
 const openedText = opened => (opened?.isPlaced === false ? t('command.waiting', { reason: opened.reason }) : t('command.enabled'));
 
 async function loadSession($) {
   session.startedAt = await $.clock.now();
   session.root = await $.session.root();
-  session.labels = JSON.parse(await $.fs.read(`${$.plugin.root}/companion/locales.json`));
   session.registry = JSON.parse(await $.fs.read(`${$.plugin.root}/meta/agdf-interaction-locales.json`));
-  const config = `${session.root}/.agdf/control/config.json`;
-  const configText = (await $.fs.exists(config)) ? await $.fs.read(config) : null;
-  // Without AGDF control, Claude's own `language` setting chooses the language (follow-up SDD-11).
-  let setting = null;
-  if (configText === null) {
-    try { setting = await $.settings.read({ key: 'language' }); } catch { /* no setting: the fallback locale */ }
-  }
-  session.locale = chatLocale(session.registry, configText, { setting, labels: session.labels });
+  session.labels = companionLabels(session.registry);
+  session.locale = await readLocale($, session.root);
   // The About entry names the plugin version; a missing or unreadable manifest only leaves it out.
   try {
     const { version } = JSON.parse(await $.fs.read(`${$.plugin.root}/.claude-plugin/plugin.json`));
@@ -188,15 +353,31 @@ async function loadSession($) {
   } catch { /* no icon shown */ }
   const dir = pluginDataDir({ configDir: await $.env.get('CLAUDE_CONFIG_DIR'), userProfile: await $.env.get('USERPROFILE'), home: await $.env.get('HOME') });
   session.statePath = dir ? `${dir}/${STATE_FILE}` : null;
+  // The MCP server journals below the same plugin data root (companion core SDD-006).
+  session.dataDir = dir;
   if (session.statePath && (await $.fs.exists(session.statePath))) session.choices = parseCompanionState(await $.fs.read(session.statePath));
 }
 
+// The AGDF chat language of the project; without AGDF control, Claude's own `language` setting
+// (follow-up SDD-11). Read again at every check, so a language change reads the run view again.
+async function readLocale($, root) {
+  const config = `${root}/.agdf/control/config.json`;
+  const configText = (await $.fs.exists(config)) ? await $.fs.read(config) : null;
+  let setting = null;
+  if (configText === null) {
+    try { setting = await $.settings.read({ key: 'language' }); } catch { /* no setting: the fallback locale */ }
+  }
+  return chatLocale(session.registry, configText, { setting, labels: session.labels });
+}
+
 const wrappedRows = (value, columns) => (value ? Math.ceil(value.length / Math.max(columns, 10)) : 0);
 
 // How many open runs the desktop list shows: the body rows left beside the other blocks, never fewer
 // than the terminal's six (the pane then scrolls). One row of them goes to "+ N more" when runs remain.
 export function listCapacity(view, { rows, columns, isAboutShown = false }) {
-  const blocks = [view.message, view.hint, view.stale].filter(Boolean);
+  const blocks = [view.message, view.hint, view.unreadableHint !== view.message ? view.unreadableHint : null, view.stale,
+    ...(view.drift ?? []), ...(view.events ? [view.events.join(' '), ...view.events.map(() => ' ')] : []),
+    ...(view.review ? [view.review.summary, view.review.match, ' ', ' '] : []), view.eventsHint].filter(Boolean);
   const fixed = DESKTOP_ROWS.figure + DESKTOP_ROWS.footer + DESKTOP_ROWS.spare + (isAboutShown ? DESKTOP_ROWS.about : 0) + 1
     + blocks.reduce((sum, value) => sum + wrappedRows(value, columns), 0) + DESKTOP_ROWS.gap * (blocks.length + 3);
   return Math.max(LISTED_RUNS, Math.floor(rows - fixed));
@@ -209,14 +390,24 @@ export function fitRunId(id, room) {
   return `${id.slice(0, room - 1 - tail)}…${id.slice(id.length - tail)}`;
 }
 
+// A run name cut at its end to `room` characters; a name reads from its start, unlike an id.
+export function fitRunName(name, room) {
+  return name.length <= room ? name : `${name.slice(0, Math.max(1, room - 1))}…`;
+}
+
 const press = ($, action) => async () => {
   try { await action(); } catch { /* a failed action leaves the last drawing */ }
   redraw($);
 };
 
-function body($, e, view) {
+function body($, e) {
   const { Box, Text, Button, Svg, Link, Select } = $.ui.resolve(e);
   const isTerminal = e.surface === 'terminal' || !Svg;
+  const view = buildPanelView({ snapshot: session.snapshot, sessionStartedAt: session.startedAt, selection: selection(),
+    mention: session.chatMention, isBrowsing: session.isBrowsing, showRunState: !isTerminal,
+    isTurnActive: session.isTurnActive, registry: session.registry, labels: session.labels, locale: session.locale,
+    columns: e.props?.bodyColumns ?? Infinity, isInfoExpanded: session.isInfoExpanded,
+    events: session.events, eventsAvailable: session.eventsAvailable ?? undefined });
   const rows = e.props?.scroll?.bodyRows;
   const fits = Number.isInteger(rows) && rows > 0;
   const columns = Number.isInteger(e.props?.bodyColumns) ? e.props.bodyColumns : 40;
@@ -238,7 +429,7 @@ function body($, e, view) {
   const commands = [
     ...(canReturn ? [['chat', t('actions.backToChat'), back]] : []),
     ['still', session.choices.still ? t('actions.stillOff') : t('actions.stillOn'), toggle('still')],
-    ['retry', t('actions.retry'), () => refresh($)],
+    ['retry', t('actions.retry'), async () => { session.journalStamp = null; await refresh($); await pollEvents($); }],
     ['notice', session.choices.notice ? t('actions.noticeOff') : t('actions.noticeOn'), toggle('notice')],
     ['sound', session.choices.sound ? t('actions.soundOff') : t('actions.soundOn'), toggle('sound')],
     ['about', t('actions.about'), async () => { session.isAboutShown = true; }],
@@ -277,14 +468,15 @@ function body($, e, view) {
   // The terminal keeps its six; the desktop lists as many as fit and gives the last row to "+ N more".
   const listed = isTerminal ? view.openRuns.slice(0, LISTED_RUNS)
     : view.openRuns.length <= capacity ? view.openRuns : view.openRuns.slice(0, capacity - 1);
-  // One listed run: the id as a plain button and, where the pane has room for the widest listed bar, its
-  // condensed gate bar at the right edge, every id shortened to the same room (the same rule for all rows,
-  // live check of 2026-10-28). The bar keeps its width; an id that still runs over is cut by the surface.
+  // One listed run: its name as a plain button (owner request of 2026-11-11: a run id tells a person
+  // nothing) and, where the pane has room for the widest listed bar, its condensed gate bar at the right
+  // edge, every name cut to the same room (the same rule for all rows, live check of 2026-10-28). The bar
+  // keeps its width; a name that still runs over is cut by the surface.
   const widest = Math.max(0, ...listed.map(run => run.bar?.length ?? 0));
   const room = columns - widest - 2;
   const withBars = widest > 0 && room >= ID_ROOM;
   const runRow = run => {
-    const id = h(Button, { key: `run-${run.id}`, plain: true, label: withBars ? fitRunId(run.id, room) : run.id, onPress: select(run.id) });
+    const id = h(Button, { key: `run-${run.id}`, plain: true, label: fitRunName(run.name ?? run.id, withBars ? room : columns), onPress: select(run.id) });
     return withBars && run.bar
       ? h(Box, { flexDirection: 'row', justifyContent: 'space-between', alignItems: 'center', gap: 1 },
         h(Box, { flexShrink: 1 }, id), h(Box, { flexShrink: 0 }, h(Text, { dimColor: true, mono: true }, run.bar)))
@@ -306,34 +498,82 @@ function body($, e, view) {
         ...listed.map(runRow),
         !isTerminal && view.openRuns.length > listed.length ? h(Text, { dimColor: true }, t('fields.moreRuns', { count: view.openRuns.length - listed.length })) : null))
     : null;
+  // The (i) opens the run's details on purpose (owner request of 2026-11-12); closed by default and
+  // only offered when there is something behind it. The label names the action, so it reads alone.
+  const infoButton = view.info?.length ? h(Button, { key: 'info', plain: true,
+    label: view.isInfoExpanded ? t('actions.infoHide') : t('actions.infoShow'),
+    onPress: press($, async () => { session.isInfoExpanded = !session.isInfoExpanded; }) }) : null;
   if (isTerminal) {
     return h(Box, { flexDirection: 'column', gap: 1 },
-      h(Text, { color: COLOR[view.mood] }, terminalText(view, { labels: session.labels, locale: session.locale })), runList, about, actions);
+      h(Text, { color: view.resting ? undefined : COLOR[view.mood] }, terminalText(view, { labels: session.labels, locale: session.locale })), infoButton, runList, about, actions);
   }
-  const figure = h(Svg, { source: figureSvg(view.mood, { still: session.choices.still, title: `${view.title}: ${view.stateLabel}` }),
-    alt: `${view.title}: ${view.stateLabel}`, width: 200, height: 140, isInteractive: !session.choices.still });
+  const scope = view.runId ? JSON.stringify([session.root, view.runId]) : null;
+  const quiet = !session.choices.enabled || session.choices.still || session.isHidden || Boolean(view.stale);
+  const still = quiet || !scope || ['unreadable', 'idle', 'completionUnconfirmed'].includes(view.figure?.reason.key);
+  // Without an assigned run a readable project smiles and keeps the idle motion (blinking) unless the
+  // still pose applies; it never gestures. The smile is a static face, so the still pose keeps it.
+  const idle = !scope && view.idle === true;
+  const idling = idle && !quiet;
+  session.figureObservation = observeFigure(session.figureObservation, { scope, figure: view.figure, current: !still });
+  const { gate, gesture, sequence } = session.figureObservation ?? {};
+  // With every run done the crew member checks the board: a tablet, never a finish flag (no run is shown).
+  const figure = h(Svg, { source: figureSvg(view.mood, { still: still && !idling, smile: idle, tablet: idle && view.allDone === true, invite: idle && view.invite === true, resting: view.resting === true, gate, workGate: view.workGate, gesture, sequence }),
+    alt: `${view.title}: ${view.stateLabel}`, width: 200, height: 140, isInteractive: !still });
   // The body is as tall as the pane's body rows less the probed reserve and the content grows, so the
   // footer sits at the bottom edge; a taller body scrolls with the footer last (live probes of
   // 2026-10-28: a cell count sizes the body, a percentage does not; SDD-08).
   return h(Box, { flexDirection: 'column', gap: 1, ...(fits ? { minHeight: rows - BODY_RESERVE } : {}) }, h(Box, { flexDirection: 'column', gap: 1, flexGrow: 1 },
     h(Box, { flexDirection: 'column', alignItems: 'center' },
       figure,
-      h(Text, { color: COLOR[view.mood], size: 'heading', weight: 'bold' }, view.stateLabel),
-      view.reason ? h(Text, { dimColor: true, wrap: 'truncate-end' }, view.reason) : null),
-    view.message ? h(Text, {}, view.message) : null,
+      // A resting run carries no signal colour: nothing happens and nothing is asked of the person.
+      h(Text, { color: view.resting ? undefined : COLOR[view.mood], size: 'heading', weight: 'bold' }, view.stateLabel),
+      // The turn block below says what the reason would; without one the reason stays under the state.
+      view.reason && !view.turn ? h(Text, { dimColor: true, wrap: 'truncate-end' }, view.reason) : null),
+    // An invitation reads as the pane's headline; every other message stays plain.
+    view.message ? h(Text, view.invite ? { weight: 'semibold', wrap: 'wrap' } : {}, view.message) : null,
     view.hint ? h(Text, { dimColor: true }, view.hint) : null,
+    view.unreadableHint && view.unreadableHint !== view.message ? h(Text, { color: 'warning' }, view.unreadableHint) : null,
+    // The run by its name, with its delivery path and the position on it.
+    view.name ? h(Box, { flexDirection: 'column' },
+      h(Text, { weight: 'semibold', wrap: 'wrap' }, view.name),
+      view.route ? h(Text, { dimColor: true, wrap: 'truncate-end' }, view.route) : null) : null,
+    // The run's goal in the chat language, before whose move it is: what an approval is measured against.
+    view.goal ? h(Box, { flexDirection: 'column' },
+      h(Text, { dimColor: true }, t('fields.objective')),
+      h(Text, { wrap: 'wrap' }, view.goal)) : null,
+    // Whose move it is, what it is and, for an approval, how it is given.
+    view.turn ? h(Box, { flexDirection: 'column', borderStyle: 'single', borderDimColor: true, paddingX: 1 },
+      h(Text, { color: TURN_COLOR[view.turn.tone], weight: 'semibold' }, view.turn.who),
+      h(Text, { wrap: 'wrap' }, view.turn.what),
+      view.turn.how ? h(Text, { dimColor: true, wrap: 'wrap' }, view.turn.how) : null) : null,
     view.gateBar ? h(Text, { mono: true, wrap: 'truncate-end' }, view.gateBar) : null,
-    view.runId ? h(Box, { flexDirection: 'column' },
-      h(Text, { weight: 'semibold', wrap: 'truncate-end' }, view.runId),
-      view.origin ? h(Text, { dimColor: true }, view.origin) : null) : null,
-    view.objective ? h(Box, { flexDirection: 'row', gap: 1, alignItems: 'center' },
-      h(Text, { dimColor: true, wrap: view.isObjectiveExpanded ? 'wrap' : 'truncate-end' }, view.objective),
-      h(Button, { key: 'objective', plain: true, label: view.isObjectiveExpanded ? t('actions.collapse') : t('actions.expand'),
-        onPress: press($, async () => { session.isObjectiveExpanded = !session.isObjectiveExpanded; }) })) : null,
     view.nextStep ? h(Box, { flexDirection: 'column' },
       h(Text, { dimColor: true }, t('fields.nextStep')),
       h(Text, {}, view.nextStep)) : null,
+    // The (i) and, once opened, the details behind it: a goal that was cut, the gate's purpose, a repeated step.
+    infoButton,
+    view.isInfoExpanded && view.info?.length ? h(Box, { flexDirection: 'column', gap: 1, borderStyle: 'single', borderDimColor: true, paddingX: 1 },
+      ...view.info.map(item => h(Box, { flexDirection: 'column' },
+        h(Text, { dimColor: true }, item.label),
+        h(Text, { wrap: 'wrap' }, item.text)))) : null,
+    ...(view.drift ?? []).map(text => h(Text, { color: 'warning' }, text)),
+    view.events ? h(Box, { flexDirection: 'column' },
+      h(Text, { dimColor: true }, t('fields.events')),
+      ...view.events.map(line => h(Text, { wrap: 'truncate-end' }, line))) : null,
+    view.review ? h(Box, { flexDirection: 'column' },
+      h(Text, { dimColor: true }, t('fields.material')),
+      h(Text, {}, `${view.review.summary} · ${view.review.match}`),
+      view.review.preview ? h(Text, { mono: true, dimColor: true, wrap: session.isPreviewExpanded ? 'wrap' : 'truncate-end' },
+        session.isPreviewExpanded ? view.review.preview : view.review.preview.split('\n')[0]) : null,
+      view.review.preview ? h(Button, { key: 'preview', plain: true, label: session.isPreviewExpanded ? t('actions.collapse') : t('actions.expand'),
+        onPress: press($, async () => { session.isPreviewExpanded = !session.isPreviewExpanded; }) }) : null,
+      view.review.truncated ? h(Text, { dimColor: true }, view.review.truncated) : null) : null,
+    view.eventsHint ? h(Text, { dimColor: true }, view.eventsHint) : null,
     runList,
+    // The run id is a reference for commands, so it stands last and dim.
+    view.runId ? h(Box, { flexDirection: 'column' },
+      h(Text, { dimColor: true, mono: true, wrap: 'truncate-end' }, view.runId),
+      view.origin ? h(Text, { dimColor: true }, view.origin) : null) : null,
     view.stale ? h(Text, { color: 'warning' }, view.stale) : null,
     about),
     actions);
@@ -365,6 +605,7 @@ export const register = on => {
         // Reading, the status line and the pane stop before the choice is stored, so a failing write
         // leaves none of them running (CR-F03); the choice is stored even if closing the pane fails.
         stopRefreshing();
+        session.figureObservation = null;
         silence($);
         try {
           await $.ui.close({ id: PANE });
@@ -387,6 +628,9 @@ export const register = on => {
         // A main-loop turn ends browsing and may name the chat's run (chat-run navigation SDD-02, SDD-04);
         // the host clock is read beside the event, never before it is passed on (SDD-11).
         session.isBrowsing = false;
+        // Pane entries of events clear at the next main-loop turn (PRD state transitions); an uncertain
+        // outcome stays until its run recorded a later operation (CR finding B7).
+        session.events = session.events.filter(event => STICKY_KINDS.includes(event.kind));
         if (!session.isHidden) session.isTurnActive = true;
         redraw($);
         const prompt = e.text;
@@ -402,15 +646,17 @@ export const register = on => {
       if (e.agentId === undefined) {
         // Cleared on every main-loop completion, also while switched off, so no stale overlay remains.
         session.isTurnActive = false;
-        // The read runs after the host has its answer, never inside the hook; a hidden pane keeps
-        // the status line and toasts current (follow-up SDD-08). The turn's final answer (`e.answer`,
-        // else the text `next(e)` returned) is matched against that read at the turn's end time, so a
-        // run created during the turn counts (CR-F05, CR-F06).
+        // The check runs after the host has its answer, never inside the hook; a hidden pane keeps
+        // the status line and toasts current (follow-up SDD-08). It reads the journal and, on a
+        // changed run-file fingerprint, the run view (SDD-007); the turn overlay ends with a redraw
+        // either way. The turn's final answer (`e.answer`, else the text `next(e)` returned) is matched
+        // at the turn's end time, so a run created during the turn counts (CR-F05, CR-F06).
         if (session.choices.enabled) {
           const answer = typeof e.answer === 'string' ? e.answer : answered?.text;
           void (async () => {
             const at = await $.clock.now();
-            await refresh($);
+            await pollEvents($);
+            if (!(await check($))) redraw($);
             if (session.choices.enabled && noteMention(answer, at)) { announce($); redraw($); }
           })().catch(() => {});
         }
@@ -424,6 +670,7 @@ export const register = on => {
   // stamps `origin` as `{ kind: 'plugin' | 'person' | 'unload' }`.
   on('ui.close', { id: PANE }, async ($, e, next) => {
     try {
+      session.figureObservation = null;
       if (e.origin?.kind === 'person') session.isHidden = true;
     } catch { /* observation only */ }
     return next(e);
@@ -432,10 +679,7 @@ export const register = on => {
   // A logic failure draws a neutral line instead of the panel; it never throws into the host.
   on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {
     try {
-      return body($, e, buildPanelView({ snapshot: session.snapshot, sessionStartedAt: session.startedAt, selection: selection(),
-        mention: session.chatMention, isBrowsing: session.isBrowsing,
-        isTurnActive: session.isTurnActive, registry: session.registry, labels: session.labels, locale: session.locale,
-        columns: e.props?.bodyColumns ?? Infinity, isObjectiveExpanded: session.isObjectiveExpanded }));
+      return body($, e);
     } catch (error) {
       const { Text } = $.ui.resolve(e);
       return h(Text, { dimColor: true }, `AGDF Companion: ${String(error?.message ?? error).slice(0, 200)}`);