argus-decision-mcp 1.7.0 → 1.9.0

package/dist/lib/ambient-prefs.js

@@ -0,0 +1,37 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { STANDING_SENSE_REFRESH } from './spine.js';
+export function readAmbientPrefs() {
+    const fallback = { sensitivity: 'normal', optOut: false };
+    try {
+        const home = process.env['ARGUS_HOME'] || path.join(os.homedir(), '.argus');
+        const cfg = JSON.parse(fs.readFileSync(path.join(home, 'config.json'), 'utf8'));
+        const amb = cfg && typeof cfg['ambient'] === 'object' && cfg['ambient'] !== null
+            ? cfg['ambient'] : null;
+        if (!amb)
+            return fallback;
+        const s = amb['sensitivity'];
+        return {
+            sensitivity: s === 'low' || s === 'high' ? s : 'normal',
+            optOut: amb['opt_out'] === true,
+        };
+    }
+    catch {
+        return fallback; // 설정 없음/파손 = 기본 감도 (조용한 기본, 시끄러운 실패 불필요 — 선호 부재는 gap이 아니다)
+    }
+}
+const LOW_SUFFIX = ' (User sensitivity preference: LOW — offer only on the very clearest consequential commitments; when in any doubt, stay silent.)';
+const HIGH_SUFFIX = ' (User sensitivity preference: HIGH — they asked for more surfacing; the restraint gate still applies, but on a consequential call do not skip the one offer out of excess caution.)';
+const OFF_SUFFIX = ' (User preference: ambient offers are OFF — make no unsolicited predict/capture offers. Recording an outcome the user themselves states is bookkeeping and stays on.)';
+/** 감도 선호를 반영한 배경감각 줄 — 모든 주입 지점은 이걸 쓴다(직접 상수 금지). */
+export function tunedStandingSense() {
+    const p = readAmbientPrefs();
+    if (p.optOut)
+        return STANDING_SENSE_REFRESH + OFF_SUFFIX;
+    if (p.sensitivity === 'low')
+        return STANDING_SENSE_REFRESH + LOW_SUFFIX;
+    if (p.sensitivity === 'high')
+        return STANDING_SENSE_REFRESH + HIGH_SUFFIX;
+    return STANDING_SENSE_REFRESH;
+}

package/dist/lib/spine.js

@@ -56,7 +56,7 @@ 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 Keep/Reword/Skip picker 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. 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.',
     '',
@@ -80,7 +80,7 @@ export const SERVER_INSTRUCTIONS = [
  * 뿐이므로, Argus 툴이 불릴 때마다 이 한 줄이 배경감각을 되살린다). 지침이지
  * 평결이 아니며, SERVER_INSTRUCTIONS의 3감각과 같은 내용의 압축이다.
  */
