2sagaco48 1.0.0

package/src/lib/sloop-runner.base.ts

@@ -0,0 +1,223 @@
+/**
+ * Adaptive SLOOP Runner — v2
+ *
+ * Strategy selection based on model intelligence (Arena Elo-aligned):
+ *
+ *  NATIVE MODE (intel ≥ NATIVE_THRESHOLD, default 85):
+ *    One single LLM call produces the entire report with SLOOP section
+ *    structure preserved (## headings). Fast, lowest memory overhead.
+ *    N-Deep can still process it section-by-section via the digest path.
+ *
+ *  SECTIONED MODE (intel < NATIVE_THRESHOLD):
+ *    Original streaming section-per-call approach. Each section is
+ *    generated independently; prior summaries provide continuity.
+ *    Memory: O(max_section_size) peak per call vs O(full_report) for native.
+ *
+ * The choice is transparent — callers always receive { finalText, trace, calls }.
+ * N-Deep downstream uses buildDraftDigest() regardless of how the draft was
+ * produced, so the two modes are fully interchangeable as N-Deep input.
+ */
+import { generateSynthesizedResponse, type GenerateParams } from "./models";
+import { buildReportSpec } from "./sloop";
+import type { PipelineTrace } from "./pipeline";
+import { settleHeap } from "./memory-governor";
+import { intelligenceOf } from "./model-intelligence";
+
+export interface SloopRunResult {
+  finalText: string;
+  trace: PipelineTrace[];
+  calls: number;
+  mode: "native" | "sectioned";
+}
+
+/** Models at or above this score produce the full report in one call. */
+const NATIVE_THRESHOLD = 85;
+
+/**
+ * Hard ceiling on pages for native single-call mode. Frontier models have an
+ * 8192 token output limit; 8 pages is the upper bound where native can still
+ * succeed on strong models. A completeness gate below catches truncation and
+ * falls back to sectioned mode if native output returns only late sections.
+ */
+const NATIVE_PAGE_CEILING = 8;
+
+function compactSources(sources: { title: string; url: string; content: string }[], sectionIndex: number) {
+  if (sources.length === 0) return [];
+  const start = (sectionIndex * 3) % Math.max(1, sources.length);
+  const rotated = [...sources.slice(start), ...sources.slice(0, start)];
+  return rotated.slice(0, 8).map(s => ({ title: s.title, url: s.url, content: (s.content || "").slice(0, 700) }));
+}
+
+function allSources(sources: { title: string; url: string; content: string }[]) {
+  // For native mode: provide all sources but cap content more aggressively
+  // to prevent the single prompt from blowing up the context window.
+  return sources.slice(0, 16).map(s => ({
+    title: s.title, url: s.url,
+    content: (s.content || "").slice(0, 1500),
+  }));
+}
+
+type SloopSection = ReturnType<typeof buildReportSpec>["sections"][number];
+
+function sectionCoverage(text: string, sections: SloopSection[]): { hits: number; required: number; firstOk: boolean } {
+  const lower = text.toLowerCase();
+  const hits = sections.filter(s => lower.includes(s.name.toLowerCase())).length;
+  const required = Math.max(3, Math.ceil(sections.length * 0.7));
+  const firstIdx = lower.indexOf(sections[0]?.name.toLowerCase() ?? "");
+  return { hits, required, firstOk: firstIdx >= 0 && firstIdx < 1200 };
+}
+
+function chooseArchetype(templateId?: string): string {
+  if (templateId === "NIH-GRANT-SRF" || templateId === "OMEGA-SCIENCE") return "scientific-academic";
+  if (templateId === "OMEGA-DILIGENCE") return "audit-assurance";
+  if (templateId === "OMEGA-BUILD") return "implementation-tech";
+  if (templateId === "OMEGA-DISCOVERY") return "market-commercial";
+  if (templateId === "OMEGA-COMPLIANCE") return "audit-assurance";
+  return "decision-strategy";
+}
+
+// ─── Native mode: one call, full report ───────────────────────────────────────
+
+async function runNativeReport(opts: {
+  query: string;
+  baseParams: GenerateParams;
+  sources: { title: string; url: string; content: string }[];
+  templateId?: string;
+  pages: number;
+  onTrace?: (t: PipelineTrace) => void;
+  onDebug?: (msg: string) => void;
+}): Promise<SloopRunResult> {
+  const spec = buildReportSpec(chooseArchetype(opts.templateId), opts.templateId ?? null);
+  const targetSections = spec.sections.slice(0, Math.max(4, Math.min(spec.sections.length, opts.pages + 2)));
+  const sectionList = targetSections.map((s, i) => `${i + 1}. ## ${s.name}`).join("\n");
+  const wordTarget = Math.max(300, opts.pages * 650);
+
+  const prompt = [
+    `Produce a COMPLETE, FULLY WRITTEN ${opts.pages}-page report using the SLOOP structure below.`,
+    `Use EXACTLY these section headings (## prefix). Do not add, rename, or merge sections.`,
+    `Target total length: ~${wordTarget} words. Write each section with full substance — no stubs, no placeholders, no meta-commentary.`,
+    `Use evidence from the retrieved sources. Where gaps exist, write professional investigator-owned analysis.`,
+    ``,
+    `SLOOP SECTIONS (generate all of them):`,
+    sectionList,
+    ``,
+    `USER ASK: ${opts.query}`,
+  ].filter(Boolean).join("\n");
+
+  opts.onDebug?.(`[SLOOP native] single-call for ${targetSections.length} sections (~${wordTarget} words)`);
+  const text = await generateSynthesizedResponse({
+    ...opts.baseParams,
+    userMessage: prompt,
+    retrievedWebData: allSources(opts.sources),
+    conversationHistory: [],
+  });
+
+  const cleaned = text.trim();
+  const coverage = sectionCoverage(cleaned, targetSections);
+  const minChars = Math.max(1200, opts.pages * 1500);
+  if (coverage.hits < coverage.required || !coverage.firstOk || cleaned.length < minChars) {
+    opts.onDebug?.(`[SLOOP native] incomplete/truncated (${coverage.hits}/${targetSections.length} headings, firstOk=${coverage.firstOk}, chars=${cleaned.length}) — falling back to sectioned mode`);
+    const fallback = await runSectionedReport(opts);
+    return { ...fallback, calls: fallback.calls + 1 };
+  }
+  const t: PipelineTrace = {
+    stage: 4,
+    label: `SLOOP native: ${targetSections.length} sections, ${cleaned.length} chars`,
+    ts: Date.now(),
+    ok: cleaned.length > 200,
+    data: { chars: cleaned.length, sections: targetSections.length, mode: "native" },
+  };
+  opts.onTrace?.(t);
+  opts.onDebug?.(`[SLOOP native] complete: ${cleaned.length} chars`);
+
+  return { finalText: String(cleaned), trace: [t], calls: 1, mode: "native" };
+}
+
+// ─── Sectioned mode: stream section-by-section ────────────────────────────────
+
+async function runSectionedReport(opts: {
+  query: string;
+  baseParams: GenerateParams;
+  sources: { title: string; url: string; content: string }[];
+  templateId?: string;
+  pages: number;
+  onTrace?: (t: PipelineTrace) => void;
+  onDebug?: (msg: string) => void;
+}): Promise<SloopRunResult> {
+  const spec = buildReportSpec(chooseArchetype(opts.templateId), opts.templateId ?? null);
+  const targetSections = spec.sections.slice(0, Math.max(4, Math.min(spec.sections.length, opts.pages + 2)));
+  const trace: PipelineTrace[] = [];
+  let calls = 0;
+  let consolidated = "";
+  const priorSummaries: string[] = [];
+
+  for (let i = 0; i < targetSections.length; i++) {
+    const section = targetSections[i];
+    const evidence = compactSources(opts.sources, i);
+    const prompt = [
+      `Generate ONLY the "${section.name}" section for the report requested by the user.`,
+      `This is SLOOP section ${i + 1}/${targetSections.length}; do not generate other sections.`,
+      `No placeholders, no meta-commentary, no raw [Source N] tokens.`,
+      `Use concrete, specific content from the evidence. If a detail is missing, write a professional investigator-owned note, not an AI refusal.`,
+      `Target depth: ${Math.max(250, Math.round((opts.pages * 700) / targetSections.length))} words for this section.`,
+      section.requiredFields?.length ? `Required fields: ${section.requiredFields.join(", ")}` : "",
+      `Prior section summaries for continuity:\n${priorSummaries.slice(-3).join("\n")}`,
+      `USER ASK: ${opts.query}`,
+    ].filter(Boolean).join("\n\n");
+
+    opts.onDebug?.(`[SLOOP sectioned] section ${i + 1}/${targetSections.length}: ${section.name}`);
+    const text = await generateSynthesizedResponse({
+      ...opts.baseParams,
+      userMessage: prompt,
+      retrievedWebData: evidence,
+      conversationHistory: [],
+    });
+    calls++;
+    const cleaned = text.trim();
+    const block = `## ${section.name}\n\n${cleaned}`;
+    consolidated = consolidated ? `${consolidated}\n\n${block}` : block;
+    const preview = String(cleaned.slice(0, 200));
+    opts.onDebug?.(`[SLOOP preview ${i + 1}/${targetSections.length}] ${preview}${cleaned.length > 200 ? "..." : ""}`);
+    priorSummaries.push(String(`${section.name}: ${cleaned.slice(0, 240).replace(/\s+/g, " ")}`));
+    const t: PipelineTrace = {
+      stage: 4 + (i + 1) / 100,
+      label: `SLOOP section: ${section.name}`,
+      ts: Date.now(),
+      ok: cleaned.length > 80,
+      data: { chars: cleaned.length, preview },
+    };
+    trace.push(t);
+    opts.onTrace?.(t);
+    await settleHeap(12);
+  }
+
+  return { finalText: String(consolidated), trace, calls, mode: "sectioned" };
+}
+
+// ─── Public API ───────────────────────────────────────────────────────────────
+
+export async function runSloopReport(opts: {
+  query: string;
+  baseParams: GenerateParams;
+  sources: { title: string; url: string; content: string }[];
+  templateId?: string;
+  pages: number;
+  onTrace?: (t: PipelineTrace) => void;
+  onDebug?: (msg: string) => void;
+}): Promise<SloopRunResult> {
+  const intel = intelligenceOf(opts.baseParams.model);
+  // Native mode requires BOTH (a) strong-enough model AND (b) requested pages
+  // within the 8192-token output ceiling. For >NATIVE_PAGE_CEILING pages,
+  // ALWAYS fall back to sectioned mode to prevent silent truncation
+  // (the "only appendix returned" failure mode observed in field testing).
+  const wouldTruncate = opts.pages > NATIVE_PAGE_CEILING;
+  const useNative = intel >= NATIVE_THRESHOLD && !wouldTruncate;
+  opts.onDebug?.(
+    `[SLOOP] model=${opts.baseParams.model} intel=${intel} pages=${opts.pages} → mode=${useNative ? "native (single-call)" : wouldTruncate ? `sectioned (pages ${opts.pages} > ${NATIVE_PAGE_CEILING} native ceiling — avoiding output truncation)` : "sectioned (stream)"}`
+  );
+  if (useNative) {
+    return runNativeReport(opts);
+  } else {
+    return runSectionedReport(opts);
+  }
+}

