@erichll/pi-auto-review 0.8.2 → 0.10.0

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # Changelog
 
+## 0.10.0 - 2026-08-22
+
+- Replace the review footer and newly appended transcript entries with one
+  above-editor `pi-auto-review` widget. Each permission check independently
+  replaces the previous display, shows the configured reviewer model while it
+  runs, and updates in place with its final outcome and metadata. The latest
+  result remains until the next check and is cleared on session change or
+  shutdown.
+- Prevent late concurrent completions and permission decisions from overwriting
+  a newer check. A current local denial adds `Local confirmation · denied` to
+  that result only. Widget failures fall back to notifications without changing
+  authorization behavior.
+- Remove tool-call grouping, timers, capacity eviction, and tool/turn flush
+  wiring for new feedback while retaining the historical entry renderer. Bound
+  target and rationale text with visible ellipses, preserve width-aware wrapping,
+  and keep token, duration, and call-count numbers in the normal metadata color.
+
+## 0.9.0 - 2026-08-22
+
+- Require `@gotgenes/pi-permission-system` `^27.0.0` and register through the
+  session-keyed `getPermissionsService(sessionId)` locator. Repeated ready
+  broadcasts are idempotent; session changes, shutdown, and late asynchronous
+  imports cannot retain or revive a stale authorizer registration. In-process
+  child nodes register against their own service without replacing the
+  parent's process-local broker capability.
+- Group local TUI review results by `(sessionId, toolCallId)` into one
+  transcript entry while preserving independent asks, model calls, verdicts,
+  grants, confirmations, and audit records. Denials flush immediately; tool
+  start, terminal permission denial, turn/agent/session end, a 60-second TTL,
+  and bounded-capacity eviction provide lossless fallback flushes. Forwarded,
+  uncorrelated, and non-TUI reviews remain immediate.
+- Add `toolCallId` to each `pi_auto_review_decision` audit entry and retain
+  compatibility rendering for historical single-result transcript entries.
+- Remove the review entry's left quote bar and combine each target with its
+  rationale and member surface/outcome on one line, keeping model/token/duration
+  metadata separate.
+- Label every displayed model token count with `toks` in both grouped and
+  single-result output.
+
 ## 0.8.2 - 2026-08-21
 
 - Structure interactive review results as headline, target, rationale, and a

package/README.md

