@zosmaai/pi-llm-wiki 0.11.3 → 0.11.5

package/commands/wiki-record.md

@@ -0,0 +1,36 @@
+---
+description: Capture the just-completed task's tool-call trajectory into the wiki as agent working-memory, then optionally distill it into a reusable skill.
+argument-hint: "<title> [--outcome success|failure|partial]"
+section: LLM Wiki
+topLevelCli: true
+---
+
+# /wiki-record
+
+Capture the trajectory of the task you just completed — the sequence of tool calls that solved it — into the wiki's working-memory layer.
+
+This is the counterpart to source capture: instead of recording what you *read*, it records what you *did*, so the wiki compounds over your own work.
+
+## User Arguments
+
+$ARGUMENTS
+
+Read the LLM Wiki skill at `.pi/skills/llm-wiki/SKILL.md` first to understand the wiki conventions.
+
+## Steps
+
+1. Call `wiki_capture_trajectory` with:
+   - `title`: short descriptive phrase for the task (≤60 chars, noun phrase)
+   - `outcome`: optional — `success` (default), `failure`, or `partial`
+   - The extension auto-extracts the tool-call trajectory from the live session, so you usually do **not** pass `steps` manually.
+2. Open the generated skeleton case page in `wiki/cases/` and flesh out:
+   - **Task** — what was requested
+   - **Approach** — the key steps and decisions (not every tool call, just the meaningful ones)
+   - **Outcome** — the result, and anything worth reusing or avoiding next time
+3. If the task taught a reusable pattern, run `wiki_distill_skills` and create a `skill` page via `wiki_ensure_page(type="skill")` that cites `[[trajectories/TRJ-...]]`.
+4. Confirm the case (and any skill) will be surfaced by `wiki_recall` / `wiki_recall_skill` in future sessions.
+
+**Rules:**
+- Only record tasks worth learning from — non-trivial debugging, refactors, integrations, multi-step workflows. Skip trivial one-shot answers.
+- The raw trajectory packet under `raw/trajectories/` is immutable. Edit the `case`/`skill` pages, never the packet.
+- One trajectory per `wiki_capture_trajectory` call.

package/commands/wiki-req.md

@@ -0,0 +1,56 @@
+---
+description: Capture and decompose a concept into atomic, traceable wiki requirements. Clarifies ambiguous requirements, splits them into atomic pieces, and persists them as wiki/requirements/ pages with status tracking.
+argument-hint: "<concept description>"
+section: LLM Wiki
+topLevelCli: true
+---
+
+# /wiki-req
+
+Capture a concept and decompose it into atomic, traceable requirements in the wiki.
+
+Transforms natural language descriptions into structured `wiki/requirements/` pages, preserving the original clarified concept as an immutable source packet in `raw/sources/`.
+
+## User Arguments
+
+$ARGUMENTS
+
+Read the LLM Wiki skill at `.pi/skills/llm-wiki/SKILL.md` first to understand the wiki conventions, architecture, and page type rules.
+
+## Steps
+
+1. **Clarify the concept**
+   - Discuss with the user: unpack ambiguous terms, surfaces implicit assumptions, identify scope boundaries
+   - Ask targeted questions to resolve unknowns (e.g., "Which providers?", "What's the fallback behavior?", "Who are the actors?")
+   - Reach mutual clarity before proceeding
+
+2. **Capture the clarified concept**
+   - Call `wiki_capture_source(text=...)` with the clarified conversation as markdown
+   - This creates an immutable record in `raw/sources/SRC-YYYY-MM-DD-NNN/`
+   - The source captures the original intent verbatim — no interpretation, no decomposition
+
+3. **Decompose into atomic requirements**
+   - Break the clarified concept into the smallest meaningful units of functionality
+   - Each requirement should represent one independently verifiable behavior
+   - For each atomic requirement, call `wiki_ensure_page(type="requirement", title="...", content="...")` where content includes:
+     - `type: requirement` and `status: draft` in frontmatter
+     - A clear `## Description` section
+     - `## Acceptance Criteria` as a checkbox list (the threshold for "done")
+     - `source_id` linking back to the source capture
+     - `depends_on` linking to any prerequisite requirements
+     - `[[wikilinks]]` to relevant entities, concepts, and other wiki pages
+   - Set priority based on user input: `p0` (blocking), `p1` (critical), `p2` (important), `p3` (nice-to-have)
+
+4. **Cross-link and finalize**
+   - Ensure each requirement page has bidirectional wikilinks to related pages
+   - Update any existing entity or concept pages that these requirements reference
+   - Report the results: how many requirements created, their priorities, and the source capture ID
+
+**Rules:**
+- One atomic requirement per `wiki_ensure_page` call — each must be independently testable
+- Always capture the clarified concept first via `wiki_capture_source` before decomposing
+- Requirements live in `wiki/requirements/` — they are editable wiki pages, not immutable sources
+- Use status values: `draft` → `clarified` → `active` → `implemented` → `deferred` → `rejected`
+- Use priority values: `p0` (blocking), `p1` (critical), `p2` (important), `p3` (nice-to-have)
+- Do not create requirements in `raw/` — that layer is for external source artifacts only
+- Inside Markdown table cells, write aliased wikilinks as `[[target\|alias]]`, never `[[target|alias]]`.

