llm-wiki-kit 0.2.11 → 0.2.13

package/docs/operations.md

@@ -127,7 +127,9 @@ Installed npm runtimes also run a cached hook-side update notice check while the
 
 - runs `npm install -g llm-wiki-kit@<target>` only when the registry target is newer than the installed runtime
 - skips npm installation when the installed runtime already satisfies the target, then still runs post-update maintenance
-- restarts into the updated binary for `post-update`
+- checks `npm root -g`/`npm prefix -g` before install and refuses to claim success when npm would update a different global prefix than the active runtime
+- verifies that the active runtime and `post-update` child runtime reached the registry target after install
+- prints before/after runtime, registry target, npm global root, active runtime root, and PATH command diagnostics
 - reinstalls hook entries without duplicating them
 - patches only managed project files across known or discovered project roots
 - backs up changed files under `~/.local/share/llm-wiki-kit/backups/`

package/docs/troubleshooting.md

@@ -113,6 +113,8 @@ If the proxy performs TLS inspection, install the organization's CA and set `caf
 
 If `npm install -g llm-wiki-kit@latest` succeeds but `llm-wiki --help` does not show newer commands such as `projects`, `context`, `lint`, or `consolidate`, the shell is probably executing an older source checkout or stale shim before the npm global binary.
 