-export const STANDING_SENSE_REFRESH = 'Background sense from here on: the open predictions above are unsettled. If the user\'s ongoing words reveal what reality did to one — even in passing, even by pronoun ("그거 결국 잘 됐어") — record it with argus_resolve in their words THEN; never infer an outcome they did not state. Keep noticing new checkable claims (argus_predict, offer once on a consequential one) and the load-bearing assumption a decision rests on — often unstated (argus_capture, at most one, as your ai_surfaced draft). But stay silent when the turn only asks you to do a task, poses a logistics or recommendation question, is small talk, or concerns a call the user already closed — and once they have moved on to another topic. A blank is honest; when unsure, do nothing.';
+export const STANDING_SENSE_REFRESH = 'Background sense from here on: the open predictions above are unsettled. If the user\'s ongoing words reveal what reality did to one — even in passing, even by pronoun ("그거 결국 잘 됐어") — record it with argus_resolve in their words THEN; never infer an outcome they did not state. Keep noticing new checkable claims (argus_predict, offer once on a consequential one) and the load-bearing assumption a decision rests on — often unstated (argus_capture, at most one, as your ai_surfaced draft). But stay silent when the turn only asks you to do a task, poses a logistics or recommendation question, is small talk, or concerns a call the user already closed — and once they have moved on to another topic. ("Only a task" holds only while no consequential call rides under it: a plan handed to you as a to-do — "here is the plan, start with X" — is still a plan; do the task AND offer its single load-bearing premise once.) A blank is honest; when unsure, do nothing.';
 /** The schema version stamped on every persisted record (addendum N1). */
 export const SCHEMA_VERSION = 1;
 /**

package/dist/tools/check-in.js

@@ -5,8 +5,9 @@ import { duePremises, groupDuePremises, dueOpenQuestions } from '../lib/premises
 import { readReceipt, SKIPPED } from '../lib/receipt.js';
 import { SURFACES, resolveResponseLocale, surfaceLocale } from '../lib/surfaces.js';
 import { z } from 'zod';
-import { STANDING_SENSE_REFRESH } from '../lib/spine.js';
+import { tunedStandingSense } from '../lib/ambient-prefs.js';
 import { envelope } from '../lib/envelope.js';
+import { canElicit } from '../lib/elicit.js';
 import { ENVELOPE_OUTPUT_SCHEMA, zArgusDir, zDate } from './tool-types.js';
 import { handleToolException } from './errors.js';
 import { briefDivergence, readV2Brief } from '../v2/mirror.js';
@@ -271,14 +272,14 @@ export const checkIn = {
                         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 },
+                        data: { due: [], due_count: 0, due_premises: [], due_premise_count: 0, due_open_questions: [], due_open_question_count: 0, first_run: true, today, picker: canElicit() ? 'one_tap' : 'text_fallback' },
                     });
                 }
                 return envelope({
                     ok: true, tool: 'argus_check_in',
                     surface: mirrorLine + S.nothing_due + accountHint + upcomingLine + fleetLine + integrityLine,
                     next_actions: ['stop'],
-                    data: { due: [], due_count: 0, due_premises: [], due_premise_count: 0, due_open_questions: [], due_open_question_count: 0, ...(openWatch.length ? { open_predictions: openWatch, standing_sense: STANDING_SENSE_REFRESH } : {}), ...(upDays > 0 ? { upcoming } : {}), ...(a['fleet'] === true ? { fleet: fleetRows } : {}), ...watchData, today, integrity: ledger.integrity, ...(process.env['ARGUS_V2_DEBUG'] === '1' ? { capture_status: captureStatus, v2_brief: readV2Brief(dir, today), v2_divergence: briefDivergence([], readV2Brief(dir, today)) } : {}) },
+                    data: { due: [], due_count: 0, due_premises: [], due_premise_count: 0, due_open_questions: [], due_open_question_count: 0, picker: canElicit() ? 'one_tap' : 'text_fallback', ...(openWatch.length ? { open_predictions: openWatch, standing_sense: tunedStandingSense() } : {}), ...(upDays > 0 ? { upcoming } : {}), ...(a['fleet'] === true ? { fleet: fleetRows } : {}), ...watchData, today, integrity: ledger.integrity, ...(process.env['ARGUS_V2_DEBUG'] === '1' ? { capture_status: captureStatus, v2_brief: readV2Brief(dir, today), v2_divergence: briefDivergence([], readV2Brief(dir, today)) } : {}) },
                 });
             }
             const parts = [];
@@ -312,6 +313,7 @@ export const checkIn = {
                 surface: mirrorLine + parts.join(' ') + upcomingLine + fleetLine + integrityLine,
                 next_actions: next,
                 data: {
+                    picker: canElicit() ? 'one_tap' : 'text_fallback',
                     due: dueEnriched, due_count: dueAll.length,
                     ...(dueTruncated > 0 ? { due_truncated: `${dueAll.length} due, showing ${DUE_TOP} oldest` } : {}),
                     due_premises: duePrem, due_premise_count: premiseGroups.length,
@@ -321,7 +323,7 @@ export const checkIn = {
                     ...(upDays > 0 ? { upcoming } : {}),
                     ...(a['fleet'] === true ? { fleet: fleetRows } : {}),
                     ...watchData,
-                    ...(openWatch.length ? { open_predictions: openWatch, standing_sense: STANDING_SENSE_REFRESH } : {}),
+                    ...(openWatch.length ? { open_predictions: openWatch, standing_sense: tunedStandingSense() } : {}),
                     today, integrity: ledger.integrity,
                     // v2 병기/진단은 ARGUS_V2_DEBUG=1 뒤로. 공개 payload에 싣던 v2_brief가
                     // 머신-전역 durable-home 저장소를 읽어 다른 프로젝트의 결정 원문을

package/dist/tools/premises.js

@@ -6,7 +6,7 @@ import { resolveContract } from '../lib/resolve-contract.js';
 import { guardTransition } from '../lib/state-machine.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 { elicit, canElicit } from '../lib/elicit.js';
 import { resolveResponseLocale } from '../lib/surfaces.js';
 import { envelope, toolError } from '../lib/envelope.js';
 import { ENVELOPE_OUTPUT_SCHEMA, zArgusDir, zId, zDate } from './tool-types.js';
@@ -188,6 +188,55 @@ async function opAdd(dir, id, today, now, state, existing, a) {
             return toolError({ ok: false, tool: 'argus_premises', error_code: 'PROVENANCE_REQUIRED', message: `source="ai_surfaced" requires ai_original (the model's original wording): "${p.text.slice(0, 60)}"`, recovery: 'Set ai_original to the exact model-drafted sentence, or source="user_stated" if the user wrote it.' });
         }
     }
+    // One-tap confirm for a DRAFTED premise — seal's picker, mirrored (the ask
+    // must be a structural picker, not prose the model may skip). Fires only in
+    // the sense's canonical case: exactly ONE ai_surfaced draft in the call
+    // (multi-premise structured flows confirm in their own conversation). Keep
+    // records it with provenance ai_surfaced UNCHANGED — a tap approves the
+    // recording, it does not transfer authorship (predictions differ: a bet must
+    // become the user's; a premise is a mirror observation whose honest tag IS
+    // the invariant). Reword typed in the form → the user's words, user_stated,
+    // with the draft preserved as ai_original. Skip / declined / no elicitation
+    // → the friction escape stays: nothing forced, no dead end.
+    {
+        const aiDrafts = inputs.filter((p) => normalizePremiseSource(p.source) === 'ai_surfaced');
+        if (aiDrafts.length === 1 && canElicit()) {
+            const draft = aiDrafts[0];
+            const dLocale = resolveResponseLocale(dir, draft.text);
+            // Native Accept/Decline (2026-07-24), mirroring seal: Accept blank → keep
+            // (provenance ai_surfaced intact), Accept + reword → the user's words
+            // (user_stated, draft kept as ai_original), Decline → skip. One keystroke
+            // to keep — no required enum to expand.
+            const picked = await elicit(dLocale === 'ko'
+                ? `이 결정이 딛고 선 전제로 기록할까요?\n"${draft.text}"\n\n그대로면 Accept · 고치려면 아래 칸에 쓰고 Accept · 기록 안 하려면 Decline.`
+                : `Record this as a premise the decision rests on?\n"${draft.text}"\n\nAccept to keep · to reword, type it below and Accept · Decline to skip.`, { type: 'object', properties: {
+                    reword: {
+                        type: 'string',
+                        description: dLocale === 'ko' ? '전제를 고쳐 쓰려면 여기에 적으세요. 비우면 위 문장 그대로 기록합니다.' : 'To reword the premise, type it here. Leave blank to keep the statement above.',
+                    },
+                } });
+            if (!picked) {
+                // Decline / cancel → drop ONLY the draft; the user's own premises in the
+                // same call still record below.
+                inputs.splice(inputs.indexOf(draft), 1);
+                if (inputs.length === 0) {
+                    return envelope({ ok: true, tool: 'argus_premises', surface: dLocale === 'ko' ? '기록하지 않았습니다.' : 'Not recorded.', next_actions: ['stop'], data: { recorded: false, choice: 'declined' } });
+                }
+            }
+            else {
+                const wording = typeof picked['reword'] === 'string' ? picked['reword'].trim() : '';
+                if (wording) {
+                    if (wording.length < 4 || wording.length > 400) {
+                        return envelope({ ok: true, tool: 'argus_premises', surface: dLocale === 'ko' ? '그럼 그 전제를 원하는 문장으로 알려주세요 (4~400자). 그 말 그대로 기록하겠습니다.' : 'Then tell me the premise in your own words (4–400 chars) and I will record exactly that.', next_actions: ['argus_capture'], data: { recorded: false, choice: 'reword' } });
+                    }
+                    draft.ai_original = draft.ai_original ?? draft.text;
+                    draft.text = wording;
+                    draft.source = 'user_stated';
+                }
+                // Accept blank → keep as drafted, provenance ai_surfaced intact.
+            }
+        }
+    }
     // Dedup against the ledger by stable id. Three cases, kept distinct so a
     // re-add is never silently swallowed behind a misleading "already recorded":
     //  - collides with an ACTIVE premise (same text)     → true idempotent dup (skip)
@@ -273,6 +322,7 @@ async function opAdd(dir, id, today, now, state, existing, a) {
     const echo = events.map((e) => ({
         ref: `P${e.ordinal}`, premise_id: e.premise_id, kind: e.kind, text: e.text,
         external: e.external, load_bearing: e.load_bearing, source: e.source,
+        ...(e['ai_original'] ? { ai_original: e['ai_original'] } : {}),
         monitored: e.kind === 'premise' && e.external === true && e.load_bearing === true,
     }));
     const monitoredCount = echo.filter((p) => p.monitored).length;

package/dist/tools/public-tools.js

@@ -5,7 +5,7 @@ import { resolveToolArgusDir } from '../lib/argus-dir.js';
 import { sanitizeOutput } from '../lib/untrusted.js';
 import { replayLedger } from '../lib/ledger-replay.js';
 import { resolveToday } from '../lib/resolve-today.js';
-import { STANDING_SENSE_REFRESH } from '../lib/spine.js';
+import { tunedStandingSense } from '../lib/ambient-prefs.js';
 import { configPath } from '../lib/layout.js';
 import { ENVELOPE_OUTPUT_SCHEMA, zArgusDir, zDate, zId } from './tool-types.js';
 import { openDecision } from './open-decision.js';
@@ -299,7 +299,7 @@ function attachOpenPredictions(result, args) {
         // 원장 predicate(사용자 저작 텍스트)를 직접 세탁해야 한다 — 안 하면 ANSI/bidi/
         // zero-width 벡터가 세탁 안 된 채 모델에 직행하는 새 경로가 된다.
         data['open_predictions'] = sanitizeOutput(open);
-        data['standing_sense'] = STANDING_SENSE_REFRESH;
+        data['standing_sense'] = tunedStandingSense();
         result.content = [{ type: 'text', text: JSON.stringify(sc, null, 2) }];
     }
     catch { /* 라이더 실패는 침묵 — 본 결과를 해치지 않는다 */ }

