aiwcli 0.11.1 → 0.12.1

package/dist/templates/cc-native/_cc-native/lib-ts/state.ts

@@ -5,12 +5,13 @@
  */
 
 import * as fs from "node:fs";
-import * as path from "node:path";
+import * as path from "node:path";
+
+import { validatePlanPath } from "./constants.js";
+import type { IterationState, IterationEntry } from "./types.js";
 import { atomicWrite } from "../../_shared/lib-ts/base/atomic-write.js";
 import { logInfo, logWarn, logError } from "../../_shared/lib-ts/base/logger.js";
 import { nowIso } from "../../_shared/lib-ts/base/utils.js";
-import { validatePlanPath } from "./constants.js";
-import type { IterationState, IterationEntry } from "./types.js";
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -72,11 +73,11 @@ export function loadState(planPath: string): Record<string, unknown> | null {
     }
 
     return state;
-  } catch (e: unknown) {
-    if (e instanceof Error && e.message.includes("Invalid plan path")) {
-      logError("state", `SECURITY: Invalid plan path: ${e}`);
+  } catch (error: unknown) {
+    if (error instanceof Error && error.message.includes("Invalid plan path")) {
+      logError("state", `SECURITY: Invalid plan path: ${error}`);
     } else {
-      logError("state", `Failed to load state: ${e}`);
+      logError("state", `Failed to load state: ${error}`);
     }
     return null;
   }
@@ -109,11 +110,11 @@ export function saveStateToPlan(
     }
 
     return true;
-  } catch (e: unknown) {
-    if (e instanceof Error && e.message.includes("Invalid plan path")) {
-      logError("state", `SECURITY: Invalid plan path: ${e}`);
+  } catch (error: unknown) {
+    if (error instanceof Error && error.message.includes("Invalid plan path")) {
+      logError("state", `SECURITY: Invalid plan path: ${error}`);
     } else {
-      logError("state", String(e));
+      logError("state", String(error));
     }
     return false;
   }
@@ -131,12 +132,12 @@ export function deleteState(planPath: string): boolean {
       logInfo("state", `Deleted state file: ${stateFile}`);
     }
     return true;
-  } catch (e: unknown) {
-    if (e instanceof Error && e.message.includes("Invalid plan path")) {
-      logError("state", `SECURITY: Invalid plan path in delete: ${e}`);
+  } catch (error: unknown) {
+    if (error instanceof Error && error.message.includes("Invalid plan path")) {
+      logError("state", `SECURITY: Invalid plan path in delete: ${error}`);
       return false;
     }
-    logWarn("state", `Failed to delete state file: ${e}`);
+    logWarn("state", `Failed to delete state file: ${error}`);
     return false;
   }
 }
