@zosmaai/pi-llm-wiki 0.11.4 → 0.11.6

package/dist/extensions/llm-wiki/lib/settings-command.js

@@ -0,0 +1,377 @@
+import { homedir } from "node:os";
+import { Container, Input, SettingsList, Spacer, Text, } from "@mariozechner/pi-tui";
+import { loadTaskConfig, loadTaskConfigSources, parseModelRef, persistSetting, trajectoriesEnabled, } from "./task-config.js";
+const SETTINGS = [
+    {
+        key: "taskModel",
+        label: "Model",
+        type: "model",
+        hint: "Model for background wiki tasks (provider/id).",
+        menuLabel: "Task model — provider/id, empty = session model",
+        format: (v) => {
+            const m = v;
+            return m ? `${m.provider}/${m.id}` : "(session model)";
+        },
+        toEdit: (v) => {
+            const m = v;
+            return m ? `${m.provider}/${m.id}` : "";
+        },
+        parse: (input) => parseModelRef(input),
+    },
+    {
+        key: "synthesisMaxTokens",
+        label: "Synthesis Tokens",
+        type: "number",
+        hint: "Max output tokens for wiki synthesis runs.",
+        defaultText: "16384",
+        format: (v) => (v != null ? String(v) : "16384 (default)"),
+        toEdit: (v) => (v != null ? String(v) : "16384"),
+        parse: (input) => {
+            const n = Number(input);
+            if (!Number.isFinite(n) || n <= 0)
+                return undefined;
+            return Math.floor(n);
+        },
+    },
+    {
+        key: "trajectories",
+        label: "Trajectories",
+        type: "boolean",
+        hint: "Capture agent trajectories into the vault.",
+        format: (v) => (v ? "ON" : "OFF"),
+        toEdit: () => "",
+        parse: (input) => Boolean(Boolean(input) && /on|true|1/i.test(input)),
+    },
+    {
+        key: "notices",
+        label: "Notices",
+        type: "boolean",
+        hint: "Show wiki recall/observation notice lines in chat.",
+        format: (v) => (v != null ? (v ? "ON" : "OFF") : "ON (default)"),
+        toEdit: () => "",
+        parse: (input) => Boolean(Boolean(input) && /on|true|1/i.test(input)),
+    },
+    {
+        key: "ambientPersonalVault",
+        label: "Ambient Personal",
+        type: "boolean",
+        hint: "Include the personal vault in ambient session context.",
+        format: (v) => (v != null ? (v ? "ON" : "OFF") : "host-dependent"),
+        toEdit: () => "",
+        parse: (input) => Boolean(Boolean(input) && /on|true|1/i.test(input)),
+    },
+    {
+        key: "synthesisLanguage",
+        label: "Synthesis Language",
+        type: "string",
+        hint: "Language for synthesized wiki content.",
+        defaultText: "en",
+        format: (v) => (v ? String(v) : "en (default)"),
+        toEdit: (v) => (v ? String(v) : "en"),
+        parse: (input) => {
+            const trimmed = input.trim();
+            return trimmed || undefined;
+        },
+    },
+    {
+        key: "semanticWeight",
+        label: "Semantic Weight",
+        type: "number",
+        hint: "0–1 weight for embedding (semantic) recall.",
+        defaultText: "0.5",
+        format: (v) => (v != null ? String(v) : "0.5 (default)"),
+        toEdit: (v) => (v != null ? String(v) : "0.5"),
+        parse: (input) => {
+            const n = Number(input);
+            if (!Number.isFinite(n) || n < 0 || n > 1)
+                return undefined;
+            return n;
+        },
+    },
+    {
+        key: "recallLinksThreshold",
+        label: "Recall Links",
+        type: "number",
+        hint: "Max recall links shown when the vault is large.",
+        defaultText: "50",
+        format: (v) => (v != null ? String(v) : "50 (default)"),
+        toEdit: (v) => (v != null ? String(v) : "50"),
+        parse: (input) => {
+            const n = Number(input);
+            if (!Number.isFinite(n) || n < 0)
+                return undefined;
+            return Math.floor(n);
+        },
+    },
+    {
+        key: "recallSkillInlineMax",
+        label: "Skill Inline Max",
+        type: "number",
+        hint: "Max characters inlined from recall into skill prompts.",
+        defaultText: "1600",
+        format: (v) => (v != null ? String(v) : "1600 (default)"),
+        toEdit: (v) => (v != null ? String(v) : "1600"),
+        parse: (input) => {
+            const n = Number(input);
+            if (!Number.isFinite(n) || n < 0)
+                return undefined;
+            return Math.floor(n);
+        },
+    },
+    {
+        key: "embeddingProvider",
+        label: "Embedding Provider",
+        type: "string",
+        hint: "Embedding provider (e.g. openai). Empty = embeddings disabled.",
+        format: (v) => (v ? String(v) : "(disabled)"),
+        toEdit: (v) => (v ? String(v) : ""),
+        parse: (input) => input.trim() || undefined,
+    },
+    {
+        key: "embeddingModel",
+        label: "Embedding Model",
+        type: "string",
+        hint: "Embedding model id.",
+        defaultText: "text-embedding-3-small",
+        format: (v) => (v ? String(v) : "text-embedding-3-small (default)"),
+        toEdit: (v) => (v ? String(v) : "text-embedding-3-small"),
+        parse: (input) => input.trim() || undefined,
+    },
+    {
+        key: "embeddingBaseUrl",
+        label: "Embedding Base URL",
+        type: "string",
+        hint: "Custom embeddings API base URL (optional).",
+        format: (v) => (v ? String(v) : "—"),
+        toEdit: (v) => (v ? String(v) : ""),
+        parse: (input) => input.trim() || undefined,
+    },
+    {
+        key: "embeddingApiKeyEnv",
+        label: "Embedding API Key Env",
+        type: "string",
+        hint: "Environment variable name holding the embeddings API key.",
+        defaultText: "OPENAI_API_KEY",
+        format: (v) => (v ? String(v) : "OPENAI_API_KEY (default)"),
+        toEdit: (v) => (v ? String(v) : "OPENAI_API_KEY"),
+        parse: (input) => input.trim() || undefined,
+    },
+];
+function isInsideHome(cwd) {
+    return cwd.startsWith(homedir());
+}
+/**
+ * Map effective settings + sources to pi-tui SettingItems.
+ *
+ * Exported for tests. `notify` is used by edit menus to report invalid input
+ * without closing the menu.
+ */
+export function buildSettingItems(sources, notify) {
+    return SETTINGS.map((def) => {
+        const entry = sources[def.key];
+        const value = entry?.value;
+        const source = entry?.source ?? "default";
+        const item = {
+            id: def.key,
+            label: def.label,
+            currentValue: def.format(value),
+            description: describeSetting(def, source),
+        };
+        if (def.type === "boolean") {
+            item.values = ["OFF", "ON"];
+            return item;
+        }
+        item.submenu = (_display, done) => {
+            const sub = new InputSubmenu(def.menuLabel ?? `Set ${def.label}`, def.toEdit(value));
+            sub.input.onSubmit = (raw) => {
+                const trimmed = raw.trim();
+                if (def.type === "model") {
+                    if (!trimmed) {
+                        done(""); // clear → back to session model
+                        return;
+                    }
+                    const ref = parseModelRef(trimmed);
+                    if (!ref) {
+                        notify(`LLM Wiki: could not parse "${trimmed}". Use provider/id.`, "error");
+                        return; // stay in the menu
+                    }
+                    done(`${ref.provider}/${ref.id}`);
+                    return;
+                }
+                if (!trimmed) {
+                    done(); // empty = no change
+                    return;
+                }
+                const parsed = def.parse(trimmed);
+                if (parsed === undefined) {
+                    notify(`LLM Wiki: invalid value "${trimmed}" for ${def.label}`, "error");
+                    return; // stay in the menu
+                }
+                done(String(parsed));
+            };
+            sub.input.onEscape = () => done();
+            return sub;
+        };
+        return item;
+    });
+}
+function describeSetting(def, source) {
+    const where = source === "default" ? "Not set — using default." : `Set in ${source} settings.`;
+    return `${def.hint}\n${where}`;
+}
+/**
+ * Parse the display string a SettingItem cycled/edited into back into the
+ * typed value to persist.
+ */
+function parseDisplay(def, display) {
+    if (def.type === "boolean")
+        return display === "ON";
+    if (def.type === "model")
+        return display ? parseModelRef(display) : undefined;
+    return def.parse(display);
+}
+function buildSettingsListTheme(theme) {
+    return {
+        label: (text, selected) => (selected ? theme.fg("accent", text) : text),
+        value: (text, selected) => (selected ? theme.fg("accent", text) : theme.fg("muted", text)),
+        description: (text) => theme.fg("dim", text),
+        cursor: theme.fg("accent", "→ "),
+        hint: (text) => theme.fg("dim", text),
+    };
+}
+/** Title + single-line input. SettingsList forwards all key input here. */
+class InputSubmenu extends Container {
+    input;
+    constructor(label, initialValue) {
+        super();
+        this.addChild(new Text(label, 0, 0));
+        this.input = new Input();
+        // Type the prefill instead of setValue(): setValue keeps the cursor at 0,
+        // which makes backspace no-op and typed input land before the prefill.
+        if (initialValue)
+            this.input.handleInput(initialValue);
+        this.addChild(this.input);
+    }
+    handleInput(data) {
+        this.input.handleInput(data);
+    }
+}
+/** Header + settings list. ui.custom gives this component focus. */
+class SettingsScreen extends Container {
+    list;
+    titleText;
+    constructor(title, list) {
+        super();
+        this.list = list;
+        this.titleText = new Text(title, 0, 0);
+        this.addChild(this.titleText);
+        this.addChild(new Spacer(1));
+        this.addChild(list);
+    }
+    handleInput(data) {
+        this.list.handleInput(data);
+    }
+    /** Update the header line in place (scope changes re-target it live). */
+    setTitle(title) {
+        this.titleText.setText(title);
+    }
+}
+/** Build the header title for the scope currently being written to. */
+function scopeTitle(scope) {
+    return `\u{1F9E0} LLM Wiki Settings \u2014 ${scope === "global" ? "Global" : "Project"} (Esc to close)`;
+}
+async function showSettingsTui(ui, cwd, scope) {
+    if (typeof ui.custom !== "function") {
+        ui.notify("LLM Wiki: this host does not support the settings screen. Edit settings.json directly.", "warning");
+        return;
+    }
+    // The editable Scope row re-targets where subsequent writes land; the
+    // picker / inside-home heuristic only chooses the starting value.
+    let writeScope = scope;
+    const scopeItem = {
+        id: "scope",
+        label: "Scope",
+        currentValue: writeScope === "global" ? "Global" : "Project",
+        values: ["Global", "Project"],
+        description: "Where edits are written. Global \u2192 ~/.pi/agent/settings.json \u00b7 Project \u2192 .pi/settings.json (this folder).",
+    };
+    const items = [scopeItem, ...buildSettingItems(loadTaskConfigSources(cwd), ui.notify.bind(ui))];
+    // Tracks the effective value so the reload note fires on actual changes.
+    let prevTrajectories = trajectoriesEnabled(loadTaskConfig(cwd));
+    let list;
+    let screenRef;
+    await ui.custom((_tui, theme, _keybindings, close) => {
+        list = new SettingsList(items, items.length, buildSettingsListTheme(theme), (id, display) => {
+            if (!list)
+                return;
+            // Scope row: re-target writes; nothing is persisted for it.
+            if (id === "scope") {
+                writeScope = display === "Global" ? "global" : "project";
+                list.updateValue("scope", display);
+                screenRef?.setTitle(scopeTitle(writeScope));
+                ui.notify(`LLM Wiki: writing to ${writeScope === "global"
+                    ? "Global (~/.pi/agent/settings.json)"
+                    : "Project (.pi/settings.json)"}`);
+                return;
+            }
+            const def = SETTINGS.find((d) => d.key === id);
+            if (!def)
+                return;
+            const value = parseDisplay(def, display);
+            // Non-model, non-boolean values are validated before done(); undefined
+            // here is only expected for the model-clear case.
+            if (value === undefined && def.type !== "model")
+                return;
+            try {
+                persistSetting(cwd, writeScope, def.key, value);
+            }
+            catch (err) {
+                ui.notify(`LLM Wiki: failed to save ${def.label}: ${err instanceof Error ? err.message : String(err)}`, "error");
+                return;
+            }
+            // Normalize the displayed value in place (e.g. cleared model shows
+            // "(session model)"; "0.50" becomes "0.5").
+            list.updateValue(id, def.format(value));
+            // trajectories gates tool registration at startup, so a live toggle
+            // cannot add/remove the 3 tools mid-session \u2014 say so on real changes.
+            if (def.key === "trajectories") {
+                const next = Boolean(value);
+                if (next !== prevTrajectories) {
+                    prevTrajectories = next;
+                    ui.notify("LLM Wiki: trajectory tools register at startup \u2014 new value applies after a reload");
+                }
+            }
+        }, () => close());
+        screenRef = new SettingsScreen(scopeTitle(writeScope), list);
+        return screenRef;
+    });
+}
+/**
+ * Register the /wiki-settings command.
+ */
+export function registerWikiSettingsCommand(pi, runtime) {
+    pi.registerCommand("wiki-settings", {
+        description: "View and edit LLM Wiki settings (model, tokens, behaviors, embeddings)",
+        handler: async (_args, ctx) => {
+            runtime.ensureConfig(ctx.cwd);
+            if (!ctx.hasUI) {
+                ctx.ui.notify("LLM Wiki: /wiki-settings requires an interactive UI. Edit settings.json directly instead.", "warning");
+                return;
+            }
+            let scope;
+            if (isInsideHome(ctx.cwd)) {
+                scope = "global";
+            }
+            else {
+                const pick = await ctx.ui.select("LLM Wiki \u2014 Settings scope?", [
+                    `Project (${ctx.cwd}/.pi/settings.json)`,
+                    "Global (~/.pi/agent/settings.json)",
+                ]);
+                if (pick === undefined)
+                    return;
+                scope = pick.startsWith("Project") ? "project" : "global";
+            }
+            await showSettingsTui(ctx.ui, ctx.cwd, scope);
+        },
+    });
+}