package/commands/wiki-retro.md

@@ -0,0 +1,35 @@
+---
+description: Save an atomic insight from the current task into the wiki. Creates a single markdown file that layered recall surfaces in future sessions.
+argument-hint: "<title> [--category <category>]"
+section: LLM Wiki
+topLevelCli: true
+---
+
+# /wiki-retro
+
+Save an atomic insight from a completed task into the wiki.
+
+Captures what you learned as a single markdown file so that layered recall surfaces it in future sessions.
+
+## User Arguments
+
+$ARGUMENTS
+
+Read the LLM Wiki skill at `.pi/skills/llm-wiki/SKILL.md` first to understand the wiki conventions.
+
+## Steps
+
+1. Identify the key insight(s) from the current task — non-obvious learnings, patterns, or decisions worth preserving
+2. For each insight, call `wiki_retro` with:
+   - `slug`: unique kebab-case identifier (e.g., `jwt-revocation-pattern`)
+   - `title`: short descriptive phrase, ≤60 chars, noun phrase not a sentence
+   - `body`: markdown explanation with `[[wikilinks]]` to related wiki pages
+   - `category`: optional (frontend, architecture, devops, bugfix, design, etc.)
+3. Confirm the insight was saved and will be surfaced by layered recall in future sessions
+4. If the insight relates to existing wiki pages, update those pages with cross-references
+
+**Rules:**
+- One atomic insight per `wiki_retro` call. Use multiple calls for multiple insights.
+- Don't save obvious things. Save non-obvious patterns, tradeoffs, and design decisions.
+- Always add `[[wikilinks]]` to connect the new insight with existing wiki knowledge.
+- Inside Markdown table cells, write aliased wikilinks as `[[target\|alias]]`, never `[[target|alias]]`.

package/commands/wiki-run.md

@@ -0,0 +1,31 @@
+---
+description: Run the full wiki cycle: discover → ingest → lint. Optionally schedule for auto-updates.
+argument-hint: "[--schedule daily|weekly]"
+section: LLM Wiki
+topLevelCli: true
+---
+
+# /wiki-run
+
+Run the complete wiki maintenance cycle: discover new sources, ingest them, and lint for health.
+
+## User Arguments
+
+$ARGUMENTS
+
+## Steps
+
+1. **Discover:** Use web search to find new sources on the wiki's topic, then capture each with `wiki_capture_source(url=<url>)` (max 5-10).
+2. **Ingest:** Call `wiki_ingest(batch_size=3)` and process returned sources — read extracted.md, update source pages, create entity/concept pages, add cross-references.
+3. **Lint:** Call `wiki_lint(auto_fix=false)` to run a health check.
+4. If critical gaps found → optionally run one more discover+ingest cycle.
+5. Save summary to `.llm-wiki/outputs/run-YYYY-MM-DD.md` using the `write` tool.
+6. Report final summary.
+
+### Scheduling
+
+If `--schedule` is provided, call `wiki_watch(interval=<daily|weekly|hourly>)`.
+
+**Important:** `wiki_watch` does NOT install a schedule. It only prints a `crontab` line.
+Report the printed line to the user verbatim and tell them to install it themselves with
+`crontab -e`. Do not claim the schedule is active until they confirm they have done so.

