@runtypelabs/cli 2.22.12 → 2.22.13

package/dist/index.js

@@ -142,9 +142,9 @@ import chalk42 from "chalk";
 // src/lib/load-env.ts
 import { readFileSync } from "fs";
 import { resolve } from "path";
-function loadEnv(path18 = resolve(process.cwd(), ".env")) {
+function loadEnv(path19 = resolve(process.cwd(), ".env")) {
   try {
-    const content = readFileSync(path18, "utf8").replace(/\r\n?/g, "\n");
+    const content = readFileSync(path19, "utf8").replace(/\r\n?/g, "\n");
     for (const line of content.split("\n")) {
       if (!line.trim() || line.trimStart().startsWith("#")) continue;
       const match = line.match(/^\s*([\w.-]+)\s*=\s*(.*)?\s*$/);
@@ -1386,10 +1386,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path18) {
-  if (!path18)
+function getElementAtPath(obj, path19) {
+  if (!path19)
     return obj;
-  return path18.reduce((acc, key) => acc?.[key], obj);
+  return path19.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1798,11 +1798,11 @@ function explicitlyAborted(x2, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path18, issues) {
+function prefixIssues(path19, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path18);
+    iss.path.unshift(path19);
     return iss;
   });
 }
@@ -1949,16 +1949,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path18 = []) => {
+  const processError = (error52, path19 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path18, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path19, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
       } else {
-        const fullpath = [...path18, ...issue2.path];
+        const fullpath = [...path19, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -1985,17 +1985,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path18 = []) => {
+  const processError = (error52, path19 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path18, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path19, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
       } else {
-        const fullpath = [...path18, ...issue2.path];
+        const fullpath = [...path19, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -2027,8 +2027,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path18 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path18) {
+  const path19 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path19) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -14714,13 +14714,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path18 = ref.slice(1).split("/").filter(Boolean);
-  if (path18.length === 0) {
+  const path19 = ref.slice(1).split("/").filter(Boolean);
+  if (path19.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path18[0] === defsKey) {
-    const key = path18[1];
+  if (path19[0] === defsKey) {
+    const key = path19[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -15182,8 +15182,8 @@ var edgeContextPayloadSchema = external_exports.object({
 });
 
 // ../shared/dist/chunk-3FPSMWBQ.mjs
-function getNestedValue(obj, path18) {
-  let normalizedPath = path18;
+function getNestedValue(obj, path19) {
+  let normalizedPath = path19;
   normalizedPath = normalizedPath.replace(/^\$\.?/, "");
   normalizedPath = normalizedPath.replace(/\[(\d+)\]/g, ".$1");
   normalizedPath = normalizedPath.replace(/\[['"]([^'"\]]+)['"]\]/g, ".$1");
@@ -19966,8 +19966,8 @@ function validateCodeToolNameCollisions(toolNames, stepRef, code, preSeededCount
   }
   return null;
 }
-function formatPath(path18) {
-  return path18.reduce((acc, part) => {
+function formatPath(path19) {
+  return path19.reduce((acc, part) => {
     if (typeof part === "number") {
       return `${acc}[${part}]`;
     }
@@ -20088,17 +20088,17 @@ function collectTransformDataCodeToolNameCheck(toolsConfig, stepIndex, stepRef,
     if (typeof toolId !== "string") {
       continue;
     }
-    const path18 = `flowSteps[${stepIndex}].config.tools.toolIds[${toolIdIndex}]`;
+    const path19 = `flowSteps[${stepIndex}].config.tools.toolIds[${toolIdIndex}]`;
     const named = parseNamedToolRef(toolId);
     if (named) {
-      selectedToolNames.push({ name: named.name, path: path18 });
+      selectedToolNames.push({ name: named.name, path: path19 });
       continue;
     }
     const { customToolIds } = separateToolIds([toolId]);
     if (customToolIds.length === 0) {
       continue;
     }
-    selectedToolIds.push({ toolId, path: path18 });
+    selectedToolIds.push({ toolId, path: path19 });
   }
   if (selectedToolIds.length > 0 || selectedToolNames.length > 0) {
     pendingChecks.hasAccountScopedReferences = true;
@@ -20131,10 +20131,10 @@ function collectCodeModeToolNameCheck(toolsConfig, stepIndex, stepRef, pendingCh
     if (typeof entry !== "string" || entry.length === 0 || entry.endsWith(":*")) {
       continue;
     }
-    const path18 = `flowSteps[${stepIndex}].config.tools.codeModeConfig.toolPool[${toolPoolIndex}]`;
+    const path19 = `flowSteps[${stepIndex}].config.tools.codeModeConfig.toolPool[${toolPoolIndex}]`;
     const named = parseNamedToolRef(entry);
     if (named) {
-      selectedToolNames.push({ name: named.name, path: path18 });
+      selectedToolNames.push({ name: named.name, path: path19 });
       continue;
     }
     if (runtimeToolNames.has(entry)) {
@@ -20145,7 +20145,7 @@ function collectCodeModeToolNameCheck(toolsConfig, stepIndex, stepRef, pendingCh
     if (customToolIds.length === 0) {
       continue;
     }
-    selectedToolIds.push({ toolId: entry, path: path18 });
+    selectedToolIds.push({ toolId: entry, path: path19 });
   }
   if (selectedToolIds.length > 0 || selectedToolNames.length > 0) {
     pendingChecks.hasAccountScopedReferences = true;
@@ -20196,19 +20196,19 @@ var TEMPLATE_STRING_FIELDS = /* @__PURE__ */ new Set([
   "requestTemplate"
 ]);
 var NON_FLOW_VARIABLE_SUBTREE_KEYS = /* @__PURE__ */ new Set(["tools"]);
-function extractTemplateStrings(config3, path18 = []) {
+function extractTemplateStrings(config3, path19 = []) {
   const results = [];
   if (typeof config3 === "string") {
-    const fieldName = path18[path18.length - 1];
-    const parentFieldName = path18.length >= 2 ? path18[path18.length - 2] : void 0;
+    const fieldName = path19[path19.length - 1];
+    const parentFieldName = path19.length >= 2 ? path19[path19.length - 2] : void 0;
     if (fieldName && TEMPLATE_STRING_FIELDS.has(fieldName) || parentFieldName && TEMPLATE_STRING_FIELDS.has(parentFieldName)) {
-      results.push({ value: config3, fieldPath: path18.join(".") });
+      results.push({ value: config3, fieldPath: path19.join(".") });
     }
     return results;
   }
   if (Array.isArray(config3)) {
     for (const [index, item] of config3.entries()) {
-      results.push(...extractTemplateStrings(item, [...path18, String(index)]));
+      results.push(...extractTemplateStrings(item, [...path19, String(index)]));
     }
     return results;
   }
@@ -20216,9 +20216,9 @@ function extractTemplateStrings(config3, path18 = []) {
     for (const [key, val] of Object.entries(config3)) {
       if (NON_FLOW_VARIABLE_SUBTREE_KEYS.has(key)) continue;
       if (typeof val === "string" && TEMPLATE_STRING_FIELDS.has(key)) {
-        results.push({ value: val, fieldPath: [...path18, key].join(".") });
+        results.push({ value: val, fieldPath: [...path19, key].join(".") });
       } else if (typeof val === "object" && val !== null) {
-        results.push(...extractTemplateStrings(val, [...path18, key]));
+        results.push(...extractTemplateStrings(val, [...path19, key]));
       }
     }
   }
@@ -20249,8 +20249,8 @@ function extractVariableReferences(config3) {
     while ((match = pattern.exec(value)) !== null) {
       const expr = match[1];
       if (!expr) continue;
-      for (const path18 of extractTemplateExpressionPaths(expr)) {
-        references.push({ variable: path18, fieldPath });
+      for (const path19 of extractTemplateExpressionPaths(expr)) {
+        references.push({ variable: path19, fieldPath });
       }
     }
   }
@@ -20403,7 +20403,7 @@ function validateUpsertRecordSourceShape(flowSteps, buckets) {
     }
   }
 }
-function checkConditionExpression(expr, path18, stepRef, buckets) {
+function checkConditionExpression(expr, path19, stepRef, buckets) {
   if (typeof expr !== "string" || !expr.includes("{{")) return;
   const match = UNQUOTED_TEMPLATE_BEFORE_OP.exec(expr) || UNQUOTED_TEMPLATE_AFTER_OP.exec(expr);
   if (!match) return;
@@ -20413,7 +20413,7 @@ function checkConditionExpression(expr, path18, stepRef, buckets) {
     {
       code: "CONDITION_UNQUOTED_TEMPLATE_COMPARISON",
       message: `Expression compares an unquoted {{...}} placeholder against a string literal (\`${snippet}\`). \`condition\` / \`when\` predicates are JavaScript evaluated after template substitution, so a non-numeric value substitutes in as a bare identifier (e.g. \`healthy === 'watch'\`) and throws "ReferenceError: <value> is not defined" at runtime. Quote the placeholder \u2014 e.g. '{{var}}' === '...' \u2014 or compare numerically.`,
-      path: path18,
+      path: path19,
       step: stepRef,
       details: { snippet }
     },
@@ -20491,24 +20491,24 @@ function collectAccountScopedReferences(step, stepIndex, pendingChecks) {
   if (step.type === "execute-agent") {
     const agentId = step.config.agentId;
     if (typeof agentId === "string" && !agentId.includes("{{")) {
-      const path18 = `flowSteps[${stepIndex}].config.agentId`;
-      registerAgentReference(agentId, path18, stepRef, pendingChecks);
+      const path19 = `flowSteps[${stepIndex}].config.agentId`;
+      registerAgentReference(agentId, path19, stepRef, pendingChecks);
     }
     return;
   }
   if (step.type === "tool-call") {
     const toolId = step.config.toolId;
     if (typeof toolId === "string") {
-      const path18 = `flowSteps[${stepIndex}].config.toolId`;
+      const path19 = `flowSteps[${stepIndex}].config.toolId`;
       const named = parseNamedToolRef(toolId);
       if (named) {
         pendingChecks.hasAccountScopedReferences = true;
-        registerReference(pendingChecks.toolReferencesByName, named.name, { path: path18, step: stepRef });
+        registerReference(pendingChecks.toolReferencesByName, named.name, { path: path19, step: stepRef });
       } else {
         const { customToolIds } = separateToolIds([toolId]);
         if (customToolIds.length > 0) {
           pendingChecks.hasAccountScopedReferences = true;
-          registerReference(pendingChecks.toolReferencesById, toolId, { path: path18, step: stepRef });
+          registerReference(pendingChecks.toolReferencesById, toolId, { path: path19, step: stepRef });
         }
       }
     }
@@ -20527,17 +20527,17 @@ function collectAccountScopedReferences(step, stepIndex, pendingChecks) {
       if (typeof toolId !== "string") {
         continue;
       }
-      const path18 = `flowSteps[${stepIndex}].config.tools.toolIds[${toolIdIndex}]`;
+      const path19 = `flowSteps[${stepIndex}].config.tools.toolIds[${toolIdIndex}]`;
       const named = parseNamedToolRef(toolId);
       if (named) {
         pendingChecks.hasAccountScopedReferences = true;
-        registerReference(pendingChecks.toolReferencesByName, named.name, { path: path18, step: stepRef });
+        registerReference(pendingChecks.toolReferencesByName, named.name, { path: path19, step: stepRef });
         continue;
       }
       const { customToolIds } = separateToolIds([toolId]);
       if (customToolIds.length > 0) {
         pendingChecks.hasAccountScopedReferences = true;
-        registerReference(pendingChecks.toolReferencesById, toolId, { path: path18, step: stepRef });
+        registerReference(pendingChecks.toolReferencesById, toolId, { path: path19, step: stepRef });
       }
     }
   }
@@ -20575,22 +20575,22 @@ function collectAccountScopedReferences(step, stepIndex, pendingChecks) {
     }
   }
 }
-function registerAgentReference(agentId, path18, stepRef, pendingChecks) {
+function registerAgentReference(agentId, path19, stepRef, pendingChecks) {
   const named = parseNamedAgentRef(agentId);
   pendingChecks.hasAccountScopedReferences = true;
   if (named) {
-    registerReference(pendingChecks.agentReferencesByName, named.name, { path: path18, step: stepRef });
+    registerReference(pendingChecks.agentReferencesByName, named.name, { path: path19, step: stepRef });
   } else {
-    registerReference(pendingChecks.agentReferencesById, agentId, { path: path18, step: stepRef });
+    registerReference(pendingChecks.agentReferencesById, agentId, { path: path19, step: stepRef });
   }
 }
-function registerFlowReference(flowId, path18, stepRef, pendingChecks) {
+function registerFlowReference(flowId, path19, stepRef, pendingChecks) {
   const named = parseNamedFlowRef(flowId);
   pendingChecks.hasAccountScopedReferences = true;
   if (named) {
-    registerReference(pendingChecks.flowReferencesByName, named.name, { path: path18, step: stepRef });
+    registerReference(pendingChecks.flowReferencesByName, named.name, { path: path19, step: stepRef });
   } else {
-    registerReference(pendingChecks.flowReferencesById, flowId, { path: path18, step: stepRef });
+    registerReference(pendingChecks.flowReferencesById, flowId, { path: path19, step: stepRef });
   }
 }
 function validateSubagentConfig(value, stepTools, stepIndex, stepRef) {
@@ -35752,7 +35752,7 @@ var CORE_BUILTIN_TOOLS_REGISTRY = [
   {
     id: "bash",
     name: "Bash",
-    description: "Run a shell command on your Linux computer (Node 22, Python 3.12, git, pnpm, uv preinstalled). Commands run in /workspace; files you write there are available to later commands, but system-level changes outside /workspace may not persist. Combined stdout/stderr is returned. Long output is truncated (head + tail) with the full output spilled to a file. Pass slow_ok=true for commands that take a while (installs, builds, test suites).",
+    description: 'Run a shell command on your Linux computer (Node 22, Python 3.12, git, pnpm, uv, ripgrep preinstalled). Commands run in /workspace; files you write there are available to later commands, but system-level changes outside /workspace may not persist. Combined stdout/stderr is returned. Prefer searching over dumping: use `rg`/`grep` to find the lines you need and `head`/`tail`/`sed -n` to read slices, rather than printing whole files or verbose logs. Output is capped (head + tail) and the full output is spilled to a file in the sandbox that you can grep \u2014 so re-running a noisy command to "see the rest" wastes time; grep the spilled file instead. Pass slow_ok=true for commands that take a while (installs, builds, test suites).',
     category: BuiltInToolCategory.SANDBOX,
     toolGroup: BuiltInToolGroup.SANDBOX_AGENT,
     providers: [BuiltInToolProvider.MULTI],
@@ -35779,7 +35779,7 @@ var CORE_BUILTIN_TOOLS_REGISTRY = [
   {
     id: "read_file",
     name: "Read File",
-    description: "Read a file from your computer. Returns the file contents as a string.",
+    description: "Read a file from your computer (relative paths resolve against /workspace). Returns the contents as a string. Large files and very long lines are truncated; to find something in a big file, grep/rg it from bash (e.g. `rg -n <pattern> <path>`) or read a slice with `sed -n` instead of reading the whole file.",
     category: BuiltInToolCategory.SANDBOX,
     toolGroup: BuiltInToolGroup.SANDBOX_AGENT,
     providers: [BuiltInToolProvider.MULTI],
@@ -40866,8 +40866,8 @@ var FLAT_ADVANCED_CONFIG_KEYS = {
 var FLAT_ADVANCED_CONFIG_KEY_LIST = Object.keys(
   FLAT_ADVANCED_CONFIG_KEYS
 );
-function createIssue(severity, code, message, path18, suggestedFix) {
-  return { code, message, path: path18, severity, ...suggestedFix ? { suggestedFix } : {} };
+function createIssue(severity, code, message, path19, suggestedFix) {
+  return { code, message, path: path19, severity, ...suggestedFix ? { suggestedFix } : {} };
 }
 function emptyResult() {
   return { valid: true, errors: [], warnings: [], recommendations: [] };
@@ -41593,16 +41593,16 @@ var FLOW_PREFIX = Object.values(RUNTIME_PREFIXES).find((spec) => spec.namespace
 var SECRET_PREFIX = Object.values(RUNTIME_PREFIXES).find(
   (spec) => spec.namespace === "secret"
 ).prefix;
-function collectStringLeafPaths(value, path18 = []) {
+function collectStringLeafPaths(value, path19 = []) {
   if (typeof value === "string") {
-    return [{ path: path18, value }];
+    return [{ path: path19, value }];
   }
   if (Array.isArray(value)) {
-    return value.flatMap((item, index) => collectStringLeafPaths(item, [...path18, String(index)]));
+    return value.flatMap((item, index) => collectStringLeafPaths(item, [...path19, String(index)]));
   }
   if (value && typeof value === "object") {
     return Object.entries(value).flatMap(
-      ([key, nestedValue]) => collectStringLeafPaths(nestedValue, [...path18, key])
+      ([key, nestedValue]) => collectStringLeafPaths(nestedValue, [...path19, key])
     );
   }
   return [];
@@ -43460,7 +43460,7 @@ function buildDashboardUrl(opts) {
   while (base.endsWith("/")) {
     base = base.slice(0, -1);
   }
-  const path18 = opts.path.startsWith("/") ? opts.path : `/${opts.path}`;
+  const path19 = opts.path.startsWith("/") ? opts.path : `/${opts.path}`;
   const params = new URLSearchParams();
   if (isValidAccountId(opts.account)) {
     params.set(ACCOUNT_QUERY_PARAM, opts.account);
@@ -43473,7 +43473,7 @@ function buildDashboardUrl(opts) {
     }
   }
   const qs = params.toString();
-  return qs ? `${base}${path18}?${qs}` : `${base}${path18}`;
+  return qs ? `${base}${path19}?${qs}` : `${base}${path19}`;
 }
 function parseAccountId(value) {
   if (!value) return null;
@@ -44776,13 +44776,13 @@ function parseJsonObject(raw, label) {
   }
   return parsed;
 }
-function readJsonFile(path18, opts = {}) {
+function readJsonFile(path19, opts = {}) {
   const label = opts.label ?? "file";
   let raw;
   try {
-    raw = readFileSync3(path18, "utf-8");
+    raw = readFileSync3(path19, "utf-8");
   } catch {
-    console.error(chalk2.red(`Failed to read ${label}: ${path18}`));
+    console.error(chalk2.red(`Failed to read ${label}: ${path19}`));
     process.exit(1);
   }
   const obj = parseJsonObject(raw, label);
@@ -48664,11 +48664,21 @@ import open2 from "open";
 
 // src/lib/account-context.ts
 init_credential_store();
-async function getCurrentAccountId() {
+async function getCurrentAccountId(options) {
+  if (options?.apiKey) {
+    try {
+      const apiKeyManager = new ApiKeyManager();
+      const user = await apiKeyManager.getCurrentUser(options.apiKey, options.apiUrl);
+      const account = selectAccountId({ userId: user.userId, organizationId: user.orgId });
+      if (account) return account;
+    } catch {
+    }
+  }
   try {
     const store = new CredentialStore();
     const creds = await store.getCredentials();
     if (!creds) return void 0;
+    if (options?.apiKey && creds.apiKey !== options.apiKey) return void 0;
     return selectAccountId({ userId: creds.userId, organizationId: creds.orgId });
   } catch {
     return void 0;
@@ -64429,8 +64439,8 @@ apiKeysCommand.command("analytics").description("Show API key usage analytics").
   const client = createCliClient(apiKey);
   if (!isTTY(options) || options.json) {
     try {
-      const path18 = options.key ? `/api-keys/${options.key}/analytics` : "/api-keys/analytics";
-      const data = await client.get(path18);
+      const path19 = options.key ? `/api-keys/${options.key}/analytics` : "/api-keys/analytics";
+      const data = await client.get(path19);
       printJson(data);
     } catch (error51) {
       const message = error51 instanceof Error ? error51.message : "Unknown error";
@@ -64447,8 +64457,8 @@ apiKeysCommand.command("analytics").description("Show API key usage analytics").
     useEffect31(() => {
       const run2 = async () => {
         try {
-          const path18 = options.key ? `/api-keys/${options.key}/analytics` : "/api-keys/analytics";
-          const data = await client.get(path18);
+          const path19 = options.key ? `/api-keys/${options.key}/analytics` : "/api-keys/analytics";
+          const data = await client.get(path19);
           printJson(data);
           setSuccess(true);
           setLoading(false);
@@ -64901,7 +64911,7 @@ clientTokensCommand.command("regenerate <id>").description("Regenerate a client
 import { Command as Command23 } from "commander";
 import chalk30 from "chalk";
 import readline3 from "readline";
-import open5 from "open";
+import openBrowser from "open";
 import { execFileSync } from "child_process";
 
 // src/lib/persona-init.ts
@@ -65238,8 +65248,52 @@ function generatePersonaInitSnippet(input, personaFormat) {
     target ? { target } : void 0
   );
 }
+function getPersonaInstallerScriptUrl() {
+  const snippet = R(
+    {
+      apiUrl: "https://api.runtype.com",
+      clientToken: "ct_test_demo_00000000000000000000000000000000",
+      parserType: "json"
+    },
+    "script-installer"
+  );
+  const match = snippet.match(/<script\s+src="([^"]+)"/);
+  return match?.[1] ?? "https://cdn.jsdelivr.net/npm/@runtypelabs/persona/dist/install.global.js";
+}
 
 // src/lib/persona-init.ts
+var PERSONA_INIT_AGENT_MODEL = "nemotron-3-ultra-550b-a55b";
+var PERSONA_INIT_DEMO_SYSTEM_PROMPT = `
+# Persona Playground Agent
+
+## Role
+
+You are the assistant inside a local Persona Playground generated by the Runtype CLI.
+
+## Goal
+
+Give the user one quick, visible "aha" moment: inspect the local page, request approval for a browser-side update, make the page change, and leave them with native next-step pills.
+
+## Available page tools
+
+- \`get_playground_state\` \u2014 read the current accent, headline, note, status, checklist, URL, and allowed origins.
+- \`update_playground\` \u2014 update the accent, headline, note, status, or checklist on the local HTML page.
+
+## Demo behavior
+
+1. Use \`get_playground_state\` before describing the current page or proposing a specific page change.
+2. Use \`update_playground\` when the user asks you to change the page.
+3. Explain, only when relevant, that mutating page updates require the user to approve Persona's tool-call bubble.
+4. After every successful \`update_playground\` call, follow \`responseGuidance\` exactly: do not send a visible response yet; first call \`suggest_replies\` with \`responseGuidance.suggestedReplies\`.
+5. When \`suggest_replies\` returns, send \`responseGuidance.assistantMessage\` exactly once as your only visible confirmation, then stop.
+6. Do not ask "what would you like to do next?" in prose; the Persona widget renders \`suggest_replies\` as tappable next-step pills.
+
+## Response style
+
+- Be concise, direct, and practical.
+- Prefer showing the page changing over explaining how it works.
+- If the user asks how to customize the demo, point them to \`index.html\`, the generated README, and the Runtype dashboard link.
+`.trim();
 async function getPersonaInitApiKeyNonInteractive(apiUrl) {
   const envApiKey = getRuntimeApiKey();
   if (envApiKey) {
@@ -65257,14 +65311,75 @@ async function getPersonaInitApiKeyNonInteractive(apiUrl) {
 }
 async function runPersonaInit(options) {
   const client = createCliClient(options.apiKey, options.apiUrl);
+  const demoEnabled = !!options.demo;
   const agent = await client.post("/agents", {
     name: options.agentName,
     description: options.agentDescription || "A Persona test agent",
     config: {
-      model: "qwen3.5-35b-a3b",
-      systemPrompt: "You are a helpful assistant."
+      model: PERSONA_INIT_AGENT_MODEL,
+      systemPrompt: demoEnabled ? PERSONA_INIT_DEMO_SYSTEM_PROMPT : "You are a helpful assistant."
     }
   });
+  let demoResources;
+  if (options.demo) {
+    const product = await client.post("/products", {
+      name: `${options.agentName} Persona Playground`,
+      description: "Local Persona WebMCP playground generated by the Runtype CLI.",
+      icon: "\u2728",
+      spec: {
+        productGoal: "Demonstrate a Persona widget operating a host page through WebMCP tools.",
+        targetAudience: "Developers testing Persona locally.",
+        productStage: "prototype"
+      }
+    });
+    const capability = await client.post(
+      `/products/${product.id}/capabilities`,
+      {
+        agentId: agent.id,
+        capabilityName: "Persona Playground Assistant",
+        capabilityDescription: "Agent that can read and update the local Persona Playground page through WebMCP tools.",
+        enabled: true
+      }
+    );
+    const allowlist = options.demo.origins.map((origin) => ({
+      origin,
+      tools: options.demo?.toolNames ?? []
+    }));
+    const surface = await client.post(
+      `/products/${product.id}/surfaces`,
+      {
+        name: "Local Persona Playground",
+        type: "chat",
+        status: "active",
+        environment: "development",
+        behavior: {
+          type: "chat",
+          welcomeMessage: "Try asking me to inspect or update this local page. I can use WebMCP tools registered by the HTML file.",
+          webmcp: {
+            enabled: true,
+            allowlist,
+            requireConfirmFor: ["update_playground"]
+          }
+        }
+      }
+    );
+    const surfaceItem = await client.post(
+      `/products/${product.id}/surfaces/${surface.id}/items`,
+      {
+        capabilityId: capability.id,
+        exposedName: "Persona Playground Assistant",
+        exposedDescription: "Operate the generated local HTML playground.",
+        enabled: true,
+        isEntryPoint: true
+      }
+    );
+    demoResources = {
+      productId: product.id,
+      capabilityId: capability.id,
+      surfaceId: surface.id,
+      surfaceItemId: surfaceItem.id
+    };
+  }
   const tokenBody = {
     name: options.tokenName,
     flowIds: [],
@@ -65274,7 +65389,8 @@ async function runPersonaInit(options) {
     rateLimitPerMinute: 10,
     rateLimitPerHour: 100,
     maxMessagesPerSession: 100,
-    sessionIdleTimeoutMinutes: 30
+    sessionIdleTimeoutMinutes: 30,
+    ...demoResources ? { productSurfaceId: demoResources.surfaceId } : {}
   };
   const tokenRes = await client.post("/client-tokens", tokenBody);
   const personaFormat = mapCliFormatToPersona(options.format);
@@ -65287,7 +65403,7 @@ async function runPersonaInit(options) {
     personaFormat
   );
   const dashboardBase = getDashboardUrl();
-  const account = await getCurrentAccountId();
+  const account = await getCurrentAccountId({ apiKey: options.apiKey, apiUrl: options.apiUrl });
   const dashboardUrl = buildDashboardUrl({
     baseUrl: dashboardBase,
     path: `/agents/${agent.id}`,
@@ -65304,20 +65420,718 @@ async function runPersonaInit(options) {
     },
     snippet: { format: options.format, code },
     dashboardUrl,
-    warnings: tokenRes.warnings
+    warnings: tokenRes.warnings,
+    ...demoResources ? { demo: demoResources } : {}
   };
 }
 
+// src/lib/persona-demo.ts
+import { createServer } from "http";
+import { createServer as createNetServer } from "net";
+import { existsSync as existsSync13, mkdirSync as mkdirSync8, readFileSync as readFileSync17, writeFileSync as writeFileSync6 } from "fs";
+import path16 from "path";
+var PERSONA_DEMO_DEFAULT_DIR = "persona-demo";
+var PERSONA_DEMO_DEFAULT_PORT = 43110;
+var PERSONA_DEMO_TOOL_NAMES = ["get_playground_state", "update_playground"];
+function unique(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+function buildPersonaDemoOrigins(port) {
+  return [`http://localhost:${port}`, `http://127.0.0.1:${port}`];
+}
+function mergePersonaDemoAllowedOrigins(requestedOrigins, demoOrigins) {
+  const explicitOrigins = (requestedOrigins ?? []).filter((origin) => origin !== "*");
+  return unique([...demoOrigins, ...explicitOrigins]);
+}
+function resolvePersonaDemoDirectory(input) {
+  return path16.resolve(process.cwd(), input?.trim() || PERSONA_DEMO_DEFAULT_DIR);
+}
+function personaDemoIndexPath(directory) {
+  return path16.join(directory, "index.html");
+}
+function personaDemoReadmePath(directory) {
+  return path16.join(directory, "README.md");
+}
+function ensurePersonaDemoCanWrite(directory, force) {
+  const existingFiles = [personaDemoIndexPath(directory), personaDemoReadmePath(directory)].filter(
+    (filePath) => existsSync13(filePath)
+  );
+  if (existingFiles.length > 0 && !force) {
+    throw new Error(
+      `Demo file already exists at ${existingFiles.join(", ")}. Pass --force to overwrite demo files or choose --demo-dir.`
+    );
+  }
+}
+function writePersonaDemoPage(options) {
+  ensurePersonaDemoCanWrite(options.directory, options.force);
+  mkdirSync8(options.directory, { recursive: true });
+  const filePath = personaDemoIndexPath(options.directory);
+  const readmePath = personaDemoReadmePath(options.directory);
+  writeFileSync6(filePath, `${options.html.trim()}
+`, "utf8");
+  writeFileSync6(readmePath, `${options.readme.trim()}
+`, "utf8");
+  return { directory: options.directory, filePath, readmePath };
+}
+async function findAvailablePersonaDemoPort(preferredPort = PERSONA_DEMO_DEFAULT_PORT) {
+  for (let offset = 0; offset < 50; offset += 1) {
+    const port = preferredPort + offset;
+    if (await canListenOnPort(port)) {
+      return port;
+    }
+  }
+  throw new Error(`Could not find an available local port starting at ${preferredPort}`);
+}
+function canListenOnPort(port) {
+  return new Promise((resolve11) => {
+    const server = createNetServer();
+    server.once("error", () => {
+      resolve11(false);
+    });
+    server.once("listening", () => {
+      server.close(() => resolve11(true));
+    });
+    server.listen(port, "127.0.0.1");
+  });
+}
+async function startPersonaDemoServer(options) {
+  const filePath = personaDemoIndexPath(options.directory);
+  const server = createServer((req, res) => {
+    const url2 = req.url?.split("?")[0] ?? "/";
+    if (url2 !== "/" && url2 !== "/index.html") {
+      res.writeHead(404, { "content-type": "text/plain; charset=utf-8" });
+      res.end("Not found");
+      return;
+    }
+    res.writeHead(200, {
+      "content-type": "text/html; charset=utf-8",
+      "cache-control": "no-store"
+    });
+    res.end(readIndexHtml(filePath));
+  });
+  await listen(server, options.port);
+  return {
+    url: `http://127.0.0.1:${options.port}/`,
+    port: options.port,
+    close: () => new Promise((resolve11, reject) => {
+      server.close((error51) => {
+        if (error51) reject(error51);
+        else resolve11();
+      });
+    })
+  };
+}
+function readIndexHtml(filePath) {
+  return readFileSync17(filePath, "utf8");
+}
+function listen(server, port) {
+  return new Promise((resolve11, reject) => {
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", () => {
+      server.off("error", reject);
+      resolve11();
+    });
+  });
+}
+function escapeHtml(value) {
+  return value.replace(/[&<>"']/g, (char) => {
+    switch (char) {
+      case "&":
+        return "&amp;";
+      case "<":
+        return "&lt;";
+      case ">":
+        return "&gt;";
+      case '"':
+        return "&quot;";
+      case "'":
+        return "&#39;";
+      default:
+        return char;
+    }
+  });
+}
+function inlineJson(value) {
+  return JSON.stringify(value, null, 2).replace(/<\//g, "<\\/");
+}
+function generatePersonaDemoHtml(input) {
+  const installerScriptUrl = input.installerScriptUrl ?? getPersonaInstallerScriptUrl();
+  const pageData = {
+    apiUrl: input.apiUrl,
+    clientToken: input.clientToken,
+    clientTokenId: input.clientTokenId,
+    agentId: input.agentId,
+    agentName: input.agentName,
+    dashboardUrl: input.dashboardUrl,
+    environment: input.environment,
+    localUrl: input.localUrl,
+    allowedOrigins: input.allowedOrigins
+  };
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Persona Local Playground</title>
+    <style>
+      :root {
+        --paper: #fcfcfa;
+        --paper-deep: #f4f0e8;
+        --ink: #24211f;
+        --muted: #67615b;
+        --line: #d9d2c7;
+        --line-strong: #201a16;
+        --accent: #4c00ff;
+        --accent-soft: color-mix(in srgb, var(--accent) 8%, var(--paper));
+        --live: #b6ff00;
+        --success: #178c4b;
+        --radius: 6px;
+      }
+      * { box-sizing: border-box; }
+      body {
+        margin: 0;
+        min-height: 100vh;
+        color: var(--ink);
+        font-family: Asap, Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+        background:
+          linear-gradient(90deg, rgba(36, 33, 31, .045) 1px, transparent 1px) 0 0 / 40px 40px,
+          linear-gradient(rgba(36, 33, 31, .04) 1px, transparent 1px) 0 0 / 40px 40px,
+          radial-gradient(circle at 18% 0%, var(--accent-soft), transparent 30rem),
+          var(--paper);
+      }
+      button { font: inherit; }
+      .shell {
+        width: min(920px, calc(100% - 32px));
+        margin: 0 auto;
+        padding: clamp(28px, 6vw, 64px) 0 112px;
+      }
+      .panel {
+        border: 1px solid var(--line-strong);
+        border-radius: var(--radius);
+        background: color-mix(in srgb, var(--paper) 91%, white);
+        box-shadow: 7px 7px 0 rgba(36, 33, 31, .12);
+        padding: clamp(18px, 3vw, 28px);
+      }
+      .demo-grid {
+        display: grid;
+        grid-template-columns: minmax(0, 1fr) minmax(260px, 340px);
+        gap: 18px;
+        align-items: stretch;
+      }
+      .preview {
+        min-height: 280px;
+        display: grid;
+        align-content: space-between;
+        gap: 24px;
+        border: 1px solid var(--line-strong);
+        border-radius: var(--radius);
+        padding: clamp(20px, 3vw, 28px);
+        color: white;
+        background: linear-gradient(135deg, color-mix(in srgb, var(--accent) 86%, black), var(--accent));
+      }
+      .preview h2 {
+        margin: 0;
+        max-width: 560px;
+        font-family: Newsreader, Georgia, "Times New Roman", serif;
+        font-size: clamp(30px, 5vw, 54px);
+        line-height: .96;
+        letter-spacing: -0.04em;
+      }
+      .preview p { max-width: 560px; margin: 12px 0 0; opacity: .9; line-height: 1.6; }
+      .status-pill {
+        justify-self: start;
+        border: 1px solid rgba(255,255,255,.75);
+        border-radius: 999px;
+        padding: 7px 10px;
+        font-size: 12px;
+        font-weight: 800;
+      }
+      .section-title {
+        margin: 0 0 12px;
+        color: var(--muted);
+        font-size: 12px;
+        font-weight: 800;
+        letter-spacing: .12em;
+        text-transform: uppercase;
+      }
+      .tasks { display: grid; gap: 9px; }
+      .task {
+        display: flex;
+        align-items: center;
+        gap: 10px;
+        padding: 11px 12px;
+        border: 1px solid var(--line);
+        border-radius: var(--radius);
+        background: var(--paper);
+      }
+      .task-dot {
+        display: grid;
+        place-items: center;
+        width: 23px;
+        height: 23px;
+        border-radius: 999px;
+        color: var(--paper);
+        background: #9c958e;
+        font-size: 13px;
+        font-weight: 900;
+      }
+      .task[data-done="true"] .task-dot { background: var(--success); }
+      .task[data-done="true"] .task-label { color: var(--muted); text-decoration: line-through; }
+      .activity {
+        margin-top: 18px;
+        padding-top: 16px;
+        border-top: 1px solid var(--line);
+      }
+      .log { display: grid; gap: 8px; max-height: 120px; overflow: auto; }
+      .log-row {
+        color: #4b463f;
+        font-size: 12px;
+        line-height: 1.45;
+      }
+      .log-row strong { color: var(--ink); }
+      .action-bar {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 10px;
+        align-items: center;
+        margin-top: 18px;
+        padding-top: 18px;
+        border-top: 1px solid var(--line);
+      }
+      .cta {
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        gap: 8px;
+        min-height: 42px;
+        border: 1px solid var(--line-strong);
+        border-radius: var(--radius);
+        padding: 10px 13px;
+        color: var(--ink);
+        font-size: 14px;
+        font-weight: 800;
+        text-decoration: none;
+        cursor: pointer;
+      }
+      .cta-primary { background: var(--accent); color: white; }
+      .cta-secondary { background: var(--paper); }
+      .cta-arrow { font-size: 18px; line-height: 1; }
+      details {
+        margin-top: 18px;
+        color: var(--muted);
+        font-size: 13px;
+      }
+      summary {
+        cursor: pointer;
+        width: fit-content;
+        color: var(--ink);
+        font-weight: 700;
+      }
+      .details-grid {
+        display: grid;
+        grid-template-columns: 90px minmax(0, 1fr);
+        gap: 8px 14px;
+        margin-top: 12px;
+      }
+      code {
+        color: #2f2a26;
+        word-break: break-word;
+        font-family: "SFMono-Regular", Consolas, "Liberation Mono", monospace;
+        font-size: 12px;
+      }
+      @media (max-width: 820px) {
+        .demo-grid { grid-template-columns: 1fr; }
+        .shell { width: min(100% - 24px, 720px); }
+      }
+      @media (prefers-reduced-motion: reduce) {
+        *, *::before, *::after { transition: none !important; }
+      }
+    </style>
+  </head>
+  <body>
+    <!-- Edit this file directly, refresh the browser, and keep customizing your Persona starter. -->
+    <main class="shell">
+      <section class="panel" aria-label="Persona demo workspace">
+        <div class="demo-grid">
+          <div class="preview" id="accent-preview">
+            <div>
+              <h2 id="playground-headline">Local tools. Visible results.</h2>
+              <p id="playground-note">Persona can read this page, request approval, and update the UI from the browser.</p>
+            </div>
+            <span class="status-pill" id="status-pill">Waiting for your first task</span>
+          </div>
+
+          <div>
+            <p class="section-title">Checklist</p>
+            <div class="tasks" id="task-list"></div>
+
+            <div class="activity">
+              <p class="section-title">Activity</p>
+              <div class="log" id="tool-log"></div>
+            </div>
+          </div>
+        </div>
+
+        <div class="action-bar" aria-label="Next actions">
+          <button class="cta cta-primary" id="use-persona-widget" type="button">
+            <span id="use-persona-label">Use Persona widget</span> <span class="cta-arrow" aria-hidden="true">\u2198</span>
+          </button>
+          <a class="cta cta-secondary" href="${escapeHtml(input.dashboardUrl)}" target="_blank" rel="noreferrer">Customize your agent</a>
+        </div>
+
+        <details>
+          <summary>Technical details</summary>
+          <div class="details-grid">
+            <span>Agent</span><code>${escapeHtml(input.agentId)}</code>
+            <span>Token</span><code>${escapeHtml(input.clientTokenId)} (${escapeHtml(input.environment)})</code>
+            <span>Edit</span><code>index.html</code>
+            <span>Origin</span><code>${escapeHtml(input.localUrl)}</code>
+            <span>Tools</span><code>${PERSONA_DEMO_TOOL_NAMES.join(", ")}</code>
+            <span>Dashboard</span><code>${escapeHtml(input.dashboardUrl)}</code>
+          </div>
+        </details>
+      </section>
+    </main>
+
+    <div id="persona-root"></div>
+
+    <!-- 1. Runtime values injected by the CLI. -->
+    <script>
+      window.__RUNTYPE_PERSONA_DEMO__ = ${inlineJson(pageData)};
+    </script>
+    <!-- 2. Minimal WebMCP host bridge for this dependency-free page. -->
+    <script>
+      (function installMinimalModelContext() {
+        if (document.modelContext && typeof document.modelContext.getTools === 'function') {
+          return;
+        }
+        const tools = new Map();
+        document.modelContext = {
+          registerTool(tool) {
+            if (!tool || !tool.name || typeof tool.execute !== 'function') {
+              throw new Error('registerTool requires a name and execute function');
+            }
+            tools.set(tool.name, tool);
+          },
+          async getTools() {
+            return Array.from(tools.values()).map((tool) => ({
+              name: tool.name,
+              title: tool.title || '',
+              description: tool.description || '',
+              inputSchema: JSON.stringify(tool.inputSchema || { type: 'object', properties: {} }),
+            }));
+          },
+          async executeTool(info, inputArgsJson) {
+            const name = typeof info === 'string' ? info : info && info.name;
+            const tool = tools.get(name);
+            if (!tool) throw new Error('Tool not registered: ' + name);
+            const args = inputArgsJson ? JSON.parse(inputArgsJson) : {};
+            const result = await tool.execute(args, {
+              requestUserInteraction: async (callback) => callback(),
+            });
+            return result === undefined ? null : JSON.stringify(result);
+          },
+        };
+      })();
+
+      const demo = window.__RUNTYPE_PERSONA_DEMO__;
+      /* 3. Page state the tools can read and update. */
+      const accentMap = {
+        violet: '#4c00ff',
+        green: '#178c4b',
+        cyan: '#008ca8',
+        orange: '#d95f02',
+      };
+      const state = {
+        accent: 'violet',
+        headline: 'Local tools. Visible results.',
+        note: 'Persona can read this page, request approval, and update the UI from the browser.',
+        status: 'Waiting for your first task',
+        tasks: [
+          { id: 'widget', label: 'Widget installed', done: true },
+          { id: 'webmcp', label: 'WebMCP tools connected', done: true },
+          { id: 'setup', label: 'Setup complete', done: false },
+        ],
+      };
+
+      function escapeText(value) {
+        return String(value).replace(/[&<>]/g, (char) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;' })[char]);
+      }
+
+      function logTool(kind, message) {
+        const log = document.getElementById('tool-log');
+        const row = document.createElement('div');
+        row.className = 'log-row';
+        row.innerHTML = '<strong>' + escapeText(kind) + '</strong> \xB7 ' + escapeText(message);
+        log.prepend(row);
+      }
+
+      function snapshot() {
+        return {
+          accent: state.accent,
+          accentHex: accentMap[state.accent],
+          headline: state.headline,
+          note: state.note,
+          status: state.status,
+          tasks: state.tasks,
+          pageUrl: location.href,
+          allowedOrigins: demo.allowedOrigins,
+        };
+      }
+
+      function render() {
+        document.documentElement.style.setProperty('--accent', accentMap[state.accent]);
+        document.getElementById('playground-headline').textContent = state.headline;
+        document.getElementById('playground-note').textContent = state.note;
+        document.getElementById('status-pill').textContent = state.status;
+        const setupDone = state.tasks.some((task) => task.id === 'setup' && task.done);
+        const ctaLabel = document.getElementById('use-persona-label');
+        if (ctaLabel) ctaLabel.textContent = setupDone ? 'Try another page change' : 'Use Persona widget';
+        const taskList = document.getElementById('task-list');
+        taskList.innerHTML = '';
+        for (const task of state.tasks) {
+          const row = document.createElement('div');
+          row.className = 'task';
+          row.dataset.done = String(task.done);
+          row.innerHTML = '<span class="task-dot">\u2713</span><span class="task-label"></span>';
+          row.querySelector('.task-label').textContent = task.label;
+          taskList.appendChild(row);
+        }
+      }
+
+      function taskLabel(id) {
+        const task = state.tasks.find((item) => item.id === id);
+        return task ? task.label : id;
+      }
+
+      function buildAssistantMessage(args, changed) {
+        if (!changed.length) return 'Done \u2014 no visible page changes were needed.';
+
+        const updates = [];
+        if (args.accent && accentMap[args.accent]) updates.push('the page is now ' + args.accent);
+        if (typeof args.headline === 'string' && args.headline.trim()) updates.push('the headline changed');
+        if (typeof args.note === 'string' && args.note.trim()) updates.push('the note changed');
+        if (typeof args.status === 'string' && args.status.trim()) updates.push('the status changed');
+        if (Array.isArray(args.completedTaskIds) && args.completedTaskIds.length) {
+          const labels = args.completedTaskIds.map((id) => taskLabel(id));
+          updates.push(
+            labels.length === 1 ? labels[0] + ' is checked' : labels.join(', ') + ' are checked'
+          );
+        }
+
+        return 'Done \u2014 ' + updates.join(' and ') + '.';
+      }
+
+      function buildSuggestedReplies() {
+        return [
+          'Change the headline',
+          'Add another page tool',
+          'Show the embed code',
+          'Customize the agent',
+        ];
+      }
+
+      /* 4. WebMCP tools exposed to the Persona widget. */
+      document.modelContext.registerTool({
+        name: 'get_playground_state',
+        title: 'Read playground state',
+        description: 'Read the current local Persona playground state: accent, headline, note, status, checklist, URL, and allowed origins. Use this before proposing page changes.',
+        inputSchema: { type: 'object', properties: {} },
+        annotations: { readOnlyHint: true },
+        async execute() {
+          logTool('Read page state', 'Persona inspected the local HTML page');
+          return snapshot();
+        },
+      });
+
+      document.modelContext.registerTool({
+        name: 'update_playground',
+        title: 'Update playground UI',
+        description: 'Update this local HTML playground. Can set accent to violet, green, cyan, or orange; rewrite the headline or note; set a short status; and mark checklist tasks complete by id.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            accent: { type: 'string', enum: Object.keys(accentMap), description: 'Accent color to apply.' },
+            headline: { type: 'string', description: 'New hero headline.' },
+            note: { type: 'string', description: 'New explanatory note under the headline.' },
+            status: { type: 'string', description: 'Short status shown inside the demo card.' },
+            completedTaskIds: {
+              type: 'array',
+              items: { type: 'string', enum: state.tasks.map((task) => task.id) },
+              description: 'Checklist task ids to mark complete.',
+            },
+          },
+        },
+        async execute(args) {
+          const changed = [];
+          if (args.accent && accentMap[args.accent]) {
+            state.accent = args.accent;
+            changed.push('accent');
+          }
+          if (typeof args.headline === 'string' && args.headline.trim()) {
+            state.headline = args.headline.trim();
+            changed.push('headline');
+          }
+          if (typeof args.note === 'string' && args.note.trim()) {
+            state.note = args.note.trim();
+            changed.push('note');
+          }
+          if (typeof args.status === 'string' && args.status.trim()) {
+            state.status = args.status.trim();
+            changed.push('status');
+          }
+          if (Array.isArray(args.completedTaskIds) && args.completedTaskIds.length) {
+            const completed = new Set(args.completedTaskIds);
+            state.tasks = state.tasks.map((task) => completed.has(task.id) ? { ...task, done: true } : task);
+            changed.push('checklist');
+          }
+          render();
+          logTool('Updated page', changed.length ? changed.join(' + ') : 'No visible changes requested');
+          return {
+            ok: true,
+            changed,
+            responseGuidance: {
+              assistantMessage: buildAssistantMessage(args, changed),
+              suggestedReplies: buildSuggestedReplies(),
+              instructions: 'Do not send a visible assistant message yet. First call suggest_replies with suggestedReplies. After suggest_replies returns, say assistantMessage exactly once, then stop.',
+            },
+            state: snapshot(),
+          };
+        },
+      });
+
+      /* 5. Persona widget config. The installer below reads window.siteAgentConfig. */
+      window.siteAgentConfig = {
+        target: '#persona-root',
+        windowKey: 'personaPlayground',
+        config: {
+          apiUrl: demo.apiUrl,
+          clientToken: demo.clientToken,
+          parserType: 'json',
+          launcher: {
+            enabled: true,
+            autoExpand: true,
+            title: 'Persona Playground',
+            subtitle: 'Local WebMCP demo',
+            width: '430px',
+          },
+          copy: {
+            welcomeTitle: 'Persona Playground',
+            welcomeSubtitle: 'Use the page tools, then pick a next step.',
+            inputPlaceholder: 'Ask Persona to update this page\u2026',
+          },
+          suggestionChips: [
+            'Turn this page green and mark Setup complete.',
+            'What page tools are available?',
+            'Show the embed code.',
+          ],
+          features: {
+            showToolCalls: true,
+            showEventStreamToggle: true,
+            suggestReplies: {
+              enabled: true,
+              expose: true,
+            },
+          },
+          webmcp: {
+            enabled: true,
+            autoApprove(info) {
+              const ok = info && info.toolName === 'get_playground_state';
+              logTool('Approval gate', (info ? info.toolName : 'unknown') + (ok ? ' auto-approved' : ' awaiting approval'));
+              return ok;
+            },
+          },
+        },
+        onChatReady(handle) {
+          window.personaPlayground = handle;
+          logTool('Widget ready', 'Persona handle is available at window.personaPlayground');
+          setTimeout(() => {
+            if (handle && typeof handle.open === 'function') handle.open();
+          }, 0);
+        },
+        onError(info) {
+          logTool('Persona error', info && info.phase ? info.phase : 'unknown phase');
+        },
+      };
+
+      document.getElementById('use-persona-widget').addEventListener('click', () => {
+        const handle = window.personaPlayground;
+        if (handle && typeof handle.open === 'function') handle.open();
+        if (handle && typeof handle.setMessage === 'function') {
+          handle.setMessage('Turn this page green and mark Setup complete.');
+        }
+        logTool('CTA', 'Opened Persona widget');
+      });
+
+      render();
+      logTool('Tools connected', 'Registered get_playground_state and update_playground');
+    </script>
+    <!-- 6. Version-pinned Persona installer from @runtypelabs/persona. -->
+    <script src="${escapeHtml(installerScriptUrl)}"></script>
+  </body>
+</html>`;
+}
+function generatePersonaDemoReadme(input) {
+  const port = (() => {
+    try {
+      return new URL(input.localUrl).port || String(PERSONA_DEMO_DEFAULT_PORT);
+    } catch {
+      return String(PERSONA_DEMO_DEFAULT_PORT);
+    }
+  })();
+  return `# Persona Playground
+
+This folder was generated by \`runtype persona init\`.
+
+## Next steps
+
+1. Use the widget: ${input.localUrl}
+2. Customize your agent: ${input.dashboardUrl}
+3. Edit the page: ./index.html
+
+## Run locally
+
+\`\`\`bash
+python3 -m http.server ${port} --bind 127.0.0.1
+\`\`\`
+
+Then open ${input.localUrl}.
+
+## What this starter demonstrates
+
+- \`window.siteAgentConfig\` installs Persona with your client token.
+- \`document.modelContext\` exposes two local WebMCP tools:
+  - \`get_playground_state\` reads the page state.
+  - \`update_playground\` changes the accent, copy, status, and checklist after approval.
+- Persona native suggested replies render next-step pills after a successful tool call.
+
+## Add another page tool
+
+1. Add a new \`document.modelContext.registerTool({ ... })\` block in \`index.html\`.
+2. Add the tool name to the WebMCP allowlist for this surface in the Runtype dashboard.
+3. Refresh the page and ask Persona to use the new tool.
+
+## Demo resources
+
+- Agent: ${input.agentId}
+- Client token: ${input.clientTokenId} (${input.environment})
+- Allowed origins: ${input.allowedOrigins.join(", ")}
+`;
+}
+
 // src/commands/persona.ts
-var FORMAT_CYCLE = [
-  "script-installer",
-  "react",
-  "script-manual",
-  "esm"
-];
+var FORMAT_CYCLE = ["script-installer", "react", "script-manual", "esm"];
 function defaultTokenName(agentName) {
   return `${agentName} Widget`;
 }
+function parsePort(raw, fallback) {
+  if (!raw) return fallback;
+  const port = Number(raw);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(`Invalid port "${raw}". Use a number between 1 and 65535.`);
+  }
+  return port;
+}
 async function promptLine(rl, question, defaultValue) {
   const hint = defaultValue ? chalk30.dim(` (${defaultValue})`) : "";
   const answer = await new Promise((resolve11) => {
@@ -65366,7 +66180,16 @@ function snippetWithFormat(format, token, apiUrl, targetSelector) {
   );
   return { format, code };
 }
-async function runSuccessKeyLoop(initial, apiUrl, targetSelector) {
+function printDemoNextSteps(demo, dashboardUrl) {
+  console.log(chalk30.cyan("\nNext steps:"));
+  console.log(`  1. Use the widget: ${chalk30.green(demo.url)}`);
+  console.log(`  2. Customize your agent: ${dashboardUrl}`);
+  console.log(`  3. Edit the page: ${demo.filePath}`);
+  if (demo.readmePath) {
+    console.log(chalk30.dim(`     Guide: ${demo.readmePath}`));
+  }
+}
+async function runSuccessKeyLoop(initial, apiUrl, targetSelector, demo) {
   if (!process.stdin.isTTY) {
     return;
   }
@@ -65380,39 +66203,48 @@ async function runSuccessKeyLoop(initial, apiUrl, targetSelector) {
   console.log(`${chalk30.bold("Snippet format:")} ${currentFormat}`);
   console.log(chalk30.dim(`
 Dashboard: ${initial.dashboardUrl}`));
+  if (demo) {
+    console.log(`${chalk30.bold("Local demo:")} ${chalk30.green(demo.url)}`);
+    console.log(chalk30.dim(`HTML: ${demo.filePath}`));
+    if (demo.readmePath) {
+      console.log(chalk30.dim(`Guide: ${demo.readmePath}`));
+    }
+  }
   if (initial.warnings?.length) {
     for (const w of initial.warnings) {
       console.log(chalk30.yellow(`\u26A0 ${w.message}`));
     }
   }
-  console.log(chalk30.cyan("\nKeys:"));
+  if (demo) {
+    printDemoNextSteps(demo, initial.dashboardUrl);
+  }
+  console.log(chalk30.cyan("\nActions:"));
   console.log(`  ${chalk30.green("c")}  Copy snippet to clipboard`);
   console.log(`  ${chalk30.green("p")}  Print snippet to the terminal`);
   console.log(`  ${chalk30.green("f")}  Switch snippet format`);
   console.log(`  ${chalk30.green("o")}  Open dashboard in browser`);
-  console.log(`  ${chalk30.green("q")}  Quit`);
-  readline3.emitKeypressEvents(process.stdin);
-  if (process.stdin.isTTY) {
-    process.stdin.setRawMode(true);
+  if (demo) {
+    console.log(`  ${chalk30.green("d")}  Open local demo in browser`);
   }
-  process.stdin.resume();
-  const cleanup = () => {
-    process.stdin.setRawMode(false);
-    process.stdin.removeAllListeners("keypress");
-    process.stdin.pause();
-  };
+  console.log(`  ${chalk30.green("q")}  Quit`);
+  console.log(chalk30.dim("\nType a letter and press Enter. Press Ctrl+C to quit."));
+  const actionKeys = demo ? "c/p/f/o/d/q" : "c/p/f/o/q";
+  const rl = readline3.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true
+  });
   await new Promise((resolve11) => {
-    const onKeypress = async (_str, key) => {
-      if (!key) return;
-      if (key.ctrl && key.name === "c") {
-        cleanup();
-        resolve11();
-        process.exit(0);
-      }
-      const name = key.name;
-      if (name === "q" || name === "escape") {
-        cleanup();
-        resolve11();
+    let finished = false;
+    const finish = () => {
+      if (finished) return;
+      finished = true;
+      rl.close();
+      resolve11();
+    };
+    const runAction = async (name) => {
+      if (name === "q") {
+        finish();
         return;
       }
       if (name === "c") {
@@ -65441,23 +66273,61 @@ Dashboard: ${initial.dashboardUrl}`));
       }
       if (name === "o") {
         try {
-          await open5(initial.dashboardUrl);
+          await openBrowser(initial.dashboardUrl);
         } catch {
           console.log(chalk30.red("Could not open browser."));
         }
+        return;
       }
+      if (name === "d" && demo) {
+        try {
+          await openBrowser(demo.url);
+        } catch {
+          console.log(chalk30.red("Could not open browser."));
+        }
+        return;
+      }
+      console.log(chalk30.yellow(`Choose one of: ${actionKeys}`));
+    };
+    const ask = () => {
+      if (finished) return;
+      rl.question(chalk30.dim(`
+Choose an action (${actionKeys}): `), (answer) => {
+        const names = answer.trim().toLowerCase().split(/[\s,]+/).filter(Boolean).map((part) => part.charAt(0));
+        void (async () => {
+          for (const name of names) {
+            await runAction(name);
+            if (finished) {
+              return;
+            }
+          }
+          if (!finished) {
+            ask();
+          }
+        })();
+      });
     };
-    process.stdin.on("keypress", onKeypress);
+    rl.on("SIGINT", finish);
+    ask();
   });
 }
 var personaCommand = new Command23("persona").description(
   "Set up Persona: create an agent, client token, and embed snippet"
 );
-personaCommand.command("init").description("Create agent + client token and output a Persona embed snippet").option("--agent-name <name>", "Name for the new agent").option("--agent-description <text", "Optional agent description").option("--token-name <name>", "Name for the new client token").option("--environment <env>", "Token environment: test or live", "test").option("--origins <origins...>", "Allowed origins (default: * \u2014 broad; prefer explicit URLs in production)").option(
+personaCommand.command("init").description("Create agent + client token and output a Persona embed snippet").option("--agent-name <name>", "Name for the new agent").option("--agent-description <text", "Optional agent description").option("--token-name <name>", "Name for the new client token").option("--environment <env>", "Token environment: test or live", "test").option(
+  "--origins <origins...>",
+  "Allowed origins (default: * \u2014 broad; prefer explicit URLs in production)"
+).option(
   "--format <fmt>",
   "Snippet format: script-installer | script-manual | esm | react",
   "script-installer"
-).option("--print-snippet", "Print the generated snippet to stdout (non-interactive summary mode)").option("--target-selector <selector>", "CSS selector for widget mount target (omit to use body)").option("--api-url <url>", "Override API base URL").option("--json", "Structured JSON output (includes snippet body)").option("--yes", "Accept defaults in interactive prompts where sensible").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(
+).option("--print-snippet", "Print the generated snippet to stdout (non-interactive summary mode)").option("--target-selector <selector>", "CSS selector for widget mount target (omit to use body)").option("--demo", "Create a dependency-free local Persona Playground HTML demo").option("--no-demo", "Skip the local Persona Playground demo").option(
+  "--demo-dir <path>",
+  `Directory for the local demo (default: ${PERSONA_DEMO_DEFAULT_DIR})`
+).option(
+  "--demo-port <port>",
+  `Preferred localhost port for the local demo (default: ${PERSONA_DEMO_DEFAULT_PORT})`
+).option("--open", "Open the local demo in a browser when demo mode is enabled").option("--no-open", "Do not open the local demo automatically").option("--force", "Overwrite existing demo files").option("--api-url <url>", "Override API base URL").option("--json", "Structured JSON output (includes snippet body)").option("--yes", "Accept defaults in interactive prompts where sensible").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(
   async (options, cmd) => {
     const globals = cmd.optsWithGlobals();
     const jsonMode = !!(options.json ?? globals.json);
@@ -65468,7 +66338,9 @@ personaCommand.command("init").description("Create agent + client token and outp
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
       if (jsonMode) {
-        console.log(JSON.stringify({ status: "error", error: msg, code: "INVALID_FORMAT" }, null, 2));
+        console.log(
+          JSON.stringify({ status: "error", error: msg, code: "INVALID_FORMAT" }, null, 2)
+        );
       } else {
         console.error(chalk30.red(msg));
       }
@@ -65476,6 +66348,20 @@ personaCommand.command("init").description("Create agent + client token and outp
     }
     const apiUrl = options.apiUrl || globals.apiUrl || getApiUrl();
     const targetSelector = options.targetSelector || void 0;
+    let preferredDemoPort;
+    try {
+      preferredDemoPort = parsePort(options.demoPort, PERSONA_DEMO_DEFAULT_PORT);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      if (jsonMode) {
+        console.log(
+          JSON.stringify({ status: "error", error: msg, code: "INVALID_DEMO_PORT" }, null, 2)
+        );
+      } else {
+        console.error(chalk30.red(msg));
+      }
+      process.exit(1);
+    }
     let env;
     if (options.environment === "test" || options.environment === "live") {
       env = options.environment;
@@ -65493,12 +66379,20 @@ personaCommand.command("init").description("Create agent + client token and outp
     let tokenName = options.tokenName?.trim();
     let allowedOrigins = options.origins;
     let chosenEnv = env;
+    let demoRequested = options.demo === true;
+    let demoDirectory;
+    let demoPort;
+    let demoOrigins;
+    let demoLocalUrl;
+    let forceDemoWrite = !!options.force;
     const rl = interactive && process.stdin.isTTY && process.stdout.isTTY ? readline3.createInterface({ input: process.stdin, output: process.stdout }) : null;
     if (!interactive) {
       if (!agentName) {
         const msg = "Non-interactive mode requires --agent-name";
         if (jsonMode) {
-          console.log(JSON.stringify({ status: "error", error: msg, code: "MISSING_AGENT_NAME" }, null, 2));
+          console.log(
+            JSON.stringify({ status: "error", error: msg, code: "MISSING_AGENT_NAME" }, null, 2)
+          );
         } else {
           console.error(chalk30.red(msg));
         }
@@ -65525,20 +66419,52 @@ personaCommand.command("init").description("Create agent + client token and outp
           tokenName = def;
         }
       }
+      if (options.demo === void 0 && !options.yes) {
+        demoRequested = await promptConfirm2(
+          rl,
+          "Create and open a local Persona Playground HTML demo?",
+          true
+        );
+      } else if (options.demo === void 0 && options.yes) {
+        demoRequested = true;
+      }
+      if (demoRequested) {
+        demoDirectory = resolvePersonaDemoDirectory(options.demoDir);
+        try {
+          ensurePersonaDemoCanWrite(demoDirectory, forceDemoWrite);
+        } catch (e) {
+          const message = e instanceof Error ? e.message : String(e);
+          const ok = await promptConfirm2(rl, `${message} Overwrite it?`, false);
+          if (!ok) {
+            console.log(chalk30.gray("Aborted."));
+            rl.close();
+            process.exit(0);
+          }
+          forceDemoWrite = true;
+        }
+        demoPort = await findAvailablePersonaDemoPort(preferredDemoPort);
+        demoOrigins = buildPersonaDemoOrigins(demoPort);
+        demoLocalUrl = `http://127.0.0.1:${demoPort}/`;
+      }
       if (!allowedOrigins?.length) {
+        const defaultOrigins = demoOrigins?.join(" ") ?? "*";
         if (options.yes) {
-          allowedOrigins = ["*"];
+          allowedOrigins = demoOrigins ?? ["*"];
         } else {
           const originsInput = await promptLine(
             rl,
             "Allowed origins (space-separated URLs, or * for any)",
-            "*"
+            defaultOrigins
           );
           allowedOrigins = originsInput === "*" ? ["*"] : originsInput.split(/\s+/).filter(Boolean);
         }
       }
       if (chosenEnv === "live") {
-        const ok = await promptConfirm2(rl, chalk30.yellow("Create a LIVE token? This is shown only once."), false);
+        const ok = await promptConfirm2(
+          rl,
+          chalk30.yellow("Create a LIVE token? This is shown only once."),
+          false
+        );
         if (!ok) {
           console.log(chalk30.gray("Aborted."));
           rl.close();
@@ -65556,6 +66482,28 @@ personaCommand.command("init").description("Create agent + client token and outp
         }
       }
     }
+    if (demoRequested && !demoDirectory) {
+      demoDirectory = resolvePersonaDemoDirectory(options.demoDir);
+      try {
+        ensurePersonaDemoCanWrite(demoDirectory, forceDemoWrite);
+      } catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        if (jsonMode) {
+          console.log(
+            JSON.stringify({ status: "error", error: message, code: "DEMO_EXISTS" }, null, 2)
+          );
+        } else {
+          console.error(chalk30.red(message));
+        }
+        process.exit(1);
+      }
+      demoPort = await findAvailablePersonaDemoPort(preferredDemoPort);
+      demoOrigins = buildPersonaDemoOrigins(demoPort);
+      demoLocalUrl = `http://127.0.0.1:${demoPort}/`;
+    }
+    if (demoRequested && demoOrigins) {
+      allowedOrigins = mergePersonaDemoAllowedOrigins(allowedOrigins, demoOrigins);
+    }
     if (rl) {
       rl.close();
     }
@@ -65607,45 +66555,155 @@ personaCommand.command("init").description("Create agent + client token and outp
         environment: chosenEnv,
         allowedOrigins,
         format: formatCli,
-        targetSelector
+        targetSelector,
+        ...demoRequested && demoOrigins ? { demo: { origins: demoOrigins, toolNames: [...PERSONA_DEMO_TOOL_NAMES] } } : {}
       });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       if (jsonMode) {
-        console.log(JSON.stringify({ status: "error", error: message, code: "API_ERROR" }, null, 2));
+        console.log(
+          JSON.stringify({ status: "error", error: message, code: "API_ERROR" }, null, 2)
+        );
       } else {
         console.error(chalk30.red("Persona init failed"));
         console.error(chalk30.red(message));
       }
       process.exit(1);
     }
+    let demoOutput;
+    let demoServer;
+    if (demoRequested && demoDirectory && demoPort && demoOrigins && demoLocalUrl) {
+      const html = generatePersonaDemoHtml({
+        apiUrl,
+        clientToken: success2.clientToken.token,
+        clientTokenId: success2.clientToken.id,
+        agentId: success2.agent.id,
+        agentName: success2.agent.name,
+        dashboardUrl: success2.dashboardUrl,
+        environment: success2.clientToken.environment,
+        localUrl: demoLocalUrl,
+        allowedOrigins: demoOrigins
+      });
+      const readme2 = generatePersonaDemoReadme({
+        apiUrl,
+        clientToken: success2.clientToken.token,
+        clientTokenId: success2.clientToken.id,
+        agentId: success2.agent.id,
+        agentName: success2.agent.name,
+        dashboardUrl: success2.dashboardUrl,
+        environment: success2.clientToken.environment,
+        localUrl: demoLocalUrl,
+        allowedOrigins: demoOrigins
+      });
+      const writeResult = writePersonaDemoPage({
+        directory: demoDirectory,
+        html,
+        readme: readme2,
+        force: forceDemoWrite
+      });
+      demoOutput = {
+        ...writeResult,
+        localUrl: demoLocalUrl,
+        port: demoPort,
+        allowedOrigins: demoOrigins,
+        serverRunning: false
+      };
+      const shouldLaunchDemo = !jsonMode && options.open !== false && (interactive || options.open === true);
+      if (shouldLaunchDemo) {
+        try {
+          demoServer = await startPersonaDemoServer({
+            directory: demoDirectory,
+            port: demoPort
+          });
+          demoOutput.serverRunning = true;
+          demoOutput.localUrl = demoServer.url;
+          await openBrowser(demoServer.url);
+        } catch (e) {
+          demoOutput.serverError = e instanceof Error ? e.message : String(e);
+          if (!jsonMode) {
+            console.log(
+              chalk30.yellow(`Could not start/open local demo server: ${demoOutput.serverError}`)
+            );
+          }
+        }
+      }
+    }
+    const output = demoOutput ? {
+      ...success2,
+      demo: {
+        ...success2.demo,
+        ...demoOutput
+      }
+    } : success2;
     if (jsonMode) {
-      printJson(success2);
+      printJson(output);
       return;
     }
     if (!tty || options.printSnippet) {
       console.log(chalk30.green("\nPersona setup complete\n"));
-      console.log(`${chalk30.bold("Agent ID:")} ${success2.agent.id}`);
-      console.log(`${chalk30.bold("Client Token ID:")} ${success2.clientToken.id}`);
-      console.log(`${chalk30.bold("Client Token:")} ${chalk30.yellow(success2.clientToken.token)}`);
-      console.log(`${chalk30.bold("Format:")} ${success2.snippet.format}`);
+      console.log(`${chalk30.bold("Agent ID:")} ${output.agent.id}`);
+      console.log(`${chalk30.bold("Client Token ID:")} ${output.clientToken.id}`);
+      console.log(`${chalk30.bold("Client Token:")} ${chalk30.yellow(output.clientToken.token)}`);
+      console.log(`${chalk30.bold("Format:")} ${output.snippet.format}`);
       console.log(chalk30.dim(`
-Dashboard: ${success2.dashboardUrl}`));
+Dashboard: ${output.dashboardUrl}`));
+      if (demoOutput) {
+        console.log(`${chalk30.bold("Demo HTML:")} ${demoOutput.filePath}`);
+        console.log(`${chalk30.bold("Demo README:")} ${demoOutput.readmePath}`);
+        console.log(`${chalk30.bold("Demo URL:")} ${chalk30.green(demoOutput.localUrl)}`);
+        if (demoOutput.serverRunning) {
+          console.log(chalk30.dim("Local demo server is running. Press Ctrl+C to stop it."));
+        } else {
+          console.log(
+            chalk30.dim(
+              `Run: cd ${demoOutput.directory} && python3 -m http.server ${demoOutput.port} --bind 127.0.0.1`
+            )
+          );
+        }
+        printDemoNextSteps(
+          {
+            url: demoOutput.localUrl,
+            filePath: demoOutput.filePath,
+            readmePath: demoOutput.readmePath
+          },
+          output.dashboardUrl
+        );
+      }
       if (success2.warnings?.length) {
         for (const w of success2.warnings) {
           console.log(chalk30.yellow(`\u26A0 ${w.message}`));
         }
       }
-      console.log(chalk30.cyan("\nRecommended next step: npm install @runtypelabs/persona"));
+      if (!demoOutput) {
+        console.log(chalk30.cyan("\nRecommended next step: npm install @runtypelabs/persona"));
+      }
       if (options.printSnippet) {
         console.log(chalk30.cyan("\n--- snippet ---\n"));
         console.log(success2.snippet.code);
       } else {
-        console.log(chalk30.dim("\nUse --print-snippet to print the embed code, or run interactively for copy shortcuts."));
+        console.log(
+          chalk30.dim(
+            "\nUse --print-snippet to print the embed code, or run interactively for copy shortcuts."
+          )
+        );
       }
       return;
     }
-    await runSuccessKeyLoop(success2, apiUrl, targetSelector);
+    try {
+      await runSuccessKeyLoop(
+        success2,
+        apiUrl,
+        targetSelector,
+        demoOutput ? {
+          url: demoOutput.localUrl,
+          filePath: demoOutput.filePath,
+          readmePath: demoOutput.readmePath
+        } : void 0
+      );
+    } finally {
+      await demoServer?.close().catch(() => {
+      });
+    }
   }
 );
 
@@ -65817,7 +66875,7 @@ import chalk32 from "chalk";
 import React23 from "react";
 import { render as render23 } from "ink";
 import { useState as useState40, useEffect as useEffect34 } from "react";
-import open6 from "open";
+import open5 from "open";
 var billingCommand = new Command25("billing").description("View billing and subscription info");
 billingCommand.command("status").description("Show current plan and usage").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (options) => {
   const apiKey = await ensureAuth();
@@ -65920,7 +66978,7 @@ billingCommand.command("portal").description("Open the billing portal in your br
       if (data.url) {
         console.log("Opening billing portal...");
         console.log(data.url);
-        await open6(data.url);
+        await open5(data.url);
       } else {
         console.log("No portal URL returned. You may need to set up billing first.");
       }
@@ -65942,7 +67000,7 @@ billingCommand.command("portal").description("Open the billing portal in your br
         try {
           const data = await client.post("/billing/portal");
           if (data.url) {
-            await open6(data.url);
+            await open5(data.url);
             setMsg("Billing portal opened in browser");
             setSuccess(true);
           } else {
@@ -66792,7 +67850,7 @@ var tailCommand = new Command28("tail").description("Stream live execution logs
 // src/commands/validate-product.ts
 import { Command as Command29, Option } from "commander";
 import chalk36 from "chalk";
-import { readFileSync as readFileSync17 } from "fs";
+import { readFileSync as readFileSync18 } from "fs";
 function createValidateProductCommand() {
   return new Command29("validate-product").description("Validate a product (FPO) or FPO template locally (no API call)").argument(
     "[input]",
@@ -66872,7 +67930,7 @@ async function readInput(input) {
   if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
     return trimmed;
   }
-  return readFileSync17(input, "utf-8");
+  return readFileSync18(input, "utf-8");
 }
 async function readStdin() {
   if (process.stdin.isTTY) {
@@ -66975,7 +68033,7 @@ function printIssues(title, issues, color) {
 import { Command as Command30 } from "commander";
 import chalk37 from "chalk";
 import * as fs16 from "fs";
-import * as path16 from "path";
+import * as path17 from "path";
 import { RuntypeApiError as RuntypeApiError4 } from "@runtypelabs/sdk";
 function bashSingleQuote(s) {
   return "'" + s.replace(/'/g, "'\\''") + "'";
@@ -67945,8 +69003,8 @@ var deployCommand = new Command30("deploy").description("Export an agent or flow
     const apiKey = await ensureAuth();
     if (!apiKey) return;
     const client = createCliClient(apiKey);
-    const outDir = path16.resolve(options.output);
-    const projectName = options.name ?? slugify2(path16.basename(outDir));
+    const outDir = path17.resolve(options.output);
+    const projectName = options.name ?? slugify2(path17.basename(outDir));
     console.log(chalk37.cyan(`
 Scaffolding ${target} deployment to ${outDir}
 `));
@@ -68011,18 +69069,18 @@ Scaffolding ${target} deployment to ${outDir}
       }
       slugSet.add(slug);
     }
-    fs16.mkdirSync(path16.join(outDir, "agents"), { recursive: true });
-    fs16.mkdirSync(path16.join(outDir, "packages"), { recursive: true });
+    fs16.mkdirSync(path17.join(outDir, "agents"), { recursive: true });
+    fs16.mkdirSync(path17.join(outDir, "packages"), { recursive: true });
     for (const { name, def } of agentDefs) {
       const filename = `${slugify2(name)}.json`;
-      fs16.writeFileSync(path16.join(outDir, "agents", filename), JSON.stringify(def, null, 2));
+      fs16.writeFileSync(path17.join(outDir, "agents", filename), JSON.stringify(def, null, 2));
       console.log(`  Wrote agents/${filename}`);
     }
     const agentNames = agentDefs.map((a) => a.name);
     let monorepoRoot = process.cwd();
     for (let i = 0; i < 8; i++) {
-      if (fs16.existsSync(path16.join(monorepoRoot, "pnpm-workspace.yaml"))) break;
-      const parent = path16.dirname(monorepoRoot);
+      if (fs16.existsSync(path17.join(monorepoRoot, "pnpm-workspace.yaml"))) break;
+      const parent = path17.dirname(monorepoRoot);
       if (parent === monorepoRoot) break;
       monorepoRoot = parent;
     }
@@ -68032,35 +69090,35 @@ Scaffolding ${target} deployment to ${outDir}
     }
     const secretNames = Array.from(allSecrets);
     if (target === "cloudflare") {
-      fs16.mkdirSync(path16.join(outDir, "src"), { recursive: true });
-      fs16.writeFileSync(path16.join(outDir, "src", "index.ts"), workerIndexTs(agentSlugs));
-      fs16.writeFileSync(path16.join(outDir, "wrangler.toml"), wranglerToml(projectName));
-      fs16.writeFileSync(path16.join(outDir, "package.json"), workerPackageJson(projectName, "workspace:*"));
-      fs16.writeFileSync(path16.join(outDir, "tsconfig.json"), workerTsconfigJson());
-      const setupPath = path16.join(outDir, "setup.sh");
+      fs16.mkdirSync(path17.join(outDir, "src"), { recursive: true });
+      fs16.writeFileSync(path17.join(outDir, "src", "index.ts"), workerIndexTs(agentSlugs));
+      fs16.writeFileSync(path17.join(outDir, "wrangler.toml"), wranglerToml(projectName));
+      fs16.writeFileSync(path17.join(outDir, "package.json"), workerPackageJson(projectName, "workspace:*"));
+      fs16.writeFileSync(path17.join(outDir, "tsconfig.json"), workerTsconfigJson());
+      const setupPath = path17.join(outDir, "setup.sh");
       fs16.writeFileSync(setupPath, workerSetupSh(monorepoRoot));
       fs16.chmodSync(setupPath, 493);
-      fs16.writeFileSync(path16.join(outDir, "README.md"), workerReadme(agentNames, secretNames));
+      fs16.writeFileSync(path17.join(outDir, "README.md"), workerReadme(agentNames, secretNames));
     } else if (target === "vercel") {
-      fs16.mkdirSync(path16.join(outDir, "api"), { recursive: true });
-      fs16.writeFileSync(path16.join(outDir, "api", "[[...route]].ts"), vercelRouteTs(agentSlugs));
-      fs16.writeFileSync(path16.join(outDir, "vercel.json"), vercelJson());
-      fs16.writeFileSync(path16.join(outDir, "package.json"), vercelPackageJson(projectName, "workspace:*"));
-      fs16.writeFileSync(path16.join(outDir, "tsconfig.json"), vercelTsconfigJson());
-      const setupPath = path16.join(outDir, "setup.sh");
+      fs16.mkdirSync(path17.join(outDir, "api"), { recursive: true });
+      fs16.writeFileSync(path17.join(outDir, "api", "[[...route]].ts"), vercelRouteTs(agentSlugs));
+      fs16.writeFileSync(path17.join(outDir, "vercel.json"), vercelJson());
+      fs16.writeFileSync(path17.join(outDir, "package.json"), vercelPackageJson(projectName, "workspace:*"));
+      fs16.writeFileSync(path17.join(outDir, "tsconfig.json"), vercelTsconfigJson());
+      const setupPath = path17.join(outDir, "setup.sh");
       fs16.writeFileSync(setupPath, vercelSetupSh(monorepoRoot));
       fs16.chmodSync(setupPath, 493);
-      fs16.writeFileSync(path16.join(outDir, "README.md"), vercelReadme(agentNames, secretNames));
+      fs16.writeFileSync(path17.join(outDir, "README.md"), vercelReadme(agentNames, secretNames));
     } else {
-      fs16.writeFileSync(path16.join(outDir, "server.ts"), serverTs());
-      fs16.writeFileSync(path16.join(outDir, "Dockerfile"), dockerfile());
-      fs16.writeFileSync(path16.join(outDir, ".dockerignore"), dockerignore());
-      fs16.writeFileSync(path16.join(outDir, "tsconfig.json"), tsconfigJson());
-      fs16.writeFileSync(path16.join(outDir, "package.json"), packageJson(projectName, "workspace:*"));
-      const setupPath = path16.join(outDir, "setup.sh");
+      fs16.writeFileSync(path17.join(outDir, "server.ts"), serverTs());
+      fs16.writeFileSync(path17.join(outDir, "Dockerfile"), dockerfile());
+      fs16.writeFileSync(path17.join(outDir, ".dockerignore"), dockerignore());
+      fs16.writeFileSync(path17.join(outDir, "tsconfig.json"), tsconfigJson());
+      fs16.writeFileSync(path17.join(outDir, "package.json"), packageJson(projectName, "workspace:*"));
+      const setupPath = path17.join(outDir, "setup.sh");
       fs16.writeFileSync(setupPath, setupSh(monorepoRoot));
       fs16.chmodSync(setupPath, 493);
-      fs16.writeFileSync(path16.join(outDir, "README.md"), readme(agentNames, secretNames));
+      fs16.writeFileSync(path17.join(outDir, "README.md"), readme(agentNames, secretNames));
     }
     console.log("");
     console.log(chalk37.green(`\u2713 Scaffold written to ${outDir}`));
@@ -68118,19 +69176,19 @@ import { Command as Command31 } from "commander";
 import chalk39 from "chalk";
 
 // src/lib/skills-install.ts
-import { mkdirSync as mkdirSync9, readFileSync as readFileSync18, writeFileSync as writeFileSync7 } from "fs";
-import path17 from "path";
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync19, writeFileSync as writeFileSync8 } from "fs";
+import path18 from "path";
 import readline4 from "readline";
 import chalk38 from "chalk";
 var SKILLS_REPO = "runtypelabs/skills";
 var SKILLS_INSTALL_RETRY_HINT = "Retry with `runtype skills install`, or install manually: npx skills add runtypelabs/skills";
 var METADATA_FILENAME = "agents-skills-install.json";
 function metadataPath() {
-  return path17.join(getRuntypeHomeDir(), METADATA_FILENAME);
+  return path18.join(getRuntypeHomeDir(), METADATA_FILENAME);
 }
 function readSkillsInstallMetadata() {
   try {
-    const raw = readFileSync18(metadataPath(), "utf8");
+    const raw = readFileSync19(metadataPath(), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) && parsed.version === 1 && typeof parsed.accepted === "boolean") {
       return parsed;
@@ -68142,8 +69200,8 @@ function readSkillsInstallMetadata() {
 }
 function writeSkillsInstallMetadata(metadata) {
   try {
-    mkdirSync9(path17.dirname(metadataPath()), { recursive: true });
-    writeFileSync7(metadataPath(), JSON.stringify(metadata, null, 2));
+    mkdirSync10(path18.dirname(metadataPath()), { recursive: true });
+    writeFileSync8(metadataPath(), JSON.stringify(metadata, null, 2));
   } catch {
   }
 }
@@ -68399,7 +69457,7 @@ skillsCommand.command("install").description(`Install Runtype skills (${SKILLS_R
 );
 
 // src/commands/apps.ts
-import { readdirSync as readdirSync6, readFileSync as readFileSync19, lstatSync, statSync as statSync7, existsSync as existsSync14 } from "fs";
+import { readdirSync as readdirSync6, readFileSync as readFileSync20, lstatSync, statSync as statSync7, existsSync as existsSync15 } from "fs";
 import { join as join12, relative as relative5 } from "path";
 import { Command as Command32 } from "commander";
 import chalk40 from "chalk";
@@ -68420,7 +69478,7 @@ function collectBundleFiles(dir) {
         if (entry === "node_modules") continue;
         walk(full);
       } else {
-        zippable[relative5(dir, full).split("\\").join("/")] = readFileSync19(full);
+        zippable[relative5(dir, full).split("\\").join("/")] = readFileSync20(full);
       }
     }
   };
@@ -68501,7 +69559,7 @@ appsCommand.command("deploy <dir>").description("Zip a bundle directory, upload
     const jsonMode = !!(options.json ?? globals.json);
     const apiKey = await ensureAuth();
     if (!apiKey) return;
-    if (!existsSync14(dir) || !statSync7(dir).isDirectory()) {
+    if (!existsSync15(dir) || !statSync7(dir).isDirectory()) {
       fail(`Not a directory: ${dir}`, jsonMode, "INVALID_DIR");
     }
     let bundleFiles = {};