pi-updater 0.3.2 → 0.3.3

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## Unreleased
+
+## 0.3.3 - 2026-05-21
+
+- Honor the update service `packageName` and install the explicit advertised npm package/version.
+- Avoid native `pi update --self` so pi-updater can update through stale native self-update behavior.
+- Keep loading under the legacy `@mariozechner/pi-coding-agent` runtime so package-name migrations can run.
+- Migrate the global pi binary when the update service advertises a new package name by force-installing the advertised package after an engine-strict dry run.
+- Treat package-name-only migrations as updates only when the advertised version is unchanged or newer, while staying on the current package if `packageName` is absent.
+- Respect npm engine requirements during pi installs so updates fail safely when Node.js is too old.
+- Switch extension imports and optional peer dependency to `@earendil-works/pi-coding-agent` so installing pi-updater no longer pulls the old `@mariozechner` pi package.
+
 ## 0.3.2 - 2026-05-02
 
 - Use pi's native `pi update --self` installer on pi 0.70.3+ and keep npm install as the fallback for older pi versions.

package/README.md

@@ -5,22 +5,20 @@ A lightweight, Codex-style auto-updater for pi with fast, cache-first startup ch
 - npm: https://www.npmjs.com/package/pi-updater
 - repo: https://github.com/tonze/pi-updater
 
-> **Note:** On pi 0.70.3+, pi-updater delegates installation to pi's native `pi update --self` command. Older pi versions fall back to npm-based installation.
+> **Note:** pi-updater installs the exact package/version returned by pi's update service with npm. This handles pi package-name migrations and avoids stale native self-update behavior while still keeping the interactive prompt/restart flow.
 
 <img width="800" height="482" alt="Screenshot 2026-02-28 at 09 01 37" src="https://github.com/user-attachments/assets/89df2dad-8d91-464b-b3cb-dfd15bce1c06" />
 
 ## What it does
 
-**On pi 0.70.3+:** pi-updater is native-aware. It keeps the interactive startup update prompt, checks pi's update service, installs with `pi update --self`, then offers to restart the current session. Pi's built-in updater only shows a notice with a command to run; pi-updater provides the clickable update/restart flow.
-
-**On older pi versions:** if a newer version is available, pi-updater shows a startup prompt:
+If a newer version is available, pi-updater shows a startup prompt:
 - **Update now** — install with npm, then auto-restart pi on the current session
 - **Skip** — dismiss until next session
 - **Skip this version** — don't ask again until a newer version appears
 
 After a successful update, pi-updater asks whether to restart immediately. If confirmed, pi relaunches seamlessly on the current session. In non-interactive modes or if auto-restart fails, it falls back to a manual restart message. Ephemeral `--no-session` runs stay ephemeral on restart.
 
