llm-wiki-kit 0.2.17 → 0.2.19

package/README.md

@@ -10,6 +10,8 @@ The goal is not to make users run `ingest` or `record` commands. After install,
 
 - Korean user prompt -> Korean hook guidance.
 - English user prompt -> English hook guidance.
+- Codex synthetic plan execution prompts such as `Implement the plan.` are treated as neutral, so they reuse the last real session language or project preference instead of forcing English.
+- Project `.kit-state.json` may set `preferredLanguage` to `ko` or `en` for neutral prompts.
 - If there is no clear current prompt language, Claude Code `settings.json` `language` is used when present.
 - If that setting is missing, local `CLAUDE.md` and `AGENTS.md` language signals are used.
 - The fallback is English.
@@ -100,19 +102,19 @@ Use Claude Code or Codex normally.
 The installed hooks:
 
 - inject functional compact context at session start, instructions loaded, and prompt submit. The hook still uses `wiki/memory.md`, `wiki/index.md`, relevant wiki search results, maintenance signals, update status, and any compact recovery packet; it formats only the useful parts so user-visible hook context does not look like a raw debug dump.
-- automatically choose Korean or English hook guidance from the current user prompt, then fall back to Claude Code `language`, local `CLAUDE.md`/`AGENTS.md`, and English.
+- automatically choose Korean or English hook guidance from the current real user prompt, keep Codex synthetic plan execution prompts neutral, then fall back to remembered session language, project `preferredLanguage`, Claude Code `language`, local `CLAUDE.md`/`AGENTS.md`, and English.
 - remove Codex-facing legacy `oh-my-codex:wiki`/`omx_wiki` surfaces at session start so `llm-wiki/` remains the active wiki implementation
 - record small redacted raw event envelopes and per-turn state
 - capture meaningful work and structured decision points, including tool evidence, changed files, verification notes, and reusable durable-candidate signals
-- attach safe `evidence_refs` candidates to generated durable candidates when changed files or verification commands are available
-- before compaction, classify the current turn and save a redacted checkpoint only for meaningful work, structured decisions, explicit durable requests, or suggested durable candidates; durable candidates get a maintenance queue item when no durable wiki update is detected
+- attach safe `evidence_refs` candidates to generated queue items when changed files or verification commands are available
+- before compaction, classify the current turn and save a redacted checkpoint only for meaningful work, structured decisions, explicit durable requests, or recovered work; explicit/structured durable candidates 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 chunked `llm-wiki/outputs/questions/YYYY-MM-DD/live-qa-001.md` style archives only for meaningful work, structured decision turns, or hook-suggested durable candidates
+- update chunked `llm-wiki/outputs/questions/YYYY-MM-DD/live-qa-001.md` style archives only for meaningful work, structured decision turns, or explicit durable requests
 - avoid automatic `wiki/queries/` and `wiki/decisions/` promotion in the default answer-first mode
-- queue durable cleanup candidates for explicit documentation requests, hook-suggested durable candidates, or recovered stale turn state that were not reflected in durable wiki files
+- queue durable cleanup candidates for explicit documentation requests, structured durable conclusions, or recovered stale turn state that were not reflected in durable wiki files
 - recover stale per-turn state into that queue on the next session start or prompt submit when the previous stop hook did not complete
-- nudge the active LLM to fold approved or hook-suggested reusable facts into existing wiki pages instead of leaving everything as one-off Q&A
+- nudge the active LLM to batch-review accumulated candidates and fold only explicit, repeated, or clearly reusable facts into existing wiki pages
 - automatically refresh managed rules/templates for older projects when the current runtime starts a session
 
 If you need to think about saving every answer manually, the setup has failed.
@@ -148,7 +150,7 @@ Installed npm runtimes also perform a cached update notice check from hooks whil
 
 `llm-wiki consolidate` refreshes only generated marker blocks in `wiki/memory.md` and `wiki/index.md`. Generated maps keep durable non-archived pages, hide default episodic records, skip stale/archived/superseded pages, and report those counts in dry-run output. It is an agent maintenance helper, not a command users should run after every turn.
 
-`llm-wiki maintenance` prints the queue and review due status from `llm-wiki/outputs/maintenance/queue.md`. Queue states are `pending -> approved -> done` or `skipped`. Use `llm-wiki maintenance --workspace <project> --approve <id> --target <wiki/...md>` when durable promotion is approved, `--done <id> --target <wiki/...md>` after the active agent has merged the fact into a durable page, and `--skip <id> [--note "..."]` for duplicate or non-durable candidates. `llm-wiki maintenance --workspace <project> --apply-lifecycle --dry-run` previews automatic queue hygiene; without `--dry-run`, high-signal or explicit candidates are moved to `approved` once pending reaches the lifecycle threshold, old low-signal candidates may be skipped, and old reviewed items move to `outputs/maintenance/archive/`. Hooks apply that lifecycle only on `SessionStart`/`InstructionsLoaded`; `UserPromptSubmit` only reminds. Approved items are shown before pending items in hook reminders. Periodic maintenance is a soft agent-side reminder, not a user command loop.
+`llm-wiki maintenance` prints the queue and review due status from `llm-wiki/outputs/maintenance/queue.md`. Queue states are `pending -> approved -> done` or `skipped`. Use `llm-wiki maintenance --workspace <project> --approve <id> --target <wiki/...md>` only when a human/agent explicitly accepts durable promotion, `--done <id> --target <wiki/...md>` after the active agent has merged the fact into a durable page, and `--skip <id> [--note "..."]` for duplicate or non-durable candidates. `llm-wiki maintenance --workspace <project> --apply-lifecycle --dry-run` previews automatic queue hygiene; without `--dry-run`, candidates remain pending for batch review, old low-signal candidates may be skipped, and old reviewed items move to `outputs/maintenance/archive/`. Hooks apply that lifecycle only on `SessionStart`/`InstructionsLoaded`; `UserPromptSubmit` only reminds for explicit documentation, recovered state, maintenance prompts, or batch thresholds. Approved items are shown before pending items in hook reminders. Periodic maintenance is a soft agent-side reminder, not a user command loop.
 
 `llm-wiki eval --workspace <project> [--fixture <path>] [--limit 5] [--json]` runs retrieval fixtures from `llm-wiki/evals/retrieval.json` by default. If the fixture is absent, it exits successfully with `no fixture found`. Fixtures list `query`, `expected`, and `unexpected` paths; output reports recall, missed expected hits, unexpected hits, and top hits using the same durable visibility policy as export.
 

package/docs/concepts.md

@@ -18,13 +18,13 @@ 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 chunked live Q&A only for turns with work evidence, structured decision/debugging conclusions, or hook-suggested durable candidates.
+5. At stop/session end, hooks append redacted chunked live Q&A only for turns with work evidence, structured decision/debugging conclusions, or explicit durable requests.
 6. When possible, generated candidates carry safe `evidence_refs` such as changed files, verification commands, raw source IDs, or external URLs.
 7. Simple answers, status checks, and keyword-only responses stay out of live Q&A and durable wiki by default.
