argus-decision-mcp 1.4.2 → 1.4.6

package/dist/tools/seal.js

@@ -65,12 +65,15 @@ export const seal = {
             }
             let predicate = String(a['predicate']);
             const checkBy = String(a['check_by']);
-            // Stamp the seal at the LOGICAL day when a today_override is given (sims,
-            // tests), else real wall-clock. Without this the receipt showed a
-            // wall-clock sealed date that diverged from the simulated timeline and
-            // read as "the record misstates my dates" (experience loop, settler). Real
-            // use passes no override, so created_at stays the true write time.
-            const now = a['today_override'] ? `${today}T12:00:00.000Z` : new Date().toISOString();
+            // 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 —
+            // the tool's own `today` disagreeing with the date it printed. recheck.ts
+            // already fixed this same class for premise cadences. Keep the real UTC
+            // time-of-day for intra-day ordering, but stamp the logical date.
+            const now = a['today_override']
+                ? `${today}T12:00:00.000Z`
+                : `${today}T${new Date().toISOString().slice(11)}`;
             // Response voice follows the predicate (M4): config > text > env.
             let locale = resolveResponseLocale(dir, predicate);
             let T = SURFACES[locale].tools.seal;
@@ -196,7 +199,7 @@ export const seal = {
                 await atomicWriteJson(bearingPath(dir, id), {
                     v: SCHEMA_VERSION, id, contract_seed: { predicate, check_by: checkBy }, predicate_owner: a['predicate_owner'],
                 });
-                const calendarPathW = await writeReturnCalendarEvent(dir, { id, predicate, check_by: checkBy, created_at: now });
+                const calendarPathW = await writeReturnCalendarEvent(dir, { id, predicate, check_by: checkBy, created_at: now, locale });
                 // 미러 힌트: 원장 이벤트에 없는 elicit 목격 여부 + 영수증 필드만 —
                 // 미러 자체는 appendLedger의 단일 관문이 수행한다 (mirror.ts).
                 const appended = await appendLedger(dir, events, now, { seal: {
@@ -261,7 +264,7 @@ export const seal = {
             // dumping the absolute path — and the English label "Calendar file:" — into
             // a one-line surface was noise, and broke the Korean voice (copy-audit /
             // loop find). Mention it briefly, localized; keep the path in data.
-            const calNote = locale === 'ko' ? ' 달력 리마인더(.ics)도 저장했어요.' : ' Saved a calendar reminder (.ics).';
+            const calNote = locale === 'ko' ? ' 달력 리마인더(.ics)도 저장했습니다.' : ' Saved a calendar reminder (.ics).';
             return envelope({
                 ok: true, tool: 'argus_seal',
                 surface: `${T.sealed(predicate, checkBy)}${calNote}${nudge}${syncLine}`,

package/dist/tools/settle.js

@@ -21,8 +21,8 @@ import { handleToolException } from './errors.js';
 const inputSchema = z.strictObject({
     argus_dir: zArgusDir,
     id: zId,
-    outcome: z.enum(['held', 'avoided', 'partial', 'still_pending', 'missed']).describe("What reality did to the prediction. Record the user's words — never infer. 'missed' means the saved prediction was wrong; 'still_pending' means reality has not answered yet and requires a future defer_to. If omitted, Argus asks the user directly on hosts that support elicitation.").optional(),
-    outcome_source: z.literal('user_stated').describe('Single value "user_stated". An AI-inferred outcome cannot be expressed.'),
+    outcome: z.enum(['held', 'avoided', 'partial', 'still_pending', 'missed']).describe("What reality did to the prediction — record the user's words, never infer. Definitions (held and avoided are counted separately, so pick the right one): held = the predicted thing actually happened; avoided = the predicted RISK did not occur (the bad thing you predicted was dodged); partial = it half-happened / mixed; missed = the saved prediction was simply wrong; still_pending = reality has not answered yet, so pass a future defer_to and it comes back. If omitted, Argus asks the user directly on hosts that support elicitation.").optional(),
+    outcome_source: z.literal('user_stated').default('user_stated').describe('Always "user_stated" — an AI-inferred outcome cannot be expressed. Defaulted, so you may omit it.'),
     what_happened: z.string().min(1).max(600).optional().describe("What reality did, in the user's words. Required when recording held/avoided/partial/missed. Omit for still_pending and pass defer_to instead."),
     broken_premise_ref: z.string().max(64).optional().describe('Optional, USER-attributed: which tracked premise (ordinal like "P1"), if any, broke and drove the outcome. Never inferred by the model — ask, or omit.'),
     defer_to: zDate.optional().describe("Only with outcome='still_pending': the new check-by (YYYY-MM-DD, a real future date) — when to look again, taken from the horizon the user names (\"the data lands next Friday\"). The decision stays alive and comes due again then. Omit only if the user has not said when; on elicitation hosts Argus will ask."),
@@ -50,14 +50,20 @@ export const settle = {
             // without elicitation.
             let outcome = a['outcome'];
             if (!outcome && canElicit()) {
-                const picked = await elicit('현실이 어떻게 답했나요? (What did reality do?)', {
+                // Localize the picker like every other elicitation (ambient-elicit does):
+                // 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?', {
                     type: 'object',
                     properties: {
                         outcome: {
                             type: 'string',
                             enum: ['held', 'avoided', 'partial', 'still_pending', 'missed'],
-                            enumNames: ['그렇게 됐다 (held)', '피했다 (avoided)', '부분적으로 (partial)', '아직 불분명 (still pending)', '빗나갔다 (missed — my read was wrong)'],
-                            description: 'What reality did to your sealed prediction.',
+                            enumNames: pickerLocale === 'ko'
+                                ? ['그렇게 됐다', '피했다', '부분적으로', '아직 불분명', '빗나갔다 (내 예측이 틀렸다)']
+                                : ['It held', 'Avoided', 'Partially', 'Still unclear', 'Missed — my read was wrong'],
+                            description: pickerLocale === 'ko' ? '봉인한 예측에 현실이 어떻게 답했는지 고르세요.' : 'What reality did to your sealed prediction.',
                         },
                     },
                     required: ['outcome'],
@@ -77,11 +83,13 @@ export const settle = {
             // Response voice follows what-happened (M4): config > text > env.
             const locale = resolveResponseLocale(dir, a['what_happened']);
             const T = SURFACES[locale].tools.settle;
-            // Settle at the LOGICAL day under a today_override (sims/tests), else real
-            // wall-clock — the receipt's settled date should match the user's timeline,
-            // not the simulator's clock (experience loop, settler). Real use has no
-            // override, so settled_at stays the true write time.
-            const now = a['today_override'] ? `${today}T12:00:00.000Z` : new Date().toISOString();
+            // The DATE part of `now` must equal the tz-aware logical `today`, else a
+            // Korea (UTC+9) user settling at 08:00 KST gets a receipt dated yesterday
+            // (raw UTC). Keep the real UTC time-of-day for ordering; stamp the logical
+            // date. (Same fix as seal.ts; recheck.ts fixed it for premise cadences.)
+            const now = a['today_override']
+                ? `${today}T12:00:00.000Z`
+                : `${today}T${new Date().toISOString().slice(11)}`;
             // still_pending = reality has NOT answered yet. This is NOT a settlement —
             // filing it as `settled` (terminal) silently closed the loop and dropped
             // the decision off check_in forever, while the surface lied "what actually

package/dist/tools/tool-types.js

@@ -7,7 +7,11 @@ export const zArgusDir = z
     .string()
     .describe('Absolute path to the .argus directory (no ".."). Omit to use the ARGUS_DIR env var from your MCP config.')
     .optional();
-export const zId = z.string().regex(/^[A-Za-z0-9._-]+$/, 'id may only contain A-Z a-z 0-9 . _ -');
+// The single id type: 1–128 chars, [A-Za-z0-9._-]. The bound lives here so
+// every tool (predict/amend/dismiss/recheck) advertises the SAME limit the
+// runtime path guard enforces — previously bare `zId` promised an unbounded id
+// that then threw a PathSafetyError deep in the write path.
+export const zId = z.string().min(1).max(128).regex(/^[A-Za-z0-9._-]+$/, 'id may only contain A-Z a-z 0-9 . _ -');
 export const zDate = z.string().regex(/^\d{4}-\d{2}-\d{2}$/, 'must be YYYY-MM-DD');
 const KO_FIELD_DESCRIPTIONS = {
     argus_dir: '프로젝트의 .argus 절대 경로입니다. 생략하면 MCP 설정의 ARGUS_DIR을 사용합니다.',
@@ -17,7 +21,7 @@ const KO_FIELD_DESCRIPTIONS = {
     reversibility: '결정을 되돌릴 수 있는 정도입니다.',
     status_quo: '아무것도 하지 않을 때 일어나는 일입니다.',
     already_decided: '이미 결정을 내렸는지 여부입니다.',
-    crux_question: '결정을 가르는 중립적인 핵심 질문 하나입니다.',
+    crux_question: '결정을 좌우하는 중립적인 핵심 질문 하나입니다.',
     load_bearing_assumption: '결정이 가장 크게 기대는 전제 하나입니다.',
     related_to: '사용자가 비슷하다고 본 과거 결정 id입니다.',
     today_override: '테스트 또는 명시적 기준일에만 사용하는 오늘 날짜입니다.',
@@ -105,7 +109,7 @@ const EN_FIELD_DESCRIPTIONS = {
     reversibility: 'How difficult the decision is to reverse.',
     status_quo: 'What happens if nothing changes.',
     already_decided: 'Whether the user has already made the decision.',
-    crux_question: 'One neutral question that separates the decision paths.',
+    crux_question: 'The one neutral, load-bearing question the decision turns on.',
     load_bearing_assumption: 'The single assumption the decision depends on most.',
     related_to: 'Past decision ids the user considers related.',
     action: 'The operation to perform.',
@@ -158,7 +162,14 @@ const EN_FIELD_DESCRIPTIONS = {
 };
 /** JSON Schema for tools/list, generated from the Zod source (drop $schema noise). */
 export function toolJsonSchema(schema) {
-    const json = z.toJSONSchema(schema);
+    // io:'input' — this schema describes the tool's ARGUMENTS. Zod v4 defaults
+    // z.toJSONSchema to io:'output', which marks every `.default()` field as
+    // REQUIRED (while still emitting its default) — so a strict host / the MCP
+    // Inspector would reject `argus_check_in {}` (the mandated session-start call),
+    // `argus_patterns {}`, and a premise without kind/external/load_bearing, even
+    // though the runtime validator fills those defaults. Input mode advertises them
+    // as optional; additionalProperties:false (strictObject) is preserved.
+    const json = z.toJSONSchema(schema, { io: 'input' });
     delete json['$schema'];
     const visit = (node) => {
         if (!node || typeof node !== 'object')
@@ -174,7 +185,16 @@ export function toolJsonSchema(schema) {
                 if (ko) {
                     const existing = typeof field['description'] === 'string' ? field['description'].trim() : '';
                     const en = EN_FIELD_DESCRIPTIONS[key] ?? existing;
-                    field['description'] = en ? `${ko}\n\n${en}` : ko;
+                    const base = en ? `${ko}\n\n${en}` : ko;
+                    // A richer Zod .describe() (e.g. the argus_patterns `view` enum-value
+                    // glossary) must not be dropped by the short bilingual map — append it
+                    // when it carries more than the base already says. Never append a
+                    // describe that references an internal tool name (argus_*): the
+                    // bilingual map masks those on purpose, and re-surfacing one leaks an
+                    // internal name into tools/list (public-surface-names guard).
+                    field['description'] = existing.length > base.length && !base.includes(existing) && !/argus_/.test(existing)
+                        ? `${base}\n\n${existing}`
+                        : base;
                 }
                 visit(field);
             }
@@ -201,6 +221,12 @@ export const ENVELOPE_OUTPUT_SCHEMA = {
         over_fire_gate: { type: 'object' },
         error_code: { type: 'string' },
         message: { type: 'string' },
+        // error results also carry these — declared so a host that validates
+        // structuredContent against outputSchema on ERROR results (the SDK does, even
+        // when isError) would still pass if the schema were ever hardened to
+        // additionalProperties:false.
+        recovery: { type: 'string' },
+        invalid_fields: { type: 'array', items: { type: 'object' } },
     },
     required: ['ok', 'tool'],
 };

package/package.json

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