argus-decision-mcp 1.4.2 → 1.5.0

package/dist/lib/localize-result.js

@@ -4,7 +4,7 @@ const KO_ERRORS = {
     INVALID_LOCALE: { message: '지원하지 않는 언어입니다.', recovery: 'locale에는 "ko" 또는 "en"을 사용하세요.' },
     ALREADY_CLOSED: { message: '이미 진행 중이거나 닫힌 결정입니다.', recovery: '실제 결과를 기록하려면 argus_resolve를 사용하세요. 닫힌 결정은 다시 열지 않습니다.' },
     CAPTURE_NOT_FOUND: { message: '일치하는 내부 메모를 찾지 못했습니다.', recovery: '전제 문장을 text에 직접 전달하세요.' },
-    AMBIGUOUS_REF: { message: '여러 내부 메모와 일치해 대상을 정할 수 없습니다.', recovery: '전제 문장을 text에 직접 전달하세요.' },
+    AMBIGUOUS_REF: { message: '참조가 여러 항목과 일치합니다.', recovery: 'P1 같은 서수(번호)로 정확히 지정하세요. 번호는 argus_patterns view="decision_context"에서 볼 수 있습니다.' },
     PROVENANCE_REQUIRED: { message: '문장의 출처를 확인해야 합니다.', recovery: '사용자가 쓴 문장이면 user_stated, AI가 제기한 문장이면 ai_surfaced와 원문을 전달하세요.' },
     PREMISES_REQUIRED: { message: '추가할 전제가 없습니다.', recovery: 'text, kind, external, load_bearing, source를 포함한 전제 1~5개를 전달하세요.' },
     PREMISE_ID_COLLISION: { message: '다른 전제가 같은 식별자를 사용하고 있습니다.', recovery: '전제 문장을 조금 다르게 표현한 뒤 다시 추가하세요.' },
@@ -29,13 +29,17 @@ const KO_ERRORS = {
     PREMATURE_SETTLE: { message: '아직 확인일이 되지 않았습니다.', recovery: '확인일까지 기다리세요. 일정이 바뀌었다면 outcome="still_pending"에 defer_to로 새 확인일을 전달하면 됩니다.' },
     // ko/en 패리티: 아래 코드들은 en에서만 상세했고 ko는 제네릭 폴백이었다 —
     // 한국어 사용자가 같은 품질의 복구 안내를 받도록 전용 문구를 둔다.
-    NO_PRIOR_SEAL: { message: '이 id로 저장된 예측이 없습니다.', recovery: 'argus_predict로 반증 가능한 예측과 확인일을 먼저 저장하세요. (id가 argus_settings sync에서 온 "mcp_" 접두사라면 접두사를 뗀 id를 쓰세요.)' },
-    BAD_CHECK_BY: { message: '확인일이 오늘 이후의 날짜(YYYY-MM-DD)가 아닙니다.', recovery: 'check_by를 오늘 이후 날짜로 다시 전달하세요.' },
-    ILLEGAL_TRANSITION: { message: '지금 상태에서는 할 수 없는 작업입니다.', recovery: 'argus_patterns view="all"로 이 결정의 현재 상태를 확인한 뒤 맞는 도구를 사용하세요.' },
+    NO_PRIOR_SEAL: { message: '이 id로 저장된 예측이 없습니다.', recovery: 'argus_predict로 나중에 확인할 수 있는 예측과 확인일을 먼저 저장하세요. (id가 argus_settings sync에서 온 "mcp_" 접두사라면 접두사를 뗀 id를 쓰세요.)' },
+    BAD_CHECK_BY: { message: '확인일이 오늘 이후의 실제 달력 날짜(YYYY-MM-DD)가 아닙니다 (예: 2026-13-01처럼 없는 달·날짜는 불가).', recovery: '오늘 이후의 올바른 날짜를 YYYY-MM-DD로 다시 전달하세요.' },
+    ILLEGAL_TRANSITION: { message: '이 결정에 지금은 할 수 없는 작업입니다 (id 오타이거나, 이미 저장·정산·종료된 상태일 수 있습니다).', recovery: 'argus_patterns view="all"로 id와 현재 상태를 확인하세요. 없는 id면 argus_capture 또는 argus_predict로 새로 시작하세요.' },
+    PREMISE_LOCKED: { message: '확인일이 지나 전제를 더는 바꿀 수 없습니다.', recovery: '먼저 argus_resolve로 실제 결과를 기록하세요. 확인일이 온 뒤에는 전제/예측을 고칠 수 없습니다.' },
+    ARGUS_DIR_INVALID: { message: 'Argus 기록 경로(argus_dir / ARGUS_DIR)가 올바르지 않습니다.', recovery: '절대 경로여야 하고 ".."을 포함할 수 없습니다. MCP 설정에서 절대 경로(예: C:\\Users\\이름\\.argus, /Users/이름/.argus)로 바꾸거나 ARGUS_DIR을 지워 기본값(~/.argus)을 쓰세요. ${...} 같은 변수는 호스트가 확장하지 못할 수 있습니다.' },
+    ARGUS_DIR_UNWRITABLE: { message: 'Argus가 기록 폴더를 만들거나 쓰지 못했습니다.', recovery: 'ARGUS_DIR(또는 argus_dir)을 실제로 있고 쓸 수 있는 폴더로 바꿔 주세요. 실제 드라이브의 절대 경로여야 하고 ".."은 넣을 수 없습니다. 그다음 다시 시도하세요.' },
+    EMPTY_PREDICATE: { message: '확인 가능한 예측 문장이 필요합니다 (공백 제외 최소 8자).', recovery: '현실이 참/거짓으로 확인할 수 있는 문장으로 다시 적으세요. 예: "컷오버 다운타임 5분 미만".' },
     ALREADY_SETTLED: { message: '이미 실제 결과가 기록된 결정입니다.', recovery: '영수증은 argus_patterns view="receipt"로 볼 수 있습니다. 새 결정이면 새 id로 여세요.' },
-    DECISION_CLOSED: { message: '접힌(닫힌) 결정이라 더 진행할 수 없습니다.', recovery: '필요하면 새 id로 다시 여세요. 닫힌 기록은 그대로 남습니다.' },
+    DECISION_CLOSED: { message: '닫힌 결정이라 더 진행할 수 없습니다.', recovery: '필요하면 새 id로 다시 여세요. 닫힌 기록은 그대로 남습니다.' },
     GOALPOST_MOVED: { message: '봉인된 예측 문장은 확인일 전에 바꿀 수 없습니다.', recovery: '일정 변경은 outcome="still_pending"과 defer_to로, 예측 자체가 달라졌다면 새 결정으로 여세요.' },
-    NO_SUCH_PREMISE: { message: '해당 번호의 전제를 찾지 못했습니다.', recovery: 'argus_patterns view="decision_context"로 전제 목록과 번호를 확인하세요.' },
+    NO_SUCH_PREMISE: { message: '해당 번호의 전제를 찾지 못했습니다 (이 결정에 아직 전제가 없을 수 있습니다).', recovery: 'argus_patterns view="decision_context"로 목록과 번호를 확인하고, 전제가 없으면 argus_capture action="add_context"로 먼저 추가하세요.' },
     WHAT_HAPPENED_REQUIRED: { message: '실제로 일어난 일을 기록해야 합니다.', recovery: '사용자에게 실제 결과를 물어 what_happened에 그대로 전달하세요.' },
     DEFER_DATE_REQUIRED: { message: '다시 확인할 날짜가 필요합니다.', recovery: '사용자에게 날짜를 물어 defer_to에 YYYY-MM-DD로 전달하세요. 더는 중요하지 않다면 argus_capture action="close"를 사용하세요.' },
     NOT_CONNECTED: { message: '이 터미널은 Argus 계정과 연결돼 있지 않습니다.', recovery: '웹 설정에서 동기화 토큰을 발급하고 MCP 설정의 ARGUS_TOKEN에 넣으세요.' },
@@ -46,10 +50,49 @@ const KO_ERRORS = {
     UNKNOWN_TOOL: { message: '알 수 없는 도구입니다.', recovery: 'tools/list에 나온 정확한 도구 이름을 사용하세요.' },
 };
 export const LOCALIZED_ERROR_CODES = new Set(Object.keys(KO_ERRORS));
+// The allowed values for each enum field, so a wrong guess (stakes="medium",
+// outcome="success", …) TEACHES the model the valid set instead of a bare "not
+// allowed". Keyed by the field's LAST path segment (so premises.0.kind → kind).
+const ENUM_HINTS = {
+    stakes: 'trivial · low · moderate · high',
+    reversibility: 'one_way_door · costly_to_reverse · easily_reversible',
+    outcome: 'held · avoided · partial · still_pending · missed',
+    outcome_source: 'user_stated',
+    view: 'active · all · receipt · decision_context · timeline · reflection',
+    action: 'open · add_context · answer_question · keep_question_open · update_fact · change_prediction · close',
+    locale: 'ko · en',
+    basis: 'judgment · luck · mixed · unsure',
+    kind: 'premise · open_question',
+    predicate_owner: 'user · ai_surfaced',
+    source: 'user_stated · ai_surfaced (update_fact에서는 url · user_stated · host_reported)',
+    dismiss_reason: 'became_irrelevant · decided_elsewhere · superseded · user_declined · changed_mind · other',
+};
+const DATE_FIELDS = new Set(['check_by', 'defer_to', 'today_override', 'snooze_until']);
+const TYPE_KO = { string: '문자열', number: '숫자', boolean: '참/거짓', array: '목록', object: '객체', integer: '정수' };
+/** The REAL allowed values, parsed from Zod's own English message
+ *  ("… expected one of "a"|"b"|"c""). Lets the Korean surface show the ACTUAL
+ *  per-tool enum instead of a hardcoded guess — ENUM_HINTS is keyed by field
+ *  NAME, so `action` in argus_settings (status·update·sync) was being told the
+ *  argus_capture action set. The message carries the truth per call; use it. */
+function enumValuesFromMessage(msg) {
+    const m = msg?.match(/expected one of (.+)$/i);
+    if (!m)
+        return [];
+    return (m[1].match(/"([^"]+)"|'([^']+)'/g) ?? []).map((s) => s.replace(/["']/g, ''));
+}
+/** The offending key name(s) from Zod's "Unrecognized key(s): "x"" message, so
+ *  the Korean surface can NAME what to remove instead of a blank "요청:". */
+function keysFromMessage(msg) {
+    if (!msg || !/unrecognized key/i.test(msg))
+        return [];
+    return (msg.match(/"([^"]+)"|'([^']+)'/g) ?? []).map((s) => s.replace(/["']/g, ''));
+}
 /** Translate one Zod issue into a Korean, actionable reason. Keeps the English
  *  argument NAME (models and users see arg names in English), but says in Korean
- *  WHY it failed — the piece the generic message threw away. */
-function koReason(issue) {
+ *  WHY it failed — the piece the generic message threw away. Field-aware so an id
+ *  regex failure isn't told to "use YYYY-MM-DD" and an enum lists its values. */
+function koReason(issue, field) {
+    const key = field.split('.').pop() || field;
     const unit = issue.origin === 'string' ? '자' : issue.origin === 'array' ? '개' : '';
     switch (issue.code) {
         case 'too_small':
@@ -65,16 +108,29 @@ function koReason(issue) {
                 return `항목이 너무 많습니다 (최대 ${issue.maximum}개)`;
             return `너무 큽니다 (최대 ${issue.maximum}${unit})`;
         case 'invalid_type':
-            return issue.expected === undefined ? '형식이 올바르지 않습니다' : `필수이거나 형식이 올바르지 않습니다 (${issue.expected} 필요)`;
+            return issue.expected === undefined ? '형식이 올바르지 않습니다' : `필수이거나 형식이 올바르지 않습니다 (${TYPE_KO[issue.expected] ?? issue.expected} 형식 필요)`;
         case 'invalid_value':
-        case 'invalid_enum_value':
-            return '허용되지 않는 값입니다';
+        case 'invalid_enum_value': {
+            const vals = enumValuesFromMessage(issue.message);
+            if (vals.length)
+                return `허용되지 않는 값입니다 (가능: ${vals.join(' · ')})`;
+            const hint = ENUM_HINTS[key];
+            return hint ? `허용되지 않는 값입니다 (가능: ${hint})` : '허용되지 않는 값입니다';
+        }
         case 'unrecognized_keys':
             return '알 수 없는 항목입니다';
         case 'invalid_format':
         case 'invalid_string':
-            return '형식이 올바르지 않습니다 (예: 날짜는 YYYY-MM-DD)';
+            if (key === 'id')
+                return '영문·숫자와 . _ - 만 쓸 수 있습니다 (한글·공백·특수문자 불가, 예: "career-move")';
+            if (DATE_FIELDS.has(key))
+                return 'YYYY-MM-DD 형식의 날짜여야 합니다';
+            return '형식이 올바르지 않습니다';
         default:
+            // Same text as the invalid_format id case so the two issues the id regex +
+            // superRefine both raise dedup to a single line.
+            if (key === 'id')
+                return '영문·숫자와 . _ - 만 쓸 수 있습니다 (한글·공백·특수문자 불가, 예: "career-move")';
             return '값을 확인해 주세요';
     }
 }
@@ -82,12 +138,115 @@ function koReason(issue) {
 function localizeInvalidInput(fields) {
     if (!fields.length)
         return KO_ERRORS.INVALID_INPUT;
-    const parts = fields.slice(0, 4).map((f) => `${f.field === '(root)' ? '요청' : f.field}: ${koReason(f)}`);
+    const seen = new Set();
+    const parts = [];
+    for (const f of fields) {
+        let part;
+        if (f.code === 'unrecognized_keys') {
+            // The field path is just '(root)'; the useful info is WHICH key. Name it,
+            // and drop the meaningless "요청:" prefix that told the user nothing.
+            const keys = keysFromMessage(f.message);
+            part = keys.length
+                ? `${keys.map((k) => `"${k}"`).join(', ')}: 이 도구가 받지 않는 항목입니다`
+                : '이 도구가 받지 않는 항목입니다';
+        }
+        else {
+            const name = f.field === '(root)' ? '요청' : f.field;
+            part = `${name}: ${koReason(f, f.field)}`;
+        }
+        if (seen.has(part))
+            continue; // dedup "id: …, id: …" (regex + superRefine both fire)
+        seen.add(part);
+        parts.push(part);
+        if (parts.length >= 4)
+            break;
+    }
     return {
-        message: `입력값이 올바르지 않습니다 — ${parts.join(', ')}.`,
+        message: `입력값이 올바르지 않습니다: ${parts.join(', ')}.`,
         recovery: '위에 표시된 인자를 고친 뒤 같은 도구를 다시 호출하세요. 사용자가 정해야 할 값은 추측하지 마세요.',
     };
 }
+/** English mirror of koReason: a plain reason for one Zod issue, so an EN user
+ *  sees "check_by is required" instead of raw "expected string, received undefined". */
+function enReason(issue) {
+    const key = issue.field.split('.').pop() || issue.field;
+    switch (issue.code) {
+        case 'too_small':
+            if (issue.origin === 'string')
+                return `is too short (min ${issue.minimum} characters)`;
+            if (issue.origin === 'array')
+                return `needs at least ${issue.minimum} item${issue.minimum === 1 ? '' : 's'}`;
+            return `is too small (min ${issue.minimum})`;
+        case 'too_big':
+            if (issue.origin === 'string')
+                return `is too long (max ${issue.maximum} characters)`;
+            if (issue.origin === 'array')
+                return `has too many items (max ${issue.maximum})`;
+            return `is too big (max ${issue.maximum})`;
+        case 'invalid_type':
+            return issue.expected ? `is required (expected ${issue.expected})` : 'has the wrong format';
+        case 'invalid_value':
+        case 'invalid_enum_value': {
+            const vals = enumValuesFromMessage(issue.message);
+            return vals.length ? `must be one of ${vals.join(', ')}` : 'is not an allowed value';
+        }
+        case 'invalid_format':
+        case 'invalid_string':
+            if (key === 'id')
+                return 'may use only letters, digits and . _ - (no spaces or other characters, e.g. "career-move")';
+            if (DATE_FIELDS.has(key))
+                return 'must be a YYYY-MM-DD date';
+            return 'has the wrong format';
+        default:
+            if (key === 'id')
+                return 'may use only letters, digits and . _ - (no spaces or other characters, e.g. "career-move")';
+            return 'needs checking';
+    }
+}
+/** English INVALID_INPUT that NAMES the offending argument(s), instead of raw
+ *  Zod ("(root): Unrecognized key", "expected string, received undefined"). */
+function englishInvalidInput(fields) {
+    const recovery = 'Fix the named argument(s) and call the same tool again. Do not infer missing user-owned fields.';
+    if (!fields.length)
+        return { message: 'Invalid input.', recovery };
+    const seen = new Set();
+    const parts = [];
+    for (const f of fields) {
+        let part;
+        if (f.code === 'unrecognized_keys') {
+            const keys = keysFromMessage(f.message);
+            part = keys.length
+                ? `${keys.map((k) => `"${k}"`).join(', ')} ${keys.length === 1 ? "isn't a field" : "aren't fields"} this tool accepts`
+                : 'an unexpected field was passed';
+        }
+        else {
+            const name = f.field === '(root)' ? 'the request' : f.field;
+            part = `${name} ${enReason(f)}`;
+        }
+        if (seen.has(part))
+            continue;
+        seen.add(part);
+        parts.push(part);
+        if (parts.length >= 4)
+            break;
+    }
+    return { message: `Invalid input: ${parts.join('; ')}.`, recovery };
+}
+/** Friendly English for the codes whose handler/guard message otherwise leaks
+ *  internal machinery (raw Zod, state-machine states). Codes NOT listed keep
+ *  their handler's already-fine English. */
+const EN_FRIENDLY = {
+    ILLEGAL_TRANSITION: {
+        message: "This isn't a step you can take on this decision right now (the id may be a typo, or it may already be saved, settled, or closed).",
+        recovery: 'Check the id and its state with argus_patterns view="all". If no such id exists, start fresh with argus_capture or argus_predict.',
+    },
+};
+function englishHumanize(code, sc) {
+    if (code === 'INVALID_INPUT' && Array.isArray(sc['invalid_fields'])) {
+        return englishInvalidInput(sc['invalid_fields']);
+    }
+    return EN_FRIENDLY[code] ?? null;
+}
 const REPRESENTATIVE_FIELDS = [
     'decision', 'predicate', 'what_happened', 'finding', 'text', 'question',
     'human_judgment', 'note', 'title', 'biggest_worry',
@@ -106,18 +265,56 @@ function responseLocale(args) {
  * user surface even on validation, guard, and rare failure paths.
  */
 export function localizeToolResult(args, result) {
-    if (!result.isError || responseLocale(args) !== 'ko')
+    if (!result.isError)
         return result;
     const sc = result.structuredContent;
     if (!sc || sc['ok'] !== false)
         return result;
     const code = String(sc['error_code'] ?? 'INTERNAL_ERROR');
+    if (responseLocale(args) !== 'ko') {
+        // English path: handler prose is already English — humanize ONLY the codes
+        // that otherwise leak raw Zod / state-machine internals to the user.
+        const en = englishHumanize(code, sc);
+        if (!en)
+            return result;
+        const enLocalized = { ...sc, message: en.message, ...(en.recovery ? { recovery: en.recovery } : {}) };
+        result.structuredContent = enLocalized;
+        result.content = [{ type: 'text', text: JSON.stringify(enLocalized, null, 2) }];
+        return result;
+    }
+    // Some handlers already return a hand-written Korean message (e.g.
+    // NOT_FALSIFIABLE: "이건 기분이지 확인 가능한 예측이 아닙니다"). If this code
+    // isn't in KO_ERRORS, the generic fallback used to DESTROY that Korean copy.
+    // Preserve any message that already contains Hangul instead of overwriting it.
+    const existingMsg = typeof sc['message'] === 'string' ? sc['message'] : '';
+    const existingRec = typeof sc['recovery'] === 'string' ? sc['recovery'] : '';
+    const genericFallback = /[가-힣]/.test(existingMsg)
+        ? { message: existingMsg, ...(existingRec ? { recovery: existingRec } : {}) }
+        : { message: '요청을 처리하지 못했습니다.', recovery: '입력값과 현재 결정 상태를 확인한 뒤 다시 시도하세요.' };
     let copy = code === 'INVALID_INPUT' && Array.isArray(sc['invalid_fields'])
         ? localizeInvalidInput(sc['invalid_fields'])
-        : KO_ERRORS[code] ?? {
-            message: '요청을 처리하지 못했습니다.',
-            recovery: '입력값과 현재 결정 상태를 확인한 뒤 다시 시도하세요.',
+        : KO_ERRORS[code] ?? genericFallback;
+    // A handler-authored KOREAN message is at least as specific as the generic
+    // map — KO_ERRORS exists to replace ENGLISH copy, not better Korean. Without
+    // this, errors.ts's "내부 오류가 발생했습니다: EACCES …" lost its detail to
+    // the generic '내부 오류가 발생했습니다.' (1.4.6 backlog: ko detail loss).
+    // Quoted spans are stripped BEFORE the Hangul test: an English template that
+    // merely embeds the user's Korean predicate ('already sealed: "매출 1억…"')
+    // is still English-authored and must still be replaced.
+    const authoredKo = (s) => /[가-힣]/.test(s.replace(/"[^"]*"|'[^']*'|「[^」]*」/g, ''));
+    if (code !== 'INVALID_INPUT' && authoredKo(existingMsg)) {
+        copy = {
+            message: existingMsg,
+            ...(existingRec && authoredKo(existingRec) ? { recovery: existingRec } : copy.recovery ? { recovery: copy.recovery } : {}),
         };
+    }
+    else if (code === 'INTERNAL_ERROR') {
+        // English-authored internal error: carry the diagnostic detail across the
+        // language switch instead of discarding it.
+        const d = existingMsg.match(/^Internal error: ([\s\S]+)$/);
+        if (d)
+            copy = { message: `내부 오류가 발생했습니다: ${d[1]}`, ...(copy.recovery ? { recovery: copy.recovery } : {}) };
+    }
     // en에만 있던 날짜 상세를 ko에서도 보존 — "언제가 확인일인데?"에 답이 되도록.
     if (code === 'PREMATURE_SETTLE') {
         const m = String(sc['message'] ?? '').match(/check-by (\d{4}-\d{2}-\d{2}), today (\d{4}-\d{2}-\d{2})/);

package/dist/lib/numeric-drift.js

@@ -111,7 +111,7 @@ export function evaluateMateriality(prev, next, rule, ctx) {
                 return { status: 'unchanged', reason: '라벨 동일 (정규화 후)' };
             return {
                 status: 'uncertain',
-                reason: '비수치/미정규 라벨 — canonical scale를 지정하면 기계 판정 가능 (host 판정 레인)',
+                reason: '비수치/미정규 라벨. canonical scale를 지정하면 기계 판정 가능 (host 판정 레인)',
                 low_confidence: true,
             };
         }
@@ -120,7 +120,7 @@ export function evaluateMateriality(prev, next, rule, ctx) {
         pv = asNumber(prev);
         nv = asNumber(next);
         if (pv === null || nv === null) {
-            return { status: 'unchanged', reason: 'non-finite input — not comparable' };
+            return { status: 'unchanged', reason: 'non-finite input; not comparable' };
         }
         // unit canonicalization before comparing (§3.2)
         if (ctx?.unit_from) {
@@ -159,7 +159,7 @@ export function evaluateMateriality(prev, next, rule, ctx) {
             }
             return {
                 status: 'uncertain',
-                reason: '부호 전환이나 0의 의미(zero_meaningful) 미선언 — 규칙을 정해주세요',
+                reason: '부호 전환이나 0의 의미(zero_meaningful) 미선언. 규칙을 정해주세요',
                 low_confidence: true,
             };
         }
@@ -169,7 +169,7 @@ export function evaluateMateriality(prev, next, rule, ctx) {
     if (axis === 'ratio') {
         return {
             status: 'uncertain',
-            reason: '값이 비율/%% — %p(delta)로 볼지 complement 축으로 볼지 정해주세요',
+            reason: '값이 비율(%)입니다. %p(퍼센트포인트)로 볼지 여집합(100−값) 축으로 볼지 정해주세요',
             low_confidence: true,
         };
     }
@@ -190,14 +190,14 @@ export function evaluateMateriality(prev, next, rule, ctx) {
         }
         return rel >= BIG_MULT
             ? { status: 'material', reason: `near-zero ${rel.toFixed(1)}배 이동: ${pv} → ${nv}` }
-            : { status: 'uncertain', reason: 'near-zero 애매 — 규칙(delta/safety_floor)을 정해주세요', low_confidence: true };
+            : { status: 'uncertain', reason: 'near-zero 애매. 규칙(delta/safety_floor)을 정해주세요', low_confidence: true };
     }
     // 4b/4c. general scale-free: knife-edge FIRST (exactly-at-threshold is the
     // >= vs > hostage case → uncertain, §8 PCT-08/DATE-09), then relative.
     const rel = Math.abs(nv - pv) / Math.abs(pv);
     const P = REL_DEFAULT;
     if (Math.abs(rel - P) <= EPS) {
-        return { status: 'uncertain', reason: `상대변화가 임계 경계에 걸침 (${Math.round(rel * 100)}%) — 규칙/밴드를 정해주세요`, low_confidence: true };
+        return { status: 'uncertain', reason: `상대변화가 임계 경계에 걸침 (${Math.round(rel * 100)}%). 규칙/밴드를 정해주세요`, low_confidence: true };
     }
     if (rel >= P) {
         return { status: 'material', reason: `${Math.round(rel * 100)}% 이동: ${pv} → ${nv}` };
@@ -213,7 +213,7 @@ function evaluateDeclaredRule(pv, nv, rule, ctx) {
     // then it's uncertain, never a manufactured alert. (threshold/band/step/map
     // are axis-agnostic — a crossed line is a crossed line.)
     if (mod?.unit_axis === 'ratio' && (rule.type === 'relative' || rule.type === 'delta')) {
-        return { status: 'uncertain', reason: '값이 비율/%% — %p(delta)로 볼지 complement 축으로 볼지 정해주세요', low_confidence: true };
+        return { status: 'uncertain', reason: '값이 비율(%)입니다. %p(퍼센트포인트)로 볼지 여집합(100−값) 축으로 볼지 정해주세요', low_confidence: true };
     }
     // sign-flip modifier (§2.3 / §6.5): dead-band AND, never "always material".
     // A declared sign_flip is decided here (not by the raw delta/relative magnitude).
@@ -225,7 +225,7 @@ function evaluateDeclaredRule(pv, nv, rule, ctx) {
         if (Math.abs(pv) >= floor && Math.abs(nv) >= floor) {
             return mod.zero_meaningful === true
                 ? { status: 'material', reason: `부호 전환: ${pv} → ${nv}` }
-                : { status: 'uncertain', reason: '부호 전환이나 0의 의미(zero_meaningful) 미선언 — 규칙을 정해주세요', low_confidence: true };
+                : { status: 'uncertain', reason: '부호 전환이나 0의 의미(zero_meaningful) 미선언. 규칙을 정해주세요', low_confidence: true };
         }
         return { status: 'unchanged', reason: 'dead-band 안 왕복 = 노이즈' };
     }
@@ -251,7 +251,7 @@ function evaluateDeclaredRule(pv, nv, rule, ctx) {
                 // boundary undefined and it matters near the line → uncertain (§1.4)
                 const atLine = pv === line || nv === line;
                 if (atLine)
-                    return { status: 'uncertain', reason: 'threshold 경계 도달인데 boundary(inclusive/exclusive) 미지정 — 정해주세요', low_confidence: true };
+                    return { status: 'uncertain', reason: 'threshold 경계 도달인데 boundary(inclusive/exclusive) 미지정. 정해주세요', low_confidence: true };
             }
             const incl = boundary === 'inclusive';
             const crossed = (() => {
@@ -291,10 +291,10 @@ function evaluateDeclaredRule(pv, nv, rule, ctx) {
         case 'relative': {
             const P = numParam(rule.params['P'], REL_DEFAULT);
             if (pv === 0)
-                return { status: 'uncertain', reason: 'relative 기준값 0 — delta 규칙이 필요합니다', low_confidence: true };
+                return { status: 'uncertain', reason: 'relative 기준값 0. delta 규칙이 필요합니다', low_confidence: true };
             const rel = Math.abs(nv - pv) / Math.abs(pv);
             if (Math.abs(rel - P) <= EPS) {
-                return { status: 'uncertain', reason: `상대변화가 임계 경계에 걸침 (${Math.round(rel * 100)}%) — 규칙/밴드를 정해주세요`, low_confidence: true };
+                return { status: 'uncertain', reason: `상대변화가 임계 경계에 걸침 (${Math.round(rel * 100)}%). 규칙/밴드를 정해주세요`, low_confidence: true };
             }
             return rel >= P
                 ? dirGate({ status: 'material', reason: `${Math.round(rel * 100)}% 이동: ${pv} → ${nv}` })
@@ -316,7 +316,7 @@ function evaluateDeclaredRule(pv, nv, rule, ctx) {
             // v1: opt-in only, and this numeric path sees just two snapshots — it cannot
             // observe a window. Honest: surface as uncertain (path/volatility not decidable
             // from prev→next alone), never fabricate a peak/crossing verdict (§1.3, §10.5).
-            return { status: 'uncertain', reason: 'stateful(경로/변동성)은 두 스냅샷으로 판정 불가 — 관측 이력이 필요합니다', low_confidence: true };
+            return { status: 'uncertain', reason: 'stateful(경로/변동성)은 두 스냅샷으로 판정 불가. 관측 이력이 필요합니다', low_confidence: true };
         case 'map':
             // handled in the label path; a numeric map here means mis-typed rule.
             return { status: 'uncertain', reason: 'map 규칙은 라벨 값에만 적용됩니다', low_confidence: true };
@@ -337,7 +337,7 @@ function evaluateMap(prevLabel, nextLabel, rule) {
     }
     return {
         status: 'uncertain',
-        reason: `상태 전이이나 등록된 material 상태집합 밖: ${prevLabel} → ${nextLabel} — 규칙 정할지 당신 몫`,
+        reason: `상태 전이이나 등록된 material 상태집합 밖: ${prevLabel} → ${nextLabel}. 규칙 정할지 당신 몫`,
         low_confidence: true,
     };
 }

package/dist/lib/receipt.js

@@ -64,6 +64,15 @@ fallback) {
             null;
     const merged = {
         ...base,
+        // The ledger is the source of truth for the sealed prediction and its date.
+        // A change_prediction (amend) updates the CONTRACT but not the seal-time
+        // receipt file on disk, so `base.predicate`/`check_by` can be STALE — the
+        // receipt then contradicts every list view (dogfood: receipt printed the
+        // pre-amend "8월" predicate while the record showed the amended "9월" one).
+        // Prefer the current contract values the settle handler resolved from the
+        // fold, so the keepsake can never disagree with the ledger.
+        ...(fallback?.predicate ? { predicate: fallback.predicate } : {}),
+        ...(fallback?.check_by ? { check_by: fallback.check_by } : {}),
         settled_at: patch.settled_at,
         what_happened: patch.what_happened,
         outcome: patch.outcome,
@@ -79,7 +88,14 @@ fallback) {
 }
 export function readReceipt(argusDir, id) {
     try {
-        return JSON.parse(deBom(fs.readFileSync(receiptPath(argusDir, id), 'utf8')));
+        const parsed = JSON.parse(deBom(fs.readFileSync(receiptPath(argusDir, id), 'utf8')));
+        // A hand-edited / corrupt receipt could be a primitive, null, or an array;
+        // renderReceipt does r.predicate.split(...) unguarded and writeSettleReceipt
+        // spreads `base`, so a non-object would crash the render / drop every field.
+        // Reject anything but a plain object — a corrupt keepsake degrades, not dies.
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            return null;
+        return parsed;
     }
     catch {
         return null;