llm-wiki-kit 0.2.16 → 0.2.17

package/README.md

@@ -148,7 +148,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. 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>` 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 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

@@ -23,9 +23,10 @@ The important behavior is a loop:
 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.
 9. At the next start/prompt after an abrupt shutdown, hooks can recover stale turn state into `outputs/maintenance/queue.md`.
-10. 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.
-11. Export and eval reuse the same durable visibility policy so handoff manifests, retrieval fixtures, and context selection describe the same wiki surface.
-12. Future sessions start from the improved wiki instead of relying on long chat history.
+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.
+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.
 
 The kit is a template/runtime repository. It must not centralize project wiki contents.
 
@@ -44,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`.
+- `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/`.
 - `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.
+- `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.
 - `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`, 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 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, 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.
 
-`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 may carry safe `evidence_refs` candidates from changed 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. 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 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.
 
 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

@@ -29,7 +29,7 @@ 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 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.
+- `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.
 - `PreToolUse` records redacted tool summaries without blocking tool calls.
@@ -37,7 +37,7 @@ Expected behavior:
 - `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.
 - `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 may carry safe `evidence_refs` candidates from changed files and verification commands. 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 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.
 - `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

@@ -75,6 +75,7 @@ Use Codex or Claude Code normally. Installed hooks:
 - 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;
 - 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;
 - 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.
 
@@ -156,7 +157,7 @@ Most users should not need these during daily coding. They are for install, upda
 - `llm-wiki export --workspace <project> [--format all|llms|llms-full|json] [--output <dir>] [--dry-run] [--json]`: write durable wiki manifests.
 - `llm-wiki lint --workspace <project>`: wiki health check.
 - `llm-wiki consolidate --workspace <project> [--dry-run]`: refresh generated blocks in `memory.md` and `index.md`.
-- `llm-wiki maintenance --workspace <project> [--approve <id> --target <wiki/...md> | --done <id> --target <wiki/...md> | --skip <id> [--note "..."]] [--json]`: show or update durable cleanup review state.
+- `llm-wiki maintenance --workspace <project> [--apply-lifecycle [--dry-run] | --approve <id> --target <wiki/...md> | --done <id> --target <wiki/...md> | --skip <id> [--note "..."]] [--json]`: show, prioritize, or update durable cleanup review state.
 - `llm-wiki archive-questions --workspace <project> [--date YYYY-MM-DD] [--dry-run]`: split old flat live Q&A files into chunks.
 - `llm-wiki uninstall`: remove kit-managed hook entries, leaving project wiki contents intact.
 
@@ -231,6 +232,7 @@ Missing fixtures exit successfully with `no fixture found`. Present fixtures rep
 `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`.
 
 ```bash
+llm-wiki maintenance --workspace <project> --apply-lifecycle --dry-run
 llm-wiki maintenance --workspace <project> --approve <id> --target wiki/concepts/topic.md
 llm-wiki maintenance --workspace <project> --done <id> --target wiki/concepts/topic.md
 llm-wiki maintenance --workspace <project> --skip <id> --note "duplicate"
@@ -238,6 +240,8 @@ 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.
+
 Hook reminders are soft:
 
 - session start and instructions loaded may show a one-item summary;

package/docs/operations.md

@@ -104,6 +104,7 @@ llm-wiki context "search phrase" --workspace /path/to/project
 llm-wiki lint --workspace /path/to/project
 llm-wiki consolidate --workspace /path/to/project
 llm-wiki maintenance --workspace /path/to/project
+llm-wiki maintenance --workspace /path/to/project --apply-lifecycle --dry-run
 llm-wiki archive-questions --workspace /path/to/project --dry-run
 ```
 
@@ -146,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`. `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; `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 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.
 
 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.
 
@@ -209,15 +210,18 @@ 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 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 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> --json` includes `reviewDue`, `reviewReasons`, `pendingCount`, `stalePendingCount`, `health`, and `recommendedCommands`. 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> --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> --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.
 
 Recommended agent checklist:
 
 ```bash
 llm-wiki lint --workspace /path/to/project
 llm-wiki maintenance --workspace /path/to/project
