create-agdf 0.31.0 → 0.32.0

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

@@ -11,7 +11,7 @@
 import { assignRun, namedRun, openRuns, stepSelection } from './assignment.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 } from './figure.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';
@@ -39,12 +39,14 @@ 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, dataDir: null, version: null, icon: null,
-    choices: defaultCompanionState(), isHidden: false, snapshot: null, isTurnActive: false, isObjectiveExpanded: false,
+    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, chatMention: null, isBrowsing: false, conversation: null,
+    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,
@@ -142,16 +144,23 @@ async function refresh($, { quiet } = {}) {
     const root = await $.session.root();
     await followConversation($);
     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: remembered ? [remembered] : [], now: await $.clock.now(), clock: () => $.clock.now() });
+      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;
@@ -160,9 +169,10 @@ async function refresh($, { quiet } = {}) {
     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).
+    // 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' ? null
+    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) {
@@ -180,8 +190,9 @@ async function refresh($, { quiet } = {}) {
 }
 
 // The run-file fingerprint (SDD-007): the run folders, `config.json` and, for each open or selected
-// run, its RUN_STATE and documents entries with size and modification time from `$.fs.list`. It reads
-// listings only, never a run file.
+// 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();
 
@@ -192,7 +203,11 @@ async function fingerprint($, root, ids = fingerprintIds(root)) {
   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) parts.push(`${id}:${files(await list(`${control}/runs/${id}`))}|${files(await list(`${control}/runs/${id}/documents`))}`);
+  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(';');
 }
 
@@ -375,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;
@@ -443,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)))
@@ -472,34 +498,64 @@ 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')),
@@ -514,6 +570,10 @@ function body($, e, view) {
       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);
