@zosmaai/pi-llm-wiki 0.10.7 → 0.11.0

package/dist/extensions/llm-wiki/lib/utils.js

@@ -0,0 +1,347 @@
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, rmdirSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, relative, sep } from "node:path";
+/**
+ * Detect the vault format at a given directory.
+ * Returns "new" if .llm-wiki exists, "legacy" if .wiki exists,
+ * and "none" otherwise. A missing config is still a detected, damaged vault.
+ */
+export function detectVaultFormat(dir) {
+    if (existsSync(join(dir, ".llm-wiki")))
+        return "new";
+    if (existsSync(join(dir, ".wiki")))
+        return "legacy";
+    return "none";
+}
+/**
+ * Get the personal wiki root directory.
+ *
+ * The "root" follows the same contract as project wikis: it is the directory
+ * that *contains* the `.llm-wiki/` dot-dir, NOT the dot-dir itself.
+ * So the personal vault lives at `<root>/.llm-wiki/`.
+ *
+ * Default root: `homedir()` → personal vault at `~/.llm-wiki/`.
+ * Override:     `WIKI_HOME` env var → personal vault at `$WIKI_HOME/.llm-wiki/`.
+ *
+ * NOTE: Previously this returned `~/.llm-wiki` (the dot-dir itself), which
+ * caused `getVaultPaths()` to compose paths like `~/.llm-wiki/.llm-wiki/raw`.
+ * See `migrateDoubledPersonalVault()` for the one-shot recovery.
+ */
+export function getPersonalWikiRoot() {
+    const envWiki = process.env.WIKI_HOME;
+    if (envWiki)
+        return envWiki;
+    return homedir();
+}
+/** Get VaultPaths for the personal wiki. */
+export function getPersonalWikiPaths() {
+    return getVaultPaths(getPersonalWikiRoot());
+}
+/**
+ * One-shot, idempotent migration for vaults that were created with the broken
+ * `getPersonalWikiRoot()` (returned the dot-dir itself, so `getVaultPaths()`
+ * composed `<root>/.llm-wiki/.llm-wiki/...`).
+ *
+ * Detects a doubled layout at `<root>/.llm-wiki/.llm-wiki/config.json` and
+ * flattens it up by one level. Safe to call on every session start: if the
+ * doubled sentinel is absent, this is a no-op.
+ *
+ * Returns a description of the action taken (or `null` if no migration was
+ * needed) so callers can surface a one-line status message.
+ */
+export function migrateDoubledPersonalVault(parentRoot = getPersonalWikiRoot()) {
+    const outerDotWiki = join(parentRoot, ".llm-wiki");
+    const innerDotWiki = join(outerDotWiki, ".llm-wiki");
+    const innerSentinel = join(innerDotWiki, "config.json");
+    if (!existsSync(innerSentinel))
+        return null;
+    const moved = [];
+    const skipped = [];
+    for (const entry of readdirSync(innerDotWiki)) {
+        const src = join(innerDotWiki, entry);
+        const dest = join(outerDotWiki, entry);
+        if (existsSync(dest)) {
+            // Collision — leave the inner copy in place rather than clobber.
+            skipped.push(entry);
+            continue;
+        }
+        renameSync(src, dest);
+        moved.push(entry);
+    }
+    // Only remove the inner dir if it is fully drained.
+    if (skipped.length === 0) {
+        try {
+            rmdirSync(innerDotWiki);
+        }
+        catch {
+            // Leave behind if something raced us; harmless.
+        }
+    }
+    return { moved, from: innerDotWiki, to: outerDotWiki, skipped };
+}
+/**
+ * Check if a vault is the personal wiki location.
+ * Used in layered recall to avoid double-counting.
+ */
+export function isPersonalVault(paths) {
+    return paths.root === getPersonalWikiRoot();
+}
+/**
+ * Resolve vault root from cwd with personal fallback.
+ *
+ * Priority:
+ * 1. cwd has .llm-wiki/ → project wiki (explicit)
+ * 2. Walk up from cwd → parent project wiki
+ * 3. ~/.llm-wiki/ exists → personal wiki
+ * 4. Fallback: ~/.llm-wiki/ (create personal wiki)
+ */
+export function resolveVaultRoot(cwd) {
+    // A vault rooted at cwd is always the project-local choice.
+    if (detectVaultFormat(cwd) !== "none")
+        return cwd;
+    // An explicit WIKI_HOME is a testable/user-selected fallback and must win
+    // over an unrelated personal vault found while walking parent directories.
+    if (process.env.WIKI_HOME)
+        return process.env.WIKI_HOME;
+    // Walk up looking for a vault sentinel (new or legacy)
+    let dir = cwd;
+    while (dir !== dirname(dir)) {
+        dir = dirname(dir);
+        if (detectVaultFormat(dir) !== "none")
+            return dir;
+    }
+    // Check personal wiki at ~/.llm-wiki/
+    const personalRoot = getPersonalWikiRoot();
+    if (detectVaultFormat(personalRoot) !== "none")
+        return personalRoot;
+    // Fallback: personal wiki
+    return personalRoot;
+}
+/** Get all vault paths for the new (.llm-wiki) layout. */
+export function getVaultPaths(root) {
+    return {
+        root,
+        raw: join(root, ".llm-wiki", "raw"),
+        rawSources: join(root, ".llm-wiki", "raw", "sources"),
+        rawTrajectories: join(root, ".llm-wiki", "raw", "trajectories"),
+        wiki: join(root, ".llm-wiki", "wiki"),
+        meta: join(root, ".llm-wiki", "meta"),
+        dotWiki: join(root, ".llm-wiki"),
+        outputs: join(root, ".llm-wiki", "outputs"),
+        discoveries: join(root, ".llm-wiki", ".discoveries"),
+    };
+}
+/** Get all vault paths for the legacy (.wiki) layout. */
+export function getLegacyVaultPaths(root) {
+    return {
+        root,
+        raw: join(root, "raw"),
+        rawSources: join(root, "raw", "sources"),
+        rawTrajectories: join(root, "raw", "trajectories"),
+        wiki: join(root, "wiki"),
+        meta: join(root, "meta"),
+        dotWiki: join(root, ".wiki"),
+        outputs: join(root, "outputs"),
+        discoveries: join(root, ".discoveries"),
+    };
+}
+/**
+ * Resolve vault paths, auto-detecting new vs legacy layout.
+ * This is the main entry point: use this instead of resolveVaultRoot + getVaultPaths.
+ */
+export function resolveVaultPaths(cwd) {
+    const root = resolveVaultRoot(cwd);
+    const format = detectVaultFormat(root);
+    if (format === "legacy")
+        return getLegacyVaultPaths(root);
+    return getVaultPaths(root);
+}
+/** Ensure all vault directories exist. */
+export function ensureVaultStructure(paths) {
+    // NOTE: the agent-trajectory dirs (raw/trajectories, wiki/skills, wiki/cases)
+    // are intentionally NOT created here — they are created lazily on first
+    // capture/distill (issue #80), so a vault with the feature off carries no
+    // trace of it. All readers of these paths are existsSync-guarded.
+    const dirs = [
+        paths.rawSources,
+        join(paths.raw, "assets"),
+        join(paths.wiki, "sources"),
+        join(paths.wiki, "entities"),
+        join(paths.wiki, "concepts"),
+        join(paths.wiki, "syntheses"),
+        join(paths.wiki, "analyses"),
+        join(paths.wiki, "requirements"),
+        paths.meta,
+        paths.dotWiki,
+        paths.outputs,
+        paths.discoveries,
+        join(paths.dotWiki, "templates"),
+        join(paths.dotWiki, "templates", "pages"),
+    ];
+    for (const d of dirs)
+        mkdirSync(d, { recursive: true });
+}
+/** Read JSON file or return default. */
+export function readJson(path, defaultValue) {
+    try {
+        if (!existsSync(path))
+            return defaultValue;
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return defaultValue;
+    }
+}
+/** Write JSON file atomically. */
+export function writeJson(path, data) {
+    writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`, "utf-8");
+}
+/** Read text file or return empty string. */
+export function readText(path) {
+    try {
+        if (!existsSync(path))
+            return "";
+        return readFileSync(path, "utf-8");
+    }
+    catch {
+        return "";
+    }
+}
+/** Generate the next source ID. */
+export function nextSourceId(paths) {
+    return nextSequentialId(paths.rawSources, "SRC");
+}
+/** Generate the next trajectory ID. */
+export function nextTrajectoryId(paths) {
+    return nextSequentialId(paths.rawTrajectories, "TRJ");
+}
+/** Generate the next sequential, date-stamped packet ID for a raw subdir. */
+function nextSequentialId(dir, kind) {
+    const today = new Date().toISOString().split("T")[0];
+    const prefix = `${kind}-${today}`;
+    if (!existsSync(dir))
+        return `${prefix}-001`;
+    const dirs = readdirSync(dir)
+        .filter((d) => d.startsWith(prefix))
+        .sort();
+    if (dirs.length === 0)
+        return `${prefix}-001`;
+    const last = dirs[dirs.length - 1];
+    const num = Number.parseInt(last.slice(-3), 10);
+    return `${prefix}-${String(num + 1).padStart(3, "0")}`;
+}
+/**
+ * Slugify a title to a kebab-case page slug.
+ *
+ * - Folds full-width ASCII forms and ideographic spaces without changing
+ *   unrelated Unicode compatibility characters.
+ * - Collapses whitespace AND existing hyphens into a single `-`.
+ * - Trims leading/trailing hyphens.
+ * - Prefixes Windows reserved device names (CON, PRN, AUX, NUL, COM1-9,
+ *   LPT1-9, including superscript 1-3 forms) with `_`.
+ * - Appends `-page` to `index`/`log` slugs to avoid colliding with the
+ *   special INDEX/LOG wiki pages.
+ */
+export function slugify(title) {
+    const slug = title
+        .replace(/[\uFF01-\uFF5E]/g, (char) => String.fromCharCode(char.charCodeAt(0) - 0xfee0))
+        .replace(/\u3000/g, " ")
+        .toLowerCase()
+        .normalize("NFC")
+        .replace(/[^\p{L}\p{N}\s-]/gu, "")
+        .trim()
+        .replace(/[\s-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 80)
+        .replace(/[\uD800-\uDBFF]$/, "")
+        .replace(/^-+|-+$/g, "") || "untitled";
+    if (/^(?:con|prn|aux|nul|com(?:[1-9¹²³])|lpt(?:[1-9¹²³]))$/.test(slug)) {
+        return `_${slug}`;
+    }
+    return slug === "index" || slug === "log" ? `${slug}-page` : slug;
+}
+/** Format date as YYYY-MM-DD. */
+export function fmtDate(d = new Date()) {
+    return d.toISOString().split("T")[0];
+}
+/** Run a shell command via pi.exec and reject failed or cancelled commands. */
+export async function exec(pi, command, args, options) {
+    const result = await pi.exec(command, args, options ?? {});
+    if (result.killed)
+        throw new Error(`Command timed out or was aborted: ${command}`);
+    if (result.code !== 0) {
+        const detail = result.stderr.trim();
+        throw new Error(`Command failed (${command} exited ${result.code})${detail ? `: ${detail}` : ""}`);
+    }
+    return result;
+}
+function appendPath(base, ...parts) {
+    if (parts.length === 0)
+        return base;
+    return `${base}${base.endsWith(sep) ? "" : sep}${parts.join(sep)}`;
+}
+function realpathWithMissingTail(path, seen = new Set()) {
+    let current = path;
+    const tail = [];
+    while (true) {
+        try {
+            const stat = lstatSync(current);
+            if (stat.isSymbolicLink()) {
+                const symlinkPath = appendPath(realpathSync.native(dirname(current)), basename(current));
+                if (seen.has(symlinkPath))
+                    throw new Error(`Cannot resolve symlink cycle: ${path}`);
+                seen.add(symlinkPath);
+                const target = readlinkSync(current).toString();
+                const resolvedTarget = isAbsolute(target) ? target : appendPath(dirname(current), target);
+                return realpathWithMissingTail(appendPath(resolvedTarget, ...tail.reverse()), seen);
+            }
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        try {
+            return appendPath(realpathSync.native(current), ...tail.reverse());
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+            const parent = dirname(current);
+            if (parent === current)
+                throw error;
+            tail.push(basename(current));
+            current = parent;
+        }
+    }
+}
+/** Return the candidate path relative to the physical root. */
+export function relativePhysicalPath(rootPath, candidatePath) {
+    return relative(realpathWithMissingTail(rootPath), realpathWithMissingTail(candidatePath));
+}
+/** Check physical containment, resolving existing symlink ancestors. */
+export function isPathWithin(rootPath, candidatePath) {
+    const relation = relativePhysicalPath(rootPath, candidatePath);
+    return (relation === "" ||
+        (!isAbsolute(relation) && relation !== ".." && !relation.startsWith(`..${sep}`)));
+}
+/** Check if a path is inside a protected directory. */
+export function isProtectedPath(absPath, paths) {
+    try {
+        if (isPathWithin(paths.raw, absPath)) {
+            return {
+                protected: true,
+                reason: "Raw sources are immutable. Use wiki_capture_source to add sources.",
+            };
+        }
+        if (isPathWithin(paths.meta, absPath)) {
+            return {
+                protected: true,
+                reason: "Metadata is auto-generated. Use wiki_rebuild_meta or wiki_log_event instead.",
+            };
+        }
+        return { protected: false };
+    }
+    catch {
+        return { protected: true, reason: "Cannot safely resolve mutation path." };
+    }
+}

package/dist/extensions/llm-wiki/lib/vault-format.js

@@ -0,0 +1,247 @@
+import { existsSync, lstatSync, readFileSync, readdirSync } from "node:fs";
+import { isAbsolute, join, relative, sep } from "node:path";
+import { parseKnowledgeDocument, parseMarkdownFrontmatter, } from "./knowledge-document.js";
+import { relativePhysicalPath } from "./utils.js";
+export class VaultWriteError extends Error {
+    diagnostics;
+    constructor(diagnostics) {
+        super(diagnostics[0]?.message ?? "Wiki vault is not writable");
+        this.diagnostics = diagnostics;
+        this.name = "VaultWriteError";
+    }
+}
+const RESERVED_NAMES = new Set(["index", "log"]);
+export function compareCodePoint(a, b) {
+    const left = a.normalize("NFC");
+    const right = b.normalize("NFC");
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function diag(severity, code, path, message) {
+    return { severity, code, path, message };
+}
+function isReservedName(filename) {
+    const name = filename.toLowerCase();
+    return name === "index.md" || name === "log.md";
+}
+export function readVaultConfig(paths) {
+    const path = join(paths.dotWiki, "config.json");
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new Error("config.json must contain an object");
+        }
+        return { ok: true, config: parsed };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            diagnostic: diag("error", "config_invalid_knowledge_format", "config.json", `Cannot read valid wiki config: ${error.message}`),
+        };
+    }
+}
+export function inspectVaultFormat(paths) {
+    const diagnostics = [];
+    let blocking = false;
+    const configResult = readVaultConfig(paths);
+    if (!configResult.ok) {
+        return {
+            knowledgeFormat: "legacy",
+            diagnostics: [configResult.diagnostic],
+            blocking: true,
+        };
+    }
+    const config = configResult.config;
+    const rawFormat = config.knowledge_format;
+    // Resolve format
+    let format;
+    if (rawFormat === undefined) {
+        format = "legacy";
+    }
+    else if (rawFormat === "legacy" || rawFormat === "okf-0.2") {
+        format = rawFormat;
+    }
+    else {
+        return {
+            knowledgeFormat: "legacy",
+            diagnostics: [
+                diag("error", "config_invalid_knowledge_format", "config.json", `Invalid knowledge_format value: ${JSON.stringify(rawFormat)}`),
+            ],
+            blocking: true,
+        };
+    }
+    // In OKF mode, check root index version
+    // Missing root index is repairable; version mismatch blocks until explicitly handled
+    if (format === "okf-0.2") {
+        const rootIndexPath = join(paths.wiki, "index.md");
+        let rootContent;
+        try {
+            rootContent = readFileSync(rootIndexPath, "utf8");
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                diagnostics.push(diag("error", "okf_version_mismatch", "wiki/index.md", `Cannot read OKF root index: ${error.message}`));
+                blocking = true;
+            }
+        }
+        if (rootContent !== undefined) {
+            const frontmatter = parseMarkdownFrontmatter(rootContent, "index.md");
+            if (!frontmatter.ok || frontmatter.mapping.okf_version !== "0.2") {
+                diagnostics.push(diag("error", "okf_version_mismatch", "wiki/index.md", frontmatter.ok
+                    ? 'OKF root index must declare okf_version "0.2"'
+                    : `Malformed OKF root index: ${frontmatter.diagnostics[0].message}`));
+                blocking = true;
+            }
+        }
+    }
+    // In legacy mode, check if root index declares unsupported version
+    if (format === "legacy") {
+        const rootIndexPath = join(paths.wiki, "index.md");
+        try {
+            const content = readFileSync(rootIndexPath, "utf8");
+            const frontmatter = parseMarkdownFrontmatter(content, "index.md");
+            if (frontmatter.ok && frontmatter.mapping.okf_version !== undefined) {
+                if (frontmatter.mapping.okf_version !== "0.2") {
+                    diagnostics.push(diag("error", "okf_version_mismatch", "wiki/index.md", `Root index declares unsupported okf_version "${frontmatter.mapping.okf_version}"`));
+                    blocking = true;
+                }
+            }
+        }
+        catch {
+            // No root index in legacy mode - fine
+        }
+    }
+    return {
+        knowledgeFormat: format,
+        diagnostics,
+        blocking,
+    };
+}
+function collectMarkdownFiles(dir, wikiRoot) {
+    const files = [];
+    const diagnostics = [];
+    let entries;
+    try {
+        entries = readdirSync(dir).sort(compareCodePoint);
+    }
+    catch (error) {
+        diagnostics.push(diag("error", "frontmatter_parse_error", relative(wikiRoot, dir).replace(/\\/g, "/") || ".", `Failed to scan knowledge directory: ${error.message}`));
+        return { files, diagnostics };
+    }
+    for (const entry of entries) {
+        const fullPath = join(dir, entry);
+        try {
+            const stat = lstatSync(fullPath);
+            if (stat.isSymbolicLink())
+                continue;
+            if (stat.isDirectory()) {
+                const child = collectMarkdownFiles(fullPath, wikiRoot);
+                files.push(...child.files);
+                diagnostics.push(...child.diagnostics);
+            }
+            else if (stat.isFile() && entry.toLowerCase().endsWith(".md") && !isReservedName(entry)) {
+                files.push(fullPath);
+            }
+        }
+        catch (error) {
+            diagnostics.push(diag("error", "frontmatter_parse_error", relative(wikiRoot, fullPath).replace(/\\/g, "/"), `Failed to inspect knowledge path: ${error.message}`));
+        }
+    }
+    return { files, diagnostics };
+}
+/** Validate vault is writable: exists, valid mode, no blocking version mismatch. */
+export function inspectWritableVault(paths) {
+    // Check vault exists
+    if (!existsSync(paths.dotWiki)) {
+        return {
+            ok: false,
+            diagnostics: [
+                diag("error", "config_invalid_knowledge_format", paths.dotWiki, "Wiki vault not found. Run wiki_bootstrap first."),
+            ],
+        };
+    }
+    const state = inspectVaultFormat(paths);
+    if (state.blocking) {
+        return { ok: false, diagnostics: state.diagnostics };
+    }
+    return { ok: true, format: state.knowledgeFormat };
+}
+/** Assert that an authoritative writer may mutate this vault. */
+export function assertWritableVault(paths) {
+    const result = inspectWritableVault(paths);
+    if (!result.ok)
+        throw new VaultWriteError(result.diagnostics);
+    return result.format;
+}
+/** Check if path is a generated OKF reserved file (mode-aware). */
+export function isGeneratedOkfPath(path, paths) {
+    const state = inspectVaultFormat(paths);
+    if (state.blocking || state.knowledgeFormat !== "okf-0.2")
+        return false;
+    const rel = relativePhysicalPath(paths.wiki, path);
+    if (!rel || rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel))
+        return false;
+    const parts = rel.split(sep);
+    const name = parts.at(-1)?.toLowerCase();
+    return name === "index.md" || (parts.length === 1 && name === "log.md");
+}
+export function discoverKnowledgeDocuments(paths) {
+    const diagnostics = [];
+    const documents = [];
+    let blocking = false;
+    const seenIds = new Map();
+    const scan = collectMarkdownFiles(paths.wiki, paths.wiki);
+    diagnostics.push(...scan.diagnostics);
+    if (scan.diagnostics.length > 0)
+        blocking = true;
+    for (const file of scan.files) {
+        const physicalPath = relative(paths.wiki, file).replace(/\\/g, "/");
+        const normalizedPath = physicalPath.normalize("NFC");
+        const id = normalizedPath.replace(/\.md$/, "");
+        // Check for reserved names (case-insensitive)
+        const filename = (normalizedPath.split("/").pop() ?? "").replace(/\.md$/i, "").toLowerCase();
+        if (RESERVED_NAMES.has(filename)) {
+            continue;
+        }
+        // Check for identity collision
+        const collisionKey = id.toLowerCase();
+        const existing = seenIds.get(collisionKey);
+        if (existing && existing.physicalPath !== physicalPath) {
+            diagnostics.push(diag("error", "concept_identity_collision", physicalPath, `Identity collision between ${existing.physicalPath} and ${physicalPath}`));
+            blocking = true;
+            continue;
+        }
+        seenIds.set(collisionKey, { id, physicalPath });
+        // Parse the document
+        try {
+            const content = readFileSync(file, "utf8");
+            const result = parseKnowledgeDocument(content, normalizedPath);
+            if (!result.ok) {
+                diagnostics.push(...result.diagnostics);
+                blocking = true;
+                continue;
+            }
+            const doc = result.document;
+            if (result.diagnostics.length > 0) {
+                diagnostics.push(...result.diagnostics);
+            }
+            documents.push({
+                ...doc,
+                id,
+                path: normalizedPath,
+                absolutePath: file,
+            });
+        }
+        catch (e) {
+            const err = e;
+            diagnostics.push(diag("error", "frontmatter_parse_error", normalizedPath, `Failed to read file: ${err.message}`));
+            blocking = true;
+        }
+    }
+    // Sort documents by code point order
+    documents.sort((a, b) => compareCodePoint(a.id, b.id));
+    return {
+        documents,
+        diagnostics,
+        blocking,
+    };
+}

package/dist/extensions/llm-wiki/lib/visible-status.js

@@ -0,0 +1,31 @@
+import { MODEL_STATUS_KEY, formatActiveModelLabel } from "./model-command.js";
+import { noticesEnabled } from "./task-config.js";
+/**
+ * Apply the two post-session-start visible status lines (issue #77,
+ * regression-fixed in #83, comments + tests hardened in #84):
+ *
+ *   1. `🧠 LLM Wiki (… tools, … active)`     — the "wiki is loaded" badge
+ *   2. `🧠 wiki model: <label>`              — the active background task model
+ *
+ * Both are user-facing chat noise and are gated by `llm-wiki.notices`
+ * (default `true`). When `notices: false`, neither status is set — that's the
+ * contract the regression in #83 was about.
+ *
+ * Extracted from `index.ts` so the gating contract is unit-testable without
+ * faking the entire pi extension factory; see `test/visible-activity.test.ts`.
+ *
+ * Pure modulo `ui.setStatus`. Callers MUST run `runtime.ensureConfig(...)` for
+ * the current cwd before invoking this so `noticesEnabled(runtime.config)`
+ * sees the loaded project settings.
+ */
+export function applySessionStartStatus(opts) {
+    // Single gate for BOTH status lines (#83 added two adjacent guards; #84
+    // collapses them — same condition, same scope).
+    if (!noticesEnabled(opts.runtime.config))
+        return;
+    opts.ui.setStatus("llm-wiki", opts.trajectoriesOn
+        ? "🧠 LLM Wiki (16 tools, trajectory + observe + recall active)"
+        : "🧠 LLM Wiki (13 tools, observe + recall active)");
+    const modelLabel = formatActiveModelLabel(opts.runtime.config, opts.sessionModelId);
+    opts.ui.setStatus(MODEL_STATUS_KEY, `🧠 wiki model: ${modelLabel}`);
+}