@@ -207,7 +208,7 @@ export function shouldContinueIterating(
   verdict: string,
   config?: Record<string, unknown>,
 ): boolean {
-  const current = iteration.current;
+  const {current} = iteration;
   const maxIter = iteration.max;
 
   // At or past max iterations

package/dist/templates/cc-native/_cc-native/lib-ts/types.ts

@@ -65,7 +65,7 @@ export interface CorroborationResult {
   blocking: CorroboratedGroup[];
   solo: SoloFinding[];
   unclassified: Array<{ agent: string; issue: ReviewIssue }>;
-  verdict: "pass" | "fail";
+  verdict: "pass" | "warn" | "fail";
 }
 
 /** Normalized review data from any reviewer */
@@ -102,7 +102,6 @@ export interface OrchestratorResult {
 export interface CombinedReviewResult {
   plan_hash: string;
   overall_verdict: Verdict;
-  cli_reviewers: Record<string, ReviewerResult>;
   orchestration: OrchestratorResult | null;
   agents: Record<string, ReviewerResult>;
   timestamp: string;
@@ -194,8 +193,16 @@ export interface PlanReviewState {
 
 /** Questions-asked tracking state */
 export interface QuestionsAskedState {
-  asked: boolean;
+  asked: boolean; // Backward-compatible: true if either phase asked
   asked_at: string;
+  early_questions_asked?: {
+    asked: boolean;
+    asked_at: string;
+  };
+  plan_questions_agent_asked?: {
+    asked: boolean;
+    asked_at: string;
+  };
 }
 
 /** Stuck detection state — tracks repeated errors, file edits, and test failures */
@@ -262,112 +269,10 @@ export interface Reviewer {
 }
 
 // ---------------------------------------------------------------------------
-// JSON Schemas
-// ---------------------------------------------------------------------------
-
-/** JSON schema for review structured output */
-export const REVIEW_SCHEMA: Record<string, unknown> = {
-  type: "object",
-  properties: {
-    verdict: { type: "string", enum: ["pass", "warn", "fail"] },
-    summary: { type: "string", minLength: 20 },
-    issues: {
-      type: "array",
-      items: {
-        type: "object",
-        properties: {
-          severity: { type: "string", enum: ["high", "medium", "low"] },
-          category: { type: "string" },
-          issue: { type: "string" },
-          suggested_fix: { type: "string" },
-          dimension: {
-            type: "string",
-            enum: [
-              "completeness", "simplicity", "security", "performance",
-              "reliability", "maintainability", "testability", "scope",
-              "feasibility", "clarity",
-            ],
-          },
-        },
-        required: ["severity", "category", "issue", "suggested_fix"],
-        additionalProperties: false,
-      },
-    },
-    missing_sections: { type: "array", items: { type: "string" } },
-    questions: { type: "array", items: { type: "string" } },
-  },
-  required: ["verdict", "summary", "issues", "missing_sections", "questions"],
-  additionalProperties: false,
-};
-
-/** JSON schema for orchestrator structured output */
-export const ORCHESTRATOR_SCHEMA: Record<string, unknown> = {
-  type: "object",
-  properties: {
-    complexity: { type: "string", enum: ["simple", "medium", "high"] },
-    category: {
-      type: "string",
-      enum: [
-        "code",
-        "infrastructure",
-        "documentation",
-        "life",
-        "business",
-        "design",
-        "research",
-      ],
-    },
-    selectedAgents: { type: "array", items: { type: "string" } },
-    reasoning: { type: "string" },
-    skipReason: { type: "string" },
-  },
-  required: ["complexity", "category", "selectedAgents", "reasoning"],
-  additionalProperties: false,
-};
-
-// ---------------------------------------------------------------------------
-// Prompt Constants
+// JSON Schemas (moved to reviewers/schemas.ts)
 // ---------------------------------------------------------------------------
-
-export const REVIEW_PROMPT_PREFIX = `You are a senior staff software engineer acting as a strict plan reviewer.
-
-Review the PLAN below. Focus on:
-- missing steps, unclear assumptions, edge cases
-- security/privacy concerns
-- testing/rollout/rollback completeness
-- operational concerns (observability, failure modes)
-`;
-
-export const AGENT_REVIEW_PROMPT_PREFIX = `# SINGLE-TURN PLAN REVIEW
-
-## CRITICAL: ONE TURN ONLY
-You have exactly ONE response to complete this review. Do NOT attempt multi-step workflows, context queries, or phased analysis. Analyze the plan and output your review immediately.
-
-## YOUR TASK
-Review the plan below from your area of expertise. Then call StructuredOutput with your assessment.
-
-## REQUIRED OUTPUT (all fields must have content)
-Call StructuredOutput with:
-- **verdict**: "pass" (no concerns), "warn" (some concerns), or "fail" (critical issues)
-- **summary**: 2-3 sentences with your overall assessment and key findings (REQUIRED)
-- **issues**: Array of concerns found. Format each as:
-  {"severity": "high/medium/low", "category": "...", "issue": "...", "suggested_fix": "...", "dimension": "..."}
-- **dimension**: Classify each issue into exactly one dimension:
-  completeness, simplicity, security, performance, reliability,
-  maintainability, testability, scope, feasibility, or clarity.
-  Examples: "missing error handling" → reliability, "excessive abstraction" → simplicity,
-  "no test strategy" → testability, "missing deployment steps" → completeness,
-  "unclear interaction between components" → clarity.
-- **missing_sections**: Topics the plan should address but doesn't
-- **questions**: Things that need clarification before implementation
-
-## IMPORTANT RULES
-1. A "warn" verdict MUST include at least one issue explaining why
-2. Summary MUST explain your reasoning, not just "looks good" or empty
-3. Focus on your expertise area (architecture, security, performance, etc.)
-4. Output StructuredOutput NOW - no other tools, no questions, no delays
-5. Return ONLY your top 3 most critical issues. Prioritize high-severity over medium/low. Quality over quantity.
-`;
+// Re-export for backwards compatibility
+export { AGENT_REVIEW_PROMPT_PREFIX, ORCHESTRATOR_SCHEMA, REVIEW_PROMPT_PREFIX, REVIEW_SCHEMA } from "./reviewers/schemas.js";
 
 // ---------------------------------------------------------------------------
 // Display Defaults

package/dist/templates/cc-native/_cc-native/lib-ts/verdict.ts

@@ -52,13 +52,13 @@ export function computeReviewDecision(
   );
 
   if (signalVerdicts.length === 0) {
-    return { should_deny: false, reason: "no_signal", score: 0.0 };
+    return { should_deny: false, reason: "no_signal", score: 0 };
   }
 
   // Fail blocks unconditionally
   const failCount = signalVerdicts.filter((v) => v === "fail").length;
   if (failCount > 0) {
-    return { should_deny: true, reason: "fail_veto", score: 1.0 };
+    return { should_deny: true, reason: "fail_veto", score: 1 };
   }
 
   // Warn also blocks — reviewers flagged concerns worth addressing
@@ -68,5 +68,5 @@ export function computeReviewDecision(
     return { should_deny: true, reason: "warn_block", score: warnRatio };
   }
 
-  return { should_deny: false, reason: "acceptable", score: 0.0 };
+  return { should_deny: false, reason: "acceptable", score: 0 };
 }

package/dist/templates/cc-native/_cc-native/plan-review.config.json

@@ -13,18 +13,6 @@
   },
   "planReview": {
     "enabled": true,
-    "reviewers": {
-      "codex": {
-        "enabled": true,
-        "model": "gpt-5.1-codex-mini",
-        "timeout": 120
-      },
-      "gemini": {
-        "enabled": false,
-        "model": "",
-        "timeout": 120
-      }
-    },
     "display": {
       "maxIssues": 12,
       "maxMissingSections": 12,
@@ -53,8 +41,8 @@
     },
     "reviewIterations": {
       "simple": 1,
-      "medium": 1,
-      "high": 2
+      "medium": 3,
+      "high": 5
     },
     "highIssueThreshold": 2,
     "earlyExitOnAllPass": true,

package/oclif.manifest.json

@@ -416,5 +416,5 @@
       ]
     }
   },
