@pellux/goodvibes-tui 1.13.0 → 1.14.0

package/src/input/commands/recall-files.ts

@@ -0,0 +1,185 @@
+/**
+ * recall-files.ts — `/recall files sync|review|apply`, the git-backed markdown
+ * projection surface for standing (project/team-scope) memory records.
+ *
+ * Round-trip:
+ *   sync   — project store records to `<dir>/<id>.md`, git-commit the directory
+ *            when it sits inside a repo. Read-only against the store.
+ *   review — diff the on-disk projection against the current store and print
+ *            the resulting proposals (a file edit -> 'update', a deleted file
+ *            for an in-scope record -> 'delete'). PURE — no store writes.
+ *   apply  — re-diff fresh, then mutate the store ONLY for the proposal ids
+ *            the caller explicitly names (or --all), through the memory spine
+ *            client's own update/delete. Never a silent write.
+ *
+ * `apply` re-diffs on every call rather than caching `review`'s output, so it
+ * always acts on the current on-disk/store state and never on a stale
+ * snapshot from an earlier `review` call.
+ *
+ * Routes through `getMemorySpine` (not the host-only `knowledgeApi.memory`)
+ * per the SDK's memory-wire-full-detach decision — same as every other
+ * mutating `/recall` subcommand, so this fully detaches from the local store
+ * file when a daemon has been adopted.
+ *
+ * The memory spine's wire `MemoryUpdatePatch` (SDK platform/runtime/memory-spine)
+ * now carries validFrom/validUntil alongside scope/summary/detail/tags — a
+ * number sets the bound, `null` clears it, and an omitted field leaves it
+ * unchanged — so a proposal whose `desired` changes ONLY the temporal window
+ * applies for real over the wire, the same as any other field change.
+ */
+import { existsSync } from 'node:fs';
+import type { CommandContext } from '../command-registry.ts';
+import {
+  diffProjectionToProposals,
+  projectMemoryToFiles,
+  readProjectedMemoryFiles,
+  type MemoryProjectionProposal,
+} from '@pellux/goodvibes-sdk/platform/state';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { requireShellPaths } from './runtime-services.ts';
+import { getMemorySpine } from './recall-query.ts';
+import { readMemoryProjectionDir } from './recall-files-config.ts';
+import { resolveSyncGitSeam } from './recall-files-git.ts';
+
+const PROJECTION_LIST_LIMIT = 5000;
+
+/** Resolve the projection directory: an explicit --dir argument wins, else the configured setting. */
+function resolveProjectionDir(args: string[], context: CommandContext): string {
+  const shellPaths = requireShellPaths(context);
+  const dirIdx = args.indexOf('--dir');
+  const explicit = dirIdx !== -1 ? args[dirIdx + 1] : undefined;
+  const configured = readMemoryProjectionDir(context.platform.configManager);
+  return shellPaths.resolveWorkspacePath(explicit || configured);
+}
+
+export async function handleRecallFilesSync(args: string[], context: CommandContext): Promise<void> {
+  const memory = getMemorySpine(context);
+  if (!memory) return;
+
+  const dir = resolveProjectionDir(args, context);
+  const records = await memory.list({ limit: PROJECTION_LIST_LIMIT });
+  // Resolve the git seam from the project working directory, not `dir` itself
+  // — `dir` may not exist yet on a first sync, and `git -C <dir>` requires the
+  // directory to already exist. The working directory is always real.
+  const gitSeam = resolveSyncGitSeam(requireShellPaths(context).workingDirectory);
+
+  try {
+    const report = projectMemoryToFiles(records, dir, gitSeam ? { git: gitSeam.seam } : {});
+    context.print(`[recall] Projected ${report.written.length} record(s) to ${report.dir}`);
+    if (gitSeam) {
+      context.print(report.committed ? `  committed in ${gitSeam.repoRoot}` : '  not committed (git seam did not run)');
+    } else {
+      context.print(`  not committed: ${dir} is not inside a git repository`);
+    }
+  } catch (error) {
+    context.print(`[recall] Projection sync failed: ${summarizeError(error)}`);
+  }
+}
+
+/** Compute the current proposals for `dir` against the live store. Returns null (already printed) when the directory doesn't exist yet. */
+async function computeProposals(
+  dir: string,
+  context: CommandContext,
+): Promise<MemoryProjectionProposal[] | null> {
+  const memory = getMemorySpine(context);
+  if (!memory) return null;
+  if (!existsSync(dir)) {
+    context.print(`[recall] No projection directory at ${dir}. Run /recall files sync first.`);
+    return null;
+  }
+  const records = await memory.list({ limit: PROJECTION_LIST_LIMIT });
+  const files = readProjectedMemoryFiles(dir);
+  return diffProjectionToProposals(records, files);
+}
+
+function printProposal(context: CommandContext, proposal: MemoryProjectionProposal): void {
+  context.print(`  ${proposal.id} [${proposal.kind}] ${proposal.reason}`);
+  if (proposal.kind === 'update' && proposal.changedFields && proposal.changedFields.length > 0) {
+    context.print(`    changed: ${proposal.changedFields.join(', ')}`);
+  }
+}
+
+export async function handleRecallFilesReview(args: string[], context: CommandContext): Promise<void> {
+  const dir = resolveProjectionDir(args, context);
+  const proposals = await computeProposals(dir, context);
+  if (proposals === null) return;
+
+  if (proposals.length === 0) {
+    context.print(`[recall] No changes — ${dir} matches the store.`);
+    return;
+  }
+  context.print(`[recall] ${proposals.length} proposal(s) from ${dir}:`);
+  for (const proposal of proposals) printProposal(context, proposal);
+  context.print('[recall] Nothing has been applied. Run /recall files apply <id> [<id> ...] | --all to confirm.');
+}
+
+export async function handleRecallFilesApply(args: string[], context: CommandContext): Promise<void> {
+  const memory = getMemorySpine(context);
+  if (!memory) return;
+
+  const applyAll = args.includes('--all') || args.includes('all');
+  const ids = new Set(args.filter((a) => a !== '--all' && a !== 'all' && a !== '--dir' && !a.startsWith('.') && !a.startsWith('/')));
+  // --dir's value (the token right after it) is not a proposal id — drop it.
+  const dirIdx = args.indexOf('--dir');
+  if (dirIdx !== -1 && args[dirIdx + 1]) ids.delete(args[dirIdx + 1]!);
+
+  if (!applyAll && ids.size === 0) {
+    context.print('[recall] Usage: /recall files apply <id> [<id> ...] | --all [--dir <path>]');
+    context.print('[recall] Run /recall files review first to see the current proposal ids.');
+    return;
+  }
+
+  const dir = resolveProjectionDir(args, context);
+  const proposals = await computeProposals(dir, context);
+  if (proposals === null) return;
+
+  const targeted = applyAll ? proposals : proposals.filter((p) => ids.has(p.id));
+  if (targeted.length === 0) {
+    context.print('[recall] No matching proposals. Run /recall files review to see the current list.');
+    return;
+  }
+  const targetedIds = new Set(targeted.map((p) => p.id));
+
+  const applied: MemoryProjectionProposal[] = [];
+  const skipped: MemoryProjectionProposal[] = [];
+  const failed: { proposal: MemoryProjectionProposal; reason: string }[] = [];
+
+  for (const proposal of proposals) {
+    if (!targetedIds.has(proposal.id)) {
+      skipped.push(proposal);
+      continue;
+    }
+    try {
+      if (proposal.kind === 'delete') {
+        const ok = await memory.delete(proposal.id);
+        if (ok) applied.push(proposal);
+        else failed.push({ proposal, reason: 'store delete returned false (record already gone?)' });
+        continue;
+      }
+      const desired = proposal.desired ?? {};
+      const patch: {
+        scope?: typeof desired.scope;
+        summary?: string;
+        detail?: string;
+        tags?: string[];
+        validFrom?: number | null;
+        validUntil?: number | null;
+      } = {};
+      if (desired.scope !== undefined) patch.scope = desired.scope;
+      if (desired.summary !== undefined) patch.summary = desired.summary;
+      if (desired.detail !== undefined) patch.detail = desired.detail;
+      if (desired.tags !== undefined) patch.tags = [...desired.tags];
+      if (desired.validFrom !== undefined) patch.validFrom = desired.validFrom;
+      if (desired.validUntil !== undefined) patch.validUntil = desired.validUntil;
+      const result = await memory.update(proposal.id, patch);
+      if (result) applied.push(proposal);
+      else failed.push({ proposal, reason: 'store update returned null (record not found?)' });
+    } catch (error) {
+      failed.push({ proposal, reason: summarizeError(error) });
+    }
+  }
+
+  context.print(`[recall] Applied ${applied.length}, skipped ${skipped.length}, failed ${failed.length}.`);
+  for (const proposal of applied) context.print(`  applied  ${proposal.id} [${proposal.kind}]`);
+  for (const { proposal, reason } of failed) context.print(`  failed   ${proposal.id} [${proposal.kind}] — ${reason}`);
+}

