llm-wiki-kit 0.2.6 → 0.2.8

package/README.md

@@ -86,10 +86,11 @@ Use Claude Code or Codex normally.
 
 The installed hooks:
 
-- inject `wiki/memory.md`, `wiki/index.md`, and relevant wiki context at session start, instructions loaded, prompt submit, and post-compact time
+- inject functional compact context at session start, instructions loaded, prompt submit, and post-compact time. The hook still uses `wiki/memory.md`, `wiki/index.md`, relevant wiki search results, maintenance signals, and update status; it formats only the useful parts so user-visible hook context does not look like a raw debug dump.
 - remove Codex-facing legacy `oh-my-codex:wiki`/`omx_wiki` surfaces at session start so `llm-wiki/` remains the active wiki implementation
 - record small redacted raw event envelopes and per-turn state
 - capture decision points, debugging findings, changed files, and verification notes
+- before compaction, classify the current turn and save a redacted checkpoint for meaningful or durable work; durable candidates also get a maintenance queue item
 - allow tool calls to proceed without secret/PII-based hook blocking
 - update `llm-wiki/outputs/questions/YYYY-MM-DD-live-qa.md` only for meaningful work turns
 - avoid automatic `wiki/queries/` and `wiki/decisions/` promotion in the default answer-first mode
@@ -100,6 +101,7 @@ The installed hooks:
 
 If you need to think about saving every answer manually, the setup has failed.
 If wiki maintenance delays the actual answer, the setup is being used wrong. The default capture mode is `LLM_WIKI_KIT_CAPTURE_MODE=answer-first`; the old eager query/decision capture path remains only as deprecated compatibility mode via `LLM_WIKI_KIT_CAPTURE_MODE=legacy-eager`.
+Pre-compact preservation uses `LLM_WIKI_KIT_PRECOMPACT_ENFORCEMENT=limited|soft|off` with default `limited`. It reads only a bounded transcript tail controlled by `LLM_WIKI_KIT_PRECOMPACT_TRANSCRIPT_TAIL_BYTES`; the raw transcript path and authentication values are redacted before any checkpoint is written.
 
 ## Operational Commands
 
@@ -119,11 +121,11 @@ Most users should not need these during daily Claude Code/Codex work. They exist
 
 `llm-wiki update` upgrades the global npm package when npm has a newer target, reinstalls the hook entries, and reapplies safe managed template updates across known project roots. If the installed runtime already satisfies the registry target, it skips `npm install -g` and still runs post-update maintenance. Use `--current-only` when you intentionally want to update only the supplied workspace. Existing wiki content is not overwritten. The command prints step progress to stderr, including registry lookup, npm install, post-update, and project discovery. Use `--timeout-ms <ms>` to bound external commands and `--max-dirs <n>` to bound project discovery under large or slow roots such as WSL `/mnt/*` trees.
 
-Installed npm runtimes also perform a cached update notice check from hooks while the user works. This does not install anything automatically. When a newer npm release is detected, the injected hook context gives the active agent a Korean update reminder and tells it to offer `llm-wiki update --workspace <project-or-search-root>`. The cache is scoped to the npm command used for lookup so test/fake npm checks do not leak into normal hook sessions. Set `LLM_WIKI_KIT_UPDATE_NOTICE=0` only when diagnosing or suppressing that reminder.
+Installed npm runtimes also perform a cached update notice check from hooks while the user works. This does not install anything automatically. When a newer npm release is detected, Codex and Claude receive the same passive runtime update status in hook context: current runtime, npm registry target, and the manual command to use when the user asks for update or maintenance work. It is not an instruction to interrupt the current answer or to sell the update to the user. The cache is scoped to the npm command used for lookup so test/fake npm checks do not leak into normal hook sessions. Set `LLM_WIKI_KIT_UPDATE_NOTICE=0` only when diagnosing or suppressing that status block.
 
 `llm-wiki post-update --workspace <project>` reapplies the current runtime's hook entries and safe managed template updates without running `npm install -g`. Use `post-update --all --workspace <search-root>` to reapply templates across discovered project roots.
 
-`llm-wiki context "<query>"` prints the same layered context used by hooks. It is mainly for debugging what Codex/Claude Code will see; daily use should rely on hook injection. By default, episodic `wiki/queries/` pages are excluded from search unless they were promoted with `memory_type: semantic` or `procedural` and `importance >= 4`; use `--include-episodic` only when debugging old automatic query records.
+`llm-wiki context "<query>"` prints the full debug view of the layered context sources used by hooks. Hook injection may render those sources as functional compact context for Codex and Claude, but this CLI stays verbose so maintainers can inspect retrieval, snippets, memory, index, and expansion behavior. Daily use should rely on hook injection. By default, episodic `wiki/queries/` pages are excluded from search unless they were promoted with `memory_type: semantic` or `procedural` and `importance >= 4`; use `--include-episodic` only when debugging old automatic query records.
 
 `llm-wiki lint` checks wiki health and detects outdated managed rules from older kit versions. Agents may use it before/after meaningful wiki maintenance.
 
@@ -171,6 +173,7 @@ llm-wiki hook claude Stop
 ## Security Defaults
 
 - Full raw transcript capture is disabled by default.
+- PreCompact may read a small bounded transcript tail to create a redacted checkpoint, but it does not store the full transcript or raw `transcript_path`.
 - Tool calls are not blocked only because inputs look sensitive.
 - Authentication values such as tokens, passwords, and private keys are redacted before durable summaries are written.
 - Hook payloads are stored only as redacted event envelopes.

package/docs/integrations/claude-code.md

