@balpal4495/quorum 3.0.3 → 3.1.0

package/modules/council/deliberate.ts

@@ -1,141 +0,0 @@
-import type { CouncilInput, CouncilOutput, CouncilDeps } from "./types"
-import { DEFAULT_PERSONAS } from "./personas"
-import { frameQuestion } from "./frame"
-import { fanOutAdvisors } from "./advisors"
-import { fanOutReviewers } from "./reviewers"
-import { chairman } from "./chairman"
-import { classifyRisk } from "./risk"
-
-const DEFAULT_ADVISOR_COUNT = 5
-const DEFAULT_REVIEWER_COUNT = 5
-const LITE_ADVISOR_COUNT = 1
-const LITE_REVIEWER_COUNT = 2
-
-/**
- * Run the Council deliberation pipeline.
- *
- * Pipeline:
- *   1. frameQuestion     — reframe outcome + design into a deliberation brief
- *   2. fanOutAdvisors    — N advisors reason in parallel from Oracle evidence
- *   3. fanOutReviewers   — N reviewers critique anonymised advisor responses in parallel
- *   4. chairman          — synthesises verdict, cites Oracle entry IDs
- *   5. oracle.propose()  — proposes verdict to Chronicle (human approval required to commit)
- *
- * The council_brief from jury_output determines framing tone:
- *   "challenge"      → find what is wrong (Jury confidence < 0.6)
- *   "pressure-test"  → try to break what looks solid (Jury confidence ≥ 0.6)
- *
- * Routing on output:
- *   satisfied: true                           → proceed to human gate → Executor
- *   satisfied: false, recommendation: redesign         → return to Designer
- *   satisfied: false, recommendation: investigate-more → return to Detective with gaps list
- */
-export async function deliberate(
-  input: CouncilInput,
-  deps: CouncilDeps,
-): Promise<CouncilOutput> {
-  const {
-    llm,
-    oracle,
-    models = {},
-  } = deps
-
-  // Classify risk to determine Council mode and advisor/reviewer counts
-  const risk = classifyRisk(input.outcome, input.design, input.evidence)
-
-  if (risk.council_mode === "jury-only") {
-    return {
-      satisfied: true,
-      verdict: "Skipped — low-risk design passed by Jury without Council review.",
-      blockers: [],
-      warnings: [],
-      challenges: [],
-      evidence_cited: [],
-      citation_validation: { valid_ids: [], hallucinated_ids: [] },
-      advisor_split: { proceed: 0, redesign: 0, "investigate-more": 0 },
-      recommendation: "proceed",
-    }
-  }
-
-  let defaultAdvisors = DEFAULT_ADVISOR_COUNT
-  let defaultReviewers = DEFAULT_REVIEWER_COUNT
-  if (risk.council_mode === "lite") {
-    defaultAdvisors = LITE_ADVISOR_COUNT
-    defaultReviewers = LITE_REVIEWER_COUNT
-  }
-  const advisorCount = deps.advisorCount ?? defaultAdvisors
-  const reviewerCount = deps.reviewerCount ?? defaultReviewers
-
-  // Select personas — cycle DEFAULT_PERSONAS if advisorCount > 5
-  const personas = Array.from(
-    { length: advisorCount },
-    (_, i) => DEFAULT_PERSONAS[i % DEFAULT_PERSONAS.length],
-  )
-
-  // 1. Frame the deliberation question
-  const framedQuestion = await frameQuestion(input, llm, models.frame)
-
-  // 2. Advisors reason in parallel
-  const advisorResponses = await fanOutAdvisors(
-    framedQuestion,
-    input.evidence,
-    personas,
-    llm,
-    models.advisors,
-  )
-
-  // 3. Reviewers critique in parallel (advisor responses anonymised inside fanOutReviewers)
-  const reviewerResponses = await fanOutReviewers(
-    advisorResponses,
-    input.evidence,
-    reviewerCount,
-    llm,
-    models.reviewers,
-  )
-
-  // 4. Chairman synthesises verdict
-  const verdict = await chairman(
-    advisorResponses,
-    reviewerResponses,
-    input.evidence,
-    llm,
-    models.chairman,
-  )
-
-  // 5. Propose verdict to Oracle — human must call oracle.commit() to index it
-  // Truncate to 200 chars so it passes propose()'s schema validation.
-  const firstSentence = verdict.verdict.split(/[.!?]/)[0]?.trim() ?? ""
-  const keyInsight = (firstSentence.length >= 20 ? firstSentence : verdict.verdict)
-    .slice(0, 200)
-
-  await oracle.propose({
-    schema_version: 2,
-    topic: input.outcome.slice(0, 80),
-    decision: keyInsight,
-    key_insight: keyInsight,
-    affected_areas: extractAffectedAreas(input.outcome, input.design),
-    alternatives_considered: verdict.challenges,
-    rejected_reason: verdict.satisfied
-      ? []
-      : verdict.blockers.map(b => b.issue).slice(0, 3),
-    status: "open",
-    confidence: input.jury_output.confidence,
-    source_module: "council",
-    evidence_cited: verdict.citation_validation.valid_ids,
-    scope: risk.reasons.slice(0, 3),
-  })
-
-  return verdict
-}
-
-/**
- * Extract candidate affected areas from the outcome and design text.
- * Looks for capitalised noun phrases as a simple heuristic.
- * The host application may override by post-processing CouncilOutput.
- */
-function extractAffectedAreas(outcome: string, design: string): string[] {
-  const text = `${outcome} ${design}`
-  const phrases = text.match(/\b[A-Z][a-zA-Z]+(?:\s[A-Z][a-zA-Z]+)*\b/g) ?? []
-  const unique = [...new Set(phrases)]
-  return unique.length > 0 ? unique.slice(0, 5) : ["general"]
-}

