@pellux/goodvibes-tui 1.16.1 → 1.18.0

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

@@ -0,0 +1,161 @@
+import { MODAL_TONES } from './modal-theme.ts';
+import { infoRow } from './modal-surface-helpers.ts';
+import type {
+  ConfigModalActionContext,
+  ConfigModalRow,
+  ConfigModalSurface,
+  ConfigModalView,
+} from '../../input/config-modal-types.ts';
+import type { MintedPairingToken, PublicPairingToken } from '@pellux/goodvibes-sdk/platform/pairing';
+import { formatDeviceLine, shortTokenId } from '../../core/pairing-devices.ts';
+
+// ---------------------------------------------------------------------------
+// Paired Devices — the settings security-domain device/token management surface.
+// Lists every per-device pairing token (name · created · last-seen · id) and
+// mirrors the pairing.tokens.* gateway verbs: revoke a device, migrate off the
+// legacy shared token, revoke the shared token. Rename needs a name, which the
+// stable-layout modal cannot capture inline, so it routes to the /devices rename
+// command with the row's id pre-filled in the guidance. buildView reads list()
+// fresh every render, so a revoke/migrate reflects immediately.
+// ---------------------------------------------------------------------------
+
+/** The token-store capability this surface needs — satisfied by PairingTokenManager. */
+export interface DevicesModalPairingTokens {
+  list(): PublicPairingToken[];
+  rename(id: string, name: string): boolean;
+  revoke(id: string): boolean;
+  mintForMigration(input: { readonly name: string }): MintedPairingToken;
+  isLegacyRevoked(): boolean;
+  revokeLegacyShared(): void;
+}
+
+export interface DevicesModalDeps {
+  readonly pairingTokens: DevicesModalPairingTokens;
+  /** Injectable clock so last-seen formatting is deterministic in tests. */
+  readonly now?: () => number;
+  readonly copyToClipboard?: (text: string) => void;
+}
+
+const DEVICE_ROW_PREFIX = 'device:';
+
+function deviceIdOf(row: ConfigModalRow | null): string | null {
+  return row && row.id.startsWith(DEVICE_ROW_PREFIX) ? row.id.slice(DEVICE_ROW_PREFIX.length) : null;
+}
+
+class DevicesModalSurface implements ConfigModalSurface {
+  readonly name = 'devices-modal';
+  readonly title = 'Paired Devices';
+  private requestRender: () => void = () => {};
+
+  constructor(private readonly deps: DevicesModalDeps) {}
+
+  readonly actions = [
+    { key: 'r', id: 'rename', label: 'rename', enabledFor: (row: ConfigModalRow | null) => deviceIdOf(row) !== null },
+    { key: 'x', id: 'revoke', label: 'revoke', confirm: true, enabledFor: (row: ConfigModalRow | null) => deviceIdOf(row) !== null },
+    { key: 'm', id: 'migrateShared', label: 'migrate off shared token' },
+    { key: 's', id: 'revokeShared', label: 'revoke shared token', confirm: true, enabledFor: () => !this.deps.pairingTokens.isLegacyRevoked() },
+  ];
+
+  onOpen(requestRender: () => void): void { this.requestRender = requestRender; }
+
+  buildView(): ConfigModalView {
+    const now = this.deps.now?.() ?? Date.now();
+    const tokens = this.deps.pairingTokens.list();
+    const rows: ConfigModalRow[] = [];
+    rows.push(infoRow('intro', 'Devices paired to this daemon. Each has its own token — revoke one without affecting the others.', { dim: true }));
+
+    if (tokens.length === 0) {
+      rows.push(infoRow('empty', 'No devices paired yet — run /pair (or open the pairing QR) to add one.'));
+    } else {
+      for (const token of tokens) {
+        rows.push({ id: `${DEVICE_ROW_PREFIX}${token.id}`, label: formatDeviceLine(token, now) });
+      }
+    }
+
+    const legacyRevoked = this.deps.pairingTokens.isLegacyRevoked();
+    rows.push(infoRow(
+      'legacy',
+      legacyRevoked
+        ? 'Legacy shared token: revoked.'
+        : 'Legacy shared token: active — migrate a device off it (m), then revoke it (s).',
+      legacyRevoked ? { dim: true } : { fg: MODAL_TONES.reasoning },
+    ));
+
+    return {
+      title: 'Paired Devices',
+      tabs: [{ id: 'devices', label: 'Devices', rows, hints: ['r rename', 'x revoke', 'm migrate off shared', 's revoke shared'] }],
+    };
+  }
+
+  onAction(id: string, ctx: ConfigModalActionContext): void {
+    const tokens = this.deps.pairingTokens;
+
+    if (id === 'rename') {
+      const deviceId = deviceIdOf(ctx.row);
+      if (!deviceId) { ctx.setStatus('Select a device row first.'); return; }
+      // The stable-layout modal cannot capture a name inline — route to the
+      // command with the id pre-filled so the user only types the new name.
+      ctx.print(`To rename this device, run:  /devices rename ${shortTokenId(deviceId)} <new name>`);
+      return;
+    }
+
+    if (id === 'revoke') {
+      const deviceId = deviceIdOf(ctx.row);
+      if (!deviceId) { ctx.setStatus('Select a device row first.'); return; }
+      const record = tokens.list().find((t) => t.id === deviceId);
+      const revoked = tokens.revoke(deviceId);
+      ctx.setStatus(revoked ? `Revoked "${record?.name ?? shortTokenId(deviceId)}" — its token stops working now.` : 'That device was already absent.');
+      this.requestRender();
+      return;
+    }
+
+    if (id === 'migrateShared') {
+      const minted = tokens.mintForMigration({ name: 'migrated device' });
+      if (this.deps.copyToClipboard) {
+        this.deps.copyToClipboard(minted.token);
+        ctx.print(`Minted "${minted.name}" and copied its one-time token to the clipboard. Pair the device, then revoke the shared token (s).`);
+      } else {
+        ctx.print(`Minted "${minted.name}" (one-time token): ${minted.token}\nPair the device with it, then revoke the shared token (s).`);
+      }
+      this.requestRender();
+      return;
+    }
+
+    if (id === 'revokeShared') {
+      if (tokens.isLegacyRevoked()) { ctx.setStatus('The legacy shared token is already revoked.'); return; }
+      tokens.revokeLegacyShared();
+      ctx.setStatus('Revoked the legacy shared token — devices on it must re-pair with their own token.');
+      this.requestRender();
+      return;
+    }
+  }
+}
+
+export function createDevicesModalSurface(deps: DevicesModalDeps): ConfigModalSurface {
+  return new DevicesModalSurface(deps);
+}
+
+/**
+ * Deterministic golden/render fixture: frozen token list + clock so last-seen
+ * formatting is stable.
+ */
+export function devicesModalGoldenSurface(): ConfigModalSurface {
+  const now = Date.UTC(2026, 6, 13, 12, 0, 0);
+  const tokens: PublicPairingToken[] = [
+    { id: 'aaaa1111bbbb2222', name: 'my laptop', createdAt: Date.UTC(2026, 6, 10, 9, 0, 0), lastSeenAt: now - 3 * 60_000 },
+    { id: 'cccc3333dddd4444', name: 'kitchen tablet', createdAt: Date.UTC(2026, 6, 1, 9, 0, 0), lastSeenAt: now - 5 * 60 * 60_000 },
+    { id: 'eeee5555ffff6666', name: 'phone (never scanned)', createdAt: Date.UTC(2026, 6, 13, 8, 0, 0) },
+  ];
+  let legacyRevoked = false;
+  return createDevicesModalSurface({
+    now: () => now,
+    pairingTokens: {
+      list: () => tokens,
+      rename: () => true,
+      revoke: () => true,
+      mintForMigration: () => ({ id: 'new', name: 'migrated device', token: 'tok', createdAt: now }),
+      isLegacyRevoked: () => legacyRevoked,
+      revokeLegacyShared: () => { legacyRevoked = true; },
+    },
+  });
+}

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