-  "version": "0.11.1"
+  "version": "0.12.1"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aiwcli",
   "description": "AI Workflow CLI - Command-line interface for AI-powered workflows",
-  "version": "0.11.1",
+  "version": "0.12.1",
   "author": "jofu-tofu",
   "bin": {
     "aiw": "bin/run.js"
@@ -21,7 +21,6 @@
   },
   "devDependencies": {
     "@eslint/compat": "^1",
-    "@oclif/prettier-config": "^0.2.1",
     "@oclif/test": "^4",
     "@types/chai": "^4",
     "@types/mocha": "^10",

package/dist/templates/cc-native/_cc-native/hooks/add_plan_context.ts

@@ -1,119 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Plan context hook — handles question marking and advisory question nudges.
- *
- * Registered for two events:
- * - PostToolUse: AskUserQuestion — marks that questions were asked this session.
- * - PreToolUse: Task — nudges Plan subagent to ask questions first (advisory, never blocks).
- *
- * All enforcement is advisory: injects additionalContext to guide Claude toward asking
- * non-obvious questions, but never blocks the tool call. Claude can proceed regardless.
- *
- * Fail-safe: Any error allows the action silently.
- */
-
-import { getProjectRoot } from "../../_shared/lib-ts/base/constants.js";
-import {
-  emitContext,
-  loadHookInput,
-  logDebug,
-  logDiagnostic,
-  logInfo,
-  runHook,
-} from "../../_shared/lib-ts/base/hook-utils.js";
-import { isInternalCall } from "../../_shared/lib-ts/base/subprocess-utils.js";
-import { getEvaluationContextReminder } from "../../_shared/lib-ts/templates/plan-context.js";
-import { markQuestionsAsked, wasQuestionsAsked } from "../lib-ts/cc-native-state.js";
-
-const CONTEXT_REMINDER = getEvaluationContextReminder();
-
-const TASK_ENFORCEMENT_CONTEXT =
-  "Before spawning a Plan agent, consider asking the user non-obvious questions " +
-  "via AskUserQuestion. Code exploration reveals WHAT exists — questions reveal WHAT MATTERS.\n\n" +
-  "Generate 5+ candidate questions across these categories, then keep only 3-4 where " +
-  "different answers would lead to meaningfully different plans:\n\n" +
-  "1. INTENT & SUCCESS CRITERIA — What does 'done well' look like? Are there multiple " +
-  "interpretations of this request? What's a 10 vs a 6?\n\n" +
-  "2. CONSTRAINTS & HISTORY — Has this been attempted before? Are there off-limits areas, " +
-  "performance requirements, or security considerations not visible in the code?\n\n" +
-  "3. TRADE-OFF PREFERENCES — Speed vs thoroughness? Minimal change vs clean architecture? " +
-  "Backward compatibility vs clean break?\n\n" +
-  "Frame each question with 2-3 concrete options so the user can choose rather than compose. " +
-  "Use AskUserQuestion with structured options — never ask questions as inline text.";
-
-function isPlanTask(payload: Record<string, unknown>): boolean {
-  const toolInput = payload.tool_input;
-  if (!toolInput || typeof toolInput !== "object") return false;
-  return String((toolInput as Record<string, unknown>).subagent_type ?? "") === "Plan";
-}
-
-function main(): void {
-  // Guard: skip for internal subprocess calls (prevents recursive hook execution)
-  if (isInternalCall()) return;
-
-  const payload = loadHookInput();
-  if (!payload) return;
-
-  const toolName = payload.tool_name;
-  const hookEvent = payload.hook_event_name ?? "unknown";
-  logDiagnostic(
-    "add_plan_context",
-    "receive",
-    `tool=${toolName}, event=${hookEvent}`,
-    { inputs: { tool_name: toolName, hook_event: hookEvent } },
-  );
-
-  const projectRoot = getProjectRoot(payload.cwd);
-
-  // PostToolUse: AskUserQuestion — mark that questions were asked
-  if (toolName === "AskUserQuestion") {
-    const sessionId = String(payload.session_id ?? "");
-    if (sessionId) {
-      markQuestionsAsked(sessionId, projectRoot);
-      logInfo("add_plan_context", `Marked questions asked for session ${sessionId.slice(0, 8)}...`);
-    }
-
-    return;
-  }
-
-  // PreToolUse: Task — nudge Plan subagent to ask questions first (advisory)
-  if (toolName === "Task") {
-    if (!isPlanTask(payload)) return; // Only gate Plan subagent spawns
-
-    const permissionMode = payload.permission_mode ?? "";
-    if (permissionMode !== "plan") return; // Only enforce during plan mode
-
-    const sessionId = payload.session_id;
-    if (!sessionId) {
-      logDebug("add_plan_context", "No session_id for Task gate, skipping enforcement");
-      return;
-    }
-
-    const sessionIdStr = String(sessionId);
-
-    if (wasQuestionsAsked(sessionIdStr, projectRoot)) {
-      logInfo("add_plan_context", "Questions asked, allowing Plan Task with eval context");
-      logDiagnostic(
-        "add_plan_context",
-        "decide",
-        "Questions asked, allowing Plan Task",
-        { decision: "allow_with_context", reasoning: "was_questions_asked=True" },
-      );
-      emitContext(CONTEXT_REMINDER);
-      return;
-    }
-
-    // Questions NOT asked: nudge toward asking questions (advisory only)
-    logInfo("add_plan_context", "Questions not asked - nudging Plan Task to ask first");
-    logDiagnostic(
-      "add_plan_context",
-      "decide",
-      "Questions not asked, nudging Plan Task",
-      { decision: "nudge", reasoning: "was_questions_asked=False, advisory context" },
-    );
-    emitContext(TASK_ENFORCEMENT_CONTEXT);
-    
-  }
-}
-
-runHook(main, "add_plan_context");

package/dist/templates/cc-native/_cc-native/lib-ts/reviewers/codex.ts

@@ -1,130 +0,0 @@
-/**
- * Codex CLI plan reviewer.
- * Runs Codex in non-interactive mode with read-only sandbox.
- * See cc-native-plan-review-spec.md §4.11
- */
-
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { logDebug, logInfo, logWarn, logError } from "../../../_shared/lib-ts/base/logger.js";
-import { findExecutable, execFileAsync } from "../../../_shared/lib-ts/base/subprocess-utils.js";
-import { parseJsonMaybe, coerceToReview } from "../json-parser.js";
-import { REVIEW_PROMPT_PREFIX } from "../types.js";
-import type { ReviewerResult, ReviewOptions } from "../types.js";
-import { makeResult } from "./types.js";
-import type { Reviewer } from "./types.js";
-
-/**
- * Codex reviewer — runs codex exec --sandbox read-only.
- */
-export class CodexReviewer implements Reviewer {
-  private settings: Record<string, unknown>;
-
-  constructor(settings: Record<string, unknown>) {
-    this.settings = settings;
-  }
-
-  async review(
-    plan: string,
-    schema: Record<string, unknown>,
-    options: ReviewOptions,
-  ): Promise<ReviewerResult> {
-    return runCodexReview(plan, schema, this.settings);
-  }
-}
-
-/**
- * Run Codex CLI to review the plan.
- * Never throws — returns error ReviewerResult on failure.
- */
-export async function runCodexReview(
-  plan: string,
-  schema: Record<string, unknown>,
-  settings: Record<string, unknown>,
-): Promise<ReviewerResult> {
-  const codexSettings =
-    ((settings.reviewers as Record<string, unknown> | undefined)?.codex as
-      | Record<string, unknown>
-      | undefined) ?? {};
-  const timeout = (codexSettings.timeout as number) ?? 120;
-  const model = (codexSettings.model as string) ?? "";
-
-  const codexPath = findExecutable("codex");
-  if (!codexPath) {
-    logWarn("codex", "CLI not found on PATH");
-    return makeResult("codex", false, "skip", {}, "", "codex CLI not found on PATH");
-  }
-
-  logDebug("codex", `Found CLI at: ${codexPath}`);
-
-  const prompt = `${REVIEW_PROMPT_PREFIX}
-Return ONLY a JSON object that matches this JSON Schema:
-${JSON.stringify(schema)}
-
-PLAN:
-<<<
-${plan}
->>>
-`;
-
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "codex-review-"));
-
-  try {
-    const schemaPath = path.join(tmpDir, "schema.json");
-    const outPath = path.join(tmpDir, "codex_review.json");
-
-    fs.writeFileSync(schemaPath, JSON.stringify(schema, null, 2), "utf-8");
-
-    const cmdArgs = ["exec", "--sandbox", "read-only"];
-
-    if (model) {
-      cmdArgs.push("--model", model);
-    }
-
-    cmdArgs.push("--output-schema", schemaPath, "-o", outPath, "-");
-
-    logDebug("codex", `Running command: codex ${cmdArgs.join(" ")}`);
-
-    const result = await execFileAsync(codexPath, cmdArgs, {
-      input: prompt,
-      timeout: timeout * 1000,
-      maxBuffer: 10 * 1024 * 1024,
-      shell: process.platform === "win32",
-    });
-
-    if (result.killed || result.signal === "SIGTERM") {
-      logWarn("codex", `TIMEOUT after ${timeout}s`);
-      return makeResult("codex", false, "error", {}, "", `codex timed out after ${timeout}s`);
-    }
-
-    if (!result.stdout && !result.stderr && !fs.existsSync(outPath) && result.exitCode !== 0) {
-      logError("codex", `Process exited with code ${result.exitCode} and no output`);
-      return makeResult("codex", false, "error", {}, "", `codex failed to run (exit ${result.exitCode})`);
-    }
-
-    logDebug("codex", `Exit code: ${result.exitCode}`);
-
-    let raw = "";
-    if (fs.existsSync(outPath)) {
-      raw = fs.readFileSync(outPath, "utf-8");
-    }
-
-    const obj = parseJsonMaybe(raw) ?? parseJsonMaybe(result.stdout);
-    const [ok, verdict, norm] = coerceToReview(
-      obj,
-      "Retry or check CLI auth/config.",
-    );
-
-    const err = result.stderr.trim();
-    return makeResult("codex", ok, verdict, norm, raw || result.stdout, err);
-  } finally {
-    // Clean up temp directory
-    try {
-      fs.rmSync(tmpDir, { recursive: true, force: true });
-    } catch {
-      // Best effort cleanup
-    }
-  }
-}
-