package/modules/council/frame.ts

@@ -1,54 +0,0 @@
-import type { LLMProvider } from "../shared/types"
-import type { CouncilInput } from "./types"
-
-/**
- * Reframe the outcome + design into a clear deliberation brief for the advisor panel.
- * Tone and scope are set by the Jury's council_brief value.
- */
-export async function frameQuestion(
-  input: CouncilInput,
-  llm: LLMProvider,
-  model?: string,
-): Promise<string> {
-  const { outcome, design, jury_output } = input
-
-  const briefInstruction =
-    jury_output.council_brief === "challenge"
-      ? `The Jury has LOW confidence (score: ${jury_output.confidence.toFixed(2)}). ` +
-        "Find what is WRONG with this design. Look for fundamental flaws, not just edge cases."
-      : `The Jury has HIGH confidence (score: ${jury_output.confidence.toFixed(2)}). ` +
-        "PRESSURE-TEST this design. Assume it is broadly correct — try to break it. " +
-        "Find edge cases, scaling failures, and hidden assumptions."
-
-  const systemPrompt = [
-    "You are the Council Framer. You write the deliberation brief that a panel of expert advisors will work from.",
-    "",
-    "Write a clear, precise brief that:",
-    "1. States what needs to be achieved (the outcome)",
-    "2. States what is being proposed (the design)",
-    "3. States the Jury's assessment and the gaps it identified",
-    "4. Sets the council directive — challenge or pressure-test",
-    "",
-    "Keep it under 300 words. Be direct. Advisors must know exactly what to evaluate.",
-  ].join("\n")
-
-  const userPrompt = [
-    `Outcome: ${outcome}`,
-    "",
-    `Design: ${design}`,
-    "",
-    `Jury assessment: ${jury_output.assessment}`,
-    `Jury confidence: ${jury_output.confidence.toFixed(2)}`,
-    `Jury gaps: ${jury_output.gaps.join("; ") || "none identified"}`,
-    "",
-    briefInstruction,
-  ].join("\n")
-
-  return llm(
-    [
-      { role: "system", content: systemPrompt },
-      { role: "user", content: userPrompt },
-    ],
-    model,
-  )
-}

package/modules/council/index.ts

@@ -1,9 +0,0 @@
-export { deliberate } from "./deliberate"
-export type {
-  CouncilInput, CouncilOutput, CouncilDeps, CouncilModels,
-  BlockerItem, WarningItem, CitationValidation, AdvisorSplit,
-  RiskLevel, CouncilMode, RiskAssessment,
-} from "./types"
-export { DEFAULT_PERSONAS } from "./personas"
-export type { AdvisorPersona } from "./personas"
-export { classifyRisk } from "./risk"

