@pellux/goodvibes-tui 1.13.1 → 1.14.0

package/src/panels/fleet-panel.ts

@@ -13,25 +13,18 @@
 
 import { readFile } from 'node:fs/promises';
 import type { Line } from '../types/grid.ts';
-import type { ProcessCostState, ProcessUsage, SteerResult } from '@pellux/goodvibes-sdk/platform/runtime/fleet';
-import { formatWorkItemIsolationDetailFromRaw } from './fleet-panel-worktree-detail.ts';
+import type { SteerResult } from '@pellux/goodvibes-sdk/platform/runtime/fleet';
 import type { ConversationMessageSnapshot } from '@pellux/goodvibes-sdk/platform/core';
 import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
 import { ScrollableListPanel } from './scrollable-list-panel.ts';
 import { PanelConfirmOverlay } from './panel-confirm-overlay.ts';
-import { formatAgentCost } from './agent-inspector-shared.ts';
-import { formatElapsed } from '../utils/format-elapsed.ts';
-import { truncateDisplay } from '../utils/terminal-width.ts';
 import { isPanelSearchBackspace, isPanelSearchCancel, isPanelSearchCommit, isPanelSearchPrintable } from './search-focus.ts';
-import { buildAlignedRow, buildKeyboardHints, buildPanelLine, buildPanelWorkspace, buildSearchInputLine, DEFAULT_PANEL_PALETTE, getPanelWorkspaceContentBudget, type ColumnSpec, type PanelPalette } from './polish.ts';
+import { buildKeyboardHints, buildPanelWorkspace, buildSearchInputLine, DEFAULT_PANEL_PALETTE, getPanelWorkspaceContentBudget, type PanelPalette } from './polish.ts';
 import {
-  fleetKindTag,
-  fleetUsageTokens,
-  hasFleetCost,
+  isBlockedOnUserState,
   isRunningProcessState,
   isTerminalProcessState,
   type FleetReadModel,
-  type FleetStateTone,
   type FleetTreeRow,
 } from './fleet-read-model.ts';
 import {
@@ -46,12 +39,12 @@ import {
   type FleetTabsState,
   type SteerBadge,
 } from './fleet-tabs.ts';
-import { liveSteerableLabels, reconcileSteerBadges as reconcileSteerBadgesPure, renderSteerBadgeLine, steerBadgeGlyph, steerBadgeTone, steerRefusalMessage } from './fleet-steer.ts';
-import { FleetStopTracker, fleetStateDisplay, toggleFleetPause, buildFleetTreeHints, countDescendantStats } from './fleet-stop.ts';
+import { liveSteerableLabels, reconcileSteerBadges as reconcileSteerBadgesPure, renderSteerBadgeLine, steerRefusalMessage } from './fleet-steer.ts';
+import { FleetStopTracker, toggleFleetPause, buildFleetTreeHints, countDescendantStats } from './fleet-stop.ts';
 import { resolveFleetDeepLinkIndex } from './fleet-deep-link.ts';
 import { parseAgentLedger, renderFleetAgentTranscript, renderFleetChainSummary, renderFleetLedgerFallback, renderFleetTranscriptLoading } from './fleet-transcript.ts';
 import { renderFleetTabStrip } from '../renderer/fleet-tab-strip.ts';
-import { planColumns, toneColor, formatFleetTokens, formatFleetCost } from './fleet-panel-format.ts';
+import { renderFleetDetailLines, renderFleetRowLine } from './fleet-panel-format.ts';
 
 const C = DEFAULT_PANEL_PALETTE;
 
@@ -322,6 +315,44 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
     this.clearError(); this.selectedIndex = idx; this.selectedNodeId = target.id; this.markDirty();
   }
 
