@moxt-ai/mobius 0.0.9 → 0.0.10

package/dist/index.js

@@ -388,7 +388,11 @@ var LocalAgentDefinition = class {
   environment;
   id;
   label;
-  constructor(id, label, command, arguments_, environment = {}, adapterVersion = "", agentVersion = "", adapterIdentity = readTrustedIdentity(command), agentIdentity = adapterIdentity) {
+  promptTimeoutMilliseconds;
+  constructor(id, label, command, arguments_, environment = {}, adapterVersion = "", agentVersion = "", adapterIdentity = readTrustedIdentity(command), agentIdentity = adapterIdentity, promptTimeoutMilliseconds = 30 * 60 * 1e3) {
+    if (!Number.isSafeInteger(promptTimeoutMilliseconds) || promptTimeoutMilliseconds < 1) {
+      throw new Error("The local Agent prompt deadline is invalid");
+    }
     this.adapterIdentity = adapterIdentity;
     this.adapterPath = adapterIdentity.realPath;
     this.adapterVersion = adapterVersion;
@@ -396,6 +400,7 @@ var LocalAgentDefinition = class {
     this.agentVersion = agentVersion;
     this.id = id;
     this.label = label;
+    this.promptTimeoutMilliseconds = promptTimeoutMilliseconds;
     this.command = adapterIdentity.realPath;
     this.arguments = Object.freeze([...arguments_]);
     this.environment = Object.freeze({ ...environment });
@@ -23587,12 +23592,27 @@ var AcpSessionManager = class {
         "session_busy"
       );
     }
+    const deadlineController = new AbortController();
+    const deadlineError = new AcpExecutionError(
+      "The local Agent prompt exceeded its deadline",
+      {},
+      "prompt_timeout"
+    );
+    const deadline = setTimeout(
+      () => deadlineController.abort(deadlineError),
+      options.agent.promptTimeoutMilliseconds
+    );
+    deadline.unref();
+    const boundedOptions = {
+      ...options,
+      signal: AbortSignal.any([options.signal, deadlineController.signal])
+    };
     this.#activeSessionIds.add(options.sessionId);
     try {
       if (this.#cancellationRequests.has(options.sessionId)) {
         return { stopReason: "cancelled" };
       }
-      const runtime = await this.ensureSession(options);
+      const runtime = await this.ensureSession(boundedOptions);
       if (this.#nativeOperations.has(
         `${options.agent.id}:${runtime.nativeSessionId()}`
       ))
@@ -23604,7 +23624,7 @@ var AcpSessionManager = class {
       if (this.#cancellationRequests.has(options.sessionId)) {
         return { stopReason: "cancelled" };
       }
-      return await runtime.prompt(options);
+      return await runtime.prompt(boundedOptions);
     } catch (error61) {
       const failedRuntime = this.#sessions.get(options.sessionId);
       if (failedRuntime !== void 0) {
@@ -23618,6 +23638,7 @@ var AcpSessionManager = class {
         cause: error61
       });
     } finally {
+      clearTimeout(deadline);
       this.#activeSessionIds.delete(options.sessionId);
       this.#cancellationRequests.delete(options.sessionId);
     }
@@ -23919,16 +23940,17 @@ import {
   writeFile
 } from "node:fs/promises";
 import { hostname as hostname3 } from "node:os";
-import { basename, join as join7, resolve as resolve3 } from "node:path";
+import { basename, join as join8, resolve as resolve3 } from "node:path";
 import { fetch } from "undici";
 
 // src/agent-catalog/discover-local-agents.ts
 import { spawn as spawn3 } from "node:child_process";
-import { isAbsolute, join as join6 } from "node:path";
+import { isAbsolute as isAbsolute2, join as join7 } from "node:path";
 import {
   methods as methods3,
   ndJsonStream as ndJsonStream2,
-  PROTOCOL_VERSION as PROTOCOL_VERSION2
+  PROTOCOL_VERSION as PROTOCOL_VERSION2,
+  RequestError
 } from "@agentclientprotocol/sdk";
 
 // src/agent-installation/installation-grants.ts
@@ -23974,6 +23996,9 @@ async function readGrantedAgents(stateDirectory) {
 }
 
 // src/agent-installation/managed-adapter-installer.ts
+import { join as join6 } from "node:path";
+
+// src/agent-installation/managed-npm-package.ts
 import {
   mkdir,
   mkdtemp,
@@ -23983,15 +24008,35 @@ import {
   rm,
   stat as stat2
 } from "node:fs/promises";
-import { delimiter, dirname as dirname3, join as join5, relative } from "node:path";
-var ADAPTER_INSTALL_TIMEOUT_MILLISECONDS = 2 * 60 * 1e3;
+import { delimiter, dirname as dirname3, isAbsolute, join as join5, relative, sep } from "node:path";
+var INSTALL_TIMEOUT_MILLISECONDS = 5 * 60 * 1e3;
 var PACKAGE_METADATA_LIMIT_BYTES = 64 * 1024;
-var ManagedAdapterInstallError = class extends Error {
+var PACKAGE_LOCK_LIMIT_BYTES = 8 * 1024 * 1024;
+var ManagedNpmPackageDefinition = class {
+  executableName;
+  packageName;
+  version;
+  constructor(packageName, version2, executableName) {
+    this.executableName = executableName;
+    this.packageName = packageName;
+    this.version = version2;
+  }
+};
+var SriManagedNpmPackageDefinition = class extends ManagedNpmPackageDefinition {
+  integrity;
+  tarballUrl;
+  constructor(packageName, version2, executableName, integrity, tarballUrl) {
+    super(packageName, version2, executableName);
+    this.integrity = integrity;
+    this.tarballUrl = tarballUrl;
+  }
+};
+var ManagedNpmPackageError = class extends Error {
   code;
   constructor(code, message, options = {}) {
     super(message, options);
     this.code = code;
-    this.name = "ManagedAdapterInstallError";
+    this.name = "ManagedNpmPackageError";
   }
 };
 function isRecord5(value) {
@@ -24000,28 +24045,43 @@ function isRecord5(value) {
 function packagePath(root, packageName) {
   return join5(root, "node_modules", ...packageName.split("/"));
 }
-async function readPackageJson(path2) {
-  const handle = await open3(path2, "r");
+function isContainedPath(root, candidate) {
+  const difference = relative(root, candidate);
+  return difference.length > 0 && difference !== ".." && !difference.startsWith(`..${sep}`) && !isAbsolute(difference);
+}
+async function readJsonRecord(path2, maximumBytes) {
   try {
-    const metadata = await handle.stat();
-    if (!metadata.isFile() || metadata.size > PACKAGE_METADATA_LIMIT_BYTES) {
-      throw new ManagedAdapterInstallError(
-        "adapter_verification_failed",
-        "The managed adapter package metadata is invalid"
+    const handle = await open3(path2, "r");
+    try {
+      const metadata = await handle.stat();
+      if (!metadata.isFile() || metadata.size > maximumBytes) {
+        throw new ManagedNpmPackageError(
+          "managed_package_verification_failed",
+          "The managed npm package metadata is invalid"
+        );
+      }
+      const value = JSON.parse(
+        await handle.readFile({ encoding: "utf8" })
       );
+      if (!isRecord5(value)) {
+        throw new ManagedNpmPackageError(
+          "managed_package_verification_failed",
+          "The managed npm package metadata is invalid"
+        );
+      }
+      return value;
+    } finally {
+      await handle.close();
     }
-    const value = JSON.parse(
-      await handle.readFile({ encoding: "utf8" })
-    );
-    if (!isRecord5(value)) {
-      throw new ManagedAdapterInstallError(
-        "adapter_verification_failed",
-        "The managed adapter package metadata is invalid"
-      );
+  } catch (error61) {
+    if (error61 instanceof ManagedNpmPackageError) {
+      throw error61;
     }
-    return value;
-  } finally {
-    await handle.close();
+    throw new ManagedNpmPackageError(
+      "managed_package_verification_failed",
+      "The managed npm package metadata is invalid",
+      { cause: error61 }
+    );
   }
 }
 function readBinPath(packageMetadata, executableName) {
@@ -24032,83 +24092,125 @@ function readBinPath(packageMetadata, executableName) {
   if (isRecord5(bin) && typeof bin[executableName] === "string") {
     return bin[executableName];
   }
-  throw new ManagedAdapterInstallError(
-    "adapter_verification_failed",
-    "The managed adapter executable declaration is invalid"
+  throw new ManagedNpmPackageError(
+    "managed_package_verification_failed",
+    "The managed npm package executable declaration is invalid"
   );
 }
-async function validateManagedAdapter(root, specification) {
+function verifyPackageLock(lock, definition) {
+  if (lock["lockfileVersion"] !== 3) {
+    throw new ManagedNpmPackageError(
+      "managed_package_verification_failed",
+      "The managed npm package lockfile is invalid"
+    );
+  }
+  const packages = lock["packages"];
+  if (!isRecord5(packages)) {
+    throw new ManagedNpmPackageError(
+      "managed_package_verification_failed",
+      "The managed npm package lockfile is invalid"
+    );
+  }
+  const suffix = `node_modules/${definition.packageName}`;
+  let entry;
+  let matches = 0;
+  for (const [key, candidate] of Object.entries(packages)) {
+    const normalizedKey = key.replaceAll("\\", "/");
+    if (normalizedKey === suffix || normalizedKey.endsWith(`/${suffix}`)) {
+      entry = candidate;
+      matches += 1;
+    }
+  }
+  if (matches !== 1 || !isRecord5(entry) || entry["integrity"] !== definition.integrity || entry["resolved"] !== definition.tarballUrl || entry["version"] !== definition.version) {
+    throw new ManagedNpmPackageError(
+      "managed_package_verification_failed",
+      "The managed npm package lockfile does not match the pinned artifact"
+    );
+  }
+}
+async function validateManagedNpmPackage(root, definition) {
+  try {
+    return await validateManagedNpmPackageContents(root, definition);
+  } catch (error61) {
+    if (error61 instanceof ManagedNpmPackageError) {
+      throw error61;
+    }
+    throw new ManagedNpmPackageError(
+      "managed_package_verification_failed",
+      "The managed npm package is invalid",
+      { cause: error61 }
+    );
+  }
+}
+async function validateManagedNpmPackageContents(root, definition) {
   const rootPath = await realpath2(root);
   const packageRoot = await realpath2(
-    packagePath(rootPath, specification.adapterPackage)
+    packagePath(rootPath, definition.packageName)
   );
-  const packageDifference = relative(rootPath, packageRoot);
-  if (packageDifference.startsWith("..") || packageDifference.length === 0) {
-    throw new ManagedAdapterInstallError(
-      "adapter_verification_failed",
-      "The managed adapter package escaped its private cache"
+  if (!isContainedPath(rootPath, packageRoot)) {
+    throw new ManagedNpmPackageError(
+      "managed_package_verification_failed",
+      "The managed npm package escaped its private cache"
     );
   }
-  const metadata = await readPackageJson(join5(packageRoot, "package.json"));
-  if (metadata["name"] !== specification.adapterPackage || metadata["version"] !== specification.adapterVersion) {
-    throw new ManagedAdapterInstallError(
-      "adapter_verification_failed",
-      "The managed adapter package identity is invalid"
+  const metadata = await readJsonRecord(
+    join5(packageRoot, "package.json"),
+    PACKAGE_METADATA_LIMIT_BYTES
+  );
+  if (metadata["name"] !== definition.packageName || metadata["version"] !== definition.version) {
+    throw new ManagedNpmPackageError(
+      "managed_package_verification_failed",
+      "The managed npm package identity is invalid"
     );
   }
-  const declaredBin = readBinPath(metadata, specification.adapterExecutable);
+  if (definition instanceof SriManagedNpmPackageDefinition) {
+    verifyPackageLock(
+      await readJsonRecord(
+        join5(rootPath, "package-lock.json"),
+        PACKAGE_LOCK_LIMIT_BYTES
+      ),
+      definition
+    );
+  }
+  const declaredBin = readBinPath(metadata, definition.executableName);
   const executable = await resolveExecutablePath(
     join5(packageRoot, declaredBin)
   );
-  if (executable === null) {
-    throw new ManagedAdapterInstallError(
-      "adapter_verification_failed",
-      "The managed adapter executable is invalid"
-    );
-  }
-  const executableDifference = relative(rootPath, executable.path);
-  if (executableDifference.startsWith("..") || executableDifference.length === 0) {
-    throw new ManagedAdapterInstallError(
-      "adapter_verification_failed",
-      "The managed adapter executable escaped its private cache"
+  if (executable === null || !isContainedPath(rootPath, executable.path)) {
+    throw new ManagedNpmPackageError(
+      "managed_package_verification_failed",
+      "The managed npm package executable is invalid"
     );
   }
   return executable;
 }
-var ManagedAdapterInstaller = class {
-  #environment;
-  #stateDirectory;
-  constructor(options) {
-    this.#environment = options.environment;
-    this.#stateDirectory = options.stateDirectory;
-  }
-  install = async (specification, signal) => {
+var ManagedNpmPackageInstaller = class {
+  install = async (root, definition, environment, signal) => {
     signal.throwIfAborted();
-    const agentCache = join5(this.#stateDirectory, "adapters", specification.id);
-    const published = join5(agentCache, specification.adapterVersion);
     try {
-      const metadata = await stat2(published);
+      const metadata = await stat2(root);
       if (metadata.isDirectory()) {
-        return await validateManagedAdapter(published, specification);
+        return await validateManagedNpmPackage(root, definition);
       }
     } catch (error61) {
       if (!(error61 instanceof Error) || !("code" in error61) || error61.code !== "ENOENT") {
         throw error61;
       }
     }
-    await mkdir(agentCache, { mode: 448, recursive: true });
+    const parent = dirname3(root);
+    await mkdir(parent, { mode: 448, recursive: true });
     const staging = await mkdtemp(
-      join5(agentCache, `.${specification.adapterVersion}.staging-`)
+      join5(parent, `.${definition.version}.staging-`)
     );
     try {
       const npm = await findExecutableOnPath(
         process.platform === "win32" ? "npm.cmd" : "npm",
-        this.#environment
+        environment
       );
       if (npm === null) {
-        throw new ManagedAdapterInstallError(
+        throw new ManagedNpmPackageError(
           "package_manager_not_found",
-          "A supported npm executable is required to install the ACP adapter"
+          "A supported npm executable is required to install the managed package"
         );
       }
       await runBoundedProcess({
@@ -24120,51 +24222,57 @@ var ManagedAdapterInstaller = class {
           "--ignore-scripts",
           "--no-audit",
           "--no-fund",
-          "--package-lock=false",
-          "--save=false",
+          "--package-lock=true",
+          "--save-exact",
           "--registry=https://registry.npmjs.org/",
-          `${specification.adapterPackage}@${specification.adapterVersion}`
+          `${definition.packageName}@${definition.version}`
         ],
         command: npm.path,
         cwd: staging,
         environment: {
           HOME: join5(staging, "home"),
           NPM_CONFIG_AUDIT: "false",
+          NPM_CONFIG_CACHE: join5(staging, ".npm-cache"),
           NPM_CONFIG_FUND: "false",
           NPM_CONFIG_IGNORE_SCRIPTS: "true",
           NPM_CONFIG_OMIT: "optional",
+          NPM_CONFIG_PACKAGE_LOCK: "true",
           NPM_CONFIG_REGISTRY: "https://registry.npmjs.org/",
           PATH: `${dirname3(process.execPath)}${delimiter}/usr/bin${delimiter}/bin`
         },
         outputLimitBytes: 64 * 1024,
         signal,
-        timeoutMilliseconds: ADAPTER_INSTALL_TIMEOUT_MILLISECONDS
+        timeoutMilliseconds: INSTALL_TIMEOUT_MILLISECONDS
       });
-      await validateManagedAdapter(staging, specification);
+      await Promise.all([
+        rm(join5(staging, ".npm-cache"), { force: true, recursive: true }),
+        rm(join5(staging, "home"), { force: true, recursive: true })
+      ]);
+      await validateManagedNpmPackage(staging, definition);
       try {
-        await rename(staging, published);
+        await rename(staging, root);
       } catch (error61) {
         try {
-          return await validateManagedAdapter(published, specification);
+          return await validateManagedNpmPackage(root, definition);
         } catch {
-          throw new ManagedAdapterInstallError(
-            "adapter_publish_failed",
-            "The managed adapter could not be published",
+          throw new ManagedNpmPackageError(
+            "managed_package_publish_failed",
+            "The managed npm package could not be published",
             { cause: error61 }
           );
         }
       }
-      return await validateManagedAdapter(published, specification);
+      return await validateManagedNpmPackage(root, definition);
     } catch (error61) {
       if (signal.aborted) {
         signal.throwIfAborted();
       }
-      if (error61 instanceof ManagedAdapterInstallError) {
+      if (error61 instanceof ManagedNpmPackageError) {
         throw error61;
       }
-      throw new ManagedAdapterInstallError(
-        "adapter_install_failed",
-        "The pinned ACP adapter could not be installed",
+      throw new ManagedNpmPackageError(
+        "managed_package_install_failed",
+        "The pinned npm package could not be installed",
         { cause: error61 }
       );
     } finally {
@@ -24173,20 +24281,152 @@ var ManagedAdapterInstaller = class {
   };
 };
 
+// src/agent-installation/managed-adapter-installer.ts
+var ManagedAdapterInstallError = class extends Error {
+  code;
+  constructor(code, message, options = {}) {
+    super(message, options);
+    this.code = code;
+    this.name = "ManagedAdapterInstallError";
+  }
+};
+function translateError(error61) {
+  if (error61 instanceof ManagedAdapterInstallError) {
+    return error61;
+  }
+  if (error61 instanceof ManagedNpmPackageError) {
+    if (error61.code === "package_manager_not_found") {
+      return new ManagedAdapterInstallError(
+        error61.code,
+        "A supported npm executable is required to install the ACP adapter",
+        { cause: error61 }
+      );
+    }
+    if (error61.code === "managed_package_verification_failed") {
+      return new ManagedAdapterInstallError(
+        "adapter_verification_failed",
+        "The managed adapter did not match its pinned artifact",
+        { cause: error61 }
+      );
+    }
+    if (error61.code === "managed_package_publish_failed") {
+      return new ManagedAdapterInstallError(
+        "adapter_publish_failed",
+        "The managed adapter could not be published",
+        { cause: error61 }
+      );
+    }
+  }
+  return new ManagedAdapterInstallError(
+    "adapter_install_failed",
+    "The pinned ACP adapter could not be installed",
+    { cause: error61 }
+  );
+}
+async function validateManagedAdapter(root, specification) {
+  try {
+    return await validateManagedNpmPackage(
+      root,
+      specification.adapterPackageDefinition
+    );
+  } catch (error61) {
+    throw translateError(error61);
+  }
+}
+var ManagedAdapterInstaller = class {
+  #environment;
+  #npmInstaller;
+  #stateDirectory;
+  constructor(options, npmInstaller = new ManagedNpmPackageInstaller()) {
+    this.#environment = options.environment;
+    this.#npmInstaller = npmInstaller;
+    this.#stateDirectory = options.stateDirectory;
+  }
+  install = async (specification, signal) => {
+    const root = join6(
+      this.#stateDirectory,
+      "adapters",
+      specification.id,
+      specification.adapterVersion
+    );
+    try {
+      return await this.#npmInstaller.install(
+        root,
+        specification.adapterPackageDefinition,
+        this.#environment,
+        signal
+      );
+    } catch (error61) {
+      if (signal.aborted) {
+        signal.throwIfAborted();
+      }
+      throw translateError(error61);
+    }
+  };
+};
+
+// src/agent-installation/pi-managed-packages.ts
+var PI_ACP_PACKAGE = new SriManagedNpmPackageDefinition(
+  "pi-acp",
+  "0.0.33",
+  "pi-acp",
+  "sha512-vX9kY1tK14E72G4dBAx+RGCk/k7XPjTHls6dLUxA8WSkBav6B6JHuSBv3eusp50LCR/GTRsR2kIKsG0Z5jANzw==",
+  "https://registry.npmjs.org/pi-acp/-/pi-acp-0.0.33.tgz"
+);
+var PI_AGENT_PACKAGE = new SriManagedNpmPackageDefinition(
+  "@earendil-works/pi-coding-agent",
+  "0.85.0",
+  "pi",
+  "sha512-INxVkLAVfAMju5MojJpmyu/0bMP+r+ffZuS7UqVv32E2JwHBRbcHfELDfmFNvapEbgYfKN2r9OYO1p3TqDBR+g==",
+  "https://registry.npmjs.org/@earendil-works/pi-coding-agent/-/pi-coding-agent-0.85.0.tgz"
+);
+
 // src/agent-catalog/discover-local-agents.ts
 var VERSION_PROBE_TIMEOUT_MILLISECONDS = 3e3;
 var ACP_PROBE_TIMEOUT_MILLISECONDS = 5e3;
 var ACP_OUTPUT_LIMIT_BYTES = 1024 * 1024;
+var DEFAULT_PROMPT_TIMEOUT_MILLISECONDS = 30 * 60 * 1e3;
+var PI_ACP_PROBE_TIMEOUT_MILLISECONDS = 3e4;
+var PI_PROMPT_TIMEOUT_MILLISECONDS = 5 * 60 * 1e3;
 var LocalAgentSpecification = class {
+  acpProbeTimeoutMilliseconds = ACP_PROBE_TIMEOUT_MILLISECONDS;
+  authenticationCommand = () => "";
+  adapterVersionArguments = ["--version"];
+  agentVersionArguments = ["--version"];
+  promptTimeoutMilliseconds = DEFAULT_PROMPT_TIMEOUT_MILLISECONDS;
+  get adapterExecutable() {
+    return this.adapterPackageDefinition.executableName;
+  }
+  get adapterPackage() {
+    return this.adapterPackageDefinition.packageName;
+  }
+  get adapterVersion() {
+    return this.adapterPackageDefinition.version;
+  }
+  resolveManagedAgent = async (stateDirectory, platform) => {
+    const executable = await resolveExecutablePath(
+      join7(stateDirectory, ...this.managedAgentExecutablePath),
+      platform
+    );
+    if (executable === null) {
+      throw new Error("The managed Agent executable is unavailable");
+    }
+    return executable;
+  };
   recoveryCommand = () => `npm install -g --omit=optional ${this.adapterPackage}@${this.adapterVersion}`;
   supportsInstallation = (platform, architecture) => (platform === "darwin" || platform === "linux") && (architecture === "arm64" || architecture === "x64");
+  verifyAcp = (_connection, _initialized, _defaultWorkspace, _signal) => Promise.resolve();
+};
+var BridgedAcpAgentDefinition = class extends LocalAgentSpecification {
 };
-var CodexAgentSpecification = class extends LocalAgentSpecification {
+var CodexAgentSpecification = class extends BridgedAcpAgentDefinition {
   adapterEnvironmentVariable = "CODEX_PATH";
-  adapterExecutable = "codex-acp";
   adapterOverrideVariable = "MOBIUS_CODEX_ACP_PATH";
-  adapterPackage = "@agentclientprotocol/codex-acp";
-  adapterVersion = "1.8.0";
+  adapterPackageDefinition = new ManagedNpmPackageDefinition(
+    "@agentclientprotocol/codex-acp",
+    "1.8.0",
+    "codex-acp"
+  );
   agentExecutable = "codex";
   agentOverrideVariable = "MOBIUS_CODEX_PATH";
   id = "codex";
@@ -24203,12 +24443,14 @@ var CodexAgentSpecification = class extends LocalAgentSpecification {
   ];
   managedAgentExecutablePath = ["agents", "codex", "bin", "codex"];
 };
-var ClaudeCodeAgentSpecification = class extends LocalAgentSpecification {
+var ClaudeCodeAgentSpecification = class extends BridgedAcpAgentDefinition {
   adapterEnvironmentVariable = "CLAUDE_CODE_EXECUTABLE";
-  adapterExecutable = "claude-agent-acp";
   adapterOverrideVariable = "MOBIUS_CLAUDE_ACP_PATH";
-  adapterPackage = "@agentclientprotocol/claude-agent-acp";
-  adapterVersion = "0.73.0";
+  adapterPackageDefinition = new ManagedNpmPackageDefinition(
+    "@agentclientprotocol/claude-agent-acp",
+    "0.73.0",
+    "claude-agent-acp"
+  );
   agentExecutable = "claude";
   agentOverrideVariable = "MOBIUS_CLAUDE_PATH";
   id = "claude";
@@ -24232,10 +24474,86 @@ var ClaudeCodeAgentSpecification = class extends LocalAgentSpecification {
     "claude"
   ];
 };
+var PiAgentSpecification = class extends BridgedAcpAgentDefinition {
+  acpProbeTimeoutMilliseconds = PI_ACP_PROBE_TIMEOUT_MILLISECONDS;
+  adapterEnvironmentVariable = "PI_ACP_PI_COMMAND";
+  adapterOverrideVariable = "MOBIUS_PI_ACP_PATH";
+  adapterPackageDefinition = PI_ACP_PACKAGE;
+  adapterVersionArguments = [];
+  authenticationCommand = () => "pi-acp --terminal-login";
+  agentExecutable = "pi";
+  agentOverrideVariable = "MOBIUS_PI_PATH";
+  id = "pi";
+  label = "Pi";
+  managedAdapterExecutablePath = [
+    "adapters",
+    "pi",
+    PI_ACP_PACKAGE.version,
+    "node_modules",
+    "pi-acp",
+    "dist",
+    "index.js"
+  ];
+  managedAgentExecutablePath = [
+    "agents",
+    "pi",
+    PI_AGENT_PACKAGE.version,
+    "node_modules",
+    "@earendil-works",
+    "pi-coding-agent",
+    "dist",
+    "bundle",
+    "cli.js"
+  ];
+  promptTimeoutMilliseconds = PI_PROMPT_TIMEOUT_MILLISECONDS;
+  resolveManagedAgent = async (stateDirectory, _platform) => await validateManagedNpmPackage(
+    join7(stateDirectory, "agents", this.id, PI_AGENT_PACKAGE.version),
+    PI_AGENT_PACKAGE
+  );
+  verifyAcp = async (connection, initialized, defaultWorkspace, signal) => {
+    const capabilities = initialized.agentCapabilities ?? {};
+    if (capabilities.loadSession !== true) {
+      throw new AgentProbeError(
+        "acp_incompatible",
+        "Pi ACP adapter does not support session recovery"
+      );
+    }
+    const session = await connection.agent.request(
+      methods3.agent.session.new,
+      {
+        additionalDirectories: [],
+        cwd: defaultWorkspace,
+        mcpServers: []
+      },
+      { cancellationSignal: signal }
+    );
+    if (session.sessionId.length === 0) {
+      throw new AgentProbeError(
+        "acp_incompatible",
+        "Pi ACP adapter returned an invalid session"
+      );
+    }
+    const prompt = await connection.agent.request(
+      methods3.agent.session.prompt,
+      {
+        prompt: [{ text: "/session", type: "text" }],
+        sessionId: session.sessionId
+      },
+      { cancellationSignal: signal }
+    );
+    if (prompt.stopReason !== "end_turn") {
+      throw new AgentProbeError(
+        "acp_incompatible",
+        "Pi ACP adapter did not complete its conformance prompt"
+      );
+    }
+  };
+};
 function supportedLocalAgentSpecifications() {
   return Object.freeze([
     new CodexAgentSpecification(),
-    new ClaudeCodeAgentSpecification()
+    new ClaudeCodeAgentSpecification(),
+    new PiAgentSpecification()
   ]);
 }
 var AgentDiscovery = class {
@@ -24288,6 +24606,14 @@ var IncompatibleAdapter = class extends UnavailableAgent {
     super(specification);
   }
 };
+var AuthenticationRequiredAgent = class extends UnavailableAgent {
+  code = "authentication_required";
+  message = "Agent authentication is required";
+  status = "authentication_required";
+  constructor(specification) {
+    super(specification);
+  }
+};
 var LocalAgentInventory = class {
   available;
   discoveries;
@@ -24309,7 +24635,10 @@ var LocalAgentInventory = class {
     this.discoveries = Object.freeze([...discoveries]);
     this.installable = Object.freeze(
       unavailable.filter(
-        (discovery) => discovery.specification.supportsInstallation(platform, architecture)
+        (discovery) => !(discovery instanceof AuthenticationRequiredAgent) && discovery.specification.supportsInstallation(
+          platform,
+          architecture
+        )
       ).map(
         (discovery) => new InstallableAgentDefinition(
           discovery.specification.id,
@@ -24336,17 +24665,21 @@ var DiscoveryAcpHandler = class {
   onPermission = (_request, _signal) => Promise.reject(new Error("ACP probe does not grant permissions"));
   onUpdate = (_notification) => Promise.resolve();
 };
-async function resolveManagedExecutable(managedExecutablePath, options) {
-  return await resolveExecutablePath(
-    join6(readStateDirectory(options.environment), ...managedExecutablePath),
-    options.platform
-  );
+async function resolveManagedExecutable(specification, options) {
+  try {
+    return await specification.resolveManagedAgent(
+      readStateDirectory(options.environment),
+      options.platform ?? process.platform
+    );
+  } catch {
+    return null;
+  }
 }
 async function resolveManagedAdapterExecutable(specification, options) {
   let managed;
   try {
     managed = await validateManagedAdapter(
-      join6(
+      join7(
         readStateDirectory(options.environment),
         "adapters",
         specification.id,
@@ -24362,7 +24695,7 @@ async function resolveManagedAdapterExecutable(specification, options) {
 async function resolveSpecificationExecutables(executableName, overrideVariable, resolveManaged, options) {
   const override = options.environment[overrideVariable];
   if (override !== void 0) {
-    if (override.length === 0 || !isAbsolute(override)) {
+    if (override.length === 0 || !isAbsolute2(override)) {
       return [];
     }
     const executable = await resolveExecutablePath(override, options.platform);
@@ -24386,10 +24719,7 @@ async function resolveAgentExecutables(specification, options) {
   return await resolveSpecificationExecutables(
     specification.agentExecutable,
     specification.agentOverrideVariable,
-    async () => await resolveManagedExecutable(
-      specification.managedAgentExecutablePath,
-      options
-    ),
+    async () => await resolveManagedExecutable(specification, options),
     options
   );
 }
@@ -24412,9 +24742,9 @@ async function resolveAdapterExecutable(specification, options) {
 function normalizedVersion(output2) {
   return output2.trim().split(/\r?\n/, 1)[0]?.trim().slice(0, 128) ?? "";
 }
-async function probeVersion(executable, environment, defaultWorkspace, signal) {
+async function probeVersion(executable, arguments_, environment, defaultWorkspace, signal) {
   const result = await runBoundedProcess({
-    arguments: ["--version"],
+    arguments: arguments_,
     command: executable.path,
     cwd: defaultWorkspace,
     environment,
@@ -24444,6 +24774,7 @@ async function findVerifiedAgentExecutable(specification, options) {
     try {
       const version2 = await probeVersion(
         executable,
+        specification.agentVersionArguments,
         options.environment,
         options.defaultWorkspace,
         options.signal
@@ -24512,14 +24843,14 @@ function writableAcpStream(output2) {
     }
   });
 }
-async function probeAcp(agent, environment, defaultWorkspace, signal) {
+async function probeAcp(specification, agent, environment, defaultWorkspace, signal) {
   signal.throwIfAborted();
   const controller = new AbortController();
   let timedOut = false;
   const timeout = setTimeout(() => {
     timedOut = true;
     controller.abort(new Error("ACP probe timed out"));
-  }, ACP_PROBE_TIMEOUT_MILLISECONDS);
+  }, specification.acpProbeTimeoutMilliseconds);
   const abort = () => controller.abort(signal.reason);
   signal.addEventListener("abort", abort, { once: true });
   if (signal.aborted) {
@@ -24578,6 +24909,13 @@ async function probeAcp(agent, environment, defaultWorkspace, signal) {
         "ACP adapter selected an unsupported protocol version"
       );
     }
+    await specification.verifyAcp(
+      connection,
+      initialized,
+      defaultWorkspace,
+      controller.signal
+    );
+    return normalizedVersion(initialized.agentInfo?.version ?? "");
   } catch (error61) {
     if (signal.aborted) {
       signal.throwIfAborted();
@@ -24592,6 +24930,13 @@ async function probeAcp(agent, environment, defaultWorkspace, signal) {
     if (error61 instanceof AgentProbeError) {
       throw error61;
     }
+    if (error61 instanceof RequestError && error61.code === -32e3 && specification.authenticationCommand().length > 0) {
+      throw new AgentProbeError(
+        "authentication_required",
+        "Agent authentication is required",
+        { cause: error61 }
+      );
+    }
     throw new AgentProbeError(
       "acp_incompatible",
       "ACP adapter initialization failed",
@@ -24608,6 +24953,9 @@ async function probeAcp(agent, environment, defaultWorkspace, signal) {
 }
 function probeFailure(specification, executableKind, error61) {
   if (error61 instanceof AgentProbeError) {
+    if (error61.code === "authentication_required") {
+      return new AuthenticationRequiredAgent(specification);
+    }
     return error61.code === "acp_incompatible" ? new IncompatibleAdapter(specification) : new ProbeFailed(specification, error61.code, error61.message);
   }
   if (error61 instanceof ProcessExecutionError) {
@@ -24642,6 +24990,7 @@ async function discoverSpecification(specification, options) {
     try {
       agentVersion = await probeVersion(
         agent,
+        specification.agentVersionArguments,
         options.environment,
         options.defaultWorkspace,
         options.signal
@@ -24656,15 +25005,18 @@ async function discoverSpecification(specification, options) {
     for (const adapter of adapters) {
       let adapterVersion = "";
       try {
-        adapterVersion = await probeVersion(
-          adapter,
-          {
-            ...options.environment,
-            [specification.adapterEnvironmentVariable]: agent.path
-          },
-          options.defaultWorkspace,
-          options.signal
-        );
+        if (specification.adapterVersionArguments.length > 0) {
+          adapterVersion = await probeVersion(
+            adapter,
+            specification.adapterVersionArguments,
+            {
+              ...options.environment,
+              [specification.adapterEnvironmentVariable]: agent.path
+            },
+            options.defaultWorkspace,
+            options.signal
+          );
+        }
       } catch (error61) {
         if (options.signal.aborted) {
           options.signal.throwIfAborted();
@@ -24681,16 +25033,39 @@ async function discoverSpecification(specification, options) {
         adapterVersion,
         agentVersion,
         adapter.identity,
-        agent.identity
+        agent.identity,
+        specification.promptTimeoutMilliseconds
       );
       try {
-        await probeAcp(
+        const acpVersion = await probeAcp(
+          specification,
           definition,
           options.environment,
           options.defaultWorkspace,
           options.signal
         );
-        return new AvailableAgent(specification, definition);
+        const verifiedAdapterVersion = adapterVersion.length > 0 ? adapterVersion : acpVersion;
+        if (verifiedAdapterVersion.length === 0) {
+          throw new AgentProbeError(
+            "acp_incompatible",
+            "ACP adapter did not report a version"
+          );
+        }
+        return new AvailableAgent(
+          specification,
+          new LocalAgentDefinition(
+            specification.id,
+            specification.label,
+            adapter.path,
+            [],
+            { [specification.adapterEnvironmentVariable]: agent.path },
+            verifiedAdapterVersion,
+            agentVersion,
+            adapter.identity,
+            agent.identity,
+            specification.promptTimeoutMilliseconds
+          )
+        );
       } catch (error61) {
         if (options.signal.aborted) {
           options.signal.throwIfAborted();
@@ -24980,10 +25355,10 @@ async function claimPairing(options, defaultWorkspace, localAgents, installableA
   return decodeClaimResponse(value);
 }
 async function persistConnection(channelId, relayOrigin, daemonToken, defaultWorkspace) {
-  const connectionsDirectory = join7(readStateDirectory(), "connections");
+  const connectionsDirectory = join8(readStateDirectory(), "connections");
   await mkdir2(connectionsDirectory, { mode: 448, recursive: true });
-  const connectionPath = join7(connectionsDirectory, `${channelId}.json`);
-  const temporaryPath = join7(
+  const connectionPath = join8(connectionsDirectory, `${channelId}.json`);
+  const temporaryPath = join8(
     connectionsDirectory,
     `.${channelId}.${randomUUID()}.tmp`
   );
@@ -25030,7 +25405,7 @@ function decodeSavedConnection(value, expectedChannelId) {
   };
 }
 async function readSavedConnection(channelId) {
-  const connectionPath = join7(
+  const connectionPath = join8(
     readStateDirectory(),
     "connections",
     `${channelId}.json`
@@ -25085,7 +25460,7 @@ function buildPairedDaemon(connection, connectionPath, inventory) {
   );
   relayUrl.protocol = relayUrl.protocol === "https:" ? "wss:" : "ws:";
   relayUrl.searchParams.set("token", connection.daemonToken);
-  const auditDatabasePath = join7(
+  const auditDatabasePath = join8(
     readStateDirectory(),
     "audit",
     `${connection.channelId}.sqlite`
@@ -25144,7 +25519,7 @@ async function pairLocalMachine(arguments_, signal = new AbortController().signa
 }
 async function resumeLocalMachine(arguments_, signal = new AbortController().signal) {
   const channelId = parseChannelArgument(arguments_);
-  const connectionPath = join7(
+  const connectionPath = join8(
     readStateDirectory(),
     "connections",
     `${channelId}.json`
@@ -25767,7 +26142,7 @@ import { resolve as resolve4 } from "node:path";
 
 // src/agent-installation/fixed-agent-install-recipes.ts
 import { mkdir as mkdir3, mkdtemp as mkdtemp2, rm as rm2 } from "node:fs/promises";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 
 // src/agent-installation/verified-download.ts
 import { createHash } from "node:crypto";
@@ -25991,18 +26366,18 @@ var CodexInstallRecipe = class extends FixedAgentInstallRecipe {
   releaseChannel = "latest";
   install = async (options) => {
     this.assertSupportedPlatform();
-    const root = join8(options.stateDirectory, "agents", this.id);
-    const temporaryRoot = join8(options.stateDirectory, "temporary");
+    const root = join9(options.stateDirectory, "agents", this.id);
+    const temporaryRoot = join9(options.stateDirectory, "temporary");
     await Promise.all([
       mkdir3(root, { mode: 448, recursive: true }),
       mkdir3(temporaryRoot, { mode: 448, recursive: true })
     ]);
     const temporaryDirectory = await mkdtemp2(
-      join8(temporaryRoot, ".codex-install-")
+      join9(temporaryRoot, ".codex-install-")
     );
-    const installerPath = join8(temporaryDirectory, "install.sh");
-    const installDirectory = join8(root, "bin");
-    const codexHome = join8(root, "home");
+    const installerPath = join9(temporaryDirectory, "install.sh");
+    const installDirectory = join9(root, "bin");
+    const codexHome = join9(root, "home");
     try {
       await Promise.all([
         mkdir3(installDirectory, { mode: 448, recursive: true }),
@@ -26046,7 +26421,7 @@ var CodexInstallRecipe = class extends FixedAgentInstallRecipe {
         timeoutMilliseconds: AGENT_INSTALL_TIMEOUT_MILLISECONDS
       });
       return await this.requireInstalledExecutable(
-        join8(installDirectory, "codex")
+        join9(installDirectory, "codex")
       );
     } catch (error61) {
       if (options.signal.aborted) {
@@ -26070,17 +26445,17 @@ var ClaudeCodeInstallRecipe = class extends FixedAgentInstallRecipe {
   releaseChannel = "stable";
   install = async (options) => {
     this.assertSupportedPlatform();
-    const root = join8(options.stateDirectory, "agents", this.id);
-    const managedHome = join8(root, "home");
-    const temporaryRoot = join8(options.stateDirectory, "temporary");
+    const root = join9(options.stateDirectory, "agents", this.id);
+    const managedHome = join9(root, "home");
+    const temporaryRoot = join9(options.stateDirectory, "temporary");
     await Promise.all([
       mkdir3(managedHome, { mode: 448, recursive: true }),
       mkdir3(temporaryRoot, { mode: 448, recursive: true })
     ]);
     const temporaryDirectory = await mkdtemp2(
-      join8(temporaryRoot, ".claude-install-")
+      join9(temporaryRoot, ".claude-install-")
     );
-    const installerPath = join8(temporaryDirectory, "install.sh");
+    const installerPath = join9(temporaryDirectory, "install.sh");
     try {
       await options.report("downloading");
       const download = await downloadVerifiedFile({
@@ -26117,7 +26492,7 @@ var ClaudeCodeInstallRecipe = class extends FixedAgentInstallRecipe {
         timeoutMilliseconds: AGENT_INSTALL_TIMEOUT_MILLISECONDS
       });
       return await this.requireInstalledExecutable(
-        join8(managedHome, ".local", "bin", "claude")
+        join9(managedHome, ".local", "bin", "claude")
       );
     } catch (error61) {
       if (options.signal.aborted) {
@@ -26135,10 +26510,82 @@ var ClaudeCodeInstallRecipe = class extends FixedAgentInstallRecipe {
     }
   };
 };
+var PiInstallRecipe = class extends FixedAgentInstallRecipe {
+  #npmInstaller;
+  id = "pi";
+  label = "Pi";
+  releaseChannel = PI_AGENT_PACKAGE.version;
+  constructor(npmInstaller = new ManagedNpmPackageInstaller()) {
+    super();
+    this.#npmInstaller = npmInstaller;
+  }
+  install = async (options) => {
+    this.assertSupportedPlatform();
+    try {
+      await options.report("downloading");
+      await options.report("verifying");
+      await options.report("installing_agent");
+      const executable = await this.#npmInstaller.install(
+        join9(
+          options.stateDirectory,
+          "agents",
+          this.id,
+          PI_AGENT_PACKAGE.version
+        ),
+        PI_AGENT_PACKAGE,
+        options.environment,
+        options.signal
+      );
+      options.audit.record(
+        "agent_npm_package_verified",
+        options.requestId,
+        this.id,
+        {
+          integrity: PI_AGENT_PACKAGE.integrity,
+          package: PI_AGENT_PACKAGE.packageName,
+          version: PI_AGENT_PACKAGE.version
+        }
+      );
+      return executable;
+    } catch (error61) {
+      if (options.signal.aborted) {
+        options.signal.throwIfAborted();
+      }
+      if (error61 instanceof ManagedNpmPackageError) {
+        if (error61.code === "managed_package_verification_failed") {
+          throw new InstallationManagerError(
+            "agent_verification_failed",
+            "The managed Pi package did not match its pinned artifact",
+            { cause: error61 }
+          );
+        }
+        if (error61.code === "managed_package_publish_failed") {
+          throw new InstallationManagerError(
+            "agent_publish_failed",
+            "The managed Pi package could not be published",
+            { cause: error61 }
+          );
+        }
+        throw new InstallationManagerError(error61.code, error61.message, {
+          cause: error61
+        });
+      }
+      if (error61 instanceof InstallationManagerError) {
+        throw error61;
+      }
+      throw new InstallationManagerError(
+        "agent_install_failed",
+        "The fixed Pi installation recipe failed",
+        { cause: error61 }
+      );
+    }
+  };
+};
 function fixedAgentInstallRecipes() {
   return Object.freeze([
     new CodexInstallRecipe(),
-    new ClaudeCodeInstallRecipe()
+    new ClaudeCodeInstallRecipe(),
+    new PiInstallRecipe()
   ]);
 }
 
@@ -26268,6 +26715,7 @@ var FixedInstallationExecutor = class {
       if (agent === null) {
         agent = await recipe.install({
           audit: this.#audit,
+          environment: this.#environment,
           report,
           requestId,
           signal,
@@ -26349,6 +26797,7 @@ var FixedInstallationExecutor = class {
         if (!installedAgent && (requiresAgentReplacement(unavailable.code) || unavailable.code === "acp_incompatible")) {
           agent = await recipe.install({
             audit: this.#audit,
+            environment: this.#environment,
             report,
             requestId,
             signal,
@@ -26412,8 +26861,8 @@ import { homedir as homedir2 } from "node:os";
 import {
   basename as basename2,
   dirname as dirname4,
-  isAbsolute as isAbsolute2,
-  join as join9,
+  isAbsolute as isAbsolute3,
+  join as join10,
   normalize,
   relative as relative2
 } from "node:path";
@@ -26465,20 +26914,20 @@ var WorkspaceDirectoryService = class {
     if (id === "home") return homedir2();
     if (id.startsWith("path-")) {
       const path2 = decodePath(id, "path-");
-      if (isAbsolute2(path2)) return path2;
+      if (isAbsolute3(path2)) return path2;
     }
     throw new LocalAuthorizationError("The directory identifier is invalid");
   };
   resolvePath = async (requested, signal) => {
     signal.throwIfAborted();
-    if (!isAbsolute2(requested) || requested.includes("\0") || normalize(requested) !== requested)
+    if (!isAbsolute3(requested) || requested.includes("\0") || normalize(requested) !== requested)
       throw new LocalAuthorizationError("The local directory path is invalid");
     try {
       const target = await realpath4(requested);
       signal.throwIfAborted();
       const metadata = await stat4(target);
       signal.throwIfAborted();
-      if (!isAbsolute2(target) || normalize(target) !== target || !metadata.isDirectory())
+      if (!isAbsolute3(target) || normalize(target) !== target || !metadata.isDirectory())
         throw new LocalAuthorizationError(
           "The selected location is not a directory"
         );
@@ -26494,7 +26943,7 @@ var WorkspaceDirectoryService = class {
   };
   label = (path2) => {
     const suffix = relative2(homedir2(), path2);
-    return suffix === "" ? "~" : !isAbsolute2(suffix) && suffix !== ".." && !suffix.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) ? `~/${suffix.replaceAll("\\", "/")}` : path2;
+    return suffix === "" ? "~" : !isAbsolute3(suffix) && suffix !== ".." && !suffix.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) ? `~/${suffix.replaceAll("\\", "/")}` : path2;
   };
   identify = async (bindingId, requestedPath, signal) => {
     this.authorizeMachine(bindingId);
@@ -26522,7 +26971,7 @@ var WorkspaceDirectoryService = class {
           continue;
         }
         try {
-          const path2 = await this.resolvePath(join9(target, child.name), signal);
+          const path2 = await this.resolvePath(join10(target, child.name), signal);
           entries.push({ directoryId: encodePath(path2), name: child.name });
         } catch (cause) {
           signal.throwIfAborted();