llm-wiki-kit 0.2.17 → 0.2.18

package/README.md

@@ -10,6 +10,8 @@ The goal is not to make users run `ingest` or `record` commands. After install,
 
 - Korean user prompt -> Korean hook guidance.
 - English user prompt -> English hook guidance.
+- Codex synthetic plan execution prompts such as `Implement the plan.` are treated as neutral, so they reuse the last real session language or project preference instead of forcing English.
+- Project `.kit-state.json` may set `preferredLanguage` to `ko` or `en` for neutral prompts.
 - If there is no clear current prompt language, Claude Code `settings.json` `language` is used when present.
 - If that setting is missing, local `CLAUDE.md` and `AGENTS.md` language signals are used.
 - The fallback is English.
@@ -100,7 +102,7 @@ Use Claude Code or Codex normally.
 The installed hooks:
 
 - inject functional compact context at session start, instructions loaded, and prompt submit. The hook still uses `wiki/memory.md`, `wiki/index.md`, relevant wiki search results, maintenance signals, update status, and any compact recovery packet; it formats only the useful parts so user-visible hook context does not look like a raw debug dump.
-- automatically choose Korean or English hook guidance from the current user prompt, then fall back to Claude Code `language`, local `CLAUDE.md`/`AGENTS.md`, and English.
+- automatically choose Korean or English hook guidance from the current real user prompt, keep Codex synthetic plan execution prompts neutral, then fall back to remembered session language, project `preferredLanguage`, Claude Code `language`, local `CLAUDE.md`/`AGENTS.md`, and English.
 - remove Codex-facing legacy `oh-my-codex:wiki`/`omx_wiki` surfaces at session start so `llm-wiki/` remains the active wiki implementation
 - record small redacted raw event envelopes and per-turn state
 - capture meaningful work and structured decision points, including tool evidence, changed files, verification notes, and reusable durable-candidate signals

package/docs/integrations/claude-code.md

@@ -44,7 +44,7 @@ The hook records redacted turn summaries but does not deny tool calls only becau
 
 At `SessionStart`/`InstructionsLoaded`, the hook first attempts a safe managed-template refresh, recovers stale turn state into `outputs/maintenance/queue.md`, applies deterministic maintenance lifecycle hygiene for the current workspace, performs a cached npm update notice check for npm installs, then injects functional compact context. The context still uses `llm-wiki/wiki/memory.md`, `llm-wiki/wiki/index.md`, relevant wiki/search state, operating rules, maintenance signals, passive runtime update status, and managed-template cleanup notes; the hook formats those signals so they are usable if shown in the Claude Code UI. At `UserPromptSubmit`, it recovers stale turn state, searches wiki pages with MiniSearch or substring fallback, expands one-hop wikilinks, redacts context fields, performs the same cached update notice check, and injects the smallest useful functional compact context set. Verbose `llm-wiki context` can explain `why selected`, `rankReason`, `matchedFields`, and `evidenceRefs`, but hook context keeps those details compact. Update notice cache is scoped by npm command, and maintenance reminders are shown for wiki/maintenance prompts, queue topic matches, approved items, durable candidates, stale/recovered items, or review-threshold pressure.
 
-Hook-visible language is selected from the current user prompt first. Korean prompts get Korean guidance, English prompts get English guidance. If no prompt language is clear, the hook checks Claude Code `settings.json` `language` when it exists, then local `CLAUDE.md`/`AGENTS.md` language signals, then English. The kit does not require Claude Code to expose a language setting.
+Hook-visible language is selected from the current real user prompt first. Korean prompts get Korean guidance, English prompts get English guidance. Neutral prompts can reuse remembered session language or project `preferredLanguage`; then the hook checks Claude Code `settings.json` `language` when it exists, local `CLAUDE.md`/`AGENTS.md` language signals, and finally English. The kit does not require Claude Code to expose a language setting.
 
 `PostToolUse` and `PostToolBatch` record redacted tool summaries in the same turn buffer. `PreCompact` classifies the current turn before compaction: simple turns record only a context note, work-evidence, structured-decision, explicit durable, or hook-suggested durable turns write a chunked live Q&A checkpoint, and durable candidates write a maintenance queue item only when no durable wiki update is detected. Queue items carry `signal_level` and may carry safe `evidence_refs` candidates from actual repo files and verification commands. The checkpoint can include only a bounded redacted transcript tail, never the full raw transcript or raw `transcript_path`. Compaction is not blocked; if checkpoint storage fails, the hook records a compact recovery packet for the next legal context-injection event. `PostCompact` stores the redacted compact summary as a context note and prepares any pending recovery packet without returning model-visible context directly. In the default `answer-first` mode, `SubagentStop` does not create live Q&A, query, decision, or maintenance files. `Stop` and `SessionEnd` append chunked live Q&A only for work-evidence, structured-decision, or durable-candidate turns and do not auto-create `wiki/queries/` or `wiki/decisions/`. If the user explicitly asked to record durable knowledge, or the turn contains reusable architecture/debugging/policy/procedure/decision signals, and no durable wiki update is detected, `Stop`/`SessionEnd` queue a pending maintenance item for agent review. The lifecycle can move explicit/high-signal items to `approved`, skip stale low-signal items, and archive old reviewed items, but it never creates durable wiki pages automatically. Approved and durable-candidate maintenance items are surfaced as compact soft reminders. `Stop` and `SessionEnd` then clear the per-session turn buffer; `SubagentStop` does not.
 

