deepseek-web-retrieval 0.4.0 → 0.5.1

package/src/installer/hosts/opencode.ts

@@ -1,33 +1,37 @@
-import { codecFor } from "../formats"
-import { isPlainObject } from "../formats/value"
-import { FORCED_COST_NOTE } from "../detect"
-import { configHome, join } from "../paths"
-import { buildRulesBlock } from "../formats/rules"
-import { rulesLines } from "../rulesContent"
-import { planHeader } from "./shared"
-import type { ConfigOp, FileEdit, HostPaths, InstallRecord, InstallerInput, InstallPlan } from "../types"
+import { FORCED_COST_NOTE, looksLikeOwnPackage } from "../detect";
+import { codecFor } from "../formats";
+import { buildRulesBlock } from "../formats/rules";
+import { isPlainObject } from "../formats/value";
+import { configHome, join } from "../paths";
+import { rulesLines } from "../rulesContent";
+import { appendedByPrevious } from "../state";
+import type { ConfigOp, FileEdit, HostPaths, InstallerInput, InstallPlan, InstallRecord } from "../types";
+import { planHeader } from "./shared";
 
 /** OpenCode's tools are named differently from the raw MCP ids. */
-const OPENCODE_TOOL_IDS = { search: "websearch (provider deepseek)", fetch: "deepseek_fetch" } as const
+const OPENCODE_TOOL_IDS = { search: "websearch (provider deepseek)", fetch: "deepseek_fetch" } as const;
 
 /** OpenCode config and rules files per scope; the host module owns this mapping. */
 function opencodePaths(input: InstallerInput): HostPaths {
   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") }
+    ? {
+        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") };
 }
 
 export function planOpenCode(input: InstallerInput, previous: InstallRecord | undefined): InstallPlan {
-  const paths = opencodePaths(input)
-  const loaded = codecFor("json", input.host).load(paths.config)
-  const tiers = { search: input.search, fetch: input.fetch }
-  const header = planHeader(input, paths, loaded, "JSONC")
+  const paths = opencodePaths(input);
+  const loaded = codecFor("json", input.host).load(paths.config);
+  const tiers = { search: input.search, fetch: input.fetch };
+  const header = planHeader(input, paths, loaded, "JSONC");
   if (header.abort) {
-    return { host: "opencode", scope: input.scope, tiers, edits: [], notes: header.notes, errors: header.errors }
+    return { host: "opencode", scope: input.scope, tiers, edits: [], notes: header.notes, errors: header.errors };
   }
-  const notes = [...header.notes]
-  const errors = [...header.errors]
-  const edits: FileEdit[] = []
+  const notes = [...header.notes];
+  const errors = [...header.errors];
+  const edits: FileEdit[] = [];
 
   if (input.search === "preferred") {
     errors.push({
@@ -35,32 +39,47 @@ export function planOpenCode(input: InstallerInput, previous: InstallRecord | un
         "OpenCode search has no preferred tier: the websearch provider is host-level config, so the model never " +
         "chooses between engines. Use --search optional (provider registered, built-in stays default), " +
         "--search forced (replace the engine), or --search off.",
-    })
+    });
   }
 
-  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 plugins = Array.isArray(loaded.value.plugins) ? loaded.value.plugins : [];
+  // Precisely ours: plugin packages a tracked init appended, plus this init's ref.
+  // Without a record nothing is excused — an untracked same-name plugin (a fork
+  // registers the same tool ids and would collide) must be removed first.
+  const trackedPackages = new Set(
+    appendedByPrevious(previous, ["plugins"])
+      .filter((entry): entry is { package: string } => isPlainObject(entry) && typeof entry.package === "string")
+      .map((entry) => entry.package),
+  );
+  const pluginPackages = plugins.filter(
+    (entry): entry is { package: string } => isPlainObject(entry) && typeof entry.package === "string",
+  );
+  const excused = previous === undefined ? new Set<string>() : new Set<string>([...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 }
+    return { host: "opencode", scope: input.scope, tiers, edits, notes, errors };
   }
 
-  const options: Record<string, unknown> = {}
-  if (input.search === "forced") options.setDefaultWebsearch = true
-  if (input.search === "off") options.searchEnabled = false
-  if (input.fetch === "forced") options.fetchOverrideWebfetch = true
-  if (input.fetch === "off") options.fetchEnabled = false
+  const options: Record<string, unknown> = {};
+  if (input.search === "forced") options.setDefaultWebsearch = true;
+  if (input.search === "off") options.searchEnabled = false;
+  if (input.fetch === "forced") options.fetchOverrideWebfetch = true;
+  if (input.fetch === "off") options.fetchEnabled = false;
 
   const ops: ConfigOp[] = [
     {
@@ -69,40 +88,40 @@ export function planOpenCode(input: InstallerInput, previous: InstallRecord | un
       entries: [{ package: input.packageRef, options }],
       existingCount: plugins.length,
     },
-  ]
+  ];
 
-  const permissions: Record<string, unknown>[] = []
-  if (input.search !== "off") permissions.push({ action: "websearch", resource: "*", effect: "allow" })
-  if (input.fetch !== "off") permissions.push({ action: "deepseek_fetch", resource: "*", effect: "allow" })
-  if (input.fetch === "forced") permissions.push({ action: "webfetch", resource: "*", effect: "allow" })
-  const existingPermissions = Array.isArray(loaded.value.permissions) ? loaded.value.permissions.length : 0
+  const permissions: Record<string, unknown>[] = [];
+  if (input.search !== "off") permissions.push({ action: "websearch", resource: "*", effect: "allow" });
+  if (input.fetch !== "off") permissions.push({ action: "deepseek_fetch", resource: "*", effect: "allow" });
+  if (input.fetch === "forced") permissions.push({ action: "webfetch", resource: "*", effect: "allow" });
+  const existingPermissions = Array.isArray(loaded.value.permissions) ? loaded.value.permissions.length : 0;
   if (permissions.length > 0) {
-    ops.push({ op: "append-array", path: ["permissions"], entries: permissions, existingCount: existingPermissions })
+    ops.push({ op: "append-array", path: ["permissions"], entries: permissions, existingCount: existingPermissions });
   }
 
   if (input.search === "forced") {
-    const currentProvider = isPlainObject(loaded.value.websearch) ? loaded.value.websearch.provider : undefined
-    ops.push({ op: "set", path: ["websearch", "provider"], value: "deepseek", previous: currentProvider })
+    const currentProvider = isPlainObject(loaded.value.websearch) ? loaded.value.websearch.provider : undefined;
+    ops.push({ op: "set", path: ["websearch", "provider"], value: "deepseek", previous: currentProvider });
     notes.push(
       currentProvider === undefined
         ? "websearch.provider is being set to deepseek (no previous value existed)."
         : `websearch.provider is being set to deepseek; the previous value "${String(currentProvider)}" is snapshotted for uninstall.`,
-    )
+    );
   }
 
