llm-wiki-kit 0.2.10 → 0.2.11

package/README.md

@@ -89,11 +89,11 @@ 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.
 - 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 decision points, debugging findings, changed files, and verification notes
-- before compaction, classify the current turn and save a redacted checkpoint for meaningful or durable work; durable candidates also get a maintenance queue item
+- capture meaningful work and structured decision points, including tool evidence, changed files, and verification notes
+- before compaction, classify the current turn and save a redacted checkpoint only for meaningful work, structured decisions, or explicit durable requests; explicit durable candidates also get a maintenance queue item when no durable wiki update is detected
 - after compaction, store the redacted compact summary only; if pre-compact preservation failed, prepare a recovery packet for the next legal model-visible context hook
 - allow tool calls to proceed without secret/PII-based hook blocking
-- update `llm-wiki/outputs/questions/YYYY-MM-DD-live-qa.md` only for meaningful work turns
+- update chunked `llm-wiki/outputs/questions/YYYY-MM-DD/live-qa-001.md` style archives only for meaningful work or structured decision turns
 - avoid automatic `wiki/queries/` and `wiki/decisions/` promotion in the default answer-first mode
 - queue durable cleanup candidates only for explicit documentation requests that were not reflected in durable wiki files, or when stale turn state is recovered
 - recover stale per-turn state into that queue on the next session start or prompt submit when the previous stop hook did not complete
@@ -112,6 +112,7 @@ Most users should not need these during daily Claude Code/Codex work. They exist
 - Diagnostics: `llm-wiki doctor`, `llm-wiki status`, `llm-wiki version`
 - Manual: `llm-wiki manual`
 - Agent maintenance helpers: `llm-wiki context`, `llm-wiki lint`, `llm-wiki consolidate`, `llm-wiki maintenance`
+- Live Q&A archive helper: `llm-wiki archive-questions --workspace <project> [--date YYYY-MM-DD] [--dry-run]`
 - Cleanup: `llm-wiki uninstall`
 
 `llm-wiki manual` prints the full package manual from `docs/manual.md`. Keep that document current when adding public commands, options, hook behavior, directory conventions, security policy, or update flows.
@@ -134,6 +135,8 @@ Installed npm runtimes also perform a cached update notice check from hooks whil
 
 `llm-wiki maintenance` prints the pending queue and review due status from `llm-wiki/outputs/maintenance/queue.md`. Hooks create only selective candidates; the active agent should merge reusable items into existing durable wiki pages and mark queue items `done` or `skipped` without delaying unrelated user answers. Periodic maintenance is a soft agent-side reminder, not a user command loop.
 
+`llm-wiki archive-questions` splits older legacy `llm-wiki/outputs/questions/YYYY-MM-DD-live-qa.md` files into the chunked `llm-wiki/outputs/questions/YYYY-MM-DD/` layout. It preserves the original under `outputs/questions/archive/originals/` with a SHA-256 sidecar and replaces the legacy file with a short pointer stub. Use `--dry-run` first when reviewing a large archive.
+
 `llm-wiki projects --workspace /apps` lists project roots that already have `llm-wiki-kit` state or an older `llm-wiki/wiki/index.md`, and shows the update commands to run. `llm-wiki update --workspace /apps` updates the global runtime once, then reapplies managed templates across every known or discovered project root under `/apps`.
 
 For `llm-wiki-kit` code releases, source tests are not enough. After code changes, publish the package, install the newly published version, and verify the installed CLI and hooks with `version`, `status`, `doctor`, `update`, `lint`, and hook smoke checks before calling the release complete.

package/docs/concepts.md

@@ -18,11 +18,12 @@ The important behavior is a loop:
 2. `memory.md`, `index.md`, and relevant wiki context are injected automatically with an answer-first instruction.
 3. The user works normally; no extra command loop is required.
 4. Hooks gather redacted prompt/tool/result summaries.
