@quickchatai/quickreview 1.2.0 → 1.3.2

package/src/setup/scantree.ts

@@ -1,259 +1,3 @@
-// The scan's source port: the reviewed checkout, read-only, as trees at a
-// chosen sha.
-//
-// "Scan my local checkout at a sha I choose" means the tree AT THAT SHA, not
-// whatever the working copy holds: the file list and every content hash come
-// from git's own objects (`ls-tree` — the blob hash IS the ledger's content
-// hash), and the files the lenses read are materialised from exactly those
-// blobs (`git cat-file --batch`, raw bytes) into
-// `<state home>/scan/tree/<sha>/`. Not `git archive`: it honours in-tree
-// `export-ignore`/`export-subst`, so a listed file could be missing or read
-// as bytes its blob hash never named; and it extracts symlinks. Only the
-// listed regular files are written, so nothing in the tree is a link. The
-// checkout itself is never written — the companion mounts it `:ro` — and no
-// credential is involved: the objects are local.
-//
-// One materialised tree is kept per sha; opening another removes the earlier
-// ones except those `keep` names (the one a running scan is reading). A tree
-// is complete only once its marker is written, so an extraction cut short is
-// redone rather than trusted. The marker is a SIBLING of the tree
-// (`<sha>.complete`), never a path inside it: a name inside the tree is one
-// the commit can occupy.
-import { execFileSync } from "node:child_process";
-import {
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  rmSync,
-  statSync,
-  writeFileSync,
-} from "node:fs";
-import { dirname, isAbsolute, join, normalize, relative } from "node:path";
-import { inRoot, MAX_READ_BYTES } from "./adapters.js";
-import type { ScanSource, ScanTree } from "./scanrun.js";
-import type { UnreadableReason } from "./scan.js";
-import { isBinaryContent, textLineCount } from "./textsniff.js";
-import type { TreeFile } from "./scan.js";
-
-/** Where materialised trees live, under the state home. */
-export const SCAN_TREES_DIR = "scan/tree";
-const COMPLETE_SUFFIX = ".complete";
-/** Blobs, and their bytes, per `cat-file --batch` call — bound one call's
- * output buffer (a single larger blob is a call of its own). */
-const BLOBS_PER_BATCH = 256;
-const BYTES_PER_BATCH = 64 * 1024 * 1024;
-const SHA_RE = /^[0-9a-f]{40}([0-9a-f]{24})?$/;
-/** A full commit sha (SHA-1 or SHA-256) — the only spelling a tree is opened at. */
-export const isFullSha = (s: string): boolean => SHA_RE.test(s);
-
-/** `treesDir` (relative to the state home) is where this source keeps its
- * trees — the scan's own by default; another reader of trees (the PR
- * replay) passes its own, so neither prunes the other's.
- * `batchBytes` bounds one `cat-file --batch` call's output (tests shrink it). */
-export function gitScanSource(
-  repoRoot: string,
-  stateRoot: string,
-  opts: { treesDir?: string; batchBytes?: number } = {},
-): ScanSource {
-  const batchBytes = opts.batchBytes ?? BYTES_PER_BATCH;
-  // Why the last git call failed — its stderr's first line, or the error
-  // (a buffer overrun, git missing) — so a refusal names the cause.
-  let lastFailure = "";
-  const failed = (err: unknown): null => {
-    const e = err as { stderr?: Buffer | string; message?: string };
-    const stderr = (
-      Buffer.isBuffer(e.stderr) ? e.stderr.toString("utf8") : (e.stderr ?? "")
-    ).trim();
-    lastFailure = (stderr.split("\n")[0] || e.message || String(err)).slice(0, 300);
-    return null;
-  };
-  const because = (): string => (lastFailure ? ` (${lastFailure})` : "");
-  const git = (args: string[], maxBuffer = 64 * 1024 * 1024): string | null => {
-    try {
-      return execFileSync("git", ["-c", `safe.directory=${repoRoot}`, "-C", repoRoot, ...args], {
-        encoding: "utf8",
-        maxBuffer,
-        stdio: ["ignore", "pipe", "pipe"],
-      });
-    } catch (err) {
-      return failed(err);
-    }
-  };
-  const gitBytes = (args: string[], input: string, maxBuffer: number): Buffer | null => {
-    try {
-      return execFileSync("git", ["-c", `safe.directory=${repoRoot}`, "-C", repoRoot, ...args], {
-        input,
-        maxBuffer,
-        stdio: ["pipe", "pipe", "pipe"],
-      });
-    } catch (err) {
-      return failed(err);
-    }
-  };
-  /** Write every listed file's blob, raw, under `root`. False when git
-   * cannot produce one — the tree is then not complete. */
-  const materialise = (root: string, files: TreeFile[]): boolean => {
-    const pathsOf = new Map<string, string[]>();
-    for (const f of files) pathsOf.set(f.blob, [...(pathsOf.get(f.blob) ?? []), f.path]);
-    const blobs = [...pathsOf.keys()];
-    if (blobs.length === 0) return true;
-    // Sizes first, so one call's output is bounded by BYTES as well as by
-    // count: a repository of large assets must not need one huge buffer.
-    const checked = gitBytes(
-      ["cat-file", "--batch-check"],
-      blobs.join("\n") + "\n",
-      64 * 1024 * 1024,
-    );
-    if (checked === null) return false;
-    const sizeOf = new Map<string, number>();
-    for (const line of checked.toString("utf8").split("\n")) {
-      const m = /^([0-9a-f]+) blob (\d+)$/.exec(line);
-      if (m) sizeOf.set(m[1]!, Number(m[2]));
-    }
-    const chunks: Array<{ blobs: string[]; bytes: number }> = [];
-    for (const blob of blobs) {
-      const size = sizeOf.get(blob);
-      if (size === undefined) return false;
-      const last = chunks[chunks.length - 1];
-      if (last && last.blobs.length < BLOBS_PER_BATCH && last.bytes + size <= batchBytes) {
-        last.blobs.push(blob);
-        last.bytes += size;
-      } else chunks.push({ blobs: [blob], bytes: size });
-    }
-    for (const { blobs: chunk, bytes } of chunks) {
-      // Each blob's header and trailing newline on top of its bytes.
-      const out = gitBytes(
-        ["cat-file", "--batch"],
-        chunk.join("\n") + "\n",
-        bytes + chunk.length * 128 + 1024,
-      );
-      if (out === null) return false;
-      let at = 0;
-      for (const blob of chunk) {
-        const nl = out.indexOf(10, at);
-        if (nl < 0) return false;
-        const m = /^([0-9a-f]+) blob (\d+)$/.exec(out.subarray(at, nl).toString("utf8"));
-        if (!m || m[1] !== blob) return false;
-        const size = Number(m[2]);
-        const body = out.subarray(nl + 1, nl + 1 + size);
-        if (body.length !== size) return false;
-        at = nl + 1 + size + 1;
-        for (const rel of pathsOf.get(blob)!) {
-          const full = normalize(join(root, rel));
-          const back = relative(root, full);
-          if (isAbsolute(rel) || !inRoot(back)) continue;
-          mkdirSync(dirname(full), { recursive: true });
-          writeFileSync(full, body);
-        }
-      }
-    }
-    return true;
-  };
-  const treesDir = join(stateRoot, opts.treesDir ?? SCAN_TREES_DIR);
-  const list = (sha: string): TreeFile[] | null => {
-    if (!SHA_RE.test(sha)) return null;
-    const listed = git(["ls-tree", "-r", "-z", "--full-tree", sha], 512 * 1024 * 1024);
-    if (listed === null) return null;
-    const files: TreeFile[] = [];
-    for (const rec of listed.split("\0")) {
-      // `<mode> <type> <object>\t<path>` — regular files only: no submodule
-      // (`commit`), no symlink (120000) a lens could follow out of the tree.
-      const m = /^(\d{6}) (\w+) ([0-9a-f]+)\t(.+)$/s.exec(rec);
-      if (!m || m[2] !== "blob" || m[1] === "120000") continue;
-      files.push({ path: m[4]!, blob: m[3]! });
-    }
-    return files;
-  };
-  return {
-    location: repoRoot,
-    resolve: (ref) => {
-      if (!/^[A-Za-z0-9._/@^~-]+$/.test(ref) || ref.startsWith("-")) return null;
-      const sha = git(["rev-parse", "--verify", "--quiet", `${ref}^{commit}`])?.trim() ?? "";
-      return SHA_RE.test(sha) ? sha : null;
-    },
-    open: (sha, keep) => {
-      if (!SHA_RE.test(sha))
-        return { ok: false, reason: `not a commit sha: ${JSON.stringify(sha)}` };
-      lastFailure = "";
-      const files = list(sha);
-      if (files === null)
-        return { ok: false, reason: `git cannot list that commit's tree${because()}` };
-      const root = join(treesDir, sha);
-      const marker = `${root}${COMPLETE_SUFFIX}`;
-      try {
-        mkdirSync(treesDir, { recursive: true });
-        for (const other of readdirSync(treesDir)) {
-          const owner = other.endsWith(COMPLETE_SUFFIX)
-            ? other.slice(0, -COMPLETE_SUFFIX.length)
-            : other;
-          if (owner !== sha && !keep.includes(owner))
-            rmSync(join(treesDir, other), { recursive: true, force: true });
-        }
-        if (!existsSync(marker)) {
-          rmSync(root, { recursive: true, force: true });
-          mkdirSync(root, { recursive: true });
-          if (!materialise(root, files))
-            return { ok: false, reason: `git cannot read that commit's blobs${because()}` };
-          writeFileSync(marker, `${sha}\n`);
-        }
-      } catch (err) {
-        return {
-          ok: false,
-          reason: `cannot materialise the tree: ${err instanceof Error ? err.message : String(err)}`,
-        };
-      }
-      return { ok: true, tree: treeAt(sha, root, files) };
-    },
-    list,
-  };
-}
-
-/** A materialised tree as the runner reads it: text within the reader's
- * size cap, never a binary (`isBinaryContent` — one stray NUL in a source
- * file is still text), never a path that leaves the root. What it cannot
- * read it says why (`whyUnreadable`), so the plan REPORTS a skipped binary
- * rather than dropping it silently. */
-export function treeAt(sha: string, root: string, files: TreeFile[]): ScanTree {
-  const why = new Map<string, UnreadableReason>();
-  const read = (rel: string): string | null => {
-    if (isAbsolute(rel)) return null;
-    const full = normalize(join(root, rel));
-    const back = relative(root, full);
-    if (!inRoot(back)) return null;
-    try {
-      const st = statSync(full);
-      if (!st.isFile()) return null;
-      if (st.size > MAX_READ_BYTES) {
-        why.set(rel, "too-big");
-        return null;
-      }
-      const buf = readFileSync(full);
-      if (isBinaryContent(buf, rel)) {
-        why.set(rel, "binary");
-        return null;
-      }
-      return buf.toString("utf8");
-    } catch {
-      return null;
-    }
-  };
-  const cache = new Map<string, number | null>();
-  return {
-    sha,
-    root,
-    files,
-    read,
-    whyUnreadable: (rel) => {
-      if (read(rel) !== null) return null;
-      return why.get(rel) ?? "unreadable";
-    },
-    lines: (rel) => {
-      if (cache.has(rel)) return cache.get(rel)!;
-      const text = read(rel);
-      const n = text === null ? null : textLineCount(text);
-      cache.set(rel, n);
-      return n;
-    },
-  };
-}
+// Moved to the plugin (packages/pi-plugin/src/scan/scantree.ts), the scan engine's
+// home: this name stays for the app's importers.
+export * from "@quickchatai/pi-quickreview/src/scan/scantree.js";

