freelang-editor 11.7.4

package/src/errors.ts

@@ -0,0 +1,281 @@
+// FreeLang v9: Custom Error Classes
+// Phase 6: Module System + Type-safe Error Handling
+// Phase 59: 위치 정보 (file/line/col/hint) 추가
+
+import { appendFileSync } from "fs";
+
+const FL_ERROR_LOG = process.env.FL_ERROR_LOG ?? "/tmp/fl-unknown-functions.jsonl";
+
+// 내장 연산자/특수폼 — swap! 등에 값으로 넘겨도 오탐 로그 제외
+const FL_BUILTIN_OPS = new Set([
+  "+", "-", "*", "/", "%", "=", "!=", "<", ">", "<=", ">=",
+  "and", "or", "not", "str", "inc", "dec", "mod"
+]);
+
+function logUnknownFunction(name: string, file?: string, line?: number) {
+  if (FL_BUILTIN_OPS.has(name)) return; // 내장 연산자 오탐 방지
+  try {
+    const entry = JSON.stringify({ name, file, line, ts: Date.now() }) + "\n";
+    appendFileSync(FL_ERROR_LOG, entry);
+  } catch { /* 로그 실패는 조용히 무시 */ }
+}
+
+/**
+ * 기본 ModuleError 클래스
+ * 모듈 시스템 관련 모든 에러의 부모 클래스
+ */
+export class ModuleError extends Error {
+  constructor(
+    message: string,
+    public moduleName: string,
+    public file?: string,
+    public line?: number,
+    public col?: number,
+    public hint?: string
+  ) {
+    super(message);
+    this.name = "ModuleError";
+    Object.setPrototypeOf(this, ModuleError.prototype);
+  }
+}
+
+/**
+ * 모듈을 찾을 수 없을 때 발생
+ */
+export class ModuleNotFoundError extends ModuleError {
+  constructor(
+    moduleName: string,
+    source?: string,
+    file?: string,
+    line?: number,
+    col?: number,
+    hint?: string
+  ) {
+    const sourceStr = source ? ` (from ${source})` : "";
+    super(`Module not found: ${moduleName}${sourceStr}`, moduleName, file, line, col, hint);
+    this.name = "ModuleNotFoundError";
+    Object.setPrototypeOf(this, ModuleNotFoundError.prototype);
+  }
+}
+
+/**
+ * 선택적 import에서 함수를 찾을 수 없을 때 발생
+ */
+export class SelectiveImportError extends ModuleError {
+  constructor(
+    moduleName: string,
+    functionName: string,
+    file?: string,
+    line?: number,
+    col?: number,
+    hint?: string
+  ) {
+    super(
+      `Function "${functionName}" not exported from module "${moduleName}"`,
+      moduleName,
+      file,
+      line,
+      col,
+      hint
+    );
+    this.name = "SelectiveImportError";
+    Object.setPrototypeOf(this, SelectiveImportError.prototype);
+  }
+}
+
+/**
+ * 모듈이 올바른 구조가 아닐 때 발생
+ */
+export class InvalidModuleStructureError extends ModuleError {
+  constructor(moduleName: string, issue: string) {
+    super(`Invalid module structure in "${moduleName}": ${issue}`, moduleName);
+    this.name = "InvalidModuleStructureError";
+    Object.setPrototypeOf(this, InvalidModuleStructureError.prototype);
+  }
+}
+
+/**
+ * 함수 등록 실패 시 발생
+ */
+export class FunctionRegistrationError extends ModuleError {
+  constructor(
+    moduleName: string,
+    functionName: string,
+    reason: string,
+    file?: string,
+    line?: number,
+    col?: number,
+    hint?: string
+  ) {
+    super(
+      `Failed to register function "${functionName}" in module "${moduleName}": ${reason}`,
+      moduleName,
+      file,
+      line,
+      col,
+      hint
+    );
+    this.name = "FunctionRegistrationError";
+    Object.setPrototypeOf(this, FunctionRegistrationError.prototype);
+  }
+}
+
+/**
+ * Phase 59: 함수를 찾을 수 없을 때 발생 (유사 이름 힌트 포함)
+ */
+export class FunctionNotFoundError extends Error {
+  constructor(
+    public functionName: string,
+    public file?: string,
+    public line?: number,
+    public col?: number,
+    public hint?: string
+  ) {
+    const hintStr = hint ? ` ${hint}` : "";
+    super(`Function not found: ${functionName}${hintStr}`);
+    this.name = "FunctionNotFoundError";
+    Object.setPrototypeOf(this, FunctionNotFoundError.prototype);
+    logUnknownFunction(functionName, file, line);
+  }
+}
+
+// ─────────────────────────────────────────────────────────────
+// Phase A (2026-04-25): 에러 코드 시스템 + 통일 런타임 에러 클래스
+// ─────────────────────────────────────────────────────────────
+
+/** 표준 에러 코드 — AI/도구가 분기·검색 가능하도록 안정 식별자 사용 */
+export const ErrorCodes = {
+  TYPE_NIL: "E_TYPE_NIL",
+  TYPE_MISMATCH: "E_TYPE_MISMATCH",
+  ARG_COUNT: "E_ARG_COUNT",
+  STACK_OVERFLOW: "E_STACK_OVERFLOW",
+  FN_NOT_FOUND: "E_FN_NOT_FOUND",
+  DIV_BY_ZERO: "E_DIV_BY_ZERO",
+  INDEX_OUT_OF_BOUNDS: "E_INDEX_OOB",
+  INVALID_FORM: "E_INVALID_FORM",
+  RUNTIME: "E_RUNTIME",
+  PURE_VIOLATION: "E_PURE_VIOLATION",
+  UNDEFINED_VAR: "E_UNDEFINED_VAR",      // Phase Y-1
+  UNRESOLVED_SYMBOL: "E_UNRESOLVED_SYMBOL", // Phase Y-1
+} as const;
+
+export type ErrorCode = typeof ErrorCodes[keyof typeof ErrorCodes];
+
+/** 코드별 기본 복구 힌트 — formatError에서 자동 표시 */
+export const RECOVERY_HINTS: Record<string, string> = {
+  E_TYPE_NIL: "값이 nil인지 (nil? x) 또는 (get-or x :key default) 로 먼저 확인하세요.",
+  E_TYPE_MISMATCH: "기대 타입과 다릅니다. (string? x) (number? x) 등으로 사전 검증하거나 변환 함수를 사용하세요.",
+  E_ARG_COUNT: "인자 갯수가 맞지 않습니다. 함수 시그니처를 다시 확인하세요.",
+  E_STACK_OVERFLOW: "재귀 깊이 초과. 종료 조건이 있는지, 또는 loop/recur 또는 reduce로 변환 가능한지 확인하세요.",
+  E_FN_NOT_FOUND: "함수가 등록되지 않았습니다. 모듈 import 또는 오타를 확인하세요.",
+  E_DIV_BY_ZERO: "0으로 나눌 수 없습니다. 분모 검증 (= denom 0) 후 분기하세요.",
+  E_INDEX_OOB: "인덱스가 범위를 벗어났습니다. (length coll) 으로 길이를 먼저 확인하세요.",
+  E_INVALID_FORM: "잘못된 special form 구조입니다. 문법 가이드를 확인하세요.",
+  E_RUNTIME: "런타임 오류. 입력 데이터와 흐름을 점검하세요.",
+  E_PURE_VIOLATION: "^pure/:effects [] 함수에서 side effect가 발견되었습니다. :effects 선언을 추가하거나 effect 호출을 제거하세요.",
+  E_UNDEFINED_VAR: "변수가 정의되지 않았습니다. (define name value) 또는 (let [[name value]] ...) 로 먼저 정의하세요.",
+  E_UNRESOLVED_SYMBOL: "심볼을 찾을 수 없습니다. 함수명 오타, 모듈 import, 또는 변수 정의를 확인하세요.",
+};
+
+export interface FLErrorContext {
+  fn?: string;          // 호출된 함수명
+  expected?: string;    // 기대 타입/갯수
+  got?: string;         // 실제 받은 값/타입/갯수
+  arg?: number;         // 인자 인덱스 (0-based)
+  varName?: string;     // 관련 변수명
+  [key: string]: any;   // 확장
+}
+
+/** FreeLang 런타임 통일 에러 — Phase A에서 throw 지점을 이걸로 통일 */
+export class FLRuntimeError extends ModuleError {
+  constructor(
+    public code: ErrorCode,
+    message: string,
+    public context: FLErrorContext = {},
+    file?: string,
+    line?: number,
+    col?: number,
+    hint?: string
+  ) {
+    super(`[${code}] ${message}`, "runtime", file, line, col, hint ?? RECOVERY_HINTS[code]);
+    this.name = "FLRuntimeError";
+    Object.setPrototypeOf(this, FLRuntimeError.prototype);
+  }
+}
+
+/** Phase Y-1: 변수 미정의 에러 — 스코프 정보 + 유사 이름 추천 포함 */
+export class VariableNotFoundError extends FLRuntimeError {
+  constructor(
+    varName: string,
+    availableVars?: string[],     // 현재 스코프의 정의된 변수들
+    similarVars?: string | string[] | null,  // 유사 이름 추천 (string | string[] | null 모두 허용)
+    file?: string,
+    line?: number,
+    col?: number
+  ) {
+    // string | null → string[] 정규화
+    if (typeof similarVars === "string") similarVars = [similarVars];
+    else if (!Array.isArray(similarVars)) similarVars = [];
+    const contextMsg = [
+      `변수 '$${varName}'이(가) 정의되지 않았습니다.`,
+      availableVars && availableVars.length > 0
+        ? `스코프 내 변수: ${availableVars.slice(0, 5).join(", ")}${availableVars.length > 5 ? " ..." : ""}`
+        : null,
+      similarVars && similarVars.length > 0
+        ? `유사 이름: ${similarVars.slice(0, 3).join(", ")}`
+        : null,
+    ]
+      .filter(Boolean)
+      .join(" | ");
+
+    super(
+      ErrorCodes.UNDEFINED_VAR,
+      contextMsg,
+      {
+        varName,
+        scope: availableVars,
+        suggestions: similarVars,
+      },
+      file,
+      line,
+      col
+    );
+    this.name = "VariableNotFoundError";
+    Object.setPrototypeOf(this, VariableNotFoundError.prototype);
+  }
+}
+
+/** Phase Y-1: 심볼 미해결 에러 */
+export class UnresolvedSymbolError extends FLRuntimeError {
+  constructor(
+    symbol: string,
+    availableSymbols?: string[],
+    similarSymbols?: string[],
+    file?: string,
+    line?: number,
+    col?: number
+  ) {
+    const contextMsg = [
+      `심볼 '${symbol}'을(를) 찾을 수 없습니다.`,
+      similarSymbols && similarSymbols.length > 0
+        ? `유사 이름: ${similarSymbols.slice(0, 3).join(", ")}`
+        : null,
+    ]
+      .filter(Boolean)
+      .join(" | ");
+
+    super(
+      ErrorCodes.UNRESOLVED_SYMBOL,
+      contextMsg,
+      {
+        symbol,
+        suggestions: similarSymbols,
+      },
+      file,
+      line,
+      col
+    );
+    this.name = "UnresolvedSymbolError";
+    Object.setPrototypeOf(this, UnresolvedSymbolError.prototype);
+  }
+}

