forge-delegate 1.0.10 → 1.1.0

package/README.md

@@ -30,9 +30,9 @@ so you're picking from actual available models rather than guessing.
 npx -y forge-delegate setup --model "opencode/deepseek-v4.1-flash-free" --targets "claude,codex,opencode"
 ```
 
-That's it — npx pulls the latest package and `setup` registers the MCP server with the agents
-you chose and sets your default model. Works on Windows (cmd/PowerShell), macOS, and Linux —
-no bash needed, and always runs the latest version.
+That's it — npx bootstraps the package, and `setup` registers the MCP server with the agents
+you chose, sets your default model, and installs a small launcher that keeps the server up to
+date. Works on Windows (cmd/PowerShell), macOS, and Linux — no bash needed.
 
 Run `setup` **without flags** and it walks you through the choices interactively (defaults in
 `[brackets]`, Enter accepts); pass any of the flags to skip that prompt. In an automated/non-terminal
@@ -47,6 +47,7 @@ run it just uses sensible defaults.
 `setup` will:
 1. Register the MCP server with each agent you chose (`--targets claude,codex,opencode`).
 2. Set your default model (`--model`) so calls can omit `model`.
+3. Install the auto-update launcher (published installs; skipped for a git checkout).
 
 Routing and cost-policy guidance is injected by the MCP server itself into the agent's context
 via MCP `instructions` — no memory-file (`CLAUDE.md`/`AGENTS.md`) editing needed.
@@ -177,25 +178,35 @@ forge-delegate --version  Print the installed version
 forge-delegate setup      Register with Claude Code / Codex / opencode
 forge-delegate serve      Start the MCP server (used internally)
 forge-delegate config     get | set | path
-forge-delegate status     Show version, update status, opencode logins, usage
+forge-delegate status     Show version, update mode, opencode logins, usage
 forge-delegate stats      Show detailed usage statistics
 ```
 
-`status` also asks npm for the newest release (cached for 24 hours in
-`~/.forge-delegate/update-check.json`) and reports it when a newer version exists. Disable the
-check with `FORGE_NO_UPDATE_CHECK=1`. `get_delegate_config` returns the same version and
-`updateAvailable` fields, so an agent can answer "is this up to date?" without a CLI call.
+`setup` on a published install writes `~/.forge-delegate/launcher.mjs` and registers that path
+instead of `npx`. The launcher keeps a private install under `~/.forge-delegate/pkg`, asks npm
+for the newest release at most every 6 hours, and installs newer **same-major** versions
+automatically. Installs use `npm install --ignore-scripts`, go through a staging directory, and
+fall back to the last good version if anything fails. A new version lands on the next agent
+start; the download itself happens in the background so startup is never delayed.
 
-Updating an npx install is not automatic: npx keeps using its cached copy. Clear it with
-`rm -rf ~/.npm/_npx` and restart your agent, or install globally with `npm i -g forge-delegate`.
+Disable automatic updates with `FORGE_AUTO_UPDATE=0`. A major release (`2.0.0`) is never
+installed automatically — re-run `npx -y forge-delegate setup` to take it deliberately.
+
+The launcher is also the CLI entry point: `node ~/.forge-delegate/launcher.mjs status` reports
+the running version and update mode, and `--version` prints the version.
+
+npx installs configured by hand are not covered by the launcher: npx keeps its cached copy
+forever, so clear it with `rm -rf ~/.npm/_npx` and restart. Running
+`npx -y forge-delegate@latest setup` migrates an npx install to the launcher; `@latest` gets its
+own npx cache slot, and if it still starts an old version, clear the cache first.
 
 ## Publishing (npm)
 
 The primary install is `npx -y forge-delegate setup`, so the package must be on npm. Checklist:
 
 1. `npm run prepublishOnly` — syntax-checks all entry files (runs automatically on publish).