package/modules/council/personas.ts

@@ -1,57 +0,0 @@
-/**
- * Default advisor personas for the Council.
- *
- * Personas are interpretive lenses, not knowledge sources.
- * All advisors receive the same Oracle evidence pack — their persona
- * determines which entries they weight and how they read them.
- *
- * Add or replace personas in CouncilDeps to specialise for your domain.
- */
-
-export interface AdvisorPersona {
-  name: string
-  /** One-line description of this persona's evidence focus. */
-  lens: string
-  /** System prompt fragment injected into the advisor's prompt. */
-  systemFragment: string
-}
-
-export const DEFAULT_PERSONAS: readonly AdvisorPersona[] = [
-  {
-    name: "Pragmatist",
-    lens: "Weights validated entries — what has worked in this codebase",
-    systemFragment:
-      "Focus on `validated` Oracle entries. What has already worked in this codebase? " +
-      "Weight evidence that confirms the design will succeed based on prior outcomes.",
-  },
-  {
-    name: "Sceptic",
-    lens: "Weights refuted entries — what has failed and why",
-    systemFragment:
-      "Focus on `refuted` Oracle entries. What has already failed in this codebase and why? " +
-      "Look for signs this design repeats past mistakes. Surface failure modes explicitly.",
-  },
-  {
-    name: "Systems thinker",
-    lens: "Looks for patterns across all entries — second-order effects",
-    systemFragment:
-      "Read all Oracle entries as a system. Look for patterns, dependencies, and second-order " +
-      "effects. What does the design miss about how the system as a whole behaves?",
-  },
-  {
-    name: "Risk analyst",
-    lens: "Weights open entries — unresolved questions and unknowns",
-    systemFragment:
-      "Focus on `open` Oracle entries — unresolved questions and unknowns. " +
-      "What has not been confirmed? What uncertainty does this design carry? " +
-      "Flag every assumption that has not been validated by an outcome.",
-  },
-  {
-    name: "Evidence auditor",
-    lens: "Focuses on gaps — what Oracle does NOT contain",
-    systemFragment:
-      "Look for what is ABSENT from the Oracle evidence. What decisions is this design making " +
-      "without any codebase evidence to support them? " +
-      "Name every gap — a gap is not a reason to reject, but it must be surfaced.",
-  },
-]

package/modules/council/reviewers.ts

@@ -1,82 +0,0 @@
-import type { LLMProvider, OracleResult } from "../shared/types"
-import { entryText } from "../shared/types"
-import type { AdvisorResponse } from "./advisors"
-
-export interface ReviewerResponse {
-  reviewerId: string
-  review: string
-}
-
-/**
- * Shuffle advisor responses and label them A–Z.
- * Prevents reviewers deferring to confident responses by position or persona name.
- */
-function anonymise(responses: AdvisorResponse[]): string {
-  const shuffled = [...responses].sort(() => Math.random() - 0.5)
-  return shuffled
-    .map((r, i) => `## Advisor ${String.fromCharCode(65 + i)}\n${r.response}`)
-    .join("\n\n---\n\n")
-}
-
-function formatEvidenceSummary(evidence: OracleResult[]): string {
-  if (evidence.length === 0) return "No Oracle evidence available."
-  return evidence
-    .map(e => `[${e.id}] (${e.status}) ${entryText(e)}`)
-    .join("\n")
-}
-
-const REVIEWER_SYSTEM_PROMPT = [
-  "You are a Council reviewer. You evaluate the quality of advisor responses.",
-  "",
-  "You are NOT deciding whether the design is correct.",
-  "You are assessing the reasoning quality of each advisor response:",
-  "",
-  "1. Does the advisor actually use the Oracle evidence, or reason from general knowledge?",
-  "2. Are Oracle entry IDs cited? Do those citations match the evidence provided?",
-  "3. Is the response internally consistent?",
-  "4. Which responses provide the strongest evidence-backed reasoning?",
-  "5. Which responses make unsupported claims?",
-  "",
-  "Be critical. Evidence quality matters more than conclusion confidence.",
-  "Keep your review under 400 words.",
-].join("\n")
-
-/**
- * Run all reviewers in parallel.
- * Each reviewer receives the anonymised advisor responses and the original evidence pack.
- * Anonymisation prevents position bias and persona deference.
- */
-export async function fanOutReviewers(
-  advisorResponses: AdvisorResponse[],
-  evidence: OracleResult[],
-  reviewerCount: number,
-  llm: LLMProvider,
-  model?: string,
-): Promise<ReviewerResponse[]> {
-  const anonymisedResponses = anonymise(advisorResponses)
-  const evidenceSummary = formatEvidenceSummary(evidence)
-
-  return Promise.all(
-    Array.from({ length: reviewerCount }, async (_, i): Promise<ReviewerResponse> => {
-      const userPrompt = [
-        "## Advisor Responses (anonymised)",
-        anonymisedResponses,
-        "",
-        "## Oracle Evidence (for cross-referencing citations)",
-        evidenceSummary,
-        "",
-        "Review each advisor response for evidence quality.",
-      ].join("\n")
-
-      const review = await llm(
-        [
-          { role: "system", content: REVIEWER_SYSTEM_PROMPT },
-          { role: "user", content: userPrompt },
-        ],
-        model,
-      )
-
-      return { reviewerId: `reviewer-${i + 1}`, review }
-    }),
-  )
-}

