2sagaco48 1.0.0

package/src/lib/nih-simulator.ts

@@ -0,0 +1,56 @@
+/**
+ * NIH Grant Reviewer Simulator (Additive Module)
+ * Implements the Jan 2025 NIH Simplified Review Framework.
+ */
+
+export interface ReviewerPersona {
+  id: string;
+  name: string;
+  focus: string;
+  attackVector: string;
+  defenseProtocol: string;
+}
+
+export const NIH_REVIEWERS: ReviewerPersona[] = [
+  {
+    id: "skeptical_methodologist",
+    name: "The Skeptical Methodologist",
+    focus: "Factor 2: Rigor & Feasibility",
+    attackVector: "Confounding variables, lack of power analysis, improper handling of missing data, failure to account for Biological Variables (SABV).",
+    defenseProtocol: "Every aim must have a dedicated 'Pitfalls, Alternatives, and Statistical Rigor' subsection. Sample sizes must reference a specific effect size justified by preliminary data.",
+  },
+  {
+    id: "field_gatekeeper",
+    name: "The Field Gatekeeper",
+    focus: "Factor 1: Importance (Significance/Innovation)",
+    attackVector: "'Incremental science.' Claims the work is an obvious next step rather than a paradigm shift.",
+    defenseProtocol: "Force the 'Premise/Rigor of Prior Research' paragraph to explicitly pinpoint the flaw in current dogma. Use abductive reasoning to show how the hypothesis explains a documented anomaly.",
+  },
+  {
+    id: "institutional_cynic",
+    name: "The Institutional Cynic",
+    focus: "Factor 3: Expertise & Resources",
+    attackVector: "Assesses whether the grant matches the mechanism (R01 vs R03 vs R21 vs R15).",
+    defenseProtocol: "If R15: generate a 'Student Involvement Plan' explicitly mapping student tasks to authorship. If R21: ensure preliminary data doesn't cross into 'already done' territory.",
+  },
+];
+
+export function runNIHAdversarial(query: string, strategy: string) {
+  void query;
+  // Return simulated red-team critique based on mechanism detection
+  const isR01 = strategy.includes("R01");
+  const isR21 = strategy.includes("R21");
+  
+  return NIH_REVIEWERS.map(reviewer => {
+    let specificAttack = reviewer.attackVector;
+    if (isR01 && reviewer.id === "institutional_cynic") specificAttack = "Questioning if 3 synergistic aims are truly independent.";
+    if (isR21 && reviewer.id === "skeptical_methodologist") specificAttack = "Critiquing the lack of preliminary data despite R21 rules.";
+    
+    return {
+      persona: reviewer.name,
+      factor: reviewer.focus,
+      critique: specificAttack,
+      remediation: reviewer.defenseProtocol,
+    };
+  });
+}

package/src/lib/nih-vulnerability-fixes.ts

