@zosmaai/pi-llm-wiki 0.11.3 → 0.11.4

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

@@ -1,6 +1,7 @@
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { getAgentDir } from "@mariozechner/pi-coding-agent";
+import { dirname } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { detectHost, listGlobalSettingsFiles, listProjectSettingsFiles, resolveProjectSettingsPath, } from "./host.js";
 export const TASK_DEFAULTS = {};
 /**
  * Resolve whether user-facing wiki notices are enabled (issue #77). Defaults
@@ -9,6 +10,16 @@ export const TASK_DEFAULTS = {};
 export function noticesEnabled(config) {
     return config?.notices !== false;
 }
+/**
+ * Resolve whether the personal vault may serve as this project's ambient
+ * vault. Explicit `ambientPersonalVault` wins; otherwise the host decides
+ * (see the field docs on {@link TaskConfig.ambientPersonalVault}).
+ */
+export function personalVaultIsAmbient(config, host = detectHost()) {
+    if (typeof config?.ambientPersonalVault === "boolean")
+        return config.ambientPersonalVault;
+    return host === "pi";
+}
 /**
  * Resolve whether agent-trajectory working-memory is enabled (issue #80).
  * INVERSE polarity of `noticesEnabled`: defaults to `false`; only an explicit
@@ -64,6 +75,9 @@ function readNamespacedConfig(path) {
         if (typeof section.notices === "boolean") {
             out.notices = section.notices;
         }
+        if (typeof section.ambientPersonalVault === "boolean") {
+            out.ambientPersonalVault = section.ambientPersonalVault;
+        }
         if (typeof section.trajectories === "boolean") {
             out.trajectories = section.trajectories;
         }
@@ -121,14 +135,19 @@ export function validateSynthesisLanguage(tag) {
     return canonical[0];
 }
 /**
- * Read a settings JSON file as a plain object, or `{}` when it is absent or
+ * Read a settings file as a plain object, or `{}` when it is absent or
  * corrupt. Reads directly (no `existsSync` pre-check) so there is no
  * check-then-use race: a missing file throws ENOENT, which the catch treats
  * the same as an empty file.
+ *
+ * `config.yml` / `config.yaml` are parsed as YAML — that is the format oh-my-pi
+ * migrates its settings to. Everything else is JSON. JSON is a YAML subset, so
+ * the YAML parser also accepts a `.yml` file that actually holds JSON.
  */
 function readSettingsObject(path) {
     try {
-        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        const text = readFileSync(path, "utf-8");
+        const parsed = path.endsWith(".yml") || path.endsWith(".yaml") ? parseYaml(text) : JSON.parse(text);
         if (parsed && typeof parsed === "object")
             return parsed;
     }
@@ -138,64 +157,70 @@ function readSettingsObject(path) {
     return {};
 }
 /**
- * Persist (or clear) the wiki background `taskModel` in the PROJECT settings
- * file `<cwd>/.pi/settings.json` under the namespaced `llm-wiki` key (issue
- * #69). Project settings win over global in `loadTaskConfig`, so this takes
- * effect immediately on the next config load. Other top-level keys and other
- * `llm-wiki` settings are preserved; passing `undefined` removes the key
- * (reverting to the session model).
+ * Rewrite the `llm-wiki` section of the project settings file, preserving every
+ * other top-level key and every other setting in the section.
+ *
+ * The target file is chosen by `resolveProjectSettingsPath` — `.pi/settings.json`
+ * or `.omp/settings.json` depending on host and on what already exists — and is
+ * always JSON, which both hosts read.
  */
-export function persistTaskModel(cwd, model) {
-    const settingsPath = join(cwd, ".pi", "settings.json");
+function updateProjectSection(cwd, mutate) {
+    const settingsPath = resolveProjectSettingsPath(cwd);
     const raw = readSettingsObject(settingsPath);
     const existing = raw[SETTINGS_KEY];
     const section = existing && typeof existing === "object" ? { ...existing } : {};
-    if (model) {
-        section.taskModel = { provider: model.provider, id: model.id };
-    }
-    else {
-        // biome-ignore lint/performance/noDelete: one-off settings rewrite, not a hot path; removing the key (vs setting undefined) keeps the JSON clean
-        delete section.taskModel;
-    }
+    mutate(section);
     raw[SETTINGS_KEY] = section;
     mkdirSync(dirname(settingsPath), { recursive: true });
     writeFileSync(settingsPath, `${JSON.stringify(raw, null, 2)}\n`, "utf-8");
 }
 /**
- * Persist the agent-trajectory flag in the PROJECT settings file
- * `<cwd>/.pi/settings.json` under the namespaced `llm-wiki` key (issue #80).
- * Mirrors `persistTaskModel`: project settings win in `loadTaskConfig`, other
- * keys are preserved. `true` writes `trajectories: true`; `false` removes the
- * key (reverting to the default-off behavior).
+ * Persist (or clear) the wiki background `taskModel` in the PROJECT settings
+ * file under the namespaced `llm-wiki` key (issue #69). Project settings win
+ * over global in `loadTaskConfig`, so this takes effect immediately on the next
+ * config load. Passing `undefined` removes the key (reverting to the session
+ * model).
+ */
+export function persistTaskModel(cwd, model) {
+    updateProjectSection(cwd, (section) => {
+        if (model) {
+            section.taskModel = { provider: model.provider, id: model.id };
+        }
+        else {
+            // biome-ignore lint/performance/noDelete: one-off settings rewrite, not a hot path; removing the key (vs setting undefined) keeps the JSON clean
+            delete section.taskModel;
+        }
+    });
+}
+/**
+ * Persist the agent-trajectory flag in the PROJECT settings file under the
+ * namespaced `llm-wiki` key (issue #80). Mirrors `persistTaskModel`: `true`
+ * writes `trajectories: true`; `false` removes the key (reverting to the
+ * default-off behavior).
  */
 export function persistTrajectoriesEnabled(cwd, enabled) {
-    const settingsPath = join(cwd, ".pi", "settings.json");
-    const raw = readSettingsObject(settingsPath);
-    const existing = raw[SETTINGS_KEY];
-    const section = existing && typeof existing === "object" ? { ...existing } : {};
-    if (enabled) {
-        section.trajectories = true;
-    }
-    else {
-        // biome-ignore lint/performance/noDelete: one-off settings rewrite, not a hot path; removing the key keeps the JSON clean (default is off)
-        delete section.trajectories;
-    }
-    raw[SETTINGS_KEY] = section;
-    mkdirSync(dirname(settingsPath), { recursive: true });
-    writeFileSync(settingsPath, `${JSON.stringify(raw, null, 2)}\n`, "utf-8");
+    updateProjectSection(cwd, (section) => {
+        if (enabled) {
+            section.trajectories = true;
+        }
+        else {
+            // biome-ignore lint/performance/noDelete: one-off settings rewrite, not a hot path; removing the key keeps the JSON clean (default is off)
+            delete section.trajectories;
+        }
+    });
 }
+/**
+ * Merge the `llm-wiki` section from every settings file both hosts may use,
+ * lowest precedence first: built-in defaults, then user-level files, then
+ * project-level files. Absent files contribute nothing.
+ */
 export function loadTaskConfig(cwd) {
-    let globalPath;
-    try {
-        globalPath = join(getAgentDir(), "settings.json");
+    const config = { ...TASK_DEFAULTS };
+    for (const path of listGlobalSettingsFiles()) {
+        Object.assign(config, readNamespacedConfig(path));
     }
-    catch {
-        globalPath = "";
+    for (const path of listProjectSettingsFiles(cwd)) {
+        Object.assign(config, readNamespacedConfig(path));
     }
-    const projectPath = join(cwd, ".pi", "settings.json");
-    return {
-        ...TASK_DEFAULTS,
-        ...(globalPath ? readNamespacedConfig(globalPath) : {}),
-        ...readNamespacedConfig(projectPath),
-    };
+    return config;
 }

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

@@ -82,20 +82,46 @@ export function migrateDoubledPersonalVault(parentRoot = getPersonalWikiRoot())
 /**
  * Check if a vault is the personal wiki location.
  * Used in layered recall to avoid double-counting.
+ *
+ * Compares PHYSICAL paths, not strings. On image-based ("atomic") Linux
+ * distributions `/home` is a symlink to `var/home`, so `homedir()` yields the
+ * `$HOME` string (`/home/u`) while `process.cwd()` — and therefore the root
+ * `resolveVaultRoot()` walks up to — yields `/var/home/u`. A string compare
+ * calls the personal vault a project vault, which makes layered recall search
+ * the same vault twice and `vaultPageCount()` double-count it.
+ *
+ * Exact equality, NOT containment: a vault nested under the home directory
+ * (`~/projects/foo/.llm-wiki`) is a project vault and must stay one.
  */
 export function isPersonalVault(paths) {
-    return paths.root === getPersonalWikiRoot();
+    const personalRoot = getPersonalWikiRoot();
+    // Fast path: identical strings need no filesystem syscalls.
+    if (paths.root === personalRoot)
+        return true;
+    try {
+        return relativePhysicalPath(personalRoot, paths.root) === "";
+    }
+    catch {
+        // Unresolvable path (permissions, symlink cycle): fall back to "not
+        // personal" so layered recall degrades to searching both vaults rather
+        // than silently dropping the personal layer.
+        return false;
+    }
 }
 /**
- * Resolve vault root from cwd with personal fallback.
+ * Resolve the vault root that belongs to THIS project, or `null` when the
+ * project has none.
  *
  * 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)
+ * 1. cwd has `.llm-wiki/` (or legacy `.wiki/`) → project wiki (explicit)
+ * 2. `WIKI_HOME` → user-selected root, explicit enough to count as the project's
+ * 3. Walk up from cwd → parent project wiki (monorepo / nested workspace)
+ *
+ * Deliberately does NOT fall back to the personal wiki: callers that need the
+ * fallback use {@link resolveVaultRoot}, callers that must distinguish "this
+ * project has a wiki" from "some wiki exists somewhere" use this.
  */
-export function resolveVaultRoot(cwd) {
+export function resolveProjectVaultRoot(cwd) {
     // A vault rooted at cwd is always the project-local choice.
     if (detectVaultFormat(cwd) !== "none")
         return cwd;
@@ -103,19 +129,36 @@ export function resolveVaultRoot(cwd) {
     // 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)
+    // 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;
+        if (detectVaultFormat(dir) === "none")
+            continue;
+        // Skip the personal vault: it is an ancestor of EVERY project under the
+        // home directory (`~/projects/foo`, and on Windows even the temp dir), so
+        // counting it here would report a project vault for directories that have
+        // none. `resolveVaultRoot` still falls back to it explicitly.
+        if (isPersonalVault(getVaultPaths(dir)))
+            continue;
+        return dir;
     }
-    // Check personal wiki at ~/.llm-wiki/
-    const personalRoot = getPersonalWikiRoot();
-    if (detectVaultFormat(personalRoot) !== "none")
-        return personalRoot;
-    // Fallback: personal wiki
-    return personalRoot;
+    return null;
+}
+/**
+ * Resolve vault root from cwd with personal fallback.
+ *
+ * Priority:
+ * 1-3. {@link resolveProjectVaultRoot}
+ * 4. Personal wiki root (`~`, or `WIKI_HOME`) — used whether or not it already
+ *    holds a vault, so first-run bootstrap has somewhere to write.
+ */
+export function resolveVaultRoot(cwd) {
+    // Realpath the personal fallback so a symlinked `$HOME` (atomic-OS layouts)
+    // yields the PHYSICAL root the ancestor walk used to return — the #145
+    // regression guard pins that. `realpathWithMissingTail` also covers first-run
+    // bootstrap, where the personal root does not exist on disk yet.
+    return resolveProjectVaultRoot(cwd) ?? realpathWithMissingTail(getPersonalWikiRoot());
 }
 /** Get all vault paths for the new (.llm-wiki) layout. */
 export function getVaultPaths(root) {

package/docs/configuration.md

@@ -31,17 +31,34 @@ The personal vault lives at `~/.llm-wiki/` (or `$WIKI_HOME`) and is always avail
 | ----------------------------- | ----------- | ----------------------------------------------- |
 | `WIKI_HOME`                   | `~/.llm-wiki` | Override the personal wiki vault location     |
 | `WIKI_MARKITDOWN_TIMEOUT_MS` | 180000      | Timeout (ms) for MarkItDown PDF/text extraction |
+| `LLM_WIKI_HOST`              | auto        | Force the host layout: `pi` or `omp`            |
 
-## Pi Agent Settings
+## Agent Settings
 
-Runtime settings for the wiki's background tasks live in `.pi/settings.json` under the `llm-wiki` namespace. These can be set globally (`~/.pi/agent/settings.json`) or per-project (`<cwd>/.pi/settings.json`).
+Runtime settings for the wiki's background tasks live under the `llm-wiki`
+namespace of the host's settings file. Both host layouts are read and merged,
+lowest precedence first:
 
-| Setting               | Default | Description                                                  |
-| --------------------- | ------- | ------------------------------------------------------------ |
-| `taskModel`           | —       | Model for background tasks (`{ provider: "openai", id: "gpt-4o" }`) |
-| `synthesisLanguage`   | —       | BCP 47 language tag for ingest synthesis (e.g. `"ru"`, `"fr"`). When unset, synthesis defaults to English. |
-| `trajectories`        | false   | Enable agent-trajectory working-memory                       |
-| `notices`             | true    | Show wiki activity notices in chat                           |
+1. `<agentDir>/settings.json`, then `config.yml` / `config.yaml`
+   — `~/.pi/agent` under pi, `~/.omp/agent` under oh-my-pi
+2. `<cwd>/.pi/{settings.json,config.yml,config.yaml}`
+3. `<cwd>/.omp/{settings.json,config.yml,config.yaml}`
+
+The **host-native** project directory is applied last, so it wins: `.omp` under
+oh-my-pi, `.pi` under pi. Reading the other host's directory means a vault
+configured under pi keeps working after `omp` takes over the repository.
+
+`/wiki-model` and `/wiki-trajectories` write JSON only, into whichever project
+config directory already exists (host-native first, created if neither is
+present). A hand-authored `config.yml` is read but never rewritten.
+
+| Setting                | Default    | Description                                                  |
+| ---------------------- | ---------- | ------------------------------------------------------------ |
+| `taskModel`            | —          | Model for background tasks (`{ provider: "openai", id: "gpt-4o" }`) |
+| `synthesisLanguage`    | —          | BCP 47 language tag for ingest synthesis (e.g. `"ru"`, `"fr"`). When unset, synthesis defaults to English. |
+| `trajectories`         | false      | Enable agent-trajectory working-memory                       |
+| `notices`              | true       | Show wiki activity notices in chat                           |
+| `ambientPersonalVault` | host-dependent | Let the personal vault act as the ambient vault in projects that have no wiki. `true` under pi, `false` under oh-my-pi — see below. |
 
 Example:
 
@@ -66,6 +83,30 @@ The vault root is resolved in this priority order:
 
 This means when you're in a project with its own `.llm-wiki/`, that project wiki is active. When you're outside any project wiki, your personal `~/.llm-wiki/` takes over automatically.
 
+### Ambient surfaces in projects without a wiki
+
+Three surfaces fire without being asked: the session notice, the periodic
+observe/retro reminder, and the `before_agent_start` recall injection (plus its
+`<wiki_status>` system-prompt footer).
+
+Because vault resolution falls back to the personal vault, those surfaces would
+otherwise speak up in *every* directory as soon as `~/.llm-wiki/` exists —
+injecting reminders and unrelated cross-project recall hits into repositories
+where no wiki was ever initialized. Under oh-my-pi the plugin is installed once
+and loads in every project, so that fallback is **off** by default there; under
+pi the historical behaviour is kept.
+
+`ambientPersonalVault` overrides the host default in either direction:
+
+```json
+{ "llm-wiki": { "ambientPersonalVault": true } }
+```
+
+The gate only affects unprompted injections. Tools and slash commands are
+always registered, so `/wiki-init` and `wiki_bootstrap` work in any directory —
+and once a project has its own `.llm-wiki/`, every ambient surface turns back on
+for it.
+
 ## Page Frontmatter
 
 ```yaml

package/extensions/llm-wiki/index.ts

@@ -20,7 +20,12 @@ import {
 } from "./lib/recall.js";
 import { registerWikiRetro } from "./lib/retro.js";
 import { registerBackgroundRuntime } from "./lib/runtime.js";
-import { loadTaskConfig, noticesEnabled, trajectoriesEnabled } from "./lib/task-config.js";
+import {
+  loadTaskConfig,
+  noticesEnabled,
+  personalVaultIsAmbient,
+  trajectoriesEnabled,
+} from "./lib/task-config.js";
 import {
   registerWikiBootstrap,
   registerWikiCaptureSource,
@@ -40,7 +45,11 @@ import {
   registerWikiDistillSkills,
   registerWikiRecallSkill,
 } from "./lib/trajectory.js";
-import { migrateDoubledPersonalVault, resolveVaultPaths } from "./lib/utils.js";
+import {
+  migrateDoubledPersonalVault,
+  resolveProjectVaultRoot,
+  resolveVaultPaths,
+} from "./lib/utils.js";
 import { inspectWritableVault } from "./lib/vault-format.js";
 import { applySessionStartStatus } from "./lib/visible-status.js";
 
@@ -68,6 +77,26 @@ export default function (pi: ExtensionAPI) {
   // work. Created first so tools (e.g. wiki_ingest) can dispatch to it.
   const runtime = registerBackgroundRuntime(pi);
 
+  /**
+   * Does a wiki apply to the directory this session is working in?
+   *
+   * Gates every AMBIENT surface — the ones that speak without being asked:
+   * session bootstrap/notice, the periodic observe/retro reminder, and
+   * `before_agent_start` recall injection. Tools and commands are registered
+   * regardless, so `/wiki-init` remains the way in.
+   *
+   * `resolveVaultRoot` falls back to the personal vault when a project has
+   * none, which is why the ambient surfaces used to fire in EVERY directory
+   * once a personal vault existed — reminders and unrelated cross-project
+   * recall hits leaking into repositories that never initialized a wiki.
+   * Under omp that fallback is off by default (`llm-wiki.ambientPersonalVault`);
+   * under pi it stays on, preserving the historical behavior.
+   *
+   * Resolved per call, not once at load: `cwd` changes within a session.
+   */
+  const wikiAppliesTo = (cwd: string): boolean =>
+    resolveProjectVaultRoot(cwd) !== null || personalVaultIsAmbient(runtime.config);
+
   registerWikiBootstrap(pi);
   registerWikiCaptureSource(pi, runtime);
   registerWikiIngest(pi, runtime);
@@ -106,9 +135,11 @@ export default function (pi: ExtensionAPI) {
   registerWikiObserve(pi, runtime, reminderState);
   // Visible observe/retro reminder by default (issue #77); silenced when the
   // user sets `llm-wiki.notices: false`. Resolver reads the live config so the
-  // setting takes effect without a restart.
+  // setting takes effect without a restart. `display: false` still injects the
+  // reminder into model context, so the "no wiki here" case needs its own gate.
   registerObservationReminder(pi, reminderState, {
     display: () => noticesEnabled(runtime.config),
+    enabled: () => wikiAppliesTo(process.cwd()),
   });
 
   installGuardrails(pi, runtime);
@@ -137,6 +168,12 @@ export default function (pi: ExtensionAPI) {
       console.warn(`[llm-wiki] doubled-dotdir migration skipped: ${(err as Error).message}`);
     }
 
+    // Ambient gate. `ensureConfig` first so an explicit
+    // `llm-wiki.ambientPersonalVault` is honored on the very first session —
+    // `runtime.config` is otherwise empty until the first `turn_start`.
+    runtime.ensureConfig(process.cwd());
+    if (!wikiAppliesTo(process.cwd())) return;
+
     const paths = resolveVaultPaths(process.cwd());
     if (!existsSync(join(paths.dotWiki, "config.json"))) {
       // Silently create the wiki vault — no UI prompts. Topic/mode will be
@@ -168,9 +205,8 @@ export default function (pi: ExtensionAPI) {
 
     // Surface the "wiki active" badge and the active background task model
     // (issue #69), both gated by `llm-wiki.notices` (issue #77, regression
-    // fixed in #83, helper extracted in #84). `ensureConfig` MUST run first so
-    // the gate sees the loaded project settings.
-    runtime.ensureConfig(process.cwd());
+    // fixed in #83, helper extracted in #84). The `ensureConfig` above the
+    // ambient gate already loaded the project settings this reads.
     applySessionStartStatus({
       ui: ctx.ui,
       runtime,
@@ -196,6 +232,8 @@ export default function (pi: ExtensionAPI) {
   //    from the user's first prompt and update config via wiki_bootstrap.
   // 2. Search both personal + project vaults for relevant pages.
   pi.on("before_agent_start", async (event, ctx) => {
+    if (!wikiAppliesTo(process.cwd())) return;
+
     const paths = resolveVaultPaths(process.cwd());
     if (!existsSync(join(paths.dotWiki, "config.json"))) {
       return;

package/extensions/llm-wiki/lib/host.ts

@@ -0,0 +1,125 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { getAgentDir } from "@mariozechner/pi-coding-agent";
+
+/**
+ * Host adapter for the two coding agents that can load this extension:
+ *
+ *  - **pi**   — `@mariozechner/pi-coding-agent`, config dir `.pi`
+ *  - **omp**  — oh-my-pi (`@oh-my-pi/pi-coding-agent`), config dir `.omp`
+ *
+ * omp rewrites `@mariozechner/pi-*` (and bare `typebox`) imports onto its own
+ * bundled packages at load time (its `legacy-pi-compat.ts`), so the *module
+ * graph* needs no changes. What does differ is the on-disk config layout:
+ *
+ * | | pi | omp |
+ * |---|---|---|
+ * | user dir      | `~/.pi/agent`   | `~/.omp/agent` |
+ * | project dir   | `<cwd>/.pi`     | `<cwd>/.omp`   |
+ * | settings file | `settings.json` | `settings.json`, then `config.yml` |
+ *
+ * omp explicitly does **not** read `.pi` (its config source order is
+ * `.omp` → `.claude` → `.codex` → `.gemini`), so a wiki configured under pi
+ * would silently lose its settings after switching hosts. This module keeps
+ * both layouts readable and picks a sensible file to write to.
+ *
+ * Everything here is additive: on pi with only a `.pi/` directory the effective
+ * behaviour is identical to the pre-compat code path, which keeps upstream
+ * merges clean.
+ */
+
+export type HostKind = "pi" | "omp";
+
+/** Project config directory name per host. */
+const CONFIG_DIR: Record<HostKind, string> = { pi: ".pi", omp: ".omp" };
+
+/** Settings file names inside a config directory, lowest → highest precedence. */
+const SETTINGS_FILES = ["settings.json", "config.yml", "config.yaml"] as const;
+
+/**
+ * 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(): HostKind {
+  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 !== undefined) 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: string, host: HostKind = detectHost()): string[] {
+  const foreign: HostKind = host === "omp" ? "pi" : "omp";
+  const files: string[] = [];
+  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(): string[] {
+  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: string, host: HostKind = detectHost()): string {
+  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");
+}

package/extensions/llm-wiki/lib/observation.ts

@@ -322,11 +322,20 @@ export function buildReminderText(): string {
  * `options.display` (issue #77) controls whether the reminder is shown to the
  * user (`true`, the default) or injected silently into model context only
  * (`false`). Pass a resolver so the live `notices` config is read at send time.
+ *
+ * `options.enabled` gates the reminder entirely — note that `display: false`
+ * still injects it into model context, so it is NOT a way to switch the
+ * reminder off. Callers pass a resolver that answers "does a wiki apply to the
+ * current working directory", evaluated per turn because the session can move.
  */
 export function registerObservationReminder(
   pi: ExtensionAPI,
   reminderState: ReminderState,
-  options?: { turnsBetweenReminders?: number; display?: boolean | (() => boolean) },
+  options?: {
+    turnsBetweenReminders?: number;
+    display?: boolean | (() => boolean);
+    enabled?: () => boolean;
+  },
 ): void {
   const REMINDER_INTERVAL = options?.turnsBetweenReminders ?? 5;
   const resolveDisplay = (): boolean => {
@@ -355,6 +364,10 @@ export function registerObservationReminder(
     // errors cause multiple retries, each firing agent_end).
     if ("willRetry" in event && (event as { willRetry?: boolean }).willRetry) return;
 
+    // No wiki applies here: never nag, and never accumulate a pending reminder
+    // that would fire the moment the session moves into a wiki-bearing project.
+    if (options?.enabled && !options.enabled()) return;
+
     turnsSinceLastReminder++;
     if (turnsSinceLastReminder < REMINDER_INTERVAL) return;
     if (reminderState.observeDoneThisSession) return;