+Newer `llm-wiki update` releases diagnose this before claiming success. If the npm global root does not match the active runtime root, or if `npm install -g` exits 0 but the active runtime is still old, `update` exits nonzero with details such as `active runtime root`, `npm global root`, `runtime before`, `runtime after`, and `command matches runtime`. On root-owned Linux prefixes, run the printed `sudo npm install -g llm-wiki-kit@<target>` command, then run the printed `llm-wiki post-update ...` command as the normal Codex/Claude user.
+
 Confirm what is actually running:
 
 ```bash

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "llm-wiki-kit",
-  "version": "0.2.11",
-  "description": "Hook-first living LLM Wiki runtime for Codex and Claude Code.",
+  "version": "0.2.13",
+  "description": "Hook-first living Markdown wiki runtime for Codex and Claude Code with Korean/English prompt-aware guidance.",
   "type": "module",
   "files": [
     "bin/",
@@ -15,6 +15,16 @@
   "bin": {
     "llm-wiki": "bin/llm-wiki.js"
   },
+  "keywords": [
+    "codex",
+    "claude-code",
+    "llm-wiki",
+    "agent-memory",
+    "markdown",
+    "hooks",
+    "korean",
+    "english"
+  ],
   "scripts": {
     "test": "node --test",
     "doctor": "node bin/llm-wiki.js doctor",

package/src/capture-policy.js

@@ -143,14 +143,21 @@ export function classifyTurn(entry, eventName = '') {
   };
 }
 
-export function formatDurableCaptureGuidance(query) {
+export function formatDurableCaptureGuidance(query, options = {}) {
   const text = capturedText(query);
   if (!text) return '';
   if (explicitDurableRequested(text)) {
+    if (options.language === 'ko') {
+      return [
+        'LLM Wiki 문서화 요청 감지:',
+        '- 현재 사용자 요청을 먼저 처리하되, 사용자가 기록/문서화를 요청했으므로 기존 durable wiki 문서를 찾아 갱신한다.',
+        '- 새 문서는 관련 기존 문서가 없을 때만 만들고, credentials/private data는 저장하지 않는다.',
+      ].join('\n');
+    }
     return [
-      'LLM Wiki 문서화 요청 감지:',
-      '- 현재 사용자 요청을 먼저 처리하되, 사용자가 기록/문서화를 요청했으므로 기존 durable wiki 문서를 찾아 갱신한다.',
-      '- 새 문서는 관련 기존 문서가 없을 때만 만들고, credentials/private data는 저장하지 않는다.',
+      'LLM Wiki documentation request detected:',
+      '- Answer the current user request first, then update the existing durable wiki page because the user asked to record or document this.',
+      '- Create a new page only when no related durable page exists, and never store credentials or private data.',
     ].join('\n');
   }
   return '';

package/src/cli.js

@@ -324,7 +324,7 @@ function formatUpdate(value) {
       `- installed: ${value.installedVersion}`,
       `- latest: ${value.latestVersion}`,
       `- update available: ${value.updateAvailable ? 'yes' : 'no'}`,
-      ...(value.updateAvailable ? [`- 권장 실행: ${commandForProject('update', value.workspace)}`] : []),
+      ...(value.updateAvailable ? [`- recommended command: ${commandForProject('update', value.workspace)}`] : []),
       `- project applied runtime: ${value.project?.lastRuntimeVersionApplied || 'unknown'}`,
     ].join('\n');
   }
@@ -341,20 +341,33 @@ function formatUpdate(value) {
       `- installed: ${value.installedVersion}`,
       `- latest: ${value.latestVersion}`,
       `- update available: ${value.updateAvailable ? 'yes' : 'no'}`,
-      ...(value.updateAvailable ? [`- 권장 실행: ${commandForProject('update', value.workspace)}`] : []),
+      ...(value.updateAvailable ? [`- recommended command: ${commandForProject('update', value.workspace)}`] : []),
       `- scope: ${value.scope || 'current'}`,
       ...(projects.length > 0 ? [`- projects checked: ${projects.length}`] : []),
       `- project template changes: ${changed}`,
       `- project template skipped: ${skipped}`,
     ].join('\n');
   }
+  const title = value.updateApplied
+    ? 'llm-wiki-kit updated'
+    : 'llm-wiki-kit already current; post-update complete';
   return [
-    'llm-wiki-kit updated',
+    title,
     `- workspace: ${value.workspace}`,
-    `- before: ${value.before}`,
+    `- runtime before: ${value.runtimeBefore || value.before}`,
+    `- registry target: ${value.latest || value.target}`,
+    `- runtime after: ${value.runtimeAfter || 'unknown'}`,
+    ...(value.postUpdateRuntime ? [`- post-update runtime: ${value.postUpdateRuntime}`] : []),
+    `- runtime verified: ${value.runtimeVerified ? 'yes' : 'no'}`,
+    `- npm install: ${value.npmInstall?.skipped ? 'skipped' : 'ran'}`,
     `- target: ${value.target}`,
+    `- active runtime root: ${value.activePackageRoot || 'unknown'}`,
+    `- npm global root: ${value.npmGlobal?.root || 'unknown'}`,
+    `- command: ${value.command?.path || 'not found'}`,
+    `- command matches runtime: ${value.command?.matchesRuntime ? 'yes' : 'no'}`,
     `- scope: ${value.scope || 'current'}`,
     ...(value.projects ? [`- projects updated: ${value.projects.length}`] : []),
+    ...((value.warnings || []).map((warning) => `- warning: ${warning}`)),
   ].join('\n');
 }
 

package/src/hook.js

@@ -9,6 +9,7 @@ import { summarizeForStorage } from './redaction.js';
 import { buildEntryFromState, clearTurnState, rememberQuestion, rememberTool } from './state.js';
 import { updateNoticeContext } from './update-notice.js';
 import { removeLegacyOmxWikiSurfaces } from './legacy-omx-wiki.js';
+import { resolveLanguage } from './language.js';
 import { relative } from 'path';
 
 async function readStdinJson() {
@@ -53,9 +54,10 @@ function contextOutput(provider, eventName, context) {
   };
 }
 
-async function hookContext(projectRoot, eventName, context, payload) {
+async function hookContext(projectRoot, eventName, context, payload, language) {
   const notice = await updateNoticeContext(projectRoot, eventName, {
     session: payload.session_id || payload.sessionId,
+    language,
   });
   return [context, notice].filter(Boolean).join('\n\n');
 }
@@ -85,7 +87,7 @@ async function handleAnswerFirstStop(projectRoot, eventName, payload, entry) {
     const archiveEntry = {
       ...entry,
       followUp: classification.suggestDurable
-        ? '이 turn에 저장할 만한 내용이 있어 보입니다. 사용자가 승인하면 기존 durable wiki 문서에 합친다.'
+        ? 'This turn may be worth preserving. If the user approves, merge it into an existing durable wiki page.'
         : entry.followUp,
     };
     const liveQaPath = await appendLiveQa(projectRoot, archiveEntry);
@@ -128,6 +130,10 @@ export async function handleHook(provider, explicitEvent) {
   const cwd = payload.cwd || process.cwd();
   const projectRoot = await findProjectRoot(cwd);
   await bootstrapProject(projectRoot);
+  const requestLanguage = await resolveLanguage(projectRoot, {
+    provider,
+    prompt: eventName === 'UserPromptSubmit' ? promptText(payload) : '',
+  }).catch(() => 'en');
   await recordProject(projectRoot, 'hook').catch(() => {});
   await autoUpdateManagedProject(projectRoot, eventName).catch(() => {});
   await removeLegacyWikiSurfaces(projectRoot, eventName).catch(() => {});
@@ -143,8 +149,9 @@ export async function handleHook(provider, explicitEvent) {
     const context = await hookContext(
       projectRoot,
       eventName,
-      [recovery, await buildContextBrief(projectRoot, 'SessionStart')].filter(Boolean).join('\n\n'),
-      payload
+      [recovery, await buildContextBrief(projectRoot, 'SessionStart', '', { language: requestLanguage })].filter(Boolean).join('\n\n'),
+      payload,
+      requestLanguage
     );
     return contextOutput(provider, eventName, context);
   }
@@ -152,13 +159,14 @@ export async function handleHook(provider, explicitEvent) {
   if (eventName === 'UserPromptSubmit') {
     const prompt = promptText(payload);
     await rememberQuestion(projectRoot, payload, prompt);
-    const guidance = formatDurableCaptureGuidance(prompt);
+    const guidance = formatDurableCaptureGuidance(prompt, { language: requestLanguage });
     const recovery = await consumeCompactRecoveryContext(projectRoot, payload).catch(() => '');
     const context = await hookContext(
       projectRoot,
       eventName,
-      [recovery, await buildContextBrief(projectRoot, eventName, prompt), guidance].filter(Boolean).join('\n\n'),
-      payload
+      [recovery, await buildContextBrief(projectRoot, eventName, prompt, { language: requestLanguage }), guidance].filter(Boolean).join('\n\n'),
+      payload,
+      requestLanguage
     );
     return contextOutput(provider, eventName, context);
   }

package/src/language.js

@@ -0,0 +1,73 @@
+import { join } from 'path';
+import { homeDir, readJson, readText } from './fs-utils.js';
+
+const HANGUL_RE = /[\u3131-\u318e\uac00-\ud7a3]/g;
+const LATIN_RE = /[A-Za-z]/g;
+
+export function normalizeLanguage(value) {
+  const text = String(value || '').trim().toLowerCase();
+  if (!text) return null;
+  if (/^(ko|kor|korean|한국어|한국|한글)$/.test(text)) return 'ko';
+  if (/^(en|eng|english|영어)$/.test(text)) return 'en';
+  if (text.includes('korean') || text.includes('한국')) return 'ko';
+  if (text.includes('english') || text.includes('영어')) return 'en';
+  return null;
+}
+
+export function detectTextLanguage(value) {
+  const text = String(value || '').normalize('NFC');
+  if (!text.trim()) return null;
+  const hangul = (text.match(HANGUL_RE) || []).length;
+  const latin = (text.match(LATIN_RE) || []).length;
+  if (hangul >= 2) return 'ko';
+  if (hangul === 1 && latin < 12) return 'ko';
+  if (latin >= 3 && hangul === 0) return 'en';
+  return null;
+}
+
+async function claudeSettingsLanguage(projectRoot) {
+  const paths = [
+    join(homeDir(), '.claude', 'settings.json'),
+    join(projectRoot, '.claude', 'settings.json'),
+    join(projectRoot, '.claude', 'settings.local.json'),
+  ];
+  let language = null;
+  for (const path of paths) {
+    const settings = await readJson(path, null);
+    const next = normalizeLanguage(settings?.language);
+    if (next) language = next;
+  }
+  return language;
+}
+
+async function instructionFileLanguage(projectRoot) {
+  const paths = [
+    join(projectRoot, 'CLAUDE.md'),
+    join(projectRoot, '.claude', 'CLAUDE.md'),
+    join(projectRoot, 'AGENTS.md'),
+    join(projectRoot, 'llm-wiki', 'AGENTS.md'),
+  ];
+  for (const path of paths) {
+    const text = await readText(path, '');
+    const explicit = text.match(/(?:preferred\s+language|response\s+language|language|언어|응답\s*언어)\s*[:：-]\s*([^\n]+)/i);
+    const normalized = normalizeLanguage(explicit?.[1]);
+    if (normalized) return normalized;
+    const detected = detectTextLanguage(text.slice(0, 4000));
+    if (detected) return detected;
+  }
+  return null;
+}
+
+export async function resolveLanguage(projectRoot, options = {}) {
+  const promptLanguage = detectTextLanguage(options.prompt || '');
+  if (promptLanguage) return promptLanguage;
+  if (String(options.provider || '').toLowerCase() === 'claude') {
+    const settingsLanguage = await claudeSettingsLanguage(projectRoot);
+    if (settingsLanguage) return settingsLanguage;
+  }
+  return (await instructionFileLanguage(projectRoot)) || 'en';
+}
+
+export function languageName(language) {
+  return language === 'ko' ? 'Korean' : 'English';
+}

package/src/live-qa.js

@@ -114,7 +114,7 @@ export function formatLiveQaBlock(entry) {
     entry.verification || '(not captured)',
     '',
     '### Follow-up',
-    entry.followUp || '작업/결정 중심으로 저장된 live Q&A 기록이다. 재사용 가능한 사실은 사용자가 원하거나 명확히 중요할 때만 기존 durable wiki 문서에 합친다.',
+    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.',
     '',
   ].join('\n');
 }

package/src/maintenance.js

@@ -22,7 +22,7 @@ function queueHeader() {
   return [
     '# LLM Wiki Maintenance Queue',
     '',
-    '정식 wiki 문서에 합칠 후보를 보관한다. Hook은 후보만 만들고, agent가 기존 durable wiki 문서를 찾아 병합한다.',
+    'Candidates to merge into durable wiki pages. Hooks only create candidates; the active agent reviews and merges them into existing durable wiki documents.',
     '',
     'Status values: pending, done, skipped.',
     '',
@@ -309,6 +309,7 @@ export async function recoverStaleTurnStates(projectRoot, options = {}) {
 
 export function formatMaintenanceContext(summary, options = {}) {
   if (!summary.reviewDue) return '';
+  const language = options.language === 'ko' ? 'ko' : 'en';
   const eventName = options.eventName || '';
   const defaultLimit = eventName === 'SessionStart' || eventName === 'InstructionsLoaded' ? 1 : 5;
   const limit = options.limit || defaultLimit;
@@ -321,13 +322,17 @@ export function formatMaintenanceContext(summary, options = {}) {
     return '';
   }
 
-  const lines = [
-    eventName === 'UserPromptSubmit'
-      ? 'LLM Wiki maintenance status:'
-      : 'LLM Wiki maintenance status:',
-    `- review due: yes (${(summary.reviewReasons || []).slice(0, 2).join('; ') || 'periodic review threshold met'}).`,
-    `- pending review items: ${summary.pendingCount}. 현재 요청이 우선이며, 관련 있을 때만 durable wiki 정리에 사용한다.`,
-  ];
+  const lines = language === 'ko'
+    ? [
+        'LLM Wiki maintenance status:',
+        `- review due: yes (${(summary.reviewReasons || []).slice(0, 2).join('; ') || 'periodic review threshold met'}).`,
+        `- pending review items: ${summary.pendingCount}. 현재 요청이 우선이며, 관련 있을 때만 durable wiki 정리에 사용한다.`,
+      ]
+    : [
+        'LLM Wiki maintenance status:',
+        `- review due: yes (${(summary.reviewReasons || []).slice(0, 2).join('; ') || 'periodic review threshold met'}).`,
+        `- pending review items: ${summary.pendingCount}. The current request comes first; use this only when it is relevant to durable wiki cleanup.`,
+      ];
   for (const item of pending) {
     lines.push(`- ${item.topic || item.id}: ${item.suggested_target}; source=${item.source}${item.result_missing ? '; result missing' : ''}`);
   }

package/src/project-state.js

@@ -436,22 +436,33 @@ export async function inspectProjectState(projectRoot) {
   };
 }
 
-export function formatProjectMaintenanceContext(inspection) {
+export function formatProjectMaintenanceContext(inspection, options = {}) {
   const files = inspection?.managedFiles || [];
   const attention = files.filter((file) => file.needsAttention);
   const outdated = files.filter((file) => !file.current && file.patchable);
   if (attention.length === 0 && outdated.length === 0) return '';
-
-  const lines = [
-    'LLM Wiki maintenance note:',
-    '- 이전 버전의 llm-wiki-kit 규칙/문서가 남아 있을 수 있다.',
-    '- 확실히 kit가 관리하는 영역은 자동 갱신된다. 사용자 편집 가능성이 있는 문서는 덮어쓰지 말고 기존 내용을 보존한 채 현재 규칙에 맞게 자연스럽게 정리한다.',
-  ];
+  const language = options.language === 'ko' ? 'ko' : 'en';
+
+  const lines = language === 'ko'
+    ? [
+        'LLM Wiki maintenance note:',
+        '- 이전 버전의 llm-wiki-kit 규칙/문서가 남아 있을 수 있다.',
+        '- 확실히 kit가 관리하는 영역은 자동 갱신된다. 사용자 편집 가능성이 있는 문서는 덮어쓰지 말고 기존 내용을 보존한 채 현재 규칙에 맞게 자연스럽게 정리한다.',
+      ]
+    : [
+        'LLM Wiki maintenance note:',
+        '- Older llm-wiki-kit rules or docs may still be present.',
+        '- Clearly managed kit areas are refreshed automatically. Preserve user-edited files and align them with current rules without overwriting local content.',
+      ];
   if (outdated.length > 0) {
-    lines.push(`- 자동 갱신 대상: ${outdated.map((file) => file.path).join(', ')}`);
+    lines.push(language === 'ko'
+      ? `- 자동 갱신 대상: ${outdated.map((file) => file.path).join(', ')}`
+      : `- auto-refresh candidates: ${outdated.map((file) => file.path).join(', ')}`);
   }
   if (attention.length > 0) {
-    lines.push(`- agent 확인 필요: ${attention.map((file) => file.path).join(', ')}`);
+    lines.push(language === 'ko'
+      ? `- agent 확인 필요: ${attention.map((file) => file.path).join(', ')}`
+      : `- needs agent review: ${attention.map((file) => file.path).join(', ')}`);
   }
   return lines.join('\n');
 }

package/src/project.js

@@ -136,19 +136,21 @@ export async function searchWiki(projectRoot, query, limit = 5) {
   return searchWikiWithIndex(projectRoot, query, typeof limit === 'number' ? { limit } : limit);
 }
 
-export async function buildContextBrief(projectRoot, eventName, query = '') {
+export async function buildContextBrief(projectRoot, eventName, query = '', options = {}) {
+  const language = options.language === 'ko' ? 'ko' : 'en';
   const pack = await buildContextPack(projectRoot, query, {
     includeLog: eventName === 'SessionStart',
     limit: 5,
   });
   const maintenance = await inspectProjectState(projectRoot)
-    .then(formatProjectMaintenanceContext)
+    .then((inspection) => formatProjectMaintenanceContext(inspection, { language }))
     .catch(() => '');
   const wikiMaintenance = await maintenanceSummary(projectRoot)
-    .then((summary) => formatMaintenanceContext(summary, { eventName, query }))
+    .then((summary) => formatMaintenanceContext(summary, { eventName, query, language }))
     .catch(() => '');
   return [formatHookContextPack(pack, {
     eventName,
+    language,
     hitLimit: eventName === 'SessionStart' ? 2 : 3,
     logLineLimit: eventName === 'SessionStart' ? 2 : 0,
   }), maintenance, wikiMaintenance].filter(Boolean).join('\n\n');