@@ -16,7 +16,7 @@ that dependency is a hard prerequisite (see [Install and enable](#install-and-en
 > **Prerequisite:** pi-auto-review is an authorizer inside
 > `@gotgenes/pi-permission-system`. Pi does not auto-install peer packages, so
 > install the permission system separately (once per machine) before this
-> extension:
+> extension. Version 0.10.0 requires permission-system 27.x:
 
 ```bash
 pi install npm:@gotgenes/pi-permission-system
@@ -49,7 +49,7 @@ adapters must consume the exact grant before retrying an operation. Changing
 the command, path, resolved path, destination, cwd, agent, or tool input
 invalidates that grant.
 
-Permission-system v24 downgrades authorizer allows on `path` and
+Permission-system downgrades authorizer allows on `path` and
 `external_directory` to `defer`. In an interactive TUI,
 `autoConfirmBoundedAllows` can bind the exact model allow to the immediately
 following recognized permission dialog. The bridge is request-ID-bound,
@@ -132,13 +132,20 @@ only a fixed, budget-checked schema correction.
 
 ## Operator feedback and exact retry
 
-Interactive sessions show a best-effort footer while review is running and a
-structured result row for allow, local confirmation, defer, deny, or circuit
-breaker outcomes. In the TUI this is a quote-style entry (`│`, muted quote
-color) that separates the outcome and surface from the target and rationale,
-then shows the reviewer model name (without provider prefix), input/output
-tokens, and duration when a model call ran. UI delivery never changes the
-authorization result.
+Interactive sessions show the current permission check in a single widget
+above the editor. Each check first shows its surface, compact target, and the
+dynamically configured reviewer model, then replaces that content in place
+with the outcome, target and rationale, model, token usage, duration, and any
+extra call count. A new check replaces the previous result; the latest result
+remains visible until then and is cleared when the session changes or shuts
+down. Concurrent older checks cannot overwrite the most recently started one.
+
+Every request still has its own model call, verdict, grant, local confirmation,
+and audit record. No new review-result transcript entries are written. Existing
+`pi-auto-review` entries in historical sessions remain renderable. Non-TUI
+modes retain best-effort notifications, and a failed TUI widget update falls
+back to the same notification path. UI delivery never changes the authorization
+result.
 
 In an interactive TUI, `/auto-review-approve` lists up to ten recent
 non-critical model denials from the current session. Selecting one asks the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@erichll/pi-auto-review",
-  "version": "0.8.2",
+  "version": "0.10.0",
   "description": "Model-backed boundary approval broker for Pi",
   "type": "module",
   "license": "MIT",
@@ -49,12 +49,12 @@
   "peerDependencies": {
     "@earendil-works/pi-ai": "^0.84.1",
     "@earendil-works/pi-coding-agent": "^0.84.1",
-    "@gotgenes/pi-permission-system": "^26.0.0"
+    "@gotgenes/pi-permission-system": "^27.0.0"
   },
   "devDependencies": {
     "@earendil-works/pi-ai": "^0.84.1",
     "@earendil-works/pi-coding-agent": "^0.84.1",
-    "@gotgenes/pi-permission-system": "^26.0.0",
+    "@gotgenes/pi-permission-system": "^27.0.0",
     "@types/node": "^26.2.0",
     "typescript": "^6.0.3"
   }

package/src/index.ts

@@ -11,11 +11,12 @@ import {
   completeSimple,
   type ApiStreamSimpleFunction,
 } from "@earendil-works/pi-ai/compat";
-import type {
-  AuthorizerLog,
-  AuthorizerVerdict,
-  PermissionQuery,
-  PromptPermissionDetails,
+import {
+  getPermissionsService,
+  type AuthorizerLog,
+  type AuthorizerVerdict,
+  type PermissionQuery,
+  type PromptPermissionDetails,
 } from "@gotgenes/pi-permission-system";
 import {
   buildClassifierTranscript,
@@ -37,14 +38,13 @@ import {
 } from "./broker/index.ts";
 import { PermissionUiAutoConfirmer } from "./ui-auto-confirm.ts";
 import {
-  buildUserReviewEntryData,
   buildUserReviewNotice,
   buildUserReviewStatus,
+  buildUserReviewWidgetData,
   notifyUserReview,
-  presentUserReview,
   renderUserReviewEntry,
   reviewTargetFromRequest,
-  setUserReviewStatus,
+  UserReviewWidgetController,
   USER_REVIEW_ENTRY_TYPE,
   type UserReviewOutcome,
   type UserReviewUsage,
@@ -251,6 +251,7 @@ type ReviewResult = {
   durationMs: number;
   transcript: TranscriptResult;
   summary: ReviewExecutionSummary;
+  unavailable?: boolean;
 };
 
 class ReviewExecutionError extends Error {
@@ -273,9 +274,6 @@ const USER_CONFIG_RELATIVE_PATH = join(
   "pi-auto-review",
   "config.json",
 );
-const PERMISSIONS_SERVICE_KEY = Symbol.for(
-  "@gotgenes/pi-permission-system:service",
-);
 const BOUNDED_SURFACES = new Set(["path", "external_directory"]);
 const REVIEWER_FRAMING_RESERVE_TOKENS = 64;
 const REVIEWER_RETRY_DELAY_MS = 250;
@@ -728,12 +726,6 @@ type PermissionsService = {
   ): () => void;
 };
 
-function permissionsService(): PermissionsService | undefined {
-  return (globalThis as Record<symbol, unknown>)[
-    PERMISSIONS_SERVICE_KEY
-  ] as PermissionsService | undefined;
-}
-
 function boundaryRequest(
   ctx: ExtensionContext,
   details: PromptPermissionDetails,
@@ -1925,6 +1917,9 @@ export function createPiAutoReviewExtension(
   let context: ExtensionContext | undefined;
   let config: Readonly<Config> = trustedConfig;
   let disposeAuthorizer: (() => void) | undefined;
+  let registeredSessionId: string | undefined;
+  let registrationEpoch = 0;
+  let shuttingDown = false;
   let disposeBrokerService: (() => void) | undefined;
   const reviewResults = new Map<string, ReviewResult>();
   const telemetryCompleted = new Set<string>();
@@ -1935,6 +1930,7 @@ export function createPiAutoReviewExtension(
   const uiAutoConfirmer = new PermissionUiAutoConfirmer(
     () => config.autoConfirmBoundedAllows,
   );
+  const reviewWidget = new UserReviewWidgetController();
 
   const emitTelemetry = (event: ReviewerTelemetryEvent): void => {
     writeOptionalAuditFile(event);
@@ -1990,6 +1986,7 @@ export function createPiAutoReviewExtension(
               durationMs: execution.summary.durationMs,
               transcript: execution.summary.transcript,
               summary: execution.summary,
+              unavailable: true,
             });
           }
           emitTelemetry(
@@ -2267,6 +2264,12 @@ export function createPiAutoReviewExtension(
   });
 
   pi.on("session_start", (_event, ctx) => {
+    shuttingDown = false;
+    registrationEpoch++;
+    disposeAuthorizer?.();
+    disposeAuthorizer = undefined;
+    registeredSessionId = undefined;
+    reviewWidget.clear(context ?? ctx);
     disposeBrokerService?.();
     broker?.clear();
     reviewResults.clear();
@@ -2280,7 +2283,17 @@ export function createPiAutoReviewExtension(
       );
       context = ctx;
       broker = createBroker();
-      disposeBrokerService = publishBoundaryBroker(broker);
+      try {
+        disposeBrokerService = publishBoundaryBroker(broker);
+      } catch (error) {
+        if (!(error instanceof Error) ||
+            error.message !== "pi-auto-review boundary broker is already published") {
+          throw error;
+        }
+        // In-process child nodes still need their own reviewer/authorizer.
+        // The process-global broker capability remains owned by the parent.
+        disposeBrokerService = undefined;
+      }
     } catch (error) {
       context = undefined;
       broker = undefined;
@@ -2300,12 +2313,46 @@ export function createPiAutoReviewExtension(
     if (context) uiAutoConfirmer.handlePrompt(event, context);
   });
 
-  pi.events.on("permissions:ready", () => {
-    try {
-      const service = permissionsService();
-      if (!service) return;
+  pi.events.on("permissions:decision", (event) => {
+    reviewWidget.permissionDecision(event);
+  });
+
+  pi.events.on("permissions:ready", (event) => {
+    const ready = event && typeof event === "object" && !Array.isArray(event)
+      ? event as Record<string, unknown>
+      : undefined;
+    const sessionId = typeof ready?.sessionId === "string" &&
+        ready.sessionId.trim()
+      ? ready.sessionId
+      : undefined;
+    if (!sessionId) {
+      console.error(
+        `${EXTENSION_NAME}: ignored permissions:ready without a session id`,
+      );
+      return;
+    }
+    if (registeredSessionId === sessionId && disposeAuthorizer) return;
+
+    const epoch = ++registrationEpoch;
+    if (registeredSessionId && registeredSessionId !== sessionId) {
       disposeAuthorizer?.();
-      disposeAuthorizer = service.registerAuthorizer(
+      disposeAuthorizer = undefined;
+      registeredSessionId = undefined;
+    }
+
+    if (shuttingDown || epoch !== registrationEpoch || !context) return;
+    const service = getPermissionsService(sessionId) as
+      | PermissionsService
+      | undefined;
+    if (!service) {
+      console.error(
+        `${EXTENSION_NAME}: permissions service unavailable for session ${sessionId}`,
+      );
+      return;
+    }
+    let dispose: (() => void) | undefined;
+    try {
+      dispose = service.registerAuthorizer(
         EXTENSION_NAME,
         async (details, query, log: AuthorizerLog) => {
           const evidence = normalizePermissionEvidence(details);
@@ -2322,133 +2369,140 @@ export function createPiAutoReviewExtension(
               surface,
               rationale: reason,
             };
-            presentUserReview(
-              pi,
-              context,
-              buildUserReviewNotice(unavailable),
-              buildUserReviewEntryData(unavailable),
-            );
+            notifyUserReview(context, buildUserReviewNotice(unavailable));
             return { kind: "deny", reason };
           }
 
           const request = boundaryRequest(context, details, query);
           const target = reviewTargetFromRequest(request);
-          setUserReviewStatus(
-            context,
-            buildUserReviewStatus(surface, target),
+          const reviewContext = context;
+          const widgetGeneration = reviewWidget.begin(request.id, reviewContext, {
+            surface,
+            target,
+            model: config.model,
+          });
+          const decision = await broker.review(request, {
+            sessionId: reviewContext.sessionManager.getSessionId(),
+            scopeKey: currentTurnScope(reviewContext),
+            issueGrant: false,
+          });
+          const result = reviewResults.get(request.id);
+          reviewResults.delete(request.id);
+          const allowCapped =
+            decision.kind === "allow" && boundedRequest(surface);
+          const autoConfirmQueued =
+            allowCapped &&
+            reviewContext.mode === "tui" &&
+            reviewContext.hasUI &&
+            uiAutoConfirmer.stage(request.id, surface);
+
+          let userOutcome: UserReviewOutcome;
+          if (decision.kind === "deny" && decision.circuitBreakerTripped) {
+            userOutcome = "circuit_breaker";
+          } else if (allowCapped && autoConfirmQueued) {
+            userOutcome = "auto_confirm";
+          } else if (allowCapped) {
+            userOutcome = "needs_confirmation";
+          } else if (decision.kind === "allow") {
+            userOutcome = "allow";
+          } else if (decision.kind === "defer") {
+            userOutcome = "defer";
+          } else {
+            userOutcome = "deny";
+          }
+          const reviewMeta = userReviewMetaFromResult(result, config.model);
+          const noticeInput = {
+            outcome: result?.unavailable ? "unavailable" as const : userOutcome,
+            surface,
+            target,
+            rationale: decision.review.rationale,
+            recoveryCommand:
+              decision.kind === "deny"
+                ? decision.recoveryCommand
+                : undefined,
+            ...reviewMeta,
+          };
+          const notice = buildUserReviewNotice(noticeInput);
+          reviewWidget.complete(
+            request.id,
+            widgetGeneration,
+            reviewContext,
+            notice,
+            buildUserReviewWidgetData(noticeInput),
           );
-          try {
-            const decision = await broker.review(request, {
-              sessionId: context.sessionManager.getSessionId(),
-              scopeKey: currentTurnScope(context),
-              issueGrant: false,
-            });
-            const result = reviewResults.get(request.id);
-            reviewResults.delete(request.id);
-            const allowCapped =
-              decision.kind === "allow" && boundedRequest(surface);
-            const autoConfirmQueued =
-              allowCapped &&
-              context.mode === "tui" &&
-              context.hasUI &&
-              uiAutoConfirmer.stage(request.id, surface);
-
-            let userOutcome: UserReviewOutcome;
-            if (decision.kind === "deny" && decision.circuitBreakerTripped) {
-              userOutcome = "circuit_breaker";
-            } else if (allowCapped && autoConfirmQueued) {
-              userOutcome = "auto_confirm";
-            } else if (allowCapped) {
-              userOutcome = "needs_confirmation";
-            } else if (decision.kind === "allow") {
-              userOutcome = "allow";
-            } else if (decision.kind === "defer") {
-              userOutcome = "defer";
-            } else {
-              userOutcome = "deny";
-            }
-            const reviewMeta = userReviewMetaFromResult(result, config.model);
-            const noticeInput = {
-              outcome: userOutcome,
-              surface,
-              target,
-              rationale: decision.review.rationale,
-              recoveryCommand:
-                decision.kind === "deny"
-                  ? decision.recoveryCommand
-                  : undefined,
-              ...reviewMeta,
-            };
-            presentUserReview(
-              pi,
-              context,
-              buildUserReviewNotice(noticeInput),
-              buildUserReviewEntryData(noticeInput),
-            );
-
-            log.review("pi_auto_review_decision", {
-              requestId: request.id,
-              surface,
-              model: config.model,
-              reviewerModel: reviewMeta.model,
-              outcome: allowCapped ? "defer" : decision.kind,
-              reviewerOutcome: decision.review.outcome,
-              riskLevel: decision.review.riskLevel,
-              userAuthorization: decision.review.userAuthorization,
-              rationale: decision.review.rationale,
-              allowCapped,
-              autoConfirmQueued,
-              userOutcome,
-              circuitBreakerTripped:
-                decision.kind === "deny"
-                  ? decision.circuitBreakerTripped
-                  : false,
-              attempts: result?.attempts ?? 0,
-              retryErrors: result?.retryErrors ?? [],
-              durationMs: result?.durationMs,
-              usageAvailability: reviewMeta.usage?.availability,
-              usage: reviewMeta.usage,
-              transcriptUserCharacters: result?.transcript.userCharacters,
-              transcriptToolCharacters: result?.transcript.toolCharacters,
-              transcriptRelevantResultCharacters:
-                result?.transcript.relevantResultCharacters,
-              transcriptTruncated: result?.transcript.truncated,
-              command: request.command,
-              path: request.path,
-              resolvedPath: request.resolvedPath,
-              destination: request.destination,
-              agentName: request.agentName,
-              requesterSessionId: request.requesterSessionId,
-              accessIntent: request.accessIntent,
-              authorization:
-                decision.kind === "allow"
-                  ? decision.authorization
-                  : undefined,
-            });
 
-            if (allowCapped || decision.kind === "defer") {
-              return { kind: "defer" };
-            }
-            if (decision.kind === "allow") return { kind: "allow" };
-            const denyInstruction =
-              decision.denialSource === "hard-deny"
-                ? LOCAL_HARD_DENY_AGENT_INSTRUCTION
-                : decision.recoveryCommand === "/auto-review-break-glass"
-                  ? REVIEWER_CRITICAL_DENY_AGENT_INSTRUCTION
-                  : decision.recoveryCommand === "/auto-review-approve"
-                    ? REVIEWER_NONCRITICAL_DENY_AGENT_INSTRUCTION
-                    : "Automatic policy critically denied this action and break-glass authorization is disabled. Do not retry, rephrase, or circumvent it.";
-            return {
-              kind: "deny",
-              reason: `${decision.review.rationale} ${denyInstruction}`,
-            };
-          } finally {
-            setUserReviewStatus(context, undefined);
+          log.review("pi_auto_review_decision", {
+            requestId: request.id,
+            toolCallId: request.toolCallId,
+            surface,
+            model: config.model,
+            reviewerModel: reviewMeta.model,
+            outcome: allowCapped ? "defer" : decision.kind,
+            reviewerOutcome: decision.review.outcome,
+            riskLevel: decision.review.riskLevel,
+            userAuthorization: decision.review.userAuthorization,
+            rationale: decision.review.rationale,
+            allowCapped,
+            autoConfirmQueued,
+            userOutcome,
+            circuitBreakerTripped:
+              decision.kind === "deny"
+                ? decision.circuitBreakerTripped
+                : false,
+            attempts: result?.attempts ?? 0,
+            retryErrors: result?.retryErrors ?? [],
+            durationMs: result?.durationMs,
+            usageAvailability: reviewMeta.usage?.availability,
+            usage: reviewMeta.usage,
+            transcriptUserCharacters: result?.transcript.userCharacters,
+            transcriptToolCharacters: result?.transcript.toolCharacters,
+            transcriptRelevantResultCharacters:
+              result?.transcript.relevantResultCharacters,
+            transcriptTruncated: result?.transcript.truncated,
+            command: request.command,
+            path: request.path,
+            resolvedPath: request.resolvedPath,
+            destination: request.destination,
+            agentName: request.agentName,
+            requesterSessionId: request.requesterSessionId,
+            accessIntent: request.accessIntent,
+            authorization:
+              decision.kind === "allow"
+                ? decision.authorization
+                : undefined,
+          });
+
+          if (allowCapped || decision.kind === "defer") {
+            return { kind: "defer" };
           }
+          if (decision.kind === "allow") return { kind: "allow" };
+          const denyInstruction =
+            decision.denialSource === "hard-deny"
+              ? LOCAL_HARD_DENY_AGENT_INSTRUCTION
+              : decision.recoveryCommand === "/auto-review-break-glass"
+                ? REVIEWER_CRITICAL_DENY_AGENT_INSTRUCTION
+                : decision.recoveryCommand === "/auto-review-approve"
+                  ? REVIEWER_NONCRITICAL_DENY_AGENT_INSTRUCTION
+                  : "Automatic policy critically denied this action and break-glass authorization is disabled. Do not retry, rephrase, or circumvent it.";
+          return {
+            kind: "deny",
+            reason: `${decision.review.rationale} ${denyInstruction}`,
+          };
         },
       );
-      writeOptionalAuditFile({ type: "authorizer_registered" });
+      if (shuttingDown || epoch !== registrationEpoch || !context) {
+        dispose();
+        return;
+      }
+      disposeAuthorizer?.();
+      disposeAuthorizer = dispose;
+      registeredSessionId = sessionId;
+      writeOptionalAuditFile({
+        type: "authorizer_registered",
+        sessionId,
+      });
     } catch (error) {
+      dispose?.();
       console.error(
         `${EXTENSION_NAME}: authorizer registration failed: ${
           error instanceof Error ? error.message : String(error)
@@ -2458,9 +2512,12 @@ export function createPiAutoReviewExtension(
   });
 
   pi.on("session_shutdown", () => {
-    setUserReviewStatus(context, undefined);
+    shuttingDown = true;
+    registrationEpoch++;
+    reviewWidget.clear(context);
     disposeAuthorizer?.();
     disposeAuthorizer = undefined;
+    registeredSessionId = undefined;
     disposeBrokerService?.();
     disposeBrokerService = undefined;
     broker?.clear();

package/src/user-feedback.ts

@@ -1,10 +1,8 @@
-import type {
-  ExtensionAPI,
-  ExtensionContext,
-} from "@earendil-works/pi-coding-agent";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 export const USER_REVIEW_STATUS_KEY = "pi-auto-review";
 export const USER_REVIEW_ENTRY_TYPE = "pi-auto-review";
+export const USER_REVIEW_WIDGET_KEY = "pi-auto-review";
 
 export type UserReviewOutcome =
   | "allow"
@@ -45,6 +43,14 @@ export function compactReviewText(value: unknown, max = 90): string {
     .slice(0, max);
 }
 
+/** Collapse whitespace and visibly truncate bounded widget text. */
+export function truncateReviewText(value: unknown, max: number): string {
+  const compact = String(value ?? "").replace(/\s+/g, " ").trim();
+  if (compact.length <= max) return compact;
+  if (max <= 1) return "…".slice(0, max);
+  return `${compact.slice(0, max - 1).trimEnd()}…`;
+}
+
 export function reviewTargetFromRequest(request: {
   resolvedPath?: string;
   path?: string;
@@ -62,7 +68,7 @@ export function reviewTargetFromRequest(request: {
     request.toolName ??
     request.skillName ??
     request.operation;
-  const compact = compactReviewText(target, 100);
+  const compact = truncateReviewText(target, 100);
   return compact || undefined;
 }
 
@@ -101,15 +107,15 @@ export function formatReviewUsage(usage: UserReviewUsage): string | undefined {
   if (input !== undefined) {
     const cache =
       usage.cacheRead && usage.cacheRead > 0
-        ? ` (${formatReviewTokenCount(usage.cacheRead)} cache)`
+        ? ` (${formatReviewTokenCount(usage.cacheRead)} toks cache)`
         : "";
-    parts.push(`${formatReviewTokenCount(input)} in${cache}`);
+    parts.push(`${formatReviewTokenCount(input)} toks in${cache}`);
   }
   if (usage.output !== undefined) {
-    parts.push(`${formatReviewTokenCount(usage.output)} out`);
+    parts.push(`${formatReviewTokenCount(usage.output)} toks out`);
   }
   if (parts.length === 0 && usage.totalTokens !== undefined) {
-    parts.push(`${formatReviewTokenCount(usage.totalTokens)} tok`);
+    parts.push(`${formatReviewTokenCount(usage.totalTokens)} toks`);
   }
   if (parts.length === 0) return undefined;
   const approx = usage.availability === "estimated" ? "~" : "";
@@ -193,6 +199,16 @@ function joinNoticeLines(lines: Array<string | undefined>): string[] {
     .filter((line) => line.length > 0);
 }
 
+function reviewTargetRationaleLine(input: {
+  target?: string;
+  rationale?: string;
+}): string | undefined {
+  const target = truncateReviewText(input.target, 100);
+  const rationale = truncateReviewText(input.rationale, 180);
+  if (target && rationale) return `${target} · ${rationale}`;
+  return target || rationale || undefined;
+}
+
 export type UserReviewNoticeInput = {
   outcome: UserReviewOutcome;
   surface: string;
@@ -211,6 +227,24 @@ export type UserReviewEntryData = {
   lines: string[];
 };
 
+export type UserReviewGroupMember = UserReviewNoticeInput & {
+  requestId: string;
+  permissionResult?: "allow" | "deny";
+};
+
+export type UserReviewGroupEntryData = {
+  kind: "group";
+  type: UserReviewNotice["type"];
+  sessionId: string;
+  toolCallId: string;
+  fullCommand?: string;
+  members: UserReviewGroupMember[];
+};
+
+export type AnyUserReviewEntryData =
+  | UserReviewEntryData
+  | UserReviewGroupEntryData;
+
 type UserReviewTheme = {
   fg(color: string, text: string): string;
   italic(text: string): string;
@@ -258,11 +292,21 @@ function outcomeVerb(outcome: UserReviewOutcome): string {
   }
 }
 
+function memberOutcomeText(outcome: UserReviewOutcome): string {
+  switch (outcome) {
+    case "auto_confirm":
+      return "allowed · auto-confirm";
+    case "needs_confirmation":
+      return "allowed · confirm locally";
+    default:
+      return outcomeVerb(outcome);
+  }
+}
+
 export function buildUserReviewLines(input: UserReviewNoticeInput): string[] {
   return joinNoticeLines([
     reviewHeadline(input.outcome, input.surface),
-    compactReviewText(input.target, 100) || undefined,
-    compactReviewText(input.rationale, 180) || undefined,
+    reviewTargetRationaleLine(input),
     recoveryLine(input.outcome, input.recoveryCommand),
     formatReviewMeta({
       model: input.model,
@@ -275,7 +319,7 @@ export function buildUserReviewLines(input: UserReviewNoticeInput): string[] {
 
 /**
  * User-facing (not agent-facing) notice after a review decision.
- * Structured for TUI wrapping: headline, target, rationale, then model/tokens.
+ * Structured for TUI wrapping: headline, target+rationale, then model/tokens.
  */
 export function buildUserReviewNotice(
   input: UserReviewNoticeInput,
@@ -297,10 +341,7 @@ export function buildUserReviewEntryData(
 }
 
 export function formatUserReviewQuoteMessage(message: string): string {
-  return message
-    .split("\n")
-    .map((line) => `│ ${line}`)
-    .join("\n");
+  return message;
 }
 
 function displayWidth(text: string): number {
@@ -362,11 +403,9 @@ export function renderUserReviewQuoteLines(
   theme: UserReviewTheme,
   width: number,
 ): string[] {
-  const contentWidth = Math.max(1, width - 2);
-  const border = theme.fg("mdQuoteBorder", "│ ");
+  const contentWidth = Math.max(1, width);
   const verb = outcomeVerb(data.outcome);
   const verbAnsi = theme.getFgAnsi(outcomeAccent(data.outcome));
-  const numberAnsi = theme.getFgAnsi("success");
   const rendered: string[] = [];
   for (const [index, line] of data.lines.entries()) {
     for (const visual of wrapReviewDisplayText(line, contentWidth)) {
@@ -377,24 +416,100 @@ export function renderUserReviewQuoteLines(
           `${verbAnsi}${verb}\x1b[0m`,
         );
       }
-      if (index === data.lines.length - 1) {
-        painted = painted.replace(
-          /(\d+(?:\.\d+)?[kM]?)(?=\s(?:in|out|tok|cache|calls)|ms\b|s\b)/g,
-          `${numberAnsi}$1\x1b[0m`,
-        );
-      }
-      rendered.push(border + withQuoteStyle(theme, painted));
+      rendered.push(withQuoteStyle(theme, painted));
     }
   }
   return rendered;
 }
 
+function groupOutcome(members: readonly UserReviewGroupMember[]): UserReviewOutcome {
+  if (members.some((member) => member.permissionResult === "deny")) return "deny";
+  for (const outcome of [
+    "circuit_breaker",
+    "deny",
+    "unavailable",
+    "defer",
+    "needs_confirmation",
+    "auto_confirm",
+  ] as const) {
+    if (members.some((member) => member.outcome === outcome)) return outcome;
+  }
+  return "allow";
+}
+
+function groupHeadline(data: UserReviewGroupEntryData): string {
+  const outcome = groupOutcome(data.members);
+  const result = outcome === "deny" || outcome === "circuit_breaker" ||
+      outcome === "unavailable"
+    ? "denied"
+    : outcome === "defer" || outcome === "needs_confirmation"
+      ? "deferred"
+      : "allowed";
+  return `Auto-review · ${result} · ${data.members.length} checks`;
+}
+
+export function buildUserReviewGroupLines(
+  data: UserReviewGroupEntryData,
+): UserReviewEntryData {
+  if (data.members.length === 1) {
+    const member = data.members[0];
+    const lines = buildUserReviewLines(member);
+    if (member.permissionResult === "deny" && member.outcome !== "deny") {
+      lines.push("Local confirmation · denied");
+    }
+    return { outcome: groupOutcome(data.members), type: data.type, lines };
+  }
+
+  const lines: string[] = [groupHeadline(data)];
+  const command = String(data.fullCommand ?? "")
+    .replace(/\s+/g, " ")
+    .trim();
+  if (command) lines.push(command);
+  for (const member of data.members) {
+    const summary = joinNoticeLines([
+      member.surface,
+      memberOutcomeText(member.outcome),
+      reviewTargetRationaleLine(member),
+    ]).join(" · ");
+    lines.push(
+      summary,
+      ...joinNoticeLines([
+        recoveryLine(member.outcome, member.recoveryCommand),
+        member.permissionResult === "deny" && member.outcome !== "deny"
+          ? "Local confirmation · denied"
+          : undefined,
+        formatReviewMeta(member),
+      ]),
+    );
+  }
+  return { outcome: groupOutcome(data.members), type: data.type, lines };
+}
+
 export function renderUserReviewEntry(
   entry: { data?: unknown },
   _options: unknown,
   theme: UserReviewTheme,
 ): { render(width: number): string[]; invalidate(): void } | undefined {
   const data = entry.data;
+  if (
+    data &&
+    typeof data === "object" &&
+    (data as UserReviewGroupEntryData).kind === "group" &&
+    Array.isArray((data as UserReviewGroupEntryData).members) &&
+    (data as UserReviewGroupEntryData).members.length > 0
+  ) {
+    const parsed = data as UserReviewGroupEntryData;
+    return {
+      render(width: number) {
+        return renderUserReviewQuoteLines(
+          buildUserReviewGroupLines(parsed),
+          theme,
+          width,
+        );
+      },
+      invalidate() {},
+    };
+  }
   if (
     !data ||
     typeof data !== "object" ||
@@ -412,20 +527,6 @@ export function renderUserReviewEntry(
   };
 }
 
-function presentUserReviewEntry(
-  pi: ExtensionAPI | undefined,
-  ctx: ExtensionContext | undefined,
-  data: UserReviewEntryData,
-): boolean {
-  if (!pi || !ctx?.hasUI || ctx.mode !== "tui") return false;
-  try {
-    pi.appendEntry(USER_REVIEW_ENTRY_TYPE, data);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 /** Best-effort toast; never throws into the authorizer path. */
 export function notifyUserReview(
   ctx: ExtensionContext | undefined,
@@ -439,27 +540,160 @@ export function notifyUserReview(
   }
 }
 
-/** TUI quote-style entry when possible; otherwise a quoted notify toast. */
-export function presentUserReview(
-  pi: ExtensionAPI | undefined,
-  ctx: ExtensionContext | undefined,
-  notice: UserReviewNotice,
-  data: UserReviewEntryData,
-): void {
-  if (presentUserReviewEntry(pi, ctx, data)) return;
-  notifyUserReview(ctx, notice);
+export type UserReviewWidgetData = UserReviewEntryData & {
+  phase: "reviewing" | "complete";
+};
+
+export function buildUserReviewingWidgetData(input: {
+  surface: string;
+  target?: string;
+  model?: string;
+}): UserReviewWidgetData {
+  const target = truncateReviewText(input.target, 100);
+  const model = formatReviewModelName(input.model) ?? "reviewer";
+  return {
+    phase: "reviewing",
+    outcome: "defer",
+    type: "info",
+    lines: joinNoticeLines([
+      `Auto-review · reviewing · ${input.surface}`,
+      target,
+      `Waiting for ${model}…`,
+    ]),
+  };
+}
+
+export function buildUserReviewWidgetData(
+  input: UserReviewNoticeInput,
+): UserReviewWidgetData {
+  return {
+    phase: "complete",
+    ...buildUserReviewEntryData(input),
+  };
+}
+
+export function renderUserReviewWidgetLines(
+  data: UserReviewWidgetData,
+  theme: UserReviewTheme,
+  width: number,
+): string[] {
+  const rendered: string[] = [];
+  const verb = data.phase === "reviewing"
+    ? "reviewing"
+    : outcomeVerb(data.outcome);
+  const accent = data.phase === "reviewing"
+    ? "muted"
+    : outcomeAccent(data.outcome);
+  const verbAnsi = theme.getFgAnsi(accent);
+  const mutedAnsi = theme.getFgAnsi("muted");
+  for (const [index, line] of data.lines.entries()) {
+    for (const visual of wrapReviewDisplayText(line, Math.max(1, width))) {
+      let painted = `${mutedAnsi}${visual}\x1b[0m`;
+      if (index === 0) {
+        painted = painted.replace(
+          verb,
+          `${verbAnsi}${verb}\x1b[0m${mutedAnsi}`,
+        );
+      }
+      rendered.push(painted);
+    }
+  }
+  return rendered;
 }
 
-/** Best-effort footer status; pass undefined to clear. */
-export function setUserReviewStatus(
+function setWidget(
   ctx: ExtensionContext | undefined,
-  text: string | undefined,
-  key = USER_REVIEW_STATUS_KEY,
-): void {
-  if (!ctx?.hasUI) return;
+  data: UserReviewWidgetData | undefined,
+): boolean {
+  if (!ctx?.hasUI || ctx.mode !== "tui") return false;
   try {
-    ctx.ui.setStatus?.(key, text);
+    ctx.ui.setWidget(
+      USER_REVIEW_WIDGET_KEY,
+      data
+        ? (_tui, theme) => ({
+            render: (width: number) =>
+              renderUserReviewWidgetLines(data, theme, width),
+            invalidate() {},
+          })
+        : undefined,
+      { placement: "aboveEditor" },
+    );
+    return true;
   } catch {
-    // UI delivery is observational and must not change a decision.
+    return false;
+  }
+}
+
+/** Owns the single live widget and rejects stale concurrent completions. */
+export class UserReviewWidgetController {
+  #generation = 0;
+  #current?: {
+    requestId: string;
+    generation: number;
+    ctx: ExtensionContext;
+    data?: UserReviewWidgetData;
+    notice?: UserReviewNotice;
+  };
+
+  begin(
+    requestId: string,
+    ctx: ExtensionContext,
+    input: { surface: string; target?: string; model?: string },
+  ): number {
+    const generation = ++this.#generation;
+    this.#current = { requestId, generation, ctx };
+    setWidget(ctx, buildUserReviewingWidgetData(input));
+    return generation;
+  }
+
+  complete(
+    requestId: string,
+    generation: number,
+    ctx: ExtensionContext,
+    notice: UserReviewNotice,
+    data: UserReviewWidgetData,
+  ): void {
+    if (!ctx.hasUI || ctx.mode !== "tui") {
+      notifyUserReview(ctx, notice);
+      return;
+    }
+    if (!this.#isCurrent(requestId, generation)) return;
+    this.#current = { requestId, generation, ctx, notice, data };
+    if (!setWidget(ctx, data)) notifyUserReview(ctx, notice);
+  }
+
+  permissionDecision(event: unknown): void {
+    if (!event || typeof event !== "object" || Array.isArray(event)) return;
+    const record = event as Record<string, unknown>;
+    const current = this.#current;
+    if (
+      record.result !== "deny" ||
+      typeof record.requestId !== "string" ||
+      record.requestId !== current?.requestId ||
+      !current.data ||
+      current.data.lines.includes("Local confirmation · denied")
+    ) return;
+    const data = {
+      ...current.data,
+      lines: [...current.data.lines, "Local confirmation · denied"],
+    };
+    const notice = {
+      type: current.notice?.type ?? data.type,
+      message: data.lines.join("\n"),
+    };
+    this.#current = { ...current, data, notice };
+    if (!setWidget(current.ctx, data)) notifyUserReview(current.ctx, notice);
+  }
+
+  clear(ctx?: ExtensionContext): void {
+    ++this.#generation;
+    const current = this.#current;
+    this.#current = undefined;
+    if (current) setWidget(ctx ?? current.ctx, undefined);
+  }
+
+  #isCurrent(requestId: string, generation: number): boolean {
+    return this.#current?.requestId === requestId &&
+      this.#current.generation === generation;
   }
 }