-2. `npm pack --dry-run` — confirm the tarball contains only `cli.mjs`, `server.mjs`, `lib.mjs`,
-   `install.sh`, `docs/`, `README.md` (via the `files` field), not `node_modules`.
+2. `npm pack --dry-run` — confirm the tarball contains only `launcher.mjs`, `cli.mjs`, `server.mjs`,
+   `lib.mjs`, `install.sh`, `docs/`, `skills/`, `README.md` (via the `files` field), not `node_modules`.
 3. Bump `version` in `package.json` (and the root `version` in `package-lock.json`).
 4. `npm login && npm publish` — the `bin` field makes `npx forge-delegate …` work.
 

package/cli.mjs

@@ -1,13 +1,16 @@
 #!/usr/bin/env node
 import { createInterface } from "node:readline/promises";
-import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync, rmSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
-import { execSync } from "node:child_process";
-import { loadConfig, saveConfig, configPath, detectOpencode, loadOpencodeAuth, checkForUpdate, VERSION } from "./lib.mjs";
+import { execSync, execFileSync } from "node:child_process";
+import { loadConfig, saveConfig, configPath, detectOpencode, loadOpencodeAuth, compareVersions, VERSION } from "./lib.mjs";
 
 const here = dirname(fileURLToPath(import.meta.url));