+  /**
+   * Focus the next node blocked on the operator (awaiting approval/input),
+   * cycling top-to-bottom in display order and wrapping. Always resolves
+   * against the LIVE fleet (blocked nodes never live in the archive), and
+   * returns to the tree view from any attached tab so the reveal is visible —
+   * mirrors receiveDeepLink's "make it visible" contract. Honest no-op with a
+   * message when nothing is currently waiting on the operator. Returns true
+   * (the 'b' key is always consumed by the panel).
+   */
+  private jumpToNextBlocked(): boolean {
+    const snapshot = this.readModel.getSnapshot();
+    const blockedIds = snapshot.blockedNodeIds;
+    if (blockedIds.length === 0) {
+      this.setError('Nothing is blocked on you right now.');
+      this.markDirty();
+      return true;
+    }
+    // Pick the blocked id strictly after the current anchor (wrapping), so
+    // repeated presses cycle through every waiting node. Anchor on whatever row
+    // is actually selected right now (the base class defaults the cursor to
+    // row 0 before any explicit navigation sets selectedNodeId), so the first
+    // press already advances past a blocked node the cursor happens to sit on.
+    const anchorId = this.getSelectedItem()?.node.id ?? this.selectedNodeId;
+    const currentPos = anchorId === null || anchorId === undefined ? -1 : blockedIds.indexOf(anchorId);
+    const nextId = blockedIds[(currentPos + 1) % blockedIds.length]!;
+    // Reveal in the live tree: leave the archive view and any active session tab.
+    this.viewMode = 'active';
+    this.tabsState = { tabs: this.tabsState.tabs, activeTabIndex: 0 };
+    const idx = snapshot.rows.findIndex((row) => row.node.id === nextId);
+    if (idx >= 0) {
+      this.selectedIndex = idx;
+      this.selectedNodeId = nextId;
+    }
+    this.clearError();
+    this.markDirty();
+    return true;
+  }
+
   /**
    * The "dropped inference" reconciliation: called on every read-model
    * snapshot update and on the panel's 1s tick. See fleet-steer.ts's
@@ -376,6 +407,13 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
       return true;
     }
 
+    // Jump-to-blocked works from ANYWHERE in the panel (root tree OR an attached
+    // session tab): it steps to the next node waiting on the operator and
+    // reveals it in the live tree so the selection is actually visible.
+    if (key === 'b') {
+      return this.jumpToNextBlocked();
+    }
+
     if (this.tabsState.activeTabIndex > 0) {
       if (key === 's') {
         return this.tryOpenSteerDraft(activeFleetTab(this.tabsState)!);
@@ -603,35 +641,11 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
   }
 
   protected renderItem(row: FleetTreeRow, _index: number, _selected: boolean, width: number): Line {
-    const node = row.node;
-    // d1: while a stop is in flight, fleetStateDisplay overrides the state
-    // glyph/label/tone with a display-only 'stopping…' so the row never claims
-    // the past-tense outcome before the state has actually flipped.
-    const stopping = this.stopTracker.isStopping(node.id);
-    const disp = fleetStateDisplay(node.state, stopping);
-    const color = toneColor(disp.tone, C);
-    const label = `${row.treePrefix}${node.label}`;
-    const badge = this.steerBadgeForNode(node.id);
-    const activity = stopping
-      ? disp.label
-      : badge
-        ? `${steerBadgeGlyph(badge.status)} ${node.currentActivity?.text ?? ''}`.trimEnd()
-        : (node.currentActivity?.text ?? '');
-    const activityColor = stopping ? color : badge ? steerBadgeTone(badge.status, C) : C.dim;
-
-    return buildAlignedRow(
-      width,
-      [
-        { text: disp.glyph, fg: color },
-        { text: fleetKindTag(node.kind), fg: C.dim },
-        { text: label, fg: C.value },
-        { text: formatElapsed(node.elapsedMs), fg: C.dim },
-        { text: formatFleetTokens(node.usage), fg: C.dim },
-        { text: formatFleetCost(node.costUsd, node.costState), fg: C.value },
-        { text: activity, fg: activityColor },
-      ],
-      planColumns(width),
-    );
+    // Display-only overrides (stopping wins, then blocked-on-user) are derived
+    // here from panel state and passed into the pure row renderer.
+    const stopping = this.stopTracker.isStopping(row.node.id);
+    const blocked = !stopping && isBlockedOnUserState(row.node.state);
+    return renderFleetRowLine(row, width, stopping, blocked, this.steerBadgeForNode(row.node.id), C);
   }
 
   /** A node's steer badge, looked up via its attached tab (if any) — null when the node has no tab or no active/recent steer. */