package/src/input/commands/recall-query.ts

@@ -2,7 +2,7 @@ import type { CommandContext } from '../command-registry.ts';
 import type { MemoryApi } from '@pellux/goodvibes-sdk/platform/knowledge';
 import type { MemorySpineClient } from '@pellux/goodvibes-sdk/platform/runtime/memory-spine';
 import type { MemorySearchFilter } from '@pellux/goodvibes-sdk/platform/state';
-import { VALID_CLASSES, VALID_SCOPES, isValidClass, isValidScope } from './recall-shared.ts';
+import { VALID_CLASSES, VALID_SCOPES, isValidClass, isValidScope, temporalStatusLabel } from './recall-shared.ts';
 
 /**
  * The local, host-only `MemoryApi` — kept for `/recall explain` and `/recall
@@ -93,7 +93,7 @@ export async function handleRecallSearch(args: string[], context: CommandContext
     const ts = new Date(record.createdAt).toISOString().slice(0, 16).replace('T', ' ');
     const tagStr = record.tags.length ? ` [${record.tags.join(', ')}]` : '';
     const scoreStr = semanticEntry ? `  sim ${Math.round(semanticEntry.similarity * 100)}%` : '';
-    context.print(`  ${record.id}  [${record.cls}]${tagStr}  ${ts}${scoreStr}`);
+    context.print(`  ${record.id}  [${record.cls}]${tagStr}  ${ts}${scoreStr}${temporalStatusLabel(record)}`);
     context.print(`    ${record.summary}`);
     if (record.provenance.length) {
       context.print(`    via: ${record.provenance.map((entry) => `${entry.kind}:${entry.ref}`).join(', ')}`);
@@ -159,6 +159,11 @@ export async function handleRecallGet(args: string[], context: CommandContext):
   if (record.detail) context.print(`  Detail:  ${record.detail}`);
   if (record.tags.length) context.print(`  Tags:    ${record.tags.join(', ')}`);
   context.print(`  Created: ${ts}`);
+  if (record.validFrom !== undefined || record.validUntil !== undefined) {
+    const from = record.validFrom !== undefined ? new Date(record.validFrom).toISOString().slice(0, 19).replace('T', ' ') : '(none)';
+    const until = record.validUntil !== undefined ? new Date(record.validUntil).toISOString().slice(0, 19).replace('T', ' ') : '(none)';
+    context.print(`  Temporal: ${from} -> ${until}${temporalStatusLabel(record)}`);
+  }
 
   if (record.provenance.length) {
     context.print('  Provenance:');
@@ -249,7 +254,7 @@ export async function handleRecallList(args: string[], context: CommandContext):
     context.print(`\n[recall] ${clsName.toUpperCase()} (${group.length}):`);
     for (const record of group) {
       const tagStr = record.tags.length ? ` [${record.tags.join(', ')}]` : '';
-      context.print(`  ${record.id} [${record.scope}]${tagStr}  ${record.summary}`);
+      context.print(`  ${record.id} [${record.scope}]${tagStr}  ${record.summary}${temporalStatusLabel(record)}`);
     }
   }
 }

package/src/input/commands/recall-review.ts

@@ -1,5 +1,5 @@
 import type { CommandContext } from '../command-registry.ts';
-import { VALID_REVIEW_STATES, VALID_SCOPES, isValidReviewState, isValidScope } from './recall-shared.ts';
+import { VALID_REVIEW_STATES, VALID_SCOPES, isValidReviewState, isValidScope, temporalStatusLabel } from './recall-shared.ts';
 import { getMemoryApi, getMemorySpine } from './recall-query.ts';
 import { buildMainSessionTurnInjectionsText, buildTurnInjectionsText } from '../../renderer/turn-injection.ts';
 
@@ -41,7 +41,7 @@ export async function handleRecallQueue(args: string[], context: CommandContext)
   context.print(`[recall] Review queue (${queue.length}):`);
   for (const record of queue) {
     const reason = record.staleReason ? ` — ${record.staleReason}` : '';
-    context.print(`  ${record.id} [${record.scope}/${record.cls}] ${record.reviewState} ${record.confidence}%  ${record.summary}${reason}`);
+    context.print(`  ${record.id} [${record.scope}/${record.cls}] ${record.reviewState} ${record.confidence}%  ${record.summary}${reason}${temporalStatusLabel(record)}`);
   }
 }
 

package/src/input/commands/recall-shared.ts

@@ -1,5 +1,6 @@
 import type { ShellPathService } from '@/runtime/index.ts';
 import type { MemoryClass, MemoryReviewState, MemoryScope } from '@pellux/goodvibes-sdk/platform/state';
+import { memoryRecordTemporalStatus } from '@pellux/goodvibes-sdk/platform/state';
 
 export const VALID_CLASSES: MemoryClass[] = ['decision', 'constraint', 'incident', 'pattern', 'fact', 'risk', 'runbook', 'architecture', 'ownership'];
 export const VALID_SCOPES: MemoryScope[] = ['session', 'project', 'team'];
@@ -20,3 +21,15 @@ export function isValidReviewState(s: string): s is MemoryReviewState {
 export function resolveBundlePath(pathArg: string, shellPaths: ShellPathService): string {
   return shellPaths.resolveWorkspacePath(pathArg);
 }
+
+/**
+ * Compact inline label for a record's temporal validity window — appended
+ * wherever `/recall` lists records, so an out-of-window record is visibly
+ * `[pending]`/`[expired]` rather than silently indistinguishable from an
+ * always-valid one. Empty string for 'active' (the common case; no window,
+ * or currently inside it) so normal listings stay unnoisy.
+ */
+export function temporalStatusLabel(record: { validFrom?: number | undefined; validUntil?: number | undefined }, now?: number): string {
+  const status = memoryRecordTemporalStatus(record, now);
+  return status === 'active' ? '' : ` [${status}]`;
+}

