argus-decision-mcp 1.2.0 → 1.3.0

package/dist/server.js

@@ -1,22 +1,26 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { TOOLS, TOOL_MAP } from './tools/index.js';
-import { toolJsonSchema } from './tools/tool-types.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { PUBLIC_TOOLS, TOOL_MAP, servedPublicTools } from './tools/index.js';
 import { listResources, listResourceTemplates, readResource } from './resources.js';
-import { listPrompts, getPrompt } from './prompts.js';
 import { SERVER_INSTRUCTIONS } from './lib/spine.js';
 import { setElicitor } from './lib/elicit.js';
+import { initAmbientElicit, armAmbientElicit } from './lib/ambient-elicit.js';
+import { settle } from './tools/settle.js';
 import { appendDueNote } from './lib/due-note.js';
 import { logError } from './lib/log.js';
 import { packageMeta } from './lib/package-meta.js';
+import { localizeToolResult } from './lib/localize-result.js';
+import { learnLocaleFromContent } from './lib/locale.js';
+import { appendLocaleMismatchNote } from './lib/locale-mismatch.js';
+import { resolveToolArgusDir } from './lib/argus-dir.js';
 import { recordServerStart, recordToolCall } from './lib/telemetry.js';
 /**
  * Argus MCP server (blueprint §4). v1 surface = Tools only — the universal
  * floor that works on every host. The spine bias is carried once by the
  * `instructions` field (the one spec-sanctioned home for the killed
- * paste-prompt), rendered from the single spine source. Resources and Prompts
- * are Phase 2; their capabilities are NOT declared until their handlers exist,
- * so a host never probes a no-op.
+ * paste-prompt), rendered from the single spine source. Resources provide one
+ * passive attention view. Separate MCP prompts were removed: they duplicated
+ * the tool surface and made users learn a second invocation system.
  */
 export async function createServer() {
     const meta = packageMeta();
@@ -25,33 +29,25 @@ export async function createServer() {
         // a host never probes a no-op (addendum J). `elicitation` is a client
         // capability we USE, not a server one we serve — advertised so the SDK
         // permits elicitInput; tools degrade to text when the host lacks it.
-        capabilities: { tools: {}, resources: {}, prompts: {} },
+        capabilities: { tools: {}, resources: {} },
         instructions: SERVER_INSTRUCTIONS,
     });
-    setElicitor((message, requestedSchema) => server.elicitInput({ message, requestedSchema }));
+    const ec = server;
+    // The capability probe reads the client's DECLARED elicitation support (set at
+    // initialize). Gating canElicit() on it means a host that never declared the
+    // capability takes the text path instead of calling elicitInput (which the SDK
+    // throws on) and silently dropping a confirm_draft seal.
+    setElicitor((message, requestedSchema) => ec.elicitInput({ message, requestedSchema }), () => Boolean(ec.getClientCapabilities?.()?.elicitation));
     // Resources — read-only context (blueprint §4.3).
     server.setRequestHandler(ListResourcesRequestSchema, async () => listResources());
     server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => listResourceTemplates());
     server.setRequestHandler(ReadResourceRequestSchema, async (req) => readResource(req.params.uri));
-    // Prompts — user-triggered discipline rituals (blueprint §4.2).
-    server.setRequestHandler(ListPromptsRequestSchema, async () => listPrompts());
-    server.setRequestHandler(GetPromptRequestSchema, async (req) => getPrompt(req.params.name, req.params.arguments));
     // Anonymous, opt-in activation signal (no-op unless ARGUS_TELEMETRY=1). Fire-
     // and-forget: never blocks server startup, never throws. See lib/telemetry.ts.
     recordServerStart();
-    server.setRequestHandler(ListToolsRequestSchema, async () => ({
-        tools: TOOLS.map((t) => ({
-            name: t.name,
-            // Top-level human-readable title (2025-06-18 spec; display priority
-            // title > annotations.title > name). Reuse the annotation we already set.
-            ...(t.annotations?.title ? { title: t.annotations.title } : {}),
-            description: t.description,
-            // JSON Schema generated from the Zod source of truth (no hand-kept copy).
-            inputSchema: toolJsonSchema(t.inputSchema),
-            ...(t.outputSchema ? { outputSchema: t.outputSchema } : {}),
-            ...(t.annotations ? { annotations: t.annotations } : {}),
-        })),
-    }));
+    // Single source (tools/index.ts): builds the descriptors AND runs schemas
+    // through publicCopy so a legacy tool name in a field description can't leak.
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: servedPublicTools() }));
     // Serialize tool calls so concurrent invocations can't interleave a
     // read-replay-then-append against the same ledger (real hosts already wait
     // for each response; this removes the foot-gun for batched/parallel clients).