package/src/lib/sloop-runner.ts

@@ -0,0 +1,104 @@
+/**
+ * Persistent OMEGA-aware SLOOP runner.
+ * Fixes the package runner's lossy generic mapping and page-based section drop.
+ */
+export * from "./sloop-runner.base";
+import { runSloopReport as baseRunSloopReport, type SloopRunResult } from "./sloop-runner.base";
+import { generateSynthesizedResponse, type GenerateParams } from "@/lib/models";
+import type { PipelineTrace } from "@/lib/pipeline";
+import { intelligenceOf } from "@/lib/model-intelligence";
+import { settleHeap } from "@/lib/memory-governor";
+import { buildAdaptiveTemplateContract, getOmegaTemplate } from "./omega-templates";
+
+type Opts = {
+  query: string;
+  baseParams: GenerateParams;
+  sources: { title: string; url: string; content: string }[];
+  templateId?: string;
+  pages: number;
+  onTrace?: (t: PipelineTrace) => void;
+  onDebug?: (msg: string) => void;
+};
+
+const NATIVE_THRESHOLD = 85;
+const NATIVE_PAGE_CEILING = 8;
+
+function sourceSlice(sources: Opts["sources"], sectionIndex = 0, max = 10) {
+  if (!sources.length) return [];
+  const start = (sectionIndex * 3) % sources.length;
+  return [...sources.slice(start), ...sources.slice(0, start)].slice(0, max).map(s => ({ ...s, content: (s.content || "").slice(0, 900) }));
+}
+
+function sectionCoverage(text: string, headings: string[]) {
+  const lower = text.toLowerCase();
+  const hits = headings.filter(h => lower.includes(h.toLowerCase())).length;
+  const empty = headings.filter(h => {
+    const at = lower.indexOf(h.toLowerCase());
+    if (at < 0) return false;
+    const next = headings.map(x => lower.indexOf(x.toLowerCase(), at + h.length)).filter(x => x > at).sort((a, b) => a - b)[0] ?? text.length;
+    return text.slice(at + h.length, next).replace(/\s/g, "").length < 40;
+  });
+  return { hits, empty };
+}
+
+async function sectioned(opts: Opts, contract: string): Promise<SloopRunResult> {
+  const t = getOmegaTemplate(opts.templateId)!;
+  const trace: PipelineTrace[] = [];
+  const summaries: string[] = [];
+  const targetWords = Math.max(700, opts.pages * 550);
+  const mainCount = Math.max(1, t.sections.filter(s => !/^§A/.test(s.id)).length);
+  const wordsPer = Math.max(90, Math.floor(targetWords / mainCount));
+  let full = "";
+  for (let i = 0; i < t.sections.length; i++) {
+    const s = t.sections[i];
+    const prompt = [
+      `Write ONLY the "${s.title}" section of a ${t.id} report.`,
+      `Section contract: ${s.hint}`,
+      `Target: ${/^§A/.test(s.id) ? "a compact evidence/method appendix" : `about ${wordsPer} words`}.`,
+      "Use the exact heading shown below. No other report sections. No placeholders, invented evidence, fake interviews, fake calculations, or bare headings.",
+      `Exact heading: ## ${s.title}`,
+      contract,
+      summaries.length ? `Prior-section continuity summaries:\n${summaries.slice(-3).join("\n")}` : "",
+      `USER ASK: ${opts.query}`,
+    ].filter(Boolean).join("\n\n");
+    opts.onDebug?.(`[SLOOP OMEGA sectioned] ${i + 1}/${t.sections.length}: ${s.title}`);
+    const raw = await generateSynthesizedResponse({ ...opts.baseParams, userMessage: prompt, retrievedWebData: sourceSlice(opts.sources, i), conversationHistory: [] });
+    const cleaned = raw.trim().replace(new RegExp(`^#{1,6}\\s*${s.title.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*`, "i"), "").trim();
+    const block = `## ${s.title}\n\n${cleaned || "[DATA GAP] Section generation returned no substantive content."}`;
+    full += (full ? "\n\n" : "") + block;
+    summaries.push(`${s.title}: ${cleaned.slice(0, 220).replace(/\s+/g, " ")}`);
+    const tr: PipelineTrace = { stage: 4 + (i + 1) / 100, label: `SLOOP OMEGA section: ${s.title}`, ts: Date.now(), ok: cleaned.length >= 40, data: { chars: cleaned.length, preview: cleaned.slice(0, 160) } };
+    trace.push(tr); opts.onTrace?.(tr);
+    await settleHeap(12);
+  }
+  return { finalText: full, trace, calls: t.sections.length, mode: "sectioned" };
+}
+
+export async function runSloopReport(opts: Opts): Promise<SloopRunResult> {
+  const template = getOmegaTemplate(opts.templateId);
+  if (!template) return baseRunSloopReport(opts);
+  const contract = buildAdaptiveTemplateContract({ templateId: opts.templateId, targetPages: opts.pages, evidenceAvailable: opts.sources.length > 0 });
+  const native = intelligenceOf(opts.baseParams.model) >= NATIVE_THRESHOLD && opts.pages <= NATIVE_PAGE_CEILING;
+  if (!native) return sectioned(opts, contract);
+
+  const headings = template.sections.map(s => s.title);
+  const wordTarget = Math.max(700, opts.pages * 550);
+  opts.onDebug?.(`[SLOOP OMEGA native] ${template.id}: ALL ${headings.length} sections, ~${wordTarget} words`);
+  const raw = await generateSynthesizedResponse({
+    ...opts.baseParams,
+    userMessage: `${contract}\n\nWrite the complete report now. Include ALL contracted sections in order, fully written. USER ASK: ${opts.query}`,
+    retrievedWebData: sourceSlice(opts.sources, 0, 16),
+    conversationHistory: [],
+  });
+  const text = raw.trim();
+  const coverage = sectionCoverage(text, headings);
+  const minChars = Math.max(1200, opts.pages * 1300);
+  if (coverage.hits < headings.length || coverage.empty.length || text.length < minChars) {
+    opts.onDebug?.(`[SLOOP OMEGA native] incomplete (${coverage.hits}/${headings.length}, empty=${coverage.empty.join(",") || "none"}, chars=${text.length}) — sectioned fallback`);
+    const fallback = await sectioned(opts, contract);
+    return { ...fallback, calls: fallback.calls + 1 };
+  }
+  const tr: PipelineTrace = { stage: 4, label: `SLOOP OMEGA native: ${headings.length} sections`, ts: Date.now(), ok: true, data: { chars: text.length, sections: headings.length } };
+  opts.onTrace?.(tr);
+  return { finalText: text, trace: [tr], calls: 1, mode: "native" };
+}

