2sagaco48 1.0.0

package/src/lib/pipeline.ts

@@ -0,0 +1,42 @@
+/**
+ * Production pipeline seam: separated prewriting research + unified genome.
+ * Alias callers receive this wrapper. Package-internal ChatApp imports its
+ * pipeline relatively and remains a documented non-interceptable boundary.
+ */
+export * from "./pipeline.orig";
+
+import { runMultiPassPipeline as packageRun } from "./pipeline.orig";
+import { runPrewritingResearch } from "@/lib/debug/research-phase";
+import { generateSynthesizedResponse } from '@/lib/models';
+
+type Args = Parameters<typeof packageRun>[0];
+type Result = Awaited<ReturnType<typeof packageRun>>;
+
+export async function runMultiPassPipeline(opts: Args): Promise<Result> {
+  const apiKey = String(opts.baseParams?.apiKey ?? "");
+  const research = await runPrewritingResearch({
+    question: opts.userQuery,
+    personaSeed: Number((opts.persona as any)?.seed ?? undefined) || undefined,
+    maxQueries: 8,
+    generateQueries: apiKey
+      ? (prompt) => generateSynthesizedResponse({
+          ...opts.baseParams,
+          userMessage: prompt,
+          retrievedWebData: undefined,
+          conversationHistory: [],
+        }).then((text) => ({ ok: !!text, text })).catch((e) => ({ ok: false, text: "", error: e instanceof Error ? e.message : String(e) }))
+      : undefined,
+    onProgress: (message) => opts.onTrace?.({ stage: 0, label: `Prewriting research · ${message}`, ts: Date.now(), ok: true }),
+  });
+  const urls = new Set((opts.retrievedData ?? []).map((s) => s.url));
+  const augmentedSources = [
+    ...(opts.retrievedData ?? []),
+    ...research.sources.filter((s) => !urls.has(s.url)),
+  ];
+  return packageRun({
+    ...opts,
+    userQuery: `${opts.userQuery}\n\n${research.innovation.directive}\n\n${research.dossier}`,
+    retrievedData: augmentedSources,
+    memory: { ...(opts.memory ?? {}), prewritingResearch: research },
+  });
+}

package/src/lib/precache.ts

@@ -0,0 +1,128 @@
+/**
+ * Pre-cache system for faster retrieval and computation.
+ * Caches common retrievals, computations, and LLM outputs to avoid redundant work.
+ */
+
+import { extractConstraints, type ExtractedConstraints } from "./constraints";
+
+interface CacheEntry<T> {
+  data: T;
+  timestamp: number;
+  ttl: number; // time-to-live in ms
+  hits: number;
+}
+
+class Cache<T> {
+  private store: Map<string, CacheEntry<T>> = new Map();
+  private defaultTTL: number;
+
+  constructor(defaultTTL: number = 5 * 60 * 1000) { // 5 minutes default
+    this.defaultTTL = defaultTTL;
+  }
+
+  // key() removed - using direct string keys instead
+
+  private isExpired(entry: CacheEntry<T>): boolean {
+    return Date.now() - entry.timestamp > entry.ttl;
+  }
+
+  get(key: string): T | null {
+    const entry = this.store.get(key);
+    if (!entry || this.isExpired(entry)) {
+      if (entry) this.store.delete(key);
+      return null;
+    }
+    entry.hits++;
+    return entry.data;
+  }
+
+  set(key: string, data: T, ttl?: number): void {
+    this.store.set(key, {
+      data,
+      timestamp: Date.now(),
+      ttl: ttl ?? this.defaultTTL,
+      hits: 0,
+    });
+  }
+
+  clear(): void {
+    this.store.clear();
+  }
+
+  stats(): { size: number; totalHits: number } {
+    let totalHits = 0;
+    this.store.forEach(entry => totalHits += entry.hits);
+    return { size: this.store.size, totalHits };
+  }
+}
+
+// Global caches
+export const constraintCache = new Cache<ExtractedConstraints>(10 * 60 * 1000); // 10 min
+export const searchCache = new Cache<any>(5 * 60 * 1000); // 5 min
+export const computationCache = new Cache<any>(15 * 60 * 1000); // 15 min
+export const llmCache = new Cache<string>(30 * 60 * 1000); // 30 min
+
+// Cached constraint extraction
+export function getCachedConstraints(query: string): ExtractedConstraints {
+  const cached = constraintCache.get(query);
+  if (cached) return cached;
+  const constraints = extractConstraints(query);
+  constraintCache.set(query, constraints);
+  return constraints;
+}
+
+// Pre-compute common patterns
+const COMMON_PATTERNS = [
+  "best stock to buy",
+  "NIH grant",
+  "heat pump",
+  "carbon",
+  "climate",
+  "investment",
+  "research",
+  "grant proposal",
+  "social welfare",
+  "mental health",
+  "housing",
+  "food insecurity",
+  "loneliness",
+];
+
+// Pre-warm cache for common queries
+export function preWarmCache(): void {
+  for (const pattern of COMMON_PATTERNS) {
+    const constraints = extractConstraints(pattern);
+    constraintCache.set(pattern, constraints, 60 * 60 * 1000); // 1 hour
+  }
+}
+
+// Pre-computation for common computations
+export function preComputeComputations(): void {
+  // Pre-compute common financial calculations
+  const commonComputations = [
+    { id: "rule_of_40", args: { growthPct: 60, marginPct: -15 } },
+    { id: "ltv_cac", args: { ltv: 1755, cac: 3000 } },
+    { id: "months_runway", args: { cash: 24000000, monthlyBurn: 1500000 } },
+  ];
+  for (const comp of commonComputations) {
+    computationCache.set(comp.id, comp.args, 60 * 60 * 1000);
+  }
+}
+
+// Initialize pre-warming on module load
+if (typeof window !== "undefined") {
+  setTimeout(() => {
+    preWarmCache();
+    preComputeComputations();
+  }, 1000);
+}
+
+// Cache stats for debugging
+export function getCacheStats(): Record<string, { size: number; totalHits: number }> {
+  return {
+    constraints: constraintCache.stats(),
+    search: searchCache.stats(),
+    computation: computationCache.stats(),
+    llm: llmCache.stats(),
+  };
+}