package/src/input/commands/relay-runtime.ts

@@ -0,0 +1,86 @@
+import type { CommandContext } from '../command-registry.ts';
+import type { CommandRegistry } from '../command-registry.ts';
+import { generateQrMatrix, renderQrToString } from '@pellux/goodvibes-sdk/platform/pairing';
+
+/**
+ * Register the /relay command — reachability status and QR-encodable pairing
+ * for the SDK's outbound zero-knowledge relay (relay.* settings, gated by the
+ * `relay-connect` feature flag). The live registration state lives only in
+ * the running daemon's memory (`DaemonServer.getRelayReachability()`), reached
+ * here through `ctx.platform.externalServices` — see relay-reachability-bridge.ts.
+ */
+
+function relayConfigured(ctx: CommandContext): { enabled: boolean; url: string; rendezvousId: string; label: string; flagOn: boolean } {
+  const config = ctx.platform.configManager;
+  return {
+    enabled: config.get('relay.enabled') === true,
+    url: String(config.get('relay.url') ?? ''),
+    rendezvousId: String(config.get('relay.rendezvousId') ?? ''),
+    label: String(config.get('relay.label') ?? ''),
+    flagOn: ctx.platform.featureFlagManager?.isEnabled('relay-connect') ?? false,
+  };
+}
+
+async function renderStatus(ctx: CommandContext): Promise<void> {
+  const cfg = relayConfigured(ctx);
+  if (!cfg.enabled || !cfg.flagOn) {
+    ctx.print([
+      'Relay: disabled',
+      `  relay.enabled: ${cfg.enabled ? 'yes' : 'no'}`,
+      `  relay-connect flag: ${cfg.flagOn ? 'on' : 'off'}`,
+      '  Both must be on for outbound relay reachability. See /config relay.',
+    ].join('\n'));
+    return;
+  }
+  const live = ctx.platform.externalServices?.relayStatus() ?? 'disabled';
+  const state = live === 'registered' ? 'registered' : live === 'disabled' ? 'disabled' : 'offline';
+  ctx.print([
+    `Relay: ${state}`,
+    `  rendezvous id: ${cfg.rendezvousId || '(not yet minted — start the daemon to generate one)'}`,
+    `  url: ${cfg.url || '(not set)'}`,
+    `  label: ${cfg.label || '(not set)'}`,
+    `  live connection state: ${live}`,
+    '  The relay operator sees only ciphertext and connection metadata — self-host your own relay for full control.',
+  ].join('\n'));
+}
+
+async function renderPair(ctx: CommandContext): Promise<void> {
+  const cfg = relayConfigured(ctx);
+  if (!cfg.enabled || !cfg.flagOn) {
+    ctx.print('Relay is disabled — enable relay.enabled and the relay-connect feature flag first (see /config relay, /flags).');
+    return;
+  }
+  const externalServices = ctx.platform.externalServices;
+  if (!externalServices) {
+    ctx.print('Relay pairing is unavailable: background service controller is not running in this build.');
+    return;
+  }
+  const minted = await externalServices.mintRelayPairing();
+  if (!minted) {
+    ctx.print('Could not mint a relay pairing payload — the relay connection may not be registered yet. Check /relay status.');
+    return;
+  }
+  const qrMatrix = generateQrMatrix(minted.encoded);
+  ctx.print([
+    'Relay pairing payload (scan with a companion app, or copy the string below):',
+    '',
+    minted.encoded,
+    '',
+    renderQrToString(qrMatrix),
+  ].join('\n'));
+}
+
+export function registerRelayRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'relay',
+    description: 'Outbound relay reachability status, or mint a QR-encodable pairing payload',
+    usage: '[status|pair]',
+    argsHint: '[status|pair]',
+    async handler(args, ctx) {
+      const sub = args[0]?.toLowerCase();
+      if (sub === 'pair') return renderPair(ctx);
+      if (sub === undefined || sub === 'status') return renderStatus(ctx);
+      ctx.print(`Unknown /relay subcommand: ${sub}. Use: status | pair`);
+    },
+  });
+}