@@ -545,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 });
@@ -609,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);
@@ -617,11 +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,
-        events: session.events, eventsAvailable: session.eventsAvailable ?? undefined }));
+      return body($, e);
     } catch (error) {
       const { Text } = $.ui.resolve(e);
       return h(Text, { dimColor: true }, `AGDF Companion: ${String(error?.message ?? error).slice(0, 200)}`);

package/generated/plugins/agdf/companion/run-state.mjs

@@ -10,6 +10,8 @@ export const READ_FAILURE_REASONS = Object.freeze(['timeout', 'unavailable', 'ex
 // Store reasons of a read that may succeed on the next attempt (a write during the read, the read
 // budget); they keep the last good view, marked stale, like a failed read (CR delta review RV-1).
 export const TRANSIENT_STORE_REASONS = Object.freeze(['source_changed', 'timeout']);
+// Evaluation errors of a single run that make the whole view incomplete (a write during its read).
+export const TRANSIENT_RUN_REASONS = Object.freeze(['source_changed']);
 // The internal steps between an approved TP and QA, shown as the build phase in the gate bar.
 export const BUILD_GATES = Object.freeze(['Brownfield Analysis', 'CD+Tests', 'CR']);
 export const isStructured = route => route === 'structured_delivery' || route === 'structured_slice';
@@ -41,6 +43,11 @@ export function companionRun(entry) {
     drift: Object.freeze((entry.drift ?? []).map(item => Object.freeze({ ...item }))),
     // The authored objective, never the status card's run title or a template text.
     objective: clip(entry.objective ?? ''),
+    // The run's stable human title (registered UR heading, else the authored objective); empty while
+    // only the run id could name it. The goal is the objective in the display language where the UR
+    // states one.
+    title: clip(entry.run_title ?? ''),
+    goal: clip(entry.goal ?? entry.objective ?? ''),
   });
 }
 
@@ -57,7 +64,9 @@ export function snapshotFromRunView(stdout, { now }) {
   }
   // A run read while its files changed (after the run view's bounded retries) makes the view incomplete;
   // like a transient store failure it keeps the last good view instead of showing that run as blocked.
-  const changedRun = view.runs.find(run => TRANSIENT_STORE_REASONS.includes(run?.evaluation_error));
+  // A single run that ran into the read budget is not transient: it stays that run's own reason, so the
+  // other runs are still shown.
+  const changedRun = view.runs.find(run => TRANSIENT_RUN_REASONS.includes(run?.evaluation_error));
   if (changedRun) return { status: 'failed', runs: [], unreadable: [], readAt: now, error: changedRun.evaluation_error };
   const status = view.store.status === 'ok' ? 'ok' : view.store.status === 'no_control' ? 'no_control' : 'unavailable';
   return {
@@ -69,6 +78,9 @@ export function snapshotFromRunView(stdout, { now }) {
     runs: view.runs.filter(entry => entry.valid !== false && entry.listed !== false).map(companionRun),
     unreadable: (view.diagnosis?.unreadable ?? []).map(({ run_id, reason }) => ({ id: run_id, reason })),
     diagnosis: view.diagnosis ?? null,
+    // A run that ran into the read budget may read on the next attempt: the adapter keeps no
+    // fingerprint for such a view, so the next check reads again instead of waiting for a file change.
+    retry: view.runs.some(run => run?.evaluation_error === 'timeout'),
     readAt: now,
   };
 }

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

@@ -3,12 +3,12 @@
 // host-independent; the adapter draws it on desktop or as text in the terminal.
 
 import { assignRun } from './assignment.mjs';
-import { FIGURE_TEXT } from './figure.mjs';
+import { FIGURE_TEXT, INVITE_TEXT } from './figure.mjs';
 import { condensedGateBar, gateBar, gateMarks } from './gate-bar.mjs';
-import { gateTitle, label } from './localization.mjs';
-import { displayState } from './state.mjs';
-import { READ_FAILURE_REASONS } from './run-state.mjs';
-import { eventText, latestReview, PANE_EVENTS, shortDigest } from './events.mjs';
+import { gateRationale, gateTitle, label } from './localization.mjs';
+import { displayState, runState } from './state.mjs';
+import { isStructured, READ_FAILURE_REASONS } from './run-state.mjs';
+import { eventText, latestReview, PANE_EVENTS, shortDigest, shortRunId } from './events.mjs';
 
 const two = value => String(value).padStart(2, '0');
 // Preview lines the terminal text shows beneath the material line.
@@ -18,8 +18,81 @@ const folderName = root => String(root ?? '').replace(/[\\/]+$/u, '').split(/[\\
 // Host-local wall-clock time, HH:MM.
 export const clockText = ms => { const at = new Date(ms); return `${two(at.getHours())}:${two(at.getMinutes())}`; };
 
+// The name a person reads for the shown run: its stable title, else the catalog's "new run". The run
+// id never names a run; it stays a reference line at the panel's end.
+export const runName = (run, t) => run.title || t('fields.newRun');
+// A listed run needs a name that tells it from its neighbours, so an untitled one adds its short id.
+export const listedRunName = (run, t) => run.title || `${t('fields.newRun')} · ${shortRunId(run.id)}`;
+
+// Whose move it is (owner request of 2026-11-11): read from the figure state Core derived, so the
+// block never decides anything itself. `tone` is you (an approval or decision is yours), claude (the
+// agent works on the gate), next (the step is up next and nobody works on it) or halt (the run is
+// blocked). This function words the moves that are yours and the block; activityOf below words the work.
+// A state that concerns no gate work has no such block, and neither has the terminal's turn overlay
+// beside a run that is not working: its reason already says that Claude works.
+export function turnOf(state, run, t, gateName) {
+  const { key, gate, decision } = state.reason;
+  const at = gate ?? run.gate;
+  if (!at) return null;
+  if (key === 'waitingApproval') {
+    return { tone: 'you', who: t('turn.you'), what: t('turn.approve', { gate: gateName(at) }),
+      how: run.missing && run.missing !== 'none' ? t('turn.inChat', { approval: run.missing }) : null, gate: at };
+  }
+  if (key === 'waitingDecision') return { tone: 'you', who: t('turn.you'), what: t('turn.decide', { gate: gateName(at) }), how: null, gate: at };
+  if (key === 'blocked') {
+    return { tone: 'halt', who: t('turn.blocked'), what: t('reasons.blocked', { gate: gateName(at), decision: run.blockingText || decision || '' }), how: null, gate: at };
+  }
+  return null;
+}
+
+// Which kind of work a step is; the catalog's `activity` section words each kind once. A step the
+// table does not know is worded by its name.
+export const ACTIVITY_KINDS = Object.freeze({ UR: 'draft', PRD: 'draft', SD: 'draft', TP: 'draft',
+  'Brownfield Review': 'analysis', 'Brownfield Analysis': 'analysis', 'Mode/Slice Decision': 'route',
+  'CD+Tests': 'build', 'Quick Task Execution': 'build', 'Verified Change Execution': 'build',
+  CR: 'review', QA: 'quality', UAT: 'acceptance', OR: 'closeout' });
+
+// What a run is busy with (owner request of 2026-11-12: "läuft" named no activity). Read from the run's
+// own state, a step Claude works on or builds, never from the turn overlay. While a main-loop turn runs,
+// the line says what is being done and the block asks for a moment. Otherwise the run rests: the line
+// says what is up next and the block how to carry on. Returns { label, turn, resting } or null.
+export function activityOf(derived, run, isTurnActive, t, title) {
+  const { key, gate } = derived.reason;
+  const at = gate ?? run.gate;
+  if ((key !== 'working' && key !== 'building') || !at) return null;
+  const kind = ACTIVITY_KINDS[at] ?? 'other';
+  const named = title(at);
+  // A document or approval gate keeps its short name beside its title; an internal step has only a title.
+  const step = named !== at && /^[A-Z]{2,3}$/u.test(at) ? `${named} (${at})` : named;
+  const label = t(`activity.${kind}.${isTurnActive ? 'working' : 'idle'}`, { gate: at, step: named });
+  const drafting = kind === 'draft';
+  const turn = isTurnActive
+    ? { tone: 'claude', who: t('turn.moment'), what: drafting ? t('turn.drafting', { step }) : t('turn.workingOn', { step }), how: null, gate: at }
+    : { tone: 'next', who: t('turn.next'), what: drafting ? t('turn.draft', { step }) : step, how: t('turn.resume'), gate: at };
+  return { label, turn, resting: !isTurnActive };
+}
+
+// About two pane lines of the goal, cut at a word, so the block that asks for a move stays in sight.
+const GOAL_LINES = 2;
+export function goalLine(goal, columns) {
+  const room = Math.max(40, (Number.isFinite(columns) ? columns : 60) * GOAL_LINES);
+  if (goal.length <= room) return goal;
+  const cut = goal.slice(0, room - 1), at = cut.lastIndexOf(' ');
+  return `${(at > room / 2 ? cut.slice(0, at) : cut).replace(/[\s,;:.–-]+$/u, '')}…`;
+}
+
+// The delivery path and the position on it, e.g. "Strukturierte Lieferung · Schritt 2 von 8". Before
+// the path is decided only that is said; a path that names no current entry gives no position.
+export function routeLine(run, marks, t) {
+  const key = isStructured(run.route) ? 'structured' : run.route === 'quick_task' || run.route === 'verified_change' ? run.route
+    : (run.route === 'undecided' || run.route == null) && run.evaluated && run.lifecycle === 'active' ? 'undecided' : null;
+  if (!key) return null;
+  const at = marks.findIndex(({ mark }) => mark === 'current');
+  return key === 'undecided' || at < 0 ? t(`routes.${key}`) : `${t(`routes.${key}`)} · ${t('fields.step', { position: at + 1, count: marks.length })}`;
+}
+
 // input: { snapshot, sessionStartedAt, selection, mention, isBrowsing, isTurnActive, registry, labels,
-// locale, columns, isObjectiveExpanded, events, eventsAvailable }. Display only: the adapter persists
+// locale, columns, isInfoExpanded, events, eventsAvailable }. Display only: the adapter persists
 // selection changes. `events` are this root's journal events since the last main-loop turn, newest first.
 export function buildPanelView(input) {
   const { snapshot, registry, labels, locale } = input;
@@ -46,7 +119,12 @@ export function buildPanelView(input) {
       : unreadable(reason);
   }
   if (snapshot.status === 'no_control') {
-    return neutral(t('messages.noControl', { folder: folderName(snapshot.root) }), { hint: t('messages.noControlHint', { path: snapshot.root ?? '' }) });
+    // A project without AGDF is invited to start, not told about a missing folder (owner request of
+    // 2026-11-12): the figure holds the start sign, and the checked path and the finding sit behind the (i).
+    return neutral(t('messages.notSetUp'), { hint: t('messages.notSetUpHint'), invite: true, idle: true,
+      isInfoExpanded: Boolean(input.isInfoExpanded), info: [
+        { label: t('fields.checkedFolder'), text: snapshot.root ?? '' },
+        { label: t('fields.finding'), text: t('messages.noControl', { folder: folderName(snapshot.root) }) }] });
   }
 
   const { run, origin, open, chatRunId } = assignRun({ runs: snapshot.runs, sessionStartedAt: input.sessionStartedAt, selection: input.selection,
@@ -55,31 +133,77 @@ export function buildPanelView(input) {
   const reasons = [...new Set(snapshot.unreadable.map(item => t(`unreadable.${item.reason}`)))].join(', ');
   const unreadableHint = snapshot.unreadable.length ? t('messages.unreadableRuns', { count: snapshot.unreadable.length, reasons }) : null;
   // Each open run carries its condensed gate bar for the list (owner request of 2026-10-28).
-  const openRuns = open.map(item => ({ id: item.id, objective: item.objective, bar: condensedGateBar(gateMarks(item)) }));
+  const openRuns = open.map(item => ({ id: item.id, name: listedRunName(item, t), objective: item.objective, bar: condensedGateBar(gateMarks(item)) }));
   if (!run) {
     const broken = input.selection && snapshot.unreadable.find(item => item.id === input.selection);
     if (broken) return { ...unreadable(broken.reason), openRuns, chatRunId, unreadableHint };
-    if (!open.length) return neutral(unreadableHint ?? t('messages.noOpenRuns'));
-    return neutral(t('messages.noRunAssigned'), { hint: t('messages.noRunAssignedHint'), openRuns, chatRunId, unreadableHint,
+    // A readable project without an assigned run idles: the figure blinks but shows no run state.
+    if (!open.length) {
+      if (unreadableHint) return neutral(unreadableHint, { idle: false });
+      const runs = snapshot.runs ?? [];
+      // "All done" only when every run completed; superseded or abandoned runs did not finish.
+      if (!runs.length) return neutral(t('messages.noRunsYet'), { idle: true, hint: t('messages.noRunsYetHint') });
+      if (runs.every(item => item.lifecycle === 'completed')) return neutral(t('messages.allRunsDone'), { idle: true, allDone: true, hint: t('messages.allRunsDoneHint') });
+      return neutral(t('messages.noOpenRuns'), { idle: true });
+    }
+    return neutral(t('messages.noRunAssigned'), { idle: true, hint: t('messages.noRunAssignedHint'), openRuns, chatRunId, unreadableHint,
       openCount: t('fields.openRuns', { count: open.length }) });
   }
 
   const position = open.findIndex(item => item.id === run.id);
   const openCount = position >= 0 ? t('fields.position', { position: position + 1, count: open.length }) : t('fields.openRuns', { count: open.length });
-  const state = displayState(run, { isTurnActive: input.isTurnActive });
+  const derived = runState(run);
+  const state = input.showRunState ? derived : displayState(run, { isTurnActive: input.isTurnActive });
   const reasonParams = { gate: gateTitle(registry, locale, state.reason.gate), decision: run.blockingText || state.reason.decision,
     reason: state.reason.reason ? t(`unreadable.${state.reason.reason}`) : '' };
+  // A gate by its localized title with its short name, e.g. "Produktanforderungen (PRD)".
+  const gateName = gate => { const title = gateTitle(registry, locale, gate); return title === gate ? gate : `${title} (${gate})`; };
+  const marks = gateMarks(run);
+  const name = runName(run, t);
+  const activity = activityOf(derived, run, Boolean(input.isTurnActive), t, gate => gateTitle(registry, locale, gate));
+  const turn = activity?.turn ?? turnOf(state, run, t, gateName);
+  // The goal in the display language; a goal that only repeats the name is not said twice.
+  const goal = run.goal || run.objective;
+  const objective = goal && goal !== name ? goal : '';
+  // What the gate in question decides; a blocked run names its block instead.
+  const rationale = turn && turn.tone !== 'halt' ? gateRationale(registry, locale, turn.gate) : null;
+  // A completed run names no next step, unless it is blocked: then the step says what to do about it.
+  const step = run.lifecycle === 'completed' && run.figure?.reason?.key !== 'blocked' ? null : run.nextText || null;
+  // For an approval the turn block already says what to do and how, so the next step only repeats it.
+  const stepRepeats = Boolean(step) && state.reason.key === 'waitingApproval' && Boolean(turn);
+  // The goal stands under the run's name, before whose move it is: it is what an approval is measured
+  // against (owner request of 2026-11-12). About two pane lines of it; the rest is behind the (i).
+  const goalShown = objective ? goalLine(objective, input.columns) : '';
+  // Details a person opens on purpose behind the (i): a goal that was cut, what the gate decides, and
+  // a next step that only repeats the approval. Closed by default.
+  const info = [
+    objective && goalShown !== objective ? { label: t('fields.objective'), text: objective } : null,
+    rationale ? { label: t('fields.gatePurpose'), text: rationale } : null,
+    stepRepeats ? { label: t('fields.nextStep'), text: step } : null,
+  ].filter(Boolean);
   return {
     ...base,
     ...events(run.id),
+    ...(input.showRunState ? { figure: state } : {}),
     mood: state.mood,
-    stateLabel: t(`states.${state.mood}`),
+    workGate: input.showRunState && run.evaluated && !snapshot.stale ? run.gate : undefined,
+    // A working run names its activity; every other state keeps its word.
+    stateLabel: activity?.label ?? t(`states.${state.mood}`),
+    // The run rests: the step is up next and no main-loop turn works on it.
+    resting: activity?.resting === true,
     reason: t(`reasons.${state.reason.key}`, reasonParams),
-    gateBar: gateBar(gateMarks(run), input.columns),
+    gateBar: gateBar(marks, input.columns),
     runId: run.id,
-    objective: run.objective,
-    isObjectiveExpanded: Boolean(input.isObjectiveExpanded),
-    nextStep: run.lifecycle === 'completed' ? null : run.nextText || null,
+    name,
+    route: routeLine(run, marks, t),
+    turn,
+    rationale,
+    objective,
+    goal: goalShown,
+    info,
+    isInfoExpanded: Boolean(input.isInfoExpanded),
+    // The next step stays in sight where it says something the turn block does not.
+    nextStep: stepRepeats ? null : step,
     unreadableHint,
     origin: t(`origin.${origin}`),
     originKind: origin,
@@ -107,14 +231,18 @@ function eventFields(input, t, naming) {
 // Text fallback for surfaces without Svg: state, gate bar and next step on separate lines.
 export function terminalText(view, { labels, locale }) {
   const t = path => label(labels, locale, path);
-  const lines = [view.title, `${FIGURE_TEXT[view.mood]} ${view.stateLabel}${view.reason ? ` · ${view.reason}` : ''}`];
+  // The turn line says what the reason would; without one the reason stays beside the state.
+  const lines = [view.title, `${view.invite ? INVITE_TEXT : FIGURE_TEXT[view.mood]} ${view.stateLabel}${view.reason && !view.turn ? ` · ${view.reason}` : ''}`];
   if (view.message) lines.push(view.message);
   if (view.hint) lines.push(view.hint);
   if (view.unreadableHint && view.unreadableHint !== view.message) lines.push(view.unreadableHint);
+  if (view.name) lines.push(view.route ? `${view.name} · ${view.route}` : view.name);
+  if (view.goal) lines.push(`${t('fields.objective')}: ${view.goal}`);
+  if (view.turn) lines.push(`${view.turn.who}: ${view.turn.what}${view.turn.how ? ` · ${view.turn.how}` : ''}`);
   if (view.gateBar) lines.push(view.gateBar);
-  if (view.runId) lines.push(view.origin ? `${view.runId} · ${view.origin}` : view.runId);
-  if (view.objective) lines.push(`${t('fields.objective')}: ${view.objective}`);
   if (view.nextStep) lines.push(`${t('fields.nextStep')}: ${view.nextStep}`);
+  // The (i) details appear only once opened; its button is drawn beside this text.
+  if (view.isInfoExpanded) for (const item of view.info ?? []) lines.push(`${item.label}: ${item.text}`);
   for (const warning of view.drift ?? []) lines.push(warning);
   if (view.events) lines.push(`${t('fields.events')}:`, ...view.events);
   if (view.review) {
@@ -123,6 +251,8 @@ export function terminalText(view, { labels, locale }) {
     if (view.review.preview) lines.push(...view.review.preview.split('\n').slice(0, TERMINAL_PREVIEW_LINES).map(line => `  ${line}`));
   }
   if (view.eventsHint) lines.push(view.eventsHint);
+  // The run id is a reference, so it stands after what a person reads.
+  if (view.runId) lines.push(view.origin ? `${view.runId} · ${view.origin}` : view.runId);
   if (view.stale) lines.push(view.stale);
   if (view.readAt) lines.push(view.readAt);
   return lines.join('\n');

package/generated/plugins/agdf/mcp/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agdf/mcp-server",
-  "version": "0.31.0",
+  "version": "0.32.0",
   "description": "Local MCP adapter for version-matched AGDF dispatch and control inspection.",
   "type": "module",
   "files": [
@@ -36,7 +36,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/server": "2.0.0",
-    "create-agdf": "0.31.0"
+    "create-agdf": "0.32.0"
   },
   "devDependencies": {
     "@modelcontextprotocol/client": "2.0.0"

package/generated/plugins/agdf/mcp/server/src/generation-runtime.js

@@ -15,7 +15,7 @@ export function startGenerationRuntime({ epoch, generation, channel }) {
   // Companion events (SD SDD-006): this generation executed the call, so it journals the final result
   // once, before the result leaves; a failing journal never changes or delays the result.
   function journal(name, args, projected) {
-    try { runtime.observeOutcome?.(name, args, projected); } catch { /* notification only */ }
+    try { return runtime.observeOutcome?.(name, args, projected) === true; } catch { return false; /* notification only */ }
   }
   function send(input, kind, payload) {
     const reply = generationMessage(epoch, generation, kind, payload, {}, input.original_operation_id, input.request_id);
@@ -41,6 +41,7 @@ export function startGenerationRuntime({ epoch, generation, channel }) {
           runtime = await createMcpDecisionRuntime({ runtime, ui });
         }
         if (runtime.ui) uiDigest = loadCockpitResource(runtime.ui).digest;
+        if (runtime.mode === 'cockpit' && uiDigest) runtime.bindResourceIdentity({ digest: uiDigest, version: inspected.expectedVersion });
         // Inspect reports package-owned immutable identities, not caller evidence.
         sdkDigest = inspected.generationIdentity.sdk_digest; serverDigest = inspected.generationIdentity.server_digest;
         executor = runtime.mode === 'cockpit' ? null : createAgdfWorkerExecutor(runtime, { releaseOwnedLock: releaseAbandonedOwnedLock });
@@ -68,7 +69,7 @@ export function startGenerationRuntime({ epoch, generation, channel }) {
         ++inflight;
         const parentOwned = typeof tool.parentOwned === 'function' ? tool.parentOwned(args) : tool.parentOwned;
         const started = performance.now();
-        let result, phase = parentOwned || !executor ? 'parse' : 'execute';
+        let result, journaled = false, phase = parentOwned || !executor ? 'parse' : 'execute';
         try {
           phase = 'parse';
           args = runtime.prepareInput?.(name, args) ?? args;
@@ -82,13 +83,14 @@ export function startGenerationRuntime({ epoch, generation, channel }) {
           if (name === 'agdf_inspect' && args.operation === 'operation-status' && result.report?.status === 'recorded'
             && (result.report.receipt?.operation_id ?? result.report.receipt?.operation?.operation_id) === args.module.split('/').at(-1)) unknown.delete(args.module.split('/').at(-1));
           const projected = runtime.projectToolResult(name, args, result);
-          journal(name, args, projected);
+          journaled = journal(name, args, projected);
           send(input, 'result', projected);
         } catch (error) {
           const facts = runtime.normalizeFailure(error, { phase });
           if (input.original_operation_id && facts.dispatch !== 'not_dispatched') unknown.add(input.original_operation_id);
           const projected = runtime.projectToolResult(name, args, runtime.failure(facts.code, name, args, { ...facts, elapsed_ms: performance.now() - started }), facts);
-          journal(name, args, projected);
+          // One call leaves at most one event: a failure after its result left an event adds none.
+          if (!journaled) journal(name, args, projected);
           send(input, 'result', projected);
         } finally { --inflight; }
       }

package/generated/plugins/agdf/mcp/server/src/generation.js

@@ -211,8 +211,9 @@ export async function createOwnedGenerationFacade({ runtime, publisher, createCo
       operations.set(key, row);
     }
     ++row.inflight; event(row, 'invoke', name);
+    let replied;
     try {
-      const result = (await request(row, 'invoke', { name, arguments: args }, actualContext, canonical ? args.operation_id : null, invokeMs)).payload;
+      const result = replied = (await request(row, 'invoke', { name, arguments: args }, actualContext, canonical ? args.operation_id : null, invokeMs)).payload;
       if (canonical && result.outcome === 'effect_unknown') row.unknown.add(key);
       if (name === 'agdf_inspect' && args.operation === 'operation-status' && result.report?.status === 'recorded'
         && (result.report.receipt?.operation_id ?? result.report.receipt?.operation?.operation_id) === id) row.unknown.delete(key);
@@ -228,7 +229,12 @@ export async function createOwnedGenerationFacade({ runtime, publisher, createCo
         }
       }
       return result;
-    } catch (error) { if (canonical && error.dispatch !== 'not_dispatched') row.unknown.add(key); throw error; }
+    } catch (error) {
+      // The generation journaled the reply it sent; a failure raised here afterwards carries it, so the
+      // server adds no second companion event for the same call.
+      if (replied && error && typeof error === 'object') error.generationResult = replied;
+      if (canonical && error.dispatch !== 'not_dispatched') row.unknown.add(key); throw error;
+    }
     finally { --row.inflight; if (closed && !row.inflight && !row.unknown.size) void retire(row, true); }
   }
   current = await reserve(publisher.initial, {}); current.state = 'current'; event(current, 'admitted');

package/generated/plugins/agdf/mcp/server/src/main.js

@@ -41,7 +41,10 @@ export async function runMcpServer({ surface, cockpitDir, cockpitMode, runtime,
     runtime = thin ? await dispatcherRuntime.createMcpDecisionTransportRuntime({ runtime, ui })
       : await dispatcherRuntime.createMcpDecisionRuntime({ runtime, ui });
   }
-  if (runtime.mode === 'cockpit') loadCockpitResource(runtime.ui);
+  if (runtime.mode === 'cockpit') {
+    const resource = loadCockpitResource(runtime.ui);
+    runtime.bindResourceIdentity?.({ digest: resource.digest, version: serverVersion });
+  }
   let transport;
   if (ownedPublication) {
     const { createOwnedGenerationFacade } = await import('./generation.js');