argus-decision-mcp 1.0.0

package/dist/lib/review/lenses.js

@@ -0,0 +1,132 @@
+/**
+ * Lens library — 9 MVP lenses (design doc §"Lens Library"). A lens is a
+ * structured review unit, NOT a prompt fragment: it declares what it applies
+ * to, what it asks, and which sentences count as failure (generic advice).
+ *
+ * "Argus의 품질은 좋은 lens를 많이 만드는 것보다 맞는 lens를 고르는 것에서 나온다."
+ * So keep this list small and let routing.ts choose.
+ */
+export const LENS_VERSION = '1';
+export const LENSES = {
+    core_question: {
+        id: 'core_question',
+        version: LENS_VERSION,
+        label: '핵심 질문',
+        applies_to: {},
+        purpose: '이 문서가 겉으로 묻는 질문과 실제로 결정해야 하는 질문이 같은지 가른다.',
+        input_requirements: ['core_question', 'decision_points'],
+        review_questions: [
+            '이 문서가 진짜로 결정하려는 것은 무엇인가?',
+            '겉 질문과 실제 결정이 다른가?',
+        ],
+        failure_modes: ['목표를 명확히 하세요', '무엇을 원하는지 정의하세요'],
+    },
+    claim_evidence: {
+        id: 'claim_evidence',
+        version: LENS_VERSION,
+        label: '주장-근거',
+        applies_to: {},
+        purpose: '핵심 주장마다 근거가 원문 안에 있는지, 아니면 추정인지 가른다.',
+        input_requirements: ['main_claims', 'evidence_items'],
+        review_questions: [
+            '이 주장의 근거가 문서 안에 있는가, 밖에서 끌어온 추정인가?',
+            '근거 없이 단정한 수치/사실은 어느 것인가?',
+        ],
+        failure_modes: ['근거를 더 조사하세요', '데이터를 보강하세요'],
+    },
+    hidden_assumption: {
+        id: 'hidden_assumption',
+        version: LENS_VERSION,
+        label: '숨은 가정',
+        applies_to: {},
+        purpose: '문서가 말하지 않았지만 의존하는 가정과, 그것이 틀렸을 때 무너지는 것을 짚는다.',
+        input_requirements: ['assumptions'],
+        review_questions: [
+            '이 결론이 성립하려면 참이어야 하는, 말하지 않은 가정은 무엇인가?',
+            '그 가정이 틀리면 무엇이 무너지는가?',
+        ],
+        failure_modes: ['가정을 검토하세요', '리스크를 고려하세요'],
+    },
+    human_judgment: {
+        id: 'human_judgment',
+        version: LENS_VERSION,
+        label: '사람이 판단할 것',
+        applies_to: {},
+        purpose: 'AI나 문서가 대신 결정하면 안 되는, 사람이 직접 lean을 가져야 하는 지점을 분리한다.',
+        input_requirements: ['decision_points'],
+        review_questions: [
+            '이 문서에서 사람만 판단할 수 있는 항목은 무엇인가?',
+            '왜 이것은 모델이나 근거로 대체할 수 없는가?',
+        ],
+        failure_modes: ['신중하게 결정하세요', '전문가와 상의하세요'],
+    },
+    stakeholder_objection: {
+        id: 'stakeholder_objection',
+        version: LENS_VERSION,
+        label: '이해관계자 반론',
+        applies_to: { min_stakes: 'medium' },
+        purpose: '핵심 의사결정자가 이 문서의 특정 claim에 가장 먼저 던질 반론을 미리 꺼낸다.',
+        input_requirements: ['stakeholders', 'main_claims'],
+        review_questions: [
+            '예산/승인을 쥔 사람이 어느 claim에서 먼저 "근거가 뭐냐"고 물을까?',
+            '그 반론은 문서의 어느 문장에 걸리는가?',
+        ],
+        failure_modes: ['이해관계자를 고려하세요', '반대 의견에 대비하세요'],
+    },
+    execution_risk: {
+        id: 'execution_risk',
+        version: LENS_VERSION,
+        label: '실행 리스크',
+        applies_to: {},
+        purpose: '실행 단계에서 막힐 dependency, sequencing, owner gap을 문서 안에서 찾는다.',
+        input_requirements: ['decision_points', 'tradeoffs'],
+        review_questions: [
+            '실행 순서상 먼저 풀리지 않으면 막히는 dependency는 무엇인가?',
+            '누가 책임지는지 비어 있는 지점은 어디인가?',
+        ],
+        failure_modes: ['실행 계획을 세우세요', '일정을 관리하세요'],
+    },
+    reversibility: {
+        id: 'reversibility',
+        version: LENS_VERSION,
+        label: '되돌릴 수 있는가',
+        applies_to: { document_type: ['rfc', 'adr', 'strategy_memo', 'proposal'] },
+        purpose: '이 결정이 되돌릴 수 있는지, 되돌릴 수 없다면 어떤 proof가 더 필요한지 가른다.',
+        input_requirements: ['decision_points'],
+        review_questions: [
+            '이 결정은 되돌릴 수 있는가, 일방향 문인가?',
+            '되돌릴 수 없다면 지금 부족한 proof는 무엇인가?',
+        ],
+        failure_modes: ['위험을 관리하세요', '신중히 진행하세요'],
+    },
+    falsifiable_followup: {
+        id: 'falsifiable_followup',
+        version: LENS_VERSION,
+        label: '반증 가능한 후속',
+        applies_to: {},
+        purpose: '나중에 현실이 pass/fail로 답할 수 있는 predicate를 1-3개 만든다.',
+        input_requirements: ['core_question', 'main_claims'],
+        review_questions: [
+            '언제 무엇을 보면 이 판단이 맞았다/틀렸다고 할 수 있는가?',
+            'pass 조건과 fail 조건, check-by는 무엇인가?',
+        ],
+        failure_modes: ['결과를 추적하세요', '지표를 모니터링하세요'],
+    },
+    deck_narrative: {
+        id: 'deck_narrative',
+        version: LENS_VERSION,
+        label: '덱 설득 흐름',
+        applies_to: { deck_only: true },
+        purpose: 'deck이 어떤 순서로 청중을 설득하는지, 핵심 ask가 언제 드러나고 어디서 논리가 점프하는지 본다.',
+        input_requirements: ['main_claims'],
+        review_questions: [
+            '첫 3장 안에 핵심 질문과 ask가 드러나는가?',
+            '핵심 claim이 처음 등장하는 슬라이드와 근거를 받는 슬라이드가 연결되는가?',
+        ],
+        failure_modes: ['슬라이드를 정리하세요', '스토리를 다듬으세요'],
+    },
+};
+export function getLens(id) {
+    return LENSES[id];
+}
+export const ALL_LENS_IDS = Object.keys(LENSES);