package/src/lib/sloop.ts

@@ -0,0 +1,114 @@
+// MODULE D — SLOOP: Small-LLM Orchestration for Output Production.
+// Decomposes a report into per-section sessions, each fitting inside a small
+// model's context window (default 4096 tokens). Pure orchestration code;
+// the LLM is called per section, never given the whole report at once.
+
+export interface SectionSpec {
+  id: string;
+  name: string;
+  promptTemplate: string;          // small, focused prompt for THIS section only
+  evidenceChunks: string[];        // IDs of evidence chunks to inject
+  dependsOn: string[];             // sections whose summaries we need
+  outputSchema?: string;           // JSON schema name (for structured decoding)
+  maxOutputTokens: number;
+  requiredFields?: string[];
+}
+
+export interface ReportSpec {
+  reportId: string;
+  template: string;                 // OMEGA archetype id
+  styleOverride: string | null;
+  sections: SectionSpec[];
+  assemblyOrder: string[];
+  calculations?: Record<string, { fn: string; inputsFrom: string }>;
+}
+
+export interface SessionBudget {
+  systemPromptTok: number;
+  contextSummaryTok: number;
+  evidenceTok: number;
+  outputReserveTok: number;
+  safetyMarginTok: number;
+}
+
+export const DEFAULT_BUDGET_4K: SessionBudget = {
+  systemPromptTok: 600,
+  contextSummaryTok: 500,
+  evidenceTok: 1200,
+  outputReserveTok: 1200,
+  safetyMarginTok: 596,
+};
+
+export function totalBudget(b: SessionBudget): number {
+  return b.systemPromptTok + b.contextSummaryTok + b.evidenceTok + b.outputReserveTok + b.safetyMarginTok;
+}
+
+// Rough token estimate (≈4 chars / token, std English heuristic).
+export const estTokens = (s: string) => Math.max(1, Math.round(s.length / 4));
+
+export interface ModelProfile {
+  id: string;
+  name: string;
+  ctxTokens: number;
+  budget: SessionBudget;
+  notes: string;
+}
+
+export const MODEL_PROFILES: ModelProfile[] = [
+  { id: "apple-fm", name: "Apple Foundation Model (on-device)", ctxTokens: 4096, budget: DEFAULT_BUDGET_4K, notes: "Standard SLOOP loop." },
+  { id: "phi-3-mini", name: "Phi-3 mini", ctxTokens: 4096, budget: DEFAULT_BUDGET_4K, notes: "Same budget; use JSON mode." },
+  { id: "qwen2-5-3b", name: "Qwen2.5 3B", ctxTokens: 4096, budget: DEFAULT_BUDGET_4K, notes: "Standard SLOOP loop." },
+  { id: "gemma-2b", name: "Gemma 2B", ctxTokens: 8192, budget: { ...DEFAULT_BUDGET_4K, evidenceTok: 2400, outputReserveTok: 2400, safetyMarginTok: 600 }, notes: "Double evidence chunks." },
+  { id: "llama-3-2-1b", name: "Llama 3.2 1B", ctxTokens: 8192, budget: { ...DEFAULT_BUDGET_4K, evidenceTok: 2400, outputReserveTok: 2000, safetyMarginTok: 800 }, notes: "Add verification session." },
+  { id: "phi-4", name: "Phi-4", ctxTokens: 16384, budget: { ...DEFAULT_BUDGET_4K, evidenceTok: 6000, outputReserveTok: 4000, safetyMarginTok: 2000 }, notes: "Can batch 2-3 sections." },
+  { id: "mistral-7b", name: "Mistral 7B", ctxTokens: 32768, budget: { ...DEFAULT_BUDGET_4K, evidenceTok: 12000, outputReserveTok: 8000, safetyMarginTok: 4000 }, notes: "Can batch 4-6 sections." },
+];
+
+export interface EscalationTrigger { id: string; label: string; }
+export const ESCALATION_TRIGGERS: EscalationTrigger[] = [
+  { id: "world-knowledge", label: "Task requires world knowledge not in evidence chunks" },
+  { id: "deep-reasoning", label: "Section requires >3 inference steps" },
+  { id: "cross-synthesis", label: "Creative synthesis across >4 evidence sources" },
+  { id: "tier-5", label: "User explicitly requested deep / Tier-5 mode" },
+  { id: "contradiction", label: "Verification detected contradictions requiring judgment" },
+  { id: "crisis-legal", label: "OMEGA-CRISIS with privilege / legal implications" },
+];
+
+export const SLOOP_PRINCIPLES = [
+  "Calculations are deterministic, not LLM-generated",
+  "Each session is stateless (memory is in controller-side summaries)",
+  "Structured output only (JSON schema → prose formatter)",
+  "Verification is controller-side, not another LLM pass",
+  "Graceful degradation: retry once, then emit [INCOMPLETE] tag",
+  "Evidence pre-chunked and ranked by relevance",
+];
+
+/** Build a default per-archetype section pipeline. */
+export function buildReportSpec(archetypeId: string, styleOverride: string | null = null): ReportSpec {
+  const orderByArchetype: Record<string, string[]> = {
+    "decision-strategy":     ["bluf", "situation", "diagnostic", "options", "recommendation", "implementation", "risks", "appendix"],
+    "investment-financial":  ["thesis", "asset", "market", "commercial-dd", "financial-dd", "value-plan", "valuation", "risks", "decision-pkg", "appendix"],
+    "implementation-tech":   ["summary", "current-state", "target-state", "portfolio", "operating-model", "roadmap", "business-case", "risk-rai", "adoption", "appendix"],
+    "audit-assurance":       ["assurance-summary", "scope", "methodology", "findings", "risk", "controls", "recommendations", "governance", "appendix"],
+    "scientific-academic":   ["abstract", "background", "aims", "methods", "results", "discussion", "impact", "compliance", "references", "supplementary"],
+    "policy-public":         ["policy-summary", "mandate", "diagnostic", "evidence", "options", "impact", "preferred", "implementation", "annexes"],
+    "market-commercial":     ["sector-summary", "market-def", "sizing", "demand", "competitive", "economics", "trends", "implications", "appendix"],
+  };
+  const sections = (orderByArchetype[archetypeId] ?? orderByArchetype["decision-strategy"]).map<SectionSpec>(id => ({
+    id, name: id.replace(/-/g, " "),
+    promptTemplate: `Generate the "${id}" section only. Do not echo other sections. Output JSON matching the section schema.`,
+    evidenceChunks: [], dependsOn: [], maxOutputTokens: 800,
+  }));
+  return {
+    reportId: `r-${Date.now().toString(36)}`, template: archetypeId, styleOverride,
+    sections, assemblyOrder: sections.map(s => s.id),
+  };
+}
+
+/** Estimate how many sessions a model needs for a given report spec. */
+export function plannedSessions(spec: ReportSpec, profile: ModelProfile): { sessions: number; words: number } {
+  const sectionsPerSession = profile.ctxTokens >= 16384 ? 2 : profile.ctxTokens >= 32000 ? 4 : 1;
+  const sessions = Math.ceil(spec.sections.length / sectionsPerSession);
+  const wordsPerSection = Math.round(profile.budget.outputReserveTok * 0.75); // tokens -> words
+  return { sessions, words: spec.sections.length * wordsPerSection };
+}