package/src/ethics-check.ts

@@ -0,0 +1,408 @@
+// ethics-check.ts — FreeLang v9 Phase 147: [ETHICS-CHECK]
+// AI가 자신의 행동/출력을 윤리적으로 자기 검사하는 시스템
+
+export type EthicsFramework = 'utilitarian' | 'deontological' | 'virtue' | 'care' | 'fairness';
+
+export interface EthicsViolation {
+  principle: string;
+  severity: 'low' | 'medium' | 'high' | 'critical';
+  description: string;
+  suggestion: string;
+  framework: EthicsFramework;
+}
+
+export interface EthicsCheckResult {
+  subject: string;          // 검사 대상 설명
+  passed: boolean;
+  violations: EthicsViolation[];
+  score: number;            // 0~1 (1이 완전히 윤리적)
+  frameworks: Record<EthicsFramework, { passed: boolean; score: number }>;
+  recommendation: string;
+  requiresHumanReview: boolean;
+}
+
+export interface EthicsPrinciple {
+  id: string;
+  name: string;
+  description: string;
+  framework: EthicsFramework;
+  check: (subject: string, context: Record<string, unknown>) => { passed: boolean; reason: string };
+}
+
+// 기본 원칙 정의들
+
+const doNoHarmPrinciple: EthicsPrinciple = {
+  id: 'do-no-harm',
+  name: '해악 금지',
+  description: '행동이나 출력이 인간이나 생명체에 해를 끼쳐서는 안 된다',
+  framework: 'deontological',
+  check: (subject: string, _context: Record<string, unknown>) => {
+    const harmKeywords = [
+      'kill', 'murder', 'harm', 'hurt', 'injure', 'damage', 'destroy',
+      '죽', '살인', '해치', '폭력', '폭발', '폭탄', '독', '자살',
+      'weapon', 'bomb', 'poison', 'explosive', 'attack', 'violence',
+      'illegal', 'steal', 'theft', 'fraud', 'abuse',
+    ];
+    const lower = subject.toLowerCase();
+    const found = harmKeywords.some(kw => lower.includes(kw));
+    return {
+      passed: !found,
+      reason: found
+        ? `해악을 초래할 수 있는 내용이 감지되었습니다: "${subject.substring(0, 50)}"`
+        : '해악 금지 원칙을 준수합니다',
+    };
+  },
+};
+
+const fairnessPrinciple: EthicsPrinciple = {
+  id: 'fairness',
+  name: '공정성',
+  description: '모든 개인과 집단을 공정하게 대우해야 한다',
+  framework: 'fairness',
+  check: (subject: string, _context: Record<string, unknown>) => {
+    const discriminationKeywords = [
+      'racist', 'sexist', 'discriminat', 'prejudice', 'bias against',
+      '차별', '편견', '혐오', '인종차별', '성차별', '장애인 차별',
+      'inferior', 'superior race', 'stereotype',
+    ];
+    const lower = subject.toLowerCase();
+    const found = discriminationKeywords.some(kw => lower.includes(kw));
+    return {
+      passed: !found,
+      reason: found
+        ? '차별 또는 편견이 감지되었습니다'
+        : '공정성 원칙을 준수합니다',
+    };
+  },
+};
+
+const transparencyPrinciple: EthicsPrinciple = {
+  id: 'transparency',
+  name: '투명성',
+  description: 'AI 시스템의 의사결정 과정은 투명하고 설명 가능해야 한다',
+  framework: 'virtue',
+  check: (subject: string, context: Record<string, unknown>) => {
+    // 숨김이나 기만 관련 패턴 검사
+    const deceptionKeywords = [
+      'deceive', 'lie', 'hide', 'conceal', 'manipulate', 'trick', 'mislead',
+      '속이', '거짓', '숨기', '조작', '기만', '사기',
+    ];
+    const lower = subject.toLowerCase();
+    const found = deceptionKeywords.some(kw => lower.includes(kw));
+    // context에 hiding flag가 있으면 위반
+    const hidingContext = context['hiding'] === true || context['deceptive'] === true;
+    return {
+      passed: !found && !hidingContext,
+      reason: (found || hidingContext)
+        ? '투명성을 해치는 내용이 감지되었습니다'
+        : '투명성 원칙을 준수합니다',
+    };
+  },
+};
+
+const privacyPrinciple: EthicsPrinciple = {
+  id: 'privacy',
+  name: '개인정보 보호',
+  description: '개인의 프라이버시와 데이터 보호 권리를 존중해야 한다',
+  framework: 'care',
+  check: (subject: string, context: Record<string, unknown>) => {
+    const privacyKeywords = [
+      'personal data', 'private information', 'ssn', 'social security',
+      'credit card', 'password', 'expose private',
+      '주민번호', '개인정보 유출', '비밀번호 노출', '사생활 침해',
+      'doxx', 'doxing', 'stalk',
+    ];
+    const lower = subject.toLowerCase();
+    const found = privacyKeywords.some(kw => lower.includes(kw));
+    const privacyViolation = context['privacy_violation'] === true;
+    return {
+      passed: !found && !privacyViolation,
+      reason: (found || privacyViolation)
+        ? '개인정보 보호 위반이 감지되었습니다'
+        : '개인정보 보호 원칙을 준수합니다',
+    };
+  },
+};
+
+const autonomyPrinciple: EthicsPrinciple = {
+  id: 'autonomy',
+  name: '자율성 존중',
+  description: '인간의 자율적 의사결정 능력을 존중하고 최대 이익을 추구한다',
+  framework: 'utilitarian',
+  check: (subject: string, context: Record<string, unknown>) => {
+    const coercionKeywords = [
+      'force', 'coerce', 'compel', 'override human', 'bypass consent',
+      '강제', '동의 없이', '허락 없이', '자율성 침해', '인간 무시',
+      'manipulate user', 'control human', 'override decision',
+    ];
+    const lower = subject.toLowerCase();
+    const found = coercionKeywords.some(kw => lower.includes(kw));
+    const autonomyViolation = context['autonomy_violation'] === true;
+    return {
+      passed: !found && !autonomyViolation,
+      reason: (found || autonomyViolation)
+        ? '인간의 자율성을 침해하는 내용이 감지되었습니다'
+        : '자율성 존중 원칙을 준수합니다',
+    };
+  },
+};
+
+const DEFAULT_PRINCIPLES: EthicsPrinciple[] = [
+  doNoHarmPrinciple,
+  fairnessPrinciple,
+  transparencyPrinciple,
+  privacyPrinciple,
+  autonomyPrinciple,
+];
+
+export class EthicsChecker {
+  private principles: EthicsPrinciple[];
+
+  constructor() {
+    this.principles = [...DEFAULT_PRINCIPLES];
+  }
+
+  // 기본 원칙 추가
+  addPrinciple(principle: EthicsPrinciple): void {
+    this.principles.push(principle);
+  }
+
+  // 윤리 검사
+  check(
+    subject: string,
+    context: Record<string, unknown> = {}
+  ): EthicsCheckResult {
+    const violations: EthicsViolation[] = [];
+    const frameworkResults: Record<string, { passed: boolean; score: number; violations: number }> = {
+      utilitarian: { passed: true, score: 1.0, violations: 0 },
+      deontological: { passed: true, score: 1.0, violations: 0 },
+      virtue: { passed: true, score: 1.0, violations: 0 },
+      care: { passed: true, score: 1.0, violations: 0 },
+      fairness: { passed: true, score: 1.0, violations: 0 },
+    };
+
+    for (const principle of this.principles) {
+      const result = principle.check(subject, context);
+      if (!result.passed) {
+        const severity = this._determineSeverity(subject, principle, context);
+        const violation: EthicsViolation = {
+          principle: principle.name,
+          severity,
+          description: result.reason,
+          suggestion: this._generateSuggestion(principle, subject),
+          framework: principle.framework,
+        };
+        violations.push(violation);
+        frameworkResults[principle.framework].passed = false;
+        frameworkResults[principle.framework].violations += 1;
+      }
+    }
+
+    // 프레임워크별 점수 계산
+    const principlesByFramework: Record<string, number> = {
+      utilitarian: 0, deontological: 0, virtue: 0, care: 0, fairness: 0,
+    };
+    for (const p of this.principles) {
+      principlesByFramework[p.framework] = (principlesByFramework[p.framework] || 0) + 1;
+    }
+    for (const fw of Object.keys(frameworkResults)) {
+      const total = principlesByFramework[fw] || 1;
+      const violated = frameworkResults[fw].violations;
+      frameworkResults[fw].score = Math.max(0, 1 - violated / total);
+    }
+
+    // 전체 점수 계산 (severity 가중치 적용)
+    let penaltySum = 0;
+    for (const v of violations) {
+      penaltySum += this._severityPenalty(v.severity);
+    }
+    const score = Math.max(0, 1 - penaltySum / Math.max(this.principles.length, 1));
+
+    const passed = violations.length === 0;
+    const hasCritical = violations.some(v => v.severity === 'critical');
+    const hasHigh = violations.some(v => v.severity === 'high');
+    const requiresHumanReview = hasCritical || hasHigh;
+
+    const frameworks: Record<EthicsFramework, { passed: boolean; score: number }> = {
+      utilitarian: { passed: frameworkResults.utilitarian.passed, score: frameworkResults.utilitarian.score },
+      deontological: { passed: frameworkResults.deontological.passed, score: frameworkResults.deontological.score },
+      virtue: { passed: frameworkResults.virtue.passed, score: frameworkResults.virtue.score },
+      care: { passed: frameworkResults.care.passed, score: frameworkResults.care.score },
+      fairness: { passed: frameworkResults.fairness.passed, score: frameworkResults.fairness.score },
+    };
+
+    const recommendation = this._generateRecommendation(passed, violations, score);
+
+    return {
+      subject,
+      passed,
+      violations,
+      score,
+      frameworks,
+      recommendation,
+      requiresHumanReview,
+    };
+  }
+
+  // 특정 프레임워크로만 검사
+  checkByFramework(
+    subject: string,
+    framework: EthicsFramework,
+    context: Record<string, unknown> = {}
+  ): { passed: boolean; score: number; violations: EthicsViolation[] } {
+    const relevantPrinciples = this.principles.filter(p => p.framework === framework);
+    const violations: EthicsViolation[] = [];
+
+    for (const principle of relevantPrinciples) {
+      const result = principle.check(subject, context);
+      if (!result.passed) {
+        const severity = this._determineSeverity(subject, principle, context);
+        violations.push({
+          principle: principle.name,
+          severity,
+          description: result.reason,
+          suggestion: this._generateSuggestion(principle, subject),
+          framework: principle.framework,
+        });
+      }
+    }
+
+    const total = relevantPrinciples.length || 1;
+    const score = Math.max(0, 1 - violations.reduce((sum, v) => sum + this._severityPenalty(v.severity), 0) / total);
+
+    return {
+      passed: violations.length === 0,
+      score,
+      violations,
+    };
+  }
+
+  // 위반 없는지 빠른 확인
+  isEthical(subject: string, context: Record<string, unknown> = {}): boolean {
+    for (const principle of this.principles) {
+      const result = principle.check(subject, context);
+      if (!result.passed) return false;
+    }
+    return true;
+  }
+
+  // 윤리적 대안 제시
+  suggestEthicalAlternative(
+    subject: string,
+    violations: EthicsViolation[]
+  ): string {
+    if (violations.length === 0) {
+      return `"${subject.substring(0, 50)}"은(는) 이미 윤리적입니다. 변경이 필요하지 않습니다.`;
+    }
+
+    const suggestions: string[] = [];
+    const frameworks = new Set(violations.map(v => v.framework));
+
+    for (const v of violations) {
+      suggestions.push(`• [${v.framework}] ${v.suggestion}`);
+    }
+
+    const frameworkAdvice: string[] = [];
+    if (frameworks.has('deontological')) frameworkAdvice.push('의무론적 관점: 절대적 해악을 제거하십시오');
+    if (frameworks.has('utilitarian')) frameworkAdvice.push('공리주의적 관점: 최대 다수의 최대 이익을 추구하십시오');
+    if (frameworks.has('virtue')) frameworkAdvice.push('덕 윤리 관점: 투명하고 정직한 방식을 택하십시오');
+    if (frameworks.has('care')) frameworkAdvice.push('돌봄 윤리 관점: 취약한 개인의 권리를 보호하십시오');
+    if (frameworks.has('fairness')) frameworkAdvice.push('공정성 관점: 모든 집단을 동등하게 대우하십시오');
+
+    return [
+      `윤리적 대안 제안 (${violations.length}개 위반):`,
+      ...suggestions,
+      '',
+      '프레임워크별 권고사항:',
+      ...frameworkAdvice,
+      '',
+      '권장: 위 사항들을 반영하여 내용을 수정하거나 전문가의 검토를 받으십시오.',
+    ].join('\n');
+  }
+
+  // 리스크 레벨
+  riskLevel(result: EthicsCheckResult): 'none' | 'low' | 'medium' | 'high' | 'critical' {
+    if (result.violations.length === 0) return 'none';
+
+    const hasCritical = result.violations.some(v => v.severity === 'critical');
+    if (hasCritical) return 'critical';
+
+    const hasHigh = result.violations.some(v => v.severity === 'high');
+    if (hasHigh) return 'high';
+
+    const hasMedium = result.violations.some(v => v.severity === 'medium');
+    if (hasMedium) return 'medium';
+
+    return 'low';
+  }
+
+  private _determineSeverity(
+    subject: string,
+    principle: EthicsPrinciple,
+    context: Record<string, unknown>
+  ): 'low' | 'medium' | 'high' | 'critical' {
+    const lower = subject.toLowerCase();
+    // critical: 심각한 물리적 해악, 생명 위협
+    const criticalKeywords = ['kill', 'murder', 'bomb', 'explosive', '살인', '폭탄', '자살'];
+    if (criticalKeywords.some(kw => lower.includes(kw))) return 'critical';
+
+    // high: 심각한 개인정보 침해, 차별
+    const highKeywords = ['doxx', 'doxing', 'stalk', 'racist', 'sexist', '주민번호', '사기'];
+    if (highKeywords.some(kw => lower.includes(kw))) return 'high';
+
+    // 컨텍스트에서 severity 힌트
+    const ctxSeverity = context['severity'] as string | undefined;
+    if (ctxSeverity === 'critical') return 'critical';
+    if (ctxSeverity === 'high') return 'high';
+    if (ctxSeverity === 'medium') return 'medium';
+
+    // medium: 중등도 위반
+    const mediumKeywords = ['harm', 'hurt', 'damage', '해치', '손해', 'manipulate'];
+    if (mediumKeywords.some(kw => lower.includes(kw))) return 'medium';
+
+    return 'low';
+  }
+
+  private _generateSuggestion(principle: EthicsPrinciple, subject: string): string {
+    const suggestions: Record<string, string> = {
+      'do-no-harm': '해악을 초래하지 않는 방향으로 내용을 수정하거나, 유해한 요소를 제거하십시오',
+      'fairness': '모든 집단을 공평하게 표현하고, 차별적 언어나 관점을 제거하십시오',
+      'transparency': '의사결정 과정을 명확히 설명하고, 숨김이나 기만 요소를 제거하십시오',
+      'privacy': '개인식별 정보를 익명화하고, 동의 없는 개인정보 처리를 중단하십시오',
+      'autonomy': '사용자의 자유로운 선택을 보장하고, 강제나 조작 요소를 제거하십시오',
+    };
+    return suggestions[principle.id] || `${principle.name} 원칙에 맞게 내용을 수정하십시오`;
+  }
+
+  private _severityPenalty(severity: 'low' | 'medium' | 'high' | 'critical'): number {
+    const penalties: Record<string, number> = {
+      low: 0.1,
+      medium: 0.25,
+      high: 0.5,
+      critical: 1.0,
+    };
+    return penalties[severity] || 0.1;
+  }
+
+  private _generateRecommendation(passed: boolean, violations: EthicsViolation[], score: number): string {
+    if (passed) {
+      return score >= 0.9
+        ? '모든 윤리 원칙을 준수합니다. 안전하게 사용할 수 있습니다.'
+        : '주요 원칙은 통과했으나 일부 개선 여지가 있습니다.';
+    }
+
+    const criticalCount = violations.filter(v => v.severity === 'critical').length;
+    const highCount = violations.filter(v => v.severity === 'high').length;
+
+    if (criticalCount > 0) {
+      return `심각한 윤리 위반 ${criticalCount}건이 발견되었습니다. 즉시 사용을 중단하고 전문가 검토가 필요합니다.`;
+    }
+    if (highCount > 0) {
+      return `중대한 윤리 위반 ${highCount}건이 발견되었습니다. 인간 전문가의 검토가 권장됩니다.`;
+    }
+    return `경미한 윤리 위반 ${violations.length}건이 발견되었습니다. 제안 사항을 참고하여 수정하십시오.`;
+  }
+}
+
+// 전역 인스턴스
+export const globalEthics = new EthicsChecker();