+llm-wiki maintenance --workspace /path/to/project --apply-lifecycle --dry-run
 llm-wiki consolidate --workspace /path/to/project --dry-run
 llm-wiki consolidate --workspace /path/to/project
 ```

package/docs/troubleshooting.md

@@ -235,10 +235,11 @@ Check the queue and health warnings:
 
 ```bash
 llm-wiki maintenance --workspace /path/to/project
+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.
+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.
 
 ## Authentication Values Were Redacted
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-wiki-kit",
-  "version": "0.2.16",
+  "version": "0.2.17",
   "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

@@ -76,6 +76,12 @@ export function hasDetectedDurableWikiChange(entry) {
   return /(?:^|[\s"'`])(?:llm-wiki\/)?(?:wiki\/(?!queries\/)(?:architecture|debugging|decisions|concepts|entities|sources|context)\/|procedures\/|llm-wiki\/wiki\/(?!queries\/)(?:architecture|debugging|decisions|concepts|entities|sources|context)\/|llm-wiki\/procedures\/)[^\s"'`]+\.md\b/i.test(text);
 }
 
+function durableSignalLevel({ durableConclusion, hasFiles, hasVerification, durableSignal }) {
+  if (durableConclusion) return 'high';
+  if ((hasFiles || hasVerification) && durableSignal) return 'high';
+  return 'low';
+}
+
 export function classifyTurn(entry, eventName = '') {
   if (eventName === 'SubagentStop') {
     return {
@@ -108,6 +114,7 @@ export function classifyTurn(entry, eventName = '') {
       archive: true,
       suggestDurable: false,
       queueIfMissingDurable: true,
+      signalLevel: 'explicit',
     };
   }
 
@@ -134,6 +141,7 @@ export function classifyTurn(entry, eventName = '') {
         archive: true,
         suggestDurable: true,
         queueIfMissingDurable: true,
+        signalLevel: durableSignalLevel({ durableConclusion, hasFiles, hasVerification, durableSignal }),
       };
     }
     return {
@@ -150,6 +158,7 @@ export function classifyTurn(entry, eventName = '') {
       archive: true,
       suggestDurable: true,
       queueIfMissingDurable: true,
+      signalLevel: 'high',
     };
   }
 

package/src/cli.js

@@ -3,7 +3,7 @@ import { resolve } from 'path';
 import { formatConsolidateResult, runConsolidate } from './consolidate.js';
 import { handleHook } from './hook.js';
 import { install, status, uninstall } from './install.js';
-import { formatMaintenanceResult, maintenanceSummary, updateMaintenanceItem } from './maintenance.js';
+import { applyMaintenanceLifecycle, formatMaintenanceResult, maintenanceSummary, updateMaintenanceItem } from './maintenance.js';
 import { bootstrapProject } from './project.js';
 import { inspectProjectState } from './project-state.js';
 import { commandForProject, knownProjectRoots, recordProject } from './projects.js';
@@ -92,6 +92,8 @@ function parseOptions(args) {
       options.check = true;
     } else if (arg === '--dry-run') {
       options.dryRun = true;
+    } else if (arg === '--apply-lifecycle') {
+      options.applyLifecycle = true;
     } else if (arg === '--limit') {
       const value = optionValue(arg, i);
       const limit = Number(value);
@@ -157,7 +159,7 @@ Usage:
   llm-wiki export --workspace <project> [--format all|llms|llms-full|json] [--output <dir>] [--dry-run] [--json]
   llm-wiki lint --workspace <project>
   llm-wiki consolidate --workspace <project> [--dry-run]
-  llm-wiki maintenance --workspace <project> [--approve <id> --target <wiki/...md> | --done <id> --target <wiki/...md> | --skip <id> [--note "..."]] [--json]
+  llm-wiki maintenance --workspace <project> [--apply-lifecycle [--dry-run] | --approve <id> --target <wiki/...md> | --done <id> --target <wiki/...md> | --skip <id> [--note "..."]] [--json]
   llm-wiki archive-questions --workspace <project> [--date YYYY-MM-DD] [--dry-run] [--json]
 `);
     return;
@@ -288,6 +290,7 @@ Usage:
   if (command === 'maintenance') {
     const projectRoot = resolve(options.workspace || process.cwd());
     const actions = [options.approve ? 'approve' : '', options.done ? 'done' : '', options.skip ? 'skip' : ''].filter(Boolean);
+    if (options.applyLifecycle && actions.length > 0) throw new Error('maintenance --apply-lifecycle cannot be combined with --approve, --done, or --skip');
     if (actions.length > 1) throw new Error('maintenance accepts only one of --approve, --done, or --skip');
     if (actions.length === 1) {
       const action = actions[0];
@@ -295,7 +298,16 @@ Usage:
       printJsonOrText(await updateMaintenanceItem(projectRoot, id, action, options), options);
       return;
     }
-    printJsonOrText(await maintenanceSummary(projectRoot, { ...options, includeLint: true }), options, formatMaintenanceResult);
+    let lifecycle = null;
+    if (options.applyLifecycle) {
+      lifecycle = await applyMaintenanceLifecycle(projectRoot, options);
+    }
+    const summary = await maintenanceSummary(projectRoot, {
+      ...options,
+      includeLint: true,
+      ...(lifecycle || {}),
+    });
+    printJsonOrText(summary, options, formatMaintenanceResult);
     return;
   }
 

package/src/compact-capture.js

@@ -221,6 +221,7 @@ export async function handlePreCompactCapture(projectRoot, provider, eventName,
         source: liveQaPath,
         eventName,
         reason: 'PreCompact durable candidate checkpoint needs review after context compaction.',
+        signalLevel: classification.signalLevel,
       });
       if (result.created === false && result.reason) {
         failures.push(`maintenance queue failed: ${result.reason}`);

package/src/evidence.js

@@ -1,4 +1,5 @@
-import { isAbsolute, relative, sep } from 'path';
+import { statSync } from 'fs';
+import { isAbsolute, join, relative, sep } from 'path';
 import { extractPathsFromText, hasSecretLikeText, isSensitivePath, redactText, summarizeForStorage } from './redaction.js';
 
 export const EVIDENCE_PREFIXES = new Set(['file', 'cmd', 'raw', 'url']);
@@ -51,20 +52,37 @@ function cleanCandidatePath(value) {
     .trim();
 }
 
-function isUsefulFileCandidate(value) {
+function hasPatchFragment(value) {
+  return /(?:\\n|\/n|@@|^\+|^-)/.test(String(value || ''));
+}
+
+function looksLikeNetworkOrCodeToken(value) {
+  const text = String(value || '');
+  if (text.startsWith('@')) return true;
+  if (/^\d{1,3}(?:\.\d{1,3}){3}(?::\d+)?$/.test(text)) return true;
+  if (/^[A-Za-z0-9.-]+\.[A-Za-z]{2,}(?::\d+)?(?::\d{1,3}(?:\.\d{1,3}){3})?$/.test(text) && !text.includes('/')) return true;
+  if (/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)+$/.test(text) && !text.includes('/')) return true;
+  return false;
+}
+
+function existingProjectFile(projectRoot, value) {
+  if (!projectRoot) return false;
+  try {
+    const info = statSync(join(projectRoot, value));
+    return info.isFile();
+  } catch {
+    return false;
+  }
+}
+
+function isUsefulFileCandidate(value, projectRoot = '') {
   const text = cleanCandidatePath(value);
   if (!text || text.includes('://') || text.startsWith('cmd:') || text.startsWith('raw:')) return false;
   if (isSensitivePath(text) || hasSecretLikeText(text)) return false;
-  return (
-    text.startsWith('llm-wiki/') ||
-    text.startsWith('src/') ||
-    text.startsWith('test/') ||
-    text.startsWith('docs/') ||
-    text.startsWith('bin/') ||
-    text.startsWith('examples/') ||
-    /^(?:README|AGENTS|CLAUDE|LICENSE|package(?:-lock)?|install)\.[A-Za-z0-9]+$/i.test(text) ||
-    /\.[A-Za-z0-9]{1,12}$/.test(text)
-  );
+  if (hasPatchFragment(text) || looksLikeNetworkOrCodeToken(text)) return false;
+  if (isAbsolute(text) || text.split('/').includes('..')) return false;
+  if (projectRoot) return existingProjectFile(projectRoot, text);
+  return false;
 }
 
 function relativeProjectPath(projectRoot, value) {
@@ -79,8 +97,7 @@ function relativeProjectPath(projectRoot, value) {
 function addFileRefs(refs, projectRoot, text) {
   for (const candidate of extractPathsFromText(text || '')) {
     const rel = relativeProjectPath(projectRoot, candidate);
-    if (!isUsefulFileCandidate(rel)) continue;
-    if (isAbsolute(rel) || rel.split('/').includes('..')) continue;
+    if (!isUsefulFileCandidate(rel, projectRoot)) continue;
     refs.push(`file:${rel}`);
   }
 }

package/src/hook.js

@@ -2,7 +2,7 @@ import { findProjectRoot } from './fs-utils.js';
 import { classifyTurn, formatDurableCaptureGuidance, hasDetectedDurableWikiChange, isLegacyEagerCaptureMode } from './capture-policy.js';
 import { bootstrapProject, appendLiveQa, appendSessionEnvelope, appendWikiLog, buildContextBrief, writeDecisionPage, writeQueryPage } from './project.js';
 import { consumeCompactRecoveryContext, finalizeCompactRecovery, handlePreCompactCapture, recordPostCompactSummary } from './compact-capture.js';
-import { recoverStaleTurnStates, recordMaintenanceForEntry } from './maintenance.js';
+import { applyMaintenanceLifecycle, recoverStaleTurnStates, recordMaintenanceForEntry } from './maintenance.js';
 import { applyProjectTemplateUpdate, inspectProjectState } from './project-state.js';
 import { recordProject } from './projects.js';
 import { summarizeForStorage } from './redaction.js';
@@ -110,6 +110,7 @@ async function handleAnswerFirstStop(projectRoot, eventName, payload, entry) {
         source: liveQaPath,
         eventName,
         reason: durableQueueReason(classification),
+        signalLevel: classification.signalLevel,
       }).catch(() => {});
     }
     await appendWikiLog(projectRoot, `captured ${eventName}; archive=${relative(projectRoot, liveQaPath)}; classification=${classification.kind}`);
@@ -155,6 +156,9 @@ export async function handleHook(provider, explicitEvent) {
   if (eventName === 'SessionStart' || eventName === 'InstructionsLoaded' || eventName === 'UserPromptSubmit') {
     await recoverStaleTurnStates(projectRoot).catch(() => []);
   }
+  if (eventName === 'SessionStart' || eventName === 'InstructionsLoaded') {
+    await applyMaintenanceLifecycle(projectRoot).catch(() => null);
+  }
 
   if (eventName === 'SessionStart' || eventName === 'InstructionsLoaded') {
     const recovery = supportsAdditionalContext(provider, eventName)

package/src/maintenance.js

@@ -13,7 +13,11 @@ const DEFAULT_STALE_PENDING_DAYS = 7;
 const DEFAULT_PENDING_LIMIT = 20;
 const DEFAULT_REVIEW_PENDING_LIMIT = 5;
 const DEFAULT_REVIEW_INTERVAL_DAYS = 14;
+const DEFAULT_LIFECYCLE_PENDING_THRESHOLD = 15;
+const DEFAULT_LOW_SIGNAL_SKIP_DAYS = 14;
+const DEFAULT_REVIEWED_KEEP = 10;
 const MEMORY_NEAR_BUDGET_BYTES = 20 * 1024;
+const SIGNAL_LEVELS = new Set(['explicit', 'high', 'low', 'recovered']);
 
 function queuePath(projectRoot) {
   return join(projectRoot, MAINTENANCE_QUEUE_REL);
@@ -26,6 +30,7 @@ function queueHeader() {
     'Candidates to merge into durable wiki pages. Hooks only create candidates; the active agent reviews and merges them 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.',
     '',
   ].join('\n');
 }
@@ -55,6 +60,44 @@ function sanitizeField(value, maxLength = 500) {
   return summarizeForStorage(String(value || '').replace(/\s+/g, ' ').trim(), maxLength);
 }
 
+function normalizeSignalLevel(value) {
+  const text = String(value || '').trim().toLowerCase();
+  return SIGNAL_LEVELS.has(text) ? text : '';
+}
+
+function inferSignalLevelFromReason(reason, resultMissing = false) {
+  const text = String(reason || '').toLowerCase();
+  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('suggested durable wiki candidate')) return 'high';
+  if (text.includes('durable wiki review')) return 'high';
+  return 'high';
+}
+
+function signalLevelForItem(item) {
+  if (item?.result_missing) return 'recovered';
+  return normalizeSignalLevel(item?.signal_level || item?.fields?.signal_level) ||
+    inferSignalLevelFromReason(item?.reason || item?.fields?.reason, item?.result_missing);
+}
+
+function isStaleByDays(item, days, nowMs = Date.now()) {
+  const time = Date.parse(item?.created_at || item?.last_seen_at || '');
+  return Number.isFinite(time) && nowMs - time >= days * 24 * 60 * 60 * 1000;
+}
+
+function reviewedTimeMs(item) {
+  const values = [item?.reviewed_at, item?.last_seen_at, item?.created_at]
+    .map((value) => Date.parse(value || ''))
+    .filter(Number.isFinite);
+  return values.length > 0 ? Math.max(...values) : 0;
+}
+
+function archiveMonth(item) {
+  const time = reviewedTimeMs(item) || Date.now();
+  return new Date(time).toISOString().slice(0, 7);
+}
+
 function inferSuggestedTarget(entry, source) {
   const text = `${entry?.question || ''}\n${entry?.result || ''}\n${entry?.work || ''}\n${source || ''}`.toLowerCase();
   if (String(source || '').includes('wiki/decisions/') || /decision|decided|결정|선택|채택|확정/.test(text)) return 'wiki/decisions/';
@@ -78,8 +121,10 @@ function itemBlock(item) {
     last_seen_at: item.last_seen_at,
     source: item.source,
     suggested_target: item.suggested_target,
+    signal_level: item.signal_level,
     target: item.target,
     reviewed_at: item.reviewed_at,
+    archived_at: item.archived_at,
     review_note: item.review_note,
     evidence_refs: normalizeEvidenceRefs(item.evidence_refs).length > 0
       ? JSON.stringify(normalizeEvidenceRefs(item.evidence_refs))
@@ -93,8 +138,10 @@ function itemBlock(item) {
     'last_seen_at',
     'source',
     'suggested_target',
+    'signal_level',
     'target',
     'reviewed_at',
+    'archived_at',
     'review_note',
     'evidence_refs',
     'reason',
@@ -159,6 +206,7 @@ export async function readMaintenanceQueue(projectRoot) {
       evidence_refs: parseEvidenceRefsField(item.fields.evidence_refs),
       evidenceRefs: parseEvidenceRefsField(item.fields.evidence_refs),
       result_missing: String(item.fields.result_missing || '').toLowerCase() === 'true',
+      signal_level: normalizeSignalLevel(item.fields.signal_level),
     })),
   };
 }
@@ -175,6 +223,168 @@ async function writeMaintenanceQueue(projectRoot, items) {
   return path;
 }
 
+function lifecycleDefaults(options = {}) {
+  return {
+    pendingThreshold: options.pendingThreshold ?? DEFAULT_LIFECYCLE_PENDING_THRESHOLD,
+    lowSignalSkipDays: options.lowSignalSkipDays ?? DEFAULT_LOW_SIGNAL_SKIP_DAYS,
+    reviewedKeep: options.reviewedKeep ?? DEFAULT_REVIEWED_KEEP,
+  };
+}
+
+function lifecycleAction(action, item, extra = {}) {
+  return {
+    action,
+    id: item.id,
+    topic: item.topic,
+    status: item.status,
+    signal_level: signalLevelForItem(item),
+    source: item.source,
+    ...extra,
+  };
+}
+
+async function appendArchivedItems(projectRoot, items, now) {
+  const grouped = new Map();
+  for (const item of items) {
+    const month = archiveMonth(item);
+    if (!grouped.has(month)) grouped.set(month, []);
+    grouped.get(month).push(item);
+  }
+
+  const files = [];
+  for (const [month, monthItems] of grouped.entries()) {
+    const path = join(projectRoot, 'llm-wiki', 'outputs', 'maintenance', 'archive', `${month}.md`);
+    const existing = await readText(path, '');
+    const header = existing ? '' : [
+      '# LLM Wiki Maintenance Archive',
+      '',
+      `Reviewed queue items archived for ${month}.`,
+      '',
+    ].join('\n');
+    const blocks = [];
+    for (const item of monthItems) {
+      if (existing.includes(`- id: ${item.id}`)) continue;
+      blocks.push(itemBlock({
+        ...item,
+        fields: { ...(item.fields || {}) },
+        archived_at: now,
+      }).trimEnd());
+    }
+    if (blocks.length === 0) continue;
+    await appendText(path, `${header}${existing && !existing.endsWith('\n') ? '\n' : ''}${blocks.join('\n\n')}\n`);
+    files.push(path);
+  }
+  return files;
+}
+
+export async function applyMaintenanceLifecycle(projectRoot, options = {}) {
+  const queue = await readMaintenanceQueue(projectRoot);
+  const defaults = lifecycleDefaults(options);
+  const now = nowIso();
+  const actions = [];
+  const pending = queue.items.filter((item) => item.status === 'pending');
+  let nextItems = queue.items.map((item) => ({ ...item, fields: { ...(item.fields || {}) } }));
+  let approvedByLifecycle = 0;
+  let skippedByLifecycle = 0;
+  let archivedReviewedCount = 0;
+  const shouldApplyPendingLifecycle = pending.length >= defaults.pendingThreshold;
+
+  if (shouldApplyPendingLifecycle) {
+    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` }));
+        const reviewNote = sanitizeField(`Auto-skipped by lifecycle because this low-signal candidate was older than ${defaults.lowSignalSkipDays} days.`, 500);
+        return {
+          ...item,
+          status: 'skipped',
+          signal_level: signal,
+          reviewed_at: now,
+          last_seen_at: now,
+          review_note: item.review_note || reviewNote,
+          fields: {
+            ...(item.fields || {}),
+            signal_level: signal,
+            reviewed_at: now,
+            last_seen_at: now,
+            review_note: item.review_note || reviewNote,
+          },
+        };
+      }
+      return {
+        ...item,
+        signal_level: signal,
+        fields: {
+          ...(item.fields || {}),
+          signal_level: signal,
+        },
+      };
+    });
+  }
+
+  const reviewed = nextItems
+    .filter((item) => item.status === 'done' || item.status === 'skipped')
+    .sort((a, b) => reviewedTimeMs(b) - reviewedTimeMs(a));
+  const reviewedToArchive = reviewed.slice(defaults.reviewedKeep);
+  if (reviewedToArchive.length > 0) {
+    archivedReviewedCount = reviewedToArchive.length;
+    for (const item of reviewedToArchive) {
+      actions.push(lifecycleAction('archive-reviewed', item, { reason: `keeping latest ${defaults.reviewedKeep} reviewed items in queue.md` }));
+    }
+    const archiveIds = new Set(reviewedToArchive.map((item) => item.id));
+    nextItems = nextItems.filter((item) => !archiveIds.has(item.id));
+  }
+
+  if (!options.dryRun && actions.length > 0) {
+    if (reviewedToArchive.length > 0) {
+      await appendArchivedItems(projectRoot, reviewedToArchive, now);
+    }
+    if (actions.length > 0 || queue.exists) {
+      await writeMaintenanceQueue(projectRoot, nextItems);
+    }
+  }
+
+  return {
+    workspace: projectRoot,
+    path: queue.path,
+    dryRun: Boolean(options.dryRun),
+    appliedPendingLifecycle: shouldApplyPendingLifecycle,
+    pendingThreshold: defaults.pendingThreshold,
+    lowSignalSkipDays: defaults.lowSignalSkipDays,
+    reviewedKeep: defaults.reviewedKeep,
+    lifecycleActions: actions,
+    actionCount: actions.length,
+    approvedByLifecycle,
+    skippedByLifecycle,
+    archivedReviewedCount,
+  };
+}
+
 export function summarizeMaintenanceQueue(queue, options = {}) {
   const staleDays = options.staleDays ?? DEFAULT_STALE_PENDING_DAYS;
   const pendingLimit = options.pendingLimit ?? DEFAULT_PENDING_LIMIT;
@@ -240,6 +450,10 @@ export async function maintenanceSummary(projectRoot, options = {}) {
     reviewReasons,
     health,
     recommendedCommands: recommendedMaintenanceCommands(projectRoot),
+    lifecycleActions: options.lifecycleActions || [],
+    approvedByLifecycle: options.approvedByLifecycle || 0,
+    skippedByLifecycle: options.skippedByLifecycle || 0,
+    archivedReviewedCount: options.archivedReviewedCount || 0,
   };
 }
 