package/dist/extensions/llm-wiki/lib/task-config.js

@@ -1,7 +1,7 @@
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { parse as parseYaml } from "yaml";
-import { detectHost, listGlobalSettingsFiles, listProjectSettingsFiles, resolveProjectSettingsPath, } from "./host.js";
+import { detectHost, listGlobalSettingsFiles, listProjectSettingsFiles, resolveGlobalSettingsPath, resolveProjectSettingsPath, } from "./host.js";
 export const TASK_DEFAULTS = {};
 /**
  * Resolve whether user-facing wiki notices are enabled (issue #77). Defaults
@@ -10,6 +10,23 @@ export const TASK_DEFAULTS = {};
 export function noticesEnabled(config) {
     return config?.notices !== false;
 }
+const WIKILINK_VALIDATION_MODES = [
+    "off",
+    "warn",
+    "strict",
+    "normalize",
+];
+/**
+ * Resolve the wikilink write-gate mode (issue #172, Layer 2). Defaults to
+ * `warn` — ingest always writes and reports; only an explicit `strict` blocks.
+ * Unknown values fall back to `warn` rather than failing the ingest.
+ */
+export function resolveWikilinkValidation(config) {
+    const v = config?.wikilinkValidation;
+    if (v && WIKILINK_VALIDATION_MODES.includes(v))
+        return v;
+    return "warn";
+}
 /**
  * Resolve whether the personal vault may serve as this project's ambient
  * vault. Explicit `ambientPersonalVault` wins; otherwise the host decides
@@ -87,6 +104,14 @@ function readNamespacedConfig(path) {
             if (canonical)
                 out.synthesisLanguage = canonical;
         }
+        const maxTokens = section.synthesisMaxTokens;
+        if (typeof maxTokens === "number" && Number.isFinite(maxTokens) && maxTokens > 0) {
+            out.synthesisMaxTokens = Math.floor(maxTokens);
+        }
+        const wl = section.wikilinkValidation;
+        if (typeof wl === "string" && WIKILINK_VALIDATION_MODES.includes(wl)) {
+            out.wikilinkValidation = wl;
+        }
         return out;
     }
     catch {
@@ -156,6 +181,19 @@ function readSettingsObject(path) {
     }
     return {};
 }
+/**
+ * Rewrite the `llm-wiki` section of the global settings file.
+ */
+function updateGlobalSection(mutate) {
+    const settingsPath = resolveGlobalSettingsPath();
+    const raw = readSettingsObject(settingsPath);
+    const existing = raw[SETTINGS_KEY];
+    const section = existing && typeof existing === "object" ? { ...existing } : {};
+    mutate(section);
+    raw[SETTINGS_KEY] = section;
+    mkdirSync(dirname(settingsPath), { recursive: true });
+    writeFileSync(settingsPath, `${JSON.stringify(raw, null, 2)}\n`, "utf-8");
+}
 /**
  * Rewrite the `llm-wiki` section of the project settings file, preserving every
  * other top-level key and every other setting in the section.
@@ -224,3 +262,64 @@ export function loadTaskConfig(cwd) {
     }
     return config;
 }
+/**
+ * Resolve where each setting is defined: project > global > default.
+ */
+/** All known setting keys — needed because TASK_DEFAULTS is {} (zero-config). */
+const KNOWN_KEYS = [
+    "taskModel",
+    "embeddingProvider",
+    "embeddingModel",
+    "embeddingBaseUrl",
+    "embeddingApiKey",
+    "embeddingApiKeyEnv",
+    "semanticWeight",
+    "recallLinksThreshold",
+    "recallSkillInlineMax",
+    "notices",
+    "ambientPersonalVault",
+    "trajectories",
+    "synthesisLanguage",
+    "synthesisMaxTokens",
+    "wikilinkValidation",
+];
+export function loadTaskConfigSources(cwd) {
+    const globalResult = {};
+    for (const path of listGlobalSettingsFiles()) {
+        Object.assign(globalResult, readNamespacedConfig(path));
+    }
+    const projectResult = {};
+    for (const path of listProjectSettingsFiles(cwd)) {
+        Object.assign(projectResult, readNamespacedConfig(path));
+    }
+    const effective = loadTaskConfig(cwd);
+    const out = {};
+    for (const key of KNOWN_KEYS) {
+        if (key in projectResult)
+            out[key] = { value: projectResult[key], source: "project" };
+        else if (key in globalResult)
+            out[key] = { value: globalResult[key], source: "global" };
+        else
+            out[key] = { value: effective[key], source: "default" };
+    }
+    return out;
+}
+/**
+ * Generic setting persist: writes any single setting to the chosen scope.
+ */
+export function persistSetting(cwd, scope, key, value) {
+    const mutate = (section) => {
+        if (value === undefined || value === null) {
+            delete section[key];
+        }
+        else {
+            section[key] = value;
+        }
+    };
+    if (scope === "project") {
+        updateProjectSection(cwd, mutate);
+    }
+    else if (scope === "global") {
+        updateGlobalSection(mutate);
+    }
+}

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