package/commands/wiki-skills.md

@@ -0,0 +1,26 @@
+---
+description: Search the wiki's distilled skills and past cases for patterns relevant to the current task — "have I done something like this before?".
+argument-hint: "[query] [--kind skill|case]"
+section: LLM Wiki
+topLevelCli: true
+---
+
+# /wiki-skills
+
+Search the agent working-memory layer of the wiki: reusable **skills** distilled from past trajectories, and specific past **cases**.
+
+## User Arguments
+
+$ARGUMENTS
+
+## Steps
+
+1. Call `wiki_recall_skill` with:
+   - `query`: the current task description or key terms (defaults to `$ARGUMENTS`)
+   - `kind`: optional — `skill`, `case`, or `any` (default)
+   - `max_results`: optional (default 5)
+2. Read the most relevant skill/case pages with `read`.
+3. Apply the recalled pattern to the current task, citing the source page with `[[skills/...]]` or `[[cases/...]]` where helpful.
+4. If no relevant skill/case exists, proceed with the task and consider running `/wiki-record` afterward so the next attempt benefits.
+
+**Tip:** Skills generalize across many trajectories ("how I do X"); cases are concrete past runs ("the time I did X for project Y"). Search `any` first, then narrow.

package/commands/wiki-status.md

@@ -0,0 +1,16 @@
+---
+description: Show wiki health overview — source count, page stats, orphan count, last activity dates.
+argument-hint: ""
+section: LLM Wiki
+topLevelCli: true
+---
+
+# /wiki-status
+
+Show a quick overview of wiki health and statistics.
+
+## Steps
+
+1. Call `wiki_status()` to get the current wiki health report.
+2. Present the results to the user.
+3. If health shows warnings (orphans > 5, many gaps), suggest running `/wiki-lint` for a detailed analysis.

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