@@ -42,13 +42,14 @@ 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`, performs a cached npm update notice check for npm installs, then injects `llm-wiki/wiki/memory.md`, `llm-wiki/wiki/index.md`, recent log context, operating rules, a one-item maintenance summary when needed, any Korean update notice, and any maintenance note for outdated or customized managed rules. 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 context set. Update notice cache is scoped by npm command, and maintenance reminders are shown only when the prompt is wiki/maintenance related or matches a queue topic.
+At `SessionStart`/`InstructionsLoaded`, the hook first attempts a safe managed-template refresh, recovers stale turn state into `outputs/maintenance/queue.md`, performs a cached npm update notice check for npm installs, then injects functional compact context. The context still uses `llm-wiki/wiki/memory.md`, `llm-wiki/wiki/index.md`, relevant wiki/search state, operating rules, maintenance signals, passive runtime update status, and managed-template cleanup notes; the hook formats those signals so they are usable if shown in the Claude Code UI. At `UserPromptSubmit`, it recovers stale turn state, searches wiki pages with MiniSearch or substring fallback, expands one-hop wikilinks, redacts context fields, performs the same cached update notice check, and injects the smallest useful functional compact context set. Update notice cache is scoped by npm command, and maintenance reminders are shown only when the prompt is wiki/maintenance related or matches a queue topic.
 
-`PostToolUse` and `PostToolBatch` record redacted tool summaries in the same turn buffer. `PreCompact` records a compaction note, and `PostCompact` records the note and returns fresh wiki context. In the default `answer-first` mode, `SubagentStop` does not create live Q&A, query, decision, or maintenance files. `Stop` and `SessionEnd` append live Q&A only for meaningful work turns and do not auto-create `wiki/queries/` or `wiki/decisions/`. If the user explicitly asked to record or document durable knowledge and no durable wiki update is detected, `Stop`/`SessionEnd` queue a pending maintenance item for agent review. `Stop` and `SessionEnd` then clear the per-session turn buffer; `SubagentStop` does not.
+`PostToolUse` and `PostToolBatch` record redacted tool summaries in the same turn buffer. `PreCompact` classifies the current turn before compaction: simple turns record only a context note, meaningful work writes a live Q&A checkpoint, and durable candidates write both a checkpoint and a maintenance queue item. The checkpoint can include only a bounded redacted transcript tail, never the full raw transcript or raw `transcript_path`. `PostCompact` stores the redacted compact summary as a context note and returns fresh wiki context. In the default `answer-first` mode, `SubagentStop` does not create live Q&A, query, decision, or maintenance files. `Stop` and `SessionEnd` append live Q&A only for meaningful work turns and do not auto-create `wiki/queries/` or `wiki/decisions/`. If the user explicitly asked to record or document durable knowledge and no durable wiki update is detected, `Stop`/`SessionEnd` queue a pending maintenance item for agent review. `Stop` and `SessionEnd` then clear the per-session turn buffer; `SubagentStop` does not.
 
 Set `LLM_WIKI_KIT_AUTO_PROJECT_UPDATE=0` only while diagnosing automatic managed-template refresh behavior.
-Set `LLM_WIKI_KIT_UPDATE_NOTICE=0` only while suppressing the cached npm update reminder.
+Set `LLM_WIKI_KIT_UPDATE_NOTICE=0` only while suppressing the cached passive runtime update status.
 Set `LLM_WIKI_KIT_CAPTURE_MODE=legacy-eager` only as deprecated compatibility mode for the old eager query/decision capture behavior.
+Set `LLM_WIKI_KIT_PRECOMPACT_ENFORCEMENT=limited|soft|off` to tune pre-compact failure handling; default `limited` blocks only when checkpoint/queue preservation fails on providers with block support. `LLM_WIKI_KIT_PRECOMPACT_TRANSCRIPT_TAIL_BYTES` controls the bounded tail size.
 
 After installation or update, run:
 

package/docs/integrations/codex.md

@@ -29,20 +29,22 @@ 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`, performs a cached npm update notice check for npm installs, then injects `llm-wiki/wiki/memory.md`, `llm-wiki/wiki/index.md`, recent log context, operating rules, a one-item maintenance summary when needed, any Korean update notice, and any maintenance note for outdated or customized managed rules.
-- `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 context set. Update notice cache is scoped by npm command, and maintenance reminders are shown only when the prompt is wiki/maintenance related or matches a queue topic.
+- `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`, 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. Update notice cache is scoped by npm command, and maintenance reminders are shown only when the prompt is wiki/maintenance related or matches a queue topic.
 - `PreToolUse` records redacted tool summaries without blocking tool calls.
 - `PostToolUse` records redacted tool summaries in a turn buffer.
-- `PreCompact` records a compaction note; `PostCompact` records the note and returns fresh wiki context.
+- `PreCompact` classifies the current turn before compaction. Simple turns record only a context note; meaningful work writes a live Q&A checkpoint; durable candidates write both a checkpoint and a maintenance queue item. The checkpoint can include only a bounded redacted transcript tail, never the full raw transcript or raw `transcript_path`.
+- `PostCompact` stores the redacted compact summary as a context note and returns fresh wiki context.
 - In the default `answer-first` mode, `SubagentStop` does not create live Q&A, query, decision, or maintenance files. `Stop` appends live Q&A only for meaningful work turns and does not auto-create `wiki/queries/` or `wiki/decisions/`.
 - If the user explicitly asked to record or document durable knowledge and no durable wiki update is detected, `Stop` queues a pending maintenance item for agent review.
 - `Stop` clears the per-session turn buffer after recording. `SubagentStop` leaves the parent turn buffer available for the final stop event.
 
-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.
+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.
 
 Set `LLM_WIKI_KIT_AUTO_PROJECT_UPDATE=0` only while diagnosing automatic managed-template refresh behavior.
-Set `LLM_WIKI_KIT_UPDATE_NOTICE=0` only while suppressing the cached npm update reminder.
+Set `LLM_WIKI_KIT_UPDATE_NOTICE=0` only while suppressing the cached passive runtime update status.
 Set `LLM_WIKI_KIT_CAPTURE_MODE=legacy-eager` only as deprecated compatibility mode for the old eager query/decision capture behavior.
+Set `LLM_WIKI_KIT_PRECOMPACT_ENFORCEMENT=limited|soft|off` to tune pre-compact failure handling; default `limited` blocks only on supported providers when checkpoint/queue preservation fails. `LLM_WIKI_KIT_PRECOMPACT_TRANSCRIPT_TAIL_BYTES` controls the bounded tail size.
 
 Run these after install:
 

package/docs/manual.md

@@ -50,7 +50,7 @@ llm-wiki/
 └── procedures/
 ```
 
-`wiki/memory.md`는 hook context에 들어가는 짧은 hot index다. 긴 설명을 복사하지 말고 중요한 entry point만 둔다.
+`wiki/memory.md`는 hook context에 들어가는 짧은 hot index다. hook은 기능을 유지하되 사용자 화면에 보일 수 있는 부분을 functional compact context로 정제하므로, 긴 설명을 복사하지 말고 중요한 entry point만 둔다.
 
 `wiki/index.md`는 wiki 전체의 navigation map이다. agent는 넓은 질문을 받으면 여기와 `memory.md`에서 시작한다.
 
@@ -62,7 +62,8 @@ llm-wiki/
 
 설치된 hook은 다음 일을 자동으로 수행한다.
 