-5. At stop/session end, hooks append redacted live Q&A only for meaningful work turns.
-6. Durable wiki promotion is selective: explicit record/document requests should be handled by the active agent in existing wiki pages; the hook queues review only when such a request was not reflected in durable files.
-7. At the next start/prompt after an abrupt shutdown, hooks can recover stale turn state into `outputs/maintenance/queue.md`.
-8. When reusable knowledge appears, the active Claude Code/Codex agent folds approved facts into existing durable wiki pages instead of leaving everything as one-off Q&A.
-9. Future sessions start from the improved wiki instead of relying on long chat history.
+5. At stop/session end, hooks append redacted chunked live Q&A only for turns with work evidence or structured decision/debugging conclusions.
+6. Simple answers, status checks, and keyword-only responses stay out of live Q&A and durable wiki by default.
+7. Durable wiki promotion is selective: explicit record/document requests should be handled by the active agent in existing wiki pages; the hook queues review only when such a request was not reflected in durable files.
+8. At the next start/prompt after an abrupt shutdown, hooks can recover stale turn state into `outputs/maintenance/queue.md`.
+9. When reusable knowledge appears, the active Claude Code/Codex agent folds approved facts into existing durable wiki pages instead of leaving everything as one-off Q&A.
+10. Future sessions start from the improved wiki instead of relying on long chat history.
 
 The kit is a template/runtime repository. It must not centralize project wiki contents.
 

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`, 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. Update notice cache is scoped by npm command, and maintenance reminders are shown only when the prompt is wiki/maintenance related or matches a queue topic.
 
-`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, meaningful work writes a live Q&A checkpoint, and durable candidates write both a checkpoint and a maintenance queue item. 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 live Q&A only for meaningful work turns and do not auto-create `wiki/queries/` or `wiki/decisions/`. If the user explicitly asked to record or document durable knowledge and no durable wiki update is detected, `Stop`/`SessionEnd` queue a pending maintenance item for agent review. `Stop` and `SessionEnd` then clear the per-session turn buffer; `SubagentStop` does not.
+`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 or structured-decision turns write a chunked live Q&A checkpoint, and explicit 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. `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 or structured-decision turns and do not auto-create `wiki/queries/` or `wiki/decisions/`. If the user explicitly asked to record or document durable knowledge and no durable wiki update is detected, `Stop`/`SessionEnd` queue a pending maintenance item for agent review. `Stop` and `SessionEnd` then clear the per-session turn buffer; `SubagentStop` does not.
 
 Set `LLM_WIKI_KIT_AUTO_PROJECT_UPDATE=0` only while diagnosing automatic managed-template refresh behavior.
 Set `LLM_WIKI_KIT_UPDATE_NOTICE=0` only while suppressing the cached passive runtime update status.

package/docs/integrations/codex.md

@@ -33,9 +33,9 @@ Expected behavior:
 - `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. Update notice cache is scoped by npm command, and maintenance reminders are shown only when the prompt is wiki/maintenance related or matches a queue topic.
 - `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; meaningful work writes a live Q&A checkpoint; durable candidates write both a checkpoint and a maintenance queue item. 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.
+- `PreCompact` classifies the current turn before compaction. Simple turns record only a context note; work-evidence or structured-decision turns write a chunked live Q&A checkpoint; explicit 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.
 - `PostCompact` stores the redacted compact summary as a context note and prepares any pending compact recovery packet. It does not return `hookSpecificOutput.additionalContext`, because Codex `PostCompact` only supports common output fields.
-- In the default `answer-first` mode, `SubagentStop` does not create live Q&A, query, decision, or maintenance files. `Stop` appends live Q&A only for meaningful work turns and does not auto-create `wiki/queries/` or `wiki/decisions/`.
+- In the default `answer-first` mode, `SubagentStop` does not create live Q&A, query, decision, or maintenance files. `Stop` appends chunked live Q&A only for work-evidence or structured-decision turns and does not auto-create `wiki/queries/` or `wiki/decisions/`.
 - If the user explicitly asked to record or document durable knowledge and no durable wiki update is detected, `Stop` queues a pending maintenance item for agent review.
 - `Stop` clears the per-session turn buffer after recording. `SubagentStop` leaves the parent turn buffer available for the final stop event.
 

package/docs/manual.md

@@ -63,9 +63,9 @@ llm-wiki/
 설치된 hook은 다음 일을 자동으로 수행한다.
 
 - session start, instructions loaded, prompt submit 시점에 functional compact context를 주입한다. `wiki/memory.md`, `wiki/index.md`, 관련 wiki 검색 결과, maintenance signal, update status, compact recovery packet은 계속 사용하되 사용자 화면에 보일 수 있는 hook context는 필요한 정보 중심으로 정제한다.