package/dist/lib/review/prompts.js

@@ -0,0 +1,155 @@
+/**
+ * Single source of truth for the review pipeline's prompts (CLAUDE.md
+ * §"Single Source of Truth for Prompts"). Each pipeline stage has a distinct
+ * role + output schema (design doc §"LLM Handoff Protocol"):
+ *   1. Extraction  → profile + Document Judgment Map (no evaluation)
+ *   2. Lens Review → one lens's findings only (anchored, no global conclusion)
+ *   3. Synthesis   → compress into receipt fields (no "proceed" tilt)
+ *
+ * Hard rules baked into every prompt:
+ *   - cite the source by unit_id (anchors) — an unanchored finding is worthless.
+ *   - no generic advice ("리스크를 고려하세요") — must reference a specific claim.
+ *   - never decide for the user; never invent facts not in the units.
+ *   - Korean output, pure JSON.
+ */
+const SPINE = `너는 Argus의 판단 검수기다. 사용자의 결정을 대신 내리지 않는다.
+- 절대 "이 전략은 틀렸다", "진행하세요" 같은 평결을 내지 않는다.
+- 모든 지적은 문서의 특정 문장에 연결한다. 근거 위치 없는 지적은 내지 않는다.
+- 사람이 읽는 문장(title·detail·rationale)에서는 위치를 사람이 읽는 표현으로만 지칭한다
+  (예: "결론 섹션의 착수 문장", "slide 4의 시장규모 주장", "3번째 문단"). unit_id 같은 내부
+  식별자(u_...)를 문장에 절대 노출하지 않는다. unit_id는 오직 unit_ids 배열에만 넣는다.
+- "리스크를 고려하세요", "더 조사하세요" 같은 일반론은 금지한다. 무엇을 확인할지 구체적으로 쓴다.
+- 원문에 없는 사실을 지어내지 않는다.
+- 출력은 순수 JSON. 마크다운/설명 없이 { 로 시작해 } 로 끝난다. 한국어로 쓴다.`;
+export function renderUnits(units, limit) {
+    return units
+        .slice(0, limit)
+        .map((u) => {
+        const a = u.source_anchor;
+        const loc = a.slide !== undefined
+            ? `slide ${a.slide}`
+            : a.section_path?.length
+                ? a.section_path.join(' › ')
+                : a.line_start !== undefined
+                    ? `L${a.line_start}`
+                    : '';
+        return `[${u.unit_id}] (${u.kind}${loc ? ' · ' + loc : ''}) ${u.text}`;
+    })
+        .join('\n');
+}
+// ---------------------------------------------------------------------------
+// 1. Extraction: Canonical Artifact → profile + Document Judgment Map
+// ---------------------------------------------------------------------------
+export function buildExtractionPrompt(units, ctx, unitLimit) {
+    const concerns = ctx.concerns?.length ? `사용자 관심사: ${ctx.concerns.join(', ')}.` : '';
+    const hints = [
+        ctx.audience_hint && `대상 독자 힌트: ${ctx.audience_hint}`,
+        ctx.decision_wanted && `얻으려는 결정: ${ctx.decision_wanted}`,
+        ctx.biggest_worry && `가장 불안한 부분: ${ctx.biggest_worry}`,
+    ]
+        .filter(Boolean)
+        .join('\n');
+    const system = `${SPINE}
+
+이번 단계는 "추출"이다. 평가/비판/추천은 하지 않는다. 문서를 판단 가능한 지도로만 바꾼다.
+document_type, intent, audience, stakes, artifact_maturity를 추론하고, 확신이 낮으면 source_confidence를 낮게 준다.
+각 항목은 반드시 관련 unit_id 배열을 포함한다.`;
+    const user = `아래는 검수할 문서의 단위(unit)들이다. 각 줄은 [unit_id] (종류 · 위치) 텍스트 형식이다.
+
+${renderUnits(units, unitLimit)}
+
+${hints}
+${concerns}
+
+다음 JSON을 출력하라:
+{
+  "profile": { "document_type": "...", "intent": "...", "audience": "...", "stakes": "low|medium|high", "artifact_maturity": "...", "source_confidence": 0.0 },
+  "core_question": "이 문서가 실제로 결정해야 하는 질문",
+  "explicit_recommendation": "문서가 겉으로 미는 결론(없으면 생략)",
+  "implicit_recommendation": "은연중 미는 결론(없으면 생략)",
+  "main_claims": [ { "text": "...", "status": "supported|weak|unsupported|human_check|contradicted", "unit_ids": ["..."], "rationale": "이 상태로 판단한 근거(원문 기준)", "evidence_needed": "이 주장을 확정하려면 무엇을 확인해야 하는가(없으면 생략)", "fix_suggestion": "이 문장 자체를 어떻게 보강할지 한 줄(선택, 없으면 생략)" } ],
+  "evidence_items": [ { "text": "...", "unit_ids": ["..."], "kind": "internal|external_cited|asserted" } ],
+  "assumptions": [ { "text": "말하지 않은 가정", "unit_ids": ["..."], "if_false": "틀리면 무너지는 것" } ],
+  "tradeoffs": [ { "text": "...", "unit_ids": ["..."] } ],
+  "stakeholders": [ { "role": "...", "likely_objection": "...", "unit_ids": ["..."] } ],
+  "open_questions": [ { "text": "...", "unit_ids": ["..."] } ],
+  "decision_points": [ { "text": "...", "human_only": true, "unit_ids": ["..."] } ],
+  "missing_sections": [ { "label": "...", "why_it_matters": "..." } ]
+}`;
+    return { system, user };
+}
+// ---------------------------------------------------------------------------
+// 2. Lens Review: one lens → findings only
+// ---------------------------------------------------------------------------
+export function buildLensPrompt(lens, mapSummary, units, unitLimit) {
+    const system = `${SPINE}
+
+너는 "${lens.label}" 렌즈다. 목적: ${lens.purpose}
+이 렌즈의 검토 질문:
+${lens.review_questions.map((q) => `- ${q}`).join('\n')}
+
+금지된 출력(이런 문장을 내면 실패로 간주한다):
+${lens.failure_modes.map((f) => `- "${f}"`).join('\n')}
+
+너의 렌즈에 해당하는 finding만 낸다. 전체 결론이나 다른 렌즈의 영역은 건드리지 않는다.
+finding이 없으면 빈 배열을 낸다(억지로 만들지 않는다).`;
+    const user = `문서 판단 지도 요약:
+${mapSummary}
+
+원문 단위:
+${renderUnits(units, unitLimit)}
+
+다음 JSON을 출력하라:
+{
+  "findings": [
+    {
+      "title": "특정 claim에 걸린 짧은 제목 (예: slide 4 시장규모 주장에 근거 없음)",
+      "detail": "무엇이 문제인지 원문 기준으로",
+      "severity": "minor|caution|critical",
+      "confidence": "low|medium|high",
+      "suggested_action": "무엇을 확인/보완할지 구체적으로 (일반론 금지)",
+      "unit_ids": ["관련 unit_id (필수, 하나 이상)"]
+    }
+  ]
+}`;
+    return { system, user };
+}
+// ---------------------------------------------------------------------------
+// 3. Synthesis: lens findings + map → receipt-level fields
+// ---------------------------------------------------------------------------
+export function buildSynthesisPrompt(mapSummary, findingsSummary, ctx, today) {
+    const system = `${SPINE}
+
+이번 단계는 "종합"이다. 렌즈 결과를 Judgment Receipt 필드로 압축한다.
+- current_heading은 중립적 방향 한 줄이다. "진행하세요" 같은 평결이 아니다.
+- judgment_obligations는 사람이 직접 판단해야 하는 항목이다. AI가 대신 결론내지 않는다.
+- 사용자가 결론을 냈다고 말하지 않는다.
+- follow-up predicate는 나중에 현실이 pass/fail로 답할 수 있어야 한다. check_by는 ${today} 이후의 미래 날짜(YYYY-MM-DD)로 제안한다.`;
+    const worry = ctx.biggest_worry ? `사용자가 가장 불안해한 부분: ${ctx.biggest_worry}` : '';
+    const user = `문서 판단 지도 요약:
+${mapSummary}
+
+렌즈 finding 요약:
+${findingsSummary}
+${worry}
+
+다음 JSON을 출력하라:
+{
+  "core_question": "한 문장으로 다듬은 핵심 판단 질문",
+  "current_heading": "지금 이 문서의 중립적 방향 한 줄 (평결 아님)",
+  "judgment_obligations": [
+    {
+      "statement": "사람이 책임지고 판단해야 할 항목",
+      "owner": "사용자",
+      "why_human": "왜 모델/근거로 대체할 수 없는가",
+      "decision_needed_by": "언제까지 (없으면 생략)",
+      "evidence_needed": "무엇을 보면 판단할 수 있는가",
+      "unit_ids": ["..."]
+    }
+  ],
+  "followups": [
+    { "predicate": "현실이 답할 예측", "pass_condition": "맞았다고 볼 조건", "fail_condition": "틀렸다고 볼 조건", "check_by": "YYYY-MM-DD" }
+  ]
+}`;
+    return { system, user };
+}

