V48 Gate 3 (implementation-only): infer + render the ReadyToFinish verdict's decision reason(s) in /deposit Telemetry

The DIV loop's iterate-vs-finish verdict already streams whole as the
cross-phase validation/readyToFinish artifact (finalApproval,
recommendation, criticalChecks, finalBlockers, finalWarnings, scores,
summary) — but nothing surfaced WHY a run iterated or finished.

- Activity builder: capture one ReadyToFinishVerdictView per DIV iteration
  (stamped with the latched iteration) with the decision reason(s) INFERRED:
  failed critical checks first (named — 'critical checks failed:
  requirements met, documentation complete'), then the concrete
  finalBlockers; a rejection with no structured reasons falls back to its
  summary; an approval carries its summary instead of reasons.
- /deposit Telemetry: a readiness-verdict block under the header — headline
  ('iter N verdict · iterate (abort) · quality 0.81 · confidence 0.28 ·
  5 warnings' / 'ready to finish'), the reason list for rejections, the
  summary for approvals, and a one-line history of prior iterations'
  verdicts. Amber while iterating, emerald when approved.

Verified: uapi 155 suites / 607 tests green (verdict capture, reason
inference order, and summary fallback pinned); tsc clean.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: geraldarthurdavis

uapi/app/deposit/DepositPageClient.tsx

@@ -1463,6 +1463,60 @@ export default function DepositPageClient() {
                     </span>
                   </div>
                 </div>
+                {synthesisActivity.readyToFinishVerdicts.length > 0 &&
+                  (() => {
+                    const verdicts = synthesisActivity.readyToFinishVerdicts;
+                    const latest = verdicts[verdicts.length - 1];
+                    const prior = verdicts.slice(0, -1);
+                    const approved = latest.finalApproval === true;
+                    return (
+                      <div
+                        data-testid="deposit-telemetry-readiness-verdict"
+                        className={`mt-3 border px-3 py-2 text-xs leading-5 ${
+                          approved
+                            ? "border-emerald-300/20 bg-emerald-300/5 text-emerald-100/90"
+                            : "border-amber-300/20 bg-amber-300/5 text-amber-100/90"
+                        }`}
+                      >
+                        <p className="font-mono text-[0.62rem] uppercase tracking-[0.16em]">
+                          {`iter ${latest.iteration ?? "—"} verdict · `}
+                          {approved
+                            ? "ready to finish"
+                            : `iterate${latest.recommendation ? ` (${latest.recommendation})` : ""}`}
+                          {typeof latest.qualityScore === "number" &&
+                            ` · quality ${latest.qualityScore.toFixed(2)}`}
+                          {typeof latest.overallConfidence === "number" &&
+                            ` · confidence ${latest.overallConfidence.toFixed(2)}`}
+                          {latest.warningsCount > 0 && ` · ${latest.warningsCount} warnings`}
+                        </p>
+                        {approved
+                          ? latest.summary && (
+                              <p className="mt-1 max-w-4xl text-neutral-300">{latest.summary}</p>
+                            )
+                          : latest.reasons.length > 0 && (
+                              <ul className="mt-1 max-w-4xl list-disc space-y-1 pl-4 text-neutral-300">
+                                {latest.reasons.map((reason, index) => (
+                                  <li key={index}>{reason}</li>
+                                ))}
+                              </ul>
+                            )}
+                        {prior.length > 0 && (
+                          <p className="mt-2 font-mono text-[0.6rem] uppercase tracking-[0.14em] text-neutral-500">
+                            {prior
+                              .map(
+                                (verdict) =>
+                                  `iter ${verdict.iteration ?? "—"}: ${
+                                    verdict.finalApproval === true
+                                      ? "ready"
+                                      : `iterate (${verdict.recommendation ?? "not approved"}, ${verdict.reasons.length} reasons)`
+                                  }`,
+                              )
+                              .join(" · ")}
+                          </p>
+                        )}
+                      </div>
+                    );
+                  })()}
                 <div className="mt-4 min-w-0">
                   <PipelineExecutionLog
                     output={synthesisActivity.output}

uapi/app/terminal/terminal-run-activity.ts

@@ -34,6 +34,14 @@ export interface TerminalRunActivitySnapshot {
    * the finish phase begins. Drives the header's 'iter N' marker.
    */
   currentIteration: number | null;
+  /**
+   * One ReadyToFinish verdict per DIV iteration (chronological), captured
+   * from the cross-phase validation/readyToFinish artifact with its decision
+   * reason(s) INFERRED — failed critical checks first, then the concrete
+   * final blockers; an approval carries its summary instead. Drives the
+   * Telemetry readiness-verdict rendering.
+   */
+  readyToFinishVerdicts: ReadyToFinishVerdictView[];
   /**
    * The CURRENT active call-chain: the rolling Phase→Agent→Step→Failsafe→
    * Generation context after the last streamed event — drives live header
@@ -48,6 +56,55 @@ export interface TerminalRunActivitySnapshot {
   } | null;
 }
 
+export interface ReadyToFinishVerdictView {
+  /** DIV iteration the verdict gated (1-based; null when never latched). */
+  iteration: number | null;
+  finalApproval: boolean | null;
+  recommendation: string | null;
+  qualityScore: number | null;
+  overallConfidence: number | null;
+  warningsCount: number;
+  /** Inferred decision reason(s): failed critical checks, then blockers. */
+  reasons: string[];
+  summary: string | null;
+}
+
+const CRITICAL_CHECK_LABELS: Record<string, string> = {
+  requirementsMet: 'requirements met',
+  testsPass: 'tests pass',
+  noSecurityIssues: 'no security issues',
+  documentationComplete: 'documentation complete',
+  performanceAcceptable: 'performance acceptable',
+};
+
+/**
+ * Infer the decision reason(s) behind a ReadyToFinish verdict. A rejection's
+ * reasons are its failed critical checks (named) followed by its concrete
+ * finalBlockers; an approval needs no reasons beyond its summary. Falls back
+ * to the summary when a rejection carries no structured reasons.
+ */
+export function inferReadyToFinishReasons(verdict: any): string[] {
+  if (!verdict || typeof verdict !== 'object') return [];
+  if (verdict.finalApproval === true) return [];
+  const reasons: string[] = [];
+  const checks =
+    verdict.criticalChecks && typeof verdict.criticalChecks === 'object' ? verdict.criticalChecks : {};
+  const failedChecks = Object.entries(checks)
+    .filter(([, passed]) => passed === false)
+    .map(([check]) => CRITICAL_CHECK_LABELS[check] || check);
+  if (failedChecks.length) reasons.push(`critical checks failed: ${failedChecks.join(', ')}`);
+  const blockers = Array.isArray(verdict.finalBlockers)
+    ? verdict.finalBlockers.filter(
+        (blocker: unknown): blocker is string => typeof blocker === 'string' && blocker.trim().length > 0,
+      )
+    : [];
+  reasons.push(...blockers);
+  if (!reasons.length && typeof verdict.summary === 'string' && verdict.summary.trim()) {
+    reasons.push(verdict.summary.trim());
+  }
+  return reasons;
+}
+
 export type MockRunActivitySnapshot = {
   output: string;
   outputDetails: Record<string, any>;
@@ -225,6 +282,7 @@ export function buildTerminalRunActivityFromEvents(
   // become rows; every other event just advances the rolling context.
   const rollingContext: ExecContext = {};
   const toolByNode = new Map<string, { name?: string; input?: unknown }>();
+  const readyToFinishVerdicts: ReadyToFinishVerdictView[] = [];
   let rowSeq = 0;
   // Pipeline mode latched from the 'synthesize-asset-packs'/'mode' store —
   // stamped onto subsequent rows (the processing indicator's 'While
@@ -305,6 +363,29 @@ export function buildTerminalRunActivityFromEvents(
       const candidate = payload.data.trim().toLowerCase();
       if (candidate === 'deposit' || candidate === 'read') pipelineMode = candidate;
     }
+
+    // Capture each iteration's ReadyToFinish verdict (the cross-phase
+    // validation/readyToFinish artifact) with its inferred decision reasons.
+    if (
+      ns === 'validation' &&
+      key === 'readyToFinish' &&
+      payload?.data &&
+      typeof payload.data === 'object' &&
+      !(payload.data as Record<string, unknown>).contentWithheld
+    ) {
+      const verdict = payload.data as Record<string, any>;
+      readyToFinishVerdicts.push({
+        iteration: rollingContext.iteration ?? null,
+        finalApproval: typeof verdict.finalApproval === 'boolean' ? verdict.finalApproval : null,
+        recommendation: typeof verdict.recommendation === 'string' ? verdict.recommendation : null,
+        qualityScore: typeof verdict.qualityScore === 'number' ? verdict.qualityScore : null,
+        overallConfidence:
+          typeof verdict.overallConfidence === 'number' ? verdict.overallConfidence : null,
+        warningsCount: Array.isArray(verdict.finalWarnings) ? verdict.finalWarnings.length : 0,
+        reasons: inferReadyToFinishReasons(verdict),
+        summary: typeof verdict.summary === 'string' ? verdict.summary : null,
+      });
+    }
     if ((ns === 'tool' || ns === 'tools') && nodeId) {
       if (key === 'name' && typeof payload?.data === 'string') {
         const acc = toolByNode.get(nodeId) || {};
@@ -401,6 +482,7 @@ export function buildTerminalRunActivityFromEvents(
       }
       : null,
     currentIteration: rollingContext.iteration ?? null,
+    readyToFinishVerdicts,
   };
 }
 
@@ -433,5 +515,6 @@ export function buildTerminalRunActivityFromMock(
     mode: null,
     latestContext: null,
     currentIteration: null,
+    readyToFinishVerdicts: [],
   };
 }