@@ -0,0 +1,86 @@
+import { Container, Text, matchesKey } from "@mariozechner/pi-tui";
+import { collectDashboardStats } from "./dashboard.js";
+const TYPE_ORDER = [
+    "concept",
+    "entity",
+    "source",
+    "skill",
+    "analysis",
+    "synthesis",
+    "requirement",
+    "short",
+    "shared",
+];
+const KIND_ORDER = ["observe", "retro", "synth", "intake"];
+function orderedPairs(counts) {
+    const keys = Object.keys(counts);
+    const known = TYPE_ORDER.filter((k) => counts[k] !== undefined);
+    const rest = keys
+        .filter((k) => !TYPE_ORDER.includes(k))
+        .sort()
+        .slice(0, 3); // cap the tail: the dashboard is a glance, not a census
+    const all = [...known, ...rest];
+    if (all.length === 0)
+        return "—";
+    return all.map((k) => `${k} ${counts[k]}`).join(" · ");
+}
+function orderedKinds(counts) {
+    const keys = Object.keys(counts);
+    const known = KIND_ORDER.filter((k) => counts[k] !== undefined);
+    const rest = keys
+        .filter((k) => !KIND_ORDER.includes(k))
+        .sort()
+        .slice(0, 3);
+    return [...known, ...rest].map((k) => `${k} ${counts[k]}`).join(" · ");
+}
+function renderStatsLines(s) {
+    const emb = s.embEnabled ? `${s.embFiles}/${s.pageCount}` : "—";
+    return [
+        `Wiki Dashboard · ${s.root}`,
+        "",
+        `Pages   ${s.pageCount} · ${s.sizeKB}KB · ${orderedPairs(s.byType)}`,
+        `Fresh   last touch ${s.lastTouch || "never"} · stale(>30d) ${s.staleCount}`,
+        `Acts 7d ${s.last7dTotal > 0 ? orderedKinds(s.last7dByKind) : "none"} · total ${s.last7dTotal}/${s.totalEvents}`,
+        `Queue   raw ${s.rawQueue} · emb ${emb}`,
+        `Links   zero-backlink ${s.zeroBacklinks} · full scan: /wiki-lint`,
+        "",
+        "Esc to close",
+    ];
+}
+/** One-screen read-only TUI; handles Esc and `q`. */
+export class DashboardScreen extends Container {
+    doneFn;
+    constructor(lines, close) {
+        super();
+        this.doneFn = close;
+        this.addChild(new Text(lines.join("\n"), 1, 1));
+    }
+    handleInput(data) {
+        // ponytail: matchesKey handles every terminal key shape (raw bytes,
+        // kitty CSI-u like \u001b[27u for Esc, ctrl combos) — a raw === "\u001b"
+        // check only works in terminals without the kitty keyboard protocol,
+        // which is exactly where Ghostty users' Esc went nowhere.
+        if (matchesKey(data, "escape") || matchesKey(data, "q")) {
+            this.doneFn();
+        }
+    }
+}
+/**
+ * Register the /wiki-dashboard command.
+ */
+export function registerWikiDashboardCommand(pi, runtime) {
+    pi.registerCommand("wiki-dashboard", {
+        description: "Show a read-only LLM Wiki dashboard (pages, freshness, activity, queue, links, emb)",
+        handler: async (_args, ctx) => {
+            runtime.ensureConfig(ctx.cwd);
+            if (!ctx.hasUI) {
+                ctx.ui.notify("LLM Wiki: /wiki-dashboard requires an interactive UI.", "warning");
+                return;
+            }
+            const stats = await collectDashboardStats(ctx.cwd);
+            await ctx.ui.custom((_tui, _theme, _keybindings, close) => {
+                return new DashboardScreen(renderStatsLines(stats), close);
+            });
+        },
+    });
+}

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

