2sagaco48 1.0.0

package/src/console/engineBridge.ts

@@ -0,0 +1,258 @@
+/**
+ * engineBridge.ts — READ-ONLY same-origin bridge to the packaged VERITAS engine.
+ * ---------------------------------------------------------------------------
+ * The engine runs inside a `<iframe srcDoc={...}>`. A srcdoc iframe inherits the
+ * PARENT origin, so the durable workspace shell may legitimately read the
+ * engine's storage and DOM. This module NEVER mutates the engine — it only
+ * observes, so it cannot alter the initial-story pipeline or its prompt set.
+ *
+ * Storage keys are the engine's own persistence keys, verified against the
+ * packaged bundle (node_modules/dist/index.html):
+ *   localStorage:  veritas.keys.v3, veritas.model.v3, veritas.settings.v2,
+ *                  veritas.persona.seed.v1, veritas.custom.templates.v1
+ *   sessionStorage: veritas.messages.v1, veritas.lastrun.v1
+ */
+
+export type EngineKeys = { gemini?: string; jina?: string; serpapi?: string; [k: string]: string | undefined };
+
+const LS_KEYS = "veritas.keys.v3";
+const LS_MODEL = "veritas.model.v3";
+const LS_SETTINGS = "veritas.settings.v2";
+const LS_PERSONA_SEED = "veritas.persona.seed.v1";
+const LS_TEMPLATES = "veritas.custom.templates.v1";
+const SS_MESSAGES = "veritas.messages.v1";
+const SS_LASTRUN = "veritas.lastrun.v1";
+
+type Frame = HTMLIFrameElement | null;
+
+function fwin(iframe: Frame): Window | null {
+  try { return iframe?.contentWindow ?? null; } catch { return null; }
+}
+function fdoc(iframe: Frame): Document | null {
+  try { return iframe?.contentDocument ?? null; } catch { return null; }
+}
+function readLocal(iframe: Frame, key: string): string | null {
+  try { const v = window.localStorage.getItem(key); if (v != null) return v; } catch { /* noop */ }
+  try { return fwin(iframe)?.localStorage.getItem(key) ?? null; } catch { return null; }
+}
+function readSession(iframe: Frame, key: string): string | null {
+  try { const v = fwin(iframe)?.sessionStorage.getItem(key); if (v != null) return v; } catch { /* noop */ }
+  try { return window.sessionStorage.getItem(key); } catch { return null; }
+}
+function parse<T>(raw: string | null, fallback: T): T {
+  if (!raw) return fallback;
+  try { return JSON.parse(raw) as T; } catch { return fallback; }
+}
+
+export function isEngineReachable(iframe: Frame): boolean {
+  return !!fdoc(iframe)?.body;
+}
+
+export function getKeys(iframe: Frame): EngineKeys {
+  return parse<EngineKeys>(readLocal(iframe, LS_KEYS), {});
+}
+export function getGeminiKey(iframe: Frame): string {
+  return (getKeys(iframe).gemini || "").trim();
+}
+export function getActiveModel(iframe: Frame): string {
+  return parse<string>(readLocal(iframe, LS_MODEL), "");
+}
+
+export type EngineSettings = {
+  templateEnabled?: boolean;
+  activeTemplateId?: string;
+  styleMode?: string;
+  deepResearch?: boolean;
+  searchDepth?: number;
+  nDeepEnabled?: boolean;
+  nDeepMaxPasses?: number;
+  clusterSearch?: boolean;
+  clusterSize?: number;
+  forceSloop?: boolean;
+  sloopPages?: number;
+  [k: string]: unknown;
+};
+export function getSettings(iframe: Frame): EngineSettings {
+  return parse<EngineSettings>(readLocal(iframe, LS_SETTINGS), {});
+}
+export function getPersonaSeed(iframe: Frame): number | null {
+  const v = parse<number | null>(readLocal(iframe, LS_PERSONA_SEED), null);
+  return typeof v === "number" ? v : null;
+}
+export function getCustomTemplateCount(iframe: Frame): number {
+  const t = parse<unknown[]>(readLocal(iframe, LS_TEMPLATES), []);
+  return Array.isArray(t) ? t.length : 0;
+}
+export function getLastRun(iframe: Frame): Record<string, unknown> | null {
+  return parse<Record<string, unknown> | null>(readSession(iframe, SS_LASTRUN), null);
+}
+
+type RawMsg = { role?: string; content?: string; text?: string; [k: string]: unknown };
+export function getMessages(iframe: Frame): RawMsg[] {
+  const m = parse<RawMsg[]>(readSession(iframe, SS_MESSAGES), []);
+  return Array.isArray(m) ? m : [];
+}
+function msgText(m: RawMsg): string {
+  if (typeof m.content === "string") return m.content;
+  if (typeof m.text === "string") return m.text;
+  return "";
+}
+function isAssistant(m: RawMsg): boolean {
+  const r = (m.role || "").toLowerCase();
+  if (r === "user" || r === "system") return false;
+  return !!msgText(m);
+}
+
+export type ManuscriptSource = "engine-messages" | "engine-dom" | "none";
+export type ManuscriptResult = { text: string; source: ManuscriptSource; chapters: number; chars: number };
+
+/** Assemble the FULL manuscript (whole book) — all assistant turns concatenated. */
+export function assembleManuscript(iframe: Frame): ManuscriptResult {
+  const assistant = getMessages(iframe).filter(isAssistant).map(msgText).map((s) => s.trim()).filter(Boolean);
+  if (assistant.length) {
+    const text = assistant.join("\n\n\u2014\u2014\u2014 CHAPTER BREAK \u2014\u2014\u2014\n\n");
+    return { text, source: "engine-messages", chapters: assistant.length, chars: text.length };
+  }
+  const d = fdoc(iframe);
+  const txt = (d?.body?.innerText || "").trim();
+  if (txt.length > 200) return { text: txt, source: "engine-dom", chapters: 0, chars: txt.length };
+  return { text: "", source: "none", chapters: 0, chars: 0 };
+}
+
+/**
+ * Best-effort adopt-back: replace the LAST assistant message in the engine's
+ * persisted `veritas.messages.v1` (iframe sessionStorage first, window fallback).
+ * HONESTY: the live engine UI is driven by React state, not storage polling,
+ * so this write is visible after the engine re-reads storage (reload) or not at
+ * all in the current session. The caller MUST surface `detail` verbatim and
+ * offer clipboard copy as the guaranteed path. Returns ok=false with the real
+ * reason when the write cannot be performed.
+ */
+export function reloadEngineFrame(iframe: Frame): boolean {
+  try {
+    if (iframe?.contentWindow) {
+      iframe.contentWindow.location.reload();
+      return true;
+    }
+  } catch {}
+  return false;
+}
+
+export function attemptAdoptToEngine(iframe: Frame, text: string): { ok: boolean; detail: string } {
+  if (!text.trim()) return { ok: false, detail: "adopt refused: empty text" };
+  try {
+    const rawF = (() => {
+      try {
+        return iframe?.contentWindow?.sessionStorage.getItem(SS_MESSAGES);
+      } catch {
+        return null;
+      }
+    })();
+    const rawW = (() => {
+      try {
+        return window.sessionStorage.getItem(SS_MESSAGES);
+      } catch {
+        return null;
+      }
+    })();
+    const raw = rawF ?? rawW;
+    let msgs: RawMsg[] = [];
+    if (raw) {
+      try {
+        const parsed = JSON.parse(raw) as RawMsg[];
+        if (Array.isArray(parsed)) msgs = parsed;
+      } catch {
+        return { ok: false, detail: "engine message store is not valid JSON" };
+      }
+    }
+    // Seed a first assistant message when the store is empty so chapter 1 of a
+    // fresh novel still lands in the main chat pipeline (no theatre: empty store
+    // used to silently fail adopt until the user had run something else first).
+    let idx = -1;
+    for (let i = msgs.length - 1; i >= 0; i--) {
+      const r = (msgs[i].role || "").toLowerCase();
+      if (r !== "user" && r !== "system" && msgText(msgs[i])) {
+        idx = i;
+        break;
+      }
+    }
+    const next = msgs.slice();
+    if (idx < 0) {
+      next.push({
+        id: `a-saga-${Date.now()}`,
+        role: "assistant",
+        content: text,
+        ts: Date.now(),
+        usedMultiPass: true,
+      } as RawMsg);
+      idx = next.length - 1;
+    } else {
+      const target = { ...next[idx] };
+      if (typeof target.content === "string") target.content = text;
+      else if (typeof target.text === "string") target.text = text;
+      else target.content = text;
+      next[idx] = target;
+    }
+    const serial = JSON.stringify(next);
+    let wrote = false;
+    try {
+      iframe?.contentWindow?.sessionStorage.setItem(SS_MESSAGES, serial);
+      wrote = true;
+    } catch {
+      /* fall through to window */
+    }
+    try {
+      window.sessionStorage.setItem(SS_MESSAGES, serial);
+      wrote = true;
+    } catch {
+      /* ignore */
+    }
+    if (!wrote) return { ok: false, detail: "storage write blocked by the browser" };
+    return {
+      ok: true,
+      detail: `wrote assistant message #${idx + 1}/${next.length} to engine store (${text.length} chars); live UI updates on engine reload`,
+    };
+  } catch (e) {
+    return { ok: false, detail: e instanceof Error ? e.message : String(e) };
+  }
+}
+
+export type RuntimeSignal = { label: string; count: number };
+const RUNTIME_KEYWORDS: Array<{ label: string; re: RegExp }> = [
+  { label: "SAGE / Saga-OS", re: /\bsaga?[-\s]?os\b|\bsage\b/gi },
+  { label: "Empty-Space", re: /empty[-\s]?space/gi },
+  { label: "Reality grounding", re: /grounding|reality[-\s]?ground/gi },
+  { label: "Judge / rubric", re: /\bjudge\b|rubric/gi },
+  { label: "Innovation genome", re: /innovation|genome/gi },
+  { label: "Blueprint", re: /blueprint/gi },
+  { label: "Persona / archetype", re: /persona|archetype/gi },
+  { label: "Adversarial", re: /adversar/gi },
+  { label: "Retrieval / scraper", re: /scrap|retriev|grounded search/gi },
+  { label: "Synthesis", re: /synthes/gi },
+];
+
+export type RuntimeSnapshot = { reachable: boolean; chapters: number; phase: string; signals: RuntimeSignal[]; traceChars: number };
+
+/**
+ * DOM keyword census — a PROXY signal, not source-level instrumentation.
+ * Counts occurrences of subsystem terms visible in the engine DOM. This is an
+ * honest lower/loose bound on activation, explicitly labelled as a proxy.
+ */
+export function observeRuntime(iframe: Frame): RuntimeSnapshot {
+  const d = fdoc(iframe);
+  const text = d?.body?.innerText || "";
+  const signals = RUNTIME_KEYWORDS.map((k) => {
+    k.re.lastIndex = 0;
+    const matches = text.match(k.re);
+    return { label: k.label, count: matches ? matches.length : 0 };
+  });
+  const lastRun = getLastRun(iframe) as { phase?: string } | null;
+  const { chapters } = assembleManuscript(iframe);
+  return {
+    reachable: !!d?.body,
+    chapters,
+    phase: (lastRun && typeof lastRun.phase === "string" && lastRun.phase) || "(not exposed by engine build)",
+    signals,
+    traceChars: text.length,
+  };
+}