package/dist/lib/review/render.js

@@ -0,0 +1,77 @@
+/**
+ * Renders a Judgment Receipt as shareable markdown (design doc §"receipt export
+ * markdown"). Same object powers the webapp view and the MCP output, so this is
+ * the single text projection. It shows findings + obligations + the neutral
+ * heading — never an AI verdict on the decision.
+ */
+export function receiptToMarkdown(r) {
+    const L = [];
+    L.push(`# Judgment Receipt — ${r.source_title}`);
+    L.push('');
+    L.push(`- 상태: ${r.state} · 검수 가능성: ${r.reviewability.score}/100`);
+    L.push(`- 문서 유형: ${r.profile.document_type} · 이해관계: ${r.profile.stakes}`);
+    // Coverage travels with the shared receipt — a partial review must never read
+    // as a full one, even when copied out of the app.
+    if (r.coverage && r.coverage.band !== 'full' && r.coverage.notes.length) {
+        L.push(`- 검수 범위: ${r.coverage.notes.join(' ')}`);
+    }
+    L.push('');
+    L.push('## 핵심 판단');
+    L.push(r.core_question || '(핵심 질문 미검출)');
+    L.push('');
+    if (r.judgment_obligations.length) {
+        L.push('## 사람이 직접 판단해야 할 것');
+        r.judgment_obligations.forEach((o, i) => {
+            L.push(`${i + 1}. ${o.statement}`);
+            if (o.why_human)
+                L.push(`   - 왜 사람인가: ${o.why_human}`);
+            if (o.evidence_needed)
+                L.push(`   - 확인할 근거: ${o.evidence_needed}`);
+        });
+        L.push('');
+    }
+    const top = r.findings.slice(0, 5);
+    if (top.length) {
+        L.push('## 주요 발견');
+        top.forEach((f) => {
+            L.push(`- [${f.severity}] ${f.title}${anchorHint(f.anchors)}`);
+            if (f.suggested_action)
+                L.push(`  - 확인: ${f.suggested_action}`);
+        });
+        L.push('');
+    }
+    if (r.hidden_assumptions.length) {
+        L.push('## 그대로 진행하면 위험한 가정');
+        r.hidden_assumptions.slice(0, 3).forEach((a) => {
+            L.push(`- ${a.text}${a.if_false ? ` → 틀리면: ${a.if_false}` : ''}`);
+        });
+        L.push('');
+    }
+    if (r.falsifiable_followups.length) {
+        L.push('## 현실이 답할 후속 예측');
+        r.falsifiable_followups.forEach((f) => {
+            L.push(`- ${f.predicate} (확인일 ${f.check_by})`);
+            if (f.pass_condition)
+                L.push(`  - 맞음: ${f.pass_condition}`);
+            if (f.fail_condition)
+                L.push(`  - 틀림: ${f.fail_condition}`);
+        });
+        L.push('');
+    }
+    L.push('---');
+    L.push(`적용 렌즈: ${r.routing.selected.join(', ')}`);
+    L.push('AI는 이 결정을 대신 판단하지 않았습니다. 판단은 당신의 몫입니다.');
+    return L.join('\n');
+}
+function anchorHint(anchors) {
+    const a = anchors[0];
+    if (!a)
+        return '';
+    if (a.slide !== undefined)
+        return ` (slide ${a.slide})`;
+    if (a.section_path?.length)
+        return ` (${a.section_path.join(' › ')})`;
+    if (a.line_start !== undefined)
+        return ` (L${a.line_start})`;
+    return '';
+}