-  edits.push({ file: paths.config, format: "json", ops })
+  edits.push({ file: paths.config, format: "json", ops });
 
   notes.push(
     "The plugin entry uses the object form so options are honored; auto-discovered plugins cannot receive options.",
-  )
+  );
   if (input.search === "optional") {
     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") {
@@ -110,9 +129,9 @@ export function planOpenCode(input: InstallerInput, previous: InstallRecord | un
       file: paths.rules,
       format: "rules",
       block: buildRulesBlock(input.host, rulesLines(OPENCODE_TOOL_IDS, input.search, input.fetch)),
-    })
-    notes.push(`Rules block upserted in ${paths.rules}; OpenCode loads AGENTS.md only (no CLAUDE.md fallback in v2).`)
+    });
+    notes.push(`Rules block upserted in ${paths.rules}; OpenCode loads AGENTS.md only (no CLAUDE.md fallback in v2).`);
   }
 
-  return { host: "opencode", scope: input.scope, tiers, edits, notes, errors }
+  return { host: "opencode", scope: input.scope, tiers, edits, notes, errors };
 }

package/src/installer/hosts/pi.ts

@@ -1,115 +1,309 @@
-import { codecFor } from "../formats"
-import { isPlainObject } from "../formats/value"
+import { API_KEY_ENV, ENABLE_FETCH_ENV, ENABLE_SEARCH_ENV } from "../../core/constants";
+import { SETTINGS_NAMESPACE } from "../../pi/settings";
 import {
   FORCED_COST_NOTE,
+  looksLikeOwnPackage,
+  looksWebCapable,
   othersStayRegisteredNote,
   replacingExistingEntryNote,
   splitCompetitors,
-} from "../detect"
-import { join } from "../paths"
-import { API_KEY_ENV, ENABLE_FETCH_ENV, ENABLE_SEARCH_ENV } from "../../core/constants"
-import { buildRulesBlock } from "../formats/rules"
-import { MCP_TOOL_IDS, rulesLines } from "../rulesContent"
-import { planHeader } from "./shared"
-import type { ConfigOp, FileEdit, HostPaths, InstallRecord, InstallerInput, InstallPlan } from "../types"
-
-/** Pi config and rules files per scope; the host module owns this mapping. */
+} from "../detect";
+import { codecFor } from "../formats";
+import { buildRulesBlock } from "../formats/rules";
+import { isPlainObject } from "../formats/value";
+import { join } from "../paths";
+import { MCP_TOOL_IDS, RAW_MCP_TOOL_IDS, rulesLines } from "../rulesContent";
+import { appendedByPrevious } from "../state";
+import type { ConfigOp, FileEdit, HostPaths, InstallerInput, InstallPlan, InstallRecord, PlanError } from "../types";
+import { planHeader } from "./shared";
+
+/** Pi config and rules files per scope and path; the host module owns this mapping. */
 function piPaths(input: InstallerInput): HostPaths {
-  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" ? join(input.home, ".pi/agent/mcp.json") : join(input.cwd, ".pi/mcp.json");
+  const settings =
+    input.scope === "global" ? join(input.home, ".pi/agent/settings.json") : join(input.cwd, ".pi/settings.json");
+  const rules = input.scope === "global" ? join(input.home, ".pi/agent/AGENTS.md") : join(input.cwd, "AGENTS.md");
+  return { config: input.path === "mcp" ? mcp : settings, rules };
+}
+
+/**
+ * The packages source this init writes: a ref that already carries Pi's `npm:`
+ * source prefix goes through as-is (wrapping it again would produce the broken
+ * `npm:npm:…` form); anything else — bare names, name@spec, npm specs like
+ * `file:` or `github:` — becomes an npm source.
+ */
+function piSourceRef(packageRef: string): string {
+  return packageRef.startsWith("npm:") ? packageRef : `npm:${packageRef}`;
+}
+
+export function planPi(input: InstallerInput, previous: InstallRecord | undefined): InstallPlan {
+  return input.path === "mcp" ? planPiMcp(input) : planPiExtension(input, previous);
 }
 
