@mutagent/cli 0.1.13 → 0.1.15

package/dist/bin/cli.js

@@ -16,44 +16,24 @@ var __toESM = (mod, isNodeMode, target) => {
       });
   return to;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// src/bin/cli.ts
-import { Command as Command12 } from "commander";
-import chalk13 from "chalk";
-import { readFileSync as readFileSync12 } from "fs";
-import { join as join3, dirname } from "path";
-import { fileURLToPath } from "url";
-
-// src/commands/auth.ts
-import { Command } from "commander";
-import inquirer from "inquirer";
-import chalk2 from "chalk";
-import ora from "ora";
-
 // src/lib/config.ts
 import { cosmiconfigSync } from "cosmiconfig";
 import { z } from "zod";
 import { homedir } from "os";
 import { join } from "path";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
-var configSchema = z.object({
-  apiKey: z.string().optional(),
-  endpoint: z.string().default("https://api.mutagent.io"),
-  format: z.enum(["table", "json"]).default("table"),
-  timeout: z.number().default(30000),
-  defaultWorkspace: z.string().optional(),
-  defaultOrganization: z.string().optional()
-});
-var credentialsSchema = z.object({
-  apiKey: z.string().optional(),
-  endpoint: z.string().optional(),
-  defaultWorkspace: z.string().optional(),
-  defaultOrganization: z.string().optional(),
-  expiresAt: z.string().optional()
-}).loose();
-var CREDENTIALS_DIR = join(homedir(), ".config", "mutagent");
-var CREDENTIALS_FILE = join(CREDENTIALS_DIR, "credentials.json");
 function parseJsonSafe(content, schema) {
   try {
     const parsed = JSON.parse(content);
@@ -161,80 +141,28 @@ function setDefaultOrganization(organizationId) {
   };
   writeFileSync(CREDENTIALS_FILE, JSON.stringify(updated, null, 2));
 }
-
-// src/lib/sdk-client.ts
-import { Mutagent, HTTPClient } from "@mutagent/sdk";
+var configSchema, credentialsSchema, CREDENTIALS_DIR, CREDENTIALS_FILE;
+var init_config = __esm(() => {
+  configSchema = z.object({
+    apiKey: z.string().optional(),
+    endpoint: z.string().default("https://api.mutagent.io"),
+    format: z.enum(["table", "json"]).default("table"),
+    timeout: z.number().default(30000),
+    defaultWorkspace: z.string().optional(),
+    defaultOrganization: z.string().optional()
+  });
+  credentialsSchema = z.object({
+    apiKey: z.string().optional(),
+    endpoint: z.string().optional(),
+    defaultWorkspace: z.string().optional(),
+    defaultOrganization: z.string().optional(),
+    expiresAt: z.string().optional()
+  }).loose();
+  CREDENTIALS_DIR = join(homedir(), ".config", "mutagent");
+  CREDENTIALS_FILE = join(CREDENTIALS_DIR, "credentials.json");
+});
 
 // src/lib/errors.ts
-class MutagentError extends Error {
-  code;
-  suggestion;
-  exitCode;
-  constructor(code, message, suggestion, exitCode = 1) {
-    super(message);
-    this.code = code;
-    this.suggestion = suggestion;
-    this.exitCode = exitCode;
-    this.name = "MutagentError";
-  }
-  toJSON() {
-    return {
-      error: {
-        code: this.code,
-        message: this.message,
-        suggestion: this.suggestion
-      }
-    };
-  }
-}
-var AUTH_REMEDIATION_MESSAGE = [
-  "Authentication required. Options:",
-  "  Interactive:     mutagent auth login --browser",
-  "  Non-interactive: export MUTAGENT_API_KEY=<your-key>",
-  "  CI/CD:           mutagent auth login --api-key <key>"
-].join(`
-`);
-
-class AuthenticationError extends MutagentError {
-  suggestions;
-  cause;
-  constructor(message, options = {}) {
-    super("AUTH_REQUIRED", message ?? 'Authentication required. Please run "mutagent auth login"', options.suggestions ? options.suggestions[0] : "Run: mutagent auth login --browser", 2);
-    this.suggestions = options.suggestions ?? [
-      "mutagent auth login --browser",
-      "export MUTAGENT_API_KEY=<your-key>",
-      "mutagent auth login --api-key <key>"
-    ];
-    this.suggestion = options.suggestions ? options.suggestions[0] : "Run: mutagent auth login --browser";
-    this.cause = options.cause;
-  }
-}
-
-class ApiError extends MutagentError {
-  statusCode;
-  constructor(status, message) {
-    super(`API_${status}`, message, status === 401 ? "Check your API key with: mutagent auth status" : undefined, 1);
-    this.statusCode = status;
-  }
-}
-var WORKSPACE_REMEDIATION_MESSAGE = [
-  "Workspace context missing. To fix:",
-  "  mutagent config set workspace <workspace-id>   # Set default workspace",
-  "  mutagent workspaces list                        # List available workspaces"
-].join(`
-`);
-
-class WorkspaceContextError extends MutagentError {
-  constructor(message) {
-    super("WORKSPACE_CONTEXT_MISSING", message ?? "Workspace context is required but not configured", "Run: mutagent config set workspace <workspace-id>", 3);
-  }
-}
-
-class ValidationError extends MutagentError {
-  constructor(message) {
-    super("VALIDATION_ERROR", message, "Check the command syntax with: mutagent <command> --help", 1);
-  }
-}
 function handleError(error, isJson) {
   if (error instanceof MutagentError) {
     if (isJson) {
@@ -313,8 +241,87 @@ function handleError(error, isJson) {
   }
   process.exit(1);
 }
+var MutagentError, AUTH_REMEDIATION_MESSAGE, AuthenticationError, ApiError, WORKSPACE_REMEDIATION_MESSAGE, WorkspaceContextError, ValidationError;
+var init_errors = __esm(() => {
+  MutagentError = class MutagentError extends Error {
+    code;
+    suggestion;
+    exitCode;
+    constructor(code, message, suggestion, exitCode = 1) {
+      super(message);
+      this.code = code;
+      this.suggestion = suggestion;
+      this.exitCode = exitCode;
+      this.name = "MutagentError";
+    }
+    toJSON() {
+      return {
+        error: {
+          code: this.code,
+          message: this.message,
+          suggestion: this.suggestion
+        }
+      };
+    }
+  };
+  AUTH_REMEDIATION_MESSAGE = [
+    "Authentication required. Options:",
+    "  Interactive:     mutagent auth login --browser",
+    "  Non-interactive: export MUTAGENT_API_KEY=<your-key>",
+    "  CI/CD:           mutagent auth login --api-key <key>"
+  ].join(`
+`);
+  AuthenticationError = class AuthenticationError extends MutagentError {
+    suggestions;
+    cause;
+    constructor(message, options = {}) {
+      super("AUTH_REQUIRED", message ?? 'Authentication required. Please run "mutagent auth login"', options.suggestions ? options.suggestions[0] : "Run: mutagent auth login --browser", 2);
+      this.suggestions = options.suggestions ?? [
+        "mutagent auth login --browser",
+        "export MUTAGENT_API_KEY=<your-key>",
+        "mutagent auth login --api-key <key>"
+      ];
+      this.suggestion = options.suggestions ? options.suggestions[0] : "Run: mutagent auth login --browser";
+      this.cause = options.cause;
+    }
+  };
+  ApiError = class ApiError extends MutagentError {
+    statusCode;
+    constructor(status, message) {
+      super(`API_${String(status)}`, message, status === 401 ? "Check your API key with: mutagent auth status" : undefined, 1);
+      this.statusCode = status;
+    }
+  };
+  WORKSPACE_REMEDIATION_MESSAGE = [
+    "Workspace context missing. To fix:",
+    "  mutagent config set workspace <workspace-id>   # Set default workspace",
+    "  mutagent workspaces list                        # List available workspaces"
+  ].join(`
+`);
+  WorkspaceContextError = class WorkspaceContextError extends MutagentError {
+    constructor(message) {
+      super("WORKSPACE_CONTEXT_MISSING", message ?? "Workspace context is required but not configured", "Run: mutagent config set workspace <workspace-id>", 3);
+    }
+  };
+  ValidationError = class ValidationError extends MutagentError {
+    constructor(message) {
+      super("VALIDATION_ERROR", message, "Check the command syntax with: mutagent <command> --help", 1);
+    }
+  };
+});
 
 // src/lib/sdk-client.ts
+var exports_sdk_client = {};
+__export(exports_sdk_client, {
+  validateApiKey: () => validateApiKey,
+  resetSDKClient: () => resetSDKClient,
+  getSDKClient: () => getSDKClient,
+  fetchWorkspaces: () => fetchWorkspaces,
+  fetchOrganizations: () => fetchOrganizations,
+  MutagentSDK: () => SDKClientWrapper
+});
+import { Mutagent, HTTPClient } from "@mutagent/sdk";
+
 class SDKClientWrapper {
   sdk;
   apiKey;
@@ -853,7 +860,6 @@ class SDKClientWrapper {
     }
   }
 }
-var sdkClient = null;
 function getSDKClient() {
   if (!sdkClient) {
     const apiKey = getApiKey();
@@ -870,6 +876,9 @@ function getSDKClient() {
   }
   return sdkClient;
 }
+function resetSDKClient() {
+  sdkClient = null;
+}
 async function validateApiKey(apiKey, endpoint) {
   try {
     const response = await fetch(`${endpoint}/api/organizations`, {
@@ -906,6 +915,28 @@ async function fetchWorkspaces(apiKey, endpoint, orgId) {
     return [];
   }
 }
+var sdkClient = null;
+var init_sdk_client = __esm(() => {
+  init_errors();
+  init_config();
+});
+
+// src/bin/cli.ts
+import { Command as Command14 } from "commander";
+import chalk18 from "chalk";
+import { readFileSync as readFileSync14 } from "fs";
+import { join as join7, dirname } from "path";
+import { fileURLToPath } from "url";
+
+// src/commands/auth.ts
+init_config();
+init_sdk_client();
+import { Command } from "commander";
+import inquirer from "inquirer";
+import chalk3 from "chalk";
+import ora from "ora";
+import { existsSync as existsSync3 } from "fs";
+import { join as join4 } from "path";
 
 // src/lib/output.ts
 import chalk from "chalk";
@@ -1028,6 +1059,9 @@ ${String(data.length)} result(s)`));
   }
 }
 
+// src/commands/auth.ts
+init_errors();
+
 // src/lib/browser-auth.ts
 import { hostname, platform } from "os";
 function generateCliToken() {
@@ -1165,22 +1199,658 @@ class BrowserAuthError extends Error {
   }
 }
 
+// src/lib/mutation-context.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join2, resolve } from "path";
+function parseTableRows(lines) {
+  const rows = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("|") || !trimmed.endsWith("|"))
+      continue;
+    if (/^\|[\s-:|]+\|$/.test(trimmed))
+      continue;
+    const cells = trimmed.slice(1, -1).split("|").map((c) => c.trim());
+    rows.push(cells);
+  }
+  return rows;
+}
+function emptyToUndefined(value) {
+  return value && value.length > 0 ? value : undefined;
+}
+function renderTable(headers, rows) {
+  const separator = headers.map((h) => "-".repeat(Math.max(h.length, 3)));
+  const lines = [
+    `| ${headers.join(" | ")} |`,
+    `| ${separator.join(" | ")} |`,
+    ...rows.map((r) => `| ${r.join(" | ")} |`)
+  ];
+  return lines.join(`
+`);
+}
+var CONTEXT_DIR = ".mutagent";
+var CONTEXT_FILE = "mutation-context.md";
+
+class MutationContext {
+  prompts = [];
+  datasets = [];
+  evaluations = [];
+  integrations = [];
+  filePath;
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  static load(projectRoot) {
+    const root = projectRoot ?? process.cwd();
+    const dirPath = join2(resolve(root), CONTEXT_DIR);
+    const filePath = join2(dirPath, CONTEXT_FILE);
+    const ctx = new MutationContext(filePath);
+    if (existsSync2(filePath)) {
+      const content = readFileSync2(filePath, "utf-8");
+      ctx.parse(content);
+    }
+    return ctx;
+  }
+  save() {
+    const dirPath = join2(this.filePath, "..");
+    if (!existsSync2(dirPath)) {
+      mkdirSync2(dirPath, { recursive: true });
+    }
+    writeFileSync2(this.filePath, this.render(), "utf-8");
+  }
+  addDiscoveredPrompt(file, line, preview) {
+    const existing = this.prompts.find((p) => p.file === file && p.line === line);
+    if (existing) {
+      existing.preview = preview;
+      return;
+    }
+    this.prompts.push({ file, line, preview, status: "discovered" });
+  }
+  markPromptUploaded(file, platformId, version) {
+    const entry = this.prompts.find((p) => p.file === file);
+    if (entry) {
+      entry.platformId = platformId;
+      entry.version = version;
+      entry.status = "uploaded";
+    }
+  }
+  getDiscoveredPrompts() {
+    return this.prompts.filter((p) => p.status === "discovered");
+  }
+  getUploadedPrompts() {
+    return this.prompts.filter((p) => p.status === "uploaded");
+  }
+  addDiscoveredDataset(file, name, items) {
+    const existing = this.datasets.find((d) => d.file === file && d.name === name);
+    if (existing) {
+      existing.items = items;
+      return;
+    }
+    this.datasets.push({ file, name, items, status: "discovered" });
+  }
+  markDatasetUploaded(file, platformId, promptId) {
+    const entry = this.datasets.find((d) => d.file === file);
+    if (entry) {
+      entry.platformId = platformId;
+      entry.promptId = promptId;
+      entry.status = "uploaded";
+    }
+  }
+  addEvaluation(name, criteriaCount, platformId, promptId) {
+    const existing = this.evaluations.find((e) => e.name === name);
+    if (existing) {
+      existing.criteriaCount = criteriaCount;
+      existing.platformId = platformId;
+      existing.promptId = promptId;
+      existing.status = "uploaded";
+      return;
+    }
+    this.evaluations.push({ name, criteriaCount, platformId, promptId, status: "uploaded" });
+  }
+  setIntegrationStatus(framework, pkg, status) {
+    const existing = this.integrations.find((i) => i.framework === framework);
+    if (existing) {
+      existing.pkg = pkg;
+      existing.status = status;
+      return;
+    }
+    this.integrations.push({ framework, pkg, status });
+  }
+  getSummary() {
+    return {
+      prompts: this.prompts.length,
+      datasets: this.datasets.length,
+      evaluations: this.evaluations.length,
+      integrated: this.integrations.map((i) => i.framework)
+    };
+  }
+  render() {
+    const now = new Date().toISOString();
+    const sections = [
+      "# MutagenT Mutation Context",
+      `<!-- MutagenT:AUTO-GENERATED - Do not edit manually -->`,
+      `<!-- Last updated: ${now} -->`,
+      "",
+      "## Discovered Resources",
+      "",
+      "### Prompts",
+      renderTable(["File", "Line", "Content Preview", "Platform ID", "Version", "Status"], this.prompts.map((p) => [
+        p.file,
+        String(p.line),
+        p.preview,
+        p.platformId ?? "",
+        p.version ?? "",
+        p.status
+      ])),
+      "",
+      "### Datasets",
+      renderTable(["File", "Name", "Items", "Platform ID", "Prompt ID", "Status"], this.datasets.map((d) => [
+        d.file,
+        d.name,
+        String(d.items),
+        d.platformId ?? "",
+        d.promptId ?? "",
+        d.status
+      ])),
+      "",
+      "### Evaluations",
+      renderTable(["Name", "Criteria Count", "Platform ID", "Prompt ID", "Status"], this.evaluations.map((e) => [
+        e.name,
+        String(e.criteriaCount),
+        e.platformId ?? "",
+        e.promptId ?? "",
+        e.status
+      ])),
+      "",
+      "## Integration Status",
+      renderTable(["Framework", "Package", "Status"], this.integrations.map((i) => [
+        i.framework,
+        i.pkg,
+        i.status
+      ])),
+      ""
+    ];
+    return sections.join(`
+`);
+  }
+  parse(content) {
+    const lines = content.split(`
+`);
+    let currentSection = null;
+    let sectionLines = [];
+    const flushSection = () => {
+      if (!currentSection || sectionLines.length === 0)
+        return;
+      const rows = parseTableRows(sectionLines);
+      const dataRows = rows.slice(1);
+      switch (currentSection) {
+        case "prompts":
+          for (const row of dataRows) {
+            const [file, lineStr, preview, pid, ver, st] = row;
+            if (file !== undefined && lineStr !== undefined && preview !== undefined) {
+              this.prompts.push({
+                file,
+                line: parseInt(lineStr, 10) || 0,
+                preview,
+                platformId: emptyToUndefined(pid),
+                version: emptyToUndefined(ver),
+                status: emptyToUndefined(st) ?? "discovered"
+              });
+            }
+          }
+          break;
+        case "datasets":
+          for (const row of dataRows) {
+            const [file, name, itemsStr, pid, prid, st] = row;
+            if (file !== undefined && name !== undefined && itemsStr !== undefined) {
+              this.datasets.push({
+                file,
+                name,
+                items: parseInt(itemsStr, 10) || 0,
+                platformId: emptyToUndefined(pid),
+                promptId: emptyToUndefined(prid),
+                status: emptyToUndefined(st) ?? "discovered"
+              });
+            }
+          }
+          break;
+        case "evaluations":
+          for (const row of dataRows) {
+            const [name, ccStr, pid, prid, st] = row;
+            if (name !== undefined && ccStr !== undefined) {
+              this.evaluations.push({
+                name,
+                criteriaCount: parseInt(ccStr, 10) || 0,
+                platformId: emptyToUndefined(pid),
+                promptId: emptyToUndefined(prid),
+                status: emptyToUndefined(st) ?? "discovered"
+              });
+            }
+          }
+          break;
+        case "integrations":
+          for (const row of dataRows) {
+            const [framework, pkg, status] = row;
+            if (framework !== undefined && pkg !== undefined && status !== undefined) {
+              this.integrations.push({ framework, pkg, status });
+            }
+          }
+          break;
+      }
+      sectionLines = [];
+    };
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed === "### Prompts") {
+        flushSection();
+        currentSection = "prompts";
+        continue;
+      }
+      if (trimmed === "### Datasets") {
+        flushSection();
+        currentSection = "datasets";
+        continue;
+      }
+      if (trimmed === "### Evaluations") {
+        flushSection();
+        currentSection = "evaluations";
+        continue;
+      }
+      if (trimmed === "## Integration Status") {
+        flushSection();
+        currentSection = "integrations";
+        continue;
+      }
+      if (trimmed.startsWith("## ") && currentSection !== null && trimmed !== "## Integration Status") {
+        flushSection();
+        currentSection = null;
+        continue;
+      }
+      if (currentSection && trimmed.startsWith("|")) {
+        sectionLines.push(trimmed);
+      }
+    }
+    flushSection();
+  }
+}
+
+// src/commands/onboarding.ts
+import chalk2 from "chalk";
+import { resolve as resolve2 } from "path";
+
+// src/lib/explorer.ts
+import { readdirSync, readFileSync as readFileSync3, statSync } from "fs";
+import { join as join3, relative, extname, basename } from "path";
+var TEMPLATE_VAR_PATTERN = /\{\{[a-zA-Z_][a-zA-Z0-9_]*\}\}/;
+var PROMPT_NAME_PATTERN = /(?:const|let|var|export)\s+\w*(?:prompt|system|agent|instruction|template)\w*\s*=/i;
+var SCHEMA_PATTERN = /["']?(?:inputSchema|outputSchema|properties|required)["']?\s*[=:]/;
+var ZOD_SCHEMA_PATTERN = /z\.object\s*\(/;
+var PYDANTIC_PATTERN = /class\s+\w+\s*\(\s*(?:BaseModel|BaseSettings)\s*\)/;
+var MARKER_START_PATTERN = /MutagenT:START\s+(\w+)(?:\s+id=(\S+))?/;
+function walkDir(dir, extensions, excludeDirs, maxDepth, currentDepth = 0) {
+  if (currentDepth >= maxDepth)
+    return [];
+  const files = [];
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return files;
+  }
+  for (const entry of entries) {
+    const fullPath = join3(dir, entry);
+    let stat;
+    try {
+      stat = statSync(fullPath);
+    } catch {
+      continue;
+    }
+    if (stat.isDirectory()) {
+      if (excludeDirs.includes(entry))
+        continue;
+      files.push(...walkDir(fullPath, extensions, excludeDirs, maxDepth, currentDepth + 1));
+    } else if (stat.isFile()) {
+      const ext = extname(entry).toLowerCase();
+      if (extensions.includes(ext)) {
+        files.push(fullPath);
+      }
+    }
+  }
+  return files;
+}
+function scanForPrompts(filePath, relativePath) {
+  const results = [];
+  let content;
+  try {
+    content = readFileSync3(filePath, "utf-8");
+  } catch {
+    return results;
+  }
+  const lines = content.split(`
+`);
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    if (!line)
+      continue;
+    if (TEMPLATE_VAR_PATTERN.test(line)) {
+      const preview = line.trim().substring(0, 80);
+      results.push({
+        file: relativePath,
+        line: i + 1,
+        preview,
+        reason: "template-variable"
+      });
+    }
+    if (PROMPT_NAME_PATTERN.test(line)) {
+      const preview = line.trim().substring(0, 80);
+      if (!results.some((r) => r.file === relativePath && r.line === i + 1)) {
+        results.push({
+          file: relativePath,
+          line: i + 1,
+          preview,
+          reason: "prompt-constant"
+        });
+      }
+    }
+    if (ZOD_SCHEMA_PATTERN.test(line)) {
+      const preview = line.trim().substring(0, 80);
+      if (!results.some((r) => r.file === relativePath && r.line === i + 1)) {
+        results.push({
+          file: relativePath,
+          line: i + 1,
+          preview,
+          reason: "zod-schema"
+        });
+      }
+    }
+    if (PYDANTIC_PATTERN.test(line)) {
+      const preview = line.trim().substring(0, 80);
+      if (!results.some((r) => r.file === relativePath && r.line === i + 1)) {
+        results.push({
+          file: relativePath,
+          line: i + 1,
+          preview,
+          reason: "pydantic-model"
+        });
+      }
+    }
+  }
+  return results;
+}
+function scanForMarkers(filePath, relativePath) {
+  const results = [];
+  let content;
+  try {
+    content = readFileSync3(filePath, "utf-8");
+  } catch {
+    return results;
+  }
+  const lines = content.split(`
+`);
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    if (!line)
+      continue;
+    const match = MARKER_START_PATTERN.exec(line);
+    if (match) {
+      const rawType = match[1]?.toLowerCase();
+      const platformId = match[2];
+      const validTypes = new Set(["prompt", "dataset", "evaluation"]);
+      if (rawType && validTypes.has(rawType)) {
+        results.push({
+          file: relativePath,
+          line: i + 1,
+          type: rawType,
+          platformId
+        });
+      }
+    }
+  }
+  return results;
+}
+function scanJsonForSchemas(filePath, relativePath) {
+  const results = [];
+  const ext = extname(filePath).toLowerCase();
+  if (ext !== ".json")
+    return results;
+  let content;
+  try {
+    content = readFileSync3(filePath, "utf-8");
+  } catch {
+    return results;
+  }
+  if (!SCHEMA_PATTERN.test(content))
+    return results;
+  const preview = `JSON with schema definitions: ${basename(filePath)}`;
+  results.push({
+    file: relativePath,
+    line: 1,
+    preview: preview.substring(0, 80),
+    reason: "json-schema"
+  });
+  return results;
+}
+function scanForDatasets(dir, rootPath, excludeDirs, maxDepth) {
+  const results = [];
+  const dataExtensions = [".json", ".jsonl", ".csv"];
+  const files = walkDir(dir, dataExtensions, excludeDirs, maxDepth);
+  for (const filePath of files) {
+    const relativePath = relative(rootPath, filePath);
+    const ext = extname(filePath).toLowerCase();
+    const name = basename(filePath, ext);
+    let content;
+    try {
+      content = readFileSync3(filePath, "utf-8");
+    } catch {
+      continue;
+    }
+    if (ext === ".csv") {
+      const lines = content.trim().split(`
+`);
+      if (lines.length > 1) {
+        const header = lines[0]?.toLowerCase() ?? "";
+        if (header.includes("input") || header.includes("output") || header.includes("expected")) {
+          results.push({ file: relativePath, name, items: lines.length - 1 });
+        }
+      }
+    } else if (ext === ".jsonl") {
+      const lines = content.trim().split(`
+`).filter((l) => l.trim().length > 0);
+      if (lines.length > 0) {
+        try {
+          const first = JSON.parse(lines[0] ?? "{}");
+          if ("input" in first || "expectedOutput" in first) {
+            results.push({ file: relativePath, name, items: lines.length });
+          }
+        } catch {}
+      }
+    } else if (ext === ".json") {
+      try {
+        const parsed = JSON.parse(content);
+        if (Array.isArray(parsed) && parsed.length > 0) {
+          const first = parsed[0];
+          if ("input" in first || "expectedOutput" in first) {
+            results.push({ file: relativePath, name, items: parsed.length });
+          }
+        }
+      } catch {}
+    }
+  }
+  return results;
+}
+function exploreCodebase(options) {
+  const rootPath = options.path;
+  const prompts = [];
+  const datasets = [];
+  const markers = [];
+  const sourceFiles = walkDir(rootPath, options.extensions, options.excludeDirs, options.depth);
+  for (const filePath of sourceFiles) {
+    const relativePath = relative(rootPath, filePath);
+    markers.push(...scanForMarkers(filePath, relativePath));
+    if (!options.markersOnly) {
+      prompts.push(...scanForPrompts(filePath, relativePath));
+    }
+  }
+  if (!options.markersOnly) {
+    const jsonFiles = walkDir(rootPath, [".json"], options.excludeDirs, options.depth);
+    for (const filePath of jsonFiles) {
+      const relativePath = relative(rootPath, filePath);
+      prompts.push(...scanJsonForSchemas(filePath, relativePath));
+    }
+    datasets.push(...scanForDatasets(rootPath, rootPath, options.excludeDirs, options.depth));
+  }
+  return { prompts, datasets, markers };
+}
+function parseExtensions(includeGlob) {
+  const braceMatch = /\{([^}]+)\}/.exec(includeGlob);
+  if (braceMatch?.[1]) {
+    return braceMatch[1].split(",").map((ext) => `.${ext.trim()}`);
+  }
+  const extMatch = /\*\.(\w+)$/.exec(includeGlob);
+  if (extMatch?.[1]) {
+    return [`.${extMatch[1]}`];
+  }
+  return [".ts", ".js", ".py", ".tsx", ".jsx"];
+}
+function parseExcludeDirs(excludePattern) {
+  return excludePattern.split(",").map((d) => d.trim()).filter(Boolean);
+}
+
+// src/commands/onboarding.ts
+async function runPostOnboarding() {
+  const inquirer = (await import("inquirer")).default;
+  console.log("");
+  console.log(chalk2.bold.cyan("  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")} Guided Integration — connect your AI framework`,
+        value: "integrate"
+      },
+      {
+        name: `${chalk2.green("B")} Quick Optimization — upload a prompt and optimize it`,
+        value: "optimize"
+      },
+      {
+        name: `${chalk2.green("C")} Exit — explore on your own`,
+        value: "exit"
+      }
+    ]
+  }]);
+  if (selectedPath === "exit") {
+    console.log("");
+    console.log(chalk2.dim("  You can run `mutagent --help` anytime to see available commands."));
+    console.log(chalk2.dim("  Try `mutagent explore` to scan your codebase for prompts."));
+    console.log("");
+    return;
+  }
+  console.log("");
+  console.log(chalk2.cyan("  Scanning your codebase..."));
+  console.log("");
+  const scanPath = resolve2(".");
+  const result = exploreCodebase({
+    path: scanPath,
+    depth: 10,
+    extensions: parseExtensions("**/*.{ts,js,py,tsx,jsx}"),
+    excludeDirs: parseExcludeDirs("node_modules,dist,.git,build,.next,__pycache__,venv,.venv"),
+    markersOnly: false
+  });
+  const totalFindings = result.prompts.length + result.datasets.length;
+  if (totalFindings > 0) {
+    console.log(chalk2.green(`  Found ${String(result.prompts.length)} prompt(s) and ${String(result.datasets.length)} dataset(s)`));
+  } else {
+    console.log(chalk2.dim("  No prompts or datasets detected yet."));
+  }
+  console.log("");
+  if (selectedPath === "integrate") {
+    await runIntegrationPath();
+  } else {
+    runOptimizationPath(result.prompts.length, result.datasets.length);
+  }
+}
+async function runIntegrationPath() {
+  const inquirerMod = (await import("inquirer")).default;
+  const { framework } = await inquirerMod.prompt([{
+    type: "list",
+    name: "framework",
+    message: "Which AI framework are you using?",
+    choices: [
+      { name: "Mastra", value: "mastra" },
+      { name: "LangChain", value: "langchain" },
+      { name: "LangGraph", value: "langgraph" },
+      { name: "Vercel AI SDK", value: "vercel-ai" },
+      { name: "Claude Code", value: "claude-code" },
+      { name: "Other / Generic", value: "generic" }
+    ]
+  }]);
+  console.log("");
+  console.log(chalk2.bold("  Next steps:"));
+  console.log("");
+  console.log(`    1. ${chalk2.green(`mutagent integrate ${framework}`)}`);
+  console.log(`       Get the integration guide for ${framework}`);
+  console.log("");
+  console.log(`    2. ${chalk2.green(`mutagent integrate ${framework} --verify`)}`);
+  console.log("       Verify your integration is working");
+  console.log("");
+  console.log(`    3. ${chalk2.green("mutagent explore")}`);
+  console.log("       Re-scan to confirm markers are in place");
+  console.log("");
+}
+function runOptimizationPath(promptCount, datasetCount) {
+  console.log(chalk2.bold("  Quick Optimization Workflow:"));
+  console.log("");
+  let step = 1;
+  if (promptCount === 0) {
+    console.log(`    ${String(step)}. ${chalk2.green('mutagent prompts create --name "my-prompt" --raw "Your prompt with {{variables}}"')}`);
+    console.log("       Create a prompt with template variables");
+    console.log("");
+    step++;
+  } else {
+    console.log(chalk2.dim(`    ${chalk2.green("✓")} Prompts detected in codebase (${String(promptCount)} found)`));
+    console.log(chalk2.dim(`      Upload one: mutagent prompts create --name "my-prompt" --raw-file <path>`));
+    console.log("");
+  }
+  if (datasetCount === 0) {
+    console.log(`    ${String(step)}. ${chalk2.green("mutagent prompts dataset add <prompt-id> --file dataset.json")}`);
+    console.log("       Upload a dataset with input/output pairs");
+    console.log("");
+    step++;
+  } else {
+    console.log(chalk2.dim(`    ${chalk2.green("✓")} Datasets detected in codebase (${String(datasetCount)} found)`));
+    console.log(chalk2.dim(`      Upload one: mutagent prompts dataset add <prompt-id> --file <path>`));
+    console.log("");
+  }
+  console.log(`    ${String(step)}. ${chalk2.green('mutagent prompts evaluation create <prompt-id> --name "My Eval" --file criteria.json')}`);
+  console.log("       Define evaluation criteria");
+  console.log("");
+  step++;
+  console.log(`    ${String(step)}. ${chalk2.green("mutagent prompts optimize start <prompt-id> --dataset <dataset-id>")}`);
+  console.log("       Start the optimization loop");
+  console.log("");
+  console.log(chalk2.dim("  Tip: Use `mutagent prompts list` to see your prompt IDs."));
+  console.log("");
+}
+
 // src/commands/auth.ts
 function createAuthCommand() {
   const auth = new Command("auth").description("Authenticate with MutagenT platform").addHelpText("after", `
 Examples:
-  ${chalk2.dim("$")} mutagent auth login
-  ${chalk2.dim("$")} mutagent auth login --browser
-  ${chalk2.dim("$")} mutagent auth login --api-key <key>
-  ${chalk2.dim("$")} mutagent auth status
-  ${chalk2.dim("$")} mutagent auth logout
+  ${chalk3.dim("$")} mutagent auth login
+  ${chalk3.dim("$")} mutagent auth login --browser
+  ${chalk3.dim("$")} mutagent auth login --api-key <key>
+  ${chalk3.dim("$")} mutagent auth status
+  ${chalk3.dim("$")} mutagent auth logout
     `);
   auth.command("login").description("Authenticate and store API key").option("--api-key <key>", "API key (non-interactive)").option("--browser", "Force browser-based authentication").option("--non-interactive", "Disable interactive prompts (auto-selects browser auth)").option("--endpoint <url>", "API endpoint", "https://api.mutagent.io").addHelpText("after", `
 Examples:
-  ${chalk2.dim("$")} mutagent auth login                    ${chalk2.dim("# Interactive (choose method)")}
-  ${chalk2.dim("$")} mutagent auth login --browser          ${chalk2.dim("# Browser OAuth flow")}
-  ${chalk2.dim("$")} mutagent auth login --api-key mg_live_xxx  ${chalk2.dim("# Direct API key (CI/CD)")}
-  ${chalk2.dim("$")} mutagent auth login --non-interactive  ${chalk2.dim("# Auto browser flow (AI agents)")}
+  ${chalk3.dim("$")} mutagent auth login                    ${chalk3.dim("# Interactive (choose method)")}
+  ${chalk3.dim("$")} mutagent auth login --browser          ${chalk3.dim("# Browser OAuth flow")}
+  ${chalk3.dim("$")} mutagent auth login --api-key mg_live_xxx  ${chalk3.dim("# Direct API key (CI/CD)")}
+  ${chalk3.dim("$")} mutagent auth login --non-interactive  ${chalk3.dim("# Auto browser flow (AI agents)")}
 
 Environment Variables:
   MUTAGENT_API_KEY              API key (skips login entirely)
@@ -1191,6 +1861,7 @@ Environment Variables:
     const isJson = getJsonFlag(auth);
     const output = new OutputFormatter(isJson ? "json" : "table");
     try {
+      const wasFirstLogin = !hasCredentials();
       let apiKey = options.apiKey ?? process.env.MUTAGENT_API_KEY;
       let endpoint = process.env.MUTAGENT_ENDPOINT ?? options.endpoint;
       let workspaceName;
@@ -1228,7 +1899,7 @@ Environment Variables:
       }
       if (!isNonInteractive && !hasCredentials()) {
         console.log(`
-` + chalk2.bold.cyan("  Welcome to MutagenT CLI!") + `
+` + chalk3.bold.cyan("  Welcome to MutagenT CLI!") + `
 `);
         console.log(`  No credentials found. Please authenticate to continue.
 `);
@@ -1368,6 +2039,9 @@ Environment Variables:
           output.info("Workspace: " + selectedWsName);
         output.info("Endpoint: " + endpoint);
       }
+      if (wasFirstLogin && process.stdin.isTTY && !isJson) {
+        await runPostOnboarding();
+      }
     } catch (error) {
       if (error instanceof MutagentError) {
         output.error(error.message);
@@ -1378,8 +2052,8 @@ Environment Variables:
   });
   auth.command("status").description("Check authentication status").addHelpText("after", `
 Examples:
-  ${chalk2.dim("$")} mutagent auth status
-  ${chalk2.dim("$")} mutagent auth status --json
+  ${chalk3.dim("$")} mutagent auth status
+  ${chalk3.dim("$")} mutagent auth status --json
     `).action(async () => {
     const isJson = getJsonFlag(auth);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -1396,13 +2070,26 @@ Examples:
       process.exit(0);
     }
     const isValid = await validateApiKey(apiKey, endpoint);
+    const cwd = process.cwd();
+    const hasOnboarding = existsSync3(join4(cwd, ".mutagentrc.json"));
+    const hasContextFile = existsSync3(join4(cwd, ".mutagent", "mutation-context.md"));
+    let contextSummary;
+    if (hasContextFile) {
+      try {
+        const ctx = MutationContext.load(cwd);
+        contextSummary = ctx.getSummary();
+      } catch {}
+    }
     if (isJson) {
       const statusResult = {
         authenticated: isValid,
         endpoint,
         keyPrefix: `${apiKey.slice(0, 8)}...`,
         defaultWorkspace: config.defaultWorkspace,
-        defaultOrganization: config.defaultOrganization
+        defaultOrganization: config.defaultOrganization,
+        onboarding: hasOnboarding,
+        contextFile: hasContextFile,
+        context: contextSummary ?? null
       };
       if (!isValid) {
         statusResult.message = "Authentication invalid — run `mutagent auth login --browser`";
@@ -1415,7 +2102,7 @@ Examples:
       output.output(statusResult);
     } else {
       if (isValid) {
-        output.success("Authenticated");
+        output.success("Authentication: Authenticated");
         output.info(`Endpoint: ${endpoint}`);
         output.info(`Key: ${apiKey.slice(0, 8)}...`);
         if (config.defaultWorkspace) {
@@ -1425,18 +2112,38 @@ Examples:
           output.info(`Organization: ${config.defaultOrganization}`);
         }
       } else {
-        output.error("Authentication invalid — run `mutagent auth login --browser`");
+        output.error("Authentication: Invalid — run `mutagent auth login --browser`");
         console.error("");
         console.error("Authentication required. Options:");
         console.error("  Interactive:     mutagent auth login --browser");
         console.error("  Non-interactive: export MUTAGENT_API_KEY=<your-key>");
         console.error("  CI/CD:           mutagent auth login --api-key <key>");
       }
+      if (hasOnboarding) {
+        output.success("Onboarding: Complete (.mutagentrc.json found)");
+      } else {
+        output.warn("Onboarding: Not initialized (run `mutagent init`)");
+      }
+      if (hasContextFile && contextSummary) {
+        const parts = [
+          `${String(contextSummary.prompts)} prompts`,
+          `${String(contextSummary.datasets)} datasets`,
+          `${String(contextSummary.evaluations)} evaluations`
+        ];
+        output.success(`Context File: .mutagent/mutation-context.md (${parts.join(", ")})`);
+      } else if (hasContextFile) {
+        output.success("Context File: .mutagent/mutation-context.md");
+      } else {
+        output.warn("Context File: Not found (run `mutagent explore`)");
+      }
+      if (contextSummary && contextSummary.integrated.length > 0) {
+        output.success(`Integration: ${contextSummary.integrated.join(", ")} (active)`);
+      }
     }
   });
   auth.command("logout").description("Clear stored credentials").addHelpText("after", `
 Examples:
-  ${chalk2.dim("$")} mutagent auth logout
+  ${chalk3.dim("$")} mutagent auth logout
     `).action(() => {
     const isJson = getJsonFlag(auth);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -1447,17 +2154,20 @@ Examples:
 }
 
 // src/commands/login.ts
+init_config();
+init_sdk_client();
 import { Command as Command2 } from "commander";
 import inquirer2 from "inquirer";
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 import ora2 from "ora";
+init_errors();
 function createLoginCommand() {
   const login = new Command2("login").description("Login to MutagenT platform").option("--api-key <key>", "API key (non-interactive)").option("--browser", "Force browser-based authentication").option("--non-interactive", "Disable interactive prompts (auto-selects browser auth)").option("--endpoint <url>", "API endpoint", "https://api.mutagent.io").addHelpText("after", `
 Examples:
-  ${chalk3.dim("$")} mutagent login
-  ${chalk3.dim("$")} mutagent login --browser
-  ${chalk3.dim("$")} mutagent login --api-key <key>
-  ${chalk3.dim("$")} mutagent login --non-interactive  ${chalk3.dim("# Auto browser flow (AI agents)")}
+  ${chalk4.dim("$")} mutagent login
+  ${chalk4.dim("$")} mutagent login --browser
+  ${chalk4.dim("$")} mutagent login --api-key <key>
+  ${chalk4.dim("$")} mutagent login --non-interactive  ${chalk4.dim("# Auto browser flow (AI agents)")}
     `).action(async (options) => {
     const isJson = getJsonFlag(login);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -1483,7 +2193,7 @@ Examples:
       }
       if (!isNonInteractive && !hasCredentials()) {
         console.log(`
-` + chalk3.bold.cyan("  Welcome to MutagenT CLI!") + `
+` + chalk4.bold.cyan("  Welcome to MutagenT CLI!") + `
 `);
         console.log(`  No credentials found. Please authenticate to continue.
 `);
@@ -1590,9 +2300,11 @@ Examples:
 }
 
 // src/commands/prompts.ts
+init_sdk_client();
 import { Command as Command3 } from "commander";
-import chalk4 from "chalk";
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import chalk7 from "chalk";
+import { readFileSync as readFileSync4, existsSync as existsSync4 } from "fs";
+init_errors();
 
 // src/lib/ui-links.ts
 function getAppBaseUrl() {
@@ -1626,6 +2338,33 @@ function playgroundLink() {
 function providerSettingsLink() {
   return `${getAppBaseUrl()}/settings/providers`;
 }
+function workspaceLink(id) {
+  return `${getAppBaseUrl()}/settings/workspaces/${String(id)}`;
+}
+function workspaceLinks(id) {
+  return {
+    settings: workspaceLink(id),
+    api: `/api/workspaces/${String(id)}`
+  };
+}
+function providerLink(id) {
+  return `${getAppBaseUrl()}/settings/providers/${String(id)}`;
+}
+function providerLinks(id) {
+  return {
+    settings: providerLink(id),
+    api: `/api/providers/${String(id)}`
+  };
+}
+function agentLink(id) {
+  return `${getAppBaseUrl()}/agents/${String(id)}`;
+}
+function agentLinks(id) {
+  return {
+    dashboard: agentLink(id),
+    api: `/api/agents/${String(id)}`
+  };
+}
 function promptLinks(promptId) {
   return {
     dashboard: promptLink(promptId),
@@ -1674,46 +2413,344 @@ function isValidJsonSchema(schema) {
     if (!("properties" in obj) || typeof obj.properties !== "object" || obj.properties === null) {
       return false;
     }
-  }
-  return true;
-}
-function buildSchemaFromVariables(variables) {
-  const properties = {};
-  for (const variable of variables) {
-    const prop = { type: variable.type };
-    if (variable.description) {
-      prop.description = variable.description;
+  }
+  return true;
+}
+function buildSchemaFromVariables(variables) {
+  const properties = {};
+  for (const variable of variables) {
+    const prop = { type: variable.type };
+    if (variable.description) {
+      prop.description = variable.description;
+    }
+    properties[variable.name] = prop;
+  }
+  return {
+    type: "object",
+    properties
+  };
+}
+function formatSchemaWarning(fieldName) {
+  return [
+    `${fieldName} doesn't appear to be a valid JSON Schema.`,
+    "",
+    "  Expected format:",
+    "  {",
+    '    "type": "object",',
+    '    "properties": {',
+    '      "variable_name": { "type": "string", "description": "Description here" }',
+    "    }",
+    "  }",
+    "",
+    "  You can also provide a schema file: mutagent prompts create --file schema.json"
+  ].join(`
+`);
+}
+
+// src/lib/eval-creator.ts
+import chalk5 from "chalk";
+var RUBRIC_TEMPLATES = {
+  "Exact Match": "Score 1.0 if the output exactly matches the expected value, 0.0 otherwise.",
+  "Semantic Similarity": "Score 0.0-1.0 based on semantic similarity to the expected output. 1.0 = identical meaning, 0.5 = partially related, 0.0 = unrelated.",
+  "Contains Key Info": "Score 1.0 if all key information from expected output is present, 0.5 if partially present, 0.0 if missing.",
+  "Format Compliance": "Score 1.0 if the output follows the expected format/structure, 0.5 for minor deviations, 0.0 for wrong format.",
+  "Factual Accuracy": "Score 1.0 if all facts are correct, 0.5 if mostly correct with minor errors, 0.0 if incorrect."
+};
+var EVAL_TYPE_DESCRIPTIONS = {
+  accuracy: "Check if outputs match expected results (exact or semantic)",
+  quality: "Assess output quality, clarity, and helpfulness",
+  custom: "Define your own evaluation criteria"
+};
+function extractSchemaFields(schema, prefix) {
+  if (!schema || typeof schema !== "object")
+    return [];
+  const obj = schema;
+  const properties = obj.properties;
+  if (properties) {
+    return Object.keys(properties).map((key) => `${prefix}.${key}`);
+  }
+  const keys = Object.keys(obj).filter((k) => k !== "type" && k !== "required" && k !== "description");
+  if (keys.length > 0) {
+    return keys.map((key) => `${prefix}.${key}`);
+  }
+  return [];
+}
+async function runGuidedEvalCreator(promptId) {
+  const inquirer3 = (await import("inquirer")).default;
+  console.log("");
+  console.log(chalk5.cyan("  Fetching prompt details..."));
+  let inputFields = [];
+  let outputFields = [];
+  try {
+    const { getSDKClient: getSDKClient2 } = await Promise.resolve().then(() => (init_sdk_client(), exports_sdk_client));
+    const client = getSDKClient2();
+    const prompt = await client.getPrompt(promptId);
+    inputFields = extractSchemaFields(prompt.inputSchema, "input");
+    outputFields = extractSchemaFields(prompt.outputSchema, "output");
+    if (inputFields.length > 0 || outputFields.length > 0) {
+      console.log(chalk5.green(`  Found ${String(inputFields.length)} input field(s) and ${String(outputFields.length)} output field(s)`));
+    } else {
+      console.log(chalk5.yellow("  No schema fields detected. You can still define criteria manually."));
+    }
+  } catch {
+    console.log(chalk5.yellow("  Could not fetch prompt. You can still define criteria manually."));
+  }
+  console.log("");
+  const { evalType } = await inquirer3.prompt([{
+    type: "list",
+    name: "evalType",
+    message: "What type of evaluation?",
+    choices: Object.entries(EVAL_TYPE_DESCRIPTIONS).map(([value, description]) => ({
+      name: `${value} — ${description}`,
+      value
+    }))
+  }]);
+  const defaultName = evalType.charAt(0).toUpperCase() + evalType.slice(1) + " Evaluation";
+  const { evalName } = await inquirer3.prompt([{
+    type: "input",
+    name: "evalName",
+    message: "Evaluation name:",
+    default: defaultName,
+    validate: (input) => {
+      if (!input.trim())
+        return "Evaluation name is required";
+      return true;
+    }
+  }]);
+  const allFields = [...inputFields, ...outputFields];
+  const criteria = [];
+  let addMore = true;
+  while (addMore) {
+    console.log("");
+    console.log(chalk5.bold(`  Criterion #${String(criteria.length + 1)}`));
+    const { criterionName } = await inquirer3.prompt([{
+      type: "input",
+      name: "criterionName",
+      message: "Name this criterion:",
+      validate: (input) => {
+        if (!input.trim())
+          return "Criterion name is required";
+        return true;
+      }
+    }]);
+    let targetField;
+    if (allFields.length > 0) {
+      const fieldChoices = [
+        ...allFields.map((f) => ({ name: f, value: f })),
+        { name: "(custom field name)", value: "__custom__" }
+      ];
+      const { field } = await inquirer3.prompt([{
+        type: "list",
+        name: "field",
+        message: "Target field:",
+        choices: fieldChoices
+      }]);
+      if (field === "__custom__") {
+        const { customField } = await inquirer3.prompt([{
+          type: "input",
+          name: "customField",
+          message: "Custom field name (e.g., output.summary):"
+        }]);
+        targetField = customField.trim();
+      } else {
+        targetField = field;
+      }
+    } else {
+      const { customField } = await inquirer3.prompt([{
+        type: "input",
+        name: "customField",
+        message: "Target field (e.g., output.result):",
+        default: "output"
+      }]);
+      targetField = customField.trim();
+    }
+    const rubricChoices = [
+      ...Object.entries(RUBRIC_TEMPLATES).map(([name, value]) => ({
+        name: `${name} — ${chalk5.dim(value.substring(0, 50))}...`,
+        value
+      })),
+      { name: "(write custom rubric)", value: "__custom__" }
+    ];
+    const { rubric } = await inquirer3.prompt([{
+      type: "list",
+      name: "rubric",
+      message: "Scoring rubric:",
+      choices: rubricChoices
+    }]);
+    let scoringRubric;
+    if (rubric === "__custom__") {
+      const { customRubric } = await inquirer3.prompt([{
+        type: "input",
+        name: "customRubric",
+        message: "Describe the scoring rubric:",
+        validate: (input) => {
+          if (!input.trim())
+            return "Rubric is required";
+          return true;
+        }
+      }]);
+      scoringRubric = customRubric.trim();
+    } else {
+      scoringRubric = rubric;
     }
-    properties[variable.name] = prop;
+    criteria.push({
+      name: criterionName.trim(),
+      targetField,
+      scoringRubric,
+      weight: 1
+    });
+    const { continueAdding } = await inquirer3.prompt([{
+      type: "confirm",
+      name: "continueAdding",
+      message: "Add another criterion?",
+      default: false
+    }]);
+    addMore = continueAdding;
+  }
+  if (criteria.length === 0) {
+    console.log(chalk5.yellow(`
+  No criteria defined. Aborting guided eval creation.`));
+    return;
+  }
+  console.log("");
+  console.log(chalk5.bold("  Evaluation Summary:"));
+  console.log(`    Name: ${chalk5.green(evalName)}`);
+  console.log(`    Type: ${evalType}`);
+  console.log(`    Criteria: ${String(criteria.length)}`);
+  for (const c of criteria) {
+    console.log(`      - ${chalk5.cyan(c.name)} → ${c.targetField}`);
+  }
+  console.log("");
+  const { confirmed } = await inquirer3.prompt([{
+    type: "confirm",
+    name: "confirmed",
+    message: "Create this evaluation?",
+    default: true
+  }]);
+  if (!confirmed) {
+    console.log(chalk5.dim(`
+  Cancelled.`));
+    return;
   }
   return {
-    type: "object",
-    properties
+    name: evalName.trim(),
+    description: `${evalType} evaluation with ${String(criteria.length)} criteria`,
+    evalConfig: { criteria }
   };
 }