package/modules/council/risk.ts

@@ -1,89 +0,0 @@
-import type { OracleResult } from "../shared/types"
-import type { RiskLevel, CouncilMode, RiskAssessment } from "./types"
-
-/**
- * Patterns that trigger risk escalation.
- * Each entry has a level (the minimum risk level it triggers) and a reason label.
- */
-const RISK_RULES: Array<{ pattern: RegExp; level: RiskLevel; reason: string }> = [
-  // Critical — always run full Council + flag for human architecture review
-  { pattern: /\b(auth(?:entication|orization)?|jwt|token|session|password|oauth|credential|bearer)\b/i, level: "critical", reason: "authentication or authorisation logic" },
-  { pattern: /\b(payment|stripe|charge|billing|checkout|refund|subscription)\b/i, level: "critical", reason: "payment or billing logic" },
-  { pattern: /\b(encrypt|decrypt|private\s+key|certificate|tls|ssl|hmac|cipher)\b/i, level: "critical", reason: "cryptography or key management" },
-  { pattern: /\b(delete\s+all|drop\s+table|truncate|wipe|destroy.*data|hard\s+delete)\b/i, level: "critical", reason: "irreversible data deletion" },
-
-  // High — full Council
-  { pattern: /\b(migrat(?:ion|e)|alter\s+table|schema\s+change|not\s+null|backfill|pg_repack|shadow\s+column)\b/i, level: "high", reason: "database schema migration" },
-  { pattern: /\b(permission|role(?:s)?|acl|rbac|access\s+control|entitlement)\b/i, level: "high", reason: "permissions or access control" },
-  { pattern: /\b(pii|personal\s+data|gdpr|ccpa|email(?:\s+address)?|phone(?:\s+number)?|ssn|passport)\b/i, level: "high", reason: "PII or compliance-regulated data" },
-  { pattern: /\b(api\s+key|secret(?:s)?|private\s+key|credentials?)\b/i, level: "high", reason: "secrets or credentials handling" },
-
-  // Medium — Jury + lite Council
-  { pattern: /\b(cache|redis|memcached|invalidat(?:e|ion))\b/i, level: "medium", reason: "cache strategy" },
-  { pattern: /\b(rate\s*limit|throttl(?:e|ing)|quota)\b/i, level: "medium", reason: "rate limiting or throttling" },
-  { pattern: /\b(webhook|event|queue|pubsub|kafka|rabbitmq|sns|sqs)\b/i, level: "medium", reason: "async event or messaging" },
-  { pattern: /\b(deploy(?:ment)?|ci(?:\/cd)?|docker|kubernetes|infra(?:structure)?)\b/i, level: "medium", reason: "deployment or infrastructure" },
-]
-
-const RISK_ORDER: RiskLevel[] = ["low", "medium", "high", "critical"]
-
-function maxLevel(a: RiskLevel, b: RiskLevel): RiskLevel {
-  return RISK_ORDER.indexOf(a) >= RISK_ORDER.indexOf(b) ? a : b
-}
-
-function councilModeForLevel(level: RiskLevel): CouncilMode {
-  switch (level) {
-    case "low":      return "jury-only"
-    case "medium":   return "lite"
-    case "high":     return "full"
-    case "critical": return "full"
-  }
-}
-
-/**
- * Classify the risk level of a proposed change from its text and evidence.
- *
- * Risk determines Council mode — avoid running full fan-out on low-risk changes:
- *   low      → jury-only  (no advisor/reviewer fan-out)
- *   medium   → lite       (Jury + 2 reviewers)
- *   high     → full       (standard 5 advisors + 5 reviewers)
- *   critical → full       (same as high, but Chronicle entry flags for human architecture review)
- *
- * Refuted Oracle entries also elevate risk — a known failure mode in the evidence pack
- * means the design is repeating something that already went wrong.
- */
-export function classifyRisk(
-  outcome: string,
-  design: string,
-  evidence: OracleResult[],
-): RiskAssessment {
-  const text = `${outcome} ${design}`
-  let level: RiskLevel = "low"
-  const reasons: string[] = []
-
-  for (const rule of RISK_RULES) {
-    if (rule.pattern.test(text)) {
-      const matched = maxLevel(level, rule.level)
-      if (matched !== level || !reasons.includes(rule.reason)) {
-        level = matched
-        reasons.push(rule.reason)
-      }
-    }
-  }
-
-  // Refuted entries in the evidence pack are a direct risk signal
-  const refutedCount = evidence.filter(e => e.status === "refuted").length
-  if (refutedCount > 0) {
-    const refutedRisk: RiskLevel = refutedCount >= 2 ? "high" : "medium"
-    if (RISK_ORDER.indexOf(refutedRisk) > RISK_ORDER.indexOf(level)) {
-      level = maxLevel(level, refutedRisk)
-    }
-    reasons.push(`${refutedCount} refuted Chronicle ${refutedCount === 1 ? "entry" : "entries"} in evidence pack`)
-  }
-
-  return {
-    level,
-    reasons: reasons.length > 0 ? reasons : ["no sensitive patterns detected"],
-    council_mode: councilModeForLevel(level),
-  }
-}

