@mutagent/cli 0.1.197 → 0.1.199

package/dist/bin/cli.js

@@ -728,8 +728,8 @@ var init_sdk_client = __esm(() => {
 // src/bin/cli.ts
 import { Command as Command12 } from "commander";
 import chalk18 from "chalk";
-import { readFileSync as readFileSync8, existsSync as existsSync9 } from "fs";
-import { join as join11, dirname as dirname3 } from "path";
+import { readFileSync as readFileSync9 } from "fs";
+import { join as join12, dirname as dirname3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/commands/auth.ts
@@ -737,8 +737,8 @@ init_config();
 init_sdk_client();
 import { Command } from "commander";
 import chalk4 from "chalk";
-import { existsSync as existsSync3 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { join as join6 } from "path";
 
 // src/lib/output.ts
 import chalk from "chalk";
@@ -937,54 +937,499 @@ init_errors();
 
 // src/commands/onboarding.ts
 import chalk2 from "chalk";
-async function runPostOnboarding() {
-  const inquirer = (await import("inquirer")).default;
-  console.log("");
-  console.log(chalk2.bold.cyan("  You are authenticated. What would you like to do next?"));
-  console.log("");
-  const { path: selectedPath } = await inquirer.prompt([{
-    type: "list",
-    name: "path",
-    message: "Choose your path:",
-    choices: [
-      {
-        name: `${chalk2.green("A")} Initialize this project — create .mutagentrc.json + install the CLI skill`,
-        value: "init"
-      },
-      {
-        name: `${chalk2.green("B")} Install a lifecycle tool — helix / diagnostics / evaluator`,
-        value: "install"
+
+// src/lib/rc-config.ts
+init_config();
+import { join as join4 } from "path";
+import { writeFileSync as writeFileSync2 } from "fs";
+
+// src/lib/framework-detection.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { execSync } from "child_process";
+import { join as join3 } from "path";
+var FRAMEWORK_DETECTION_MAP = {
+  "@mastra/core": {
+    name: "mastra",
+    displayName: "Mastra",
+    npmPackage: "@mastra/core"
+  },
+  "@langchain/langgraph": {
+    name: "langgraph",
+    displayName: "LangGraph",
+    npmPackage: "@langchain/langgraph",
+    mutagentPackage: "@mutagent/langgraph"
+  },
+  langchain: {
+    name: "langchain",
+    displayName: "LangChain",
+    npmPackage: "langchain",
+    mutagentPackage: "@mutagent/langchain"
+  },
+  "@langchain/core": {
+    name: "langchain",
+    displayName: "LangChain",
+    npmPackage: "@langchain/core",
+    mutagentPackage: "@mutagent/langchain"
+  },
+  "@ai-sdk/core": {
+    name: "vercel-ai",
+    displayName: "Vercel AI SDK",
+    npmPackage: "@ai-sdk/core",
+    mutagentPackage: "@mutagent/vercel-ai"
+  },
+  ai: {
+    name: "vercel-ai",
+    displayName: "Vercel AI SDK",
+    npmPackage: "ai",
+    mutagentPackage: "@mutagent/vercel-ai"
+  },
+  "@google/genai": {
+    name: "generic",
+    displayName: "Google GenAI",
+    npmPackage: "@google/genai"
+  },
+  openai: {
+    name: "openai",
+    displayName: "OpenAI SDK",
+    npmPackage: "openai",
+    mutagentPackage: "@mutagent/openai"
+  }
+};
+function detectPackageManager(cwd = process.cwd()) {
+  if (existsSync3(join3(cwd, "bun.lockb")) || existsSync3(join3(cwd, "bun.lock"))) {
+    return "bun";
+  }
+  if (existsSync3(join3(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (existsSync3(join3(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (existsSync3(join3(cwd, "package-lock.json"))) {
+    return "npm";
+  }
+  try {
+    execSync("bun --version", { stdio: "ignore" });
+    return "bun";
+  } catch {
+    return "npm";
+  }
+}
+function getInstallCommand(pm, packages) {
+  const pkgList = packages.join(" ");
+  const commands = {
+    bun: `bun add ${pkgList}`,
+    npm: `npm install ${pkgList}`,
+    yarn: `yarn add ${pkgList}`,
+    pnpm: `pnpm add ${pkgList}`
+  };
+  return commands[pm];
+}
+function detectFrameworkFromPackageJson(cwd = process.cwd()) {
+  const pkgPath = join3(cwd, "package.json");
+  if (!existsSync3(pkgPath)) {
+    return null;
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+  } catch {
+    return null;
+  }
+  const allDeps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  };
+  for (const [depName, framework] of Object.entries(FRAMEWORK_DETECTION_MAP)) {
+    if (depName in allDeps) {
+      return framework;
+    }
+  }
+  return null;
+}
+function hasRcConfig(cwd = process.cwd()) {
+  return existsSync3(join3(cwd, ".mutagentrc.json"));
+}
+
+// src/lib/rc-config.ts
+function writeRcConfig(config, cwd = process.cwd()) {
+  const rcPath = join4(cwd, ".mutagentrc.json");
+  writeFileSync2(rcPath, JSON.stringify(config, null, 2) + `
+`);
+}
+function scaffoldRcConfig(cwd = process.cwd(), deps = {}) {
+  const load = deps.loadConfig ?? loadConfig;
+  const hasRc = deps.hasRcConfig ?? hasRcConfig;
+  const write = deps.writeRcConfig ?? writeRcConfig;
+  const cfg = load();
+  const rcConfig = {
+    endpoint: cfg.endpoint ?? "https://api.mutagent.io",
+    ...cfg.defaultWorkspace ? { defaultWorkspace: cfg.defaultWorkspace } : {},
+    ...cfg.defaultOrganization ? { defaultOrganization: cfg.defaultOrganization } : {}
+  };
+  if (hasRc(cwd)) {
+    return { created: false, alreadyPresent: true, config: rcConfig };
+  }
+  write(rcConfig, cwd);
+  return { created: true, alreadyPresent: false, config: rcConfig };
+}
+
+// src/lib/installer.ts
+init_errors();
+init_config();
+import { spawn as spawn2 } from "child_process";
+
+// src/lib/installer-helix.ts
+init_errors();
+init_config();
+import { spawn } from "child_process";
+import { createHash } from "crypto";
+import { homedir as homedir2 } from "os";
+import { join as join5 } from "path";
+import {
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync4,
+  renameSync,
+  rmSync,
+  writeFileSync as writeFileSync3
+} from "fs";
+async function installHelix(opts, deps = {}) {
+  const auth = (deps.resolveAuth ?? defaultResolveAuth)();
+  const fetchImpl = deps.fetchImpl ?? globalThis.fetch;
+  const descriptor = await fetchDescriptor(fetchImpl, auth, opts.version);
+  const baseDir = deps.homeDir ?? join5(homedir2(), ".mutagent", "helix");
+  const versionDir = join5(baseDir, descriptor.version);
+  mkdirSync2(versionDir, { recursive: true });
+  const tgzPath = join5(versionDir, `helix-plugin-${descriptor.version}.tgz`);
+  const tmpPath = `${tgzPath}.${String(process.pid)}.${String(Date.now())}.part`;
+  const download = deps.download ?? defaultDownload;
+  await download(descriptor.url, tmpPath);
+  const sha256 = deps.sha256 ?? defaultSha256;
+  const actual = (await sha256(tmpPath)).toLowerCase();
+  const expected = descriptor.sha256.toLowerCase();
+  if (actual !== expected) {
+    safeRm(tmpPath);
+    throw new MutagentError("INTEGRITY_ERROR", `Downloaded helix plugin failed sha256 verification (expected ${expected.slice(0, 12)}…, got ${actual.slice(0, 12)}…).`, "The download may be corrupt or tampered with. Retry: mutagent install helix");
+  }
+  renameSync(tmpPath, tgzPath);
+  const extract = deps.extract ?? defaultExtract;
+  await extract(tgzPath, versionDir);
+  const locateInitBin = deps.locateInitBin ?? defaultLocateInitBin;
+  const binPath = await locateInitBin(versionDir);
+  const initArgs = ["init", "--harness", opts.harness];
+  if (opts.global)
+    initArgs.push("--global");
+  const runInit = deps.runInit ?? defaultRunInit;
+  const code = await runInit(binPath, initArgs, process.cwd());
+  if (code !== 0) {
+    throw new MutagentError("INSTALL_FAILED", `helix plugin init exited with code ${String(code)}.`, "Re-run: mutagent install helix — or run the plugin init manually and report the error.");
+  }
+  await postTelemetry(fetchImpl, auth, {
+    pkg: "helix",
+    version: descriptor.version,
+    harness: opts.harness,
+    cliVersion: deps.cliVersion ?? readCliVersion()
+  });
+  return { version: descriptor.version };
+}
+async function fetchDescriptor(fetchImpl, auth, version) {
+  if (!auth.apiKey) {
+    throw new MutagentError("AUTH_REQUIRED", "Authentication required to install helix.", "Run: mutagent login");
+  }
+  const url = `${auth.apiBase}/api/helix/plugin/download?version=${encodeURIComponent(version)}`;
+  let res;
+  try {
+    res = await fetchImpl(url, {
+      method: "GET",
+      headers: { "x-api-key": auth.apiKey, ...auth.headers }
+    });
+  } catch {
+    throw new MutagentError("SERVER_UNAVAILABLE", "Could not reach the MutagenT plugin broker.", "Check your network connection or verify the endpoint with: mutagent config show");
+  }
+  if (res.status === 401) {
+    throw new MutagentError("AUTH_REQUIRED", "The plugin broker rejected your credentials.", "Re-authenticate: mutagent login");
+  }
+  if (!res.ok) {
+    const detail = await readErrorMessage(res);
+    throw new MutagentError("INSTALL_FAILED", `Plugin broker returned ${String(res.status)}.${detail ? ` ${detail}` : ""}`, "Verify the requested version exists, then retry: mutagent install helix");
+  }
+  const raw = await res.json();
+  if (!isBrokerResponse(raw)) {
+    throw new MutagentError("INSTALL_FAILED", "Plugin broker returned a malformed response (missing version/sha256/url).", "Retry: mutagent install helix — if it persists, report it.");
+  }
+  return raw;
+}
+async function postTelemetry(fetchImpl, auth, event) {
+  if (!auth.apiKey)
+    return;
+  try {
+    await fetchImpl(`${auth.apiBase}/api/helix/installs`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": auth.apiKey,
+        ...auth.headers
       },
-      {
-        name: `${chalk2.green("C")} Exit — explore the CLI on your own`,
-        value: "exit"
+      body: JSON.stringify(event)
+    });
+  } catch {}
+}
+function defaultResolveAuth() {
+  const apiKey = getApiKey();
+  const config = loadConfig();
+  const apiBase = config.endpoint ?? "https://api.mutagent.io";
+  const headers = {};
+  if (config.defaultWorkspace)
+    headers["x-workspace-id"] = config.defaultWorkspace;
+  if (config.defaultOrganization)
+    headers["x-organization-id"] = config.defaultOrganization;
+  return { apiBase, apiKey, headers };
+}
+async function defaultDownload(url, destPath) {
+  let res;
+  try {
+    res = await globalThis.fetch(url);
+  } catch {
+    throw new MutagentError("SERVER_UNAVAILABLE", "Failed to download the helix plugin from storage.", "Check your network connection and retry: mutagent install helix");
+  }
+  if (!res.ok) {
+    throw new MutagentError("INSTALL_FAILED", `Plugin download failed with status ${String(res.status)}.`, "The signed URL may have expired — retry: mutagent install helix");
+  }
+  const bytes = Buffer.from(await res.arrayBuffer());
+  writeFileSync3(destPath, bytes);
+}
+async function defaultSha256(filePath) {
+  return Promise.resolve(createHash("sha256").update(readFileSync4(filePath)).digest("hex"));
+}
+function defaultExtract(tgzPath, destDir) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("tar", ["-xzf", tgzPath, "-C", destDir], {
+      stdio: ["ignore", "ignore", "pipe"]
+    });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf-8");
+    });
+    child.on("error", (err) => {
+      reject(new MutagentError("INSTALL_FAILED", `Failed to extract the helix plugin: ${err.message}`, 'Ensure "tar" is installed and available on your PATH.'));
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new MutagentError("INSTALL_FAILED", `Extracting the helix plugin failed (tar exit ${String(code ?? 1)}).${stderr ? ` ${stderr.trim().slice(0, 200)}` : ""}`, "The downloaded archive may be corrupt — retry: mutagent install helix"));
       }
-    ]
+    });
+  });
+}
+function defaultLocateInitBin(extractedDir) {
+  const pkgDir = existsSync4(join5(extractedDir, "package", "package.json")) ? join5(extractedDir, "package") : extractedDir;
+  const pkgJsonPath = join5(pkgDir, "package.json");
+  if (!existsSync4(pkgJsonPath)) {
+    return Promise.reject(new MutagentError("INSTALL_FAILED", "Could not find package.json in the extracted helix plugin.", "The archive layout is unexpected — retry or report: mutagent install helix"));
+  }
+  const raw = JSON.parse(readFileSync4(pkgJsonPath, "utf-8"));
+  const binRel = resolveBinField(raw);
+  if (!binRel) {
+    return Promise.reject(new MutagentError("INSTALL_FAILED", "The helix plugin package.json declares no runnable bin.", "The plugin package is malformed — report: mutagent install helix"));
+  }
+  const binPath = join5(pkgDir, binRel);
+  if (!existsSync4(binPath)) {
+    return Promise.reject(new MutagentError("INSTALL_FAILED", `The helix plugin bin was not found at ${binRel}.`, "The plugin package is incomplete — report: mutagent install helix"));
+  }
+  return Promise.resolve(binPath);
+}
+function defaultRunInit(binPath, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("node", [binPath, ...args], { cwd, stdio: "inherit" });
+    child.on("error", (err) => {
+      reject(new MutagentError("INSTALL_FAILED", `Failed to run the helix plugin init: ${err.message}`, 'Ensure "node" is installed and available on your PATH.'));
+    });
+    child.on("close", (code) => {
+      resolve(code ?? 1);
+    });
+  });
+}
+function resolveBinField(pkg) {
+  if (!pkg || typeof pkg !== "object")
+    return;
+  const bin = pkg.bin;
+  if (typeof bin === "string")
+    return bin;
+  if (bin && typeof bin === "object") {
+    const entries = bin;
+    const preferred = entries["mutagent-helix"];
+    if (typeof preferred === "string")
+      return preferred;
+    for (const value of Object.values(entries)) {
+      if (typeof value === "string")
+        return value;
+    }
+  }
+  return;
+}
+function isBrokerResponse(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const v = value;
+  return typeof v.version === "string" && typeof v.sha256 === "string" && typeof v.url === "string";
+}
+async function readErrorMessage(res) {
+  try {
+    const body = await res.json();
+    if (body && typeof body === "object") {
+      const b = body;
+      if (typeof b.message === "string")
+        return b.message;
+      if (typeof b.error === "string")
+        return b.error;
+    }
+  } catch {}
+  return;
+}
+function readCliVersion() {
+  if (process.env.CLI_VERSION)
+    return process.env.CLI_VERSION;
+  return "unknown";
+}
+function safeRm(path) {
+  try {
+    rmSync(path, { force: true });
+  } catch {}
+}
+
+// src/lib/installer.ts
+var VALID_PACKAGES = ["helix", "diagnostics", "evaluator"];
+var VALID_HARNESSES = ["claude-code", "codex", "omp"];
+var VERSION_MATRIX = {
+  helix: "latest",
+  diagnostics: "latest",
+  evaluator: "latest"
+};
+var NPM_PACKAGES = {
+  diagnostics: "@mutagent/diagnostics",
+  evaluator: "@mutagent/evaluator"
+};
+var defaultRunner = (cmd, args) => new Promise((resolve, reject) => {
+  const child = spawn2(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+  let stdout = "";
+  let stderr = "";
+  child.stdout.on("data", (chunk) => {
+    stdout += chunk.toString("utf-8");
+  });
+  child.stderr.on("data", (chunk) => {
+    stderr += chunk.toString("utf-8");
+  });
+  child.on("error", (err) => {
+    reject(new MutagentError("INSTALL_FAILED", `Failed to run ${cmd}: ${err.message}`, `Ensure "${cmd}" is installed and available on your PATH.`));
+  });
+  child.on("close", (code) => {
+    resolve({ code: code ?? 1, stdout, stderr });
+  });
+});
+function isValidPackage(pkg) {
+  return VALID_PACKAGES.includes(pkg);
+}
+function isValidHarness(harness) {
+  return VALID_HARNESSES.includes(harness);
+}
+async function installPackage(pkg, opts, deps = {}) {
+  const isAuthed = deps.isAuthed ?? hasCredentials;
+  if (!isAuthed()) {
+    throw new MutagentError("AUTH_REQUIRED", `Authentication required to install ${pkg}.`, "Run: mutagent login");
+  }
+  if (!isValidPackage(pkg)) {
+    throw new MutagentError("INVALID_ARGUMENTS", `Unknown package "${pkg}". Valid: ${VALID_PACKAGES.join(", ")}`, "Run: mutagent install --help");
+  }
+  if (!isValidHarness(opts.harness)) {
+    throw new MutagentError("INVALID_ARGUMENTS", `Unknown harness "${opts.harness}". Valid: ${VALID_HARNESSES.join(", ")}`, "Run: mutagent install --help");
+  }
+  const version = opts.version ?? VERSION_MATRIX[pkg];
+  if (pkg === "helix") {
+    const { version: resolved } = await installHelix({ harness: opts.harness, global: opts.global, version }, deps.helix ?? {});
+    return {
+      package: pkg,
+      version: resolved,
+      harness: opts.harness,
+      global: opts.global
+    };
+  }
+  const npmPackage = NPM_PACKAGES[pkg];
+  const args = ["install", "-g", `${npmPackage}@${version}`];
+  const runner = deps.runner ?? defaultRunner;
+  const result = await runner("npm", args);
+  if (result.code !== 0) {
+    const detail = result.stderr.trim();
+    throw new MutagentError("INSTALL_FAILED", `npm failed to install ${npmPackage}@${version} (exit ${String(result.code)}).${detail ? ` ${detail.slice(0, 200)}` : ""}`, "Verify the package and version exist and that you have permission for a global npm install.");
+  }
+  return {
+    package: pkg,
+    version,
+    harness: opts.harness,
+    global: opts.global,
+    command: `npm ${args.join(" ")}`
+  };
+}
+
+// src/commands/onboarding.ts
+init_errors();
+var ONBOARDING_CHOICES = [
+  { name: "1) Install Helix — set up the ADL lifecycle conductor here", value: "helix" },
+  { name: "2) Exit — explore the CLI on your own", value: "exit" }
+];
+async function defaultSelectAction(choices) {
+  const inquirer = (await import("inquirer")).default;
+  const { action } = await inquirer.prompt([{
+    type: "list",
+    name: "action",
+    message: "What would you like to do next?",
+    choices,
+    default: "helix"
   }]);
+  return action;
+}
+async function runPostOnboarding(deps = {}) {
+  const cwd = deps.cwd ?? process.cwd();
+  const scaffold = deps.scaffoldRcConfig ?? scaffoldRcConfig;
+  const select = deps.selectAction ?? defaultSelectAction;
+  const install = deps.installPackage ?? installPackage;
   console.log("");
-  if (selectedPath === "init") {
-    console.log(chalk2.bold("  Project setup:"));
-    console.log("");
-    console.log(`    1. ${chalk2.green("mutagent init")}`);
-    console.log("       Scaffold .mutagentrc.json and select your workspace");
-    console.log("");
-    console.log(`    2. ${chalk2.green("mutagent skills install")}`);
-    console.log("       Install the MutagenT CLI skill for AI coding agents");
-    console.log("");
-    console.log(`    3. ${chalk2.green("mutagent providers list")}`);
-    console.log("       Confirm an LLM provider is configured");
-    console.log("");
-  } else if (selectedPath === "install") {
-    console.log(chalk2.bold("  Install a lifecycle tool:"));
-    console.log("");
-    console.log(`    ${chalk2.green("mutagent install diagnostics")}   ${chalk2.dim("Root-cause analysis from your traces")}`);
-    console.log(`    ${chalk2.green("mutagent install evaluator")}     ${chalk2.dim("Build trustworthy eval suites")}`);
-    console.log(`    ${chalk2.green("mutagent install helix")}         ${chalk2.dim("The ADL lifecycle conductor")}`);
-    console.log("");
-    console.log(chalk2.dim("  All installs are login-gated. Run `mutagent install --help` for flags."));
+  console.log(chalk2.bold.cyan("  You are authenticated."));
+  console.log("");
+  const rc = scaffold(cwd);
+  if (rc.alreadyPresent) {
+    console.log(`  ${chalk2.green("✓")} .mutagentrc.json already present`);
+  } else {
+    console.log(`  ${chalk2.green("✓")} Created .mutagentrc.json`);
+  }
+  console.log("");
+  const action = await select(ONBOARDING_CHOICES);
+  console.log("");
+  if (action === "helix") {
+    console.log(chalk2.bold("  Installing Helix…"));
+    console.log(chalk2.dim("  Downloading + verifying the plugin, then writing .claude/ + .codex/"));
     console.log("");
+    try {
+      await install("helix", { harness: "claude-code", global: true });
+      console.log("");
+      console.log(`  ${chalk2.green("✓")} Helix ready — run ${chalk2.cyan("*help")} inside your agent`);
+      console.log("");
+    } catch (error) {
+      console.log("");
+      if (error instanceof MutagentError) {
+        console.error(`  ${chalk2.red("✗")} Helix install failed: ${error.message}`);
+        if (error.suggestion)
+          console.error(`  ${chalk2.yellow("→")} ${error.suggestion}`);
+      } else {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`  ${chalk2.red("✗")} Helix install failed: ${message}`);
+      }
+      console.error("");
+      process.exitCode = 1;
+    }
   } else {
-    console.log(chalk2.dim("  You can run `mutagent --help` anytime to see available commands."));
+    console.log(chalk2.dim(`  Run ${chalk2.cyan("mutagent --help")} to explore the CLI.`));
     console.log(chalk2.dim('  Hit a snag? Send feedback: mutagent feedback send "what happened"'));
     console.log("");
   }
@@ -1418,7 +1863,7 @@ Examples:
     }
     const isValid = await validateApiKey(apiKey, endpoint);
     const cwd = process.cwd();
-    const hasOnboarding = existsSync3(join3(cwd, ".mutagentrc.json"));
+    const hasOnboarding = existsSync5(join6(cwd, ".mutagentrc.json"));
     if (isJson) {
       const statusResult = {
         authenticated: isValid,
@@ -2322,125 +2767,8 @@ init_config();
 import { Command as Command6 } from "commander";
 import inquirer2 from "inquirer";
 import chalk12 from "chalk";
-import { existsSync as existsSync5, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
 import { execSync as execSync2 } from "child_process";
-import { join as join5 } from "path";
 init_errors();
-
-// src/lib/framework-detection.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-import { execSync } from "child_process";
-import { join as join4 } from "path";
-var FRAMEWORK_DETECTION_MAP = {
-  "@mastra/core": {
-    name: "mastra",
-    displayName: "Mastra",
-    npmPackage: "@mastra/core"
-  },
-  "@langchain/langgraph": {
-    name: "langgraph",
-    displayName: "LangGraph",
-    npmPackage: "@langchain/langgraph",
-    mutagentPackage: "@mutagent/langgraph"
-  },
-  langchain: {
-    name: "langchain",
-    displayName: "LangChain",
-    npmPackage: "langchain",
-    mutagentPackage: "@mutagent/langchain"
-  },
-  "@langchain/core": {
-    name: "langchain",
-    displayName: "LangChain",
-    npmPackage: "@langchain/core",
-    mutagentPackage: "@mutagent/langchain"
-  },
-  "@ai-sdk/core": {
-    name: "vercel-ai",
-    displayName: "Vercel AI SDK",
-    npmPackage: "@ai-sdk/core",
-    mutagentPackage: "@mutagent/vercel-ai"
-  },
-  ai: {
-    name: "vercel-ai",
-    displayName: "Vercel AI SDK",
-    npmPackage: "ai",
-    mutagentPackage: "@mutagent/vercel-ai"
-  },
-  "@google/genai": {
-    name: "generic",
-    displayName: "Google GenAI",
-    npmPackage: "@google/genai"
-  },
-  openai: {
-    name: "openai",
-    displayName: "OpenAI SDK",
-    npmPackage: "openai",
-    mutagentPackage: "@mutagent/openai"
-  }
-};
-function detectPackageManager(cwd = process.cwd()) {
-  if (existsSync4(join4(cwd, "bun.lockb")) || existsSync4(join4(cwd, "bun.lock"))) {
-    return "bun";
-  }
-  if (existsSync4(join4(cwd, "pnpm-lock.yaml"))) {
-    return "pnpm";
-  }
-  if (existsSync4(join4(cwd, "yarn.lock"))) {
-    return "yarn";
-  }
-  if (existsSync4(join4(cwd, "package-lock.json"))) {
-    return "npm";
-  }
-  try {
-    execSync("bun --version", { stdio: "ignore" });
-    return "bun";
-  } catch {
-    return "npm";
-  }
-}
-function getInstallCommand(pm, packages) {
-  const pkgList = packages.join(" ");
-  const commands = {
-    bun: `bun add ${pkgList}`,
-    npm: `npm install ${pkgList}`,
-    yarn: `yarn add ${pkgList}`,
-    pnpm: `pnpm add ${pkgList}`
-  };
-  return commands[pm];
-}
-function detectFrameworkFromPackageJson(cwd = process.cwd()) {
-  const pkgPath = join4(cwd, "package.json");
-  if (!existsSync4(pkgPath)) {
-    return null;
-  }
-  let pkg;
-  try {
-    pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
-  } catch {
-    return null;
-  }
-  const allDeps = {
-    ...pkg.dependencies,
-    ...pkg.devDependencies
-  };
-  for (const [depName, framework] of Object.entries(FRAMEWORK_DETECTION_MAP)) {
-    if (depName in allDeps) {
-      return framework;
-    }
-  }
-  return null;
-}
-function hasRcConfig(cwd = process.cwd()) {
-  return existsSync4(join4(cwd, ".mutagentrc.json"));
-}
-
-// src/commands/init.ts
-function writeRcConfig(config, cwd = process.cwd()) {
-  const rcPath = join5(cwd, ".mutagentrc.json");
-  writeFileSync2(rcPath, JSON.stringify(config, null, 2) + `
-`);
-}
 function createInitCommand() {
   const init = new Command6("init").description("Initialize MutagenT in your project").option("--non-interactive", "Skip interactive prompts (defaults to CLI-only mode)").addHelpText("after", `
 Examples:
@@ -2631,9 +2959,8 @@ Modes:
         }
         console.log("");
         output.info("Next steps:");
-        output.info("  1. Run: mutagent skills install  (install the CLI skill for AI agents)");
-        output.info(`  2. Add MutagenT tracing to your ${confirmedFramework.name} code via ${confirmedFramework.mutagentPackage}`);
-        output.info("  3. Run: mutagent providers list  (confirm an LLM provider is configured)");
+        output.info(`  1. Add MutagenT tracing to your ${confirmedFramework.name} code via ${confirmedFramework.mutagentPackage}`);
+        output.info("  2. Run: mutagent providers list  (confirm an LLM provider is configured)");
       } else {
         writeRcConfig(rcConfig, cwd);
         output.success("Created .mutagentrc.json");
@@ -2653,60 +2980,9 @@ Modes:
           }
         }
       }
-      const skillPath = join5(cwd, ".claude/skills/mutagent-cli/SKILL.md");
-      const skillInstalled = existsSync5(skillPath);
-      if (!isNonInteractive && !skillInstalled) {
-        const { installSkill } = await inquirer2.prompt([{
-          type: "confirm",
-          name: "installSkill",
-          message: "Install MutagenT skill for Claude Code? (Teaches AI agents how to use the CLI)",
-          default: true
-        }]);
-        if (installSkill) {
-          try {
-            const skillDir = join5(cwd, ".claude/skills/mutagent-cli");
-            if (!existsSync5(skillDir)) {
-              mkdirSync2(skillDir, { recursive: true });
-            }
-            execSync2("node " + join5(cwd, "node_modules/.bin/mutagent") + " skills install", {
-              cwd,
-              stdio: "ignore"
-            });
-            output.success("Installed MutagenT CLI skill for Claude Code");
-          } catch {
-            output.info("Install skill manually: mutagent skills install");
-          }
-        }
-      }
       const initDirective = {
-        instruction: skillInstalled ? "Verify workspace. Run: mutagent workspaces list --json" : [
-          "MANDATORY: Ask the user whether they want to install the MutagenT CLI skill and Claude Code hooks.",
-          "Use your AskUserQuestion tool to present the following choices:",
-          "1. Install skill + hooks (Recommended) — Installs the CLI skill AND configures Claude Code session telemetry hooks",
-          "2. Install skill only — Installs the CLI skill (teaches AI agents to use MutagenT CLI)",
-          "3. Skip — Do not install",
-          "",
-          "If the user picks option 1, run BOTH commands:",
-          "  mutagent skills install --json",
-          "  mutagent hooks install --json",
-          "",
-          "If the user picks option 2, run only: mutagent skills install --json",
-          "",
-          "After skill/hooks install, verify workspace: mutagent workspaces list --json"
-        ].join(`
-`),
-        next: ["mutagent workspaces list --json", "mutagent providers list --json"],
-        ...!skillInstalled ? {
-          askUserQuestions: [{
-            question: "Would you like to install the MutagenT CLI skill and Claude Code hooks?",
-            options: [
-              { label: "Install skill + hooks (Recommended)", description: "Installs the CLI skill AND configures Claude Code session telemetry hooks" },
-              { label: "Install skill only", description: "Installs the CLI skill (teaches AI agents to use MutagenT CLI)" },
-              { label: "Skip", description: "Do not install" }
-            ],
-            multiSelect: false
-          }]
-        } : {}
+        instruction: "Verify workspace. Run: mutagent workspaces list --json",
+        next: ["mutagent workspaces list --json", "mutagent providers list --json"]
       };
       const summary = {
         success: true,
@@ -2716,7 +2992,6 @@ Modes:
         framework: confirmedFramework?.name ?? null,
         authenticated,
         workspaceValidation: workspaceValidation ?? null,
-        skillInstalled: skillInstalled || existsSync5(skillPath),
         _directive: initDirective
       };
       output.output(summary);
@@ -2730,8 +3005,8 @@ Modes:
 // src/commands/skills.ts
 import { Command as Command7 } from "commander";
 import chalk13 from "chalk";
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
-import { dirname, join as join6 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "fs";
+import { dirname, join as join7 } from "path";
 import { execSync as execSync3 } from "child_process";
 
 // src/generated/skill-content.ts
@@ -3099,7 +3374,8 @@ name: mutagent-cli-workflows-install
 description: |
   Meta-installer workflow. Installs a MutagenT package (helix, diagnostics, or
   evaluator) into the user's environment via \`mutagent install <package>\`.
-  Login-gated. diagnostics/evaluator come from public npm; helix self-hosts.
+  Login-gated. diagnostics/evaluator come from public npm; helix is fetched
+  from a private registry via a login-brokered signed URL (no static secret).
 triggers:
   - "install diagnostics"
   - "install evaluator"
@@ -3138,7 +3414,7 @@ Where \`<package>\` is one of:
 |---|---|---|
 | \`diagnostics\` | public npm \`@mutagent/diagnostics\` | Ready to install |
 | \`evaluator\` | public npm \`@mutagent/evaluator\` | Ready to install |
-| \`helix\` | self-hosted install | Pending — may return \`NOT_IMPLEMENTED\` for now |
+| \`helix\` | private registry via login-brokered signed URL | Ready to install — login-gated download, sha256-verified, then initialized into your project |
 
 **Flags** (verify against \`--help\`):
 - \`--harness <claude-code|codex|omp>\` -- target coding-agent harness (default \`claude-code\`).
@@ -3171,6 +3447,8 @@ Where \`<package>\` is one of:
 ## Examples
 
 \`\`\`bash
+mutagent install helix --json
+mutagent install helix --harness codex --json
 mutagent install diagnostics --json
 mutagent install evaluator --version 1.2.3 --json
 mutagent install diagnostics --harness codex --json
@@ -3181,15 +3459,15 @@ mutagent install diagnostics --harness codex --json
 ## Output handling
 
 - On success (\`{ success: true, package, version, harness, global }\`): tell the user what was installed and the resolved version. Surface \`_links.install\` / \`_links.login\`.
-- If \`helix\` returns \`NOT_IMPLEMENTED\`: explain that self-hosted helix install is still pending (tracked upstream) and suggest \`diagnostics\` / \`evaluator\`, which install from public npm today.
-- On an auth error: route to the login workflow, then retry.
+- For \`helix\`: the CLI resolves a signed download URL from the login broker, downloads + sha256-verifies the plugin, then runs its init into the project. An \`INTEGRITY_ERROR\` means the download failed checksum verification — retry.
+- On an auth error (including a broker \`AUTH_REQUIRED\`): route to the login workflow, then retry.
 
 ---
 
 ## Common pitfalls
 
 - Running before login → auth error (install is login-gated).
-- Assuming \`helix\` installs like the npm packages — it self-hosts and may not be wired yet.
+- Assuming \`helix\` installs from public npm — it is fetched from a private registry via a login-brokered signed URL (the CLI holds no static secret).
 - Installing without confirming with the user first (Core Rule 5).
 
 ---
@@ -3383,7 +3661,7 @@ that teaches coding agents how to use the MutagenT CLI effectively.
     const isJson = parentCmd ? getJsonFlag(parentCmd) : false;
     const output = new OutputFormatter(isJson ? "json" : "table");
     const repoRoot = findRepoRoot();
-    const skillDir = join6(repoRoot, SKILL_DIR);
+    const skillDir = join7(repoRoot, SKILL_DIR);
     const files = getSkillFiles();
     const writtenFiles = [];
     let totalBytes = 0;
@@ -3395,7 +3673,7 @@ that teaches coding agents how to use the MutagenT CLI effectively.
       return a.localeCompare(b);
     });
     for (const relPath of sortedKeys) {
-      const destPath = join6(skillDir, relPath);
+      const destPath = join7(skillDir, relPath);
       const parentDir = dirname(destPath);
       if (!existsSync6(parentDir)) {
         mkdirSync3(parentDir, { recursive: true });
@@ -3404,7 +3682,7 @@ that teaches coding agents how to use the MutagenT CLI effectively.
       const finalContent = raw.endsWith(`
 `) ? raw : `${raw}
 `;
-      writeFileSync3(destPath, finalContent, "utf-8");
+      writeFileSync4(destPath, finalContent, "utf-8");
       writtenFiles.push({ path: destPath, bytes: finalContent.length });
       totalBytes += finalContent.length;
     }
@@ -3507,18 +3785,18 @@ import { Command as Command9 } from "commander";
 import { randomUUID } from "crypto";
 
 // src/commands/hooks/state.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, renameSync, unlinkSync, existsSync as existsSync7 } from "fs";
-import { join as join7 } from "path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync5, renameSync as renameSync2, unlinkSync, existsSync as existsSync7 } from "fs";
+import { join as join8 } from "path";
 import { tmpdir } from "os";
 function stateFilePath(sessionId) {
-  return join7(tmpdir(), `mutagent-hook-${sessionId}.json`);
+  return join8(tmpdir(), `mutagent-hook-${sessionId}.json`);
 }
 function readState(sessionId) {
   const path = stateFilePath(sessionId);
   if (!existsSync7(path))
     return null;
   try {
-    const raw = JSON.parse(readFileSync4(path, "utf-8"));
+    const raw = JSON.parse(readFileSync5(path, "utf-8"));
     if (!Array.isArray(raw.parentStack)) {
       raw.parentStack = [];
     }
@@ -3533,8 +3811,8 @@ function readState(sessionId) {
 function writeState(sessionId, state) {
   const path = stateFilePath(sessionId);
   const tmpPath = `${path}.${process.pid.toString()}.tmp`;
-  writeFileSync4(tmpPath, JSON.stringify(state), "utf-8");
-  renameSync(tmpPath, path);
+  writeFileSync5(tmpPath, JSON.stringify(state), "utf-8");
+  renameSync2(tmpPath, path);
 }
 function deleteState(sessionId) {
   const path = stateFilePath(sessionId);
@@ -4185,8 +4463,8 @@ async function handlePostToolUseFailure() {
 }
 
 // src/commands/hooks/install.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync5, existsSync as existsSync8, mkdirSync as mkdirSync4 } from "fs";
-import { join as join8 } from "path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync6, existsSync as existsSync8, mkdirSync as mkdirSync4 } from "fs";
+import { join as join9 } from "path";
 
 class SettingsParseError extends Error {
   settingsPath;
@@ -4248,17 +4526,17 @@ function migrateV1Hooks(settings) {
   return migrated;
 }
 function installHooks(cwd) {
-  const claudeDir = join8(cwd, ".claude");
-  const settingsPath = join8(claudeDir, "settings.local.json");
+  const claudeDir = join9(cwd, ".claude");
+  const settingsPath = join9(claudeDir, "settings.local.json");
   const existed = existsSync8(settingsPath);
   let settings = {};
   if (existed) {
-    const raw = readFileSync5(settingsPath, "utf-8");
+    const raw = readFileSync6(settingsPath, "utf-8");
     try {
       settings = JSON.parse(raw);
     } catch (err) {
       const backupPath = `${settingsPath}.bak.${new Date().toISOString().replace(/:/g, "-")}`;
-      writeFileSync5(backupPath, raw, "utf-8");
+      writeFileSync6(backupPath, raw, "utf-8");
       throw new SettingsParseError(settingsPath, backupPath, err);
     }
   }
@@ -4291,7 +4569,7 @@ function installHooks(cwd) {
     if (!existsSync8(claudeDir)) {
       mkdirSync4(claudeDir, { recursive: true });
     }
-    writeFileSync5(settingsPath, JSON.stringify(settings, null, 2) + `
+    writeFileSync6(settingsPath, JSON.stringify(settings, null, 2) + `
 `, "utf-8");
   }
   if (added.length > 0) {
@@ -4437,8 +4715,8 @@ times is safe.
 import { Command as Command10 } from "commander";
 import chalk16 from "chalk";
 import { type as osType, release as osRelease } from "os";
-import { readFileSync as readFileSync7 } from "fs";
-import { join as join10, dirname as dirname2 } from "path";
+import { readFileSync as readFileSync8 } from "fs";
+import { join as join11, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 init_errors();
 init_config();
@@ -4446,11 +4724,11 @@ init_config();
 // src/lib/transcript.ts
 init_errors();
 import { homedir as osHomedir } from "os";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 import {
   existsSync as fsExistsSync,
   statSync as fsStatSync,
-  readFileSync as readFileSync6,
+  readFileSync as readFileSync7,
   readdirSync,
   openSync,
   readSync,
@@ -4461,7 +4739,7 @@ var TAIL_BYTES = 200000;
 function defaultReadTail(path, tailBytes) {
   const { size } = fsStatSync(path);
   if (size <= tailBytes) {
-    return { content: readFileSync6(path, "utf-8"), truncated: false };
+    return { content: readFileSync7(path, "utf-8"), truncated: false };
   }
   const fd = openSync(path, "r");
   try {
@@ -4484,7 +4762,7 @@ function defaultScan(dir) {
       return;
     }
     for (const entry of entries) {
-      const full = join9(current, entry.name);
+      const full = join10(current, entry.name);
       if (entry.isDirectory())
         walk(full);
       else if (entry.isFile() && entry.name.endsWith(".jsonl"))
@@ -4495,11 +4773,11 @@ function defaultScan(dir) {
   return out;
 }
 function buildSources(env, home) {
-  const ompBase = env.PI_CODING_AGENT_DIR ?? join9(home, ".omp", "agent");
+  const ompBase = env.PI_CODING_AGENT_DIR ?? join10(home, ".omp", "agent");
   return [
-    { harness: "claude-code", dir: join9(home, ".claude", "projects") },
-    { harness: "codex", dir: join9(home, ".codex", "sessions") },
-    { harness: "omp", dir: join9(ompBase, "sessions") }
+    { harness: "claude-code", dir: join10(home, ".claude", "projects") },
+    { harness: "codex", dir: join10(home, ".codex", "sessions") },
+    { harness: "omp", dir: join10(ompBase, "sessions") }
   ];
 }
 function resolveTranscript(attach, deps = {}) {
@@ -4553,8 +4831,8 @@ function getCliVersion() {
     return process.env.CLI_VERSION;
   try {
     const __dirname2 = dirname2(fileURLToPath(import.meta.url));
-    const pkgPath = join10(__dirname2, "..", "..", "package.json");
-    const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
+    const pkgPath = join11(__dirname2, "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync8(pkgPath, "utf-8"));
     return pkg.version ?? "0.1.1";
   } catch {
     return "0.1.1";
@@ -4719,78 +4997,6 @@ Or set an API key: mutagent config set apiKey <key>`);
 import { Command as Command11 } from "commander";
 import chalk17 from "chalk";
 init_errors();
-
-// src/lib/installer.ts
-init_errors();
-init_config();
-import { spawn } from "child_process";
-var VALID_PACKAGES = ["helix", "diagnostics", "evaluator"];
-var VALID_HARNESSES = ["claude-code", "codex", "omp"];
-var VERSION_MATRIX = {
-  helix: "latest",
-  diagnostics: "latest",
-  evaluator: "latest"
-};
-var NPM_PACKAGES = {
-  diagnostics: "@mutagent/diagnostics",
-  evaluator: "@mutagent/evaluator"
-};
-var defaultRunner = (cmd, args) => new Promise((resolve, reject) => {
-  const child = spawn(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
-  let stdout = "";
-  let stderr = "";
-  child.stdout.on("data", (chunk) => {
-    stdout += chunk.toString("utf-8");
-  });
-  child.stderr.on("data", (chunk) => {
-    stderr += chunk.toString("utf-8");
-  });
-  child.on("error", (err) => {
-    reject(new MutagentError("INSTALL_FAILED", `Failed to run ${cmd}: ${err.message}`, `Ensure "${cmd}" is installed and available on your PATH.`));
-  });
-  child.on("close", (code) => {
-    resolve({ code: code ?? 1, stdout, stderr });
-  });
-});
-function isValidPackage(pkg) {
-  return VALID_PACKAGES.includes(pkg);
-}
-function isValidHarness(harness) {
-  return VALID_HARNESSES.includes(harness);
-}
-async function installPackage(pkg, opts, deps = {}) {
-  const isAuthed = deps.isAuthed ?? hasCredentials;
-  if (!isAuthed()) {
-    throw new MutagentError("AUTH_REQUIRED", `Authentication required to install ${pkg}.`, "Run: mutagent login");
-  }
-  if (!isValidPackage(pkg)) {
-    throw new MutagentError("INVALID_ARGUMENTS", `Unknown package "${pkg}". Valid: ${VALID_PACKAGES.join(", ")}`, "Run: mutagent install --help");
-  }
-  if (!isValidHarness(opts.harness)) {
-    throw new MutagentError("INVALID_ARGUMENTS", `Unknown harness "${opts.harness}". Valid: ${VALID_HARNESSES.join(", ")}`, "Run: mutagent install --help");
-  }
-  const version = opts.version ?? VERSION_MATRIX[pkg];
-  if (pkg === "helix") {
-    throw new MutagentError("NOT_IMPLEMENTED", "helix self-host install is not available yet — hosting on install.mutagent.io is pending (see issue #1191, task CI1).", "Track: gh issue view 1191. For now install diagnostics/evaluator via npm.");
-  }
-  const npmPackage = NPM_PACKAGES[pkg];
-  const args = ["install", "-g", `${npmPackage}@${version}`];
-  const runner = deps.runner ?? defaultRunner;
-  const result = await runner("npm", args);
-  if (result.code !== 0) {
-    const detail = result.stderr.trim();
-    throw new MutagentError("INSTALL_FAILED", `npm failed to install ${npmPackage}@${version} (exit ${String(result.code)}).${detail ? ` ${detail.slice(0, 200)}` : ""}`, "Verify the package and version exist and that you have permission for a global npm install.");
-  }
-  return {
-    package: pkg,
-    version,
-    harness: opts.harness,
-    global: opts.global,
-    command: `npm ${args.join(" ")}`
-  };
-}
-
-// src/commands/install/index.ts
 function createInstallCommand(deps) {
   const install = new Command11("install").description("Install a MutagenT package (helix, diagnostics, evaluator)").argument("<package>", `Package to install: ${VALID_PACKAGES.join(", ")}`).option("--harness <harness>", `Target harness: ${VALID_HARNESSES.join(", ")}`, "claude-code").option("--global", "Install globally", true).option("--version <version>", "Package version to install (default: latest)").addHelpText("after", `
 ${chalk17.bold("Arguments & flags:")}
@@ -4801,15 +5007,18 @@ ${chalk17.bold("Arguments & flags:")}
   ${chalk17.bold("--json")}               Structured output
 
 ${chalk17.bold("Examples:")}
+  ${chalk17.dim("$")} mutagent install helix
+  ${chalk17.dim("$")} mutagent install helix --harness codex
   ${chalk17.dim("$")} mutagent install diagnostics
   ${chalk17.dim("$")} mutagent install evaluator --version 1.2.3
   ${chalk17.dim("$")} mutagent install diagnostics --harness codex --json
 
 ${chalk17.bold("Packages:")}
+  ${chalk17.bold("helix")}        ${chalk17.green("(available)")} — the ADL conductor. Downloaded from a private
+                 registry via a login-brokered signed URL, sha256-verified, then
+                 initialized into your project. No static secret ships in the CLI.
   ${chalk17.bold("diagnostics")}  Public npm package @mutagent/diagnostics ${chalk17.green("(available)")}
   ${chalk17.bold("evaluator")}    Public npm package @mutagent/evaluator ${chalk17.green("(available)")}
-  ${chalk17.bold("helix")}        ${chalk17.yellow("NOT yet available")} — self-host on install.mutagent.io is pending (#1191).
-                 Running it today errors with ${chalk17.bold("NOT_IMPLEMENTED")} by design (no fake install).
 
 ${chalk17.yellow("Note:")} install is login-gated. Run ${chalk17.cyan("mutagent login")} first (else exits with a login directive).
     `).action(async (pkg, options) => {
@@ -4847,8 +5056,8 @@ if (process.env.CLI_VERSION) {
 } else {
   try {
     const __dirname2 = dirname3(fileURLToPath2(import.meta.url));
-    const pkgPath = join11(__dirname2, "..", "..", "package.json");
-    const pkg = JSON.parse(readFileSync8(pkgPath, "utf-8"));
+    const pkgPath = join12(__dirname2, "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
     cliVersion = pkg.version ?? cliVersion;
   } catch {}
 }
@@ -4863,12 +5072,12 @@ program.name("mutagent").description(`MutagenT CLI - command-line client for the
 });
 program.addHelpText("after", `
 ${chalk18.bold.cyan("WORKFLOWS:")}
-  ${chalk18.bold("Setup")}                mutagent login  →  mutagent init  →  mutagent skills install
-  ${chalk18.bold("Lifecycle Tools")}      mutagent install <diagnostics|evaluator>  ${chalk18.dim("(login-gated; helix pending #1191)")}
+  ${chalk18.bold("Setup")}                mutagent login  →  mutagent init
+  ${chalk18.bold("Lifecycle Tools")}      mutagent install <helix|diagnostics|evaluator>  ${chalk18.dim("(login-gated)")}
   ${chalk18.bold("Feedback")}             mutagent feedback send "<what happened>" --category <cli|helix|stage:<x>>  ${chalk18.dim("[--session <id>] [--attach-transcript]")}
 
 ${chalk18.dim("For CLI usage guidance for AI agents, see the Skill at")}
-${chalk18.cyan(".claude/skills/mutagent-cli/SKILL.md")} ${chalk18.dim("(install via")} ${chalk18.cyan("mutagent skills install")}${chalk18.dim(")")}
+${chalk18.cyan(".claude/skills/mutagent-cli/SKILL.md")}
 
 ${chalk18.yellow("Non-Interactive Mode (CI/CD & Coding Agents):")}
   export MUTAGENT_API_KEY=mt_...  ${chalk18.dim("or")}  --api-key mt_...
@@ -4885,11 +5094,10 @@ ${chalk18.yellow("Command Navigation:")}
   mutagent providers list --json        ${chalk18.dim("List configured BYOK providers")}
   mutagent providers list --models      ${chalk18.dim("See available models per provider")}
 
-  mutagent install diagnostics          ${chalk18.dim("Install diagnostics from npm (login-gated)")}
+  mutagent install helix                ${chalk18.dim("Install the ADL lifecycle conductor (login-gated)")}
   mutagent install evaluator --version 1.2.3  ${chalk18.dim("Pin a version")}
-  mutagent install --help               ${chalk18.dim("helix (pending #1191) | diagnostics | evaluator")}
+  mutagent install --help               ${chalk18.dim("helix | diagnostics | evaluator")}
 
-  mutagent skills install               ${chalk18.dim("Install the MutagenT CLI skill for AI agents")}
   mutagent hooks --help                 ${chalk18.dim("Hook setup for Claude Code session telemetry upload")}
 
 ${chalk18.bold.red("Report Issues:")}
@@ -4909,7 +5117,6 @@ ${chalk18.yellow("Directive System:")}
   ${chalk18.bold("_compat")}                 Compat metadata: cliVersion, skillVersion, skillMinCliVersion
 
 ${chalk18.yellow("AI Agent Rules (MANDATORY for coding agents):")}
-  0. If .claude/skills/mutagent-cli/SKILL.md does not exist, run mutagent skills install first
   1. Login (two paths):
      - CI / fully automated: export MUTAGENT_API_KEY=mt_... then mutagent login --json
      - Helping a user onboard: mutagent login --browser --json
@@ -4962,15 +5169,7 @@ program.addCommand(createUsageCommand());
 program.addCommand(createHooksCommand());
 program.addCommand(createInstallCommand());
 program.addCommand(createFeedbackCommand());
-var isInteractive = process.stdin.isTTY && !rawArgs.includes("--json") && process.env.CI !== "true";
-var isSkillCommand = rawArgs[0] === "skills" || rawArgs[0] === "hooks";
-if (isInteractive && !isSkillCommand) {
-  const skillPath = join11(process.cwd(), ".claude/skills/mutagent-cli/SKILL.md");
-  if (!existsSync9(skillPath)) {
-    console.log(chalk18.dim("MutagenT SKILL not installed. Install it for AI agent support? Run:"), chalk18.cyan("mutagent skills install"));
-  }
-}
 program.parse();
 
-//# debugId=9788EBFA942A533664756E2164756E21
+//# debugId=8FB723E6C0DFB02564756E2164756E21
 //# sourceMappingURL=cli.js.map