-function formatSchemaWarning(fieldName) {
-  return [
-    `${fieldName} doesn't appear to be a valid JSON Schema.`,
-    "",
-    "  Expected format:",
-    "  {",
-    '    "type": "object",',
-    '    "properties": {',
-    '      "variable_name": { "type": "string", "description": "Description here" }',
-    "    }",
-    "  }",
-    "",
-    "  You can also provide a schema file: mutagent prompts create --file schema.json"
-  ].join(`
-`);
+
+// src/lib/scorecard.ts
+import chalk6 from "chalk";
+function truncateText(text, maxLen) {
+  if (text.length <= maxLen)
+    return text;
+  return text.substring(0, maxLen - 3) + "...";
+}
+function formatScoreChange(before, after) {
+  if (before === undefined || after === undefined)
+    return "";
+  const diff = after - before;
+  const pct = before > 0 ? Math.round(diff / before * 100) : 0;
+  if (diff > 0)
+    return chalk6.green(` (+${String(pct)}%)`);
+  if (diff < 0)
+    return chalk6.red(` (${String(pct)}%)`);
+  return chalk6.dim(" (no change)");
+}
+function formatScore(score) {
+  if (score === undefined)
+    return chalk6.dim("N/A");
+  return score >= 0.8 ? chalk6.green(score.toFixed(2)) : score >= 0.5 ? chalk6.yellow(score.toFixed(2)) : chalk6.red(score.toFixed(2));
+}
+function renderScorecard(data) {
+  const { job, prompt } = data;
+  const boxWidth = 55;
+  const topBorder = `┌${"─".repeat(boxWidth)}┐`;
+  const bottomBorder = `└${"─".repeat(boxWidth)}┘`;
+  const separator = `│ ${"─".repeat(boxWidth - 2)} │`;
+  const pad = (text, width) => {
+    const stripped = text.replace(/\u001B\[[0-9;]*m/g, "");
+    const remaining = width - stripped.length;
+    return remaining > 0 ? text + " ".repeat(remaining) : text;
+  };
+  const line = (text) => `│ ${pad(text, boxWidth - 2)} │`;
+  const originalScore = data.originalScore;
+  const bestScore = data.bestScore;
+  const iterations = data.iterationsCompleted ?? job.config?.maxIterations ?? 0;
+  const originalText = data.originalPrompt?.systemPrompt ?? data.originalPrompt?.rawPrompt ?? "(original prompt)";
+  const optimizedText = prompt.systemPrompt ?? prompt.rawPrompt ?? prompt.humanPrompt ?? "(optimized prompt)";
+  console.log("");
+  console.log(topBorder);
+  console.log(line(chalk6.bold("Optimization Results")));
+  console.log(separator);
+  console.log(line(chalk6.dim("BEFORE")));
+  console.log(line(`  Prompt: ${chalk6.dim(truncateText(originalText, 38))}`));
+  console.log(line(`  Score:  ${formatScore(originalScore)}`));
+  console.log(line(""));
+  console.log(line(chalk6.bold("AFTER")));
+  console.log(line(`  Prompt: ${chalk6.cyan(truncateText(optimizedText, 38))}`));
+  console.log(line(`  Score:  ${formatScore(bestScore)}${formatScoreChange(originalScore, bestScore)}`));
+  console.log(separator);
+  const statusStr = job.status === "completed" ? chalk6.green("completed") : chalk6.yellow(job.status);
+  console.log(line(`Status: ${statusStr}  |  Iterations: ${String(iterations)}`));
+  if (job.config?.model) {
+    console.log(line(`Model: ${chalk6.dim(job.config.model)}`));
+  }
+  if (data.scoreProgression && data.scoreProgression.length > 0) {
+    console.log(line(""));
+    console.log(line(chalk6.dim("Score Progression:")));
+    const progression = data.scoreProgression.map((s, i) => `#${String(i + 1)}: ${s.toFixed(2)}`).join("  ");
+    if (progression.length > boxWidth - 4) {
+      const mid = Math.ceil(data.scoreProgression.length / 2);
+      const line1 = data.scoreProgression.slice(0, mid).map((s, i) => `#${String(i + 1)}: ${s.toFixed(2)}`).join("  ");
+      const line2 = data.scoreProgression.slice(mid).map((s, i) => `#${String(i + mid + 1)}: ${s.toFixed(2)}`).join("  ");
+      console.log(line(chalk6.dim(line1)));
+      console.log(line(chalk6.dim(line2)));
+    } else {
+      console.log(line(chalk6.dim(progression)));
+    }
+  }
+  console.log(separator);
+  console.log(line(`Dashboard: ${chalk6.underline(optimizerLink(job.jobId))}`));
+  console.log(bottomBorder);
+  console.log("");
+}
+async function promptScorecardAction() {
+  const inquirer3 = (await import("inquirer")).default;
+  const { action } = await inquirer3.prompt([{
+    type: "list",
+    name: "action",
+    message: "What would you like to do?",
+    choices: [
+      { name: chalk6.green("Apply") + " — Update prompt to optimized version", value: "apply" },
+      { name: chalk6.red("Reject") + " — Keep original prompt", value: "reject" },
+      { name: chalk6.dim("View Details") + " — Show full diff", value: "details" }
+    ]
+  }]);
+  return { action };
+}
+function showPromptDiff(original, optimized) {
+  console.log("");
+  console.log(chalk6.bold("  Prompt Diff:"));
+  console.log("");
+  console.log(chalk6.red("  - " + (original ?? "(empty)")));
+  console.log(chalk6.green("  + " + (optimized ?? "(empty)")));
+  console.log("");
 }
 
 // src/commands/prompts.ts
+function updateMutationContext(updater) {
+  try {
+    const ctx = MutationContext.load();
+    updater(ctx);
+    ctx.save();
+  } catch {}
+}
 var PREREQUISITES_TEXT = `
-${chalk4.yellow("Prerequisites:")}
-  1. Evaluation criteria defined  ${chalk4.dim("(via dashboard or evaluation create)")}
-  2. Dataset uploaded             ${chalk4.dim("mutagent prompts dataset list <prompt-id>")}
-  ${chalk4.dim("Note: LLM provider config is only required when the server uses external providers (USE_EXT_PROVIDERS=true)")}`;
+${chalk7.yellow("Prerequisites:")}
+  1. Evaluation criteria defined  ${chalk7.dim("(via dashboard or evaluation create)")}
+  2. Dataset uploaded             ${chalk7.dim("mutagent prompts dataset list <prompt-id>")}
+  ${chalk7.dim("Note: LLM provider config is only required when the server uses external providers (USE_EXT_PROVIDERS=true)")}`;
 function parseValidationErrors(error) {
   if (error instanceof ApiError) {
     try {
@@ -1824,16 +2861,16 @@ async function promptForInputSchema() {
       validate: (input) => {
         if (!input.trim())
           return "File path is required";
-        if (!existsSync2(input.trim()))
+        if (!existsSync4(input.trim()))
           return `File not found: ${input.trim()}`;
         return true;
       }
     }]);
-    const content = readFileSync2(fileAnswer.path.trim(), "utf-8");
+    const content = readFileSync4(fileAnswer.path.trim(), "utf-8");
     try {
       const parsed = JSON.parse(content);
       if (!isValidJsonSchema(parsed)) {
-        console.log(chalk4.yellow(`
+        console.log(chalk7.yellow(`
   Warning: ${formatSchemaWarning("inputSchema")}
 `));
       }
@@ -1891,12 +2928,12 @@ function parseDatasetFile(rawContent, filePath) {
 function createPromptsCommand() {
   const prompts = new Command3("prompts").description("Manage prompts, datasets, evaluations, and optimizations").addHelpText("after", `
 Examples:
-  ${chalk4.dim("$")} mutagent prompts list
-  ${chalk4.dim("$")} mutagent prompts get <prompt-id>
-  ${chalk4.dim("$")} mutagent prompts create --file prompt.json
-  ${chalk4.dim("$")} mutagent prompts dataset list <prompt-id>
-  ${chalk4.dim("$")} mutagent prompts evaluation create <prompt-id> --name "My Eval"
-  ${chalk4.dim("$")} mutagent prompts optimize start <prompt-id> --dataset <dataset-id>
+  ${chalk7.dim("$")} mutagent prompts list
+  ${chalk7.dim("$")} mutagent prompts get <prompt-id>
+  ${chalk7.dim("$")} mutagent prompts create --file prompt.json
+  ${chalk7.dim("$")} mutagent prompts dataset list <prompt-id>
+  ${chalk7.dim("$")} mutagent prompts evaluation create <prompt-id> --name "My Eval"
+  ${chalk7.dim("$")} mutagent prompts optimize start <prompt-id> --dataset <dataset-id>
 
 Subcommands:
   list, get, create, update, delete
@@ -1906,11 +2943,11 @@ Subcommands:
     `);
   prompts.command("list").description("List all prompts").option("-l, --limit <n>", "Limit results", "50").addHelpText("after", `
 Examples:
-  ${chalk4.dim("$")} mutagent prompts list
-  ${chalk4.dim("$")} mutagent prompts list --limit 10
-  ${chalk4.dim("$")} mutagent prompts list --json
+  ${chalk7.dim("$")} mutagent prompts list
+  ${chalk7.dim("$")} mutagent prompts list --limit 10
+  ${chalk7.dim("$")} mutagent prompts list --json
 
-${chalk4.dim("Tip: Use --json for machine-readable output (AI agents, CI pipelines).")}
+${chalk7.dim("Tip: Use --json for machine-readable output (AI agents, CI pipelines).")}
     `).action(async (options) => {
     const isJson = getJsonFlag(prompts);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -1941,11 +2978,11 @@ ${chalk4.dim("Tip: Use --json for machine-readable output (AI agents, CI pipelin
   });
   prompts.command("get").description("Get prompt details with nested data").argument("<id>", "Prompt ID (from: mutagent prompts list)").option("--with-datasets", "Include datasets").option("--with-evals", "Include evaluations").addHelpText("after", `
 Examples:
-  ${chalk4.dim("$")} mutagent prompts get <id>
-  ${chalk4.dim("$")} mutagent prompts get <id> --with-datasets --with-evals
-  ${chalk4.dim("$")} mutagent prompts get <id> --json
+  ${chalk7.dim("$")} mutagent prompts get <id>
+  ${chalk7.dim("$")} mutagent prompts get <id> --with-datasets --with-evals
+  ${chalk7.dim("$")} mutagent prompts get <id> --json
 
-${chalk4.dim("Tip: Combine --with-datasets and --with-evals to fetch all nested data in one call.")}
+${chalk7.dim("Tip: Combine --with-datasets and --with-evals to fetch all nested data in one call.")}
     `).action(async (id, options) => {
     const isJson = getJsonFlag(prompts);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -1969,35 +3006,46 @@ ${chalk4.dim("Tip: Combine --with-datasets and --with-evals to fetch all nested
       handleError(error, isJson);
     }
   });
-  prompts.command("create").description("Create a new prompt").option("-f, --file <path>", "Create from JSON file").option("--raw-file <path>", "Create from plain text file (used as rawPrompt)").option("-n, --name <name>", "Prompt name").option("-c, --content <content>", "Prompt content (rawPrompt) [DEPRECATED: use --raw]").option("-r, --raw <text>", "Raw prompt text (single prompt)").option("--system <text>", "System prompt (use with --human)").option("--human <text>", "Human prompt (use with --system)").option("--messages <json>", `Messages array as JSON (e.g., '[{"role":"system","content":"..."}]')`).addHelpText("after", `
+  prompts.command("create").description("Create a new prompt").option("-d, --data <json>", "Prompt as JSON string (recommended — curl-style inline)").option("-f, --file <path>", "Create from JSON file").option("--raw-file <path>", "Create from plain text file (used as rawPrompt)").option("-n, --name <name>", "Prompt name").option("-c, --content <content>", "Prompt content (rawPrompt) [DEPRECATED: use --raw]").option("-r, --raw <text>", "Raw prompt text (single prompt)").option("--system <text>", "System prompt (use with --human)").option("--human <text>", "Human prompt (use with --system)").option("--messages <json>", `Messages array as JSON (e.g., '[{"role":"system","content":"..."}]')`).option("--output-schema <json>", "Output schema as JSON string (required for optimization)").addHelpText("after", `
 Examples:
-  ${chalk4.dim("$")} mutagent prompts create --name "my-prompt" --system "You are helpful" --human "Hello"
-  ${chalk4.dim("$")} mutagent prompts create --name "raw-prompt" --raw "Summarize: {{text}}"
-  ${chalk4.dim("$")} mutagent prompts create --file prompt.json
-  ${chalk4.dim("$")} mutagent prompts create --name "chat" --messages '[{"role":"system","content":"..."}]'
-  ${chalk4.dim("$")} mutagent prompts create --name "from-file" --raw-file prompt.txt
+  ${chalk7.dim("$")} mutagent prompts create -d '{"name":"summarizer","systemPrompt":"Summarize","humanPrompt":"{{text}}","outputSchema":{"type":"object","properties":{"summary":{"type":"string"}}}}'
+  ${chalk7.dim("$")} mutagent prompts create --name "my-prompt" --system "You are helpful" --human "Hello" --output-schema '{"type":"object","properties":{"result":{"type":"string"}}}'
+  ${chalk7.dim("$")} mutagent prompts create --file prompt.json
+  ${chalk7.dim("$")} mutagent prompts create --name "raw-prompt" --raw "Summarize: {{text}}"
 
-Prompt Input Methods (pick one):
+Prompt Input Methods (pick one, priority order):
+  -d, --data         Inline JSON object (recommended for CI/scripts)
+  --file             Load from JSON file (full prompt object)
+  --raw-file         Load plain text file as raw prompt
   --system/--human   Structured system + user message pair
   --raw              Single raw prompt text with {{variables}}
-  --raw-file         Load plain text file as raw prompt
   --messages         Full messages array as JSON
-  --file             Load from JSON file (full prompt object)
 
-${chalk4.dim("Hint: Use --file with JSON or --raw-file for plain text. Get prompt IDs: mutagent prompts list")}
+${chalk7.dim("Note: --data and --file are mutually exclusive. outputSchema is required (include in --data/--file or use --output-schema).")}
     `).action(async (options) => {
     const isJson = getJsonFlag(prompts);
     const output = new OutputFormatter(isJson ? "json" : "table");
     try {
       let data;
-      if (options.file) {
-        const content = readFileSync2(options.file, "utf-8");
+      if (options.data && options.file) {
+        throw new MutagentError("INVALID_ARGUMENTS", "Cannot use --data and --file together", "Use --data for inline JSON or --file for file-based input, not both");
+      }
+      if (options.data) {
+        try {
+          data = JSON.parse(options.data);
+        } catch {
+          throw new MutagentError("INVALID_JSON", "Invalid JSON in --data flag", `Provide a valid JSON object, e.g., '{"name":"my-prompt","systemPrompt":"You are helpful"}'`);
+        }
+        if (options.name)
+          data.name = options.name;
+      } else if (options.file) {
+        const content = readFileSync4(options.file, "utf-8");
         data = JSON.parse(content);
       } else if (options.rawFile) {
-        if (!existsSync2(options.rawFile)) {
+        if (!existsSync4(options.rawFile)) {
           throw new MutagentError("FILE_NOT_FOUND", `File not found: ${options.rawFile}`, "Check the file path and try again");
         }
-        const textContent = readFileSync2(options.rawFile, "utf-8");
+        const textContent = readFileSync4(options.rawFile, "utf-8");
         data = {
           name: options.name ?? options.rawFile.replace(/^.*[\\/]/, "").replace(/\.[^.]+$/, ""),
           rawPrompt: textContent
@@ -2026,15 +3074,46 @@ ${chalk4.dim("Hint: Use --file with JSON or --raw-file for plain text. Get promp
         } else if (options.content) {
           data.rawPrompt = options.content;
         } else {
-          throw new MutagentError("MISSING_ARGUMENTS", "Prompt content required", "Use --raw, --raw-file, --system/--human, or --messages to specify prompt content");
+          throw new MutagentError("MISSING_ARGUMENTS", "Prompt content required", "Use --data, --raw, --raw-file, --system/--human, or --messages to specify prompt content");
         }
       } else {
-        throw new MutagentError("MISSING_ARGUMENTS", "Either --file, --raw-file, or --name with prompt content is required", "Use --file to load from JSON, --raw-file for plain text, or provide --name with --raw, --system/--human, or --messages");
+        throw new MutagentError("MISSING_ARGUMENTS", "Either --data, --file, --raw-file, or --name with prompt content is required", "Use --data for inline JSON, --file to load from JSON, --raw-file for plain text, or provide --name with --raw, --system/--human, or --messages");
       }
       const promptContent = data.rawPrompt ?? data.systemPrompt ?? data.humanPrompt ?? "";
       if (promptContent && !isJson) {
         warnSingleBraceVariables(promptContent, output);
       }
+      if (options.outputSchema) {
+        try {
+          data.outputSchema = JSON.parse(options.outputSchema);
+        } catch {
+          throw new MutagentError("INVALID_JSON", "Invalid JSON in --output-schema flag", `Provide a valid JSON Schema, e.g., '{"type":"object","properties":{"result":{"type":"string"}}}'`);
+        }
+      }
+      if (isSchemaEmpty(data.outputSchema)) {
+        if (!isJson && process.stdin.isTTY) {
+          const inquirer3 = (await import("inquirer")).default;
+          output.warn("outputSchema is required for optimization. Define the expected output structure.");
+          const schemaAnswer = await inquirer3.prompt([{
+            type: "input",
+            name: "schema",
+            message: "Output schema (JSON):",
+            validate: (input) => {
+              if (!input.trim())
+                return "outputSchema is required";
+              try {
+                JSON.parse(input);
+                return true;
+              } catch {
+                return 'Invalid JSON. Example: {"type":"object","properties":{"result":{"type":"string"}}}';
+              }
+            }
+          }]);
+          data.outputSchema = JSON.parse(schemaAnswer.schema);
+        } else {
+          throw new MutagentError("MISSING_ARGUMENTS", "outputSchema is required for prompt creation", `Use --output-schema '{"type":"object","properties":{...}}' or include outputSchema in --data/--file`);
+        }
+      }
       if (!isJson && isSchemaEmpty(data.inputSchema)) {
         if (process.stdin.isTTY) {
           const schema = await promptForInputSchema();
@@ -2061,30 +3140,51 @@ ${chalk4.dim("Hint: Use --file with JSON or --raw-file for plain text. Get promp
         });
         console.log(hints);
       }
+      const sourceFile = options.file ?? options.rawFile;
+      if (sourceFile) {
+        updateMutationContext((ctx) => {
+          const preview = (data.rawPrompt ?? data.systemPrompt ?? data.name ?? "").slice(0, 50);
+          ctx.addDiscoveredPrompt(sourceFile, 1, preview);
+          ctx.markPromptUploaded(sourceFile, String(prompt.id), prompt.version);
+        });
+      }
     } catch (error) {
       handleError(error, isJson);
     }
   });
-  prompts.command("update").description("Update a prompt").argument("<id>", "Prompt ID (from: mutagent prompts list)").option("-f, --file <path>", "Update from JSON file").option("--raw-file <path>", "Update from plain text file (used as rawPrompt)").option("-n, --name <name>", "New name").option("-c, --content <content>", "New content (rawPrompt) [DEPRECATED: use --raw]").option("-r, --raw <text>", "Raw prompt text (single prompt)").option("--system <text>", "System prompt (use with --human)").option("--human <text>", "Human prompt (use with --system)").option("--messages <json>", `Messages array as JSON (e.g., '[{"role":"system","content":"..."}]')`).addHelpText("after", `
+  prompts.command("update").description("Update a prompt").argument("<id>", "Prompt ID (from: mutagent prompts list)").option("-d, --data <json>", "Update fields as JSON string (recommended — curl-style inline)").option("-f, --file <path>", "Update from JSON file").option("--raw-file <path>", "Update from plain text file (used as rawPrompt)").option("-n, --name <name>", "New name").option("-c, --content <content>", "New content (rawPrompt) [DEPRECATED: use --raw]").option("-r, --raw <text>", "Raw prompt text (single prompt)").option("--system <text>", "System prompt (use with --human)").option("--human <text>", "Human prompt (use with --system)").option("--messages <json>", `Messages array as JSON (e.g., '[{"role":"system","content":"..."}]')`).addHelpText("after", `
 Examples:
-  ${chalk4.dim("$")} mutagent prompts update <id> --name "new-name"
-  ${chalk4.dim("$")} mutagent prompts update <id> --system "Updated system prompt"
-  ${chalk4.dim("$")} mutagent prompts update <id> --raw-file updated-prompt.txt
-  ${chalk4.dim("$")} mutagent prompts update <id> --file updated-prompt.json
-  ${chalk4.dim("$")} mutagent prompts update <id> --json
+  ${chalk7.dim("$")} mutagent prompts update <id> -d '{"name":"new-name","systemPrompt":"Updated prompt"}'
+  ${chalk7.dim("$")} mutagent prompts update <id> --name "new-name"
+  ${chalk7.dim("$")} mutagent prompts update <id> --system "Updated system prompt"
+  ${chalk7.dim("$")} mutagent prompts update <id> --raw-file updated-prompt.txt
+  ${chalk7.dim("$")} mutagent prompts update <id> --file updated-prompt.json
+
+${chalk7.dim("Note: --data and --file are mutually exclusive. CLI flags (--name) override --data fields.")}
     `).action(async (id, options) => {
     const isJson = getJsonFlag(prompts);
     const output = new OutputFormatter(isJson ? "json" : "table");
     try {
       let data = {};
-      if (options.file) {
-        const content = readFileSync2(options.file, "utf-8");
+      if (options.data && options.file) {
+        throw new MutagentError("INVALID_ARGUMENTS", "Cannot use --data and --file together", "Use --data for inline JSON or --file for file-based input, not both");
+      }
+      if (options.data) {
+        try {
+          data = JSON.parse(options.data);
+        } catch {
+          throw new MutagentError("INVALID_JSON", "Invalid JSON in --data flag", `Provide a valid JSON object, e.g., '{"name":"new-name","systemPrompt":"Updated prompt"}'`);
+        }
+        if (options.name)
+          data.name = options.name;
+      } else if (options.file) {
+        const content = readFileSync4(options.file, "utf-8");
         data = JSON.parse(content);
       } else if (options.rawFile) {
-        if (!existsSync2(options.rawFile)) {
+        if (!existsSync4(options.rawFile)) {
           throw new MutagentError("FILE_NOT_FOUND", `File not found: ${options.rawFile}`, "Check the file path and try again");
         }
-        const textContent = readFileSync2(options.rawFile, "utf-8");
+        const textContent = readFileSync4(options.rawFile, "utf-8");
         data.rawPrompt = textContent;
         if (options.name)
           data.name = options.name;
@@ -2115,7 +3215,7 @@ Examples:
         }
       }
       if (Object.keys(data).length === 0) {
-        throw new MutagentError("MISSING_ARGUMENTS", "No update data provided", "Use --file, --raw-file, --name, --raw, --system/--human, or --messages");
+        throw new MutagentError("MISSING_ARGUMENTS", "No update data provided", "Use --data, --file, --raw-file, --name, --raw, --system/--human, or --messages");
       }
       const promptContent = data.rawPrompt ?? data.systemPrompt ?? data.humanPrompt ?? "";
       if (promptContent && !isJson) {
@@ -2136,17 +3236,23 @@ Examples:
         });
         console.log(hints);
       }
+      const sourceFile = options.file ?? options.rawFile;
+      if (sourceFile) {
+        updateMutationContext((ctx) => {
+          ctx.markPromptUploaded(sourceFile, String(prompt.id), prompt.version);
+        });
+      }
     } catch (error) {
       handleError(error, isJson);
     }
   });
   prompts.command("delete").description("Delete a prompt").argument("<id>", "Prompt ID (from: mutagent prompts list)").option("--force", "Skip confirmation").addHelpText("after", `
 Examples:
-  ${chalk4.dim("$")} mutagent prompts delete <id>
-  ${chalk4.dim("$")} mutagent prompts delete <id> --force
-  ${chalk4.dim("$")} mutagent prompts delete <id> --force --json
+  ${chalk7.dim("$")} mutagent prompts delete <id>
+  ${chalk7.dim("$")} mutagent prompts delete <id> --force
+  ${chalk7.dim("$")} mutagent prompts delete <id> --force --json
 
-${chalk4.dim("Tip: Use --force to skip confirmation (required for non-interactive/CI usage).")}
+${chalk7.dim("Tip: Use --force to skip confirmation (required for non-interactive/CI usage).")}
     `).action(async (id, options) => {
     const isJson = getJsonFlag(prompts);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -2173,14 +3279,14 @@ ${chalk4.dim("Tip: Use --force to skip confirmation (required for non-interactiv
   });
   const dataset = prompts.command("dataset").description("Manage datasets for prompts").addHelpText("after", `
 Examples:
-  ${chalk4.dim("$")} mutagent prompts dataset list <prompt-id>
-  ${chalk4.dim("$")} mutagent prompts dataset add <prompt-id> --file dataset.jsonl
-  ${chalk4.dim("$")} mutagent prompts dataset remove <prompt-id> <dataset-id>
+  ${chalk7.dim("$")} mutagent prompts dataset list <prompt-id>
+  ${chalk7.dim("$")} mutagent prompts dataset add <prompt-id> --file dataset.jsonl
+  ${chalk7.dim("$")} mutagent prompts dataset remove <prompt-id> <dataset-id>
     `);
   dataset.command("list").description("List datasets for a prompt").argument("<prompt-id>", "Prompt ID (from: mutagent prompts list)").addHelpText("after", `
 Examples:
-  ${chalk4.dim("$")} mutagent prompts dataset list <prompt-id>
-  ${chalk4.dim("$")} mutagent prompts dataset list <prompt-id> --json
+  ${chalk7.dim("$")} mutagent prompts dataset list <prompt-id>
+  ${chalk7.dim("$")} mutagent prompts dataset list <prompt-id> --json
     `).action(async (promptId) => {
     const isJson = getJsonFlag(prompts);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -2206,21 +3312,21 @@ Examples:
   });
   dataset.command("add").description("Add dataset to a prompt").argument("<prompt-id>", "Prompt ID (from: mutagent prompts list)").option("-f, --file <path>", "Dataset file (JSON array, JSONL, or CSV)").option("-d, --data <json>", "Inline JSON array of dataset items").option("-n, --name <name>", "Dataset name (default: timestamped)").addHelpText("after", `
 Examples:
-  ${chalk4.dim("$")} mutagent prompts dataset add <prompt-id> --file dataset.json
-  ${chalk4.dim("$")} mutagent prompts dataset add <prompt-id> --file dataset.jsonl --name "My Dataset"
-  ${chalk4.dim("$")} mutagent prompts dataset add <prompt-id> --file dataset.csv
-  ${chalk4.dim("$")} mutagent prompts dataset add <prompt-id> -d '[{"input":{"text":"hello"},"expectedOutput":{"result":"world"}}]'
+  ${chalk7.dim("$")} mutagent prompts dataset add <prompt-id> --file dataset.json
+  ${chalk7.dim("$")} mutagent prompts dataset add <prompt-id> --file dataset.jsonl --name "My Dataset"
+  ${chalk7.dim("$")} mutagent prompts dataset add <prompt-id> --file dataset.csv
+  ${chalk7.dim("$")} mutagent prompts dataset add <prompt-id> -d '[{"input":{"text":"hello"},"expectedOutput":{"result":"world"}}]'
 
 Supported file formats:
-  ${chalk4.dim(".json")}   JSON array of objects: [{"input": {...}, "expectedOutput": {...}}, ...]
-  ${chalk4.dim(".jsonl")}  One JSON object per line (newline-delimited JSON)
-  ${chalk4.dim(".csv")}    Comma-separated values with header row
+  ${chalk7.dim(".json")}   JSON array of objects: [{"input": {...}, "expectedOutput": {...}}, ...]
+  ${chalk7.dim(".jsonl")}  One JSON object per line (newline-delimited JSON)
+  ${chalk7.dim(".csv")}    Comma-separated values with header row
 
 Inline data format (-d):
   JSON array of objects, e.g.:
-  ${chalk4.dim('[{"input": {"text": "hello"}, "expectedOutput": {"result": "world"}}]')}
+  ${chalk7.dim('[{"input": {"text": "hello"}, "expectedOutput": {"result": "world"}}]')}
 
-${chalk4.dim("Note: --file and -d are mutually exclusive. Provide one or the other.")}
+${chalk7.dim("Note: --file and -d are mutually exclusive. Provide one or the other.")}
     `).action(async (promptId, options) => {
     const isJson = getJsonFlag(prompts);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -2246,11 +3352,30 @@ ${chalk4.dim("Note: --file and -d are mutually exclusive. Provide one or the oth
         }
       } else {
         const filePath = options.file;
-        const rawContent = readFileSync2(filePath, "utf-8");
+        const rawContent = readFileSync4(filePath, "utf-8");
         content = parseDatasetFile(rawContent, filePath);
       }
+      let datasetName = options.name;
+      if (!datasetName && !isJson && process.stdin.isTTY) {
+        const inquirer3 = (await import("inquirer")).default;
+        const defaultName = options.file ? options.file.replace(/^.*[\\/]/, "").replace(/\.[^.]+$/, "") : undefined;
+        const nameAnswer = await inquirer3.prompt([{
+          type: "input",
+          name: "name",
+          message: "Name this dataset:",
+          default: defaultName,
+          validate: (input) => {
+            if (!input.trim())
+              return "Dataset name is required";
+            if (input.trim().length < 2)
+              return "Dataset name must be at least 2 characters";
+            return true;
+          }
+        }]);
+        datasetName = nameAnswer.name.trim();
+      }
       const client = getSDKClient();
-      const datasetResult = await client.addDataset(promptId, content, options.name);
+      const datasetResult = await client.addDataset(promptId, content, datasetName);
       if (isJson) {
         output.output({
           ...datasetResult,
@@ -2270,14 +3395,19 @@ ${chalk4.dim("Note: --file and -d are mutually exclusive. Provide one or the oth
         });
         console.log(hints);
       }
+      const datasetFile = options.file ?? "inline-data";
+      updateMutationContext((ctx) => {
+        ctx.addDiscoveredDataset(datasetFile, datasetResult.name, datasetResult.itemCount ?? 0);
+        ctx.markDatasetUploaded(datasetFile, String(datasetResult.id), promptId);
+      });
     } catch (error) {
       handleError(error, isJson);
     }
   });
   dataset.command("remove").description("Remove dataset from a prompt").argument("<prompt-id>", "Prompt ID (from: mutagent prompts list)").argument("<dataset-id>", "Dataset ID (from: mutagent prompts dataset list <prompt-id>)").addHelpText("after", `
 Examples:
-  ${chalk4.dim("$")} mutagent prompts dataset remove <prompt-id> <dataset-id>
-  ${chalk4.dim("$")} mutagent prompts dataset remove <prompt-id> <dataset-id> --json
+  ${chalk7.dim("$")} mutagent prompts dataset remove <prompt-id> <dataset-id>
+  ${chalk7.dim("$")} mutagent prompts dataset remove <prompt-id> <dataset-id> --json
     `).action(async (promptId, datasetId) => {
     const isJson = getJsonFlag(prompts);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -2291,14 +3421,14 @@ Examples:
   });
   const evaluation = prompts.command("evaluation").description("Manage evaluations for prompts").addHelpText("after", `
 Examples:
-  ${chalk4.dim("$")} mutagent prompts evaluation list <prompt-id>
-  ${chalk4.dim("$")} mutagent prompts evaluation create <prompt-id> --name "My Eval"
-  ${chalk4.dim("$")} mutagent prompts evaluation results <run-id>
+  ${chalk7.dim("$")} mutagent prompts evaluation list <prompt-id>
+  ${chalk7.dim("$")} mutagent prompts evaluation create <prompt-id> --name "My Eval"
+  ${chalk7.dim("$")} mutagent prompts evaluation results <run-id>
     `);
   evaluation.command("list").description("List evaluations for a prompt").argument("<prompt-id>", "Prompt ID (from: mutagent prompts list)").addHelpText("after", `
 Examples:
-  ${chalk4.dim("$")} mutagent prompts evaluation list <prompt-id>
-  ${chalk4.dim("$")} mutagent prompts evaluation list <prompt-id> --json
+  ${chalk7.dim("$")} mutagent prompts evaluation list <prompt-id>
+  ${chalk7.dim("$")} mutagent prompts evaluation list <prompt-id> --json
     `).action(async (promptId) => {
     const isJson = getJsonFlag(prompts);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -2322,30 +3452,85 @@ Examples:
       handleError(error, isJson);
     }
   });
-  evaluation.command("create").description("Create an evaluation configuration for a prompt").argument("<prompt-id>", "Prompt ID (from: mutagent prompts list)").requiredOption("-n, --name <name>", "Evaluation name").option("-f, --file <path>", "Load evaluation criteria from JSON file").option("--description <text>", "Evaluation description").option("-d, --dataset <id>", "Dataset ID to associate (from: mutagent prompts dataset list)").addHelpText("after", `
+  evaluation.command("create").description("Create an evaluation configuration for a prompt").argument("<prompt-id>", "Prompt ID (from: mutagent prompts list)").option("-d, --data <json>", "Evaluation as JSON string (recommended — curl-style inline)").option("-n, --name <name>", "Evaluation name (required unless --guided)").option("-f, --file <path>", "Load evaluation criteria from JSON file").option("--description <text>", "Evaluation description").option("--dataset <id>", "Dataset ID to associate (from: mutagent prompts dataset list)").option("--guided", "Interactive guided mode — build criteria step by step").addHelpText("after", `
 Examples:
-  ${chalk4.dim("$")} mutagent prompts evaluation create <prompt-id> --name "Accuracy Check"
-  ${chalk4.dim("$")} mutagent prompts evaluation create <prompt-id> --name "Full Eval" --file criteria.json --dataset <dataset-id>
-  ${chalk4.dim("$")} mutagent prompts evaluation create <prompt-id> --name "QA" --description "Quality assurance eval" --json
-
-Criteria file format (--file):
-  ${chalk4.dim('{ "evalConfig": { "criteria": [...] }, "llmConfig": { "model": "gpt-4" } }')}
-
-${chalk4.dim("AI Agent Hint: Create an evaluation before running it. Use --file to load criteria from JSON.")}
-${chalk4.dim("Get prompt IDs: mutagent prompts list | Get dataset IDs: mutagent prompts dataset list <prompt-id>")}
+  ${chalk7.dim("$")} mutagent prompts evaluation create <prompt-id> --guided
+  ${chalk7.dim("$")} mutagent prompts evaluation create <prompt-id> --data '{"name":"Accuracy","evalConfig":{"criteria":[...]}}' --name "Accuracy"
+  ${chalk7.dim("$")} mutagent prompts evaluation create <prompt-id> --name "Accuracy Check"
+  ${chalk7.dim("$")} mutagent prompts evaluation create <prompt-id> --name "Full Eval" --file criteria.json --dataset <dataset-id>
+  ${chalk7.dim("$")} mutagent prompts evaluation create <prompt-id> --name "QA" --description "Quality assurance eval" --json
+
+Criteria file format (--file or --data):
+  ${chalk7.dim('{ "name": "...", "evalConfig": { "criteria": [...] }, "llmConfig": { "model": "gpt-4" } }')}
+
+${chalk7.dim("Note: --data and --file are mutually exclusive. CLI flags (--name, --description) override --data fields.")}
+${chalk7.dim("Tip: Use --guided for an interactive walkthrough of criteria creation.")}
+${chalk7.dim("Get prompt IDs: mutagent prompts list | Get dataset IDs: mutagent prompts dataset list <prompt-id>")}
     `).action(async (promptId, options) => {
     const isJson = getJsonFlag(prompts);
     const output = new OutputFormatter(isJson ? "json" : "table");
     try {
+      if (options.guided) {
+        if (!process.stdin.isTTY || isJson) {
+          throw new MutagentError("INTERACTIVE_REQUIRED", "--guided requires an interactive terminal", "Remove --guided for non-interactive usage, or use --data/--file to provide criteria");
+        }
+        const guidedResult = await runGuidedEvalCreator(promptId);
+        if (!guidedResult) {
+          return;
+        }
+        const client2 = getSDKClient();
+        const evalResult2 = await client2.createEvaluation(promptId, {
+          name: guidedResult.name,
+          description: guidedResult.description,
+          evalConfig: guidedResult.evalConfig,
+          datasetId: options.dataset ? parseInt(options.dataset, 10) : undefined
+        });
+        output.success(`Created evaluation: ${evalResult2.name} (id: ${String(evalResult2.id)})`);
+        const hints = formatCreationHints({
+          resourceType: "Evaluation",
+          id: evalResult2.id,
+          name: evalResult2.name,
+          dashboardUrl: evaluationLink(promptId, evalResult2.id),
+          apiPath: `/api/prompts/${promptId}/evaluations/${String(evalResult2.id)}`
+        });
+        console.log(hints);
+        const criteriaCount2 = guidedResult.evalConfig.criteria.length;
+        updateMutationContext((ctx) => {
+          ctx.addEvaluation(evalResult2.name, criteriaCount2, String(evalResult2.id), promptId);
+        });
+        return;
+      }
+      if (!options.name) {
+        throw new MutagentError("MISSING_ARGUMENTS", "Evaluation name is required", "Use --name <name> or --guided for interactive mode");
+      }
+      if (options.data && options.file) {
+        throw new MutagentError("INVALID_ARGUMENTS", "Cannot use --data and --file together", "Use --data for inline JSON or --file for file-based input, not both");
+      }
       const evalData = {
         name: options.name,
         description: options.description
       };
-      if (options.file) {
-        if (!existsSync2(options.file)) {
+      if (options.data) {
+        try {
+          const parsed = JSON.parse(options.data);
+          if (parsed.evalConfig)
+            evalData.evalConfig = parsed.evalConfig;
+          if (parsed.llmConfig)
+            evalData.llmConfig = parsed.llmConfig;
+          if (parsed.tags)
+            evalData.tags = parsed.tags;
+          if (parsed.metadata)
+            evalData.metadata = parsed.metadata;
+          if (parsed.datasetId)
+            evalData.datasetId = parsed.datasetId;
+        } catch {
+          throw new MutagentError("INVALID_JSON", "Invalid JSON in --data flag", `Provide a valid JSON object, e.g., '{"evalConfig":{"criteria":[...]},"llmConfig":{"model":"gpt-4"}}'`);
+        }
+      } else if (options.file) {
+        if (!existsSync4(options.file)) {
           throw new MutagentError("FILE_NOT_FOUND", `File not found: ${options.file}`, "Check the file path and try again");
         }
-        const fileContent = readFileSync2(options.file, "utf-8");
+        const fileContent = readFileSync4(options.file, "utf-8");
         try {
           const parsed = JSON.parse(fileContent);
           if (parsed.evalConfig)
@@ -2360,6 +3545,10 @@ ${chalk4.dim("Get prompt IDs: mutagent prompts list | Get dataset IDs: mutagent
           throw new MutagentError("INVALID_JSON", `Failed to parse criteria file: ${options.file}`, "Ensure the file contains valid JSON with evalConfig and/or llmConfig");
         }
       }
+      if (options.name)
+        evalData.name = options.name;
+      if (options.description)
+        evalData.description = options.description;
       if (options.dataset) {
         evalData.datasetId = parseInt(options.dataset, 10);
         if (isNaN(evalData.datasetId)) {
@@ -2384,14 +3573,18 @@ ${chalk4.dim("Get prompt IDs: mutagent prompts list | Get dataset IDs: mutagent
         });
         console.log(hints);
       }
+      const criteriaCount = evalData.evalConfig?.criteria?.length ?? 0;
+      updateMutationContext((ctx) => {
+        ctx.addEvaluation(evalResult.name, criteriaCount, String(evalResult.id), promptId);
+      });
     } catch (error) {
       handleError(error, isJson);
     }
   });
   evaluation.command("results").description("Get evaluation results").argument("<run-id>", "Evaluation run ID (from: mutagent prompts evaluation list <prompt-id>)").addHelpText("after", `
 Examples:
-  ${chalk4.dim("$")} mutagent prompts evaluation results <run-id>
-  ${chalk4.dim("$")} mutagent prompts evaluation results <run-id> --json
+  ${chalk7.dim("$")} mutagent prompts evaluation results <run-id>
+  ${chalk7.dim("$")} mutagent prompts evaluation results <run-id> --json
     `).action(async (runId) => {
     const isJson = getJsonFlag(prompts);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -2405,21 +3598,21 @@ Examples:
   });
   const optimize = prompts.command("optimize").description("Manage prompt optimization jobs").addHelpText("after", `
 Examples:
-  ${chalk4.dim("$")} mutagent prompts optimize start <prompt-id> --dataset <dataset-id>
-  ${chalk4.dim("$")} mutagent prompts optimize status <job-id>
-  ${chalk4.dim("$")} mutagent prompts optimize results <job-id>
+  ${chalk7.dim("$")} mutagent prompts optimize start <prompt-id> --dataset <dataset-id>
+  ${chalk7.dim("$")} mutagent prompts optimize status <job-id>
+  ${chalk7.dim("$")} mutagent prompts optimize results <job-id>
 
 Workflow: start -> status (poll) -> results
     `);
   optimize.command("start").description("Start prompt optimization").argument("<prompt-id>", "Prompt ID (from: mutagent prompts list)").requiredOption("-d, --dataset <id>", "Dataset ID for optimization (from: mutagent prompts dataset list <prompt-id>)").option("--max-iterations <n>", "Max optimization iterations (default: 3)").option("--target-score <n>", "Target accuracy 0-1 (e.g., 0.9)").option("--patience <n>", "Iterations without improvement before stopping").option("--model <model-id>", 'Target LLM model (e.g., "claude-sonnet-4-5-20250929")').option("--eval-model <model-id>", "Evaluation model (defaults to target model)").addHelpText("after", `
 Examples:
-  ${chalk4.dim("$")} mutagent prompts optimize start <prompt-id> --dataset <dataset-id>
-  ${chalk4.dim("$")} mutagent prompts optimize start <prompt-id> --dataset <dataset-id> --max-iterations 5
-  ${chalk4.dim("$")} mutagent prompts optimize start <prompt-id> --dataset <dataset-id> --target-score 0.95 --model claude-sonnet-4-5-20250929
-  ${chalk4.dim("$")} mutagent prompts optimize start <prompt-id> --dataset <dataset-id> --json
+  ${chalk7.dim("$")} mutagent prompts optimize start <prompt-id> --dataset <dataset-id>
+  ${chalk7.dim("$")} mutagent prompts optimize start <prompt-id> --dataset <dataset-id> --max-iterations 5
+  ${chalk7.dim("$")} mutagent prompts optimize start <prompt-id> --dataset <dataset-id> --target-score 0.95 --model claude-sonnet-4-5-20250929
+  ${chalk7.dim("$")} mutagent prompts optimize start <prompt-id> --dataset <dataset-id> --json
 ${PREREQUISITES_TEXT}
 
-${chalk4.dim("Monitor progress with: mutagent prompts optimize status <job-id>")}
+${chalk7.dim("Monitor progress with: mutagent prompts optimize status <job-id>")}
     `).action(async (promptId, options) => {
     const isJson = getJsonFlag(prompts);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -2454,9 +3647,9 @@ ${chalk4.dim("Monitor progress with: mutagent prompts optimize status <job-id>")
       if (error instanceof ApiError) {
         const messages = parseValidationErrors(error);
         if (!isJson) {
-          console.error(chalk4.red("Optimization failed. Missing requirements:"));
+          console.error(chalk7.red("Optimization failed. Missing requirements:"));
           for (const msg of messages) {
-            console.error(chalk4.red(`  - ${msg}`));
+            console.error(chalk7.red(`  - ${msg}`));
           }
           console.error("");
           console.error(PREREQUISITES_TEXT);
@@ -2467,8 +3660,8 @@ ${chalk4.dim("Monitor progress with: mutagent prompts optimize status <job-id>")
   });
   optimize.command("status").description("Check optimization status").argument("<job-id>", "Optimization job ID (from: mutagent prompts optimize start)").addHelpText("after", `
 Examples:
-  ${chalk4.dim("$")} mutagent prompts optimize status <job-id>
-  ${chalk4.dim("$")} mutagent prompts optimize status <job-id> --json
+  ${chalk7.dim("$")} mutagent prompts optimize status <job-id>
+  ${chalk7.dim("$")} mutagent prompts optimize status <job-id> --json
     `).action(async (jobId) => {
     const isJson = getJsonFlag(prompts);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -2491,19 +3684,59 @@ Examples:
   });
   optimize.command("results").description("Get optimization results").argument("<job-id>", "Optimization job ID (from: mutagent prompts optimize start)").addHelpText("after", `
 Examples:
-  ${chalk4.dim("$")} mutagent prompts optimize results <job-id>
-  ${chalk4.dim("$")} mutagent prompts optimize results <job-id> --json
+  ${chalk7.dim("$")} mutagent prompts optimize results <job-id>
+  ${chalk7.dim("$")} mutagent prompts optimize results <job-id> --json
     `).action(async (jobId) => {
     const isJson = getJsonFlag(prompts);
     const output = new OutputFormatter(isJson ? "json" : "table");
     try {
       const client = getSDKClient();
       const results = await client.getOptimizationResults(jobId);
+      const resultData = results;
       if (isJson) {
-        output.output({ ...results, _links: { optimizer: optimizerLink(jobId) } });
+        output.output({ ...resultData, _links: { optimizer: optimizerLink(jobId) } });
       } else {
-        output.output(results);
-        output.info(`View: ${optimizerLink(jobId)}`);
+        renderScorecard(resultData);
+        const jobData = resultData.job;
+        const isCompleted = jobData?.status === "completed";
+        if (isCompleted && process.stdin.isTTY) {
+          let showDetails = true;
+          while (showDetails) {
+            const { action } = await promptScorecardAction();
+            if (action === "details") {
+              const original = resultData.originalPrompt;
+              const optimized = resultData.prompt;
+              showPromptDiff(original?.systemPrompt ?? original?.rawPrompt ?? null, optimized?.systemPrompt ?? optimized?.rawPrompt ?? null);
+              continue;
+            }
+            if (action === "apply") {
+              const optimizedPrompt = resultData.prompt;
+              const promptIdStr = String(jobData.promptId);
+              if (optimizedPrompt && promptIdStr) {
+                output.info("Applying optimized prompt...");
+                const updateData = {};
+                if (optimizedPrompt.systemPrompt)
+                  updateData.systemPrompt = optimizedPrompt.systemPrompt;
+                if (optimizedPrompt.humanPrompt)
+                  updateData.humanPrompt = optimizedPrompt.humanPrompt;
+                if (optimizedPrompt.rawPrompt)
+                  updateData.rawPrompt = optimizedPrompt.rawPrompt;
+                await client.updatePrompt(promptIdStr, updateData);
+                output.success("Optimized prompt applied as new version!");
+                updateMutationContext((ctx) => {
+                  ctx.markPromptUploaded(`optimization:${jobId}`, promptIdStr, "optimized");
+                });
+              }
+            } else {
+              output.info("Kept original prompt. No changes applied.");
+            }
+            showDetails = false;
+          }
+        } else if (!isCompleted) {
+          const statusStr = jobData?.status ?? "unknown";
+          output.info(`Job status: ${statusStr}. Results may be partial.`);
+          output.info(`View: ${optimizerLink(jobId)}`);
+        }
       }
     } catch (error) {
       handleError(error, isJson);
@@ -2513,26 +3746,28 @@ Examples:
 }
 
 // src/commands/traces.ts
+init_sdk_client();
 import { Command as Command4 } from "commander";
-import chalk5 from "chalk";
+import chalk8 from "chalk";
+init_errors();
 function createTracesCommand() {
   const traces = new Command4("traces").description("View and analyze traces (replaces Langfuse)").addHelpText("after", `
 Examples:
-  ${chalk5.dim("$")} mutagent traces list
-  ${chalk5.dim("$")} mutagent traces list --prompt <prompt-id>
-  ${chalk5.dim("$")} mutagent traces get <trace-id>
-  ${chalk5.dim("$")} mutagent traces analyze <prompt-id>
-  ${chalk5.dim("$")} mutagent traces export --format json --output traces.json
+  ${chalk8.dim("$")} mutagent traces list
+  ${chalk8.dim("$")} mutagent traces list --prompt <prompt-id>
+  ${chalk8.dim("$")} mutagent traces get <trace-id>
+  ${chalk8.dim("$")} mutagent traces analyze <prompt-id>
+  ${chalk8.dim("$")} mutagent traces export --format json --output traces.json
 
 Note: MutagenT traces replace Langfuse for observability.
     `);
   traces.command("list").description("List traces").option("-p, --prompt <id>", "Filter by prompt ID").option("-l, --limit <n>", "Limit results", "50").addHelpText("after", `
 Examples:
-  ${chalk5.dim("$")} mutagent traces list
-  ${chalk5.dim("$")} mutagent traces list --prompt <prompt-id>
-  ${chalk5.dim("$")} mutagent traces list --limit 10 --json
+  ${chalk8.dim("$")} mutagent traces list
+  ${chalk8.dim("$")} mutagent traces list --prompt <prompt-id>
+  ${chalk8.dim("$")} mutagent traces list --limit 10 --json
 
-${chalk5.dim("Tip: Filter by prompt to see traces for a specific prompt version.")}
+${chalk8.dim("Tip: Filter by prompt to see traces for a specific prompt version.")}
     `).action(async (options) => {
     const isJson = getJsonFlag(traces);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -2566,10 +3801,10 @@ ${chalk5.dim("Tip: Filter by prompt to see traces for a specific prompt version.
   });
   traces.command("get").description("Get trace details").argument("<id>", "Trace ID").addHelpText("after", `
 Examples:
-  ${chalk5.dim("$")} mutagent traces get <trace-id>
-  ${chalk5.dim("$")} mutagent traces get <trace-id> --json
+  ${chalk8.dim("$")} mutagent traces get <trace-id>
+  ${chalk8.dim("$")} mutagent traces get <trace-id> --json
 
-${chalk5.dim("Returns full trace details including spans, tokens, and latency.")}
+${chalk8.dim("Returns full trace details including spans, tokens, and latency.")}
     `).action(async (id) => {
     const isJson = getJsonFlag(traces);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -2588,10 +3823,10 @@ ${chalk5.dim("Returns full trace details including spans, tokens, and latency.")
   });
   traces.command("analyze").description("Analyze traces for a prompt").argument("<prompt-id>", "Prompt ID").addHelpText("after", `
 Examples:
-  ${chalk5.dim("$")} mutagent traces analyze <prompt-id>
-  ${chalk5.dim("$")} mutagent traces analyze <prompt-id> --json
+  ${chalk8.dim("$")} mutagent traces analyze <prompt-id>
+  ${chalk8.dim("$")} mutagent traces analyze <prompt-id> --json
 
-${chalk5.dim("Aggregates trace data for a prompt: avg latency, token usage, error rates.")}
+${chalk8.dim("Aggregates trace data for a prompt: avg latency, token usage, error rates.")}
     `).action(async (promptId) => {
     const isJson = getJsonFlag(traces);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -2609,12 +3844,12 @@ ${chalk5.dim("Aggregates trace data for a prompt: avg latency, token usage, erro
   });
   traces.command("export").description("Export traces").option("-p, --prompt <id>", "Filter by prompt ID").option("-f, --format <format>", "Export format (json, csv)", "json").option("-o, --output <path>", "Output file path").addHelpText("after", `
 Examples:
-  ${chalk5.dim("$")} mutagent traces export
-  ${chalk5.dim("$")} mutagent traces export --format json --output traces.json
-  ${chalk5.dim("$")} mutagent traces export --format csv --output traces.csv
-  ${chalk5.dim("$")} mutagent traces export --prompt <prompt-id> --format json
+  ${chalk8.dim("$")} mutagent traces export
+  ${chalk8.dim("$")} mutagent traces export --format json --output traces.json
+  ${chalk8.dim("$")} mutagent traces export --format csv --output traces.csv
+  ${chalk8.dim("$")} mutagent traces export --prompt <prompt-id> --format json
 
-${chalk5.dim("Exports to stdout by default. Use --output to save to a file.")}
+${chalk8.dim("Exports to stdout by default. Use --output to save to a file.")}
     `).action(async (options) => {
     const isJson = getJsonFlag(traces);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -2642,8 +3877,8 @@ ${chalk5.dim("Exports to stdout by default. Use --output to save to a file.")}
         throw new Error(`Unsupported format: ${options.format}`);
       }
       if (options.output) {
-        const { writeFileSync: writeFileSync2 } = await import("fs");
-        writeFileSync2(options.output, content);
+        const { writeFileSync: writeFileSync3 } = await import("fs");
+        writeFileSync3(options.output, content);
         output.success(`Exported ${String(tracesList.length)} traces to ${options.output}`);
       } else {
         process.stdout.write(content);
@@ -2656,13 +3891,15 @@ ${chalk5.dim("Exports to stdout by default. Use --output to save to a file.")}
 }
 
 // src/commands/integrate.ts
+init_config();
 import { Command as Command5 } from "commander";
-import chalk6 from "chalk";
-import { writeFileSync as writeFileSync2, existsSync as existsSync9 } from "fs";
+import chalk9 from "chalk";
+import { writeFileSync as writeFileSync3, existsSync as existsSync11 } from "fs";
 import { execSync } from "child_process";
+init_errors();
 
 // src/lib/integrations/mastra.ts
-import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
+import { readFileSync as readFileSync5, existsSync as existsSync5 } from "fs";
 function renderPrerequisites(config) {
   const keyPreview = config.apiKey.slice(0, 8) + "..." + config.apiKey.slice(-4);
   return `✓ MUTAGENT_API_KEY: ${keyPreview}
@@ -2676,14 +3913,14 @@ var mastraIntegration = {
     const files = ["mastra.config.ts", "mastra.config.js"];
     const found = [];
     for (const file of files) {
-      if (existsSync3(file)) {
+      if (existsSync5(file)) {
         found.push(file);
       }
     }
     let hasMastraDep = false;
-    if (existsSync3("package.json")) {
+    if (existsSync5("package.json")) {
       try {
-        const pkg = JSON.parse(readFileSync3("package.json", "utf-8"));
+        const pkg = JSON.parse(readFileSync5("package.json", "utf-8"));
         const deps = { ...pkg.dependencies, ...pkg.devDependencies };
         hasMastraDep = "@mastra/core" in deps;
       } catch {}
@@ -2858,15 +4095,15 @@ mutagent traces analyze <prompt-id>
 };
 
 // src/lib/integrations/langchain.ts
-import { readFileSync as readFileSync4, existsSync as existsSync4 } from "fs";
+import { readFileSync as readFileSync6, existsSync as existsSync6 } from "fs";
 var langchainIntegration = {
   name: "langchain",
   description: "LangChain framework",
   async detect() {
     let hasLangchain = false;
-    if (existsSync4("package.json")) {
+    if (existsSync6("package.json")) {
       try {
-        const pkg = JSON.parse(readFileSync4("package.json", "utf-8"));
+        const pkg = JSON.parse(readFileSync6("package.json", "utf-8"));
         const deps = { ...pkg.dependencies, ...pkg.devDependencies };
         hasLangchain = "langchain" in deps || "@langchain/core" in deps;
       } catch {}
@@ -2998,15 +4235,15 @@ mutagent traces analyze <prompt-id>
 };
 
 // src/lib/integrations/langgraph.ts
-import { readFileSync as readFileSync5, existsSync as existsSync5 } from "fs";
+import { readFileSync as readFileSync7, existsSync as existsSync7 } from "fs";
 var langgraphIntegration = {
   name: "langgraph",
   description: "LangGraph agent workflow framework",
   async detect() {
     let hasLanggraph = false;
-    if (existsSync5("package.json")) {
+    if (existsSync7("package.json")) {
       try {
-        const pkg = JSON.parse(readFileSync5("package.json", "utf-8"));
+        const pkg = JSON.parse(readFileSync7("package.json", "utf-8"));
         const deps = { ...pkg.dependencies, ...pkg.devDependencies };
         hasLanggraph = "@langchain/langgraph" in deps;
       } catch {}
@@ -3124,15 +4361,15 @@ mutagent traces analyze <node-prompt-id>
 };
 
 // src/lib/integrations/vercel-ai.ts
-import { readFileSync as readFileSync6, existsSync as existsSync6 } from "fs";
+import { readFileSync as readFileSync8, existsSync as existsSync8 } from "fs";
 var vercelAiIntegration = {
   name: "vercel-ai",
   description: "Vercel AI SDK",
   async detect() {
     let hasAiSdk = false;
-    if (existsSync6("package.json")) {
+    if (existsSync8("package.json")) {
       try {
-        const pkg = JSON.parse(readFileSync6("package.json", "utf-8"));
+        const pkg = JSON.parse(readFileSync8("package.json", "utf-8"));
         const deps = { ...pkg.dependencies, ...pkg.devDependencies };
         hasAiSdk = "ai" in deps;
       } catch {}
@@ -3245,15 +4482,15 @@ mutagent traces export --prompt <prompt-id> --format json
 };
 
 // src/lib/integrations/openai.ts
-import { readFileSync as readFileSync7, existsSync as existsSync7 } from "fs";
+import { readFileSync as readFileSync9, existsSync as existsSync9 } from "fs";
 var openaiIntegration = {
   name: "openai",
   description: "OpenAI SDK integration with automatic tracing",
   async detect() {
     let hasOpenAI = false;
-    if (existsSync7("package.json")) {
+    if (existsSync9("package.json")) {
       try {
-        const pkg = JSON.parse(readFileSync7("package.json", "utf-8"));
+        const pkg = JSON.parse(readFileSync9("package.json", "utf-8"));
         const deps = { ...pkg.dependencies, ...pkg.devDependencies };
         hasOpenAI = "openai" in deps;
       } catch {}
@@ -3383,15 +4620,15 @@ mutagent traces export --format json
 };
 
 // src/lib/integrations/claude-code.ts
-import { readFileSync as readFileSync8, existsSync as existsSync8 } from "fs";
+import { readFileSync as readFileSync10, existsSync as existsSync10 } from "fs";
 var claudeCodeIntegration = {
   name: "claude-code",
   description: "Claude Code SDK",
   async detect() {
     let hasClaudeCode = false;
-    if (existsSync8("package.json")) {
+    if (existsSync10("package.json")) {
       try {
-        const pkg = JSON.parse(readFileSync8("package.json", "utf-8"));
+        const pkg = JSON.parse(readFileSync10("package.json", "utf-8"));
         const deps = { ...pkg.dependencies, ...pkg.devDependencies };
         hasClaudeCode = "@anthropic-ai/claude-code" in deps || "@anthropic-ai/sdk" in deps;
       } catch {}
@@ -3703,16 +4940,16 @@ function getFrameworkMetadata(name) {
 
 // src/commands/integrate.ts
 function detectPackageManager() {
-  if (existsSync9("bun.lockb") || existsSync9("bun.lock")) {
+  if (existsSync11("bun.lockb") || existsSync11("bun.lock")) {
     return "bun";
   }
-  if (existsSync9("pnpm-lock.yaml")) {
+  if (existsSync11("pnpm-lock.yaml")) {
     return "pnpm";
   }
-  if (existsSync9("yarn.lock")) {
+  if (existsSync11("yarn.lock")) {
     return "yarn";
   }
-  if (existsSync9("package-lock.json")) {
+  if (existsSync11("package-lock.json")) {
     return "npm";
   }
   try {
@@ -3762,12 +4999,12 @@ AI AGENT: Please determine the framework by:
 function createIntegrateCommand() {
   const integrate = new Command5("integrate").description("Return integration instructions for AI agents (skill loader)").addHelpText("after", `
 Examples:
-  ${chalk6.dim("$")} mutagent integrate              # Return exploration instructions for AI agents
-  ${chalk6.dim("$")} mutagent integrate langchain     # Return @mutagent/langchain integration steps
-  ${chalk6.dim("$")} mutagent integrate openai        # Return @mutagent/openai integration steps
-  ${chalk6.dim("$")} mutagent integrate vercel-ai --verify    # Verify integration
-  ${chalk6.dim("$")} mutagent integrate langchain --output ./INTEGRATION.md
-  ${chalk6.dim("$")} mutagent integrate --list          # List available frameworks
+  ${chalk9.dim("$")} mutagent integrate              # Return exploration instructions for AI agents
+  ${chalk9.dim("$")} mutagent integrate langchain     # Return @mutagent/langchain integration steps
+  ${chalk9.dim("$")} mutagent integrate openai        # Return @mutagent/openai integration steps
+  ${chalk9.dim("$")} mutagent integrate vercel-ai --verify    # Verify integration
+  ${chalk9.dim("$")} mutagent integrate langchain --output ./INTEGRATION.md
+  ${chalk9.dim("$")} mutagent integrate --list          # List available frameworks
 
 Frameworks: mastra, langchain, langgraph, vercel-ai, openai, claude-code, generic
 
@@ -3786,7 +5023,7 @@ It returns INSTRUCTIONS that AI agents execute - it does NOT auto-install packag
       if (!frameworkArg) {
         const explorationInstructions = generateExplorationInstructions();
         if (options.output) {
-          writeFileSync2(options.output, explorationInstructions);
+          writeFileSync3(options.output, explorationInstructions);
           output.success(`Exploration instructions saved to ${options.output}`);
         } else if (options.raw === true || isJson) {
           process.stdout.write(explorationInstructions);
@@ -3834,7 +5071,7 @@ export MUTAGENT_API_KEY=${apiKey.substring(0, 12)}...
 AI AGENT: Execute these steps using Bash for install, Write/Edit for code changes.
 `;
       if (options.output) {
-        writeFileSync2(options.output, instructions);
+        writeFileSync3(options.output, instructions);
         output.success(`Integration instructions saved to ${options.output}`);
       } else if (options.raw === true || isJson) {
         process.stdout.write(instructions);
@@ -3869,23 +5106,25 @@ AI AGENT: Execute these steps using Bash for install, Write/Edit for code change
 }
 
 // src/commands/agents.ts
+init_sdk_client();
 import { Command as Command6 } from "commander";
-import chalk7 from "chalk";
-import { readFileSync as readFileSync9 } from "fs";
+import chalk10 from "chalk";
+import { readFileSync as readFileSync11 } from "fs";
+init_errors();
 function createAgentsCommand() {
   const agents = new Command6("agents").description("Manage AI agents").addHelpText("after", `
 Examples:
-  ${chalk7.dim("$")} mutagent agents list
-  ${chalk7.dim("$")} mutagent agents get <agent-id>
-  ${chalk7.dim("$")} mutagent agents create --file agent.json
-  ${chalk7.dim("$")} mutagent agents create --name "Code Reviewer" --slug code-reviewer --system-prompt "You are a code reviewer..."
-  ${chalk7.dim("$")} mutagent agents update <agent-id> --name "Updated Name"
-  ${chalk7.dim("$")} mutagent agents delete <agent-id> --force
-  ${chalk7.dim("$")} mutagent agents conversations list <agent-id>
-  ${chalk7.dim("$")} mutagent agents conversations get <agent-id> <conversation-id>
-  ${chalk7.dim("$")} mutagent agents conversations create <agent-id>
-  ${chalk7.dim("$")} mutagent agents conversations delete <agent-id> <conversation-id>
-  ${chalk7.dim("$")} mutagent agents conversations messages <agent-id> <conversation-id>
+  ${chalk10.dim("$")} mutagent agents list
+  ${chalk10.dim("$")} mutagent agents get <agent-id>
+  ${chalk10.dim("$")} mutagent agents create --file agent.json
+  ${chalk10.dim("$")} mutagent agents create --name "Code Reviewer" --slug code-reviewer --system-prompt "You are a code reviewer..."
+  ${chalk10.dim("$")} mutagent agents update <agent-id> --name "Updated Name"
+  ${chalk10.dim("$")} mutagent agents delete <agent-id> --force
+  ${chalk10.dim("$")} mutagent agents conversations list <agent-id>
+  ${chalk10.dim("$")} mutagent agents conversations get <agent-id> <conversation-id>
+  ${chalk10.dim("$")} mutagent agents conversations create <agent-id>
+  ${chalk10.dim("$")} mutagent agents conversations delete <agent-id> <conversation-id>
+  ${chalk10.dim("$")} mutagent agents conversations messages <agent-id> <conversation-id>
 
 Subcommands:
   list, get, create, update, delete
@@ -3893,9 +5132,9 @@ Subcommands:
     `);
   agents.command("list").description("List all agents").option("-l, --limit <n>", "Limit results", "50").option("-o, --offset <n>", "Offset for pagination").option("-n, --name <name>", "Filter by name").option("-s, --status <status>", "Filter by status (active, paused, archived)").addHelpText("after", `
 Examples:
-  ${chalk7.dim("$")} mutagent agents list
-  ${chalk7.dim("$")} mutagent agents list --status active
-  ${chalk7.dim("$")} mutagent agents list --name "reviewer" --json
+  ${chalk10.dim("$")} mutagent agents list
+  ${chalk10.dim("$")} mutagent agents list --status active
+  ${chalk10.dim("$")} mutagent agents list --name "reviewer" --json
     `).action(async (options) => {
     const isJson = getJsonFlag(agents);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -3915,7 +5154,11 @@ Examples:
       }
       const result = await client.listAgents(filters);
       if (isJson) {
-        output.output(result);
+        const withLinks = result.data.map((a) => ({
+          ...a,
+          _links: agentLinks(a.id)
+        }));
+        output.output({ ...result, data: withLinks });
       } else {
         const formatted = result.data.map((a) => ({
           id: a.id,
@@ -3924,7 +5167,8 @@ Examples:
           model: a.model,
           status: a.status,
           isPublic: a.isPublic ? "Yes" : "No",
-          updated: a.updatedAt ? new Date(a.updatedAt).toLocaleDateString() : "N/A"
+          updated: a.updatedAt ? new Date(a.updatedAt).toLocaleDateString() : "N/A",
+          url: agentLink(a.id)
         }));
         output.output(formatted);
       }
@@ -3934,8 +5178,8 @@ Examples:
   });
   agents.command("get").description("Get agent details").argument("<id>", "Agent ID").addHelpText("after", `
 Examples:
-  ${chalk7.dim("$")} mutagent agents get <agent-id>
-  ${chalk7.dim("$")} mutagent agents get <agent-id> --json
+  ${chalk10.dim("$")} mutagent agents get <agent-id>
+  ${chalk10.dim("$")} mutagent agents get <agent-id> --json
     `).action(async (id) => {
     const isJson = getJsonFlag(agents);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -3943,7 +5187,7 @@ Examples:
       const client = getSDKClient();
       const agent = await client.getAgent(id);
       if (isJson) {
-        output.output(agent);
+        output.output({ ...agent, _links: agentLinks(agent.id) });
       } else {
         const formatted = {
           id: agent.id,
@@ -3960,15 +5204,16 @@ Examples:
           tags: agent.tags?.join(", ") ?? "None",
           createdBy: agent.createdBy ?? "N/A",
           createdAt: agent.createdAt ? new Date(agent.createdAt).toLocaleString() : "N/A",
-          updatedAt: agent.updatedAt ? new Date(agent.updatedAt).toLocaleString() : "N/A"
+          updatedAt: agent.updatedAt ? new Date(agent.updatedAt).toLocaleString() : "N/A",
+          url: agentLink(agent.id)
         };
         output.output(formatted);
         if (agent.systemPrompt) {
-          console.log(chalk7.bold(`
+          console.log(chalk10.bold(`
 System Prompt:`));
-          console.log(chalk7.gray("─".repeat(60)));
+          console.log(chalk10.gray("─".repeat(60)));
           console.log(agent.systemPrompt);
-          console.log(chalk7.gray("─".repeat(60)));
+          console.log(chalk10.gray("─".repeat(60)));
         }
       }
     } catch (error) {
@@ -3977,18 +5222,18 @@ System Prompt:`));
   });
   agents.command("create").description("Create a new agent").option("-f, --file <path>", "Create from JSON file").option("-n, --name <name>", "Agent name").option("-s, --slug <slug>", "Agent slug (URL-friendly identifier)").option("-p, --system-prompt <prompt>", "System prompt").option("-m, --model <model>", "Model (claude-sonnet-4-5, claude-opus-4-5, claude-haiku-4-5)").option("-d, --description <description>", "Agent description").addHelpText("after", `
 Examples:
-  ${chalk7.dim("$")} mutagent agents create --name "Code Reviewer" --slug code-reviewer --system-prompt "Review code for bugs"
-  ${chalk7.dim("$")} mutagent agents create --file agent.json
-  ${chalk7.dim("$")} mutagent agents create --name "Helper" --slug helper --system-prompt "..." --model claude-sonnet-4-5 --json
+  ${chalk10.dim("$")} mutagent agents create --name "Code Reviewer" --slug code-reviewer --system-prompt "Review code for bugs"
+  ${chalk10.dim("$")} mutagent agents create --file agent.json
+  ${chalk10.dim("$")} mutagent agents create --name "Helper" --slug helper --system-prompt "..." --model claude-sonnet-4-5 --json
 
-${chalk7.dim("Required: --name, --slug, and --system-prompt (or --file).")}
+${chalk10.dim("Required: --name, --slug, and --system-prompt (or --file).")}
     `).action(async (options) => {
     const isJson = getJsonFlag(agents);
     const output = new OutputFormatter(isJson ? "json" : "table");
     try {
       let data;
       if (options.file) {
-        const content = readFileSync9(options.file, "utf-8");
+        const content = readFileSync11(options.file, "utf-8");
         data = JSON.parse(content);
       } else if (options.name && options.slug && options.systemPrompt) {
         data = {
@@ -4013,16 +5258,16 @@ ${chalk7.dim("Required: --name, --slug, and --system-prompt (or --file).")}
   });
   agents.command("update").description("Update an agent").argument("<id>", "Agent ID").option("-f, --file <path>", "Update from JSON file").option("-n, --name <name>", "New name").option("-p, --system-prompt <prompt>", "New system prompt").option("-m, --model <model>", "New model").option("-d, --description <description>", "New description").option("-s, --status <status>", "New status (active, paused, archived)").addHelpText("after", `
 Examples:
-  ${chalk7.dim("$")} mutagent agents update <id> --name "New Name"
-  ${chalk7.dim("$")} mutagent agents update <id> --status paused
-  ${chalk7.dim("$")} mutagent agents update <id> --file updated-agent.json --json
+  ${chalk10.dim("$")} mutagent agents update <id> --name "New Name"
+  ${chalk10.dim("$")} mutagent agents update <id> --status paused
+  ${chalk10.dim("$")} mutagent agents update <id> --file updated-agent.json --json
     `).action(async (id, options) => {
     const isJson = getJsonFlag(agents);
     const output = new OutputFormatter(isJson ? "json" : "table");
     try {
       let data = {};
       if (options.file) {
-        const content = readFileSync9(options.file, "utf-8");
+        const content = readFileSync11(options.file, "utf-8");
         data = JSON.parse(content);
       } else {
         if (options.name)
@@ -4049,11 +5294,11 @@ Examples:
   });
   agents.command("delete").description("Delete an agent").argument("<id>", "Agent ID").option("--force", "Skip confirmation").addHelpText("after", `
 Examples:
-  ${chalk7.dim("$")} mutagent agents delete <id>
-  ${chalk7.dim("$")} mutagent agents delete <id> --force
-  ${chalk7.dim("$")} mutagent agents delete <id> --force --json
+  ${chalk10.dim("$")} mutagent agents delete <id>
+  ${chalk10.dim("$")} mutagent agents delete <id> --force
+  ${chalk10.dim("$")} mutagent agents delete <id> --force --json
 
-${chalk7.dim("Tip: Use --force to skip confirmation (required for non-interactive/CI usage).")}
+${chalk10.dim("Tip: Use --force to skip confirmation (required for non-interactive/CI usage).")}
     `).action(async (id, options) => {
     const isJson = getJsonFlag(agents);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -4080,14 +5325,14 @@ ${chalk7.dim("Tip: Use --force to skip confirmation (required for non-interactiv
   });
   const conversations = agents.command("conversations").description("Manage conversations for agents").addHelpText("after", `
 Examples:
-  ${chalk7.dim("$")} mutagent agents conversations list <agent-id>
-  ${chalk7.dim("$")} mutagent agents conversations create <agent-id>
-  ${chalk7.dim("$")} mutagent agents conversations messages <agent-id> <conversation-id>
+  ${chalk10.dim("$")} mutagent agents conversations list <agent-id>
+  ${chalk10.dim("$")} mutagent agents conversations create <agent-id>
+  ${chalk10.dim("$")} mutagent agents conversations messages <agent-id> <conversation-id>
     `);
   conversations.command("list").description("List conversations for an agent").argument("<agent-id>", "Agent ID").option("-l, --limit <n>", "Limit results", "50").option("-o, --offset <n>", "Offset for pagination").addHelpText("after", `
 Examples:
-  ${chalk7.dim("$")} mutagent agents conversations list <agent-id>
-  ${chalk7.dim("$")} mutagent agents conversations list <agent-id> --limit 10 --json
+  ${chalk10.dim("$")} mutagent agents conversations list <agent-id>
+  ${chalk10.dim("$")} mutagent agents conversations list <agent-id> --limit 10 --json
     `).action(async (agentId, options) => {
     const isJson = getJsonFlag(agents);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -4119,8 +5364,8 @@ Examples:
   });
   conversations.command("get").description("Get conversation details").argument("<agent-id>", "Agent ID").argument("<conversation-id>", "Conversation ID").addHelpText("after", `
 Examples:
-  ${chalk7.dim("$")} mutagent agents conversations get <agent-id> <conversation-id>
-  ${chalk7.dim("$")} mutagent agents conversations get <agent-id> <conversation-id> --json
+  ${chalk10.dim("$")} mutagent agents conversations get <agent-id> <conversation-id>
+  ${chalk10.dim("$")} mutagent agents conversations get <agent-id> <conversation-id> --json
     `).action(async (agentId, conversationId) => {
     const isJson = getJsonFlag(agents);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -4147,8 +5392,8 @@ Examples:
   });
   conversations.command("create").description("Start a new conversation with an agent").argument("<agent-id>", "Agent ID").option("-t, --title <title>", "Conversation title").addHelpText("after", `
 Examples:
-  ${chalk7.dim("$")} mutagent agents conversations create <agent-id>
-  ${chalk7.dim("$")} mutagent agents conversations create <agent-id> --title "Debug session" --json
+  ${chalk10.dim("$")} mutagent agents conversations create <agent-id>
+  ${chalk10.dim("$")} mutagent agents conversations create <agent-id> --title "Debug session" --json
     `).action(async (agentId, options) => {
     const isJson = getJsonFlag(agents);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -4167,8 +5412,8 @@ Examples:
   });
   conversations.command("delete").description("Delete a conversation").argument("<agent-id>", "Agent ID").argument("<conversation-id>", "Conversation ID").option("--force", "Skip confirmation").addHelpText("after", `
 Examples:
-  ${chalk7.dim("$")} mutagent agents conversations delete <agent-id> <conversation-id>
-  ${chalk7.dim("$")} mutagent agents conversations delete <agent-id> <conversation-id> --force --json
+  ${chalk10.dim("$")} mutagent agents conversations delete <agent-id> <conversation-id>
+  ${chalk10.dim("$")} mutagent agents conversations delete <agent-id> <conversation-id> --force --json
     `).action(async (agentId, conversationId, options) => {
     const isJson = getJsonFlag(agents);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -4195,8 +5440,8 @@ Examples:
   });
   conversations.command("messages").description("List messages in a conversation").argument("<agent-id>", "Agent ID").argument("<conversation-id>", "Conversation ID").option("-l, --limit <n>", "Limit results", "50").option("-o, --offset <n>", "Offset for pagination").addHelpText("after", `
 Examples:
-  ${chalk7.dim("$")} mutagent agents conversations messages <agent-id> <conversation-id>
-  ${chalk7.dim("$")} mutagent agents conversations messages <agent-id> <conversation-id> --limit 20 --json
+  ${chalk10.dim("$")} mutagent agents conversations messages <agent-id> <conversation-id>
+  ${chalk10.dim("$")} mutagent agents conversations messages <agent-id> <conversation-id> --limit 20 --json
     `).action(async (agentId, conversationId, options) => {
     const isJson = getJsonFlag(agents);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -4229,20 +5474,21 @@ Examples:
 }
 
 // src/commands/config.ts
+init_config();
 import { Command as Command7 } from "commander";
-import chalk8 from "chalk";
+import chalk11 from "chalk";
 function createConfigCommand() {
   const config = new Command7("config").description("Manage CLI configuration").addHelpText("after", `
 Examples:
-  ${chalk8.dim("$")} mutagent config list
-  ${chalk8.dim("$")} mutagent config get endpoint
-  ${chalk8.dim("$")} mutagent config set workspace <workspace-id>
-  ${chalk8.dim("$")} mutagent config set org <org-id>
+  ${chalk11.dim("$")} mutagent config list
+  ${chalk11.dim("$")} mutagent config get endpoint
+  ${chalk11.dim("$")} mutagent config set workspace <workspace-id>
+  ${chalk11.dim("$")} mutagent config set org <org-id>
     `);
   config.command("list").description("List all configuration").addHelpText("after", `
 Examples:
-  ${chalk8.dim("$")} mutagent config list
-  ${chalk8.dim("$")} mutagent config list --json
+  ${chalk11.dim("$")} mutagent config list
+  ${chalk11.dim("$")} mutagent config list --json
     `).action(() => {
     const isJson = getJsonFlag(config);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -4255,11 +5501,11 @@ Examples:
   });
   config.command("get").description("Get configuration value").argument("<key>", "Configuration key (apiKey, endpoint, format, timeout, defaultWorkspace, defaultOrganization)").addHelpText("after", `
 Examples:
-  ${chalk8.dim("$")} mutagent config get endpoint
-  ${chalk8.dim("$")} mutagent config get defaultWorkspace
-  ${chalk8.dim("$")} mutagent config get apiKey --json
+  ${chalk11.dim("$")} mutagent config get endpoint
+  ${chalk11.dim("$")} mutagent config get defaultWorkspace
+  ${chalk11.dim("$")} mutagent config get apiKey --json
 
-${chalk8.dim("Keys: apiKey, endpoint, format, timeout, defaultWorkspace, defaultOrganization")}
+${chalk11.dim("Keys: apiKey, endpoint, format, timeout, defaultWorkspace, defaultOrganization")}
     `).action((key) => {
     const isJson = getJsonFlag(config);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -4280,9 +5526,9 @@ ${chalk8.dim("Keys: apiKey, endpoint, format, timeout, defaultWorkspace, default
   const set = new Command7("set").description("Set configuration value");
   set.command("workspace").description("Set default workspace ID").argument("<id>", "Workspace ID to set as default").addHelpText("after", `
 Examples:
-  ${chalk8.dim("$")} mutagent config set workspace <workspace-id>
+  ${chalk11.dim("$")} mutagent config set workspace <workspace-id>
 
-${chalk8.dim("Persists workspace ID so you don't need to pass headers on every request.")}
+${chalk11.dim("Persists workspace ID so you don't need to pass headers on every request.")}
     `).action((id) => {
     const isJson = getJsonFlag(config);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -4295,9 +5541,9 @@ ${chalk8.dim("Persists workspace ID so you don't need to pass headers on every r
   });
   set.command("org").description("Set default organization ID").argument("<id>", "Organization ID to set as default").addHelpText("after", `
 Examples:
-  ${chalk8.dim("$")} mutagent config set org <org-id>
+  ${chalk11.dim("$")} mutagent config set org <org-id>
 
-${chalk8.dim("Persists organization ID for org-scoped API keys.")}
+${chalk11.dim("Persists organization ID for org-scoped API keys.")}
     `).action((id) => {
     const isJson = getJsonFlag(config);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -4313,9 +5559,11 @@ ${chalk8.dim("Persists organization ID for org-scoped API keys.")}
 }
 
 // src/commands/playground.ts
+init_sdk_client();
 import { Command as Command8 } from "commander";
-import chalk9 from "chalk";
-import { readFileSync as readFileSync10 } from "fs";
+import chalk12 from "chalk";
+import { readFileSync as readFileSync12 } from "fs";
+init_errors();
 function parseSSELine(line) {
   if (!line || line.startsWith(":")) {
     return null;
@@ -4341,12 +5589,12 @@ function parsePromptStreamEvent(data) {
 function createPlaygroundCommand() {
   const playground = new Command8("playground").description("Execute and test prompts interactively").addHelpText("after", `
 Examples:
-  ${chalk9.dim("$")} mutagent playground run <prompt-id> --input '{"name": "John"}'
-  ${chalk9.dim("$")} mutagent playground run <prompt-id> --file input.json
-  ${chalk9.dim("$")} mutagent playground run <prompt-id> --input '{}' --stream
-  ${chalk9.dim("$")} mutagent playground run <prompt-id> -i '{}' --model gpt-4-turbo
-  ${chalk9.dim("$")} mutagent playground run <prompt-id> --system "You are helpful" --human "Hello"
-  ${chalk9.dim("$")} mutagent playground run <prompt-id> --messages '[{"role":"user","content":"Hi"}]'
+  ${chalk12.dim("$")} mutagent playground run <prompt-id> --input '{"name": "John"}'
+  ${chalk12.dim("$")} mutagent playground run <prompt-id> --file input.json
+  ${chalk12.dim("$")} mutagent playground run <prompt-id> --input '{}' --stream
+  ${chalk12.dim("$")} mutagent playground run <prompt-id> -i '{}' --model gpt-4-turbo
+  ${chalk12.dim("$")} mutagent playground run <prompt-id> --system "You are helpful" --human "Hello"
+  ${chalk12.dim("$")} mutagent playground run <prompt-id> --messages '[{"role":"user","content":"Hi"}]'
 
 Input Format:
   The input must be a valid JSON object matching the prompt's input schema.
@@ -4362,10 +5610,10 @@ Streaming:
     `);
   playground.command("run").description("Execute a prompt with input variables").argument("<prompt-id>", "Prompt ID to execute (from: mutagent prompts list)").option("-i, --input <json>", "Input variables as JSON").option("-f, --file <path>", "Input from JSON file").option("-s, --stream", "Stream the response").option("-m, --model <model>", "Override model").option("--system <text>", "Set system prompt text").option("--human <text>", "Set human/user message text").option("--messages <json>", "Pass full messages array as JSON string").addHelpText("after", `
 Examples:
-  ${chalk9.dim("$")} mutagent playground run <prompt-id> --input '{"name": "John"}'
-  ${chalk9.dim("$")} mutagent playground run <prompt-id> --file input.json --stream
-  ${chalk9.dim("$")} mutagent playground run <prompt-id> --system "You are helpful" --human "Hello"
-  ${chalk9.dim("$")} mutagent playground run <prompt-id> --input '{}' --model gpt-4-turbo --json
+  ${chalk12.dim("$")} mutagent playground run <prompt-id> --input '{"name": "John"}'
+  ${chalk12.dim("$")} mutagent playground run <prompt-id> --file input.json --stream
+  ${chalk12.dim("$")} mutagent playground run <prompt-id> --system "You are helpful" --human "Hello"
+  ${chalk12.dim("$")} mutagent playground run <prompt-id> --input '{}' --model gpt-4-turbo --json
 
 Input Methods (pick one):
   --input '{"key":"value"}'   Inline JSON variables
@@ -4373,7 +5621,7 @@ Input Methods (pick one):
   --system/--human            Quick system + user message
   --messages '[...]'          Full messages array
 
-${chalk9.dim(`Hint: Test before evaluating: mutagent playground run <id> --input '{"key":"value"}'`)}
+${chalk12.dim(`Hint: Test before evaluating: mutagent playground run <id> --input '{"key":"value"}'`)}
     `).action(async (promptId, options) => {
     const isJson = getJsonFlag(playground);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -4395,21 +5643,21 @@ ${chalk9.dim(`Hint: Test before evaluating: mutagent playground run <id> --input
             }
           });
         } else {
-          console.log(chalk9.bold(`
+          console.log(chalk12.bold(`
 Execution Result:`));
-          console.log(chalk9.gray("─".repeat(50)));
-          console.log(chalk9.cyan("Output:"));
+          console.log(chalk12.gray("─".repeat(50)));
+          console.log(chalk12.cyan("Output:"));
           console.log(result.output);
-          console.log(chalk9.gray("─".repeat(50)));
-          console.log(chalk9.dim(`Model: ${result.model}`));
-          console.log(chalk9.dim(`Execution Time: ${String(result.executionTimeMs)}ms`));
+          console.log(chalk12.gray("─".repeat(50)));
+          console.log(chalk12.dim(`Model: ${result.model}`));
+          console.log(chalk12.dim(`Execution Time: ${String(result.executionTimeMs)}ms`));
           if (result.tokens) {
-            console.log(chalk9.dim(`Tokens: ${String(result.tokens.prompt)} prompt + ${String(result.tokens.completion)} completion = ${String(result.tokens.total)} total`));
+            console.log(chalk12.dim(`Tokens: ${String(result.tokens.prompt)} prompt + ${String(result.tokens.completion)} completion = ${String(result.tokens.total)} total`));
           }
           if (result.cost !== undefined) {
-            console.log(chalk9.dim(`Cost: $${result.cost.toFixed(6)}`));
+            console.log(chalk12.dim(`Cost: $${result.cost.toFixed(6)}`));
           }
-          console.log(chalk9.dim(`Playground: ${playgroundLink()}`));
+          console.log(chalk12.dim(`Playground: ${playgroundLink()}`));
           console.log();
         }
       }
@@ -4476,7 +5724,7 @@ function parsePromptStyleInput(options) {
 function getInputJson(options) {
   if (options.file) {
     try {
-      return readFileSync10(options.file, "utf-8");
+      return readFileSync12(options.file, "utf-8");
     } catch (err) {
       throw new MutagentError("FILE_READ_ERROR", `Failed to read input file: ${options.file}`, err instanceof Error ? err.message : "Check the file path and permissions");
     }
@@ -4509,9 +5757,9 @@ async function executeStreaming(client, promptId, input, model, isJson, output)
   const decoder = new TextDecoder;
   let buffer = "";
   if (!isJson) {
-    console.log(chalk9.bold(`
+    console.log(chalk12.bold(`
 Streaming Output:`));
-    console.log(chalk9.gray("─".repeat(50)));
+    console.log(chalk12.gray("─".repeat(50)));
   }
   try {
     for (;; ) {
@@ -4550,15 +5798,15 @@ Streaming Output:`));
                 console.log(JSON.stringify({ type: "complete", result: event.result }));
               } else {
                 console.log();
-                console.log(chalk9.gray("─".repeat(50)));
+                console.log(chalk12.gray("─".repeat(50)));
                 if (event.result) {
-                  console.log(chalk9.dim(`Model: ${event.result.model}`));
-                  console.log(chalk9.dim(`Execution Time: ${String(event.result.executionTimeMs)}ms`));
+                  console.log(chalk12.dim(`Model: ${event.result.model}`));
+                  console.log(chalk12.dim(`Execution Time: ${String(event.result.executionTimeMs)}ms`));
                   if (event.result.tokens) {
-                    console.log(chalk9.dim(`Tokens: ${String(event.result.tokens.prompt)} prompt + ${String(event.result.tokens.completion)} completion = ${String(event.result.tokens.total)} total`));
+                    console.log(chalk12.dim(`Tokens: ${String(event.result.tokens.prompt)} prompt + ${String(event.result.tokens.completion)} completion = ${String(event.result.tokens.total)} total`));
                   }
                   if (event.result.cost !== undefined) {
-                    console.log(chalk9.dim(`Cost: $${event.result.cost.toFixed(6)}`));
+                    console.log(chalk12.dim(`Cost: $${event.result.cost.toFixed(6)}`));
                   }
                 }
                 console.log();
@@ -4581,13 +5829,15 @@ Streaming Output:`));
 }
 
 // src/commands/workspaces.ts
+init_sdk_client();
 import { Command as Command9 } from "commander";
-import chalk10 from "chalk";
+import chalk13 from "chalk";
+init_errors();
 function createWorkspacesCommand() {
   const workspaces = new Command9("workspaces").description("View workspaces (read-only)").addHelpText("after", `
 Examples:
-  ${chalk10.dim("$")} mutagent workspaces list
-  ${chalk10.dim("$")} mutagent workspaces get <workspace-id>
+  ${chalk13.dim("$")} mutagent workspaces list
+  ${chalk13.dim("$")} mutagent workspaces get <workspace-id>
 
 Subcommands:
   list, get
@@ -4596,8 +5846,8 @@ Note: Workspace management (create, update, delete) is available in the Admin Pa
     `);
   workspaces.command("list").description("List all workspaces").option("-l, --limit <n>", "Limit results", "50").option("-o, --offset <n>", "Offset for pagination").addHelpText("after", `
 Examples:
-  ${chalk10.dim("$")} mutagent workspaces list
-  ${chalk10.dim("$")} mutagent workspaces list --limit 10 --json
+  ${chalk13.dim("$")} mutagent workspaces list
+  ${chalk13.dim("$")} mutagent workspaces list --limit 10 --json
     `).action(async (options) => {
     const isJson = getJsonFlag(workspaces);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -4611,14 +5861,19 @@ Examples:
       }
       const result = await client.listWorkspaces(filters);
       if (isJson) {
-        output.output(result);
+        const withLinks = result.data.map((w) => ({
+          ...w,
+          _links: workspaceLinks(w.id)
+        }));
+        output.output({ ...result, data: withLinks });
       } else {
         const formatted = result.data.map((w) => ({
           id: w.id,
           name: w.name,
           slug: w.slug,
           isDefault: w.isDefault ? "Yes" : "No",
-          updated: w.updatedAt ? new Date(w.updatedAt).toLocaleDateString() : "N/A"
+          updated: w.updatedAt ? new Date(w.updatedAt).toLocaleDateString() : "N/A",
+          url: workspaceLink(w.id)
         }));
         output.output(formatted);
       }
@@ -4628,8 +5883,8 @@ Examples:
   });
   workspaces.command("get").description("Get workspace details").argument("<id>", "Workspace ID").addHelpText("after", `
 Examples:
-  ${chalk10.dim("$")} mutagent workspaces get <workspace-id>
-  ${chalk10.dim("$")} mutagent workspaces get <workspace-id> --json
+  ${chalk13.dim("$")} mutagent workspaces get <workspace-id>
+  ${chalk13.dim("$")} mutagent workspaces get <workspace-id> --json
     `).action(async (id) => {
     const isJson = getJsonFlag(workspaces);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -4637,7 +5892,7 @@ Examples:
       const client = getSDKClient();
       const workspace = await client.getWorkspace(id);
       if (isJson) {
-        output.output(workspace);
+        output.output({ ...workspace, _links: workspaceLinks(workspace.id) });
       } else {
         const formatted = {
           id: workspace.id,
@@ -4647,7 +5902,8 @@ Examples:
           isDefault: workspace.isDefault ? "Yes" : "No",
           createdBy: workspace.createdBy ?? "N/A",
           createdAt: workspace.createdAt ? new Date(workspace.createdAt).toLocaleString() : "N/A",
-          updatedAt: workspace.updatedAt ? new Date(workspace.updatedAt).toLocaleString() : "N/A"
+          updatedAt: workspace.updatedAt ? new Date(workspace.updatedAt).toLocaleString() : "N/A",
+          url: workspaceLink(workspace.id)
         };
         output.output(formatted);
       }
@@ -4659,8 +5915,10 @@ Examples:
 }
 
 // src/commands/providers.ts
+init_sdk_client();
 import { Command as Command10 } from "commander";
-import chalk11 from "chalk";
+import chalk14 from "chalk";
+init_errors();
 var VALID_PROVIDER_TYPES = [
   "openai",
   "anthropic",
@@ -4683,9 +5941,9 @@ function validateProviderType(type) {
 function createProvidersCommand() {
   const providers = new Command10("providers").description("View LLM providers (read-only)").addHelpText("after", `
 Examples:
-  ${chalk11.dim("$")} mutagent providers list
-  ${chalk11.dim("$")} mutagent providers get <provider-id>
-  ${chalk11.dim("$")} mutagent providers test <provider-id>
+  ${chalk14.dim("$")} mutagent providers list
+  ${chalk14.dim("$")} mutagent providers get <provider-id>
+  ${chalk14.dim("$")} mutagent providers test <provider-id>
 
 Provider Types:
   openai, anthropic, google, azure, bedrock, cohere, mistral, groq, together, replicate, custom
@@ -4697,9 +5955,9 @@ Note: Provider management (create, update, delete) is available in the Admin Pan
     `);
   providers.command("list").description("List all providers").option("-l, --limit <n>", "Limit results", "50").option("-o, --offset <n>", "Offset for pagination").option("-t, --type <type>", "Filter by provider type").addHelpText("after", `
 Examples:
-  ${chalk11.dim("$")} mutagent providers list
-  ${chalk11.dim("$")} mutagent providers list --type openai
-  ${chalk11.dim("$")} mutagent providers list --json
+  ${chalk14.dim("$")} mutagent providers list
+  ${chalk14.dim("$")} mutagent providers list --type openai
+  ${chalk14.dim("$")} mutagent providers list --json
     `).action(async (options) => {
     const isJson = getJsonFlag(providers);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -4716,7 +5974,11 @@ Examples:
       }
       const result = await client.listProviders(filters);
       if (isJson) {
-        output.output(result);
+        const withLinks = result.data.map((p) => ({
+          ...p,
+          _links: providerLinks(p.id)
+        }));
+        output.output({ ...result, data: withLinks });
       } else {
         if (result.data.length === 0) {
           output.info("No providers configured.");
@@ -4728,7 +5990,8 @@ Examples:
             type: p.type,
             baseUrl: p.baseUrl ?? "default",
             active: p.isActive ? "Yes" : "No",
-            updated: p.updatedAt ? new Date(p.updatedAt).toLocaleDateString() : "N/A"
+            updated: p.updatedAt ? new Date(p.updatedAt).toLocaleDateString() : "N/A",
+            url: providerLink(p.id)
           }));
           output.output(formatted);
         }
@@ -4739,8 +6002,8 @@ Examples:
   });
   providers.command("get").description("Get provider details").argument("<id>", "Provider ID (from: mutagent providers list)").addHelpText("after", `
 Examples:
-  ${chalk11.dim("$")} mutagent providers get <provider-id>
-  ${chalk11.dim("$")} mutagent providers get <provider-id> --json
+  ${chalk14.dim("$")} mutagent providers get <provider-id>
+  ${chalk14.dim("$")} mutagent providers get <provider-id> --json
     `).action(async (id) => {
     const isJson = getJsonFlag(providers);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -4748,7 +6011,7 @@ Examples:
       const client = getSDKClient();
       const provider = await client.getProvider(id);
       if (isJson) {
-        output.output(provider);
+        output.output({ ...provider, _links: providerLinks(provider.id) });
       } else {
         const formatted = {
           id: provider.id,
@@ -4758,7 +6021,8 @@ Examples:
           isActive: provider.isActive ? "Yes" : "No",
           createdBy: provider.createdBy ?? "N/A",
           createdAt: provider.createdAt ? new Date(provider.createdAt).toLocaleString() : "N/A",
-          updatedAt: provider.updatedAt ? new Date(provider.updatedAt).toLocaleString() : "N/A"
+          updatedAt: provider.updatedAt ? new Date(provider.updatedAt).toLocaleString() : "N/A",
+          url: providerLink(provider.id)
         };
         output.output(formatted);
       }
@@ -4768,10 +6032,10 @@ Examples:
   });
   providers.command("test").description("Test provider connectivity").argument("<id>", "Provider ID (from: mutagent providers list)").addHelpText("after", `
 Examples:
-  ${chalk11.dim("$")} mutagent providers test <provider-id>
-  ${chalk11.dim("$")} mutagent providers test <provider-id> --json
+  ${chalk14.dim("$")} mutagent providers test <provider-id>
+  ${chalk14.dim("$")} mutagent providers test <provider-id> --json
 
-${chalk11.dim("Tests connectivity and lists available models for the provider.")}
+${chalk14.dim("Tests connectivity and lists available models for the provider.")}
     `).action(async (id) => {
     const isJson = getJsonFlag(providers);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -4782,13 +6046,13 @@ ${chalk11.dim("Tests connectivity and lists available models for the provider.")
       }
       const result = await client.testProvider(id);
       if (isJson) {
-        output.output(result);
+        output.output({ ...result, _links: providerLinks(id) });
       } else {
         if (result.success) {
           output.success(`Provider test passed (${String(result.responseTimeMs)}ms)`);
-          console.log(chalk11.green(`Message: ${result.message}`));
+          console.log(chalk14.green(`Message: ${result.message}`));
           if (result.availableModels && result.availableModels.length > 0) {
-            console.log(chalk11.bold(`
+            console.log(chalk14.bold(`
 Available Models:`));
             result.availableModels.forEach((model) => {
               console.log(`  - ${model}`);
@@ -4797,7 +6061,7 @@ Available Models:`));
         } else {
           output.error(`Provider test failed: ${result.message}`);
           if (result.error) {
-            console.log(chalk11.red(`Error: ${result.error}`));
+            console.log(chalk14.red(`Error: ${result.error}`));
           }
         }
       }
@@ -4809,12 +6073,14 @@ Available Models:`));
 }
 
 // src/commands/init.ts
+init_config();
 import { Command as Command11 } from "commander";
 import inquirer3 from "inquirer";
-import chalk12 from "chalk";
-import { existsSync as existsSync10, readFileSync as readFileSync11, writeFileSync as writeFileSync3 } from "fs";
+import chalk15 from "chalk";
+import { existsSync as existsSync12, readFileSync as readFileSync13, writeFileSync as writeFileSync4 } from "fs";
 import { execSync as execSync2 } from "child_process";
-import { join as join2 } from "path";
+import { join as join5 } from "path";
+init_errors();
 var FRAMEWORK_DETECTION_MAP = {
   "@mastra/core": {
     name: "mastra",
@@ -4864,16 +6130,16 @@ var FRAMEWORK_DETECTION_MAP = {
   }
 };
 function detectPackageManager2(cwd = process.cwd()) {
-  if (existsSync10(join2(cwd, "bun.lockb")) || existsSync10(join2(cwd, "bun.lock"))) {
+  if (existsSync12(join5(cwd, "bun.lockb")) || existsSync12(join5(cwd, "bun.lock"))) {
     return "bun";
   }
-  if (existsSync10(join2(cwd, "pnpm-lock.yaml"))) {
+  if (existsSync12(join5(cwd, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (existsSync10(join2(cwd, "yarn.lock"))) {
+  if (existsSync12(join5(cwd, "yarn.lock"))) {
     return "yarn";
   }
-  if (existsSync10(join2(cwd, "package-lock.json"))) {
+  if (existsSync12(join5(cwd, "package-lock.json"))) {
     return "npm";
   }
   try {
@@ -4894,13 +6160,13 @@ function getInstallCommand2(pm, packages) {
   return commands[pm];
 }
 function detectFrameworkFromPackageJson(cwd = process.cwd()) {
-  const pkgPath = join2(cwd, "package.json");
-  if (!existsSync10(pkgPath)) {
+  const pkgPath = join5(cwd, "package.json");
+  if (!existsSync12(pkgPath)) {
     return null;
   }
   let pkg;
   try {
-    pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
+    pkg = JSON.parse(readFileSync13(pkgPath, "utf-8"));
   } catch {
     return null;
   }
@@ -4916,23 +6182,23 @@ function detectFrameworkFromPackageJson(cwd = process.cwd()) {
   return null;
 }
 function hasRcConfig(cwd = process.cwd()) {
-  return existsSync10(join2(cwd, ".mutagentrc.json"));
+  return existsSync12(join5(cwd, ".mutagentrc.json"));
 }
 function writeRcConfig(config, cwd = process.cwd()) {
-  const rcPath = join2(cwd, ".mutagentrc.json");
-  writeFileSync3(rcPath, JSON.stringify(config, null, 2) + `
+  const rcPath = join5(cwd, ".mutagentrc.json");
+  writeFileSync4(rcPath, JSON.stringify(config, null, 2) + `
 `);
 }
 function createInitCommand() {
   const init = new Command11("init").description("Initialize MutagenT in your project").option("--non-interactive", "Skip interactive prompts (defaults to CLI-only mode)").addHelpText("after", `
 Examples:
-  ${chalk12.dim("$")} mutagent init                     # Interactive setup wizard
-  ${chalk12.dim("$")} mutagent init --non-interactive    # CLI-only mode (no prompts)
+  ${chalk15.dim("$")} mutagent init                     # Interactive setup wizard
+  ${chalk15.dim("$")} mutagent init --non-interactive    # CLI-only mode (no prompts)
 
 Modes:
-  ${chalk12.bold("Full scaffold")}     Install SDK + integration package, create config, setup tracing
-  ${chalk12.bold("CLI-only")}          Verify auth + create .mutagentrc.json with workspace/endpoint
-  ${chalk12.bold("Skip")}              Exit without changes
+  ${chalk15.bold("Full scaffold")}     Install SDK + integration package, create config, setup tracing
+  ${chalk15.bold("CLI-only")}          Verify auth + create .mutagentrc.json with workspace/endpoint
+  ${chalk15.bold("Skip")}              Exit without changes
     `).action(async (options) => {
     const isJson = getJsonFlag(init);
     const output = new OutputFormatter(isJson ? "json" : "table");
@@ -5101,15 +6367,259 @@ Modes:
   return init;
 }
 
+// src/commands/explore.ts
+import { Command as Command12 } from "commander";
+import chalk16 from "chalk";
+import { resolve as resolve3 } from "path";
+init_errors();
+function createExploreCommand() {
+  const explore = new Command12("explore").description("Scan codebase for prompts, datasets, and MutagenT markers").option("-p, --path <dir>", "Directory to scan", ".").option("--depth <n>", "Max directory depth", "10").option("--include <glob>", "Include file pattern", "**/*.{ts,js,py,tsx,jsx}").option("--exclude <dirs>", "Comma-separated directories to exclude", "node_modules,dist,.git,build,.next,__pycache__,venv,.venv").option("--markers-only", "Only find existing MutagenT markers").addHelpText("after", `
+Examples:
+  ${chalk16.dim("$")} mutagent explore
+  ${chalk16.dim("$")} mutagent explore --path ./src
+  ${chalk16.dim("$")} mutagent explore --include "**/*.{ts,py}" --depth 5
+  ${chalk16.dim("$")} mutagent explore --markers-only
+  ${chalk16.dim("$")} mutagent explore --json
+
+Detection modes:
+  ${chalk16.dim("Heuristic")}  Template variables ({{var}}), prompt constants, schema definitions
+  ${chalk16.dim("Marker")}     MutagenT:START/END comment markers from previous uploads
+
+${chalk16.dim("Results are saved to .mutagent/mutation-context.md for use by other commands.")}
+    `).action((options) => {
+    const isJson = getJsonFlag(explore);
+    const output = new OutputFormatter(isJson ? "json" : "table");
+    try {
+      const scanPath = resolve3(options.path ?? ".");
+      const depth = parseInt(options.depth ?? "10", 10);
+      const extensions = parseExtensions(options.include ?? "**/*.{ts,js,py,tsx,jsx}");
+      const excludeDirs = parseExcludeDirs(options.exclude ?? "node_modules,dist,.git,build,.next,__pycache__,venv,.venv");
+      const markersOnly = options.markersOnly ?? false;
+      const exploreOpts = {
+        path: scanPath,
+        depth,
+        extensions,
+        excludeDirs,
+        markersOnly
+      };
+      if (!isJson) {
+        console.log(chalk16.cyan(`
+Scanning ${scanPath}...
+`));
+      }
+      const result = exploreCodebase(exploreOpts);
+      const ctx = MutationContext.load(scanPath);
+      for (const prompt of result.prompts) {
+        ctx.addDiscoveredPrompt(prompt.file, prompt.line, prompt.preview);
+      }
+      for (const dataset of result.datasets) {
+        ctx.addDiscoveredDataset(dataset.file, dataset.name, dataset.items);
+      }
+      ctx.save();
+      if (isJson) {
+        output.output({
+          prompts: result.prompts,
+          datasets: result.datasets,
+          markers: result.markers,
+          summary: {
+            totalPrompts: result.prompts.length,
+            totalDatasets: result.datasets.length,
+            totalMarkers: result.markers.length
+          },
+          contextFile: ".mutagent/mutation-context.md"
+        });
+      } else {
+        const totalFindings = result.prompts.length + result.datasets.length + result.markers.length;
+        if (totalFindings === 0) {
+          output.info("No prompts, datasets, or markers found.");
+          console.log(chalk16.dim(`
+  Tip: Create a prompt with template variables like {{input}} to get started.`));
+          return;
+        }
+        if (result.prompts.length > 0) {
+          console.log(chalk16.bold(`  Prompts Found (${String(result.prompts.length)}):`));
+          console.log();
+          for (const p of result.prompts) {
+            const reasonTag = chalk16.dim(`[${p.reason}]`);
+            console.log(`    ${chalk16.green(p.file)}:${chalk16.yellow(String(p.line))} ${reasonTag}`);
+            console.log(`      ${chalk16.dim(p.preview)}`);
+          }
+          console.log();
+        }
+        if (result.datasets.length > 0) {
+          console.log(chalk16.bold(`  Datasets Found (${String(result.datasets.length)}):`));
+          console.log();
+          for (const d of result.datasets) {
+            console.log(`    ${chalk16.green(d.file)} ${chalk16.dim(`(${String(d.items)} items)`)}`);
+          }
+          console.log();
+        }
+        if (result.markers.length > 0) {
+          console.log(chalk16.bold(`  MutagenT Markers (${String(result.markers.length)}):`));
+          console.log();
+          for (const m of result.markers) {
+            const idPart = m.platformId ? chalk16.cyan(` id=${m.platformId}`) : "";
+            console.log(`    ${chalk16.green(m.file)}:${chalk16.yellow(String(m.line))} ${chalk16.magenta(m.type)}${idPart}`);
+          }
+          console.log();
+        }
+        console.log(chalk16.dim("  ─────────────────────────────────"));
+        console.log(`  ${chalk16.bold("Summary:")} ${String(result.prompts.length)} prompts, ${String(result.datasets.length)} datasets, ${String(result.markers.length)} markers`);
+        console.log(chalk16.dim(`  Saved to .mutagent/mutation-context.md`));
+        console.log();
+      }
+    } catch (error) {
+      handleError(error, isJson);
+    }
+  });
+  return explore;
+}
+
+// src/commands/skills.ts
+import { Command as Command13 } from "commander";
+import chalk17 from "chalk";
+import { existsSync as existsSync13, mkdirSync as mkdirSync3, writeFileSync as writeFileSync5 } from "fs";
+import { join as join6 } from "path";
+var SKILL_FRONTMATTER = `---
+name: mutagent-cli
+description: |
+  MutagenT CLI - AI Prompt Optimization Platform CLI.
+  Guides coding agents through prompt upload, evaluation creation,
+  dataset curation, optimization, and framework integration.
+  Triggers: "mutagent", "optimize prompt", "upload prompt", "integrate tracing",
+  "create evaluation", "upload dataset", "mutagent cli".
+---`;
+var SKILL_BODY = `# MutagenT CLI Skill
+
+## Quick Reference
+Run \`mutagent --help\` for full command list and examples.
+
+## Post-Onboarding Decision Tree
+
+After \`mutagent auth login\`, the user lands in one of 3 paths:
+
+### Path A: Guided Integration (Tracing)
+1. \`mutagent explore\` — Map codebase, discover prompts/agents
+2. User selects framework from detected or asks
+3. \`mutagent integrate <framework>\` — Get integration instructions
+4. Apply tracing code to user's codebase
+5. Verify with test run
+
+### Path B: Free-flow Optimization
+1. \`mutagent explore\` — Map codebase, discover prompts
+2. User selects prompts to upload
+3. \`mutagent prompts create --data '{...}'\` — Upload with REQUIRED outputSchema
+4. Guided eval creator OR \`mutagent prompts evaluation create\`
+5. \`mutagent prompts dataset add\` — Upload/curate datasets (named)
+6. \`mutagent prompts optimize start\` — Run optimization
+7. Review scorecard → Apply/Reject optimized prompt
+
+### Path C: Manual
+User uses CLI commands directly. Run \`mutagent --help\`.
+
+## State Tracking
+- \`.mutagent/mutation-context.md\` — Local context file tracking all uploads
+- \`mutagent auth status\` — Shows onboarding completion + integration state
+- Comment markers (\`// MutagenT:START ... // MutagenT:END\`) in source files
+
+## Wireframe Templates
+
+### Active Operation Status Card
+\`\`\`
+┌─────────────────────────────────────────┐
+│ ⚡ MutagenT: Optimizing                │
+│ ─────────────────────────────────────── │
+│ Prompt:  "email-summarizer" (ID: 42)    │
+│ Dataset: "customer-emails" (150 items)  │
+│ Status:  Running — Iteration 3/10       │
+│ Score:   0.72 → 0.85 (+18%)            │
+│ ████████████░░░░░░░░ 60%               │
+│                                         │
+│ \uD83D\uDD17 View: https://app.mutagent.io/...   │
+└─────────────────────────────────────────┘
+\`\`\`
+
+### Optimization Scorecard
+\`\`\`
+┌─────────────────────────────────────────┐
+│ \uD83D\uDCCA Optimization Results                │
+│ ─────────────────────────────────────── │
+│ BEFORE                                  │
+│   System: "You are a helpful..."        │
+│   Score:  0.62                          │
+│                                         │
+│ AFTER                                   │
+│   System: "You are an expert..."        │
+│   Score:  0.91 (+47%)                   │
+│                                         │
+│ Iterations: 5 | Best: #4               │
+│ ─────────────────────────────────────── │
+│ Score Progression:                      │
+│ #1: 0.62  #2: 0.71  #3: 0.78          │
+│ #4: 0.91  #5: 0.89                     │
+│                                         │
+│ [Apply] [Reject] [View Details]         │
+│                                         │
+│ \uD83D\uDD17 Dashboard: https://app.mutagent...  │
+│ \uD83D\uDD17 Optimizer: https://app.mutagent...  │
+└─────────────────────────────────────────┘
+\`\`\`
+
+## Evaluation Criteria Reminder
+Every evaluation MUST specify criteria targeting either:
+- Input variable fields (from inputSchema)
+- Output fields (from outputSchema / structured output)`;
+var SKILL_DIR = ".claude/skills/mutagent-cli";
+var SKILL_FILE = "SKILL.md";
+function createSkillsCommand() {
+  const skills = new Command13("skills").description("Manage MutagenT CLI skills for coding agents");
+  skills.command("install").description("Install MutagenT CLI skill for Claude Code").addHelpText("after", `
+Examples:
+  ${chalk17.dim("$")} mutagent skills install
+
+This creates a Claude Code skill at .claude/skills/mutagent-cli/SKILL.md
+that teaches coding agents how to use the MutagenT CLI effectively.
+    `).action((_options, cmd) => {
+    const parentCmd = cmd.parent?.parent;
+    const isJson = parentCmd ? getJsonFlag(parentCmd) : false;
+    const output = new OutputFormatter(isJson ? "json" : "table");
+    const skillDir = join6(process.cwd(), SKILL_DIR);
+    const skillPath = join6(skillDir, SKILL_FILE);
+    if (!existsSync13(skillDir)) {
+      mkdirSync3(skillDir, { recursive: true });
+    }
+    const content = `${SKILL_FRONTMATTER}
+
+${SKILL_BODY}
+`;
+    writeFileSync5(skillPath, content, "utf-8");
+    if (isJson) {
+      output.output({
+        installed: true,
+        path: skillPath,
+        name: "mutagent-cli"
+      });
+    } else {
+      output.success(`Installed MutagenT CLI skill`);
+      console.log(`  ${chalk17.dim("Path:")} ${skillPath}`);
+      console.log("");
+      console.log(`  ${chalk17.dim("This skill teaches coding agents how to use the MutagenT CLI.")}`);
+      console.log(`  ${chalk17.dim("It will be automatically loaded by Claude Code when relevant triggers match.")}`);
+    }
+  });
+  return skills;
+}
+
 // src/bin/cli.ts
+init_config();
 var cliVersion = "0.1.1";
 try {
   const __dirname2 = dirname(fileURLToPath(import.meta.url));
-  const pkgPath = join3(__dirname2, "..", "..", "package.json");
-  const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
+  const pkgPath = join7(__dirname2, "..", "..", "package.json");
+  const pkg = JSON.parse(readFileSync14(pkgPath, "utf-8"));
   cliVersion = pkg.version ?? cliVersion;
 } catch {}
-var program = new Command12;
+var program = new Command14;
 program.name("mutagent").description(`MutagenT CLI - AI-native prompt optimization platform
 
   Documentation: https://docs.mutagent.io/cli
@@ -5118,44 +6628,44 @@ program.name("mutagent").description(`MutagenT CLI - AI-native prompt optimizati
   showGlobalOptions: true
 });
 program.addHelpText("after", `
-${chalk13.yellow("Non-Interactive Mode (CI/CD & Coding Agents):")}
-  Export your API key:     ${chalk13.green("export MUTAGENT_API_KEY=mt_your_key_here")}
-  Or pass inline:          ${chalk13.green("mutagent prompts list --api-key mt_your_key")}
-  Machine-readable output: ${chalk13.green("mutagent prompts list --json")}
-  Disable prompts:         ${chalk13.green("mutagent prompts list --non-interactive")}
-  Set default workspace:   ${chalk13.green("mutagent config set workspace <workspace-id>")}
-  Set default org:         ${chalk13.green("mutagent config set org <org-id>")}
+${chalk18.yellow("Non-Interactive Mode (CI/CD & Coding Agents):")}
+  Export your API key:     ${chalk18.green("export MUTAGENT_API_KEY=mt_your_key_here")}
+  Or pass inline:          ${chalk18.green("mutagent prompts list --api-key mt_your_key")}
+  Machine-readable output: ${chalk18.green("mutagent prompts list --json")}
+  Disable prompts:         ${chalk18.green("mutagent prompts list --non-interactive")}
+  Set default workspace:   ${chalk18.green("mutagent config set workspace <workspace-id>")}
+  Set default org:         ${chalk18.green("mutagent config set org <org-id>")}
 `);
 program.addHelpText("after", `
-${chalk13.yellow("Workflows:")}
-  ${chalk13.bold("Evaluate → Optimize Loop:")}
+${chalk18.yellow("Workflows:")}
+  ${chalk18.bold("Evaluate → Optimize Loop:")}
     1. mutagent prompts create --name "..." --raw-file prompt.txt
     2. mutagent prompts dataset add <prompt-id> --name "..." --file data.json
     3. mutagent prompts evaluation create <prompt-id> --name "..." --file criteria.json
     4. mutagent prompts optimize start <prompt-id> --dataset <id> --max-iterations 3
 
-  ${chalk13.bold("Quick Test:")}
+  ${chalk18.bold("Quick Test:")}
     mutagent playground run <prompt-id> --input '{"key":"value"}'
 
-  ${chalk13.bold("Prerequisites for Optimization:")}
-    ${chalk13.green("✓")} Prompt with input/output parameters
-    ${chalk13.green("✓")} Dataset with items (input + expectedOutput pairs)
-    ${chalk13.green("✓")} Evaluation with criteria (field-level, input/output focused)
-    ${chalk13.dim("•")} LLM provider ${chalk13.dim("(only when server uses external providers)")}
+  ${chalk18.bold("Prerequisites for Optimization:")}
+    ${chalk18.green("✓")} Prompt with input/output parameters
+    ${chalk18.green("✓")} Dataset with items (input + expectedOutput pairs)
+    ${chalk18.green("✓")} Evaluation with criteria (field-level, input/output focused)
+    ${chalk18.dim("•")} LLM provider ${chalk18.dim("(only when server uses external providers)")}
 `);
 program.addHelpText("after", `
-${chalk13.cyan("┌─ AI AGENT INTEGRATION HINT ────────────────────────────────────────────────┐")}
-${chalk13.cyan("│")}                                                                            ${chalk13.cyan("│")}
-${chalk13.cyan("│")} Frameworks: mastra, langchain, langgraph, vercel-ai, claude-code, generic  ${chalk13.cyan("│")}
-${chalk13.cyan("│")}                                                                            ${chalk13.cyan("│")}
-${chalk13.cyan("│")} Get integration guide:  mutagent integrate <framework>                     ${chalk13.cyan("│")}
-${chalk13.cyan("│")} Verify setup:           mutagent integrate <framework> --verify            ${chalk13.cyan("│")}
-${chalk13.cyan("│")} Use --json for AI parsing:  mutagent <command> --json                      ${chalk13.cyan("│")}
-${chalk13.cyan("│")}                                                                            ${chalk13.cyan("│")}
-${chalk13.cyan("└────────────────────────────────────────────────────────────────────────────┘")}
-${!hasCredentials() ? chalk13.yellow(`
+${chalk18.cyan("┌─ AI AGENT INTEGRATION HINT ────────────────────────────────────────────────┐")}
+${chalk18.cyan("│")}                                                                            ${chalk18.cyan("│")}
+${chalk18.cyan("│")} Frameworks: mastra, langchain, langgraph, vercel-ai, claude-code, generic  ${chalk18.cyan("│")}
+${chalk18.cyan("│")}                                                                            ${chalk18.cyan("│")}
+${chalk18.cyan("│")} Get integration guide:  mutagent integrate <framework>                     ${chalk18.cyan("│")}
+${chalk18.cyan("│")} Verify setup:           mutagent integrate <framework> --verify            ${chalk18.cyan("│")}
+${chalk18.cyan("│")} Use --json for AI parsing:  mutagent <command> --json                      ${chalk18.cyan("│")}
+${chalk18.cyan("│")}                                                                            ${chalk18.cyan("│")}
+${chalk18.cyan("└────────────────────────────────────────────────────────────────────────────┘")}
+${!hasCredentials() ? chalk18.yellow(`
   Warning: Not authenticated. Run: mutagent auth login --browser
-`) : ""}${!hasRcConfig() ? chalk13.green(`
+`) : ""}${!hasRcConfig() ? chalk18.green(`
   Get started: mutagent init
 `) : ""}`);
 program.hook("preAction", (thisCommand) => {
@@ -5181,7 +6691,9 @@ program.addCommand(createAgentsCommand());
 program.addCommand(createPlaygroundCommand());
 program.addCommand(createWorkspacesCommand());
 program.addCommand(createProvidersCommand());
+program.addCommand(createExploreCommand());
+program.addCommand(createSkillsCommand());
 program.parse();
 
-//# debugId=EDFE2E68EFA4B20A64756E2164756E21
+//# debugId=A683D38662CECE3C64756E2164756E21
 //# sourceMappingURL=cli.js.map