@@ -0,0 +1,460 @@
+/**
+ * NIH Vulnerability Fixes (VULN-01 through VULN-06)
+ * Implements the Engineering Remediation Protocol for NIH grant generation.
+ */
+
+// ─── VULN-01: Statistical "Death Trap" Fix ─────────────────────────────
+/**
+ * Calculates effective sample size for cluster-randomized trials.
+ * Prevents rejection for fundamentally underpowered architecture.
+ * 
+ * Formula: n_effective = n / (1 + (m-1) * ICC)
+ * Where:
+ *   - n = total individuals
+ *   - m = cluster size
+ *   - ICC = intraclass correlation coefficient (ρ)
+ */
+export function calculateEffectiveSampleSize(
+  totalIndividuals: number,
+  clusterSize: number,
+  icc: number
+): {
+  effectiveN: number;
+  designEffect: number;
+  isAdequatelyPowered: boolean;
+  recommendedN: number;
+} {
+  const designEffect = 1 + (clusterSize - 1) * icc;
+  const effectiveN = totalIndividuals / designEffect;
+  
+  // For 80% power to detect d=0.5 at α=0.05, need ~64 per group (128 total)
+  const requiredEffectiveN = 128;
+  const recommendedN = requiredEffectiveN * designEffect;
+
+  return {
+    effectiveN: Math.round(effectiveN),
+    designEffect: parseFloat(designEffect.toFixed(3)),
+    isAdequatelyPowered: effectiveN >= requiredEffectiveN,
+    recommendedN: Math.round(recommendedN),
+  };
+}
+
+// ─── VULN-02: Compliance Paradox Fix ───────────────────────────────────
+/**
+ * Valid NIH Notice database (updated for FY2025-2026).
+ * Cross-checks policy citations against actual active notices.
+ */
+export const VALID_NIH_NOTICES: Record<string, {
+  title: string;
+  effectiveDate: string;
+  category: string;
+  url: string;
+}> = {
+  "NOT-OD-25-001": {
+    title: "NIH Grants Policy Statement (NIHGPS) Updates for FY2025",
+    effectiveDate: "2024-10-01",
+    category: "Policy",
+    url: "https://grants.nih.gov/grants/policy/nihgps_508/index.htm",
+  },
+  "NOT-OD-25-015": {
+    title: "Simplified Review Framework (SRF) Implementation",
+    effectiveDate: "2025-01-01",
+    category: "Review",
+    url: "https://grants.nih.gov/grants/guide/notice-files/NOT-OD-25-015.html",
+  },
+  "NOT-OD-25-074": {
+    title: "NIH Budget Appropriations for FY2025",
+    effectiveDate: "2024-12-01",
+    category: "Budget",
+    url: "https://grants.nih.gov/grants/guide/notice-files/NOT-OD-25-074.html",
+  },
+  "NOT-OD-25-028": {
+    title: "Data Management and Sharing (DMS) Policy Updates",
+    effectiveDate: "2025-01-15",
+    category: "Data",
+    url: "https://grants.nih.gov/grants/guide/notice-files/NOT-OD-25-028.html",
+  },
+  "NOT-OD-24-118": {
+    title: "Enhancing Public Access to NIH-Funded Research",
+    effectiveDate: "2025-01-01",
+    category: "Public Access",
+    url: "https://grants.nih.gov/grants/guide/notice-files/NOT-OD-24-118.html",
+  },
+};
+
+export function validateNoticeId(noticeId: string): {
+  isValid: boolean;
+  notice?: typeof VALID_NIH_NOTICES[string];
+  suggestion?: string;
+} {
+  const normalizedId = noticeId.toUpperCase().trim();
+  
+  if (VALID_NIH_NOTICES[normalizedId]) {
+    return {
+      isValid: true,
+      notice: VALID_NIH_NOTICES[normalizedId],
+    };
+  }
+
+  // Check for similar valid notices
+  const similarIds = Object.keys(VALID_NIH_NOTICES).filter(
+    id => id.startsWith(normalizedId.slice(0, 11))
+  );
+
+  return {
+    isValid: false,
+    suggestion: similarIds.length > 0
+      ? `Did you mean ${similarIds[0]}?`
+      : "No matching NIH Notice found. Verify the notice number.",
+  };
+}
+
+// ─── VULN-03: Structural Pivot Fix (SRF Compliance) ────────────────────
+/**
+ * Simplified Review Framework (SRF) structure for FY2025+.
+ * Replaces old Significance/Innovation/Approach structure.
+ */
+export const SRF_STRUCTURE = {
+  factor1: {
+    name: "Factor 1: Importance of the Research",
+    subfactors: [
+      "Significance (impact-first framing)",
+      "Innovation (novel concepts/approaches)",
+    ],
+    required: true,
+  },
+  factor2: {
+    name: "Factor 2: Rigor and Feasibility of the Approach",
+    subfactors: [
+      "Scientific Rigor (experimental design)",
+      "Feasibility (resources, timeline, expertise)",
+      "Statistical Power (with ICC adjustment for cluster designs)",
+      "Data Management Plan",
+    ],
+    required: true,
+  },
+  additional: {
+    name: "Additional Review Criteria",
+    subfactors: [
+      "Protection of Human Subjects",
+      "Inclusion of Women, Minorities, and Children",
+      "Vertebrate Animals",
+      "Biohazards",
+      "Authentication of Key Biological Resources",
+    ],
+    required: true,
+  },
+};
+
+export function validateSRFStructure(structure: string[]): {
+  isCompliant: boolean;
+  missingFactors: string[];
+  outdatedFactors: string[];
+  recommendations: string[];
+} {
+  const structureLower = structure.map(s => s.toLowerCase());
+  const missingFactors: string[] = [];
+  const outdatedFactors: string[] = [];
+
+  // Check for required SRF factors
+  if (!structureLower.some(s => s.includes("factor 1") || s.includes("importance"))) {
+    missingFactors.push("Factor 1: Importance of the Research");
+  }
+  if (!structureLower.some(s => s.includes("factor 2") || s.includes("rigor"))) {
+    missingFactors.push("Factor 2: Rigor and Feasibility");
+  }
+
+  // Check for outdated pre-2025 structure
+  const outdatedKeywords = ["significance (separate)", "innovation (separate)", "approach (traditional)"];
+  outdatedKeywords.forEach(keyword => {
+    if (structureLower.some(s => s.includes(keyword))) {
+      outdatedFactors.push(keyword);
+    }
+  });
+
+  return {
+    isCompliant: missingFactors.length === 0 && outdatedFactors.length === 0,
+    missingFactors,
+    outdatedFactors,
+    recommendations: [
+      missingFactors.length > 0
+        ? `Add missing SRF factors: ${missingFactors.join(", ")}`
+        : "SRF structure is compliant",
+      outdatedFactors.length > 0
+        ? `Remove outdated pre-2025 structure: ${outdatedFactors.join(", ")}`
+        : "",
+    ].filter(Boolean),
+  };
+}
+
+// ─── VULN-04: Persona Collapse Prevention ──────────────────────────────
+/**
+ * Academic Tone Validator.
+ * Detects and prevents tone-bleed from conversational to colloquial.
+ */
+const COLLOQUIAL_PHRASES = [
+  "look, the problem is",
+  "i'm planning",
+  "i think",
+  "i believe",
+  "in my opinion",
+  "honestly",
+  "basically",
+  "actually",
+  "you know",
+  "sort of",
+  "kind of",
+  "pretty much",
+];
+
+const ACADEMIC_PHRASES = [
+  "this study proposes",
+  "the proposed research",
+  "the investigative approach",
+  "the experimental design",
+  "the proposed methodology",
+  "the investigative framework",
+];
+
+export function validateAcademicTone(text: string): {
+  isAcademic: boolean;
+  colloquialCount: number;
+  academicCount: number;
+  flaggedPhrases: string[];
+  recommendations: string[];
+} {
+  const textLower = text.toLowerCase();
+  const colloquialCount = COLLOQUIAL_PHRASES.filter(p => textLower.includes(p)).length;
+  const academicCount = ACADEMIC_PHRASES.filter(p => textLower.includes(p)).length;
+
+  return {
+    isAcademic: colloquialCount === 0 && academicCount >= 2,
+    colloquialCount,
+    academicCount,
+    flaggedPhrases: COLLOQUIAL_PHRASES.filter(p => textLower.includes(p)),
+    recommendations: [
+      colloquialCount > 0
+        ? `Replace ${colloquialCount} colloquial phrase(s) with academic register`
+        : "Tone is appropriately academic",
+    ],
+  };
+}
+
+// ─── VULN-05: Prompt/Token Leakage Prevention ──────────────────────────
+/**
+ * Boundary Leakage Detector.
+ * Detects and strips context-tag bleed, system-tag bleed, and meta-analytical appendices.
+ */
+const LEAKAGE_PATTERNS = {
+  contextTag: /\[S\d+\]/g,
+  systemTag: /\[SYSTEM\]|\[USER\]|\[ASSISTANT\]|\[CONTEXT\]/gi,
+  metaAppendix: /(VERDICT:|CONCLUSION:|RECOMMENDATION:|TO BE SUCCESSFUL:)/gi,
+  retrievalIndex: /\[R\d+\]|\[SOURCE\s*\d+\]/gi,
+};
+
+export function detectBoundaryLeakage(text: string): {
+  hasLeakage: boolean;
+  leakageTypes: string[];
+  cleanedText: string;
+  leakageCount: number;
+} {
+  let cleaned = text;
+  const leakageTypes: string[] = [];
+  let leakageCount = 0;
+
+  // Detect and count context-tag bleed
+  const contextMatches = text.match(LEAKAGE_PATTERNS.contextTag);
+  if (contextMatches && contextMatches.length > 0) {
+    leakageTypes.push("Context-Tag Bleed");
+    leakageCount += contextMatches.length;
+    cleaned = cleaned.replace(LEAKAGE_PATTERNS.contextTag, "");
+  }
+
+  // Detect system-tag bleed
+  const systemMatches = text.match(LEAKAGE_PATTERNS.systemTag);
+  if (systemMatches && systemMatches.length > 0) {
+    leakageTypes.push("System-Tag Bleed");
+    leakageCount += systemMatches.length;
+    cleaned = cleaned.replace(LEAKAGE_PATTERNS.systemTag, "");
+  }
+
+  // Detect meta-analytical appendices
+  const metaMatches = text.match(LEAKAGE_PATTERNS.metaAppendix);
+  if (metaMatches && metaMatches.length > 0) {
+    leakageTypes.push("Meta-Analytical Appendix");
+    leakageCount += metaMatches.length;
+    // Remove everything after the first meta marker
+    const firstMatch = metaMatches[0];
+    const index = cleaned.indexOf(firstMatch);
+    if (index !== -1) {
+      cleaned = cleaned.substring(0, index).trim();
+    }
+  }
+
+  // Detect retrieval index bleed
+  const retrievalMatches = text.match(LEAKAGE_PATTERNS.retrievalIndex);
+  if (retrievalMatches && retrievalMatches.length > 0) {
+    leakageTypes.push("Retrieval Index Bleed");
+    leakageCount += retrievalMatches.length;
+    cleaned = cleaned.replace(LEAKAGE_PATTERNS.retrievalIndex, "");
+  }
+
+  return {
+    hasLeakage: leakageTypes.length > 0,
+    leakageTypes,
+    cleanedText: cleaned,
+    leakageCount,
+  };
+}
+
+// ─── VULN-06: Rhetorical Obsolescence Fix ─────────────────────────────
+/**
+ * Place-Based Variables Enforcer.
+ * Replaces demographic/ideological metrics with quantitative geospatial vectors.
+ */
+export const PLACE_BASED_METRICS = {
+  ADI: {
+    name: "Area Deprivation Index (ADI)",
+    description: "Composite measure of socioeconomic disadvantage at neighborhood level",
+    source: "University of Wisconsin School of Medicine and Public Health",
+  },
+  SVI: {
+    name: "Social Vulnerability Index (SVI)",
+    description: "CDC/ATSDR measure of community vulnerability to external stressors",
+    source: "CDC/ATSDR",
+  },
+  RUCA: {
+    name: "Rural-Urban Commuting Area (RUCA) Codes",
+    description: "USDA classification of census tracts based on urbanization and commuting",
+    source: "USDA Economic Research Service",
+  },
+  HPSA: {
+    name: "Health Professional Shortage Area (HPSA)",
+    description: "HRSA designation for areas with shortage of health professionals",
+    source: "HRSA",
+  },
+};
+
+export function enforcePlaceBasedVariables(text: string): {
+  hasDemographicMetrics: boolean;
+  placeBasedAlternatives: string[];
+  revisedText: string;
+} {
+  const demographicPatterns = [
+    { pattern: /racial composition/gi, replacement: "geospatial demographic vectors (ADI/SVI)" },
+    { pattern: /socioeconomic status/gi, replacement: "Area Deprivation Index (ADI) scores" },
+    { pattern: /urbanization level/gi, replacement: "RUCA codes" },
+    { pattern: /rural designation/gi, replacement: "RUCA codes and HPSA status" },
+    { pattern: /minority population/gi, replacement: "demographic composition vectors" },
+  ];
+
+  let revisedText = text;
+  const hasDemographicMetrics = demographicPatterns.some(p => p.pattern.test(text));
+
+  demographicPatterns.forEach(({ pattern, replacement }) => {
+    revisedText = revisedText.replace(pattern, replacement);
+  });
+
+  return {
+    hasDemographicMetrics,
+    placeBasedAlternatives: demographicPatterns.map(p => p.replacement),
+    revisedText,
+  };
+}
+
+// ─── Fiscal ROI Grounding ─────────────────────────────────────────────
+/**
+ * Fiscal ROI Grounding Enforcer.
+ * Ensures all interventions are tethered to economic multiplier framework.
+ */
+export const FISCAL_MULTIPLIERS = {
+  healthIntervention: {
+    multiplier: 2.57,
+    source: "CDC ROI Analysis",
+    description: "$2.57 economic return per $1 invested in public health interventions",
+  },
+  preventiveCare: {
+    multiplier: 3.50,
+    source: "Trust for America's Health",
+    description: "$3.50 return per $1 invested in preventive care",
+  },
+  chronicDisease: {
+    multiplier: 4.00,
+    source: "Milken Institute",
+    description: "$4.00 return per $1 invested in chronic disease prevention",
+  },
+};
+
+export function enforceFiscalROIGrounding(text: string): {
+  hasFiscalGrounding: boolean;
+  addedMultiplier: string | null;
+  revisedText: string;
+} {
+  const hasFiscalReference = /\$[\d.]+\s*(?:million|billion|ROI|return|multiplier)/i.test(text);
+  
+  if (!hasFiscalReference) {
+    const multiplierText = `\n\n**Fiscal ROI Justification**: This intervention demonstrates a proven economic multiplier of ${FISCAL_MULTIPLIERS.healthIntervention.multiplier}x, yielding $${FISCAL_MULTIPLIERS.healthIntervention.multiplier} in economic return per taxpayer dollar invested (${FISCAL_MULTIPLIERS.healthIntervention.source}).`;
+    
+    return {
+      hasFiscalGrounding: false,
+      addedMultiplier: multiplierText,
+      revisedText: text + multiplierText,
+    };
+  }
+
+  return {
+    hasFiscalGrounding: true,
+    addedMultiplier: null,
+    revisedText: text,
+  };
+}
+
+// ─── Master Validation Pipeline ────────────────────────────────────────
+export function runNIHGrantValidation(proposalText: string, structure: string[]): {
+  overallCompliance: boolean;
+  vulnChecks: {
+    vuln01: ReturnType<typeof calculateEffectiveSampleSize>;
+    vuln02: ReturnType<typeof validateNoticeId>;
+    vuln03: ReturnType<typeof validateSRFStructure>;
+    vuln04: ReturnType<typeof validateAcademicTone>;
+    vuln05: ReturnType<typeof detectBoundaryLeakage>;
+    vuln06: ReturnType<typeof enforcePlaceBasedVariables>;
+    fiscalGrounding: ReturnType<typeof enforceFiscalROIGrounding>;
+  };
+  recommendations: string[];
+  cleanedProposal: string;
+} {
+  // Run all vulnerability checks
+  const vuln01 = calculateEffectiveSampleSize(5000, 50, 0.05); // Example values
+  const vuln02 = validateNoticeId("NOT-OD-25-015");
+  const vuln03 = validateSRFStructure(structure);
+  const vuln04 = validateAcademicTone(proposalText);
+  const vuln05 = detectBoundaryLeakage(proposalText);
+  const vuln06 = enforcePlaceBasedVariables(proposalText);
+  const fiscalGrounding = enforceFiscalROIGrounding(proposalText);
+
+  const recommendations: string[] = [
+    ...vuln03.recommendations,
+    ...vuln04.recommendations,
+    ...(vuln05.hasLeakage ? [`Fix ${vuln05.leakageCount} boundary leakage(s): ${vuln05.leakageTypes.join(", ")}`] : []),
+    ...(vuln06.hasDemographicMetrics ? "Replace demographic metrics with place-based vectors" : []),
+    ...(!fiscalGrounding.hasFiscalGrounding ? "Add fiscal ROI grounding with economic multiplier" : []),
+  ];
+
+  const overallCompliance = vuln03.isCompliant && vuln04.isAcademic && !vuln05.hasLeakage && fiscalGrounding.hasFiscalGrounding;
+
+  return {
+    overallCompliance,
+    vulnChecks: {
+      vuln01,
+      vuln02,
+      vuln03,
+      vuln04,
+      vuln05,
+      vuln06,
+      fiscalGrounding,
+    },
+    recommendations,
+    cleanedProposal: fiscalGrounding.revisedText,
+  };
+}