-8. Durable wiki promotion is selective: explicit record/document requests and hook-suggested durable candidates should be handled by the active agent in existing wiki pages; the hook queues review only when the turn was not reflected in durable files.
+8. Durable wiki promotion is selective: explicit record/document requests and structured durable conclusions enter the queue, but the active agent should batch-review and merge only explicit, repeated, or clearly reusable facts into existing wiki pages.
 9. At the next start/prompt after an abrupt shutdown, hooks can recover stale turn state into `outputs/maintenance/queue.md`.
-10. At session start, deterministic lifecycle hygiene may approve explicit/high-signal pending items, skip old low-signal items, and archive old reviewed items without generating wiki pages automatically.
-11. When reusable knowledge appears, the active Claude Code/Codex agent folds approved or hook-suggested facts into existing durable wiki pages instead of leaving everything as one-off Q&A.
+10. At session start, deterministic lifecycle hygiene keeps candidates pending for batch review, may skip old low-signal items, and archives old reviewed items without generating wiki pages automatically.
+11. When reusable knowledge appears repeatedly or explicitly, the active Claude Code/Codex agent folds it into existing durable wiki pages instead of creating one page per candidate.
 12. Export and eval reuse the same durable visibility policy so handoff manifests, retrieval fixtures, and context selection describe the same wiki surface.
 13. Future sessions start from the improved wiki instead of relying on long chat history.
 
@@ -45,9 +45,9 @@ The maintenance loop is intentionally layered:
 - `index.md`: broad navigation map.
 - MiniSearch + wikilinks: retrieval over durable `wiki/**/*.md`, with episodic `wiki/queries/`, `wiki/context/`, and `session-log` pages hidden by default unless promoted or `--include-episodic` is requested; archived/superseded pages stay preserved but hidden unless `--include-archived` is requested. Verbose context explains `why selected`; hook context stays compact.
 - `evidence_refs`: optional frontmatter that ties durable claims to `file:`, `cmd:`, `raw:`, or `url:` evidence without embedding secrets or raw transcripts.
-- `outputs/maintenance/queue.md`: selective reminders for explicit durable requests, hook-suggested durable candidates, and stale turn recovery that need review. Queue state is `pending`, `approved`, `done`, or `skipped`; reviewed history can move to `outputs/maintenance/archive/`.
+- `outputs/maintenance/queue.md`: selective reminders for explicit durable requests, structured durable conclusions, and stale turn recovery that need batch review. Queue state is `pending`, `approved`, `done`, or `skipped`; reviewed history can move to `outputs/maintenance/archive/`.
 - `lint`: finds broken links, stale pages, duplicates, metadata gaps, invalid evidence refs, secret-like content, outdated managed rules, memory/page-count budget pressure, hidden episodic growth, and stale/archived discoverability gaps.
-- `maintenance`: reports `reviewDue` only when periodic thresholds are met; hook reminders are soft and limited to session start/instructions loaded or compact prompt-time reminders for maintenance prompts, approved items, durable candidates, stale/recovered items, or review-threshold pressure. `--apply-lifecycle` previews or applies bounded queue hygiene; it does not merge or create durable wiki pages.
+- `maintenance`: reports `reviewDue` only when periodic thresholds are met; hook reminders are soft and limited to session start/instructions loaded or compact prompt-time reminders for maintenance prompts, approved items, explicit durable requests, recovered items, or batch-threshold pressure. `--apply-lifecycle` previews or applies bounded queue hygiene; it does not merge, auto-approve, or create durable wiki pages.
 - `consolidate`: agent helper that refreshes generated blocks in `memory.md` and `index.md` while preserving handwritten notes, keeping default query/context/session pages out of the durable generated maps, and skipping stale/archived/superseded pages.
 - `eval`: checks retrieval fixtures in `llm-wiki/evals/retrieval.json` and reports expected recall, missed expected paths, unexpected hits, and top hits.
 - `export`: writes redacted `llms.txt`, `llms-full.txt`, and `llm-wiki.json` manifests for agent onboarding, handoff, retrieval eval, and external consumption. `llms.txt` is not treated as a passive SEO artifact.

package/docs/integrations/claude-code.md

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

package/docs/integrations/codex.md

@@ -30,14 +30,14 @@ Handled events:
 Expected behavior:
 
 - `SessionStart` first attempts a safe managed-template refresh, removes Codex-facing legacy `oh-my-codex:wiki`/`omx_wiki` surfaces when they reappear, recovers stale turn state into `outputs/maintenance/queue.md`, applies deterministic maintenance lifecycle hygiene for the current workspace, performs a cached npm update notice check for npm installs, then injects functional compact context. The context still uses `llm-wiki/wiki/memory.md`, `llm-wiki/wiki/index.md`, relevant wiki/search state, operating rules, maintenance signals, passive runtime update status, and managed-template cleanup notes; the hook formats those signals so they are usable if shown in the Codex UI.
-- `UserPromptSubmit` recovers stale turn state, searches project wiki pages with MiniSearch or substring fallback, expands one-hop wikilinks, redacts context fields, performs the same cached update notice check, and injects the smallest useful functional compact context set. Verbose `llm-wiki context` can explain `why selected`, `rankReason`, `matchedFields`, and `evidenceRefs`, but hook context keeps those details compact. Update notice cache is scoped by npm command, and maintenance reminders are shown for wiki/maintenance prompts, queue topic matches, approved items, durable candidates, stale/recovered items, or review-threshold pressure.
-- Hook-visible language is selected from the current user prompt first. Korean prompts get Korean guidance, English prompts get English guidance. If no prompt language is clear, Codex falls back to local `CLAUDE.md`/`AGENTS.md` language signals, then English.
+- `UserPromptSubmit` recovers stale turn state, searches project wiki pages with MiniSearch or substring fallback, expands one-hop wikilinks, redacts context fields, performs the same cached update notice check, and injects the smallest useful functional compact context set. Verbose `llm-wiki context` can explain `why selected`, `rankReason`, `matchedFields`, and `evidenceRefs`, but hook context keeps those details compact. Update notice cache is scoped by npm command, and maintenance reminders are shown only for wiki/maintenance prompts, approved items, explicit durable requests, recovered items, or batch review threshold pressure.
+- Hook-visible language is selected from the current real user prompt first. Korean prompts get Korean guidance, English prompts get English guidance. Codex synthetic plan execution prompts such as `Implement the plan.` are treated as neutral, so they reuse remembered session language or project `preferredLanguage` instead of forcing English. If no prompt language is clear, Codex falls back to local `CLAUDE.md`/`AGENTS.md` language signals, then English.
 - `PreToolUse` records redacted tool summaries without blocking tool calls.
 - `PostToolUse` records redacted tool summaries in a turn buffer.