@@ -16,7 +16,7 @@ import type {
 } from '../../input/config-modal-types.ts';
 
 // ---------------------------------------------------------------------------
-// Hooks → config-modal surface (W6.1 group-B port). Two tabs: 'Hooks' (active
+// Hooks → config-modal surface (group-B port). Two tabs: 'Hooks' (active
 // registrations + contract posture) and 'Activity' (recent runtime activity +
 // managed authoring + last simulation — the panel's expand-activity view, now a
 // dedicated tab). All sources are in-memory (dispatcher/workbench/tracker hold

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

@@ -9,7 +9,7 @@ import type {
 import { KeybindingsManager } from '../../input/keybindings.ts';
 
 // ---------------------------------------------------------------------------
-// Docs + Shortcuts → 'keybindings' config-modal surface (W6.1 group-B port).
+// Docs + Shortcuts → 'keybindings' config-modal surface (group-B port).
 // A MERGE of the retired DocsPanel (tools/models/shortcuts) and the
 // shortcuts-overlay reference. Three tabs: 'Tools', 'Models', and 'Shortcuts'
 // (the categorized keyboard reference — driven live off keybindingsManager so
@@ -112,7 +112,7 @@ class KeybindingsModalSurface implements ConfigModalSurface {
     if (id === 'refresh') { ctx.setStatus('Docs & shortcuts are read live.'); ctx.requestRender(); return; }
     if (id !== 'activate') return;
     if (ctx.tabId === 'tools') {
-      // DEBT-5 item 4: pass the tool name through as a deep-link target.
+      // item 4: pass the tool name through as a deep-link target.
       // Honest caveat (documented, not a bug to silently paper over): fleet's
       // ProcessKind set has no 'tool' node — a docs Tools row names a static
       // tool DEFINITION, not a live process, so FleetPanel.receiveDeepLink

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

@@ -9,7 +9,7 @@ import type {
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 
 // ---------------------------------------------------------------------------
-// Knowledge (graph) → config-modal surface (W6.1 group-B port). Two tabs:
+// Knowledge (graph) → config-modal surface (group-B port). Two tabs:
 // 'Browse' (sources/nodes/issues + schedules) and 'Review' (the open-issue
 // queue) — the panel's browse/review toggle, now host tabs. Issue review
 // mutations (accept/reject/resolve/reopen) route to the `/knowledge

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

@@ -38,14 +38,14 @@ interface MarketplaceRow {
 const KINDS: readonly EcosystemEntryKind[] = ['plugin', 'skill', 'hook-pack', 'policy-pack'];
 
 /**
- * Marketplace → config-modal surface (W6.1 group-B port). Local-first
+ * Marketplace → config-modal surface (group-B port). Local-first
  * publish/import catalog (NOT a remote store) with provenance, compatibility,
  * and install posture. Disk catalog loads happen in refresh() (never in
  * buildView), mirroring the panel's explicit render()/refresh() split.
  * Install/uninstall route to the `/marketplace` command path (charter: no
  * destructive confirm folded into a modal).
  *
- * B30 (honest empty-state): the panel's original "No curated marketplace
+ * Honest empty-state: the panel's original "No curated marketplace
  * entries found yet." copy implied a curated remote catalog. It isn't one —
  * loadEcosystemCatalog only ever reads .goodvibes/ecosystem/<kind>s.json under
  * the project/home, populated solely by `/marketplace publish` and
@@ -118,7 +118,7 @@ class MarketplaceModalSurface implements ConfigModalSurface {
     const snapshot = this.deps.readModel?.getSnapshot();
     const rows: ConfigModalRow[] = [];
 
-    // Honest empty / degraded state (B30). loadError → degraded banner.
+    // Honest empty / degraded state. loadError → degraded banner.
     if (this.loadError) {
       return { title: 'Marketplace', degraded: this.loadError, tabs: [{ id: 'catalog', label: 'Catalog', rows: [] }] };
     }
@@ -205,7 +205,7 @@ export function createMarketplaceModalSurface(deps: MarketplaceModalDeps): Confi
  * Deterministic golden fixture: catalog roots wired at a fresh tmp path that is
  * removed immediately (loadEcosystemCatalog/listInstalledEcosystemEntries guard
  * missing paths with existsSync → [], so refresh() finds nothing and renders the
- * B30 honest empty-state copy). The random tmp path never appears in the
+ * honest empty-state copy). The random tmp path never appears in the
  * rendered lines (the empty-state copy is static), so the golden is byte-stable.
  */
 export function marketplaceModalGoldenSurface(): ConfigModalSurface {

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

@@ -7,9 +7,11 @@ import type {
   ConfigModalView,
 } from '../../input/config-modal-types.ts';
 import { memoryRecordTemporalStatus } from '@pellux/goodvibes-sdk/platform/state';
+import type { MemoryConsolidationGatewayResolution, MemoryConsolidationProposal } from '../memory-consolidation-gateway.ts';
+import { classifyConsolidationFetchError } from '../memory-consolidation-gateway.ts';
 
 // ---------------------------------------------------------------------------
-// Memory → config-modal surface (W6.1 group-B port). Two tabs: 'All Records'
+// Memory → config-modal surface (group-B port). Two tabs: 'All Records'
 // (the full record list) and 'Review Queue' (the operator review queue) — the
 // same split the panel toggled with Tab, now real host tabs. Review-state
 // mutations (reviewed/stale/contradicted/fresh) and record delete route to the
@@ -63,8 +65,23 @@ export interface MemoryModalDeps {
       readonly indexUnavailableReason?: string | null | undefined;
     }>;
   };
+  /**
+   * Resolve the memory-consolidation-receipts gateway (memory-consolidation-gateway.ts),
+   * lazily — called fresh each time the Proposals tab (re)fetches, exactly like
+   * the Fleet panel's `resolveGateway` (fleet-gateway.ts / fleet-acts.ts). Absent
+   * in a session with no daemon-backed control plane wired: the Proposals tab
+   * then renders its "unavailable" honest state without ever attempting a fetch.
+   */
+  readonly resolveConsolidationGateway?: () => MemoryConsolidationGatewayResolution;
 }
 
+/** The Proposals tab's fetch state — one honest rendering per state, never a blend. */
+type ProposalsStatus =
+  | { readonly kind: 'loading' }
+  | { readonly kind: 'unavailable'; readonly reason: string }
+  | { readonly kind: 'error'; readonly message: string }
+  | { readonly kind: 'ready'; readonly proposals: readonly MemoryConsolidationProposal[] };
+
 /**
  * Client-side port of the SDK's MemoryStore.reviewQueue ranking
  * (memory-store-helpers.ts reviewQueueScore/isReviewCandidate): all four
@@ -104,11 +121,14 @@ class MemoryModalSurface implements ConfigModalSurface {
   private reviewRecords: MemoryRecordLike[] = [];
   /** Honest note on the last read: a wire failure (client mode) or the index-unavailable fallback reason — never silently dropped. */
   private loadNote: string | null = null;
+  /** The Proposals tab's fetch state — starts 'loading' whenever a gateway is wired (see refreshProposals). */
+  private proposalsStatus: ProposalsStatus = { kind: 'loading' };
   private requestRender: (() => void) | null = null;
 
   constructor(private readonly deps: MemoryModalDeps) {}
 
   private readonly reviewGate = (row: ConfigModalRow | null, tabId: string): boolean => tabId === 'review' && row !== null;
+  private readonly proposalsGate = (row: ConfigModalRow | null, tabId: string): boolean => tabId === 'proposals' && row !== null;
 
   readonly actions = [
     { key: 'enter', id: 'markReviewed', label: 'reviewed', enabledFor: this.reviewGate },
@@ -117,6 +137,13 @@ class MemoryModalSurface implements ConfigModalSurface {
     { key: 'f', id: 'markFresh', label: 'fresh', enabledFor: this.reviewGate },
     { key: 'd', id: 'remove', label: 'delete', enabledFor: (row: ConfigModalRow | null) => row !== null },
     { key: 'r', id: 'refresh', label: 'refresh' },
+    // Jump from a selected proposal to one of its affected records in the
+    // Review Queue tab. A DISTINCT key from 'enter' (not shared with
+    // markReviewed): ConfigModal.resolveAction matches the FIRST action bound
+    // to a key and returns null if THAT one's enabledFor fails, rather than
+    // trying the next action bound to the same key — so gating two different
+    // 'enter' actions by tabId alone would silently break one of them.
+    { key: 'v', id: 'jumpToReviewQueue', label: 'view in review queue', enabledFor: this.proposalsGate },
   ];
 
   onOpen(requestRender: () => void): void {
@@ -129,6 +156,10 @@ class MemoryModalSurface implements ConfigModalSurface {
   }
 
   private async refresh(): Promise<void> {
+    await Promise.all([this.refreshRecords(), this.refreshProposals()]);
+  }
+
+  private async refreshRecords(): Promise<void> {
     if (!this.deps.memoryRegistry) { this.allRecords = []; this.reviewRecords = []; this.loadNote = null; return; }
     try {
       const result = await this.deps.memoryRegistry.honestSearch({ limit: 100 });
@@ -142,10 +173,50 @@ class MemoryModalSurface implements ConfigModalSurface {
     this.requestRender?.();
   }
 
+  /**
+   * Lazy fetch of memory.consolidation.receipts (memory-consolidation-gateway.ts)
+   * — only attempted when this surface opens or refreshes, never polled. No
+   * gateway resolver wired at all (session has no daemon-backed control
+   * plane) renders the same honest "unavailable" state as a resolved-but-
+   * refused gateway (daemon disabled / no control-plane URL) or a 501/404
+   * from an older daemon with no consolidation scheduler — three different
+   * causes, one bucket, because from the operator's seat they mean the same
+   * thing: nothing to show, and no fault of theirs.
+   */
+  private async refreshProposals(): Promise<void> {
+    if (!this.deps.resolveConsolidationGateway) {
+      this.proposalsStatus = { kind: 'unavailable', reason: 'No consolidation gateway wired for this session.' };
+      return;
+    }
+    this.proposalsStatus = { kind: 'loading' };
+    this.requestRender?.();
+    const resolution = this.deps.resolveConsolidationGateway();
+    if (!resolution.available) {
+      this.proposalsStatus = { kind: 'unavailable', reason: resolution.reason };
+      return;
+    }
+    try {
+      const result = await resolution.gateway.fetchReceipts();
+      this.proposalsStatus = { kind: 'ready', proposals: result.pendingProposals };
+    } catch (error) {
+      this.proposalsStatus = classifyConsolidationFetchError(error);
+    }
+  }
+
   private recordFrom(id: string): MemoryRecordLike | undefined {
     return this.allRecords.find((r) => r.id === id) ?? this.reviewRecords.find((r) => r.id === id);
   }
 
+  /** First pending proposal that names a given record id, keyed for the Review Queue's reason correlation (item 3). */
+  private proposalsByRecordId(): Map<string, MemoryConsolidationProposal> {
+    const map = new Map<string, MemoryConsolidationProposal>();
+    if (this.proposalsStatus.kind !== 'ready') return map;
+    for (const proposal of this.proposalsStatus.proposals) {
+      for (const id of proposal.ids) if (!map.has(id)) map.set(id, proposal);
+    }
+    return map;
+  }
+
   private allTab(): ConfigModalTab {
     const rows: ConfigModalRow[] = this.allRecords.map((record) => ({
       id: record.id,
@@ -162,10 +233,25 @@ 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})` : ''}${temporalSuffix(record)}`,
-    }));
+    const proposalByRecord = this.proposalsByRecordId();
+    const rows: ConfigModalRow[] = this.reviewRecords.map((record) => {
+      // A contradiction proposal already carries its reason on the record
+      // itself (the daemon sets reviewState 'contradicted' + staleReason); a
+      // cross-scope-duplicate proposal marks the record 'fresh' with NO
+      // staleReason, so without this correlation those rows are bare and
+      // unexplained (item 3) — fall back to the fetched proposal's own
+      // reason only when the record didn't already carry one.
+      const proposal = record.staleReason ? undefined : proposalByRecord.get(record.id);
+      const reasonSuffix = record.staleReason
+        ? `  (stale: ${record.staleReason})`
+        : proposal
+          ? `  (${proposal.kind}: ${proposal.reason})`
+          : '';
+      return {
+        id: record.id,
+        label: `${record.reviewState.padEnd(13)} ${String(record.confidence).padStart(3)}%  ${record.summary}${reasonSuffix}${temporalSuffix(record)}`,
+      };
+    });
     return {
       id: 'review',
       label: 'Review Queue',
@@ -176,6 +262,40 @@ class MemoryModalSurface implements ConfigModalSurface {
     };
   }
 
+  /**
+   * The Proposals tab — WHAT the daemon's idle-time consolidation pass
+   * proposed (contradiction / cross-scope-duplicate / stale-delete) and is
+   * holding for human judgment, read lazily over memory.consolidation.receipts
+   * (memory-consolidation-gateway.ts). Three distinct honest states render as
+   * three distinct lines — 'loading' / 'unavailable' / 'error' never collapse
+   * into a shared "nothing to show" — plus the true empty state ('ready' with
+   * zero proposals) which is a fourth, equally honest line.
+   */
+  private proposalsTab(): ConfigModalTab {
+    const status = this.proposalsStatus;
+    const header = [`pending proposals ${status.kind === 'ready' ? status.proposals.length : 0}`];
+    if (status.kind === 'loading') {
+      return { id: 'proposals', label: 'Proposals', header, rows: [], emptyText: 'Loading pending proposals…' };
+    }
+    if (status.kind === 'unavailable') {
+      return { id: 'proposals', label: 'Proposals', header, rows: [], emptyText: `Pending proposals unavailable: ${status.reason}` };
+    }
+    if (status.kind === 'error') {
+      return { id: 'proposals', label: 'Proposals', header, rows: [], emptyText: `Could not fetch pending proposals: ${status.message}` };
+    }
+    const rows: ConfigModalRow[] = status.proposals.map((proposal, index) => ({
+      id: `proposal:${index}`,
+      label: `[${proposal.kind}] ${proposal.reason}  — ${proposal.ids.length} record${proposal.ids.length === 1 ? '' : 's'}: ${proposal.ids.join(', ')}`,
+    }));
+    return {
+      id: 'proposals',
+      label: 'Proposals',
+      header,
+      rows,
+      emptyText: 'No pending proposals — nothing awaiting judgment right now.',
+    };
+  }
+
   buildView(): ConfigModalView {
     if (!this.deps.memoryRegistry) {
       return {
@@ -187,12 +307,13 @@ class MemoryModalSurface implements ConfigModalSurface {
     return {
       title: 'Memory',
       ...(this.loadNote ? { degraded: this.loadNote } : {}),
-      tabs: [this.allTab(), this.reviewTab()],
+      tabs: [this.allTab(), this.reviewTab(), this.proposalsTab()],
     };
   }
 
   onAction(id: string, ctx: ConfigModalActionContext): void {
     if (id === 'refresh') { void this.refresh(); ctx.setStatus('Reloading memory records...'); return; }
+    if (id === 'jumpToReviewQueue') { this.handleJumpToReviewQueue(ctx); return; }
     const record = ctx.row ? this.recordFrom(ctx.row.id) : undefined;
     if (!record) return;
     const review = (state: string, confidence: number, reason?: string): void => {
@@ -209,6 +330,29 @@ class MemoryModalSurface implements ConfigModalSurface {
       case 'remove': void ctx.executeCommand?.('recall', ['remove', record.id]); ctx.setStatus(`Dispatched /recall remove ${record.id}.`); break;
     }
   }
+
+  /**
+   * The Proposals tab's "jump": move to the Review Queue tab with one of the
+   * selected proposal's affected records selected — the same host mechanism
+   * (`ctx.jumpToRow`) any future in-surface jump would use. A proposal's
+   * `ids` are not guaranteed to all be inside the review queue's top-24
+   * window, so this picks the first id that IS present there rather than
+   * assuming the first id always is; when none are, it says so honestly
+   * instead of jumping nowhere and leaving the user to wonder why.
+   */
+  private handleJumpToReviewQueue(ctx: ConfigModalActionContext): void {
+    if (this.proposalsStatus.kind !== 'ready' || !ctx.row) return;
+    const index = Number(ctx.row.id.slice('proposal:'.length));
+    const proposal = this.proposalsStatus.proposals[index];
+    if (!proposal) return;
+    const target = proposal.ids.find((id) => this.reviewRecords.some((r) => r.id === id));
+    if (!target) {
+      ctx.setStatus(`None of this proposal's ${proposal.ids.length} record(s) are in the current review-queue window.`);
+      return;
+    }
+    ctx.jumpToRow?.('review', target);
+    ctx.setStatus(`Jumped to ${target} in the Review Queue.`);
+  }
 }
 
 export function createMemoryModalSurface(deps: MemoryModalDeps): ConfigModalSurface {
@@ -227,9 +371,9 @@ export async function memoryModalGoldenSurface(): Promise<ConfigModalSurface> {
   const records: readonly MemoryRecordLike[] = [
     {
       id: 'mem-0000001a', scope: 'project', cls: 'decision',
-      summary: 'Wave-6 batches panel retirements behind modal builders.',
-      detail: 'Applies to KNOWLEDGE, MEMORY, WORK-PLAN in WO-B.',
-      tags: ['wave-6', 'modals'], reviewState: 'reviewed', confidence: 90,
+      summary: 'Panel retirements are batched behind modal builders.',
+      detail: 'Applies to the knowledge, memory, and work-plan modals.',
+      tags: ['panels', 'modals'], reviewState: 'reviewed', confidence: 90,
       reviewedAt: FIXED_CREATED_AT + 3600000, reviewedBy: 'operator', createdAt: FIXED_CREATED_AT,
       provenance: [{ kind: 'session', ref: 'session-fixed-1' }],
     },

package/src/panels/modals/modal-surface-helpers.ts

@@ -3,7 +3,7 @@ import type { ModalSectionStyle } from '../../renderer/modal-factory.ts';
 import type { ConfigModalRow } from '../../input/config-modal-types.ts';
 
 /**
- * Shared formatting helpers for W6.1 config-modal surfaces. Row styling reuses
+ * Shared formatting helpers for config-modal surfaces. Row styling reuses
  * DEFAULT_PANEL_PALETTE (the retired panels' palette) so a migrated modal reads
  * as the same surface it replaced — the goldens stay panel-consistent.
  */

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

@@ -1,7 +1,7 @@
 import { activeUiTones, registerThemeRefresh } from '../../renderer/theme.ts';
 
 // ---------------------------------------------------------------------------
-// Semantic tone tokens for the W6.1 group-B config modals.
+// Semantic tone tokens for the group-B config modals.
 //
 // Derived entirely from the chrome token set so the builders carry NO raw hex
 // color literals (architecture: no-raw-hex-literal-growth). Rebuilt IN PLACE