llm-wiki-kit 0.2.10 → 0.2.12

package/docs/operations.md

@@ -104,6 +104,7 @@ llm-wiki context "search phrase" --workspace /path/to/project
 llm-wiki lint --workspace /path/to/project
 llm-wiki consolidate --workspace /path/to/project
 llm-wiki maintenance --workspace /path/to/project
+llm-wiki archive-questions --workspace /path/to/project --dry-run
 ```
 
 `status` is offline and answers whether the local installation is internally consistent:
@@ -143,7 +144,9 @@ After a plain `npm install -g llm-wiki-kit@latest`, existing hooks keep working
 
 Daily use should be Claude Code/Codex first. The user should not need to run a chain of `llm-wiki` commands while working. Hooks inject context automatically, but the current user answer takes priority over wiki cleanup. The active agent updates durable wiki pages when reusable project knowledge appears and the turn's importance or user consent justifies persistence. Hook context policy is function-first: memory, search, maintenance, and update signals remain available, while user-visible context is formatted as functional compact context instead of a raw dump.
 
-In the default `LLM_WIKI_KIT_CAPTURE_MODE=answer-first` mode, `Stop` and `SessionEnd` append live Q&A only for meaningful work turns. They do not auto-create `wiki/queries/` or `wiki/decisions/`. If the user explicitly asked for recording/documentation and no durable wiki update is detected, a pending cleanup candidate is written to `llm-wiki/outputs/maintenance/queue.md`. `PreCompact` performs the same answer-first classification before context compaction: simple turns get only a context note, archive-worthy turns get a live Q&A checkpoint, and durable candidates get a checkpoint plus queue item. If checkpoint storage fails, compaction still proceeds and the hook prepares an important-only compact recovery packet for the next legal context-injection event. `SessionStart` and `UserPromptSubmit` also recover stale per-turn state into the same queue when the previous stop hook did not complete. `SessionStart` injects a one-item queue summary; `UserPromptSubmit` injects a soft reminder only when the prompt is wiki/maintenance related or matches a queue topic. This is a recovery and reminder layer, not a full transcript capture path.
+In the default `LLM_WIKI_KIT_CAPTURE_MODE=answer-first` mode, `Stop` and `SessionEnd` append live Q&A only for meaningful work evidence or structured decision turns. Simple answers, status checks, and keyword-only responses are not archived. Live Q&A uses chunked files under `llm-wiki/outputs/questions/YYYY-MM-DD/` and rolls over by line/byte budget. Hooks do not auto-create `wiki/queries/` or `wiki/decisions/`. If the user explicitly asked for recording/documentation and no durable wiki update is detected, a pending cleanup candidate is written to `llm-wiki/outputs/maintenance/queue.md`. `PreCompact` performs the same answer-first classification before context compaction: simple turns get only a context note, archive-worthy turns get a live Q&A checkpoint, and explicit durable candidates get a checkpoint plus queue item only when needed. If checkpoint storage fails, compaction still proceeds and the hook prepares an important-only compact recovery packet for the next legal context-injection event. `SessionStart` and `UserPromptSubmit` also recover stale per-turn state into the same queue when the previous stop hook did not complete. `SessionStart` injects a one-item queue summary; `UserPromptSubmit` injects a soft reminder only when the prompt is wiki/maintenance related or matches a queue topic. This is a recovery and reminder layer, not a full transcript capture path.
+
+Use `llm-wiki archive-questions --workspace <project> --dry-run` to review splitting legacy `outputs/questions/YYYY-MM-DD-live-qa.md` files into the chunked layout. Running it without `--dry-run` preserves the original under `outputs/questions/archive/originals/` with a checksum sidecar and replaces the legacy file with a pointer stub.
 
 Pre-compact preservation defaults to `LLM_WIKI_KIT_PRECOMPACT_ENFORCEMENT=limited`, but compaction is never blocked by llm-wiki-kit. `limited` and `soft` emit non-blocking failure warnings, and `off` suppresses failure output. `LLM_WIKI_KIT_PRECOMPACT_TRANSCRIPT_TAIL_BYTES` controls the small bounded transcript tail used for checkpoint context. Authentication values and the raw transcript path are redacted before storage.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "llm-wiki-kit",
-  "version": "0.2.10",
-  "description": "Hook-first living LLM Wiki runtime for Codex and Claude Code.",
+  "version": "0.2.12",
+  "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

@@ -2,7 +2,9 @@ const NOT_CAPTURED = '(not captured)';
 
 const EXPLICIT_DURABLE_RE = /(?:기록해|기록해줘|문서화|문서화해|wiki에\s*남겨|위키에\s*남겨|wiki[^.\n]{0,40}(?:남겨|저장|기록)|위키[^.\n]{0,40}(?:남겨|저장|기록)|remember\s+this|save\s+this|document\s+this|record\s+this|persist\s+this)/i;
 
-const DURABLE_KEYWORD_RE = /(?:debug|bug|fix|failure|failed|error|root cause|architecture|runtime|hook|install|update|deploy|release|publish|migration|security|policy|procedure|decision|decided|verification|test|lint|build|doctor|디버깅|버그|오류|에러|실패|수정|원인|아키텍처|구조|런타임|훅|설치|업데이트|배포|릴리스|마이그레이션|보안|정책|절차|결정|선택|채택|확정|검증|테스트|문서|위키|wiki)/i;
+const DURABLE_KEYWORD_RE = /(?:root cause|architecture|policy|procedure|decision|decided|migration|security|디버깅|원인|아키텍처|구조|정책|절차|결정|선택|채택|확정)/i;
+
+const DURABLE_CONCLUSION_RE = /(?:^|\n)\s*(?:Decision|Decided|Policy|Procedure|Root cause|Resolution|Fix|Verification|결정|정책|절차|원인|해결|수정|검증)\s*[:：-]/i;
 
 const MAINTENANCE_QUERY_RE = /(?:llm-wiki|wiki|위키|maintenance|maintain|문서|문서화|기록|정리|consolidate|lint|queue|AGENTS\.md)/i;
 
@@ -44,6 +46,11 @@ export function hasDurableKeyword(value) {
   return DURABLE_KEYWORD_RE.test(text);
 }
 
+export function hasDurableConclusion(value) {
+  const text = typeof value === 'string' ? value : entrySearchText(value);
+  return DURABLE_CONCLUSION_RE.test(text);
+}
+
 export function isMaintenanceRelatedQuery(query, pendingItems = []) {
   const text = capturedText(query);
   if (!text) return false;
@@ -107,50 +114,50 @@ export function classifyTurn(entry, eventName = '') {
   const hasWork = Boolean(work);
   const hasFiles = Boolean(changedFiles);
   const hasVerification = Boolean(verification);
-  const longWork = work.length > 800;
-  const durableKeyword = hasDurableKeyword(text);
-  const simple =
-    !hasWork &&
-    !hasFiles &&
-    !hasVerification &&
-    question.length <= 120 &&
-    result.length <= 800 &&
-    !durableKeyword;
-
-  if (simple) {
+  const hasWorkEvidence = hasWork || hasFiles || hasVerification;
+  const durableConclusion = hasDurableConclusion(text);
+
+  if (hasWorkEvidence) {
     return {
-      kind: 'simple',
-      archive: false,
+      kind: hasDetectedDurableWikiChange(entry) ? 'durable-updated' : 'work',
+      archive: true,
       suggestDurable: false,
       queueIfMissingDurable: false,
     };
   }
 
-  if (durableKeyword) {
+  if (durableConclusion) {
     return {
-      kind: 'suggest-durable',
+      kind: 'decision',
       archive: true,
-      suggestDurable: true,
+      suggestDurable: false,
       queueIfMissingDurable: false,
     };
   }
 
   return {
-    kind: hasWork || hasFiles || hasVerification || longWork || result.length > 800 ? 'archive-only' : 'simple',
-    archive: hasWork || hasFiles || hasVerification || longWork || result.length > 800,
+    kind: 'simple',
+    archive: false,
     suggestDurable: false,
     queueIfMissingDurable: false,
   };
 }
 
-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

@@ -12,6 +12,7 @@ import { migrate } from './migrate.js';
 import { postUpdate, update } from './update.js';
 import { buildContextPack, formatContextPack } from './wiki-search.js';
 import { formatLintResult, runLint } from './wiki-lint.js';
+import { archiveQuestions, formatArchiveQuestionsResult } from './live-qa.js';
 
 function parseOptions(args) {
   const options = {};
@@ -32,6 +33,13 @@ function parseOptions(args) {
     } else if (arg === '--to') {
       options.to = optionValue(arg, i);
       i += 1;
+    } else if (arg === '--date') {
+      const value = optionValue(arg, i);
+      if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+        throw new Error('--date must use YYYY-MM-DD');
+      }
+      options.date = value;
+      i += 1;
     } else if (arg === '--timeout-ms') {
       const value = optionValue(arg, i);
       const timeout = Number(value);
@@ -122,6 +130,7 @@ Usage:
   llm-wiki lint --workspace <project>
   llm-wiki consolidate --workspace <project> [--dry-run]
   llm-wiki maintenance --workspace <project> [--json]
+  llm-wiki archive-questions --workspace <project> [--date YYYY-MM-DD] [--dry-run] [--json]
 `);
     return;
   }