@@ -6,11 +6,11 @@ import { launchEmbedPages, reindexEmbeddings, resolveEmbedder } from "./embeddin
 import { scheduleReindex } from "./indexing.js";
 import { runIngestSynthesis } from "./ingest-worker.js";
 import { createKnowledgeDocument, serializeKnowledgeDocument, writeKnowledgeDocumentFile, } from "./knowledge-document.js";
-import { buildResolvedBacklinks } from "./knowledge-links.js";
+import { applyWikilinkGate, buildResolvedBacklinks, buildWikilinkIndex, } from "./knowledge-links.js";
 import { repairLegacyKnowledgeDocuments } from "./legacy-repair.js";
 import { appendEvent, rebuildMetadata, rebuildMetadataLight } from "./metadata.js";
 import { captureFile, captureText, captureUrl } from "./source-packet.js";
-import { parseModelRef } from "./task-config.js";
+import { loadTaskConfig, parseModelRef, resolveWikilinkValidation } from "./task-config.js";
 import { detectVaultFormat, fmtDate, getVaultPaths, readJson, resolveVaultPaths, slugify, writeJson, } from "./utils.js";
 import { assertWritableVault, compareCodePoint, discoverKnowledgeDocuments, inspectVaultFormat, inspectWritableVault, } from "./vault-format.js";
 import { getWikiStatus, searchRegistry } from "./wiki-service.js";