@@ -641,41 +655,11 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
 
   private renderDetail(row: FleetTreeRow, width: number): Line[] {
     const node = row.node;
-    // d1: mirror the tree row's 'stopping…' override so the literal state text
-    // never claims 'killed' mid-write either.
-    const disp = fleetStateDisplay(node.state, this.stopTracker.isStopping(node.id));
-    const color = toneColor(disp.tone, C);
-
-    const line1 = buildPanelLine(width, [
-      [' ', C.dim],
-      [disp.glyph, color],
-      [` ${node.kind}`, C.dim],
-      ['  id ', C.label],
-      [node.id, C.value],
-      ['  state ', C.label],
-      [disp.label, color],
-      ['  elapsed ', C.label],
-      [formatElapsed(node.elapsedMs), C.value],
-    ]);
-    const line2 = buildPanelLine(width, [
-      [' model ', C.label],
-      [node.model ?? 'unknown', C.info],
-      ['  tokens ', C.label],
-      [formatFleetTokens(node.usage), C.value],
-      ['  cost ', C.label],
-      [formatFleetCost(node.costUsd, node.costState), C.value],
-    ]);
-    const activityText = node.currentActivity
-      ? `${node.currentActivity.kind}: ${node.currentActivity.text}`
-      : '(no recent activity)';
-    const line3 = buildPanelLine(width, [
-      [' activity ', C.label],
-      [truncateDisplay(activityText, Math.max(0, width - 11)), C.dim],
-    ]);
-    // Approval history attaches here once session tabs land.
-    const line4 = buildPanelLine(width, [[' approvals ', C.label], ['—', C.dim]]);
-    const isolationDetail = node.kind === 'work-item' ? formatWorkItemIsolationDetailFromRaw(node.raw) : null;
-    return [line1, line2, line3, line4, ...(isolationDetail ? [buildPanelLine(width, [[' isolation ', C.label], [isolationDetail, C.dim]])] : [])];
+    // Mirror the tree row's display-only overrides (stopping wins, then blocked)
+    // so the detail's literal state text never contradicts the row glyph.
+    const stopping = this.stopTracker.isStopping(node.id);
+    const blocked = !stopping && isBlockedOnUserState(node.state);
+    return renderFleetDetailLines(node, width, stopping, blocked, C);
   }
 
   /** Renders the active session tab's content (transcript / chain summary / ledger fallback) in place of the tree. */