package/src/lib/small-model-adapters.ts

@@ -0,0 +1,82 @@
+import type { DriverId } from "./resource-estimator";
+
+export interface AdapterDescriptor {
+  id: DriverId;
+  label: string;
+  role: string;
+  anchorRequirement: "optional" | "preferred" | "required";
+  context: string;
+  toolMode: string;
+  degradePath: string[];
+  bestFor: string;
+  caveat: string;
+}
+
+export const ADAPTERS: AdapterDescriptor[] = [
+  {
+    id: "frontier",
+    label: "Frontier cloud model",
+    role: "Full federation lead, synthesis judge, and fallback worker.",
+    anchorRequirement: "optional",
+    context: "Large enough for broad briefs; still benefits from anchor-first retrieval.",
+    toolMode: "Native or API-level tool routing, model-dependent.",
+    degradePath: ["full", "verified-lite", "anchor-only"],
+    bestFor: "Tier 4-5 exhaustive runs and high-stakes synthesis.",
+    caveat: "External verification is still required; self-evaluation is not treated as proof.",
+  },
+  {
+    id: "gemma4-31b",
+    label: "Gemma 4 31B",
+    role: "Primary small-frontier orchestrator with high-context synthesis.",
+    anchorRequirement: "preferred",
+    context: "Designed in this app as a long-context anchor-brief reader.",
+    toolMode: "Gemini API generateContent path, with model availability checked per API key.",
+    degradePath: ["full", "lite", "anchor-only-rag"],
+    bestFor: "Tier 2-4 chat and dashboard runs when a Google AI key supports the model.",
+    caveat: "The app wires the requested model id. Runtime availability is confirmed by the provider response/model list.",
+  },
+  {
+    id: "qwen3.6",
+    label: "Qwen 3.6 class adapter",
+    role: "Reasoning-heavy worker and falsification specialist.",
+    anchorRequirement: "preferred",
+    context: "Configured as a large-brief worker when available behind a compatible gateway.",
+    toolMode: "Structured JSON harness if native function calling is unavailable.",
+    degradePath: ["worker", "sequential-worker", "anchor-only-rag"],
+    bestFor: "Hard verification plans, contradiction analysis, and boundary searches.",
+    caveat: "No direct connector is installed yet; descriptor is ready for an OpenAI-compatible gateway.",
+  },
+  {
+    id: "gemma4-e4b",
+    label: "Gemma 4 E4B class adapter",
+    role: "Laptop or browser worker for low-cost anchor-grounded runs.",
+    anchorRequirement: "required",
+    context: "Uses chunked baseline briefs rather than broad free-recall.",
+    toolMode: "Constrained JSON harness, one worker at a time.",
+    degradePath: ["lite", "single-worker", "anchor-only-rag"],
+    bestFor: "Tier 0-2 local/private research with Kiwix/Wikidata anchors.",
+    caveat: "Small models must not assert unsupported technical facts.",
+  },
+  {
+    id: "apple-ondevice",
+    label: "Apple on-device class adapter",
+    role: "Private-data handler and offline worker.",
+    anchorRequirement: "required",
+    context: "Local files and local anchor store first; cloud optional.",
+    toolMode: "No remote tool calls unless user explicitly enables cloud access.",
+    degradePath: ["private-worker", "anchor-only-rag", "abstain"],
+    bestFor: "Sensitive notes, local documents, and privacy-first summaries.",
+    caveat: "Exact model capability is treated as runtime-probed, not assumed.",
+  },
+  {
+    id: "bonsai-8b",
+    label: "Bonsai 8B class adapter",
+    role: "Extreme-edge retrieval shell over a verified anchor.",
+    anchorRequirement: "required",
+    context: "Tiny context strategy: search, read one chunk, verify, then synthesize.",
+    toolMode: "Strict extractor mode; no free-form factual recall.",
+    degradePath: ["extractor", "anchor-only-rag", "abstain"],
+    bestFor: "Phone-sized/offline fact lookup and short anchored answers.",
+    caveat: "Full-power quality comes from the anchor and verifiers, not from parametric recall.",
+  },
+];