@@ -247,6 +461,7 @@ function recommendedMaintenanceCommands(projectRoot) {
   return [
     `llm-wiki lint --workspace ${projectRoot}`,
     `llm-wiki maintenance --workspace ${projectRoot}`,
+    `llm-wiki maintenance --workspace ${projectRoot} --apply-lifecycle --dry-run`,
     `llm-wiki consolidate --workspace ${projectRoot} --dry-run`,
     `llm-wiki consolidate --workspace ${projectRoot}`,
   ];
@@ -345,6 +560,9 @@ export async function recordMaintenanceForEntry(projectRoot, entry, options = {}
   if (!source && !options.resultMissing) return { created: false, reason: 'missing-source' };
   if (!entry?.question || entry.question === '(not captured)') return { created: false, reason: 'missing-question' };
   const created = nowIso();
+  const reason = sanitizeField(options.reason || `Captured ${options.eventName || 'turn'} needs durable wiki review.`, 300);
+  const signalLevel = normalizeSignalLevel(options.signalLevel) ||
+    inferSignalLevelFromReason(reason, Boolean(options.resultMissing));
   const item = {
     id: itemId(projectRoot, source, entry),
     status: 'pending',
@@ -353,8 +571,9 @@ export async function recordMaintenanceForEntry(projectRoot, entry, options = {}
     last_seen_at: created,
     source,
     suggested_target: options.suggestedTarget || inferSuggestedTarget(entry, source),
+    signal_level: signalLevel,
     evidence_refs: evidenceRefsFromEntry(entry, { projectRoot }),
-    reason: sanitizeField(options.reason || `Captured ${options.eventName || 'turn'} needs durable wiki review.`, 300),
+    reason,
     result_missing: Boolean(options.resultMissing),
   };
   return appendMaintenanceItem(projectRoot, item);
@@ -395,6 +614,7 @@ export async function recoverStaleTurnStates(projectRoot, options = {}) {
       eventName: 'recovered stale turn state',
       reason: 'Recovered from stale turn state because Stop/SessionEnd did not complete.',
       resultMissing: true,
+      signalLevel: 'recovered',
     });
     await unlink(path).catch(() => {});
     output.push({ ...result, statePath: path, session: state.session });
@@ -469,6 +689,14 @@ export function formatMaintenanceResult(summary) {
   if ((summary.reviewReasons || []).length > 0) {
     lines.push(`- review reasons: ${summary.reviewReasons.join('; ')}`);
   }
+  if ((summary.lifecycleActions || []).length > 0) {
+    lines.push(
+      `- lifecycle actions: ${summary.lifecycleActions.length}`,
+      `- lifecycle approved: ${summary.approvedByLifecycle || 0}`,
+      `- lifecycle skipped: ${summary.skippedByLifecycle || 0}`,
+      `- lifecycle archived reviewed: ${summary.archivedReviewedCount || 0}`
+    );
+  }
   if ((summary.approved || []).length > 0) {
     lines.push('', 'Approved:');
     for (const item of summary.approved.slice(0, 10)) {

package/src/templates.js

@@ -16,7 +16,7 @@ This repository uses llm-wiki-kit as a hook-first living Markdown wiki for Codex
 - 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. 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. 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\`.
 - 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.
 - Record verification commands, evidence files, and uncertainty. Mark inference explicitly and preserve contradictions in Open Questions or Contradictions.
@@ -66,8 +66,8 @@ These rules replace older OMX/OMC/\`omx_wiki/\` rules for this project.
 - 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 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 editing. Show only short reminders at \`SessionStart\`/\`InstructionsLoaded\`, and compact prompt-time reminders when durable candidates or review thresholds need agent attention.
+- 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.
 - 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 +106,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\`.
+- 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.
 `;
 }
 
@@ -225,9 +225,10 @@ 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. Merge pending or hook-suggested durable candidates into existing durable pages when appropriate, then mark them \`done\` or \`skipped\`.
-4. \`llm-wiki consolidate --workspace <project> --dry-run\`
-5. Run \`llm-wiki consolidate --workspace <project>\` when the dry run is acceptable.
+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\`.
+5. \`llm-wiki consolidate --workspace <project> --dry-run\`
+6. Run \`llm-wiki consolidate --workspace <project>\` when the dry run is acceptable.
 
 Apply automatic fixes only to clearly managed kit areas. Do not overwrite user-editable documents; surface cleanup needs in the next work context.
 `,