-- `PreCompact` classifies the current turn before compaction. Simple turns record only a context note; work-evidence, structured-decision, explicit durable, or hook-suggested durable turns write a chunked live Q&A checkpoint; durable candidates write a maintenance queue item only when no durable wiki update is detected. The checkpoint can include only a bounded redacted transcript tail, never the full raw transcript or raw `transcript_path`. Compaction is not blocked; if checkpoint storage fails, the hook records a compact recovery packet for the next legal context-injection event.
+- `PreCompact` classifies the current turn before compaction. Simple turns record only a context note; work-evidence, structured-decision, explicit durable, or recovered turns write a chunked live Q&A checkpoint; explicit/structured 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 chunked live Q&A only for work-evidence, structured-decision, or durable-candidate turns and does not auto-create `wiki/queries/` or `wiki/decisions/`.
-- If the user explicitly asked to record durable knowledge, or the turn contains reusable architecture/debugging/policy/procedure/decision signals, and no durable wiki update is detected, `Stop` queues a pending maintenance item for agent review. Queue items carry `signal_level` and may carry safe `evidence_refs` candidates from actual repo files and verification commands. The lifecycle can move explicit/high-signal items to `approved`, skip stale low-signal items, and archive old reviewed items, but it never creates durable wiki pages automatically. Approved and durable-candidate maintenance items are surfaced as compact soft reminders.
+- If the user explicitly asked to record durable knowledge, or the turn contains a structured durable conclusion, and no durable wiki update is detected, `Stop` queues a pending maintenance item for batch review. Queue items carry `signal_level` and may carry safe `evidence_refs` candidates from actual repo files and verification commands. The lifecycle keeps candidates pending for batch review, skips stale low-signal items, and archives old reviewed items, but it never creates durable wiki pages automatically or auto-approves promotion. Prompt-time reminders are limited to explicit durable requests, recovered state, maintenance prompts, approved items, or batch thresholds.
 - `Stop` clears the per-session turn buffer after recording. `SubagentStop` leaves the parent turn buffer available for the final stop event.
 
 Hook payloads are stored as small redacted event envelopes rather than full transcripts. Context output is also redacted field by field before it is returned to Codex. Functional compact context is a presentation policy, not a feature reduction: Codex still receives the wiki memory, search, maintenance, and passive update signals needed for the hook workflow.

package/docs/manual.md

@@ -10,6 +10,8 @@ The runtime supports seamless Korean/English use:
 
 - If the current user prompt is clearly Korean, hook-visible guidance is Korean.
 - If the current user prompt is clearly English, hook-visible guidance is English.
+- Codex synthetic plan execution prompts such as `Implement the plan.` are not treated as English; they reuse the last real session language or project preference.
+- A project can set `preferredLanguage` in `llm-wiki/.kit-state.json` for neutral prompts.
 - When there is no clear prompt language, Claude Code may use its `settings.json` `language` value when present.
 - If no setting exists, the runtime checks local `CLAUDE.md` and `AGENTS.md` language signals.
 - The fallback is English.
@@ -68,14 +70,14 @@ llm-wiki/
 Use Codex or Claude Code normally. Installed hooks:
 
 - inject functional compact context at session start, instructions loaded, and prompt submit;
-- select Korean or English hook guidance from the current user prompt and local instruction files;
+- select Korean or English hook guidance from the current real user prompt, remembered session language, project preference, and local instruction files;
 - use `wiki/memory.md`, `wiki/index.md`, relevant wiki search, maintenance signals, update notices, and compact recovery packets;
 - record redacted prompt/tool/result summaries in per-turn state;
 - preserve safe evidence pointers as `evidence_refs` when changed files or verification commands are available;
-- archive only meaningful work turns, structured decision/debugging turns, or hook-suggested durable candidates into chunked `outputs/questions/YYYY-MM-DD/live-qa-001.md` files;
+- archive only meaningful work turns, structured decision/debugging turns, or explicit durable requests into chunked `outputs/questions/YYYY-MM-DD/live-qa-001.md` files;
 - avoid automatic `wiki/queries/` and `wiki/decisions/` promotion in the default answer-first mode;
-- queue durable cleanup candidates for explicit documentation requests, hook-suggested durable candidates, or recovered stale turn state that were not reflected in durable wiki files;
-- apply deterministic queue lifecycle hygiene at session start so explicit/high-signal candidates can move to `approved`, stale low-signal candidates can be skipped, and old reviewed items can be archived without creating wiki pages automatically;
+- queue durable cleanup candidates for explicit documentation requests, structured durable conclusions, or recovered stale turn state that were not reflected in durable wiki files;
+- apply deterministic queue lifecycle hygiene at session start so candidates stay pending for batch review, stale low-signal candidates can be skipped, and old reviewed items can be archived without creating wiki pages automatically;
 - refresh clearly managed rules/templates for older projects at session start;
 - remove legacy Codex-facing `oh-my-codex:wiki`/`omx_wiki` surfaces when they reappear.
 
@@ -89,7 +91,7 @@ Default:
 LLM_WIKI_KIT_CAPTURE_MODE=answer-first
 ```
 
-`answer-first` keeps simple Q&A, status checks, and keyword-only replies out of durable wiki and live Q&A by default. It archives work turns with tool evidence, changed-file evidence, verification, structured `Decision:`/`Root cause:` style conclusions, or reusable durable-candidate signals. Explicit durable requests and hook-suggested durable candidates create maintenance queue candidates only when no durable wiki update is detected.
+`answer-first` keeps simple Q&A, status checks, and keyword-only replies out of durable wiki and live Q&A by default. It archives work turns with tool evidence, changed-file evidence, verification, or structured `Decision:`/`Root cause:` style conclusions. Explicit durable requests and structured durable conclusions create maintenance queue candidates only when no durable wiki update is detected.
 
 Deprecated compatibility mode:
 
@@ -229,7 +231,7 @@ Missing fixtures exit successfully with `no fixture found`. Present fixtures rep
 
 ## Maintenance
 
-`llm-wiki maintenance` reports queue state and review health. It does not merge pages automatically. The active agent should merge reusable items into existing durable pages and mark queue items through `pending`, `approved`, `done`, or `skipped`.
+`llm-wiki maintenance` reports queue state and review health. It does not merge pages automatically. The active agent should batch-review candidates, merge only explicit, repeated, or clearly reusable facts into existing durable pages, and mark queue items through `pending`, `approved`, `done`, or `skipped`.
 
 ```bash
 llm-wiki maintenance --workspace <project> --apply-lifecycle --dry-run
@@ -240,12 +242,12 @@ llm-wiki maintenance --workspace <project> --skip <id> --note "duplicate"
 
 `approved` means durable promotion is accepted but not yet merged. `done` means the durable page has been updated. `skipped` means the item was duplicate or not reusable enough. Approved reminders are shown before pending reminders.
 
-Lifecycle hygiene applies when pending reaches 15: explicit/high-signal candidates move to `approved`, old low-signal candidates may move to `skipped`, explicit requests and recovered `result_missing` items are not auto-skipped, and old reviewed items beyond the latest 10 move to `outputs/maintenance/archive/YYYY-MM.md`. Hooks apply this only on `SessionStart`/`InstructionsLoaded`; `UserPromptSubmit` only reminds.
+Lifecycle hygiene applies when pending reaches 15: candidates remain pending for batch review, old low-signal candidates may move to `skipped`, explicit requests and recovered `result_missing` items are not auto-skipped, and old reviewed items beyond the latest 10 move to `outputs/maintenance/archive/YYYY-MM.md`. Hooks apply this only on `SessionStart`/`InstructionsLoaded`; `UserPromptSubmit` only reminds.
 
 Hook reminders are soft:
 
 - session start and instructions loaded may show a one-item summary;