package/dist/lib/review/reviewability.js

@@ -0,0 +1,83 @@
+/**
+ * Reviewability scoring (design doc §"Reviewability Score가 필요하다").
+ *
+ * Not every document can be reviewed to the same depth. Argus judges
+ * reviewability FIRST so it never speaks confidently over a scanned PDF or an
+ * image-only deck. Bands drive the UX:
+ *   80–100 normal · 60–79 caveated · 40–59 limited · <40 no full receipt.
+ *
+ * The score is computed in two passes: a pre-review estimate from the artifact
+ * alone (extraction / structure / anchor coverage), then finalized after the
+ * judgment map exists (decision clarity / evidence availability).
+ */
+import { reviewabilityBand, } from './schema.js';
+const EXTRACTION_WEIGHT = {
+    high: 100,
+    medium: 70,
+    low: 35,
+    unsupported: 0,
+};
+export function scoreReviewability(artifact, map) {
+    const reasons = [];
+    // 1. extraction
+    const extraction = EXTRACTION_WEIGHT[artifact.extraction_quality];
+    if (artifact.extraction_quality === 'unsupported') {
+        reasons.push('텍스트를 추출하지 못해 전체 검수가 어렵습니다.');
+    }
+    else if (artifact.extraction_quality === 'low') {
+        reasons.push('텍스트 추출 품질이 낮습니다.');
+    }
+    // 2. structure — headings/sections/slides give the reviewer scaffolding
+    const s = artifact.detected_structure;
+    const structuralUnits = (s.heading_count ?? 0) + (s.slide_count ?? 0) + (s.section_count ?? 0);
+    const structure = clamp(structuralUnits === 0 ? 40 : 60 + Math.min(40, structuralUnits * 8));
+    if (structuralUnits === 0 && artifact.units.length > 0) {
+        reasons.push('구조(제목/섹션)가 없어 근거 위치를 짚기 어렵습니다.');
+    }
+    // 3. anchor coverage — share of units that carry a usable anchor
+    const anchored = artifact.units.filter((u) => hasAnchor(u.source_anchor)).length;
+    const anchor_coverage = artifact.units.length === 0 ? 0 : Math.round((anchored / artifact.units.length) * 100);
+    // 4/5. decision clarity + evidence availability (need the map)
+    let decision_clarity = 50;
+    let evidence_availability = 50;
+    if (map) {
+        const hasCore = !!map.core_question && map.core_question.length > 8;
+        const decisionPoints = map.decision_points.length;
+        decision_clarity = clamp((hasCore ? 55 : 20) + Math.min(45, decisionPoints * 15));
+        if (!hasCore)
+            reasons.push('문서에서 결정할 질문이 뚜렷하지 않습니다.');
+        const claims = map.main_claims.length || 1;
+        const withEvidence = map.main_claims.filter((c) => c.anchors.length > 0 || c.status === 'supported').length;
+        evidence_availability = clamp(Math.round((withEvidence / claims) * 100));
+    }
+    const score = Math.round(extraction * 0.35 +
+        structure * 0.15 +
+        anchor_coverage * 0.15 +
+        decision_clarity * 0.2 +
+        evidence_availability * 0.15);
+    const band = reviewabilityBand(score);
+    if (band === 'insufficient') {
+        reasons.push('전체 receipt 대신 "무엇이 빠졌는지"를 먼저 보여줍니다.');
+    }
+    else if (band === 'limited') {
+        reasons.push('제한적으로만 검수하고 부족한 맥락을 요청합니다.');
+    }
+    return {
+        score,
+        extraction,
+        structure,
+        decision_clarity,
+        evidence_availability,
+        anchor_coverage,
+        reasons,
+    };
+}
+function hasAnchor(a) {
+    return (a.line_start !== undefined ||
+        a.page !== undefined ||
+        a.slide !== undefined ||
+        (a.section_path !== undefined && a.section_path.length > 0));
+}
+function clamp(n) {
+    return Math.max(0, Math.min(100, Math.round(n)));
+}