package/src/console/gemini.ts

@@ -0,0 +1,106 @@
+/**
+ * gemini.ts — REAL Google Generative Language API client (browser fetch).
+ * ---------------------------------------------------------------------------
+ * Every call is an independent HTTP request with NO conversation history, so
+ * each grading / revision call runs in a genuinely fresh context window.
+ * CORS: generativelanguage.googleapis.com accepts browser calls with ?key=.
+ *
+ * HONESTY: if a call does not occur or fails, the result carries ok=false and
+ * the real error string. Nothing is fabricated.
+ */
+
+// Real, currently-served Gemini models (editable by the user in the UI).
+export const DEFAULT_MODEL_ROTATION: string[] = [
+  "gemini-3.7-flash",
+  "gemini-3.6-flash",
+  "gemini-3.5-flash",
+  "gemini-3.5-flash-lite",
+  "gemini-3.1-flash-lite",
+  "gemini-3-flash-preview",
+  "gemini-2.5-pro",
+  "gemini-2.5-flash",
+  "gemini-2.5-flash-lite",
+  "gemma-4-31b-it",
+  "gemma-4-26b-it",
+  "gemma-3-27b-it",
+];
+
+export function pickModel(pool: string[], exclude?: string): string {
+  const arr = pool.length ? pool : DEFAULT_MODEL_ROTATION;
+  const candidates = exclude ? arr.filter((m) => m !== exclude) : arr;
+  const src = candidates.length ? candidates : arr;
+  return src[Math.floor(Math.random() * src.length)];
+}
+
+export type GeminiResult = { ok: boolean; text: string; model: string; error?: string; ms: number };
+
+export type CallOpts = {
+  apiKey: string;
+  model: string;
+  prompt: string;
+  system?: string;
+  temperature?: number;
+  maxOutputTokens?: number;
+  signal?: AbortSignal;
+};
+
+export async function callGemini(opts: CallOpts): Promise<GeminiResult> {
+  const started = Date.now();
+  const { apiKey, model, prompt, system, temperature = 0.7, maxOutputTokens = 8192, signal } = opts;
+  if (!apiKey) return { ok: false, text: "", model, error: "Missing Gemini API key (set it in the engine's Chat → Keys panel).", ms: 0 };
+  const url =
+    "https://generativelanguage.googleapis.com/v1beta/models/" +
+    encodeURIComponent(model) +
+    ":generateContent?key=" +
+    encodeURIComponent(apiKey);
+  const body: Record<string, unknown> = {
+    contents: [{ role: "user", parts: [{ text: prompt }] }],
+    generationConfig: { temperature, maxOutputTokens },
+  };
+  if (system) body.systemInstruction = { parts: [{ text: system }] };
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal,
+    });
+    if (!res.ok) {
+      const t = await res.text().catch(() => "");
+      return { ok: false, text: "", model, error: "HTTP " + res.status + ": " + t.slice(0, 400), ms: Date.now() - started };
+    }
+    const data = await res.json();
+    const cand = data?.candidates?.[0];
+    const parts = cand?.content?.parts;
+    const text = Array.isArray(parts) ? parts.map((p: { text?: string }) => p?.text || "").join("") : "";
+    if (!text) {
+      const reason = cand?.finishReason || data?.promptFeedback?.blockReason || "empty";
+      return { ok: false, text: "", model, error: "No text returned (finishReason: " + reason + ")", ms: Date.now() - started };
+    }
+    return { ok: true, text, model, ms: Date.now() - started };
+  } catch (e) {
+    return { ok: false, text: "", model, error: e instanceof Error ? e.message : String(e), ms: Date.now() - started };
+  }
+}
+
+/**
+ * Random model per call + one resilient fallback to a DIFFERENT random model on
+ * failure. Preserves "random model each call" while surviving a rate-limited or
+ * unavailable model. Returns which model actually produced the output.
+ */
+export async function callGeminiResilient(
+  pool: string[],
+  exclude: string | undefined,
+  opts: Omit<CallOpts, "model">,
+): Promise<GeminiResult> {
+  let excl = exclude;
+  let last: GeminiResult | null = null;
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const model = pickModel(pool, excl);
+    const res = await callGemini({ ...opts, model });
+    if (res.ok) return res;
+    last = res;
+    excl = model;
+  }
+  return last ?? { ok: false, text: "", model: "", error: "No model available", ms: 0 };
+}