@@ -328,6 +328,7 @@ export function registerWikiIngest(pi, runtime) {
                                 manifest: s.manifest,
                                 extracted: s.extracted,
                                 synthesisLanguage: runtime.config.synthesisLanguage,
+                                wikilinkValidation: runtime.config.wikilinkValidation,
                             });
                             if (committed) {
                                 // Background semantic embeddings (#66): embed the pages this
@@ -341,8 +342,10 @@ export function registerWikiIngest(pi, runtime) {
                                 ];
                                 launchEmbedPages(runtime, launchCtx, paths, pageIds, `embed:ingest:${s.id}`);
                             }
+                            const wl = committed?.wikilinkDiagnostics?.length ?? 0;
+                            const wlNote = wl > 0 ? `, ${wl} wikilink issue${wl === 1 ? "" : "s"}` : "";
                             const summary = committed
-                                ? `LLM Wiki: ingested ${s.id} → ${committed.entitiesCreated.length} entit${committed.entitiesCreated.length === 1 ? "y" : "ies"}, ${committed.conceptsCreated.length} concept${committed.conceptsCreated.length === 1 ? "" : "s"}`
+                                ? `LLM Wiki: ingested ${s.id} → ${committed.entitiesCreated.length} entit${committed.entitiesCreated.length === 1 ? "y" : "ies"}, ${committed.conceptsCreated.length} concept${committed.conceptsCreated.length === 1 ? "" : "s"}${wlNote}`
                                 : `LLM Wiki: ${s.id} produced no synthesis`;
                             if (ctx.hasUI) {
                                 ctx.ui.notify(summary, committed ? "info" : "warning");
@@ -459,7 +462,31 @@ export function registerWikiEnsurePage(pi, runtime) {
                 };
             }
             const today = fmtDate();