-- session start, prompt submit, post compact 시점에 `wiki/memory.md`, `wiki/index.md`, 관련 wiki 검색 결과를 context로 주입한다.
+- session start, prompt submit, post compact 시점에 functional compact context를 주입한다. `wiki/memory.md`, `wiki/index.md`, 관련 wiki 검색 결과, maintenance signal, update status는 계속 사용하되 사용자 화면에 보일 수 있는 hook context는 필요한 정보 중심으로 정제한다.
+- pre compact 시점에는 현재 turn을 분류하고, simple turn은 context note만 남기며, meaningful/durable turn은 redacted live Q&A checkpoint와 필요한 maintenance queue 후보를 남긴다.
 - prompt/tool/result summary를 redaction한 뒤 turn buffer에 기록한다.
 - 의미 있는 작업 turn만 `outputs/questions/YYYY-MM-DD-live-qa.md`에 live Q&A로 남긴다.
 - 기본 answer-first mode에서는 `wiki/queries/`와 `wiki/decisions/`를 매 turn 자동 생성하지 않는다.
@@ -71,6 +72,8 @@ llm-wiki/
 - 새 runtime이 오래된 project rules/templates를 발견하면 안전하게 갱신 가능한 managed file만 refresh한다.
 - `SessionStart`/`InstructionsLoaded`에서 Codex-facing legacy `oh-my-codex:wiki`/`omx_wiki` 설정과 스킬 표면이 되살아났는지 확인하고 제거한다. wiki 기능은 `llm-wiki/`가 단일 활성 구현이다.
 
+hook UX 정책은 기능 보존이 우선이다. Codex와 Claude Code 모두 같은 기능 신호를 받으며, 차이는 raw dump가 아니라 읽기 쉬운 functional compact formatting으로 보여주는 것이다.
+
 매번 저장 여부를 사용자가 고민해야 한다면 잘못 쓰고 있는 것이다. 답변보다 wiki maintenance가 먼저 오면 안 된다. 현재 사용자 요청을 먼저 처리하고, 오래 쓸 지식만 필요한 만큼 정리한다.
 
 ## Capture Modes
@@ -161,7 +164,7 @@ llm-wiki update --workspace /path/to/search-root --timeout-ms 120000 --max-dirs
 
 `update`는 source checkout에서 self-update하지 않는다. source checkout 개발 중에는 npm package나 local tarball로 global install한 뒤 update behavior를 테스트한다.
 
-global npm runtime으로 설치된 경우 hook은 사용 흐름 중 cached update notice check를 수행한다. 자동 설치는 하지 않는다. 새 npm release가 감지되면 hook context가 active agent에게 한국어로 “업데이트 가능”을 짧게 알리고 `llm-wiki update --workspace <project-or-search-root>` 실행을 제안하게 한다. cache는 lookup에 사용한 npm command별로 분리되어 test/fake npm 결과가 일반 hook session에 섞이지 않는다. `LLM_WIKI_KIT_UPDATE_NOTICE=0`으로 이 reminder만 끌 수 있다.
+global npm runtime으로 설치된 경우 hook은 사용 흐름 중 cached update notice check를 수행한다. 자동 설치는 하지 않는다. 새 npm release가 감지되면 hook context에는 passive runtime update status가 들어간다. 이 block은 현재 runtime, npm registry target, 업데이트/정비 요청이 있을 때 쓸 수 있는 `llm-wiki update --workspace <project-or-search-root>` 명령을 짧게 보여주는 상태 정보다. 현재 답변을 중단하거나 업데이트 권유를 하라는 지시문이 아니다. cache는 lookup에 사용한 npm command별로 분리되어 test/fake npm 결과가 일반 hook session에 섞이지 않는다. `LLM_WIKI_KIT_UPDATE_NOTICE=0`으로 이 status block만 끌 수 있다.
 
 ### `llm-wiki post-update`
 
@@ -260,7 +263,7 @@ older OMX/OMC/`omx_wiki/` material은 migration input일 뿐이다. 현재 proje
 
 ### `llm-wiki context`
 