@@ -774,7 +758,10 @@ export class FleetPanel extends ScrollableListPanel<FleetTreeRow> {
     // can actually accept them (most kinds are never interruptible; nothing is
     // killable once terminal), incl. the d2 state-dependent p pause/resume chip.
     // Mirrors the handleInput guards above. See buildFleetTreeHints (fleet-stop.ts).
-    const hints = buildFleetTreeHints(selected?.node, this.follow, this.tabsState.tabs.length > 0, this.viewMode);
+    // Blocked count is always taken from the LIVE fleet (blocked nodes never
+    // live in the archive), so the 'b' jump hint shows even from the archive view.
+    const blockedCount = this.readModel.getSnapshot().blockedNodeIds.length;
+    const hints = buildFleetTreeHints(selected?.node, this.follow, this.tabsState.tabs.length > 0, this.viewMode, blockedCount);
 
     // Tab strip renders only when tabs exist — omitting it entirely with no
     // tabs attached keeps the pre-session-tab root-tree rendering byte-identical.

package/src/panels/fleet-read-model.ts

@@ -63,6 +63,14 @@ export interface FleetSnapshot {
   readonly totalTokens: number | null;
   /** Count of nodes in an actively-working state (see isRunningProcessState). */
   readonly runningCount: number;
+  /**
+   * Ids of the nodes that are "blocked on me" — waiting on a user approval or
+   * user input right now (see isBlockedOnUserState) — in display (row) order.
+   * This is a DERIVED view over the same node states the rows already carry,
+   * never a second source of truth: the panel reads it to badge/jump, it is
+   * not a store. Empty when nothing is waiting on the operator.
+   */
+  readonly blockedNodeIds: readonly string[];
   readonly capturedAt: number;
 }
 
@@ -127,6 +135,17 @@ const STATE_TONES: Record<ProcessState, FleetStateTone> = {
 /** Terminal states — interrupt/kill are not offered; not counted as running. */
 const TERMINAL_STATES = new Set<ProcessState>(['done', 'failed', 'killed', 'interrupted']);
 
+/**
+ * States that mean "this node is waiting on ME right now" — a user approval or
+ * user input. Today the registry derives exactly one such state,
+ * `awaiting-approval` (an agent parked at a permission prompt). This is the
+ * single place that mapping lives, so if the SDK adds a distinct
+ * awaiting-user-input state later it joins here and every "blocked on me"
+ * surface (badge, sort, jump) picks it up for free. Kept as a set for that
+ * forward-compatibility, not because more than one state qualifies today.
+ */
+const BLOCKED_ON_USER_STATES = new Set<ProcessState>(['awaiting-approval']);
+
 /** States representing actively-working nodes (drives runningCount + follow target). */
 const RUNNING_STATES = new Set<ProcessState>([
   'thinking', 'executing-tool', 'awaiting-approval', 'streaming', 'stalled', 'retrying',
@@ -171,6 +190,11 @@ export function isRunningProcessState(state: ProcessState): boolean {
   return RUNNING_STATES.has(state);
 }
 
+/** True when a node is waiting on a user approval or user input right now — "blocked on me". */
+export function isBlockedOnUserState(state: ProcessState): boolean {
+  return BLOCKED_ON_USER_STATES.has(state);
+}
+
 // ---------------------------------------------------------------------------
 // Honest usage/cost helpers (W0.9 convention, ported from agent-inspector-shared.ts)
 // ---------------------------------------------------------------------------
@@ -201,10 +225,53 @@ export function hasFleetCost(costUsd: number | null | undefined, costState: Proc
 // Tree builder — pure, testable (ported tree-walk shape from process-modal.ts)
 // ---------------------------------------------------------------------------
 
-function compareNodes(a: ProcessNode, b: ProcessNode): number {
-  const delta = (a.startedAt ?? Infinity) - (b.startedAt ?? Infinity);
-  if (delta !== 0) return delta;
-  return a.id.localeCompare(b.id);
+/**
+ * Sibling comparator. `blockedSubtree` is the set of node ids whose own subtree
+ * contains a node blocked on the user (see collectBlockedSubtrees) — those
+ * siblings sort to the TOP of their level so a blocked node (and the family
+ * that leads to it) floats up the tree, at every depth, without breaking the
+ * parent/child structure. Ties fall back to startedAt then id, unchanged.
+ */
+function makeCompareNodes(blockedSubtree: ReadonlySet<string>): (a: ProcessNode, b: ProcessNode) => number {
+  return (a, b) => {
+    const aBlocked = blockedSubtree.has(a.id) ? 0 : 1;
+    const bBlocked = blockedSubtree.has(b.id) ? 0 : 1;
+    if (aBlocked !== bBlocked) return aBlocked - bBlocked;
+    const delta = (a.startedAt ?? Infinity) - (b.startedAt ?? Infinity);
+    if (delta !== 0) return delta;
+    return a.id.localeCompare(b.id);
+  };
+}
+
+/**
+ * The set of node ids whose subtree (the node itself or any descendant) holds a
+ * node currently blocked on the user. Post-order DFS with a memo + visiting
+ * guard so a defensive parentId cycle terminates. Drives the blocked-first
+ * sibling ordering; purely derived from the live node states.
+ */
+function collectBlockedSubtrees(
+  nodes: readonly ProcessNode[],
+  childrenByParent: Map<string, ProcessNode[]>,
+): Set<string> {
+  const blocked = new Set<string>();
+  const memo = new Map<string, boolean>();
+  const visiting = new Set<string>();
+  const dfs = (node: ProcessNode): boolean => {
+    const cached = memo.get(node.id);
+    if (cached !== undefined) return cached;
+    if (visiting.has(node.id)) return false; // cycle guard
+    visiting.add(node.id);
+    let has = isBlockedOnUserState(node.state);
+    for (const child of childrenByParent.get(node.id) ?? []) {
+      if (dfs(child)) has = true;
+    }
+    visiting.delete(node.id);
+    memo.set(node.id, has);
+    if (has) blocked.add(node.id);
+    return has;
+  };
+  for (const node of nodes) dfs(node);
+  return blocked;
 }
 
 function appendSubtree(
@@ -215,17 +282,18 @@ function appendSubtree(
   ancestorPrefix: string,
   isLast: boolean,
   visited: Set<string>,
+  compare: (a: ProcessNode, b: ProcessNode) => number,
 ): void {
   if (visited.has(node.id)) return; // cycle guard
   visited.add(node.id);
 
-  const children = (childrenByParent.get(node.id) ?? []).slice().sort(compareNodes);
+  const children = (childrenByParent.get(node.id) ?? []).slice().sort(compare);
   const treePrefix = depth === 0 ? '' : `${ancestorPrefix}${isLast ? '└─ ' : '├─ '}`;
   rows.push({ node, depth, treePrefix, isLastChild: isLast, hasChildren: children.length > 0 });
 
   const descendantPrefix = depth === 0 ? '' : `${ancestorPrefix}${isLast ? '   ' : '│  '}`;
   children.forEach((child, index) => {
-    appendSubtree(rows, child, childrenByParent, depth + 1, descendantPrefix, index === children.length - 1, visited);
+    appendSubtree(rows, child, childrenByParent, depth + 1, descendantPrefix, index === children.length - 1, visited, compare);
   });
 }
 
@@ -254,18 +322,24 @@ export function buildFleetRows(nodes: readonly ProcessNode[]): FleetTreeRow[] {
     }
   }
 
+  // Blocked-on-user nodes (and the families that lead to them) float to the top
+  // at every level — see makeCompareNodes / collectBlockedSubtrees. Derived from
+  // the live node states on this same pass; never a stored flag.
+  const blockedSubtree = collectBlockedSubtrees(nodes, childrenByParent);
+  const compare = makeCompareNodes(blockedSubtree);
+
   const rows: FleetTreeRow[] = [];
   const visited = new Set<string>();
 
-  for (const root of roots.slice().sort(compareNodes)) {
-    appendSubtree(rows, root, childrenByParent, 0, '', true, visited);
+  for (const root of roots.slice().sort(compare)) {
+    appendSubtree(rows, root, childrenByParent, 0, '', true, visited, compare);
   }
 
   // Defensive: nodes never reached because their entire ancestor chain forms
   // a cycle with no true root. Walked as pseudo-roots so they still render.
-  const leftovers = nodes.filter((n) => !visited.has(n.id)).sort(compareNodes);
+  const leftovers = nodes.filter((n) => !visited.has(n.id)).sort(compare);
   for (const node of leftovers) {
-    appendSubtree(rows, node, childrenByParent, 0, '', true, visited);
+    appendSubtree(rows, node, childrenByParent, 0, '', true, visited, compare);
   }
 
   return rows;
@@ -381,7 +455,13 @@ export function buildFleetSnapshot(nodes: readonly ProcessNode[], capturedAt: nu
     if (isFleetRunningLeaf(node)) runningCount++;
   }
 
-  return { rows, totalCost, totalTokens, runningCount, capturedAt };
+  // Blocked ids in display (row) order so the panel's jump key steps through
+  // them top-to-bottom exactly as they appear on screen.
+  const blockedNodeIds = rows
+    .filter((row) => isBlockedOnUserState(row.node.state))
+    .map((row) => row.node.id);
+
+  return { rows, totalCost, totalTokens, runningCount, blockedNodeIds, capturedAt };
 }
 
 /**

package/src/panels/fleet-stop.ts

@@ -14,6 +14,8 @@ import { fleetStateGlyph, fleetStateTone, isTerminalProcessState, type FleetStat
 export const STOP_SETTLE_MS = 1500;
 /** Display-only glyph for a node with an in-flight stop request. Verified free against STATE_GLYPHS (fleet-read-model.ts) and width-1 like its ⊘/⊟ siblings. */
 export const STOPPING_GLYPH = '⊗';
+/** Display-only glyph for a node blocked on the user (awaiting your approval/input). Verified free against STATE_GLYPHS + STOPPING_GLYPH and width-1. */
+export const BLOCKED_GLYPH = '⚑';
 
 /**
  * Tracks node ids the operator just asked to stop (kill/interrupt/pause) mapped
@@ -54,10 +56,18 @@ export interface FleetStateDisplay {
   readonly tone: FleetStateTone;
 }
 
-export function fleetStateDisplay(state: ProcessState, stopping: boolean): FleetStateDisplay {
-  return stopping
-    ? { glyph: STOPPING_GLYPH, label: 'stopping…', tone: 'warn' }
-    : { glyph: fleetStateGlyph(state), label: state, tone: fleetStateTone(state) };
+/**
+ * Glyph/label/tone for a row, applying two display-only overrides in priority
+ * order: an in-flight stop ('stopping…') wins first (a node the operator just
+ * asked to stop is no longer meaningfully "blocked on you"), then a
+ * blocked-on-user node gets the distinct ⚑ badge + 'blocked on you' label so it
+ * reads as needing the operator, not as an anonymous 'awaiting-approval'. Both
+ * are display-only; neither is a ProcessState.
+ */
+export function fleetStateDisplay(state: ProcessState, stopping: boolean, blocked = false): FleetStateDisplay {
+  if (stopping) return { glyph: STOPPING_GLYPH, label: 'stopping…', tone: 'warn' };
+  if (blocked) return { glyph: BLOCKED_GLYPH, label: 'blocked on you', tone: 'warn' };
+  return { glyph: fleetStateGlyph(state), label: state, tone: fleetStateTone(state) };
 }
 
 /** The narrow action + side-effect surface `toggleFleetPause` needs from FleetPanel. */
@@ -109,6 +119,7 @@ export function buildFleetTreeHints(
   follow: boolean,
   hasTabs: boolean,
   viewMode: 'active' | 'archived' = 'active',
+  blockedCount = 0,
 ): FleetHint[] {
   const live = selected !== undefined && !isTerminalProcessState(selected.state);
   const isPaused = selected !== undefined && selected.state === 'paused';
@@ -116,6 +127,10 @@ export function buildFleetTreeHints(
     { keys: 'j/k', label: 'navigate' },
     { keys: 'Enter', label: 'attach' },
   ];
+  // Jump-to-blocked is offered whenever something is waiting on the operator,
+  // in either view (the blocked nodes live in the active fleet, and the jump
+  // switches back to it) — so it is placed before the view-specific branch.
+  if (blockedCount > 0) hints.push({ keys: 'b', label: `blocked (${blockedCount})` });
   if (viewMode === 'archived') {
     // Archive view: restore + return to the live fleet; nothing here is live,
     // so the live-only control hints (s/i/K/p) never apply.

package/src/panels/modals/memory-modal.ts

@@ -6,6 +6,7 @@ import type {
   ConfigModalTab,
   ConfigModalView,
 } from '../../input/config-modal-types.ts';
+import { memoryRecordTemporalStatus } from '@pellux/goodvibes-sdk/platform/state';
 
 // ---------------------------------------------------------------------------
 // Memory → config-modal surface (W6.1 group-B port). Two tabs: 'All Records'
@@ -44,9 +45,17 @@ interface MemoryRecordLike {
   readonly reviewedBy?: string | undefined;
   readonly createdAt: number;
   readonly updatedAt?: number | undefined;
+  readonly validFrom?: number | undefined;
+  readonly validUntil?: number | undefined;
   readonly provenance: readonly { readonly kind: string; readonly ref: string }[];
 }
 
+/** Compact `[pending]`/`[expired]` suffix for a record row; empty for 'active' (no window, or currently inside it). */
+function temporalSuffix(record: Pick<MemoryRecordLike, 'validFrom' | 'validUntil'>): string {
+  const status = memoryRecordTemporalStatus(record);
+  return status === 'active' ? '' : ` [${status}]`;
+}
+
 export interface MemoryModalDeps {
   readonly memoryRegistry?: {
     honestSearch(filter?: { limit?: number }): Promise<{
@@ -140,7 +149,7 @@ class MemoryModalSurface implements ConfigModalSurface {
   private allTab(): ConfigModalTab {
     const rows: ConfigModalRow[] = this.allRecords.map((record) => ({
       id: record.id,
-      label: `[${record.scope.slice(0, 1).toUpperCase()}/${record.cls.slice(0, 3).toUpperCase()}] ${record.id.slice(-8)}  ${fmtTime(record.createdAt)}  ${record.summary}${record.tags.length > 0 ? `  #${record.tags.join(' #')}` : ''}`,
+      label: `[${record.scope.slice(0, 1).toUpperCase()}/${record.cls.slice(0, 3).toUpperCase()}] ${record.id.slice(-8)}  ${fmtTime(record.createdAt)}  ${record.summary}${record.tags.length > 0 ? `  #${record.tags.join(' #')}` : ''}${temporalSuffix(record)}`,
     }));
     return {
       id: 'all',
@@ -155,7 +164,7 @@ class MemoryModalSurface implements ConfigModalSurface {
   private reviewTab(): ConfigModalTab {
     const rows: ConfigModalRow[] = this.reviewRecords.map((record) => ({
       id: record.id,
-      label: `${record.reviewState.padEnd(13)} ${String(record.confidence).padStart(3)}%  ${record.summary}${record.staleReason ? `  (stale: ${record.staleReason})` : ''}`,
+      label: `${record.reviewState.padEnd(13)} ${String(record.confidence).padStart(3)}%  ${record.summary}${record.staleReason ? `  (stale: ${record.staleReason})` : ''}${temporalSuffix(record)}`,
     }));
     return {
       id: 'review',

package/src/permissions/hunk-selection.ts

@@ -1,4 +1,4 @@
-import type { PermissionPromptRequest } from '@pellux/goodvibes-sdk/platform/permissions';
+import type { PermissionAttribution, PermissionPromptRequest } from '@pellux/goodvibes-sdk/platform/permissions';
 
 /**
  * Per-hunk accept/reject at the approval gate (W1.3 v1).
@@ -158,22 +158,103 @@ export function buildModifiedEditArgs(
   return { ...request.args, edits: filtered };
 }
 
+/** Narrow approval-broker surface needed to attribute a prompt to its requester. */
+export interface ApprovalRequesterLookup {
+  listApprovals(limit?: number): ReadonlyArray<{
+    readonly callId: string;
+    readonly sessionId?: string | undefined;
+    readonly metadata: Record<string, unknown>;
+  }>;
+}
+
+/**
+ * Human label for a `mcp-server` or `sandbox-escalation` attribution — the two
+ * non-agent origins the approval broker can name (see PermissionAttribution in
+ * the SDK). `background-agent` deliberately falls through to the
+ * broker-metadata lookup below instead, which resolves a richer label
+ * (agentId/session) than the attribution alone carries.
+ */
+function describeNonAgentAttribution(attribution: PermissionAttribution): string | null {
+  switch (attribution.kind) {
+    case 'mcp-server':
+      return `MCP server: ${attribution.serverName}`;
+    case 'sandbox-escalation':
+      return `${attribution.sandbox} wants: ${attribution.escalations.join(', ')}`;
+    default:
+      return null;
+  }
+}
+
+/**
+ * Human label for WHICH agent/process/server/sandbox raised this approval.
+ *
+ * Prefers the request's own typed `attribution` (see PermissionAttribution)
+ * for the `mcp-server` and `sandbox-escalation` origins, since those carry
+ * structured data (which server, which escalations) no broker-metadata scan
+ * can reconstruct. For `background-agent` (and when no attribution is
+ * present), falls back to the approval broker by callId (the broker record
+ * for a request exists by the time its local prompt is shown), preferring an
+ * explicit requester recorded in the broker record's metadata (agentId /
+ * agent / requestedBy / actor / actorSurface), then the owning session id.
+ * Returns null when nothing identifying is available — the prompt then omits
+ * the attribution line rather than guessing a name.
+ */
+export function resolveApprovalRequester(
+  broker: ApprovalRequesterLookup | null | undefined,
+  callId: string,
+  attribution?: PermissionAttribution | undefined,
+): string | null {
+  if (attribution && attribution.kind !== 'background-agent') {
+    const described = describeNonAgentAttribution(attribution);
+    if (described) return described;
+  }
+  if (!broker) return null;
+  let record: { readonly sessionId?: string | undefined; readonly metadata: Record<string, unknown> } | undefined;
+  try {
+    record = broker.listApprovals().find((r) => r.callId === callId);
+  } catch {
+    return null;
+  }
+  if (!record) return null;
+  const meta = record.metadata ?? {};
+  for (const key of ['agentId', 'agent', 'requestedBy', 'actor', 'actorSurface'] as const) {
+    const value = meta[key];
+    if (typeof value === 'string' && value.trim().length > 0) return value.trim();
+  }
+  if (typeof record.sessionId === 'string' && record.sessionId.length > 0) {
+    return `session ${record.sessionId.slice(0, 8)}`;
+  }
+  return null;
+}
+
 /**
  * buildPendingPermissionExtras — the `hunkState` + wrapped `resolve` fields
- * main.ts spreads onto its PendingPermissionState alongside `...request`.
- * Bundled into one helper (rather than inlined in main.ts) to keep main.ts's
- * net line count at zero for this change — main.ts sits at the 800-line
- * architecture cap and must never grow it.
+ * (plus the input-debounce timestamp and requester attribution) main.ts spreads
+ * onto its PendingPermissionState alongside `...request`. Bundled into one
+ * helper (rather than inlined in main.ts) to keep main.ts's net line count at
+ * zero for this change — main.ts sits at the 800-line architecture cap and must
+ * never grow it.
+ *
+ * `openedAt` is the moment the prompt appeared; the blocking-input handler uses
+ * it to swallow typed-ahead keystrokes for a short settle window so buffered
+ * text cannot answer a prompt the user has not seen yet. `requestedBy` is the
+ * requester attribution resolved from the broker (see resolveApprovalRequester).
  */
 export function buildPendingPermissionExtras(
   request: PermissionPromptRequest,
   resolvePromise: (decision: PermissionPromptDecisionWithModifiedArgs) => void,
+  broker?: ApprovalRequesterLookup | null,
+  now: number = Date.now(),
 ): {
   hunkState: HunkSelectionState | undefined;
   resolve: (approved: boolean, remember?: boolean, modifiedArgs?: Record<string, unknown>) => void;
+  openedAt: number;
+  requestedBy: string | undefined;
 } {
   return {
     hunkState: isHunkSelectable(request) ? buildHunkSelectionState(request) : undefined,
     resolve: (approved, remember = false, modifiedArgs) => resolvePromise({ approved, remember, modifiedArgs }),
+    openedAt: now,
+    requestedBy: resolveApprovalRequester(broker, request.callId, request.attribution) ?? undefined,
   };
 }