@@ -61,6 +57,12 @@ export async function createServer() {
         chain = run.then(() => undefined, () => undefined);
         return run;
     };
+    // Out-of-band ambient ask (lib/ambient-elicit.ts) — after a tool call ends
+    // and the session goes quiet, the server may ask the ONE due settlement
+    // question directly (spike-proven server→client elicitation). Recording rides
+    // the real settle handler through the SAME serialize chain, so an ambient
+    // write can never interleave with an in-band tool call.
+    initAmbientElicit({ settleHandler: (a) => settle.handler(a), serialize });
     // The low-level SDK handler's expected return is a broad ServerResult union
     // (incl. a task-augmented variant) our envelope type isn't nominally part of —
     // `any` is the sanctioned boundary here; every return below is a real
@@ -69,7 +71,11 @@ export async function createServer() {
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const { name, arguments: args } = request.params;
         const tool = TOOL_MAP.get(name);
-        if (!tool) {
+        // The v6 semantic recorder is a P4 pilot. Keeping it out of discovery is
+        // not enough: a cached or hand-written client must not be able to invoke it
+        // until the operator explicitly opts in.
+        const pilotDisabled = name === 'argus_record' && process.env['ARGUS_DKK_V6_PILOT'] !== '1';
+        if (!tool || pilotDisabled) {
             return {
                 content: [{ type: 'text', text: JSON.stringify({ ok: false, error_code: 'UNKNOWN_TOOL', message: `Unknown tool: ${name}` }) }],
                 isError: true,
@@ -79,28 +85,76 @@ export async function createServer() {
         // A schema failure is a client bug → a clean, actionable tool-result error
         // (not a protocol crash); the handler only ever sees validated, default-
         // applied args.
-        const parsed = tool.inputSchema.safeParse(args ?? {});
+        const rawArgs = (args ?? {});
+        // Deterministic protocol tests need a logical clock, but that test-only
+        // control must not become part of the public MCP schema users and models
+        // have to understand.
+        const hiddenTestClock = process.env['NODE_ENV'] === 'test'
+            && PUBLIC_TOOLS.some((candidate) => candidate.name === name)
+            && typeof rawArgs['today_override'] === 'string';
+        const validationArgs = hiddenTestClock
+            ? Object.fromEntries(Object.entries(rawArgs).filter(([key]) => key !== 'today_override'))
+            : rawArgs;
+        const parsed = tool.inputSchema.safeParse(validationArgs);
         if (!parsed.success) {
             const issues = parsed.error.issues.map((i) => `${i.path.join('.') || '(root)'}: ${i.message}`).join('; ');
+            // Carry the offending field(s) + machine-readable reason STRUCTURALLY, so
+            // the Korean localizer can name what to fix (not collapse every failure to
+            // a generic "invalid input"). Without this, a Korean user is told to "fix
+            // the flagged argument" but nothing is flagged — an unactionable dead end.
+            const invalidFields = parsed.error.issues.map((i) => {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const raw = i;
+                return {
+                    field: i.path.join('.') || '(root)',
+                    code: i.code,
+                    message: i.message,
+                    ...(typeof raw.minimum === 'number' ? { minimum: raw.minimum } : {}),
+                    ...(typeof raw.maximum === 'number' ? { maximum: raw.maximum } : {}),
+                    ...(raw.expected !== undefined ? { expected: String(raw.expected) } : {}),
+                    // Zod v4 tags size issues with `origin` ('string' | 'number' | 'array'…).
+                    ...(raw.origin !== undefined ? { origin: String(raw.origin) } : raw.type !== undefined ? { origin: String(raw.type) } : {}),
+                };
+            });
             const error = {
                 ok: false,
                 tool: name,
                 error_code: 'INVALID_INPUT',
                 message: `Invalid arguments. ${issues}`,
+                invalid_fields: invalidFields,
                 recovery: 'Fix the named argument(s) and call the same tool again. Do not infer missing user-owned fields.',
             };
-            return {
+            return localizeToolResult((args ?? {}), {
                 content: [{ type: 'text', text: JSON.stringify(error) }],
                 structuredContent: error,
                 isError: true,
-            };
+            });
         }
         try {
-            const result = await serialize(() => tool.handler(parsed.data));
+            const callArgs = hiddenTestClock
+                ? { ...parsed.data, today_override: rawArgs['today_override'] }
+                : parsed.data;
+            const raw = await serialize(() => tool.handler(callArgs));
+            // 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));
             // 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);
-            return appendDueNote(name, parsed.data, result);
+            // Debounced out-of-band ask arms on every call and fires only after the
+            // session goes quiet; a check_in call spends the budget instead (the user
+            // just saw their dues). Never throws, never taxes this call.
+            armAmbientElicit(name, callArgs);
+            return appendDueNote(name, callArgs, result);
         }
         catch (e) {
             recordToolCall(name, false);

package/dist/tools/candidates.js

@@ -48,7 +48,7 @@ export const candidates = {
         today_override: zDate.optional(),
     })
         .refine((a) => a.action === 'list' || a.candidate_id !== undefined, { message: 'candidate_id is required for promote/drop/snooze' })
-        .refine((a) => a.action !== 'promote' || a.decision_id !== undefined, { message: 'promote links a candidate to an existing sealed decision — pass decision_id (seal first with argus_seal)' })
+        .refine((a) => a.action !== 'promote' || a.decision_id !== undefined, { message: 'promote links a candidate to an existing saved prediction — pass decision_id (save it first with argus_predict)' })
         .refine((a) => a.action !== 'snooze' || a.snooze_until !== undefined, { message: 'snooze requires snooze_until (YYYY-MM-DD)' }),
     outputSchema: ENVELOPE_OUTPUT_SCHEMA,
     annotations: { title: 'Captured decision candidates', readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
@@ -74,7 +74,7 @@ export const candidates = {
                     : [T.header(brief.candidates_active.length, brief.candidates_expired), ...rows, T.quote_note].join('\n');
                 return envelope({
                     ok: true, tool: 'argus_candidates', surface,
-                    next_actions: rows.length === 0 ? ['stop'] : ['argus_seal', 'argus_candidates'],
+                    next_actions: rows.length === 0 ? ['stop'] : ['argus_predict', 'stop'],
                     data: {
                         candidates: brief.candidates_active.map((c) => {
                             const rec = state.candidates.get(c.candidate_id);
@@ -99,7 +99,7 @@ export const candidates = {
                 return envelope({
                     ok: true, tool: 'argus_candidates',
                     surface: T.promoted(candidateId, String(a['decision_id'])),
-                    next_actions: ['argus_seal'],
+                    next_actions: ['argus_predict'],
                     data: { candidate_id: candidateId, action, decision_id: a['decision_id'], today },
                 });
             }

package/dist/tools/check-in.js

@@ -9,6 +9,7 @@ import { envelope } from '../lib/envelope.js';
 import { ENVELOPE_OUTPUT_SCHEMA, zArgusDir, zDate } from './tool-types.js';
 import { handleToolException } from './errors.js';
 import { briefDivergence, readV2Brief } from '../v2/mirror.js';
+import { drainCaptureOnCheckIn } from '../v2/capture-runtime.js';
 /**
  * The watch anchor is the one surface a user cannot close: a contract has
  * settle/dismiss and an open_question has still_open, but an anchor has no ack
@@ -41,6 +42,7 @@ export const checkIn = {
         try {
             const dir = resolveToolArgusDir(a['argus_dir']);
             const today = resolveToday({ override: a['today_override'] });
+            const captureStatus = await drainCaptureOnCheckIn(dir, today);
             const ledger = replayLedger(dir, today);
             const seeds = bearingContracts(dir, today, ledger);
             const dueMap = new Map();
@@ -98,13 +100,23 @@ export const checkIn = {
             // a due question came back framed in English around the user's own words.
             const premiseGroups = groupDuePremises(duePremises(ledger));
             const openQs = dueOpenQuestions(ledger);
-            // Last resort: ANY contract predicate (replay order = deterministic) —
-            // without it a quiet day on an all-Korean ledger greeted in English
-            // ("Nothing is due.") because nothing due meant nothing to sniff
-            // (75-day life loop find). Still ledger text only, never env/Intl.
-            const anyLedgerText = [...ledger.contracts.values()].find((c) => typeof c.predicate === 'string' && c.predicate)?.predicate;
-            const ledgerVoiceSample = lastAnchor?.text || ledger.overdue[0]?.text || due[0]?.predicate
-                || premiseGroups[0]?.premises[0]?.decision_text || openQs[0]?.text || anyLedgerText;
+            // Sniff the user's LOCALE from the ledger's own words (never env/Intl for
+            // Korean users on an English OS). The old priority-OR chain silently fell
+            // through to `undefined` — English — whenever every earlier slot was empty
+            // AND the last resort read a field that doesn't exist on ContractEntry
+            // (`.predicate`; the entry stores `.text`). A Korean session whose only due
+            // item was an open question came back framed in English around its own
+            // Korean quote. Fix: pool ALL available ledger user-text defensively so any
+            // single Korean line is enough to detect. (Found via the check_in
+            // localization yellow, 2026-07-14.)
+            const ledgerVoiceSample = [
+                lastAnchor?.text,
+                ...ledger.overdue.map((o) => o.text),
+                ...due.map((d) => d.predicate),
+                ...premiseGroups.flatMap((g) => g.premises.map((p) => p.decision_text)),
+                ...openQs.map((q) => q.text),
+                ...[...ledger.contracts.values()].map((c) => c.text),
+            ].filter((t) => typeof t === 'string' && t.trim().length > 0).join(' ') || undefined;
             const S = ledgerVoiceSample
                 ? SURFACES[resolveResponseLocale(dir, ledgerVoiceSample)].checkin
                 : SURFACES[surfaceLocale(dir)].checkin;
@@ -227,7 +239,7 @@ export const checkIn = {
                     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, ...(upDays > 0 ? { upcoming } : {}), ...(a['fleet'] === true ? { fleet: fleetRows } : {}), ...watchData, today, 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, ...(upDays > 0 ? { upcoming } : {}), ...(a['fleet'] === true ? { fleet: fleetRows } : {}), ...watchData, today, capture_status: captureStatus, v2_brief: readV2Brief(dir, today), v2_divergence: briefDivergence([], readV2Brief(dir, today)) },
                 });
             }
             const parts = [];
@@ -252,10 +264,10 @@ export const checkIn = {
             // Route to the tool that acts on whatever is due: settle a contract first,
             // else reconsider/recall. argus_premises closes or defers an open question.
             const next = due.length > 0
-                ? ['argus_settle']
+                ? ['argus_resolve']
                 : openQs.length > 0
-                    ? ['argus_premises', 'argus_recall']
-                    : ['argus_recall'];
+                    ? ['argus_capture', 'argus_patterns']
+                    : ['argus_patterns'];
             return envelope({
                 ok: true, tool: 'argus_check_in',
                 surface: mirrorLine + parts.join(' ') + upcomingLine + fleetLine + integrityLine,
@@ -270,7 +282,7 @@ export const checkIn = {
                     ...(upDays > 0 ? { upcoming } : {}),
                     ...(a['fleet'] === true ? { fleet: fleetRows } : {}),
                     ...watchData,
-                    today, integrity: ledger.integrity,
+                    today, integrity: ledger.integrity, capture_status: captureStatus,
                     // v2 병기 (P2-3): v1이 여전히 정본이고 surface는 무접촉 — 관찰용.
                     // P2 읽기 전환 전에 두 원장의 답이 갈리는지 실사용에서 드러낸다.
                     v2_brief: readV2Brief(dir, today),

package/dist/tools/errors.js

@@ -3,6 +3,7 @@ import { ArgusDirError } from '../lib/argus-dir.js';
 import { PathSafetyError } from '../lib/safe-path.js';
 import { GuardError } from '../lib/state-machine.js';
 import { logError } from '../lib/log.js';
+import { localizedErrorCopy } from '../lib/localized-message.js';
 /**
  * Map a thrown exception to a spine-safe tool error envelope. Known typed
  * errors carry their own code + recovery hint; anything else is an internal
@@ -10,14 +11,27 @@ import { logError } from '../lib/log.js';
  */
 export function handleToolException(tool, e) {
     if (e instanceof ArgusDirError) {
-        return toolError({ ok: false, tool, error_code: e.code, message: e.message, recovery: 'Pass an absolute .argus path with no "..".' });
+        const copy = localizedErrorCopy(null, undefined, {
+            en: { message: e.message, recovery: 'Pass an absolute .argus path with no "..".' },
+            ko: { message: 'Argus 기록 경로가 올바르지 않습니다.', recovery: '".."이 없는 절대 .argus 경로를 전달하세요.' },
+        });
+        return toolError({ ok: false, tool, error_code: e.code, ...copy });
     }
     if (e instanceof PathSafetyError) {
-        return toolError({ ok: false, tool, error_code: e.code, message: e.message, recovery: 'Use ids/labels matching [A-Za-z0-9._-] only.' });
+        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._-] 문자만 사용하세요.' },
+        });
+        return toolError({ ok: false, tool, error_code: e.code, ...copy });
     }
     if (e instanceof GuardError) {
         return toolError({ ok: false, tool, error_code: e.code, message: e.message, recovery: e.recovery });
     }
     logError(`[${tool}] unhandled`, e);
-    return toolError({ ok: false, tool, error_code: 'INTERNAL_ERROR', message: String(e instanceof Error ? e.message : e) });
+    const detail = String(e instanceof Error ? e.message : e);
+    const copy = localizedErrorCopy(null, undefined, {
+        en: { message: `Internal error: ${detail}`, recovery: 'Try the same operation again. If it repeats, inspect the server log.' },
+        ko: { message: `내부 오류가 발생했습니다: ${detail}`, recovery: '같은 작업을 다시 시도하세요. 반복되면 서버 로그를 확인하세요.' },
+    });
+    return toolError({ ok: false, tool, error_code: 'INTERNAL_ERROR', ...copy });
 }

package/dist/tools/index.js

@@ -11,6 +11,38 @@ import { premises } from './premises.js';
 import { recheck } from './recheck.js';
 import { watch } from './watch.js';
 import { candidates } from './candidates.js';
+import { decide, history, settings, publicSeal, publicCheckIn, publicSettle, publicCopy } from './public-tools.js';
+import { toolJsonSchema } from './tool-types.js';
+import { bilingualToolPresentation } from '../lib/tool-presentation.js';
+import { semanticRecord } from './semantic-record.js';
 /** The full registered tool set. There is deliberately no verdict/grade/score tool. */
-export const TOOLS = [openDecision, review, premises, seal, recheck, settle, checkIn, recall, sync, amend, dismiss, candidates, watch, init, config];
-export const TOOL_MAP = new Map(TOOLS.map((t) => [t.name, t]));
+export const TOOLS = [openDecision, review, premises, seal, recheck, settle, checkIn, recall, sync, amend, dismiss, candidates, watch, init, config, semanticRecord];
+/** The small, purpose-led surface returned by tools/list. Legacy tools stay in
+ * TOOL_MAP for cached clients and one-version compatibility, but new users and
+ * models no longer have to choose among internal state-machine parts. */
+export const PUBLIC_TOOLS = [decide, publicSeal, publicCheckIn, publicSettle, history, settings];
+/** The semantic vertical slice is deliberately opt-in until the P5 value gate. */
+export const V3_PILOT_TOOLS = [semanticRecord];
+export const TOOL_MAP = new Map([...TOOLS, ...PUBLIC_TOOLS].map((t) => [t.name, t]));
+/**
+ * The exact tool descriptors returned by tools/list — single source shared by
+ * the server and the host-surface guard test. inputSchema runs through
+ * publicCopy so that a legacy tool name embedded in a Zod field description
+ * (e.g. seal's "no prior argus_open_decision is needed") is rewritten to the
+ * public name before it reaches a host. Without this, the tool-call RESULTS are
+ * translated but the tool SCHEMAS still leaked the old vocabulary.
+ */
+export function servedPublicTools() {
+    const served = process.env['ARGUS_DKK_V6_PILOT'] === '1' ? [...PUBLIC_TOOLS, ...V3_PILOT_TOOLS] : PUBLIC_TOOLS;
+    return served.map((t) => {
+        const presentation = bilingualToolPresentation(t.name, t.annotations?.title, t.description);
+        return {
+            name: t.name,
+            title: presentation.title,
+            description: publicCopy(presentation.description),
+            inputSchema: publicCopy(toolJsonSchema(t.inputSchema)),
+            ...(t.outputSchema ? { outputSchema: t.outputSchema } : {}),
+            ...(t.annotations ? { annotations: t.annotations } : {}),
+        };
+    });
+}

package/dist/tools/init-config.js

@@ -14,6 +14,7 @@ import path from 'path';
 import { envelope, toolError } from '../lib/envelope.js';
 import { ENVELOPE_OUTPUT_SCHEMA, zArgusDir } from './tool-types.js';
 import { handleToolException } from './errors.js';
+import { localizedMessage } from '../lib/localized-message.js';
 import { gitCommonDirOf } from '../v2/git-discovery.js';
 import { initV2 } from '../v2/init.js';
 import { argusHome, ledgerPath } from '../v2/ledger.js';
@@ -39,7 +40,19 @@ export const init = {
             await ensurePrivacyGitignore(dir);
             writeBoundMarker(dir);
             if (!fsSync.existsSync(configPath(dir))) {
-                const cfg = { schema_version: SCHEMA_VERSION, locale: detectLocale(dir), boss: null, team: null, archive: null };
+                // Seed a locale ONLY on a positive Korean env signal (KST machine → ko
+                // once, so the very first contentless surface is Korean). On the default
+                // English/Intl fallback, OMIT locale so runtime content-detection stays
+                // live — otherwise a Korean user on an English-locale OS gets locale:en
+                // pinned on first use, and config-wins means their Korean text can NEVER
+                // reclaim a Korean surface. (Found via the check_in localization yellow,
+                // 2026-07-14: an all-Korean session came back in English forever.)
+                const seededLocale = detectLocale(dir);
+                const cfg = {
+                    schema_version: SCHEMA_VERSION,
+                    ...(seededLocale === 'ko' ? { locale: 'ko' } : {}),
+                    boss: null, team: null, archive: null,
+                };
                 await atomicWriteText(configPath(dir), yaml.dump(cfg));
             }
             // ── v2 바인딩 (P1 수술 1단계 — 파괴 없는 추가) ──
@@ -78,18 +91,18 @@ export const init = {
             // "today is yesterday" immediately instead of at the first missed check-in.
             // Default is system-local; ARGUS_TZ is the explicit override.
             const tz = process.env['ARGUS_TZ'] || `${resolveDefaultTimeZone()} (system local; set ARGUS_TZ to override)`;
+            const locale = readConfig(dir)?.locale ?? detectLocale(dir);
             return envelope({
                 ok: true, tool: 'argus_init',
                 surface: empty
-                    ? 'Argus is ready. It does not give answers — it records a prediction + a check-by date and meets reality on that date. Open your first decision with argus_open_decision.'
-                    : 'Argus is ready.',
-                next_actions: empty ? ['argus_open_decision'] : ['argus_check_in'],
+                    ? localizedMessage(dir, undefined, {
+                        en: 'Argus is ready. Describe a decision you are weighing. It can clarify the decision, save a prediction with a check date, and later record what actually happened. No grades, just your own track record over time.',
+                        ko: 'Argus가 준비됐습니다. 고민 중인 결정을 말해 주세요. 결정을 명료하게 정리하고 확인일이 있는 예측을 저장한 뒤, 그날 실제로 일어난 일을 기록할 수 있습니다. 점수나 평결 없이 당신의 판단 기록만 남습니다.',
+                    })
+                    : localizedMessage(dir, undefined, { en: 'Argus is ready.', ko: 'Argus가 준비됐습니다.' }),
+                next_actions: empty ? ['argus_capture'] : ['argus_check_in'],
                 data: {
-                    initialized: true, argus_dir: dir, today, tz, v2,
-                    // §9.3 — one quiet pointer, data-only, never a push: the daily-watch
-                    // host snippets (CLAUDE.md block + SessionStart hook) ship in the
-                    // package for users who want the watch rhythm carried by their host.
-                    watch_snippets: 'optional — see snippets/claude-code-watch.md in the argus-decision-mcp package',
+                    initialized: true, argus_dir: dir, today, tz, locale, v2,
                 },
             });
         }
@@ -118,7 +131,13 @@ 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) {
-                return envelope({ ok: true, tool: 'argus_config', surface: 'Config read.', next_actions: ['stop'], data: { config: existing, existed: !!readConfig(dir) } });
+                return envelope({
+                    ok: true,
+                    tool: 'argus_config',
+                    surface: localizedMessage(dir, undefined, { en: 'Config read.', ko: '설정을 읽었습니다.' }),
+                    next_actions: ['stop'],
+                    data: { config: existing, existed: !!readConfig(dir) },
+                });
             }
             if ('locale' in a && a['locale'] !== 'ko' && a['locale'] !== 'en') {
                 return toolError({ ok: false, tool: 'argus_config', error_code: 'INVALID_LOCALE', message: 'locale must be "ko" or "en".' });
@@ -134,7 +153,16 @@ export const config = {
                 ...(('premise_sync' in a) ? { premise_sync: a['premise_sync'] } : {}),
             };
             await atomicWriteText(configPath(dir), yaml.dump(merged));
-            return envelope({ ok: true, tool: 'argus_config', surface: 'Config updated.', next_actions: ['stop'], data: { config: merged } });
+            return envelope({
+                ok: true,
+                tool: 'argus_config',
+                surface: localizedMessage(dir, undefined, {
+                    en: `Config updated: ${writeKeys.join(', ')}.`,
+                    ko: `설정을 수정했습니다: ${writeKeys.join(', ')}.`,
+                }),
+                next_actions: ['stop'],
+                data: { config: merged },
+            });
         }
         catch (e) {
             return handleToolException('argus_config', e);

package/dist/tools/open-decision.js

@@ -6,6 +6,7 @@ import { resolveContract } from '../lib/resolve-contract.js';
 import { overfireGate } from '../lib/overfire-gate.js';
 import { validateCrux } from '../lib/validate-crux.js';
 import { computeContinuity } from '../lib/continuity.js';
+import { relatedOpenForPremises } from '../v2/connection-io.js';
 import { resolveResponseLocale, SURFACES } from '../lib/surfaces.js';
 import { appendLedger } from '../lib/ledger-append.js';
 import { ensurePrivacyGitignore } from '../lib/privacy.js';
@@ -50,13 +51,14 @@ export const openDecision = {
             const id = String(a['id'] ?? '');
             const today = resolveToday({ override: a['today_override'] });
             // Response voice follows the decision sentence (M4): config > text > env.
-            const T = SURFACES[resolveResponseLocale(dir, a['decision'])].tools.open_decision;
+            const locale = resolveResponseLocale(dir, a['decision']);
+            const T = SURFACES[locale].tools.open_decision;
             const current = resolveContract(dir, id, today);
             if (a['already_decided'] === true && (current.state === 'sealed' || current.state === 'due' || current.state === 'settled')) {
                 return toolError({
                     ok: false, tool: 'argus_open_decision', error_code: 'ALREADY_CLOSED',
                     message: 'This decision is already underway or closed.',
-                    recovery: 'To check reality, call argus_settle. Closed decisions are not reopened.',
+                    recovery: 'To record what reality did, call argus_resolve. Closed decisions are not reopened.',
                 });
             }
             const signals = {
@@ -65,16 +67,36 @@ export const openDecision = {
                 already_decided: a['already_decided'] === true,
             };
             const gate = overfireGate(signals);
+            // Validate any model-supplied crux BEFORE any side-effect — invalid input
+            // must error without persisting. (The public capture surface no longer
+            // sends a crux; this guards internal callers that still can.)
+            const cruxErr = validateCrux(a['crux_question']);
+            if (cruxErr) {
+                return toolError({ ok: false, tool: 'argus_open_decision', error_code: cruxErr.code, message: cruxErr.message, recovery: cruxErr.recovery });
+            }
             const now = new Date().toISOString();
             // Always log the gate inputs for post-hoc accuracy measurement (M2).
             await appendLedger(dir, [{ id, event: 'gate_input', gate: { ...signals, verdict: gate.reason } }], now);
+            // 기록과 의식을 분리한다: the user's own decision and premise are recorded
+            // REGARDLESS of the gate — deciding it "isn't worth keeping" would itself
+            // be a judgment about the user's decision (zero-judgment violation). The
+            // over-fire gate now governs only the surface CEREMONY (whether a crux is
+            // offered and a seal is nudged), never whether the record is written.
+            await ensurePrivacyGitignore(dir);
+            await atomicWriteJson(sessionFilePath(dir, id), {
+                v: SCHEMA_VERSION, id, problem_text: a['decision'], status_quo: a['status_quo'],
+                load_bearing_assumption: a['load_bearing_assumption'] ?? null, created_at: now,
+            });
+            await appendLedger(dir, [{ id, event: 'harvest', decision: a['decision'] }], now);
+            const relatedIds = Array.isArray(a['related_to']) ? a['related_to'] : [];
+            const continuity = relatedIds.length ? computeContinuity(dir, relatedIds) : undefined;
             if (gate.response === 'reconfirm') {
                 return envelope({
                     ok: true, tool: 'argus_open_decision',
                     surface: T.reconfirm,
-                    next_actions: ['argus_open_decision', 'leave_as_is'],
+                    next_actions: ['leave_as_is'],
                     over_fire_gate: { fired: false, reason: gate.reason },
-                    data: { id, crux_question: null, restraint_option: a['status_quo'], fork_emitted: false, harvest_written: false },
+                    data: { id, crux_question: null, restraint_option: a['status_quo'], fork_emitted: false, harvest_written: true, continuity },
                 });
             }
             if (!gate.fire) {
@@ -82,33 +104,40 @@ export const openDecision = {
                     ok: true, tool: 'argus_open_decision',
                     // Human sentence, not a snake_case enum (11 P2-1). Contract (§4): the
                     // line ENDS by naming the option and returning the handle — never a
-                    // directive ("leave it") issued in the user's stead.
-                    // §9.4 절벽 제거: the restraint verdict stands, but a user who still
-                    // wants the thought KEPT gets an exit — a watch note, not a decision.
-                    surface: `${T.reason[gate.reason] ?? T.reason_fallback} ${T.leave_coda}${T.watch_exit}`,
-                    next_actions: ['leave_as_is', 'argus_watch', 'skip'],
+                    // directive ("leave it") issued in the user's stead. The decision is
+                    // now recorded quietly, so the old "jot a note if you want it kept"
+                    // exit is gone (it IS kept); the gate only withholds the ceremony.
+                    surface: `${T.reason[gate.reason] ?? T.reason_fallback} ${T.leave_coda}`,
+                    next_actions: ['leave_as_is', 'skip'],
                     over_fire_gate: { fired: false, reason: gate.reason },
-                    data: { id, crux_question: null, restraint_option: a['status_quo'], fork_emitted: false, harvest_written: false },
+                    data: { id, crux_question: null, restraint_option: a['status_quo'], fork_emitted: false, harvest_written: true, continuity },
                 });
             }
-            // FIRE: validate any model-supplied crux, persist the harvest.
-            const cruxErr = validateCrux(a['crux_question']);
-            if (cruxErr) {
-                return toolError({ ok: false, tool: 'argus_open_decision', error_code: cruxErr.code, message: cruxErr.message, recovery: cruxErr.recovery });
-            }
-            await ensurePrivacyGitignore(dir);
-            await atomicWriteJson(sessionFilePath(dir, id), {
-                v: SCHEMA_VERSION, id, problem_text: a['decision'], status_quo: a['status_quo'],
-                load_bearing_assumption: a['load_bearing_assumption'] ?? null, created_at: now,
-            });
-            await appendLedger(dir, [{ id, event: 'harvest', decision: a['decision'] }], now);
+            // FIRE: the ceremony — surface the one neutral crux (if supplied) and the
+            // seal path. Persistence already happened above.
             const crux = a['crux_question'] ?? null;
-            const relatedIds = Array.isArray(a['related_to']) ? a['related_to'] : [];
-            const continuity = relatedIds.length ? computeContinuity(dir, relatedIds) : undefined;
+            // Capture-time connection (정본 §8-§11, §8-C): the same mechanical read the
+            // settle surface uses, moved to the front door. If the premise this
+            // decision rests on is one the user already tracks under another OPEN
+            // decision, name that fact + the handle — never a verdict, never "revisit
+            // it". best-effort: a non-git/uninit/failed v2 read just yields no line.
+            const premiseTexts = [
+                typeof a['load_bearing_assumption'] === 'string' ? a['load_bearing_assumption'] : '',
+                ...(Array.isArray(a['premises']) ? a['premises'].map((p) => p?.text ?? '') : []),
+            ];
+            const connections = relatedOpenForPremises(dir, today, premiseTexts, id);
+            let connectionLine = '';
+            if (connections.length > 0) {
+                const shown = connections.slice(0, 3).map((c) => c.decision_id);
+                const extra = connections.length - shown.length;
+                connectionLine = locale === 'ko'
+                    ? `\n이 결정이 기댄 전제와 같은 가정이나 근거에 선 다른 열린 결정: ${shown.join(', ')}${extra > 0 ? ` 외 ${extra}개` : ''}. argus_check_in으로 함께 볼 수 있어요.`
+                    : `\nOther open decisions rest on the same assumption or fact this one leans on: ${shown.join(', ')}${extra > 0 ? ` (+${extra} more)` : ''}. Review them together with argus_check_in.`;
+            }
             return envelope({
                 ok: true, tool: 'argus_open_decision',
-                surface: crux ? T.opened_with_crux(crux) : T.opened_bare,
-                next_actions: ['argus_seal', 'leave_as_is', 'skip'],
+                surface: (crux ? T.opened_with_crux(crux) : T.opened_bare) + connectionLine,
+                next_actions: ['argus_predict', 'leave_as_is', 'skip'],
                 over_fire_gate: { fired: true, reason: gate.reason },
                 data: {
                     id,
@@ -119,6 +148,10 @@ export const openDecision = {
                     fork_emitted: false,
                     harvest_written: true,
                     continuity,
+                    ...(connections.length > 0 ? {
+                        connections: connections.map((c) => c.decision_id),
+                        connection_reasons: connections.map((c) => ({ id: c.decision_id, reason: c.reason, ...(c.via ? { via: c.via } : {}) })),
+                    } : {}),
                     lean_disclosure: 'Naming the load-bearing question points faintly at the flip; that residual lean is a known limit, not a verdict.',
                 },
             });