@mutagent/cli 0.1.196 → 0.1.198

package/dist/bin/cli.js

@@ -317,125 +317,6 @@ var init_errors = __esm(() => {
   };
 });
 
-// src/lib/scorecard-extraction.ts
-function extractScorecardDetails(rawState, iterCtx) {
-  if (!iterCtx)
-    return {};
-  const gc = rawState.globalContext;
-  const gcCtx = gc?.context;
-  const beforeExec = gcCtx?.executions;
-  const beforeResults = beforeExec?.results ?? [];
-  const beforeById = new Map;
-  for (const r of beforeResults) {
-    const id = r.id;
-    if (id)
-      beforeById.set(id, r);
-  }
-  let originalScore;
-  if (beforeResults.length > 0) {
-    const sum = beforeResults.reduce((acc, r) => {
-      const eval_ = r.evaluation;
-      return acc + (eval_?.score ?? 0);
-    }, 0);
-    originalScore = sum / beforeResults.length;
-  }
-  const afterExec = iterCtx.executionResults;
-  const afterResults = afterExec?.executions ?? [];
-  const datasetResults = afterResults.length > 0 ? afterResults.map((r) => {
-    const id = r.id || "unknown";
-    const afterEval = r.evaluation;
-    const afterScore = afterEval?.score ?? 0;
-    const beforeResult = beforeById.get(id);
-    const beforeEval = beforeResult?.evaluation;
-    const beforeScore = beforeEval?.score;
-    return { id, beforeScore, afterScore };
-  }) : undefined;
-  const criteriaScores = extractCriteriaScores(beforeResults, afterResults);
-  const rawFailureModes = iterCtx.failureModes;
-  const failureModes = rawFailureModes?.categories && rawFailureModes.failures ? rawFailureModes.categories.map((category) => ({
-    category,
-    failures: (rawFailureModes.failures?.[category] ?? []).map((f) => ({
-      description: f.description ?? f.label,
-      summary: f.summary
-    }))
-  })) : undefined;
-  const rawMutations = iterCtx.mutations;
-  const mutations = rawMutations && rawMutations.length > 0 ? rawMutations.map((m) => ({
-    label: m.label ?? "Unknown mutation",
-    status: m.status ?? "pending",
-    priority: m.priority,
-    rationale: m.target?.rationale
-  })) : undefined;
-  const evaluationDetails = afterResults.length > 0 ? afterResults.map((r) => {
-    const id = r.id || "unknown";
-    const eval_ = r.evaluation;
-    const score = eval_?.score ?? 0;
-    const success = eval_?.success ?? false;
-    const metrics = eval_?.evaluations?.map((metric) => {
-      const criteria = metric.evaluationChecklist?.items?.map((item) => ({
-        name: item.evaluationParameter ?? item.criteria ?? "unknown",
-        score: item.llmScore ?? 0,
-        success: item.success ?? false
-      }));
-      return {
-        name: metric.name ?? "unknown",
-        score: metric.score ?? 0,
-        success: metric.success ?? false,
-        failureMode: metric.failureMode,
-        reasoning: metric.reasoning,
-        criteria: criteria && criteria.length > 0 ? criteria : undefined
-      };
-    });
-    return {
-      itemId: id,
-      score,
-      success,
-      metrics: metrics && metrics.length > 0 ? metrics : undefined
-    };
-  }) : undefined;
-  return {
-    originalScore,
-    criteriaScores,
-    datasetResults,
-    failureModes,
-    mutations,
-    evaluationDetails
-  };
-}
-function extractCriteriaScores(beforeResults, afterResults) {
-  const metricNames = new Set;
-  const beforeScores = new Map;
-  const afterScores = new Map;
-  for (const r of beforeResults) {
-    const eval_ = r.evaluation;
-    for (const m of eval_?.evaluations ?? []) {
-      const name = m.name ?? "unknown";
-      metricNames.add(name);
-      const existing = beforeScores.get(name) ?? [];
-      existing.push(m.score ?? 0);
-      beforeScores.set(name, existing);
-    }
-  }
-  for (const r of afterResults) {
-    const eval_ = r.evaluation;
-    for (const m of eval_?.evaluations ?? []) {
-      const name = m.name ?? "unknown";
-      metricNames.add(name);
-      const existing = afterScores.get(name) ?? [];
-      existing.push(m.score ?? 0);
-      afterScores.set(name, existing);
-    }
-  }
-  if (metricNames.size === 0)
-    return;
-  const avg = (arr) => arr.reduce((a, b) => a + b, 0) / arr.length;
-  return Array.from(metricNames).map((name) => ({
-    name,
-    before: beforeScores.has(name) ? avg(beforeScores.get(name) ?? []) : undefined,
-    after: afterScores.has(name) ? avg(afterScores.get(name) ?? []) : undefined
-  }));
-}
-
 // src/lib/sdk-client.ts
 var exports_sdk_client = {};
 __export(exports_sdk_client, {
@@ -546,416 +427,6 @@ class SDKClientWrapper {
     }
     return response.json();
   }
-  async requestRaw(path, options) {
-    const optHeaders = options?.headers;
-    let extraHeaders = {};
-    if (optHeaders instanceof Headers) {
-      optHeaders.forEach((value, key) => {
-        extraHeaders[key] = value;
-      });
-    } else if (optHeaders) {
-      extraHeaders = optHeaders;
-    }
-    const tenancyHeaders = {};
-    if (this.workspaceId)
-      tenancyHeaders["x-workspace-id"] = this.workspaceId;
-    if (this.organizationId)
-      tenancyHeaders["x-organization-id"] = this.organizationId;
-    return fetch(`${this.endpoint}${path}`, {
-      ...options,
-      headers: {
-        "x-api-key": this.apiKey,
-        "Content-Type": "application/json",
-        ...tenancyHeaders,
-        ...extraHeaders
-      }
-    });
-  }
-  async listPrompts() {
-    try {
-      const response = await this.sdk.prompt.listPrompts();
-      return response.result.data;
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  async getPrompt(id) {
-    try {
-      const response = await this.sdk.prompt.getPrompt({ id: parseInt(id, 10) });
-      return response;
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  async createPrompt(data) {
-    try {
-      const response = await this.sdk.prompt.createPrompt({
-        name: data.name ?? "",
-        description: data.description ?? undefined,
-        version: data.version ?? undefined,
-        isLatest: data.isLatest ?? undefined,
-        systemPrompt: data.systemPrompt ?? undefined,
-        humanPrompt: data.humanPrompt ?? undefined,
-        rawPrompt: data.rawPrompt ?? undefined,
-        inputSchema: data.inputSchema ?? undefined,
-        outputSchema: data.outputSchema ?? undefined,
-        metadata: data.metadata ?? undefined,
-        tags: data.tags ?? undefined
-      });
-      return response;
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  async updatePrompt(id, data) {
-    try {
-      const body = {
-        description: data.description ?? undefined,
-        isLatest: data.isLatest ?? undefined,
-        systemPrompt: data.systemPrompt ?? undefined,
-        humanPrompt: data.humanPrompt ?? undefined,
-        rawPrompt: data.rawPrompt ?? undefined,
-        inputSchema: data.inputSchema,
-        outputSchema: data.outputSchema,
-        metadata: data.metadata,
-        tags: data.tags ?? undefined
-      };
-      if (data.name !== undefined) {
-        body.name = data.name;
-      }
-      const updateArgs = { id: parseInt(id, 10), body };
-      const response = await this.sdk.prompt.updatePrompt(updateArgs);
-      return response;
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  async deletePrompt(id, options) {
-    try {
-      if (options?.force) {
-        await this.request(`/api/prompt/${id}?force=true`, { method: "DELETE" });
-      } else {
-        await this.sdk.prompt.deletePrompt({ id: parseInt(id, 10) });
-      }
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  async getDataset(datasetId) {
-    try {
-      return await this.request(`/api/prompts/datasets/${String(datasetId)}`);
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  async getDatasetItem(itemId) {
-    try {
-      return await this.request(`/api/prompts/dataset-items/${String(itemId)}`);
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  async listDatasets(promptId) {
-    try {
-      const response = await this.request(`/api/prompt/${promptId}/datasets`);
-      return Array.isArray(response) ? response : response.data;
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  async addDataset(promptId, fileContent, name) {
-    try {
-      let parsed;
-      try {
-        parsed = JSON.parse(fileContent);
-      } catch {
-        parsed = null;
-      }
-      let datasetName = name ?? `Dataset ${new Date().toISOString().slice(0, 16)}`;
-      let items;
-      if (parsed !== null && !Array.isArray(parsed) && typeof parsed === "object" && "name" in parsed) {
-        const meta = parsed;
-        datasetName = meta.name ?? datasetName;
-        if (Array.isArray(meta.items)) {
-          items = meta.items;
-        }
-      } else if (Array.isArray(parsed)) {
-        items = parsed;
-      }
-      const dataset = await this.request(`/api/prompt/${promptId}/datasets`, {
-        method: "POST",
-        body: JSON.stringify({
-          name: datasetName
-        })
-      });
-      let itemCount = 0;
-      if (items && items.length > 0) {
-        const mappedItems = items.map((item, index) => ({
-          input: item.input ?? item,
-          expectedOutput: item.expectedOutput ?? item.expected_output ?? undefined,
-          name: item.name ?? `Item ${String(index + 1)}`,
-          userFeedback: item.userFeedback,
-          systemFeedback: item.systemFeedback,
-          labels: item.labels,
-          metadata: item.metadata
-        }));
-        const missingExpectedOutputCount = mappedItems.filter((item) => item.expectedOutput === undefined).length;
-        const bulkResult = await this.requestRaw(`/api/prompts/datasets/${String(dataset.id)}/items/bulk`, {
-          method: "POST",
-          body: JSON.stringify({ items: mappedItems })
-        });
-        if (!bulkResult.ok) {
-          const bodyText = await bulkResult.text();
-          let parsed2;
-          try {
-            parsed2 = JSON.parse(bodyText);
-          } catch {}
-          const typed = parsed2;
-          if (typed && typed.kind === "bulk_insert_rollback") {
-            const constraint = typeof typed.failingConstraint === "string" ? typed.failingConstraint : "unknown";
-            const rowIndex = typeof typed.failingRowIndex === "number" ? typed.failingRowIndex : null;
-            throw new ApiError(bulkResult.status, `Bulk insert rolled back — constraint: ${constraint}` + (rowIndex !== null ? `, first failing row: ${String(rowIndex)}` : ""));
-          }
-          throw new ApiError(bulkResult.status, bodyText || "Bulk insert failed");
-        }
-        itemCount = mappedItems.length;
-        return { ...dataset, itemCount, missingExpectedOutputCount };
-      }
-      return { ...dataset, itemCount };
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  async listDatasetItems(datasetId) {
-    try {
-      const response = await this.request(`/api/prompts/datasets/${datasetId}/items`);
-      return Array.isArray(response) ? response : response.data;
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  async deleteDataset(_promptId, datasetId, options) {
-    try {
-      const query = options?.force ? "?force=true" : "";
-      await this.request(`/api/prompts/datasets/${datasetId}${query}`, { method: "DELETE" });
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  async listEvaluations(promptId) {
-    try {
-      const response = await this.request(`/api/prompts/evaluations?promptId=${promptId}`);
-      return response.data;
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  async getEvaluation(evaluationId) {
-    try {
-      return await this.request(`/api/prompts/evaluations/${evaluationId}`);
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  async createEvaluation(promptId, data) {
-    try {
-      return await this.request("/api/prompts/evaluations", {
-        method: "POST",
-        body: JSON.stringify({
-          promptId: parseInt(promptId, 10),
-          name: data.name,
-          description: data.description,
-          evalConfig: data.evalConfig,
-          llmConfig: data.llmConfig,
-          tags: data.tags,
-          metadata: data.metadata
-        })
-      });
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  async deleteEvaluation(evaluationId) {
-    try {
-      await this.request(`/api/prompts/evaluations/${evaluationId}`, { method: "DELETE" });
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  async listOptimizations() {
-    try {
-      const response = await this.request("/api/optimizations");
-      if (Array.isArray(response))
-        return response;
-      const r = response;
-      if (Array.isArray(r.data))
-        return r.data;
-      return [];
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  async listExperiments(filters) {
-    try {
-      const params = new URLSearchParams;
-      if (filters?.promptId !== undefined)
-        params.set("promptId", String(filters.promptId));
-      if (filters?.status)
-        params.set("status", filters.status);
-      if (filters?.limit !== undefined)
-        params.set("limit", String(filters.limit));
-      if (filters?.offset !== undefined)
-        params.set("offset", String(filters.offset));
-      const qs = params.toString();
-      const response = await this.request(`/api/prompts/experiments${qs ? `?${qs}` : ""}`);
-      if (Array.isArray(response))
-        return { experiments: response, total: response.length };
-      const r = response;
-      const experiments = r.experiments ?? r.data ?? [];
-      return { experiments, total: r.total ?? experiments.length };
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  async createExperiment(data) {
-    try {
-      return await this.request("/api/prompts/experiments", {
-        method: "POST",
-        body: JSON.stringify(data)
-      });
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  async getExperiment(id) {
-    try {
-      return await this.request(`/api/prompts/experiments/${id}`);
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  async deleteExperiment(id) {
-    try {
-      await this.request(`/api/prompts/experiments/${id}`, { method: "DELETE" });
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  async executeExperiment(id) {
-    try {
-      return await this.request(`/api/prompts/experiments/${id}/execute`, { method: "POST", body: JSON.stringify({}) });
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  async playgroundEval(promptId, data) {
-    try {
-      return await this.request(`/api/prompt/${promptId}/playground/eval`, {
-        method: "POST",
-        body: JSON.stringify(data)
-      });
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  async cancelOptimization(jobId) {
-    try {
-      return await this.request(`/api/optimization/${jobId}/cancel`, {
-        method: "POST"
-      });
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  async startOptimization(promptId, datasetId, evaluationId, config) {
-    try {
-      return await this.request(`/api/prompt/${promptId}/optimize`, {
-        method: "POST",
-        body: JSON.stringify({
-          datasetId: parseInt(datasetId, 10),
-          evaluationId: parseInt(evaluationId, 10),
-          config: {
-            maxIterations: config?.maxIterations ?? 1,
-            targetScore: config?.targetScore ?? 0.8,
-            patience: config?.patience,
-            ...config?.executionModel ? { executionModel: config.executionModel } : {},
-            ...config?.evaluationModel ? { evaluationModel: config.evaluationModel } : {},
-            ...config?.optimizationModel ? { optimizationModel: config.optimizationModel } : {},
-            ...config?.providerId ? { executionProviderId: config.providerId } : {},
-            ...config?.evalProviderId ? { evaluationProviderId: config.evalProviderId } : {},
-            ...config?.optProviderId ? { optimizationProviderId: config.optProviderId } : {}
-          },
-          executionMode: "worker_loop"
-        })
-      });
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  async getOptimizationStatus(jobId) {
-    try {
-      const raw = await this.request(`/api/optimization/${jobId}`);
-      const id = raw.id;
-      return {
-        ...raw,
-        jobId: id ?? jobId,
-        progressPercent: typeof raw.progress === "number" ? raw.progress : 0
-      };
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  async getOptimizationScorecard(jobId) {
-    try {
-      const res = await this.request(`/api/optimization/${jobId}/results`);
-      if (res.scorecard?.rendered) {
-        return { rendered: res.scorecard.rendered, data: res.scorecard.data ?? [] };
-      }
-      return null;
-    } catch {
-      return null;
-    }
-  }
-  async getOptimizationResults(jobId) {
-    try {
-      const job = await this.request(`/api/optimization/${jobId}`);
-      const progress = await this.request(`/api/optimization/${jobId}/progress`);
-      const prompt = await this.getPrompt(String(job.promptId ?? ""));
-      const statesRes = await this.request(`/api/optimization/${jobId}/states`).catch(() => ({ states: [] }));
-      const scorecardDigest = await this.getOptimizationScorecard(jobId);
-      const latestState = statesRes.states[statesRes.states.length - 1];
-      const rawState = latestState?.state ?? {};
-      const iterCtx = rawState.iterationContext ?? rawState.current?.context;
-      const basePromptObj = iterCtx?.basePrompt;
-      const currentPromptObj = iterCtx?.currentPrompt;
-      const mutatedPromptText = typeof currentPromptObj?.prompt === "string" ? currentPromptObj.prompt : undefined;
-      const originalPromptText = typeof basePromptObj?.prompt === "string" ? basePromptObj.prompt : undefined;
-      const extracted = extractScorecardDetails(rawState, iterCtx);
-      return {
-        job: {
-          id: job.id ?? jobId,
-          promptId: job.promptId ?? 0,
-          status: job.status ?? "unknown",
-          config: job.config
-        },
-        prompt,
-        bestScore: job.bestScore,
-        originalScore: extracted.originalScore,
-        iterationsCompleted: job.currentIteration,
-        scoreProgression: Array.isArray(progress.progression) ? progress.progression.map((p) => typeof p.score === "number" ? p.score : 0) : undefined,
-        mutatedPromptText,
-        originalPromptText,
-        criteriaScores: extracted.criteriaScores,
-        datasetResults: extracted.datasetResults,
-        failureModes: extracted.failureModes,
-        mutations: extracted.mutations,
-        evaluationDetails: extracted.evaluationDetails,
-        ...scorecardDigest ? { scorecard: scorecardDigest } : {}
-      };
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
   async listAgents(filters) {
     try {
       const response = await this.sdk.agents.listAgents({
@@ -1063,42 +534,6 @@ class SDKClientWrapper {
       this.handleError(error);
     }
   }
-  async executePrompt(promptId, input, options) {
-    try {
-      return await this.request(`/api/prompt/${promptId}/playground/call`, {
-        method: "POST",
-        body: JSON.stringify({ input, model: options?.model })
-      });
-    } catch (error) {
-      this.handleError(error);
-    }
-  }
-  async executePromptStream(promptId, input, options) {
-    const response = await fetch(`${this.endpoint}/api/prompt/${promptId}/execute/stream`, {
-      method: "POST",
-      headers: {
-        "x-api-key": this.apiKey,
-        "Content-Type": "application/json",
-        Accept: "text/event-stream"
-      },
-      body: JSON.stringify({ input, ...options })
-    });
-    if (!response.ok) {
-      if (response.status === 401) {
-        throw new AuthenticationError;
-      }
-      if (response.status === 403) {
-        throw new ApiError(403, await response.text() || "Access denied");
-      }
-      const error = await response.text();
-      const errorLower = error.toLowerCase();
-      if (errorLower.includes("workspace") && (errorLower.includes("missing") || errorLower.includes("required")) || errorLower.includes("x-workspace-id")) {
-        throw new WorkspaceContextError(error);
-      }
-      throw new ApiError(response.status, error);
-    }
-    return response;
-  }
   async listProviders(filters) {
     try {
       const response = await this.sdk.providerConfigs.listProviders({
@@ -1293,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, existsSync as existsSync10 } from "fs";
+import { join as join12, dirname as dirname3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/commands/auth.ts
@@ -3664,7 +3099,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"
@@ -3703,7 +3139,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\`).
@@ -3736,6 +3172,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
@@ -3746,15 +3184,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).
 
 ---
@@ -4011,7 +3449,7 @@ init_errors();
 init_sdk_client();
 var PROVIDERS_URL = "https://app.mutagent.io/settings/providers";
 function createUsageCommand() {
-  const usage = new Command8("usage").description("Show resource counts (prompts, datasets, evaluations, optimizations, experiments)").addHelpText("after", `
+  const usage = new Command8("usage").description("Show account resource counts (providers, workspaces) and provider status").addHelpText("after", `
 Examples:
   ${chalk14.dim("$")} mutagent usage
   ${chalk14.dim("$")} mutagent usage --json
@@ -4026,41 +3464,20 @@ Examples:
       }
       const spinner = await createSpinner("Fetching usage data...", isJson).start();
       const client = await getSDKClient();
-      const prompts = await client.listPrompts();
-      const promptCount = prompts.length;
-      let datasetCount = 0;
-      let evaluationCount = 0;
-      if (promptCount > 0) {
-        const results = await Promise.all(prompts.map(async (prompt) => {
-          const id = String(prompt.id);
-          const [datasets, evaluations] = await Promise.all([
-            client.listDatasets(id).catch(() => []),
-            client.listEvaluations(id).catch(() => [])
-          ]);
-          return { datasets: datasets.length, evaluations: evaluations.length };
-        }));
-        for (const r of results) {
-          datasetCount += r.datasets;
-          evaluationCount += r.evaluations;
-        }
-      }
-      const [optimizations, experiments] = await Promise.all([
-        client.listOptimizations().catch(() => []),
-        client.listExperiments().catch(() => [])
+      const [providers, workspaces] = await Promise.all([
+        client.listProviders().catch(() => ({ data: [], total: 0 })),
+        client.listWorkspaces().catch(() => ({ data: [], total: 0 }))
       ]);
-      const optimizationCount = Array.isArray(optimizations) ? optimizations.length : 0;
-      const experimentCount = Array.isArray(experiments) ? experiments.length : 0;
+      const providerCount = providers.total || providers.data.length;
+      const workspaceCount = workspaces.total || workspaces.data.length;
       if (spinner && typeof spinner.stop === "function") {
         spinner.stop();
       }
       if (isJson) {
         output.output({
           resources: {
-            prompts: promptCount,
-            datasets: datasetCount,
-            evaluations: evaluationCount,
-            optimizations: optimizationCount,
-            experiments: experimentCount
+            providers: providerCount,
+            workspaces: workspaceCount
           },
           _links: {
             providers: PROVIDERS_URL,
@@ -4073,13 +3490,10 @@ Examples:
         console.log(chalk14.dim("─".repeat(45)));
         console.log("");
         console.log(chalk14.bold("Resources:"));
-        console.log(`  Prompts:         ${chalk14.cyan(String(promptCount))}`);
-        console.log(`  Datasets:        ${chalk14.cyan(String(datasetCount))}`);
-        console.log(`  Evaluations:     ${chalk14.cyan(String(evaluationCount))}`);
-        console.log(`  Optimizations:   ${chalk14.cyan(String(optimizationCount))}`);
-        console.log(`  Experiments:     ${chalk14.cyan(String(experimentCount))}`);
+        console.log(`  Providers:       ${chalk14.cyan(String(providerCount))}`);
+        console.log(`  Workspaces:      ${chalk14.cyan(String(workspaceCount))}`);
         console.log("");
-        console.log(`  Providers: ${chalk14.underline(PROVIDERS_URL)}`);
+        console.log(`  Manage providers: ${chalk14.underline(PROVIDERS_URL)}`);
         console.log("");
       }
     } catch (error) {
@@ -5312,7 +4726,229 @@ init_errors();
 // 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 join11 } from "path";
+import {
+  existsSync as existsSync9,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync8,
+  renameSync as renameSync2,
+  rmSync,
+  writeFileSync as writeFileSync6
+} 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 ?? join11(homedir2(), ".mutagent", "helix");
+  const versionDir = join11(baseDir, descriptor.version);
+  mkdirSync5(versionDir, { recursive: true });
+  const tgzPath = join11(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");
+  }
+  renameSync2(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
+      },
+      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());
+  writeFileSync6(destPath, bytes);
+}
+async function defaultSha256(filePath) {
+  return Promise.resolve(createHash("sha256").update(readFileSync8(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 = existsSync9(join11(extractedDir, "package", "package.json")) ? join11(extractedDir, "package") : extractedDir;
+  const pkgJsonPath = join11(pkgDir, "package.json");
+  if (!existsSync9(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(readFileSync8(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 = join11(pkgDir, binRel);
+  if (!existsSync9(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 = {
@@ -5325,7 +4961,7 @@ var NPM_PACKAGES = {
   evaluator: "@mutagent/evaluator"
 };
 var defaultRunner = (cmd, args) => new Promise((resolve, reject) => {
-  const child = spawn(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+  const child = spawn2(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
   let stdout = "";
   let stderr = "";
   child.stdout.on("data", (chunk) => {
@@ -5360,7 +4996,13 @@ async function installPackage(pkg, opts, deps = {}) {
   }
   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 { 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}`];
@@ -5390,15 +5032,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) => {
@@ -5436,14 +5081,14 @@ 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 {}
 }
 setCliVersion(cliVersion);
 var program = new Command12;
-program.name("mutagent").description(`MutagenT CLI - AI-native prompt optimization platform
+program.name("mutagent").description(`MutagenT CLI - command-line client for the MutagenT platform
 
   Documentation: https://docs.mutagent.io/cli
   Dashboard:     https://app.mutagent.io`).option("-v, --version", "Display the version number").option("--json", "Output results as JSON (for AI agents)").option("--api-key <key>", "MutagenT API key").option("--endpoint <url>", "MutagenT server endpoint").option("--non-interactive", "Disable interactive prompts (for CI/AI agents)").configureHelp({
@@ -5554,12 +5199,12 @@ 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)) {
+  const skillPath = join12(process.cwd(), ".claude/skills/mutagent-cli/SKILL.md");
+  if (!existsSync10(skillPath)) {
     console.log(chalk18.dim("MutagenT SKILL not installed. Install it for AI agent support? Run:"), chalk18.cyan("mutagent skills install"));
   }
 }
 program.parse();
 
-//# debugId=99CE977B18F421C764756E2164756E21
+//# debugId=9CA84168C389E42C64756E2164756E21
 //# sourceMappingURL=cli.js.map