package/src/setup/stage2request.ts

@@ -1,347 +1,3 @@
-// Scan stage 2's start channel: the files through which a stage-2 proposal
-// is shown and started from outside the companion — the TUI's click. A leaf:
-// it reaches its siblings by type only, so the TUI (which never imports the
-// setup engine — tests/single-shepherd.test.ts) can read the proposal and
-// ask for its start. The click's whole TUI half lives here
-// (`clickStartStage2`, `stage2ClickOutcome`); the [8] scan tab's plan pane
-// (`P`, then ⏎) is its button.
-//
-// Stage 2 starts one of two ways, and neither keeps an approval record:
-//
-//   * the operator's word — the companion calls `scan_stage2_start` with the
-//     proposal's key (and, for a narrowed "do it", the `rows` it may run —
-//     the same `keptRows` rule as the click's narrowing below);
-//   * a TUI click — the TUI writes `STAGE2_START_FILE` naming the key of the
-//     proposal it showed; the companion's scan belt picks it up within
-//     seconds and starts exactly that proposal, answering in
-//     `STAGE2_RESULT_FILE`.
-//
-// Either way the start quotes a key, and the engine re-plans before it runs:
-// a proposal that moved since it was shown (a new proposal, a new commit, a
-// price that changed) is refused, so nothing runs that the operator did not
-// see priced. A request is answered once — the result names the request it
-// answered — so a click is never replayed.
-//
-// The click may narrow the plan (space toggles a row off in the plan pane;
-// the operator's word narrows the same way through `scan_stage2_start`'s
-// `rows`): the request then names the runnable rows the operator kept, and
-// the run is exactly those rows, stopped hard at their total — the sum
-// the pane showed. It can only narrow: a row that was not runnable in the
-// proposal (covered, over the budget) can never be named, so nothing runs
-// that was not shown priced and runnable.
-//
-// Files, all in the state home: `scan/stage2.json` (the latest proposal, the
-// engine's), `scan/stage2-start.json` (the TUI's request),
-// `scan/stage2-start-result.json` (the engine's answer).
-import { join } from "node:path";
-import { readTextIfPresent, writeAtomic } from "../channelfs.js";
-import type { ScanDepth } from "../config.js";
-import type { RowPrice, Stage2Floor, Stage2Row, Stage2RowRequest } from "./stage2.js";
-
-export const STAGE2_FILE = "scan/stage2.json";
-export const STAGE2_START_FILE = "scan/stage2-start.json";
-export const STAGE2_RESULT_FILE = "scan/stage2-start-result.json";
-export const STAGE2_VERSION = 1;
-
-/** The latest proposal, as stored — what the TUI shows and a start quotes. */
-export interface StoredStage2Proposal {
-  key: string;
-  sha: string;
-  at: string;
-  /** What the companion asked for — the start re-plans from exactly this. */
-  request: Stage2RowRequest[];
-  budget_usd: number | null;
-  /** The plan it priced. */
-  rows: Stage2Row[];
-  /** The hard stop: the runnable rows' total. */
-  cap_usd: number;
-  runnable: number;
-  over_budget_usd: number;
-  validator: boolean;
-  /** The depth it was made at — a start re-plans at this depth, whatever
-   * `[scan] depth` says by then. Absent = standard (a proposal stored before
-   * depths). */
-  depth?: ScanDepth;
-  /** A deep proposal's floor: its lenses, and what it left out. */
-  floor?: Stage2Floor | null;
-}
-
-/** The depth a stored proposal was made at. */
-export const proposalDepth = (p: Pick<StoredStage2Proposal, "depth">): ScanDepth =>
-  p.depth === "deep" ? "deep" : "standard";
-
-export interface Stage2File {
-  version: number;
-  proposal: StoredStage2Proposal | null;
-}
-
-export interface Stage2StartRequest {
-  /** Unique per click; the result names it. */
-  id: string;
-  key: string;
-  at: string;
-  by: "tui";
-  /** The runnable rows the operator kept (their ids); absent = all of them. */
-  rows?: string[];
-}
-
-export interface Stage2StartResult {
-  request: string;
-  key: string;
-  at: string;
-  ok: boolean;
-  /** The run it started. */
-  run: string | null;
-  errors: string[];
-}
-
-const clean = (err: unknown): string => (err instanceof Error ? err.message : String(err));
-
-/** Parse the proposal file; throws on anything this version does not read. */
-export function parseStage2File(text: string): Stage2File {
-  const raw = JSON.parse(text) as Partial<Stage2File> | null;
-  if (typeof raw !== "object" || raw === null || raw.version !== STAGE2_VERSION)
-    throw new Error("not a version-1 stage 2 file");
-  const p = raw.proposal ?? null;
-  if (
-    p !== null &&
-    (typeof p !== "object" ||
-      typeof p.key !== "string" ||
-      typeof p.sha !== "string" ||
-      typeof p.cap_usd !== "number" ||
-      !Array.isArray(p.rows) ||
-      !Array.isArray(p.request))
-  ) {
-    throw new Error("`proposal` is not a stage 2 proposal");
-  }
-  return { version: STAGE2_VERSION, proposal: p };
-}
-
-/** Parse a start request, or null when it is not one. */
-export function parseStartRequest(text: string): Stage2StartRequest | null {
-  try {
-    const r = JSON.parse(text) as Partial<Stage2StartRequest> | null;
-    if (
-      typeof r !== "object" ||
-      r === null ||
-      typeof r.id !== "string" ||
-      r.id === "" ||
-      typeof r.key !== "string"
-    )
-      return null;
-    if (
-      r.rows !== undefined &&
-      (!Array.isArray(r.rows) || !r.rows.every((x) => typeof x === "string"))
-    )
-      return null;
-    return {
-      id: r.id,
-      key: r.key,
-      at: typeof r.at === "string" ? r.at : "",
-      by: "tui",
-      ...(r.rows !== undefined ? { rows: [...r.rows] } : {}),
-    };
-  } catch {
-    return null;
-  }
-}
-
-/** Parse a start result, or null when it is not one. */
-export function parseStartResult(text: string): Stage2StartResult | null {
-  try {
-    const r = JSON.parse(text) as Partial<Stage2StartResult> | null;
-    if (
-      typeof r !== "object" ||
-      r === null ||
-      typeof r.request !== "string" ||
-      typeof r.ok !== "boolean"
-    )
-      return null;
-    return {
-      request: r.request,
-      key: typeof r.key === "string" ? r.key : "",
-      at: typeof r.at === "string" ? r.at : "",
-      ok: r.ok,
-      run: typeof r.run === "string" ? r.run : null,
-      errors: Array.isArray(r.errors)
-        ? r.errors.filter((e): e is string => typeof e === "string")
-        : [],
-    };
-  } catch {
-    return null;
-  }
-}
-
-/** The latest stage-2 proposal in the state home at `home`, none, or why it
- * cannot be read (then the TUI shows UNKNOWN — never "no proposal"). */
-export function readStage2Proposal(
-  home: string,
-): { ok: true; proposal: StoredStage2Proposal | null } | { ok: false; error: string } {
-  try {
-    const text = readTextIfPresent(join(home, STAGE2_FILE));
-    return { ok: true, proposal: text === null ? null : parseStage2File(text).proposal };
-  } catch (err) {
-    return { ok: false, error: `${STAGE2_FILE} cannot be read: ${clean(err)}` };
-  }
-}
-
-/**
- * The runnable rows a start runs: all of them, or the subset `keep` names —
- * refused when `keep` is empty or names a row that is not runnable in the
- * proposal (the engine applies the same rule after it re-plans).
- */
-export function keptRows(
-  rows: readonly Stage2Row[],
-  keep: readonly string[] | undefined,
-): { ok: true; rows: Stage2Row[]; cap_usd: number | null } | { ok: false; errors: string[] } {
-  const runnable = rows.filter((r) => r.status === "run");
-  if (keep === undefined) return { ok: true, rows: runnable, cap_usd: null };
-  if (keep.length === 0)
-    return { ok: false, errors: ["every row is toggled off — keep at least one"] };
-  const bad = keep.filter((id) => !runnable.some((r) => r.id === id));
-  if (bad.length > 0)
-    return { ok: false, errors: [`not a runnable row of the proposal: ${bad.join(", ")}`] };
-  const kept = runnable.filter((r) => keep.includes(r.id));
-  return { ok: true, rows: kept, cap_usd: kept.reduce((n, r) => n + r.estimate_usd, 0) };
-}
-
-/**
- * The TUI's click: ask the companion to start the stored proposal whose key
- * the TUI showed — all its runnable rows, or the ones in `keep`. Refused when
- * there is no proposal, it is no longer the one shown (`key`), or `keep`
- * names a row that is not runnable. Writes the request; the companion starts
- * it (or says why not) in `STAGE2_RESULT_FILE`.
- */
-export function requestStage2Start(
-  home: string,
-  key: string,
-  now: Date,
-  keep?: readonly string[],
-):
-  | {
-      ok: true;
-      request: Stage2StartRequest;
-      proposal: StoredStage2Proposal;
-      rows: number;
-      cap_usd: number;
-    }
-  | { ok: false; errors: string[] } {
-  const read = readStage2Proposal(home);
-  if (!read.ok) return { ok: false, errors: [read.error] };
-  const p = read.proposal;
-  if (p === null)
-    return { ok: false, errors: ["no stage 2 proposal — ask the companion to propose one"] };
-  if (p.key !== key) {
-    return {
-      ok: false,
-      errors: [
-        `the proposal changed since it was shown (showed ${key}, now ${p.key}) — look at the new one first`,
-      ],
-    };
-  }
-  if (p.runnable === 0) return { ok: false, errors: ["the proposal has no row to run"] };
-  const kept = keptRows(p.rows, keep);
-  if (!kept.ok) return kept;
-  const request: Stage2StartRequest = {
-    id: `${now.toISOString()}-${Math.random().toString(36).slice(2, 8)}`,
-    key,
-    at: now.toISOString(),
-    by: "tui",
-    ...(keep !== undefined ? { rows: [...keep] } : {}),
-  };
-  try {
-    writeAtomic(join(home, STAGE2_START_FILE), `${JSON.stringify(request)}\n`);
-  } catch (err) {
-    return { ok: false, errors: [`the start request could not be written: ${clean(err)}`] };
-  }
-  return {
-    ok: true,
-    request,
-    proposal: p,
-    rows: kept.rows.length,
-    cap_usd: kept.cap_usd ?? p.cap_usd,
-  };
-}
-
-/** The companion's answer to the request `id`, or null while it has not
- * answered (or answered another one); throws when the answer file exists
- * but cannot be read. */
-export function readStage2StartResult(home: string, id: string): Stage2StartResult | null {
-  const text = readTextIfPresent(join(home, STAGE2_RESULT_FILE));
-  const r = text === null ? null : parseStartResult(text);
-  return r !== null && r.request === id ? r : null;
-}
-
-// ---- the TUI's click -------------------------------------------------------------
-
-const usd = (n: number): string => `$${n.toFixed(2)}`;
-
-/**
- * The click: ask the companion to start the proposal whose key the TUI
- * showed — its kept rows when the operator toggled some off. The notice line
- * says what was asked, or why nothing was.
- */
-export function clickStartStage2(
-  home: string,
-  key: string,
-  now: Date = new Date(),
-  keep?: readonly string[],
-): { ok: true; request: string; line: string } | { ok: false; line: string } {
-  const r = requestStage2Start(home, key, now, keep);
-  if (!r.ok) return { ok: false, line: `stage 2 not started: ${r.errors.join("; ")}` };
-  return {
-    ok: true,
-    request: r.request.id,
-    line: `stage 2 asked to start — ${r.rows} row(s), hard stop ${usd(r.cap_usd)}; the companion starts it within seconds`,
-  };
-}
-
-/** What became of the click `request`: the companion's answer, or null while
- * it has not answered (a companion that is down starts nothing) — or that
- * the answer cannot be read. */
-export function stage2ClickOutcome(home: string, request: string): string | null {
-  let r: Stage2StartResult | null;
-  try {
-    r = readStage2StartResult(home, request);
-  } catch (err) {
-    // Not "no answer yet": the answer may be there, unreadable — said once,
-    // never polled for silently.
-    return `stage 2's answer cannot be read (${STAGE2_RESULT_FILE}: ${clean(err)}) — check scan_status`;
-  }
-  if (r === null) return null;
-  return r.ok ? `stage 2 started: ${r.run}` : `stage 2 refused: ${r.errors.join("; ")}`;
-}
-
-// ---- a row's price, as the preview names it -------------------------------------
-
-/** Whether a row's price is a measurement of the row's own lens at its own
- * settings and depth — every other basis is an estimate. */
-export function priceIsMeasured(p: RowPrice): boolean {
-  return p.basis === "measured" && p.across_depth !== true;
-}
-
-/** What the preview says a row's price stands on: `measured`, or
- * `estimate: …` and how it was made. */
-export function priceLabel(p: RowPrice): string {
-  const label = basisLabel(p);
-  return p.across_depth
-    ? `${p.basis === "measured" ? "estimate: measured" : label} — from readings at the other depth`
-    : label;
-}
-
-function basisLabel(p: RowPrice): string {
-  const onOff = (v: boolean): string => (v ? "on" : "off");
-  switch (p.basis) {
-    case "measured":
-      return "measured";
-    case "borrowed":
-      return `estimate: borrowed from ${p.from}`;
-    case "learned":
-      return p.learned
-        ? `estimate: learned from ${p.from} with the validator ${onOff(p.learned.validator)} (×${p.learned.factor.toFixed(2)} stage 1), ` +
-            `stage 1 validator ${onOff(!p.learned.validator)}/${onOff(p.learned.validator)} ×${p.learned.skeptic.toFixed(2)}`
-        : `estimate: learned from ${p.from}`;
-    default:
-      return `estimate: extrapolated from ${p.from}${p.factor !== undefined ? ` (×${p.factor})` : ""}`;
-  }
-}
+// Moved to the plugin (packages/pi-plugin/src/scan/stage2request.ts), the scan engine's
+// home: this name stays for the app's importers.
+export * from "@quickchatai/pi-quickreview/src/scan/stage2request.js";