-export function planPi(input: InstallerInput, _previous: InstallRecord | undefined): InstallPlan {
-  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")
+/**
+ * The native-extension path (Pi's default): registers the package in
+ * settings.json's `packages` array; Pi resolves the source at session start
+ * and loads `src/pi/extension.ts` through the package's `pi` manifest.
+ */
+function planPiExtension(input: InstallerInput, previous: InstallRecord | undefined): InstallPlan {
+  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 }
+    return { host: "pi", scope: input.scope, tiers, edits: [], notes: header.notes, errors: header.errors };
+  }
+  const notes = [...header.notes];
+  const errors = [...header.errors];
+  const edits: FileEdit[] = [];
+
+  const packages = Array.isArray(loaded.value.packages) ? loaded.value.packages : [];
+  const source = piSourceRef(input.packageRef);
+  // Precisely ours: what a tracked init appended, plus what this init would write.
+  // Only a tracked init can excuse a same-name source — without a record, even an
+  // exact match is an untracked install this installer must not adopt silently.
+  const trackedSources = appendedByPrevious(previous, ["packages"]).filter(
+    (entry): entry is string => typeof entry === "string",
+  );
+  const excused = previous === undefined ? new Set<string>() : new Set<string>([...trackedSources, source]);
+  const sources = packages.filter((entry): entry is string => 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) {
+    // Pi has no per-package kill switch in settings.json, so a web-capable
+    // package or extension source cannot be excluded from the plan — refuse the
+    // tier instead of promising routing that is not actually forced.
+    const ownSources = new Set<string>([...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: ConfigOp[] = [
+    { 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 };
   }
-  const notes = [...header.notes]
-  const errors = [...header.errors]
-  const edits: FileEdit[] = []
 
-  const env: Record<string, string> = { [API_KEY_ENV]: `\${${API_KEY_ENV}}` }
-  if (input.search === "off") env[ENABLE_SEARCH_ENV] = "false"
-  if (input.fetch === "off") env[ENABLE_FETCH_ENV] = "false"
+  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 };
+}
+
+/**
+ * Disables web-capable MCP competitors for the forced tier: one `enabled:
+ * false` op per server (Pi entries carry an `enabled` key), each snapshotting
+ * its prior value for uninstall. Shared by both Pi paths — the MCP path folds
+ * the ops into its own mcp.json edit, the extension path opens a separate one.
+ */
+function planCompetitorDisables(
+  servers: Record<string, unknown>,
+  competitors: readonly string[],
+  notes: string[],
+  errors: PlanError[],
+): readonly ConfigOp[] {
+  const ops: ConfigOp[] = [];
+  const excluded: string[] = [];
+  const unexcludable: string[] = [];
+  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;
+    // Keep the op even when already disabled: a re-init must retain the claim
+    // and original snapshot, otherwise orphan reverts would re-enable it.
+    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;
+}
+
+/** Disables web-capable MCP servers for the forced tier; the extension path still shares the field with them. */
+function planMcpCompetitorDisables(input: InstallerInput, notes: string[], errors: PlanError[]): FileEdit[] {
+  const mcpFile = input.scope === "global" ? join(input.home, ".pi/agent/mcp.json") : join(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: FileEdit[] = [];
+  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;
+}
+
+/** The MCP-server path (`--path mcp`): registers the stdio server in mcp.json. */
+function planPiMcp(input: InstallerInput): InstallPlan {
+  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: FileEdit[] = [];
+
+  const env: Record<string, string> = { [API_KEY_ENV]: `\${${API_KEY_ENV}}` };
+  if (input.search === "off") env[ENABLE_SEARCH_ENV] = "false";
+  if (input.fetch === "off") env[ENABLE_FETCH_ENV] = "false";
   const entry = {
     command: "npx",
     args: ["-y", input.packageRef],
     env,
     exposure: "direct",
     enabled: true,
-  }
+  };
 
-  const servers = loaded.value.mcpServers
-  const existingEntry = isPlainObject(servers) ? servers.deepseek : undefined
-  const ops: ConfigOp[] = [
-    { op: "set", path: ["mcpServers", "deepseek"], value: entry, previous: existingEntry },
-  ]
-  edits.push({ file: paths.config, format: "json", ops })
+  const servers = loaded.value.mcpServers;
+  const existingEntry = isPlainObject(servers) ? servers.deepseek : undefined;
+  const ops: ConfigOp[] = [{ op: "set", path: ["mcpServers", "deepseek"], value: entry, previous: existingEntry }];
+  edits.push({ file: paths.config, format: "json", ops });
 
   if (isPlainObject(servers)) {
-    if (servers.deepseek !== undefined) notes.push(replacingExistingEntryNote("mcpServers.deepseek"))
-    const { competitors, bystanders } = splitCompetitors(servers)
-    const forced = input.search === "forced" || input.fetch === "forced"
+    if (servers.deepseek !== undefined) notes.push(replacingExistingEntryNote("mcpServers.deepseek"));
+    const { competitors, bystanders } = splitCompetitors(servers);
+    const forced = input.search === "forced" || input.fetch === "forced";
     if (forced) {
-      // Forced demands exclusivity: disable the web-capable competitors (Pi entries
-      // carry an `enabled` key), snapshotting each prior value for uninstall.
-      const excluded: string[] = []
-      const unexcludable: string[] = []
-      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 // already excluded
-        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) notes.push(othersStayRegisteredNote(stayRegistered))
+    const stayRegistered = forced ? bystanders : [...competitors, ...bystanders];
+    if (stayRegistered.length > 0) notes.push(othersStayRegisteredNote(stayRegistered));
   }
-  notes.push('"exposure": "direct" is required: Pi 1.3.0 defaults MCP tools to codemode, which hides them from the model.')
+  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,
       format: "rules",
       block: buildRulesBlock(input.host, rulesLines(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.`)
+    });
+    notes.push(
+      `Rules block upserted in ${paths.rules}; Pi loads AGENTS.md context files from the working directory and its parents.`,
+    );
   }
 
   if (input.search === "forced" || input.fetch === "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 }
+  return { host: "pi", scope: input.scope, tiers, edits, notes, errors };
+}
+
+/** Pulls the string sources out of a settings packages/extensions array. */
+function collectSources(value: unknown): readonly string[] {
+  return Array.isArray(value) ? value.filter((entry): entry is string => typeof entry === "string") : [];
 }

package/src/installer/hosts/shared.ts

@@ -1,13 +1,13 @@
-import { BOTH_CAPABILITIES_OFF, competitorSteeringNote, findCompetitorSteering } from "../detect"
-import type { LoadedConfig } from "../formats"
-import type { HostPaths, InstallerInput, PlanError } from "../types"
+import { BOTH_CAPABILITIES_OFF, competitorSteeringNote, findCompetitorSteering } from "../detect";
+import { codecFor, type LoadedConfig } from "../formats";
+import type { HostPaths, InstallerInput, PlanError } from "../types";
 
 /** What the shared plan header accumulated: notes and errors so far, and whether to stop. */
 export interface PlanHeader {
-  readonly notes: string[]
-  readonly errors: PlanError[]
+  readonly notes: string[];
+  readonly errors: PlanError[];
   /** True when the caller must return the (empty-edits) plan as-is. */
-  readonly abort: boolean
+  readonly abort: boolean;
 }
 
 /**
@@ -16,16 +16,21 @@ export interface PlanHeader {
  * competitor steering in the rules file. Host-specific checks follow in the module.
  */
 export function planHeader(input: InstallerInput, paths: HostPaths, loaded: LoadedConfig, dialect: string): PlanHeader {
-  const notes: string[] = []
-  const errors: PlanError[] = []
+  const notes: string[] = [];
+  const errors: PlanError[] = [];
   if (loaded.parseError) {
-    errors.push({ message: `${paths.config} exists but does not parse as ${dialect}: ${loaded.parseError}` })
-    return { notes, errors, abort: true }
+    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 })
+    errors.push({ message: BOTH_CAPABILITIES_OFF });
   }
-  const steering = findCompetitorSteering(input.host, paths.rules)
-  if (steering.length > 0) notes.push(competitorSteeringNote(paths.rules, steering))
-  return { notes, errors, abort: false }
+  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 };
 }