+const herePosix = here.replace(/\\/g, "/");
+const ROOT = join(homedir(), ".forge-delegate");
+const LAUNCHER = join(ROOT, "launcher.mjs");
 
 function parseArgs(argv) {
   const args = {};
@@ -25,14 +28,60 @@ function parseArgs(argv) {
   return args;
 }
 
-function launchCommand() {
-  const isPublished = here.includes(join("node_modules", "forge-delegate")) || here.includes("/.npm/_npx/");
-  return isPublished ? "npx -y forge-delegate serve" : `node ${join(here, "cli.mjs")} serve`;
+function isPublishedInstall() {
+  return herePosix.includes("node_modules/forge-delegate") || herePosix.includes("/.npm/_npx/");
 }
 
-function launchArray() {
-  const isPublished = here.includes(join("node_modules", "forge-delegate")) || here.includes("/.npm/_npx/");
-  return isPublished ? ["npx", "-y", "forge-delegate", "serve"] : [process.execPath, join(here, "cli.mjs"), "serve"];
+// How this copy was installed matters to the user: only the launcher path can
+// update itself.
+function installKind() {
+  if (herePosix.includes("/.forge-delegate/pkg/")) return "launcher";
+  if (herePosix.includes("/.npm/_npx/") || herePosix.includes("node_modules/forge-delegate")) return "package";
+  return "checkout";
+}
+
+function readLauncherState() {
+  try {
+    return JSON.parse(readFileSync(join(ROOT, "launcher-state.json"), "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+// Copy the launcher out of the package to a path that never changes, then
+// pre-install this version so the first client launch is fast. A failure here
+// is not fatal: the launcher installs on demand.
+function ensureLauncher() {
+  const src = join(here, "launcher.mjs");
+  if (!existsSync(src)) return null;
+  try {
+    mkdirSync(ROOT, { recursive: true });
+    const want = readFileSync(src, "utf8");
+    let have = null;
+    try {
+      have = readFileSync(LAUNCHER, "utf8");
+    } catch {}
+    if (have !== want) writeFileSync(LAUNCHER, want);
+  } catch {
+    return null;
+  }
+  try {
+    execFileSync(process.execPath, [LAUNCHER, "--install-only", VERSION], {
+      stdio: "ignore",
+      timeout: 180_000,
+    });
+  } catch {}
+  return LAUNCHER;
+}
+
+function launchForThisInstall() {
+  if (!isPublishedInstall()) {
+    const cli = join(here, "cli.mjs");
+    return { command: `node "${cli}"`, array: ["node", cli, "serve"] };
+  }
+  const launcher = ensureLauncher();
+  if (launcher) return { command: `node "${launcher}"`, array: ["node", launcher] };
+  return { command: "npx -y forge-delegate serve", array: ["npx", "-y", "forge-delegate", "serve"] };
 }
 
 // The MCP server's `instructions` are injected once at session start and decay as the
@@ -143,8 +192,12 @@ async function setup() {
   projectDir = projectDir ?? process.cwd();
   targets = targets.split(",").map((s) => s.trim().toLowerCase());
 
-  const launch = launchCommand();
-  const launchArr = launchArray();
+  const { command: launch, array: launchArr } = launchForThisInstall();
+  if (launch.includes("launcher.mjs")) console.log(`  ✓ automatic updates (launcher: ${LAUNCHER})`);
+  // 1.0.x wrote this cache; the launcher keeps its own state elsewhere.
+  try {
+    rmSync(join(ROOT, "update-check.json"), { force: true });
+  } catch {}
 
   // 1. Set the default model first so it's saved even if registration hits an issue
   if (model && model !== current.defaultModel) {
@@ -210,14 +263,30 @@ function configCmd(argv) {
 }
 
 async function status() {
-  const update = await checkForUpdate();
   const oc = await detectOpencode();
+  const kind = installKind();
   let versionNote;
-  if (update.disabled) versionNote = "  (update check disabled)";
-  else if (update.updateAvailable) versionNote = `  \u2192 ${update.latest} available`;
-  else if (update.error && !update.latest) versionNote = "  (update check unavailable)";
-  else if (update.error) versionNote = `  (latest known: ${update.latest}; check failed)`;
-  else versionNote = "  (up to date)";
+  if (kind === "launcher") {
+    const state = readLauncherState();
+    versionNote = state?.autoUpdate === false ? "  (auto-update off)" : "  (auto-update on)";
+    if (state?.autoUpdate !== false) {
+      try {
+        const latest = JSON.parse(readFileSync(join(ROOT, "latest.json"), "utf8"));
+        if (latest?.version && compareVersions(latest.version, VERSION) > 0) {
+          const latestMajor = String(latest.version).split(".")[0];
+          const currentMajor = String(VERSION).split(".")[0];
+          versionNote +=
+            latestMajor === currentMajor
+              ? ` — ${latest.version} pending`
+              : ` — ${latest.version} requires a manual upgrade`;
+        }
+      } catch {}
+    }
+  } else if (kind === "package") {
+    versionNote = "  (npx install — manual updates)";
+  } else {
+    versionNote = "  (checkout)";
+  }
   console.log(`\nforge-delegate: ${VERSION}${versionNote}`);
   console.log(
     `opencode: ${oc.found ? (oc.version?.raw ?? "unknown version") : "not found on PATH"}` +
@@ -235,10 +304,9 @@ async function status() {
       console.log(`recorded delegations: ${lines} (see 'forge-delegate stats')`);
     }
   } catch {}
-  if (update.updateAvailable) {
-    console.log(`\nUpdate to ${update.latest}:`);
-    console.log("  npx install:  rm -rf ~/.npm/_npx   (then restart your agent)");
-    console.log("  global:       npm i -g forge-delegate");
+  if (kind === "package") {
+    console.log("\nThis npx install never refreshes itself.");
+    console.log("Switch to automatic updates: npx -y forge-delegate@latest setup");
   }
 }
 
@@ -291,9 +359,12 @@ Usage:
   forge-delegate config set --model <m> [--agent <a>] [--variant <v>]
                           [--timeout <s>] [--dir <path>] [--autoApprove true|false]
   forge-delegate config path                  Print config file path
-  forge-delegate status                       Show version, update status, opencode logins, usage
+  forge-delegate status                       Show version, update mode, opencode logins, usage
   forge-delegate stats                        Show detailed usage statistics
 
+Automatic updates (launcher installs) are on by default. Disable with:
+  FORGE_AUTO_UPDATE=0
+
 Models come from your opencode installation:
   opencode auth login <provider>   add a provider
   opencode models                  list available models

package/launcher.mjs

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+// forge-delegate launcher.
+//
+// Clients run this file instead of npx. It keeps a private install under
+// ~/.forge-delegate/pkg, refreshes it from npm when a newer same-major release
+// exists, then starts `node cli.mjs serve`.
+//
+// An update never blocks startup: the new version is fetched in the background
+// and used on the next launch. If the registry or npm is unavailable, the last
+// good version runs. A cold start with nothing installed falls back to npx.
+//
+// `--install-only <version>` exists for `setup`, which pre-installs the running
+// version so a client's first launch does not have to wait for npm.
+
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+const SELF = fileURLToPath(import.meta.url);
+const ROOT = join(homedir(), ".forge-delegate");
+const PKG = join(ROOT, "pkg");
+const STATE = join(ROOT, "launcher-state.json");
+const LATEST = join(ROOT, "latest.json");
+const SKILL = join(homedir(), ".claude", "skills", "delegate-work", "SKILL.md");
+const REGISTRY = process.env.FORGE_REGISTRY ?? "https://registry.npmjs.org";
+const TTL = 6 * 3600 * 1000;
+const AUTO =
+  process.env.FORGE_AUTO_UPDATE !== "0" &&
+  process.env.FORGE_AUTO_UPDATE !== "false" &&
+  process.env.FORGE_NO_AUTO_UPDATE !== "1";
+
+function parseVersion(v) {
+  const m = String(v ?? "").match(/^(\d+)\.(\d+)\.(\d+)/);
+  return m ? [+m[1], +m[2], +m[3]] : null;
+}
+
+function compareVersions(a, b) {
+  const pa = parseVersion(a);
+  const pb = parseVersion(b);
+  if (!pa || !pb) return 0;
+  for (let i = 0; i < 3; i++) if (pa[i] !== pb[i]) return pa[i] - pb[i];
+  return 0;
+}
+
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function cliPath(version) {
+  if (!version) return null;
+  const cli = join(PKG, version, "node_modules", "forge-delegate", "cli.mjs");
+  return existsSync(cli) ? cli : null;
+}
+
+// Newest first. A version directory only counts once its cli.mjs exists, so a
+// half-finished install can never be selected.
+function installedVersions() {
+  try {
+    return readdirSync(PKG)
+      .filter((name) => /^\d+\.\d+\.\d+$/.test(name) && cliPath(name))
+      .sort((a, b) => compareVersions(b, a));
+  } catch {
+    return [];
+  }
+}
+
+async function latestVersion() {
+  const cached = readJson(LATEST);
+  if (cached?.version && Number.isFinite(cached.checkedAt) && Date.now() - cached.checkedAt < TTL) {
+    return cached.version;
+  }
+  try {
+    const res = await fetch(`${REGISTRY}/forge-delegate/latest`, { signal: AbortSignal.timeout(2000) });
+    if (!res.ok) return null;
+    const { version } = await res.json();
+    if (!parseVersion(version)) return null;
+    mkdirSync(ROOT, { recursive: true });
+    writeFileSync(LATEST, JSON.stringify({ version, checkedAt: Date.now() }));
+    return version;
+  } catch {
+    return null;
+  }
+}
+
+// Install into a staging directory and rename it into place, so a failed or
+// interrupted download never becomes the version the launcher picks.
+function installVersion(version) {
+  if (cliPath(version)) return true;
+  mkdirSync(PKG, { recursive: true });
+  const stage = join(PKG, `.tmp-${process.pid}-${Date.now().toString(36)}`);
+  try {
+    const npm = process.platform === "win32" ? "npm.cmd" : "npm";
+    const res = spawnSync(
+      npm,
+      [
+        "install",
+        "--prefix",
+        stage,
+        "--ignore-scripts",
+        "--no-audit",
+        "--no-fund",
+        "--silent",
+        `forge-delegate@${version}`,
+      ],
+      { stdio: "ignore", timeout: 180_000 }
+    );
+    if (res.status !== 0 || !existsSync(join(stage, "node_modules", "forge-delegate", "cli.mjs"))) return false;
+    try {
+      renameSync(stage, join(PKG, version));
+    } catch {
+      // Another process won the race; its copy is complete because it also
+      // installed into a staging directory before renaming.
+    }
+    return Boolean(cliPath(version));
+  } finally {
+    try {
+      rmSync(stage, { recursive: true, force: true });
+    } catch {}
+  }
+}
+
+// Keep the selected version plus one fallback.
+function prune(keep) {
+  const versions = installedVersions();
+  const keepSet = new Set([keep, versions.find((v) => v !== keep)]);
+  for (const version of versions) {
+    if (keepSet.has(version)) continue;
+    try {
+      rmSync(join(PKG, version), { recursive: true, force: true });
+    } catch {}
+  }
+}
+
+function installOnly(version) {
+  if (!parseVersion(version)) return false;
+  const ok = installVersion(version);
+  if (ok) prune(version);
+  return ok;
+}
+
+// The skill is a file on disk that only `setup` rewrites. Refresh it from the
+// version being launched, but never create one the user did not ask for.
+function syncSkill(cli) {
+  try {
+    const src = join(dirname(cli), "skills", "delegate-work", "SKILL.md");
+    if (!existsSync(src) || !existsSync(SKILL)) return;
+    const want = readFileSync(src, "utf8");
+    if (readFileSync(SKILL, "utf8") !== want) writeFileSync(SKILL, want);
+  } catch {}
+}
+
+// `setup` copies this file once, but a later release may fix update logic.
+// Refresh it from the version being launched; the running copy is already in
+// memory, so replacing the file on disk is safe.
+function syncLauncher(cli) {
+  try {
+    const src = join(dirname(cli), "launcher.mjs");
+    if (!existsSync(src) || !existsSync(SELF)) return;
+    const want = readFileSync(src, "utf8");
+    if (readFileSync(SELF, "utf8") !== want) writeFileSync(SELF, want);
+  } catch {}
+}
+
+if (process.argv[2] === "--install-only") {
+  process.exit(installOnly(process.argv[3]) ? 0 : 1);
+}
+
+const current = installedVersions()[0] ?? null;
+let target = current;
+
+if (AUTO) {
+  const latest = await latestVersion();
+  if (latest) {
+    const latestMajor = parseVersion(latest)[0];
+    const currentMajor = current ? parseVersion(current)[0] : latestMajor;
+    if (latestMajor === currentMajor && compareVersions(latest, current ?? "0.0.0") > 0) {
+      if (cliPath(latest)) {
+        target = latest;
+      } else if (current) {
+        // Update in the background and run the current version now, so an
+        // npm install can never hold up the MCP handshake.
+        const child = spawn(process.execPath, [SELF, "--install-only", latest], {
+          detached: true,
+          stdio: "ignore",
+        });
+        child.unref();
+      } else if (installVersion(latest)) {
+        // Nothing usable installed yet — this one has to be synchronous.
+        target = latest;
+      }
+    } else if (current && latestMajor > currentMajor) {
+      process.stderr.write(
+        `forge-delegate: ${latest} is a major update and needs a manual upgrade; running ${current}\n`
+      );
+    }
+  }
+}
+
+const cli = cliPath(target);
+if (cli) {
+  syncLauncher(cli);
+  syncSkill(cli);
+  try {
+    mkdirSync(ROOT, { recursive: true });
+    writeFileSync(STATE, JSON.stringify({ version: target, autoUpdate: AUTO, updatedAt: Date.now() }));
+  } catch {}
+}
+
+const npx = process.platform === "win32" ? "npx.cmd" : "npx";
+// No args means "serve" (the MCP entry point). Any other arg is forwarded, so
+// `node ~/.forge-delegate/launcher.mjs status` works without a global binary.
+const args = process.argv.slice(2);
+const cliArgs = args.length ? args : ["serve"];
+const child = cli
+  ? spawn(process.execPath, [cli, ...cliArgs], { stdio: "inherit" })
+  : spawn(npx, ["-y", "forge-delegate", ...cliArgs], { stdio: "inherit" });
+
+for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+  process.on(signal, () => child.kill(signal));
+}
+
+child.on("exit", (code, signal) => {
+  if (signal) process.kill(process.pid, signal);
+  else process.exit(code ?? 0);
+});

package/lib.mjs

@@ -53,8 +53,6 @@ const AUTH_PATH = join(homedir(), ".local/share/opencode/auth.json");
 const OPENCODE_CONFIG_PATH = join(homedir(), ".config/opencode/opencode.json");
 const CATALOG_CACHE = join(CONFIG_DIR, "models-dev.json");
 const CATALOG_TTL = 24 * 3600 * 1000;
-const UPDATE_CACHE = join(CONFIG_DIR, "update-check.json");
-const UPDATE_TTL = 24 * 3600 * 1000;
 const OLLAMA_BASE = process.env.OLLAMA_URL ?? "http://localhost:11434";
 
 function parseVersion(v) {
@@ -70,62 +68,6 @@ export function compareVersions(a, b) {
   return 0;
 }
 
-function readUpdateCache() {
-  try {
-    const cached = JSON.parse(readFileSync(UPDATE_CACHE, "utf8"));
-    if (cached?.latest && Number.isFinite(cached.checkedAt)) return cached;
-  } catch {}
-  return null;
-}
-
-// An installed copy cannot see the registry on its own, and npx happily reuses a
-// cached install forever — which is how this server ran 1.0.7 while 1.0.9 was
-// published. Check once a day, cache the answer, and never let a network failure
-// break the caller. Opt out with FORGE_NO_UPDATE_CHECK=1 (or NO_UPDATE_NOTIFIER=1).
-export async function checkForUpdate({ force = false, timeoutMs = 3000 } = {}) {
-  const cached = readUpdateCache();
-  if (!force && cached && Date.now() - cached.checkedAt < UPDATE_TTL) {
-    return {
-      current: VERSION,
-      latest: cached.latest,
-      updateAvailable: compareVersions(cached.latest, VERSION) > 0,
-      checkedAt: cached.checkedAt,
-    };
-  }
-
-  if (process.env.FORGE_NO_UPDATE_CHECK || process.env.NO_UPDATE_NOTIFIER) {
-    return { current: VERSION, latest: null, updateAvailable: false, checkedAt: null, disabled: true };
-  }
-
-  try {
-    const res = await fetch("https://registry.npmjs.org/forge-delegate/latest", {
-      signal: AbortSignal.timeout(timeoutMs),
-    });
-    if (!res.ok) throw new Error(`registry returned ${res.status}`);
-    const { version } = await res.json();
-    if (!parseVersion(version)) throw new Error("registry returned no version");
-    const checkedAt = Date.now();
-    try {
-      mkdirSync(CONFIG_DIR, { recursive: true });
-      writeFileSync(UPDATE_CACHE, JSON.stringify({ latest: version, checkedAt }));
-    } catch {}
-    return {
-      current: VERSION,
-      latest: version,
-      updateAvailable: compareVersions(version, VERSION) > 0,
-      checkedAt,
-    };
-  } catch (e) {
-    return {
-      current: VERSION,
-      latest: cached?.latest ?? null,
-      updateAvailable: cached ? compareVersions(cached.latest, VERSION) > 0 : false,
-      checkedAt: cached?.checkedAt ?? null,
-      error: e.message,
-    };
-  }
-}
-
 function execFileText(cmd, args, opts = {}) {
   return new Promise((resolve, reject) => {
     execFile(cmd, args, { timeout: 15_000, maxBuffer: 4 * 1024 * 1024, ...opts }, (err, stdout) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forge-delegate",
-  "version": "1.0.10",
+  "version": "1.1.0",
   "description": "MCP server that relays coding work to other AI models (DeepSeek, Gemini, OpenAI, Ollama) so Claude Code saves tokens",
   "type": "module",
   "bin": {
@@ -9,9 +9,10 @@
   "scripts": {
     "setup": "node cli.mjs setup",
     "start": "node cli.mjs serve",
-    "prepublishOnly": "node --check cli.mjs && node --check server.mjs && node --check lib.mjs && node test-handshake.mjs"
+    "prepublishOnly": "node --check launcher.mjs && node --check cli.mjs && node --check server.mjs && node --check lib.mjs && node test-handshake.mjs"
   },
   "files": [
+    "launcher.mjs",
     "cli.mjs",
     "server.mjs",
     "lib.mjs",

package/server.mjs

@@ -21,13 +21,22 @@ import {
   saveConfig,
   configPath,
   resolveConfig,
-  checkForUpdate,
   VERSION,
 } from "./lib.mjs";
 
 const execFileAsync = promisify(execFile);
 const RUNS_DIR = join(homedir(), ".forge-delegate", "runs");
 const here = dirname(fileURLToPath(import.meta.url));
+const herePosix = here.replace(/\\/g, "/");
+
+// Only a launcher install can refresh itself; the report tells the user (and
+// the model) which kind they have.
+function installKind() {
+  if (herePosix.includes("/.forge-delegate/pkg/")) return "launcher (automatic updates)";
+  if (herePosix.includes("/.npm/_npx/") || herePosix.includes("node_modules/forge-delegate"))
+    return "npx/package (manual updates)";
+  return "checkout";
+}
 
 // The installed skill is a file on disk that only `setup` rewrites, so a published
 // skill change goes unnoticed. Compare the two and say so, rather than running
@@ -287,27 +296,19 @@ server.tool(
 
 server.tool(
   "get_delegate_config",
-  "Read the current forge-delegate configuration: defaultModel, defaultAgent, defaultVariant, autoApprove, timeoutMs, defaultDirectory, and named profiles — plus the installed version and whether a newer release is published. Call this to see what will be used when a model/directory is omitted, or when the user asks whether forge-delegate is up to date.",
+  "Read the current forge-delegate configuration: defaultModel, defaultAgent, defaultVariant, autoApprove, timeoutMs, defaultDirectory, and named profiles — plus the installed version and whether it updates automatically. Call this to see what will be used when a model/directory is omitted, or when the user asks which version is running.",
   {},
   async () => {
     const cfg = loadConfig();
-    const update = await checkForUpdate();
     const { profiles, ...rest } = cfg;
     const lines = Object.entries(rest).map(([k, v]) => `  ${k}: ${v ?? "(unset)"}`);
     const prof = Object.entries(profiles).map(([k, v]) => `  ${k}: ${JSON.stringify(v)}`).join("\n") || "  (none)";
     const skill = SKILL_STATUS ? `\nskill (delegate-work): ${SKILL_STATUS.detail}${SKILL_STATUS.state === "ok" ? "" : " — run: npx -y forge-delegate setup"}` : "";
-    const updateLine = update.disabled
-      ? "updateAvailable: unknown (check disabled)"
-      : update.error && !update.latest
-        ? `updateAvailable: unknown (${update.error})`
-        : update.updateAvailable
-          ? `updateAvailable: true (latest ${update.latest}, running ${VERSION})`
-          : "updateAvailable: false";
     return {
       content: [
         {
           type: "text",
-          text: `version: ${VERSION}\n${updateLine}\nconfig: ${configPath()}\n${lines.join("\n")}\nprofiles:\n${prof}${skill}`,
+          text: `version: ${VERSION}\ninstall: ${installKind()}\nconfig: ${configPath()}\n${lines.join("\n")}\nprofiles:\n${prof}${skill}`,
         },
       ],
     };
@@ -339,7 +340,3 @@ server.tool(
 
 const transport = new StdioServerTransport();
 await server.connect(transport);
-
-// Warm the update cache after the handshake — a registry call must never delay
-// the MCP connection. get_delegate_config reads whatever this leaves behind.
-checkForUpdate().catch(() => {});