-            const body = params.content ?? buildPageBody(type, params.title);
+            let body = params.content ?? buildPageBody(type, params.title);
+            // Pre-write wikilink gate (#172): validate/normalize caller-supplied content.
+            const mode = resolveWikilinkValidation(loadTaskConfig(ctx.cwd));
+            let wikilinkIssues = [];
+            if (mode !== "off") {
+                const registry = readJson(join(paths.meta, "registry.json"), { pages: {} });
+                const gate = applyWikilinkGate(body, buildWikilinkIndex(Object.keys(registry.pages)), `${folder}/${slug}`, mode);
+                wikilinkIssues = gate.diagnostics.map((d) => d.message);
+                if (!gate.ok) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Rejected write — unresolved/ambiguous wikilinks:\n${wikilinkIssues
+                                    .map((m) => `- ${m}`)
+                                    .join("\n")}`,
+                            },
+                        ],
+                        details: { error: "link_validation", issues: wikilinkIssues },
+                        isError: true,
+                    };
+                }
+                if (mode === "normalize")
+                    body = gate.body;
+            }
             const doc = createKnowledgeDocument(`${folder}/${slug}.md`, {
                 type,
                 title: params.title,
@@ -483,9 +510,16 @@ export function registerWikiEnsurePage(pi, runtime) {
             else {
                 rebuildMetadataLight(paths);
             }
+            const gateNote = wikilinkIssues.length
+                ? `\n\n⚠️ ${wikilinkIssues.length} wikilink issue(s):\n${wikilinkIssues.map((m) => `- ${m}`).join("\n")}`
+                : "";
             return {
-                content: [{ type: "text", text: `✅ Created ${type} page: \`${pagePath}\`` }],
-                details: { path: pagePath, created: true },
+                content: [{ type: "text", text: `✅ Created ${type} page: \`${pagePath}\`${gateNote}` }],
+                details: {
+                    path: pagePath,
+                    created: true,
+                    wikilinkIssues,
+                },
             };
         },
     });