package/dist/templates/cc-native/_cc-native/lib-ts/reviewers/gemini.ts

@@ -1,107 +0,0 @@
-/**
- * Gemini CLI plan reviewer.
- * Runs Gemini CLI in YOLO mode (auto-approve).
- * See cc-native-plan-review-spec.md §4.12
- */
-
-import { logDebug, logInfo, logWarn, logError } from "../../../_shared/lib-ts/base/logger.js";
-import { findExecutable, execFileAsync } from "../../../_shared/lib-ts/base/subprocess-utils.js";
-import { parseJsonMaybe, coerceToReview } from "../json-parser.js";
-import type { ReviewerResult, ReviewOptions } from "../types.js";
-import { makeResult } from "./types.js";
-import type { Reviewer } from "./types.js";
-
-/**
- * Gemini reviewer — runs gemini -y -p <instruction>.
- */
-export class GeminiReviewer implements Reviewer {
-  private settings: Record<string, unknown>;
-
-  constructor(settings: Record<string, unknown>) {
-    this.settings = settings;
-  }
-
-  async review(
-    plan: string,
-    schema: Record<string, unknown>,
-    options: ReviewOptions,
-  ): Promise<ReviewerResult> {
-    return runGeminiReview(plan, schema, this.settings);
-  }
-}
-
-/**
- * Run Gemini CLI to review the plan.
- * Never throws — returns error ReviewerResult on failure.
- */
-export async function runGeminiReview(
-  plan: string,
-  schema: Record<string, unknown>,
-  settings: Record<string, unknown>,
-): Promise<ReviewerResult> {
-  const geminiSettings =
-    ((settings.reviewers as Record<string, unknown> | undefined)?.gemini as
-      | Record<string, unknown>
-      | undefined) ?? {};
-  const timeout = (geminiSettings.timeout as number) ?? 120;
-  const model = (geminiSettings.model as string) ?? "";
-
-  const geminiPath = findExecutable("gemini");
-  if (!geminiPath) {
-    logWarn("gemini", "CLI not found on PATH");
-    return makeResult("gemini", false, "skip", {}, "", "gemini CLI not found on PATH");
-  }
-
-  logDebug("gemini", `Found CLI at: ${geminiPath}`);
-
-  const instruction = `
-
-Review the PLAN above as a senior staff software engineer. Focus on:
-- missing steps, unclear assumptions, edge cases
-- security/privacy concerns
-- testing/rollout/rollback completeness
-- operational concerns (observability, failure modes)
-
-Return ONLY a JSON object that matches this JSON Schema (no markdown, no code fences):
-${JSON.stringify(schema)}
-`;
-
-  const cmdArgs = ["-y", "-p", instruction];
-
-  if (model) {
-    cmdArgs.push("--model", model);
-  }
-
-  logDebug("gemini", "Running command: gemini -y -p <instruction>");
-
-  const result = await execFileAsync(geminiPath, cmdArgs, {
-    input: plan,
-    timeout: timeout * 1000,
-    maxBuffer: 10 * 1024 * 1024,
-    shell: process.platform === "win32",
-  });
-
-  if (result.killed || result.signal === "SIGTERM") {
-    logWarn("gemini", `TIMEOUT after ${timeout}s`);
-    return makeResult("gemini", false, "error", {}, "", `gemini timed out after ${timeout}s`);
-  }
-
-  if (!result.stdout && !result.stderr && result.exitCode !== 0) {
-    logError("gemini", `Process exited with code ${result.exitCode}`);
-    return makeResult("gemini", false, "error", {}, "", `gemini failed to run (exit ${result.exitCode})`);
-  }
-
-  logDebug("gemini", `Exit code: ${result.exitCode}`);
-
-  const raw = result.stdout.trim();
-  const err = result.stderr.trim();
-
-  const obj = parseJsonMaybe(raw);
-  const [ok, verdict, norm] = coerceToReview(
-    obj,
-    "Retry or check CLI auth/config.",
-  );
-
-  return makeResult("gemini", ok, verdict, norm, raw, err);
-}
-