-hook이 주입하는 layered context를 수동으로 확인한다.
+hook이 사용하는 layered context source를 full debug 형태로 수동 확인한다. Codex/Claude hook은 같은 source를 functional compact context로 정제해 주입할 수 있지만, 이 CLI는 retrieval과 formatting 문제를 점검할 수 있도록 verbose debug 출력을 유지한다.
 
 ```bash
 llm-wiki context "auth architecture" --workspace /path/to/project
@@ -382,7 +385,11 @@ Claude Code handled events:
 - `Stop`
 - `SessionEnd`
 
-Hook payload는 full transcript가 아니라 작은 redacted event envelope다. context output도 field별 redaction을 거친다.
+Hook payload는 full transcript가 아니라 작은 redacted event envelope다. context output도 field별 redaction을 거친다. `PreCompact`는 checkpoint 생성을 위해 작은 bounded transcript tail만 읽을 수 있고, 저장 전 인증값과 raw `transcript_path`를 redaction한다.
+
+Context를 반환하는 Codex/Claude hook event는 기능을 제거하지 않는다. memory hot index, navigation index, relevant wiki hits, link expansion, maintenance signal, passive runtime update status를 계속 사용할 수 있고, 사용자 화면에 보일 수 있는 `additionalContext`만 functional compact context로 정제한다. `llm-wiki context` CLI의 full debug 출력은 이 hook formatting 정책과 별도로 유지한다.
+
+Pre-compact 보존은 기본 `LLM_WIKI_KIT_PRECOMPACT_ENFORCEMENT=limited`로 동작한다. `limited`는 checkpoint/queue 저장 실패 시 block을 지원하는 provider에서만 compact block을 시도하고, 그 외에는 failure context를 남긴다. `soft`는 block하지 않고, `off`는 실패 output을 억제한다. `LLM_WIKI_KIT_PRECOMPACT_TRANSCRIPT_TAIL_BYTES`로 transcript tail byte 한도를 조정한다.
 
 ## Security Defaults
 
@@ -392,6 +399,7 @@ Hook payload는 full transcript가 아니라 작은 redacted event envelope다.
 - token, password, bearer credential, private key, `.env` 원문 같은 authentication value는 durable summary에 쓰기 전 redaction한다.
 - phone number, email, date, business identifier는 local work context로 유용할 수 있어 기본 보존한다.
 - full raw transcript capture는 기본 기능이 아니다.
+- `PreCompact` checkpoint는 bounded redacted transcript tail만 사용할 수 있으며 full transcript와 raw `transcript_path`는 저장하지 않는다.
 - `llm-wiki lint`는 wiki 안의 secret-like content를 error로 보고한다.
 
 민감한 raw command output, log, screenshot, transcript를 저장해야 할 때는 먼저 redaction한다. 인증값은 wiki, report, live Q&A, command history에 남기지 않는다.

package/docs/operations.md

@@ -118,7 +118,7 @@ llm-wiki maintenance --workspace /path/to/project
 
 `update --check [--to <version-or-tag>]` is online and asks npm for the target version. It reports `update available` only when that registry target is newer than the installed version, so it does not suggest downgrades.
 
-Installed npm runtimes also run a cached hook-side update notice check while the user works. It never installs automatically. If npm has a newer release, `SessionStart`/`InstructionsLoaded`/`UserPromptSubmit` context gives the active agent a Korean update reminder and tells it to offer `llm-wiki update --workspace <project-or-search-root>`. The cache is scoped to the npm command used for lookup so test/fake npm checks do not leak into normal hook sessions. Set `LLM_WIKI_KIT_UPDATE_NOTICE=0` to suppress this reminder while diagnosing.
+Installed npm runtimes also run a cached hook-side update notice check while the user works. It never installs automatically. If npm has a newer release, `SessionStart`/`InstructionsLoaded`/`UserPromptSubmit` context includes a passive runtime update status for both Codex and Claude: current runtime, npm registry target, and the manual `llm-wiki update --workspace <project-or-search-root>` command to use when the user asks for update or maintenance work. It is not an active instruction to interrupt the current answer or tell the user to update. The cache is scoped to the npm command used for lookup so test/fake npm checks do not leak into normal hook sessions. Set `LLM_WIKI_KIT_UPDATE_NOTICE=0` to suppress this status block while diagnosing.
 
 `projects --workspace <search-root>` lists discovered project roots that have `llm-wiki/.kit-state.json` or an older `llm-wiki/wiki/index.md`, reports whether their managed templates are current, and prints the update commands for the search root.
 
@@ -141,13 +141,15 @@ After a plain `npm install -g llm-wiki-kit@latest`, existing hooks keep working
 
 ## Context And Wiki Maintenance
 
-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.
+Daily use should be Claude Code/Codex first. The user should not need to run a chain of `llm-wiki` commands while working. Hooks inject context automatically, but the current user answer takes priority over wiki cleanup. The active agent updates durable wiki pages when reusable project knowledge appears and the turn's importance or user consent justifies persistence. Hook context policy is function-first: memory, search, maintenance, and update signals remain available, while user-visible context is formatted as functional compact context instead of a raw dump.
 
-In the default `LLM_WIKI_KIT_CAPTURE_MODE=answer-first` mode, `Stop` and `SessionEnd` append live Q&A only for meaningful work turns. They do not auto-create `wiki/queries/` or `wiki/decisions/`. If the user explicitly asked for recording/documentation and no durable wiki update is detected, a pending cleanup candidate is written to `llm-wiki/outputs/maintenance/queue.md`. `SessionStart` and `UserPromptSubmit` also recover stale per-turn state into the same queue when the previous stop hook did not complete. `SessionStart` injects a one-item queue summary; `UserPromptSubmit` injects a soft reminder only when the prompt is wiki/maintenance related or matches a queue topic. This is a recovery and reminder layer, not a full transcript capture path.
+In the default `LLM_WIKI_KIT_CAPTURE_MODE=answer-first` mode, `Stop` and `SessionEnd` append live Q&A only for meaningful work turns. They do not auto-create `wiki/queries/` or `wiki/decisions/`. If the user explicitly asked for recording/documentation and no durable wiki update is detected, a pending cleanup candidate is written to `llm-wiki/outputs/maintenance/queue.md`. `PreCompact` performs the same answer-first classification before context compaction: simple turns get only a context note, archive-worthy turns get a live Q&A checkpoint, and durable candidates get a checkpoint plus queue item. `SessionStart` and `UserPromptSubmit` also recover stale per-turn state into the same queue when the previous stop hook did not complete. `SessionStart` injects a one-item queue summary; `UserPromptSubmit` injects a soft reminder only when the prompt is wiki/maintenance related or matches a queue topic. This is a recovery and reminder layer, not a full transcript capture path.
+
+Pre-compact preservation defaults to `LLM_WIKI_KIT_PRECOMPACT_ENFORCEMENT=limited`. In that mode, checkpoint/queue write failures can block compact only on providers that support hook blocking; otherwise the hook returns best-effort failure context. `soft` never blocks, and `off` suppresses failure output. `LLM_WIKI_KIT_PRECOMPACT_TRANSCRIPT_TAIL_BYTES` controls the small bounded transcript tail used for checkpoint context. Authentication values and the raw transcript path are redacted before storage.
 
 `LLM_WIKI_KIT_CAPTURE_MODE=legacy-eager` keeps the old eager live Q&A/query/decision/maintenance behavior for compatibility only. New projects should rely on the answer-first default.
 
-`llm-wiki context "<query>"` is the manual debug form of hook context injection. It reads:
+`llm-wiki context "<query>"` is the manual full-debug form of the context sources used by hook injection. Hook output for Codex and Claude may be functionally compact, but this command remains verbose so maintainers can inspect all source layers. It reads:
 
 - `llm-wiki/wiki/memory.md` as the short hot index
 - `llm-wiki/wiki/index.md` as the navigation map

package/docs/security.md

@@ -13,4 +13,4 @@ Before writing durable summaries, the runtime redacts authentication values such
 
 Manual and hook context output also runs through redaction before returning excerpts or search hits. `llm-wiki lint` reports remaining secret-like wiki content as an error so it can be removed or rewritten before it becomes reusable project memory.
 
-Hook payloads are stored as small event envelopes, not full raw transcripts. Full transcript capture is intentionally not implemented as a default. If a project needs it, add a project-local policy and a redaction path first.
+Hook payloads are stored as small event envelopes, not full raw transcripts. Full transcript capture is intentionally not implemented as a default. `PreCompact` may read a small bounded transcript tail for a redacted checkpoint, but it does not store the raw transcript path or full transcript. If a project needs raw transcript capture, add a project-local policy and a redaction path first.

package/docs/troubleshooting.md

@@ -242,7 +242,7 @@ If the queue is always empty during ordinary Q&A, that is normal. If you expecte
 
 The hook does not block tool calls only because inputs look sensitive. Durable summaries redact authentication values before writing, while ordinary work context such as dates, phone numbers, emails, and business identifiers is preserved by default.
 
-Hook payloads are stored as small redacted event envelopes rather than full transcripts. Manual and hook context output is redacted before wiki excerpts or search hits are returned.
+Hook payloads are stored as small redacted event envelopes rather than full transcripts. `PreCompact` checkpoints may include a bounded redacted transcript tail, but the full transcript and raw `transcript_path` are not stored. Manual and hook context output is redacted before wiki excerpts or search hits are returned.
 
 ## Duplicate Pages Appear
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-wiki-kit",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "Hook-first living LLM Wiki runtime for Codex and Claude Code.",
   "type": "module",
   "files": [

package/src/capture-policy.js

@@ -153,12 +153,5 @@ export function formatDurableCaptureGuidance(query) {
       '- 새 문서는 관련 기존 문서가 없을 때만 만들고, credentials/private data는 저장하지 않는다.',
     ].join('\n');
   }
-  if (hasDurableKeyword(text)) {
-    return [
-      'LLM Wiki 저장 후보 알림:',
-      '- 현재 답변을 먼저 한다.',
-      '- 다음 세션에도 재사용할 만한 내용(결정, 정책, 디버깅 결과, 운영 절차, 검증된 상태 등)이 있으면 답변 끝에서 짧게 wiki 문서화 여부를 물어본다.',
-    ].join('\n');
-  }
   return '';
 }

package/src/compact-capture.js

@@ -0,0 +1,214 @@
+import { open, stat } from 'fs/promises';
+import { relative } from 'path';
+import { classifyTurn } from './capture-policy.js';
+import { recordMaintenanceForEntry } from './maintenance.js';
+import { appendContextNote, appendLiveQa, appendWikiLog } from './project.js';
+import { redactText, summarizeForStorage } from './redaction.js';
+import { buildEntryFromState } from './state.js';
+
+const DEFAULT_PRECOMPACT_TAIL_BYTES = 32 * 1024;
+const MAX_PRECOMPACT_TAIL_BYTES = 256 * 1024;
+const ENFORCEMENT_MODES = new Set(['limited', 'soft', 'off']);
+
+function contextOutput(eventName, context) {
+  if (!context) return {};
+  return {
+    hookSpecificOutput: {
+      hookEventName: eventName,
+      additionalContext: context,
+    },
+  };
+}
+
+function providerSupportsBlock(provider) {
+  return String(provider || '').toLowerCase() === 'claude';
+}
+
+export function preCompactEnforcementMode(env = process.env) {
+  const value = String(env.LLM_WIKI_KIT_PRECOMPACT_ENFORCEMENT || 'limited').toLowerCase();
+  return ENFORCEMENT_MODES.has(value) ? value : 'limited';
+}
+
+export function preCompactTranscriptTailBytes(env = process.env) {
+  const raw = env.LLM_WIKI_KIT_PRECOMPACT_TRANSCRIPT_TAIL_BYTES;
+  if (raw === undefined || raw === '') return DEFAULT_PRECOMPACT_TAIL_BYTES;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 0) return DEFAULT_PRECOMPACT_TAIL_BYTES;
+  return Math.min(Math.floor(parsed), MAX_PRECOMPACT_TAIL_BYTES);
+}
+
+export function compactSummaryText(payload) {
+  return summarizeForStorage(
+    payload.compact_summary ||
+      payload.compactSummary ||
+      payload.summary ||
+      payload.message ||
+      '',
+    4000
+  );
+}
+
+function transcriptPath(payload) {
+  return payload.transcript_path || payload.transcriptPath || '';
+}
+
+function redactTranscriptPath(text, path) {
+  let output = String(text || '');
+  if (path) output = output.split(path).join('[REDACTED:transcript-path]');
+  output = output.replace(/("transcript_path"\s*:\s*)"[^"]*"/gi, '$1"[REDACTED:transcript-path]"');
+  output = output.replace(/('transcript_path'\s*:\s*)'[^']*'/gi, "$1'[REDACTED:transcript-path]'");
+  output = output.replace(/\btranscript_path\s*=\s*[^\s"'`]+/gi, 'transcript_path=[REDACTED:transcript-path]');
+  return output;
+}
+
+async function readTranscriptTail(path, maxBytes) {
+  if (!path) return { ok: false, reason: 'missing-transcript-path', text: '' };
+  if (maxBytes <= 0) return { ok: false, reason: 'transcript-tail-disabled', text: '' };
+
+  let handle = null;
+  try {
+    const info = await stat(path);
+    if (!info.isFile()) return { ok: false, reason: 'transcript-not-file', text: '' };
+    const length = Math.min(info.size, maxBytes);
+    const start = Math.max(0, info.size - length);
+    const buffer = Buffer.alloc(length);
+    handle = await open(path, 'r');
+    await handle.read(buffer, 0, length, start);
+    const text = summarizeForStorage(redactTranscriptPath(buffer.toString('utf8'), path), 4000);
+    return {
+      ok: true,
+      text,
+      bytesRead: length,
+      truncated: info.size > maxBytes,
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      reason: summarizeForStorage(error?.code || error?.message || 'read-failed', 200),
+      text: '',
+    };
+  } finally {
+    await handle?.close().catch(() => {});
+  }
+}
+
+function appendToField(current, addition) {
+  const existing = String(current || '').trim();
+  if (!existing || existing === '(not captured)') return addition;
+  return `${existing}\n${addition}`;
+}
+
+function entryWithTranscriptTail(entry, tail) {
+  const next = { ...entry };
+  if (tail.ok && tail.text) {
+    const marker = tail.truncated
+      ? 'PreCompact transcript tail (redacted bounded excerpt; earlier transcript omitted):'
+      : 'PreCompact transcript tail (redacted bounded excerpt):';
+    next.result = appendToField(next.result, `${marker}\n${tail.text}`);
+    next.followUp = appendToField(
+      next.followUp,
+      'Compact checkpoint includes only a bounded redacted transcript tail, not the raw transcript path or full transcript.'
+    );
+  } else if (tail.reason && tail.reason !== 'missing-transcript-path') {
+    next.followUp = appendToField(
+      next.followUp,
+      `Transcript tail unavailable during PreCompact (${tail.reason}); checkpoint used turn state only.`
+    );
+  }
+  return next;
+}
+
+function failureOutput(provider, eventName, message, mode) {
+  if (mode === 'off') return {};
+  const reason = summarizeForStorage(message, 1200);
+  if (mode === 'limited' && providerSupportsBlock(provider)) {
+    return {
+      decision: 'block',
+      reason,
+    };
+  }
+  return contextOutput(eventName, `LLM Wiki PreCompact preservation warning:\n${reason}`);
+}
+
+export async function handlePreCompactCapture(projectRoot, provider, eventName, payload) {
+  const mode = preCompactEnforcementMode();
+  const failures = [];
+  const tail = await readTranscriptTail(transcriptPath(payload), preCompactTranscriptTailBytes());
+  const stateEntry = await buildEntryFromState(projectRoot, payload, payload.last_assistant_message || payload.response || '');
+  const entry = entryWithTranscriptTail(stateEntry, tail);
+  const classification = classifyTurn(entry, eventName);
+
+  await appendContextNote(
+    projectRoot,
+    eventName,
+    [
+      `PreCompact classification: ${classification.kind}.`,
+      tail.ok ? `Transcript tail bytes read: ${tail.bytesRead}.` : `Transcript tail: ${tail.reason || 'not available'}.`,
+      'Turn state is intentionally kept for the later Stop/SessionEnd hook.',
+    ].join('\n')
+  ).catch((error) => {
+    failures.push(`context note failed: ${error?.message || error}`);
+  });
+
+  let liveQaPath = null;
+  if (classification.archive) {
+    const checkpointEntry = {
+      ...entry,
+      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 before context compaction; reusable facts should be merged only when appropriate.'
+      ),
+    };
+    try {
+      liveQaPath = await appendLiveQa(projectRoot, checkpointEntry);
+    } catch (error) {
+      failures.push(`live Q&A checkpoint failed: ${error?.message || error}`);
+    }
+  }
+
+  if (liveQaPath && ['suggest-durable', 'explicit-durable'].includes(classification.kind)) {
+    try {
+      const result = await recordMaintenanceForEntry(projectRoot, entry, {
+        source: liveQaPath,
+        eventName,
+        reason: 'PreCompact durable candidate checkpoint needs review after context compaction.',
+      });
+      if (result.created === false && result.reason) {
+        failures.push(`maintenance queue failed: ${result.reason}`);
+      }
+    } catch (error) {
+      failures.push(`maintenance queue failed: ${error?.message || error}`);
+    }
+  }
+
+  if (liveQaPath) {
+    await appendWikiLog(
+      projectRoot,
+      `precompact checkpoint; archive=${relative(projectRoot, liveQaPath)}; classification=${classification.kind}`
+    ).catch((error) => {
+      failures.push(`wiki log failed: ${error?.message || error}`);
+    });
+  }
+
+  if (failures.length > 0) {
+    return failureOutput(
+      provider,
+      eventName,
+      `LLM Wiki PreCompact preservation did not complete. ${failures.join('; ')}`,
+      mode
+    );
+  }
+
+  return {};
+}
+
+export async function recordPostCompactSummary(projectRoot, eventName, payload) {
+  const summary = compactSummaryText(payload);
+  await appendContextNote(
+    projectRoot,
+    eventName,
+    summary ? `Compact summary:\n${redactText(summary, 4000)}` : 'Compact summary was not provided.'
+  );
+}

