argus-decision-mcp 1.4.2 → 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/due-note.js

@@ -4,6 +4,7 @@ import { resolveToolArgusDir } from './argus-dir.js';
 import { resolveToday } from './resolve-today.js';
 import { configPath } from './layout.js';
 import { ambientDueFromState, ambientLine } from './ambient-due.js';
+import { stripUnsafeChars } from './untrusted.js';
 /**
  * Dispatch-level ambient due-note (plan v5 §5-2 · M1 §1.3, restraint rules §3.4).
  *
@@ -86,7 +87,11 @@ export function appendDueNote(toolName, args, result) {
             na.push('argus_check_in');
         // ── channel 2: the surface tail — session-once, mute-respecting, localized ──
         if (!ambientShownFor.has(dir) && !ambientMuted(dir)) {
-            const line = ambientLine(dir, due, state); // state lends the ledger's own voice
+            // This tail is appended AFTER envelope() already ran sanitizeOutput, so it
+            // must be sanitized itself — ambientLine reads ledger text (via `state`),
+            // and one future change that quotes the ledger's words would otherwise
+            // inject past the sanitizer.
+            const line = stripUnsafeChars(ambientLine(dir, due, state));
             if (line && typeof sc['surface'] === 'string') {
                 sc['surface'] = String(sc['surface']) + line;
                 data['ambient_shown'] = true;

package/dist/lib/elicit.js

@@ -9,6 +9,7 @@
  * elicitation (many don't yet), `elicit` returns null and callers fall back to
  * the text flow — no crash, no dead end.
  */
+import { stripUnsafeChars } from './untrusted.js';
 let _elicit = null;
 let _capable = null;
 /** Wire the elicitor and, optionally, a live capability probe. The probe must
@@ -33,7 +34,14 @@ export async function elicit(message, requestedSchema) {
     if (!_elicit)
         return null;
     try {
-        const res = await _elicit(message, requestedSchema);
+        // The elicitation `message` is a SEPARATE server→client request — it does NOT
+        // pass through envelope()/sanitizeOutput, so a raw predicate/premise
+        // interpolated into it (seal.ts, premises.ts) could carry ANSI escapes or a
+        // forged "AI VERDICT" line that a terminal host renders (screen-clear +
+        // spine spoof). Sanitize here, at the one seam every picker passes through,
+        // so no call site can forget. stripUnsafeChars keeps \n and \t (a message
+        // like `Record this?\n"…"` needs the newline).
+        const res = await _elicit(stripUnsafeChars(message), requestedSchema);
         return res.action === 'accept' && res.content ? res.content : null;
     }
     catch {

package/dist/lib/ledger-append.js

@@ -1,5 +1,6 @@
 import fs from 'fs';
 import fsP from 'fs/promises';
+import { randomUUID } from 'crypto';
 import { ledgerPath, ledgerDir } from './layout.js';
 import { SCHEMA_VERSION } from './spine.js';
 import { mirrorV1Events } from '../v2/mirror.js';
@@ -11,45 +12,116 @@ import { mirrorV1Events } from '../v2/mirror.js';
  * counting the calibration record. O_EXCL create is the atomic primitive;
  * a lock older than STALE_MS is treated as a crash leftover and stolen.
  */
-const LOCK_STALE_MS = 5000;
 const LOCK_WAIT_MS = 25;