@@ -0,0 +1,175 @@
+/**
+ * Read-only vault statistics for the /wiki-dashboard screen.
+ *
+ * Everything is computed from pre-existing on-disk state:
+ *  - page tree (paths.wiki + skills dir): counts, mtimes, sizes
+ *  - meta/registry.json: page types (values; keys can carry legacy prefix noise)
+ *  - meta/backlinks.json: zero-inbound pages
+ *  - meta/events.jsonl: activity stream (observes/retros/syntheses...)
+ *  - raw/sources: pending ingest queue
+ *  - emb/: embedding coverage
+ *
+ * No writes, no LLM calls, no new files. Pure reader.
+ */
+import { readFile, readdir, stat } from "node:fs/promises";
+import { readJson, resolveVaultPaths } from "./utils.js";
+/** Directories excluded from the page walk (infrastructure, not pages). */
+const SKIP_DIRS = new Set([
+    "templates",
+    "cases",
+    "outputs",
+    ".discoveries",
+    "raw",
+    "meta",
+    "emb",
+    ".git",
+]);
+async function walkPages(dir, rel, out) {
+    try {
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const e of entries) {
+            const childRel = rel === "" ? e.name : `${rel}/${e.name}`;
+            if (e.isDirectory()) {
+                if (SKIP_DIRS.has(e.name))
+                    continue;
+                await walkPages(`${dir}/${e.name}`, childRel, out);
+                continue;
+            }
+            if (!e.name.endsWith(".md"))
+                continue;
+            try {
+                const st = await stat(`${dir}/${e.name}`);
+                out.push({ rel: childRel, mtime: st.mtimeMs, bytes: st.size });
+            }
+            catch {
+                // unreadable file: skip
+            }
+        }
+    }
+    catch {
+        // missing dir (empty vault): nothing to walk
+    }
+}
+function humanAge(ms) {
+    const mins = Math.floor(ms / 60_000);
+    if (mins < 1)
+        return "now";
+    if (mins < 60)
+        return `${mins}m`;
+    const hrs = Math.floor(mins / 60);
+    if (hrs < 48)
+        return `${hrs}h`;
+    return `${Math.floor(hrs / 24)}d`;
+}
+async function readEvents(metaDir) {
+    const byKind = {};
+    let recent = 0;
+    let total = 0;
+    try {
+        const raw = await readFile(`${metaDir}/events.jsonl`, "utf-8");
+        const cutoff = Date.now() - 7 * 86400_000;
+        for (const line of raw.split("\n")) {
+            if (!line.trim())
+                continue;
+            let ev;
+            try {
+                ev = JSON.parse(line);
+            }
+            catch {
+                continue; // corrupted line: skip, not fatal
+            }
+            const ts = typeof ev.timestamp === "string" ? Date.parse(ev.timestamp) : Number.NaN;
+            const kind = typeof ev.kind === "string" && ev.kind ? ev.kind : "event";
+            total += 1;
+            if (Number.isFinite(ts) && ts >= cutoff) {
+                byKind[kind] = (byKind[kind] ?? 0) + 1;
+                recent += 1;
+            }
+        }
+    }
+    catch {
+        // no events file: zeros
+    }
+    return { byKind, recent, total };
+}
+/**
+ * Collect all dashboard stats for the vault reachable from `cwd`.
+ * Reuses the extension's own path resolution (same root the tools see).
+ */
+export async function collectDashboardStats(cwd) {
+    const paths = resolveVaultPaths(cwd);
+    const pages = [];
+    await walkPages(paths.wiki, "", pages);
+    // skill pages register as type:skill and live under <dotWiki>/skills
+    try {
+        const st = await stat(`${paths.dotWiki}/skills`);
+        if (st.isDirectory()) {
+            await walkPages(`${paths.dotWiki}/skills`, "skills", pages);
+        }
+    }
+    catch {
+        // no skills dir: fine
+    }
+    // type map from registry values — keys may carry legacy noise, so normalize
+    const registry = readJson(`${paths.meta}/registry.json`, { pages: {} });
+    const typeByKey = {};
+    for (const [key, val] of Object.entries(registry.pages ?? {})) {
+        const norm = key.startsWith('"') ? key.slice(1) : key;
+        if (val?.type)
+            typeByKey[norm] = val.type;
+    }
+    const byType = {};
+    for (const p of pages) {
+        const slug = p.rel.endsWith(".md") ? p.rel.slice(0, -3) : p.rel;
+        const type = typeByKey[slug] ?? p.rel.split("/")[0] ?? "other";
+        byType[type] = (byType[type] ?? 0) + 1;
+    }
+    let sizeBytes = 0;
+    let latestMtime = 0;
+    const staleCutoff = Date.now() - 30 * 86400_000;
+    let stale = 0;
+    for (const p of pages) {
+        sizeBytes += p.bytes;
+        if (p.mtime > latestMtime)
+            latestMtime = p.mtime;
+        if (p.mtime < staleCutoff)
+            stale += 1;
+    }
+    const events = await readEvents(paths.meta);
+    let rawQueue = 0;
+    try {
+        const pkts = await readdir(paths.rawSources, { withFileTypes: true });
+        for (const e of pkts) {
+            if (e.isDirectory())
+                rawQueue += 1; // each subdirectory is one packet
+        }
+    }
+    catch {
+        // no raw/sources: empty queue
+    }
+    const backlinks = readJson(`${paths.meta}/backlinks.json`, {});
+    const zeroBacklinks = Object.values(backlinks).filter((v) => (v ?? []).length === 0).length;
+    let embFiles = 0;
+    try {
+        const embEntries = await readdir(`${paths.dotWiki}/emb`);
+        embFiles = embEntries.filter((f) => f.endsWith(".bin")).length;
+    }
+    catch {
+        // no emb dir: none
+    }
+    return {
+        root: paths.root,
+        pageCount: pages.length,
+        byType,
+        sizeKB: Math.max(1, Math.round(sizeBytes / 1024)),
+        lastTouch: pages.length === 0 ? "" : humanAge(Date.now() - latestMtime),
+        staleCount: stale,
+        last7dByKind: events.byKind,
+        last7dTotal: events.recent,
+        totalEvents: events.total,
+        rawQueue,
+        zeroBacklinks,
+        embFiles,
+        embEnabled: embFiles > 0,
+    };
+}

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