-- pre compact 시점에는 현재 turn을 분류하고, simple turn은 context note만 남기며, meaningful/durable turn은 redacted live Q&A checkpoint와 필요한 maintenance queue 후보를 남긴다. 저장 실패 시에도 compact는 진행시키고, 중요한 내용만 recovery packet으로 준비한다.
+- pre compact 시점에는 현재 turn을 분류하고, simple turn은 context note만 남기며, 실제 작업 evidence가 있거나 구조화된 decision 결과가 있는 turn만 redacted live Q&A checkpoint로 남긴다. 명시적 durable 기록 요청이 durable wiki에 반영되지 않았을 때만 maintenance queue 후보를 남긴다. 저장 실패 시에도 compact는 진행시키고, 중요한 내용만 recovery packet으로 준비한다.
 - prompt/tool/result summary를 redaction한 뒤 turn buffer에 기록한다.
-- 의미 있는 작업 turn만 `outputs/questions/YYYY-MM-DD-live-qa.md`에 live Q&A로 남긴다.
+- 의미 있는 작업/결정 turn만 `outputs/questions/YYYY-MM-DD/live-qa-001.md` 같은 chunked live Q&A archive에 남긴다.
 - 기본 answer-first mode에서는 `wiki/queries/`와 `wiki/decisions/`를 매 turn 자동 생성하지 않는다.
 - 사용자가 명시적으로 문서화/기록을 요청했는데 durable wiki 반영이 없으면 `outputs/maintenance/queue.md`에 정리 후보를 남긴다.
 - 이전 session이 깨끗하게 종료되지 않았을 때 stale turn state를 maintenance queue로 복구할 수 있다.
@@ -86,9 +86,9 @@ LLM_WIKI_KIT_CAPTURE_MODE=answer-first
 
 `answer-first` mode는 현재 답변을 우선한다.
 
-- 단순 Q&A나 상태 확인은 durable wiki로 승격하지 않는다.
-- 의미 있는 작업 turn은 live Q&A archive에 남길 수 있다.
-- explicit durable request가 빠졌을 때만 selective maintenance queue를 만든다.
+- 단순 Q&A, 상태 확인, 키워드만 포함된 답변은 durable wiki나 live Q&A archive로 승격하지 않는다.
+- tool evidence, changed-file evidence, verification, 구조화된 `Decision:`/`Root cause:` 같은 결론이 있는 turn은 live Q&A archive에 남길 수 있다.
+- explicit durable request가 durable wiki에 반영되지 않았을 때만 selective maintenance queue를 만든다.
 - reusable fact는 active agent가 기존 wiki 문서에 병합한다.
 
 과거 호환용 eager mode도 남아 있다.
@@ -309,6 +309,7 @@ llm-wiki lint --workspace /path/to/project
 - stale/archived page의 supersession/link discoverability
 - outdated managed rules/templates
 - stale or oversized maintenance queue
+- oversized legacy live Q&A files or oversized live Q&A chunks
 
 broken links, invalid source IDs, secret-like content는 error이며 exit code 1을 반환한다. metadata/discoverability gap은 warning이다.
 
@@ -341,6 +342,18 @@ llm-wiki maintenance --workspace /path/to/project --json
 
 JSON 출력에는 `reviewDue`, `reviewReasons`, `pendingCount`, `stalePendingCount`, `health`, `recommendedCommands`가 포함된다. Review due 조건은 마지막 review 후 14일 경과, pending 5개 이상, stale/result-missing pending item, lint warning/error, `memory.md` near-budget 이상, wiki page count가 search cap의 80% 이상인 경우다. Hook은 due 상태를 `SessionStart`/`InstructionsLoaded`에서만 짧게 보여주고, `UserPromptSubmit`에서는 사용자가 wiki/maintenance/정리 관련 질문을 했을 때만 보여준다. 현재 답변을 중단하거나 정리를 강제하지 않는다.
 