package/src/console/grading.ts

@@ -0,0 +1,250 @@
+/**
+ * grading.ts — Manuscript grading rubric, prompt builders, parser, and the
+ * recursive-revision prompt builder.
+ *
+ * The weighted rubric matches the user-specified headings/weights exactly.
+ * A supplementary set + a line-level rewrite-suggestion table are added.
+ * NOTE (honesty): the uploaded "additional criteria" image was NOT provided to
+ * this build, so the supplementary set + rewrite-table columns use a standard
+ * professional editorial format compatible with the described rubric. This is
+ * disclosed in the UI.
+ */
+import { clampNum, round2 } from "./util";
+
+export type Criterion = { key: string; label: string; weight: number };
+
+export const CRITERIA: Criterion[] = [
+  { key: "theme", label: "Theme & Conceptual Ambition", weight: 0.15 },
+  { key: "world", label: "Worldbuilding & Setting Depth", weight: 0.15 },
+  { key: "prose", label: "Prose Style & Syntactic Craft", weight: 0.15 },
+  { key: "voice", label: "Character Voice & Coherence", weight: 0.2 },
+  { key: "plot", label: "Plot Architecture & Pacing", weight: 0.2 },
+  { key: "clean", label: "Cleanliness & Narrative Logic", weight: 0.15 },
+];
+
+export const SUPPLEMENTARY_LABELS: string[] = [
+  "Dialogue Authenticity",
+  "Emotional Resonance",
+  "Originality & Trope Subversion",
+  "Sensory Immersion",
+  "Scene-Level Momentum",
+  "Line Economy & Redundancy",
+];
+
+export type CriterionScore = {
+  key: string;
+  label: string;
+  weight: number;
+  score: number;
+  weighted: number;
+  grade: string;
+  justification: string;
+};
+export type Supp = { label: string; score: number; note: string };
+export type Rewrite = { location: string; excerpt: string; diagnosis: string; suggestedRewrite: string; rationale: string };
+
+export type GradeReport = {
+  criteria: CriterionScore[];
+  supplementary: Supp[];
+  rewrites: Rewrite[];
+  composite: number;
+  compositeGrade: string;
+  narrative: string;
+  weaknesses: string[];
+  model: string;
+  ms: number;
+  raw: string;
+  parseError?: string;
+};
+
+export function letterGrade(s: number): string {
+  if (s >= 93) return "A";
+  if (s >= 90) return "A-";
+  if (s >= 87) return "B+";
+  if (s >= 83) return "B";
+  if (s >= 80) return "B-";
+  if (s >= 77) return "C+";
+  if (s >= 73) return "C";
+  if (s >= 70) return "C-";
+  if (s >= 67) return "D+";
+  if (s >= 63) return "D";
+  if (s >= 60) return "D-";
+  return "F";
+}
+
+export function buildGradingPrompt(manuscript: string): { system: string; prompt: string } {
+  const system =
+    "You are a ruthless, calibrated literary editor and manuscript grader. You evaluate the ENTIRE manuscript provided (the whole book, all chapters), never a summary. You never inflate scores. A truncated, contradictory, or reset plot MUST score in the F range for Plot Architecture & Pacing and for Cleanliness & Narrative Logic. You output STRICT JSON only — no markdown, no code fences, no prose outside the JSON object.";
+
+  const prompt = [
+    "Grade the manuscript with this WEIGHTED rubric. Score each criterion 1-100:",
+    CRITERIA.map((c) => "- " + c.label + " (" + Math.round(c.weight * 100) + "%) [key: " + c.key + "]").join("\n"),
+    "",
+    "Also score these SUPPLEMENTARY dimensions 1-100 (informational, unweighted):",
+    SUPPLEMENTARY_LABELS.map((l) => "- " + l).join("\n"),
+    "",
+    "Then produce 5-12 line-level REWRITE SUGGESTIONS. Each must quote a SHORT VERBATIM excerpt (<=25 words) taken from the manuscript, diagnose the specific problem, propose a concrete suggested rewrite that PRESERVES the author's voice and vibe, and give a one-line rationale.",
+    "",
+    "Return ONLY this JSON object (fill every field, keep the exact keys):",
+    "{",
+    '  "criteria": [ {"key": "theme", "score": 0, "qualitativeGrade": "", "justification": ""} ],',
+    '  "supplementary": [ {"label": "", "score": 0, "note": ""} ],',
+    '  "rewriteSuggestions": [ {"location": "", "excerpt": "", "diagnosis": "", "suggestedRewrite": "", "rationale": ""} ],',
+    '  "narrative": "2-4 sentence overall assessment",',
+    '  "topWeaknesses": ["", "", ""]',
+    "}",
+    "There must be exactly one criteria entry per key: " + CRITERIA.map((c) => c.key).join(", ") + ".",
+    "",
+    "MANUSCRIPT:",
+    "<<<BEGIN_MANUSCRIPT>>>",
+    manuscript,
+    "<<<END_MANUSCRIPT>>>",
+  ].join("\n");
+
+  return { system, prompt };
+}
+
+function extractJson(raw: string): Record<string, unknown> | null {
+  const t = raw.replace(/```json/gi, "").replace(/```/g, "").trim();
+  const a = t.indexOf("{");
+  const b = t.lastIndexOf("}");
+  if (a < 0 || b < 0 || b <= a) return null;
+  try {
+    return JSON.parse(t.slice(a, b + 1)) as Record<string, unknown>;
+  } catch {
+    return null;
+  }
+}
+
+export function parseGrade(raw: string, model: string, ms: number): GradeReport {
+  const j = extractJson(raw);
+  if (!j) {
+    return {
+      criteria: CRITERIA.map((c) => ({ ...c, score: 0, weighted: 0, grade: "F", justification: "(unparsed)" })),
+      supplementary: [],
+      rewrites: [],
+      composite: 0,
+      compositeGrade: "F",
+      narrative: "Model output could not be parsed as JSON. The raw output is shown below for inspection.",
+      weaknesses: [],
+      model,
+      ms,
+      raw,
+      parseError: "JSON parse failed",
+    };
+  }
+
+  type MC = { key?: string; label?: string; score?: unknown; justification?: string; note?: string };
+  const modelCrit: MC[] = Array.isArray(j.criteria) ? (j.criteria as MC[]) : [];
+  const firstWord = (s: string) => s.toLowerCase().split(/\s+/)[0];
+
+  const criteria: CriterionScore[] = CRITERIA.map((c) => {
+    const found =
+      modelCrit.find((m) => (m?.key || "").toLowerCase() === c.key) ||
+      modelCrit.find((m) => String(m?.label || "").toLowerCase().includes(firstWord(c.label)));
+    const score = clampNum(found?.score, 1, 100, 1);
+    return {
+      key: c.key,
+      label: c.label,
+      weight: c.weight,
+      score,
+      weighted: round2(score * c.weight),
+      grade: letterGrade(score),
+      justification: String(found?.justification || found?.note || ""),
+    };
+  });
+
+  const composite = round2(criteria.reduce((sum, c) => sum + c.weighted, 0));
+
+  type MS = { label?: string; score?: unknown; note?: string };
+  const supplementary: Supp[] = Array.isArray(j.supplementary)
+    ? (j.supplementary as MS[]).slice(0, 12).map((s) => ({
+        label: String(s?.label || ""),
+        score: clampNum(s?.score, 1, 100, 0),
+        note: String(s?.note || ""),
+      }))
+    : [];
+
+  type MR = { location?: string; excerpt?: string; diagnosis?: string; suggestedRewrite?: string; rationale?: string };
+  const rewrites: Rewrite[] = Array.isArray(j.rewriteSuggestions)
+    ? (j.rewriteSuggestions as MR[]).slice(0, 12).map((r) => ({
+        location: String(r?.location || ""),
+        excerpt: String(r?.excerpt || ""),
+        diagnosis: String(r?.diagnosis || ""),
+        suggestedRewrite: String(r?.suggestedRewrite || ""),
+        rationale: String(r?.rationale || ""),
+      }))
+    : [];
+
+  const weaknesses: string[] = Array.isArray(j.topWeaknesses)
+    ? (j.topWeaknesses as unknown[]).map((w) => String(w)).filter(Boolean).slice(0, 8)
+    : [];
+
+  return {
+    criteria,
+    supplementary,
+    rewrites,
+    composite,
+    compositeGrade: letterGrade(composite),
+    narrative: String(j.narrative || ""),
+    weaknesses,
+    model,
+    ms,
+    raw,
+  };
+}
+
+/** Fixed-width ASCII report matching the requested table layout (copy/export). */
+export function buildAsciiReport(r: GradeReport): string {
+  const bar = "=".repeat(98);
+  const dash = "-".repeat(98);
+  const head =
+    "EVALUATION CRITERIA (WEIGHT)".padEnd(42) +
+    "SCORE (1-100)".padEnd(16) +
+    "WEIGHTED".padEnd(16) +
+    "QUALITATIVE GRADE";
+  const rows = r.criteria.map((c) => {
+    const name = (c.label + " (" + Math.round(c.weight * 100) + "%)").padEnd(42);
+    const score = (c.score + " / 100").padEnd(16);
+    const wtd = c.weighted.toFixed(2).padEnd(16);
+    return name + score + wtd + c.grade;
+  });
+  const composite =
+    "WEIGHTED COMPOSITE SCORE (100%)".padEnd(42) +
+    (r.composite.toFixed(2) + " / 100").padEnd(32) +
+    "GRADE: " + r.compositeGrade;
+  return [bar, head, dash, ...rows, dash, composite, bar, "", "Model: " + r.model, "Assessment: " + r.narrative].join("\n");
+}
+
+export function buildRevisionPrompt(
+  manuscript: string,
+  report: GradeReport,
+  target: number,
+): { system: string; prompt: string } {
+  const system =
+    "You are a master literary reviser. Your job is to raise a manuscript's grade while changing as FEW words as possible. You preserve the original voice, vibe, tense, diction, and style. You keep every chapter heading and the same story, characters, and events. You make minimal, surgical edits — prioritising pacing, narrative logic, coherence, and cleanliness. You NEVER add meta-commentary, notes, JSON, or code fences.";
+
+  const lowest = report.criteria.slice().sort((a, b) => a.score - b.score).slice(0, 3);
+  const prompt = [
+    "Target composite score: " + target + "/100. Current composite: " + report.composite + "/100 (" + report.compositeGrade + ").",
+    "Apply the smallest possible set of edits (add / change / delete as few words as possible) to reach the target. Do NOT rewrite wholesale. Keep the same plot and voice.",
+    "",
+    "LOWEST-SCORING WEIGHTED CRITERIA (fix these first):",
+    lowest.map((c) => "- " + c.label + ": " + c.score + "/100 — " + c.justification).join("\n"),
+    "",
+    "TOP WEAKNESSES:",
+    (report.weaknesses.length ? report.weaknesses : ["(none provided)"]).map((w) => "- " + w).join("\n"),
+    "",
+    "LINE-LEVEL REWRITE SUGGESTIONS (apply where they help):",
+    (report.rewrites.length ? report.rewrites : []).map((r) => '- "' + r.excerpt + '" => ' + r.suggestedRewrite + "  (" + r.diagnosis + ")").join("\n") || "- (none provided)",
+    "",
+    "Output ONLY the full revised manuscript text (all chapters, in order). No commentary.",
+    "",
+    "MANUSCRIPT:",
+    "<<<BEGIN_MANUSCRIPT>>>",
+    manuscript,
+    "<<<END_MANUSCRIPT>>>",
+  ].join("\n");
+
+  return { system, prompt };
+}

package/src/console/util.ts

@@ -0,0 +1,45 @@
+// Small shared helpers for the Engineering Console overlay.
+// Pure, dependency-free, framework-agnostic.
+
+export function cx(...parts: Array<string | false | null | undefined>): string {
+  return parts.filter(Boolean).join(" ");
+}
+
+export function round2(n: number): number {
+  return Math.round(n * 100) / 100;
+}
+
+export function clampNum(v: unknown, lo: number, hi: number, fallback: number): number {
+  const n = typeof v === "number" ? v : Number(v);
+  if (!Number.isFinite(n)) return fallback;
+  return Math.min(hi, Math.max(lo, n));
+}
+
+export function download(name: string, text: string): void {
+  try {
+    const blob = new Blob([text], { type: "text/plain;charset=utf-8" });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = name;
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    URL.revokeObjectURL(url);
+  } catch {
+    /* ignore */
+  }
+}
+
+export async function copyText(text: string): Promise<boolean> {
+  try {
+    await navigator.clipboard.writeText(text);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function nowStamp(): string {
+  return new Date().toISOString().replace("T", " ").replace(/\.\d+Z$/, "Z");
+}