package/dist/tools/seal.js

@@ -36,8 +36,8 @@ const inputSchema = z.strictObject({
     id: zId.describe('A short slug you pick for this decision (e.g. "q3-cutover"). A fresh id starts the record on its own.'),
     predicate: z.string().min(8).max(400).describe('A prediction reality can mark true/false. Good: "cutover downtime < 5 min". Bad: "it will go well".'),
     check_by: zDate.describe('YYYY-MM-DD, a real future date when the result can be checked.'),
-    predicate_owner: z.enum(['user', 'ai_surfaced']).describe('Provenance. Never forge. "user" = the user wrote or affirmed it. "ai_surfaced" = Argus drafted, unconfirmed — on a host with a picker this AUTOMATICALLY shows one-tap Keep/Reword/Skip before saving.'),
-    confirm_draft: z.boolean().optional().describe('Optional extra confirmation: force the one-tap picker even for a "user" predicate. ai_surfaced predicates get the picker automatically on supporting hosts. In the picker, Keep affirms and saves it as theirs, Reword saves the wording the user types (or asks in chat if left blank), Skip records nothing. Without picker support, saving proceeds — confirm in your own message first.'),
+    predicate_owner: z.enum(['user', 'ai_surfaced']).describe('Provenance. Never forge. "user" = the user wrote or affirmed it. "ai_surfaced" = Argus drafted, unconfirmed — on a host with a picker this AUTOMATICALLY shows a one-tap confirm before saving.'),
+    confirm_draft: z.boolean().optional().describe('Optional extra confirmation: force the one-tap confirm even for a "user" predicate. ai_surfaced predicates get it automatically on supporting hosts. The picker maps to the host\'s native Accept/Decline: Accept with both fields blank keeps the draft as theirs, Accept with `reword` saves the user\'s wording, Accept with `check_by` adjusts the date, Decline records nothing. Without picker support, saving proceeds — confirm in your own message first.'),
     basis: z.enum(['judgment', 'luck', 'mixed', 'unsure']).optional(),
     real_question: z.string().max(400).describe('The real question behind the answer (receipt).').optional(),
     unverified_assumption: z.string().max(400).describe('The core assumption not yet verified (receipt).').optional(),
@@ -64,7 +64,7 @@ export const seal = {
                 return toolError({ ok: false, tool: 'argus_seal', error_code: vErr.code, message: vErr.message, recovery: vErr.recovery });
             }
             let predicate = String(a['predicate']);
-            const checkBy = String(a['check_by']);
+            let checkBy = String(a['check_by']);
             // The DATE part of `now` must equal the tz-aware logical `today`. Plain
             // new Date().toISOString() is always UTC, so a Korea (UTC+9) user sealing
             // at 08:00 KST (= 23:00Z the day before) got a receipt dated YESTERDAY —
@@ -76,66 +76,62 @@ export const seal = {
             let locale = resolveResponseLocale(dir, predicate);
             let T = SURFACES[locale].tools.seal;
             // One-tap confirm for a DRAFTED predicate (the activation fix; §9.7 O1
-            // 방4): show the draft with Keep / Reword / Skip before it lands.
-            // Keep = the user affirmed it → record as THEIRS. Reword with wording
-            // typed in the same form = record THAT, user-authored, one round-trip.
-            // Reword without wording / Skip / a declined picker = record nothing
-            // (respect the non-yes). STRUCTURAL trigger: an ai_surfaced predicate
-            // fires the picker on any capable host even when the model forgot
-            // confirm_draft — "the draft was confirmed" must not depend on prose
-            // compliance. On a host with no elicitation, this is skipped and the
-            // seal proceeds with honest ai_surfaced provenance (the friction escape
+            // 방4). Design (2026-07-24, 창업자 도그푸딩): the picker maps to
+            // elicitation's NATIVE Accept/Decline instead of a required 3-way enum —
+            // a required enum forced "expand → pick → Accept" (3-4 keystrokes) and
+            // rendered as an unset field the user had to hunt for. Now:
+            //   Accept, both fields blank → KEEP the draft (the user affirmed it → theirs)
+            //   Accept + `reword`         → record the user's wording (user_stated)
+            //   Accept + `check_by`       → adjust the horizon inline (the "그 날짜 쎄"
+            //                               escape — keep the statement, fix only the date)
+            //   Decline / cancel          → SKIP (record nothing)
+            // Both edit fields are OPTIONAL, so Accept is actionable in one keystroke.
+            // STRUCTURAL trigger: an ai_surfaced predicate fires the picker on any
+            // capable host even if the model forgot confirm_draft. No elicitation →
+            // the seal proceeds with honest ai_surfaced provenance (friction escape
             // stays; forced typing is NOT the invariant — honest provenance is).
-            let elicitedKeep = false; // v2 provenance용: elicit 채널로 확인된 것만 elicited_user (II-B) — Keep 또는 폼에 직접 쓴 reword
+            let elicitedKeep = false; // v2 provenance: only elicit-channel confirmation counts as elicited_user (II-B)
             if ((a['confirm_draft'] === true || a['predicate_owner'] === 'ai_surfaced') && canElicit()) {
-                const picked = await elicit(locale === 'ko' ? `이 예측으로 기록할까요?\n"${predicate}" (확인일 ${checkBy})` : `Record this prediction?\n"${predicate}" (check-by ${checkBy})`, { type: 'object', required: ['choice'], properties: {
-                        choice: {
-                            type: 'string', enum: ['keep', 'reword', 'skip'],
-                            enumNames: locale === 'ko' ? ['그대로 기록', '직접 고쳐 쓰기', '건너뛰기'] : ['Keep it', 'Let me reword', 'Skip'],
-                            description: locale === 'ko' ? '이 예측을 기록할지 고르세요.' : 'Whether to record this prediction.',
+                const picked = await elicit(locale === 'ko'
+                    ? `이 예측으로 기록할까요?\n"${predicate}"\n확인일 ${checkBy}\n\n그대로면 Accept · 문장이나 날짜를 고치려면 아래 칸에 쓰고 Accept · 기록 안 하려면 Decline.`
+                    : `Record this prediction?\n"${predicate}"\ncheck-by ${checkBy}\n\nAccept to keep · to change the wording or date, fill a field below and Accept · Decline to skip.`, { type: 'object', properties: {
+                        reword: {
+                            type: 'string',
+                            description: locale === 'ko' ? '예측 문장을 고쳐 쓰려면 여기에 적으세요. 비우면 위 문장 그대로 기록합니다.' : 'To reword the prediction, type it here. Leave blank to keep the statement above.',
                         },
-                        your_wording: {
+                        check_by: {
                             type: 'string',
-                            description: locale === 'ko' ? '"직접 고쳐 쓰기"를 골랐다면, 원하는 예측 문장을 여기에 적어 주세요. 그 말 그대로 저장됩니다.' : 'If you chose "Let me reword", type your prediction here. It is saved exactly as written.',
+                            description: locale === 'ko' ? `확인일을 바꾸려면 YYYY-MM-DD로 적으세요. 비우면 ${checkBy} 그대로.` : `To change the check-by date, type YYYY-MM-DD. Leave blank to keep ${checkBy}.`,
                         },
                     } });
-                const choice = picked?.['choice'];
-                if (choice === 'reword') {
-                    const wording = typeof picked?.['your_wording'] === 'string' ? picked['your_wording'].trim() : '';
-                    if (wording) {
-                        // One-shot reword: the user's own words replace the draft — but they
-                        // pass the SAME falsifiability gate as any predicate (a vibe typed by
-                        // the user is still unsettleable; refusing honestly beats recording a
-                        // dead reminder).
-                        if (wording.length < 8 || wording.length > 400) {
-                            return toolError({ ok: false, tool: 'argus_seal', error_code: 'SEAL_INVALID', message: locale === 'ko' ? `다시 쓴 예측이 너무 ${wording.length < 8 ? '짧습니다' : '깁니다'} (8~400자).` : `The reworded prediction is too ${wording.length < 8 ? 'short' : 'long'} (8–400 chars).`, recovery: locale === 'ko' ? '예측 문장을 8~400자로 다시 알려주세요.' : 'Give the prediction again in 8–400 characters.' });
-                        }
-                        const rErr = validateSeal(wording, checkBy, today);
-                        if (rErr) {
-                            return toolError({ ok: false, tool: 'argus_seal', error_code: rErr.code, message: rErr.message, recovery: rErr.recovery });
-                        }
-                        predicate = wording;
-                        a = { ...a, predicate: wording, predicate_owner: 'user' };
-                        elicitedKeep = true; // typed through the elicit channel — evidenced user input
-                        // The voice follows the USER's wording now (they may have reworded
-                        // an English draft in Korean).
-                        locale = resolveResponseLocale(dir, predicate);
-                        T = SURFACES[locale].tools.seal;
-                    }
-                    else {
-                        // Reword chosen but no wording typed (or the host renders enum-only
-                        // forms) — fall back to the two-step: ask in chat, model re-calls.
-                        return envelope({ ok: true, tool: 'argus_seal', surface: locale === 'ko' ? '그럼 원하는 예측 문장을 알려주세요. 그 말 그대로 저장하겠습니다.' : "Then tell me the prediction in your own words and I'll save exactly that.", next_actions: ['argus_predict'], data: { sealed: false, choice: 'reword' } });
-                    }
+                if (!picked) {
+                    // Decline / cancel / no-accept → record nothing (respect the non-yes).
+                    return envelope({ ok: true, tool: 'argus_seal', surface: locale === 'ko' ? '기록하지 않았습니다.' : 'Not recorded.', next_actions: ['stop'], data: { sealed: false, choice: 'declined' } });
                 }
-                else if (choice !== 'keep') {
-                    // skip, or a declined/cancelled picker — record nothing.
-                    return envelope({ ok: true, tool: 'argus_seal', surface: locale === 'ko' ? '기록하지 않았습니다.' : 'Not recorded.', next_actions: ['stop'], data: { sealed: false, choice: choice ?? 'declined' } });
+                // Accept. Apply any optional edits, then re-gate through validateSeal —
+                // a vibe typed by the user is still unsettleable; refusing honestly beats
+                // recording a dead reminder.
+                const rw = typeof picked['reword'] === 'string' ? picked['reword'].trim() : '';
+                const cbEdit = typeof picked['check_by'] === 'string' ? picked['check_by'].trim() : '';
+                if (rw)
+                    predicate = rw;
+                if (cbEdit)
+                    checkBy = cbEdit;
+                if (rw && rw.length > 400) {
+                    return toolError({ ok: false, tool: 'argus_seal', error_code: 'SEAL_INVALID', message: locale === 'ko' ? '다시 쓴 예측이 너무 깁니다 (최대 400자).' : 'The reworded prediction is too long (max 400 chars).', recovery: locale === 'ko' ? '예측 문장을 400자 이내로 다시 알려주세요.' : 'Give the prediction again within 400 characters.' });
+                }
+                if (rw || cbEdit) {
+                    const rErr = validateSeal(predicate, checkBy, today);
+                    if (rErr) {
+                        return toolError({ ok: false, tool: 'argus_seal', error_code: rErr.code, message: rErr.message, recovery: rErr.recovery });
+                    }
                 }
-                else {
-                    // keep → the user affirmed the draft, so it is theirs now.
-                    a = { ...a, predicate_owner: 'user' };
-                    elicitedKeep = true;
+                // Accept (blank or edited) = the user affirmed it → it is theirs now.
+                a = { ...a, predicate, check_by: checkBy, predicate_owner: 'user' };
+                elicitedKeep = true;
+                if (rw) { // voice follows the user's wording (they may have reworded EN→KO)
+                    locale = resolveResponseLocale(dir, predicate);
+                    T = SURFACES[locale].tools.seal;
                 }
             }
             await ensurePrivacyGitignore(dir);

package/dist/tools/settle.js

@@ -65,12 +65,27 @@ export const settle = {
                                 : ['It held', 'Avoided', 'Partially', 'Still unclear', 'Missed: my read was wrong'],
                             description: pickerLocale === 'ko' ? '저장한 예측에 현실이 어떻게 답했는지 고르세요.' : 'What reality did to your sealed prediction.',
                         },
+                        // Capture what-happened in the SAME picker so a settle that reached
+                        // the picker doesn't dead-end on WHAT_HAPPENED_REQUIRED after the user
+                        // already answered. Optional: if the model already passed what_happened
+                        // from the conversation, the user can leave this blank. What the user
+                        // types here is THEIR words (spine-safe — never model-inferred).
+                        what_happened: {
+                            type: 'string',
+                            description: pickerLocale === 'ko' ? '무슨 일이 있었는지 당신의 말로 한 줄. (아직 불분명이면 비워도 됩니다.)' : "One line on what actually happened, in your words. (Leave blank if still unclear.)",
+                        },
                     },
                     required: ['outcome'],
                 });
                 const v = picked?.['outcome'];
                 if (v === 'held' || v === 'avoided' || v === 'partial' || v === 'still_pending' || v === 'missed')
                     outcome = v;
+                // If the model didn't already supply what_happened, take the user's
+                // picker text (their own words) so the settle completes in one round.
+                const pickedWhat = typeof picked?.['what_happened'] === 'string' ? picked['what_happened'].trim() : '';
+                if (pickedWhat && !(typeof a['what_happened'] === 'string' && a['what_happened'].trim())) {
+                    a = { ...a, what_happened: pickedWhat };
+                }
             }
             if (!outcome) {
                 return toolError({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "argus-decision-mcp",
-  "version": "1.7.0",
+  "version": "1.9.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",