package/src/lib/py-sandbox.ts

@@ -0,0 +1,205 @@
+/**
+ * Deterministic Python-like Sandbox Runtime
+ * Safe expression evaluator for arithmetic, comparisons, finance/temporal helpers.
+ * No eval(), no arbitrary code — pure AST parsing and interpretation.
+ */
+
+type Expr =
+  | { type: "num"; value: number }
+  | { type: "str"; value: string }
+  | { type: "bool"; value: boolean }
+  | { type: "call"; func: string; args: Expr[] }
+  | { type: "binop"; op: string; left: Expr; right: Expr }
+  | { type: "unop"; op: string; operand: Expr }
+  | { type: "ident"; name: string };
+
+const HELPERS: Record<string, (...args: any[]) => any> = {
+  abs: (x: number) => Math.abs(x),
+  round: (x: number, d = 0) => Number(x.toFixed(d)),
+  floor: (x: number) => Math.floor(x),
+  ceil: (x: number) => Math.ceil(x),
+  min: (...xs: number[]) => Math.min(...xs),
+  max: (...xs: number[]) => Math.max(...xs),
+  sqrt: (x: number) => Math.sqrt(x),
+  pow: (x: number, y: number) => Math.pow(x, y),
+  sum: (...xs: number[]) => xs.reduce((a, b) => a + b, 0),
+  avg: (...xs: number[]) => xs.reduce((a, b) => a + b, 0) / xs.length,
+  pct: (part: number, whole: number) => whole !== 0 ? (part / whole) * 100 : 0,
+  pctChange: (from: number, to: number) => from !== 0 ? ((to - from) / from) * 100 : 0,
+  npv: (rate: number, ...cashflows: number[]) => cashflows.reduce((acc, cf, t) => acc + cf / Math.pow(1 + rate, t + 1), 0),
+  irr: (initial: number, ...cashflows: number[]) => {
+    let r = 0.1;
+    for (let i = 0; i < 100; i++) {
+      const npvVal = cashflows.reduce((acc, cf, t) => acc + cf / Math.pow(1 + r, t + 1), 0) - initial;
+      const dnpv = cashflows.reduce((acc, cf, t) => acc + (-(t + 1) * cf) / Math.pow(1 + r, t + 2), 0);
+      if (Math.abs(dnpv) < 1e-12) break;
+      r -= npvVal / dnpv;
+    }
+    return r;
+  },
+  cagr: (begin: number, end: number, years: number) => years > 0 && begin > 0 ? Math.pow(end / begin, 1 / years) - 1 : 0,
+  daysBetween: (ts1: number, ts2: number) => Math.floor(Math.abs(ts2 - ts1) / (1000 * 60 * 60 * 24)),
+  mean: (...xs: number[]) => xs.reduce((a, b) => a + b, 0) / xs.length,
+  variance: (...xs: number[]) => { const m = xs.reduce((a, b) => a + b, 0) / xs.length; return xs.reduce((acc, x) => acc + Math.pow(x - m, 2), 0) / xs.length; },
+  stdev: (...xs: number[]) => Math.sqrt(xs.reduce((acc, x) => acc + Math.pow(x - xs.reduce((a, b) => a + b, 0) / xs.length, 2), 0) / xs.length),
+  len: (s: string) => s.length,
+  upper: (s: string) => s.toUpperCase(),
+  lower: (s: string) => s.toLowerCase(),
+};
+
+function tokenize(code: string): string[] {
+  const tokens: string[] = [];
+  let i = 0;
+  while (i < code.length) {
+    const ch = code[i];
+    if (/\s/.test(ch)) { i++; continue; }
+    if (/[0-9.]/.test(ch)) {
+      let num = "";
+      while (i < code.length && /[0-9.]/.test(code[i])) num += code[i++];
+      tokens.push(num);
+    } else if (/[a-zA-Z_]/.test(ch)) {
+      let ident = "";
+      while (i < code.length && /[a-zA-Z0-9_]/.test(code[i])) ident += code[i++];
+      tokens.push(ident);
+    } else if (ch === '"' || ch === "'") {
+      const quote = ch;
+      let str = "";
+      i++;
+      while (i < code.length && code[i] !== quote) str += code[i++];
+      i++;
+      tokens.push(`"${str}"`);
+    } else if (["==", "!=", "<=", ">=", "&&", "||"].includes(code.slice(i, i + 2))) {
+      tokens.push(code.slice(i, i + 2));
+      i += 2;
+    } else if (["+", "-", "*", "/", "%", "^", "(", ")", ",", "[", "]", ">", "<", "=", "!"].includes(ch)) {
+      tokens.push(ch);
+      i++;
+    } else { i++; }
+  }
+  return tokens;
+}
+
+class Parser {
+  tokens: string[];
+  pos = 0;
+  constructor(tokens: string[]) { this.tokens = tokens; }
+  peek(): string { return this.tokens[this.pos] ?? ""; }
+  consume(): string { return this.tokens[this.pos++] ?? ""; }
+  parse(): Expr { return this.parseExpr(); }
+  parseExpr(): Expr { return this.parseComparison(); }
+  parseComparison(): Expr {
+    let left = this.parseAdditive();
+    while (["==", "!=", "<=", ">=", "<", ">"].includes(this.peek())) {
+      const op = this.consume();
+      const right = this.parseAdditive();
+      left = { type: "binop", op, left, right };
+    }
+    return left;
+  }
+  parseAdditive(): Expr {
+    let left = this.parseMultiplicative();
+    while (["+", "-"].includes(this.peek())) {
+      const op = this.consume();
+      const right = this.parseMultiplicative();
+      left = { type: "binop", op, left, right };
+    }
+    return left;
+  }
+  parseMultiplicative(): Expr {
+    let left = this.parsePower();
+    while (["*", "/", "%"].includes(this.peek())) {
+      const op = this.consume();
+      const right = this.parsePower();
+      left = { type: "binop", op, left, right };
+    }
+    return left;
+  }
+  parsePower(): Expr {
+    let left = this.parsePrimary();
+    if (this.peek() === "^") {
+      this.consume();
+      const right = this.parsePrimary();
+      left = { type: "binop", op: "^", left, right };
+    }
+    return left;
+  }
+  parsePrimary(): Expr {
+    const tok = this.peek();
+    if (!tok) throw new Error("Unexpected end");
+    if (/^[0-9.]+$/.test(tok)) { this.consume(); return { type: "num", value: parseFloat(tok) }; }
+    if (tok.startsWith('"')) { this.consume(); return { type: "str", value: tok.slice(1, -1) }; }
+    if (/^[a-zA-Z_]/.test(tok)) {
+      this.consume();
+      if (this.peek() === "(") {
+        this.consume();
+        const args: Expr[] = [];
+        while (this.peek() !== ")") {
+          args.push(this.parseExpr());
+          if (this.peek() === ",") this.consume();
+        }
+        this.consume();
+        return { type: "call", func: tok, args };
+      }
+      return { type: "ident", name: tok };
+    }
+    if (tok === "(") {
+      this.consume();
+      const expr = this.parseExpr();
+      if (this.peek() === ")") this.consume();
+      return expr;
+    }
+    throw new Error(`Unexpected: ${tok}`);
+  }
+}
+
+function evaluate(expr: Expr, env: Record<string, any> = {}): any {
+  switch (expr.type) {
+    case "num": case "str": case "bool": return expr.value;
+    case "ident": return env[expr.name] ?? 0;
+    case "binop": {
+      const l = evaluate(expr.left, env);
+      const r = evaluate(expr.right, env);
+      if (typeof l === "number" && typeof r === "number") {
+        switch (expr.op) {
+          case "+": return l + r; case "-": return l - r; case "*": return l * r;
+          case "/": return r !== 0 ? l / r : 0; case "%": return l % r; case "^": return Math.pow(l, r);
+          case "==": return l === r; case "!=": return l !== r;
+          case "<": return l < r; case ">": return l > r; case "<=": return l <= r; case ">=": return l >= r;
+        }
+      }
+      return 0;
+    }
+    case "unop": { const v = evaluate(expr.operand, env); return typeof v === "number" && expr.op === "-" ? -v : v; }
+    case "call": {
+      const args = expr.args.map(a => evaluate(a, env));
+      const fn = HELPERS[expr.func];
+      return fn ? fn(...args) : 0;
+    }
+    default: return 0;
+  }
+}
+
+export interface SandboxResult { success: boolean; result: any; error?: string; trace?: string; }
+
+export function runSandbox(code: string): SandboxResult {
+  try {
+    const tokens = tokenize(code);
+    const parser = new Parser(tokens);
+    const ast = parser.parse();
+    const result = evaluate(ast);
+    return { success: true, result, trace: `AST: ${JSON.stringify(ast).slice(0, 200)}` };
+  } catch (err: any) {
+    return { success: false, result: null, error: err.message };
+  }
+}
+
+export const SANDBOX_TEMPLATES = [
+  { label: "pctChange(from, to)", code: "pctChange(211.14, 308.81)" },
+  { label: "round(pct(a, b), d)", code: "round(pct(57 + 41, 100), 1)" },
+  { label: "daysBetween(ts1, ts2)", code: "daysBetween(0, 60 * 86400000)" },
+  { label: "NPV", code: "npv(0.1, -100, 40, 50, 60)" },
+  { label: "CAGR", code: "cagr(100, 250, 5)" },
+  { label: "IRR", code: "irr(1000, 300, 400, 500)" },
+  { label: "mean", code: "mean(10, 20, 30, 40, 50)" },
+  { label: "stdev", code: "stdev(10, 20, 30, 40, 50)" },
+];

