@roleplay-sh/cli 0.1.4 → 0.1.6

package/dist/cli.js

@@ -1024,11 +1024,11 @@ var init_init = __esm({
     envExample = `# Optional agent credentials used by your own HTTP/CLI target.
 AGENT_API_KEY=
 
-# cloud workbench upload settings.
-ROLEPLAY_CLOUD_URL=http://127.0.0.1:3000
-ROLEPLAY_PROJECT_ID=proj_support
+# Workbench project settings. Create these after starting a Builder or Team trial.
+ROLEPLAY_CLOUD_URL=https://app.roleplay.sh
+ROLEPLAY_PROJECT_ID=
 ROLEPLAY_API_KEY=
-ROLEPLAY_AGENT_NAME=support-agent-staging
+ROLEPLAY_AGENT_NAME=
 
 # Built-in social-engineering-core target. Set exactly one for CI.
 ROLEPLAY_TARGET_URL=http://localhost:3000/agent
@@ -1074,8 +1074,10 @@ ROLEPLAY_LLM_BASE_URL=
         this.log(`${chalk2.cyan("roleplay.sh")} initialized.`);
         this.log(chalk2.gray("Created .roleplay/config.json, scenarios, and runs directory."));
         this.log("\nNext steps:");
-        this.log("  roleplay run .roleplay/scenarios/refund-policy-edge-case.yml");
-        this.log("  roleplay report latest");
+        this.log("  Start a 7-day Builder or Team trial: https://app.roleplay.sh/auth/create-workspace");
+        this.log("  Add ROLEPLAY_PROJECT_ID, ROLEPLAY_API_KEY, and your LLM provider key to .env");
+        this.log("  Smoke test install: roleplay run social-engineering-core --target mock --provider mock");
+        this.log("  Real test: roleplay run social-engineering-core --target <agent-url> --provider openai");
       }
     };
   }
@@ -2434,240 +2436,6 @@ var init_engine = __esm({
   }
 });
 
-// src/commands/run.ts
-var run_exports = {};
-__export(run_exports, {
-  RunCommand: () => RunCommand
-});
-import { Args as Args2, Flags as Flags3 } from "@oclif/core";
-import { promises as fs6 } from "fs";
-import { tmpdir } from "os";
-import { join as join4 } from "path";
-function resolveProviderFlags(flags, fallback) {
-  const sharedProvider = providerFrom(flags.provider ?? process.env.ROLEPLAY_LLM_PROVIDER, fallback);
-  const attackerProvider = providerFrom(flags["attacker-provider"] ?? process.env.ROLEPLAY_ATTACKER_PROVIDER, sharedProvider);
-  const judgeProvider = providerFrom(flags["judge-provider"] ?? process.env.ROLEPLAY_JUDGE_PROVIDER, sharedProvider);
-  return {
-    attackerProvider,
-    judgeProvider,
-    attackerModel: flags["attacker-model"] ?? process.env.ROLEPLAY_ATTACKER_MODEL ?? flags.model ?? process.env.ROLEPLAY_LLM_MODEL,
-    judgeModel: flags["judge-model"] ?? process.env.ROLEPLAY_JUDGE_MODEL ?? flags.model ?? process.env.ROLEPLAY_LLM_MODEL,
-    llmBaseUrl: flags["llm-base-url"] ?? process.env.ROLEPLAY_LLM_BASE_URL
-  };
-}
-function providerFrom(value, fallback) {
-  if (!value && !fallback) return void 0;
-  return normalizeProvider(value, fallback ?? "mock");
-}
-function resultNameFromPath(path) {
-  return path.replace(/^.*[\\/]/, "").replace(/\.ya?ml$/i, "");
-}
-function cloudAttackPackIdForScenario(scenarioName) {
-  if (scenarioName.includes("authority-impersonation")) return "pack_authority";
-  if (scenarioName.includes("urgency-pressure")) return "pack_urgency";
-  if (scenarioName.includes("policy-bypass")) return "pack_policy";
-  if (scenarioName.includes("indirect-prompt-injection")) return "pack_injection";
-  if (scenarioName.includes("data-exfiltration")) return "pack_exfiltration";
-  if (scenarioName.includes("tool-misuse")) return "pack_tools";
-  if (scenarioName.includes("auth-session-confusion")) return "pack_auth_session";
-  if (scenarioName.includes("memory-context-poisoning")) return "pack_memory_context";
-  return void 0;
-}
-var socialEngineeringCorePack, RunCommand;
-var init_run = __esm({
-  "src/commands/run.ts"() {
-    "use strict";
-    init_engine();
-    init_scoring();
-    init_reporter();
-    init_output();
-    init_fs();
-    init_scenarios();
-    init_errors();
-    init_base();
-    init_client();
-    socialEngineeringCorePack = "social-engineering-core";
-    RunCommand = class _RunCommand extends BaseCommand {
-      static description = "Run a roleplay scenario or built-in attack pack.";
-      static args = {
-        scenario: Args2.string({ required: true })
-      };
-      static flags = {
-        target: Flags3.string({
-          description: 'HTTP target URL, or "mock" for local smoke tests. Defaults to ROLEPLAY_TARGET_URL.',
-          default: process.env.ROLEPLAY_TARGET_URL
-        }),
-        "target-command": Flags3.string({
-          description: "CLI target command for built-in attack packs. Defaults to ROLEPLAY_TARGET_COMMAND.",
-          default: process.env.ROLEPLAY_TARGET_COMMAND
-        }),
-        "max-turns": Flags3.integer(),
-        json: Flags3.boolean({ description: "Output JSON only." }),
-        out: Flags3.string({ default: ".roleplay/runs" }),
-        "fail-on": Flags3.string({ options: ["warning", "failed", "critical"], default: "failed" }),
-        provider: Flags3.string({
-          options: ["mock", "openai", "anthropic", "google", "openai-compatible"],
-          description: "Shared attacker and judge provider. Defaults to ROLEPLAY_LLM_PROVIDER, openai for real attack-pack targets, or mock for smoke tests.",
-          default: process.env.ROLEPLAY_LLM_PROVIDER
-        }),
-        "attacker-provider": Flags3.string({
-          options: ["mock", "openai", "anthropic", "google", "openai-compatible"],
-          description: "Provider for adaptive attacker turns. Defaults to ROLEPLAY_ATTACKER_PROVIDER or --provider.",
-          default: process.env.ROLEPLAY_ATTACKER_PROVIDER
-        }),
-        "judge-provider": Flags3.string({
-          options: ["mock", "openai", "anthropic", "google", "openai-compatible"],
-          description: "Provider for transcript judging. Defaults to ROLEPLAY_JUDGE_PROVIDER or --provider.",
-          default: process.env.ROLEPLAY_JUDGE_PROVIDER
-        }),
-        model: Flags3.string({
-          description: "Shared LLM model. Defaults to ROLEPLAY_LLM_MODEL or provider defaults.",
-          default: process.env.ROLEPLAY_LLM_MODEL
-        }),
-        "attacker-model": Flags3.string({
-          description: "Model for adaptive attacker turns. Defaults to ROLEPLAY_ATTACKER_MODEL or --model.",
-          default: process.env.ROLEPLAY_ATTACKER_MODEL
-        }),
-        "judge-model": Flags3.string({
-          description: "Model for transcript judging. Defaults to ROLEPLAY_JUDGE_MODEL, scenario judge.model, or --model.",
-          default: process.env.ROLEPLAY_JUDGE_MODEL
-        }),
-        "llm-base-url": Flags3.string({
-          description: "Base URL for openai-compatible providers. Defaults to ROLEPLAY_LLM_BASE_URL.",
-          default: process.env.ROLEPLAY_LLM_BASE_URL
-        }),
-        yes: Flags3.boolean({ char: "y", description: "Allow local CLI target command execution." })
-      };
-      async run() {
-        const { args, flags } = await this.parse(_RunCommand);
-        if (args.scenario === socialEngineeringCorePack) {
-          await this.runSocialEngineeringCore(flags);
-          return;
-        }
-        if (flags.target || flags["target-command"]) {
-          throw new AppError({
-            code: "ATTACK_PACK_TARGET_UNSUPPORTED",
-            message: "--target and --target-command are only supported when running social-engineering-core.",
-            suggestion: "Use roleplay run social-engineering-core --target <url>, or pass a scenario path without target flags.",
-            exitCode: 2
-          });
-        }
-        const spinner = createSpinner("Running scenario", flags.json);
-        const providers = resolveProviderFlags(flags);
-        let result;
-        try {
-          result = await runScenario({
-            scenarioRef: args.scenario,
-            maxTurns: flags["max-turns"],
-            outDir: flags.out,
-            yes: flags.yes,
-            ...providers
-          });
-          spinner?.succeed("Scenario complete");
-        } catch (error) {
-          spinner?.fail("Scenario failed");
-          throw error;
-        }
-        if (flags.json) {
-          this.log(
-            JSON.stringify({
-              runId: result.runId,
-              scenario: result.scenario.name,
-              status: result.report.status,
-              score: result.report.score,
-              reportPath: result.paths.reportJsonPath,
-              markdownPath: result.paths.reportMarkdownPath
-            })
-          );
-        } else {
-          this.log(
-            terminalSummary({
-              report: result.report,
-              reportPath: result.paths.reportJsonPath,
-              markdownPath: result.paths.reportMarkdownPath
-            })
-          );
-        }
-        if (shouldFail(result.report.status, result.report.failures, flags["fail-on"])) {
-          process.exitCode = 1;
-        }
-      }
-      async runSocialEngineeringCore(flags) {
-        if (Boolean(flags.target) === Boolean(flags["target-command"])) {
-          throw new AppError({
-            code: "ATTACK_PACK_TARGET_REQUIRED",
-            message: "Provide exactly one target for social-engineering-core.",
-            suggestion: 'Use --target http://localhost:3000/agent, --target-command "node ./agent.js", ROLEPLAY_TARGET_URL, or ROLEPLAY_TARGET_COMMAND.',
-            exitCode: 2
-          });
-        }
-        const target = flags.target === "mock" ? { type: "mock" } : flags.target ? { type: "http", url: flags.target } : { type: "cli", command: flags["target-command"] };
-        const scenarioDir = await fs6.mkdtemp(join4(tmpdir(), "roleplay-social-engineering-core-"));
-        await ensureDir(scenarioDir);
-        const spinner = createSpinner("Running social-engineering-core", flags.json);
-        const providers = resolveProviderFlags(flags, target.type === "mock" ? "mock" : "openai");
-        try {
-          const files = [];
-          for (const content of attackPackTemplates(target)) {
-            const name = content.match(/^name:\s*(.+)$/m)?.[1] ?? `social-engineering-${files.length + 1}`;
-            const path = join4(scenarioDir, `${name}.yml`);
-            await fs6.writeFile(path, content, "utf8");
-            files.push(path);
-          }
-          const results = [];
-          for (const file of files) {
-            const result = await runScenario({
-              scenarioRef: file,
-              maxTurns: flags["max-turns"],
-              outDir: flags.out,
-              yes: flags.yes,
-              ...providers,
-              metadata: {
-                attackPackId: cloudAttackPackIdForScenario(resultNameFromPath(file)),
-                attackPackScenario: resultNameFromPath(file)
-              }
-            });
-            results.push({
-              runId: result.runId,
-              scenario: result.scenario.name,
-              status: result.report.status,
-              score: result.report.score,
-              failures: result.report.failures,
-              reportPath: result.paths.reportJsonPath,
-              markdownPath: result.paths.reportMarkdownPath
-            });
-          }
-          spinner?.succeed("Attack pack complete");
-          const failed = results.filter(
-            (result) => shouldFail(result.status, result.failures, flags["fail-on"])
-          );
-          if (flags.json) {
-            this.log(
-              JSON.stringify({
-                pack: socialEngineeringCorePack,
-                target: target.type,
-                total: results.length,
-                failed: failed.length,
-                results
-              })
-            );
-          } else {
-            this.log(
-              results.map((result) => `${result.status.toUpperCase()} ${result.score}/100 ${result.scenario} ${result.runId}`).join("\n")
-            );
-          }
-          if (failed.length) process.exitCode = 1;
-        } catch (error) {
-          spinner?.fail("Attack pack failed");
-          throw error;
-        } finally {
-          await fs6.rm(scenarioDir, { recursive: true, force: true });
-        }
-      }
-    };
-  }
-});
-
 // src/schemas/report.schema.ts
 import { z as z4 } from "zod";
 var requiredString, criterionResultSchema, failureSchema2, reportSchema;
@@ -2910,8 +2678,8 @@ var init_cloud_upload_schema = __esm({
 });
 
 // src/cloud/upload-client.ts
-import { promises as fs7 } from "fs";
-import { join as join5 } from "path";
+import { promises as fs6 } from "fs";
+import { join as join4 } from "path";
 function requireUploadApiKey(apiKey) {
   const normalized = apiKey?.trim();
   if (normalized) return normalized;
@@ -2932,12 +2700,42 @@ function requireUploadProjectId(projectId) {
     exitCode: 1
   });
 }
+function requireRunApiKey(apiKey) {
+  const normalized = apiKey?.trim();
+  if (normalized) return normalized;
+  throw new AppError({
+    code: "WORKBENCH_API_KEY_REQUIRED",
+    message: "A Builder or Team trial is required to run real agent tests.",
+    suggestion: "Start a 7-day trial at https://app.roleplay.sh/auth/create-workspace, then set ROLEPLAY_PROJECT_ID and ROLEPLAY_API_KEY.",
+    exitCode: 1
+  });
+}
+function requireRunProjectId(projectId) {
+  const normalized = projectId?.trim();
+  if (normalized) return normalized;
+  throw new AppError({
+    code: "WORKBENCH_PROJECT_REQUIRED",
+    message: "A Builder or Team trial is required to run real agent tests.",
+    suggestion: "Start a 7-day trial at https://app.roleplay.sh/auth/create-workspace, then set ROLEPLAY_PROJECT_ID and ROLEPLAY_API_KEY.",
+    exitCode: 1
+  });
+}
+async function assertRunEntitlement(input) {
+  const verification = await verifyCloudCredentials(input);
+  if (verification.entitlement.canRun) return verification;
+  throw inactiveSubscriptionError();
+}
+async function assertUploadEntitlement(input) {
+  const verification = await verifyCloudCredentials(input);
+  if (verification.entitlement.canUpload) return verification;
+  throw inactiveSubscriptionError();
+}
 async function buildUploadPayload(input) {
   const runDir = await resolveRunDir(input.run, input.runsDir);
-  const reportPath = join5(runDir, "report.json");
-  const transcriptPath = join5(runDir, "transcript.json");
-  const scenarioPath = join5(runDir, "scenario.yml");
-  const metadataPath = join5(runDir, "metadata.json");
+  const reportPath = join4(runDir, "report.json");
+  const transcriptPath = join4(runDir, "transcript.json");
+  const scenarioPath = join4(runDir, "scenario.yml");
+  const metadataPath = join4(runDir, "metadata.json");
   const includeFullEvidence = input.mode === "full_transcript_opt_in";
   const reportArtifact = await readJsonArtifact(reportPath);
   const report = reportSchema.parse(reportArtifact);
@@ -3070,7 +2868,7 @@ function parseCredentialVerification(body) {
   const candidate = body;
   const key = candidate?.key;
   const policy = candidate?.uploadPolicy;
-  if (candidate && typeof candidate === "object" && typeof candidate.projectId === "string" && candidate.authenticated === true && key && typeof key === "object" && typeof key.id === "string" && typeof key.name === "string" && typeof key.preview === "string" && typeof key.createdAt === "string" && policy && typeof policy === "object" && (policy.mode === "sanitized_findings" || policy.mode === "full_transcript_opt_in") && typeof policy.transcriptUpload === "boolean" && typeof policy.redactedSnippets === "boolean" && typeof policy.secretRedaction === "boolean" && Number.isInteger(policy.retentionDays) && policy.retentionDays > 0) {
+  if (candidate && typeof candidate === "object" && typeof candidate.projectId === "string" && candidate.authenticated === true && key && typeof key === "object" && typeof key.id === "string" && typeof key.name === "string" && typeof key.preview === "string" && typeof key.createdAt === "string" && policy && typeof policy === "object" && candidate.entitlement && typeof candidate.entitlement === "object" && (candidate.entitlement.plan === "builder" || candidate.entitlement.plan === "team") && ["trialing", "active", "past_due", "canceled"].includes(String(candidate.entitlement.status)) && typeof candidate.entitlement.canRun === "boolean" && typeof candidate.entitlement.canUpload === "boolean" && (policy.mode === "sanitized_findings" || policy.mode === "full_transcript_opt_in") && typeof policy.transcriptUpload === "boolean" && typeof policy.redactedSnippets === "boolean" && typeof policy.secretRedaction === "boolean" && Number.isInteger(policy.retentionDays) && policy.retentionDays > 0) {
     return candidate;
   }
   throw new AppError({
@@ -3080,6 +2878,14 @@ function parseCredentialVerification(body) {
     exitCode: 1
   });
 }
+function inactiveSubscriptionError() {
+  return new AppError({
+    code: "WORKBENCH_SUBSCRIPTION_INACTIVE",
+    message: "Your workspace subscription is not active.",
+    suggestion: "Open billing to start or resume Builder/Team access: https://app.roleplay.sh/billing",
+    exitCode: 1
+  });
+}
 function assertUploadResponseMatchesPayload(response, payload) {
   if (response.projectId === payload.projectId && response.runId === payload.run.report.runId && response.mode === payload.mode) {
     return;
@@ -3112,14 +2918,14 @@ function isRelativeCloudPath(value) {
   return value.startsWith("/") && !value.startsWith("//");
 }
 async function readJsonArtifact(path) {
-  const contents = await fs7.readFile(path, "utf8");
+  const contents = await fs6.readFile(path, "utf8");
   return JSON.parse(contents.replace(/^\uFEFF/, ""));
 }
 async function readOptionalJsonArtifact(path) {
   return pathExists(path).then((exists) => exists ? readJsonArtifact(path) : void 0);
 }
 async function readOptionalTextArtifact(path) {
-  return pathExists(path).then((exists) => exists ? fs7.readFile(path, "utf8") : void 0);
+  return pathExists(path).then((exists) => exists ? fs6.readFile(path, "utf8") : void 0);
 }
 async function readRequiredTranscriptArtifact(path) {
   if (await pathExists(path)) return readJsonArtifact(path);
@@ -3143,10 +2949,280 @@ var init_upload_client = __esm({
   }
 });
 
-// src/commands/upload.ts
-var upload_exports = {};
-__export(upload_exports, {
-  UploadCommand: () => UploadCommand
+// src/commands/run.ts
+var run_exports = {};
+__export(run_exports, {
+  RunCommand: () => RunCommand
+});
+import { Args as Args2, Flags as Flags3 } from "@oclif/core";
+import { promises as fs7 } from "fs";
+import { tmpdir } from "os";
+import { join as join5 } from "path";
+function resolveProviderFlags(flags, fallback) {
+  const sharedProvider = providerFrom(flags.provider ?? process.env.ROLEPLAY_LLM_PROVIDER, fallback);
+  const attackerProvider = providerFrom(flags["attacker-provider"] ?? process.env.ROLEPLAY_ATTACKER_PROVIDER, sharedProvider);
+  const judgeProvider = providerFrom(flags["judge-provider"] ?? process.env.ROLEPLAY_JUDGE_PROVIDER, sharedProvider);
+  return {
+    attackerProvider,
+    judgeProvider,
+    attackerModel: flags["attacker-model"] ?? process.env.ROLEPLAY_ATTACKER_MODEL ?? flags.model ?? process.env.ROLEPLAY_LLM_MODEL,
+    judgeModel: flags["judge-model"] ?? process.env.ROLEPLAY_JUDGE_MODEL ?? flags.model ?? process.env.ROLEPLAY_LLM_MODEL,
+    llmBaseUrl: flags["llm-base-url"] ?? process.env.ROLEPLAY_LLM_BASE_URL
+  };
+}
+function providerFrom(value, fallback) {
+  if (!value && !fallback) return void 0;
+  return normalizeProvider(value, fallback ?? "mock");
+}
+function scenarioRequiresRunEntitlement(scenario, providers) {
+  return scenario.target.type !== "mock" || scenario.attacker?.provider !== void 0 && scenario.attacker.provider !== "mock" || scenario.judge.type !== "mock" || providersContainRealProvider(providers);
+}
+function providersContainRealProvider(providers) {
+  return [providers.attackerProvider, providers.judgeProvider].some((provider) => provider !== void 0 && provider !== "mock");
+}
+function resultNameFromPath(path) {
+  return path.replace(/^.*[\\/]/, "").replace(/\.ya?ml$/i, "");
+}
+function cloudAttackPackIdForScenario(scenarioName) {
+  if (scenarioName.includes("authority-impersonation")) return "pack_authority";
+  if (scenarioName.includes("urgency-pressure")) return "pack_urgency";
+  if (scenarioName.includes("policy-bypass")) return "pack_policy";
+  if (scenarioName.includes("indirect-prompt-injection")) return "pack_injection";
+  if (scenarioName.includes("data-exfiltration")) return "pack_exfiltration";
+  if (scenarioName.includes("tool-misuse")) return "pack_tools";
+  if (scenarioName.includes("auth-session-confusion")) return "pack_auth_session";
+  if (scenarioName.includes("memory-context-poisoning")) return "pack_memory_context";
+  return void 0;
+}
+var socialEngineeringCorePack, RunCommand;
+var init_run = __esm({
+  "src/commands/run.ts"() {
+    "use strict";
+    init_engine();
+    init_run_store();
+    init_scenario_schema();
+    init_scoring();
+    init_reporter();
+    init_output();
+    init_fs();
+    init_scenarios();
+    init_errors();
+    init_base();
+    init_client();
+    init_upload_client();
+    socialEngineeringCorePack = "social-engineering-core";
+    RunCommand = class _RunCommand extends BaseCommand {
+      static description = "Run a roleplay scenario or built-in attack pack.";
+      static args = {
+        scenario: Args2.string({ required: true })
+      };
+      static flags = {
+        target: Flags3.string({
+          description: 'HTTP target URL, or "mock" for local smoke tests. Defaults to ROLEPLAY_TARGET_URL.',
+          default: process.env.ROLEPLAY_TARGET_URL
+        }),
+        "target-command": Flags3.string({
+          description: "CLI target command for built-in attack packs. Defaults to ROLEPLAY_TARGET_COMMAND.",
+          default: process.env.ROLEPLAY_TARGET_COMMAND
+        }),
+        "max-turns": Flags3.integer(),
+        json: Flags3.boolean({ description: "Output JSON only." }),
+        out: Flags3.string({ default: ".roleplay/runs" }),
+        "fail-on": Flags3.string({ options: ["warning", "failed", "critical"], default: "failed" }),
+        provider: Flags3.string({
+          options: ["mock", "openai", "anthropic", "google", "openai-compatible"],
+          description: "Shared attacker and judge provider. Defaults to ROLEPLAY_LLM_PROVIDER, openai for real attack-pack targets, or mock for smoke tests.",
+          default: process.env.ROLEPLAY_LLM_PROVIDER
+        }),
+        "attacker-provider": Flags3.string({
+          options: ["mock", "openai", "anthropic", "google", "openai-compatible"],
+          description: "Provider for adaptive attacker turns. Defaults to ROLEPLAY_ATTACKER_PROVIDER or --provider.",
+          default: process.env.ROLEPLAY_ATTACKER_PROVIDER
+        }),
+        "judge-provider": Flags3.string({
+          options: ["mock", "openai", "anthropic", "google", "openai-compatible"],
+          description: "Provider for transcript judging. Defaults to ROLEPLAY_JUDGE_PROVIDER or --provider.",
+          default: process.env.ROLEPLAY_JUDGE_PROVIDER
+        }),
+        model: Flags3.string({
+          description: "Shared LLM model. Defaults to ROLEPLAY_LLM_MODEL or provider defaults.",
+          default: process.env.ROLEPLAY_LLM_MODEL
+        }),
+        "attacker-model": Flags3.string({
+          description: "Model for adaptive attacker turns. Defaults to ROLEPLAY_ATTACKER_MODEL or --model.",
+          default: process.env.ROLEPLAY_ATTACKER_MODEL
+        }),
+        "judge-model": Flags3.string({
+          description: "Model for transcript judging. Defaults to ROLEPLAY_JUDGE_MODEL, scenario judge.model, or --model.",
+          default: process.env.ROLEPLAY_JUDGE_MODEL
+        }),
+        "llm-base-url": Flags3.string({
+          description: "Base URL for openai-compatible providers. Defaults to ROLEPLAY_LLM_BASE_URL.",
+          default: process.env.ROLEPLAY_LLM_BASE_URL
+        }),
+        endpoint: Flags3.string({
+          description: "cloud workbench URL for real-run entitlement checks. Defaults to ROLEPLAY_CLOUD_URL.",
+          default: process.env.ROLEPLAY_CLOUD_URL ?? "http://127.0.0.1:3000"
+        }),
+        project: Flags3.string({
+          description: "cloud workbench project ID for real agent tests. Defaults to ROLEPLAY_PROJECT_ID.",
+          default: process.env.ROLEPLAY_PROJECT_ID
+        }),
+        "api-key": Flags3.string({
+          description: "cloud workbench API key for real agent tests. Defaults to ROLEPLAY_API_KEY.",
+          default: process.env.ROLEPLAY_API_KEY
+        }),
+        yes: Flags3.boolean({ char: "y", description: "Allow local CLI target command execution." })
+      };
+      async run() {
+        const { args, flags } = await this.parse(_RunCommand);
+        if (args.scenario === socialEngineeringCorePack) {
+          await this.runSocialEngineeringCore(flags);
+          return;
+        }
+        if (flags.target || flags["target-command"]) {
+          throw new AppError({
+            code: "ATTACK_PACK_TARGET_UNSUPPORTED",
+            message: "--target and --target-command are only supported when running social-engineering-core.",
+            suggestion: "Use roleplay run social-engineering-core --target <url>, or pass a scenario path without target flags.",
+            exitCode: 2
+          });
+        }
+        const providers = resolveProviderFlags(flags);
+        const scenario = await loadScenarioFile(await resolveScenarioPath(args.scenario));
+        if (scenarioRequiresRunEntitlement(scenario, providers)) {
+          await assertRunEntitlement({
+            endpoint: flags.endpoint,
+            projectId: requireRunProjectId(flags.project),
+            apiKey: requireRunApiKey(flags["api-key"])
+          });
+        }
+        const spinner = createSpinner("Running scenario", flags.json);
+        let result;
+        try {
+          result = await runScenario({
+            scenarioRef: args.scenario,
+            maxTurns: flags["max-turns"],
+            outDir: flags.out,
+            yes: flags.yes,
+            ...providers
+          });
+          spinner?.succeed("Scenario complete");
+        } catch (error) {
+          spinner?.fail("Scenario failed");
+          throw error;
+        }
+        if (flags.json) {
+          this.log(
+            JSON.stringify({
+              runId: result.runId,
+              scenario: result.scenario.name,
+              status: result.report.status,
+              score: result.report.score,
+              reportPath: result.paths.reportJsonPath,
+              markdownPath: result.paths.reportMarkdownPath
+            })
+          );
+        } else {
+          this.log(
+            terminalSummary({
+              report: result.report,
+              reportPath: result.paths.reportJsonPath,
+              markdownPath: result.paths.reportMarkdownPath
+            })
+          );
+        }
+        if (shouldFail(result.report.status, result.report.failures, flags["fail-on"])) {
+          process.exitCode = 1;
+        }
+      }
+      async runSocialEngineeringCore(flags) {
+        if (Boolean(flags.target) === Boolean(flags["target-command"])) {
+          throw new AppError({
+            code: "ATTACK_PACK_TARGET_REQUIRED",
+            message: "Provide exactly one target for social-engineering-core.",
+            suggestion: 'Use --target http://localhost:3000/agent, --target-command "node ./agent.js", ROLEPLAY_TARGET_URL, or ROLEPLAY_TARGET_COMMAND.',
+            exitCode: 2
+          });
+        }
+        const target = flags.target === "mock" ? { type: "mock" } : flags.target ? { type: "http", url: flags.target } : { type: "cli", command: flags["target-command"] };
+        const scenarioDir = await fs7.mkdtemp(join5(tmpdir(), "roleplay-social-engineering-core-"));
+        await ensureDir(scenarioDir);
+        const providers = resolveProviderFlags(flags, target.type === "mock" ? "mock" : "openai");
+        if (target.type !== "mock" || providersContainRealProvider(providers)) {
+          await assertRunEntitlement({
+            endpoint: flags.endpoint,
+            projectId: requireRunProjectId(flags.project),
+            apiKey: requireRunApiKey(flags["api-key"])
+          });
+        }
+        const spinner = createSpinner("Running social-engineering-core", flags.json);
+        try {
+          const files = [];
+          for (const content of attackPackTemplates(target)) {
+            const name = content.match(/^name:\s*(.+)$/m)?.[1] ?? `social-engineering-${files.length + 1}`;
+            const path = join5(scenarioDir, `${name}.yml`);
+            await fs7.writeFile(path, content, "utf8");
+            files.push(path);
+          }
+          const results = [];
+          for (const file of files) {
+            const result = await runScenario({
+              scenarioRef: file,
+              maxTurns: flags["max-turns"],
+              outDir: flags.out,
+              yes: flags.yes,
+              ...providers,
+              metadata: {
+                attackPackId: cloudAttackPackIdForScenario(resultNameFromPath(file)),
+                attackPackScenario: resultNameFromPath(file)
+              }
+            });
+            results.push({
+              runId: result.runId,
+              scenario: result.scenario.name,
+              status: result.report.status,
+              score: result.report.score,
+              failures: result.report.failures,
+              reportPath: result.paths.reportJsonPath,
+              markdownPath: result.paths.reportMarkdownPath
+            });
+          }
+          spinner?.succeed("Attack pack complete");
+          const failed = results.filter(
+            (result) => shouldFail(result.status, result.failures, flags["fail-on"])
+          );
+          if (flags.json) {
+            this.log(
+              JSON.stringify({
+                pack: socialEngineeringCorePack,
+                target: target.type,
+                total: results.length,
+                failed: failed.length,
+                results
+              })
+            );
+          } else {
+            this.log(
+              results.map((result) => `${result.status.toUpperCase()} ${result.score}/100 ${result.scenario} ${result.runId}`).join("\n")
+            );
+          }
+          if (failed.length) process.exitCode = 1;
+        } catch (error) {
+          spinner?.fail("Attack pack failed");
+          throw error;
+        } finally {
+          await fs7.rm(scenarioDir, { recursive: true, force: true });
+        }
+      }
+    };
+  }
+});
+
+// src/commands/upload.ts
+var upload_exports = {};
+__export(upload_exports, {
+  UploadCommand: () => UploadCommand
 });
 import { Args as Args3, Flags as Flags4 } from "@oclif/core";
 import chalk4 from "chalk";
@@ -3180,12 +3256,7 @@ async function selectedUploadRunIds(run, runsDir) {
 }
 async function assertUploadPolicyAllowsMode(input) {
   if (input.mode !== "full_transcript_opt_in") return;
-  const verification = await verifyCloudCredentials({
-    endpoint: input.endpoint,
-    projectId: input.projectId,
-    apiKey: input.apiKey
-  });
-  if (verification.uploadPolicy.mode === "full_transcript_opt_in" && verification.uploadPolicy.transcriptUpload) {
+  if (input.verification.uploadPolicy.mode === "full_transcript_opt_in" && input.verification.uploadPolicy.transcriptUpload) {
     return;
   }
   throw new AppError({
@@ -3261,11 +3332,15 @@ var init_upload = __esm({
         );
         try {
           const runIds = await selectedUploadRunIds(args.run, flags.out);
-          await assertUploadPolicyAllowsMode({
+          const verification = await assertUploadEntitlement({
             endpoint: flags.endpoint,
             projectId,
-            apiKey,
-            mode
+            apiKey
+          });
+          await assertUploadPolicyAllowsMode({
+            projectId,
+            mode,
+            verification
           });
           if (args.run === "all") {
             const uploads = [];
@@ -3532,10 +3607,12 @@ async function checkCloudCredentials(cloudUrl, projectId, apiKey) {
       apiKey: normalizedApiKey
     });
     const policy = verification.uploadPolicy;
+    const entitlement = verification.entitlement;
+    const access2 = entitlement.canRun && entitlement.canUpload;
     return {
       name: "cloud workbench API key",
-      ok: true,
-      detail: `${verification.key.name} (${verification.key.preview}) can upload to ${verification.projectId} with ${policy.mode}, ${policy.retentionDays}d retention`
+      ok: access2,
+      detail: access2 ? `${verification.key.name} (${verification.key.preview}) can run and upload to ${verification.projectId} with ${policy.mode}, ${policy.retentionDays}d retention` : `subscription ${entitlement.status}; open billing to start or resume Builder/Team access`
     };
   } catch (error) {
     return {
@@ -3545,6 +3622,29 @@ async function checkCloudCredentials(cloudUrl, projectId, apiKey) {
     };
   }
 }
+function checkProviderKey(provider) {
+  if (!provider || provider === "mock") {
+    return {
+      name: "LLM provider key",
+      ok: true,
+      detail: "mock provider is available for install smoke tests"
+    };
+  }
+  const envName = providerKeyEnv(provider);
+  const ok = Boolean(envName && process.env[envName]?.trim());
+  return {
+    name: "LLM provider key",
+    ok,
+    detail: ok ? `${envName} is configured for real adaptive runs` : `set ${envName ?? "ROLEPLAY_LLM_API_KEY"} before running real adaptive tests, or use --provider mock for smoke tests`
+  };
+}
+function providerKeyEnv(provider) {
+  if (provider === "openai") return "ROLEPLAY_OPENAI_API_KEY";
+  if (provider === "anthropic") return "ROLEPLAY_ANTHROPIC_API_KEY";
+  if (provider === "google") return "ROLEPLAY_GOOGLE_API_KEY";
+  if (provider === "openai-compatible") return "ROLEPLAY_LLM_API_KEY";
+  return void 0;
+}
 function cloudHealthDetail(body, endpoint) {
   const service = body.service ?? "cloud workbench";
   const privacy = body.privacy;
@@ -3587,6 +3687,11 @@ var init_doctor = __esm({
         "api-key": Flags8.string({
           description: "cloud workbench API key for credential verification. Defaults to ROLEPLAY_API_KEY.",
           default: process.env.ROLEPLAY_API_KEY
+        }),
+        provider: Flags8.string({
+          options: ["mock", "openai", "anthropic", "google", "openai-compatible"],
+          description: "LLM provider to check for real adaptive runs. Defaults to ROLEPLAY_LLM_PROVIDER or openai.",
+          default: process.env.ROLEPLAY_LLM_PROVIDER ?? "openai"
         })
       };
       async run() {
@@ -3601,6 +3706,7 @@ var init_doctor = __esm({
           checks.push(await checkCloudHealth(flags["cloud-url"]));
           if (flags.project || flags["api-key"]) {
             checks.push(await checkCloudCredentials(flags["cloud-url"], flags.project, flags["api-key"]));
+            checks.push(checkProviderKey(flags.provider));
           }
         }
         if (flags.json) {
@@ -3867,13 +3973,14 @@ var HelpCommand = class extends Command2 {
     command: Args6.string({ required: false })
   };
   async run() {
-    this.log(`${chalk8.cyan("roleplay.sh")} - Test your AI agent before your users do.
+    this.log(`${chalk8.cyan("roleplay.sh")} - Included CLI for Builder and Team workspaces.
 
 Usage:
   roleplay init
   roleplay scenario:create <name>
   roleplay run <scenario>
-  roleplay run social-engineering-core --target <url> --provider openai
+  roleplay run social-engineering-core --target mock --provider mock
+  roleplay run social-engineering-core --target <url> --provider openai --project <projectId>
   roleplay report latest|<runId> [--out .roleplay/runs]
   roleplay replay latest|<runId> [--out .roleplay/runs]
   roleplay upload latest|all --project <projectId>
@@ -3881,6 +3988,7 @@ Usage:
   roleplay doctor
   roleplay mcp
 
+Use mock mode for install smoke tests. Use a project API key for real agent tests.
 Use --json on commands for machine-readable output.`);
   }
 };