package/modules/council/types.ts

@@ -1,107 +0,0 @@
-import type { OracleResult, LLMProvider, OracleClient } from "../shared/types"
-import type { JuryOutput } from "../jury/types"
-
-export interface CouncilInput {
-  /** What needs to be achieved. */
-  outcome: string
-  /** Proposed approach from the Designer. */
-  design: string
-  /** Same evidence pack the Jury received. */
-  evidence: OracleResult[]
-  /** Jury output — drives the council brief and confidence. */
-  jury_output: JuryOutput
-}
-
-/** A finding that must be resolved before the design can proceed. */
-export interface BlockerItem {
-  issue: string
-  /** Oracle entry IDs that evidence this blocker. */
-  evidence: string[]
-  /** What must change in the design to resolve this. */
-  required_fix: string
-}
-
-/** A finding that should be addressed but does not block proceeding. */
-export interface WarningItem {
-  issue: string
-  suggested_fix?: string
-}
-
-/** Validates that cited Oracle IDs actually appeared in the evidence pack. */
-export interface CitationValidation {
-  /** IDs that were cited and exist in the evidence pack. */
-  valid_ids: string[]
-  /** IDs that were cited but were NOT in the evidence pack — likely hallucinated. */
-  hallucinated_ids: string[]
-}
-
-/** How advisors split on their recommendation. Signals disagreement level. */
-export interface AdvisorSplit {
-  proceed: number
-  redesign: number
-  "investigate-more": number
-}
-
-export interface CouncilOutput {
-  satisfied: boolean
-  /** Chairman synthesis — every material conclusion cites Oracle entry IDs. */
-  verdict: string
-  /**
-   * Findings that MUST be resolved before the design proceeds.
-   * Each blocker names the issue, the Oracle evidence behind it, and the required fix.
-   */
-  blockers: BlockerItem[]
-  /**
-   * Findings that SHOULD be addressed but don't block execution.
-   */
-  warnings: WarningItem[]
-  /** Flat list of all issues raised — backwards compatible with existing consumers. */
-  challenges: string[]
-  /** Oracle entry IDs referenced in the verdict. */
-  evidence_cited: string[]
-  /** Validation of whether cited IDs exist in the evidence pack. */
-  citation_validation: CitationValidation
-  /** How advisors split on recommendation — high disagreement = escalate. */
-  advisor_split: AdvisorSplit
-  recommendation: "proceed" | "redesign" | "investigate-more"
-}
-
-export interface CouncilModels {
-  /** Model for the framer step. */
-  frame?: string
-  /** Model for advisors. High volume — cheaper model appropriate here. */
-  advisors?: string
-  /** Model for reviewers. Critical analysis — stronger model recommended. */
-  reviewers?: string
-  /** Model for the chairman. Synthesis — best available model recommended. */
-  chairman?: string
-}
-
-export interface CouncilDeps {
-  llm: LLMProvider
-  oracle: OracleClient
-  /** Number of advisors to run in parallel. Default: 5. */
-  advisorCount?: number
-  /** Number of reviewers to run in parallel. Default: 5. */
-  reviewerCount?: number
-  models?: CouncilModels
-}
-
-// ── Risk classifier types ─────────────────────────────────────────────────────
-
-export type RiskLevel = "low" | "medium" | "high" | "critical"
-
-/**
- * Determines which Council mode to use.
- *   skip        → Oracle query only, no LLM validation
- *   jury-only   → Jury scores, Council skipped entirely (low-risk fast path)
- *   lite        → Jury + 1–2 reviewers (no full advisor fan-out)
- *   full        → Full Council (default 5 advisors + 5 reviewers + Chairman)
- */
-export type CouncilMode = "skip" | "jury-only" | "lite" | "full"
-
-export interface RiskAssessment {
-  level: RiskLevel
-  reasons: string[]
-  council_mode: CouncilMode
-}