-- prompt submit shows one compact reminder for wiki/maintenance prompts, queue topic matches, approved items, durable candidates, stale/recovered items, or review-threshold pressure.
+- prompt submit shows one compact reminder for wiki/maintenance prompts, approved items, explicit durable requests, recovered items, or the batch review threshold.
 
 ## PreCompact
 

package/docs/operations.md

@@ -147,7 +147,7 @@ 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 evidence, structured decision turns, or reusable durable-candidate signals. 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, or the turn contains reusable architecture/debugging/policy/procedure/decision signals, and no durable wiki update is detected, a pending cleanup candidate is written to `llm-wiki/outputs/maintenance/queue.md` with a local `signal_level` such as `explicit`, `high`, `low`, or `recovered`. `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 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 and applies deterministic queue lifecycle hygiene; `UserPromptSubmit` injects a compact soft reminder when the prompt is wiki/maintenance related, matches a queue topic, has approved or durable-candidate items, or the queue crosses the review threshold. 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, structured decision turns, or explicit durable requests. Simple answers, status checks, keyword-only responses, and ordinary durable keywords such as "root cause" inside work summaries are not promoted into durable review by themselves. 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, or the turn contains a structured durable conclusion such as `Decision:` or `Root cause:`, and no durable wiki update is detected, a pending cleanup candidate is written to `llm-wiki/outputs/maintenance/queue.md` with a local `signal_level` such as `explicit`, `high`, `low`, or `recovered`. `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/structured 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 and applies deterministic queue lifecycle hygiene; `UserPromptSubmit` injects a compact soft reminder only for wiki/maintenance prompts, approved items, explicit durable requests, recovered items, or when the queue crosses the batch review threshold. 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.
 
@@ -210,11 +210,11 @@ Broken links, invalid source IDs, and secret-like content are errors and return
 
 Agents may run `consolidate` after meaningful wiki growth. Users should not need to run it after every turn.
 
-`llm-wiki maintenance --workspace <project>` prints queue counts, review due status, and the first pending items. It does not merge wiki pages by itself; the active agent should review pending or approved items, update the closest existing durable wiki document, then mark the queue item `done` or `skipped`. Periodic maintenance is an agent-side task, not something users need to run after every turn.
+`llm-wiki maintenance --workspace <project>` prints queue counts, review due status, and the first pending items. It does not merge wiki pages by itself; the active agent should batch-review pending or approved items, update the closest existing durable wiki document only for explicit, repeated, or clearly reusable facts, then mark the queue item `done` or `skipped`. Periodic maintenance is an agent-side task, not something users need to run after every turn.
 
-`llm-wiki maintenance --workspace <project> --apply-lifecycle --dry-run` previews automatic queue hygiene. Running it without `--dry-run` approves explicit/high-signal pending candidates when pending reaches 15, skips low-signal pending candidates older than 14 days, never auto-skips explicit requests or recovered `result_missing` items, and moves old `done`/`skipped` items beyond the latest 10 into `outputs/maintenance/archive/YYYY-MM.md`. The lifecycle never writes durable wiki pages automatically; it only keeps the review queue bounded and prioritized. Hooks run the same lifecycle on `SessionStart`/`InstructionsLoaded`, while `UserPromptSubmit` only surfaces reminders.
+`llm-wiki maintenance --workspace <project> --apply-lifecycle --dry-run` previews automatic queue hygiene. Running it without `--dry-run` keeps explicit/high-signal pending candidates pending for batch review when pending reaches 15, skips low-signal pending candidates older than 14 days, never auto-skips explicit requests or recovered `result_missing` items, and moves old `done`/`skipped` items beyond the latest 10 into `outputs/maintenance/archive/YYYY-MM.md`. The lifecycle never writes durable wiki pages automatically and never auto-approves page promotion; it only keeps the review queue bounded and prioritized. Hooks run the same lifecycle on `SessionStart`/`InstructionsLoaded`, while `UserPromptSubmit` only surfaces reminders.
 
-`llm-wiki maintenance --workspace <project> --json` includes `reviewDue`, `reviewReasons`, `pendingCount`, `stalePendingCount`, `health`, `recommendedCommands`, and lifecycle action counts when lifecycle is applied. Review is due when the last review is older than 14 days, pending queue size reaches 5, stale or result-missing pending items exist, lint has warnings/errors, `memory.md` is near budget, or wiki page count reaches 80% of the search cap. Hook reminders are soft: `SessionStart`/`InstructionsLoaded` may show a short due note, while `UserPromptSubmit` shows one compact item for wiki/maintenance prompts, approved items, durable candidates, stale/recovered items, or review-threshold pressure. The reminder never blocks the current answer.
+`llm-wiki maintenance --workspace <project> --json` includes `reviewDue`, `reviewReasons`, `pendingCount`, `stalePendingCount`, `health`, `recommendedCommands`, and lifecycle action counts when lifecycle is applied. Review is due when the last review is older than 14 days, pending queue size reaches 15, stale or result-missing pending items exist, lint has warnings/errors, `memory.md` is near budget, or wiki page count reaches 80% of the search cap. Hook reminders are soft: `SessionStart`/`InstructionsLoaded` may show a short due note, while `UserPromptSubmit` shows one compact item only for wiki/maintenance prompts, approved items, explicit durable requests, recovered items, or batch review threshold pressure. The reminder never blocks the current answer.
 
 Recommended agent checklist:
 
@@ -296,6 +296,8 @@ Managed project files are conservative:
 
 Real registry checks require `llm-wiki-kit` to be published to npm. Before publication, `llm-wiki update --check` returns npm 404. Use fake npm in tests or local tarball install for server smoke checks.
 
+For Korean-first Codex projects, set `preferredLanguage: "ko"` in `llm-wiki/.kit-state.json` when neutral prompts should stay Korean. This is especially useful after Codex plan approval, because Codex may submit `Implement the plan.` as the next prompt and the runtime deliberately treats that exact synthetic prompt as language-neutral.
+
 ## Release Checklist
 
 Before publishing:

package/docs/troubleshooting.md

@@ -229,7 +229,7 @@ Check:
 
 ## Maintenance Queue Is Empty Or Stale
 
-In the default answer-first mode, `llm-wiki/outputs/maintenance/queue.md` is created when a user explicitly asked for durable recording/documentation, a turn was classified as a hook-suggested durable candidate, or stale per-turn state is recovered, and no durable wiki update was detected. It is not expected to grow after every normal `Stop`.
+In the default answer-first mode, `llm-wiki/outputs/maintenance/queue.md` is created when a user explicitly asked for durable recording/documentation, a turn has a structured durable conclusion, or stale per-turn state is recovered, and no durable wiki update was detected. It is not expected to grow after every normal `Stop`, and ordinary durable words inside a work summary are not enough by themselves.
 
 Check the queue and health warnings:
 