package/src/hook.js

@@ -1,6 +1,7 @@
 import { findProjectRoot } from './fs-utils.js';
 import { classifyTurn, formatDurableCaptureGuidance, hasDetectedDurableWikiChange, isLegacyEagerCaptureMode } from './capture-policy.js';
-import { bootstrapProject, appendContextNote, appendLiveQa, appendSessionEnvelope, appendWikiLog, buildContextBrief, writeDecisionPage, writeQueryPage } from './project.js';
+import { bootstrapProject, appendLiveQa, appendSessionEnvelope, appendWikiLog, buildContextBrief, writeDecisionPage, writeQueryPage } from './project.js';
+import { compactSummaryText, handlePreCompactCapture, recordPostCompactSummary } from './compact-capture.js';
 import { recoverStaleTurnStates, recordMaintenanceForEntry } from './maintenance.js';
 import { applyProjectTemplateUpdate, inspectProjectState } from './project-state.js';
 import { recordProject } from './projects.js';
@@ -156,11 +157,13 @@ export async function handleHook(provider, explicitEvent) {
   }
 
   if (eventName === 'PreCompact' || eventName === 'PostCompact') {
-    await appendContextNote(projectRoot, eventName, 'Compaction lifecycle event captured by llm-wiki-kit.');
     if (eventName === 'PostCompact') {
-      return contextOutput(eventName, await buildContextBrief(projectRoot, eventName));
+      const summary = compactSummaryText(payload);
+      await recordPostCompactSummary(projectRoot, eventName, payload);
+      const context = await hookContext(projectRoot, eventName, await buildContextBrief(projectRoot, eventName, summary), payload);
+      return contextOutput(eventName, context);
     }
-    return {};
+    return handlePreCompactCapture(projectRoot, provider, eventName, payload);
   }
 
   if (eventName === 'Stop' || eventName === 'SubagentStop' || eventName === 'SessionEnd') {

package/src/install.js

@@ -19,6 +19,8 @@ import { bootstrapProject } from './project.js';
 import { recordProject } from './projects.js';
 import { binPath, detectInstallSource, packageRoot, runtimeVersion } from './version.js';
 
+const SESSION_START_MATCHER = 'startup|resume|clear|compact';
+
 export function hookCommand(provider, eventName, options = {}) {
   return commandForNodeScript(binPath, ['hook', provider, eventName], options);
 }
@@ -125,11 +127,23 @@ async function reconcileWindowsCommand() {
 
 function addHook(hooks, eventName, command, options = {}) {
   hooks[eventName] = Array.isArray(hooks[eventName]) ? hooks[eventName] : [];
-  const already = hooks[eventName].some((entry) => (
+  const existing = hooks[eventName].find((entry) => (
     Array.isArray(entry?.hooks) &&
     entry.hooks.some((hook) => hook?.type === 'command' && hook?.command === command)
   ));
-  if (already) return false;
+  if (existing) {
+    let changed = false;
+    if (options.matcher && existing.matcher !== options.matcher) {
+      existing.matcher = options.matcher;
+      changed = true;
+    }
+    const hook = existing.hooks.find((item) => item?.type === 'command' && item?.command === command);
+    if (hook && options.commandWindows && hook.commandWindows !== options.commandWindows) {
+      hook.commandWindows = options.commandWindows;
+      changed = true;
+    }
+    return changed;
+  }
   const entry = {
     hooks: [
       {
@@ -186,12 +200,21 @@ function unsupportedKitClaudeEvents(hooks, supportedEvents) {
     .sort();
 }
 
-function hookTextIncludes(text, value) {
-  return normalizeHookPathText(text).includes(normalizeHookPathText(value));
+function expectedMatcher(eventName) {
+  return eventName === 'SessionStart' ? SESSION_START_MATCHER : undefined;
 }
 
-function hookEventIncludesBin(entries) {
-  return hookTextIncludes(JSON.stringify(entries || {}), binPath);
+function hookCommandMatches(hook, command) {
+  return hook?.command === command || hook?.commandWindows === command;
+}
+
+function hookEventIsCurrent(entries, eventName, command) {
+  const matcher = expectedMatcher(eventName);
+  return Array.isArray(entries) && entries.some((entry) => (
+    (!matcher || entry.matcher === matcher) &&
+    Array.isArray(entry?.hooks) &&
+    entry.hooks.some((hook) => hook?.type === 'command' && hookCommandMatches(hook, command))
+  ));
 }
 
 export async function install(options = {}) {
@@ -221,7 +244,7 @@ export async function install(options = {}) {
       changed.push('codex:replaced');
     }
     for (const eventName of CODEX_EVENTS) {
-      const matcher = eventName === 'SessionStart' ? 'startup|resume|clear' : undefined;
+      const matcher = expectedMatcher(eventName);
       const command = hookCommand('codex', eventName, { platform });
       const commandWindows = isWindows({ platform }) ? hookCommand('codex', eventName, { platform: 'win32' }) : undefined;
       if (addHook(codex.hooks, eventName, command, { matcher, commandWindows })) {
@@ -251,7 +274,7 @@ export async function install(options = {}) {
       changed.push(...removedUnsupported.map((eventName) => `claude:removed-unsupported:${eventName}`));
     }
     for (const eventName of claudeEvents) {
-      const matcher = eventName === 'SessionStart' ? 'startup|resume|clear' : undefined;
+      const matcher = expectedMatcher(eventName);
       if (addHook(claude.hooks, eventName, hookCommand('claude', eventName, { platform }), { matcher })) {
         claudeChanged = true;
         changed.push(`claude:${eventName}`);
@@ -312,9 +335,18 @@ export async function status(options = {}) {
   const claude = await readJson(claudeSettingsPath, {});
   const claudeDetection = detectClaudeVersion();
   const claudeEvents = supportedClaudeEvents(claudeDetection);
-  const claudeMissingEvents = claudeEvents.filter((eventName) => !hookEventIncludesBin(claude.hooks?.[eventName] || []));
+  const codexMissingEvents = CODEX_EVENTS.filter((eventName) => !hookEventIsCurrent(
+    codex.hooks?.[eventName] || [],
+    eventName,
+    hookCommand('codex', eventName, { platform })
+  ));
+  const claudeMissingEvents = claudeEvents.filter((eventName) => !hookEventIsCurrent(
+    claude.hooks?.[eventName] || [],
+    eventName,
+    hookCommand('claude', eventName, { platform })
+  ));
   const claudeUnsupportedKitEvents = unsupportedKitClaudeEvents(claude.hooks || {}, claudeEvents);
-  const codexInstalled = hookEventIncludesBin(codex.hooks || {});
+  const codexInstalled = codexMissingEvents.length === 0;
   const claudeInstalled = claudeMissingEvents.length === 0 && claudeUnsupportedKitEvents.length === 0;
   const discoveredCommandPaths = await findCommandPaths('llm-wiki', { platform });
   const commandPath = discoveredCommandPaths[0] || null;
@@ -344,6 +376,7 @@ export async function status(options = {}) {
     claudeVersion: claudeDetection.version || 'unknown',
     claudeModernHooks: claudeDetection.modern,
     claudeSupportedEvents: claudeEvents,
+    codexMissingEvents,
     claudeMissingEvents,
     claudeUnsupportedKitEvents,
     hooksCurrent: codexInstalled && claudeInstalled,

package/src/maintenance.js

@@ -240,15 +240,15 @@ export function formatMaintenanceContext(summary, options = {}) {
 
   const lines = [
     eventName === 'UserPromptSubmit'
-      ? 'LLM Wiki maintenance queue soft reminder:'
-      : 'LLM Wiki maintenance queue summary:',
-    `- pending: ${summary.pendingCount}. 현재 사용자 요청을 지연시키지 말고, 관련 있을 때만 기존 durable wiki 문서에 병합한다.`,
+      ? 'LLM Wiki maintenance status:'
+      : 'LLM Wiki maintenance status:',
+    `- pending review items: ${summary.pendingCount}. 현재 요청이 우선이며, 관련 있을 때만 durable wiki 정리에 사용한다.`,
   ];
   for (const item of pending) {
-    lines.push(`- ${item.topic || item.id}: source=${item.source}; target=${item.suggested_target}; reason=${item.reason}${item.result_missing ? '; result_missing=true' : ''}`);
+    lines.push(`- ${item.topic || item.id}: ${item.suggested_target}; source=${item.source}${item.result_missing ? '; result missing' : ''}`);
   }
   if (summary.pending.length > pending.length) {
-    lines.push(`- ${summary.pending.length - pending.length} more pending item(s) hidden from context.`);
+    lines.push(`- ${summary.pending.length - pending.length} more pending item(s) available in llm-wiki/outputs/maintenance/queue.md.`);
   }
   return lines.join('\n');
 }

package/src/project.js

@@ -13,7 +13,7 @@ import { formatMaintenanceContext, maintenanceSummary } from './maintenance.js';
 import { normalizeForStorage, redactText, summarizeForStorage } from './redaction.js';
 import { gitignore, indexPage, llmWikiAgents, logPage, memoryPage, procedure, rootAgentsPolicy } from './templates.js';
 import { formatProjectMaintenanceContext, inspectProjectState, recordManagedTemplates } from './project-state.js';
-import { buildContextPack, formatContextPack, searchWiki as searchWikiWithIndex } from './wiki-search.js';
+import { buildContextPack, formatHookContextPack, searchWiki as searchWikiWithIndex } from './wiki-search.js';
 
 export async function bootstrapProject(projectRoot, options = {}) {
   if (process.env.LLM_WIKI_KIT_DISABLE_BOOTSTRAP === '1') return { created: false };
@@ -171,5 +171,9 @@ export async function buildContextBrief(projectRoot, eventName, query = '') {
   const wikiMaintenance = await maintenanceSummary(projectRoot)
     .then((summary) => formatMaintenanceContext(summary, { eventName, query }))
     .catch(() => '');
-  return [formatContextPack(pack), maintenance, wikiMaintenance].filter(Boolean).join('\n\n');
+  return [formatHookContextPack(pack, {
+    eventName,
+    hitLimit: eventName === 'SessionStart' ? 2 : 3,
+    logLineLimit: eventName === 'SessionStart' ? 2 : 0,
+  }), maintenance, wikiMaintenance].filter(Boolean).join('\n\n');
 }

package/src/update-notice.js

@@ -114,12 +114,11 @@ export async function updateNoticeContext(projectRoot, eventName, options = {})
   const workspace = resolve(projectRoot || process.cwd());
   const updateCommand = commandForProject('update', workspace);
   return [
-    'LLM Wiki 업데이트 알림:',
-    `- 설치된 llm-wiki-kit: ${notice.installedVersion}`,
-    `- npm 최신 릴리스: ${notice.latestVersion}`,
-    '- hook 사용 중 더 새로운 llm-wiki-kit 릴리스가 자동 감지되었습니다.',
-    `- 사용자에게 업데이트 가능 사실을 짧게 알리고 다음 명령 실행을 제안하세요: \`${updateCommand}\``,
-    '- 알려진 모든 프로젝트 root를 업데이트하려면 같은 명령에서 더 넓은 search root를 사용합니다. 예: `--workspace /apps`.',
-    '- 사용자가 요청하기 전에는 자동 설치하지 마세요.',
+    'LLM Wiki runtime update status:',
+    `- current hook runtime: ${notice.installedVersion}; npm registry: ${notice.latestVersion}`,
+    '- 현재 요청 처리가 우선이며, 현재 runtime 기능은 계속 동작한다.',
+    `- 업데이트/정비를 수행할 때 사용할 명령: \`${updateCommand}\``,
+    '- npm 전역 설치 권한 오류가 나면 환경에 맞게 `npm install -g llm-wiki-kit@latest` 또는 `sudo npm install -g llm-wiki-kit@latest` 후 같은 update 명령을 다시 실행한다.',
+    '- 이 status만으로 설치나 업데이트를 실행하지 않는다.',
   ].join('\n');
 }

package/src/wiki-search.js

@@ -5,11 +5,13 @@ import {
   buildWikiGraph,
   collectWikiPages,
   pageLookup,
+  parseFrontmatter,
   readMemoryExcerpt,
 } from './wiki-model.js';
 
 const DEFAULT_LIMIT = 5;
 const SNIPPET_CHARS = 350;
+const HOOK_SNIPPET_CHARS = 180;
 let miniSearchLoader = null;
 
 async function loadMiniSearch() {
@@ -202,6 +204,80 @@ function redactHit(hit) {
   };
 }
 
+function compactText(value, maxLength = 220) {
+  const text = String(value || '').replace(/\s+/g, ' ').trim();
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, Math.max(0, maxLength - 3)).trimEnd()}...`;
+}
+
+function stripGeneratedMemoryBlock(value) {
+  return String(value || '')
+    .replace(/<!-- llm-wiki-kit:memory-start -->[\s\S]*?<!-- llm-wiki-kit:memory-end -->/g, '')
+    .trim();
+}
+
+function sectionBody(body, heading) {
+  const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const match = String(body || '').match(new RegExp(`(?:^|\\n)##\\s+${escaped}\\s*\\n([\\s\\S]*?)(?=\\n##\\s+|$)`, 'i'));
+  return match?.[1] || '';
+}
+
+function bulletLines(value) {
+  return String(value || '')
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => /^-\s+/.test(line))
+    .map((line) => compactText(line, 240));
+}
+
+function memoryFocusLines(memoryExcerpt, limit = 6) {
+  const { body } = parseFrontmatter(memoryExcerpt || '');
+  const bodyWithoutGenerated = stripGeneratedMemoryBlock(body);
+  const current = bulletLines(sectionBody(bodyWithoutGenerated, 'Current Focus'));
+  const entries = bulletLines(sectionBody(bodyWithoutGenerated, 'Durable Entry Points')).slice(0, 2);
+  if (current.length > 0) {
+    const currentLimit = Math.max(1, limit - entries.length);
+    return [...current.slice(-currentLimit), ...entries].slice(0, limit);
+  }
+
+  const bullets = bulletLines(bodyWithoutGenerated);
+  if (bullets.length > 0) return bullets.slice(-limit);
+
+  const lines = bodyWithoutGenerated
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean);
+
+  return lines
+    .filter((line) => !/^#+\s+/.test(line))
+    .map((line) => compactText(line, 240))
+    .slice(0, Math.max(1, Math.min(limit, 3)));
+}
+
+function logFocusLines(logExcerpt, limit = 2) {
+  return String(logExcerpt || '')
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => /^-\s+/.test(line))
+    .slice(-limit)
+    .map((line) => compactText(line, 220));
+}
+
+function metaWikiQuery(query) {
+  return /(?:llm-wiki|wiki|위키|memory|메모리|기억|index|인덱스|log|로그|maintenance|queue|문서|문서화|기록|정리|context|컨텍스트)/i.test(String(query || ''));
+}
+
+function internalContextPath(path) {
+  return /^(?:wiki\/)?(?:memory|index|log)\.md$/i.test(String(path || ''));
+}
+
+function hookHits(pack, options = {}) {
+  const allowInternal = options.includeInternalHits || metaWikiQuery(pack.query);
+  return (pack.hits || [])
+    .filter((hit) => allowInternal || !internalContextPath(hit.path))
+    .slice(0, options.hitLimit || 3);
+}
+
 export async function buildContextPack(projectRoot, query, options = {}) {
   const limit = Number(options.limit || DEFAULT_LIMIT);
   const expand = options.expand !== false;
@@ -258,3 +334,45 @@ export function formatContextPack(pack) {
   }
   return lines.join('\n').trim();
 }
+
+export function formatHookContextPack(pack, options = {}) {
+  const lines = [
+    'LLM Wiki context (functional compact):',
+    '- Priority: answer the current user request first; use wiki context when it helps.',
+    '- 기능 유지: 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.',
+  ];
+  if (pack.query) {
+    lines.push(`- query: "${compactText(pack.query, 180)}"`);
+    lines.push(`- search: ${pack.search}`);
+  }
+
+  const memoryLines = memoryFocusLines(pack.memoryExcerpt, options.memoryLineLimit ?? 6);
+  if (memoryLines.length > 0) {
+    lines.push('', 'Memory focus:');
+    lines.push(...memoryLines.map((line) => `- ${line.replace(/^-\s+/, '')}`));
+  } else {
+    lines.push('', 'Memory focus:', '- See llm-wiki/wiki/memory.md and llm-wiki/wiki/index.md when project context is needed.');
+  }
+
+  const hits = hookHits(pack, options);
+  if (hits.length > 0) {
+    lines.push('', 'Relevant wiki pages:');
+    for (const hit of hits) {
+      const suffix = hit.source === 'linked' && hit.via.length > 0
+        ? `, via ${hit.via.join(', ')}`
+        : '';
+      lines.push(`- ${hit.path} (${hit.source}${suffix}): ${compactText(hit.snippet, HOOK_SNIPPET_CHARS)}`);
+    }
+  } else if (pack.query) {
+    lines.push('', 'Relevant wiki pages:', '- No directly relevant durable wiki page found; answer normally and inspect files/wiki only if needed.');
+  }
+
+  const logLines = logFocusLines(pack.logExcerpt, options.logLineLimit ?? 2);
+  if (logLines.length > 0) {
+    lines.push('', 'Recent log:');
+    lines.push(...logLines.map((line) => `- ${line.replace(/^-\s+/, '')}`));
+  }
+
+  return lines.join('\n').trim();
+}