@@ -240,6 +249,12 @@ Usage:
     return;
   }
 
+  if (command === 'archive-questions') {
+    const projectRoot = resolve(options.workspace || process.cwd());
+    printJsonOrText(await archiveQuestions(projectRoot, options), options, formatArchiveQuestionsResult);
+    return;
+  }
+
   if (command === 'hook') {
     const provider = rest[0] || 'codex';
     const eventName = rest[1];
@@ -309,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');
   }
@@ -326,7 +341,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)}`] : []),
       `- scope: ${value.scope || 'current'}`,
       ...(projects.length > 0 ? [`- projects checked: ${projects.length}`] : []),
       `- project template changes: ${changed}`,

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

@@ -0,0 +1,321 @@
+import { copyFile, readdir } from 'fs/promises';
+import { basename, dirname, join, relative } from 'path';
+import {
+  appendText,
+  ensureDir,
+  exists,
+  readText,
+  sha256,
+  timeKst,
+  todayKst,
+  writeText,
+} from './fs-utils.js';
+import { redactText } from './redaction.js';
+
+export const DEFAULT_LIVE_QA_MAX_LINES = 500;
+export const DEFAULT_LIVE_QA_MAX_BYTES = 80 * 1024;
+
+const ARCHIVE_STUB_MARKER = '<!-- llm-wiki-kit:archived-live-qa -->';
+
+function positiveInteger(value, fallback) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1) return fallback;
+  return parsed;
+}
+
+export function liveQaMaxLines(env = process.env) {
+  return positiveInteger(env.LLM_WIKI_KIT_LIVE_QA_MAX_LINES, DEFAULT_LIVE_QA_MAX_LINES);
+}
+
+export function liveQaMaxBytes(env = process.env) {
+  return positiveInteger(env.LLM_WIKI_KIT_LIVE_QA_MAX_BYTES, DEFAULT_LIVE_QA_MAX_BYTES);
+}
+
+export function liveQaDayDir(projectRoot, day = todayKst()) {
+  return join(projectRoot, 'llm-wiki', 'outputs', 'questions', day);
+}
+
+function liveQaLegacyPath(projectRoot, day) {
+  return join(projectRoot, 'llm-wiki', 'outputs', 'questions', `${day}-live-qa.md`);
+}
+
+function chunkName(number) {
+  return `live-qa-${String(number).padStart(3, '0')}.md`;
+}
+
+function chunkNumber(file) {
+  const match = file.match(/^live-qa-(\d+)\.md$/);
+  return match ? Number(match[1]) : null;
+}
+
+function countLines(text) {
+  if (!text) return 0;
+  return String(text).split(/\r?\n/).length;
+}
+
+function countBlocks(text) {
+  return (String(text || '').match(/^## \d{2}:\d{2} KST - /gm) || []).length;
+}
+
+async function listChunkFiles(dayDir) {
+  let entries = [];
+  try {
+    entries = await readdir(dayDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries
+    .filter((entry) => entry.isFile() && chunkNumber(entry.name) !== null)
+    .map((entry) => entry.name)
+    .sort((a, b) => chunkNumber(a) - chunkNumber(b));
+}
+
+function exceedsLimit(existing, addition, options = {}) {
+  if (!existing) return false;
+  const maxLines = options.maxLines ?? liveQaMaxLines();
+  const maxBytes = options.maxBytes ?? liveQaMaxBytes();
+  return (
+    countLines(existing) + countLines(addition) > maxLines ||
+    Buffer.byteLength(existing, 'utf8') + Buffer.byteLength(addition, 'utf8') > maxBytes
+  );
+}
+
+async function targetChunkPath(projectRoot, day, block, options = {}) {
+  const dayDir = liveQaDayDir(projectRoot, day);
+  await ensureDir(dayDir);
+  const files = await listChunkFiles(dayDir);
+  let number = files.length > 0 ? chunkNumber(files.at(-1)) : 1;
+  let path = join(dayDir, chunkName(number));
+  const existing = await readText(path, '');
+  if (exceedsLimit(existing, block, options)) {
+    number += 1;
+    path = join(dayDir, chunkName(number));
+  }
+  return path;
+}
+
+export function formatLiveQaBlock(entry) {
+  return [
+    `\n## ${timeKst()} KST - ${entry.topic || 'session turn'}`,
+    '',
+    '### Question',
+    entry.question || '(not captured)',
+    '',
+    '### Work',
+    entry.work || '(not captured)',
+    '',
+    '### Result',
+    entry.result || '(not captured)',
+    '',
+    '### Changed files',
+    entry.changedFiles || '(not captured)',
+    '',
+    '### 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.',
+    '',
+  ].join('\n');
+}
+
+export async function refreshLiveQaIndex(projectRoot, day = todayKst()) {
+  const dayDir = liveQaDayDir(projectRoot, day);
+  const files = await listChunkFiles(dayDir);
+  const rows = [];
+  let totalBlocks = 0;
+  for (const file of files) {
+    const rel = file;
+    const text = await readText(join(dayDir, file), '');
+    const blocks = countBlocks(text);
+    totalBlocks += blocks;
+    rows.push(`- [${rel}](${rel}) - ${blocks} turn(s), ${countLines(text)} line(s)`);
+  }
+  const content = [
+    `# Live Q&A ${day}`,
+    '',
+    'Chunked live Q&A archive for meaningful work and decision turns.',
+    '',
+    `- chunks: ${files.length}`,
+    `- turns: ${totalBlocks}`,
+    `- updated_at: ${new Date().toISOString()}`,
+    '',
+    '## Chunks',
+    '',
+    rows.length > 0 ? rows.join('\n') : '(none)',
+    '',
+  ].join('\n');
+  await writeText(join(dayDir, 'index.md'), content);
+}
+
+export async function appendLiveQa(projectRoot, entry, options = {}) {
+  const day = todayKst();
+  const block = redactText(formatLiveQaBlock(entry), 12000);
+  const path = await targetChunkPath(projectRoot, day, block, options);
+  await appendText(path, block);
+  await refreshLiveQaIndex(projectRoot, day);
+  return path;
+}
+
+function splitLiveQaBlocks(text) {
+  const blocks = [];
+  let current = [];
+  for (const line of String(text || '').replace(/\r\n/g, '\n').split('\n')) {
+    if (/^## \d{2}:\d{2} KST - /.test(line) && current.some((item) => item.trim())) {
+      blocks.push(`\n${current.join('\n').trim()}\n`);
+      current = [line];
+    } else {
+      current.push(line);
+    }
+  }
+  if (current.some((item) => item.trim())) {
+    blocks.push(`\n${current.join('\n').trim()}\n`);
+  }
+  return blocks;
+}
+
+function packBlocks(blocks, options = {}) {
+  const chunks = [];
+  let current = '';
+  for (const block of blocks) {
+    if (current && exceedsLimit(current, block, options)) {
+      chunks.push(current);
+      current = block;
+    } else {
+      current += block;
+    }
+  }
+  if (current) chunks.push(current);
+  return chunks;
+}
+
+async function writeGeneratedFile(path, content) {
+  const current = await readText(path, null);
+  if (current !== null && current !== content) {
+    throw new Error(`refusing to overwrite existing generated target with different content: ${path}`);
+  }
+  if (current === content) return false;
+  await writeText(path, content);
+  return true;
+}
+
+async function backupTarget(projectRoot, sourcePath, checksum) {
+  const base = join(projectRoot, 'llm-wiki', 'outputs', 'questions', 'archive', 'originals', basename(sourcePath));
+  if (!(await exists(base))) return base;
+  const currentChecksum = await readText(`${base}.sha256`, '');
+  if (currentChecksum.includes(checksum)) return base;
+  const parsed = basename(sourcePath, '.md');
+  return join(projectRoot, 'llm-wiki', 'outputs', 'questions', 'archive', 'originals', `${parsed}-${checksum.slice(0, 12)}.md`);
+}
+
+async function archiveOne(projectRoot, day, options = {}) {
+  const sourcePath = liveQaLegacyPath(projectRoot, day);
+  const sourceRel = relative(projectRoot, sourcePath).split('\\').join('/');
+  if (!(await exists(sourcePath))) {
+    return { date: day, status: 'missing', source: sourceRel, chunks: [] };
+  }
+
+  const text = await readText(sourcePath, '');
+  if (text.includes(ARCHIVE_STUB_MARKER)) {
+    return { date: day, status: 'already-archived', source: sourceRel, chunks: [] };
+  }
+
+  const blocks = splitLiveQaBlocks(text);
+  if (blocks.length === 0) {
+    return { date: day, status: 'empty', source: sourceRel, chunks: [] };
+  }
+
+  const checksum = sha256(text);
+  const backupPath = await backupTarget(projectRoot, sourcePath, checksum);
+  const backupRel = relative(projectRoot, backupPath).split('\\').join('/');
+  const chunks = packBlocks(blocks, options);
+  const dayDir = liveQaDayDir(projectRoot, day);
+  const existingChunks = await listChunkFiles(dayDir);
+  const firstChunkNumber = existingChunks.length > 0 ? chunkNumber(existingChunks.at(-1)) + 1 : 1;
+  const chunkTargets = chunks.map((content, index) => ({
+    path: join(dayDir, chunkName(firstChunkNumber + index)),
+    rel: relative(projectRoot, join(dayDir, chunkName(firstChunkNumber + index))).split('\\').join('/'),
+    content,
+    blocks: countBlocks(content),
+    lines: countLines(content),
+  }));
+
+  const result = {
+    date: day,
+    status: options.dryRun ? 'planned' : 'archived',
+    source: sourceRel,
+    original: backupRel,
+    checksum,
+    blocks: blocks.length,
+    chunks: chunkTargets.map(({ rel, blocks: blockCount, lines }) => ({ path: rel, blocks: blockCount, lines })),
+  };
+  if (options.dryRun) return result;
+
+  await ensureDir(dirname(backupPath));
+  if (!(await exists(backupPath))) await copyFile(sourcePath, backupPath);
+  await writeText(`${backupPath}.sha256`, `${checksum}  ${basename(sourcePath)}\n`);
+  await ensureDir(dayDir);
+  for (const target of chunkTargets) {
+    await writeGeneratedFile(target.path, target.content);
+  }
+  await refreshLiveQaIndex(projectRoot, day);
+  const stub = [
+    '# Live Q&A Archived',
+    ARCHIVE_STUB_MARKER,
+    '',
+    'This legacy daily live Q&A file was archived into chunked files.',
+    '',
+    `- original: ${backupRel}`,
+    `- sha256: ${checksum}`,
+    `- index: llm-wiki/outputs/questions/${day}/index.md`,
+    '',
+  ].join('\n');
+  await writeText(sourcePath, stub);
+  return result;
+}
+
+async function datesToArchive(projectRoot, options = {}) {
+  if (options.date) return [options.date];
+  const questionsDir = join(projectRoot, 'llm-wiki', 'outputs', 'questions');
+  let entries = [];
+  try {
+    entries = await readdir(questionsDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries
+    .filter((entry) => entry.isFile())
+    .map((entry) => entry.name.match(/^(\d{4}-\d{2}-\d{2})-live-qa\.md$/)?.[1])
+    .filter(Boolean)
+    .sort();
+}
+
+export async function archiveQuestions(projectRoot, options = {}) {
+  const dates = await datesToArchive(projectRoot, options);
+  const files = [];
+  for (const day of dates) {
+    files.push(await archiveOne(projectRoot, day, options));
+  }
+  return {
+    workspace: projectRoot,
+    dryRun: Boolean(options.dryRun),
+    date: options.date || null,
+    files,
+  };
+}
+
+export function formatArchiveQuestionsResult(result) {
+  const lines = [
+    'llm-wiki archive-questions',
+    `- workspace: ${result.workspace}`,
+    `- dry-run: ${result.dryRun ? 'yes' : 'no'}`,
+    `- files: ${result.files.length}`,
+  ];
+  for (const file of result.files) {
+    lines.push(`- ${file.date}: ${file.status}; blocks=${file.blocks || 0}; chunks=${file.chunks.length}`);
+    for (const chunk of file.chunks) {
+      lines.push(`  - ${chunk.path} (${chunk.blocks} turn(s), ${chunk.lines} line(s))`);
+    }
+  }
+  return lines.join('\n');
+}