-**`/update`:** manually check for updates (always fetches fresh from pi's update service, unless `PI_OFFLINE` is set). On pi 0.70.3+ it installs with `pi update --self`; on older pi it falls back to npm.
+**`/update`:** manually check for updates (always fetches fresh from pi's update service, unless `PI_OFFLINE` is set). It installs the exact npm package/version advertised by pi's update service and respects npm engine requirements, so upgrade Node.js first if the new pi release requires it.
 
 ## How version checks work
 

package/index.ts

@@ -1,39 +1,118 @@
 import type {
   ExtensionAPI,
   ExtensionContext,
-} from "@mariozechner/pi-coding-agent";
-import { VERSION, BorderedLoader, getAgentDir } from "@mariozechner/pi-coding-agent";
+} from "@earendil-works/pi-coding-agent";
 import { spawnSync } from "node:child_process";
-import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { readFileSync, realpathSync, writeFileSync, mkdirSync } from "node:fs";
 import { join, dirname } from "node:path";
 
-const PACKAGE_NAME = "@mariozechner/pi-coding-agent";
+const PACKAGE_NAME = "@earendil-works/pi-coding-agent";
+const LEGACY_PACKAGE_NAME = "@mariozechner/pi-coding-agent";
 const LATEST_VERSION_URL = "https://pi.dev/api/latest-version";
-const NATIVE_SELF_UPDATE_MIN_VERSION = "0.70.3";
-const CACHE_FILE = join(getAgentDir(), "update-cache.json");
+const NATIVE_VERSION_NOTICE_MIN_VERSION = "0.70.3";
 
 const ENV_SKIP_VERSION_CHECK = "PI_SKIP_VERSION_CHECK";
 const ENV_OFFLINE = "PI_OFFLINE";
 const ENV_INTERNAL_SKIP = "PI_UPDATER_SUPPRESSED_NATIVE_VERSION_CHECK";
 
+interface LatestRelease {
+  version: string;
+  packageName?: string;
+}
+
 interface VersionCache {
   latestVersion: string;
+  latestPackageName?: string;
   dismissedVersion?: string;
+  dismissedPackageName?: string;
   checkedAt?: string;
 }
 
-function readCache(): VersionCache | undefined {
+type BorderedLoaderConstructor = new (...args: any[]) => any;
+
+interface PiRuntime {
+  VERSION: string;
+  BorderedLoader: BorderedLoaderConstructor;
+  getAgentDir: () => string;
+  packageName: string;
+}
+
+let VERSION = "0.0.0";
+let BorderedLoader: BorderedLoaderConstructor;
+let getAgentDir: () => string;
+
+function packageNameFromNodeModulesPath(path: string): string | undefined {
+  const normalized = path.replace(/\\/g, "/");
+  const marker = "/node_modules/";
+  const index = normalized.lastIndexOf(marker);
+  if (index === -1) return undefined;
+
+  const parts = normalized.slice(index + marker.length).split("/");
+  if (!parts[0]) return undefined;
+  if (parts[0].startsWith("@")) {
+    if (!parts[1]) return undefined;
+    return `${parts[0]}/${parts[1]}`;
+  }
+  return parts[0];
+}
+
+async function findOwningPiPackageName(pi: ExtensionAPI): Promise<string | undefined> {
+  try {
+    const cmd = process.platform === "win32" ? "where" : "which";
+    const result = await pi.exec(cmd, ["pi"]);
+    const binary = result.code === 0 ? result.stdout?.trim().split(/\r?\n/)[0] : undefined;
+    if (!binary) return undefined;
+
+    try {
+      return packageNameFromNodeModulesPath(realpathSync(binary));
+    } catch {
+      return packageNameFromNodeModulesPath(binary);
+    }
+  } catch {
+    return undefined;
+  }
+}
+
+async function loadPiRuntime(preferredPackageName?: string): Promise<PiRuntime> {
+  const packageNames = [
+    preferredPackageName,
+    PACKAGE_NAME,
+    LEGACY_PACKAGE_NAME,
+  ].filter((packageName): packageName is string => !!packageName);
+
+  for (const packageName of new Set(packageNames)) {
+    try {
+      const runtime = await import(packageName);
+      if (
+        typeof runtime.VERSION === "string" &&
+        typeof runtime.BorderedLoader === "function" &&
+        typeof runtime.getAgentDir === "function"
+      ) {
+        return {
+          VERSION: runtime.VERSION,
+          BorderedLoader: runtime.BorderedLoader,
+          getAgentDir: runtime.getAgentDir,
+          packageName,
+        };
+      }
+    } catch {}
+  }
+
+  throw new Error(`Could not load ${PACKAGE_NAME} or ${LEGACY_PACKAGE_NAME}`);
+}
+
+function readCache(cacheFile: string): VersionCache | undefined {
   try {
-    return JSON.parse(readFileSync(CACHE_FILE, "utf-8"));
+    return JSON.parse(readFileSync(cacheFile, "utf-8"));
   } catch {
     return undefined;
   }
 }
 
-function writeCache(cache: VersionCache) {
+function writeCache(cacheFile: string, cache: VersionCache) {
   try {
-    mkdirSync(dirname(CACHE_FILE), { recursive: true });
-    writeFileSync(CACHE_FILE, JSON.stringify(cache) + "\n");
+    mkdirSync(dirname(cacheFile), { recursive: true });
+    writeFileSync(cacheFile, JSON.stringify(cache) + "\n");
   } catch {}
 }
 
@@ -70,11 +149,6 @@ function compareVersions(leftVersion: string, rightVersion: string): number | un
   return left.prerelease.localeCompare(right.prerelease);
 }
 
-function isNewer(latest: string, current: string): boolean {
-  const comparison = compareVersions(latest, current);
-  return comparison !== undefined && comparison > 0;
-}
-
 function isAtLeast(version: string, minimum: string): boolean {
   const comparison = compareVersions(version, minimum);
   return comparison !== undefined && comparison >= 0;
@@ -102,20 +176,46 @@ function piUserAgent(): string {
   return `pi/${VERSION} (${process.platform}; ${runtime}; ${process.arch})`;
 }
 
-function hasNativeSelfUpdate(): boolean {
-  return isAtLeast(VERSION, NATIVE_SELF_UPDATE_MIN_VERSION);
+function hasNativeVersionNotice(): boolean {
+  return isAtLeast(VERSION, NATIVE_VERSION_NOTICE_MIN_VERSION);
+}
+
+function targetPackageName(release: LatestRelease, currentPackageName: string): string {
+  return release.packageName ?? currentPackageName;
+}
+
+function releaseKey(release: LatestRelease, currentPackageName: string): string {
+  return `${targetPackageName(release, currentPackageName)}@${release.version}`;
 }
 
-function saveLatestToCache(latest: string) {
-  const prev = readCache();
-  writeCache({
-    latestVersion: latest,
+function isUpdateAvailable(release: LatestRelease, currentPackageName: string): boolean {
+  const comparison = compareVersions(release.version, VERSION);
+  if (comparison === undefined) return false;
+  return comparison > 0 || (comparison === 0 && targetPackageName(release, currentPackageName) !== currentPackageName);
+}
+
+function isDismissed(
+  cache: VersionCache,
+  release: LatestRelease,
+  currentPackageName: string,
+): boolean {
+  if (cache.dismissedVersion !== release.version) return false;
+  if (!cache.dismissedPackageName) return !release.packageName;
+  return cache.dismissedPackageName === targetPackageName(release, currentPackageName);
+}
+
+function saveLatestToCache(cacheFile: string, latest: LatestRelease) {
+  const prev = readCache(cacheFile);
+  writeCache(cacheFile, {
+    latestVersion: latest.version,
+    latestPackageName: latest.packageName,
     dismissedVersion: prev?.dismissedVersion,
+    dismissedPackageName: prev?.dismissedPackageName,
     checkedAt: new Date().toISOString(),
   });
 }
 
-async function fetchLatestVersion(): Promise<string | undefined> {
+async function fetchLatestRelease(): Promise<LatestRelease | undefined> {
   try {
     const res = await fetch(LATEST_VERSION_URL, {
       headers: {
@@ -125,69 +225,158 @@ async function fetchLatestVersion(): Promise<string | undefined> {
       signal: AbortSignal.timeout(10_000),
     });
     if (!res.ok) return undefined;
-    const version = ((await res.json()) as { version?: string }).version;
-    return typeof version === "string" && version.trim()
-      ? version.trim()
-      : undefined;
+    const data = (await res.json()) as { version?: string; packageName?: string };
+    if (typeof data.version !== "string" || !data.version.trim()) return undefined;
+    const packageName =
+      typeof data.packageName === "string" && data.packageName.trim()
+        ? data.packageName.trim()
+        : undefined;
+    return { version: data.version.trim(), packageName };
   } catch {
     return undefined;
   }
 }
 
 /** Returns a cached upgrade if available and not dismissed. */
-function getCachedUpgradeVersion(): string | undefined {
-  const cache = readCache();
+function getCachedUpgradeRelease(
+  cacheFile: string,
+  currentPackageName: string,
+): LatestRelease | undefined {
+  const cache = readCache(cacheFile);
   if (!cache) return undefined;
-  if (!isNewer(cache.latestVersion, VERSION)) return undefined;
-  if (cache.dismissedVersion === cache.latestVersion) return undefined;
-  return cache.latestVersion;
+  const release = {
+    version: cache.latestVersion,
+    packageName: cache.latestPackageName,
+  };
+  if (!isUpdateAvailable(release, currentPackageName)) return undefined;
+  if (isDismissed(cache, release, currentPackageName)) return undefined;
+  return release;
 }
 
 /** Fetch latest from Pi's update endpoint and refresh cache. */
-async function refreshLatestVersionInCache(): Promise<string | undefined> {
-  const latest = await fetchLatestVersion();
+async function refreshLatestReleaseInCache(cacheFile: string): Promise<LatestRelease | undefined> {
+  const latest = await fetchLatestRelease();
   if (!latest) return undefined;
-  saveLatestToCache(latest);
+  saveLatestToCache(cacheFile, latest);
   return latest;
 }
 
-function dismissVersion(version: string) {
-  const cache = readCache();
-  writeCache({
-    latestVersion: cache?.latestVersion ?? version,
-    dismissedVersion: version,
+function dismissRelease(
+  cacheFile: string,
+  release: LatestRelease,
+  currentPackageName: string,
+) {
+  const cache = readCache(cacheFile);
+  writeCache(cacheFile, {
+    latestVersion: cache?.latestVersion ?? release.version,
+    latestPackageName: cache?.latestPackageName ?? release.packageName,
+    dismissedVersion: release.version,
+    dismissedPackageName: targetPackageName(release, currentPackageName),
     checkedAt: cache?.checkedAt,
   });
 }
 
-interface InstallCommand {
+interface InstallStep {
   program: string;
   args: string[];
   display: string;
 }
 
-function getInstallCommand(version: string): InstallCommand {
-  if (hasNativeSelfUpdate()) {
+interface InstallCommand {
+  steps: InstallStep[];
+  display: string;
+  targetVersion: string;
+  targetPackageName: string;
+}
+
+interface InstallFailure {
+  step: InstallStep;
+  code: number;
+  output: string;
+}
+
+function npmInstallStep(packageSpec: string, args: string[] = []): InstallStep {
+  const stepArgs = ["install", "-g", packageSpec, ...args];
+  return {
+    program: "npm",
+    args: stepArgs,
+    display: ["npm", ...stepArgs].join(" "),
+  };
+}
+
+function getInstallCommand(
+  release: LatestRelease,
+  currentPackageName: string,
+): InstallCommand {
+  const updatePackageName = targetPackageName(release, currentPackageName);
+  const targetVersion = release.version;
+  const packageSpec = `${updatePackageName}@${targetVersion}`;
+  const packageChanged = updatePackageName !== currentPackageName;
+  const installStep = npmInstallStep(packageSpec, ["--engine-strict=true"]);
+
+  if (!packageChanged) {
     return {
-      program: "pi",
-      args: ["update", "--self"],
-      display: "pi update --self",
+      steps: [installStep],
+      display: installStep.display,
+      targetVersion,
+      targetPackageName: updatePackageName,
     };
   }
 
   return {
-    program: "npm",
-    args: ["install", "-g", `${PACKAGE_NAME}@${version}`],
-    display: `npm install -g ${PACKAGE_NAME}@${version}`,
+    steps: [
+      npmInstallStep(packageSpec, ["--dry-run", "--engine-strict=true"]),
+      npmInstallStep(packageSpec, ["--force"]),
+    ],
+    display: `migrate ${currentPackageName} → ${packageSpec}`,
+    targetVersion,
+    targetPackageName: updatePackageName,
   };
 }
 
-function fmtCmd(cmd: InstallCommand): string {
-  return cmd.display;
+function extractRequiredNodeVersion(output: string): string | undefined {
+  return (
+    output.match(/required:\s*\{\s*node:\s*['"]([^'"]+)['"]/i)?.[1] ??
+    output.match(/Required:\s*\{[^}]*"node":"([^"]+)"/i)?.[1]
+  );
+}
+
+function formatInstallFailure(failure: InstallFailure, cmd: InstallCommand): string {
+  if (/EBADENGINE|Unsupported engine|not compatible with your version of node/i.test(failure.output)) {
+    const requiredNode = extractRequiredNodeVersion(failure.output);
+    const requirement = requiredNode ? ` Requires Node.js ${requiredNode}.` : "";
+    return `Update blocked: pi ${cmd.targetVersion} is incompatible with current Node.js ${process.version}.${requirement} Upgrade Node.js, restart pi, then run /update again.`;
+  }
+
+  return `Update failed while running \`${failure.step.display}\` (exit ${failure.code})${failure.output ? `: ${failure.output}` : ""}`;
+}
+
+async function runInstallCommand(
+  pi: ExtensionAPI,
+  cmd: InstallCommand,
+): Promise<InstallFailure | undefined> {
+  for (const step of cmd.steps) {
+    const result = await pi.exec(step.program, step.args, { timeout: 120_000 });
+    if (result.code !== 0) {
+      return {
+        step,
+        code: result.code,
+        output: [result.stderr, result.stdout].filter(Boolean).join("\n").trim(),
+      };
+    }
+  }
 }
 
-export default function (pi: ExtensionAPI) {
-  const suppressNativeCheck = hasNativeSelfUpdate() && !userSkippedVersionCheck;
+export default async function (pi: ExtensionAPI) {
+  const owningPackageName = await findOwningPiPackageName(pi);
+  const runtime = await loadPiRuntime(owningPackageName);
+  VERSION = runtime.VERSION;
+  BorderedLoader = runtime.BorderedLoader;
+  getAgentDir = runtime.getAgentDir;
+  const currentPackageName = owningPackageName ?? runtime.packageName;
+
+  const cacheFile = join(getAgentDir(), "update-cache.json");
+  const suppressNativeCheck = hasNativeVersionNotice() && !userSkippedVersionCheck;
   if (suppressNativeCheck) {
     process.env[ENV_SKIP_VERSION_CHECK] = "1";
     process.env[ENV_INTERNAL_SKIP] = "1";
@@ -245,31 +434,10 @@ export default function (pi: ExtensionAPI) {
       const loader = new BorderedLoader(tui, theme, `Running ${cmd.display}...`);
       loader.onAbort = () => done(false);
 
-      const runUpdateCommand = async () => {
-        if (suppressNativeCheck && cmd.program === "pi") {
-          delete process.env[ENV_SKIP_VERSION_CHECK];
-          delete process.env[ENV_INTERNAL_SKIP];
-          try {
-            return await pi.exec(cmd.program, cmd.args, { timeout: 120_000 });
-          } finally {
-            process.env[ENV_SKIP_VERSION_CHECK] = "1";
-            process.env[ENV_INTERNAL_SKIP] = "1";
-          }
-        }
-        return pi.exec(cmd.program, cmd.args, { timeout: 120_000 });
-      };
-
-      runUpdateCommand()
-        .then((result) => {
-          if (result.code !== 0) {
-            const output = [result.stderr, result.stdout]
-              .filter(Boolean)
-              .join("\n")
-              .trim();
-            ctx.ui.notify(
-              `Update failed (exit ${result.code})${output ? `: ${output}` : ""}`,
-              "error",
-            );
+      runInstallCommand(pi, cmd)
+        .then((failure) => {
+          if (failure) {
+            ctx.ui.notify(formatInstallFailure(failure, cmd), "error");
             done(false);
           } else {
             done(true);
@@ -319,36 +487,39 @@ export default function (pi: ExtensionAPI) {
     );
   }
 
-  async function showUpdatePrompt(ctx: ExtensionContext, latest: string) {
-    const cmd = getInstallCommand(latest);
-    const choice = await ctx.ui.select(`Update ${VERSION} → ${latest}`, [
-      `Update now (${fmtCmd(cmd)})`,
+  async function showUpdatePrompt(ctx: ExtensionContext, latest: LatestRelease) {
+    const cmd = getInstallCommand(latest, currentPackageName);
+    const currentLabel = `${currentPackageName}@${VERSION}`;
+    const targetLabel = `${cmd.targetPackageName}@${cmd.targetVersion}`;
+    const choice = await ctx.ui.select(`Update ${currentLabel} → ${targetLabel}`, [
+      `Update now (${cmd.display})`,
       "Skip",
       "Skip this version",
     ]);
 
     if (!choice || choice === "Skip") return;
     if (choice === "Skip this version") {
-      dismissVersion(latest);
+      dismissRelease(cacheFile, latest, currentPackageName);
       return;
     }
-    await doInstall(ctx, latest, cmd);
+    await doInstall(ctx, targetLabel, cmd);
   }
 
-  function canAutoPromptVersion(latest: string): boolean {
-    if (!isNewer(latest, VERSION)) return false;
-    if (promptedVersions.has(latest)) return false;
-    if (readCache()?.dismissedVersion === latest) return false;
+  function canAutoPromptVersion(latest: LatestRelease): boolean {
+    if (!isUpdateAvailable(latest, currentPackageName)) return false;
+    if (promptedVersions.has(releaseKey(latest, currentPackageName))) return false;
+    const cache = readCache(cacheFile);
+    if (cache && isDismissed(cache, latest, currentPackageName)) return false;
     return true;
   }
 
-  async function maybeShowAutoPrompt(ctx: ExtensionContext, latest: string) {
+  async function maybeShowAutoPrompt(ctx: ExtensionContext, latest: LatestRelease) {
     if (!ctx.hasUI) return;
     if (promptOpen) return;
     if (!canAutoPromptVersion(latest)) return;
 
     promptOpen = true;
-    promptedVersions.add(latest);
+    promptedVersions.add(releaseKey(latest, currentPackageName));
     try {
       await showUpdatePrompt(ctx, latest);
     } finally {
@@ -360,13 +531,13 @@ export default function (pi: ExtensionAPI) {
     if (!ctx.hasUI) return;
     if (shouldSkipAutoChecks()) return;
 
-    const cached = getCachedUpgradeVersion();
+    const cached = getCachedUpgradeRelease(cacheFile, currentPackageName);
     if (cached) void maybeShowAutoPrompt(ctx, cached);
 
     if (liveCheckStarted) return;
     liveCheckStarted = true;
 
-    void refreshLatestVersionInCache()
+    void refreshLatestReleaseInCache(cacheFile)
       .then((latest) => {
         if (!latest) return;
         void maybeShowAutoPrompt(ctx, latest);
@@ -380,14 +551,14 @@ export default function (pi: ExtensionAPI) {
   });
 
   pi.registerCommand("update", {
-    description: "Check for pi updates and install via native updater when available",
+    description: "Check for pi updates and install with npm",
     handler: async (rawArgs, ctx) => {
       // /update --test — simulate the full UI flow without a real install
       if (rawArgs?.trim() === "--test") {
         const fakeLatest = "99.0.0";
-        const cmd = getInstallCommand(fakeLatest);
-        const choice = await ctx.ui.select(`Update ${VERSION} → ${fakeLatest}`, [
-          `Update now (${fmtCmd(cmd)})`,
+        const cmd = getInstallCommand({ version: fakeLatest }, currentPackageName);
+        const choice = await ctx.ui.select(`Update ${currentPackageName}@${VERSION} → ${cmd.targetPackageName}@${fakeLatest}`, [
+          `Update now (${cmd.display})`,
           "Skip",
           "Skip this version",
         ]);
@@ -422,7 +593,7 @@ export default function (pi: ExtensionAPI) {
         return;
       }
 
-      const latest = await ctx.ui.custom<string | null>(
+      const latest = await ctx.ui.custom<LatestRelease | null>(
         (tui, theme, _kb, done) => {
           const loader = new BorderedLoader(
             tui,
@@ -430,7 +601,7 @@ export default function (pi: ExtensionAPI) {
             "Checking for updates...",
           );
           loader.onAbort = () => done(null);
-          fetchLatestVersion()
+          fetchLatestRelease()
             .then((v) => done(v ?? null))
             .catch(() => done(null));
           return loader;
@@ -442,14 +613,14 @@ export default function (pi: ExtensionAPI) {
         return;
       }
 
-      saveLatestToCache(latest);
+      saveLatestToCache(cacheFile, latest);
 
-      if (!isNewer(latest, VERSION)) {
-        ctx.ui.notify(`Already on latest version (${VERSION}).`, "info");
+      if (!isUpdateAvailable(latest, currentPackageName)) {
+        ctx.ui.notify(`Already on latest version (${currentPackageName}@${VERSION}).`, "info");
         return;
       }
 
-      promptedVersions.add(latest);
+      promptedVersions.add(releaseKey(latest, currentPackageName));
       await showUpdatePrompt(ctx, latest);
     },
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-updater",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "Codex-style auto-updater for pi. Checks for new versions on startup and prompts to install.",
   "type": "module",
   "license": "MIT",
@@ -26,10 +26,15 @@
     "CHANGELOG.md"
   ],
   "peerDependencies": {
-    "@mariozechner/pi-coding-agent": "*"
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "peerDependenciesMeta": {
+    "@earendil-works/pi-coding-agent": {
+      "optional": true
+    }
   },
   "devDependencies": {
-    "@mariozechner/pi-coding-agent": "^0.65.0",
+    "@earendil-works/pi-coding-agent": "^0.74.1",
     "@types/node": "^25.3.2",
     "typescript": "^5.9.3"
   }