argus-decision-mcp 1.10.0 → 1.12.0

package/dist/lib/ambient-elicit.js

@@ -166,7 +166,11 @@ async function fire(dir, todayOverride) {
             ? `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'],
+            // 필수 필드 없음 (2026-07-27) — 필수 enum은 호스트가 접어서 렌더하고
+            // (펼치기 키가 하나 더 붙는다) 빈 Accept를 폼 안에서 빨갛게 막는다.
+            // 여기선 특히 나쁘다: 이건 사용자가 부르지도 않았는데 뜨는 선제
+            // 픽커라, 마찰 탈출구가 살아 있어야 한다. 빈 Accept는 아래에서
+            // 거절과 같은 길로 흘러 아무것도 쓰지 않는다 — 정직한 공백.
             properties: {
                 outcome: {
                     type: 'string',
@@ -193,7 +197,8 @@ async function fire(dir, todayOverride) {
                 ? '실제로 무슨 일이 있었나요? 한 줄이면 됩니다. 당신의 말 그대로 기록됩니다.'
                 : 'What actually happened, in one line? Recorded verbatim, in your words.', {
                 type: 'object',
-                required: ['what_happened'],
+                // 필수 필드 없음 — 같은 이유. 비우고 Accept하면 아래에서
+                // 기록하지 않는다(날조 금지). 폼이 막을 일이 아니다.
                 properties: {
                     what_happened: {
                         type: 'string', maxLength: 600,

package/dist/lib/locale.js

@@ -46,10 +46,22 @@ export function learnLocaleFromContent(argusDir, args) {
  *  month precisely because nothing ever said "your config disagrees with
  *  your words"). */
 export function contentLocaleFromArgs(args) {
-    const sample = CONTENT_FIELDS
+    const parts = CONTENT_FIELDS
         .map((k) => args[k])
-        .filter((v) => typeof v === 'string' && v.trim().length > 0)
-        .join('\n');
+        .filter((v) => typeof v === 'string' && v.trim().length > 0);
+    // User-authored words also arrive NESTED: a premises op=add call carries
+    // them only in premises[].text, invisible to the flat sample above — so a
+    // Korean add-premises call was answered in English until a later flat-field
+    // call re-taught the session (content battery S06, 2026-07-27).
+    const prems = args['premises'];
+    if (Array.isArray(prems)) {
+        for (const p of prems) {
+            const t = p?.['text'];
+            if (typeof t === 'string' && t.trim().length > 0)
+                parts.push(t);
+        }
+    }
+    const sample = parts.join('\n');
     return sample ? detectLocaleFromText(sample) : null;
 }
 /**

package/dist/lib/spine.js

@@ -56,11 +56,11 @@ export const SERVER_INSTRUCTIONS = [
     '',
     'Run these three as a CONTINUOUS BACKGROUND SENSE over the whole conversation — never as a checklist you make the user complete:',
     '',
-    '1. NOTICE A PREDICTION AS IT PASSES. When the user, doing their work, makes a claim reality can later check — "this should cut costs ~10%", "we\'ll ship Friday", "churn drops once we launch" — that IS a prediction, whether or not they call it one. The tell is a claim that pairs a direction or target with a horizon or a number (a "will / should / by-Friday" plus something measurable, or a ship/close/hire event). But it must be a claim the user COMMITS TO as their own: a question they put to YOU — which option is better, whether something will work, "can you draft / build / configure X" — is soliciting your help, not a prediction they are making, however weighty the topic; answer it and stay out. Do not wait to be told "save this." On a CONSEQUENTIAL one, offer ONCE: turn it into a falsifiable line in THEIR words (e.g. "ship Friday" → "shipped to TestFlight by 2026-07-10"), take a check-by from the horizon they named, and call argus_predict with confirm_draft:true — the one-tap confirm picker (Accept to keep, or reword / adjust the date, Decline to skip) IS the ask; never ask "want me to save this?" in prose and wait. When they dictate one word-for-word, just save it (predicate_owner:"user"). On a trivial or flat call, stay quiet; a blank is honest. Record exactly ONE falsifiable claim per predicate: if the turn carries two (e.g. a ship date AND closing deals, or two separate numbers), keep only the single most load-bearing one — never conjoin them with "and"/"so" into one predicate, which stacks two predictions that cannot settle cleanly. Notice it ONLY as it is spoken this turn: if the claim surfaced turns ago and the user has since moved to a different topic, the moment has passed — never reach back to resurface a past turn\'s claim mid-new-topic (a stale offer reads as not listening).',
+    '1. NOTICE A PREDICTION AS IT PASSES. When the user, doing their work, makes a claim reality can later check — "this should cut costs ~10%", "we\'ll ship Friday", "churn drops once we launch" — that IS a prediction, whether or not they call it one. The tell is a claim that pairs a direction or target with a horizon or a number (a "will / should / by-Friday" plus something measurable, or a ship/close/hire event). But it must be a claim the user COMMITS TO as their own: a question they put to YOU — which option is better, whether something will work, "can you draft / build / configure X" — is soliciting your help, not a prediction they are making, however weighty the topic; answer it and stay out. Do not wait to be told "save this." On a CONSEQUENTIAL one, offer ONCE: turn it into a falsifiable line in THEIR words (e.g. "ship Friday" → "shipped to TestFlight by 2026-07-10"), take a check-by from the horizon they named, and call argus_predict with confirm_draft:true — the one-tap confirm picker (Accept to keep, or reword / adjust the date, Decline to skip) IS the ask; never ask "want me to save this?" in prose and wait, and never DOUBLE-ask (a chat question beside the picker asks twice — any chat line accompanying the picker states what you noticed, it does not ask). Falsifiable means a stranger could mark it true or false later from observable facts: sharpen a vague verb ("flops", "잘 된다") into the measurable the user already named — a number, a date, a named event — and if they named none, anchor to the nearest observable comparison ("beats last launch\'s first-week signups"), still in their words. When they dictate one word-for-word, just save it (predicate_owner:"user"). On a trivial or flat call, stay quiet; a blank is honest. Record exactly ONE falsifiable claim per predicate: if the turn carries two (e.g. a ship date AND closing deals, or two separate numbers), keep only the single most load-bearing one — never conjoin them with "and"/"so" into one predicate, which stacks two predictions that cannot settle cleanly. Notice it ONLY as it is spoken this turn: if the claim surfaced turns ago and the user has since moved to a different topic, the moment has passed — never reach back to resurface a past turn\'s claim mid-new-topic (a stale offer reads as not listening).',
     '',
     '2. NOTICE THE OUTCOME AS IT SURFACES. This is the whole reason you live in the conversation. You already know which predictions are open (argus_check_in at the session start, or read the ledger). So when the user\'s ongoing work reveals what reality did — "oh, the migration went fine", "we missed the number", "we shipped Tuesday" — recognize that it settles a tracked prediction and record it THEN with argus_resolve, in the user\'s own words. Do NOT make them come back to report, and do NOT wait for the check-by date when reality has already spoken in the conversation. Never infer an outcome the user did not state; if reality has not answered, leave it open (or argus_resolve outcome:"still_pending" with defer_to). Recording an outcome is neutral bookkeeping — never praise, never grade.',
     '',
-    '3. NOTICE THE LOAD-BEARING ASSUMPTION. A consequential decision rests on something — and it counts even when the user hands it to you as work to execute ("here is the plan, start with X" is still a plan whose load-bearing premise you can notice while you do the task). The tell is a conditional the call would flip on if it broke — an "as long as / because / only if / assuming" clause. If the user reasoned it out loud, catch the single assumption it most rests on in their own words (argus_capture action=open or add_context). If they did not spell it out, offer ONE sharp candidate as your draft — exactly one premise in one clause, never two stacked (predicate_owner/source "ai_surfaced", your wording preserved) for a one-tap confirm — never a guess passed off as their fact, never more than one. The tells of stacking to avoid: an "and", a "so"/"therefore", or a second fact/date/number in the premise — split them and keep only the ONE the decision most rests on. The load-bearing premise is usually NOT the reason they said out loud: the stated reason is the surface, and the real premise is the specific, often-unstated fact the decision REVERSES on if it turns out false. ("Drop the free tier because it is too generous" rests on the unstated bet that squeezed free users convert to paid, not that free is what drives signups; "defer billing to next sprint" rests on the bet that nobody churns while it is absent; "we are fine as long as the vendor deal holds" rests on whether that deal is actually locked in, not on the volume continuing.) Name that specific mechanism in concrete, falsifiable terms — not a generic restatement of their rationale, and not a paraphrase of the clause they already spoke. Update a changed external fact with argus_capture action=update_fact and honest provenance; state the fact, and whether to revisit is the user\'s call. Draft it only for the decision in the user\'s CURRENT message — never reach back to surface an assumption from an earlier turn the user has already moved past; once they are on a new topic, that decision\'s moment is closed.',
+    '3. NOTICE THE LOAD-BEARING ASSUMPTION. A consequential decision rests on something — and it counts even when the user hands it to you as work to execute ("here is the plan, start with X" is still a plan whose load-bearing premise you can notice while you do the task). The tell is a conditional the call would flip on if it broke — an "as long as / because / only if / assuming" clause. If the user reasoned it out loud, catch the single assumption it most rests on in their own words (argus_capture action=open or add_context). If they did not spell it out, offer ONE sharp candidate as your draft — exactly one premise in one clause, never two stacked (predicate_owner/source "ai_surfaced", your wording preserved) for a one-tap confirm — the confirm IS the ask, so no parallel chat question — never a guess passed off as their fact, never more than one. The tells of stacking to avoid: an "and", a "so"/"therefore", or a second fact/date/number in the premise — split them and keep only the ONE the decision most rests on. The load-bearing premise is usually NOT the reason they said out loud: the stated reason is the surface, and the real premise is the specific, often-unstated fact the decision REVERSES on if it turns out false. ("Drop the free tier because it is too generous" rests on the unstated bet that squeezed free users convert to paid, not that free is what drives signups; "defer billing to next sprint" rests on the bet that nobody churns while it is absent; "we are fine as long as the vendor deal holds" rests on whether that deal is actually locked in, not on the volume continuing.) Name that specific mechanism in concrete, falsifiable terms — not a generic restatement of their rationale, and not a paraphrase of the clause they already spoke. Update a changed external fact with argus_capture action=update_fact and honest provenance; state the fact, and whether to revisit is the user\'s call. Draft it only for the decision in the user\'s CURRENT message — never reach back to surface an assumption from an earlier turn the user has already moved past; once they are on a new topic, that decision\'s moment is closed.',
     '',
     'Never break the spine while sensing:',
     '- No verdict, ever. No "you were right/wrong", no "the stronger case is X", no disclaimed lean. There is no verdict tool because there is no verdict to give.',

package/dist/lib/surface-lint.js

@@ -69,7 +69,10 @@ export function lintEnvelope(env) {
             if (hasUnsafeChars(surface)) {
                 out.push({ severity: 'red', rule: 'unsafe-chars', message: 'surface carries control/bidi/zero-width characters (terminal-escape or homograph injection vector)' });
             }
-            if (surface.length > SURFACE_MAX) {
+            // A keepsake card (seal plate / judgment receipt / logbook — the boxed
+            // '┌─ ARGUS' artifacts) is deliberately bigger than a line; length-lint
+            // only the prose surfaces.
+            if (surface.length > SURFACE_MAX && !surface.includes('┌─ ARGUS')) {
                 out.push({ severity: 'yellow', rule: 'surface-too-long', message: `surface is ${surface.length} chars (>${SURFACE_MAX}) — a line, not a paragraph`, excerpt: surface.slice(0, 140) });
             }
         }

package/dist/lib/surfaces.js

@@ -126,7 +126,10 @@ export const SURFACES = {
             footer: 'argus · prediction saved → result recorded ⚓',
         },
         wake: {
-            header: 'ARGUS · YOUR DECISIONS',
+            // The logbook: what a ship keeps of its voyage — dates, positions, what
+            // happened. Identity without ceremony (창업자 2026-07-27: 터미널에도
+            // 항해 정체성을, 과하지 않게).
+            header: 'ARGUS · LOGBOOK',
             counts: (total, sealed, settled) => `decisions ${total} · awaiting check ${sealed} · results recorded ${settled}`,
             overdue_group: (n) => `past check-by (${n})`,
             overdue_hint: '← argus_resolve',
@@ -136,7 +139,7 @@ export const SURFACES = {
             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}`,
+            record_since: (date) => `logbook since ${date}`,
         },
         receipt: {
             header: 'ARGUS · JUDGMENT RECEIPT',
@@ -277,7 +280,7 @@ export const SURFACES = {
             footer: 'argus · 예측 저장 → 실제 결과 기록 ⚓',
         },
         wake: {
-            header: 'ARGUS · 결정 기록',
+            header: 'ARGUS · 항해일지',
             // "예측 저장 0"은 정산이 끝나면 0으로 줄어 "저장한 적 없음"처럼 읽혔다
             // (1.4.6 재진단): 이 칸의 의미는 '지금 확인일을 기다리는 것'이다.
             counts: (total, sealed, settled) => `결정 ${total} · 확인 대기 ${sealed} · 결과 기록 ${settled}`,
@@ -289,7 +292,7 @@ export const SURFACES = {
             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 · 판단 영수증',
@@ -327,7 +330,7 @@ export const SURFACES = {
                     factual: '이건 답이 있는 질문이지, 열어둘 결정이 아닙니다.',
                     already_closed: '이미 내린 결정입니다. Argus는 이걸 다시 열지 않습니다.',
                     flat: '선택지가 거의 대등합니다. 억지로 만들 핵심 질문이 없습니다.',
-                    reversible_low_stakes: '되돌리기 쉽고 크게 걸린 것도 없는 결정이에요.',
+                    reversible_low_stakes: '되돌리기 쉽고 크게 걸린 것도 없는 결정입니다.',
                     low_stakes: '걸린 것이 별로 없습니다. 그대로 두는 편이 무난합니다.',
                 },
                 reason_fallback: '여기서 억지로 지어낼 결정은 없습니다.',
@@ -335,7 +338,7 @@ export const SURFACES = {
                 watch_exit: ' 기록하지 않고 그대로 두어도 괜찮습니다.',
                 reconfirm: '신호가 서로 어긋납니다 (걸린 것은 큰데 되돌리기는 쉽습니다). 더 나아가기 전에 이 둘을 다시 짚어 보세요.',
                 opened_with_crux: (crux) => `열었습니다. 이 결정을 좌우하는 단 하나의 질문: ${crux}`,
-                opened_bare: '이 결정, 기록해뒀어요.',
+                opened_bare: '이 결정, 기록해뒀습니다.',
                 lean_disclosure: '핵심 질문을 짚는 것 자체가 뒤집히는 쪽을 희미하게 가리킬 수 있습니다. 그렇게 남는 쏠림은 알려진 한계일 뿐, 이 결정에 대한 평가가 아닙니다.',
             },
             seal: {
@@ -349,7 +352,7 @@ export const SURFACES = {
                 settled: (outcome, predicate) => `실제 결과를 기록했습니다: ${({ held: '예측대로 됐다', avoided: '걱정한 일은 안 일어났다', partial: '일부만 맞았다', missed: '예측이 빗나갔다' })[outcome]}.${predicate ? ` (예측: "${predicate}".)` : ''} 영수증에 예측과 실제가 나란히 남습니다. 평가는 없습니다.`,
                 sync_failed: (reason) => ` (계정 동기화가 안 됐습니다. ${reason}. 결과는 로컬에 안전합니다. 동기화되기 전까지 계정은 이걸 계속 "확인 필요"로 표시할 수 있습니다. 나중에 argus_settings action=sync를 시도하세요.)`,
                 deferred: (newDate) => `아직 결과를 기록하지 않았습니다. 현실이 답하지 않았으니 평가한 것도 없습니다. ${newDate}에 다시 가져오겠습니다.`,
-                defer_dismissed: '접어뒀습니다. 이건 이제 답이 필요 없어요. 평가한 것은 없습니다.',
+                defer_dismissed: '접어뒀습니다. 이건 이제 답이 필요 없습니다. 평가한 것은 없습니다.',
             },
             recheck: {
                 baseline: (ref, finding, source, cadenceDays) => `P${ref} 기준값을 기록했습니다: "${finding}" (${source}). ${cadenceDays}일 뒤에 다시 확인하길 권합니다.`,

package/dist/tools/premises.js

@@ -444,7 +444,10 @@ async function opResolve(dir, id, now, state, existing, a) {
         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'] });
+            : `Your open question on this decision: "${premise.text}". What is your call now, in your own words? (You can also leave it open.)`, 
+        // 필수 필드 없음 — 빈 채 Accept는 아래 `if (!decision)`가 정직하게
+        // 되묻는다. "아직 못 정했다"도 유효한 답이므로 폼이 막아선 안 된다.
+        { type: 'object', properties: { decision: { type: 'string', maxLength: 400, description: qLocale === 'ko' ? '당신의 판단, 당신의 표현. (아직이면 비워두고 Accept)' : 'Your call, your words. (Leave blank and Accept if still undecided.)' } } });
         decision = typeof got?.['decision'] === 'string' ? got['decision'].trim() : '';
     }
     if (!decision) {

package/dist/tools/settle.js

@@ -54,7 +54,9 @@ export const settle = {
                 // a bilingual "그렇게 됐다 (held)" mishmash showed to BOTH a Korean and an
                 // English user. Voice follows the language the decision was sealed in.
                 const pickerLocale = resolveResponseLocale(dir, current.predicate ?? null);
-                const picked = await elicit(pickerLocale === 'ko' ? '현실이 어떻게 답했나요?' : 'What did reality do?', {
+                const picked = await elicit(pickerLocale === 'ko'
+                    ? '현실이 어떻게 답했나요?\n\n결과를 고르고 Accept · 아직 모르겠으면 Decline.'
+                    : 'What did reality do?\n\nPick the outcome and Accept · Decline if you are not sure yet.', {
                     type: 'object',
                     properties: {
                         outcome: {
@@ -75,7 +77,19 @@ export const settle = {
                             description: pickerLocale === 'ko' ? '무슨 일이 있었는지 당신의 말로 한 줄. (아직 불분명이면 비워도 됩니다.)' : "One line on what actually happened, in your words. (Leave blank if still unclear.)",
                         },
                     },
-                    required: ['outcome'],
+                    // 필수 필드 없음 (2026-07-27, 창업자 도그푸딩 스크린샷).
+                    //
+                    // R34가 봉인/전제 픽커에서 걷어낸 바로 그 패턴이 정산 픽커엔
+                    // 그대로 남아 있었다. 필수 enum은 호스트에서 접힌 채 뜨고
+                    // (`→ to expand`), 사용자가 what_happened만 적고 Accept하면 폼
+                    // 안에서 빨간 "This field is required"로 막힌다 — 우리가 서버에서
+                    // 없앤 막다름이 클라이언트로 자리만 옮긴 것이다. 하필 정산은
+                    // 귀환 경로, 이 제품의 두 번째 인상 한복판이다.
+                    //
+                    // 비운 채 Accept해도 잃는 게 없다: 아래 `if (!outcome)`가 이미
+                    // OUTCOME_REQUIRED로 정직하게 되묻고 모델이 대화로 물어본다.
+                    // 폼 안에서 빨간 글씨로 막느니 한 번 더 묻는 쪽이 낫다.
+                    // 스파인 무접촉 — 비었다고 결과를 추론하지 않는다.
                 });
                 const v = picked?.['outcome'];
                 if (v === 'held' || v === 'avoided' || v === 'partial' || v === 'still_pending' || v === 'missed')
@@ -271,7 +285,12 @@ async function deferStillPending(args) {
     //    matters should not be forced into a fake future date).
     let dismissChosen = false;
     if (!newDate && canElicit()) {
-        const picked = await elicit(locale === 'ko' ? '아직 답이 안 나왔군요. 언제 다시 볼까요?' : "Not answered yet. When should I look again?", { type: 'object', required: ['when'], properties: { when: {
+        const picked = await elicit(locale === 'ko'
+            ? '아직 답이 안 나왔군요. 언제 다시 볼까요?\n\n고르고 Accept · 지금 정하기 싫으면 Decline.'
+            : "Not answered yet. When should I look again?\n\nPick one and Accept · Decline to leave it for now.", 
+        // 필수 필드 없음 — 같은 이유. 빈 채 Accept는 Decline과 같은 길로
+        // 흐르고(newDate undefined → 아래 정직한 에러), 폼 안에서 막지 않는다.
+        { type: 'object', properties: { when: {
                     type: 'string', enum: ['week', 'month', 'quarter', 'dismiss'],
                     enumNames: locale === 'ko'
                         ? ['약 1주 뒤', '약 1달 뒤', '약 3달 뒤', '이제 필요 없음 (접기)']

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "argus-decision-mcp",
-  "version": "1.10.0",
+  "version": "1.12.0",
   "description": "Argus decision-accountability MCP server — clarify a decision, save a falsifiable prediction, and record what reality did. The model never grades you.",
   "type": "module",
   "main": "dist/index.js",