package/dist/lib/review/routing.js

@@ -0,0 +1,147 @@
+/**
+ * Dynamic lens routing (design doc §"Dynamic Lens Routing").
+ *
+ * "Argus의 품질은 좋은 lens를 많이 만드는 것보다 맞는 lens를 고르는 것에서 나온다."
+ * Routing is deterministic and testable: it reads the profile + the deck flag +
+ * the user's concern chips and returns which lenses run, which are skipped (with
+ * a reason), and a user-facing disclosure line — the routing is never hidden.
+ */
+import { LENSES, ALL_LENS_IDS } from './lenses.js';
+const STAKES_ORDER = { low: 0, medium: 1, high: 2 };
+/** Lenses that always run — the judgment spine of any review. */
+const BASE = [
+    'core_question',
+    'claim_evidence',
+    'hidden_assumption',
+    'human_judgment',
+    'falsifiable_followup',
+];
+const CONCERN_TO_LENS = {
+    strategic_fit: ['core_question', 'hidden_assumption'],
+    evidence: ['claim_evidence'],
+    stakeholder_objection: ['stakeholder_objection'],
+    execution_risk: ['execution_risk'],
+    ai_answer_trust: ['claim_evidence', 'human_judgment'],
+    full_judgment_review: [...ALL_LENS_IDS],
+};
+export function routeLenses(profile, artifact, opts = { maxLensCalls: 7 }) {
+    const isDeck = artifact.detected_structure.is_deck;
+    const concerns = opts.concerns ?? [];
+    // Candidate set: base + profile-driven + concern-driven, filtered by applies_to.
+    const wanted = new Set(BASE);
+    if (isDeck)
+        wanted.add('deck_narrative');
+    if (STAKES_ORDER[profile.stakes] >= STAKES_ORDER.medium)
+        wanted.add('stakeholder_objection');
+    if (profile.intent === 'request_approval' || profile.intent === 'persuade' || profile.intent === 'pitch') {
+        wanted.add('stakeholder_objection');
+    }
+    if (['prd', 'proposal', 'strategy_memo'].includes(profile.document_type))
+        wanted.add('execution_risk');
+    if (['rfc', 'adr', 'strategy_memo', 'proposal'].includes(profile.document_type))
+        wanted.add('reversibility');
+    const concernRequested = new Set();
+    for (const c of concerns)
+        for (const id of CONCERN_TO_LENS[c] ?? []) {
+            wanted.add(id);
+            concernRequested.add(id);
+        }
+    // Keep lenses that pass structural gates (deck/document-type — never bypassed).
+    // Soft gates (stakes/intent/audience/maturity) can be bypassed when the user
+    // explicitly asked for the lens via a concern chip.
+    const matched = [...wanted].filter((id) => appliesStructural(LENSES[id], profile, isDeck) && (concernRequested.has(id) || appliesSoft(LENSES[id], profile)));
+    // Priority: base spine first, then deck/objection/execution, cap at budget.
+    const priority = orderByPriority(matched, concerns);
+    const selected = priority.slice(0, Math.max(1, opts.maxLensCalls));
+    const cutForBudget = priority.slice(selected.length);
+    const skipped = [];
+    for (const id of ALL_LENS_IDS) {
+        if (selected.includes(id))
+            continue;
+        if (cutForBudget.includes(id)) {
+            skipped.push({ id, reason: '분석 예산(렌즈 수) 초과로 이번엔 제외' });
+        }
+        else if (!applies(LENSES[id], profile, isDeck)) {
+            skipped.push({ id, reason: skipReason(id, profile, isDeck) });
+        }
+        else {
+            skipped.push({ id, reason: '이 문서에는 우선순위가 낮아 제외' });
+        }
+    }
+    return { selected, skipped, disclosure: buildDisclosure(selected, profile) };
+}
+/** Structural gates — a lens simply cannot apply to this document shape. */
+export function appliesStructural(lens, profile, isDeck) {
+    const f = lens.applies_to;
+    if (f.deck_only && !isDeck)
+        return false;
+    if (f.document_type && !f.document_type.includes(profile.document_type))
+        return false;
+    return true;
+}
+/** Soft gates — relevance heuristics a user concern may override. */
+export function appliesSoft(lens, profile) {
+    const f = lens.applies_to;
+    if (f.artifact_maturity && !f.artifact_maturity.includes(profile.artifact_maturity))
+        return false;
+    if (f.intent && !f.intent.includes(profile.intent))
+        return false;
+    if (f.audience && !f.audience.includes(profile.audience))
+        return false;
+    if (f.min_stakes && STAKES_ORDER[profile.stakes] < STAKES_ORDER[f.min_stakes])
+        return false;
+    return true;
+}
+/** Full applies check (structural + soft), used by callers that don't route. */
+export function applies(lens, profile, isDeck) {
+    return appliesStructural(lens, profile, isDeck) && appliesSoft(lens, profile);
+}
+function orderByPriority(ids, concerns) {
+    const concernBoost = new Set();
+    for (const c of concerns)
+        for (const id of CONCERN_TO_LENS[c] ?? [])
+            concernBoost.add(id);
+    const rank = (id) => {
+        let r = BASE.includes(id) ? 0 : 5;
+        if (id === 'deck_narrative')
+            r = 2; // decks: narrative is load-bearing
+        if (concernBoost.has(id))
+            r -= 3; // user asked for it
+        return r;
+    };
+    return [...ids].sort((a, b) => rank(a) - rank(b) || ALL_LENS_IDS.indexOf(a) - ALL_LENS_IDS.indexOf(b));
+}
+function skipReason(id, profile, isDeck) {
+    if (id === 'deck_narrative' && !isDeck)
+        return '덱이 아니어서 제외';
+    if (id === 'reversibility')
+        return '되돌림 판단이 핵심이 아닌 문서 유형이어서 제외';
+    if (id === 'stakeholder_objection')
+        return '이해관계/stakes가 낮아 제외';
+    void profile;
+    return '이 문서에 해당하지 않아 제외';
+}
+function buildDisclosure(selected, profile) {
+    const labels = selected.map((id) => LENSES[id].label).join(', ');
+    const typeKo = documentTypeKo(profile.document_type);
+    return `적용한 검수 렌즈: ${labels}. 이유: 이 문서는 ${typeKo}이고, 핵심 주장과 사람이 책임질 판단을 우선 확인했습니다.`;
+}
+function documentTypeKo(t) {
+    const map = {
+        strategy_memo: '전략 메모',
+        prd: '제품 요구사항 문서(PRD)',
+        rfc: 'RFC',
+        adr: 'ADR',
+        strategy_deck: '전략 덱',
+        pitch_deck: '피치 덱',
+        board_deck: '보드 덱',
+        sales_deck: '세일즈 덱',
+        investor_update: '투자자 업데이트',
+        research_report: '리서치 리포트',
+        meeting_notes: '회의록',
+        llm_answer: 'AI 답변',
+        proposal: '제안서',
+        unknown: '문서',
+    };
+    return map[t] ?? '문서';
+}

