seal-gate 0.3.0

package/dist/types.d.ts

@@ -0,0 +1,184 @@
+export type ArtifactType = 'llm_response' | 'code_diff' | 'test_plan' | 'design' | 'migration' | 'plan_review';
+export type RiskLevel = 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
+export type Verdict = 'PASS' | 'PASS_WITH_WARNINGS' | 'REVISE' | 'ESCALATE_TO_HUMAN' | 'BLOCK';
+export type IssueType = 'SPEC_MISMATCH' | 'LOGIC_BUG' | 'TEST_GAP' | 'MISSING_EVIDENCE' | 'SECURITY_RISK' | 'DATA_RISK' | 'HALLUCINATION' | 'AMBIGUITY' | 'COMPATIBILITY_RISK' | 'FABRICATED_EVIDENCE' | 'OTHER';
+export type IssueLayer = 'L1' | 'L2' | 'L3' | 'L4' | 'EXTENSION' | 'LLM_OVERLAY';
+export type ClaimType = 'test_result_claim' | 'implementation_claim' | 'compatibility_claim' | 'risk_claim' | 'build_claim' | 'production_claim' | 'generic_claim';
+export type CitationStatus = 'verified' | 'drifted' | 'void' | 'phantom' | 'not_applicable';
+export type StructuralClaimType = 'structural_endpoint' | 'structural_auth' | 'structural_migration' | 'structural_dependency';
+export type EvidenceEnvelope = {
+    type: 'file';
+    path: string;
+    line: number;
+    snapshot: string;
+} | {
+    type: 'command';
+    command: string;
+    exit_code: number;
+    output: string;
+} | {
+    type: 'url';
+    url: string;
+    retrieved_at: string;
+    content_snapshot: string;
+} | {
+    type: 'text';
+    label: string;
+    content: string;
+} | {
+    type: 'memory';
+    memory_key: string;
+    retrieved_at: string;
+    content_snapshot: string;
+};
+export interface SealEvidence {
+    test_log: string;
+    build_log: string;
+    diff: string;
+    references: EvidenceEnvelope[];
+}
+export interface SealInput {
+    artifact_type: ArtifactType;
+    spec: string | null;
+    output: string;
+    evidence: SealEvidence;
+    risk_hint: RiskLevel | null;
+    context?: {
+        agent_id?: string;
+        agent_role?: string;
+        aria_axioms?: string[];
+        aria_pattern_memory?: Record<string, unknown>;
+        locked_criteria?: Array<{
+            id: string;
+            text: string;
+            source_file?: string;
+            source_line?: number;
+        }>;
+        [key: string]: unknown;
+    };
+}
+export interface Claim {
+    text: string;
+    type: ClaimType;
+    start_pos: number;
+    end_pos: number;
+    requires_evidence: boolean;
+}
+export interface StructuralClaim {
+    type: StructuralClaimType;
+    target: string;
+    line: number;
+    description: string;
+    requires_auth?: boolean;
+    has_rollback?: boolean;
+    change_type?: 'added' | 'modified' | 'removed';
+}
+export interface EvidenceResult {
+    envelope: EvidenceEnvelope;
+    structurally_valid: boolean;
+    filesystem_verified: boolean | null;
+    mismatch_detail?: string;
+    citation_status?: CitationStatus;
+}
+export interface ScoreBreakdown {
+    base: number;
+    issue_deductions: number;
+    missing_evidence_deductions: number;
+    risk_deductions: number;
+    overconfidence_deductions: number;
+    evidence_bonuses: number;
+    final: number;
+}
+export interface FabricatedEvidence {
+    type: IssueType;
+    severity: 'CRITICAL' | 'HIGH' | 'MEDIUM' | 'LOW';
+    is_blocking: boolean;
+    evidence: string;
+    layer: IssueLayer;
+    source: 'core' | 'llm-overlay' | 'extension';
+    citation_status: CitationStatus;
+    fabricated_reason: 'location_not_found' | 'content_mismatch';
+    claimed_evidence: {
+        file?: string;
+        lines?: number[];
+        quote?: string;
+    };
+}
+export interface SealIssue {
+    type: IssueType;
+    severity: 'CRITICAL' | 'HIGH' | 'MEDIUM' | 'LOW';
+    is_blocking: boolean;
+    required_verdict?: Verdict;
+    evidence: string;
+    required_fix?: string;
+    suggested_fix?: string;
+    layer: IssueLayer;
+    rule_id?: string;
+    source: 'core' | 'llm-overlay' | 'extension';
+    trust_deduction?: number;
+    evidence_file?: string;
+    evidence_lines?: number[];
+    evidence_quote?: string;
+    criterion_ref?: string;
+    confidence?: number;
+    policy_tags?: string[];
+    citation_status?: CitationStatus;
+}
+export type EvidenceGrade = 'strong' | 'weak' | 'none';
+export declare function gradeEvidence(issue: SealIssue): EvidenceGrade;
+export interface LLMSignals {
+    suspected_issues: string[];
+    missing_requirements: string[];
+    possible_edge_cases: string[];
+    evidence_gaps: string[];
+    risk_guess: RiskLevel;
+    confidence: number;
+}
+export interface PartialVerdict {
+    trust_score: number;
+    risk_level: RiskLevel;
+    deterministic_findings: SealIssue[];
+    missing_evidence: string[];
+    assumptions_detected: string[];
+}
+export interface TrustMemorySummary {
+    agent_id: string;
+    reliability_score: number | null;
+    drift_trend: 'improving' | 'stable' | 'degrading';
+    review_count: number;
+    last_reviewed_at: number | null;
+}
+export interface SealVerdict {
+    verdict: Verdict;
+    trust_score: number;
+    risk_level: RiskLevel;
+    summary: string;
+    deterministic_findings: SealIssue[];
+    llm_findings: SealIssue[];
+    blocking_issues: SealIssue[];
+    non_blocking_issues: SealIssue[];
+    missing_evidence: string[];
+    assumptions_detected: string[];
+    advisory_notes: string[];
+    next_action: string;
+    schema_version: string;
+    score_breakdown: ScoreBreakdown;
+    fabricated_evidence: FabricatedEvidence[];
+    trust_memory_summary?: TrustMemorySummary;
+}
+export interface SealExtension {
+    name: string;
+    description: string;
+    check(input: SealInput): SealIssue[];
+}
+export interface LLMReviewerAdapter {
+    review(input: SealInput, partial: PartialVerdict): Promise<LLMSignals> | LLMSignals;
+}
+export declare const SCHEMA_VERSION = "0.2.0";
+export declare const VERDICT_ORDER: Verdict[];
+export declare function worstOf(a: Verdict, b: Verdict): Verdict;
+export declare const maxVerdict: typeof worstOf;
+export declare function verdictFromScore(score: number, hasBlocking: boolean): Verdict;
+export declare const NEXT_ACTION: Record<Verdict, string>;
+export declare function isBlocking(severity: SealIssue['severity']): boolean;
+export declare function makeIssue(partial: Omit<SealIssue, 'is_blocking'>): SealIssue;

