llm-wiki-kit 0.2.16 → 0.2.18

package/src/language.js

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

package/src/live-qa.js

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

package/src/maintenance.js

@@ -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/project.js

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

package/src/state.js

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

package/src/templates.js

@@ -9,14 +9,14 @@ This repository uses llm-wiki-kit as a hook-first living Markdown wiki for Codex
 
 - This block supersedes older OMX/OMC/\`omx_wiki/\` LLM Wiki instructions for this repository.
 - Use Codex or Claude Code normally. Do not create a workflow where users must remember extra \`llm-wiki\` commands during ordinary work.
-- Language: respond in the user's current prompt language when it is clearly Korean or English. Keep technical identifiers, commands, paths, code, and original error text unchanged. If no prompt language is clear, follow local \`CLAUDE.md\`/\`AGENTS.md\` guidance, then fall back to English.
+- Language: respond in the user's current real prompt language when it is clearly Korean or English. Codex synthetic plan execution prompts such as \`Implement the plan.\` are neutral and should reuse the last real session language or project preference. Keep technical identifiers, commands, paths, code, and original error text unchanged. If no prompt language is clear, follow local \`CLAUDE.md\`/\`AGENTS.md\` guidance, then fall back to English.
 - Treat chat memory as temporary. Durable project knowledge belongs in repository Markdown under \`llm-wiki/\`.
 - \`llm-wiki/raw/\` is the immutable or redacted evidence layer. Do not modify raw captures except safe hook envelope append.
 - \`llm-wiki/wiki/\` is the curated knowledge layer managed by the agent. Put decisions, architecture, debugging findings, concepts, procedures, and context there.
 - Keep \`llm-wiki/wiki/memory.md\` short. Link to important documents instead of copying long explanations.
 - Use hook-injected context when helpful, but answer the current user request first. Use \`llm-wiki context\`, \`llm-wiki lint\`, and \`llm-wiki consolidate\` only as agent maintenance helpers.
 - Hooks safely store redacted raw envelopes and work/decision-focused live Q&A. Simple answers, status checks, and keyword-only turns should not be promoted to live Q&A or durable wiki by default.
-- Hooks may queue durable cleanup candidates in \`llm-wiki/outputs/maintenance/queue.md\` at stop/start boundaries. 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.
@@ -46,7 +46,8 @@ The user should not need to run many \`llm-wiki\` commands manually. The agent c
 These rules replace older OMX/OMC/\`omx_wiki/\` rules for this project.
 
 ## Language
-- Follow the user's current prompt language when it is clearly Korean or English.
+- Follow the user's current real prompt language when it is clearly Korean or English.
+- Treat Codex synthetic plan execution prompts such as \`Implement the plan.\` as neutral; reuse the last real session language or project preference when available.
 - If no current prompt language is clear, follow local \`CLAUDE.md\`/\`AGENTS.md\` guidance, then fall back to English.
 - Keep commands, paths, code identifiers, API names, package names, logs, and original error text unchanged.
 - Korean and English users should both be able to use Codex/Claude Code naturally without changing \`llm-wiki\` commands.
@@ -66,8 +67,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 +107,7 @@ superseded_by: []
 - query: use hook-injected context when useful, but answer the current request first. Manual commands are diagnostics, not required daily workflow.
 - lint: agent helper for user-requested or wiki maintenance work. Do not run it every turn.
 - consolidate: safely refresh generated blocks in \`memory.md\`/\`index.md\`. Do not overwrite handwritten sections or curated document bodies.
-- maintenance: \`outputs/maintenance/queue.md\` stores stop/start cleanup candidates. Review surfaced durable candidates without delaying the current user request, then mark them \`done\` or \`skipped\`.
+- 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 +226,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.
 `,