package/modules/jury/index.ts

@@ -1,5 +0,0 @@
-export { evaluate } from "./evaluate"
-export type { JuryInput, JuryOutput, JuryDeps, ConfidenceBreakdown } from "./types"
-export { JuryOutputSchema } from "./schema"
-export { runPreflight, formatPreflight } from "./preflight"
-export type { PreflightResult } from "./preflight"

package/modules/jury/preflight.ts

@@ -1,101 +0,0 @@
-import type { OracleResult } from "../shared/types"
-import { entryText } from "../shared/types"
-
-/** Areas that warrant elevated scrutiny. */
-const SENSITIVE_PATTERNS: Record<string, RegExp> = {
-  auth:          /\b(auth(?:entication|orization)?|jwt|token|session|password|oauth|login|logout|credential|bearer)\b/i,
-  database:      /\b(migrat(?:ion|e)|alter\s+table|schema\s+change|postgres|mysql|sqlite|prisma|drizzle|knex|sequelize)\b/i,
-  crypto:        /\b(encrypt|decrypt|cipher|hash(?:ing)?|hmac|sign(?:ing)?|verify|private\s+key|certificate|tls|ssl)\b/i,
-  payments:      /\b(payment|stripe|charge|billing|invoice|subscription|price|checkout|refund)\b/i,
-  permissions:   /\b(permission|role(?:s)?|acl|access\s+control|rbac|authorization|entitlement)\b/i,
-  pii:           /\b(pii|personal\s+data|gdpr|ccpa|email(?:\s+address)?|phone(?:\s+number)?|postal\s+address|ssn|passport)\b/i,
-  data_deletion: /\b(delete(?:\s+all)?|drop\s+table|truncate|purge|wipe|destroy.*data|hard\s+delete)\b/i,
-  secrets:       /\b(api\s+key|secret(?:s)?|env(?:ironment)?\s+var(?:iable)?|\.env|private\s+key|credentials?)\b/i,
-}
-
-const ROLLBACK_PATTERNS = /\b(rollback|roll\s+back|revert|undo|restore|recovery|fallback|backward[- ]compat)\b/i
-const TEST_PATTERNS     = /\b(test(?:ing|s)?|spec(?:ification)?|unit\s+test|integration\s+test|coverage|vitest|jest|mocha)\b/i
-
-export interface PreflightResult {
-  touches_sensitive_area: boolean
-  /** Which sensitive area categories were detected. */
-  sensitive_areas: string[]
-  /** Whether the design mentions a rollback or recovery strategy. */
-  rollback_mentioned: boolean
-  /** Whether the design mentions testing. */
-  test_strategy_mentioned: boolean
-  /**
-   * IDs of refuted Chronicle entries that semantically overlap with the design text.
-   * These are potential conflicts — Jury should surface them.
-   */
-  chronicle_conflicts: string[]
-}
-
-/**
- * Static preflight analysis — no LLM required.
- *
- * Runs deterministic checks on the outcome + design text and the evidence pack
- * before any LLM call. Results are injected into the Jury prompt so the LLM
- * reasons over concrete signals rather than discovering them itself.
- */
-export function runPreflight(
-  outcome: string,
-  design: string,
-  evidence: OracleResult[],
-): PreflightResult {
-  const text = `${outcome} ${design}`
-
-  const sensitive_areas = Object.entries(SENSITIVE_PATTERNS)
-    .filter(([, pattern]) => pattern.test(text))
-    .map(([area]) => area)
-
-  // Refuted entries whose primary text shares at least one significant word with the design
-  const designWords = new Set(
-    text
-      .toLowerCase()
-      .split(/\W+/)
-      .filter(w => w.length > 4),
-  )
-
-  const chronicle_conflicts = evidence
-    .filter(e => {
-      if (e.status !== "refuted") return false
-      const entryWords = entryText(e)
-        .toLowerCase()
-        .split(/\W+/)
-        .filter(w => w.length > 4)
-      return entryWords.some(w => designWords.has(w))
-    })
-    .map(e => e.id)
-
-  return {
-    touches_sensitive_area: sensitive_areas.length > 0,
-    sensitive_areas,
-    rollback_mentioned: ROLLBACK_PATTERNS.test(text),
-    test_strategy_mentioned: TEST_PATTERNS.test(text),
-    chronicle_conflicts,
-  }
-}
-
-/** Format preflight result for injection into the Jury prompt. */
-export function formatPreflight(preflight: PreflightResult): string {
-  const lines: string[] = ["## Deterministic Preflight (machine-checked, not LLM-inferred)"]
-
-  if (preflight.touches_sensitive_area) {
-    lines.push(`⚠ Sensitive areas detected: ${preflight.sensitive_areas.join(", ")}`)
-  } else {
-    lines.push("✓ No sensitive areas detected")
-  }
-
-  lines.push(preflight.rollback_mentioned ? "✓ Rollback strategy mentioned" : "✗ No rollback strategy mentioned")
-  lines.push(preflight.test_strategy_mentioned ? "✓ Test strategy mentioned" : "✗ No test strategy mentioned")
-
-  if (preflight.chronicle_conflicts.length > 0) {
-    lines.push(`⚠ Refuted Chronicle entries potentially conflicting: ${preflight.chronicle_conflicts.join(", ")}`)
-    lines.push("  These entries were previously tried and failed — verify the design addresses the documented failure reason.")
-  } else {
-    lines.push("✓ No conflicting refuted Chronicle entries")
-  }
-
-  return lines.join("\n")
-}

package/modules/jury/schema.ts

@@ -1,24 +0,0 @@
-import { z } from "zod"
-
-const ConfidenceBreakdownSchema = z.object({
-  evidence_support: z.number().min(0).max(1),
-  feasibility: z.number().min(0).max(1),
-  risk: z.number().min(0).max(1),
-  completeness: z.number().min(0).max(1),
-})
-
-/**
- * Zod schema for the Jury's structured LLM output.
- * evaluate() validates all LLM responses against this before returning.
- */
-export const JuryOutputSchema = z.object({
-  confidence: z.number().min(0).max(1),
-  confidence_breakdown: ConfidenceBreakdownSchema,
-  assessment: z.string().min(1),
-  gaps: z.array(z.string()),
-  blocking_gaps: z.array(z.string()),
-  council_brief: z.enum(["challenge", "pressure-test"]),
-  recommendation: z.enum(["proceed", "investigate-more", "redesign"]),
-})
-
-export type JuryOutputParsed = z.infer<typeof JuryOutputSchema>