package/dist/types.js

@@ -0,0 +1,61 @@
+export function gradeEvidence(issue) {
+    const hasFile = !!issue.evidence_file;
+    const hasLines = !!(issue.evidence_lines && issue.evidence_lines.length > 0);
+    const hasQuote = !!issue.evidence_quote;
+    const hasCriterionRef = !!issue.criterion_ref;
+    // Type G: contradiction pair — both line spans present
+    const isTypeG = hasFile && hasLines && (issue.evidence_lines?.length ?? 0) >= 2 && hasQuote;
+    // Type H: unsatisfied forward-criterion with criterion_ref
+    const isTypeH = hasCriterionRef && hasFile && hasLines;
+    // Type A+B: file + lines present
+    const isAB = hasFile && hasLines;
+    // Type D: quote references spec requirement or AC bullet (heuristic: quote contains AC- or SHALL/MUST)
+    const isTypeD = hasQuote && /\bAC-\d+\b|SHALL|MUST|SHOULD/i.test(issue.evidence_quote ?? '');
+    if (isTypeG || isTypeH || isAB || isTypeD)
+        return 'strong';
+    // Type E: quote contains code/diff excerpt; Type F: AMBIGUITY issue type
+    const isTypeE = hasQuote && /```|diff --git|@@/.test(issue.evidence_quote ?? '');
+    const isTypeF = issue.type === 'AMBIGUITY';
+    if (isTypeE || isTypeF)
+        return 'weak';
+    return 'none';
+}
+export const SCHEMA_VERSION = '0.2.0';
+export const VERDICT_ORDER = ['PASS', 'PASS_WITH_WARNINGS', 'REVISE', 'ESCALATE_TO_HUMAN', 'BLOCK'];
+// Semantic worst-of comparison — safe against enum reordering because it reads VERDICT_ORDER, not integer values.
+// Use this everywhere instead of arithmetic max over enum indices.
+export function worstOf(a, b) {
+    return VERDICT_ORDER.indexOf(a) >= VERDICT_ORDER.indexOf(b) ? a : b;
+}
+// Alias for backward compatibility — prefer worstOf in new code
+export const maxVerdict = worstOf;
+export function verdictFromScore(score, hasBlocking) {
+    if (hasBlocking)
+        return maxVerdict(scoreToVerdict(score), 'REVISE');
+    return scoreToVerdict(score);
+}
+function scoreToVerdict(score) {
+    if (score >= 85)
+        return 'PASS';
+    if (score >= 70)
+        return 'PASS_WITH_WARNINGS';
+    if (score >= 50)
+        return 'REVISE';
+    if (score >= 30)
+        return 'ESCALATE_TO_HUMAN';
+    return 'BLOCK';
+}
+export const NEXT_ACTION = {
+    PASS: 'Proceed',
+    PASS_WITH_WARNINGS: 'Proceed with caution — review warnings',
+    REVISE: 'Return to producing agent with blocking_issues',
+    ESCALATE_TO_HUMAN: 'Halt — requires human review before continuing',
+    BLOCK: 'Halt — do not proceed',
+};
+export function isBlocking(severity) {
+    return severity === 'CRITICAL' || severity === 'HIGH';
+}
+export function makeIssue(partial) {
+    return { ...partial, is_blocking: isBlocking(partial.severity) };
+}
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "seal-gate",
+  "version": "0.3.0",
+  "description": "Universal standalone AI quality gate — deterministic core + optional LLM overlay",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "bin": {
+    "seal": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "engines": {
+    "node": ">=22.5.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "tsc",
+    "test": "bun test tests/input-normalizer.test.ts tests/claim-extractor.test.ts tests/trust-memory.test.ts tests/integration/ tests/extensions/aria.test.ts tests/extensions/context-guard tests/detectors/ tests/engine/ tests/conformance/ && bun tests/extensions/lyra-bleed-vietnamese.test.ts",
+    "test:watch": "bun test --watch",
+    "review": "node dist/cli.js review"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "bun-types": "latest",
+    "typescript": "^6.0.3"
+  }
+}

package/src/adapters/generic-llm-reviewer.ts

@@ -0,0 +1,144 @@
+/**
+ * Generic OpenAI-compatible LLM Reviewer Adapter
+ * Works with any provider that speaks the OpenAI chat completions API:
+ * MiniMax, Fireworks, Gemini (OpenAI-compat), Qwen/MiMo, local (port 3546), etc.
+ *
+ * Usage:
+ *   Seal.withLLM(createReviewer({ provider: 'minimax' }))
+ *   Seal.withLLM(createReviewer({ provider: 'fireworks', model: 'accounts/...' }))
+ *   Seal.withLLM(createReviewer({ baseUrl: 'http://localhost:3546/v1', apiKey: 'none', model: 'local' }))
+ */
+import { LLMReviewerAdapter, LLMSignals, SealInput, PartialVerdict } from '../types.js'
+
+// Known providers from ~/.anima/providers.d/
+const PROVIDERS: Record<string, { baseUrl: string; apiKeyEnv: string; defaultModel: string }> = {
+  minimax:   { baseUrl: 'https://api.minimax.io/v1',               apiKeyEnv: 'MINIMAX_PLAN_KEY',   defaultModel: 'MiniMax-M3' },
+  fireworks: { baseUrl: 'https://api.fireworks.ai/inference/v1',   apiKeyEnv: 'FIREWORKS_API_KEY',  defaultModel: 'accounts/fireworks/models/mixtral-8x7b-instruct' },
+  gemini:    { baseUrl: 'https://generativelanguage.googleapis.com/v1beta/openai', apiKeyEnv: 'GEMINI_API_KEY', defaultModel: 'gemini-2.0-flash' },
+  xiaomimo:  { baseUrl: 'https://token-plan-sgp.xiaomimimo.com/v1', apiKeyEnv: 'XIAOMI_MIMO_API_KEY', defaultModel: 'mimo-v2.5-pro' },
+  openai:    { baseUrl: 'https://api.openai.com/v1',               apiKeyEnv: 'OPENAI_API_KEY',     defaultModel: 'gpt-4o-mini' },
+  local:     { baseUrl: 'http://localhost:3546/v1',                apiKeyEnv: '',                   defaultModel: 'local' },
+}
+
+const SYSTEM_PROMPT = `You are Seal, a quality gate in an AI engineering workflow.
+
+Your job is NOT to be polite or creative. Your job is to detect semantic issues the deterministic rules could not catch.
+
+Review AI agent output for semantic correctness, subtle logic bugs, and missing requirements.
+The deterministic layer already checked: evidence presence, risk keywords, spec headers, test logs.
+Your focus: semantic reasoning, prose logic, subtle edge cases, spec compliance.
+
+Return ONLY valid JSON:
+{
+  "suspected_issues": ["string — exact reasoning error, max 3"],
+  "missing_requirements": ["string — spec requirement clearly absent"],
+  "possible_edge_cases": ["string — edge cases to consider"],
+  "evidence_gaps": ["string — claims needing evidence that slipped through"],
+  "risk_guess": "LOW | MEDIUM | HIGH | CRITICAL",
+  "confidence": 0.0
+}
+
+Rules: confidence 0.0–1.0. Empty arrays if output is correct. No padding.`
+
+function buildMessage(input: SealInput, partial: PartialVerdict): string {
+  const parts: string[] = []
+  if (input.spec) parts.push(`=== SPEC ===\n${input.spec}`)
+  parts.push(`=== OUTPUT (${input.artifact_type}) ===\n${input.output}`)
+  const blocking = partial.deterministic_findings.filter(f => f.is_blocking)
+  if (blocking.length) {
+    parts.push(`=== ALREADY FLAGGED (do not repeat) ===\n${blocking.map(f => `- [${f.rule_id ?? f.type}] ${f.evidence}`).join('\n')}`)
+  }
+  parts.push(`=== PARTIAL VERDICT ===\ntrust_score: ${partial.trust_score}, risk: ${partial.risk_level}`)
+  return parts.join('\n\n')
+}
+
+function extractJSON(raw: string): string {
+  // Strip <think>...</think> blocks (thinking models like MiniMax-M3, MiMo)
+  const stripped = raw.replace(/<think>[\s\S]*?<\/think>/g, '').trim()
+  const match = stripped.match(/\{[\s\S]*\}/)
+  return match ? match[0] : stripped
+}
+
+export interface GenericReviewerOptions {
+  provider?: keyof typeof PROVIDERS   // named provider from PROVIDERS table
+  baseUrl?: string                    // override — takes precedence over provider
+  apiKey?: string                     // override — takes precedence over env var
+  model?: string                      // override model
+  timeoutMs?: number                  // default 30000
+}
+
+export class GenericLLMReviewer implements LLMReviewerAdapter {
+  private baseUrl: string
+  private apiKey: string
+  private model: string
+  private timeoutMs: number
+
+  constructor(opts: GenericReviewerOptions = {}) {
+    const preset = opts.provider ? PROVIDERS[opts.provider] : null
+
+    this.baseUrl  = opts.baseUrl  ?? preset?.baseUrl  ?? PROVIDERS.minimax.baseUrl
+    this.apiKey   = opts.apiKey   ?? (preset ? (process.env[preset.apiKeyEnv] ?? '') : (process.env.MINIMAX_PLAN_KEY ?? ''))
+    this.model    = opts.model    ?? preset?.defaultModel ?? PROVIDERS.minimax.defaultModel
+    this.timeoutMs = opts.timeoutMs ?? 30_000
+  }
+
+  async review(input: SealInput, partial: PartialVerdict): Promise<LLMSignals> {
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs)
+
+    let response: Response
+    try {
+      response = await fetch(`${this.baseUrl}/chat/completions`, {
+        signal: controller.signal,
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': this.apiKey ? `Bearer ${this.apiKey}` : 'Bearer none',
+        },
+        body: JSON.stringify({
+          model: this.model,
+          messages: [
+            { role: 'system', content: SYSTEM_PROMPT },
+            { role: 'user',   content: buildMessage(input, partial) },
+          ],
+          response_format: { type: 'json_object' },
+          temperature: 0.1,
+          max_tokens: 1024,
+        }),
+      })
+    } finally {
+      clearTimeout(timer)
+    }
+
+    if (!response.ok) {
+      const body = await response.text().catch(() => '')
+      throw new Error(`LLM reviewer ${this.model} error ${response.status}: ${body.slice(0, 200)}`)
+    }
+
+    const data = await response.json() as { choices: Array<{ message: { content: string } }> }
+    const raw = data.choices?.[0]?.message?.content ?? '{}'
+    const jsonStr = extractJSON(raw)
+
+    let signals: Partial<LLMSignals>
+    try { signals = JSON.parse(jsonStr) }
+    catch { throw new Error(`LLM reviewer returned invalid JSON: ${raw.slice(0, 200)}`) }
+
+    const VALID_RISKS = ['LOW', 'MEDIUM', 'HIGH', 'CRITICAL']
+    return {
+      suspected_issues:     Array.isArray(signals.suspected_issues)    ? signals.suspected_issues    : [],
+      missing_requirements: Array.isArray(signals.missing_requirements) ? signals.missing_requirements : [],
+      possible_edge_cases:  Array.isArray(signals.possible_edge_cases)  ? signals.possible_edge_cases  : [],
+      evidence_gaps:        Array.isArray(signals.evidence_gaps)        ? signals.evidence_gaps        : [],
+      risk_guess:           VALID_RISKS.includes(signals.risk_guess ?? '') ? signals.risk_guess as LLMSignals['risk_guess'] : 'MEDIUM',
+      confidence:           typeof signals.confidence === 'number' ? Math.max(0, Math.min(1, signals.confidence)) : 0.5,
+    }
+  }
+}
+
+/** Pre-configured factories */
+export const createReviewer = (opts: GenericReviewerOptions) => new GenericLLMReviewer(opts)
+export const createMinimaxReviewer  = (model?: string) => new GenericLLMReviewer({ provider: 'minimax',   model })
+export const createFireworksReviewer = (model?: string) => new GenericLLMReviewer({ provider: 'fireworks', model })
+export const createGeminiReviewer   = (model?: string) => new GenericLLMReviewer({ provider: 'gemini',    model })
+export const createMiMoReviewer     = (model?: string) => new GenericLLMReviewer({ provider: 'xiaomimo',  model })
+export const createLocalReviewer    = (model?: string) => new GenericLLMReviewer({ provider: 'local',     model })

package/src/adapters/llm-reviewer.ts

@@ -0,0 +1 @@
+export { LLMReviewerAdapter, LLMSignals, PartialVerdict } from '../types.js'

package/src/adapters/minimax-llm-reviewer.ts

@@ -0,0 +1,146 @@
+/**
+ * MiniMax LLM Reviewer Adapter — v0.3
+ * Uses MiniMax-M3 (tokenplan) as semantic reviewer for Seal Gate L2.
+ *
+ * MiniMax is a SENSOR, not a judge. Returns structured signals.
+ * PolicyEngine converts signals to SealIssue[] via deterministic rules.
+ */
+import { LLMReviewerAdapter, LLMSignals, SealInput, PartialVerdict } from '../types.js'
+
+const MINIMAX_BASE_URL = process.env.MINIMAX_BASE_URL ?? 'https://api.minimax.io/v1'
+const MINIMAX_API_KEY = process.env.MINIMAX_PLAN_KEY ?? process.env.MINIMAX_API_KEY ?? ''
+const DEFAULT_MODEL = process.env.MINIMAX_MODEL ?? 'MiniMax-M3'
+
+const SYSTEM_PROMPT = `You are Seal, a quality gate in an AI engineering workflow.
+
+Your job is NOT to be polite, creative, or helpful by default.
+Your job is to detect semantic issues the deterministic rules could not catch.
+
+You are reviewing AI agent output for semantic correctness, subtle logic bugs, and missing requirements.
+The deterministic layer has already checked: evidence presence, risk keywords, spec headers, test logs.
+Your focus: semantic reasoning, prose logic, subtle edge cases, missing requirements not covered by structural checks.
+
+Return ONLY valid JSON with this exact schema:
+{
+  "suspected_issues": ["string — one per suspected logic bug or reasoning error"],
+  "missing_requirements": ["string — requirements from spec not addressed in output"],
+  "possible_edge_cases": ["string — edge cases that should be considered"],
+  "evidence_gaps": ["string — claims that need evidence but may have slipped through"],
+  "risk_guess": "LOW | MEDIUM | HIGH | CRITICAL",
+  "confidence": 0.0
+}
+
+Rules:
+- suspected_issues: max 3. Only include if you can name the exact reasoning error.
+- missing_requirements: only if spec is provided and requirement is clearly absent.
+- confidence: 0.0–1.0. Be honest. If output is clear and correct, say 0.85+.
+- Do not reward fluent explanations. Reward verifiable correctness.
+- If output looks correct and complete, return empty arrays and high confidence.`
+
+function buildUserMessage(input: SealInput, partial: PartialVerdict): string {
+  const parts: string[] = []
+
+  if (input.spec) {
+    parts.push(`=== SPEC ===\n${input.spec}`)
+  }
+
+  parts.push(`=== OUTPUT (artifact_type: ${input.artifact_type}) ===\n${input.output}`)
+
+  if (partial.deterministic_findings.length > 0) {
+    const issues = partial.deterministic_findings
+      .filter(f => f.is_blocking)
+      .map(f => `- [${f.rule_id ?? f.type}] ${f.evidence}`)
+      .join('\n')
+    if (issues) parts.push(`=== DETERMINISTIC FINDINGS (already flagged, do not repeat) ===\n${issues}`)
+  }
+
+  parts.push(`=== PARTIAL VERDICT ===\ntrust_score: ${partial.trust_score}, risk_level: ${partial.risk_level}`)
+
+  return parts.join('\n\n')
+}
+
+export class MinimaxLLMReviewer implements LLMReviewerAdapter {
+  constructor(
+    private model = DEFAULT_MODEL,
+    private baseUrl = MINIMAX_BASE_URL,
+    private apiKey = MINIMAX_API_KEY,
+  ) {}
+
+  async review(input: SealInput, partial: PartialVerdict): Promise<LLMSignals> {
+    if (!this.apiKey) {
+      throw new Error('MINIMAX_PLAN_KEY or MINIMAX_API_KEY not set')
+    }
+
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), 30_000)
+
+    let response: Response
+    try {
+      response = await fetch(`${this.baseUrl}/chat/completions`, {
+        signal: controller.signal,
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.apiKey}`,
+        },
+        body: JSON.stringify({
+          model: this.model,
+          messages: [
+            { role: 'system', content: SYSTEM_PROMPT },
+            { role: 'user', content: buildUserMessage(input, partial) },
+          ],
+          response_format: { type: 'json_object' },
+          temperature: 0.1,
+          max_tokens: 1024,
+        }),
+      })
+    } finally {
+      clearTimeout(timer)
+    }
+
+    if (!response.ok) {
+      const body = await response.text().catch(() => '')
+      throw new Error(`MiniMax API error ${response.status}: ${body.slice(0, 200)}`)
+    }
+
+    const data = await response.json() as { choices: Array<{ message: { content: string } }> }
+    let content = data.choices?.[0]?.message?.content ?? '{}'
+
+    // Strip <think>...</think> reasoning block (MiniMax-M3 thinking model)
+    content = content.replace(/<think>[\s\S]*?<\/think>/g, '').trim()
+
+    // Extract JSON object — model may wrap it in prose
+    const jsonMatch = content.match(/\{[\s\S]*\}/)
+    const jsonStr = jsonMatch ? jsonMatch[0] : content
+
+    let signals: Partial<LLMSignals>
+    try {
+      signals = JSON.parse(jsonStr)
+    } catch {
+      throw new Error(`MiniMax returned invalid JSON: ${content.slice(0, 200)}`)
+    }
+
+    return {
+      suspected_issues:     Array.isArray(signals.suspected_issues) ? signals.suspected_issues : [],
+      missing_requirements: Array.isArray(signals.missing_requirements) ? signals.missing_requirements : [],
+      possible_edge_cases:  Array.isArray(signals.possible_edge_cases) ? signals.possible_edge_cases : [],
+      evidence_gaps:        Array.isArray(signals.evidence_gaps) ? signals.evidence_gaps : [],
+      risk_guess:           (['LOW','MEDIUM','HIGH','CRITICAL'].includes(signals.risk_guess ?? ''))
+                              ? signals.risk_guess as LLMSignals['risk_guess']
+                              : 'MEDIUM',
+      confidence:           typeof signals.confidence === 'number'
+                              ? Math.max(0, Math.min(1, signals.confidence))
+                              : 0.5,
+    }
+  }
+}
+
+/**
+ * Convenience: create a pre-configured MiniMax reviewer.
+ * Usage:
+ *   import { createMinimaxReviewer } from 'seal-gate/adapters/minimax-llm-reviewer'
+ *   Seal.withLLM(createMinimaxReviewer())
+ */
+export function createMinimaxReviewer(model?: string): MinimaxLLMReviewer {
+  return new MinimaxLLMReviewer(model)
+}