-const LOCK_TRIES = 120; // ~3s worst case
+const LOCK_TRIES = 120; // ~3s worst case before failing OPEN (availability > strictness)
+// A normal critical section is milliseconds. 10 min = a zombie / reused pid, or a
+// lock synced in from a now-offline machine — the only cases old enough to steal
+// when we can't prove the holder is dead by pid.
+const LOCK_HELD_TOO_LONG_MS = 10 * 60_000;
+function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === 'EPERM';
+    } // EPERM = alive but not ours; ESRCH = dead
+}
+/**
+ * A held lock is stealable ONLY if its holder is provably gone: the pid is dead
+ * (same machine) or it has been held absurdly long. The old code stole any lock
+ * older than 5s by mtime, which let a LIVE holder inside a slow critical section
+ * (large ledger fsync, network FS) be robbed — two writers then both believed
+ * they held the lock and both appended, double-counting the calibration record.
+ */
+function lockStealable(lockPath) {
+    try {
+        let body = null;
+        try {
+            body = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+        }
+        catch { /* legacy/torn — fall to mtime */ }
+        if (body && typeof body === 'object') {
+            const b = body;
+            const started = typeof b.started_at === 'string' ? Date.parse(b.started_at) : NaN;
+            if (Number.isFinite(started) && Date.now() - started > LOCK_HELD_TOO_LONG_MS)
+                return true;
+            if (typeof b.pid === 'number')
+                return !pidAlive(b.pid);
+        }
+        // legacy bare-pid or malformed body: fall back to a GENEROUS mtime age.
+        return Date.now() - fs.statSync(lockPath).mtimeMs > LOCK_HELD_TOO_LONG_MS;
+    }
+    catch {
+        return true; // vanished between attempts — retry create
+    }
+}
 export async function withLedgerLock(argusDir, fn) {
     await fsP.mkdir(ledgerDir(argusDir), { recursive: true });
     const lockPath = ledgerPath(argusDir) + '.lock';
+    const nonce = randomUUID();
+    const bodyStr = JSON.stringify({ nonce, pid: process.pid, started_at: new Date().toISOString() });
+    const tmp = `${lockPath}.${nonce}.tmp`;
     let acquired = false;
     for (let i = 0; i < LOCK_TRIES && !acquired; i++) {
         try {
-            const fd = fs.openSync(lockPath, fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_WRONLY);
-            fs.writeSync(fd, String(process.pid), null, 'utf8');
-            fs.closeSync(fd);
+            // Complete the body first, then create the lock via an ATOMIC hardlink —
+            // the lock file exists only ever with a full body (no empty window a racer
+            // could misread as "crashed mid-write"), and EEXIST means someone holds it.
+            fs.writeFileSync(tmp, bodyStr, 'utf8');
+            fs.linkSync(tmp, lockPath);
             acquired = true;
         }
-        catch {
+        catch (e) {
+            const code = e.code;
+            if (code !== 'EEXIST') {
+                // linkSync unsupported on this FS (rare) — degrade to O_EXCL create.
+                try {
+                    const fd = fs.openSync(lockPath, fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_WRONLY);
+                    fs.writeSync(fd, bodyStr, null, 'utf8');
+                    fs.closeSync(fd);
+                    acquired = true;
+                }
+                catch { /* held — fall through to steal/wait */ }
+            }
+            if (!acquired) {
+                if (lockStealable(lockPath)) {
+                    // Steal ATOMICALLY via rename — exactly one racer's rename wins; the
+                    // loser throws (already moved) and retries. (unlink+recreate let two
+                    // stealers both delete then both create — the double-steal race.)
+                    try {
+                        const grave = `${lockPath}.stale-${nonce}`;
+                        fs.renameSync(lockPath, grave);
+                        fs.unlinkSync(grave);
+                    }
+                    catch { /* lost the steal to another racer — just retry create */ }
+                    continue; // retry immediately
+                }
+                await new Promise((r) => setTimeout(r, LOCK_WAIT_MS));
+            }
+        }
+        finally {
             try {
-                const st = fs.statSync(lockPath);
-                if (Date.now() - st.mtimeMs > LOCK_STALE_MS) {
-                    fs.unlinkSync(lockPath);
-                    continue;
-                } // crash leftover
+                fs.unlinkSync(tmp);
             }
-            catch {
-                continue;
-            } // lock vanished between attempts — retry immediately
-            await new Promise((r) => setTimeout(r, LOCK_WAIT_MS));
+            catch { /* linked away on success, or never created */ }
         }
     }
-    // Lock or no lock, the work proceeds (availability over strictness — a stuck
-    // lock must never brick the ledger; the steal above bounds the wait).
+    // Fail OPEN if never acquired (availability > strictness — a stuck lock must
+    // never brick the ledger; the steal logic bounds the wait to ~3s).
     try {
         return await fn();
     }
     finally {
         if (acquired) {
+            // Release only our OWN lock (nonce match) — never delete a lock a later
+            // holder created after ours was legitimately stolen (ABA guard).
             try {
-                fs.unlinkSync(lockPath);
+                const cur = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+                if (cur.nonce === nonce)
+                    fs.unlinkSync(lockPath);
             }
-            catch { /* already gone */ }
+            catch { /* gone, or not ours */ }
         }
     }
 }
@@ -112,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 {
@@ -32,7 +35,13 @@ export function replayLedger(argusDir, today) {
     catch {
         return { today, overdue: [], ids, sealedPredicates, contracts: map, stats, watch, integrity: { dropped_lines: 0, skipped_unknown: 0 } };
     }
-    for (const line of raw.split('\n')) {
+    for (const rawLine of raw.split('\n')) {
+        // Strip a per-LINE BOM: deBom only removes one at byte 0, but a U+FEFF can
+        // ride the first line of a concatenated second file, or be prepended per
+        // append by a Windows PowerShell co-writer (>>/Out-File) sharing the ledger.
+        // JSON.parse('{…}') throws, so without this a real settle line would
+        // be dropped and its outcome vanish from calibration.
+        const line = rawLine.charCodeAt(0) === 0xfeff ? rawLine.slice(1) : rawLine;
         if (!line.trim())
             continue;
         let ev;
@@ -80,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':
@@ -115,9 +124,16 @@ export function replayLedger(argusDir, today) {
                     map.set(id, cur);
                 } // B1: self-create
                 cur.status = 'settled';
-                stats.total_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 ⑤).
@@ -126,19 +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
-                // so the frequency buckets stay complete (total_settled == sum of buckets).
-                if (outcome === 'held' || outcome === 'happened')
-                    stats.held++;
-                else if (outcome === 'avoided')
-                    stats.avoided++;
-                else if (outcome === 'partial')
-                    stats.partial++;
-                else if (outcome === 'still_pending')
-                    stats.still_pending++;
-                else if (outcome === 'missed')
-                    stats.missed++;
+                // 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': {
@@ -342,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) }];