package/src/lib/quality-score.ts

@@ -0,0 +1,96 @@
+import type { ComputeRecord } from "./compute-sandbox";
+
+export interface QualityScoreItem {
+  name: string;
+  score: number;
+  note: string;
+}
+
+export interface NumericAuditItem {
+  value: string;
+  status: "computed" | "sourced" | "unverified";
+  rationale: string;
+  unit?: string;
+  line?: number;
+}
+
+export interface QualityReport {
+  overall: number;
+  items: QualityScoreItem[];
+  numericAudit: NumericAuditItem[];
+  triggeredKernels: string[];
+  mythos: string;
+}
+
+const clamp10 = (n: number) => Math.max(1, Math.min(10, Math.round(n)));
+
+function hasAny(text: string, terms: RegExp[]) {
+  return terms.some((re) => re.test(text));
+}
+
+function numericAudit(answer: string, computeRecords: ComputeRecord[]): NumericAuditItem[] {
+  const computedText = computeRecords
+    .flatMap((r) => r.result ? Object.values(r.result).map(String) : [])
+    .join(" ");
+  const numbers = Array.from(new Set(answer.match(/\b\d+(?:\.\d+)?\s*(?:%|percent|million|billion|trillion|k|M|B|clusters?|sites?|participants?|adults?|months?|years?|QALYs?|ROI|ICC|IAC|β|alpha|α)?\b/gi) ?? []))
+    .slice(0, 32);
+  const lines = answer.split(/\n/);
+  return numbers.map((value) => {
+    const escaped = value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const nearSource = new RegExp(`${escaped}[\\s\\S]{0,80}(?:Source|source|citation|NIH|NOFO|NOT-)`, "i").test(answer) ||
+      new RegExp(`(?:Source|source|citation|NIH|NOFO|NOT-)[\\s\\S]{0,80}${escaped}`, "i").test(answer);
+    const computed = computedText.includes(value.replace(/\s+/g, "")) || computeRecords.some((r) => JSON.stringify(r.result ?? {}).includes(value.replace(/\s+/g, "")));
+    const unitMatch = value.match(/(%|percent|million|billion|trillion|k|M|B|clusters?|sites?|participants?|adults?|months?|years?|QALYs?|ROI|ICC|IAC|β|alpha|α)$/i);
+    const line = lines.findIndex(l => l.includes(value));
+    const base = { value, unit: unitMatch?.[1], line: line >= 0 ? line + 1 : undefined };
+    if (computed) return { ...base, status: "computed" as const, rationale: "Matches deterministic compute sandbox output." };
+    if (nearSource) return { ...base, status: "sourced" as const, rationale: "Appears adjacent to source/citation language." };
+    return { ...base, status: "unverified" as const, rationale: "Not linked to a compute record or nearby citation; treat as load-bearing only if externally verified." };
+  });
+}
+
+export function scoreAnswer(opts: {
+  query: string;
+  answer: string;
+  sourceCount: number;
+  verifiedClaims: number;
+  totalClaims: number;
+  computeRecords: ComputeRecord[];
+  activeTemplateId?: string;
+}): QualityReport {
+  const a = opts.answer;
+  const lower = a.toLowerCase();
+  const nums = numericAudit(a, opts.computeRecords);
+  const unverifiedNums = nums.filter((n) => n.status === "unverified").length;
+  const refusal = /\b(provided data|retrieved sources|source context|available evidence)\b[\s\S]{0,160}\b(does not contain|insufficient|cannot|unable)\b/i.test(a)
+    || /A defensible answer can be built from the retrieved evidence/i.test(a)
+    || a.trim().length < 200;
+  const placeholder = /\[(?:list of|description of|insert|tbd|placeholder|source\s*\d+(?:\s*,\s*(?:source\s*)?\d+)+)[^\]]*\]/i.test(a);
+  const journalAbstract = /\bmethods\b[\s\S]{0,80}\bresults\b[\s\S]{0,80}\bconclusions\b/i.test(a) && /\banticipated|projected|we hypothesize|expected reduction\b/i.test(a);
+  const templateFit = opts.activeTemplateId ? !placeholder && !journalAbstract && a.length > 600 : a.length > 250;
+  const coverage = opts.totalClaims > 0 ? opts.verifiedClaims / opts.totalClaims : opts.sourceCount > 0 ? 0.5 : 0.2;
+
+  const items: QualityScoreItem[] = [
+    { name: "Science / Method", score: clamp10(6 + (hasAny(lower, [/specific aims/i, /approach/i, /analytic/i, /mechanism/i]) ? 2 : 0) - (journalAbstract ? 4 : 0)), note: journalAbstract ? "Journal-style abstract structure detected." : "Method structure appears bounded by current gates." },
+    { name: "Math / Numerics", score: clamp10(10 - unverifiedNums * 2), note: unverifiedNums ? `${unverifiedNums} number(s) lack compute/source linkage.` : "No unsupported load-bearing numbers detected." },
+    { name: "Grounding", score: clamp10(4 + Math.round(coverage * 6) - (refusal && opts.sourceCount >= 8 ? 5 : 0)), note: refusal ? "Source-rich refusal pattern detected." : `${opts.verifiedClaims}/${opts.totalClaims || 1} claims verified with ${opts.sourceCount} source(s).` },
+    { name: "Template Fit", score: clamp10(templateFit ? 9 : 4), note: templateFit ? "Output appears to follow a substantive structure." : "Template or section completeness risk detected." },
+    { name: "Tone / AI-ness", score: clamp10(9 - (hasAny(lower, [/as an ai/i, /i cannot/i, /provided data does not/i]) ? 4 : 0)), note: hasAny(lower, [/as an ai/i, /provided data does not/i]) ? "AI/metadiscourse leakage detected." : "Plain-English output without obvious AI disclaimers." },
+  ];
+  const overall = clamp10(items.reduce((s, x) => s + x.score, 0) / items.length);
+  const triggeredKernels = [
+    "K27 Atomic claim extraction",
+    "K28 Claim-source entailment",
+    "GATE-SOURCE-RICH-REFUSAL",
+    "GATE-CITATION-BLEED",
+    unverifiedNums ? "GATE-L NUMERICAL DETERMINISM" : "GATE-L NUMERICAL DETERMINISM PASS",
+    opts.activeTemplateId ? `Template:${opts.activeTemplateId}` : "Template:none",
+  ];
+  return {
+    overall,
+    items,
+    numericAudit: nums,
+    triggeredKernels,
+    mythos: overall >= 9 ? "Stable: answer, evidence, and style form a coherent report object." : "Needs review: at least one quality dimension remains below frontier-grade threshold.",
+  };
+}