argus-decision-mcp 1.4.6 → 1.5.0

package/dist/lib/ambient-elicit.js

@@ -163,17 +163,19 @@ async function fire(dir, todayOverride) {
         // 물음 1 — 정산 outcome (spine-SAFE 구조 픽: 현실이지 평결이 아니다).
         // 대화 맥락이 없는 사용자를 위해 그의 예측을 그대로 되비춘다 (우정 1조).
         const picked = await withTimeout(elicit(ko
-            ? `Argus — 확인일이 지난 예측이 있어요: "${text}" (확인일 ${first.date}). 현실이 어떻게 답했나요? 지금 어려우면 닫아도 됩니다 — 다시 조르지 않아요.`
-            : `Argus — a prediction passed its check-by: "${text}" (due ${first.date}). What did reality do? Dismiss if now is a bad time — no re-asking.`, {
+            ? `Argus: 확인일이 지난 예측이 있어요. "${text}" (확인일 ${first.date}). 현실이 어떻게 답했나요? 지금 어려우면 닫아도 됩니다. 다시 조르지 않아요.`
+            : `Argus: a prediction passed its check-by. "${text}" (due ${first.date}). What did reality do? Dismiss if now is a bad time; no re-asking.`, {
             type: 'object',
             required: ['outcome'],
             properties: {
                 outcome: {
                     type: 'string',
                     enum: ['held', 'avoided', 'partial', 'still_pending', 'missed'],
+                    // Same labels as the in-band settle picker (settle.ts) — 풀어쓰기.
+                    // (Duplicated across the two picker sites; keep them in lockstep.)
                     enumNames: ko
-                        ? ['그렇게 됐다 (held)', '피했다 (avoided)', '부분적으로 (partial)', '아직 불분명 (still pending)', '빗나갔다 (missed)']
-                        : ['It held', 'Avoided it', 'Partially', 'Still pending', 'Missed — my read was wrong'],
+                        ? ['예측대로 됐다', '걱정한 일은 안 일어났다', '일부만 맞았다', '아직 불분명', '예측이 빗나갔다']
+                        : ['It held', 'Avoided', 'Partially', 'Still unclear', 'Missed: my read was wrong'],
                     description: ko ? '봉인한 예측에 현실이 어떻게 답했는지.' : 'What reality did to your sealed prediction.',
                 },
             },
@@ -188,7 +190,7 @@ async function fire(dir, todayOverride) {
         let whatHappened;
         if (outcome !== 'still_pending') {
             const wh = await withTimeout(elicit(ko
-                ? '실제로 무슨 일이 있었나요? 한 줄이면 됩니다 — 당신의 말 그대로 기록됩니다.'
+                ? '실제로 무슨 일이 있었나요? 한 줄이면 됩니다. 당신의 말 그대로 기록됩니다.'
                 : 'What actually happened, in one line? Recorded verbatim, in your words.', {
                 type: 'object',
                 required: ['what_happened'],

package/dist/lib/continuity.js

@@ -21,11 +21,11 @@ export function computeContinuity(argusDir, relatedIds) {
     }
     const frequency_statement = settled === 0
         ? 'No settled history among the decisions you tagged as similar.'
-        : `Of ${settled} similar decision(s) you settled: ${held} held, ${settled - held} did not.`;
+        : `Of ${settled} similar ${settled === 1 ? 'decision' : 'decisions'} you settled: ${held} held, ${settled - held} did not.`;
     return {
         related,
         frequency_statement,
         sample_size: settled,
-        sample_size_caveat: settled > 0 && settled < 10 ? 'Sample is small — read this as history, not a pattern about you.' : undefined,
+        sample_size_caveat: settled > 0 && settled < 10 ? 'Sample is small. Read this as history, not a pattern about you.' : undefined,
     };
 }

package/dist/lib/detect-signals.js

@@ -0,0 +1,151 @@
+/**
+ * Layer-2 deterministic signal detection (blueprint continuation of the plugin's
+ * `decision-signals.js`, whose comment reads "Layer 2 widens precision — later").
+ *
+ * WHY THIS EXISTS (the trust answer, 2026-07-20). In an MCP the *noticing* of a
+ * passing prediction / a surfacing outcome / a load-bearing assumption is, by the
+ * protocol, the host model's act — the server never sees the conversation, and
+ * Claude does not yet support server-driven `sampling` (feature req #1785). So
+ * "the model will notice" is a goodwill dependency, not a guarantee. This module
+ * turns the part that CAN be code into code: a pure, dependency-free, unit-tested
+ * RULE scan of a turn's text. It does not replace the model — it RAISES RECALL so
+ * the model is handed a specific candidate in the user's own words instead of
+ * being trusted to spot it from scratch.
+ *
+ * LLM-glue invariant: because this is rules (not a model), a test can pin it —
+ * "plausible" cannot masquerade as "correct". Every detected span is the user's
+ * OWN words (a verbatim slice), never a fabricated stand-in.
+ *
+ * SPINE (mirror clause — max detect, min fire): this detector leans HIGH-RECALL.
+ * Restraint lives in the FIRING gate around it (the hook's once-per-session +
+ * cooldown, and the model's freedom to stay silent on a flat case), NOT here.
+ * Detection ≠ interruption: a caller may detect and still choose to say nothing.
+ */
+/* ── Cue groups (named so tests + the plugin mirror can pin them) ──────────── */
+/** Future / modal markers: the claim points at a not-yet-settled state. */
+const FUTURE = [
+    /\bwill\b/i, /\bwon'?t\b/i, /\bgoing to\b/i, /\bgonna\b/i, /\bshall\b/i,
+    /\bexpect(s|ed|ing)?\b/i, /\bshould\b/i, /\blikely\b/i, /\bplan(ning)? to\b/i,
+    /\bby (mon|tue|wed|thu|fri|sat|sun)\w*/i,
+    /\bby (jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\w*/i,
+    /\bby \d/i, /\bwithin \d+\s*(day|week|month|quarter)/i,
+    /\bnext (week|month|quarter|year|sprint)\b/i,
+    // Korean futures / commitments / thresholds-as-future
+    /(할|될|갈|낼|올|줄)\s*(것|거|게|걸)/, /하겠|되겠|시키겠/, /(ㄹ|를|을)\s*거(다|예요|야|임)/,
+    /예상|전망|목표|계획|할 예정|될 예정/, /까지(는|\b|\s)/, /안에|이내(에)?/,
+    /다음\s*(주|달|분기|해|스프린트)/, /(유지|달성|돌파|출시|완료)(할|될|하겠|되겠|한다|된다)/,
+    // Korean prospective endings — "-ㄹ 거예요 / -ㄹ 겁니다 / -ㄹ 것으로": the ㄹ is
+    // fused into a composed syllable (빨라질) so match the trailing marker itself.
+    /(거예요|거에요|거야|겁니다|거고|건데|건가|것으로|것입니다|것이다|것\s*같)/, /(ㄹ|을|를)\s*것\b/,
+];
+/** Measurable checkpoints: a number, percent, money, date, threshold, comparison. */
+const MEASURABLE = [
+    /\d/, /%|percent|퍼센트|프로/i, /\$|원\b|달러|억|만원|USD|KRW/i,
+    /\b(faster|slower|lower|higher|cheaper|under|over|below|above|less than|more than|at least|no more than)\b/i,
+    /이하|이상|미만|초과|아래|위(로)?|밑(으로)?|이내|보다\s*(빠|느|싸|비|많|적|높|낮)/,
+    /\b(mon|tue|wed|thu|fri|sat|sun)\w*/i,
+    /\b(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\w*/i, /\d{4}-\d{2}-\d{2}/,
+];
+/** Completion verbs: a discrete event reality can confirm happened or not. */
+const COMPLETION = [
+    /\b(ship|launch|release|deliver|deploy|close|hire|sign|land|finish|complete|onboard|migrate|cut over)\b/i,
+    /출시|배포|출고|런칭|납품|마감|채용|계약|체결|완료|오픈|이전|전환|성사|입사|합류/,
+];
+/** Past-tense resolution markers: reality has spoken about something. */
+const RESOLVED = [
+    /\bturn(s|ed)? out\b/i, /\bended up\b/i, /\bcame in at\b/i, /\bended at\b/i,
+    /\bwe (shipped|launched|missed|hit|closed|hired|signed|landed|deployed)\b/i,
+    /\bit (went|held|worked|failed|slipped|held up)\b/i,
+    /\bdidn'?t (happen|work|ship|hold|land)\b/i, /\b(hit|missed|beat|met) (the|our) (target|number|deadline|goal)\b/i,
+    /됐(어|다|고|는데|네|음)|됐다|성사(됐|했)|끝났|출시했|배포했|이전했|전환했/,
+    /안\s*(됐|나|됐어|됐다)|못\s*(했|했다|해서|이룬)|실패(했|함)|무산(됐|됨)/,
+    /결국|실제로(는)?|막상|나왔(다|어|고)|나온|드러났|밝혀졌|판명/,
+];
+/** Causal / conditional markers: the reasoning rests on a stated premise. */
+const CONDITIONAL = [
+    /\bbecause\b/i, /\bsince\b/i, /\bassuming\b/i, /\bas long as\b/i, /\bdepends on\b/i,
+    /\bonly if\b/i, /\bprovided that\b/i, /\bbanking on\b/i, /\bhinges? on\b/i,
+    /\bcontingent on\b/i, /\bthe (key|whole thing) (is|hinges|rests|depends)\b/i,
+    /니까|때문에|덕분에|탓에/, /(라|다)면\b|(으|)ㄴ다면|는다면/, /는\s*한(에서)?|한(에서만)?/,
+    /(에|에게)\s*달렸|달려\s*있|전제로|가정하(면|고)|관건은|핵심은|믿고\s*있/,
+];
+/* ── Helpers ──────────────────────────────────────────────────────────────── */
+const anyMatch = (groups, s) => groups.some((re) => re.test(s));
+const whichMatch = (name, groups, s) => groups.some((re) => re.test(s)) ? name : null;
+/** Split into sentence-ish spans on terminators + newlines; keep the user's text. */
+function clauses(text) {
+    return text
+        .split(/(?<=[.!?。！？])\s+|\n+/)
+        .map((c) => c.trim())
+        .filter((c) => c.length >= 6 && c.length <= 400);
+}
+/** Cheap token overlap for outcome↔open-predicate. Prefix-aware so Korean josa
+ *  ("이전은" vs "이전", "다운타임은" vs "다운타임") still counts as the same word —
+ *  naive exact-token overlap silently under-fires on every particle-attached noun. */
+function overlaps(a, b) {
+    const tok = (s) => s.toLowerCase()
+        .replace(/[^\p{L}\p{N}\s]/gu, ' ')
+        .split(/\s+/)
+        .filter((t) => t.length >= 2);
+    const A = tok(a);
+    const B = tok(b);
+    if (A.length === 0 || B.length === 0)
+        return false;
+    let hit = 0;
+    for (const x of A) {
+        for (const y of B) {
+            if (x === y || x.startsWith(y) || y.startsWith(x)) {
+                hit++;
+                break;
+            }
+        }
+    }
+    return hit >= 2; // two salient shared/overlapping tokens — the floor against chatter
+}
+/* ── The detector ─────────────────────────────────────────────────────────── */
+/**
+ * Scan a turn's text for the three senses. Pure and deterministic. Returns each
+ * detected signal with the user's own span and the cues that fired. High recall
+ * by design; the caller owns the firing gate (see module header).
+ */
+export function detectSignals(text, opts = {}) {
+    if (typeof text !== 'string' || text.trim().length < 6)
+        return [];
+    const openPredicates = (opts.openPredicates ?? []).filter((p) => typeof p === 'string' && p.trim());
+    const max = typeof opts.max === 'number' && opts.max > 0 ? opts.max : 4;
+    const out = [];
+    const seen = new Set();
+    const push = (kind, span, cues) => {
+        const key = `${kind}:${span}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        out.push({ kind, span, cues });
+    };
+    for (const c of clauses(text)) {
+        // 1) PREDICTION — a claim reality can later check: FUTURE ∧ (MEASURABLE ∨ COMPLETION).
+        const future = whichMatch('future', FUTURE, c);
+        const measurable = whichMatch('measurable', MEASURABLE, c);
+        const completion = whichMatch('completion', COMPLETION, c);
+        if (future && (measurable || completion)) {
+            push('prediction', c, [future, measurable, completion].filter((x) => !!x));
+        }
+        // 3) ASSUMPTION — reasoning that rests on a stated premise. Conservative: the
+        //    clause must ALSO carry a checkable/consequential cue, so a throwaway
+        //    "because I'm tired" does not register as a load-bearing assumption.
+        const conditional = whichMatch('conditional', CONDITIONAL, c);
+        if (conditional && (measurable || completion || future)) {
+            push('assumption', c, [conditional, measurable, completion, future].filter((x) => !!x));
+        }
+        // 2) OUTCOME — reality answering a KNOWN open prediction. Needs a resolution
+        //    cue AND overlap with an open predicate (the floor against past-tense chatter).
+        const resolved = whichMatch('resolved', RESOLVED, c);
+        if (resolved && openPredicates.some((p) => overlaps(c, p))) {
+            push('outcome', c, [resolved, 'matches-open-prediction']);
+        }
+    }
+    return out.slice(0, max);
+}
+/** The named cue groups, exported so the plugin mirror + a drift guard can pin
+ *  that the two surfaces detect the SAME things (single-source-of-truth rule). */
+export const CUE_GROUPS = { FUTURE, MEASURABLE, COMPLETION, RESOLVED, CONDITIONAL };

package/dist/lib/ledger-append.js

@@ -184,7 +184,17 @@ export async function appendLedger(argusDir, events, now, hints) {
             try {
                 fs.fsyncSync(fd);
             }
-            catch { /* fsync unsupported on this fs — the write still landed */ }
+            catch (e) {
+                // fsync legitimately fails as "unsupported" on some filesystems/handles
+                // (EINVAL/ENOTSUP/EOPNOTSUPP — tmpfs, pipes, certain network mounts):
+                // there the write still landed, so swallow. But EIO / ENOSPC / EBADF are
+                // REAL flush failures — the settlement is NOT durable. Rethrow so the
+                // tool returns isError instead of a false "saved!" (fail loud, never
+                // report a durability we don't have).
+                const code = e?.code;
+                if (code !== 'EINVAL' && code !== 'ENOTSUP' && code !== 'EOPNOTSUPP')
+                    throw e;
+            }
             resolve();
         }
         catch (e) {

package/dist/lib/ledger-replay.js

@@ -24,6 +24,9 @@ export function replayLedger(argusDir, today) {
     let dropped = 0;
     let skippedUnknown = 0;
     let oldestTs;
+    // Ids that ever saw a seal EVENT — survives settle/dismiss so total_sealed
+    // means "ever sealed", derived per-id (not per-line) below.
+    const everSealed = new Set();
     const watch = { anchors: new Map(), captures: [] };
     let raw;
     try {
@@ -86,7 +89,7 @@ export function replayLedger(argusDir, today) {
                 if (typeof ev['basis'] === 'string')
                     cur.basis = ev['basis'];
                 cur.status = 'sealed';
-                stats.total_sealed++;
+                everSealed.add(id);
                 break;
             }
             case 'amend':
@@ -123,6 +126,14 @@ export function replayLedger(argusDir, today) {
                 cur.status = 'settled';
                 const outcome = ev['outcome'];
                 cur.outcome = outcome;
+                // Retain what-reality-did from the settle line. This binary writes it as
+                // `decision`; the plugin CLI writes `what_happened` — read both (same
+                // dual-vocab tolerance as ts/at below) so a lost receipt is honestly
+                // reconstructable from the fold, whatever surface settled it.
+                const wh = typeof ev['decision'] === 'string' ? ev['decision']
+                    : typeof ev['what_happened'] === 'string' ? ev['what_happened'] : undefined;
+                if (wh)
+                    cur.what_happened = wh;
                 // Timestamp field is two-vocab across surfaces: this binary stamps `ts`,
                 // the plugin CLI stamps `at` — read both so a plugin-settled decision
                 // still gets its settled date on the receipt (O2 방1 finding ⑤).
@@ -131,36 +142,9 @@ export function replayLedger(argusDir, today) {
                     cur.settled_on = settledTs.slice(0, 10);
                 if (typeof ev['broken_premise_id'] === 'string')
                     cur.broken_premise_id = ev['broken_premise_id'];
-                // `happened` is the plugin CLI's legacy spelling of `held` (pre plain-canon
-                // unification). Old ledgers keep their bytes — the alias lives at read time.
-                // total_settled is incremented HERE, together with the bucket, so the
-                // invariant total_settled == sum(buckets) always holds. A settle event
-                // with an UNKNOWN outcome (a corrupt or externally-synced ledger — the
-                // zod enum blocks it on the MCP write path) still marks the decision
-                // settled, but is not counted into a calibration frequency it can't be
-                // categorized into (it used to inflate total_settled, so the surface read
-                // "N settled: 0 · 0 · 0 · 0" — a settle that vanished from its own breakdown).
-                if (outcome === 'held' || outcome === 'happened') {
-                    stats.held++;
-                    stats.total_settled++;
-                }
-                else if (outcome === 'avoided') {
-                    stats.avoided++;
-                    stats.total_settled++;
-                }
-                else if (outcome === 'partial') {
-                    stats.partial++;
-                    stats.total_settled++;
-                }
-                else if (outcome === 'missed') {
-                    stats.missed++;
-                    stats.total_settled++;
-                }
-                // 'still_pending' is NOT a terminal outcome — the MCP settle tool routes
-                // it to a `defer` event, never a `settle`. A settle+still_pending is
-                // therefore external/legacy only; it is not counted (the displayed
-                // breakdown shows four buckets, so counting it would make the visible
-                // line under-sum: "1 settled: 0 · 0 · 0 · 0"). v2 rejects it likewise.
+                // Buckets are NOT counted here — stats derive from the FOLDED STATE
+                // after the loop (see below), so a duplicated or reordered settle line
+                // in an externally-edited ledger cannot double-count a calibration.
                 break;
             }
             case 'defer': {
@@ -364,16 +348,50 @@ export function replayLedger(argusDir, today) {
                 break;
         }
     }
+    // Stats are DERIVED from the folded state, never counted per event line
+    // (state-derivation, 1.4.6 backlog): a hand-edited/merged ledger with a
+    // duplicated seal or settle line folds to the same state, so it must fold to
+    // the same calibration. Invariant preserved: total_settled == sum of the four
+    // buckets; a settled contract with an unknown/legacy outcome ('still_pending',
+    // corrupt) is settled but uncounted, exactly as before. `happened` stays the
+    // plugin CLI's legacy alias of `held` (old ledgers keep their bytes).
+    stats.total_sealed = everSealed.size;
+    for (const c of map.values()) {
+        if (c.status !== 'settled')
+            continue;
+        const o = c.outcome === 'happened' ? 'held' : c.outcome;
+        if (o === 'held') {
+            stats.held++;
+            stats.total_settled++;
+        }
+        else if (o === 'avoided') {
+            stats.avoided++;
+            stats.total_settled++;
+        }
+        else if (o === 'partial') {
+            stats.partial++;
+            stats.total_settled++;
+        }
+        else if (o === 'missed') {
+            stats.missed++;
+            stats.total_settled++;
+        }
+    }
     const overdue = [];
+    const undatedSeals = [];
     for (const [id, item] of map.entries()) {
         if (item.status !== 'sealed')
             continue;
         const date = asDate(item.check_by);
-        if (date && date <= today)
+        if (!date) {
+            undatedSeals.push(id);
+            continue;
+        } // sealed but no valid check-by → can never come due; surface it, don't lose it
+        if (date <= today)
             overdue.push({ id, date, text: item.text || '' });
     }
     overdue.sort((a, b) => (a.date < b.date ? -1 : 1));
-    return { today, overdue, ids, sealedPredicates, contracts: map, stats, watch, oldest_ts: oldestTs, integrity: { dropped_lines: dropped, skipped_unknown: skippedUnknown } };
+    return { today, overdue, ids, sealedPredicates, contracts: map, stats, watch, oldest_ts: oldestTs, integrity: { dropped_lines: dropped, skipped_unknown: skippedUnknown, ...(undatedSeals.length ? { undated_seals: undatedSeals } : {}) } };
 }
 /**
  * Bearing-file contract seeds that are due but not yet represented in the

package/dist/lib/locale-mismatch.js

@@ -39,8 +39,8 @@ export function appendLocaleMismatchNote(argusDir, args, result) {
             return result; // never decorate errors
         fs.writeFileSync(marker, new Date().toISOString());
         const note = spoken === 'ko'
-            ? '\n(설정 언어가 English로 고정되어 있어요. 한국어로 바꾸려면 argus_settings에 locale="ko" 한 번이면 돼요 — 이 안내는 다시 나오지 않아요.)'
-            : '\n(Your saved language is Korean. To switch, call argus_settings with locale="en" once — this note will not appear again.)';
+            ? '\n(설정 언어가 English로 고정되어 있어요. 한국어로 바꾸려면 argus_settings에 locale="ko" 한 번이면 돼요. 이 안내는 다시 나오지 않아요.)'
+            : '\n(Your saved language is Korean. To switch, call argus_settings with locale="en" once; this note will not appear again.)';
         const next = { ...sc, surface: `${sc['surface']}${note}` };
         result.structuredContent = next;
         result.content = [{ type: 'text', text: JSON.stringify(next, null, 2) }];

package/dist/lib/localize-result.js

@@ -29,14 +29,15 @@ 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를 쓰세요.)' },
+    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"로 목록과 번호를 확인하고, 전제가 없으면 argus_capture action="add_context"로 먼저 추가하세요.' },
     WHAT_HAPPENED_REQUIRED: { message: '실제로 일어난 일을 기록해야 합니다.', recovery: '사용자에게 실제 결과를 물어 what_happened에 그대로 전달하세요.' },
@@ -64,9 +65,28 @@ const ENUM_HINTS = {
     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',
+    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. Field-aware so an id
@@ -88,9 +108,12 @@ function koReason(issue, field) {
                 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': {
+            const vals = enumValuesFromMessage(issue.message);
+            if (vals.length)
+                return `허용되지 않는 값입니다 (가능: ${vals.join(' · ')})`;
             const hint = ENUM_HINTS[key];
             return hint ? `허용되지 않는 값입니다 (가능: ${hint})` : '허용되지 않는 값입니다';
         }
@@ -99,7 +122,7 @@ function koReason(issue, field) {
         case 'invalid_format':
         case 'invalid_string':
             if (key === 'id')
-                return '영문·숫자와 . _ - 만 쓸 수 있습니다 (한글·공백·특수문자 불가 — 예: "career-move")';
+                return '영문·숫자와 . _ - 만 쓸 수 있습니다 (한글·공백·특수문자 불가, 예: "career-move")';
             if (DATE_FIELDS.has(key))
                 return 'YYYY-MM-DD 형식의 날짜여야 합니다';
             return '형식이 올바르지 않습니다';
@@ -107,7 +130,7 @@ function koReason(issue, field) {
             // 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 '영문·숫자와 . _ - 만 쓸 수 있습니다 (한글·공백·특수문자 불가, 예: "career-move")';
             return '값을 확인해 주세요';
     }
 }
@@ -118,8 +141,19 @@ function localizeInvalidInput(fields) {
     const seen = new Set();
     const parts = [];
     for (const f of fields) {
-        const name = f.field === '(root)' ? '요청' : f.field;
-        const part = `${name}: ${koReason(f, f.field)}`;
+        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);
@@ -128,10 +162,91 @@ function localizeInvalidInput(fields) {
             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',
@@ -150,12 +265,23 @@ 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.
@@ -168,6 +294,27 @@ export function localizeToolResult(args, result) {
     let copy = code === 'INVALID_INPUT' && Array.isArray(sc['invalid_fields'])
         ? localizeInvalidInput(sc['invalid_fields'])
         : 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})/);