package/docs/integrations/codex.md

@@ -31,7 +31,7 @@ Expected behavior:
 
 - `SessionStart` first attempts a safe managed-template refresh, removes Codex-facing legacy `oh-my-codex:wiki`/`omx_wiki` surfaces when they reappear, recovers stale turn state into `outputs/maintenance/queue.md`, applies deterministic maintenance lifecycle hygiene for the current workspace, performs a cached npm update notice check for npm installs, then injects functional compact context. The context still uses `llm-wiki/wiki/memory.md`, `llm-wiki/wiki/index.md`, relevant wiki/search state, operating rules, maintenance signals, passive runtime update status, and managed-template cleanup notes; the hook formats those signals so they are usable if shown in the Codex UI.
 - `UserPromptSubmit` recovers stale turn state, searches project wiki pages with MiniSearch or substring fallback, expands one-hop wikilinks, redacts context fields, performs the same cached update notice check, and injects the smallest useful functional compact context set. Verbose `llm-wiki context` can explain `why selected`, `rankReason`, `matchedFields`, and `evidenceRefs`, but hook context keeps those details compact. Update notice cache is scoped by npm command, and maintenance reminders are shown for wiki/maintenance prompts, queue topic matches, approved items, durable candidates, stale/recovered items, or review-threshold pressure.
-- Hook-visible language is selected from the current user prompt first. Korean prompts get Korean guidance, English prompts get English guidance. If no prompt language is clear, Codex falls back to local `CLAUDE.md`/`AGENTS.md` language signals, then English.
+- Hook-visible language is selected from the current real user prompt first. Korean prompts get Korean guidance, English prompts get English guidance. Codex synthetic plan execution prompts such as `Implement the plan.` are treated as neutral, so they reuse remembered session language or project `preferredLanguage` instead of forcing English. If no prompt language is clear, Codex falls back to local `CLAUDE.md`/`AGENTS.md` language signals, then English.
 - `PreToolUse` records redacted tool summaries without blocking tool calls.
 - `PostToolUse` records redacted tool summaries in a turn buffer.
 - `PreCompact` classifies the current turn before compaction. Simple turns record only a context note; work-evidence, structured-decision, explicit durable, or hook-suggested durable turns write a chunked live Q&A checkpoint; durable candidates write a maintenance queue item only when no durable wiki update is detected. The checkpoint can include only a bounded redacted transcript tail, never the full raw transcript or raw `transcript_path`. Compaction is not blocked; if checkpoint storage fails, the hook records a compact recovery packet for the next legal context-injection event.

package/docs/manual.md

@@ -10,6 +10,8 @@ The runtime supports seamless Korean/English use:
 
 - If the current user prompt is clearly Korean, hook-visible guidance is Korean.
 - If the current user prompt is clearly English, hook-visible guidance is English.
+- Codex synthetic plan execution prompts such as `Implement the plan.` are not treated as English; they reuse the last real session language or project preference.
+- A project can set `preferredLanguage` in `llm-wiki/.kit-state.json` for neutral prompts.
 - When there is no clear prompt language, Claude Code may use its `settings.json` `language` value when present.
 - If no setting exists, the runtime checks local `CLAUDE.md` and `AGENTS.md` language signals.
 - The fallback is English.
@@ -68,7 +70,7 @@ llm-wiki/
 Use Codex or Claude Code normally. Installed hooks:
 
 - inject functional compact context at session start, instructions loaded, and prompt submit;
-- select Korean or English hook guidance from the current user prompt and local instruction files;
+- select Korean or English hook guidance from the current real user prompt, remembered session language, project preference, and local instruction files;
 - use `wiki/memory.md`, `wiki/index.md`, relevant wiki search, maintenance signals, update notices, and compact recovery packets;
 - record redacted prompt/tool/result summaries in per-turn state;
 - preserve safe evidence pointers as `evidence_refs` when changed files or verification commands are available;

package/docs/operations.md

@@ -296,6 +296,8 @@ Managed project files are conservative:
 
 Real registry checks require `llm-wiki-kit` to be published to npm. Before publication, `llm-wiki update --check` returns npm 404. Use fake npm in tests or local tarball install for server smoke checks.
 
+For Korean-first Codex projects, set `preferredLanguage: "ko"` in `llm-wiki/.kit-state.json` when neutral prompts should stay Korean. This is especially useful after Codex plan approval, because Codex may submit `Implement the plan.` as the next prompt and the runtime deliberately treats that exact synthetic prompt as language-neutral.
+
 ## Release Checklist
 
 Before publishing:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-wiki-kit",
