llm-wiki-kit 0.1.6 → 0.1.8

package/src/projects.js

@@ -50,6 +50,11 @@ export async function recordProject(projectRoot, source = 'unknown') {
   return registry.projects[workspace];
 }
 
+async function looksLikeProjectRoot(root) {
+  return (await exists(join(root, 'llm-wiki', '.kit-state.json'))) ||
+    (await exists(join(root, 'llm-wiki', 'wiki', 'index.md')));
+}
+
 export async function discoverProjectRoots(searchRoot, options = {}) {
   const root = resolve(searchRoot || process.cwd());
   const maxDirs = options.maxDirs || 5000;
@@ -60,7 +65,7 @@ export async function discoverProjectRoots(searchRoot, options = {}) {
     if (seen >= maxDirs) return;
     seen += 1;
 
-    if (await exists(join(dir, 'llm-wiki', '.kit-state.json'))) {
+    if (await looksLikeProjectRoot(dir)) {
       roots.add(dir);
     }
 
@@ -73,8 +78,15 @@ export async function discoverProjectRoots(searchRoot, options = {}) {
 
     for (const entry of entries) {
       if (seen >= maxDirs) return;
-      if (!entry.isDirectory() || SKIP_DIRS.has(entry.name)) continue;
-      await walk(join(dir, entry.name));
+      if (!entry.isDirectory()) continue;
+      const child = join(dir, entry.name);
+      if (SKIP_DIRS.has(entry.name)) {
+        if (entry.name === 'llm-wiki' && await looksLikeProjectRoot(child)) {
+          await walk(child);
+        }
+        continue;
+      }
+      await walk(child);
     }
   }
 
@@ -92,7 +104,7 @@ export async function knownProjectRoots(options = {}) {
 
   const existing = [];
   for (const root of [...roots].sort()) {
-    if (await isDirectory(root) && await exists(join(root, 'llm-wiki', '.kit-state.json'))) {
+    if (await isDirectory(root) && await looksLikeProjectRoot(root)) {
       existing.push(root);
     }
   }

package/src/state.js

@@ -1,4 +1,5 @@
 import { join } from 'path';
+import { unlink } from 'fs/promises';
 import { kitDataDir, readJson, sha256, writeJson } from './fs-utils.js';
 import { summarizeForStorage } from './redaction.js';
 
@@ -33,6 +34,10 @@ export async function writeTurnState(projectRoot, payload, state) {
   await writeJson(statePath(projectRoot, payload), state);
 }
 
+export async function clearTurnState(projectRoot, payload) {
+  await unlink(statePath(projectRoot, payload)).catch(() => {});
+}
+
 export async function rememberQuestion(projectRoot, payload, prompt) {
   const state = await readTurnState(projectRoot, payload);
   const clean = summarizeForStorage(prompt, 3000);

package/src/templates.js

@@ -1,7 +1,27 @@
 import { runtimeVersion } from './version.js';
 
 export function rootAgentsPolicy() {
-  return `\n<!-- llm-wiki-kit:start -->\n## LLM Wiki Policy\n\nThis repository uses llm-wiki-kit as a hook-first living Markdown wiki for Codex and Claude Code.\n\n- This block supersedes older OMX/OMC/\`omx_wiki/\` LLM Wiki instructions for this repository.\n- Treat chat memory as temporary; durable project knowledge belongs in \`llm-wiki/\`.\n- \`llm-wiki/raw/\` stores immutable or redacted source material. Do not edit raw source files.\n- \`llm-wiki/wiki/\` stores LLM-maintained knowledge pages such as decisions, architecture, debugging, context, concepts, and queries.\n- \`llm-wiki/wiki/memory.md\` is the short hot index for the most reusable current facts; keep it concise and link to deeper pages.\n- Before non-trivial work, use the injected LLM Wiki context and consult \`llm-wiki/wiki/memory.md\` and \`llm-wiki/wiki/index.md\` when present.\n- Capture reusable decisions, debugging findings, verification commands, and open questions into the wiki.\n- Preserve useful work context, but do not store raw authentication values such as tokens, passwords, or private keys.\n- Mark inference explicitly and preserve contradictions instead of silently overwriting them.\n\n<!-- llm-wiki-kit:end -->\n`;
+  return `
+<!-- llm-wiki-kit:start -->
+## LLM Wiki Policy
+
+This repository uses llm-wiki-kit as a hook-first living Markdown wiki for Codex and Claude Code.
+
+- This block supersedes older OMX/OMC/\`omx_wiki/\` LLM Wiki instructions for this repository.
+- 평소처럼 Codex 또는 Claude Code를 사용한다. 사용자가 별도 \`llm-wiki\` 명령을 외워서 실행해야 하는 흐름을 만들지 않는다.
+- 채팅 기억은 임시로 본다. 오래 남길 프로젝트 지식은 \`llm-wiki/\` Markdown에 남긴다.
+- \`llm-wiki/raw/\`는 원본 또는 redacted 근거 저장소다. hook envelope append 외에는 원본 capture를 수정하지 않는다.
+- \`llm-wiki/wiki/\`는 agent가 관리하는 지식층이다. 결정, 구조, 디버깅, 개념, 절차, 맥락을 여기에 정리한다.
+- \`llm-wiki/wiki/memory.md\`는 짧은 핵심 기억이다. 긴 설명 대신 현재 상태와 중요한 문서 링크만 유지한다.
+- hook이 주입한 context를 우선 사용한다. 수동 확인이나 정리에는 \`llm-wiki context\`, \`llm-wiki lint\`, \`llm-wiki consolidate\`를 agent 보조 도구로 사용한다.
+- hook은 redacted live Q&A와 query/decision 후보를 기록한다. 재사용 가능한 지식은 agent가 기존 정식 wiki 문서에 합친다.
+- 새 문서를 만들기 전에 기존 wiki 문서를 먼저 찾아 갱신한다. 반복해서 쓸 사실은 \`outputs/questions/\`에만 두지 말고 적절한 wiki 문서에 합친다.
+- 일회성 작업 기록은 \`llm-wiki/outputs/questions/\`에 보존하고, 재사용 가능한 결론은 \`wiki/architecture/\`, \`wiki/debugging/\`, \`wiki/decisions/\`, \`wiki/concepts/\`, \`procedures/\`에 반영한다.
+- 검증 명령, 근거 파일, 불확실한 점을 함께 남긴다. 추론은 추론이라고 표시하고, 모순은 지우지 말고 Open Questions 또는 Contradictions에 남긴다.
+- 인증값, token, password, private key, \`.env\` 원문은 저장하지 않는다. 필요한 경우 redacted summary만 남긴다.
+
+<!-- llm-wiki-kit:end -->
+`;
 }
 
 export function llmWikiAgents() {
@@ -10,23 +30,26 @@ export function llmWikiAgents() {
 Generated by llm-wiki-kit ${runtimeVersion()}.
 
 ## Purpose
-Maintain a living Markdown LLM Wiki from immutable source files and redacted Codex/Claude Code session events.
-These rules supersede older OMX/OMC/\`omx_wiki/\` LLM Wiki rules for this project.
+Codex와 Claude Code를 평소처럼 사용하는 동안 living Markdown LLM Wiki를 자연스럽게 유지한다.
+사용자가 많은 \`llm-wiki\` 명령을 직접 실행하는 방식이 아니라, agent가 작업 중 필요한 wiki 조회와 정리를 수행하는 것이 기본이다.
+이 규칙은 오래된 OMX/OMC/\`omx_wiki/\` 규칙을 대체한다.
 
 ## Directories
-- \`raw/\`: immutable or redacted source material. Never edit original source captures.
-- \`wiki/\`: AI-maintained knowledge pages. \`wiki/memory.md\` is the short hot index injected into hook context.
-- \`outputs/\`: live Q&A summaries, reports, and generated briefs.
-- \`procedures/\`: detailed operating rules for ingest, query, lint, and security.
+- \`raw/\`: 원본 또는 redacted 근거 저장소. hook이 redacted envelope를 append하는 경우 외에는 원본 capture를 수정하지 않는다.
+- \`wiki/\`: agent가 관리하는 정식 지식 문서. \`wiki/memory.md\`는 hook context에 들어가는 짧은 핵심 기억이다.
+- \`outputs/\`: live Q&A, 보고서, 긴 생성물 저장소. 일회성 기록은 여기에 둔다.
+- \`procedures/\`: ingest, query, lint, security 같은 운영 규칙.
 
 ## Core Rules
-- Never modify \`raw/\` source material except to append redacted session envelopes generated by hooks.
-- Do not state unsupported claims as facts.
-- Mark inference explicitly.
-- Add \`source_ids\` or file references for important claims.
-- Update \`wiki/memory.md\`, \`wiki/index.md\`, and \`wiki/log.md\` whenever new durable knowledge changes the active project map.
-- Preserve contradictions in \`Contradictions\` or \`Open Questions\` instead of overwriting them.
-- Preserve useful work context and redact authentication values before writing durable notes.
+- 사용자는 Claude Code/Codex를 평소처럼 사용한다. agent가 필요한 wiki 조회와 정리를 자연스럽게 수행한다.
+- \`raw/\` 원본은 수정하지 않는다. 안전한 hook envelope append만 예외다.
+- 근거 없는 내용을 사실처럼 쓰지 않는다. 추론은 명시한다.
+- 중요한 주장에는 \`source_ids\`, 파일 경로, 검증 명령 중 하나 이상을 남긴다.
+- 오래 남길 내용이 생기면 새 문서부터 만들지 말고 기존 \`wiki/\` 문서를 먼저 찾아 갱신한다.
+- 반복해서 쓸 지식은 \`outputs/questions/\`에만 두지 말고 \`wiki/architecture/\`, \`wiki/debugging/\`, \`wiki/decisions/\`, \`wiki/concepts/\`, \`procedures/\`에 합친다.
+- \`wiki/memory.md\`는 짧게 유지한다. 긴 설명 대신 현재 상태와 중요한 문서 링크를 둔다.
+- 모순은 덮어쓰지 말고 \`Contradictions\` 또는 \`Open Questions\`에 보존한다.
+- 인증값, token, password, private key, \`.env\` 원문은 wiki에 저장하지 않는다.
 
 ## Page Format
 Use YAML frontmatter when creating wiki pages:
@@ -36,7 +59,7 @@ Use YAML frontmatter when creating wiki pages:
 title: ""
 type: "source | concept | entity | decision | architecture | debugging | context | query | session-log | convention"
 source_ids: []
-status: "draft | reviewed | stale"
+status: "draft | reviewed | stale | archived"
 last_updated: "YYYY-MM-DD"
 confidence: "high | medium | low"
 memory_type: "semantic | episodic | procedural"
@@ -48,15 +71,47 @@ superseded_by: []
 \`\`\`
 
 ## Operations
-- ingest: read \`wiki/memory.md\` and \`wiki/index.md\`, ingest new raw files, create or update wiki pages, then update the active map and \`wiki/log.md\`.
-- query: start from \`llm-wiki context "<query>"\` or \`wiki/memory.md\`, read relevant wiki pages, answer with source references, and save reusable answers.
-- lint: run \`llm-wiki lint --workspace <project>\` to find stale pages, orphan pages, broken wiki/Markdown links, unsafe source IDs, secret-like content, missing sources, duplicate concepts, contradictions, and missing links.
-- consolidate: run \`llm-wiki consolidate --workspace <project>\` after meaningful wiki growth to refresh generated memory/index blocks without overwriting hand-written notes. Default query/context/session-log pages are excluded unless explicitly durable.
+- ingest: \`wiki/memory.md\`와 \`wiki/index.md\`를 먼저 읽고, 새 근거를 확인한 뒤 기존 wiki 문서를 우선 갱신한다.
+- query: hook이 주입한 context를 우선 사용한다. 수동 명령은 점검용이며 일반 사용 흐름의 필수 단계가 아니다.
+- lint: agent가 필요할 때 wiki 건강 상태를 점검하는 보조 도구다. 사용자가 매번 직접 실행해야 하는 명령이 아니다.
+- consolidate: agent가 \`memory.md\`/\`index.md\` generated block을 안전하게 갱신할 때 쓰는 보조 도구다. 손글씨 영역과 정식 문서 본문은 덮어쓰지 않는다.
 `;
 }
 
 export function indexPage() {
-  return `# LLM Wiki Index\n\nGenerated by llm-wiki-kit.\n\n## Overview\n\nThis is the navigation map for the project living wiki. Keep it short and useful.\n\n## Main Areas\n\n- [Memory](memory.md) - short hot index and durable entry points.\n- [Sources](sources/) - source summaries and source IDs.\n- [Concepts](concepts/) - reusable concepts and terminology.\n- [Entities](entities/) - people, systems, modules, vendors, services, and tools.\n- [Decisions](decisions/) - decisions and rationale.\n- [Architecture](architecture/) - system structure and data/control flow.\n- [Debugging](debugging/) - root causes, fixes, verification evidence.\n- [Context](context/) - session continuity and project memory.\n- [Queries](queries/) - durable answers to useful questions.\n\n## Operating Notes\n\n- Start from memory and this index before broad project questions.\n- Read 3-7 relevant pages first; inspect raw sources only when precision matters.\n- Add links using \`[[page-or-topic]]\` when pages become related.\n\n<!-- llm-wiki-kit:index-start -->\n## Generated Page Map\n\nRun \`llm-wiki consolidate --workspace <project>\` to refresh this generated block.\n<!-- llm-wiki-kit:index-end -->\n`;
+  return `# LLM Wiki Index
+
+Generated by llm-wiki-kit.
+
+## Overview
+
+이 파일은 living wiki의 짧은 지도다. 자세한 설명을 길게 쓰기보다, agent가 다음 작업에서 빠르게 찾아갈 entry point를 유지한다.
+
+## Main Areas
+
+- [Memory](memory.md) - 짧은 핵심 기억과 주요 entry point.
+- [Sources](sources/) - source summary와 source id.
+- [Concepts](concepts/) - 재사용 가능한 개념과 용어.
+- [Entities](entities/) - 시스템, 모듈, 도구, 서비스, 주요 객체.
+- [Decisions](decisions/) - 결정과 근거.
+- [Architecture](architecture/) - 구조와 데이터/제어 흐름.
+- [Debugging](debugging/) - 원인, 수정, 검증 evidence.
+- [Context](context/) - 세션 연속성과 프로젝트 맥락.
+- [Queries](queries/) - 재사용 가능한 질문 답변. 일회성 기록은 outputs/questions에 둔다.
+
+## Operating Notes
+
+- 넓은 질문은 memory와 이 index에서 시작한다.
+- 새 문서를 만들기 전에 관련 기존 문서 3-7개를 먼저 확인한다.
+- 오래 쓸 결론은 기존 정식 문서에 합치고, 일회성 기록은 outputs/questions에 둔다.
+- 관련 페이지가 생기면 \`[[page-or-topic]]\` 링크를 추가한다.
+
+<!-- llm-wiki-kit:index-start -->
+## Generated Page Map
+
+Agent가 필요할 때 \`llm-wiki consolidate --workspace <project>\`로 이 generated block을 갱신한다.
+<!-- llm-wiki-kit:index-end -->
+`;
 }
 
 export function memoryPage() {
@@ -76,11 +131,11 @@ superseded_by: []
 
 # LLM Wiki Memory
 
-Short hot index for project memory. Keep this page compact enough for hook context. Link to deeper pages instead of copying long notes.
+짧은 핵심 기억이다. hook context에 들어갈 만큼 작게 유지하고, 긴 설명을 복사하지 말고 깊은 문서로 링크한다.
 
 ## Current Focus
 
-- Add the current project focus here when it becomes durable.
+- 오래 남길 현재 프로젝트 초점을 여기에 짧게 추가한다.
 
 ## Durable Entry Points
 
@@ -90,25 +145,74 @@ Short hot index for project memory. Keep this page compact enough for hook conte
 <!-- llm-wiki-kit:memory-start -->
 ## Generated Memory Map
 
-Run \`llm-wiki consolidate --workspace <project>\` to refresh this generated block.
+Agent가 필요할 때 \`llm-wiki consolidate --workspace <project>\`로 이 generated block을 갱신한다.
 <!-- llm-wiki-kit:memory-end -->
 `;
 }
 
 export function logPage() {
-  return `# LLM Wiki Log\n\nAppend-only operating history for this project wiki.\n`;
+  return `# LLM Wiki Log
+
+Append-only operating history for this project wiki.
+`;
 }
 
 export function procedure(name) {
   const procedures = {
-    'ingest.md': `# Ingest Procedure\n\n1. Read \`wiki/memory.md\` and \`wiki/index.md\` first.\n2. Inspect new material under \`raw/inbox/\` or \`raw/sources/\`.\n3. Create or update \`wiki/sources/<slug>.md\` for each source.\n4. Update related concept, entity, decision, architecture, debugging, or context pages.\n5. Prefer updating existing pages over creating duplicates.\n6. Add source references, confidence, memory type, importance, and verification status.\n7. Update \`wiki/memory.md\` or run \`llm-wiki consolidate\` when durable entry points change.\n8. Update \`wiki/index.md\` and append to \`wiki/log.md\`.\n`,
-    'query.md': `# Query Procedure\n\n1. Start from \`llm-wiki context \"<query>\"\` or read \`wiki/memory.md\` and \`wiki/index.md\`.\n2. Use \`--limit\` or \`--no-expand\` when you need a narrower context pack.\n3. Search \`wiki/\` for relevant pages.\n4. Read the smallest useful set of pages first.\n5. Use raw sources only when exact evidence matters.\n6. Separate verified facts from inference.\n7. Save reusable answers into \`wiki/queries/\` and link them from related pages.\n`,
-    'lint.md': `# Lint Procedure\n\nRun \`llm-wiki lint --workspace <project>\` to check for stale pages, orphan pages, broken wiki/Markdown links, unsafe source IDs, secret-like content, missing sources, duplicate concepts, unsupported claims, and unresolved contradictions. Prefer producing a review report before automatic edits.\n`,
-    'security.md': `# Security Procedure\n\n- Preserve useful work context for the local project wiki.\n- Do not block reads or tool calls only because they look sensitive.\n- Redact authentication values such as tokens, passwords, bearer credentials, and private keys before writing hook payloads, summaries, or context packs.\n- Run \`llm-wiki lint --workspace <project>\` when sensitive material might have entered wiki pages; secret-like content is reported as an error.\n- Full raw transcript capture is disabled by default and must be explicitly enabled by project policy.\n`,
+    'ingest.md': `# Ingest Procedure
+
+1. \`wiki/memory.md\`와 \`wiki/index.md\`를 먼저 읽는다.
+2. 새 근거가 있으면 \`raw/inbox/\` 또는 \`raw/sources/\`를 확인한다.
+3. source별 요약이 필요하면 \`wiki/sources/<slug>.md\`를 만들거나 갱신한다.
+4. 새 문서부터 만들지 말고 관련 concept/entity/decision/architecture/debugging/context 문서를 먼저 찾아 갱신한다.
+5. 중복 문서를 만들지 않는다. 같은 사실이 이미 있으면 기존 문서에 합친다.
+6. 중요한 주장에는 source reference, confidence, memory type, importance, verification status를 남긴다.
+7. durable entry point가 바뀌면 \`wiki/memory.md\`를 짧게 갱신하거나 agent가 \`llm-wiki consolidate\`를 사용한다.
+8. 의미 있는 변화는 \`wiki/log.md\`에 짧게 남긴다.
+`,
+    'query.md': `# Query Procedure
+
+1. hook이 주입한 context를 먼저 사용한다. 수동으로 확인할 때만 \`llm-wiki context "<query>"\`를 쓴다.
+2. \`wiki/memory.md\`와 \`wiki/index.md\`에서 시작한다.
+3. 관련 \`wiki/\` 문서를 최소한으로 읽는다.
+4. 정확한 근거가 필요할 때만 raw source를 확인한다.
+5. 검증된 사실과 추론을 분리한다.
+6. 일회성 답변은 \`outputs/questions/\`에 남기고, 재사용 가능한 답변은 기존 \`wiki/queries/\` 또는 관련 정식 문서에 연결한다.
+7. 반복해서 쓸 결론은 \`wiki/architecture/\`, \`wiki/debugging/\`, \`wiki/decisions/\`, \`wiki/concepts/\`, \`procedures/\`에 합친다.
+`,
+    'lint.md': `# Lint Procedure
+
+\`llm-wiki lint --workspace <project>\`는 agent가 필요할 때 쓰는 wiki 건강 점검 도구다. 사용자가 매번 실행해야 하는 명령이 아니다.
+
+점검 대상: stale page, orphan page, broken wiki/Markdown link, unsafe source id, secret-like content, missing source, duplicate concept/title, unsupported claim, unresolved contradiction, outdated managed rule.
+
+자동 수정은 확실히 kit가 관리하는 영역에만 적용한다. 사용자 편집 가능성이 있는 문서는 덮어쓰지 말고 다음 작업 context에 정리 필요성을 올린다.
+`,
+    'security.md': `# Security Procedure
+
+- 로컬 프로젝트 wiki에 유용한 작업 맥락은 보존한다.
+- 입력이 민감해 보인다는 이유만으로 read/tool call을 막지 않는다.
+- token, password, bearer credential, private key, \`.env\` 원문 같은 인증값은 hook payload, summary, context pack, wiki page에 저장하기 전에 redaction한다.
+- 민감정보가 wiki에 들어갔을 가능성이 있으면 agent가 \`llm-wiki lint --workspace <project>\`를 사용해 점검한다.
+- full raw transcript capture는 기본 비활성이다. 프로젝트가 명시적으로 opt-in하고 redaction 경로가 있을 때만 허용한다.
+`,
   };
   return procedures[name] || '';
 }
 
 export function gitignore() {
-  return `# llm-wiki-kit safety defaults\nraw/sessions/*.jsonl\nraw/sessions/*.ndjson\nraw/private/\nraw_private/\nsecrets/\n*.key\n*.pem\n*.p12\n*.pfx\n.env\n.env.*\n.cache/\n`;
+  return `# llm-wiki-kit safety defaults
+raw/sessions/*.jsonl
+raw/sessions/*.ndjson
+raw/private/
+raw_private/
+secrets/
+*.key
+*.pem
+*.p12
+*.pfx
+.env
+.env.*
+.cache/
+`;
 }

package/src/update.js

@@ -4,7 +4,7 @@ import { exists } from './fs-utils.js';
 import { appendWikiLog } from './project.js';
 import { install } from './install.js';
 import { applyProjectTemplateUpdate, inspectProjectState } from './project-state.js';
-import { knownProjectRoots } from './projects.js';
+import { knownProjectRoots, recordProject } from './projects.js';
 import { binPath, detectInstallSource, packageName, runtimeVersion } from './version.js';
 
 function runCommand(command, args, options = {}) {
@@ -39,10 +39,61 @@ async function hasProjectWiki(projectRoot) {
   return exists(join(projectRoot, 'llm-wiki', 'wiki'));
 }
 
+function shouldUpdateAllProjects(options = {}) {
+  return options.all || !options.currentOnly;
+}
+
+async function projectRootsForUpdate(workspace, options = {}) {
+  if (!shouldUpdateAllProjects(options)) return [workspace];
+  const roots = await knownProjectRoots({ workspace });
+  return roots.length > 0 ? roots : [workspace];
+}
+
+async function applyTemplatesToProject(projectRoot, options = {}) {
+  const projectResult = options.noProject
+    ? null
+    : await applyProjectTemplateUpdate(projectRoot, { dryRun: options.dryRun });
+  if (!options.noProject && !options.dryRun && await hasProjectWiki(projectRoot)) {
+    await recordProject(projectRoot, options.source || 'post-update').catch(() => {});
+  }
+  return projectResult;
+}
+
+function parseJsonOutput(output) {
+  try {
+    return JSON.parse(output);
+  } catch {
+    return null;
+  }
+}
+
 export function parseRegistryVersion(output) {
   return String(output || '').trim().split(/\s+/).at(-1) || '';
 }
 
+export function compareVersions(a, b) {
+  const parse = (value) => {
+    const [core, prerelease = ''] = String(value || '').trim().replace(/^v/, '').split('-', 2);
+    return {
+      nums: core.split('.').slice(0, 3).map((part) => {
+        const parsed = Number.parseInt(part, 10);
+        return Number.isFinite(parsed) ? parsed : 0;
+      }),
+      prerelease,
+    };
+  };
+  const left = parse(a);
+  const right = parse(b);
+  for (let i = 0; i < 3; i += 1) {
+    const diff = (left.nums[i] || 0) - (right.nums[i] || 0);
+    if (diff !== 0) return diff > 0 ? 1 : -1;
+  }
+  if (left.prerelease && !right.prerelease) return -1;
+  if (!left.prerelease && right.prerelease) return 1;
+  if (left.prerelease === right.prerelease) return 0;
+  return left.prerelease > right.prerelease ? 1 : -1;
+}
+
 export async function checkForUpdate(options = {}) {
   const target = options.to || 'latest';
   const installedVersion = runtimeVersion();
@@ -55,7 +106,7 @@ export async function checkForUpdate(options = {}) {
     installedVersion,
     latestVersion,
     target,
-    updateAvailable: latestVersion !== installedVersion,
+    updateAvailable: compareVersions(latestVersion, installedVersion) > 0,
   };
 }
 
@@ -72,9 +123,7 @@ export async function postUpdate(options = {}) {
     const workspaces = await knownProjectRoots({ workspace });
     const projects = [];
     for (const projectRoot of workspaces) {
-      const projectResult = options.noProject
-        ? null
-        : await applyProjectTemplateUpdate(projectRoot);
+      const projectResult = await applyTemplatesToProject(projectRoot, options);
       if (!options.noProject && await hasProjectWiki(projectRoot)) {
         await appendWikiLog(projectRoot, `llm-wiki-kit post-update applied runtime ${runtimeVersion()}; changed templates: ${projectResult.changed.length}`);
       }
@@ -91,9 +140,7 @@ export async function postUpdate(options = {}) {
     };
   }
 
-  const projectResult = options.noProject
-    ? null
-    : await applyProjectTemplateUpdate(workspace);
+  const projectResult = await applyTemplatesToProject(workspace, options);
 
   if (!options.noProject && await hasProjectWiki(workspace)) {
     await appendWikiLog(workspace, `llm-wiki-kit post-update applied runtime ${runtimeVersion()}; changed templates: ${projectResult.changed.length}`);
@@ -125,12 +172,22 @@ export async function update(options = {}) {
   }
 
   if (options.dryRun) {
+    const workspaces = await projectRootsForUpdate(workspace, options);
+    const projects = [];
+    for (const projectRoot of workspaces) {
+      projects.push({
+        workspace: projectRoot,
+        project: options.noProject ? null : await applyProjectTemplateUpdate(projectRoot, { dryRun: true }),
+      });
+    }
     return {
       mode: 'dry-run',
       workspace,
       ...check,
       installSource: detectInstallSource(),
-      project: options.noProject ? null : await applyProjectTemplateUpdate(workspace, { dryRun: true }),
+      scope: shouldUpdateAllProjects(options) ? 'all' : 'current',
+      project: projects.find((item) => item.workspace === workspace)?.project || projects[0]?.project || null,
+      projects: shouldUpdateAllProjects(options) ? projects : undefined,
     };
   }
 
@@ -140,8 +197,8 @@ export async function update(options = {}) {
   });
   assertCommandOk(installResult, 'npm install -g');
 
-  const postArgs = [binCommand(), 'post-update', '--workspace', workspace];
-  if (options.all) postArgs.push('--all');
+  const postArgs = [binCommand(), 'post-update', '--workspace', workspace, '--json'];
+  if (shouldUpdateAllProjects(options)) postArgs.push('--all');
   if (options.profile) postArgs.push('--profile', options.profile);
   if (options.noProject) postArgs.push('--no-project');
   if (options.codex === false) postArgs.push('--no-codex');
@@ -150,16 +207,20 @@ export async function update(options = {}) {
     timeout: options.timeout || 120000,
   });
   assertCommandOk(postResult, 'post-update');
+  const parsedPostUpdate = parseJsonOutput(postResult.stdout);
 
   return {
     mode: 'update',
     workspace,
     before: check.installedVersion,
     target,
+    scope: shouldUpdateAllProjects(options) ? 'all' : 'current',
     npmInstall: {
       stdout: installResult.stdout.trim(),
       stderr: installResult.stderr.trim(),
     },
-    postUpdate: postResult.stdout.trim(),
+    postUpdate: parsedPostUpdate || postResult.stdout.trim(),
+    project: parsedPostUpdate?.project,
+    projects: parsedPostUpdate?.projects,
   };
 }

package/src/wiki-lint.js

@@ -1,6 +1,7 @@
 import { readdir } from 'fs/promises';
 import { dirname, isAbsolute, join, parse, relative, resolve, sep } from 'path';
 import { exists, readText } from './fs-utils.js';
+import { inspectProjectState } from './project-state.js';
 import { hasSecretLikeText } from './redaction.js';
 import {
   buildAliasMap,
@@ -23,7 +24,7 @@ const VALID_TYPES = new Set([
   'session-log',
   'convention',
 ]);
-const VALID_STATUS = new Set(['draft', 'reviewed', 'stale']);
+const VALID_STATUS = new Set(['draft', 'reviewed', 'stale', 'archived']);
 const VALID_CONFIDENCE = new Set(['high', 'medium', 'low']);
 const VALID_MEMORY_TYPES = new Set(['semantic', 'episodic', 'procedural']);
 const CORE_PAGES = new Set(['wiki/index.md', 'wiki/log.md', 'wiki/memory.md']);
@@ -234,6 +235,15 @@ export async function runLint(projectRoot, options = {}) {
     }
   }
 
+  const projectState = await inspectProjectState(projectRoot).catch(() => null);
+  for (const file of projectState?.managedFiles || []) {
+    if (file.needsAttention) {
+      issues.push(issue('warning', 'outdated-managed-rule', file.path, 'previous llm-wiki-kit rule file appears customized; preserve user text and align it with current natural-use rules'));
+    } else if (!file.current && file.patchable) {
+      issues.push(issue('warning', 'outdated-managed-template', file.path, 'managed llm-wiki-kit rule/template can be automatically updated on the next hook or post-update run'));
+    }
+  }
+
   return lintResult(projectRoot, pages, issues);
 }
 

package/src/wiki-search.js

@@ -216,6 +216,9 @@ export function formatContextPack(pack) {
     '- Treat chat memory as temporary; update project Markdown when knowledge should persist.',
     '- Preserve raw/wiki separation. Do not store secrets, tokens, .env contents, private keys, or personal/customer identifiers.',
     '- Prefer updating existing wiki pages over creating duplicate pages.',
+    '- Claude Code/Codex를 평소처럼 사용한다. 사용자가 별도 명령을 실행하지 않아도 agent가 필요한 wiki 조회와 정리를 수행한다.',
+    '- 오래 쓸 지식은 outputs/questions에만 두지 말고 기존 wiki/architecture, wiki/debugging, wiki/decisions, wiki/concepts, procedures 문서에 합친다.',
+    '- wiki/memory.md는 짧은 핵심 기억으로 유지하고, 긴 설명 대신 관련 정식 문서 링크를 둔다.',
   ];
   if (pack.query) {
     lines.push(`- query: "${pack.query}"`);