deepseek-web-retrieval 0.3.0 → 0.5.0

package/dist/cli.js

@@ -16,13 +16,82 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
 // src/core/constants.ts
-var SEARCH_ENDPOINT = "https://api.deepseek.com/v1/tools/search", FETCH_ENDPOINT = "https://api.deepseek.com/v1/tools/fetch", DEFAULT_SEARCH_COUNT = 10, DEFAULT_MAX_RESULTS = 5, DEFAULT_MIN_RERANK = 1.5, DEFAULT_MIN_AUTHORITY = 2, DEFAULT_MAX_SUMMARY_CHARS = 1200, DEFAULT_FETCH_MAX_CHARS = 16000, DEFAULT_TIMEOUT_MS = 30000, MIN_TIMEOUT_MS = 1000, MAX_TIMEOUT_MS = 120000, MAX_QUERY_CHARS = 128, MAX_URL_CHARS = 8192, MAX_ERROR_BODY_CHARS = 2000, MAX_RESPONSE_BYTES, FETCH_TRUNCATION_MARKER = `
+var SEARCH_ENDPOINT = "https://api.deepseek.com/v1/tools/search", FETCH_ENDPOINT = "https://api.deepseek.com/v1/tools/fetch", DEFAULT_SEARCH_COUNT = 10, DEFAULT_MAX_RESULTS = 10, DEFAULT_MIN_RERANK = 0, DEFAULT_MIN_AUTHORITY = 0, DEFAULT_MAX_SUMMARY_CHARS = 1200, DEFAULT_FETCH_MAX_CHARS = 16000, DEFAULT_TIMEOUT_MS = 30000, MIN_TIMEOUT_MS = 1000, MAX_TIMEOUT_MS = 120000, MAX_QUERY_CHARS = 128, MAX_URL_CHARS = 8192, MAX_ERROR_BODY_CHARS = 2000, MAX_RESPONSE_BYTES, FETCH_TRUNCATION_MARKER = `
 
 [content truncated]`, DEFAULT_API_KEY_SOURCE = "auto", DEFAULT_MAX_RETRIES = 0, MAX_RETRIES = 5, DEFAULT_RETRY_BASE_DELAY_MS = 250, MAX_RETRY_DELAY_MS = 1e4, API_KEY_ENV = "DEEPSEEK_API_KEY", ENABLE_SEARCH_ENV = "DEEPSEEK_ENABLE_SEARCH", ENABLE_FETCH_ENV = "DEEPSEEK_ENABLE_FETCH";
 var init_constants = __esm(() => {
   MAX_RESPONSE_BYTES = 5 * 1024 * 1024;
 });
 
+// src/installer/persistence.ts
+import { randomUUID } from "node:crypto";
+import {
+  closeSync,
+  fchmodSync,
+  fsyncSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  realpathSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "node:fs";
+import { basename, dirname, join } from "node:path";
+function atomicWrite(file, text, mode) {
+  let target = file;
+  let existingMode;
+  try {
+    const entry = lstatSync(file);
+    if (entry.isSymbolicLink())
+      target = realpathSync(file);
+    existingMode = statSync(target).mode & 511;
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+    try {
+      if (lstatSync(file).isSymbolicLink())
+        throw new Error(`Cannot write dangling symlink ${file}`);
+    } catch (linkError) {
+      if (linkError.code !== "ENOENT")
+        throw linkError;
+    }
+  }
+  const dir = dirname(target);
+  mkdirSync(dir, { recursive: true });
+  const temporary = join(dir, `.${basename(target)}.${randomUUID()}.tmp`);
+  let fd;
+  try {
+    fd = openSync(temporary, "wx", 384);
+    writeFileSync(fd, text);
+    if (readFileSync(temporary, "utf8") !== text)
+      throw new Error(`Incomplete write to ${file}`);
+    fchmodSync(fd, mode ?? existingMode ?? 438 & ~process.umask());
+    fsyncSync(fd);
+    closeSync(fd);
+    fd = undefined;
+    renameSync(temporary, target);
+    syncDirectory(dir);
+  } finally {
+    if (fd !== undefined)
+      closeSync(fd);
+    rmSync(temporary, { force: true });
+  }
+}
+function syncDirectory(dir) {
+  if (process.platform === "win32")
+    return;
+  const fd = openSync(dir, "r");
+  try {
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+var init_persistence = () => {};
+
 // node_modules/jsonc-parser/lib/esm/impl/scanner.js
 function createScanner(text, ignoreTrivia = false) {
   const len = text.length;
@@ -750,10 +819,10 @@ function parse(text, errors = [], options = ParseOptions.DEFAULT) {
       currentParent = previousParents.pop();
     },
     onArrayBegin: () => {
-      const array2 = [];
-      onValue(array2);
+      const array = [];
+      onValue(array);
       previousParents.push(currentParent);
-      currentParent = array2;
+      currentParent = array;
       currentProperty = null;
     },
     onArrayEnd: () => {
@@ -1379,10 +1448,12 @@ var init_jsonc = __esm(() => {
   init_main();
 });
 
-// src/installer/formats/value.ts
+// src/core/object.ts
 function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+
+// src/installer/formats/value.ts
 function deepEqual(a, b) {
   if (a === b)
     return true;
@@ -1432,13 +1503,14 @@ function appendEntries(existing, entries, path) {
   const appended = entries.filter((entry) => !list.some((item) => deepEqual(item, entry)));
   return { list, appended };
 }
+var init_value = () => {};
 
 // src/installer/formats/json.ts
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync as readFileSync2 } from "node:fs";
 function loadJson(file) {
   if (!existsSync(file))
     return { exists: false, text: "", value: {}, lossy: false };
-  const text = readFileSync(file, "utf8");
+  const text = readFileSync2(file, "utf8");
   try {
     return { exists: true, text, value: parseJsonc(text), lossy: false };
   } catch (error) {
@@ -1547,6 +1619,7 @@ var JSON_FORMATTING, jsonCodec;
 var init_json = __esm(() => {
   init_main();
   init_jsonc();
+  init_value();
   JSON_FORMATTING = { insertSpaces: true, tabSize: 2, insertFinalNewline: false };
   jsonCodec = {
     format: "json",
@@ -1569,7 +1642,7 @@ var init_json = __esm(() => {
 });
 
 // src/installer/formats/rules.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
 function rulesMarkers(host) {
   return {
     begin: `<!-- deepseek-web-retrieval:${host}:rules:begin -->`,
@@ -1591,28 +1664,47 @@ ${block}
 `;
 }
 function removeBlock(host, text) {
-  const markers = rulesMarkers(host);
-  const start = text.indexOf(markers.begin);
-  if (start === -1)
+  const range = blockRange(host, text);
+  if (range === undefined)
     return text;
-  const end = text.indexOf(markers.end);
-  if (end === -1)
-    return text.slice(0, start);
-  let after = text.slice(end + markers.end.length);
-  after = after.replace(/^\n{1,2}/, "");
-  const before = text.slice(0, start);
-  return before.endsWith(`
+  const before = text.slice(0, range.start).trimEnd();
+  const after = text.slice(range.end).replace(/^\n{1,2}/, "").trimStart();
+  if (before && after)
+    return `${before}
 
-`) ? `${before.slice(0, -1)}${after}` : before + after;
+${after}`;
+  if (before)
+    return `${before}
+`;
+  return after;
 }
 function hasBlock(host, text) {
+  return blockRange(host, text) !== undefined;
+}
+function blockRange(host, text) {
   const markers = rulesMarkers(host);
-  return text.includes(markers.begin) && text.includes(markers.end);
+  const start = text.indexOf(markers.begin);
+  const end = text.indexOf(markers.end);
+  if (start === -1 && end === -1)
+    return;
+  if (start === -1 || end < start || text.indexOf(markers.begin, start + markers.begin.length) !== -1 || text.indexOf(markers.end, end + markers.end.length) !== -1) {
+    throw new Error(`malformed rules block for ${host}: expected one begin marker followed by one end marker; repair the markers before retrying`);
+  }
+  return { start, end: end + markers.end.length };
 }
 function rulesCodec(host) {
   return {
     format: "rules",
-    load: (file) => existsSync2(file) ? { exists: true, text: readFileSync2(file, "utf8"), value: {}, lossy: false } : { exists: false, text: "", value: {}, lossy: false },
+    load: (file) => {
+      const exists = existsSync2(file);
+      const text = exists ? readFileSync3(file, "utf8") : "";
+      try {
+        blockRange(host, text);
+        return { exists, text, value: {}, lossy: false };
+      } catch (error) {
+        return { exists, text, value: {}, lossy: false, parseError: String(error) };
+      }
+    },
     apply: (text, edit2) => {
       if (edit2.format !== "rules")
         throw new Error(`rules codec cannot apply a ${edit2.format} edit`);
@@ -2669,30 +2761,30 @@ function stringifyInlineTable(obj, depth, numberAsFloat, strictTemporal) {
   }
   return res + " }";
 }
-function stringifyArray(array2, depth, numberAsFloat, strictTemporal) {
-  if (array2.length === 0)
+function stringifyArray(array, depth, numberAsFloat, strictTemporal) {
+  if (array.length === 0)
     return "[]";
   let res = "[ ";
-  for (let i = 0;i < array2.length; i++) {
+  for (let i = 0;i < array.length; i++) {
     if (i)
       res += ", ";
-    if (array2[i] === null || array2[i] === undefined) {
+    if (array[i] === null || array[i] === undefined) {
       throw new TypeError("arrays cannot contain null or undefined values");
     }
-    res += stringifyValue(array2[i], extendedTypeOf(array2[i]), depth - 1, numberAsFloat, strictTemporal);
+    res += stringifyValue(array[i], extendedTypeOf(array[i]), depth - 1, numberAsFloat, strictTemporal);
   }
   return res + " ]";
 }
-function stringifyArrayTable(array2, key, depth, numberAsFloat, strictTemporal) {
+function stringifyArrayTable(array, key, depth, numberAsFloat, strictTemporal) {
   if (depth === 0) {
     throw new Error("Could not stringify the object: maximum object depth exceeded");
   }
   let res = "";
-  for (let i = 0;i < array2.length; i++) {
+  for (let i = 0;i < array.length; i++) {
     res += `${res && `
 `}[[${key}]]
 `;
-    res += stringifyTable(0, array2[i], key, depth, numberAsFloat, strictTemporal);
+    res += stringifyTable(0, array[i], key, depth, numberAsFloat, strictTemporal);
   }
   return res;
 }
@@ -2813,11 +2905,11 @@ var init_dist = __esm(() => {
 });
 
 // src/installer/formats/toml.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { existsSync as existsSync3, readFileSync as readFileSync4 } from "node:fs";
 function loadToml(file) {
   if (!existsSync3(file))
     return { exists: false, text: "", value: {}, lossy: false };
-  const text = readFileSync3(file, "utf8");
+  const text = readFileSync4(file, "utf8");
   try {
     return { exists: true, text, value: parse3(text), lossy: hasTomlComment(text) };
   } catch (error) {
@@ -2863,7 +2955,7 @@ function applyTomlOps(value, ops) {
     const parent = navigate(target, op.path, createdParents);
     const key = op.path[op.path.length - 1];
     if (op.op === "set") {
-      const previous = Object.prototype.hasOwnProperty.call(parent, key) ? parent[key] : undefined;
+      const previous = Object.hasOwn(parent, key) ? parent[key] : undefined;
       parent[key] = structuredClone(op.value);
       recorded.push({ op: "set", path: op.path, applied: structuredClone(op.value), previous });
       continue;
@@ -2945,6 +3037,7 @@ function tomlOpHolds(text, op) {
 var tomlCodec;
 var init_toml = __esm(() => {
   init_dist();
+  init_value();
   tomlCodec = {
     format: "toml",
     load: loadToml,
@@ -2971,11 +3064,8 @@ var init_toml = __esm(() => {
 });
 
 // src/installer/formats/index.ts
-import { mkdirSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
 function writeConfig(file, serialized) {
-  mkdirSync(dirname(file), { recursive: true });
-  writeFileSync(file, serialized);
+  atomicWrite(file, serialized);
 }
 function codecFor(format2, host) {
   if (format2 === "json")
@@ -2985,140 +3075,737 @@ function codecFor(format2, host) {
   return rulesCodec(host);
 }
 var init_formats = __esm(() => {
+  init_persistence();
   init_json();
   init_rules();
   init_toml();
 });
 
-// src/installer/detect.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
-function replacingExistingEntryNote(path) {
-  return `An existing ${path} entry is being replaced; its previous form is recorded for uninstall.`;
+// src/installer/revert.ts
+import { existsSync as existsSync4, readFileSync as readFileSync5, rmdirSync, unlinkSync } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+function pruneEmptyDir(dir) {
+  try {
+    rmdirSync(dir);
+  } catch {}
 }
-function othersStayRegisteredNote(others) {
-  return `Other MCP servers stay registered (${others.join(", ")}); routing to DeepSeek is not exclusive while they offer web tools.`;
+function revertRecordedFile(file, host, opts) {
+  const lines = [];
+  if (!existsSync4(file.file)) {
+    lines.push(`already absent: ${file.file}${opts.label}`);
+    return lines;
+  }
+  const codec = codecFor(file.format, host);
+  const text = readFileSync5(file.file, "utf8");
+  if (file.format === "rules") {
+    const edit2 = { file: file.file, format: "rules", block: file.blockApplied ?? "" };
+    if (!codec.verify(text, edit2)) {
+      lines.push(`no rules block${opts.label} in ${file.file}; left untouched`);
+      return lines;
+    }
+    const updated = codec.revert(text, file).text;
+    if (opts.whole && codec.isEffectivelyEmpty(updated)) {
+      unlinkSync(file.file);
+      pruneEmptyDir(dirname2(file.file));
+      lines.push(`deleted ${file.file} (installer-created, now empty)`);
+    } else {
+      writeConfig(file.file, updated);
+      lines.push(`removed rules block${opts.label} from ${file.file}`);
+    }
+    return lines;
+  }
+  const reverted = codec.revert(text, file);
+  if (opts.whole && file.created && codec.isEffectivelyEmpty(reverted.text)) {
+    unlinkSync(file.file);
+    pruneEmptyDir(dirname2(file.file));
+    lines.push(`deleted ${file.file} (installer-created, now empty)`);
+  } else {
+    writeConfig(file.file, reverted.text);
+    lines.push(`reverted artifacts${opts.label} in ${file.file}`);
+  }
+  lines.push(...reverted.notes.map((note) => `  note: ${note}`));
+  return lines;
 }
-function looksWebCapable(name, entry) {
-  if (WEB_TOOL_HINT.test(name))
-    return true;
-  if (!isPlainObject(entry))
-    return false;
-  const command = typeof entry.command === "string" ? entry.command : "";
-  const url = typeof entry.url === "string" ? entry.url : "";
-  const args = Array.isArray(entry.args) ? entry.args.filter((arg) => typeof arg === "string").join(" ") : "";
-  return WEB_TOOL_HINT.test(`${command} ${args} ${url}`);
+var init_revert = __esm(() => {
+  init_formats();
+});
+
+// src/installer/paths.ts
+import { join as pathJoin } from "node:path";
+function join2(...parts) {
+  const nonEmpty = parts.filter((part) => part.length > 0);
+  return nonEmpty.length === 0 ? "" : pathJoin(...nonEmpty);
 }
-function findCompetitorSteering(host, file) {
-  if (!existsSync4(file))
-    return [];
+function configHome(roots) {
+  return roots.configHome ?? join2(roots.home, ".config");
+}
+function stateDir(roots, scope) {
+  return scope === "global" ? join2(configHome(roots), "deepseek-web-retrieval") : join2(roots.cwd, ".deepseek-web-retrieval");
+}
+var init_paths = () => {};
+
+// src/installer/state.ts
+import { existsSync as existsSync5, lstatSync as lstatSync2, readdirSync, readFileSync as readFileSync6, rmSync as rmSync2 } from "node:fs";
+import { isAbsolute, join as join3 } from "node:path";
+import { z as z2 } from "zod/v4";
+function statePathFor(input) {
+  return join3(stateDir(input, input.scope), `install.${input.host}.json`);
+}
+function readRecordFile(file, host, scope) {
   let text;
   try {
-    text = readFileSync4(file, "utf8");
+    text = readFileSync6(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      try {
+        lstatSync2(file);
+      } catch (statError) {
+        if (statError.code === "ENOENT")
+          return;
+      }
+    }
+    throw new InstallRecordError(file, "unreadable", error.code ?? "read failed");
+  }
+  let value;
+  try {
+    value = JSON.parse(text);
   } catch {
+    throw new InstallRecordError(file, "invalid", "malformed JSON");
+  }
+  const result = recordSchema.safeParse(value);
+  if (!result.success) {
+    throw new InstallRecordError(file, "invalid", "unsupported version or malformed record structure");
+  }
+  if (result.data.host !== host || result.data.scope !== scope) {
+    throw new InstallRecordError(file, "invalid", "host or scope does not match its location");
+  }
+  return result.data;
+}
+function readRecord(input) {
+  return readRecordFile(statePathFor(input), input.host, input.scope);
+}
+function claimedByOtherScope(input, files) {
+  const other = input.scope === "global" ? "project" : "global";
+  const record = readRecord({ ...input, scope: other });
+  if (record === undefined)
+    return [];
+  return files.filter((file) => record.files.some((candidate) => candidate.file === file));
+}
+function writeRecord(input, record) {
+  const file = statePathFor(input);
+  atomicWrite(file, `${JSON.stringify(record, null, 2)}
+`, 384);
+}
+function appendedByPrevious(record, path) {
+  if (record === undefined)
     return [];
+  const entries = [];
+  for (const file of record.files) {
+    for (const op of file.ops) {
+      if (op.op !== "append-array" || op.path.join("\x00") !== path.join("\x00"))
+        continue;
+      if (Array.isArray(op.applied))
+        entries.push(...op.applied);
+    }
   }
-  return removeBlock(host, text).split(`
-`).map((line) => line.trim()).filter((line) => line.length > 0 && STEERING_HINT.test(line) && !line.includes("deepseek")).slice(0, 2);
+  return entries;
 }
-function competitorSteeringNote(file, lines) {
-  const quoted = lines.map((line) => `"${line}"`).join(", ");
-  return `Existing rules in ${file} steer toward other web tools (${quoted}); the plan surfaces this conflict — it does not resolve it.`;
+function deleteRecord(input) {
+  const file = statePathFor(input);
+  if (existsSync5(file))
+    rmSync2(file);
 }
-function splitCompetitors(servers) {
-  const competitors = [];
-  const bystanders = [];
-  for (const [name, entry] of Object.entries(servers)) {
-    if (name === "deepseek")
-      continue;
-    (looksWebCapable(name, entry) ? competitors : bystanders).push(name);
+function listRecords(roots) {
+  const records = [];
+  for (const scope of ["global", "project"]) {
+    const dir = stateDir(roots, scope);
+    let names;
+    try {
+      names = readdirSync(dir);
+    } catch (error) {
+      if (error.code === "ENOENT")
+        continue;
+      throw new InstallRecordError(dir, "unreadable", error.code ?? "list failed");
+    }
+    for (const name of names) {
+      if (!name.startsWith("install.") || !name.endsWith(".json"))
+        continue;
+      const record = readRecordFile(join3(dir, name), name.slice("install.".length, -".json".length), scope);
+      if (record !== undefined)
+        records.push(record);
+    }
   }
-  return { competitors, bystanders };
+  return records;
 }
-var BOTH_CAPABILITIES_OFF = "Both capabilities are off; nothing would be installed.", FORCED_COST_NOTE, WEB_TOOL_HINT, STEERING_HINT;
-var init_detect = __esm(() => {
-  init_rules();
-  FORCED_COST_NOTE = "Forced routing is deterministic, and Search and Fetch are billed per successful request — " + `see the README's "Privacy and cost" section before applying.`;
-  WEB_TOOL_HINT = /(web[_ -]?(search|fetch)|search|fetch|browse|scrape|crawl|tavily|brave|exa|perplexity|firecrawl|jina|serp|duckduckgo|reader)/i;
-  STEERING_HINT = /(web[_ ]?(search|fetch)|websearch|webfetch|tavily|exa|brave|perplexity|firecrawl|jina|serp|duckduckgo|google|bing)/i;
+var keyPath, tier, operation, recordSchema, InstallRecordError;
+var init_state = __esm(() => {
+  init_paths();
+  init_persistence();
+  keyPath = z2.array(z2.string().min(1)).min(1);
+  tier = z2.enum(["optional", "preferred", "forced", "off"]);
+  operation = z2.discriminatedUnion("op", [
+    z2.object({ op: z2.literal("set"), path: keyPath, applied: z2.unknown(), previous: z2.unknown().optional() }),
+    z2.object({
+      op: z2.literal("append-array"),
+      path: keyPath,
+      applied: z2.array(z2.unknown()),
+      previous: z2.unknown().optional()
+    })
+  ]);
+  recordSchema = z2.object({
+    version: z2.literal(1),
+    host: z2.enum(["opencode", "pi", "codex"]),
+    scope: z2.enum(["global", "project"]),
+    tiers: z2.object({ search: tier, fetch: tier }),
+    createdAt: z2.string().refine((value) => Number.isFinite(Date.parse(value))),
+    files: z2.array(z2.object({
+      file: z2.string().refine(isAbsolute),
+      format: z2.enum(["json", "toml", "rules"]),
+      created: z2.boolean(),
+      shared: z2.literal(true).optional(),
+      ops: z2.array(operation),
+      blockApplied: z2.string().optional(),
+      createdParents: z2.array(keyPath).optional()
+    }))
+  });
+  InstallRecordError = class InstallRecordError extends Error {
+    file;
+    kind;
+    constructor(file, kind, detail) {
+      super(`${kind === "invalid" ? "Invalid install record" : "Cannot read install record"} at ${file} (${detail}). ` + "Restore a valid record from backup or repair its permissions before retrying; configuration was not changed. Do not delete undo state to bypass this check.");
+      this.file = file;
+      this.kind = kind;
+      this.name = "InstallRecordError";
+    }
+  };
 });
 
-// src/installer/paths.ts
-function join(...parts) {
-  return parts.filter((part) => part.length > 0).join("/");
+// src/installer/ownership.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync7, realpathSync as realpathSync2, rmSync as rmSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { basename as basename2, dirname as dirname3, join as join4, resolve } from "node:path";
+function canonicalPath(file) {
+  const absolute = resolve(file);
+  if (existsSync6(absolute))
+    return realpathSync2(absolute);
+  return join4(canonicalPath(dirname3(absolute)), basename2(absolute));
+}
+function ownerOf(input) {
+  return { recordPath: canonicalPath(statePathFor(input)), scope: input.scope, cwd: canonicalPath(input.cwd) };
+}
+function claimPaths(input, files) {
+  return [
+    ...new Set(files.filter((file) => file.format !== "rules").map((file) => {
+      const target = canonicalPath(file.file);
+      return join4(dirname3(target), `.${basename2(target)}.deepseek-web-retrieval.${input.host}.owner.json`);
+    }))
+  ];
 }
-function configHome(roots) {
-  return roots.configHome ?? join(roots.home, ".config");
+function readOwner(file) {
+  if (!existsSync6(file))
+    return;
+  try {
+    const value = JSON.parse(readFileSync7(file, "utf8"));
+    if (isPlainObject(value) && typeof value.recordPath === "string" && typeof value.cwd === "string" && (value.scope === "project" || value.scope === "global")) {
+      return { recordPath: value.recordPath, cwd: value.cwd, scope: value.scope };
+    }
+  } catch {}
+  throw new Error(`Cannot read config ownership in ${file}; repair the ownership record before retrying.`);
 }
-function stateDir(roots, scope) {
-  return scope === "global" ? join(configHome(roots), "deepseek-web-retrieval") : join(roots.cwd, ".deepseek-web-retrieval");
+function assertOwner(input, claim) {
+  const owner = readOwner(claim);
+  if (owner === undefined || owner.recordPath === ownerOf(input).recordPath)
+    return;
+  throw new Error(`A ${input.host} install is already recorded at the ${owner.scope} scope (${owner.recordPath}) and claims the same config file. ` + `Uninstall it first: deepseek-web-retrieval uninstall --host ${input.host} --scope ${owner.scope} --cwd ${JSON.stringify(owner.cwd)}. ` + "Two install records must not edit one file.");
 }
-
-// src/installer/rulesContent.ts
-function rulesLines(ids, search, fetch) {
-  const lines = ["DeepSeek retrieval guidance:"];
-  if (search !== "off") {
-    lines.push(`- Use ${ids.search} when the task needs fresh external information: current docs, version numbers,`, "  changelogs, or anything you cannot know from the repository alone. Do not search for facts already", "  present locally.");
-  }
-  if (fetch !== "off") {
-    lines.push(`- Use ${ids.fetch} to read a specific public web page as Markdown when its content is needed.`);
+function assertFileOwnership(input, files) {
+  for (const claim of claimPaths(input, files))
+    assertOwner(input, claim);
+}
+function fileOwnershipNotes(input, files) {
+  return claimPaths(input, files.filter((file) => file.shared)).map((claim) => `Shared config ownership is recorded in ${claim}; uninstall releases it. Keep this local metadata with the config.`);
+}
+function acquireFileOwnership(input, files) {
+  const acquired = [];
+  const owner = ownerOf(input);
+  const releaseNew = () => {
+    for (const claim of acquired.reverse())
+      releaseClaim(input, claim);
+  };
+  try {
+    for (const claim of claimPaths(input, files.filter((file) => file.shared))) {
+      assertOwner(input, claim);
+      mkdirSync2(dirname3(claim), { recursive: true });
+      try {
+        writeFileSync2(claim, `${JSON.stringify(owner)}
+`, { flag: "wx", mode: 384 });
+        acquired.push(claim);
+      } catch (error) {
+        if (error.code !== "EEXIST")
+          throw error;
+        assertOwner(input, claim);
+      }
+    }
+    return releaseNew;
+  } catch (error) {
+    releaseNew();
+    throw error;
   }
-  lines.push("- Never send localhost or private-network URLs to the DeepSeek tools; use local tools for those (the", "  server blocks private hosts by default).", "- DeepSeek requests are billed per successful call; retrieve only what the task needs.");
-  return lines;
 }
-var MCP_TOOL_IDS;
-var init_rulesContent = __esm(() => {
-  MCP_TOOL_IDS = { search: "mcp__deepseek__deepseek_web_search", fetch: "mcp__deepseek__deepseek_fetch" };
+function releaseClaim(input, claim) {
+  const owner = readOwner(claim);
+  if (owner === undefined)
+    return;
+  assertOwner(input, claim);
+  rmSync3(claim);
+  pruneEmptyDir(dirname3(claim));
+}
+function releaseFileOwnership(input, files) {
+  for (const claim of claimPaths(input, files))
+    releaseClaim(input, claim);
+}
+var init_ownership = __esm(() => {
+  init_revert();
+  init_state();
 });
 
-// src/installer/hosts/shared.ts
-function planHeader(input, paths, loaded, dialect) {
-  const notes = [];
-  const errors = [];
-  if (loaded.parseError) {
-    errors.push({ message: `${paths.config} exists but does not parse as ${dialect}: ${loaded.parseError}` });
-    return { notes, errors, abort: true };
+// src/installer/operation-lock.ts
+import { mkdirSync as mkdirSync3, rmSync as rmSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname4 } from "node:path";
+function withOperationLock(files, run) {
+  const locks = [...new Set(files.map((file) => `${canonicalPath(file)}.deepseek-web-retrieval.lock`))].sort();
+  const acquired = [];
+  let outcome;
+  try {
+    for (const lock of locks) {
+      mkdirSync3(dirname4(lock), { recursive: true });
+      try {
+        mkdirSync3(lock, { mode: 448 });
+      } catch (error) {
+        if (error.code !== "EEXIST")
+          throw error;
+        throw new Error(`Installer operation is locked at ${lock}. Wait for the other init/uninstall to finish. ` + "If it was interrupted, verify the config and install record and ensure no installer is running before removing this lock directory; retry with a new plan.");
+      }
+      acquired.push(lock);
+      writeFileSync3(`${lock}/owner.json`, JSON.stringify({ pid: process.pid, startedAt: new Date().toISOString() }), {
+        mode: 384
+      });
+    }
+    outcome = { ok: true, value: run() };
+  } catch (error) {
+    outcome = { ok: false, error };
   }
-  if (input.search === "off" && input.fetch === "off") {
-    errors.push({ message: BOTH_CAPABILITIES_OFF });
+  {
+    const errors = [];
+    for (const lock of acquired.reverse()) {
+      try {
+        rmSync4(lock, { recursive: true });
+        pruneEmptyDir(dirname4(lock));
+      } catch (error) {
+        errors.push(`${lock}: ${String(error)}`);
+      }
+    }
+    if (errors.length > 0) {
+      throw new Error(`${outcome.ok ? "Operation finished" : String(outcome.error)}; could not release operation lock(s): ${errors.join("; ")}`, { cause: outcome.ok ? undefined : outcome.error });
+    }
   }
-  const steering = findCompetitorSteering(input.host, paths.rules);
-  if (steering.length > 0)
-    notes.push(competitorSteeringNote(paths.rules, steering));
-  return { notes, errors, abort: false };
+  if (!outcome.ok)
+    throw outcome.error;
+  return outcome.value;
 }
-var init_shared = __esm(() => {
-  init_detect();
+var init_operation_lock = __esm(() => {
+  init_ownership();
+  init_revert();
 });
 
-// src/installer/hosts/codex.ts
-function codexPaths(input) {
-  return {
-    config: join(input.home, ".codex/config.toml"),
-    rules: input.scope === "global" ? join(input.home, ".codex/AGENTS.md") : join(input.cwd, "AGENTS.md")
-  };
-}
-function planCodex(input, _previous) {
-  const paths = codexPaths(input);
-  const loaded = codecFor("toml", input.host).load(paths.config);
-  const tiers = { search: input.search, fetch: input.fetch };
-  const header = planHeader(input, paths, loaded, "TOML");
-  if (header.abort) {
-    return { host: "codex", scope: input.scope, tiers, edits: [], notes: header.notes, errors: header.errors };
+// src/installer/apply.ts
+import { existsSync as existsSync7, readFileSync as readFileSync8, rmSync as rmSync5 } from "node:fs";
+import { dirname as dirname5 } from "node:path";
+function applyPlan(plan, input) {
+  if (plan.errors.length > 0) {
+    throw new Error(`refusing to apply a plan with errors: ${plan.errors.map((error) => error.message).join("; ")}`);
   }
-  const notes = [...header.notes];
-  const errors = [...header.errors];
-  const edits = [];
-  const tools = loaded.value.tools;
-  if (isPlainObject(tools) && "web_search" in tools) {
-    errors.push({
-      message: `${paths.config} sets [tools] web_search, which is a silent no-op at Codex 0.163.0 (only the top-level ` + "web_search key controls the tool). Remove it first so the config cannot mislead."
-    });
+  return withOperationLock([statePathFor(input)], () => withOperationLock([...plan.edits, ...plan.reverts ?? []].map((file) => file.file), () => applyLocked(plan, input)));
+}
+function applyLocked(plan, input) {
+  const touched = [...plan.edits, ...plan.reverts ?? []];
+  assertFileOwnership(input, touched);
+  assertNoDrift(plan);
+  const previous = readRecord(input);
+  if (Object.hasOwn(plan, "previousRecord") && !deepEqual(previous, plan.previousRecord)) {
+    throw new Error("The install record changed since the plan was rendered. Re-run init to plan against the current install.");
   }
-  const servers = loaded.value.mcp_servers;
-  if (isPlainObject(servers)) {
-    if ("deepseek" in servers)
-      notes.push(replacingExistingEntryNote("mcp_servers.deepseek"));
-    const { competitors, bystanders } = splitCompetitors(servers);
+  const prepared = plan.edits.map((edit2) => prepareEdit(edit2, plan.host));
+  const snapshots = snapshotTouchedFiles(plan);
+  const files = [];
+  const lines = [];
+  const releaseNewClaims = acquireFileOwnership(input, touched);
+  try {
+    for (const item of prepared) {
+      item.write();
+      const desired = item.edit.format === "rules" ? [] : item.edit.ops;
+      files.push(mergeRecorded(item.recorded, previous?.files.find((file) => file.file === item.edit.file), desired));
+      lines.push(`${item.recorded.created ? "created" : "updated"} ${item.edit.file}`);
+    }
+    if ((plan.reverts ?? []).length > 0) {
+      lines.push(...applyReverts(plan));
+    }
+    const verification = verifyEdits(plan.edits, plan.host);
+    if (!verification.ok) {
+      throw new Error(`verification failed: ${verification.lines.filter((line) => line.startsWith("FAIL")).join("; ")}`);
+    }
+    lines.push(...verification.lines);
+    const record = {
+      version: 1,
+      host: plan.host,
+      scope: plan.scope,
+      tiers: plan.tiers,
+      createdAt: new Date().toISOString(),
+      files
+    };
+    writeRecord(input, record);
+  } catch (error) {
+    const rollback = rollbackApply(input, previous, snapshots);
+    if (rollback.complete) {
+      try {
+        releaseNewClaims();
+      } catch (releaseError) {
+        rollback.complete = false;
+        rollback.report.push(`could not release new config ownership: ${errorMessage(releaseError)}`);
+      }
+    }
+    const status = rollback.complete ? "rolled_back" : "recovery_required";
+    const outcome = rollback.complete ? "was rolled back" : "recovery is required";
+    const guidance = rollback.complete ? "Fix the cause and re-run init." : "Restore the reported files and ownership metadata before re-running init.";
+    throw new ApplyError(status, `apply failed and ${outcome} (${errorMessage(error)}). Rollback report: ${rollback.report.join("; ")}. ${guidance}`, error);
+  }
+  try {
+    releaseFileOwnership(input, (previous?.files ?? []).filter((file) => !files.some((current) => current.file === file.file)));
+  } catch (error) {
+    throw new ApplyError("recovery_required", `apply was written and verified, but old config ownership could not be released (${errorMessage(error)}). ` + "The new install record is retained; repair the reported ownership metadata before re-running init.", error);
+  }
+  return { lines, ok: true };
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function assertNoDrift(plan) {
+  const drifts = [];
+  for (const edit2 of plan.edits) {
+    if (edit2.format === "rules")
+      continue;
+    const loaded = codecFor(edit2.format, plan.host).load(edit2.file);
+    if (loaded.parseError) {
+      drifts.push(`${edit2.file} no longer parses (${loaded.parseError})`);
+      continue;
+    }
+    for (const op of edit2.ops) {
+      if (op.op !== "set")
+        continue;
+      const current = valueAt(loaded.value, op.path);
+      if (!deepEqual(current, op.previous)) {
+        drifts.push(`${edit2.file}: ${op.path.join(".")} changed since the plan was rendered`);
+      }
+    }
+  }
+  if (drifts.length > 0) {
+    throw new Error(`refusing to apply — the config changed since the plan was rendered: ${drifts.join("; ")}. ` + "Re-run init to re-plan against the current files.");
+  }
+}
+function snapshotTouchedFiles(plan) {
+  const snapshots = new Map;
+  const touched = [...plan.edits.map((edit2) => edit2.file), ...(plan.reverts ?? []).map((revert) => revert.file)];
+  for (const file of new Set(touched)) {
+    snapshots.set(file, existsSync7(file) ? { exists: true, text: readFileSync8(file, "utf8") } : { exists: false, text: "" });
+  }
+  return snapshots;
+}
+function rollbackApply(input, previous, snapshots) {
+  const report = [];
+  let complete = true;
+  for (const [file, snapshot] of [...snapshots.entries()].reverse()) {
+    try {
+      if (snapshot.exists) {
+        if (existsSync7(file) && readFileSync8(file, "utf8") === snapshot.text)
+          continue;
+        writeConfig(file, snapshot.text);
+        if (readFileSync8(file, "utf8") !== snapshot.text)
+          throw new Error("restored contents differ from the snapshot");
+      } else {
+        if (!existsSync7(file))
+          continue;
+        rmSync5(file);
+        if (existsSync7(file))
+          throw new Error("created file still exists after removal");
+        pruneEmptyDir(dirname5(file));
+      }
+      report.push(`restored ${file}`);
+    } catch (restoreError) {
+      complete = false;
+      report.push(`could not restore ${file}: ${errorMessage(restoreError)}`);
+    }
+  }
+  try {
+    if (previous !== undefined)
+      writeRecord(input, previous);
+    else
+      deleteRecord(input);
+    if (previous === undefined ? existsSync7(statePathFor(input)) : !deepEqual(readRecord(input), previous)) {
+      throw new Error("restored install record differs from its previous state");
+    }
+  } catch (restoreError) {
+    complete = false;
+    report.push(`could not restore the install record: ${errorMessage(restoreError)}`);
+  }
+  return { complete, report };
+}
+function prepareEdit(edit2, host) {
+  const codec = codecFor(edit2.format, host);
+  const loaded = codec.load(edit2.file);
+  if (loaded.parseError) {
+    throw new Error(`${edit2.file} does not parse: ${loaded.parseError}`);
+  }
+  const applied = codec.apply(loaded.text, edit2);
+  const recorded = edit2.format === "rules" ? { file: edit2.file, format: "rules", created: !loaded.exists, ops: [], blockApplied: edit2.block } : {
+    file: edit2.file,
+    format: edit2.format,
+    created: !loaded.exists,
+    ...edit2.shared ? { shared: true } : {},
+    ops: applied.recorded,
+    createdParents: applied.createdParents
+  };
+  return {
+    edit: edit2,
+    recorded,
+    write: () => writeConfig(edit2.file, applied.text)
+  };
+}
+function applyReverts(plan) {
+  const lines = [];
+  for (const revert of plan.reverts ?? []) {
+    const whole = !plan.edits.some((edit2) => edit2.file === revert.file);
+    lines.push(...revertRecordedFile(revert, plan.host, { label: " (previous init)", whole }));
+  }
+  return lines;
+}
+function mergeRecorded(current, before, desired) {
+  if (before === undefined)
+    return current;
+  const ops = current.ops.map((op) => {
+    const old = before.ops.find((candidate) => candidate.op === op.op && candidate.path.join("\x00") === op.path.join("\x00"));
+    if (old === undefined)
+      return op;
+    if (op.op === "set" && old.op === "set" && deepEqual(op.previous, old.applied)) {
+      return { ...op, previous: old.previous };
+    }
+    if (op.op === "append-array" && old.op === "append-array") {
+      const wanted = desired.find((candidate) => candidate.op === "append-array" && candidate.path.join("\x00") === op.path.join("\x00"));
+      const kept = (Array.isArray(old.applied) ? old.applied : []).filter((entry) => (wanted?.entries ?? []).some((candidate) => deepEqual(candidate, entry)));
+      return { ...op, applied: [...kept, ...Array.isArray(op.applied) ? op.applied : []] };
+    }
+    return op;
+  });
+  return {
+    ...current,
+    created: before.created,
+    ops,
+    createdParents: [...before.createdParents ?? [], ...current.createdParents ?? []]
+  };
+}
+function verifyEdits(edits, host) {
+  const lines = [];
+  let ok = true;
+  for (const edit2 of edits) {
+    if (!existsSync7(edit2.file)) {
+      lines.push(`FAIL ${edit2.file} does not exist after apply`);
+      ok = false;
+      continue;
+    }
+    const codec = codecFor(edit2.format, host);
+    const text = readFileSync8(edit2.file, "utf8");
+    if (edit2.format === "rules") {
+      const good = codec.verify(text, edit2);
+      lines.push(`${good ? "pass" : "FAIL"} ${edit2.file}: rules block ${good ? "present" : "missing"}`);
+      ok = ok && good;
+      continue;
+    }
+    for (const op of edit2.ops) {
+      const good = codec.verify(text, edit2, op);
+      lines.push(`${good ? "pass" : "FAIL"} ${edit2.file}: ${describeOp(op)} ${good ? "holds" : "missing"}`);
+      ok = ok && good;
+    }
+  }
+  return { lines, ok };
+}
+function describeOp(op) {
+  if (op.op === "set")
+    return `set ${op.path.join(".")}`;
+  return `append ${op.path.join(".")}`;
+}
+var ApplyError;
+var init_apply = __esm(() => {
+  init_formats();
+  init_value();
+  init_operation_lock();
+  init_ownership();
+  init_revert();
+  init_state();
+  ApplyError = class ApplyError extends Error {
+    status;
+    constructor(status, message, cause) {
+      super(message, { cause });
+      this.status = status;
+      this.name = "ApplyError";
+    }
+  };
+});
+
+// src/installer/detect.ts
+import { existsSync as existsSync8, readFileSync as readFileSync9 } from "node:fs";
+function replacingExistingEntryNote(path) {
+  return `An existing ${path} entry is being replaced; its previous form is recorded for uninstall.`;
+}
+function othersStayRegisteredNote(others) {
+  return `Other MCP servers stay registered (${others.join(", ")}); routing to DeepSeek is not exclusive while they offer web tools.`;
+}
+function looksWebCapable(name, entry) {
+  if (WEB_TOOL_HINT.test(name))
+    return true;
+  if (!isPlainObject(entry))
+    return false;
+  const command = typeof entry.command === "string" ? entry.command : "";
+  const url = typeof entry.url === "string" ? entry.url : "";
+  const args = Array.isArray(entry.args) ? entry.args.filter((arg) => typeof arg === "string").join(" ") : "";
+  return WEB_TOOL_HINT.test(`${command} ${args} ${url}`);
+}
+function looksLikeOwnPackage(source) {
+  return /(^|[/:@])deepseek-web-retrieval($|[@/]|-\d)/.test(source);
+}
+function findCompetitorSteering(host, file) {
+  if (!existsSync8(file))
+    return [];
+  let text;
+  try {
+    text = readFileSync9(file, "utf8");
+  } catch {
+    return [];
+  }
+  return removeBlock(host, text).split(`
+`).map((line) => line.trim()).filter((line) => line.length > 0 && STEERING_HINT.test(line) && !line.includes("deepseek")).slice(0, 2);
+}
+function competitorSteeringNote(file, lines) {
+  const quoted = lines.map((line) => `"${line}"`).join(", ");
+  return `Existing rules in ${file} steer toward other web tools (${quoted}); the plan surfaces this conflict — it does not resolve it.`;
+}
+function splitCompetitors(servers) {
+  const competitors = [];
+  const bystanders = [];
+  for (const [name, entry] of Object.entries(servers)) {
+    if (name === "deepseek")
+      continue;
+    (looksWebCapable(name, entry) ? competitors : bystanders).push(name);
+  }
+  return { competitors, bystanders };
+}
+var BOTH_CAPABILITIES_OFF = "Both capabilities are off; nothing would be installed.", FORCED_COST_NOTE, WEB_TOOL_HINT, STEERING_HINT;
+var init_detect = __esm(() => {
+  init_rules();
+  init_value();
+  FORCED_COST_NOTE = "Forced routing is deterministic, and Search and Fetch are billed per successful request — " + `see the README's "Privacy and cost" section before applying.`;
+  WEB_TOOL_HINT = /(web[_ -]?(search|fetch)|search|fetch|browse|scrape|crawl|tavily|brave|exa|perplexity|firecrawl|jina|serp|duckduckgo|reader)/i;
+  STEERING_HINT = /(web[_ ]?(search|fetch)|websearch|webfetch|tavily|exa|brave|perplexity|firecrawl|jina|serp|duckduckgo|google|bing)/i;
+});
+
+// src/installer/rulesContent.ts
+function rulesLines(ids, search, fetch) {
+  const lines = ["DeepSeek retrieval guidance:"];
+  if (search === "preferred") {
+    lines.push(`- Use ${ids.search} when the task needs fresh external information: current docs, version numbers,`, "  changelogs, or anything you cannot know from the repository alone. Do not search for facts already", "  present locally.");
+  }
+  if (fetch === "preferred") {
+    lines.push(`- Use ${ids.fetch} to read a specific public web page as Markdown when its content is needed.`);
+  }
+  lines.push("- Never send localhost or private-network URLs to the DeepSeek tools; use local tools for those (the", "  server blocks private hosts by default).", "- DeepSeek requests are billed per successful call; retrieve only what the task needs.");
+  return lines;
+}
+var MCP_TOOL_IDS, RAW_MCP_TOOL_IDS;
+var init_rulesContent = __esm(() => {
+  MCP_TOOL_IDS = {
+    search: "mcp__deepseek__deepseek_web_search",
+    fetch: "mcp__deepseek__deepseek_fetch"
+  };
+  RAW_MCP_TOOL_IDS = { search: "deepseek_web_search", fetch: "deepseek_fetch" };
+});
+
+// src/installer/hosts/shared.ts
+function planHeader(input, paths, loaded, dialect) {
+  const notes = [];
+  const errors = [];
+  if (loaded.parseError) {
+    errors.push({ message: `${paths.config} exists but does not parse as ${dialect}: ${loaded.parseError}` });
+    return { notes, errors, abort: true };
+  }
+  if (input.search === "off" && input.fetch === "off") {
+    errors.push({ message: BOTH_CAPABILITIES_OFF });
+  }
+  const rules = codecFor("rules", input.host).load(paths.rules);
+  if (rules.parseError) {
+    errors.push({ message: `${paths.rules}: ${rules.parseError}` });
+    return { notes, errors, abort: true };
+  }
+  const steering = findCompetitorSteering(input.host, paths.rules);
+  if (steering.length > 0)
+    notes.push(competitorSteeringNote(paths.rules, steering));
+  return { notes, errors, abort: false };
+}
+var init_shared = __esm(() => {
+  init_detect();
+  init_formats();
+});
+
+// src/installer/hosts/codex.ts
+import { spawnSync } from "node:child_process";
+function probeCodexVersion(err) {
+  const result = spawnSync("codex", ["--version"], { timeout: 5000, encoding: "utf8", env: process.env });
+  const version = result.status === 0 ? parseCodexVersion(result.stdout ?? "") : undefined;
+  if (version === undefined) {
+    err("note: codex was not found on PATH or printed no version; the version-drift check was skipped");
+  }
+  return version;
+}
+function parseCodexVersion(output) {
+  return /\bcodex(?:-cli)?\s+(\d+\.\d+\.\d+)\b/.exec(output)?.[1];
+}
+function codexPaths(input) {
+  return {
+    config: join2(input.home, ".codex/config.toml"),
+    rules: input.scope === "global" ? join2(input.home, ".codex/AGENTS.md") : join2(input.cwd, "AGENTS.md")
+  };
+}
+function planCodex(input, _previous) {
+  const paths = codexPaths(input);
+  const loaded = codecFor("toml", input.host).load(paths.config);
+  const tiers = { search: input.search, fetch: input.fetch };
+  const header = planHeader(input, paths, loaded, "TOML");
+  if (header.abort) {
+    return { host: "codex", scope: input.scope, tiers, edits: [], notes: header.notes, errors: header.errors };
+  }
+  const notes = [...header.notes];
+  const errors = [...header.errors];
+  const edits = [];
+  if (input.hostVersion !== undefined && input.hostVersion !== CODEX_TESTED_VERSION) {
+    notes.push(`Codex ${input.hostVersion} is installed, but this installer's Codex facts are verified against ` + `${CODEX_TESTED_VERSION} (the docs/hosts.jsonc lock). Kill-switch and trap behavior may have drifted ` + "between the two — re-verify the tiers if routing misbehaves.");
+  }
+  const tools = loaded.value.tools;
+  if (isPlainObject(tools) && "web_search" in tools) {
+    errors.push({
+      message: `${paths.config} sets [tools] web_search, which is a silent no-op at Codex 0.163.0 (only the top-level ` + "web_search key controls the tool). Remove it first so the config cannot mislead."
+    });
+  }
+  const servers = loaded.value.mcp_servers;
+  if (isPlainObject(servers)) {
+    if ("deepseek" in servers)
+      notes.push(replacingExistingEntryNote("mcp_servers.deepseek"));
+    const { competitors, bystanders } = splitCompetitors(servers);
     if ((input.search === "forced" || input.fetch === "forced") && competitors.length > 0) {
       errors.push({
         message: `Forced cannot deliver exclusive routing: [mcp_servers.${competitors.join("], [mcp_servers.")}] look(s) web-capable, ` + "and Codex offers no per-server kill switch. Remove the server(s), disable their tools by hand via their " + "disabled_tools key, or choose a lower tier."
@@ -3128,27 +3815,29 @@ function planCodex(input, _previous) {
     if (stayRegistered.length > 0)
       notes.push(othersStayRegisteredNote(stayRegistered));
   }
-  const env = {};
-  if (input.search === "off")
-    env[ENABLE_SEARCH_ENV] = "false";
-  if (input.fetch === "off")
-    env[ENABLE_FETCH_ENV] = "false";
+  const existingEntry = isPlainObject(servers) ? servers.deepseek : undefined;
+  const rawToolIds = Object.values(RAW_MCP_TOOL_IDS);
+  const keptDisabled = isPlainObject(existingEntry) && Array.isArray(existingEntry.disabled_tools) ? existingEntry.disabled_tools.filter((name) => typeof name === "string" && !rawToolIds.includes(name)) : [];
+  const offDisabled = [
+    ...input.search === "off" ? [RAW_MCP_TOOL_IDS.search] : [],
+    ...input.fetch === "off" ? [RAW_MCP_TOOL_IDS.fetch] : []
+  ];
   const entry = {
     command: "npx",
     args: ["-y", input.packageRef],
-    ...Object.keys(env).length > 0 ? { env } : {},
+    ...keptDisabled.length > 0 || offDisabled.length > 0 ? { disabled_tools: [...keptDisabled, ...offDisabled] } : {},
     env_vars: [API_KEY_ENV]
   };
-  const existingEntry = isPlainObject(servers) ? servers.deepseek : undefined;
-  const ops = [
-    { op: "set", path: ["mcp_servers", "deepseek"], value: entry, previous: existingEntry }
-  ];
+  const ops = [{ op: "set", path: ["mcp_servers", "deepseek"], value: entry, previous: existingEntry }];
+  if (offDisabled.length > 0) {
+    notes.push(`Off capabilities use Codex's own disabled_tools key (${offDisabled.join(", ")}): the tools are removed from ` + "the model's context while the server keeps running and stays re-enableable by deleting the entries.");
+  }
   if (input.search === "forced") {
     const previous = typeof loaded.value.web_search === "string" ? loaded.value.web_search : undefined;
     ops.push({ op: "set", path: ["web_search"], value: "disabled", previous });
     notes.push(previous === undefined ? 'web_search is being set to "disabled" (no previous value existed; the default is "cached").' : `web_search is being set to "disabled"; the previous value "${previous}" is snapshotted for uninstall.`);
   }
-  edits.push({ file: paths.config, format: "toml", ops });
+  edits.push({ file: paths.config, format: "toml", shared: true, ops });
   notes.push(`Codex stdio children do not inherit the parent environment, so the entry forwards ${API_KEY_ENV} explicitly ` + "via env_vars; the key must be set in the shell that launches Codex.");
   if (input.scope === "project") {
     notes.push("Codex config lives in ~/.codex/config.toml only (user level), so the server registration and kill switch are " + "written there even for a project-scope install; the rules file stays project-local.");
@@ -3157,7 +3846,7 @@ function planCodex(input, _previous) {
     notes.push(`${paths.config} contains comments; the TOML rewrite will drop them.`);
   }
   if (input.search === "forced" || input.fetch === "forced") {
-    notes.push('Forced search is exclusion: the built-in web_search tool is disabled ("disabled" mode). ' + FORCED_COST_NOTE);
+    notes.push(`Forced search is exclusion: the built-in web_search tool is disabled ("disabled" mode). ${FORCED_COST_NOTE}`);
   }
   if (input.search === "optional" || input.fetch === "optional") {
     notes.push('Note: Codex ships a built-in web_search tool (default "cached" mode, an OpenAI index) that stays available ' + "alongside the DeepSeek tools under the optional tier.");
@@ -3172,18 +3861,24 @@ function planCodex(input, _previous) {
   }
   return { host: "codex", scope: input.scope, tiers, edits, notes, errors };
 }
+var CODEX_TESTED_VERSION = "0.163.0";
 var init_codex = __esm(() => {
-  init_formats();
-  init_detect();
   init_constants();
+  init_detect();
+  init_formats();
   init_rules();
+  init_value();
+  init_paths();
   init_rulesContent();
   init_shared();
 });
 
 // src/installer/hosts/opencode.ts
 function opencodePaths(input) {
-  return input.scope === "global" ? { config: join(configHome(input), "opencode/opencode.jsonc"), rules: join(configHome(input), "opencode/AGENTS.md") } : { config: join(input.cwd, "opencode.jsonc"), rules: join(input.cwd, "AGENTS.md") };
+  return input.scope === "global" ? {
+    config: join2(configHome(input), "opencode/opencode.jsonc"),
+    rules: join2(configHome(input), "opencode/AGENTS.md")
+  } : { config: join2(input.cwd, "opencode.jsonc"), rules: join2(input.cwd, "AGENTS.md") };
 }
 function planOpenCode(input, previous) {
   const paths = opencodePaths(input);
@@ -3202,14 +3897,17 @@ function planOpenCode(input, previous) {
     });
   }
   const plugins = Array.isArray(loaded.value.plugins) ? loaded.value.plugins : [];
-  const alreadyInstalled = plugins.some((entry) => isPlainObject(entry) && typeof entry.package === "string" && entry.package.includes("deepseek-web-retrieval"));
-  if (alreadyInstalled && previous === undefined) {
+  const trackedPackages = new Set(appendedByPrevious(previous, ["plugins"]).filter((entry) => isPlainObject(entry) && typeof entry.package === "string").map((entry) => entry.package));
+  const pluginPackages = plugins.filter((entry) => isPlainObject(entry) && typeof entry.package === "string");
+  const excused = previous === undefined ? new Set : new Set([...trackedPackages, input.packageRef]);
+  const foreignOwn = pluginPackages.filter((entry) => looksLikeOwnPackage(entry.package) && !excused.has(entry.package));
+  if (foreignOwn.length > 0) {
     errors.push({
       message: `${paths.config} already has a plugins entry referencing deepseek-web-retrieval that this installer did not ` + "write. Remove it (or run uninstall if it came from a previous init), then retry."
     });
   }
-  if (alreadyInstalled && errors.length === 0) {
-    notes.push("A previous init wrote the plugins entry; re-applying updates it and carries the original snapshots over.");
+  if (previous !== undefined && pluginPackages.some((entry) => excused.has(entry.package))) {
+    notes.push("A previous init wrote the plugins entry; re-applying keeps it the only entry (a changed package ref or tier " + "options replace it, an unchanged one is a no-op) and the original snapshots carry over.");
   }
   if (errors.length > 0) {
     return { host: "opencode", scope: input.scope, tiers, edits, notes, errors };
@@ -3253,7 +3951,7 @@ function planOpenCode(input, previous) {
     notes.push("Search tier optional: the deepseek provider is registered but the built-in provider stays the default engine; " + "set websearch.provider to deepseek (or rerun with --search forced) to route search through DeepSeek.");
   }
   if (input.search === "forced" || input.fetch === "forced") {
-    notes.push("Forced tier replaces built-in routing. " + FORCED_COST_NOTE);
+    notes.push(`Forced tier replaces built-in routing. ${FORCED_COST_NOTE}`);
   }
   if (input.fetch === "preferred") {
     edits.push({
@@ -3267,19 +3965,164 @@ function planOpenCode(input, previous) {
 }
 var OPENCODE_TOOL_IDS;
 var init_opencode = __esm(() => {
-  init_formats();
   init_detect();
+  init_formats();
   init_rules();
+  init_value();
+  init_paths();
   init_rulesContent();
+  init_state();
   init_shared();
   OPENCODE_TOOL_IDS = { search: "websearch (provider deepseek)", fetch: "deepseek_fetch" };
 });
 
+// src/pi/settings.ts
+var SETTINGS_NAMESPACE = "deepseekWebRetrieval";
+var init_settings = () => {};
+
 // src/installer/hosts/pi.ts
 function piPaths(input) {
-  return input.scope === "global" ? { config: join(input.home, ".pi/agent/mcp.json"), rules: join(input.home, ".pi/agent/AGENTS.md") } : { config: join(input.cwd, ".pi/mcp.json"), rules: join(input.cwd, "AGENTS.md") };
+  const mcp = input.scope === "global" ? join2(input.home, ".pi/agent/mcp.json") : join2(input.cwd, ".pi/mcp.json");
+  const settings = input.scope === "global" ? join2(input.home, ".pi/agent/settings.json") : join2(input.cwd, ".pi/settings.json");
+  const rules = input.scope === "global" ? join2(input.home, ".pi/agent/AGENTS.md") : join2(input.cwd, "AGENTS.md");
+  return { config: input.path === "mcp" ? mcp : settings, rules };
+}
+function piSourceRef(packageRef) {
+  return packageRef.startsWith("npm:") ? packageRef : `npm:${packageRef}`;
+}
+function planPi(input, previous) {
+  return input.path === "mcp" ? planPiMcp(input) : planPiExtension(input, previous);
+}
+function planPiExtension(input, previous) {
+  const paths = piPaths(input);
+  const loaded = codecFor("json", input.host).load(paths.config);
+  const tiers = { search: input.search, fetch: input.fetch };
+  const header = planHeader(input, paths, loaded, "JSON");
+  if (header.abort) {
+    return { host: "pi", scope: input.scope, tiers, edits: [], notes: header.notes, errors: header.errors };
+  }
+  const notes = [...header.notes];
+  const errors = [...header.errors];
+  const edits = [];
+  const packages = Array.isArray(loaded.value.packages) ? loaded.value.packages : [];
+  const source = piSourceRef(input.packageRef);
+  const trackedSources = appendedByPrevious(previous, ["packages"]).filter((entry) => typeof entry === "string");
+  const excused = previous === undefined ? new Set : new Set([...trackedSources, source]);
+  const sources = packages.filter((entry) => typeof entry === "string");
+  const foreignOwn = sources.filter((entry) => looksLikeOwnPackage(entry) && !excused.has(entry));
+  if (foreignOwn.length > 0) {
+    errors.push({
+      message: `${paths.config} already lists ${foreignOwn.join(", ")} — this package (or a fork of it) that this installer did not ` + "write. Remove it (pi remove <source>, or uninstall if it came from a previous init), then retry."
+    });
+  }
+  if (previous !== undefined && sources.some((entry) => excused.has(entry))) {
+    notes.push("A previous init wrote the packages entry; re-applying reuses it (an unchanged source deduplicates, a changed " + "--package ref replaces the old source) and the original snapshots carry over.");
+  }
+  const forced = input.search === "forced" || input.fetch === "forced";
+  if (forced) {
+    const ownSources = new Set([...trackedSources, source]);
+    const unexcludable = [...collectSources(loaded.value.packages), ...collectSources(loaded.value.extensions)].filter((entry) => !ownSources.has(entry) && looksWebCapable(entry, undefined));
+    if (unexcludable.length > 0) {
+      errors.push({
+        message: `Forced cannot deliver exclusive routing: settings sources ${unexcludable.join(", ")} look web-capable, ` + "and Pi offers no per-package kill switch. Remove them (pi remove <source>) or choose a lower tier."
+      });
+    }
+  }
+  if (errors.length > 0) {
+    return { host: "pi", scope: input.scope, tiers, edits: [], notes, errors };
+  }
+  const ops = [
+    { op: "append-array", path: ["packages"], entries: [source], existingCount: packages.length }
+  ];
+  const namespace = isPlainObject(loaded.value[SETTINGS_NAMESPACE]) ? loaded.value[SETTINGS_NAMESPACE] : {};
+  if (input.search === "off") {
+    ops.push({
+      op: "set",
+      path: [SETTINGS_NAMESPACE, "enableSearch"],
+      value: false,
+      previous: typeof namespace.enableSearch === "boolean" ? namespace.enableSearch : undefined
+    });
+  }
+  if (input.fetch === "off") {
+    ops.push({
+      op: "set",
+      path: [SETTINGS_NAMESPACE, "enableFetch"],
+      value: false,
+      previous: typeof namespace.enableFetch === "boolean" ? namespace.enableFetch : undefined
+    });
+  }
+  edits.push({ file: paths.config, format: "json", ops });
+  notes.push("Pi resolves the packages source at session start; the first launch after apply fetches the package from npm " + "(pi update --extensions refreshes it later).");
+  notes.push(`The extension reads ${API_KEY_ENV} from the Pi process environment; no env forwarding is needed. ` + "Set it in the shell that launches Pi.");
+  if (input.search === "off" || input.fetch === "off") {
+    notes.push(`Off capability switches are written into the "${SETTINGS_NAMESPACE}" settings namespace; the extension ` + "reads them at load (they outrank the DEEPSEEK_ENABLE_* environment variables).");
+  }
+  notes.push(`Extension tools are declared to the model with exposure "direct" by Pi's own default; no exposure key is needed.`);
+  if (forced) {
+    edits.push(...planMcpCompetitorDisables(input, notes, errors));
+  }
+  if (errors.length > 0) {
+    return { host: "pi", scope: input.scope, tiers, edits: [], notes, errors };
+  }
+  if (input.search === "preferred" || input.fetch === "preferred") {
+    edits.push({
+      file: paths.rules,
+      format: "rules",
+      block: buildRulesBlock(input.host, rulesLines(RAW_MCP_TOOL_IDS, input.search, input.fetch))
+    });
+    notes.push(`Rules block upserted in ${paths.rules}; Pi loads AGENTS.md context files from the working directory and its parents.`);
+  }
+  if (forced) {
+    notes.push("Forced tier: Pi 1.3.0 ships no built-in web tool, so the registered tools are the only web path (de-facto). " + FORCED_COST_NOTE);
+  }
+  return { host: "pi", scope: input.scope, tiers, edits, notes, errors };
+}
+function planCompetitorDisables(servers, competitors, notes, errors) {
+  const ops = [];
+  const excluded = [];
+  const unexcludable = [];
+  for (const name of competitors) {
+    const current = servers[name];
+    if (!isPlainObject(current)) {
+      unexcludable.push(name);
+      continue;
+    }
+    const previous = typeof current.enabled === "boolean" ? current.enabled : undefined;
+    ops.push({ op: "set", path: ["mcpServers", name, "enabled"], value: false, previous });
+    excluded.push(name);
+  }
+  if (excluded.length > 0) {
+    notes.push(`Forced tier: web-capable MCP servers are disabled so DeepSeek routing is exclusive (${excluded.join(", ")}; ` + "prior enabled values are snapshotted for uninstall).");
+  }
+  if (unexcludable.length > 0) {
+    errors.push({
+      message: `Forced cannot deliver exclusive routing: mcpServers entries ${unexcludable.join(", ")} look web-capable ` + "but are not objects, so the plan cannot set their enabled key. Fix or remove them, or choose a lower tier."
+    });
+  }
+  return ops;
+}
+function planMcpCompetitorDisables(input, notes, errors) {
+  const mcpFile = input.scope === "global" ? join2(input.home, ".pi/agent/mcp.json") : join2(input.cwd, ".pi/mcp.json");
+  const loaded = codecFor("json", input.host).load(mcpFile);
+  if (loaded.parseError) {
+    errors.push({ message: `${mcpFile} does not parse: ${loaded.parseError}` });
+    return [];
+  }
+  const servers = isPlainObject(loaded.value.mcpServers) ? loaded.value.mcpServers : undefined;
+  if (!isPlainObject(servers))
+    return [];
+  const { competitors, bystanders } = splitCompetitors(servers);
+  const edits = [];
+  if (competitors.length > 0) {
+    const ops = planCompetitorDisables(servers, competitors, notes, errors);
+    if (ops.length > 0)
+      edits.push({ file: mcpFile, format: "json", ops });
+  }
+  if (bystanders.length > 0)
+    notes.push(othersStayRegisteredNote(bystanders));
+  return edits;
 }
-function planPi(input, _previous) {
+function planPiMcp(input) {
   const paths = piPaths(input);
   const loaded = codecFor("json", input.host).load(paths.config);
   const tiers = { search: input.search, fetch: input.fetch };
@@ -3304,9 +4147,7 @@ function planPi(input, _previous) {
   };
   const servers = loaded.value.mcpServers;
   const existingEntry = isPlainObject(servers) ? servers.deepseek : undefined;
-  const ops = [
-    { op: "set", path: ["mcpServers", "deepseek"], value: entry, previous: existingEntry }
-  ];
+  const ops = [{ op: "set", path: ["mcpServers", "deepseek"], value: entry, previous: existingEntry }];
   edits.push({ file: paths.config, format: "json", ops });
   if (isPlainObject(servers)) {
     if (servers.deepseek !== undefined)
@@ -3314,28 +4155,7 @@ function planPi(input, _previous) {
     const { competitors, bystanders } = splitCompetitors(servers);
     const forced = input.search === "forced" || input.fetch === "forced";
     if (forced) {
-      const excluded = [];
-      const unexcludable = [];
-      for (const name of competitors) {
-        const current = servers[name];
-        if (!isPlainObject(current)) {
-          unexcludable.push(name);
-          continue;
-        }
-        const previous = typeof current.enabled === "boolean" ? current.enabled : undefined;
-        if (previous === false)
-          continue;
-        ops.push({ op: "set", path: ["mcpServers", name, "enabled"], value: false, previous });
-        excluded.push(name);
-      }
-      if (excluded.length > 0) {
-        notes.push(`Forced tier: web-capable MCP servers are disabled so DeepSeek routing is exclusive (${excluded.join(", ")}; ` + "prior enabled values are snapshotted for uninstall).");
-      }
-      if (unexcludable.length > 0) {
-        errors.push({
-          message: `Forced cannot deliver exclusive routing: mcpServers entries ${unexcludable.join(", ")} look web-capable ` + "but are not objects, so the plan cannot set their enabled key. Fix or remove them, or choose a lower tier."
-        });
-      }
+      ops.push(...planCompetitorDisables(servers, competitors, notes, errors));
     }
     const stayRegistered = forced ? bystanders : [...competitors, ...bystanders];
     if (stayRegistered.length > 0)
@@ -3343,9 +4163,6 @@ function planPi(input, _previous) {
   }
   notes.push('"exposure": "direct" is required: Pi 1.3.0 defaults MCP tools to codemode, which hides them from the model.');
   notes.push(`\`${API_KEY_ENV}\` is written as "\${${API_KEY_ENV}}" so the key expands from the shell that launches Pi and stays out of the file.`);
-  if (loaded.lossy) {
-    notes.push(`${paths.config} contains comments; the JSON edit preserves them.`);
-  }
   if (input.search === "preferred" || input.fetch === "preferred") {
     edits.push({
       file: paths.rules,
@@ -3359,81 +4176,56 @@ function planPi(input, _previous) {
   }
   return { host: "pi", scope: input.scope, tiers, edits, notes, errors };
 }
+function collectSources(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
 var init_pi = __esm(() => {
-  init_formats();
-  init_detect();
   init_constants();
+  init_settings();
+  init_detect();
+  init_formats();
   init_rules();
+  init_value();
+  init_paths();
   init_rulesContent();
+  init_state();
   init_shared();
 });
 
-// src/installer/state.ts
-import { chmodSync, existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync5, readdirSync, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join2 } from "node:path";
-function statePathFor(input) {
-  return join2(stateDir(input, input.scope), `install.${input.host}.json`);
-}
-function readRecord(input) {
-  const file = statePathFor(input);
-  if (!existsSync5(file))
-    return;
-  try {
-    return JSON.parse(readFileSync5(file, "utf8"));
-  } catch {
-    return;
-  }
-}
-function claimedByOtherScope(input, files) {
-  const other = input.scope === "global" ? "project" : "global";
-  const record = readRecord({ ...input, scope: other });
-  if (record === undefined)
-    return [];
-  return files.filter((file) => record.files.some((candidate) => candidate.file === file));
-}
-function writeRecord(input, record) {
-  const file = statePathFor(input);
-  mkdirSync2(join2(file, ".."), { recursive: true });
-  writeFileSync2(file, `${JSON.stringify(record, null, 2)}
-`, { mode: 384 });
-  chmodSync(file, 384);
-}
-function deleteRecord(input) {
-  const file = statePathFor(input);
-  if (existsSync5(file))
-    rmSync(file);
-}
-function listRecords(roots) {
-  const records = [];
-  for (const scope of ["global", "project"]) {
-    const dir = stateDir(roots, scope);
-    if (!existsSync5(dir))
-      continue;
-    for (const name of readdirSync(dir)) {
-      if (!name.startsWith("install.") || !name.endsWith(".json"))
-        continue;
-      try {
-        records.push(JSON.parse(readFileSync5(join2(dir, name), "utf8")));
-      } catch {}
-    }
-  }
-  return records;
-}
-var init_state = () => {};
-
 // src/installer/hosts/index.ts
 function planForHost(host, input) {
-  const previous = readRecord(input);
-  const planned = withCrossScopeGuard(HOST_PLANNERS[host](input, previous), input);
-  return withSecretGuard(withOrphanReverts(planned, input, previous));
+  try {
+    const previous = readRecord(input);
+    const planned = withCrossScopeGuard(HOST_PLANNERS[host](input, previous), input);
+    return {
+      ...withSecretGuard(withOrphanReverts(withLegacySharedConfigGuard(planned, previous), previous)),
+      previousRecord: previous
+    };
+  } catch (error) {
+    if (!(error instanceof InstallRecordError))
+      throw error;
+    return {
+      host,
+      scope: input.scope,
+      tiers: { search: input.search, fetch: input.fetch },
+      edits: [],
+      notes: [],
+      errors: [{ message: error.message }]
+    };
+  }
 }
 function withCrossScopeGuard(plan, input) {
   if (plan.errors.length > 0)
     return plan;
+  try {
+    assertFileOwnership(input, plan.edits);
+  } catch (error) {
+    return { ...plan, edits: [], reverts: undefined, errors: [{ message: String(error) }] };
+  }
   const other = input.scope === "global" ? "project" : "global";
   const overlap = claimedByOtherScope(input, plan.edits.map((edit2) => edit2.file));
   if (overlap.length === 0)
-    return plan;
+    return { ...plan, notes: [...plan.notes, ...fileOwnershipNotes(input, plan.edits)] };
   return {
     ...plan,
     edits: [],
@@ -3445,6 +4237,30 @@ function withCrossScopeGuard(plan, input) {
     ]
   };
 }
+function withLegacySharedConfigGuard(plan, previous) {
+  if (plan.errors.length > 0 || previous !== undefined)
+    return plan;
+  for (const edit2 of plan.edits) {
+    if (edit2.format === "rules" || !edit2.shared)
+      continue;
+    for (const op of edit2.ops) {
+      const old = op.previous;
+      if (op.op !== "set" || !isPlainObject(old) || old.command !== "npx" || !Array.isArray(old.args) || old.args[0] !== "-y" || !Array.isArray(old.env_vars) || !old.env_vars.includes(API_KEY_ENV))
+        continue;
+      return {
+        ...plan,
+        edits: [],
+        reverts: undefined,
+        errors: [
+          {
+            message: `${edit2.file} contains an installer-style registration without an install record for this location. ` + "It may belong to an older install in another project. Re-run init or uninstall from that original project and scope first; " + "if the registration was created manually, remove it before retrying. No existing registration was adopted."
+          }
+        ]
+      };
+    }
+  }
+  return plan;
+}
 function withSecretGuard(plan) {
   for (const edit2 of plan.edits) {
     if (edit2.format === "rules")
@@ -3483,224 +4299,52 @@ function findSecretLike(value, at) {
   }
   return;
 }
-function withOrphanReverts(plan, input, previous) {
+function withOrphanReverts(plan, previous) {
   if (plan.errors.length > 0)
     return plan;
   if (previous === undefined)
     return plan;
   const reverts = [];
   for (const file of previous.files) {
-    const edit2 = plan.edits.find((candidate) => candidate.file === file.file);
-    if (edit2 === undefined) {
-      reverts.push(file);
-      continue;
-    }
-    if (edit2.format === "rules" || file.format === "rules")
-      continue;
-    const orphanOps = file.ops.filter((op) => !edit2.ops.some((candidate) => candidate.op === op.op && candidate.path.join("\x00") === op.path.join("\x00")));
-    if (orphanOps.length > 0)
-      reverts.push({ ...file, ops: orphanOps });
-  }
-  if (reverts.length === 0)
-    return plan;
-  return { ...plan, reverts };
-}
-var HOST_PLANNERS;
-var init_hosts = __esm(() => {
-  init_codex();
-  init_opencode();
-  init_pi();
-  init_constants();
-  init_state();
-  HOST_PLANNERS = {
-    opencode: planOpenCode,
-    pi: planPi,
-    codex: planCodex
-  };
-});
-
-// src/installer/revert.ts
-import { existsSync as existsSync6, readFileSync as readFileSync6, rmdirSync, unlinkSync } from "node:fs";
-import { dirname as dirname2 } from "node:path";
-function pruneEmptyDir(dir) {
-  try {
-    rmdirSync(dir);
-  } catch {}
-}
-function revertRecordedFile(file, host, opts) {
-  const lines = [];
-  if (!existsSync6(file.file)) {
-    lines.push(`already absent: ${file.file}${opts.label}`);
-    return lines;
-  }
-  const codec = codecFor(file.format, host);
-  const text = readFileSync6(file.file, "utf8");
-  if (file.format === "rules") {
-    const edit2 = { file: file.file, format: "rules", block: file.blockApplied ?? "" };
-    if (!codec.verify(text, edit2)) {
-      lines.push(`no rules block${opts.label} in ${file.file}; left untouched`);
-      return lines;
-    }
-    const updated = codec.revert(text, file).text;
-    if (opts.whole && codec.isEffectivelyEmpty(updated)) {
-      unlinkSync(file.file);
-      pruneEmptyDir(dirname2(file.file));
-      lines.push(`deleted ${file.file} (installer-created, now empty)`);
-    } else {
-      writeConfig(file.file, updated);
-      lines.push(`removed rules block${opts.label} from ${file.file}`);
-    }
-    return lines;
-  }
-  const reverted = codec.revert(text, file);
-  if (opts.whole && file.created && codec.isEffectivelyEmpty(reverted.text)) {
-    unlinkSync(file.file);
-    pruneEmptyDir(dirname2(file.file));
-    lines.push(`deleted ${file.file} (installer-created, now empty)`);
-  } else {
-    writeConfig(file.file, reverted.text);
-    lines.push(`reverted artifacts${opts.label} in ${file.file}`);
-  }
-  lines.push(...reverted.notes.map((note) => `  note: ${note}`));
-  return lines;
-}
-var init_revert = __esm(() => {
-  init_formats();
-});
-
-// src/installer/apply.ts
-import { existsSync as existsSync7, readFileSync as readFileSync7 } from "node:fs";
-function applyPlan(plan, input) {
-  if (plan.errors.length > 0) {
-    throw new Error(`refusing to apply a plan with errors: ${plan.errors.map((error) => error.message).join("; ")}`);
-  }
-  assertNoDrift(plan);
-  const previous = readRecord(input);
-  const prepared = plan.edits.map((edit2) => prepareEdit(edit2, plan.host));
-  const files = [];
-  const lines = [];
-  for (const item of prepared) {
-    item.write();
-    files.push(mergeRecorded(item.recorded, previous?.files.find((file) => file.file === item.edit.file)));
-    lines.push(`${item.recorded.created ? "created" : "updated"} ${item.edit.file}`);
-  }
-  if ((plan.reverts ?? []).length > 0) {
-    lines.push(...applyReverts(plan));
-  }
-  const record = {
-    version: 1,
-    host: plan.host,
-    scope: plan.scope,
-    tiers: plan.tiers,
-    createdAt: new Date().toISOString(),
-    files
-  };
-  writeRecord(input, record);
-  const verification = verifyEdits(plan.edits, plan.host);
-  lines.push(...verification.lines);
-  return { lines, ok: verification.ok };
-}
-function assertNoDrift(plan) {
-  const drifts = [];
-  for (const edit2 of plan.edits) {
-    if (edit2.format === "rules")
-      continue;
-    const loaded = codecFor(edit2.format, plan.host).load(edit2.file);
-    if (loaded.parseError) {
-      drifts.push(`${edit2.file} no longer parses (${loaded.parseError})`);
-      continue;
-    }
-    for (const op of edit2.ops) {
-      if (op.op !== "set")
-        continue;
-      const current = valueAt(loaded.value, op.path);
-      if (!deepEqual(current, op.previous)) {
-        drifts.push(`${edit2.file}: ${op.path.join(".")} changed since the plan was rendered`);
-      }
-    }
-  }
-  if (drifts.length > 0) {
-    throw new Error(`refusing to apply — the config changed since the plan was rendered: ${drifts.join("; ")}. ` + "Re-run init to re-plan against the current files.");
-  }
-}
-function prepareEdit(edit2, host) {
-  const codec = codecFor(edit2.format, host);
-  const loaded = codec.load(edit2.file);
-  if (loaded.parseError) {
-    throw new Error(`${edit2.file} does not parse: ${loaded.parseError}`);
-  }
-  const applied = codec.apply(loaded.text, edit2);
-  const recorded = edit2.format === "rules" ? { file: edit2.file, format: "rules", created: !loaded.exists, ops: [], blockApplied: edit2.block } : { file: edit2.file, format: edit2.format, created: !loaded.exists, ops: applied.recorded, createdParents: applied.createdParents };
-  return {
-    edit: edit2,
-    recorded,
-    write: () => writeConfig(edit2.file, applied.text)
-  };
-}
-function applyReverts(plan) {
-  const lines = [];
-  for (const revert of plan.reverts ?? []) {
-    const whole = !plan.edits.some((edit2) => edit2.file === revert.file);
-    lines.push(...revertRecordedFile(revert, plan.host, { label: " (previous init)", whole }));
-  }
-  return lines;
-}
-function mergeRecorded(current, before) {
-  if (before === undefined)
-    return current;
-  const ops = current.ops.map((op) => {
-    const old = before.ops.find((candidate) => candidate.op === op.op && candidate.path.join("\x00") === op.path.join("\x00"));
-    if (old === undefined)
-      return op;
-    if (op.op === "set" && old.op === "set" && deepEqual(op.previous, old.applied)) {
-      return { ...op, previous: old.previous };
-    }
-    if (op.op === "append-array" && old.op === "append-array") {
-      return { ...op, applied: [...old.applied, ...op.applied] };
-    }
-    return op;
-  });
-  return {
-    ...current,
-    created: before.created,
-    ops,
-    createdParents: [...before.createdParents ?? [], ...current.createdParents ?? []]
-  };
-}
-function verifyEdits(edits, host) {
-  const lines = [];
-  let ok = true;
-  for (const edit2 of edits) {
-    if (!existsSync7(edit2.file)) {
-      lines.push(`FAIL ${edit2.file} does not exist after apply`);
-      ok = false;
-      continue;
-    }
-    const codec = codecFor(edit2.format, host);
-    const text = readFileSync7(edit2.file, "utf8");
-    if (edit2.format === "rules") {
-      const good = codec.verify(text, edit2);
-      lines.push(`${good ? "pass" : "FAIL"} ${edit2.file}: rules block ${good ? "present" : "missing"}`);
-      ok = ok && good;
-      continue;
-    }
-    for (const op of edit2.ops) {
-      const good = codec.verify(text, edit2, op);
-      lines.push(`${good ? "pass" : "FAIL"} ${edit2.file}: ${describeOp(op)} ${good ? "holds" : "missing"}`);
-      ok = ok && good;
+    const edit2 = plan.edits.find((candidate) => candidate.file === file.file);
+    if (edit2 === undefined) {
+      reverts.push(file);
+      continue;
     }
+    if (edit2.format === "rules" || file.format === "rules")
+      continue;
+    const orphanOps = file.ops.flatMap((op) => {
+      const claimed = edit2.ops.find((candidate) => candidate.op === op.op && candidate.path.join("\x00") === op.path.join("\x00"));
+      if (op.op !== "append-array" || claimed === undefined || claimed.op !== "append-array") {
+        return claimed === undefined ? [op] : [];
+      }
+      const dropped = (Array.isArray(op.applied) ? op.applied : []).filter((entry) => !(claimed.entries ?? []).some((wanted) => deepEqual(wanted, entry)));
+      return dropped.length > 0 ? [{ ...op, applied: dropped }] : [];
+    });
+    if (orphanOps.length > 0)
+      reverts.push({ ...file, ops: orphanOps });
   }
-  return { lines, ok };
-}
-function describeOp(op) {
-  if (op.op === "set")
-    return `set ${op.path.join(".")}`;
-  return `append ${op.path.join(".")}`;
+  if (reverts.length === 0)
+    return plan;
+  return { ...plan, reverts };
 }
-var init_apply = __esm(() => {
-  init_formats();
-  init_revert();
+var HOST_PLANNERS, HOST_VERSION_PROBES;
+var init_hosts = __esm(() => {
+  init_constants();
+  init_value();
+  init_ownership();
   init_state();
+  init_codex();
+  init_opencode();
+  init_pi();
+  HOST_PLANNERS = {
+    opencode: planOpenCode,
+    pi: planPi,
+    codex: planCodex
+  };
+  HOST_VERSION_PROBES = {
+    codex: probeCodexVersion
+  };
 });
 
 // src/installer/render.ts
@@ -3764,25 +4408,43 @@ function preview(value) {
 
 // src/installer/uninstall.ts
 function uninstall(input) {
-  const record = readRecord(input);
-  if (record === undefined) {
-    throw new Error(`No ${input.host} install is recorded for the ${input.scope} scope.`);
-  }
+  return withOperationLock([statePathFor(input)], () => {
+    const record = readRecord(input);
+    if (record === undefined) {
+      throw new Error(`No ${input.host} install is recorded for the ${input.scope} scope.`);
+    }
+    return withOperationLock(record.files.map((file) => file.file), () => uninstallLocked(input, record));
+  });
+}
+function uninstallLocked(input, record) {
+  assertFileOwnership(input, record.files);
   const other = input.scope === "global" ? "project" : "global";
   const overlap = claimedByOtherScope(input, record.files.map((file) => file.file));
   if (overlap.length > 0) {
     throw new Error(`A ${input.host} install is also recorded at the ${other} scope and claims the same file(s): ${overlap.join(", ")}. ` + `Uninstall the ${other}-scope install first so this rollback cannot clobber its entries.`);
   }
   const lines = [];
+  for (const file of record.files) {
+    if (file.format !== "rules")
+      continue;
+    const loaded = codecFor("rules", record.host).load(file.file);
+    if (loaded.parseError)
+      throw new Error(`${file.file}: ${loaded.parseError}`);
+  }
   for (const file of [...record.files].reverse()) {
     lines.push(...revertRecordedFile(file, record.host, { label: "", whole: true }));
   }
   deleteRecord(input);
+  releaseFileOwnership(input, record.files);
   pruneEmptyDir(stateDir(input, input.scope));
   lines.push(`removed install record (${input.host}, ${input.scope})`);
   return lines;
 }
 var init_uninstall = __esm(() => {
+  init_formats();
+  init_operation_lock();
+  init_ownership();
+  init_paths();
   init_revert();
   init_state();
 });
@@ -3793,7 +4455,7 @@ __export(exports_cli, {
   runInstallerCli: () => runInstallerCli
 });
 import { homedir } from "node:os";
-import { resolve } from "node:path";
+import { resolve as resolve2 } from "node:path";
 function parseFlags(args) {
   const values = new Map;
   const booleans = new Set;
@@ -3807,6 +4469,10 @@ function parseFlags(args) {
     const eq = arg.indexOf("=");
     const name = eq === -1 ? arg.slice(2) : arg.slice(2, eq);
     if (BOOLEAN_FLAGS.has(name)) {
+      if (eq !== -1) {
+        problems.push(`--${name} does not accept a value; use --${name} to enable it or omit it`);
+        continue;
+      }
       booleans.add(name);
       continue;
     }
@@ -3844,11 +4510,17 @@ async function runInstallerCli(argv, io = {}) {
 ${USAGE}`);
     return 1;
   }
-  const cwd = resolve(flags.values.get("cwd") ?? process.cwd());
+  const cwd = resolve2(flags.values.get("cwd") ?? process.cwd());
   const home = process.env.HOME ?? homedir();
   const configHome2 = resolveConfigHome(home);
   if (command === "list") {
-    const records = listRecords({ home, cwd, configHome: configHome2 });
+    let records;
+    try {
+      records = listRecords({ home, cwd, configHome: configHome2 });
+    } catch (error) {
+      err(error instanceof Error ? error.message : String(error));
+      return 1;
+    }
     if (records.length === 0) {
       out("No installs recorded.");
       return 0;
@@ -3883,7 +4555,9 @@ ${USAGE}`);
   if (!required.ok)
     return usageError(required.problems, err);
   const { input } = required;
-  const plan = planForHost(input.host, input);
+  const probe = HOST_VERSION_PROBES[input.host];
+  const hostVersion = probe?.(err);
+  const plan = planForHost(input.host, hostVersion === undefined ? input : { ...input, hostVersion });
   if (plan.errors.length > 0) {
     for (const error of plan.errors)
       err(`error: ${error.message}`);
@@ -3925,6 +4599,7 @@ function requireInput(flags, cwd, home, configHome2, needsTiers) {
   const scope = flags.values.get("scope");
   const search = needsTiers ? flags.values.get("search") ?? "" : "optional";
   const fetch = needsTiers ? flags.values.get("fetch") ?? "" : "optional";
+  const path = flags.values.get("path");
   if (host === undefined)
     problems.push(`--host is required (one of: ${HOSTS.join(", ")})`);
   else if (!HOSTS.includes(host))
@@ -3933,6 +4608,13 @@ function requireInput(flags, cwd, home, configHome2, needsTiers) {
     problems.push(`--scope is required (one of: ${SCOPES.join(", ")})`);
   else if (!SCOPES.includes(scope))
     problems.push(`invalid --scope value "${scope}" (one of: ${SCOPES.join(", ")})`);
+  if (path !== undefined) {
+    if (host !== "pi") {
+      problems.push(`--path is only supported for host pi (${host ?? "no host"} has a single integration path)`);
+    } else if (!PATH_CHOICES.includes(path)) {
+      problems.push(`invalid --path value "${path}" (one of: ${PATH_CHOICES.join(", ")})`);
+    }
+  }
   if (needsTiers) {
     if (!TIERS.includes(search)) {
       problems.push(flags.values.has("search") ? `invalid --search value "${search}" (one of: ${TIERS.join(", ")})` : `--search is required (one of: ${TIERS.join(", ")})`);
@@ -3955,14 +4637,15 @@ function requireInput(flags, cwd, home, configHome2, needsTiers) {
       packageRef: flags.values.get("package") ?? "deepseek-web-retrieval",
       home,
       cwd,
-      configHome: configHome2
+      configHome: configHome2,
+      ...path !== undefined ? { path } : {}
     }
   };
 }
-var HOSTS, HOST_CHOICES, SCOPES, TIERS, USAGE, VALUE_FLAGS, BOOLEAN_FLAGS;
+var HOSTS, HOST_CHOICES, SCOPES, TIERS, USAGE, VALUE_FLAGS, BOOLEAN_FLAGS, PATH_CHOICES;
 var init_cli = __esm(() => {
-  init_hosts();
   init_apply();
+  init_hosts();
   init_state();
   init_uninstall();
   HOSTS = Object.keys(HOST_PLANNERS);
@@ -3970,14 +4653,20 @@ var init_cli = __esm(() => {
   SCOPES = ["project", "global"];
   TIERS = ["optional", "preferred", "forced", "off"];
   USAGE = `Usage:
-  deepseek-web-retrieval init --host ${HOST_CHOICES} --scope <project|global> --search <optional|preferred|forced|off> --fetch <optional|preferred|forced|off> [--package <npm ref>] [--cwd <dir>] [--apply]
+  deepseek-web-retrieval init --host ${HOST_CHOICES} --scope <project|global> --search <optional|preferred|forced|off> --fetch <optional|preferred|forced|off> [--path <extension|mcp>] [--package <npm ref>] [--cwd <dir>] [--apply]
   deepseek-web-retrieval uninstall --host ${HOST_CHOICES} --scope <project|global> [--cwd <dir>]
   deepseek-web-retrieval list [--cwd <dir>]
 
 init prints the full plan (every file, old value → new value) and writes nothing
-until --apply is passed. uninstall restores what the plan applied.`;
-  VALUE_FLAGS = new Set(["host", "scope", "search", "fetch", "package", "cwd"]);
+until --apply is passed. uninstall restores what the plan applied. --path picks
+the integration mechanism for hosts with more than one (Pi: extension by
+default, mcp for the stdio MCP server). --package overrides the package ref
+written into host config; the Pi extension path turns it into the packages
+source (a bare name is prefixed with npm:, a ref that already starts with npm:
+is written as-is).`;
+  VALUE_FLAGS = new Set(["host", "scope", "search", "fetch", "path", "package", "cwd"]);
   BOOLEAN_FLAGS = new Set(["apply"]);
+  PATH_CHOICES = ["extension", "mcp"];
 });
 
 // src/mcp/cli.ts
@@ -3990,17 +4679,7 @@ function apiKeyFromEnv(env = process.env) {
   return key ? key : undefined;
 }
 
-// src/mcp/auth.ts
-init_constants();
-var MISSING_API_KEY_MESSAGE = `DeepSeek API key not found. Set ${API_KEY_ENV} in the MCP server's env configuration.`;
-function requireApiKey(env) {
-  const apiKey = apiKeyFromEnv(env);
-  if (!apiKey)
-    throw new Error(MISSING_API_KEY_MESSAGE);
-  return apiKey;
-}
-
-// src/mcp/config.ts
+// src/core/env.ts
 init_constants();
 
 // src/core/options.ts
@@ -4128,7 +4807,7 @@ function resolveSearchOptions(input) {
     maxResults: clampInt(input?.maxResults, DEFAULT_MAX_RESULTS, 0, 50),
     minRerank: finiteNumber(input?.minRerank, DEFAULT_MIN_RERANK),
     minAuthority: finiteNumber(input?.minAuthority, DEFAULT_MIN_AUTHORITY),
-    allowUnknownAuthority: input?.allowUnknownAuthority === true,
+    allowUnknownAuthority: input?.allowUnknownAuthority !== false,
     blockedDomains: normalizeDomains(input?.blockedDomains),
     includeDomains: normalizeDomains(input?.includeDomains),
     language: optionalText(input?.language),
@@ -4173,7 +4852,7 @@ function clampInt(value, fallback, min, max) {
   return Math.min(max, Math.max(min, number));
 }
 
-// src/mcp/config.ts
+// src/core/env.ts
 var NUMBER_ENV = {
   count: "DEEPSEEK_SEARCH_COUNT",
   maxResults: "DEEPSEEK_SEARCH_MAX_RESULTS",
@@ -4195,10 +4874,8 @@ var DOMAINS_ENV = {
   fetchAllowedDomains: "DEEPSEEK_FETCH_ALLOWED_DOMAINS",
   fetchBlockedDomains: "DEEPSEEK_FETCH_BLOCKED_DOMAINS"
 };
-var FLAG_ENV = {
-  allowUnknownAuthority: "DEEPSEEK_SEARCH_ALLOW_UNKNOWN_AUTHORITY"
-};
 var FALSE_ONLY_ENV = {
+  allowUnknownAuthority: "DEEPSEEK_SEARCH_ALLOW_UNKNOWN_AUTHORITY",
   fetchBlockPrivateHosts: "DEEPSEEK_FETCH_BLOCK_PRIVATE_HOSTS",
   searchEnabled: ENABLE_SEARCH_ENV,
   fetchEnabled: ENABLE_FETCH_ENV
@@ -4212,7 +4889,7 @@ function pluginOptionsFromEnv(env) {
   putNumber(options, "maxResults", env);
   putNumber(options, "minRerank", env);
   putNumber(options, "minAuthority", env);
-  putBoolean(options, "allowUnknownAuthority", env);
+  putFalseOnly(options, "allowUnknownAuthority", env);
   putDomains(options, "blockedDomains", env);
   putDomains(options, "includeDomains", env);
   putText(options, "language", env);
@@ -4248,10 +4925,6 @@ function putText(target, key, env) {
   if (trimmed)
     target[key] = trimmed;
 }
-function putBoolean(target, key, env) {
-  if (isTrueValue(env[FLAG_ENV[key]]))
-    target[key] = true;
-}
 function putFalseOnly(target, key, env) {
   if (isFalseValue(env[FALSE_ONLY_ENV[key]]))
     target[key] = false;
@@ -4264,18 +4937,145 @@ function putDomains(target, key, env) {
   if (domains.length > 0)
     target[key] = domains;
 }
-function isTrueValue(value) {
-  const trimmed = value?.trim().toLowerCase();
-  return trimmed === "true" || trimmed === "1" || trimmed === "yes" || trimmed === "on";
-}
 function isFalseValue(value) {
   const trimmed = value?.trim().toLowerCase();
   return trimmed === "false" || trimmed === "0" || trimmed === "no" || trimmed === "off";
 }
 
+// src/mcp/auth.ts
+init_constants();
+var MISSING_API_KEY_MESSAGE = `DeepSeek API key not found. Set ${API_KEY_ENV} in the MCP server's env configuration.`;
+function requireApiKey(env) {
+  const apiKey = apiKeyFromEnv(env);
+  if (!apiKey)
+    throw new Error(MISSING_API_KEY_MESSAGE);
+  return apiKey;
+}
+
+// src/mcp/client.ts
+import { CLIENT_INFO_META_KEY } from "@modelcontextprotocol/server";
+var JSON_REPLACING_CLIENT_NAMES = new Set(["codex-mcp-client"]);
+function clientNameOf(server, ctx) {
+  const envelope = ctx.mcpReq.envelope;
+  const name = envelope?.[CLIENT_INFO_META_KEY];
+  if (typeof name === "object" && name !== null && "name" in name && typeof name.name === "string") {
+    return name.name;
+  }
+  return server.server.getClientVersion()?.name;
+}
+function isJsonReplacingClient(name) {
+  return name !== undefined && JSON_REPLACING_CLIENT_NAMES.has(name);
+}
+function omitStructuredContent(server, ctx) {
+  return isJsonReplacingClient(clientNameOf(server, ctx));
+}
+
 // src/mcp/server.ts
 import { McpServer } from "@modelcontextprotocol/server";
 import * as z from "zod/v4";
+// package.json
+var package_default = {
+  $schema: "https://json.schemastore.org/package.json",
+  name: "deepseek-web-retrieval",
+  version: "0.5.0",
+  description: "Token-efficient DeepSeek Search and Fetch for coding agents, starting with OpenCode v2.",
+  type: "module",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/gwokhou/deepseek-web-retrieval.git"
+  },
+  homepage: "https://github.com/gwokhou/deepseek-web-retrieval#readme",
+  bugs: "https://github.com/gwokhou/deepseek-web-retrieval/issues",
+  keywords: [
+    "opencode",
+    "opencode-plugin",
+    "pi",
+    "pi-extension",
+    "deepseek",
+    "websearch",
+    "webfetch",
+    "coding-agent",
+    "mcp"
+  ],
+  exports: {
+    ".": "./index.ts",
+    "./core": "./src/core/index.ts",
+    "./mcp": "./src/mcp/server.ts",
+    "./pi": "./src/pi/extension.ts"
+  },
+  pi: {
+    extensions: [
+      "./src/pi/extension.ts"
+    ]
+  },
+  bin: {
+    "deepseek-web-retrieval": "dist/cli.js"
+  },
+  files: [
+    "index.ts",
+    "src",
+    "dist",
+    "docs",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "examples"
+  ],
+  scripts: {
+    lint: "biome check --error-on-warnings .",
+    "lint:ci": "biome ci --error-on-warnings .",
+    "lint:fix": "biome check --write --error-on-warnings .",
+    format: "biome format --write .",
+    typecheck: "tsc --noEmit",
+    build: "bun build src/mcp/cli.ts --target=node --format=esm --outdir=dist --external @modelcontextprotocol/server --external @modelcontextprotocol/server/stdio --external zod --external zod/v4",
+    prepublishOnly: "bun run check:release",
+    test: "bun test",
+    "test:package": "node scripts/test-package.mjs",
+    "test:e2e:keyless": "bun run test:e2e pi pi-extension installer reinit upgrade pkg capability-off",
+    "check:release": "bun run check && bun run test:package && bun run test:e2e:keyless",
+    "test:e2e": "bun run test/e2e/run.ts",
+    "docs:matrix": "bun run scripts/render-matrix.ts",
+    "test:coverage": "bun test --coverage",
+    check: "bun run lint && bun run typecheck && bun run docs:matrix --check && bun run build && bun test"
+  },
+  peerDependencies: {
+    "@earendil-works/pi-ai": "^1.3.0",
+    "@earendil-works/pi-coding-agent": "^1.3.0",
+    "@opencode/plugin": "^2.0.32"
+  },
+  peerDependenciesMeta: {
+    "@earendil-works/pi-ai": {
+      optional: true
+    },
+    "@earendil-works/pi-coding-agent": {
+      optional: true
+    },
+    "@opencode/plugin": {
+      optional: true
+    }
+  },
+  devDependencies: {
+    "@biomejs/biome": "2.5.15",
+    "@earendil-works/pi-ai": "1.3.0",
+    "@earendil-works/pi-coding-agent": "1.3.0",
+    "@modelcontextprotocol/client": "^2.3.1",
+    "@opencode/plugin": "2.0.32",
+    "@types/bun": "1.4.0",
+    "@types/node": "^26.6.5",
+    typescript: "5.9.3"
+  },
+  engines: {
+    bun: ">=1.3.0",
+    node: ">=20"
+  },
+  dependencies: {
+    "@modelcontextprotocol/server": "^2.3.1",
+    "jsonc-parser": "^3.3.1",
+    "smol-toml": "^1.9.1",
+    zod: "^4"
+  }
+};
 
 // src/core/client.ts
 init_constants();
@@ -4357,6 +5157,14 @@ function formatSearchResults(results) {
 
 `);
 }
+function toStructuredResult(result) {
+  return {
+    url: result.url,
+    ...result.title ? { title: result.title } : {},
+    ...result.content ? { content: result.content } : {},
+    ...result.published !== undefined ? { published: result.published } : {}
+  };
+}
 function escapeBrackets(value) {
   return value.replaceAll("[", "\\[").replaceAll("]", "\\]");
 }
@@ -4439,8 +5247,12 @@ function processResults(raw, options) {
     if (!url || seen.has(url))
       continue;
     const rerank = item.rerank_score;
-    if (typeof rerank !== "number" || !Number.isFinite(rerank) || rerank < options.minRerank)
+    if (typeof rerank === "number" && Number.isFinite(rerank)) {
+      if (rerank < options.minRerank)
+        continue;
+    } else if (options.minRerank > 0) {
       continue;
+    }
     const authority = item.authority;
     const knownAuthority = typeof authority === "number" && Number.isFinite(authority) && authority >= 0;
     if (knownAuthority) {
@@ -4682,22 +5494,26 @@ async function searchWeb(query, options, request) {
     query: builtQuery,
     count: options.count,
     need_content: false
-  }, "DeepSeek Search", { signal: request.signal, auth: request.auth, retry: request.retry, timeoutMs: timeout });
+  }, "DeepSeek Search", { ...request, timeoutMs: timeout });
   if (!Array.isArray(payload.results)) {
     throw new Error("DeepSeek Search returned a response without a results array");
   }
   return processResults(payload.results, options);
 }
 async function fetchPage(url, options, request) {
-  assertFetchHostPolicy(url, options);
+  const target = parseFetchUrl(url.href);
+  assertFetchHostPolicy(target, options);
   const timeout = effectiveTimeout(options.timeoutMs, request.timeoutMs);
-  const payload = await postJson(FETCH_ENDPOINT, { url: url.href }, "DeepSeek Fetch", { signal: request.signal, auth: request.auth, retry: request.retry, timeoutMs: timeout });
+  const payload = await postJson(FETCH_ENDPOINT, { url: target.href }, "DeepSeek Fetch", {
+    ...request,
+    timeoutMs: timeout
+  });
   const title = typeof payload.title === "string" ? payload.title.trim() : "";
   const content = typeof payload.content === "string" ? payload.content : "";
   if (!content.trim()) {
     throw new Error("DeepSeek Fetch returned no page content (the page may be empty or unavailable)");
   }
-  return { url: url.href, title, content };
+  return { url: target.href, title, content };
 }
 async function fetchDocument(url, options, request) {
   if (typeof url !== "string" && !(url instanceof URL))
@@ -4711,6 +5527,15 @@ async function fetchDocument(url, options, request) {
     truncated: formatted.truncated
   };
 }
+function createRetrievalClient(dependencies = {}) {
+  const bind = (request) => ({ ...request, ...dependencies });
+  return {
+    searchWeb: (query, options, request) => searchWeb(query, options, bind(request)),
+    fetchPage: (url, options, request) => fetchPage(url, options, bind(request)),
+    fetchDocument: (url, options, request) => fetchDocument(url, options, bind(request))
+  };
+}
+var retrievalClient = createRetrievalClient();
 
 // src/mcp/server.ts
 init_constants();
@@ -4721,120 +5546,34 @@ var FETCH_OUTPUT_TRUNCATED = "Output is truncated to the configured size.";
 var SEARCH_RANKED_FILTERED = "Results are ranked by relevance and source authority, deduplicated by URL, and capped at the configured maximum.";
 var SEARCH_EMPTY_IS_NORMAL = "An empty result list is normal, not an error.";
 var SEARCH_QUERY_OPERATORS = "Use site:/-site: operators in the query to include or exclude domains; the full query must stay within 128 characters.";
-// package.json
-var package_default = {
-  $schema: "https://json.schemastore.org/package.json",
-  name: "deepseek-web-retrieval",
-  version: "0.3.0",
-  description: "Token-efficient DeepSeek Search and Fetch for coding agents, starting with OpenCode v2.",
-  type: "module",
-  license: "MIT",
-  repository: {
-    type: "git",
-    url: "git+https://github.com/gwokhou/deepseek-web-retrieval.git"
-  },
-  homepage: "https://github.com/gwokhou/deepseek-web-retrieval#readme",
-  bugs: "https://github.com/gwokhou/deepseek-web-retrieval/issues",
-  keywords: [
-    "opencode",
-    "opencode-plugin",
-    "deepseek",
-    "websearch",
-    "webfetch",
-    "coding-agent",
-    "mcp"
-  ],
-  exports: {
-    ".": "./index.ts",
-    "./core": "./src/core/index.ts",
-    "./mcp": "./src/mcp/server.ts"
-  },
-  bin: {
-    "deepseek-web-retrieval": "dist/cli.js"
-  },
-  files: [
-    "index.ts",
-    "src",
-    "dist",
-    "docs",
-    "README.md",
-    "LICENSE",
-    "CHANGELOG.md",
-    "examples"
-  ],
-  scripts: {
-    typecheck: "tsc --noEmit",
-    build: "bun build src/mcp/cli.ts --target=node --format=esm --outdir=dist --external @modelcontextprotocol/server --external @modelcontextprotocol/server/stdio --external zod --external zod/v4",
-    prepublishOnly: "bun run typecheck && bun run build",
-    test: "bun test",
-    "test:e2e": "bun run test/e2e/run.ts",
-    "docs:matrix": "bun run scripts/render-matrix.ts",
-    "test:coverage": "bun test --coverage",
-    check: "bun run typecheck && bun run docs:matrix --check && bun run build && bun test"
-  },
-  peerDependencies: {
-    "@opencode/plugin": "^2.0.32"
-  },
-  devDependencies: {
-    "@modelcontextprotocol/client": "^2.3.1",
-    "@opencode/plugin": "2.0.32",
-    "@types/bun": "1.4.0",
-    "@types/node": "^26.6.5",
-    typescript: "5.9.3"
-  },
-  engines: {
-    bun: ">=1.3.0",
-    node: ">=20"
-  },
-  dependencies: {
-    "@modelcontextprotocol/server": "^2.3.1",
-    "jsonc-parser": "^3.3.1",
-    "smol-toml": "^1.9.1",
-    zod: "^4"
-  }
-};
+var SEARCH_TOOL_DESCRIPTION = "Search the web with DeepSeek's in-house search engine and return a short, filtered result " + "list (title, URL, summary). " + `${SEARCH_RANKED_FILTERED} ` + `${SEARCH_EMPTY_IS_NORMAL} ` + `${SEARCH_QUERY_OPERATORS} ` + "To read a full page, pass a result URL to the deepseek_fetch tool.";
+var FETCH_TOOL_DESCRIPTION = "Fetch one web page as clean Markdown through DeepSeek's Fetch API. " + `${FETCH_SERVICE_LIMITS} ` + `${FETCH_OUTPUT_TRUNCATED}`;
+var SEARCH_QUERY_PARAMETER = "Search query, 128 characters or fewer including operators (site:, -site:, quoted phrases, lang:).";
+var FETCH_URL_PARAMETER = "Absolute http:// or https:// URL to fetch. Credentials are rejected.";
 
 // src/mcp/server.ts
 var MCP_SERVER_NAME = "deepseek-web-retrieval";
 var SEARCH_INPUT = z.object({
-  query: z.string().min(1).describe("Search query, 128 characters or fewer including operators (site:, -site:, quoted phrases, lang:).")
-});
-var SEARCH_OUTPUT = z.object({
-  results: z.array(z.object({
-    url: z.string(),
-    title: z.string().optional(),
-    content: z.string().optional(),
-    published: z.number().optional()
-  }))
+  query: z.string().min(1).describe(SEARCH_QUERY_PARAMETER)
 });
 var FETCH_INPUT = z.object({
-  url: z.string().min(1).describe("Absolute http:// or https:// URL to fetch. Credentials are rejected.")
-});
-var FETCH_OUTPUT = z.object({
-  url: z.string(),
-  title: z.string(),
-  content: z.string(),
-  truncated: z.boolean()
+  url: z.string().min(1).describe(FETCH_URL_PARAMETER)
 });
-var SEARCH_DESCRIPTION = "Search the web with DeepSeek's in-house search engine and return a short, filtered result " + "list (title, URL, summary). " + `${SEARCH_RANKED_FILTERED} ` + `${SEARCH_EMPTY_IS_NORMAL} ` + `${SEARCH_QUERY_OPERATORS} ` + "To read a full page, pass a result URL to the deepseek_fetch tool.";
-var FETCH_DESCRIPTION = "Fetch one web page as clean Markdown through DeepSeek's Fetch API. " + `${FETCH_SERVICE_LIMITS} ` + `${FETCH_OUTPUT_TRUNCATED}`;
-function createDeepSeekServer(config, env = process.env) {
+function createDeepSeekServer(config, env = process.env, client = retrievalClient) {
   const server = new McpServer({ name: MCP_SERVER_NAME, version: package_default.version });
   if (config.search.enabled) {
     server.registerTool("deepseek_web_search", {
       title: "DeepSeek Web Search",
-      description: SEARCH_DESCRIPTION,
+      description: SEARCH_TOOL_DESCRIPTION,
       inputSchema: SEARCH_INPUT,
-      outputSchema: SEARCH_OUTPUT,
       annotations: { readOnlyHint: true }
     }, async ({ query }, ctx) => {
       try {
         const request = requestContext(config, env, ctx.mcpReq.signal);
-        const results = await searchWeb(query, config.search, request);
-        return {
-          content: [{ type: "text", text: formatSearchResults(results) }],
-          structuredContent: { results: results.map(toStructuredResult) }
-        };
+        const results = await client.searchWeb(query, config.search, request);
+        return callResult(server, ctx, formatSearchResults(results), {
+          results: results.map(toStructuredResult)
+        });
       } catch (error) {
         return toErrorResult(error);
       }
@@ -4843,23 +5582,19 @@ function createDeepSeekServer(config, env = process.env) {
   if (config.fetch.enabled) {
     server.registerTool("deepseek_fetch", {
       title: "DeepSeek Fetch",
-      description: FETCH_DESCRIPTION,
+      description: FETCH_TOOL_DESCRIPTION,
       inputSchema: FETCH_INPUT,
-      outputSchema: FETCH_OUTPUT,
       annotations: { readOnlyHint: true }
     }, async ({ url }, ctx) => {
       try {
         const request = requestContext(config, env, ctx.mcpReq.signal);
-        const page = await fetchDocument(url, config.fetch, request);
-        return {
-          content: [{ type: "text", text: page.content }],
-          structuredContent: {
-            url: page.url,
-            title: page.title,
-            content: page.content,
-            truncated: page.truncated
-          }
-        };
+        const page = await client.fetchDocument(url, config.fetch, request);
+        return callResult(server, ctx, page.content, {
+          url: page.url,
+          title: page.title,
+          content: page.content,
+          truncated: page.truncated
+        });
       } catch (error) {
         return toErrorResult(error);
       }
@@ -4870,13 +5605,10 @@ function createDeepSeekServer(config, env = process.env) {
 function requestContext(config, env, signal) {
   return { signal, auth: { apiKey: requireApiKey(env) }, retry: config.retry };
 }
-function toStructuredResult(result) {
-  return {
-    url: result.url,
-    ...result.title ? { title: result.title } : {},
-    ...result.content ? { content: result.content } : {},
-    ...result.published !== undefined ? { published: result.published } : {}
-  };
+function callResult(server, ctx, text, structured) {
+  if (omitStructuredContent(server, ctx))
+    return { content: [{ type: "text", text }] };
+  return { content: [{ type: "text", text }], structuredContent: structured };
 }
 function servePrecheck(config) {
   if (config.search.enabled || config.fetch.enabled)
@@ -4905,7 +5637,16 @@ if (precheck) {
   console.error(precheck);
   process.exit(1);
 }
-var handle = serveStdio(() => createDeepSeekServer(config, env));
+var handle = serveStdio(() => {
+  const server = createDeepSeekServer(config, env);
+  server.server.oninitialized = () => {
+    const info = server.server.getClientVersion();
+    if (info === undefined)
+      return;
+    console.error(`mcp client: ${info.name} ${info.version ?? "unknown"} — ` + (isJsonReplacingClient(info.name) ? "text-only results (this client replaces content with serialized structuredContent)" : "text + structuredContent results"));
+  };
+  return server;
+});
 var tools = [
   config.search.enabled ? `search (max ${config.search.maxResults} results)` : null,
   config.fetch.enabled ? `fetch (max ${config.fetch.maxChars} chars)` : null