feat: enhance readiness reporting with review gate status and isolation modes

Author: lhy0718

src/core/doctor.ts

@@ -53,10 +53,13 @@ export interface DoctorReadinessSnapshot {
   workspaceRoot: string;
   workspaceProbePath: string;
   blocked: boolean;
+  llmMode?: "codex_chatgpt_only" | "openai_api" | "ollama";
+  pdfAnalysisMode?: "codex_text_image_hybrid" | "responses_api_pdf" | "ollama_vision";
   approvalMode: "manual" | "minimal";
   executionApprovalMode: "manual" | "risk_ack" | "full_auto";
   dependencyMode: "local" | "docker" | "remote_gpu" | "plan_only";
   sessionMode: "fresh" | "existing";
+  candidateIsolation?: "attempt_snapshot_restore" | "attempt_worktree";
   networkPolicy?: ExperimentNetworkPolicy;
   networkPurpose?: ExperimentNetworkPurpose;
   networkDeclarationPresent: boolean;
@@ -310,10 +313,13 @@ export async function runDoctorReport(
       workspaceRoot,
       workspaceProbePath: workspaceWriteProbe.probePath,
       blocked: failedChecks.length > 0 || harness?.status === "fail",
+      llmMode: opts?.llmMode,
+      pdfAnalysisMode: opts?.pdfAnalysisMode,
       approvalMode,
       executionApprovalMode,
       dependencyMode,
       sessionMode,
+      candidateIsolation: opts?.candidateIsolation,
       networkPolicy,
       networkPurpose,
       networkDeclarationPresent,
@@ -416,6 +422,17 @@ async function directoryExists(dirPath: string): Promise<boolean> {
 
 export function buildDoctorHighlightLines(report: DoctorReport): string[] {
   const lines: string[] = [];
+  const profileMark = report.readiness.blocked
+    ? "[ATTN]"
+    : report.readiness.warningChecks.length > 0
+      ? "[WARN]"
+      : "[OK]";
+  const isolationLabel = report.readiness.candidateIsolation || "not-configured";
+  lines.push(
+    `${profileMark} profile: llm=${report.readiness.llmMode || "unknown"}, `
+      + `pdf=${report.readiness.pdfAnalysisMode || "unknown"}, `
+      + `dependency=${report.readiness.dependencyMode}, isolation=${isolationLabel}.`
+  );
   const networkCheck = report.checks.find((check) => check.name === "experiment-web-restriction");
   const networkStatus = networkCheck ? getDoctorCheckStatus(networkCheck) : undefined;
   if (networkStatus === "warning") {
@@ -431,6 +448,25 @@ export function buildDoctorHighlightLines(report: DoctorReport): string[] {
       );
     }
   }
+  const providerFailures = report.readiness.failedChecks.filter((check) =>
+    check === "openai-api-key"
+      || check === "codex-cli"
+      || check === "codex-login"
+      || check.startsWith("ollama-")
+      || check === "python"
+      || check === "pip"
+      || check === "latex"
+      || check === "pdftotext"
+      || check === "pdfinfo"
+      || check === "pdftoppm"
+  );
+  if (providerFailures.length > 0) {
+    lines.push(`[ATTN] provider/runtime blockers: ${providerFailures.join(", ")}.`);
+  }
+  const degradedChecks = report.readiness.warningChecks.filter((check) => check !== "experiment-web-restriction");
+  if (degradedChecks.length > 0) {
+    lines.push(`[WARN] degraded checks: ${degradedChecks.join(", ")}.`);
+  }
   const pageBudgetCheck = report.checks.find((check) => check.name === "paper-page-budget");
   if (pageBudgetCheck) {
     lines.push(

src/core/nodes/analyzeResults.ts

@@ -383,14 +383,17 @@ export function createAnalyzeResultsNode(deps: NodeExecutionDeps): GraphNodeHand
           runId: run.id,
           title: run.title,
           stage: "analysis",
-          summary: [buildAnalyzeResultsCompletionSummary(summary)],
+          summary: [
+            buildAnalyzeResultsCompletionSummary(summary),
+            `Next governed gate: ${transitionRecommendation.targetNode || "review"} via ${transitionRecommendation.action}.`
+          ],
           decision: `Transition recommendation: ${transitionRecommendation.action}${transitionRecommendation.targetNode ? ` -> ${transitionRecommendation.targetNode}` : ""}. ${transitionRecommendation.reason}`,
           blockers: (summary.failure_taxonomy || []).slice(0, 3).map((item) => item.summary),
           openQuestions: (summary.synthesis?.discussion_points || []).slice(0, 3),
           nextActions:
             (summary.synthesis?.follow_up_actions || []).slice(0, 3).length > 0
               ? (summary.synthesis?.follow_up_actions || []).slice(0, 3)
-              : [transitionRecommendation.reason],
+              : [transitionRecommendation.reason, "Enter review and inspect the review packet before treating the run as paper-ready."],
           references: [
             { label: "Analysis report", path: "result_analysis.json" },
             { label: "Transition recommendation", path: "transition_recommendation.json" },

src/core/nodes/review.ts

@@ -164,7 +164,7 @@ export function createReviewNode(deps: NodeExecutionDeps): GraphNodeHandler {
       });
 
       const findingsPath = await writeRunArtifact(run, "review/findings.jsonl", renderJsonl(panel.findings));
-      await writeRunArtifact(run, "review/scorecard.json", `${JSON.stringify(panel.scorecard, null, 2)}\n`);
+      const scorecardPath = await writeRunArtifact(run, "review/scorecard.json", `${JSON.stringify(panel.scorecard, null, 2)}\n`);
       await writeRunArtifact(
         run,
         "review/consistency_report.json",
@@ -196,18 +196,25 @@ export function createReviewNode(deps: NodeExecutionDeps): GraphNodeHandler {
           stage: "review",
           summary: [
             packet.objective_summary,
-            `Review readiness: ${packet.readiness.status}.`
+            `Review readiness: ${packet.readiness.status}.`,
+            `Panel scorecard: ${panel.scorecard.overall_score_1_to_5}/5 overall across ${panel.reviewers.length} reviewer(s).`,
+            `Paper quality: ${llmEvalResult.evaluation.overall_score_1_to_10}/10 (${llmEvalResult.evaluation.paper_worthiness}).`
           ],
           decision: `${panel.decision.outcome}${panel.decision.recommended_transition ? ` -> ${panel.decision.recommended_transition}` : ""}. ${panel.decision.summary}`,
           blockers: [
             ...preDraftCritique.blocking_issues.slice(0, 3).map((issue) => issue.summary),
             ...readinessRisks.risks.filter((risk) => risk.severity === "blocked").slice(0, 2).map((risk) => risk.message)
           ],
-          openQuestions: panel.decision.required_actions.slice(0, 3),
+          openQuestions: [
+            ...panel.decision.required_actions.slice(0, 2),
+            ...llmEvalResult.evaluation.weaknesses.slice(0, 2)
+          ].slice(0, 3),
           nextActions: packet.suggested_actions.slice(0, 3),
           references: [
             { label: "Review packet", path: "review/review_packet.json" },
+            { label: "Review scorecard", path: "review/scorecard.json" },
             { label: "Paper critique", path: "review/paper_critique.json" },
+            { label: "Review decision", path: "review/decision.json" },
             { label: "Minimum gate", path: "review/minimum_gate.json" },
             { label: "Readiness risks", path: "review/readiness_risks.json" }
           ]
@@ -229,6 +236,10 @@ export function createReviewNode(deps: NodeExecutionDeps): GraphNodeHandler {
             sourcePath: reviewPacketPath,
             targetRelativePath: "review_packet.json"
           },
+          {
+            sourcePath: scorecardPath,
+            targetRelativePath: "scorecard.json"
+          },
           {
             sourcePath: checklistPath,
             targetRelativePath: "checklist.md"

src/core/nodes/writePaper.ts

@@ -1010,14 +1010,16 @@ export function createWritePaperNode(deps: NodeExecutionDeps): GraphNodeHandler
           stage: "paper",
           summary: [
             `Paper readiness: ${paperReadiness.readiness_state}.`,
-            paperReadiness.reason
+            paperReadiness.reason,
+            `Venue: ${postDraftCritique.target_venue_style}. Manuscript decision: ${postDraftCritique.overall_decision}.`
           ],
           decision: `paper_ready=${paperReadiness.paper_ready}; evidence_gate=${paperReadiness.evidence_gate_status}; scientific_validation=${paperReadiness.scientific_validation_status}.`,
           blockers: readinessRisks.risks.filter((risk) => risk.severity === "blocked").slice(0, 4).map((risk) => risk.message),
           openQuestions: readinessRisks.risks.filter((risk) => risk.severity === "warning").slice(0, 3).map((risk) => risk.message),
           nextActions: readinessRisks.risks.slice(0, 3).map((risk) => risk.recommended_action),
           references: [
             { label: "Paper readiness", path: "paper/paper_readiness.json" },
+            { label: "Paper critique", path: "paper/paper_critique.json" },
             { label: "Readiness risks", path: "paper/readiness_risks.json" },
             { label: "Claim evidence table", path: "paper/claim_evidence_table.json" },
             { label: "Evidence gate decision", path: "paper/evidence_gate_decision.json" },
@@ -1103,6 +1105,11 @@ export function createWritePaperNode(deps: NodeExecutionDeps): GraphNodeHandler
             targetRelativePath: "paper_readiness.json",
             optional: true
           },
+          {
+            sourcePath: path.join(runPaperDir, "paper_critique.json"),
+            targetRelativePath: "paper_critique.json",
+            optional: true
+          },
           {
             sourcePath: path.join(runPaperDir, "readiness_risks.json"),
             targetRelativePath: "readiness_risks.json",

src/core/runs/jobsProjection.ts

@@ -21,6 +21,20 @@ interface ReviewCritiqueProjection {
   overall_decision?: string;
 }
 
+interface ReviewPacketProjection {
+  readiness?: {
+    status?: "ready" | "warning" | "blocking";
+  };
+  decision?: {
+    outcome?: string;
+    recommended_transition?: string;
+  };
+}
+
+interface ReviewScorecardProjection {
+  overall_score_1_to_5?: number;
+}
+
 interface PaperReadinessProjection {
   paper_ready?: boolean;
   readiness_state?: string;
@@ -77,7 +91,9 @@ export async function buildRunJobsSnapshot(input: {
 
   return {
     generated_at: new Date().toISOString(),
-    runs: projected.map(stripInternalProjection),
+    runs: projected
+      .sort((left, right) => Date.parse(right.last_event_at) - Date.parse(left.last_event_at))
+      .map(stripInternalProjection),
     top_failures: summarizeFailures(projected)
   };
 }
@@ -93,13 +109,21 @@ export async function buildAnalyzeResultsOperatorSummary(input: {
   const transitionRecommendation = await readJsonArtifact<Record<string, unknown>>(
     path.join(runDir, "transition_recommendation.json")
   );
+  const reviewPacket = await readJsonArtifact<ReviewPacketProjection>(
+    path.join(runDir, "review", "review_packet.json")
+  );
+  const reviewScorecard = await readJsonArtifact<ReviewScorecardProjection>(
+    path.join(runDir, "review", "scorecard.json")
+  );
 
   const artifactRefs = [
     maybeArtifactRef(projected.analysis_ready, "Analysis report", "result_analysis.json"),
     maybeArtifactRef(projected.analysis_ready, "Transition recommendation", "transition_recommendation.json"),
-    maybeArtifactRef(projected.review_ready, "Review packet", "review/review_packet.json"),
+    maybeArtifactRef(Boolean(reviewPacket), "Review packet", "review/review_packet.json"),
+    maybeArtifactRef(Boolean(reviewScorecard), "Review scorecard", "review/scorecard.json"),
     maybeArtifactRef(projected.review_ready, "Paper critique", "review/paper_critique.json"),
     maybeArtifactRef(projected.review_ready, "Review minimum gate", "review/minimum_gate.json"),
+    maybeArtifactRef(projected.review_ready, "Review readiness risks", "review/readiness_risks.json"),
     maybeArtifactRef(projected.paper_ready || Boolean(projected.paper_readiness_state), "Paper readiness", "paper/paper_readiness.json")
   ].filter((item): item is { label: string; path: string } => Boolean(item));
 
@@ -121,6 +145,26 @@ export async function buildAnalyzeResultsOperatorSummary(input: {
     lines.push(`Transition: ${transitionRecommendation.action}${target}.`);
   }
 
+  if (!projected.review_ready) {
+    lines.push("Review gate: not started yet or still missing one of the required review artifacts.");
+  } else if (projected.review_gate_status || projected.review_decision_outcome) {
+    const transitionHint = projected.review_recommended_transition
+      ? ` -> ${projected.review_recommended_transition}`
+      : "";
+    const decisionHint = projected.review_decision_outcome
+      ? `${projected.review_decision_outcome}${transitionHint}`
+      : projected.review_gate_status;
+    lines.push(`Review gate: ${decisionHint}.`);
+  }
+
+  if (typeof projected.review_score_overall === "number") {
+    lines.push(`Review scorecard: ${projected.review_score_overall}/5 overall.`);
+  }
+
+  if (projected.paper_readiness_state) {
+    lines.push(`Paper readiness state: ${projected.paper_readiness_state}.`);
+  }
+
   if (projected.blocker_summary) {
     lines.push(`Blocker: ${projected.blocker_summary}`);
   }
@@ -148,9 +192,16 @@ export function buildJobsTemplateLines(input: {
 }): string[] {
   const activeCount = input.snapshot.runs.filter((run) => run.lifecycle_status !== "completed").length;
   const blockedCount = input.snapshot.runs.filter((run) => run.recommended_next_action === "inspect_blocker").length;
+  const reviewPendingCount = input.snapshot.runs.filter(
+    (run) => run.recommended_next_action === "resume_review" || run.current_node === "review"
+  ).length;
+  const paperBlockedCount = input.snapshot.runs.filter(
+    (run) => Boolean(run.paper_readiness_state) && !run.paper_ready
+  ).length;
   return [
     `${input.window === "3d" ? "3-day" : "7-day"} operator check-in template`,
     `Runs in view: ${input.snapshot.runs.length}. Active: ${activeCount}. Blocked for inspection: ${blockedCount}.`,
+    `Review-adjacent runs: ${reviewPendingCount}. Paper-blocked runs: ${paperBlockedCount}.`,
     "1. Confirm the current_node and recommended_next_action for the top active runs.",
     "2. Inspect one blocker artifact before retrying any failed or paused run.",
     "3. Verify whether review is the next governed gate before treating a run as paper-ready.",
@@ -200,6 +251,12 @@ async function buildRunJobProjectionInternal(input: {
   const reviewCritique = await readJsonArtifact<ReviewCritiqueProjection>(
     path.join(runDir, "review", "paper_critique.json")
   );
+  const reviewPacket = await readJsonArtifact<ReviewPacketProjection>(
+    path.join(runDir, "review", "review_packet.json")
+  );
+  const reviewScorecard = await readJsonArtifact<ReviewScorecardProjection>(
+    path.join(runDir, "review", "scorecard.json")
+  );
   const lifecycleStatus = deriveLifecycleStatus(input.run);
   const lastEventAt = await readLastEventTimestamp(runDir, input.run.updatedAt);
   const dominantFailure = deriveDominantFailure({
@@ -229,8 +286,16 @@ async function buildRunJobProjectionInternal(input: {
     analysis_ready: analysisReady,
     review_ready: reviewReady,
     paper_ready: paperReady,
+    review_gate_status: normalizeReviewGateStatus(reviewPacket?.readiness?.status),
+    review_decision_outcome: asNonEmptyString(reviewPacket?.decision?.outcome),
+    review_recommended_transition: asNonEmptyString(reviewPacket?.decision?.recommended_transition),
+    review_score_overall:
+      typeof reviewScorecard?.overall_score_1_to_5 === "number"
+        ? Number(reviewScorecard.overall_score_1_to_5.toFixed(1))
+        : undefined,
     paper_readiness_state:
       asNonEmptyString(paperReadiness?.readiness_state) || asNonEmptyString(reviewCritique?.paper_readiness_state),
+    paper_readiness_reason: asNonEmptyString(paperReadiness?.reason),
     blocker_summary: dominantFailure?.summary,
     dominantFailure
   };
@@ -248,7 +313,12 @@ function stripInternalProjection(input: RunJobProjectionInternal): RunJobProject
     analysis_ready: input.analysis_ready,
     review_ready: input.review_ready,
     paper_ready: input.paper_ready,
+    review_gate_status: input.review_gate_status,
+    review_decision_outcome: input.review_decision_outcome,
+    review_recommended_transition: input.review_recommended_transition,
+    review_score_overall: input.review_score_overall,
     paper_readiness_state: input.paper_readiness_state,
+    paper_readiness_reason: input.paper_readiness_reason,
     blocker_summary: input.blocker_summary
   };
 }
@@ -480,6 +550,15 @@ function asNonEmptyString(value: unknown): string | undefined {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
 }
 
+function normalizeReviewGateStatus(
+  value: "ready" | "warning" | "blocking" | undefined
+): RunJobProjection["review_gate_status"] {
+  if (value === "ready" || value === "warning" || value === "blocking") {
+    return value;
+  }
+  return undefined;
+}
+
 function yesNo(value: boolean): string {
   return value ? "yes" : "no";
 }
@@ -524,6 +603,21 @@ export function formatRunJobProjectionLines(input: {
     `  readiness: analysis=${yesNo(input.projection.analysis_ready)} review=${yesNo(input.projection.review_ready)} paper=${yesNo(input.projection.paper_ready)} | next=${input.projection.recommended_next_action}`,
     `  last event: ${input.projection.last_event_at}`
   ];
+  if (input.projection.review_gate_status || input.projection.review_decision_outcome || typeof input.projection.review_score_overall === "number") {
+    const gateLabel = input.projection.review_decision_outcome
+      ? `${input.projection.review_decision_outcome}${input.projection.review_recommended_transition ? ` -> ${input.projection.review_recommended_transition}` : ""}`
+      : input.projection.review_gate_status || "missing";
+    const scoreLabel = typeof input.projection.review_score_overall === "number"
+      ? ` | score=${input.projection.review_score_overall}/5`
+      : "";
+    lines.push(`  review gate: ${gateLabel}${scoreLabel}`);
+  }
+  if (input.projection.paper_readiness_state) {
+    const paperDetail = input.projection.paper_readiness_reason
+      ? ` | ${compactOneLine(input.projection.paper_readiness_reason, 120)}`
+      : "";
+    lines.push(`  paper state: ${input.projection.paper_readiness_state}${paperDetail}`);
+  }
   if (input.projection.blocker_summary) {
     lines.push(`  blocker: ${compactOneLine(input.projection.blocker_summary, 180)}`);
   }

src/interaction/InteractionSession.ts

@@ -1224,9 +1224,11 @@ export class InteractionSession {
       maxHarnessFindings: 30
     });
     this.pushLog(
-      `[${report.readiness.blocked ? "ATTN" : "OK"}] readiness: approval=${report.readiness.approvalMode}, `
+      `[${report.readiness.blocked ? "ATTN" : "OK"}] readiness: llm=${report.readiness.llmMode || "unknown"}, `
+        + `pdf=${report.readiness.pdfAnalysisMode || "unknown"}, approval=${report.readiness.approvalMode}, `
         + `execution=${report.readiness.executionApprovalMode}, dependency=${report.readiness.dependencyMode}, `
-        + `session=${report.readiness.sessionMode}, network=${formatDoctorNetworkSummary(report.readiness)}`
+        + `session=${report.readiness.sessionMode}, isolation=${report.readiness.candidateIsolation || "not-configured"}, `
+        + `network=${formatDoctorNetworkSummary(report.readiness)}`
     );
     for (const line of buildDoctorHighlightLines(report)) {
       this.pushLog(line);

src/tui/TerminalApp.ts

@@ -2623,9 +2623,11 @@ export class TerminalApp {
       maxHarnessFindings: 30
     });
     this.pushLog(
-      `[${report.readiness.blocked ? "ATTN" : "OK"}] readiness: approval=${report.readiness.approvalMode}, `
+      `[${report.readiness.blocked ? "ATTN" : "OK"}] readiness: llm=${report.readiness.llmMode || "unknown"}, `
+        + `pdf=${report.readiness.pdfAnalysisMode || "unknown"}, approval=${report.readiness.approvalMode}, `
         + `execution=${report.readiness.executionApprovalMode}, dependency=${report.readiness.dependencyMode}, `
-        + `session=${report.readiness.sessionMode}, network=${formatDoctorNetworkSummary(report.readiness)}`
+        + `session=${report.readiness.sessionMode}, isolation=${report.readiness.candidateIsolation || "not-configured"}, `
+        + `network=${formatDoctorNetworkSummary(report.readiness)}`
     );
     for (const line of buildDoctorHighlightLines(report)) {
       this.pushLog(line);