nexus-agents 2.62.0 → 2.63.0

package/dist/{chunk-X5WDX7L3.js → chunk-4G7MSCIK.js}

@@ -68,7 +68,7 @@ import {
   clampTaskTtl,
   getAvailabilityCache,
   resolveFallback
-} from "./chunk-V7AFOKWC.js";
+} from "./chunk-FMFQJLMR.js";
 import {
   DEFAULTS
 } from "./chunk-H43PABG4.js";
@@ -53661,4 +53661,4 @@ export {
   detectBackend,
   createTaskTracker
 };
-//# sourceMappingURL=chunk-X5WDX7L3.js.map
+//# sourceMappingURL=chunk-4G7MSCIK.js.map

package/dist/{chunk-OJBW4II4.js → chunk-7C32M23X.js}

@@ -8,7 +8,7 @@ import {
   checkSqlite,
   defaultConfig,
   initDataDirectories
-} from "./chunk-V7AFOKWC.js";
+} from "./chunk-FMFQJLMR.js";
 import {
   BUILT_IN_EXPERTS
 } from "./chunk-GJVHRJO2.js";
@@ -1933,4 +1933,4 @@ export {
   setupCommand,
   setupCommandAsync
 };
-//# sourceMappingURL=chunk-OJBW4II4.js.map
+//# sourceMappingURL=chunk-7C32M23X.js.map

package/dist/{chunk-V7AFOKWC.js → chunk-FMFQJLMR.js}

@@ -38,7 +38,7 @@ import {
 } from "./chunk-CLYZ7FWP.js";
 
 // src/version.ts
-var VERSION = true ? "2.62.0" : "dev";
+var VERSION = true ? "2.63.0" : "dev";
 
 // src/config/schemas-core.ts
 import { z } from "zod";
