llm-wiki-kit 0.1.4 → 0.1.6

package/src/consolidate.js

@@ -0,0 +1,203 @@
+import { join } from 'path';
+import { appendWikiLog } from './project.js';
+import { backupFile, exists, readText, writeText } from './fs-utils.js';
+import { hasSecretLikeText, isSensitivePath, normalizeForStorage } from './redaction.js';
+import { indexPage, memoryPage } from './templates.js';
+import { collectWikiPages } from './wiki-model.js';
+import { runLint } from './wiki-lint.js';
+
+export const MEMORY_START = '<!-- llm-wiki-kit:memory-start -->';
+export const MEMORY_END = '<!-- llm-wiki-kit:memory-end -->';
+export const INDEX_START = '<!-- llm-wiki-kit:index-start -->';
+export const INDEX_END = '<!-- llm-wiki-kit:index-end -->';
+
+function replaceOrAppendBlock(content, startMarker, endMarker, block) {
+  const replacement = `${startMarker}\n${block.trim()}\n${endMarker}`;
+  const firstStart = content.indexOf(startMarker);
+  const firstEnd = content.indexOf(endMarker);
+  if (firstStart === -1 && firstEnd === -1) {
+    return { next: `${content.trimEnd()}\n\n${replacement}\n`, malformed: false };
+  }
+  const lastStart = content.lastIndexOf(startMarker);
+  const lastEnd = content.lastIndexOf(endMarker);
+  if (firstStart === -1 || firstEnd === -1 || firstEnd < firstStart || lastStart > lastEnd) {
+    return { next: content, malformed: true };
+  }
+  return {
+    next: `${content.slice(0, firstStart)}${replacement}${content.slice(lastEnd + endMarker.length)}`,
+    malformed: false,
+  };
+}
+
+function pageTarget(page) {
+  return page.rel.replace(/^wiki\//, '').replace(/\.md$/i, '');
+}
+
+function pageReference(page) {
+  return `[[${pageTarget(page)}|${page.title}]]`;
+}
+
+function importance(page) {
+  const value = Number(page.frontmatter.importance || 0);
+  return Number.isFinite(value) ? value : 0;
+}
+
+function isPromotableEpisodicPage(page) {
+  return ['semantic', 'procedural'].includes(page.memoryType) && importance(page) >= 4;
+}
+
+function isGeneratedBlockCandidate(page) {
+  if (['wiki/index.md', 'wiki/log.md', 'wiki/memory.md'].includes(page.rel)) return false;
+  if (isSensitivePath(page.rel) || isSensitivePath(page.title)) return false;
+  if (hasSecretLikeText(`${page.rel}\n${page.title}\n${page.content}`)) return false;
+  const type = String(page.type || '').toLowerCase();
+  if (
+    type === 'query' ||
+    type === 'context' ||
+    type === 'session-log' ||
+    page.rel.startsWith('wiki/queries/') ||
+    page.rel.startsWith('wiki/context/')
+  ) {
+    return isPromotableEpisodicPage(page);
+  }
+  return true;
+}
+
+function sortedPages(pages) {
+  return pages
+    .filter(isGeneratedBlockCandidate)
+    .sort((a, b) => {
+      const importanceDiff = importance(b) - importance(a);
+      if (importanceDiff !== 0) return importanceDiff;
+      const typeDiff = String(a.type || '').localeCompare(String(b.type || ''));
+      if (typeDiff !== 0) return typeDiff;
+      return a.rel.localeCompare(b.rel);
+    });
+}
+
+function buildGeneratedMemoryBlock(pages) {
+  const candidates = sortedPages(pages).slice(0, 25);
+  const lines = [
+    '## Generated Memory Map',
+    '',
+    `- Pages indexed: ${sortedPages(pages).length}`,
+  ];
+  if (candidates.length === 0) {
+    lines.push('- No durable pages found yet.');
+    return lines.join('\n');
+  }
+  lines.push('', '### High-Value Pages');
+  for (const page of candidates) {
+    const metadata = [
+      page.type || 'unknown',
+      page.memoryType ? `memory:${page.memoryType}` : '',
+      importance(page) > 0 ? `importance:${importance(page)}` : '',
+      page.confidence ? `confidence:${page.confidence}` : '',
+    ].filter(Boolean).join(', ');
+    lines.push(`- ${pageReference(page)}${metadata ? ` - ${metadata}` : ''}`);
+  }
+  return lines.join('\n');
+}
+
+function buildGeneratedIndexBlock(pages) {
+  const groups = new Map();
+  const candidates = sortedPages(pages);
+  for (const page of candidates) {
+    const type = page.type || 'uncategorized';
+    if (!groups.has(type)) groups.set(type, []);
+    groups.get(type).push(page);
+  }
+
+  const lines = [
+    '## Generated Page Map',
+    '',
+    `- Pages indexed: ${candidates.length}`,
+  ];
+  if (groups.size === 0) {
+    lines.push('- No durable pages found yet.');
+    return lines.join('\n');
+  }
+  for (const type of [...groups.keys()].sort()) {
+    lines.push('', `### ${type}`);
+    for (const page of groups.get(type).slice(0, 50)) {
+      lines.push(`- ${pageReference(page)}`);
+    }
+  }
+  return lines.join('\n');
+}
+
+async function updateMarkedFile(projectRoot, rel, initialContent, startMarker, endMarker, block, options) {
+  const absolutePath = join(projectRoot, rel);
+  const current = await readText(absolutePath, initialContent);
+  const { next, malformed } = replaceOrAppendBlock(current || initialContent, startMarker, endMarker, block);
+  if (malformed) return { skipped: { path: rel, reason: 'malformed-marker' } };
+  if (normalizeForStorage(current) === normalizeForStorage(next)) return null;
+  if (!options.dryRun) {
+    if (await exists(absolutePath)) await backupFile(absolutePath, rel);
+    await writeText(absolutePath, next);
+  }
+  return { changed: { path: rel } };
+}
+
+export async function runConsolidate(projectRoot, options = {}) {
+  const lintResult = await runLint(projectRoot, { maxFiles: options.maxFiles || 1000 });
+  const pages = await collectWikiPages(projectRoot, { maxFiles: options.maxFiles || 1000 });
+  const changed = [];
+  const skipped = [];
+
+  const memoryChange = await updateMarkedFile(
+    projectRoot,
+    join('llm-wiki', 'wiki', 'memory.md'),
+    memoryPage(),
+    MEMORY_START,
+    MEMORY_END,
+    buildGeneratedMemoryBlock(pages),
+    options,
+  );
+  if (memoryChange?.changed) changed.push(memoryChange.changed);
+  if (memoryChange?.skipped) skipped.push(memoryChange.skipped);
+
+  const indexChange = await updateMarkedFile(
+    projectRoot,
+    join('llm-wiki', 'wiki', 'index.md'),
+    indexPage(),
+    INDEX_START,
+    INDEX_END,
+    buildGeneratedIndexBlock(pages),
+    options,
+  );
+  if (indexChange?.changed) changed.push(indexChange.changed);
+  if (indexChange?.skipped) skipped.push(indexChange.skipped);
+
+  const finalLintResult = options.dryRun || changed.length === 0
+    ? lintResult
+    : await runLint(projectRoot, { maxFiles: options.maxFiles || 1000 });
+
+  if (changed.length > 0 && !options.dryRun) {
+    await appendWikiLog(projectRoot, `consolidate: refreshed ${changed.map((item) => item.path).join(', ')}; lint errors=${finalLintResult.errorCount}; warnings=${finalLintResult.warningCount}`);
+  }
+
+  return {
+    workspace: projectRoot,
+    dryRun: Boolean(options.dryRun),
+    changed,
+    skipped,
+    lint: {
+      ok: finalLintResult.ok,
+      errorCount: finalLintResult.errorCount,
+      warningCount: finalLintResult.warningCount,
+    },
+  };
+}
+
+export function formatConsolidateResult(result) {
+  return [
+    'llm-wiki consolidate',
+    `- workspace: ${result.workspace}`,
+    `- dry run: ${result.dryRun ? 'yes' : 'no'}`,
+    `- changed: ${result.changed.length ? result.changed.map((item) => item.path).join(', ') : 'none'}`,
+    `- skipped: ${result.skipped?.length ? result.skipped.map((item) => `${item.path} (${item.reason})`).join(', ') : 'none'}`,
+    `- lint errors: ${result.lint.errorCount}`,
+    `- lint warnings: ${result.lint.warningCount}`,
+  ].join('\n');
+}

package/src/doctor.js

@@ -17,6 +17,8 @@ export async function runDoctor() {
   add('node >= 20', nodeMajor() >= 20, process.version);
   add('runtime version detected', Boolean(stat.runtimeVersion), stat.runtimeVersion || 'unknown');
   add('llm-wiki bin exists', await exists(stat.binPath), stat.binPath);
+  add('runtime installed from npm', stat.installSource === 'npm', `${stat.installSource}; npm install -g does not update source checkouts`);
+  add('llm-wiki command resolves to current runtime', stat.commandMatchesRuntime, stat.commandPath ? `command=${stat.commandPath}; runtime=${stat.binPath}` : 'command not found on PATH');
   add('Codex hook installed', stat.codexInstalled, stat.codexHooksPath);
   add('Claude hook installed', stat.claudeInstalled, stat.claudeSettingsPath);
   add('project templates current', stat.project.managedFilesCurrent, stat.project.statePath);

package/src/install.js

@@ -1,4 +1,6 @@
+import { realpathSync } from 'fs';
 import { chmod } from 'fs/promises';
+import { spawnSync } from 'child_process';
 import { join, resolve } from 'path';
 import { CLAUDE_EVENTS, CODEX_EVENTS, KIT_NAME } from './constants.js';
 import { backupFile, ensureDir, exists, homeDir, readJson, safeSymlink, writeJson } from './fs-utils.js';
@@ -15,6 +17,23 @@ export function hookCommand(provider, eventName) {
   return `${shellQuote(process.execPath)} ${shellQuote(binPath)} hook ${provider} ${eventName}`;
 }
 
+function llmWikiCommandPaths() {
+  const result = spawnSync('sh', ['-lc', 'which -a llm-wiki 2>/dev/null || true'], {
+    encoding: 'utf8',
+  });
+  if (result.error) return [];
+  return [...new Set(result.stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean))];
+}
+
+function realpathOrOriginal(path) {
+  if (!path) return null;
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+}
+
 function addHook(hooks, eventName, command, options = {}) {
   hooks[eventName] = Array.isArray(hooks[eventName]) ? hooks[eventName] : [];
   const already = JSON.stringify(hooks[eventName]).includes(command);
@@ -59,8 +78,10 @@ export async function install(options = {}) {
     await backupFile(localBinPath, 'local-bin-llm-wiki');
   }
   await safeSymlink(binPath, localBinPath);
-  await bootstrapProject(workspace, { profile: options.profile || 'standard', recordState: true });
-  await recordProject(workspace, 'install');
+  if (!options.noProject) {
+    await bootstrapProject(workspace, { profile: options.profile || 'standard', recordState: true });
+    await recordProject(workspace, 'install');
+  }
 
   const codexHooksPath = join(homeDir(), '.codex', 'hooks.json');
   const claudeSettingsPath = join(homeDir(), '.claude', 'settings.json');
@@ -151,11 +172,18 @@ export async function status(options = {}) {
   const claude = await readJson(claudeSettingsPath, {});
   const codexInstalled = JSON.stringify(codex.hooks || {}).includes(binPath);
   const claudeInstalled = JSON.stringify(claude.hooks || {}).includes(binPath);
+  const commandPaths = llmWikiCommandPaths();
+  const commandPath = commandPaths[0] || null;
+  const resolvedCommandPath = realpathOrOriginal(commandPath);
+  const resolvedBinPath = realpathOrOriginal(binPath);
   return {
     runtimeVersion: runtimeVersion(),
     packageRoot,
     installSource: detectInstallSource(),
     binPath,
+    commandPath,
+    commandPaths,
+    commandMatchesRuntime: Boolean(resolvedCommandPath && resolvedBinPath && resolvedCommandPath === resolvedBinPath),
     codexInstalled,
     claudeInstalled,
     hooksCurrent: codexInstalled && claudeInstalled,

package/src/project-state.js

@@ -1,7 +1,7 @@
 import { dirname, join, relative } from 'path';
 import { backupFile, ensureDir, exists, readJson, readText, sha256, writeJson, writeText } from './fs-utils.js';
 import { runtimeVersion } from './version.js';
-import { llmWikiAgents, procedure, rootAgentsPolicy } from './templates.js';
+import { llmWikiAgents, memoryPage, procedure, rootAgentsPolicy } from './templates.js';
 
 export const PROJECT_STATE_SCHEMA_VERSION = 1;
 export const PROJECT_STATE_FILE = '.kit-state.json';
@@ -27,7 +27,12 @@ function templateDescriptors() {
       path: join('llm-wiki', 'AGENTS.md'),
       content: llmWikiAgents(),
       mode: 'generated-file',
-      marker: 'Generated by llm-wiki-kit',
+    },
+    {
+      id: 'wiki-memory',
+      path: join('llm-wiki', 'wiki', 'memory.md'),
+      content: memoryPage(),
+      mode: 'create-only',
     },
     ...PROCEDURE_NAMES.map((name) => ({
       id: `procedure-${name.replace(/\.md$/, '')}`,
@@ -81,32 +86,45 @@ function replaceMarkedBlock(current, replacement) {
   return `${current.slice(0, start)}${replacement.trimStart().trimEnd()}${current.slice(afterEnd)}`;
 }
 
-function hasGeneratedMarker(text, descriptor) {
-  return descriptor.marker ? text.includes(descriptor.marker) : false;
+function markerStatus(current) {
+  const start = current.indexOf(ROOT_POLICY_START);
+  const end = current.indexOf(ROOT_POLICY_END);
+  if (start === -1 && end === -1) return 'missing';
+  if (start === -1 || end === -1 || end < start) return 'malformed';
+  return 'complete';
 }
 
 function isRecordedManaged(state, descriptor, currentText) {
   const recorded = state.managedTemplates?.[descriptor.id];
   if (!recorded) return false;
+  if (descriptor.mode === 'create-only') return true;
   if (descriptor.mode === 'marker') return true;
-  return !recorded.hash || recorded.hash === templateHash(currentText);
+  return Boolean(recorded.hash) && recorded.hash === templateHash(currentText);
 }
 
 function isKnownGeneratedContent(text, descriptor) {
+  if (descriptor.mode === 'create-only') return false;
   if (descriptor.mode === 'marker') return replaceMarkedBlock(text, descriptor.content) !== null;
-  return templateHash(text) === templateHash(descriptor.content) || hasGeneratedMarker(text, descriptor);
+  return templateHash(text) === templateHash(descriptor.content);
 }
 
-function canPatchDescriptor(state, descriptor, currentText) {
+function canPatchDescriptor(state, descriptor, currentText, fileExists = true) {
+  if (descriptor.mode === 'create-only') return !fileExists;
   if (descriptor.mode === 'marker') return replaceMarkedBlock(currentText, descriptor.content) !== null;
   return isRecordedManaged(state, descriptor, currentText) || isKnownGeneratedContent(currentText, descriptor);
 }
 
-function desiredTextForDescriptor(descriptor, currentText) {
+function desiredTextForDescriptor(descriptor, currentText, fileExists = true) {
+  if (descriptor.mode === 'create-only') return fileExists ? currentText : descriptor.content;
   if (descriptor.mode === 'marker') return replaceMarkedBlock(currentText, descriptor.content);
   return descriptor.content;
 }
 
+async function createOnlyParentExists(projectRoot, descriptor) {
+  if (descriptor.mode !== 'create-only') return true;
+  return exists(dirname(join(projectRoot, descriptor.path)));
+}
+
 export async function inspectProjectState(projectRoot) {
   const state = await readProjectState(projectRoot);
   const runtime = runtimeVersion();
@@ -116,12 +134,18 @@ export async function inspectProjectState(projectRoot) {
     const absolutePath = join(projectRoot, descriptor.path);
     const fileExists = await exists(absolutePath);
     const currentText = fileExists ? await readText(absolutePath) : '';
-    const desiredText = fileExists ? desiredTextForDescriptor(descriptor, currentText) : descriptor.content;
+    const desiredText = desiredTextForDescriptor(descriptor, currentText, fileExists);
     const desiredHash = templateHash(desiredText || descriptor.content);
     const currentHash = fileExists ? templateHash(currentText) : null;
     const recorded = state.managedTemplates[descriptor.id] || null;
-    const patchable = fileExists ? canPatchDescriptor(state, descriptor, currentText) : false;
-    const current = fileExists && desiredText !== null && currentHash === templateHash(desiredText);
+    const markerState = descriptor.mode === 'marker' && fileExists ? markerStatus(currentText) : null;
+    const parentExists = await createOnlyParentExists(projectRoot, descriptor);
+    const patchable = descriptor.mode === 'create-only' && !fileExists && !parentExists
+      ? false
+      : (markerState === 'malformed' || canPatchDescriptor(state, descriptor, currentText, fileExists));
+    const current = descriptor.mode === 'create-only'
+      ? fileExists
+      : fileExists && desiredText !== null && currentHash === templateHash(desiredText);
 
     files.push({
       id: descriptor.id,
@@ -133,6 +157,7 @@ export async function inspectProjectState(projectRoot) {
       desiredHash,
       recordedHash: recorded?.hash || null,
       recordedVersion: recorded?.version || null,
+      reason: markerState === 'malformed' ? 'malformed-marker' : null,
     });
   }
 
@@ -155,6 +180,14 @@ export async function recordManagedTemplates(projectRoot) {
     const absolutePath = join(projectRoot, descriptor.path);
     if (!(await exists(absolutePath))) continue;
     const currentText = await readText(absolutePath);
+    if (descriptor.mode === 'create-only') {
+      state.managedTemplates[descriptor.id] = {
+        path: descriptor.path,
+        version: runtime,
+        hash: templateHash(currentText),
+      };
+      continue;
+    }
     if (!canPatchDescriptor(state, descriptor, currentText)) continue;
     state.managedTemplates[descriptor.id] = {
       path: descriptor.path,
@@ -177,11 +210,43 @@ export async function applyProjectTemplateUpdate(projectRoot, options = {}) {
   for (const descriptor of templateDescriptors()) {
     const absolutePath = join(projectRoot, descriptor.path);
     if (!(await exists(absolutePath))) {
+      if (descriptor.mode === 'create-only') {
+        if (!(await createOnlyParentExists(projectRoot, descriptor))) {
+          skipped.push({ id: descriptor.id, path: descriptor.path, reason: 'missing-wiki' });
+          continue;
+        }
+        if (!options.dryRun) {
+          await ensureDir(dirname(absolutePath));
+          await writeText(absolutePath, descriptor.content, 'utf8');
+        }
+        changed.push({ id: descriptor.id, path: descriptor.path });
+        state.managedTemplates[descriptor.id] = {
+          path: descriptor.path,
+          version: runtime,
+          hash: templateHash(descriptor.content),
+        };
+        continue;
+      }
       skipped.push({ id: descriptor.id, path: descriptor.path, reason: 'missing' });
       continue;
     }
 
     const currentText = await readText(absolutePath);
+    if (descriptor.mode === 'marker' && markerStatus(currentText) === 'malformed') {
+      skipped.push({ id: descriptor.id, path: descriptor.path, reason: 'malformed-marker' });
+      continue;
+    }
+
+    if (descriptor.mode === 'create-only') {
+      unchanged.push({ id: descriptor.id, path: descriptor.path });
+      state.managedTemplates[descriptor.id] = {
+        path: descriptor.path,
+        version: runtime,
+        hash: templateHash(currentText),
+      };
+      continue;
+    }
+
     if (!canPatchDescriptor(state, descriptor, currentText)) {
       skipped.push({ id: descriptor.id, path: descriptor.path, reason: 'not-managed' });
       continue;

package/src/project.js

@@ -3,7 +3,6 @@ import {
   appendText,
   ensureDir,
   exists,
-  listMarkdownFiles,
   readText,
   timeKst,
   todayKst,
@@ -11,8 +10,9 @@ import {
 } from './fs-utils.js';
 import { LLM_WIKI_DIRS } from './constants.js';
 import { normalizeForStorage, redactText, summarizeForStorage } from './redaction.js';
-import { gitignore, indexPage, llmWikiAgents, logPage, procedure, rootAgentsPolicy } from './templates.js';
+import { gitignore, indexPage, llmWikiAgents, logPage, memoryPage, procedure, rootAgentsPolicy } from './templates.js';
 import { recordManagedTemplates } from './project-state.js';
+import { buildContextPack, formatContextPack, searchWiki as searchWikiWithIndex } from './wiki-search.js';
 
 export async function bootstrapProject(projectRoot, options = {}) {
   if (process.env.LLM_WIKI_KIT_DISABLE_BOOTSTRAP === '1') return { created: false };
@@ -28,6 +28,7 @@ export async function bootstrapProject(projectRoot, options = {}) {
 
   await maybeCreate(join(base, 'AGENTS.md'), llmWikiAgents());
   await maybeCreate(join(base, 'wiki', 'index.md'), indexPage());
+  await maybeCreate(join(base, 'wiki', 'memory.md'), memoryPage());
   await maybeCreate(join(base, 'wiki', 'log.md'), logPage());
   await maybeCreate(join(base, '.gitignore'), gitignore());
   for (const name of ['ingest.md', 'query.md', 'lint.md', 'security.md']) {
@@ -128,7 +129,7 @@ export async function writeQueryPage(projectRoot, entry) {
   const slug = slugify(entry.question, 'query');
   const path = join(projectRoot, 'llm-wiki', 'wiki', 'queries', `${day}-${slug}.md`);
   if (await exists(path)) return path;
-  const content = `---\ntitle: "${entry.topic || slug}"\ntype: "query"\nsource_ids: []\nstatus: "draft"\nlast_updated: "${day}"\nconfidence: "medium"\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 content = `---\ntitle: "${entry.topic || slug}"\ntype: "query"\nsource_ids: []\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`;
   await writeTextIfMissing(path, redactText(content, 12000));
   return path;
 }
@@ -141,7 +142,7 @@ export async function writeDecisionPage(projectRoot, entry) {
   const slug = slugify(entry.topic || entry.question || 'decision', 'decision');
   const path = join(projectRoot, 'llm-wiki', 'wiki', 'decisions', `${day}-${slug}.md`);
   if (await exists(path)) return path;
-  const content = `---\ntitle: "${entry.topic || slug}"\ntype: "decision"\nsource_ids: []\nstatus: "draft"\nlast_updated: "${day}"\nconfidence: "medium"\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 content = `---\ntitle: "${entry.topic || slug}"\ntype: "decision"\nsource_ids: []\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`;
   await writeTextIfMissing(path, redactText(content, 12000));
   return path;
 }
@@ -153,59 +154,14 @@ export async function appendContextNote(projectRoot, eventName, text) {
   await appendText(path, block);
 }
 
-function tokenize(text) {
-  return String(text || '')
-    .toLowerCase()
-    .replace(/[^\p{Letter}\p{Number}]+/gu, ' ')
-    .split(/\s+/)
-    .filter((token) => token.length >= 2)
-    .slice(0, 80);
-}
-
 export async function searchWiki(projectRoot, query, limit = 5) {
-  const wikiRoot = join(projectRoot, 'llm-wiki', 'wiki');
-  const files = await listMarkdownFiles(wikiRoot, 400);
-  const terms = tokenize(query);
-  if (terms.length === 0) return [];
-  const scored = [];
-  for (const file of files) {
-    const raw = await readText(file);
-    const content = raw.slice(0, 50000);
-    const lower = content.toLowerCase();
-    let score = 0;
-    for (const term of terms) {
-      if (lower.includes(term)) score += term.length > 3 ? 2 : 1;
-    }
-    if (score > 0) {
-      const rel = relative(join(projectRoot, 'llm-wiki'), file);
-      scored.push({
-        score,
-        path: rel,
-        snippet: content.replace(/\s+/g, ' ').slice(0, 350),
-      });
-    }
-  }
-  return scored.sort((a, b) => b.score - a.score).slice(0, limit);
+  return searchWikiWithIndex(projectRoot, query, typeof limit === 'number' ? { limit } : limit);
 }
 
 export async function buildContextBrief(projectRoot, eventName, query = '') {
-  const index = await readText(join(projectRoot, 'llm-wiki', 'wiki', 'index.md'));
-  const log = await readText(join(projectRoot, 'llm-wiki', 'wiki', 'log.md'));
-  const hits = query ? await searchWiki(projectRoot, query, 5) : [];
-  const parts = [
-    'LLM Wiki context from llm-wiki-kit:',
-    '- Treat chat memory as temporary; update project Markdown when knowledge should persist.',
-    '- Preserve raw/wiki separation. Do not store secrets, tokens, .env contents, private keys, or personal/customer identifiers.',
-    '- Prefer updating existing wiki pages over creating duplicate pages.',
-    '',
-    'Index excerpt:',
-    index.slice(0, 1200).trim(),
-  ];
-  if (hits.length > 0) {
-    parts.push('', 'Relevant wiki pages:', ...hits.map((hit) => `- ${hit.path}: ${hit.snippet}`));
-  }
-  if (eventName === 'SessionStart') {
-    parts.push('', 'Recent log excerpt:', log.slice(-1000).trim());
-  }
-  return parts.join('\n').trim();
+  const pack = await buildContextPack(projectRoot, query, {
+    includeLog: eventName === 'SessionStart',
+    limit: 5,
+  });
+  return formatContextPack(pack);
 }