package/dist/lib/review/schema.js

@@ -0,0 +1,36 @@
+/**
+ * Argus Document Judgment Review — Phase 0 Schema Lock.
+ *
+ * Single source of truth for the intermediate objects that the review
+ * pipeline produces. Per the design doc
+ * (docs/strategy/argus-product-loop-ux-subtask-b-2026-07-01.md → "구현 순서 /
+ * Phase 0: Schema Lock"): fix the objects BEFORE the pipeline and the UI, so
+ * the same `JudgmentReceipt` can be produced by the webapp and the MCP/plugin.
+ *
+ * Design invariants encoded here (do not weaken without revisiting the doc):
+ *  - Every high-confidence finding MUST be able to carry a `source_anchor`.
+ *    A finding with no anchor cannot be `high` confidence (enforced in the
+ *    pipeline, typed as optional here so degraded reviews can still exist).
+ *  - Provenance (schema/lens/model versions) rides on every receipt, so we can
+ *    later prove "Argus got better" instead of asserting it.
+ *  - Ownership fields (lean, pass/fail, settlement outcome) are user-owned.
+ *    The pipeline never fills them — see the Zero-Judgment spine in CLAUDE.md.
+ */
+export const REVIEW_SCHEMA_VERSION = '1';
+export const DEFAULT_BUDGET = {
+    quick: { max_units: 60, max_tokens: 8000, max_lens_calls: 4, depth: 'quick' },
+    standard: { max_units: 160, max_tokens: 16000, max_lens_calls: 7, depth: 'standard' },
+    deep: { max_units: 400, max_tokens: 32000, max_lens_calls: 9, depth: 'deep' },
+};
+// ---------------------------------------------------------------------------
+// Reviewability banding helper (pure — safe to import anywhere).
+// ---------------------------------------------------------------------------
+export function reviewabilityBand(score) {
+    if (score >= 80)
+        return 'normal';
+    if (score >= 60)
+        return 'caveated';
+    if (score >= 40)
+        return 'limited';
+    return 'insufficient';
+}