@@ -2025,7 +2025,7 @@ async function runDoctorFix(result) {
   writeLine2("\u2500".repeat(40));
   let fixCount = 0;
   if (!result.dataDirectory.rootExists || result.dataDirectory.subdirectories.some((d) => !d.exists || !d.writable)) {
-    const { runSetup } = await import("./setup-command-FC67SJSP.js");
+    const { runSetup } = await import("./setup-command-QKAVRVLV.js");
     const setupResult = runSetup({
       skipMcp: true,
       skipRules: true,
@@ -2135,4 +2135,4 @@ export {
   startStdioServer,
   closeServer
 };
-//# sourceMappingURL=chunk-V7AFOKWC.js.map
+//# sourceMappingURL=chunk-FMFQJLMR.js.map

package/dist/cli.d.ts

@@ -109,6 +109,8 @@ interface ParsedCliArgs {
         portable?: boolean;
         gitignore?: boolean;
         mcpConfig?: boolean;
+        install?: boolean;
+        uninstall?: boolean;
     };
     positionals: string[];
 }

package/dist/cli.js

@@ -16,7 +16,7 @@ import "./chunk-6QU4DJYW.js";
 import {
   setupCommandAsync,
   verifyCommand
-} from "./chunk-OJBW4II4.js";
+} from "./chunk-7C32M23X.js";
 import "./chunk-QGZBCD2A.js";
 import {
   AuthHandler,
@@ -142,7 +142,7 @@ import {
   validateCommand,
   validateWorkflow,
   wrapInMarkdownFence
-} from "./chunk-X5WDX7L3.js";
+} from "./chunk-4G7MSCIK.js";
 import "./chunk-ED6VQWNG.js";
 import {
   resolveToken
@@ -201,7 +201,7 @@ import {
   loadConfig,
   runDoctor,
   validateNexusEnv
-} from "./chunk-V7AFOKWC.js";
+} from "./chunk-FMFQJLMR.js";
 import {
   DEFAULTS
 } from "./chunk-H43PABG4.js";
@@ -17668,6 +17668,15 @@ var PARSE_ARGS_CONFIG = {
     "mcp-config": {
       type: "boolean",
       default: false
+    },
+    // init --portable --install / --uninstall flags (#2311)
+    install: {
+      type: "boolean",
+      default: false
+    },
+    uninstall: {
+      type: "boolean",
+      default: false
     }
   },
   allowPositionals: true,
@@ -17726,27 +17735,27 @@ function isValidCommand(value) {
 }
 
 // src/cli-commands-handlers.ts
-import { existsSync as existsSync20 } from "fs";
+import { existsSync as existsSync22 } from "fs";
 
 // src/cli/init-portable.ts
 import {
-  existsSync as existsSync18,
-  mkdirSync as mkdirSync3,
+  existsSync as existsSync20,
+  mkdirSync as mkdirSync5,
   readdirSync as readdirSync2,
   statSync as statSync3,
   appendFileSync as appendFileSync2,
-  readFileSync as readFileSync11
+  readFileSync as readFileSync12
 } from "fs";
-import { resolve as resolve11, join as join14, isAbsolute as isAbsolute2 } from "path";
+import { resolve as resolve11, join as join16, isAbsolute as isAbsolute2 } from "path";
 
 // src/cli/mcp-config-emitter.ts
 import { existsSync as existsSync17, readFileSync as readFileSync10, writeFileSync as writeFileSync5, appendFileSync } from "fs";
 import { join as join13 } from "path";
 var MCP_CONFIG_FILENAME = ".mcp.json";
 var NEXUS_SERVER_KEY = "nexus-agents";
-function buildNexusServerEntry(dataDir) {
+function buildNexusServerEntry(dataDir, commandPath) {
   return {
-    command: "nexus-agents",
+    command: commandPath ?? "nexus-agents",
     args: ["--mode=server"],
     env: { NEXUS_DATA_DIR: dataDir }
   };
@@ -17821,7 +17830,7 @@ function emitMcpConfig(options) {
   const mcpConfigPath = join13(options.workspaceDir, MCP_CONFIG_FILENAME);
   const dryRun = options.dryRun === true;
   const force = options.force === true;
-  const desired = buildNexusServerEntry(options.dataDir);
+  const desired = buildNexusServerEntry(options.dataDir, options.commandPath);
   const loaded = loadExistingConfig(mcpConfigPath);
   if (!loaded.ok) return makeFailure(mcpConfigPath, loaded.error);
   const decision = decideEmission(loaded.value, desired, force);
@@ -17854,6 +17863,165 @@ function makeFailure(mcpConfigPath, error) {
   };
 }
 
+// src/cli/portable-installer.ts
+import { execFile } from "child_process";
+import { existsSync as existsSync19, mkdirSync as mkdirSync4, rmSync, writeFileSync as writeFileSync7 } from "fs";
+import { join as join15 } from "path";
+import { promisify } from "util";
+
+// src/cli/bin-shim.ts
+import { existsSync as existsSync18, readFileSync as readFileSync11, writeFileSync as writeFileSync6, chmodSync as chmodSync2, mkdirSync as mkdirSync3 } from "fs";
+import { join as join14 } from "path";
+var SHIM_BASENAME = "nexus-agents";
+var SHIM_MODE = 493;
+function buildShimContents(cliEntryPath) {
+  const lines = [
+    "#!/usr/bin/env node",
+    "// Generated by `nexus-agents init --portable --install` (#3a).",
+    "// Do not edit by hand \u2014 re-run `init --portable --install` to refresh.",
+    `import('${cliEntryPath}').catch((e) => { console.error(e); process.exit(1); });`,
+    ""
+  ];
+  return lines.join("\n");
+}
+function writeBinShim(options) {
+  const shimPath = join14(options.binDir, SHIM_BASENAME);
+  const desired = buildShimContents(options.cliEntryPath);
+  const dryRun = options.dryRun === true;
+  try {
+    if (existsSync18(shimPath)) {
+      const current = readFileSync11(shimPath, "utf-8");
+      if (current === desired) {
+        return { success: true, shimPath, written: false, alreadyMatched: true, error: null };
+      }
+    }
+    if (!dryRun) {
+      if (!existsSync18(options.binDir)) mkdirSync3(options.binDir, { recursive: true });
+      writeFileSync6(shimPath, desired, "utf-8");
+      chmodSync2(shimPath, SHIM_MODE);
+    }
+    return { success: true, shimPath, written: true, alreadyMatched: false, error: null };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return { success: false, shimPath, written: false, alreadyMatched: false, error: msg };
+  }
+}
+
+// src/cli/portable-installer.ts
+var execFileAsync = promisify(execFile);
+var CLI_SUBDIR = "cli";
+var BIN_SUBDIR = "bin";
+var CLI_ENTRY_RELATIVE = "node_modules/nexus-agents/dist/cli.js";
+var NPM_INSTALL_TIMEOUT_MS = 5 * 60 * 1e3;
+function resolveInstallVersion(override) {
+  const v = override ?? VERSION;
+  if (v === "dev" || v === "" || v.includes(" ")) {
+    return {
+      ok: false,
+      error: `cannot resolve install version: got '${v}'. Portable install requires a published nexus-agents version (build the CLI from a release).`
+    };
+  }
+  return { ok: true, value: v };
+}
+function writeInstallManifest(cliDir, version) {
+  const manifest = {
+    name: "nexus-agents-portable-shim",
+    private: true,
+    version: "0.0.0",
+    description: "Local install root for portable nexus-agents (generated; do not commit)",
+    dependencies: { "nexus-agents": version }
+  };
+  writeFileSync7(join15(cliDir, "package.json"), JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+}
+function isAlreadyInstalled(cliDir) {
+  return existsSync19(join15(cliDir, "node_modules", "nexus-agents", "package.json"));
+}
+async function spawnNpmInstall(cliDir) {
+  await execFileAsync("npm", ["install", "--no-audit", "--no-fund", "--silent"], {
+    cwd: cliDir,
+    timeout: NPM_INSTALL_TIMEOUT_MS
+  });
+}
+function cleanupOnFailure(cliDir) {
+  try {
+    rmSync(cliDir, { recursive: true, force: true });
+  } catch {
+  }
+}
+async function runNpmStep(ctx) {
+  try {
+    if (!existsSync19(ctx.cliDir)) mkdirSync4(ctx.cliDir, { recursive: true });
+    writeInstallManifest(ctx.cliDir, ctx.version);
+    await spawnNpmInstall(ctx.cliDir);
+    return void 0;
+  } catch (error) {
+    cleanupOnFailure(ctx.cliDir);
+    const msg = error instanceof Error ? error.message : String(error);
+    return { success: false, ...ctx, skipped: false, error: `npm install failed: ${msg}` };
+  }
+}
+async function installPortable(options) {
+  const cliDir = join15(options.dataDir, CLI_SUBDIR);
+  const binDir = join15(options.dataDir, BIN_SUBDIR);
+  const versionResolution = resolveInstallVersion(options.version);
+  if (!versionResolution.ok) {
+    return {
+      success: false,
+      version: "",
+      cliDir,
+      binDir,
+      skipped: false,
+      error: versionResolution.error
+    };
+  }
+  const ctx = { cliDir, binDir, version: versionResolution.value };
+  if (isAlreadyInstalled(cliDir) && options.force !== true) {
+    return { success: true, ...ctx, skipped: true, error: null };
+  }
+  if (options.dryRun === true) {
+    return { success: true, ...ctx, skipped: false, error: null };
+  }
+  const npmFailure = await runNpmStep(ctx);
+  if (npmFailure !== void 0) return npmFailure;
+  const shim = writeBinShim({ binDir, cliEntryPath: join15(cliDir, CLI_ENTRY_RELATIVE) });
+  if (!shim.success) {
+    cleanupOnFailure(cliDir);
+    return {
+      success: false,
+      ...ctx,
+      shim,
+      skipped: false,
+      error: `bin shim emission failed: ${shim.error ?? "unknown"}`
+    };
+  }
+  return { success: true, ...ctx, shim, skipped: false, error: null };
+}
+function uninstallPortable(options) {
+  const cliDir = join15(options.dataDir, CLI_SUBDIR);
+  const binDir = join15(options.dataDir, BIN_SUBDIR);
+  const removed = [];
+  const notPresent = [];
+  const dryRun = options.dryRun === true;
+  try {
+    for (const dir of [cliDir, binDir]) {
+      if (!existsSync19(dir)) {
+        notPresent.push(dir);
+        continue;
+      }
+      if (!dryRun) rmSync(dir, { recursive: true, force: true });
+      removed.push(dir);
+    }
+    return { success: true, removed, notPresent, error: null };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return { success: false, removed, notPresent, error: msg };
+  }
+}
+function findBinShim(dataDir) {
+  const shimPath = join15(dataDir, BIN_SUBDIR, "nexus-agents");
+  return existsSync19(shimPath) ? shimPath : void 0;
+}
+
 // src/cli/init-portable.ts
 var DEFAULT_PORTABLE_DIRNAME = ".nexus-agents";
 var RESTRICTED_SUBDIRS = /* @__PURE__ */ new Set(["auth"]);
@@ -17864,29 +18032,29 @@ function resolveTargetPath(rawPath) {
   return isAbsolute2(rawPath) ? rawPath : resolve11(process.cwd(), rawPath);
 }
 function isNonEmpty(dir) {
-  if (!existsSync18(dir)) return false;
+  if (!existsSync20(dir)) return false;
   const stat2 = statSync3(dir);
   if (!stat2.isDirectory()) return true;
   return readdirSync2(dir).length > 0;
 }
 function ensureDir(path23, dryRun, created, alreadyExisted, mode) {
-  if (existsSync18(path23)) {
+  if (existsSync20(path23)) {
     alreadyExisted.push(path23);
     return;
   }
   if (!dryRun) {
-    mkdirSync3(path23, { recursive: true, ...mode !== void 0 ? { mode } : {} });
+    mkdirSync5(path23, { recursive: true, ...mode !== void 0 ? { mode } : {} });
   }
   created.push(path23);
 }
 function maybeUpdateGitignore(workspaceDir, portableDirName, dryRun) {
-  const gitDir = join14(workspaceDir, ".git");
-  if (!existsSync18(gitDir)) return false;
-  const gitignorePath = join14(workspaceDir, ".gitignore");
+  const gitDir = join16(workspaceDir, ".git");
+  if (!existsSync20(gitDir)) return false;
+  const gitignorePath = join16(workspaceDir, ".gitignore");
   const entry = `${portableDirName}/`;
   let existing = "";
-  if (existsSync18(gitignorePath)) {
-    existing = readFileSync11(gitignorePath, "utf-8");
+  if (existsSync20(gitignorePath)) {
+    existing = readFileSync12(gitignorePath, "utf-8");
     if (existing.split("\n").some((l) => l.trim() === entry || l.trim() === portableDirName)) {
       return false;
     }
@@ -17899,18 +18067,18 @@ function maybeUpdateGitignore(workspaceDir, portableDirName, dryRun) {
   return true;
 }
 function inspectTarget(target) {
-  const exists = existsSync18(target);
+  const exists = existsSync20(target);
   if (!exists) return { exists: false, nonEmpty: false, isExistingNexusDir: false };
   const nonEmpty = isNonEmpty(target);
   const stat2 = statSync3(target);
-  const isExistingNexusDir = stat2.isDirectory() && existsSync18(join14(target, "audit"));
+  const isExistingNexusDir = stat2.isDirectory() && existsSync20(join16(target, "audit"));
   return { exists, nonEmpty, isExistingNexusDir };
 }
 function createDataLayout(target, dryRun, created, alreadyExisted) {
   ensureDir(target, dryRun, created, alreadyExisted);
   for (const subdir of DATA_SUBDIRECTORIES) {
     const mode = RESTRICTED_SUBDIRS.has(subdir) ? 448 : void 0;
-    ensureDir(join14(target, subdir), dryRun, created, alreadyExisted, mode);
+    ensureDir(join16(target, subdir), dryRun, created, alreadyExisted, mode);
   }
 }
 function makeResult(opts) {
@@ -17922,6 +18090,8 @@ function makeResult(opts) {
     skipped: opts.skipped ?? false,
     gitignoreUpdated: opts.gitignoreUpdated ?? false,
     ...opts.mcpConfig !== void 0 ? { mcpConfig: opts.mcpConfig } : {},
+    ...opts.install !== void 0 ? { install: opts.install } : {},
+    ...opts.uninstall !== void 0 ? { uninstall: opts.uninstall } : {},
     error: opts.error ?? null
   };
 }
@@ -17934,23 +18104,60 @@ function applyGitignoreOption(target, options, dryRun) {
 function applyMcpConfigOption(target, options, dryRun) {
   if (options.mcpConfig !== true) return void 0;
   const workspaceDir = resolve11(target, "..");
+  const shimPath = findBinShim(target);
   return emitMcpConfig({
     workspaceDir,
     dataDir: target,
+    ...shimPath !== void 0 && { commandPath: shimPath },
     force: options.force === true,
     dryRun
   });
 }
-function buildSuccessResult(base, flags, mcpConfig) {
-  if (mcpConfig === void 0) {
-    return makeResult({ ...base, ...flags, success: true });
+async function applyInstallOption(target, options, dryRun) {
+  if (options.install !== true) return void 0;
+  return installPortable({ dataDir: target, force: options.force === true, dryRun });
+}
+function buildSuccessResult(base, flags, extras) {
+  const installFailed = extras.install !== void 0 && !extras.install.success;
+  const mcpFailed = extras.mcpConfig !== void 0 && !extras.mcpConfig.success;
+  if (installFailed) {
+    return makeResult({
+      ...base,
+      ...flags,
+      success: false,
+      ...extras,
+      error: extras.install?.error ?? "install failed"
+    });
   }
-  if (mcpConfig.success) {
-    return makeResult({ ...base, ...flags, success: true, mcpConfig });
+  if (mcpFailed) {
+    return makeResult({
+      ...base,
+      ...flags,
+      success: false,
+      ...extras,
+      error: extras.mcpConfig?.error ?? "mcp-config emission failed"
+    });
   }
-  return makeResult({ ...base, ...flags, success: false, mcpConfig, error: mcpConfig.error });
+  return makeResult({ ...base, ...flags, success: true, ...extras });
+}
+async function collectExtras(target, options, dryRun) {
+  const extras = {};
+  const install = await applyInstallOption(target, options, dryRun);
+  if (install !== void 0) extras.install = install;
+  const mcpConfig = applyMcpConfigOption(target, options, dryRun);
+  if (mcpConfig !== void 0) extras.mcpConfig = mcpConfig;
+  return extras;
+}
+function handleUninstall(target, base, dryRun) {
+  const uninstall = uninstallPortable({ dataDir: target, dryRun });
+  return makeResult({
+    ...base,
+    success: uninstall.success,
+    uninstall,
+    error: uninstall.error
+  });
 }
-function initPortable(options = {}) {
+async function initPortable(options = {}) {
   const created = [];
   const alreadyExisted = [];
   const dryRun = options.dryRun === true;
@@ -17958,14 +18165,12 @@ function initPortable(options = {}) {
   const target = resolveTargetPath(options.path);
   const base = { absolutePath: target, created, alreadyExisted };
   try {
+    if (options.uninstall === true) return handleUninstall(target, base, dryRun);
     const state = inspectTarget(target);
     if (state.isExistingNexusDir && !force) {
       createDataLayout(target, dryRun, created, alreadyExisted);
-      return buildSuccessResult(
-        base,
-        { skipped: true },
-        applyMcpConfigOption(target, options, dryRun)
-      );
+      const extras2 = await collectExtras(target, options, dryRun);
+      return buildSuccessResult(base, { skipped: true }, extras2);
     }
     if (state.nonEmpty && !state.isExistingNexusDir && !force) {
       const error = `target ${target} already exists and is not empty; pass --force to use anyway`;
@@ -17973,11 +18178,8 @@ function initPortable(options = {}) {
     }
     createDataLayout(target, dryRun, created, alreadyExisted);
     const gitignoreUpdated = applyGitignoreOption(target, options, dryRun);
-    return buildSuccessResult(
-      base,
-      { gitignoreUpdated },
-      applyMcpConfigOption(target, options, dryRun)
-    );
+    const extras = await collectExtras(target, options, dryRun);
+    return buildSuccessResult(base, { gitignoreUpdated }, extras);
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
     return makeResult({ ...base, success: false, error: msg });
@@ -18004,11 +18206,34 @@ function renderMcpConfigCaveat(mcpConfig) {
     "run `nexus-agents init --portable --mcp-config` themselves."
   ];
 }
+function renderInstallLines(install) {
+  if (install.skipped) return [`\u2713 Portable install already present (${install.version})`];
+  return [
+    `\u2713 Installed nexus-agents@${install.version} \u2192 ${install.cliDir}`,
+    `\u2713 Wrote bin shim \u2192 ${install.shim?.shimPath ?? install.binDir + "/nexus-agents"}`
+  ];
+}
+function renderUninstallLines(uninstall) {
+  const lines = [];
+  if (uninstall.removed.length === 0 && uninstall.notPresent.length > 0) {
+    lines.push("Nothing to uninstall \u2014 cli/ and bin/ were not present.");
+  }
+  for (const r of uninstall.removed) lines.push(`\u2713 Removed: ${r}`);
+  if (uninstall.removed.length > 0) {
+    lines.push("");
+    lines.push("Note: data subdirs (memory, audit, voting, sessions, \u2026) preserved.");
+    lines.push("To purge data too, remove the parent dir manually.");
+  }
+  return lines;
+}
 function formatInitPortableMessage(result, dryRun) {
   if (!result.success) {
     return `init --portable failed: ${result.error ?? "unknown error"}
 `;
   }
+  if (result.uninstall !== void 0) {
+    return renderUninstallLines(result.uninstall).join("\n") + "\n";
+  }
   if (dryRun) {
     const lines2 = [
       `(dry-run) would create ${String(result.created.length)} entries under:`,
@@ -18021,6 +18246,7 @@ function formatInitPortableMessage(result, dryRun) {
     result.skipped ? `\u2713 Already initialized: ${result.absolutePath}` : `\u2713 Created: ${result.absolutePath}`
   );
   if (result.gitignoreUpdated) lines.push(`\u2713 Added entry to .gitignore`);
+  if (result.install !== void 0) lines.push(...renderInstallLines(result.install));
   if (result.mcpConfig !== void 0) lines.push(...renderMcpConfigLines(result.mcpConfig));
   lines.push("");
   lines.push("Activate by exporting:");
@@ -20843,8 +21069,8 @@ function printFirstRunHint() {
   const isTTY = process.stderr.isTTY;
   if (!isTTY) return;
   const dataDir = getNexusDataDir();
-  const hasConfig = existsSync20("./nexus-agents.yaml") || existsSync20("./nexus-agents.yml");
-  if (existsSync20(dataDir) || hasConfig) return;
+  const hasConfig = existsSync22("./nexus-agents.yaml") || existsSync22("./nexus-agents.yml");
+  if (existsSync22(dataDir) || hasConfig) return;
   process.stderr.write(
     "\n\x1B[36mnexus-agents\x1B[0m: First time? Run \x1B[1mnexus-agents setup\x1B[0m to configure.\n\n"
   );
@@ -21010,20 +21236,29 @@ async function handleDoctorCommand(args) {
   }
   process.exit(exitCode === 0 ? EXIT_CODES.SUCCESS : EXIT_CODES.SERVER_START_FAILED);
 }
-function handleInitCommand(args) {
+function validateInitFlags(args) {
   if (args.options.portable !== true) {
     process.stderr.write(
-      "Usage: nexus-agents init --portable [path] [--force] [--dry-run] [--gitignore]\nBootstraps a workspace-local nexus-agents data directory.\n"
+      "Usage: nexus-agents init --portable [path] [--force] [--dry-run]\n                            [--gitignore] [--mcp-config]\n                            [--install | --uninstall]\nBootstraps a workspace-local nexus-agents data directory.\n"
     );
     process.exit(EXIT_CODES.INVALID_ARGS);
   }
+  if (args.options.install === true && args.options.uninstall === true) {
+    process.stderr.write("Error: --install and --uninstall are mutually exclusive.\n");
+    process.exit(EXIT_CODES.INVALID_ARGS);
+  }
+}
+async function handleInitCommand(args) {
+  validateInitFlags(args);
   const targetPath = args.positionals[1];
-  const result = initPortable({
+  const result = await initPortable({
     ...targetPath !== void 0 && targetPath !== "" ? { path: targetPath } : {},
     force: args.options.force,
     dryRun: args.options.dryRun,
     gitignore: args.options.gitignore ?? false,
-    mcpConfig: args.options.mcpConfig ?? false
+    mcpConfig: args.options.mcpConfig ?? false,
+    install: args.options.install ?? false,
+    uninstall: args.options.uninstall ?? false
   });
   process.stdout.write(formatInitPortableMessage(result, args.options.dryRun));
   process.exit(result.success ? EXIT_CODES.SUCCESS : EXIT_CODES.SERVER_START_FAILED);
@@ -22501,7 +22736,7 @@ function handleStatusCommand2(args) {
 
 // src/cli/scenario-command.ts
 import { readdir as readdir4 } from "fs/promises";
-import { join as join16, resolve as resolve14 } from "path";
+import { join as join18, resolve as resolve14 } from "path";
 
 // src/testing/e2e/scenario-runner.ts
 import { readFile as readFile7 } from "fs/promises";
@@ -22871,7 +23106,7 @@ async function handleRun(args) {
     process.exit(EXIT_CODES.SERVER_START_FAILED);
   }
   const runner = createScenarioRunner();
-  const fixturePath = join16(FIXTURES_DIR, `${name}${SCENARIO_SUFFIX}`);
+  const fixturePath = join18(FIXTURES_DIR, `${name}${SCENARIO_SUFFIX}`);
   try {
     const fixture = await runner.loadFixture(fixturePath);
     const result = await runner.run(fixture);
@@ -23134,8 +23369,6 @@ var SYNC_COMMAND_HANDLERS = {
   status: handleStatusCommand2,
   // Issue #1023: Warm-Up Command
   "warm-up": handleWarmUpCommand,
-  // #2305: Init Portable Command
-  init: handleInitCommand,
   "e2e-eval": handleE2EEvalCommand,
   "routing-ab": handleRoutingABCommand,
   "memory-eval": handleMemoryEvalCommand,
@@ -23175,6 +23408,8 @@ var ASYNC_COMMAND_HANDLERS = {
   hooks: handleHooksCommand,
   setup: handleSetupCommandAsync,
   // Uses async for interactive wizard support (Issue #425)
+  // #2305 / #2308 / #2311: Init Portable Command (async because --install spawns npm)
+  init: handleInitCommand,
   demo: handleDemoCommand,
   // Made async for live CLI execution
   // Issue #526: Newly wired async commands
@@ -23590,7 +23825,9 @@ function buildInitOptions(values) {
   return {
     portable: values.portable,
     gitignore: values.gitignore,
-    mcpConfig: values["mcp-config"]
+    mcpConfig: values["mcp-config"],
+    install: values.install,
+    uninstall: values.uninstall
   };
 }
 function parseCliArgs(args = process.argv.slice(2)) {