argus-decision-mcp 1.4.2 → 1.4.6

package/dist/lib/surfaces.js

@@ -88,6 +88,7 @@ export const SURFACES = {
         },
         checkin: {
             nothing_due: 'Nothing is due right now.',
+            first_run: 'Argus is ready. Tell me a decision you are weighing. I can clarify what it rests on, save a prediction with a check-by date, and record what actually happened when that date arrives. Nothing is tracked yet; describe a decision to begin.',
             account_hint: ' This screen reads the local decision record only. Predictions saved in your account show up with argus_settings action=sync.',
             upcoming: (n, days) => ` ${n} coming due within ${days} day(s). Informational; no result is due yet.`,
             due_contracts: (n) => `${n} saved prediction(s) past check-by. Time to record what happened (argus_resolve).`,
@@ -131,7 +132,8 @@ export const SURFACES = {
             days_past: (n) => `${n}d past`,
             waiting_group: (n) => `waiting for the outcome (${n})`,
             answer_on: (date) => `due ${date}`,
-            settled_group: (n, held, avoided, partial) => `results recorded (${n}): held ${held} · avoided ${avoided} · partial ${partial}`,
+            settled_group: (n, held, avoided, partial, missed) => `results recorded (${n}): held ${held} · avoided ${avoided} · partial ${partial} · missed ${missed}`,
+            outcome_label: (o) => ({ held: 'held', avoided: 'avoided', partial: 'partial', missed: 'missed', still_pending: 'pending' })[o] ?? o,
             more: (n) => `… (+${n})`,
             record_since: (date) => `on record since ${date}`,
         },
@@ -145,8 +147,8 @@ export const SURFACES = {
             human_only: 'HUMAN-ONLY CALL',
             made_by_label: '…made by',
             made_by: 'Me. (not the model)',
-            called_as: '…called it',
-            basis_label: (v) => ({ judgment: 'judgment', luck: 'luck', mixed: 'a mix of both', unsure: 'not sure' })[v] ?? v,
+            called_as: '…looking back',
+            basis_label: (v) => ({ judgment: 'mostly my judgment', luck: 'mostly luck', mixed: 'a mix of both', unsure: 'not sure' })[v] ?? v,
             // A blank field, stated neutrally — "you skipped naming this" read as a
             // nag about the user's completeness on a receipt they wanted plain
             // (experience loop, settler: a zero-judgment surface must not grade even
@@ -176,7 +178,7 @@ export const SURFACES = {
                 watch_exit: ' Leaving it unrecorded is fine.',
                 reconfirm: 'These signals look contradictory (high stakes yet easily reversible). Re-confirm stakes and reversibility before going further.',
                 opened_with_crux: (crux) => `Opened. The one question that decides this: ${crux}`,
-                opened_bare: 'Opened. Surface exactly ONE neutral crux question (a question, not a fork or a lean), then save a falsifiable prediction.',
+                opened_bare: 'Opened. If one neutral question decides this, naming it is the next step. Then save a falsifiable prediction.',
             },
             seal: {
                 sealed: (predicate, checkBy) => `Prediction saved. "${predicate}" Check-by is ${checkBy}. Come back then with argus_resolve to record what happened.`,
@@ -230,6 +232,7 @@ export const SURFACES = {
         },
         checkin: {
             nothing_due: '지금 확인할 차례가 된 것은 없습니다.',
+            first_run: 'Argus가 준비됐습니다. 지금 고민 중인 결정을 하나 말해 주세요. 그 결정이 어떤 전제 위에 서 있는지 정리하고, 예측과 확인일을 저장한 뒤, 그 날이 오면 실제로 어떻게 됐는지 기록합니다. 아직 기록된 것은 없습니다. 결정을 말하면 시작합니다.',
             account_hint: ' 이 화면은 로컬 판단 기록만 읽습니다. 계정에 저장한 예측은 argus_settings action=sync로 가져올 수 있습니다.',
             upcoming: (n, days) => ` ${days}일 안에 확인일이 오는 예측이 ${n}건 있습니다. 아직 결과를 기록할 때는 아닙니다.`,
             due_contracts: (n) => `저장한 예측 ${n}건이 확인일을 지났습니다. 실제 결과를 기록할 차례입니다 (argus_resolve).`,
@@ -273,9 +276,10 @@ export const SURFACES = {
             days_past: (n) => `${n}일 경과`,
             waiting_group: (n) => `결과를 기다리는 중 (${n})`,
             answer_on: (date) => `답 ${date}`,
-            settled_group: (n, held, avoided, partial) => `결과 기록됨 (${n}): 그렇게 됨 ${held} · 피함 ${avoided} · 부분 ${partial}`,
+            settled_group: (n, held, avoided, partial, missed) => `결과 기록됨 (${n}): 그렇게 됨 ${held} · 피함 ${avoided} · 부분 ${partial} · 빗나감 ${missed}`,
+            outcome_label: (o) => ({ held: '그렇게 됨', avoided: '피함', partial: '부분', missed: '빗나감', still_pending: '대기' })[o] ?? o,
             more: (n) => `… (+${n})`,
-            record_since: (date) => `기록 시작 ${date} 부터`,
+            record_since: (date) => `${date}부터 기록`,
         },
         receipt: {
             header: 'ARGUS · 판단 영수증',
@@ -287,8 +291,8 @@ export const SURFACES = {
             human_only: '사람만의 판단',
             made_by_label: '…내린 사람',
             made_by: '나. (모델이 아니라)',
-            called_as: '…판단한 내용',
-            basis_label: (v) => ({ judgment: '판단', luck: '운', mixed: '반반', unsure: '모르겠음' })[v] ?? v,
+            called_as: '…돌아보니',
+            basis_label: (v) => ({ judgment: '판단이 컸다', luck: '운이 컸다', mixed: '판단 반 운 반', unsure: '잘 모르겠다' })[v] ?? v,
             // 빈 칸을 사실 그대로. "이름 붙이지 않고 넘어갔습니다"는 사용자의 완성도를
             // 지적하는 잔소리로 읽혔다 (experience loop, settler).
             skipped: '— (없음)',
@@ -305,23 +309,23 @@ export const SURFACES = {
         tools: {
             open_decision: {
                 reason: {
-                    vent: '이건 소리 내어 말할 일이지, 억지로 만들 갈림길이 아닙니다.',
+                    vent: '이건 소리 내어 말할 일이지, 억지로 결정으로 만들 일이 아닙니다.',
                     factual: '이건 답이 있는 질문이지, 열어둘 결정이 아닙니다.',
                     already_closed: '이미 내린 결정입니다. Argus는 이걸 다시 열지 않습니다.',
                     flat: '선택지가 거의 대등합니다. 억지로 만들 핵심 질문이 없습니다.',
                     reversible_low_stakes: '되돌리기 쉽고 걸린 것도 적습니다. 직접 해보는 것이 곧 검증입니다.',
                     low_stakes: '걸린 것이 별로 없습니다. 그대로 두는 편이 무난합니다.',
                 },
-                reason_fallback: '여기서 지어낼 갈림길은 없습니다.',
+                reason_fallback: '여기서 억지로 지어낼 결정은 없습니다.',
                 leave_coda: '그대로 두는 것도 여전히 진짜 선택지입니다.',
                 watch_exit: ' 기록하지 않고 그대로 두어도 괜찮습니다.',
-                reconfirm: '신호가 서로 어긋납니다 (걸린 것은 큰데 되돌리기는 쉽습니다). 더 나아가기 전에 stakes와 reversibility를 다시 확인하세요.',
-                opened_with_crux: (crux) => `열었습니다. 이걸 가르는 단 하나의 질문: ${crux}`,
-                opened_bare: '열었습니다. 중립적인 핵심 질문 딱 하나만 꺼내세요(갈림길도 기울임도 아닌 질문). 그다음 반증 가능한 예측을 저장하세요.',
+                reconfirm: '신호가 서로 어긋납니다 (걸린 것은 큰데 되돌리기는 쉽습니다). 더 나아가기 전에 이 둘을 다시 짚어 보세요.',
+                opened_with_crux: (crux) => `열었습니다. 이 결정을 좌우하는 단 하나의 질문: ${crux}`,
+                opened_bare: '열었습니다. 이 결정을 좌우하는 핵심 질문 하나가 있다면 그걸 짚어 보는 게 다음 단계입니다. 그다음 반증 가능한 예측을 저장하면 됩니다.',
             },
             seal: {
                 sealed: (predicate, checkBy) => `예측을 저장했습니다. "${predicate}" 확인일은 ${checkBy}입니다. 그날 argus_resolve로 실제로 어땠는지 기록하세요.`,
-                nudge_assumption: ' 원하면 핵심 전제를 적어 나중에 같이 확인할 수 있어요.',
+                nudge_assumption: ' 원하면 핵심 전제를 적어두면 나중에 같이 확인합니다.',
                 synced: ' 계정에 동기화했습니다. 확인일이 오면 이메일로 알려드립니다.',
                 sync_failed: (reason) => ` (계정 동기화가 안 됐습니다. ${reason}. 예측은 로컬에 안전합니다. 동기화되기 전까지는 이메일 알림이 오지 않습니다. 나중에 argus_settings action=sync를 시도하세요.)`,
             },

package/dist/lib/tool-presentation.js

@@ -6,7 +6,7 @@ const KO_TOOL_PRESENTATION = {
     argus_predict: { titleKo: '예측 저장', descriptionKo: '현실이 확인할 수 있는 예측과 확인일을 저장하고 작성 주체를 정직하게 기록합니다.' },
     argus_resolve: { titleKo: '실제 결과 기록', descriptionKo: '확인일이 된 예측에 실제로 일어난 일을 기록합니다. Argus는 결과를 평가하지 않습니다.' },
     argus_patterns: { titleKo: '판단 기록 보기', descriptionKo: '진행 중인 결정, 전체 계약, 판단 영수증, 전제, 누적 기록을 읽고, 당신이 쓴 예측·전제와 그 결과를 되읽는 reflection을 봅니다.' },
-    argus_open_decision: { titleKo: '결정 열기', descriptionKo: '중요하고 되돌리기 어려운 진짜 갈림길인지 확인하고, 맞다면 중립적인 핵심 질문 하나로 결정을 엽니다.' },
+    argus_open_decision: { titleKo: '결정 열기', descriptionKo: '중요하고 되돌리기 어려운 진짜 결정인지 확인하고, 맞다면 중립적인 핵심 질문 하나로 결정을 엽니다.' },
     argus_review: { titleKo: '문서 판단 검수', descriptionKo: '기존 문서의 주장·근거·숨은 전제·사람이 판단할 지점을 원문 위치에 연결해 검수합니다.' },
     argus_premises: { titleKo: '결정 전제 추적', descriptionKo: '결정이 기대는 사실과 미결 질문을 출처와 함께 추가·수정·정리합니다.' },
     argus_seal: { titleKo: '예측 봉인', descriptionKo: '현실이 확인할 수 있는 예측과 확인일을 봉인합니다. 예측의 작성 주체를 정직하게 기록합니다.' },

package/dist/lib/untrusted.js

@@ -36,14 +36,14 @@
  * escape sequences.
  */
 // eslint-disable-next-line no-control-regex
-const CONTROL_CHARS = /[\u0000-\u0008\u000B-\u001F\u007F]/g;
+const CONTROL_CHARS = /[\u0000-\u0008\u000B-\u001F\u007F-\u009F]/g;
 /**
  * Invisible and direction-controlling characters: zero-width space/joiners,
  * LTR/RTL marks, bidi embeddings and isolates. These render as nothing (or
  * reverse the surrounding text) for the human while the model reads them intact
  * - the classic "the human and the model see different strings" gap.
  */
-const INVISIBLE_CHARS = /[\u200B-\u200F\u202A-\u202E\u2066-\u2069\uFEFF]/g;
+const INVISIBLE_CHARS = /[\u200B-\u200F\u202A-\u202E\u2028\u2029\u2066-\u2069\uFEFF]/g;
 /** Strip the mechanical-injection vectors from one string. Newlines and tabs
  *  survive (a rendered receipt is multi-line ASCII art). */
 export function stripUnsafeChars(s) {
@@ -52,7 +52,7 @@ export function stripUnsafeChars(s) {
 /** True when the string carries anything stripUnsafeChars would remove. The
  *  surface lint uses this so a raw path fails loudly in CI. */
 export function hasUnsafeChars(s) {
-    return /[\u0000-\u0008\u000B-\u001F\u007F\u200B-\u200F\u202A-\u202E\u2066-\u2069\uFEFF]/.test(s);
+    return /[\u0000-\u0008\u000B-\u001F\u007F-\u009F\u200B-\u200F\u202A-\u202E\u2028\u2029\u2066-\u2069\uFEFF]/.test(s);
 }
 /**
  * Quote recorded text INLINE into a one-line surface: strip the unsafe

package/dist/lib/validate-seal.js

@@ -1,4 +1,4 @@
-import { asDate } from './resolve-today.js';
+import { asDate, isRealDate } from './resolve-today.js';
 // Obvious non-falsifiable vibes. Weak/advisory only.
 const VIBE = /\b(go well|be fine|be good|be great|work out|feel right|be successful|do better|improve somehow)\b/i;
 // Korean vibe-predicates (12 P1-4): "잘 될 것 같다 아마도" sealed — and was
@@ -14,10 +14,13 @@ export function validateSeal(predicate, checkBy, today) {
         };
     }
     const date = asDate(checkBy);
-    if (!date) {
+    if (!date || !isRealDate(date)) {
+        // A calendar-invalid but digit-shaped date (2026-13-01, 2026-09-31) must be
+        // refused here: it would otherwise seal a malformed .ics and a wrong due
+        // date, and only be caught by luck if it happened to sort before today.
         return {
             code: 'BAD_CHECK_BY',
-            message: 'check_by must be a real date in YYYY-MM-DD form.',
+            message: 'check_by must be a real calendar date in YYYY-MM-DD form.',
             recovery: 'Pick the date when reality will answer, e.g. "2026-09-01".',
         };
     }

package/dist/resources.js

@@ -5,6 +5,7 @@ import { readReceipt } from './lib/receipt.js';
 import { safeSegment } from './lib/safe-path.js';
 import { logDebug } from './lib/log.js';
 import { duePremises, groupDuePremises, isMonitored, isDueForRecheck } from './lib/premises.js';
+import { sanitizeOutput } from './lib/untrusted.js';
 /**
  * MCP Resources (blueprint §4.3). Read-only context the host can auto-inject —
  * the ledger, the due contracts, a receipt, the current bearing. They are
@@ -56,7 +57,11 @@ export function readResource(uri) {
         return { contents: [unbound(uri)] };
     }
     const today = resolveToday({});
-    const payload = computePayload(uri, dir, today);
+    // Resources are model-facing (auto-injected context) and bypass the envelope()
+    // sanitizer. JSON.stringify escapes C0/ANSI but NOT bidi (U+202E) / zero-width
+    // (U+200B) — the "human and model see different strings" gap. Run the same
+    // chokepoint sanitizer over the payload first.
+    const payload = sanitizeOutput(computePayload(uri, dir, today));
     return { contents: [{ uri, mimeType: JSON_MIME, text: JSON.stringify(payload, null, 2) }] };
 }
 function computePayload(uri, dir, today) {

package/dist/server.js

@@ -135,18 +135,23 @@ export async function createServer() {
                 ? { ...parsed.data, today_override: rawArgs['today_override'] }
                 : parsed.data;
             const raw = await serialize(() => tool.handler(callArgs));
+            let result = localizeToolResult(callArgs, raw);
             // Learn the session's language from the user's OWN words (never env), so
             // every later surface — including contentless ones (errors, recall) — stays
-            // in that language start to finish. Runs after the handler (auto-init has
-            // created config by now) and before localize, so even this call's result
-            // is localized to the just-learned locale.
-            const dirForLocale = resolveToolArgusDir(callArgs['argus_dir']);
-            learnLocaleFromContent(dirForLocale, callArgs);
-            // §9.7 O1: if an EXPLICIT pin contradicts the language the user is
-            // actually speaking, say so once (fact + argus_settings handle) — a pin
-            // is never silently overridden, but it must not be silently obeyed
-            // against the user's own words forever either.
-            const result = appendLocaleMismatchNote(dirForLocale, callArgs, localizeToolResult(callArgs, raw));
+            // in that language start to finish. This is BEST-EFFORT: a bad argus_dir
+            // (relative / unexpanded ${VAR} — the #1 setup mistake) already surfaced a
+            // proper, localized error from the handler; re-resolving it here to learn
+            // the locale must NOT re-throw and clobber that with a raw INTERNAL_ERROR.
+            try {
+                const dirForLocale = resolveToolArgusDir(callArgs['argus_dir']);
+                learnLocaleFromContent(dirForLocale, callArgs);
+                // §9.7 O1: if an EXPLICIT pin contradicts the language the user is
+                // actually speaking, say so once (fact + argus_settings handle) — a pin
+                // is never silently overridden, but it must not be silently obeyed
+                // against the user's own words forever either.
+                result = appendLocaleMismatchNote(dirForLocale, callArgs, result);
+            }
+            catch { /* invalid argus_dir — the handler already surfaced it; skip locale learning */ }
             // Opt-in usage signal: which tool ran + that it didn't crash. Carries no
             // arguments — never the decision content. Fire-and-forget (see telemetry.ts).
             recordToolCall(name, true);

package/dist/tools/amend-dismiss.js

@@ -8,6 +8,7 @@ import { validateSeal } from '../lib/validate-seal.js';
 import { appendLedger, withLedgerLock } from '../lib/ledger-append.js';
 import { pushToAccount } from '../lib/push-account.js';
 import { accountPushId } from '../lib/install-id.js';
+import { writeReturnCalendarEvent } from '../lib/calendar.js';
 import { resolveResponseLocale, SURFACES, humanizeSyncReason } from '../lib/surfaces.js';
 import { SCHEMA_VERSION } from '../lib/spine.js';
 import { z } from 'zod';
@@ -35,6 +36,19 @@ export const amend = {
             const today = resolveToday({ override: a['today_override'] });
             const current = resolveContract(dir, id, today);
             guardTransition(current.state, 'amend'); // GOALPOST_MOVED / DECISION_CLOSED / ILLEGAL_TRANSITION
+            // Goalpost guard, extended past the `due` state: a still_pending defer
+            // re-arms the contract to `sealed`, which the state machine then treats
+            // like a never-due decision — so due→defer→sealed→amend let the PREDICATE
+            // be rewritten AFTER the original check-by had already arrived (reality had
+            // begun answering). Re-scheduling the date via defer stays legitimate;
+            // rewriting the claim does not. Refuse only the predicate change post-defer.
+            if (a['predicate'] != null && (current.entry?.defer_count ?? 0) > 0) {
+                return toolError({
+                    ok: false, tool: 'argus_amend', error_code: 'GOALPOST_MOVED',
+                    message: 'Cannot rewrite the prediction after the decision was deferred — its original check-by has passed.',
+                    recovery: 'Re-schedule the date if the timeline moved, or settle it against reality. The claim itself is locked once its check-by first arrived.',
+                });
+            }
             const predicate = a['predicate'] ?? current.predicate;
             const checkBy = a['check_by'] ?? current.check_by;
             if (a['check_by'] != null || a['predicate'] != null) {
@@ -54,6 +68,13 @@ export const amend = {
             const v2Write = asV2WriteField(mirrorAmend);
             // Response voice follows the (new or existing) predicate (M4).
             const locale = resolveResponseLocale(dir, predicate);
+            // Regenerate the .ics so the return reminder rings on the AMENDED date /
+            // text. amend used to update the ledger + bearing + account but leave the
+            // on-disk calendar file — the only account-free return channel — pointing
+            // at the OLD check-by, so the reminder fired on the stale date.
+            if ((a['check_by'] != null || a['predicate'] != null) && predicate && checkBy) {
+                await writeReturnCalendarEvent(dir, { id, predicate, check_by: checkBy, created_at: now, locale });
+            }
             const T = SURFACES[locale].tools.amend;
             // Tell the ACCOUNT the date moved. Without this, argus_amend was silent to
             // the account forever: the Companion Brief kept emailing on the ORIGINAL

package/dist/tools/check-in.js

@@ -37,7 +37,11 @@ export const checkIn = {
     description: 'Return decision contracts whose check-by date has arrived (and optionally upcoming ones). A return nudge — reads and routes to argus_settle. If nothing is due, it says so and stops; it does not manufacture engagement.',
     inputSchema,
     outputSchema: ENVELOPE_OUTPUT_SCHEMA,
-    annotations: { title: 'Check what is due', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    // readOnlyHint:false — honest: the FIRST call on an un-initialized dir routes
+    // through ensureInitialized, which creates .argus/ (dirs, config, .gitignore,
+    // bound marker, v2 registry). "read-only" must not lie (hardening principle),
+    // even though every subsequent call is a pure read.
+    annotations: { title: 'Check what is due', readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     handler: async (a) => {
         try {
             const dir = resolveToolArgusDir(a['argus_dir']);
@@ -235,6 +239,25 @@ export const checkIn = {
                 const accountHint = (process.env.ARGUS_TOKEN || '').trim()
                     ? S.account_hint
                     : '';
+                // First-run vs caught-up: SERVER_INSTRUCTIONS routes EVERY session start
+                // to check_in, so a brand-new user used to land on the same "nothing due"
+                // + stop a veteran sees — a dead end at the flagship cold-start. Fire the
+                // on-ramp ONLY when the surface would otherwise be a BARE "nothing due":
+                // no decisions, no watch mirror, no account, no upcoming/fleet/integrity.
+                // Anything else (a caught-up veteran, a watch anchor, an account seal)
+                // keeps nothing_due, so the mirror/silence contracts are untouched.
+                // `!ledger.oldest_ts` = the ledger has NO events at all (not just no
+                // decisions — no watch anchors either), the one true "brand new" signal.
+                // Excluded under ARGUS_V2_DEBUG (the v2 observation channel expects its
+                // diagnostic payload even on an empty v1 ledger).
+                if (!ledger.oldest_ts && !mirrorLine && !accountHint && !upcomingLine && !fleetLine && !integrityLine && process.env['ARGUS_V2_DEBUG'] !== '1') {
+                    return envelope({
+                        ok: true, tool: 'argus_check_in',
+                        surface: S.first_run,
+                        next_actions: ['argus_capture'],
+                        data: { due: [], due_count: 0, due_premises: [], due_premise_count: 0, due_open_questions: [], due_open_question_count: 0, first_run: true, today },
+                    });
+                }
                 return envelope({
                     ok: true, tool: 'argus_check_in',
                     surface: mirrorLine + S.nothing_due + accountHint + upcomingLine + fleetLine + integrityLine,

package/dist/tools/errors.js

@@ -12,15 +12,15 @@ import { localizedErrorCopy } from '../lib/localized-message.js';
 export function handleToolException(tool, e) {
     if (e instanceof ArgusDirError) {
         const copy = localizedErrorCopy(null, undefined, {
-            en: { message: e.message, recovery: 'Pass an absolute .argus path with no "..".' },
-            ko: { message: 'Argus 기록 경로가 올바르지 않습니다.', recovery: '".."이 없는 절대 .argus 경로를 전달하세요.' },
+            en: { message: e.message, recovery: 'Set ARGUS_DIR (or the per-call argus_dir) to an absolute path with no "..", e.g. C:\\Users\\you\\.argus or /Users/you/.argus — or remove ARGUS_DIR to use the default ~/.argus. A ${VAR} may be passed through unexpanded by your host.' },
+            ko: { message: 'Argus 기록 경로(argus_dir / ARGUS_DIR)가 올바르지 않습니다.', recovery: '절대 경로여야 하고 ".."을 포함할 수 없습니다. MCP 설정에서 절대 경로(예: C:\\Users\\이름\\.argus, /Users/이름/.argus)로 바꾸거나 ARGUS_DIR을 지워 기본값(~/.argus)을 쓰세요. ${...} 같은 변수는 호스트가 확장하지 못할 수 있습니다.' },
         });
         return toolError({ ok: false, tool, error_code: e.code, ...copy });
     }
     if (e instanceof PathSafetyError) {
         const copy = localizedErrorCopy(null, undefined, {
-            en: { message: e.message, recovery: 'Use ids/labels matching [A-Za-z0-9._-] only.' },
-            ko: { message: '안전하지 않은 id 또는 label입니다.', recovery: 'id와 label에는 [A-Za-z0-9._-] 문자만 사용하세요.' },
+            en: { message: e.message, recovery: 'Use A-Za-z0-9._- only, with no trailing dot or space, and avoid reserved device names (con, nul, com1…). Example: "career-move".' },
+            ko: { message: '이 id 또는 label은 쓸 수 없습니다.', recovery: '영문·숫자·. _ - 만 쓰되, 끝에 마침표나 공백을 두지 말고 con·nul·com1 같은 예약어는 피하세요. 예: "career-move".' },
         });
         return toolError({ ok: false, tool, error_code: e.code, ...copy });
     }

package/dist/tools/init-config.js

@@ -131,6 +131,20 @@ export const config = {
             const writeKeys = ['locale', 'boss', 'team', 'archive', 'ambient_mute', 'premise_sync'].filter((k) => k in a);
             const existing = readConfig(dir) ?? { schema_version: SCHEMA_VERSION, locale: detectLocale(dir), boss: null, team: null, archive: null };
             if (writeKeys.length === 0) {
+                // action=update with no writable field is a MISTAKE (a read is
+                // action=status). Saying "Config read." reports the OPPOSITE operation
+                // as a success and hides that nothing changed — name the supported set.
+                if (a['action'] === 'update') {
+                    return envelope({
+                        ok: true, tool: 'argus_config',
+                        surface: localizedMessage(dir, undefined, {
+                            en: 'No setting was changed. Supported fields: locale (ko/en), ambient_mute (true/false), premise_sync (true/false).',
+                            ko: '변경된 설정이 없습니다. 바꿀 수 있는 항목: locale(ko/en), ambient_mute(true/false), premise_sync(true/false).',
+                        }),
+                        next_actions: ['stop'],
+                        data: { config: existing, existed: !!readConfig(dir), changed: [] },
+                    });
+                }
                 return envelope({
                     ok: true,
                     tool: 'argus_config',

package/dist/tools/premises.js

@@ -4,7 +4,7 @@ import { replayLedger } from '../lib/ledger-replay.js';
 import { resolveToday } from '../lib/resolve-today.js';
 import { resolveContract } from '../lib/resolve-contract.js';
 import { guardTransition } from '../lib/state-machine.js';
-import { appendLedger } from '../lib/ledger-append.js';
+import { appendLedger, withLedgerLock } from '../lib/ledger-append.js';
 import { premiseId, resolvePremiseRef, normalizePremiseText, MAX_ACTIVE_PREMISES, MAX_LOAD_BEARING, } from '../lib/premises.js';
 import { elicit } from '../lib/elicit.js';
 import { resolveResponseLocale } from '../lib/surfaces.js';
@@ -251,8 +251,21 @@ async function opAdd(dir, id, today, now, state, existing, a) {
         // premise added under a today_override in real use.
         anchor_date: today,
     }));
-    if (events.length > 0)
-        await appendLedger(dir, events, now);
+    if (events.length > 0) {
+        // §9.4 두 기기 안전: the ordinal base was read OUTSIDE any lock, so two
+        // concurrent sessions adding premises to the same decision both saw max=4
+        // and both assigned ordinal 5 — a DUPLICATE P5 whose second premise is
+        // unreferenceable (resolvePremiseRef returns only the first). Re-derive the
+        // ordinals under the ledger lock from a fresh fold, then append — the same
+        // read-check-append-under-lock discipline seal/settle use.
+        await withLedgerLock(dir, async () => {
+            const freshPremises = replayLedger(dir, today).contracts.get(id)?.premises ?? [];
+            let ord = freshPremises.reduce((m, p) => Math.max(m, p.ordinal), 0) + 1;
+            for (const e of events)
+                e.ordinal = ord++;
+            await appendLedger(dir, events, now);
+        });
+    }
     // Full echo — the silent-premise defense: the host always has the material to
     // show the user exactly what was recorded (plan v5 §2).
     const echo = events.map((e) => ({
@@ -374,7 +387,12 @@ async function opResolve(dir, id, now, state, existing, a) {
     if (!decision) {
         // MCP-native elicitation: ask the USER directly. The question replays their
         // own open question verbatim and takes free text — no options, no leans.
-        const got = await elicit(`Your open question on this decision: "${premise.text}". What is your call now, in your own words? (You can also leave it open.)`, { type: 'object', properties: { decision: { type: 'string', maxLength: 400, description: 'Your call, your words.' } }, required: ['decision'] });
+        // Localize like the rest of the tool — a Korean user closing their own
+        // Korean question used to get an English form. Voice follows the question.
+        const qLocale = resolveResponseLocale(dir, premise.text);
+        const got = await elicit(qLocale === 'ko'
+            ? `이 결정에 남겨둔 질문입니다: "${premise.text}". 지금은 어떻게 판단하시나요? 당신의 말로 적어주세요. (그대로 열어둬도 됩니다.)`
+            : `Your open question on this decision: "${premise.text}". What is your call now, in your own words? (You can also leave it open.)`, { type: 'object', properties: { decision: { type: 'string', maxLength: 400, description: qLocale === 'ko' ? '당신의 판단, 당신의 표현.' : 'Your call, your words.' } }, required: ['decision'] });
         decision = typeof got?.['decision'] === 'string' ? got['decision'].trim() : '';
     }
     if (!decision) {

package/dist/tools/public-tools.js

@@ -16,6 +16,7 @@ import { checkIn } from './check-in.js';
 import { settle } from './settle.js';
 import { detectLocaleFromText } from '../lib/locale.js';
 import { gitCommonDirOf } from '../v2/git-discovery.js';
+import { handleToolException } from './errors.js';
 const premiseInput = z.strictObject({
     text: z.string().min(3).max(400).describe('결정이 기대는 사실 또는 아직 답하지 못한 질문입니다. 사용자의 표현을 그대로 씁니다.').optional(),
     kind: z.enum(['premise', 'open_question']).default('premise').describe('premise는 확인할 전제, open_question은 사용자가 아직 답하지 않은 질문입니다.'),
@@ -69,7 +70,7 @@ const decideSchema = z.discriminatedUnion('action', [
         id: zId.describe('대상 결정 id입니다.'),
         ref: z.string().max(64).describe('재확인할 전제 번호 또는 id입니다.'),
         finding: z.string().min(1).max(800).describe('현재 확인한 사실을 비교 가능한 한 문장으로 적습니다.'),
-        numeric_value: z.number().describe('수치 사실의 현재 값을 명시적으로 전달합니다.').optional(),
+        numeric_value: z.number().finite().describe('수치 사실의 현재 값을 명시적으로 전달합니다.').optional(),
         changed: z.boolean().describe('문장형 사실이 기준값에서 실질적으로 달라졌는지 표시합니다.').optional(),
         // default user_stated: the runtime union validates BEFORE the handler-level
         // default can apply, so a required source here made every real update_fact
@@ -112,7 +113,7 @@ const decidePublicSchema = z.strictObject({
     ref: z.string().max(64).describe('답하거나 재확인할 전제 또는 미결 질문 번호입니다.').optional(),
     reconsider_cadence_days: z.number().int().min(1).max(365).describe('미결 질문을 다시 볼 간격(일)입니다.').optional(),
     finding: z.string().min(1).max(800).describe('현재 확인한 사실을 비교 가능한 한 문장으로 적습니다.').optional(),
-    numeric_value: z.number().describe('수치 사실의 현재 값을 명시적으로 전달합니다.').optional(),
+    numeric_value: z.number().finite().describe('수치 사실의 현재 값을 명시적으로 전달합니다.').optional(),
     changed: z.boolean().describe('문장형 사실이 기준값에서 실질적으로 달라졌는지 표시합니다.').optional(),
     source: z.enum(['url', 'user_stated', 'host_reported']).describe('현재 사실을 확인한 출처입니다.').optional(),
     source_detail: z.string().max(1000).describe('출처 URL 또는 짧은 인용 정보입니다.').optional(),
@@ -266,10 +267,20 @@ async function ensureInitialized(args) {
     return null;
 }
 async function runPublic(publicName, args, handler) {
-    const initError = await ensureInitialized(args);
-    if (initError)
-        return rewriteResult(initError, publicName);
-    return rewriteResult(await handler(args), publicName);
+    try {
+        const initError = await ensureInitialized(args);
+        if (initError)
+            return rewriteResult(initError, publicName);
+        return rewriteResult(await handler(args), publicName);
+    }
+    catch (e) {
+        // ensureInitialized() → resolveToolArgusDir() THROWS ArgusDirError on a
+        // relative or unexpanded-${VAR} argus_dir — the #1 setup mistake. Without
+        // this catch the throw escaped to the server's String(e) fallback, so the
+        // user saw a raw "INTERNAL_ERROR: ArgusDirError: …" with no recovery. Route
+        // it through the typed handler to get the localized message + fix.
+        return rewriteResult(handleToolException(publicName, e), publicName);
+    }
 }
 export const decide = {
     name: 'argus_capture',
@@ -335,7 +346,9 @@ export const history = {
     description: 'Read decisions already on record: what is open, all contracts, one Judgment Receipt, one decision’s premises, the accumulated timeline, or a reflection that replays your own past predictions and premises next to what reality did. Read-only.',
     inputSchema: historySchema,
     outputSchema: ENVELOPE_OUTPUT_SCHEMA,
-    annotations: { title: 'View judgment history', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    // readOnlyHint:false — like argus_check_in, the first call auto-initializes
+    // .argus/ via ensureInitialized, so it can write on first use (honest hint).
+    annotations: { title: 'View judgment history', readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     handler: (a) => {
         const viewMap = {
             active: 'bearing',

package/dist/tools/recall.js

@@ -18,9 +18,9 @@ const byCheckBy = (a, b) => (a.check_by || '9999-99-99') < (b.check_by || '9999-
 function frequencyStatement(s, locale) {
     const n = s.total_settled;
     if (n === 0)
-        return locale === 'ko' ? '아직 정산된 결정이 없습니다 — 요약할 것이 없습니다.' : 'No settled decisions yet — nothing to summarize.';
+        return locale === 'ko' ? '아직 결과를 기록한 결정이 없습니다 — 요약할 것이 없습니다.' : 'No settled decisions yet — nothing to summarize.';
     return locale === 'ko'
-        ? `정산 ${n}건 중: 그렇게 됨 ${s.held} · 피함 ${s.avoided} · 부분 ${s.partial} · 빗나감 ${s.missed}.`
+        ? `결과 기록 ${n}건 중: 그렇게 됨 ${s.held} · 피함 ${s.avoided} · 부분 ${s.partial} · 빗나감 ${s.missed}.`
         : `Of ${n} settled: ${s.held} held, ${s.avoided} avoided, ${s.partial} partial, ${s.missed} missed.`;
 }
 /** Voice for a read view: the view's own text, else any ledger user-text, else
@@ -97,8 +97,11 @@ export const recall = {
                 // don't render it. The full formatted card stays in data.receipt_text as
                 // the keepsake. (User-value review, 2026-07-14.)
                 const clip = (s, n) => { const t = String(s ?? '').trim(); return t.length > n ? `${t.slice(0, n)}…` : t; };
+                // One word per outcome across the whole flow: surfaces.ts settle uses
+                // 부분/대기, so the receipt-recall surface must match (was 부분적/아직 —
+                // three words for `partial` in one decision's lifecycle).
                 const label = receiptLocale === 'ko'
-                    ? { held: '그렇게 됨', avoided: '피함', partial: '부분적', missed: '빗나감', still_pending: '아직' }
+                    ? { held: '그렇게 됨', avoided: '피함', partial: '부분', missed: '빗나감', still_pending: '대기' }
                     : { held: 'held', avoided: 'avoided', partial: 'partial', missed: 'missed', still_pending: 'still pending' };
                 const outcomeKey = (r.outcome ?? 'still_pending');
                 const receiptSurface = receiptLocale === 'ko'
@@ -203,8 +206,13 @@ export const recall = {
                 const shown = all.slice(0, 60);
                 const locale = readVoice(dir, ledger, all[0]?.predicate);
                 const wake = wakeText(ledger, today, dir);
+                // Empty ledger → an on-ramp with a capture handle, not "0 decision(s)" +
+                // stop (a "show me my decisions" newcomer must get a next move).
+                const allSurface = all.length === 0
+                    ? (locale === 'ko' ? '아직 기록에 남은 결정이 없습니다. 고민 중인 결정을 말하면 argus_capture로 시작합니다.' : 'No decisions on record yet. Describe a decision you are weighing and argus_capture begins it.')
+                    : (locale === 'ko' ? `기록에 남은 결정 ${all.length}건.` : `${all.length} decision(s) on record.`);
                 return envelope({
-                    ok: true, tool: 'argus_recall', surface: locale === 'ko' ? `기록에 남은 결정 ${all.length}건.` : `${all.length} decision(s) on record.`, next_actions: ['stop'],
+                    ok: true, tool: 'argus_recall', surface: allSurface, next_actions: all.length === 0 ? ['argus_capture'] : ['stop'],
                     data: { contracts: shown, ...(all.length > shown.length ? { truncated: all.length - shown.length } : {}), today, ...(wake ? { wake_text: wake } : {}) },
                 });
             }
@@ -244,7 +252,7 @@ export const recall = {
                 return envelope({
                     ok: true, tool: 'argus_recall',
                     surface: rn > 0 ? `${framing} ${rfreq}` : framing,
-                    next_actions: ['stop'],
+                    next_actions: ledger.ids.size === 0 ? ['argus_capture'] : ['stop'], // empty ledger → a handle, not a dead end
                     data: {
                         judgment_tier: null, judgment_score: null, // spine rule 2 — never a verdict about who you are
                         reflections, reflection_count: reflections.length,
@@ -278,7 +286,7 @@ export const recall = {
             return envelope({
                 ok: true, tool: 'argus_recall',
                 surface: premiseAttribution ? `${freq} ${premiseAttribution}` : freq,
-                next_actions: ['stop'],
+                next_actions: ledger.ids.size === 0 ? ['argus_capture'] : ['stop'], // empty ledger → a handle, not a dead end
                 data: {
                     judgment_tier: null, judgment_score: null, // drift-guard asserts these stay null
                     frequency_statement: freq,

package/dist/tools/recheck.js

@@ -10,6 +10,33 @@ import { resolveResponseLocale, SURFACES } from '../lib/surfaces.js';
 import { envelope, toolError } from '../lib/envelope.js';
 import { ENVELOPE_OUTPUT_SCHEMA, zArgusDir, zId, zDate } from './tool-types.js';
 import { handleToolException } from './errors.js';
+/**
+ * The materiality engine's `uncertain` reasons are hard-coded Korean and used to
+ * splice STRAIGHT into the English recheck surface (`T.uncertain(reason)`) — an
+ * English user rechecking an ambiguous numeric premise saw a Korean sentence
+ * mid-line. Localize at the surface: map each known reason to an English hint,
+ * and fall back to a generic "define a rule" line so no Korean can ever leak.
+ * (The raw `reason` stays in `data.reason` for diagnostics.)
+ */
+function localizeUncertainReason(reason, locale) {
+    if (locale === 'ko')
+        return reason;
+    if (reason.includes('비율(%)'))
+        return 'this reads as a percentage — say whether the change is in percentage-points or on the complement (100 − value) axis';
+    if (reason.includes('near-zero'))
+        return 'the values sit near zero — set a rule (a delta or a safety floor) so this can be judged mechanically';
+    if (reason.includes('임계 경계'))
+        return 'the relative change sits right on the threshold — set a rule or a dead-band';
+    if (reason.includes('zero_meaningful') || reason.includes('부호 전환'))
+        return 'the sign flipped, but whether zero is meaningful is undeclared — set a rule';
+    if (reason.includes('boundary') || reason.includes('경계 도달'))
+        return 'the value reached the threshold line, but inclusive/exclusive is unspecified — set the boundary';
+    if (reason.includes('기준값 0'))
+        return 'the baseline is 0, so a relative rule cannot apply — set a delta rule';
+    if (reason.includes('canonical scale') || reason.includes('비수치'))
+        return 'this label is non-numeric — set a canonical scale so it can be judged mechanically';
+    return 'this change is ambiguous under the current rule — define a materiality rule so it can be judged mechanically';
+}
 /**
  * argus_recheck — re-check one premise against reality (plan v5 §2, §7.1).
  *
@@ -30,7 +57,7 @@ const inputSchema = z.strictObject({
     id: zId.describe('The decision id.'),
     ref: z.string().max(64).describe('Which premise — ordinal ("P1"), premise_id, or unambiguous prefix.'),
     finding: z.string().min(3).max(400).describe('The CURRENT state of the fact, one literal comparable sentence. e.g. "base rate 3.75% after a 25bp hike".'),
-    numeric_value: z.number().optional().describe('The fact\'s current number, named EXPLICITLY (e.g. 3.75). Never extracted from prose by regex. When present, drift is decided mechanically (>=10% move or sign flip).'),
+    numeric_value: z.number().finite().optional().describe('The fact\'s current number, named EXPLICITLY (e.g. 3.75). Never extracted from prose by regex. When present, drift is decided mechanically (>=10% move or sign flip).'),
     changed: z.boolean().optional().describe('Text premises only: has the FACT materially changed vs the recorded baseline? A research finding about external reality (provenance required) — never a judgment of the user.'),
     source: z.enum(['url', 'user_stated', 'host_reported']).describe('Where the finding comes from. host_reported = the model\'s own research without a citation — recorded honestly as such.'),
     source_detail: z.string().max(300).optional().describe('URL or short citation when source="url".'),
@@ -63,8 +90,16 @@ export const recheck = {
             }
             const finding = String(a['finding']);
             // Response voice follows the finding sentence (M4): config > text > env.
-            const T = SURFACES[resolveResponseLocale(dir, String(a['finding']))].tools.recheck;
+            const rLocale = resolveResponseLocale(dir, String(a['finding']));
+            const T = SURFACES[rLocale].tools.recheck;
             const source = String(a['source']);
+            // Localize the source enum before it reaches the surface — a recheck line
+            // printed the raw "(host_reported)" / "(user_stated)" token to the user.
+            const SOURCE_LABEL = {
+                ko: { url: '출처 링크', user_stated: '당신이 확인함', host_reported: '어시스턴트 조사' },
+                en: { url: 'from a cited source', user_stated: 'as you reported it', host_reported: "from the assistant's own research" },
+            };
+            const srcLabel = SOURCE_LABEL[rLocale]?.[source] ?? source;
             const sourceDetail = a['source_detail'];
             const numericValue = a['numeric_value'];
             const changed = a['changed'];
@@ -143,14 +178,14 @@ export const recheck = {
                 ? T.uncertain_heuristic_note
                 : '';
             const surface = baselineOnly
-                ? T.baseline(premise.ordinal, finding, source, recheckCadenceDays(premise))
+                ? T.baseline(premise.ordinal, finding, srcLabel, recheckCadenceDays(premise))
                 : status === 'material'
-                    ? T.material(premise.ordinal, prior.finding, finding, source)
+                    ? T.material(premise.ordinal, prior.finding, finding, srcLabel)
                     : status === 'uncertain'
                         // M2 §4/§7: uncertain surfaces the FACT only — no handle, no fork. The
                         // user decides whether to define a rule or leave it.
-                        ? `${T.uncertain(premise.ordinal, reason)}${heuristicNote}`
-                        : T.unchanged(premise.ordinal, source);
+                        ? `${T.uncertain(premise.ordinal, localizeUncertainReason(reason, rLocale))}${heuristicNote}`
+                        : T.unchanged(premise.ordinal, srcLabel);
             // ── SPINE (M2 §4, mirror clause): the handle auto-attaches ONLY on
             //    `material`. `uncertain` (depends / boundary / rule-uncovered) NEVER
             //    auto-attaches argus_recall — that would manufacture a fork on a flat