@@ -239,7 +239,7 @@ llm-wiki maintenance --workspace /path/to/project --apply-lifecycle --dry-run
 llm-wiki lint --workspace /path/to/project
 ```
 
-If the queue is always empty during ordinary Q&A, that is normal. If you expected an explicit documentation request or durable candidate to queue, confirm hooks run and that the turn had a captured `UserPromptSubmit`. If pending items stay around, the active agent should merge reusable content into existing durable wiki pages and mark each item `done` or `skipped` without delaying unrelated answers. When pending reaches the lifecycle threshold, `--apply-lifecycle` can promote explicit/high-signal items to `approved`, skip stale low-signal items, and archive old reviewed entries; it does not create durable wiki pages automatically.
+If the queue is always empty during ordinary Q&A, that is normal. If you expected an explicit documentation request or structured durable conclusion to queue, confirm hooks run and that the turn had a captured `UserPromptSubmit`. If pending items stay around, the active agent should batch-review them, merge only explicit, repeated, or clearly reusable content into existing durable wiki pages, and mark each item `done` or `skipped` without delaying unrelated answers. When pending reaches the lifecycle threshold, `--apply-lifecycle` keeps candidates pending for batch review, skips stale low-signal items, and archives old reviewed entries; it does not create durable wiki pages automatically or auto-approve promotion.
 
 ## Authentication Values Were Redacted
 

package/package.json

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

package/src/capture-policy.js

@@ -123,7 +123,8 @@ export function classifyTurn(entry, eventName = '') {
   const hasVerification = Boolean(verification);
   const hasWorkEvidence = hasWork || hasFiles || hasVerification;
   const durableConclusion = hasDurableConclusion(text);
-  const durableSignal = durableConclusion || hasDurableKeyword(text);
+  const durableKeyword = hasDurableKeyword(text);
+  const durableSignal = durableConclusion || durableKeyword;
   const durableUpdated = hasDetectedDurableWikiChange(entry);
 
   if (hasWorkEvidence) {
@@ -135,7 +136,7 @@ export function classifyTurn(entry, eventName = '') {
         queueIfMissingDurable: false,
       };
     }
-    if (durableSignal) {
+    if (durableConclusion) {
       return {
         kind: 'suggest-durable',
         archive: true,
@@ -144,6 +145,14 @@ export function classifyTurn(entry, eventName = '') {
         signalLevel: durableSignalLevel({ durableConclusion, hasFiles, hasVerification, durableSignal }),
       };
     }
+    if (durableKeyword) {
+      return {
+        kind: 'work',
+        archive: true,
+        suggestDurable: false,
+        queueIfMissingDurable: false,
+      };
+    }
     return {
       kind: 'work',
       archive: true,

package/src/compact-capture.js

@@ -204,7 +204,7 @@ export async function handlePreCompactCapture(projectRoot, provider, eventName,
       followUp: appendToField(
         entry.followUp,
         classification.suggestDurable
-          ? 'PreCompact saved this checkpoint and queued durable wiki review; merge reusable facts into existing wiki pages after the current answer.'
+          ? 'PreCompact saved this checkpoint and queued batch durable review; merge only if it remains reusable with related candidates.'
           : 'PreCompact saved this checkpoint before context compaction; reusable facts should be merged only when appropriate.'
       ),
     };
@@ -220,7 +220,7 @@ export async function handlePreCompactCapture(projectRoot, provider, eventName,
       const result = await recordMaintenanceForEntry(projectRoot, entry, {
         source: liveQaPath,
         eventName,
-        reason: 'PreCompact durable candidate checkpoint needs review after context compaction.',
+        reason: 'PreCompact structured durable checkpoint is waiting for batch review after context compaction.',
         signalLevel: classification.signalLevel,
       });
       if (result.created === false && result.reason) {

package/src/consolidate.js

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

package/src/hook.js

@@ -6,10 +6,10 @@ import { applyMaintenanceLifecycle, recoverStaleTurnStates, recordMaintenanceFor
 import { applyProjectTemplateUpdate, inspectProjectState } from './project-state.js';
 import { recordProject } from './projects.js';
 import { summarizeForStorage } from './redaction.js';
-import { buildEntryFromState, clearTurnState, rememberQuestion, rememberTool } from './state.js';
+import { buildEntryFromState, clearTurnState, readRememberedLanguage, rememberLanguage, rememberQuestion, rememberTool } from './state.js';
 import { updateNoticeContext } from './update-notice.js';
 import { removeLegacyOmxWikiSurfaces } from './legacy-omx-wiki.js';
-import { resolveLanguage } from './language.js';
+import { detectTextLanguage, isSyntheticPlanPrompt, resolveLanguage } from './language.js';
 import { relative } from 'path';
 
 async function readStdinJson() {
@@ -30,6 +30,11 @@ function promptText(payload) {
   return payload.prompt || payload.user_prompt || payload.userPrompt || payload.message || payload.input || '';
 }
 
+function storagePromptText(prompt, language) {
+  if (!isSyntheticPlanPrompt(prompt)) return prompt;
+  return language === 'ko' ? '승인된 계획 실행' : 'Approved plan implementation.';
+}
+
 function toolSummary(payload) {
   const toolName = payload.tool_name || payload.toolName || payload.name || payload.tool?.name || 'tool';
   const input = payload.tool_input || payload.toolInput || payload.input || payload.arguments || payload.tool?.input || {};
@@ -85,12 +90,12 @@ function durableQueueReason(classification) {
   if (classification.kind === 'explicit-durable') {
     return 'Explicit durable documentation request did not have a detected durable wiki update.';
   }
-  return 'Suggested durable wiki candidate did not have a detected durable wiki update.';
+  return 'Structured durable conclusion is waiting for batch review.';
 }
 
 function durableFollowUp(entry, classification) {
   if (!classification.suggestDurable) return entry.followUp;
-  const message = 'This turn is a durable wiki candidate. After the current answer, merge reusable facts into an existing durable wiki page or mark the maintenance item skipped.';
+  const message = 'This turn has a structured durable conclusion. Keep it in the maintenance queue for batch review; merge only if it remains reusable with related candidates, otherwise mark it skipped.';
   const current = String(entry.followUp || '').trim();
   if (!current || current === '(not captured)') return message;
   if (current.includes(message)) return current;
@@ -145,10 +150,17 @@ export async function handleHook(provider, explicitEvent) {
   const cwd = payload.cwd || process.cwd();
   const projectRoot = await findProjectRoot(cwd);
   await bootstrapProject(projectRoot);
+  const prompt = eventName === 'UserPromptSubmit' ? promptText(payload) : '';
+  const promptLanguage = eventName === 'UserPromptSubmit' ? detectTextLanguage(prompt) : null;
+  const rememberedLanguage = await readRememberedLanguage(projectRoot, payload).catch(() => null);
   const requestLanguage = await resolveLanguage(projectRoot, {
     provider,
-    prompt: eventName === 'UserPromptSubmit' ? promptText(payload) : '',
+    prompt,
+    rememberedLanguage,
   }).catch(() => 'en');
+  if (eventName === 'UserPromptSubmit' && promptLanguage) {
+    await rememberLanguage(projectRoot, payload, promptLanguage, 'prompt').catch(() => null);
+  }
   await recordProject(projectRoot, 'hook').catch(() => {});
   await autoUpdateManagedProject(projectRoot, eventName).catch(() => {});
   await removeLegacyWikiSurfaces(projectRoot, eventName).catch(() => {});
@@ -175,14 +187,17 @@ export async function handleHook(provider, explicitEvent) {
   }
 
   if (eventName === 'UserPromptSubmit') {
-    const prompt = promptText(payload);
-    await rememberQuestion(projectRoot, payload, prompt);
-    const guidance = formatDurableCaptureGuidance(prompt, { language: requestLanguage });
+    const storedPrompt = storagePromptText(prompt, requestLanguage);
+    await rememberQuestion(projectRoot, payload, storedPrompt, {
+      language: requestLanguage,
+      skipIfExisting: isSyntheticPlanPrompt(prompt),
+    });
+    const guidance = formatDurableCaptureGuidance(storedPrompt, { language: requestLanguage });
     const recovery = await consumeCompactRecoveryContext(projectRoot, payload).catch(() => '');
     const context = await hookContext(
       projectRoot,
       eventName,
-      [recovery, await buildContextBrief(projectRoot, eventName, prompt, { language: requestLanguage }), guidance].filter(Boolean).join('\n\n'),
+      [recovery, await buildContextBrief(projectRoot, eventName, storedPrompt, { language: requestLanguage }), guidance].filter(Boolean).join('\n\n'),
       payload,
       requestLanguage
     );
@@ -210,7 +225,10 @@ export async function handleHook(provider, explicitEvent) {
 
   if (eventName === 'Stop' || eventName === 'SubagentStop' || eventName === 'SessionEnd') {
     const assistantText = payload.last_assistant_message || payload.response || payload.assistant_response || '';
-    const entry = await buildEntryFromState(projectRoot, payload, assistantText);
+    const entry = {
+      ...await buildEntryFromState(projectRoot, payload, assistantText),
+      language: requestLanguage,
+    };
     if (isLegacyEagerCaptureMode()) {
       await handleLegacyEagerStop(projectRoot, eventName, payload, entry);
     } else {

package/src/language.js

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

package/src/live-qa.js

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

package/src/maintenance.js

@@ -11,7 +11,7 @@ export const MAINTENANCE_QUEUE_REL = 'llm-wiki/outputs/maintenance/queue.md';
 const DEFAULT_STALE_TURN_MS = 10 * 60 * 1000;
 const DEFAULT_STALE_PENDING_DAYS = 7;
 const DEFAULT_PENDING_LIMIT = 20;
-const DEFAULT_REVIEW_PENDING_LIMIT = 5;
+const DEFAULT_REVIEW_PENDING_LIMIT = 15;
 const DEFAULT_REVIEW_INTERVAL_DAYS = 14;
 const DEFAULT_LIFECYCLE_PENDING_THRESHOLD = 15;
 const DEFAULT_LOW_SIGNAL_SKIP_DAYS = 14;
@@ -27,10 +27,10 @@ function queueHeader() {
   return [
     '# LLM Wiki Maintenance Queue',
     '',
-    'Candidates to merge into durable wiki pages. Hooks only create candidates; the active agent reviews and merges them into existing durable wiki documents.',
+    'Candidates for batch durable wiki review. Hooks only create candidates; the active agent merges only explicit, repeated, or clearly reusable facts into existing durable wiki documents.',
     '',
     'Status values: pending, approved, done, skipped.',
-    'Lifecycle keeps explicit/high-signal candidates visible, may skip old low-signal candidates, and archives old reviewed items.',
+    'Lifecycle keeps candidates pending until batch review, may skip old low-signal candidates, and archives old reviewed items.',
     '',
   ].join('\n');
 }
@@ -70,6 +70,7 @@ function inferSignalLevelFromReason(reason, resultMissing = false) {
   if (resultMissing || text.includes('recovered from stale turn state')) return 'recovered';
   if (text.includes('explicit durable documentation request')) return 'explicit';
   if (text.includes('precompact durable candidate')) return 'high';
+  if (text.includes('structured durable conclusion')) return 'high';
   if (text.includes('suggested durable wiki candidate')) return 'high';
   if (text.includes('durable wiki review')) return 'high';
   return 'high';
@@ -293,29 +294,6 @@ export async function applyMaintenanceLifecycle(projectRoot, options = {}) {
     nextItems = nextItems.map((item) => {
       if (item.status !== 'pending') return item;
       const signal = signalLevelForItem(item);
-      if (signal === 'explicit' || signal === 'high') {
-        approvedByLifecycle += 1;
-        actions.push(lifecycleAction('approve', item, { reason: `pending threshold ${defaults.pendingThreshold} reached` }));
-        const target = item.target || item.suggested_target || '';
-        const reviewNote = sanitizeField('Auto-approved by lifecycle because the pending queue reached the review threshold.', 500);
-        return {
-          ...item,
-          status: 'approved',
-          signal_level: signal,
-          target,
-          reviewed_at: now,
-          last_seen_at: now,
-          review_note: item.review_note || reviewNote,
-          fields: {
-            ...(item.fields || {}),
-            signal_level: signal,
-            ...(target ? { target } : {}),
-            reviewed_at: now,
-            last_seen_at: now,
-            review_note: item.review_note || reviewNote,
-          },
-        };
-      }
       if (signal === 'low' && isStaleByDays(item, defaults.lowSignalSkipDays)) {
         skippedByLifecycle += 1;
         actions.push(lifecycleAction('skip', item, { reason: `low-signal item older than ${defaults.lowSignalSkipDays} days` }));
@@ -403,7 +381,7 @@ export function summarizeMaintenanceQueue(queue, options = {}) {
     .filter(Number.isFinite);
   const lastReviewMs = reviewTimes.length > 0 ? Math.max(...reviewTimes) : null;
   const reviewReasons = [];
-  if (approved.length > 0) reviewReasons.push(`approved queue has ${approved.length} item(s) ready for durable wiki merge`);
+  if (approved.length > 0) reviewReasons.push(`approved queue has ${approved.length} item(s) ready for manual durable wiki review`);
   if (pending.length >= reviewPendingLimit) reviewReasons.push(`pending queue has ${pending.length} items (threshold ${reviewPendingLimit})`);
   if (stalePending.length > 0) reviewReasons.push(`${stalePending.length} pending item(s) older than ${staleDays} days`);
   if (pending.some((item) => item.result_missing)) reviewReasons.push('pending recovered turn state needs review');
@@ -622,28 +600,30 @@ export async function recoverStaleTurnStates(projectRoot, options = {}) {
   return output;
 }
 
-function isDurablePromotionCandidate(item) {
-  if (item?.status === 'approved') return true;
+function isExplicitDurableCandidate(item) {
+  const signal = signalLevelForItem(item);
+  if (signal === 'explicit') return true;
   const text = `${item?.reason || ''} ${item?.fields?.reason || ''}`.toLowerCase();
-  return /suggested durable wiki candidate|precompact durable candidate|explicit durable documentation|durable wiki review/.test(text);
+  return /explicit durable documentation/.test(text);
 }
 
 function shouldSurfacePromptMaintenance(summary, query, reviewCandidates) {
   if (isMaintenanceRelatedQuery(query || '', reviewCandidates)) return true;
   if ((summary.approvedCount || 0) > 0) return true;
-  if (reviewCandidates.some(isDurablePromotionCandidate)) return true;
+  if (reviewCandidates.some(isExplicitDurableCandidate)) return true;
   if ((summary.pendingCount || 0) >= (summary.reviewPendingLimit || DEFAULT_REVIEW_PENDING_LIMIT)) return true;
-  if ((summary.stalePendingCount || 0) > 0) return true;
   return reviewCandidates.some((item) => item.result_missing);
 }
 
 export function formatMaintenanceContext(summary, options = {}) {
-  if (!summary.reviewDue) return '';
   const language = options.language === 'ko' ? 'ko' : 'en';
   const eventName = options.eventName || '';
   const defaultLimit = eventName === 'SessionStart' || eventName === 'InstructionsLoaded' ? 1 : 5;
   const limit = options.limit || defaultLimit;
   const reviewCandidates = [...(summary.approved || []), ...(summary.pending || [])];
+  const maintenancePrompt = eventName === 'UserPromptSubmit' &&
+    isMaintenanceRelatedQuery(options.query || '', reviewCandidates);
+  if (!summary.reviewDue && !maintenancePrompt) return '';
   let pending = reviewCandidates.slice(0, limit);
 
   if (eventName === 'UserPromptSubmit') {
@@ -654,16 +634,19 @@ export function formatMaintenanceContext(summary, options = {}) {
   }
 
   const reviewCount = (summary.approvedCount || 0) + (summary.pendingCount || 0);
+  const reviewDueText = summary.reviewDue
+    ? `yes (${(summary.reviewReasons || []).slice(0, 2).join('; ') || 'periodic review threshold met'})`
+    : 'no (maintenance prompt)';
   const lines = language === 'ko'
     ? [
         'LLM Wiki maintenance status:',
-        `- review due: yes (${(summary.reviewReasons || []).slice(0, 2).join('; ') || 'periodic review threshold met'}).`,
-        `- approved/pending review items: ${reviewCount}. 현재 요청이 우선이며, 관련 있거나 세션 종료 전 여유가 있으면 durable wiki에 병합하거나 skipped로 표시한다.`,
+        `- review due: ${reviewDueText}.`,
+        `- approved/pending review items: ${reviewCount}. 현재 요청이 우선이다. 후보는 충분히 쌓인 뒤 batch review에서 관련 항목만 durable wiki에 병합하고, 나머지는 skipped로 표시한다.`,
       ]
     : [
         'LLM Wiki maintenance status:',
-        `- review due: yes (${(summary.reviewReasons || []).slice(0, 2).join('; ') || 'periodic review threshold met'}).`,
-        `- approved/pending review items: ${reviewCount}. The current request comes first; when relevant or before ending the session, merge candidates into durable wiki pages or mark them skipped.`,
+        `- review due: ${reviewDueText}.`,
+        `- approved/pending review items: ${reviewCount}. The current request comes first. Review candidates in batches after enough have accumulated, merge only relevant durable facts, and mark the rest skipped.`,
       ];
   for (const item of pending) {
     const target = item.target || item.suggested_target;

package/src/project.js

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

package/src/state.js

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

package/src/templates.js

@@ -9,16 +9,16 @@ This repository uses llm-wiki-kit as a hook-first living Markdown wiki for Codex
 
 - This block supersedes older OMX/OMC/\`omx_wiki/\` LLM Wiki instructions for this repository.
 - Use Codex or Claude Code normally. Do not create a workflow where users must remember extra \`llm-wiki\` commands during ordinary work.
-- Language: respond in the user's current prompt language when it is clearly Korean or English. Keep technical identifiers, commands, paths, code, and original error text unchanged. If no prompt language is clear, follow local \`CLAUDE.md\`/\`AGENTS.md\` guidance, then fall back to English.
+- Language: respond in the user's current real prompt language when it is clearly Korean or English. Codex synthetic plan execution prompts such as \`Implement the plan.\` are neutral and should reuse the last real session language or project preference. Keep technical identifiers, commands, paths, code, and original error text unchanged. If no prompt language is clear, follow local \`CLAUDE.md\`/\`AGENTS.md\` guidance, then fall back to English.
 - Treat chat memory as temporary. Durable project knowledge belongs in repository Markdown under \`llm-wiki/\`.
 - \`llm-wiki/raw/\` is the immutable or redacted evidence layer. Do not modify raw captures except safe hook envelope append.
 - \`llm-wiki/wiki/\` is the curated knowledge layer managed by the agent. Put decisions, architecture, debugging findings, concepts, procedures, and context there.
 - Keep \`llm-wiki/wiki/memory.md\` short. Link to important documents instead of copying long explanations.
 - Use hook-injected context when helpful, but answer the current user request first. Use \`llm-wiki context\`, \`llm-wiki lint\`, and \`llm-wiki consolidate\` only as agent maintenance helpers.
 - Hooks safely store redacted raw envelopes and work/decision-focused live Q&A. Simple answers, status checks, and keyword-only turns should not be promoted to live Q&A or durable wiki by default.
-- Hooks may queue durable cleanup candidates in \`llm-wiki/outputs/maintenance/queue.md\` at stop/start boundaries. Session-start lifecycle may move explicit/high-signal candidates to \`approved\`, skip stale low-signal candidates, and archive old reviewed items, but it never creates durable wiki pages automatically. Treat maintenance as a soft agent-side reminder; merge surfaced candidates when relevant or before ending the session, then mark them \`done\` or \`skipped\`.
+- Hooks may queue durable cleanup candidates in \`llm-wiki/outputs/maintenance/queue.md\` at stop/start boundaries. Lifecycle keeps candidates pending for batch review, skips stale low-signal candidates, and archives old reviewed items, but it never creates durable wiki pages automatically. Treat maintenance as a soft agent-side reminder; merge only explicit, repeated, or clearly reusable facts after enough candidates accumulate, then mark items \`done\` or \`skipped\`.
 - Before creating new wiki pages, search existing pages and update the right one when possible. Reusable facts should not stay only in chunked \`outputs/questions/\`.
-- Store one-off work or decision records in \`llm-wiki/outputs/questions/YYYY-MM-DD/live-qa-001.md\` when needed. Merge reusable knowledge into \`wiki/architecture/\`, \`wiki/debugging/\`, \`wiki/decisions/\`, \`wiki/concepts/\`, or \`procedures/\` when approved, hook-suggested, or clearly important.
+- Store one-off work or decision records in \`llm-wiki/outputs/questions/YYYY-MM-DD/live-qa-001.md\` when needed. Merge reusable knowledge into \`wiki/architecture/\`, \`wiki/debugging/\`, \`wiki/decisions/\`, \`wiki/concepts/\`, or \`procedures/\` only when explicitly requested, repeated across related candidates, or clearly important.
 - Record verification commands, evidence files, and uncertainty. Mark inference explicitly and preserve contradictions in Open Questions or Contradictions.
 - Never store credentials, tokens, passwords, private keys, or raw \`.env\` contents. Store only redacted summaries when needed.
 
@@ -46,7 +46,8 @@ The user should not need to run many \`llm-wiki\` commands manually. The agent c
 These rules replace older OMX/OMC/\`omx_wiki/\` rules for this project.
 
 ## Language
-- Follow the user's current prompt language when it is clearly Korean or English.
+- Follow the user's current real prompt language when it is clearly Korean or English.
+- Treat Codex synthetic plan execution prompts such as \`Implement the plan.\` as neutral; reuse the last real session language or project preference when available.
 - If no current prompt language is clear, follow local \`CLAUDE.md\`/\`AGENTS.md\` guidance, then fall back to English.
 - Keep commands, paths, code identifiers, API names, package names, logs, and original error text unchanged.
 - Korean and English users should both be able to use Codex/Claude Code naturally without changing \`llm-wiki\` commands.
@@ -64,10 +65,10 @@ These rules replace older OMX/OMC/\`omx_wiki/\` rules for this project.
 - Important claims should include at least one of: \`source_ids\`, file paths, or verification commands.
 - When durable knowledge appears, search existing \`wiki/\` pages before creating a new page.
 - Do not promote simple answers, status checks, keyword-only replies, or one-off chat into live Q&A, \`wiki/queries\`, or maintenance.
-- Hooks may flag work/decision turns as durable wiki candidates when they contain reusable architecture, debugging, policy, procedure, or decision signals. Treat those as review prompts, not automatic page creation.
-- Merge reusable knowledge into \`wiki/architecture/\`, \`wiki/debugging/\`, \`wiki/decisions/\`, \`wiki/concepts/\`, or \`procedures/\` based on importance, hook suggestions, and user consent flow.
-- Review \`outputs/maintenance/queue.md\` pending or approved items when surfaced by hook context, related to the current request, or review is due. Merge into existing durable wiki pages, then mark items \`done\` or \`skipped\`.
-- Periodic maintenance is agent review, not automatic page creation. Session-start lifecycle may approve explicit/high-signal items, skip stale low-signal items, and archive old reviewed items. Show only short reminders at \`SessionStart\`/\`InstructionsLoaded\`, and compact prompt-time reminders when durable candidates or review thresholds need agent attention.
+- Hooks may flag explicit documentation requests, structured conclusions, and recovered work as durable wiki candidates. Treat those as batch review prompts, not automatic page creation.
+- Merge reusable knowledge into \`wiki/architecture/\`, \`wiki/debugging/\`, \`wiki/decisions/\`, \`wiki/concepts/\`, or \`procedures/\` only when explicitly requested, repeated across related candidates, or clearly important.
+- Review \`outputs/maintenance/queue.md\` pending or approved items when surfaced by hook context, related to the current request, or review is due. Batch related candidates, merge only durable reusable facts into existing wiki pages, then mark items \`done\` or \`skipped\`.
+- Periodic maintenance is agent review, not automatic page creation. Session-start lifecycle keeps candidates pending for batch review, skips stale low-signal items, and archives old reviewed items. Show only short reminders at \`SessionStart\`/\`InstructionsLoaded\`, and compact prompt-time reminders only for explicit documentation, recovered state, maintenance prompts, or batch review thresholds.
 - Keep \`wiki/memory.md\` short. Use links to current state and important documents instead of long explanations.
 - Preserve contradictions in \`Contradictions\` or \`Open Questions\`; do not overwrite them silently.
 - Do not store credentials, tokens, passwords, private keys, or raw \`.env\` contents in wiki.
@@ -106,7 +107,7 @@ superseded_by: []
 - query: use hook-injected context when useful, but answer the current request first. Manual commands are diagnostics, not required daily workflow.
 - lint: agent helper for user-requested or wiki maintenance work. Do not run it every turn.
 - consolidate: safely refresh generated blocks in \`memory.md\`/\`index.md\`. Do not overwrite handwritten sections or curated document bodies.
-- maintenance: \`outputs/maintenance/queue.md\` stores stop/start cleanup candidates. Review surfaced durable candidates without delaying the current user request, then mark them \`done\` or \`skipped\`. Use \`llm-wiki maintenance --workspace <project> --apply-lifecycle --dry-run\` when queue hygiene needs inspection.
+- maintenance: \`outputs/maintenance/queue.md\` stores stop/start cleanup candidates. Review surfaced durable candidates in batches without delaying the current user request, merge only durable reusable facts, then mark items \`done\` or \`skipped\`. Use \`llm-wiki maintenance --workspace <project> --apply-lifecycle --dry-run\` when queue hygiene needs inspection.
 `;
 }
 