+### `llm-wiki archive-questions`
+
+legacy daily live Q&A 파일을 chunked archive layout으로 분할한다.
+
+```bash
+llm-wiki archive-questions --workspace /path/to/project --dry-run
+llm-wiki archive-questions --workspace /path/to/project --date 2026-06-07
+llm-wiki archive-questions --workspace /path/to/project --date 2026-06-07 --json
+```
+
+대상은 `outputs/questions/YYYY-MM-DD-live-qa.md` 형식의 기존 파일이다. 실행하면 원본은 `outputs/questions/archive/originals/` 아래에 SHA-256 sidecar와 함께 보존하고, 새 기록은 `outputs/questions/YYYY-MM-DD/index.md`와 `live-qa-001.md` style chunk들로 나눈다. 기존 top-level 파일은 새 위치를 가리키는 짧은 stub로 대체한다. `--dry-run`은 어떤 파일도 쓰지 않고 split 계획만 출력한다.
+
 Agent checklist:
 
 ```bash

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

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,37 +114,30 @@ 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,
   };

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];

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 || '작업/결정 중심으로 저장된 live Q&A 기록이다. 재사용 가능한 사실은 사용자가 원하거나 명확히 중요할 때만 기존 durable wiki 문서에 합친다.',
+    '',
+  ].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');
+}

package/src/project.js

@@ -14,6 +14,7 @@ import { normalizeForStorage, redactText, summarizeForStorage } from './redactio
 import { gitignore, indexPage, llmWikiAgents, logPage, memoryPage, procedure, rootAgentsPolicy } from './templates.js';
 import { formatProjectMaintenanceContext, inspectProjectState, recordManagedTemplates } from './project-state.js';
 import { buildContextPack, formatHookContextPack, searchWiki as searchWikiWithIndex } from './wiki-search.js';
+import { appendLiveQa as appendChunkedLiveQa } from './live-qa.js';
 
 export async function bootstrapProject(projectRoot, options = {}) {
   if (process.env.LLM_WIKI_KIT_DISABLE_BOOTSTRAP === '1') return { created: false };
@@ -97,32 +98,7 @@ function hasCapturedQuestion(entry) {
 }
 
 export async function appendLiveQa(projectRoot, entry) {
-  const day = todayKst();
-  const path = join(projectRoot, 'llm-wiki', 'outputs', 'questions', `${day}-live-qa.md`);
-  const block = [
-    `\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 || '다음 작업에서 이 turn의 reusable fact가 있으면 기존 wiki 문서에 합치고, 일회성 기록은 이 Q&A에만 보존한다.',
-    '',
-  ].join('\n');
-  await appendText(path, redactText(block, 12000));
-  return path;
+  return appendChunkedLiveQa(projectRoot, entry);
 }
 
 export async function writeQueryPage(projectRoot, entry) {

package/src/templates.js

@@ -14,10 +14,10 @@ This repository uses llm-wiki-kit as a hook-first living Markdown wiki for Codex
 - \`llm-wiki/wiki/\`는 agent가 관리하는 지식층이다. 결정, 구조, 디버깅, 개념, 절차, 맥락을 여기에 정리한다.
 - \`llm-wiki/wiki/memory.md\`는 짧은 핵심 기억이다. 긴 설명 대신 현재 상태와 중요한 문서 링크만 유지한다.
 - hook이 주입한 context를 참고하되, 현재 사용자 답변을 먼저 처리한다. 수동 확인이나 정리에는 \`llm-wiki context\`, \`llm-wiki lint\`, \`llm-wiki consolidate\`를 agent 보조 도구로 사용한다.
-- hook은 redacted raw envelope와 필요한 live Q&A를 안전하게 남긴다. \`wiki/queries\`/\`wiki/decisions\` 자동 승격은 기본값이 아니며, durable 지식은 중요도와 동의 흐름에 따라 agent가 기존 정식 wiki 문서에 합친다.
+- hook은 redacted raw envelope와 작업/결정 중심 live Q&A만 안전하게 남긴다. 단순 답변, 상태 확인, 키워드만 포함된 응답은 live Q&A나 durable wiki로 승격하지 않는다. \`wiki/queries\`/\`wiki/decisions\` 자동 승격은 기본값이 아니며, durable 지식은 중요도와 동의 흐름에 따라 agent가 기존 정식 wiki 문서에 합친다.
 - hook은 종료/시작 경계에서 정말 필요한 정리 후보를 \`llm-wiki/outputs/maintenance/queue.md\`에 남길 수 있다. 정기 maintenance는 agent-side soft reminder이며, pending 항목은 현재 응답을 지연시키지 않는 범위에서 agent가 병합하거나 done/skipped로 표시한다.
-- 새 문서를 만들기 전에 기존 wiki 문서를 먼저 찾아 갱신한다. 반복해서 쓸 사실은 \`outputs/questions/\`에만 두지 말고 적절한 wiki 문서에 합친다.
-- 일회성 작업 기록은 필요할 때 \`llm-wiki/outputs/questions/\`에 보존하고, 재사용 가능한 사실/지식은 승인된 경우 \`wiki/architecture/\`, \`wiki/debugging/\`, \`wiki/decisions/\`, \`wiki/concepts/\`, \`procedures/\`에 반영한다.
+- 새 문서를 만들기 전에 기존 wiki 문서를 먼저 찾아 갱신한다. 반복해서 쓸 사실은 chunked \`outputs/questions/\`에만 두지 말고 적절한 wiki 문서에 합친다.
+- 일회성 작업/결정 기록은 필요할 때 \`llm-wiki/outputs/questions/YYYY-MM-DD/live-qa-001.md\` style chunk에 보존하고, 재사용 가능한 사실/지식은 승인된 경우 \`wiki/architecture/\`, \`wiki/debugging/\`, \`wiki/decisions/\`, \`wiki/concepts/\`, \`procedures/\`에 반영한다.
 - 검증 명령, 근거 파일, 불확실한 점을 함께 남긴다. 추론은 추론이라고 표시하고, 모순은 지우지 말고 Open Questions 또는 Contradictions에 남긴다.
 - 인증값, token, password, private key, \`.env\` 원문은 저장하지 않는다. 필요한 경우 redacted summary만 남긴다.
 
@@ -47,7 +47,7 @@ Codex와 Claude Code를 평소처럼 사용하는 동안 living Markdown LLM Wik
 - 근거 없는 내용을 사실처럼 쓰지 않는다. 추론은 명시한다.
 - 중요한 주장에는 \`source_ids\`, 파일 경로, 검증 명령 중 하나 이상을 남긴다.
 - 오래 남길 내용이 생기면 새 문서부터 만들지 말고 기존 \`wiki/\` 문서를 먼저 찾아 갱신한다.
-- 단순 답변, 상태 확인, 일회성 대화는 과도하게 \`wiki/queries\`나 maintenance로 승격하지 않는다.
+- 단순 답변, 상태 확인, 키워드만 포함된 응답, 일회성 대화는 live Q&A, \`wiki/queries\`, maintenance로 승격하지 않는다.
 - 반복해서 쓸 지식은 중요도와 동의 흐름에 따라 \`wiki/architecture/\`, \`wiki/debugging/\`, \`wiki/decisions/\`, \`wiki/concepts/\`, \`procedures/\`에 합친다.
 - hook이 만든 \`outputs/maintenance/queue.md\` pending 항목은 현재 요청과 관련 있거나 review due 안내가 있을 때 확인하고, 기존 정식 wiki 문서에 병합한 뒤 done 또는 skipped로 표시한다.
 - 정기 maintenance는 자동 수정이 아니라 agent review다. \`SessionStart\`/\`InstructionsLoaded\`에서만 짧게 안내되고, \`UserPromptSubmit\`에서는 사용자가 wiki/maintenance/정리 관련 질문을 한 경우에만 안내된다.
@@ -108,7 +108,7 @@ Generated by llm-wiki-kit.
 
 - 넓은 질문은 memory와 이 index에서 시작한다.
 - 새 문서를 만들기 전에 관련 기존 문서 3-7개를 먼저 확인한다.
-- 오래 쓸 사실/지식은 기존 정식 문서에 합치고, 일회성 기록은 outputs/questions에 둔다.
+- 오래 쓸 사실/지식은 기존 정식 문서에 합치고, 작업/결정 중심 일회성 기록은 chunked outputs/questions에 둔다.
 - 관련 페이지가 생기면 \`[[page-or-topic]]\` 링크를 추가한다.
 
 <!-- llm-wiki-kit:index-start -->
@@ -184,14 +184,14 @@ export function procedure(name) {
 4. 정확한 근거가 필요할 때만 raw source를 확인한다.
 5. 검증된 사실과 추론을 분리한다.
 6. 수동 확인이 필요할 때만 \`llm-wiki context "<query>"\`를 쓴다. 과거 episodic query/context까지 봐야 할 때는 \`--include-episodic\`을 붙이고, archived/superseded page까지 봐야 할 때만 \`--include-archived\`를 붙인다.
-7. 일회성 답변은 durable wiki로 승격하지 않는다. 필요한 작업 turn만 \`outputs/questions/\`에 남긴다.
+7. 일회성 답변, 상태 확인, 키워드만 포함된 응답은 durable wiki나 live Q&A로 승격하지 않는다. tool evidence, changed-file evidence, verification, 구조화된 decision/debugging 결론이 있는 작업 turn만 \`outputs/questions/YYYY-MM-DD/live-qa-001.md\` style chunk에 남긴다.
 8. 반복해서 쓸 사실/지식은 중요도와 동의 흐름에 따라 \`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, memory budget, page count growth, hidden episodic/context growth, stale/archived discoverability, maintenance review due.
+점검 대상: 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, memory budget, page count growth, hidden episodic/context growth, stale/archived discoverability, maintenance review due, oversized legacy live Q&A, oversized live Q&A chunk.
 
 정기 maintenance는 사용자가 매 turn 실행할 필요가 없는 agent-side task다. 필요할 때 agent가 다음 순서로 확인한다:
 

package/src/wiki-lint.js

@@ -4,6 +4,7 @@ import { exists, readText } from './fs-utils.js';
 import { maintenanceSummary } from './maintenance.js';
 import { inspectProjectState } from './project-state.js';
 import { hasSecretLikeText } from './redaction.js';
+import { liveQaMaxBytes, liveQaMaxLines } from './live-qa.js';
 import {
   buildAliasMap,
   buildWikiGraph,
@@ -41,11 +42,57 @@ const CORE_PAGES = new Set(['wiki/index.md', 'wiki/log.md', 'wiki/memory.md']);
 const MEMORY_NEAR_BUDGET_BYTES = 20 * 1024;
 const HIDDEN_PAGE_WARNING_THRESHOLD = 50;
 const SEARCH_CAP_WARNING_RATIO = 0.8;
+const ARCHIVED_LIVE_QA_MARKER = '<!-- llm-wiki-kit:archived-live-qa -->';
 
 function issue(severity, code, path, message) {
   return { severity, code, path, message };
 }
 
+function countLines(text) {
+  if (!text) return 0;
+  return String(text).split(/\r?\n/).length;
+}
+
+function liveQaOversized(text) {
+  return countLines(text) > liveQaMaxLines() || Buffer.byteLength(text || '', 'utf8') > liveQaMaxBytes();
+}
+
+async function liveQaGrowthIssues(projectRoot) {
+  const issues = [];
+  const root = join(projectRoot, 'llm-wiki', 'outputs', 'questions');
+  let entries = [];
+  try {
+    entries = await readdir(root, { withFileTypes: true });
+  } catch {
+    return issues;
+  }
+  for (const entry of entries) {
+    const full = join(root, entry.name);
+    if (entry.isFile() && /^\d{4}-\d{2}-\d{2}-live-qa\.md$/.test(entry.name)) {
+      const text = await readText(full, '');
+      if (!text.includes(ARCHIVED_LIVE_QA_MARKER) && liveQaOversized(text)) {
+        issues.push(issue('warning', 'live-qa-legacy-oversized', `outputs/questions/${entry.name}`, 'legacy daily live Q&A file is oversized; run archive-questions to split it into chunks'));
+      }
+    }
+    if (entry.isDirectory() && /^\d{4}-\d{2}-\d{2}$/.test(entry.name)) {
+      let chunkEntries = [];
+      try {
+        chunkEntries = await readdir(full, { withFileTypes: true });
+      } catch {
+        chunkEntries = [];
+      }
+      for (const chunk of chunkEntries) {
+        if (!chunk.isFile() || !/^live-qa-\d+\.md$/.test(chunk.name)) continue;
+        const text = await readText(join(full, chunk.name), '');
+        if (liveQaOversized(text)) {
+          issues.push(issue('warning', 'live-qa-chunk-oversized', `outputs/questions/${entry.name}/${chunk.name}`, 'live Q&A chunk exceeds the configured rollover budget'));
+        }
+      }
+    }
+  }
+  return issues;
+}
+
 function isDateLike(value) {
   return value === 'unknown' || /^\d{4}-\d{2}-\d{2}$/.test(String(value || ''));
 }
@@ -291,6 +338,8 @@ export async function runLint(projectRoot, options = {}) {
     }
   }
 
+  issues.push(...await liveQaGrowthIssues(projectRoot));
+
   return lintResult(projectRoot, pages, issues);
 }