@@ -65,11 +65,37 @@ function parseMoveDestination(line) {
 function scanPatchString(input) {
     const paths = [];
     let sawHeader = false;
+    let sawApplyPatchHeader = false;
+    let applyPatchComplete = true;
     let sectionHasMove = false;
     let complete = true;
     const stripped = input.startsWith("\uFEFF") ? input.slice(1) : input;
     for (const line of stripped.split("\n")) {
-        const trimmed = line.replace(/\r$/, "").trim();
+        const raw = line.replace(/\r$/, "");
+        // apply_patch envelope headers (#162): matched on the raw (untrimmed)
+        // line so body rows (space/+/- prefixed) that quote the envelope shape
+        // are never mistaken for headers.
+        const fileOp = /^\*{3}\s+(?:update|add|delete)\s+file:\s*(\S.*)$/i.exec(raw);
+        if (fileOp) {
+            sawApplyPatchHeader = true;
+            const path = normalizeMutationPath(fileOp[1]);
+            if (path)
+                paths.push(path);
+            else
+                applyPatchComplete = false;
+            continue;
+        }
+        const moveTo = /^\*{3}\s+move\s+to:\s*(\S.*)$/i.exec(raw);
+        if (moveTo) {
+            sawApplyPatchHeader = true;
+            const destination = normalizeMutationPath(moveTo[1]);
+            if (destination)
+                paths.push(destination);
+            else
+                applyPatchComplete = false;
+            continue;
+        }
+        const trimmed = raw.trim();
         if (trimmed.startsWith("[")) {
             sawHeader = true;
             sectionHasMove = false;
@@ -90,6 +116,9 @@ function scanPatchString(input) {
             sectionHasMove = true;
         }
     }
+    if (sawApplyPatchHeader) {
+        return { paths, complete: applyPatchComplete && paths.length > 0 };
+    }
     return { paths, complete: sawHeader && complete };
 }
 function mergeMutationScans(target, source) {

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

@@ -0,0 +1,117 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { getAgentDir } from "@mariozechner/pi-coding-agent";
+/** Project config directory name per host. */
+const CONFIG_DIR = { pi: ".pi", omp: ".omp" };
+/** Settings file names inside a config directory, lowest → highest precedence. */
+const SETTINGS_FILES = ["settings.json", "config.yml", "config.yaml"];
+/**
+ * Detect which agent is hosting this extension.
+ *
+ * Ordered by reliability:
+ *  1. `LLM_WIKI_HOST` — explicit escape hatch (tests, exotic embeddings).
+ *  2. The agent directory path: pi resolves `~/.pi/agent`, omp `~/.omp/agent`.
+ *     A `PI_CODING_AGENT_DIR` override that keeps the marker segment still
+ *     classifies correctly; anything else falls through.
+ *  3. `OMP_PROFILE`, which omp sets on itself whenever a profile is active.
+ *  4. Default `pi` — the historical behaviour.
+ */
+export function detectHost() {
+    const forced = process.env.LLM_WIKI_HOST?.trim().toLowerCase();
+    if (forced === "omp" || forced === "pi")
+        return forced;
+    let agentDir = "";
+    try {
+        agentDir = getAgentDir();
+    }
+    catch {
+        agentDir = "";
+    }
+    if (agentDir) {
+        const segments = agentDir.split(/[\\/]/);
+        if (segments.includes(".omp"))
+            return "omp";
+        if (segments.includes(".pi"))
+            return "pi";
+    }
+    if (process.env.OMP_PROFILE)
+        return "omp";
+    return "pi";
+}
+/**
+ * Every project settings file that may hold `llm-wiki` configuration, ordered
+ * from lowest to highest precedence so callers can merge left-to-right.
+ *
+ * The host's *native* directory is last (wins). The foreign directory is still
+ * read so a vault configured under pi keeps working after omp takes over the
+ * repository, and vice versa. Within a directory `config.yml` follows
+ * `settings.json`, matching omp's own project-settings precedence.
+ */
+export function listProjectSettingsFiles(cwd, host = detectHost()) {
+    const foreign = host === "omp" ? "pi" : "omp";
+    const files = [];
+    for (const kind of [foreign, host]) {
+        const dir = join(cwd, CONFIG_DIR[kind]);
+        for (const name of SETTINGS_FILES)
+            files.push(join(dir, name));
+    }
+    return files;
+}
+/**
+ * User-level settings files, lowest → highest precedence.
+ *
+ * `getAgentDir()` already resolves per host (`~/.pi/agent` vs `~/.omp/agent`),
+ * so only the file names differ: omp migrates `settings.json` into `config.yml`
+ * on first start, and a migrated install has *only* the YAML file.
+ */
+export function listGlobalSettingsFiles() {
+    let agentDir = "";
+    try {
+        agentDir = getAgentDir();
+    }
+    catch {
+        return [];
+    }
+    if (!agentDir)
+        return [];
+    return SETTINGS_FILES.map((name) => join(agentDir, name));
+}
+/**
+ * The project settings file this extension writes to.
+ *
+ * Always JSON (`settings.json`) — both hosts read it, and rewriting a user's
+ * hand-authored `config.yml` would destroy comments and formatting.
+ *
+ * Directory choice: an already-existing project config directory wins (so a
+ * repo that only has `.pi/` keeps a single settings file), otherwise the
+ * detected host's native directory is created.
+ */
+export function resolveProjectSettingsPath(cwd, host = detectHost()) {
+    const native = join(cwd, CONFIG_DIR[host]);
+    if (existsSync(native))
+        return join(native, "settings.json");
+    const foreign = join(cwd, CONFIG_DIR[host === "omp" ? "pi" : "omp"]);
+    if (existsSync(foreign))
+        return join(foreign, "settings.json");
+    return join(native, "settings.json");
+}
+/**
+ * The global (user-level) settings file this extension writes to.
+ *
+ * Always writes to `settings.json` inside the agent dir — both hosts read it.
+ */
+export function resolveGlobalSettingsPath(host = detectHost()) {
+    let agentDir = "";
+    try {
+        agentDir = getAgentDir();
+    }
+    catch {
+        agentDir = "";
+    }
+    if (!agentDir) {
+        // Fallback: ~/.pi/agent/settings.json
+        const home = process.env.HOME || "~";
+        return join(home, ".pi", "agent", "settings.json");
+    }
+    return join(agentDir, "settings.json");
+}

package/dist/extensions/llm-wiki/lib/ingest-worker.js

@@ -365,7 +365,7 @@ Rules:
  * synthesis.
  */
 export async function runIngestSynthesis(args) {
-    const { model, apiKey, headers, paths, sourceId, manifest, extracted, maxChars, signal, synthesisLanguage, } = args;
+    const { model, apiKey, headers, paths, sourceId, manifest, extracted, maxChars, signal, synthesisLanguage, synthesisMaxTokens, } = args;
     const content = extracted.slice(0, maxChars ?? 24_000);
     if (!content.trim())
         return undefined;
@@ -402,6 +402,7 @@ export async function runIngestSynthesis(args) {
         systemPrompt,
         userPrompt,
         tools: [commitTool],
+        maxTokens: synthesisMaxTokens ?? 16384,
         signal,
     });
     if (committed)