@@ -199,7 +200,7 @@ export function procedure(name) {
 3. Create or update \`wiki/sources/<slug>.md\` only when a source summary is useful.
 4. Before creating a new page, look for related concept/entity/decision/architecture/debugging/context pages and update those first.
 5. Do not create duplicates. Merge facts into existing pages when they already exist.
-6. Do not promote simple answers or one-off chat into durable wiki, but do review hook-suggested durable candidates for reusable facts.
+6. Do not promote simple answers or one-off chat into durable wiki. Let queued candidates accumulate for batch review unless the user explicitly requested documentation.
 7. Important claims should record source references, confidence, memory type, importance, and verification status.
 8. When durable entry points change, update \`wiki/memory.md\` briefly or use \`llm-wiki consolidate\`.
 9. Add a short entry to \`wiki/log.md\` for meaningful wiki changes.
@@ -212,8 +213,8 @@ export function procedure(name) {
 4. Inspect raw sources only when exact evidence matters.
 5. Separate verified facts from inference.
 6. Use \`llm-wiki context "<query>"\` only when manual inspection is useful. Add \`--include-episodic\` only for historical query/context pages, and \`--include-archived\` only for archived/superseded pages.
-7. Do not promote one-off answers, status checks, or keyword-only replies to durable wiki or live Q&A. Archive only work turns with tool evidence, changed-file evidence, verification, structured decision/debugging conclusions, or hook-suggested durable candidates.
-8. Merge reusable facts into \`wiki/architecture/\`, \`wiki/debugging/\`, \`wiki/decisions/\`, \`wiki/concepts/\`, or \`procedures/\` based on importance, hook suggestions, and user consent flow.
+7. Do not promote one-off answers, status checks, or keyword-only replies to durable wiki or live Q&A. Archive work turns with tool evidence, changed-file evidence, verification, structured decision/debugging conclusions, or explicit durable requests.
+8. Merge reusable facts into \`wiki/architecture/\`, \`wiki/debugging/\`, \`wiki/decisions/\`, \`wiki/concepts/\`, or \`procedures/\` only when explicitly requested, repeated across related candidates, or clearly important.
 `,
     'lint.md': `# Lint Procedure
 
@@ -226,7 +227,7 @@ Periodic maintenance is an agent-side task, not a per-turn user command. When ne
 1. \`llm-wiki lint --workspace <project>\`
 2. \`llm-wiki maintenance --workspace <project>\`
 3. \`llm-wiki maintenance --workspace <project> --apply-lifecycle --dry-run\`
-4. Merge pending, approved, or hook-suggested durable candidates into existing durable pages when appropriate, then mark them \`done\` or \`skipped\`.
+4. Review pending or approved durable candidates in batches; merge only explicit, repeated, or clearly reusable facts into existing durable pages, then mark items \`done\` or \`skipped\`.
 5. \`llm-wiki consolidate --workspace <project> --dry-run\`
 6. Run \`llm-wiki consolidate --workspace <project>\` when the dry run is acceptable.
 

package/src/wiki-search.js

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