nugit-cli 0.1.0 → 0.1.1

package/src/stack-view/run-stack-view.js

@@ -14,17 +14,11 @@ import {
 import {
   findGitRoot,
   parseRepoFullName,
-  readStackFile,
-  validateStackDoc,
   createInferredStackDoc
 } from "../nugit-stack.js";
 import { getRepoFullNameFromGitRoot } from "../git-info.js";
-import { discoverStacksInRepo, stackTipPrNumber } from "../stack-discover.js";
-import { getStackDiscoveryOpts, effectiveMaxOpenPrs } from "../stack-discovery-config.js";
-import { tryLoadStackIndex, writeStackIndex } from "../stack-graph.js";
 import { fetchStackPrDetails } from "./fetch-pr-data.js";
-import { loadStackDocForView } from "./loader.js";
-import { inferStackDocForRemoteView, isGithubNotFoundError } from "./remote-infer-doc.js";
+import { inferStackDocForRemoteView } from "./remote-infer-doc.js";
 import { getRepoMetadata } from "../api-client.js";
 import { StackInkApp, createExitPayload } from "./ink-app.js";
 import { renderStaticStackView } from "./static-render.js";
@@ -43,56 +37,16 @@ import { RepoPickerBackError } from "./repo-picker-back.js";
 import { ReviewHubBackError } from "../review-hub/review-hub-back.js";
 import {
   augmentAlternatePickStacksWithInfer,
-  ensureDocRepresentedInPickStacks
+  ensureDocRepresentedInPickStacks,
+  stackDocToPickStackRow
 } from "./merge-alternate-pick-stacks.js";
+import { stackTipPrNumber } from "./merge-alternate-pick-stacks.js";
 import { withStackLoadInkScreen } from "./loading-ink.js";
+import { discoverStacksByInference } from "../services/stack-inference.js";
 
-/**
- * @param {string} owner
- * @param {string} repoName
- * @param {Record<string, unknown>} doc
- * @param {{ viewerLogin?: string, defaultBranch?: string, fullReviewFetch?: boolean }} mergedReviewFetch
- * @param {boolean} [reviewAutoapply]
- */
-export async function fetchStackRowsWithAutoapply(
-  owner,
-  repoName,
-  doc,
-  mergedReviewFetch,
-  reviewAutoapply
-) {
-  let rows = await fetchStackPrDetails(owner, repoName, doc.prs, 6, mergedReviewFetch);
-
-  if (reviewAutoapply && resolveGithubToken() && mergedReviewFetch.viewerLogin) {
-    const cfg = loadReviewAutoapproveConfig();
-    if (cfg) {
-      let approvedAny = false;
-      for (const row of rows) {
-        if (row.error || !row.pull) continue;
-        const head = row.pull.head && typeof row.pull.head === "object" ? row.pull.head : {};
-        const headRef = typeof head.ref === "string" ? head.ref : "";
-        if (!isRepoHeadAutoapproveEligible(cfg, owner, repoName, headRef)) continue;
-        const m = row.viewerReviewMeta;
-        if (!m?.staleApproval || m.riskyChangeAfterApproval) continue;
-        const ms = row.pull.mergeable_state;
-        if (ms && ms !== "clean" && ms !== "unstable") continue;
-        try {
-          await githubPostPullReview(owner, repoName, row.entry.pr_number, {
-            event: "APPROVE",
-            body: "nugit auto-approve: merge-only delta (review-autoapprove.json)"
-          });
-          approvedAny = true;
-        } catch {
-          /* ignore per-PR */
-        }
-      }
-      if (approvedAny) {
-        rows = await fetchStackPrDetails(owner, repoName, doc.prs, 6, mergedReviewFetch);
-      }
-    }
-  }
-  return rows;
-}
+// ---------------------------------------------------------------------------
+// Spinner helper (stderr, non-TUI)
+// ---------------------------------------------------------------------------
 
 function createSpinner(prefix) {
   const frames = [chalk.cyan("⠋"), chalk.cyan("⠙"), chalk.cyan("⠹"), chalk.cyan("⠸"), chalk.cyan("⠼"), chalk.cyan("⠴")];
@@ -100,13 +54,9 @@ function createSpinner(prefix) {
   let msg = "starting...";
   let timer = null;
   return {
-    update(nextMsg) {
-      msg = nextMsg || msg;
-    },
+    update(nextMsg) { msg = nextMsg || msg; },
     start() {
-      if (!process.stderr.isTTY) {
-        return;
-      }
+      if (!process.stderr.isTTY) return;
       timer = setInterval(() => {
         const frame = frames[i % frames.length];
         i += 1;
@@ -115,24 +65,20 @@ function createSpinner(prefix) {
     },
     stop(finalMsg) {
       if (!process.stderr.isTTY) {
-        if (finalMsg) {
-          console.error(`${prefix} ${finalMsg}`);
-        }
+        if (finalMsg) console.error(`${prefix} ${finalMsg}`);
         return;
       }
-      if (timer) {
-        clearInterval(timer);
-      }
+      if (timer) clearInterval(timer);
       const done = finalMsg ? `${chalk.bold(prefix)} ${chalk.green(finalMsg)}` : "";
       process.stderr.write(`\r${done}${" ".repeat(30)}\n`);
     }
   };
 }
 
-/**
- * @param {{ tip_pr_number: number, tip_head_branch: string, pr_count: number, created_by: string }[]} stacks
- * @returns {Promise<number>}
- */
+// ---------------------------------------------------------------------------
+// Non-TUI stack picker (stdin prompt fallback)
+// ---------------------------------------------------------------------------
+
 async function pickDiscoveredStackIndex(stacks) {
   const stackTree = (s) => {
     const prs = Array.isArray(s.prs) ? s.prs : [];
@@ -159,26 +105,18 @@ async function pickDiscoveredStackIndex(stacks) {
       );
       console.error(stackTree(s));
     }
-    const ans = String(
-      await questionLine(chalk.green("Select stack number (empty=cancel): "))
-    ).trim();
-    if (!ans) {
-      return -1;
-    }
+    const ans = String(await questionLine(chalk.green("Select stack number (empty=cancel): "))).trim();
+    if (!ans) return -1;
     const n = Number.parseInt(ans, 10);
-    if (Number.isInteger(n) && n >= 1 && n <= stacks.length) {
-      return n - 1;
-    }
+    if (Number.isInteger(n) && n >= 1 && n <= stacks.length) return n - 1;
     console.error("Invalid choice.");
   }
 }
 
-/**
- * @param {string} owner
- * @param {string} repo
- * @param {number} prNumber
- * @returns {Promise<string[]>}
- */
+// ---------------------------------------------------------------------------
+// Reviewer prompt
+// ---------------------------------------------------------------------------
+
 async function promptReviewers(owner, repo, prNumber) {
   let candidates = [];
   const spin = createSpinner("Loading reviewers");
@@ -186,9 +124,7 @@ async function promptReviewers(owner, repo, prNumber) {
   try {
     const users = await githubListAssignableUsers(owner, repo);
     candidates = Array.isArray(users)
-      ? users
-          .map((u) => (u && typeof u === "object" ? String(u.login || "") : ""))
-          .filter(Boolean)
+      ? users.map((u) => (u && typeof u === "object" ? String(u.login || "") : "")).filter(Boolean)
       : [];
   } catch {
     candidates = [];
@@ -204,10 +140,7 @@ async function promptReviewers(owner, repo, prNumber) {
     console.error(chalk.yellow("No assignable users listed by GitHub. You can still type logins."));
   }
   const raw = await questionLine(chalk.green("Assign Reviewers (empty=cancel): "));
-  const parts = raw
-    .split(",")
-    .map((s) => s.trim())
-    .filter(Boolean);
+  const parts = raw.split(",").map((s) => s.trim()).filter(Boolean);
   const chosen = [];
   for (const p of parts) {
     const n = Number.parseInt(p, 10);
@@ -220,318 +153,222 @@ async function promptReviewers(owner, repo, prNumber) {
   return [...new Set(chosen)];
 }
 
+// ---------------------------------------------------------------------------
+// Auto-approve helper
+// ---------------------------------------------------------------------------
+
 /**
- * When the viewer opens with an explicit ref (repo picker, `nugit view owner/repo`, etc.),
- * `discoverableStacks` is never set. Populate from `.nugit/stack-index.json` or a scan so
- * Backspace can reopen the multi-stack Ink picker.
- *
- * @param {string | null} root
- * @param {string} repoFull
  * @param {string} owner
  * @param {string} repoName
- * @param {unknown[] | null} current
- * @param {boolean} tuiSession
- * @returns {Promise<{ stacks: unknown[] | null, openPullNumbers: Set<number> | null }>}
+ * @param {Record<string, unknown>} doc
+ * @param {{ viewerLogin?: string, defaultBranch?: string, fullReviewFetch?: boolean }} mergedReviewFetch
+ * @param {boolean} [reviewAutoapply]
  */
-async function hydrateDiscoverableStacksForAlternatePicker(
-  root,
-  repoFull,
-  owner,
-  repoName,
-  current,
-  tuiSession
-) {
-  /** @type {{ stacks: unknown[] | null, openPullNumbers: Set<number> | null }} */
-  const wrap = (stacks, openPullNumbers = null) => ({ stacks, openPullNumbers });
+export async function fetchStackRowsWithAutoapply(owner, repoName, doc, mergedReviewFetch, reviewAutoapply) {
+  let rows = await fetchStackPrDetails(owner, repoName, doc.prs, 6, mergedReviewFetch);
 
-  if (!repoFull || !resolveGithubToken()) {
-    return wrap(current);
+  if (reviewAutoapply && resolveGithubToken() && mergedReviewFetch.viewerLogin) {
+    const cfg = loadReviewAutoapproveConfig();
+    if (cfg) {
+      let approvedAny = false;
+      for (const row of rows) {
+        if (row.error || !row.pull) continue;
+        const head = row.pull.head && typeof row.pull.head === "object" ? row.pull.head : {};
+        const headRef = typeof head.ref === "string" ? head.ref : "";
+        if (!isRepoHeadAutoapproveEligible(cfg, owner, repoName, headRef)) continue;
+        const m = row.viewerReviewMeta;
+        if (!m?.staleApproval || m.riskyChangeAfterApproval) continue;
+        const ms = row.pull.mergeable_state;
+        if (ms && ms !== "clean" && ms !== "unstable") continue;
+        try {
+          await githubPostPullReview(owner, repoName, row.entry.pr_number, {
+            event: "APPROVE",
+            body: "nugit auto-approve: merge-only delta (review-autoapprove.json)"
+          });
+          approvedAny = true;
+        } catch { /* ignore per-PR */ }
+      }
+      if (approvedAny) {
+        rows = await fetchStackPrDetails(owner, repoName, doc.prs, 6, mergedReviewFetch);
+      }
+    }
   }
+  return rows;
+}
 
-  if (current && Array.isArray(current) && current.length > 1) {
-    return augmentAlternatePickStacksWithInfer(owner, repoName, current);
-  }
+// ---------------------------------------------------------------------------
+// Alternate stack picker hydration (inference-only — no stack-index.json)
+// ---------------------------------------------------------------------------
 
-  if (root) {
-    const cached = tryLoadStackIndex(root, repoFull);
-    const stacks = cached && Array.isArray(cached.stacks) ? cached.stacks : null;
-    if (stacks && stacks.length > 1) {
-      return augmentAlternatePickStacksWithInfer(owner, repoName, stacks);
-    }
-  }
+/**
+ * Ensure the alternate picker has discoverable stacks; uses inference only.
+ */
+async function hydrateDiscoverableStacks(repoFull, owner, repoName, current, tuiSession) {
+  const wrap = (stacks, openPullNumbers = null) => ({ stacks, openPullNumbers });
 
-  const discovery = getStackDiscoveryOpts();
-  if (discovery.mode === "manual") {
-    return augmentAlternatePickStacksWithInfer(owner, repoName, Array.isArray(current) ? current : []);
+  if (!repoFull || !resolveGithubToken()) return wrap(current);
+  if (current && Array.isArray(current) && current.length > 1) {
+    return augmentAlternatePickStacksWithInfer(owner, repoName, current);
   }
 
-  const full =
-    process.env.NUGIT_STACK_DISCOVERY_FULL === "1" || process.env.NUGIT_STACK_DISCOVERY_FULL === "true";
   const spinner = createSpinner("Scanning stacks");
-  if (!tuiSession) {
-    spinner.start();
-  }
+  if (!tuiSession) spinner.start();
   try {
-    const discovered = await discoverStacksInRepo(owner, repoName, {
-      maxOpenPrs: effectiveMaxOpenPrs(discovery, full),
-      enrich: false,
-      fetchConcurrency: discovery.fetchConcurrency,
-      onProgress: (m) => (!tuiSession ? spinner.update(m) : undefined)
-    });
+    const { stacks, openPullNumbers } = await discoverStacksByInference(owner, repoName);
     if (!tuiSession) {
-      spinner.stop(
-        `found ${discovered.stacks_found} stack(s) across ${discovered.scanned_open_prs} open PR(s)`
-      );
+      spinner.stop(`found ${stacks.length} stack(s)`);
     }
-    if (root) {
-      try {
-        if (discovery.mode === "eager" || discovery.mode === "lazy") {
-          writeStackIndex(root, discovered);
-        }
-      } catch {
-        /* ignore index write */
-      }
-    }
-    if (discovered.stacks_found > 1) {
-      return augmentAlternatePickStacksWithInfer(owner, repoName, discovered.stacks);
-    }
-    if (discovered.stacks_found === 1) {
-      return augmentAlternatePickStacksWithInfer(owner, repoName, discovered.stacks);
-    }
-    return augmentAlternatePickStacksWithInfer(owner, repoName, []);
+    return { stacks, openPullNumbers };
   } catch {
-    if (!tuiSession) {
-      spinner.stop("scan failed");
-    }
+    if (!tuiSession) spinner.stop("scan failed");
     return augmentAlternatePickStacksWithInfer(owner, repoName, Array.isArray(current) ? current : []);
   }
 }
 
+// ---------------------------------------------------------------------------
+// Main entry
+// ---------------------------------------------------------------------------
+
 /**
  * @param {object} opts
  * @param {boolean} [opts.noTui]
  * @param {string} [opts.repo]
  * @param {string} [opts.ref]
  * @param {string} [opts.file]
- * @param {Record<string, unknown>} [opts.explicitDoc] skip discovery / stack.json load
+ * @param {Record<string, unknown>} [opts.explicitDoc] skip inference / load
  * @param {{ viewerLogin?: string, defaultBranch?: string, fullReviewFetch?: boolean }} [opts.reviewFetchOpts]
- * @param {string} [opts.viewTitle] Ink header
- * @param {boolean} [opts.reviewAutoapply] apply review-autoapprove.json rules once after load
- * @param {boolean} [opts.shellMode] multi-page nugit view layout (default true for TUI)
- * @param {boolean} [opts.allowBackToRepoPicker] inferred PR-group Ink picker: Backspace throws RepoPickerBackError (repo-picker loop only)
- * @param {boolean} [opts.allowBackToReviewHub] stack picker Backspace throws ReviewHubBackError (review hub loop only)
+ * @param {string} [opts.viewTitle]
+ * @param {boolean} [opts.reviewAutoapply]
+ * @param {boolean} [opts.shellMode]
+ * @param {boolean} [opts.allowBackToRepoPicker]
+ * @param {boolean} [opts.allowBackToReviewHub]
  */
 export async function runStackViewCommand(opts) {
   const tuiSession = !opts.noTui && process.stdin.isTTY && process.stdout.isTTY;
-  /** @type {unknown[] | null} Re-open stack picker (Backspace) when length > 1 */
+  /** @type {unknown[] | null} */
   let discoverableStacks = null;
 
   if (!resolveGithubToken()) {
     console.error(
       chalk.dim(
-        "No NUGIT_USER_TOKEN: using unauthenticated GitHub reads (low rate limit; public repos only for API data). Set a PAT for private repos, higher limits, or posting comments."
+        "No NUGIT_USER_TOKEN: using unauthenticated GitHub reads (low rate limit; public repos only). " +
+          "Set a PAT or run `nugit auth login` for private repos and higher limits."
       )
     );
   }
+
   const root = findGitRoot();
   let repo = opts.repo;
   let ref = opts.ref;
   let explicitDoc = opts.explicitDoc || null;
 
-  if (!explicitDoc && !opts.file && !ref) {
+  // If no explicit doc/file and no ref, discover stacks by inference
+  if (!explicitDoc && !opts.file) {
     let repoFull = repo || null;
     if (!repoFull && root) {
-      try {
-        repoFull = getRepoFullNameFromGitRoot(root);
-      } catch {
-        repoFull = null;
-      }
+      try { repoFull = getRepoFullNameFromGitRoot(root); } catch { repoFull = null; }
     }
     if (repoFull) {
-      const { owner, repo: repoName } = parseRepoFullName(repoFull);
-      const discovery = getStackDiscoveryOpts();
-      const full =
-        process.env.NUGIT_STACK_DISCOVERY_FULL === "1" || process.env.NUGIT_STACK_DISCOVERY_FULL === "true";
-      let discovered = null;
-      let usedCache = false;
-      if (discovery.mode === "manual" && root) {
-        discovered = tryLoadStackIndex(root, repoFull);
-        if (!discovered) {
-          throw new Error(
-            'Stack discovery mode is "manual". Run `nugit stack index` first or pass --repo/--ref explicitly.'
-          );
-        }
-        usedCache = true;
-      } else if (discovery.mode === "lazy" && root && !full) {
-        const cached = tryLoadStackIndex(root, repoFull);
-        if (cached) {
-          discovered = cached;
-          usedCache = true;
-        }
-      }
-      const discoverOpts = {
-        maxOpenPrs: effectiveMaxOpenPrs(discovery, full),
-        enrich: false,
-        fetchConcurrency: discovery.fetchConcurrency
-      };
+      const { owner: discO, repo: discR } = parseRepoFullName(repoFull);
       /** @type {object[]} */
       let mergedForPick = [];
 
+      const doDiscover = async () => {
+        const { stacks } = await discoverStacksByInference(discO, discR);
+        mergedForPick = stacks;
+      };
+
       if (tuiSession) {
-        await withStackLoadInkScreen("Loading stacks…", async () => {
-          if (!discovered) {
-            discovered = await discoverStacksInRepo(owner, repoName, {
-              ...discoverOpts,
-              onProgress: undefined
-            });
-            if (root) {
-              try {
-                if (discovery.mode === "eager" || discovery.mode === "lazy") {
-                  writeStackIndex(root, discovered);
-                }
-              } catch {
-                /* ignore index write */
-              }
-            }
-          }
-          const rawStacks = discovered && Array.isArray(discovered.stacks) ? discovered.stacks : [];
-          const aug = await augmentAlternatePickStacksWithInfer(owner, repoName, rawStacks);
-          mergedForPick = aug.stacks;
-        });
+        await withStackLoadInkScreen("Loading stacks…", doDiscover);
       } else {
-        if (!discovered) {
-          const spinner = createSpinner("Scanning stacks");
-          spinner.start();
-          discovered = await discoverStacksInRepo(owner, repoName, {
-            ...discoverOpts,
-            onProgress: (m) => spinner.update(m)
-          });
-          spinner.stop(
-            `found ${discovered.stacks_found} stack(s) across ${discovered.scanned_open_prs} open PR(s)`
-          );
-          if (root) {
-            try {
-              if (discovery.mode === "eager" || discovery.mode === "lazy") {
-                writeStackIndex(root, discovered);
-              }
-            } catch {
-              /* ignore index write */
-            }
-          }
-        } else if (usedCache) {
-          console.error(chalk.dim("Using .nugit/stack-index.json — set NUGIT_STACK_DISCOVERY_FULL=1 to rescan GitHub."));
-        }
-        const rawStacks = discovered && Array.isArray(discovered.stacks) ? discovered.stacks : [];
-        const aug = await augmentAlternatePickStacksWithInfer(owner, repoName, rawStacks);
-        mergedForPick = aug.stacks;
+        const sp = createSpinner("Scanning stacks");
+        sp.start();
+        await doDiscover();
+        sp.stop(`found ${mergedForPick.length} stack(s)`);
+      }
+
+      if (mergedForPick.length === 0 && !ref) {
+        throw new Error(`No open PR stacks found in ${repoFull}. Open some stacked PRs and try again.`);
       }
+
       if (mergedForPick.length > 1) {
         if (opts.noTui) {
-          console.log(
-            chalk.bold.cyan(`Stacks in ${repoFull}`) +
-              chalk.dim(
-                ` · ${mergedForPick.length} candidate(s) (PR heads with .nugit/stack.json + inferred same-repo chains)`
-              )
-          );
+          console.log(chalk.bold.cyan(`Stacks in ${repoFull}`) + chalk.dim(` · ${mergedForPick.length} candidate(s) (inferred from open PR chains)`));
           console.log("");
           for (const s of mergedForPick) {
-            const tag =
-              s && typeof s === "object" && /** @type {{ inferredOnly?: boolean }} */ (s).inferredOnly
-                ? chalk.dim(" (inferred)")
-                : "";
             const row = /** @type {{ tip_pr_number: number, pr_count: number, tip_head_branch: string }} */ (s);
-            console.log(
-              `  ${chalk.yellow("tip #" + row.tip_pr_number)} · ${row.pr_count} PR(s) · ${chalk.magenta(row.tip_head_branch)}${tag}`
-            );
+            console.log(`  ${chalk.yellow("tip #" + row.tip_pr_number)} · ${row.pr_count} PR(s) · ${chalk.magenta(row.tip_head_branch)}`);
           }
           console.log("");
-          console.log(chalk.dim("Re-run with a TTY to pick interactively, or pass --ref to a stack tip branch."));
+          console.log(chalk.dim("Re-run with a TTY to pick interactively, or pass --repo/--ref to open a specific stack."));
           return;
         }
-        const useInkPick =
-          !opts.noTui && process.stdin.isTTY && process.stdout.isTTY;
+
         discoverableStacks = mergedForPick;
-        /** @type {{ tip_head_branch: string } | null} */
-        let pickedStack = null;
-        if (useInkPick) {
-          const hasBack = !!(opts.allowBackToRepoPicker || opts.allowBackToReviewHub);
-          pickedStack = await pickStackIndexWithInk(mergedForPick, {
-            allowBackToRepo: hasBack,
-            escapeToRepo: hasBack
-          });
-          if (pickedStack === STACK_PICK_BACK_TO_REPO) {
-            if (opts.allowBackToReviewHub) {
-              throw new ReviewHubBackError();
-            }
-            if (opts.allowBackToRepoPicker) {
-              throw new RepoPickerBackError();
-            }
-            console.error(
-              chalk.dim("Backspace: repo list is only available when you start with `nugit view` (no args) from a TTY.")
-            );
-            return;
-          }
-        } else {
+        const hasBack = !!(opts.allowBackToRepoPicker || opts.allowBackToReviewHub);
+        const picked = tuiSession
+          ? await pickStackIndexWithInk(mergedForPick, { allowBackToRepo: hasBack, escapeToRepo: hasBack })
+          : null;
+
+        if (picked === STACK_PICK_BACK_TO_REPO) {
+          if (opts.allowBackToReviewHub) throw new ReviewHubBackError();
+          if (opts.allowBackToRepoPicker) throw new RepoPickerBackError();
+          return;
+        }
+
+        let pickedStack;
+        if (!tuiSession) {
           const idx = await pickDiscoveredStackIndex(
             /** @type {{ tip_head_branch: string, tip_pr_number: number, pr_count: number, created_by: string, prs: unknown[] }[]} */ (
               mergedForPick
             )
           );
-          if (idx < 0) {
-            console.error("Cancelled.");
-            return;
-          }
+          if (idx < 0) { console.error("Cancelled."); return; }
           pickedStack = mergedForPick[idx];
+        } else {
+          pickedStack = picked;
         }
+
         if (!pickedStack) {
-          if (opts.allowBackToReviewHub) {
-            throw new ReviewHubBackError();
-          }
-          if (opts.allowBackToRepoPicker) {
-            throw new RepoPickerBackError();
-          }
+          if (opts.allowBackToReviewHub) throw new ReviewHubBackError();
+          if (opts.allowBackToRepoPicker) throw new RepoPickerBackError();
           console.error("Cancelled.");
           return;
         }
+
         repo = repoFull;
         ref = pickedStack.tip_head_branch;
-        if (pickedStack.inferredOnly || pickedStack.inferredFromViewerDoc) {
-          const prNums = Array.isArray(pickedStack.prs)
-            ? pickedStack.prs
-                .filter((p) => p && typeof p === "object" && typeof p.pr_number === "number")
-                .sort((a, b) => (a.position ?? 0) - (b.position ?? 0))
-                .map((p) => p.pr_number)
-            : [];
-          if (prNums.length > 0) {
-            explicitDoc = createInferredStackDoc(repoFull, String(pickedStack.created_by || ""), prNums);
-          }
-        }
-        if (!tuiSession) {
-          console.error(`Viewing selected stack tip: ${repo}@${ref}`);
+        const prNums = Array.isArray(pickedStack.prs)
+          ? pickedStack.prs
+              .filter((p) => p && typeof p === "object" && typeof p.pr_number === "number")
+              .sort((a, b) => (a.position ?? 0) - (b.position ?? 0))
+              .map((p) => p.pr_number)
+          : [];
+        if (prNums.length > 0) {
+          explicitDoc = createInferredStackDoc(repoFull, String(pickedStack.created_by || ""), prNums);
         }
+        if (!tuiSession) console.error(`Viewing stack tip: ${repo}@${ref}`);
+
       } else if (mergedForPick.length === 1) {
+        const only = /** @type {{ tip_head_branch: string, created_by?: string, prs?: { pr_number: number, position?: number }[] }} */ (mergedForPick[0]);
         repo = repoFull;
-        const only = /** @type {{ tip_head_branch: string, inferredOnly?: boolean, inferredFromViewerDoc?: boolean, created_by?: string, prs?: { pr_number: number, position?: number }[] }} */ (mergedForPick[0]);
         ref = only.tip_head_branch;
         discoverableStacks = mergedForPick;
-        if (only.inferredOnly || only.inferredFromViewerDoc) {
-          const prNums = Array.isArray(only.prs)
-            ? only.prs
-                .filter((p) => p && typeof p === "object" && typeof p.pr_number === "number")
-                .sort((a, b) => (a.position ?? 0) - (b.position ?? 0))
-                .map((p) => p.pr_number)
-            : [];
-          if (prNums.length > 0) {
-            explicitDoc = createInferredStackDoc(repoFull, String(only.created_by || ""), prNums);
-          }
-        }
-        if (!tuiSession) {
-          console.error(`Viewing stack tip: ${repo}@${ref}`);
+        const prNums = Array.isArray(only.prs)
+          ? only.prs
+              .filter((p) => p && typeof p === "object" && typeof p.pr_number === "number")
+              .sort((a, b) => (a.position ?? 0) - (b.position ?? 0))
+              .map((p) => p.pr_number)
+          : [];
+        if (prNums.length > 0) {
+          explicitDoc = createInferredStackDoc(repoFull, String(only.created_by || ""), prNums);
         }
+        if (!tuiSession) console.error(`Viewing stack tip: ${repo}@${ref}`);
       }
     }
   }
 
+  // Resolve default branch if needed
   if (!ref && repo && !explicitDoc) {
     const { owner: dbO, repo: dbR } = parseRepoFullName(repo);
     const dbMeta = await getRepoMetadata(dbO, dbR);
@@ -553,89 +390,49 @@ export async function runStackViewCommand(opts) {
 
   if (explicitDoc) {
     doc = explicitDoc;
-    validateStackDoc(doc);
+  } else if (opts.file) {
+    const raw = fs.readFileSync(opts.file, "utf8");
+    doc = JSON.parse(raw);
   } else {
-    try {
-      const loaded = await loadStackDocForView({
-        root,
-        repo,
-        ref,
-        file: opts.file
-      });
-      doc = loaded.doc;
-    } catch (e) {
-      const canInfer =
-        repo &&
-        ref &&
-        !opts.file &&
-        resolveGithubToken() &&
-        isGithubNotFoundError(e);
-      if (!canInfer) {
-        throw e;
-      }
-      if (!tuiSession) {
-        console.error(
-          chalk.dim(
-            "No .nugit/stack.json on that ref — inferring stack from open PRs (same-repo). " +
-              "Use an explicit --ref to a branch that has stack.json if this is wrong."
-          )
-        );
-      }
-      const useInkInfer =
-        !opts.noTui && process.stdin.isTTY && process.stdout.isTTY;
-      const { doc: inferred, viewerLogin } = await inferStackDocForRemoteView(repo, {
-        interactivePick: !opts.noTui,
-        tuiChainPick: useInkInfer
-          ? (ch, pl) =>
-              pickInferChainIndexWithInk(ch, pl, { allowBackToRepo: !!(opts.allowBackToRepoPicker || opts.allowBackToReviewHub) })
-          : undefined
-      });
-      doc = inferred;
-      const { owner: oInf, repo: rInf } = parseRepoFullName(doc.repo_full_name);
-      const meta = await getRepoMetadata(oInf, rInf);
-      const defaultBranch = typeof meta.default_branch === "string" ? meta.default_branch : "main";
-      mergedReviewFetch = {
-        ...mergedReviewFetch,
-        viewerLogin: mergedReviewFetch?.viewerLogin || viewerLogin,
-        defaultBranch: mergedReviewFetch?.defaultBranch || defaultBranch,
-        fullReviewFetch: mergedReviewFetch?.fullReviewFetch ?? true
-      };
+    // Inference: no explicit doc, repo must be set
+    if (!repo) {
+      throw new Error("Cannot load stack: no repo specified. Pass --repo owner/repo or run inside a git clone.");
     }
+    const useInkInfer = !opts.noTui && process.stdin.isTTY && process.stdout.isTTY;
+    const { doc: inferred, viewerLogin } = await inferStackDocForRemoteView(repo, {
+      interactivePick: !opts.noTui,
+      tuiChainPick: useInkInfer
+        ? (ch, pl) => pickInferChainIndexWithInk(ch, pl, { allowBackToRepo: !!(opts.allowBackToRepoPicker || opts.allowBackToReviewHub) })
+        : undefined
+    });
+    doc = inferred;
+    const { owner: oInf, repo: rInf } = parseRepoFullName(doc.repo_full_name);
+    const meta = await getRepoMetadata(oInf, rInf);
+    const defaultBranch = typeof meta.default_branch === "string" ? meta.default_branch : "main";
+    mergedReviewFetch = {
+      ...mergedReviewFetch,
+      viewerLogin: mergedReviewFetch?.viewerLogin || viewerLogin,
+      defaultBranch: mergedReviewFetch?.defaultBranch || defaultBranch,
+      fullReviewFetch: mergedReviewFetch?.fullReviewFetch ?? true
+    };
   }
 
   let { owner, repo: repoName } = parseRepoFullName(doc.repo_full_name);
   let rows;
   const loadRowsOnce = async () => {
-    rows = await fetchStackRowsWithAutoapply(
-      owner,
-      repoName,
-      doc,
-      mergedReviewFetch,
-      !!opts.reviewAutoapply
-    );
+    rows = await fetchStackRowsWithAutoapply(owner, repoName, doc, mergedReviewFetch, !!opts.reviewAutoapply);
   };
   if (tuiSession) {
     await withStackLoadInkScreen("Loading stack…", loadRowsOnce);
   } else {
     const loadSpinner = createSpinner("Loading stack");
-    if (!tuiSession) {
-      loadSpinner.start();
-    }
+    loadSpinner.start();
     await loadRowsOnce();
-    if (!tuiSession) {
-      loadSpinner.stop(`loaded ${rows.length} PR(s)`);
-    }
+    loadSpinner.stop(`loaded ${rows.length} PR(s)`);
   }
 
   const repoFullStr = String(doc.repo_full_name || "");
-  const hydrated = await hydrateDiscoverableStacksForAlternatePicker(
-    root,
-    repoFullStr,
-    owner,
-    repoName,
-    discoverableStacks,
-    tuiSession
-  );
+  const hydrated = await hydrateDiscoverableStacks(repoFullStr, owner, repoName, discoverableStacks, tuiSession);
   discoverableStacks = ensureDocRepresentedInPickStacks(
     hydrated.stacks,
     /** @type {Record<string, unknown>} */ (doc),
@@ -650,9 +447,7 @@ export async function runStackViewCommand(opts) {
 
   let running = true;
   while (running) {
-    if (tuiSession) {
-      clearInkScreen();
-    }
+    if (tuiSession) clearInkScreen();
     const exitPayload = createExitPayload();
     const { waitUntilExit } = render(
       React.createElement(StackInkApp, {
@@ -667,25 +462,16 @@ export async function runStackViewCommand(opts) {
       })
     );
     await waitUntilExit();
-    // Give terminal mode a short moment to settle before readline prompts.
     await new Promise((r) => setTimeout(r, 25));
 
     const next = exitPayload.next;
-    if (!next || next.type === "quit") {
-      running = false;
-      break;
-    }
+    if (!next || next.type === "quit") { running = false; break; }
 
     if (next.type === "issue_comment") {
       try {
         const body = await questionLine(`New issue comment on PR #${next.prNumber} (empty=cancel): `);
         if (body.trim()) {
-          await githubPostIssueComment(
-            owner,
-            repoName,
-            /** @type {number} */ (next.prNumber),
-            body.trim()
-          );
+          await githubPostIssueComment(owner, repoName, /** @type {number} */ (next.prNumber), body.trim());
         }
         const refresh = createSpinner("Refreshing stack");
         refresh.start();
@@ -697,16 +483,27 @@ export async function runStackViewCommand(opts) {
       continue;
     }
 
+    if (next.type === "review_approve") {
+      try {
+        await githubPostPullReview(owner, repoName, /** @type {number} */ (next.prNumber), {
+          event: "APPROVE",
+          body: typeof next.body === "string" ? next.body : ""
+        });
+        const refresh = createSpinner("Refreshing stack");
+        refresh.start();
+        rows = await fetchStackPrDetails(owner, repoName, doc.prs, 6, mergedReviewFetch);
+        refresh.stop(`loaded ${rows.length} PR(s)`);
+      } catch (e) {
+        console.error(`Action failed: ${String(e?.message || e)}`);
+      }
+      continue;
+    }
+
     if (next.type === "review_reply") {
       try {
-        const body = await questionLine(`Reply in review thread (empty=cancel): `);
+        const body = await questionLine("Reply in review thread (empty=cancel): ");
         if (body.trim()) {
-          await githubPostPullReviewCommentReply(
-            owner,
-            repoName,
-            /** @type {number} */ (next.commentId),
-            body.trim()
-          );
+          await githubPostPullReviewCommentReply(owner, repoName, /** @type {number} */ (next.commentId), body.trim());
         }
         const refresh = createSpinner("Refreshing stack");
         refresh.start();
@@ -722,9 +519,7 @@ export async function runStackViewCommand(opts) {
       try {
         const logins = await promptReviewers(owner, repoName, /** @type {number} */ (next.prNumber));
         if (logins.length) {
-          await githubPostRequestedReviewers(owner, repoName, /** @type {number} */ (next.prNumber), {
-            reviewers: logins
-          });
+          await githubPostRequestedReviewers(owner, repoName, /** @type {number} */ (next.prNumber), { reviewers: logins });
         }
         const refresh = createSpinner("Refreshing stack");
         refresh.start();
@@ -743,23 +538,17 @@ export async function runStackViewCommand(opts) {
         const filePath = String(next.path || "");
         const commitId = String(next.commitId || "");
         const patchIdx = typeof next.patchLineIndex === "number" ? next.patchLineIndex : -1;
-
         const prRow = rows.find((r) => r.entry.pr_number === prNum);
         const fileObj = Array.isArray(prRow?.files) ? prRow.files.find((f) => f && String(f.filename) === filePath) : null;
         const pLines = fileObj && typeof fileObj.patch === "string" ? String(fileObj.patch).split("\n") : [];
         const mapped = pLines.length > 0 && patchIdx >= 0 ? diffLineToGitHub(pLines, patchIdx) : null;
-
         if (!mapped) {
           console.error(chalk.yellow("Cannot comment on this line (header or unmappable)."));
         } else {
           const body = await questionLine(`Comment on ${filePath}:${mapped.line} (${mapped.side}) (empty=cancel): `);
           if (body.trim()) {
             await githubPostPullReviewLineComment(owner, repoName, prNum, {
-              body: body.trim(),
-              commit_id: commitId,
-              path: filePath,
-              line: mapped.line,
-              side: mapped.side
+              body: body.trim(), commit_id: commitId, path: filePath, line: mapped.line, side: mapped.side
             });
           }
           const refresh = createSpinner("Refreshing stack");
@@ -774,120 +563,58 @@ export async function runStackViewCommand(opts) {
     }
 
     if (next.type === "pick_stack") {
-      const hydratedPick = await hydrateDiscoverableStacksForAlternatePicker(
-        root,
-        String(doc.repo_full_name || ""),
-        owner,
-        repoName,
-        discoverableStacks,
-        tuiSession
-      );
+      const repoFullForPick = String(doc.repo_full_name || "");
+      const hydratedPick = await hydrateDiscoverableStacks(repoFullForPick, owner, repoName, discoverableStacks, tuiSession);
       discoverableStacks = ensureDocRepresentedInPickStacks(
         hydratedPick.stacks,
         /** @type {Record<string, unknown>} */ (doc),
         ref,
         hydratedPick.openPullNumbers
       );
-      if (!discoverableStacks || discoverableStacks.length < 2) {
-        continue;
-      }
+      if (!discoverableStacks || discoverableStacks.length < 2) continue;
+
       const viewingTip = stackTipPrNumber(doc);
       const viewingHeadRef = typeof ref === "string" && ref.trim() ? ref.trim() : undefined;
       const hasBackFromViewer = !!(opts.allowBackToRepoPicker || opts.allowBackToReviewHub);
       const picked = await pickStackIndexWithInk(
         /** @type {{ tip_head_branch: string, tip_pr_number: number }[]} */ (discoverableStacks),
-        {
-          allowBackToRepo: hasBackFromViewer,
-          escapeToRepo: hasBackFromViewer,
-          viewingTipPrNumber: viewingTip != null ? viewingTip : undefined,
-          viewingHeadRef
-        }
+        { allowBackToRepo: hasBackFromViewer, escapeToRepo: hasBackFromViewer, viewingTipPrNumber: viewingTip ?? undefined, viewingHeadRef }
       );
       if (picked === STACK_PICK_BACK_TO_REPO) {
-        if (opts.allowBackToReviewHub) {
-          throw new ReviewHubBackError();
-        }
-        if (opts.allowBackToRepoPicker) {
-          throw new RepoPickerBackError();
-        }
-        console.error(
-          chalk.dim("Backspace: repo list is only available when you start with `nugit view` (no args) from a TTY.")
-        );
-        continue;
-      }
-      if (!picked) {
+        if (opts.allowBackToReviewHub) throw new ReviewHubBackError();
+        if (opts.allowBackToRepoPicker) throw new RepoPickerBackError();
         continue;
       }
+      if (!picked) continue;
+
       ref = picked.tip_head_branch;
-      const pickedIsInferred = !!(picked.inferredOnly || picked.inferredFromViewerDoc);
-      let pickedDoc = null;
-      if (pickedIsInferred && Array.isArray(picked.prs)) {
-        const prNums = picked.prs
-          .filter((p) => p && typeof p === "object" && typeof p.pr_number === "number")
-          .sort((a, b) => (a.position ?? 0) - (b.position ?? 0))
-          .map((p) => p.pr_number);
-        if (prNums.length > 0) {
-          pickedDoc = createInferredStackDoc(
-            String(doc.repo_full_name || `${owner}/${repoName}`),
-            String(picked.created_by || ""),
-            prNums
-          );
-        }
-      }
+      const prNums = Array.isArray(picked.prs)
+        ? picked.prs.filter((p) => p && typeof p === "object" && typeof p.pr_number === "number").sort((a, b) => (a.position ?? 0) - (b.position ?? 0)).map((p) => p.pr_number)
+        : [];
+      const pickedDoc = prNums.length > 0
+        ? createInferredStackDoc(String(doc.repo_full_name || `${owner}/${repoName}`), String(picked.created_by || ""), prNums)
+        : null;
+
       try {
-        if (tuiSession) {
-          await withStackLoadInkScreen("Loading stack…", async () => {
-            if (pickedDoc) {
-              doc = pickedDoc;
-            } else {
-              const loaded = await loadStackDocForView({
-                root,
-                repo,
-                ref,
-                file: opts.file
-              });
-              doc = loaded.doc;
-            }
-            const { owner: oPick, repo: rPick } = parseRepoFullName(doc.repo_full_name);
-            rows = await fetchStackRowsWithAutoapply(
-              oPick,
-              rPick,
-              doc,
-              mergedReviewFetch,
-              !!opts.reviewAutoapply
-            );
-            owner = oPick;
-            repoName = rPick;
-          });
-        } else {
+        const reloadStack = async () => {
           if (pickedDoc) {
             doc = pickedDoc;
           } else {
-            const loaded = await loadStackDocForView({
-              root,
-              repo,
-              ref,
-              file: opts.file
-            });
-            doc = loaded.doc;
+            const { doc: inferred } = await inferStackDocForRemoteView(`${owner}/${repoName}`, { preselectedChainIndex: 0 });
+            doc = inferred;
           }
           const { owner: oPick, repo: rPick } = parseRepoFullName(doc.repo_full_name);
-          const reloadPick = createSpinner("Loading stack");
-          reloadPick.start();
-          rows = await fetchStackRowsWithAutoapply(
-            oPick,
-            rPick,
-            doc,
-            mergedReviewFetch,
-            !!opts.reviewAutoapply
-          );
-          reloadPick.stop(`loaded ${rows.length} PR(s)`);
+          rows = await fetchStackRowsWithAutoapply(oPick, rPick, doc, mergedReviewFetch, !!opts.reviewAutoapply);
           owner = oPick;
           repoName = rPick;
+        };
+        if (tuiSession) {
+          await withStackLoadInkScreen("Loading stack…", reloadStack);
+        } else {
+          await reloadStack();
         }
       } catch (e) {
-        console.error(`Could not load stack: ${String(/** @type {{ message?: string }} */ (e)?.message || e)}`);
-        continue;
+        console.error(`Could not load stack: ${String(e?.message || e)}`);
       }
       continue;
     }
@@ -911,14 +638,14 @@ export async function runStackViewCommand(opts) {
         rows = await fetchStackPrDetails(owner, repoName, doc.prs, 6, mergedReviewFetch);
         refresh.stop(`loaded ${rows.length} PR(s)`);
       } catch (e) {
-        console.error(`Review submit failed: ${String(/** @type {{ message?: string }} */ (e)?.message || e)}`);
+        console.error(`Review submit failed: ${String(e?.message || e)}`);
       }
       continue;
     }
 
     if (next.type === "submit_review_changes") {
       try {
-        const body = await questionLine(`Request changes — comment (required, empty=cancel): `);
+        const body = await questionLine("Request changes — comment (required, empty=cancel): ");
         if (body.trim()) {
           await githubPostPullReview(owner, repoName, /** @type {number} */ (next.prNumber), {
             event: "REQUEST_CHANGES",
@@ -930,7 +657,7 @@ export async function runStackViewCommand(opts) {
           refresh.stop(`loaded ${rows.length} PR(s)`);
         }
       } catch (e) {
-        console.error(`Review submit failed: ${String(/** @type {{ message?: string }} */ (e)?.message || e)}`);
+        console.error(`Review submit failed: ${String(e?.message || e)}`);
       }
       continue;
     }
@@ -947,25 +674,20 @@ export async function runStackViewCommand(opts) {
         const headRef = typeof head.ref === "string" ? head.ref : "";
         const hr = head.repo && typeof head.repo === "object" ? head.repo : {};
         const cloneUrl = typeof hr.clone_url === "string" ? hr.clone_url : "";
-        if (!cloneUrl || !headRef) {
-          throw new Error("Missing clone URL or head ref");
-        }
+        if (!cloneUrl || !headRef) throw new Error("Missing clone URL or head ref");
         const safeName = `${owner}-${repoName}-${headRef}`.replace(/[^a-zA-Z0-9._-]+/g, "_");
         const dest = path.join(os.tmpdir(), `nugit-review-${safeName}`);
-        const url =
-          tok && cloneUrl.startsWith("https://")
-            ? cloneUrl.replace("https://", `https://x-access-token:${tok}@`)
-            : cloneUrl;
+        const url = tok && cloneUrl.startsWith("https://")
+          ? cloneUrl.replace("https://", `https://x-access-token:${tok}@`)
+          : cloneUrl;
         if (fs.existsSync(dest)) {
           console.error(chalk.yellow(`Directory exists, skipping clone: ${dest}`));
         } else {
-          execFileSync("git", ["clone", "--depth", "1", "--branch", headRef, url, dest], {
-            stdio: "inherit"
-          });
+          execFileSync("git", ["clone", "--depth", "1", "--branch", headRef, url, dest], { stdio: "inherit" });
           console.error(chalk.green(`Cloned to ${dest}`));
         }
       } catch (e) {
-        console.error(`Clone failed: ${String(/** @type {{ message?: string }} */ (e)?.message || e)}`);
+        console.error(`Clone failed: ${String(e?.message || e)}`);
       }
       continue;
     }
@@ -973,27 +695,28 @@ export async function runStackViewCommand(opts) {
     if (next.type === "split") {
       try {
         const r = findGitRoot();
-        if (!r) {
-          throw new Error("Not inside a git repository");
-        }
+        if (!r) throw new Error("Not inside a git repository");
         const { runSplitCommand } = await import("../split-view/run-split.js");
-        await runSplitCommand({
+        const splitResult = await runSplitCommand({
           root: r,
           owner,
           repo: repoName,
           prNumber: /** @type {number} */ (next.prNumber),
           dryRun: false
         });
-        const refreshed = readStackFile(r);
-        if (refreshed) {
-          doc = refreshed;
+        // Refresh viewer doc with the new inferred stack (post-split)
+        if (splitResult?.newPrNumbers?.length) {
+          const { authMe } = await import("../api-client.js");
+          const me = await authMe();
+          const login = me && typeof me.login === "string" ? me.login : "viewer";
+          doc = createInferredStackDoc(`${owner}/${repoName}`, login, splitResult.newPrNumbers);
         }
         const reload = createSpinner("Reloading stack");
         reload.start();
         rows = await fetchStackPrDetails(owner, repoName, doc.prs, 6, mergedReviewFetch);
         reload.stop(`loaded ${rows.length} PR(s)`);
       } catch (e) {
-        console.error(`Split failed: ${String(/** @type {{ message?: string }} */ (e)?.message || e)}`);
+        console.error(`Split failed: ${String(e?.message || e)}`);
       }
       continue;
     }