package/src/lib/sscp.ts

@@ -0,0 +1,86 @@
+/**
+ * SSCP Receipt + Merkle seal — REAL cryptography via Web Crypto API (SHA-256).
+ * No mock hashes. Every receipt is reproducible from its inputs.
+ *
+ * A receipt binds together the claim ledger, tool log, gate results, and
+ * evidence index into a Merkle tree, then exposes the root hash as the
+ * audit seal printed in the OMEGA unified header block.
+ */
+
+export type EvidenceTier = "CTX" | "SRC" | "TOOL" | "DERIV";
+
+export interface SSCPLeaf {
+  domain: string;     // e.g. "claim", "tool", "gate", "evidence"
+  text: string;       // canonical content of the leaf
+  status: string;     // e.g. VERIFIED / CONFIRMED / PASS
+}
+
+export interface SSCPReceipt {
+  stateRootHash: string;
+  claimLedgerRootHash: string;
+  toolLogRootHash: string;
+  gateRootHash: string;
+  evidenceTier: EvidenceTier;
+  leafCount: number;
+  hashAlg: "SHA-256";
+  tsUtc: number;
+  allGatesPass: boolean;
+}
+
+async function sha256Hex(input: string): Promise<string> {
+  const data = new TextEncoder().encode(input);
+  const buf = await crypto.subtle.digest("SHA-256", data);
+  return [...new Uint8Array(buf)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+/** CT-style domain separation: leaf prefix 0x00, node prefix 0x01. */
+async function merkleRoot(leaves: string[]): Promise<string> {
+  if (leaves.length === 0) return sha256Hex("EMPTY");
+  let level = await Promise.all(leaves.map((l) => sha256Hex("\x00" + l)));
+  while (level.length > 1) {
+    const next: string[] = [];
+    for (let i = 0; i < level.length; i += 2) {
+      const a = level[i];
+      const b = i + 1 < level.length ? level[i + 1] : level[i];
+      next.push(await sha256Hex("\x01" + a + b));
+    }
+    level = next;
+  }
+  return level[0];
+}
+
+export interface BuildReceiptInput {
+  claims: SSCPLeaf[];
+  tools: SSCPLeaf[];
+  gates: SSCPLeaf[];
+  evidence: SSCPLeaf[];
+  evidenceTier: EvidenceTier;
+  allGatesPass: boolean;
+}
+
+const leafStr = (l: SSCPLeaf) => `${l.domain}|${l.status}|${l.text}`;
+
+export async function buildSSCPReceipt(input: BuildReceiptInput): Promise<SSCPReceipt> {
+  const claimRoot = await merkleRoot(input.claims.map(leafStr));
+  const toolRoot = await merkleRoot(input.tools.map(leafStr));
+  const gateRoot = await merkleRoot(input.gates.map(leafStr));
+  const evidenceRoot = await merkleRoot(input.evidence.map(leafStr));
+  const stateRoot = await merkleRoot([claimRoot, toolRoot, gateRoot, evidenceRoot]);
+  return {
+    stateRootHash: stateRoot,
+    claimLedgerRootHash: claimRoot,
+    toolLogRootHash: toolRoot,
+    gateRootHash: gateRoot,
+    evidenceTier: input.evidenceTier,
+    leafCount: input.claims.length + input.tools.length + input.gates.length + input.evidence.length,
+    hashAlg: "SHA-256",
+    tsUtc: Date.now(),
+    allGatesPass: input.allGatesPass,
+  };
+}
+
+/** Short display form of a hash: first 8 + last 4. */
+export function shortHash(h: string): string {
+  if (h.length <= 14) return h;
+  return `${h.slice(0, 8)}…${h.slice(-4)}`;
+}