package/src/input/commands/review-runtime.ts

@@ -0,0 +1,160 @@
+import type { CommandContext, CommandRegistry } from '../command-registry.ts';
+import type { DiffReviewPanel } from '../../panels/diff-review-panel.ts';
+import type { ReviewHunk } from '../../panels/diff-review-model.ts';
+import { hunkPatchText, buildHunkRevertReceiptBlock } from '../../panels/diff-review-model.ts';
+import { requirePanelManager } from './runtime-services.ts';
+
+/** checkpoints.revertHunkPreview result — the read-only clean-or-conflict check plus a confirm token. */
+interface RevertHunkPreview {
+  readonly applies: boolean;
+  readonly conflict: string | null;
+  readonly addedLinesRemoved: number;
+  readonly removedLinesRestored: number;
+  readonly token: string | null;
+}
+
+/** checkpoints.revertHunk result — one applied hunk revert, or a confirmation refusal. */
+interface RevertHunkResult {
+  readonly receipt: {
+    readonly path: string;
+    readonly hunkHeader: string;
+    readonly addedLinesRemoved: number;
+    readonly removedLinesRestored: number;
+    readonly safetyCheckpointId: string | null;
+  } | null;
+  readonly refused: boolean;
+  readonly refusal: { readonly reason: string } | null;
+}
+
+const INVOKE_CONTEXT = { context: { clientKind: 'tui' as const } };
+
+/** True for the honest 409 the revert verb throws when the hunk drifted since it was captured. */
+function isConflict(err: unknown): boolean {
+  return typeof err === 'object' && err !== null && (err as { status?: unknown }).status === 409;
+}
+
+function errorText(err: unknown): string {
+  return err instanceof Error ? err.message : String(err);
+}
+
+/**
+ * Reject one hunk: checkpoints.revertHunkPreview (read-only clean check + token)
+ * → DiffPanel confirm of exactly what reverts → checkpoints.revertHunk with that
+ * token. A stale hunk is an honest "changed since captured" with a refresh, never
+ * a partial write; a success renders the HUNK_REVERTED receipt into the transcript
+ * and refreshes the review panel so the reverted hunk disappears from the diff.
+ */
+async function revertHunkFlow(ctx: CommandContext, panel: DiffReviewPanel, hunk: ReviewHunk): Promise<void> {
+  const gateway = ctx.workspace.gatewayMethods;
+  if (!gateway || !ctx.workspace.workspaceCheckpointManager) {
+    panel.note('Hunk revert unavailable: the checkpoint/gateway surface is not wired in this session.');
+    return;
+  }
+  const path = hunk.filePath;
+  const hunkText = hunkPatchText(hunk);
+  const sessionId = ctx.session.runtime.sessionId;
+
+  let preview: RevertHunkPreview;
+  try {
+    preview = (await gateway.invoke('checkpoints.revertHunkPreview', { ...INVOKE_CONTEXT, body: { path, hunk: hunkText } })) as RevertHunkPreview;
+  } catch (err) {
+    panel.note(`Could not check this hunk: ${errorText(err)}`);
+    return;
+  }
+
+  if (!preview.applies || !preview.token) {
+    panel.note(`Cannot revert — ${preview.conflict ?? 'this hunk no longer applies'}. The file changed since this diff was captured; press r again after /review reloads. Nothing was changed.`);
+    await panel.refresh();
+    return;
+  }
+
+  const { DiffPanel } = await import('../../panels/diff-panel.ts');
+  const pm = requirePanelManager(ctx);
+  let diff = pm.getAllOpen().find((p) => p.id === 'diff');
+  if (!diff) {
+    try { diff = pm.open('diff'); } catch { panel.note('Could not open the diff panel to confirm the revert.'); return; }
+  }
+  pm.activateById('diff');
+  if (!pm.isVisible()) pm.show();
+  ctx.focusPanels?.();
+  const diffPanel = diff as InstanceType<typeof DiffPanel>;
+  diffPanel.showDiff(path, hunkText);
+
+  const summary = `restore ${preview.removedLinesRestored} deleted / drop ${preview.addedLinesRemoved} added line(s)`;
+  diffPanel.confirmOverlay.arm({
+    id: `${path}:${hunk.header}`,
+    label: `Revert hunk in ${path} — ${summary}`,
+    verb: 'Revert',
+    onConfirm: async () => {
+      let result: RevertHunkResult;
+      try {
+        result = (await gateway.invoke('checkpoints.revertHunk', { ...INVOKE_CONTEXT, body: { path, hunk: hunkText, confirmToken: preview.token, sessionId } })) as RevertHunkResult;
+      } catch (err) {
+        pm.close('diff');
+        ctx.focusPanels?.();
+        if (isConflict(err)) {
+          panel.note(`Not reverted — ${errorText(err)}. The file changed since captured; nothing was written. Reloading /review…`);
+          await panel.refresh();
+        } else {
+          panel.note(`Revert failed: ${errorText(err)}`);
+        }
+        return;
+      }
+      pm.close('diff');
+      ctx.focusPanels?.();
+      const receipt = result.receipt;
+      if (!receipt) {
+        panel.note(`Revert not applied: ${result.refusal?.reason ?? 'confirmation was refused.'}`);
+        return;
+      }
+      ctx.session.conversationManager.addTypedSystemMessage(buildHunkRevertReceiptBlock(receipt), 'operational');
+      await panel.refresh();
+    },
+    onCancel: () => {
+      pm.close('diff');
+      ctx.focusPanels?.();
+      panel.note('Revert cancelled — nothing changed.');
+    },
+  });
+  ctx.renderRequest();
+}
+
+/**
+ * `/review` — open the comment-on-hunk review loop. Loads this session's file
+ * changes (the files the SDK SessionChangeTracker recorded) as a git working-
+ * tree diff, hunk-boundaried, and wires the panel's steering submit path to the
+ * session so an attached comment is sent to the model as a steering message with
+ * structured context (file path, line range, patch excerpt). A hunk can also be
+ * rejected: `r` reverse-applies exactly that one hunk via checkpoints.revertHunk
+ * (preview + confirm), a working-tree change recorded as a [Revert] receipt.
+ */
+export function registerReviewRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'review',
+    aliases: [],
+    description: 'Review this session\'s diff hunk-by-hunk, steer comments, or revert a hunk',
+    async handler(_args, ctx) {
+      const pm = requirePanelManager(ctx);
+      let panel = pm.getAllOpen().find((p) => p.id === 'review');
+      if (!panel) {
+        try {
+          panel = pm.open('review');
+        } catch {
+          ctx.print('Could not open the review panel.');
+          return;
+        }
+      }
+      pm.activateById('review');
+      if (!pm.isVisible()) pm.show();
+
+      const reviewPanel = panel as DiffReviewPanel;
+      if (ctx.submitInput) {
+        reviewPanel.setSubmit((text) => ctx.submitInput!(text));
+      }
+      reviewPanel.setRevertHandler((hunk) => { void revertHunkFlow(ctx, reviewPanel, hunk); });
+      await reviewPanel.loadSessionReview();
+      ctx.focusPanels?.();
+      ctx.renderRequest();
+    },
+  });
+}