-  "version": "0.2.17",
+  "version": "0.2.18",
   "description": "Hook-first living Markdown wiki runtime for Codex and Claude Code with Korean/English prompt-aware guidance.",
   "type": "module",
   "files": [

package/src/consolidate.js

@@ -3,6 +3,7 @@ import { appendWikiLog } from './project.js';
 import { backupFile, exists, readText, writeText } from './fs-utils.js';
 import { hasSecretLikeText, isSensitivePath, normalizeForStorage } from './redaction.js';
 import { indexPage, memoryPage } from './templates.js';
+import { resolveLanguage } from './language.js';
 import { collectWikiPages } from './wiki-model.js';
 import { runLint } from './wiki-lint.js';
 import {
@@ -99,22 +100,25 @@ function sortedPages(pages) {
     });
 }
 
-function buildGeneratedMemoryBlock(pages, stats) {
+function buildGeneratedMemoryBlock(pages, stats, options = {}) {
+  const ko = options.language === 'ko';
   const allCandidates = sortedPages(pages);
   const candidates = allCandidates.slice(0, 25);
   stats.memoryPages = candidates.length;
   const lines = [
-    '## Generated Memory Map',
+    ko ? '## 생성된 Memory Map' : '## Generated Memory Map',
     '',
-    `- Durable pages indexed: ${allCandidates.length}`,
-    `- Hidden episodic pages: ${stats.hiddenEpisodicPages}`,
-    `- Skipped archived/stale/superseded pages: ${stats.archivedSkippedPages}/${stats.staleSkippedPages}/${stats.supersededSkippedPages}`,
+    ko ? `- 색인된 durable 문서: ${allCandidates.length}` : `- Durable pages indexed: ${allCandidates.length}`,
+    ko ? `- 숨긴 episodic 문서: ${stats.hiddenEpisodicPages}` : `- Hidden episodic pages: ${stats.hiddenEpisodicPages}`,
+    ko
+      ? `- 건너뛴 archived/stale/superseded 문서: ${stats.archivedSkippedPages}/${stats.staleSkippedPages}/${stats.supersededSkippedPages}`
+      : `- Skipped archived/stale/superseded pages: ${stats.archivedSkippedPages}/${stats.staleSkippedPages}/${stats.supersededSkippedPages}`,
   ];
   if (candidates.length === 0) {
-    lines.push('- No durable pages found yet.');
+    lines.push(ko ? '- 아직 durable 문서가 없습니다.' : '- No durable pages found yet.');
     return lines.join('\n');
   }
-  lines.push('', '### High-Value Pages');
+  lines.push('', ko ? '### 핵심 문서' : '### High-Value Pages');
   for (const page of candidates) {
     const metadata = [
       page.type || 'unknown',
@@ -127,7 +131,8 @@ function buildGeneratedMemoryBlock(pages, stats) {
   return lines.join('\n');
 }
 
-function buildGeneratedIndexBlock(pages) {
+function buildGeneratedIndexBlock(pages, options = {}) {
+  const ko = options.language === 'ko';
   const groups = new Map();
   const candidates = sortedPages(pages);
   for (const page of candidates) {
@@ -137,12 +142,12 @@ function buildGeneratedIndexBlock(pages) {
   }
 
   const lines = [
-    '## Generated Page Map',
+    ko ? '## 생성된 문서 지도' : '## Generated Page Map',
     '',
-    `- Durable pages indexed: ${candidates.length}`,
+    ko ? `- 색인된 durable 문서: ${candidates.length}` : `- Durable pages indexed: ${candidates.length}`,
   ];
   if (groups.size === 0) {
-    lines.push('- No durable pages found yet.');
+    lines.push(ko ? '- 아직 durable 문서가 없습니다.' : '- No durable pages found yet.');
     return lines.join('\n');
   }
   for (const type of [...groups.keys()].sort()) {
@@ -171,6 +176,7 @@ export async function runConsolidate(projectRoot, options = {}) {
   const lintResult = await runLint(projectRoot, { maxFiles: options.maxFiles || 1000 });
   const pages = await collectWikiPages(projectRoot, { maxFiles: options.maxFiles || 1000 });
   const { candidates, stats } = classifyGeneratedPages(pages);
+  const language = await resolveLanguage(projectRoot, {}).catch(() => 'en');
   const changed = [];
   const skipped = [];
 
@@ -180,7 +186,7 @@ export async function runConsolidate(projectRoot, options = {}) {
     memoryPage(),
     MEMORY_START,
     MEMORY_END,
-    buildGeneratedMemoryBlock(candidates, stats),
+    buildGeneratedMemoryBlock(candidates, stats, { language }),
     options,
   );
   if (memoryChange?.changed) changed.push(memoryChange.changed);
@@ -192,7 +198,7 @@ export async function runConsolidate(projectRoot, options = {}) {
     indexPage(),
     INDEX_START,
     INDEX_END,
-    buildGeneratedIndexBlock(candidates),
+    buildGeneratedIndexBlock(candidates, { language }),
     options,
   );
   if (indexChange?.changed) changed.push(indexChange.changed);

package/src/hook.js

@@ -6,10 +6,10 @@ import { applyMaintenanceLifecycle, recoverStaleTurnStates, recordMaintenanceFor
 import { applyProjectTemplateUpdate, inspectProjectState } from './project-state.js';
 import { recordProject } from './projects.js';
 import { summarizeForStorage } from './redaction.js';
-import { buildEntryFromState, clearTurnState, rememberQuestion, rememberTool } from './state.js';
+import { buildEntryFromState, clearTurnState, readRememberedLanguage, rememberLanguage, rememberQuestion, rememberTool } from './state.js';
 import { updateNoticeContext } from './update-notice.js';
 import { removeLegacyOmxWikiSurfaces } from './legacy-omx-wiki.js';
-import { resolveLanguage } from './language.js';
+import { detectTextLanguage, isSyntheticPlanPrompt, resolveLanguage } from './language.js';
 import { relative } from 'path';
 
 async function readStdinJson() {
@@ -30,6 +30,11 @@ function promptText(payload) {
   return payload.prompt || payload.user_prompt || payload.userPrompt || payload.message || payload.input || '';
 }
 
+function storagePromptText(prompt, language) {
+  if (!isSyntheticPlanPrompt(prompt)) return prompt;
+  return language === 'ko' ? '승인된 계획 실행' : 'Approved plan implementation.';
+}
+
 function toolSummary(payload) {
   const toolName = payload.tool_name || payload.toolName || payload.name || payload.tool?.name || 'tool';
   const input = payload.tool_input || payload.toolInput || payload.input || payload.arguments || payload.tool?.input || {};
@@ -145,10 +150,17 @@ export async function handleHook(provider, explicitEvent) {
   const cwd = payload.cwd || process.cwd();
   const projectRoot = await findProjectRoot(cwd);
   await bootstrapProject(projectRoot);
+  const prompt = eventName === 'UserPromptSubmit' ? promptText(payload) : '';
+  const promptLanguage = eventName === 'UserPromptSubmit' ? detectTextLanguage(prompt) : null;
+  const rememberedLanguage = await readRememberedLanguage(projectRoot, payload).catch(() => null);
   const requestLanguage = await resolveLanguage(projectRoot, {
     provider,
-    prompt: eventName === 'UserPromptSubmit' ? promptText(payload) : '',
+    prompt,
+    rememberedLanguage,
   }).catch(() => 'en');
+  if (eventName === 'UserPromptSubmit' && promptLanguage) {
+    await rememberLanguage(projectRoot, payload, promptLanguage, 'prompt').catch(() => null);
+  }
   await recordProject(projectRoot, 'hook').catch(() => {});
   await autoUpdateManagedProject(projectRoot, eventName).catch(() => {});
   await removeLegacyWikiSurfaces(projectRoot, eventName).catch(() => {});
@@ -175,14 +187,17 @@ export async function handleHook(provider, explicitEvent) {
   }
 
   if (eventName === 'UserPromptSubmit') {
-    const prompt = promptText(payload);
-    await rememberQuestion(projectRoot, payload, prompt);
-    const guidance = formatDurableCaptureGuidance(prompt, { language: requestLanguage });
+    const storedPrompt = storagePromptText(prompt, requestLanguage);
+    await rememberQuestion(projectRoot, payload, storedPrompt, {
+      language: requestLanguage,
+      skipIfExisting: isSyntheticPlanPrompt(prompt),
+    });
+    const guidance = formatDurableCaptureGuidance(storedPrompt, { language: requestLanguage });
     const recovery = await consumeCompactRecoveryContext(projectRoot, payload).catch(() => '');
     const context = await hookContext(
       projectRoot,
       eventName,
-      [recovery, await buildContextBrief(projectRoot, eventName, prompt, { language: requestLanguage }), guidance].filter(Boolean).join('\n\n'),
+      [recovery, await buildContextBrief(projectRoot, eventName, storedPrompt, { language: requestLanguage }), guidance].filter(Boolean).join('\n\n'),
       payload,
       requestLanguage
     );
@@ -210,7 +225,10 @@ export async function handleHook(provider, explicitEvent) {
 
   if (eventName === 'Stop' || eventName === 'SubagentStop' || eventName === 'SessionEnd') {
     const assistantText = payload.last_assistant_message || payload.response || payload.assistant_response || '';
-    const entry = await buildEntryFromState(projectRoot, payload, assistantText);
+    const entry = {
+      ...await buildEntryFromState(projectRoot, payload, assistantText),
+      language: requestLanguage,
+    };
     if (isLegacyEagerCaptureMode()) {
       await handleLegacyEagerStop(projectRoot, eventName, payload, entry);
     } else {

package/src/language.js

@@ -3,6 +3,7 @@ import { homeDir, readJson, readText } from './fs-utils.js';
 
 const HANGUL_RE = /[\u3131-\u318e\uac00-\ud7a3]/g;
 const LATIN_RE = /[A-Za-z]/g;
+const SYNTHETIC_PLAN_PROMPT_RE = /^\s*implement\s+the\s+plan\.?\s*$/i;
 
 export function normalizeLanguage(value) {
   const text = String(value || '').trim().toLowerCase();
@@ -14,9 +15,14 @@ export function normalizeLanguage(value) {
   return null;
 }
 
+export function isSyntheticPlanPrompt(value) {
+  return SYNTHETIC_PLAN_PROMPT_RE.test(String(value || ''));
+}
+
 export function detectTextLanguage(value) {
   const text = String(value || '').normalize('NFC');
   if (!text.trim()) return null;
+  if (isSyntheticPlanPrompt(text)) return null;
   const hangul = (text.match(HANGUL_RE) || []).length;
   const latin = (text.match(LATIN_RE) || []).length;
   if (hangul >= 2) return 'ko';
@@ -25,6 +31,11 @@ export function detectTextLanguage(value) {
   return null;
 }
 
+async function projectPreferredLanguage(projectRoot) {
+  const state = await readJson(join(projectRoot, 'llm-wiki', '.kit-state.json'), null);
+  return normalizeLanguage(state?.preferredLanguage || state?.preferred_language);
+}
+
 async function claudeSettingsLanguage(projectRoot) {
   const paths = [
     join(homeDir(), '.claude', 'settings.json'),
@@ -61,6 +72,10 @@ async function instructionFileLanguage(projectRoot) {
 export async function resolveLanguage(projectRoot, options = {}) {
   const promptLanguage = detectTextLanguage(options.prompt || '');
   if (promptLanguage) return promptLanguage;
+  const rememberedLanguage = normalizeLanguage(options.rememberedLanguage);
+  if (rememberedLanguage) return rememberedLanguage;
+  const preferredLanguage = await projectPreferredLanguage(projectRoot);
+  if (preferredLanguage) return preferredLanguage;
   if (String(options.provider || '').toLowerCase() === 'claude') {
     const settingsLanguage = await claudeSettingsLanguage(projectRoot);
     if (settingsLanguage) return settingsLanguage;

package/src/live-qa.js

@@ -95,31 +95,52 @@ async function targetChunkPath(projectRoot, day, block, options = {}) {
 }
 
 export function formatLiveQaBlock(entry) {
+  const korean = entry.language === 'ko';
+  const labels = korean
+    ? {
+        question: '### 질문',
+        work: '### 작업',
+        result: '### 결과',
+        changedFiles: '### 변경 파일',
+        verification: '### 검증',
+        followUp: '### 후속 조치',
+        fallback: '작업/결정 중심 live Q&A 기록입니다. 재사용할 사실은 사용자가 요청했거나 명확히 중요할 때만 기존 durable wiki 문서에 병합합니다.',
+      }
+    : {
+        question: '### Question',
+        work: '### Work',
+        result: '### Result',
+        changedFiles: '### Changed files',
+        verification: '### Verification',
+        followUp: '### Follow-up',
+        fallback: 'Work/decision-focused live Q&A record. Merge reusable facts into existing durable wiki pages only when the user asks or the fact is clearly important.',
+      };
   return [
     `\n## ${timeKst()} KST - ${entry.topic || 'session turn'}`,
     '',
-    '### Question',
+    labels.question,
     entry.question || '(not captured)',
     '',
-    '### Work',
+    labels.work,
     entry.work || '(not captured)',
     '',
-    '### Result',
+    labels.result,
     entry.result || '(not captured)',
     '',
-    '### Changed files',
+    labels.changedFiles,
     entry.changedFiles || '(not captured)',
     '',
-    '### Verification',
+    labels.verification,
     entry.verification || '(not captured)',
     '',
-    '### Follow-up',
-    entry.followUp || 'Work/decision-focused live Q&A record. Merge reusable facts into existing durable wiki pages only when the user asks or the fact is clearly important.',
+    labels.followUp,
+    entry.followUp || labels.fallback,
     '',
   ].join('\n');
 }
 
-export async function refreshLiveQaIndex(projectRoot, day = todayKst()) {
+export async function refreshLiveQaIndex(projectRoot, day = todayKst(), options = {}) {
+  const korean = options.language === 'ko';
   const dayDir = liveQaDayDir(projectRoot, day);
   const files = await listChunkFiles(dayDir);
   const rows = [];
@@ -134,13 +155,15 @@ export async function refreshLiveQaIndex(projectRoot, day = todayKst()) {
   const content = [
     `# Live Q&A ${day}`,
     '',
-    'Chunked live Q&A archive for meaningful work and decision turns.',
+    korean
+      ? '의미 있는 작업과 결정 turn을 날짜별 chunk로 보관하는 live Q&A archive입니다.'
+      : 'Chunked live Q&A archive for meaningful work and decision turns.',
     '',
     `- chunks: ${files.length}`,
     `- turns: ${totalBlocks}`,
     `- updated_at: ${new Date().toISOString()}`,
     '',
-    '## Chunks',
+    korean ? '## 청크' : '## Chunks',
     '',
     rows.length > 0 ? rows.join('\n') : '(none)',
     '',
@@ -153,7 +176,7 @@ export async function appendLiveQa(projectRoot, entry, options = {}) {
   const block = redactText(formatLiveQaBlock(entry), 12000);
   const path = await targetChunkPath(projectRoot, day, block, options);
   await appendText(path, block);
-  await refreshLiveQaIndex(projectRoot, day);
+  await refreshLiveQaIndex(projectRoot, day, { language: entry.language });
   return path;
 }
 

package/src/project.js

@@ -109,7 +109,27 @@ export async function writeQueryPage(projectRoot, entry) {
   const path = join(projectRoot, 'llm-wiki', 'wiki', 'queries', `${day}-${slug}.md`);
   if (await exists(path)) return path;
   const evidenceRefs = frontmatterEvidenceRefs(evidenceRefsFromEntry(entry, { projectRoot }));
-  const content = `---\ntitle: "${entry.topic || slug}"\ntype: "query"\nsource_ids: []\n${evidenceRefs}\nstatus: "draft"\nlast_updated: "${day}"\nconfidence: "medium"\nmemory_type: "episodic"\nimportance: 2\nlast_verified: "unknown"\nsupersedes: []\nsuperseded_by: []\n---\n\n# ${entry.topic || entry.question.slice(0, 80)}\n\n## Question\n${entry.question}\n\n## Answer Summary\n${entry.result || '(not captured)'}\n\n## Work Notes\n${entry.work || '(not captured)'}\n\n## Verification\n${entry.verification || '(not captured)'}\n\n## Related Pages\n- [[index]]\n\n## Change Log\n- ${day}: Captured automatically by llm-wiki-kit hook.\n`;
+  const ko = entry.language === 'ko';
+  const labels = ko
+    ? {
+        question: '질문',
+        answer: '답변 요약',
+        work: '작업 메모',
+        verification: '검증',
+        related: '관련 문서',
+        changeLog: '변경 기록',
+        captured: 'llm-wiki-kit hook이 자동 기록함.',
+      }
+    : {
+        question: 'Question',
+        answer: 'Answer Summary',
+        work: 'Work Notes',
+        verification: 'Verification',
+        related: 'Related Pages',
+        changeLog: 'Change Log',
+        captured: 'Captured automatically by llm-wiki-kit hook.',
+      };
+  const content = `---\ntitle: "${entry.topic || slug}"\ntype: "query"\nsource_ids: []\n${evidenceRefs}\nstatus: "draft"\nlast_updated: "${day}"\nconfidence: "medium"\nmemory_type: "episodic"\nimportance: 2\nlast_verified: "unknown"\nsupersedes: []\nsuperseded_by: []\n---\n\n# ${entry.topic || entry.question.slice(0, 80)}\n\n## ${labels.question}\n${entry.question}\n\n## ${labels.answer}\n${entry.result || '(not captured)'}\n\n## ${labels.work}\n${entry.work || '(not captured)'}\n\n## ${labels.verification}\n${entry.verification || '(not captured)'}\n\n## ${labels.related}\n- [[index]]\n\n## ${labels.changeLog}\n- ${day}: ${labels.captured}\n`;
   await writeTextIfMissing(path, redactText(content, 12000));
   return path;
 }
@@ -123,7 +143,33 @@ export async function writeDecisionPage(projectRoot, entry) {
   const path = join(projectRoot, 'llm-wiki', 'wiki', 'decisions', `${day}-${slug}.md`);
   if (await exists(path)) return path;
   const evidenceRefs = frontmatterEvidenceRefs(evidenceRefsFromEntry(entry, { projectRoot }));
-  const content = `---\ntitle: "${entry.topic || slug}"\ntype: "decision"\nsource_ids: []\n${evidenceRefs}\nstatus: "draft"\nlast_updated: "${day}"\nconfidence: "medium"\nmemory_type: "semantic"\nimportance: 4\nlast_verified: "unknown"\nsupersedes: []\nsuperseded_by: []\n---\n\n# ${entry.topic || 'Decision'}\n\n## Decision\n${entry.result || '(captured from assistant response; review needed)'}\n\n## Context\n${entry.question || '(not captured)'}\n\n## Evidence\n${entry.work || '(not captured)'}\n\n## Verification\n${entry.verification || '(not captured)'}\n\n## Open Questions\n${entry.followUp || '(none captured)'}\n\n## Change Log\n- ${day}: Captured automatically by llm-wiki-kit hook.\n`;
+  const ko = entry.language === 'ko';
+  const labels = ko
+    ? {
+        title: '결정',
+        decision: '결정',
+        context: '맥락',
+        evidence: '근거',
+        verification: '검증',
+        openQuestions: '열린 질문',
+        changeLog: '변경 기록',
+        fallbackDecision: '(assistant 응답에서 캡처됨; 검토 필요)',
+        fallbackOpen: '(기록 없음)',
+        captured: 'llm-wiki-kit hook이 자동 기록함.',
+      }
+    : {
+        title: 'Decision',
+        decision: 'Decision',
+        context: 'Context',
+        evidence: 'Evidence',
+        verification: 'Verification',
+        openQuestions: 'Open Questions',
+        changeLog: 'Change Log',
+        fallbackDecision: '(captured from assistant response; review needed)',
+        fallbackOpen: '(none captured)',
+        captured: 'Captured automatically by llm-wiki-kit hook.',
+      };
+  const content = `---\ntitle: "${entry.topic || slug}"\ntype: "decision"\nsource_ids: []\n${evidenceRefs}\nstatus: "draft"\nlast_updated: "${day}"\nconfidence: "medium"\nmemory_type: "semantic"\nimportance: 4\nlast_verified: "unknown"\nsupersedes: []\nsuperseded_by: []\n---\n\n# ${entry.topic || labels.title}\n\n## ${labels.decision}\n${entry.result || labels.fallbackDecision}\n\n## ${labels.context}\n${entry.question || '(not captured)'}\n\n## ${labels.evidence}\n${entry.work || '(not captured)'}\n\n## ${labels.verification}\n${entry.verification || '(not captured)'}\n\n## ${labels.openQuestions}\n${entry.followUp || labels.fallbackOpen}\n\n## ${labels.changeLog}\n- ${day}: ${labels.captured}\n`;
   await writeTextIfMissing(path, redactText(content, 12000));
   return path;
 }

package/src/state.js

@@ -1,6 +1,7 @@
 import { join } from 'path';
 import { unlink } from 'fs/promises';
 import { kitDataDir, readJson, sha256, writeJson } from './fs-utils.js';
+import { normalizeLanguage } from './language.js';
 import { summarizeForStorage } from './redaction.js';
 
 export function sessionKey(projectRoot, payload) {
@@ -17,6 +18,18 @@ export function statePath(projectRoot, payload) {
   return join(kitDataDir(), 'state', `${sessionKey(projectRoot, payload)}.json`);
 }
 
+function projectLanguageKey(projectRoot) {
+  return sha256(projectRoot).slice(0, 32);
+}
+
+export function sessionLanguagePath(projectRoot, payload) {
+  return join(kitDataDir(), 'language', `${sessionKey(projectRoot, payload)}.json`);
+}
+
+export function projectLanguagePath(projectRoot) {
+  return join(kitDataDir(), 'language', `${projectLanguageKey(projectRoot)}-project.json`);
+}
+
 export async function readTurnState(projectRoot, payload) {
   return (await readJson(statePath(projectRoot, payload), null)) || {
     projectRoot,
@@ -54,12 +67,40 @@ export async function clearCompactRecovery(projectRoot, payload) {
   await unlink(compactRecoveryPath(projectRoot, payload)).catch(() => {});
 }
 
-export async function rememberQuestion(projectRoot, payload, prompt) {
+export async function rememberLanguage(projectRoot, payload, language, source = 'prompt') {
+  const normalized = normalizeLanguage(language);
+  if (!normalized) return null;
+  const record = {
+    language: normalized,
+    source,
+    updated_at: new Date().toISOString(),
+  };
+  await writeJson(sessionLanguagePath(projectRoot, payload), record);
+  await writeJson(projectLanguagePath(projectRoot), record);
+  return record;
+}
+
+export async function readRememberedLanguage(projectRoot, payload) {
+  const session = await readJson(sessionLanguagePath(projectRoot, payload), null);
+  const sessionLanguage = normalizeLanguage(session?.language);
+  if (sessionLanguage) return sessionLanguage;
+  const project = await readJson(projectLanguagePath(projectRoot), null);
+  return normalizeLanguage(project?.language);
+}
+
+export async function rememberQuestion(projectRoot, payload, prompt, options = {}) {
   const state = await readTurnState(projectRoot, payload);
+  if (options.skipIfExisting && state.questions.length > 0) {
+    if (options.language) state.language = normalizeLanguage(options.language) || state.language;
+    await writeTurnState(projectRoot, payload, state);
+    return state;
+  }
   const clean = summarizeForStorage(prompt, 3000);
   if (clean) state.questions.push({ at: new Date().toISOString(), text: clean });
   state.questions = state.questions.slice(-5);
+  if (options.language) state.language = normalizeLanguage(options.language) || state.language;
   await writeTurnState(projectRoot, payload, state);
+  return state;
 }
 
 export async function rememberTool(projectRoot, payload, summary) {
@@ -112,5 +153,6 @@ export function buildEntryFromTurnState(state, assistantText = '') {
     followUp: '',
     firstTimestamp: questions[0]?.at || tools[0]?.at || state.updated_at,
     session: state.session,
+    language: normalizeLanguage(state.language),
   };
 }

package/src/templates.js

@@ -9,7 +9,7 @@ This repository uses llm-wiki-kit as a hook-first living Markdown wiki for Codex
 
 - This block supersedes older OMX/OMC/\`omx_wiki/\` LLM Wiki instructions for this repository.
 - Use Codex or Claude Code normally. Do not create a workflow where users must remember extra \`llm-wiki\` commands during ordinary work.
-- Language: respond in the user's current prompt language when it is clearly Korean or English. Keep technical identifiers, commands, paths, code, and original error text unchanged. If no prompt language is clear, follow local \`CLAUDE.md\`/\`AGENTS.md\` guidance, then fall back to English.
+- Language: respond in the user's current real prompt language when it is clearly Korean or English. Codex synthetic plan execution prompts such as \`Implement the plan.\` are neutral and should reuse the last real session language or project preference. Keep technical identifiers, commands, paths, code, and original error text unchanged. If no prompt language is clear, follow local \`CLAUDE.md\`/\`AGENTS.md\` guidance, then fall back to English.
 - Treat chat memory as temporary. Durable project knowledge belongs in repository Markdown under \`llm-wiki/\`.
 - \`llm-wiki/raw/\` is the immutable or redacted evidence layer. Do not modify raw captures except safe hook envelope append.
 - \`llm-wiki/wiki/\` is the curated knowledge layer managed by the agent. Put decisions, architecture, debugging findings, concepts, procedures, and context there.
@@ -46,7 +46,8 @@ The user should not need to run many \`llm-wiki\` commands manually. The agent c
 These rules replace older OMX/OMC/\`omx_wiki/\` rules for this project.
 
 ## Language
-- Follow the user's current prompt language when it is clearly Korean or English.
+- Follow the user's current real prompt language when it is clearly Korean or English.
+- Treat Codex synthetic plan execution prompts such as \`Implement the plan.\` as neutral; reuse the last real session language or project preference when available.
 - If no current prompt language is clear, follow local \`CLAUDE.md\`/\`AGENTS.md\` guidance, then fall back to English.
 - Keep commands, paths, code identifiers, API names, package names, logs, and original error text unchanged.
 - Korean and English users should both be able to use Codex/Claude Code naturally without changing \`llm-wiki\` commands.

package/src/wiki-search.js

@@ -470,16 +470,16 @@ export function formatHookContextPack(pack, options = {}) {
   const language = options.language === 'ko' ? 'ko' : 'en';
   const lines = language === 'ko'
     ? [
-        'LLM Wiki context (functional compact):',
+        'LLM Wiki context (기능 요약):',
         '- 우선순위: 현재 사용자 요청에 먼저 답하고, wiki context는 도움이 될 때만 사용한다.',
         '- 언어: 현재 사용자 입력 언어를 따른다. 경로, 명령어, 코드 식별자, 오류 원문은 원래 언어를 유지한다.',
-        '- 기능 유지: hook memory/search/capture/maintenance/update signals are active.',
+        '- 기능 유지: hook memory/search/capture/maintenance/update 신호가 활성화되어 있다.',
         '- 오래 남길 프로젝트 지식은 llm-wiki/wiki에 둔다. credentials, tokens, private keys, .env contents는 저장하지 않는다.',
       ]
     : [
         'LLM Wiki context (functional compact):',
         '- Priority: answer the current user request first; use wiki context when it helps.',
-        '- Language: follow the current user prompt language. Keep paths, commands, code identifiers, and original error text unchanged.',
+        '- Language: follow the current real user prompt language. Keep paths, commands, code identifiers, and original error text unchanged.',
         '- Functionality: hook memory/search/capture/maintenance/update signals are active.',
         '- Durable project knowledge belongs in llm-wiki/wiki; never store credentials, tokens, private keys, or .env contents.',
       ];
@@ -490,12 +490,12 @@ export function formatHookContextPack(pack, options = {}) {
 
   const memoryLines = memoryFocusLines(pack.memoryExcerpt, options.memoryLineLimit ?? 6);
   if (memoryLines.length > 0) {
-    lines.push('', language === 'ko' ? 'Memory focus:' : 'Memory focus:');
+    lines.push('', language === 'ko' ? '메모리 핵심:' : 'Memory focus:');
     lines.push(...memoryLines.map((line) => `- ${line.replace(/^-\s+/, '')}`));
   } else {
     lines.push(
       '',
-      'Memory focus:',
+      language === 'ko' ? '메모리 핵심:' : 'Memory focus:',
       language === 'ko'
         ? '- 프로젝트 맥락이 필요하면 llm-wiki/wiki/memory.md와 llm-wiki/wiki/index.md를 확인한다.'
         : '- See llm-wiki/wiki/memory.md and llm-wiki/wiki/index.md when project context is needed.'
@@ -504,7 +504,7 @@ export function formatHookContextPack(pack, options = {}) {
 
   const hits = hookHits(pack, options);
   if (hits.length > 0) {
-    lines.push('', language === 'ko' ? 'Relevant wiki pages:' : 'Relevant wiki pages:');
+    lines.push('', language === 'ko' ? '관련 wiki 문서:' : 'Relevant wiki pages:');
     for (const hit of hits) {
       const suffix = hit.source === 'linked' && hit.via.length > 0
         ? `, via ${hit.via.join(', ')}`
@@ -514,7 +514,7 @@ export function formatHookContextPack(pack, options = {}) {
   } else if (pack.query) {
     lines.push(
       '',
-      'Relevant wiki pages:',
+      language === 'ko' ? '관련 wiki 문서:' : 'Relevant wiki pages:',
       language === 'ko'
         ? '- 직접 관련된 durable wiki 문서를 찾지 못했다. 정상적으로 답하고, 필요할 때만 파일/wiki를 확인한다.'
         : '- No directly relevant durable wiki page found; answer normally and inspect files/wiki only if needed.'
@@ -523,7 +523,7 @@ export function formatHookContextPack(pack, options = {}) {
 
   const logLines = logFocusLines(pack.logExcerpt, options.logLineLimit ?? 2);
   if (logLines.length > 0) {
-    lines.push('', 'Recent log:');
+    lines.push('', language === 'ko' ? '최근 로그:' : 'Recent log:');
     lines.push(...logLines.map((line) => `- ${line.replace(/^-\s+/, '')}`));
   }