@@ -740,14 +774,14 @@ function runWikiLint(paths, autoFix) {
     }
     const discovery = discoverKnowledgeDocuments(paths);
     const pages = discovery.documents;
-    const knownIds = new Set(pages.map((page) => page.id));
+    const wikilinkIndex = buildWikilinkIndex(pages.map((page) => page.id));
     const inbound = Object.fromEntries(pages.map((page) => [page.id, 0]));
     const gapSources = new Map();
     const findings = [];
     let missingPages = 0;
     let contradictions = 0;
     for (const page of pages) {
-        const resolved = buildResolvedBacklinks(page.id, page.body, knownIds);
+        const resolved = buildResolvedBacklinks(page.id, page.body, wikilinkIndex);
         for (const target of resolved.targets)
             inbound[target]++;
         for (const unresolved of resolved.unresolved) {
@@ -757,6 +791,11 @@ function runWikiLint(paths, autoFix) {
             missingPages++;
             findings.push(`Missing page: ${unresolved.target} (in ${page.id})`);
         }
+        for (const d of resolved.diagnostics) {
+            if (d.code === "link_ambiguous") {
+                findings.push(d.message.replace("Ambiguous wikilink: ", "Ambiguous: "));
+            }
+        }
     }
     let orphans = 0;
     for (const page of pages) {

package/dist/mcp/index.js

@@ -13,6 +13,7 @@ import { join } from "node:path";
 import { McpServer } from "@modelcontextprotocol/server";
 import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
 import * as z from "zod/v4";
+import { loadTaskConfig, resolveWikilinkValidation, } from "../extensions/llm-wiki/lib/task-config.js";
 import { getVaultPaths, resolveVaultPaths } from "../extensions/llm-wiki/lib/utils.js";
 import { createExecApi } from "./exec.js";
 import { bootstrapOperation, captureSourceOperation, recallOperation, retroOperation, searchOperation, statusOperation, } from "./operations.js";
@@ -206,7 +207,7 @@ server.registerTool("wiki_retro", {
         };
     }
     const paths = getPaths();
-    const result = await retroOperation(paths, slug, title, body, category);
+    const result = await retroOperation(paths, slug, title, body, category, resolveWikilinkValidation(loadTaskConfig(process.cwd())));
     if (!result.ok) {
         return {
             content: [