@wayai/cli 0.3.89 → 0.3.90

package/dist/index.js

@@ -165,11 +165,11 @@ function captureException2(error, context) {
     Sentry.captureException(error);
   });
 }
-function addApiBreadcrumb(method, path26) {
+function addApiBreadcrumb(method, path27) {
   if (!initialized) return;
   Sentry.addBreadcrumb({
     category: "http",
-    message: `${method} ${path26}`,
+    message: `${method} ${path27}`,
     level: "info"
   });
 }
@@ -231,9 +231,9 @@ var init_api_client = __esm({
     ApiError = class extends Error {
       status;
       body;
-      constructor(method, path26, status, body) {
+      constructor(method, path27, status, body) {
         const safeBody = redactSecrets(body);
-        super(`API request failed: ${method} ${path26} (${status}): ${safeBody}`);
+        super(`API request failed: ${method} ${path27} (${status}): ${safeBody}`);
         this.name = "ApiError";
         this.status = status;
         this.body = safeBody;
@@ -376,8 +376,8 @@ var init_api_client = __esm({
           ...organizationId && { organization_id: organizationId }
         });
       }
-      async lookup(path26, opts) {
-        const params = new URLSearchParams({ path: path26 });
+      async lookup(path27, opts) {
+        const params = new URLSearchParams({ path: path27 });
         if (opts?.organizationId) params.set("organization_id", opts.organizationId);
         return this.request("GET", `/api/ci/lookup?${params.toString()}`);
       }
@@ -765,9 +765,9 @@ var init_api_client = __esm({
        * sandbox for this conversation, or the blob was purged).
        */
       async downloadArchiveSandboxFs(hubId, conversationId) {
-        const path26 = `/api/archive/${encodeURIComponent(hubId)}/conversations/${encodeURIComponent(conversationId)}/sandbox`;
-        addApiBreadcrumb("GET", path26);
-        const url = `${this.apiUrl}${path26}`;
+        const path27 = `/api/archive/${encodeURIComponent(hubId)}/conversations/${encodeURIComponent(conversationId)}/sandbox`;
+        addApiBreadcrumb("GET", path27);
+        const url = `${this.apiUrl}${path27}`;
         let response = await this.send(url, "GET");
         if (response.status === 401 && this.onUnauthorized) {
           let refreshed;
@@ -781,7 +781,7 @@ var init_api_client = __esm({
           }
         }
         if (!response.ok) {
-          throw new ApiError("GET", path26, response.status, await response.text());
+          throw new ApiError("GET", path27, response.status, await response.text());
         }
         return new Uint8Array(await response.arrayBuffer());
       }
@@ -821,9 +821,9 @@ var init_api_client = __esm({
           `/api/admin/data-explorer/debug/observability/${encodeURIComponent(hubId)}/conversations/${encodeURIComponent(conversationId)}${qs}`
         );
       }
-      async request(method, path26, body) {
-        addApiBreadcrumb(method, path26);
-        const url = `${this.apiUrl}${path26}`;
+      async request(method, path27, body) {
+        addApiBreadcrumb(method, path27);
+        const url = `${this.apiUrl}${path27}`;
         let refreshedOn401 = false;
         for (let retry = 0; ; retry++) {
           let response = await this.send(url, method, body);
@@ -847,7 +847,7 @@ var init_api_client = __esm({
             await delay(RETRYABLE_BACKOFF_MS[retry]);
             continue;
           }
-          throw new ApiError(method, path26, response.status, errorBody);
+          throw new ApiError(method, path27, response.status, errorBody);
         }
       }
       /** Issue a single authenticated request with the client's current token. */
@@ -1282,8 +1282,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path26, errorMaps, issueData } = params;
-      const fullPath = [...path26, ...issueData.path || []];
+      const { data, path: path27, errorMaps, issueData } = params;
+      const fullPath = [...path27, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -1594,11 +1594,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path26, key) {
+      constructor(parent, value, path27, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path26;
+        this._path = path27;
         this._key = key;
       }
       get path() {
@@ -5052,12 +5052,12 @@ function typeMatches(typeField, allowed) {
   if (Array.isArray(typeField)) return typeField.every((t) => typeof t === "string" && allowed.has(t));
   return false;
 }
-function validateSchema(schema, path26, errors, opts = {}) {
+function validateSchema(schema, path27, errors, opts = {}) {
   if (typeof schema === "boolean") return;
   const depth = opts.depth ?? 0;
   if (depth > MAX_SCHEMA_DEPTH) {
     errors.push({
-      path: path26 || "<root>",
+      path: path27 || "<root>",
       message: `schema nesting exceeds ${MAX_SCHEMA_DEPTH} levels`,
       suggestion: "Flatten the schema; LLM providers reject deeply nested tool input_schemas."
     });
@@ -5065,7 +5065,7 @@ function validateSchema(schema, path26, errors, opts = {}) {
   }
   if (!isRecord(schema)) {
     errors.push({
-      path: path26,
+      path: path27,
       message: `expected object, got ${schema === null ? "null" : typeof schema}`
     });
     return;
@@ -5073,14 +5073,14 @@ function validateSchema(schema, path26, errors, opts = {}) {
   if (opts.isRoot) {
     if ("type" in schema && schema.type !== "object") {
       errors.push({
-        path: path26 ? `${path26}.type` : "type",
+        path: path27 ? `${path27}.type` : "type",
         message: `root type must be 'object', got ${JSON.stringify(schema.type)}`,
         suggestion: "Tool parameters at the root must be an object: `{ type: 'object', properties: { ... } }`."
       });
     }
   } else if ("type" in schema && !typeMatches(schema.type, ALLOWED_TYPES)) {
     errors.push({
-      path: `${path26}.type`,
+      path: `${path27}.type`,
       message: `type must be one of ${[...ALLOWED_TYPES].join("/")} or an array of those, got ${JSON.stringify(schema.type)}`
     });
   }
@@ -5089,25 +5089,25 @@ function validateSchema(schema, path26, errors, opts = {}) {
     if (typeof e === "string") {
       const isPlaceholder = PLACEHOLDER_TOKENS.includes(e);
       errors.push({
-        path: `${path26}.enum`,
+        path: `${path27}.enum`,
         message: `enum must be a non-empty array of primitives, got string ${JSON.stringify(e)}`,
         suggestion: isPlaceholder ? "Set `operation: 'update_kanban_status'` on the tool and ensure at least one hub.kanban_status has `allowsAgentUpdate: true` so the platform can render the placeholder into a valid array." : 'Wrap the value in an array: `enum: ["value"]`.'
       });
     } else if (!Array.isArray(e)) {
       errors.push({
-        path: `${path26}.enum`,
+        path: `${path27}.enum`,
         message: `enum must be a non-empty array of primitives, got ${typeof e}`
       });
     } else if (e.length === 0) {
       errors.push({
-        path: `${path26}.enum`,
+        path: `${path27}.enum`,
         message: "enum must not be empty"
       });
     } else {
       for (let i = 0; i < e.length; i++) {
         if (!isPrimitive(e[i])) {
           errors.push({
-            path: `${path26}.enum[${i}]`,
+            path: `${path27}.enum[${i}]`,
             message: `enum entry must be a primitive (string/number/boolean/null), got ${typeof e[i]}`
           });
         }
@@ -5117,7 +5117,7 @@ function validateSchema(schema, path26, errors, opts = {}) {
   for (const key of ["exclusiveMinimum", "exclusiveMaximum"]) {
     if (key in schema && typeof schema[key] === "boolean") {
       errors.push({
-        path: `${path26}.${key}`,
+        path: `${path27}.${key}`,
         message: `${key} as boolean is draft-04 syntax; draft 2020-12 requires a numeric value`,
         suggestion: `Replace with the numeric bound, e.g. \`${key}: 0\`.`
       });
@@ -5126,45 +5126,45 @@ function validateSchema(schema, path26, errors, opts = {}) {
   if ("properties" in schema) {
     if (!isRecord(schema.properties)) {
       errors.push({
-        path: `${path26}.properties`,
+        path: `${path27}.properties`,
         message: `properties must be an object, got ${Array.isArray(schema.properties) ? "array" : typeof schema.properties}`
       });
     } else {
       for (const [propName, propSchema] of Object.entries(schema.properties)) {
-        validateSchema(propSchema, `${path26}.properties.${propName}`, errors, { depth: depth + 1 });
+        validateSchema(propSchema, `${path27}.properties.${propName}`, errors, { depth: depth + 1 });
       }
     }
   }
   if (schemaTypeIncludes(schema, "array") && "items" in schema) {
     if (Array.isArray(schema.items)) {
-      schema.items.forEach((sub, i) => validateSchema(sub, `${path26}.items[${i}]`, errors, { depth: depth + 1 }));
+      schema.items.forEach((sub, i) => validateSchema(sub, `${path27}.items[${i}]`, errors, { depth: depth + 1 }));
     } else {
-      validateSchema(schema.items, `${path26}.items`, errors, { depth: depth + 1 });
+      validateSchema(schema.items, `${path27}.items`, errors, { depth: depth + 1 });
     }
   }
   for (const key of SUBSCHEMA_OBJECT_KEYWORDS) {
     if (key in schema && isRecord(schema[key])) {
-      validateSchema(schema[key], `${path26}.${key}`, errors, { depth: depth + 1 });
+      validateSchema(schema[key], `${path27}.${key}`, errors, { depth: depth + 1 });
     }
   }
   for (const key of SUBSCHEMA_LIST_KEYWORDS) {
     const list = schema[key];
     if (Array.isArray(list)) {
-      list.forEach((sub, i) => validateSchema(sub, `${path26}.${key}[${i}]`, errors, { depth: depth + 1 }));
+      list.forEach((sub, i) => validateSchema(sub, `${path27}.${key}[${i}]`, errors, { depth: depth + 1 }));
     }
   }
   for (const key of SUBSCHEMA_MAP_KEYWORDS) {
     const map = schema[key];
     if (isRecord(map)) {
       for (const [name, sub] of Object.entries(map)) {
-        validateSchema(sub, `${path26}.${key}.${name}`, errors, { depth: depth + 1 });
+        validateSchema(sub, `${path27}.${key}.${name}`, errors, { depth: depth + 1 });
       }
     }
   }
   const reportedPaths = new Set(errors.map((e) => e.path));
   for (const [k, v] of Object.entries(schema)) {
     if (typeof v !== "string") continue;
-    const fieldPath = `${path26}.${k}`;
+    const fieldPath = `${path27}.${k}`;
     if (reportedPaths.has(fieldPath)) continue;
     for (const token of PLACEHOLDER_TOKENS) {
       if (v === token) {
@@ -5320,10 +5320,10 @@ function refineHubAsCodeLanes(config, ctx) {
     }
   }
 }
-function isSafeTemplatePath(path26) {
-  if (path26.length === 0 || path26.length > 300) return false;
-  if (path26.startsWith("/") || path26.includes("\\")) return false;
-  const segments = path26.split("/");
+function isSafeTemplatePath(path27) {
+  if (path27.length === 0 || path27.length > 300) return false;
+  if (path27.startsWith("/") || path27.includes("\\")) return false;
+  const segments = path27.split("/");
   return segments.every(
     (seg) => seg.length > 0 && seg !== "." && seg !== ".." && /^[A-Za-z0-9._-]+$/.test(seg)
   );
@@ -8795,9 +8795,9 @@ function getVersionCachePath(filename = CLI_CACHE_FILE) {
 }
 function readVersionCache(filename = CLI_CACHE_FILE) {
   try {
-    const path26 = getVersionCachePath(filename);
-    if (!existsSync4(path26)) return null;
-    const parsed = JSON.parse(readFileSync5(path26, "utf-8"));
+    const path27 = getVersionCachePath(filename);
+    if (!existsSync4(path27)) return null;
+    const parsed = JSON.parse(readFileSync5(path27, "utf-8"));
     if (typeof parsed.lastCheck !== "number") return null;
     if (parsed.latest !== null && typeof parsed.latest !== "string") return null;
     return parsed;
@@ -8817,10 +8817,10 @@ function isVersionCacheStale(filename = CLI_CACHE_FILE, maxAgeMs = MAX_AGE_24H_M
   return Date.now() - cache.lastCheck > maxAgeMs;
 }
 function writeVersionCache(filename, cache) {
-  const path26 = getVersionCachePath(filename);
-  const dir = dirname3(path26);
+  const path27 = getVersionCachePath(filename);
+  const dir = dirname3(path27);
   if (!existsSync4(dir)) mkdirSync(dir, { recursive: true });
-  writeFileSync2(path26, JSON.stringify(cache));
+  writeFileSync2(path27, JSON.stringify(cache));
 }
 function touchVersionCache(filename) {
   writeVersionCache(filename, { lastCheck: Date.now(), latest: readVersionCache(filename)?.latest ?? null });
@@ -8859,14 +8859,14 @@ function parseFrontmatterVersion(content) {
 function findInstalledSkills(projectRoot, paths = SKILL_INSTALL_PATHS) {
   const found = [];
   for (const rel of paths) {
-    const path26 = join7(projectRoot, rel);
-    if (!existsSync5(path26)) continue;
+    const path27 = join7(projectRoot, rel);
+    if (!existsSync5(path27)) continue;
     let version = null;
     try {
-      version = parseFrontmatterVersion(readFileSync6(path26, "utf-8"));
+      version = parseFrontmatterVersion(readFileSync6(path27, "utf-8"));
     } catch {
     }
-    found.push({ path: path26, version });
+    found.push({ path: path27, version });
   }
   return found;
 }
@@ -10099,6 +10099,85 @@ var init_constants = __esm({
   }
 });
 
+// src/lib/workspace-files.ts
+import * as fs8 from "fs";
+import * as path9 from "path";
+function perHubAgentsMd(hubFolderName) {
+  return [
+    `# ${hubFolderName}`,
+    "",
+    "Notes about THIS hub that the config files (hub.yaml, agents/) don't capture:",
+    "why it exists, key decisions and the reasons behind them, business rules that",
+    "only apply here, terminology, integration quirks.",
+    "",
+    "Keep it short and about *why / what is different* \u2014 platform mechanics live in",
+    "the WayAI skill. Fill this in as you learn about the hub; delete this",
+    "placeholder once you do.",
+    ""
+  ].join("\n");
+}
+function isWorkspace(gitRoot) {
+  if (fs8.existsSync(path9.join(gitRoot, ".wayai.yaml"))) return true;
+  return isDirectory(resolveLayout(gitRoot).hubsDir);
+}
+function writeIfAbsent(filePath, content) {
+  if (fs8.existsSync(filePath)) return null;
+  fs8.writeFileSync(filePath, content, "utf-8");
+  return path9.basename(filePath);
+}
+function ensureWorkspaceFiles(gitRoot) {
+  if (!isWorkspace(gitRoot)) return [];
+  const created = [];
+  const agents = writeIfAbsent(path9.join(gitRoot, "AGENTS.md"), ROOT_AGENTS_MD);
+  if (agents) created.push(agents);
+  const claude = writeIfAbsent(path9.join(gitRoot, "CLAUDE.md"), CLAUDE_MD_SHIM);
+  if (claude) created.push(claude);
+  return created;
+}
+var REKOR_SKILL_INSTALL_COMMAND, CLAUDE_MD_SHIM, ROOT_AGENTS_MD;
+var init_workspace_files = __esm({
+  "src/lib/workspace-files.ts"() {
+    "use strict";
+    init_constants();
+    init_layout();
+    REKOR_SKILL_INSTALL_COMMAND = SKILL_INSTALL_COMMAND.replace(
+      "wayai-pro/wayai-skill",
+      "wayai-pro/rekor-skill"
+    );
+    CLAUDE_MD_SHIM = "@AGENTS.md\n";
+    ROOT_AGENTS_MD = [
+      "# Working with WayAI and Rekor",
+      "",
+      "WayAI is the layer that talks to people across channels; Rekor is the data",
+      "layer (system of record) behind it. They are used together.",
+      "",
+      "## At the start of every session",
+      "",
+      "1. Check for updates first. Make sure both skills and both CLIs are current,",
+      "   and update whatever is not:",
+      `   - WayAI skill: \`wayai status\` \u2192 if newer, \`${SKILL_INSTALL_COMMAND}\``,
+      `   - Rekor skill: \`rekor status\` \u2192 if newer, \`${REKOR_SKILL_INSTALL_COMMAND}\``,
+      "   - CLIs: `wayai update` and `rekor update`",
+      "2. Load both the WayAI and Rekor skills at the start of every session \u2014 every",
+      "   time, even for a quick task. They hold the real instructions for everything",
+      "   else.",
+      "",
+      "More detail if you need it:",
+      "- WayAI: https://www.wayai.pro/docs/get-started",
+      "- Rekor: https://rekor.pro/en/docs/get-started",
+      "",
+      "## When helping the person you are working with",
+      "",
+      "- They may be new to WayAI and Rekor \u2014 use plain language, not jargon.",
+      "- Don't explain things they didn't ask about. Only if they seem stuck or ask",
+      "  what something means, give a one-line answer, then move on \u2014 don't turn",
+      "  replies into tutorials.",
+      "- Keep answers short and to the point.",
+      ""
+    ].join("\n");
+  }
+});
+
 // src/commands/init.ts
 var init_exports = {};
 __export(init_exports, {
@@ -10108,12 +10187,12 @@ __export(init_exports, {
   parseArgs: () => parseArgs3
 });
 import { mkdirSync as mkdirSync5 } from "fs";
-import path9 from "path";
+import path10 from "path";
 function ensureHubsDir(gitRoot) {
   const hubsDir = resolveLayout(gitRoot).hubsDir;
   if (isDirectory(hubsDir)) return null;
   mkdirSync5(hubsDir, { recursive: true });
-  return `${path9.relative(gitRoot, hubsDir)}/`;
+  return `${path10.relative(gitRoot, hubsDir)}/`;
 }
 function parseArgs3(args2) {
   let orgId;
@@ -10156,6 +10235,9 @@ async function initCommand(args2) {
     if (createdDir) {
       console.log(`Created ${createdDir}`);
     }
+    for (const file of ensureWorkspaceFiles(gitRoot)) {
+      console.log(`Created ${file}`);
+    }
   }
   console.log(
     `Run \`${SKILL_INSTALL_CMD}\` to install the WayAI skill in your AI harness, then \`wayai pull\` to fetch hub configuration.`
@@ -10236,6 +10318,7 @@ var init_init = __esm({
     init_repo_config();
     init_workspace();
     init_layout();
+    init_workspace_files();
     init_utils();
     init_constants();
     SKILL_INSTALL_CMD = SKILL_INSTALL_COMMAND;
@@ -10243,8 +10326,8 @@ var init_init = __esm({
 });
 
 // src/lib/resource-files.ts
-import * as fs8 from "fs";
-import * as path10 from "path";
+import * as fs9 from "fs";
+import * as path11 from "path";
 import * as crypto3 from "crypto";
 function isBinaryFile(filename) {
   const ext = filename.split(".").pop()?.toLowerCase() || "";
@@ -10290,14 +10373,14 @@ function computeHash(data) {
 }
 function scanResourceFiles(dir, prefix = "") {
   const files = [];
-  const entries = fs8.readdirSync(dir, { withFileTypes: true });
+  const entries = fs9.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
     const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
     if (entry.isDirectory()) {
-      files.push(...scanResourceFiles(path10.join(dir, entry.name), relPath));
+      files.push(...scanResourceFiles(path11.join(dir, entry.name), relPath));
     } else if (entry.isFile()) {
-      const fullPath = path10.join(dir, entry.name);
-      const stat = fs8.statSync(fullPath);
+      const fullPath = path11.join(dir, entry.name);
+      const stat = fs9.statSync(fullPath);
       if (stat.size > MAX_RESOURCE_FILE_SIZE2) {
         console.warn(`  Warning: skipping ${relPath} (${(stat.size / 1024 / 1024).toFixed(1)}MB exceeds 10MB limit)`);
         continue;
@@ -10307,7 +10390,7 @@ function scanResourceFiles(dir, prefix = "") {
         mime_type: guessMimeType(entry.name),
         file_size: stat.size
       };
-      const data = fs8.readFileSync(fullPath);
+      const data = fs9.readFileSync(fullPath);
       fileEntry.hash = computeHash(data);
       if (isBinaryFile(entry.name)) {
         fileEntry.content_base64 = data.toString("base64");
@@ -10321,37 +10404,37 @@ function scanResourceFiles(dir, prefix = "") {
 }
 function writeResourceFileTree(resDir, files) {
   if (files.length === 0) {
-    if (fs8.existsSync(resDir)) cleanOrphanFiles(resDir, "", /* @__PURE__ */ new Set());
+    if (fs9.existsSync(resDir)) cleanOrphanFiles(resDir, "", /* @__PURE__ */ new Set());
     return;
   }
   const writtenPaths = /* @__PURE__ */ new Set();
   for (const file of files) {
-    const filePath = path10.join(resDir, file.path);
-    if (!filePath.startsWith(resDir + path10.sep) && filePath !== resDir) {
+    const filePath = path11.join(resDir, file.path);
+    if (!filePath.startsWith(resDir + path11.sep) && filePath !== resDir) {
       console.warn(`  Warning: skipping ${file.path} (path traversal detected)`);
       continue;
     }
-    const fileDir = path10.dirname(filePath);
-    if (!fs8.existsSync(fileDir)) fs8.mkdirSync(fileDir, { recursive: true });
+    const fileDir = path11.dirname(filePath);
+    if (!fs9.existsSync(fileDir)) fs9.mkdirSync(fileDir, { recursive: true });
     writtenPaths.add(file.path);
     if (file.content !== void 0) {
-      fs8.writeFileSync(filePath, file.content, "utf-8");
+      fs9.writeFileSync(filePath, file.content, "utf-8");
     } else if (file.content_base64) {
-      fs8.writeFileSync(filePath, Buffer.from(file.content_base64, "base64"));
+      fs9.writeFileSync(filePath, Buffer.from(file.content_base64, "base64"));
     }
   }
-  if (fs8.existsSync(resDir)) cleanOrphanFiles(resDir, "", writtenPaths);
+  if (fs9.existsSync(resDir)) cleanOrphanFiles(resDir, "", writtenPaths);
 }
 function cleanOrphanFiles(dir, prefix, writtenPaths) {
-  const entries = fs8.readdirSync(dir, { withFileTypes: true });
+  const entries = fs9.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
     const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
-    const fullPath = path10.join(dir, entry.name);
+    const fullPath = path11.join(dir, entry.name);
     if (entry.isDirectory()) {
       cleanOrphanFiles(fullPath, relPath, writtenPaths);
-      if (fs8.readdirSync(fullPath).length === 0) fs8.rmdirSync(fullPath);
+      if (fs9.readdirSync(fullPath).length === 0) fs9.rmdirSync(fullPath);
     } else if (!writtenPaths.has(relPath)) {
-      fs8.unlinkSync(fullPath);
+      fs9.unlinkSync(fullPath);
     }
   }
 }
@@ -10360,8 +10443,8 @@ async function downloadBinaryFiles(resDir, files) {
   for (const file of files) {
     if (!file.download_url || file.content !== void 0) continue;
     try {
-      const filePath = path10.join(resDir, file.path);
-      if (!filePath.startsWith(resDir + path10.sep) && filePath !== resDir) {
+      const filePath = path11.join(resDir, file.path);
+      if (!filePath.startsWith(resDir + path11.sep) && filePath !== resDir) {
         console.warn(`  Warning: skipping ${file.path} (path traversal detected)`);
         continue;
       }
@@ -10371,9 +10454,9 @@ async function downloadBinaryFiles(resDir, files) {
         continue;
       }
       const buffer = Buffer.from(await response.arrayBuffer());
-      const fileDir = path10.dirname(filePath);
-      if (!fs8.existsSync(fileDir)) fs8.mkdirSync(fileDir, { recursive: true });
-      fs8.writeFileSync(filePath, buffer);
+      const fileDir = path11.dirname(filePath);
+      if (!fs9.existsSync(fileDir)) fs9.mkdirSync(fileDir, { recursive: true });
+      fs9.writeFileSync(filePath, buffer);
       count++;
     } catch (err) {
       console.warn(`  Warning: failed to download ${file.path} (${err instanceof Error ? err.message : String(err)})`);
@@ -10410,8 +10493,8 @@ var init_resource_files = __esm({
 });
 
 // src/lib/yaml-writer.ts
-import * as fs9 from "fs";
-import * as path11 from "path";
+import * as fs10 from "fs";
+import * as path12 from "path";
 import * as yaml4 from "js-yaml";
 function buildEvalYamlObject(evalEntry, slug) {
   const out = {};
@@ -10444,43 +10527,43 @@ function buildEvalYamlObject(evalEntry, slug) {
   }
   return out;
 }
-function writeHubFolder(hubFolder, payload) {
-  const agentsDir = path11.join(hubFolder, "agents");
-  if (!fs9.existsSync(hubFolder)) {
-    fs9.mkdirSync(hubFolder, { recursive: true });
+function writeHubFolder(hubFolder, payload, options = {}) {
+  const agentsDir = path12.join(hubFolder, "agents");
+  if (!fs10.existsSync(hubFolder)) {
+    fs10.mkdirSync(hubFolder, { recursive: true });
   }
-  if (!fs9.existsSync(agentsDir)) {
-    fs9.mkdirSync(agentsDir, { recursive: true });
+  if (!fs10.existsSync(agentsDir)) {
+    fs10.mkdirSync(agentsDir, { recursive: true });
   }
   const yamlPayload = buildYamlPayload(payload);
   const agentFiles = extractAgentFiles(payload);
   const yamlContent = yaml4.dump(yamlPayload, YAML_DUMP_OPTIONS);
-  fs9.writeFileSync(path11.join(hubFolder, "hub.yaml"), yamlContent, "utf-8");
-  const claudeShimPath = path11.join(hubFolder, "CLAUDE.md");
-  if (!fs9.existsSync(claudeShimPath)) {
-    fs9.writeFileSync(claudeShimPath, "@AGENTS.md\n", "utf-8");
+  fs10.writeFileSync(path12.join(hubFolder, "hub.yaml"), yamlContent, "utf-8");
+  if (options.seedAgentContext ?? true) {
+    writeIfAbsent(path12.join(hubFolder, "AGENTS.md"), perHubAgentsMd(path12.basename(hubFolder)));
+    writeIfAbsent(path12.join(hubFolder, "CLAUDE.md"), CLAUDE_MD_SHIM);
   }
-  const oldYamlPath = path11.join(hubFolder, "wayai.yaml");
-  if (fs9.existsSync(oldYamlPath)) {
-    fs9.unlinkSync(oldYamlPath);
+  const oldYamlPath = path12.join(hubFolder, "wayai.yaml");
+  if (fs10.existsSync(oldYamlPath)) {
+    fs10.unlinkSync(oldYamlPath);
   }
   const yamlSlugs = writeAgentYamlFiles(agentsDir, payload.agents || []);
   const mdSlugs = /* @__PURE__ */ new Set();
   for (const { slug, content } of agentFiles) {
     mdSlugs.add(slug);
-    fs9.writeFileSync(path11.join(agentsDir, `${slug}.md`), content, "utf-8");
+    fs10.writeFileSync(path12.join(agentsDir, `${slug}.md`), content, "utf-8");
   }
-  const existingFiles = fs9.readdirSync(agentsDir);
+  const existingFiles = fs10.readdirSync(agentsDir);
   for (const file of existingFiles) {
     if (file.endsWith(".yaml")) {
       const slug = file.slice(0, -5);
       if (!yamlSlugs.has(slug)) {
-        fs9.unlinkSync(path11.join(agentsDir, file));
+        fs10.unlinkSync(path12.join(agentsDir, file));
       }
     } else if (file.endsWith(".md")) {
       const slug = file.slice(0, -3);
       if (!mdSlugs.has(slug)) {
-        fs9.unlinkSync(path11.join(agentsDir, file));
+        fs10.unlinkSync(path12.join(agentsDir, file));
       }
     }
   }
@@ -10491,10 +10574,10 @@ function writeHubFolder(hubFolder, payload) {
 function setPreviewLabelInHubYaml(hubFolder, label) {
   const yamlPath = resolveHubYamlPath(hubFolder);
   if (!yamlPath) return;
-  const obj = yaml4.load(fs9.readFileSync(yamlPath, "utf-8")) ?? {};
+  const obj = yaml4.load(fs10.readFileSync(yamlPath, "utf-8")) ?? {};
   if (label) obj.preview_label = label;
   else delete obj.preview_label;
-  fs9.writeFileSync(yamlPath, yaml4.dump(obj, YAML_DUMP_OPTIONS), "utf-8");
+  fs10.writeFileSync(yamlPath, yaml4.dump(obj, YAML_DUMP_OPTIONS), "utf-8");
 }
 function buildYamlPayload(payload) {
   const result = {
@@ -10540,7 +10623,7 @@ function writeAgentYamlFiles(agentsDir, agents) {
     const entry = { ...agent };
     delete entry.instructions;
     const yamlContent = yaml4.dump(entry, YAML_DUMP_OPTIONS);
-    fs9.writeFileSync(path11.join(agentsDir, `${slug}.yaml`), yamlContent, "utf-8");
+    fs10.writeFileSync(path12.join(agentsDir, `${slug}.yaml`), yamlContent, "utf-8");
   }
   return slugs;
 }
@@ -10557,65 +10640,65 @@ function extractAgentFiles(payload) {
   return files;
 }
 function writeEvalYamlFiles(hubFolder, evals) {
-  const evalsDir = path11.join(hubFolder, "evals");
+  const evalsDir = path12.join(hubFolder, "evals");
   if (evals.length === 0) {
-    if (fs9.existsSync(evalsDir)) {
+    if (fs10.existsSync(evalsDir)) {
       cleanEvalOrphans(evalsDir, /* @__PURE__ */ new Set());
       try {
-        if (fs9.readdirSync(evalsDir).length === 0) fs9.rmdirSync(evalsDir);
+        if (fs10.readdirSync(evalsDir).length === 0) fs10.rmdirSync(evalsDir);
       } catch {
       }
     }
     return;
   }
-  if (!fs9.existsSync(evalsDir)) {
-    fs9.mkdirSync(evalsDir, { recursive: true });
+  if (!fs10.existsSync(evalsDir)) {
+    fs10.mkdirSync(evalsDir, { recursive: true });
   }
   const writtenRelPaths = /* @__PURE__ */ new Set();
   for (const evalEntry of evals) {
     const slug = slugify(evalEntry.name);
     const setName = evalEntry.path && evalEntry.path.trim().length > 0 ? evalEntry.path : null;
     const relPath = setName ? `${setName}/${slug}.yaml` : `${slug}.yaml`;
-    const targetPath = path11.join(evalsDir, relPath);
-    if (!targetPath.startsWith(evalsDir + path11.sep)) {
+    const targetPath = path12.join(evalsDir, relPath);
+    if (!targetPath.startsWith(evalsDir + path12.sep)) {
       console.warn(`  Warning: skipping eval "${evalEntry.name}" (scenario set "${setName}" escapes evals/ \u2014 possible bad backend data)`);
       continue;
     }
     if (setName) {
-      const setDir = path11.join(evalsDir, setName);
-      if (!fs9.existsSync(setDir)) {
-        fs9.mkdirSync(setDir, { recursive: true });
+      const setDir = path12.join(evalsDir, setName);
+      if (!fs10.existsSync(setDir)) {
+        fs10.mkdirSync(setDir, { recursive: true });
       }
     }
     const yamlContent = yaml4.dump(buildEvalYamlObject(evalEntry, slug), YAML_DUMP_OPTIONS);
-    fs9.writeFileSync(targetPath, yamlContent, "utf-8");
+    fs10.writeFileSync(targetPath, yamlContent, "utf-8");
     writtenRelPaths.add(relPath);
   }
   cleanEvalOrphans(evalsDir, writtenRelPaths);
 }
 function cleanEvalOrphans(evalsDir, writtenRelPaths) {
-  const entries = fs9.readdirSync(evalsDir, { withFileTypes: true });
+  const entries = fs10.readdirSync(evalsDir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path11.join(evalsDir, entry.name);
+    const fullPath = path12.join(evalsDir, entry.name);
     if (entry.isFile()) {
       if (entry.name.endsWith(".yaml") && !writtenRelPaths.has(entry.name)) {
-        fs9.unlinkSync(fullPath);
+        fs10.unlinkSync(fullPath);
       }
       continue;
     }
     if (entry.isDirectory()) {
       const setName = entry.name;
-      const subEntries = fs9.readdirSync(fullPath, { withFileTypes: true });
+      const subEntries = fs10.readdirSync(fullPath, { withFileTypes: true });
       for (const sub of subEntries) {
         if (sub.isFile() && sub.name.endsWith(".yaml")) {
           const relPath = `${setName}/${sub.name}`;
           if (!writtenRelPaths.has(relPath)) {
-            fs9.unlinkSync(path11.join(fullPath, sub.name));
+            fs10.unlinkSync(path12.join(fullPath, sub.name));
           }
         }
       }
       try {
-        if (fs9.readdirSync(fullPath).length === 0) fs9.rmdirSync(fullPath);
+        if (fs10.readdirSync(fullPath).length === 0) fs10.rmdirSync(fullPath);
       } catch {
       }
     }
@@ -10651,19 +10734,19 @@ function buildJourneyYamlObject(journeyEntry, slug) {
   return out;
 }
 function writeJourneyYamlFiles(hubFolder, journeys) {
-  const journeysDir = path11.join(hubFolder, "journeys");
+  const journeysDir = path12.join(hubFolder, "journeys");
   if (journeys.length === 0) {
-    if (fs9.existsSync(journeysDir)) {
+    if (fs10.existsSync(journeysDir)) {
       cleanJourneyOrphans(journeysDir, /* @__PURE__ */ new Set());
       try {
-        if (fs9.readdirSync(journeysDir).length === 0) fs9.rmdirSync(journeysDir);
+        if (fs10.readdirSync(journeysDir).length === 0) fs10.rmdirSync(journeysDir);
       } catch {
       }
     }
     return;
   }
-  if (!fs9.existsSync(journeysDir)) {
-    fs9.mkdirSync(journeysDir, { recursive: true });
+  if (!fs10.existsSync(journeysDir)) {
+    fs10.mkdirSync(journeysDir, { recursive: true });
   }
   const writtenFiles = /* @__PURE__ */ new Set();
   const usedSlugs = /* @__PURE__ */ new Set();
@@ -10671,33 +10754,33 @@ function writeJourneyYamlFiles(hubFolder, journeys) {
     const slug = ensureUniqueSlug(slugify(journeyEntry.name), usedSlugs);
     const fileName = `${slug}.yaml`;
     const yamlContent = yaml4.dump(buildJourneyYamlObject(journeyEntry, slug), YAML_DUMP_OPTIONS);
-    fs9.writeFileSync(path11.join(journeysDir, fileName), yamlContent, "utf-8");
+    fs10.writeFileSync(path12.join(journeysDir, fileName), yamlContent, "utf-8");
     writtenFiles.add(fileName);
   }
   cleanJourneyOrphans(journeysDir, writtenFiles);
 }
 function cleanJourneyOrphans(journeysDir, writtenFiles) {
-  const entries = fs9.readdirSync(journeysDir, { withFileTypes: true });
+  const entries = fs10.readdirSync(journeysDir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isFile() && entry.name.endsWith(".yaml") && !writtenFiles.has(entry.name)) {
-      fs9.unlinkSync(path11.join(journeysDir, entry.name));
+      fs10.unlinkSync(path12.join(journeysDir, entry.name));
     }
   }
 }
 function writeResourceFiles(hubFolder, resources) {
-  const resourcesDir = path11.join(hubFolder, "resources");
+  const resourcesDir = path12.join(hubFolder, "resources");
   const currentSlugs = /* @__PURE__ */ new Set();
   for (const resource of resources) {
     const resSlug = slugify(resource.name);
     currentSlugs.add(resSlug);
-    const resDir = path11.join(resourcesDir, resSlug);
+    const resDir = path12.join(resourcesDir, resSlug);
     writeResourceFileTree(resDir, resource.files || []);
   }
-  if (fs9.existsSync(resourcesDir)) {
-    const existingDirs = fs9.readdirSync(resourcesDir, { withFileTypes: true });
+  if (fs10.existsSync(resourcesDir)) {
+    const existingDirs = fs10.readdirSync(resourcesDir, { withFileTypes: true });
     for (const entry of existingDirs) {
       if (entry.isDirectory() && !currentSlugs.has(entry.name)) {
-        fs9.rmSync(path11.join(resourcesDir, entry.name), { recursive: true, force: true });
+        fs10.rmSync(path12.join(resourcesDir, entry.name), { recursive: true, force: true });
       }
     }
   }
@@ -10709,6 +10792,7 @@ var init_yaml_writer = __esm({
     init_dist();
     init_utils();
     init_resource_files();
+    init_workspace_files();
     YAML_DUMP_OPTIONS = {
       lineWidth: -1,
       // don't wrap lines
@@ -10722,8 +10806,8 @@ var init_yaml_writer = __esm({
 });
 
 // src/lib/parser.ts
-import * as fs10 from "fs";
-import * as path12 from "path";
+import * as fs11 from "fs";
+import * as path13 from "path";
 import * as yaml5 from "js-yaml";
 function expected(message) {
   const err = new Error(message);
@@ -10737,7 +10821,7 @@ function parseHubFolder(hubFolder, opts) {
     err.isExpected = true;
     throw err;
   }
-  const yamlContent = fs10.readFileSync(yamlPath, "utf-8");
+  const yamlContent = fs11.readFileSync(yamlPath, "utf-8");
   let config;
   try {
     config = yaml5.load(yamlContent);
@@ -10772,9 +10856,9 @@ function parseHubFolder(hubFolder, opts) {
     const resolved = { ...agent };
     if (typeof resolved.instructions === "string" && resolved.instructions.endsWith(".md")) {
       const instrValue = resolved.instructions;
-      const instructionsPath = instrValue.startsWith("agents/") ? path12.join(hubFolder, instrValue) : path12.join(hubFolder, "agents", instrValue);
-      if (fs10.existsSync(instructionsPath)) {
-        resolved.instructions = fs10.readFileSync(instructionsPath, "utf-8");
+      const instructionsPath = instrValue.startsWith("agents/") ? path13.join(hubFolder, instrValue) : path13.join(hubFolder, "agents", instrValue);
+      if (fs11.existsSync(instructionsPath)) {
+        resolved.instructions = fs11.readFileSync(instructionsPath, "utf-8");
       } else {
         const err = new Error(
           `Agent instructions file not found: ${instructionsPath} (referenced by agent "${agent.name}")`
@@ -10783,9 +10867,9 @@ function parseHubFolder(hubFolder, opts) {
         throw err;
       }
     } else if (resolved.instructions === void 0 && typeof agent.name === "string") {
-      const conventionPath = path12.join(hubFolder, "agents", `${slugify(agent.name)}.md`);
-      if (fs10.existsSync(conventionPath)) {
-        resolved.instructions = fs10.readFileSync(conventionPath, "utf-8");
+      const conventionPath = path13.join(hubFolder, "agents", `${slugify(agent.name)}.md`);
+      if (fs11.existsSync(conventionPath)) {
+        resolved.instructions = fs11.readFileSync(conventionPath, "utf-8");
       }
     }
     return resolved;
@@ -10835,26 +10919,26 @@ function parseHubFolder(hubFolder, opts) {
   return payload;
 }
 function scanEvalYamlFiles(hubFolder) {
-  const evalsDir = path12.join(hubFolder, "evals");
-  if (!fs10.existsSync(evalsDir)) return [];
+  const evalsDir = path13.join(hubFolder, "evals");
+  if (!fs11.existsSync(evalsDir)) return [];
   const evals = [];
   const seen = /* @__PURE__ */ new Set();
-  const topEntries = fs10.readdirSync(evalsDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  const topEntries = fs11.readdirSync(evalsDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
   for (const entry of topEntries) {
     if (entry.isFile() && entry.name.endsWith(".yaml")) {
-      collectEval(evals, seen, path12.join(evalsDir, entry.name), `evals/${entry.name}`, null);
+      collectEval(evals, seen, path13.join(evalsDir, entry.name), `evals/${entry.name}`, null);
     } else if (entry.isDirectory()) {
       const setName = entry.name;
-      const setDir = path12.join(evalsDir, setName);
-      const setEntries = fs10.readdirSync(setDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+      const setDir = path13.join(evalsDir, setName);
+      const setEntries = fs11.readdirSync(setDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
       for (const sub of setEntries) {
         if (sub.isDirectory()) {
           throw expected(
-            `Nested scenario sets are not supported: ${path12.relative(hubFolder, path12.join(setDir, sub.name))}. Move scenarios up to evals/${setName}/.`
+            `Nested scenario sets are not supported: ${path13.relative(hubFolder, path13.join(setDir, sub.name))}. Move scenarios up to evals/${setName}/.`
           );
         }
         if (sub.isFile() && sub.name.endsWith(".yaml")) {
-          collectEval(evals, seen, path12.join(setDir, sub.name), `evals/${setName}/${sub.name}`, setName);
+          collectEval(evals, seen, path13.join(setDir, sub.name), `evals/${setName}/${sub.name}`, setName);
         }
       }
     }
@@ -10868,14 +10952,14 @@ function collectEval(evals, seen, filePath, relPath, setName) {
   if (seen.has(key)) {
     const where = setName ? `scenario set "${setName}"` : "root";
     throw expected(
-      `Duplicate eval at ${where}: "${evalEntry.name}" (in ${path12.basename(filePath)}). Each (name, scenario set) pair must be unique.`
+      `Duplicate eval at ${where}: "${evalEntry.name}" (in ${path13.basename(filePath)}). Each (name, scenario set) pair must be unique.`
     );
   }
   seen.add(key);
   evals.push(evalEntry);
 }
 function parseEvalYaml(filePath, relPath, setName) {
-  const content = fs10.readFileSync(filePath, "utf-8");
+  const content = fs11.readFileSync(filePath, "utf-8");
   let raw;
   try {
     raw = yaml5.load(content);
@@ -10890,7 +10974,7 @@ function parseEvalYaml(filePath, relPath, setName) {
     return null;
   }
   const data = raw;
-  const fileSlug = path12.basename(filePath, ".yaml");
+  const fileSlug = path13.basename(filePath, ".yaml");
   const evalName = typeof data.name === "string" && data.name.trim().length > 0 ? data.name : fileSlug;
   if (typeof data.agent !== "string" || data.agent.trim().length === 0) {
     throw expected(`Eval "${evalName}" in ${relPath}: missing required field "agent" (string).`);
@@ -10944,19 +11028,19 @@ function parseFixtureField(raw, label, key) {
   return trimmed.length > 0 ? trimmed : void 0;
 }
 function scanJourneyYamlFiles(hubFolder) {
-  const journeysDir = path12.join(hubFolder, "journeys");
-  if (!fs10.existsSync(journeysDir)) return [];
+  const journeysDir = path13.join(hubFolder, "journeys");
+  if (!fs11.existsSync(journeysDir)) return [];
   const journeys = [];
   const seen = /* @__PURE__ */ new Set();
-  const entries = fs10.readdirSync(journeysDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  const entries = fs11.readdirSync(journeysDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
   for (const entry of entries) {
     if (entry.isDirectory()) {
       throw expected(
-        `Subfolders are not supported under journeys/: ${path12.relative(hubFolder, path12.join(journeysDir, entry.name))}. A journey owns its own managed scenario set \u2014 put each journey in a single journeys/<slug>.yaml file.`
+        `Subfolders are not supported under journeys/: ${path13.relative(hubFolder, path13.join(journeysDir, entry.name))}. A journey owns its own managed scenario set \u2014 put each journey in a single journeys/<slug>.yaml file.`
       );
     }
     if (!entry.isFile() || !entry.name.endsWith(".yaml")) continue;
-    const journeyEntry = parseJourneyYaml(path12.join(journeysDir, entry.name), `journeys/${entry.name}`);
+    const journeyEntry = parseJourneyYaml(path13.join(journeysDir, entry.name), `journeys/${entry.name}`);
     if (!journeyEntry) continue;
     if (seen.has(journeyEntry.name)) {
       throw expected(
@@ -10969,7 +11053,7 @@ function scanJourneyYamlFiles(hubFolder) {
   return journeys;
 }
 function parseJourneyYaml(filePath, relPath) {
-  const content = fs10.readFileSync(filePath, "utf-8");
+  const content = fs11.readFileSync(filePath, "utf-8");
   let raw;
   try {
     raw = yaml5.load(content);
@@ -10984,7 +11068,7 @@ function parseJourneyYaml(filePath, relPath) {
     return null;
   }
   const data = raw;
-  const fileSlug = path12.basename(filePath, ".yaml");
+  const fileSlug = path13.basename(filePath, ".yaml");
   const journeyName = typeof data.name === "string" && data.name.trim().length > 0 ? data.name : fileSlug;
   if (typeof data.agent !== "string" || data.agent.trim().length === 0) {
     throw expected(`Journey "${journeyName}" in ${relPath}: missing required field "agent" (string).`);
@@ -11020,14 +11104,14 @@ function parseJourneyYaml(filePath, relPath) {
   return journeyEntry;
 }
 function scanAgentYamlFiles(hubFolder) {
-  const agentsDir = path12.join(hubFolder, "agents");
-  if (!fs10.existsSync(agentsDir)) return [];
-  const yamlFiles = fs10.readdirSync(agentsDir).filter((f) => f.endsWith(".yaml")).sort();
+  const agentsDir = path13.join(hubFolder, "agents");
+  if (!fs11.existsSync(agentsDir)) return [];
+  const yamlFiles = fs11.readdirSync(agentsDir).filter((f) => f.endsWith(".yaml")).sort();
   if (yamlFiles.length === 0) return [];
   const agents = [];
   for (const file of yamlFiles) {
-    const filePath = path12.join(agentsDir, file);
-    const content = fs10.readFileSync(filePath, "utf-8");
+    const filePath = path13.join(agentsDir, file);
+    const content = fs11.readFileSync(filePath, "utf-8");
     let agent;
     try {
       agent = yaml5.load(content);
@@ -11049,7 +11133,7 @@ function scanAgentYamlFiles(hubFolder) {
   return agents;
 }
 function parseResources(hubFolder, configResources) {
-  const resourcesDir = path12.join(hubFolder, "resources");
+  const resourcesDir = path13.join(hubFolder, "resources");
   const results = [];
   for (const res of configResources) {
     const resource = {
@@ -11062,8 +11146,8 @@ function parseResources(hubFolder, configResources) {
     if (res.user_browsable) resource.user_browsable = res.user_browsable;
     if (res.skill_name) resource.skill_name = res.skill_name;
     const resSlug = slugify(resource.name);
-    const resDir = path12.join(resourcesDir, resSlug);
-    if (fs10.existsSync(resDir)) {
+    const resDir = path13.join(resourcesDir, resSlug);
+    if (fs11.existsSync(resDir)) {
       const files = scanResourceFiles(resDir, "");
       if (files.length > 0) {
         resource.files = files;
@@ -11117,8 +11201,8 @@ __export(pull_exports, {
   resolveHubTarget: () => resolveHubTarget,
   writeProductionMirror: () => writeProductionMirror
 });
-import * as fs11 from "fs";
-import * as path13 from "path";
+import * as fs12 from "fs";
+import * as path14 from "path";
 function parseArgs4(args2) {
   let autoConfirm = false;
   let hubSelector;
@@ -11137,7 +11221,7 @@ function resolveHubTarget(workspaceDir, selector) {
   const allHubs = scanWorkspaceHubs(workspaceDir);
   if (selector) {
     const match = allHubs.find(
-      (h) => h.hubId === selector || path13.basename(h.hubFolder) === selector
+      (h) => h.hubId === selector || path14.basename(h.hubFolder) === selector
     );
     if (match) return { hubId: match.hubId, hubFolder: match.hubFolder };
     if (UUID_RE.test(selector)) return { hubId: selector, hubFolder: null };
@@ -11154,7 +11238,7 @@ function resolveHubTarget(workspaceDir, selector) {
   }
   console.error(`Multiple hubs found in ${wsLabel}/. Pass --hub <uuid|folder-name> to choose, or run from inside a hub folder:`);
   for (const h of previewHubs) {
-    console.error(`  ${path13.basename(h.hubFolder)} (${h.hubId})`);
+    console.error(`  ${path14.basename(h.hubFolder)} (${h.hubId})`);
   }
   process.exit(1);
 }
@@ -11167,6 +11251,11 @@ async function pullCommand(args2) {
   const workspaceDir = resolveWorkspaceDir();
   const gitRoot = findGitRoot();
   if (gitRoot) warnLayoutOnce(gitRoot);
+  if (gitRoot) {
+    for (const file of ensureWorkspaceFiles(gitRoot)) {
+      console.error(`Created ${file}`);
+    }
+  }
   const { hubId, hubFolder: existingFolder } = resolveHubTarget(workspaceDir, hubSelector);
   console.log("Fetching hub configuration...");
   const payload = await client.pull(hubId, organizationId);
@@ -11187,7 +11276,7 @@ async function pullCommand(args2) {
       payload.preview_label,
       payload.branch_name
     );
-    fs11.mkdirSync(path13.dirname(hubFolder), { recursive: true });
+    fs12.mkdirSync(path14.dirname(hubFolder), { recursive: true });
     console.log("Writing hub configuration...");
     writeHubFolder(hubFolder, payload);
     await downloadBinaryResourceFiles(hubFolder, payload);
@@ -11248,8 +11337,8 @@ async function pullCommand(args2) {
 }
 async function writeProductionMirror(workspaceDir, prodPayload) {
   const folder = resolveHubFolder(workspaceDir, prodPayload.hub_id, prodPayload.hub.name, "production", null, null);
-  fs11.mkdirSync(path13.dirname(folder), { recursive: true });
-  writeHubFolder(folder, prodPayload);
+  fs12.mkdirSync(path14.dirname(folder), { recursive: true });
+  writeHubFolder(folder, prodPayload, { seedAgentContext: false });
   await downloadBinaryResourceFiles(folder, prodPayload);
   const finalFolder = autoRenameHubFolder(folder, prodPayload.hub.name, "production", prodPayload.hub_id, null, null);
   prependMirrorMarker(finalFolder, prodPayload.hub_id);
@@ -11265,13 +11354,13 @@ async function mirrorLinkedProduction(client, workspaceDir, productionHubId, org
   }
 }
 function prependMirrorMarker(hubFolder, productionHubId) {
-  const hubYaml = path13.join(hubFolder, "hub.yaml");
+  const hubYaml = path14.join(hubFolder, "hub.yaml");
   try {
-    const content = fs11.readFileSync(hubYaml, "utf-8");
+    const content = fs12.readFileSync(hubYaml, "utf-8");
     if (content.startsWith(MIRROR_MARKER_PREFIX)) return;
     const marker = `${MIRROR_MARKER_PREFIX} ${productionHubId}. Edits are ignored; push is blocked. Edit the linked preview hub instead.
 `;
-    fs11.writeFileSync(hubYaml, marker + content, "utf-8");
+    fs12.writeFileSync(hubYaml, marker + content, "utf-8");
   } catch {
   }
 }
@@ -11280,7 +11369,7 @@ async function downloadBinaryResourceFiles(hubFolder, payload) {
   let downloadCount = 0;
   for (const resource of resources) {
     if (!resource.files) continue;
-    const resDir = path13.join(hubFolder, "resources", slugify(resource.name));
+    const resDir = path14.join(hubFolder, "resources", slugify(resource.name));
     downloadCount += await downloadBinaryFiles(resDir, resource.files);
   }
   if (downloadCount > 0) {
@@ -11313,6 +11402,7 @@ var init_pull = __esm({
     init_resource_files();
     init_workspace();
     init_layout();
+    init_workspace_files();
     init_repo_config();
     init_hub_binding();
     MIRROR_MARKER_PREFIX = "# Read-only mirror of production hub";
@@ -11331,8 +11421,8 @@ __export(push_exports, {
   selectExistingHub: () => selectExistingHub,
   shouldWarnIgnoredPreviewLabel: () => shouldWarnIgnoredPreviewLabel
 });
-import * as fs12 from "fs";
-import * as path14 from "path";
+import * as fs13 from "fs";
+import * as path15 from "path";
 import * as yaml6 from "js-yaml";
 function parseArgs5(args2) {
   let autoConfirm = false;
@@ -11416,13 +11506,13 @@ function printWarnings(warnings) {
   }
 }
 async function autoRenameAgentFiles(client, hubId, hubFolder, organizationId) {
-  const agentsDir = path14.join(hubFolder, "agents");
+  const agentsDir = path15.join(hubFolder, "agents");
   let agentsWithIds = [];
-  if (fs12.existsSync(agentsDir)) {
-    const yamlFiles = fs12.readdirSync(agentsDir).filter((f) => f.endsWith(".yaml"));
+  if (fs13.existsSync(agentsDir)) {
+    const yamlFiles = fs13.readdirSync(agentsDir).filter((f) => f.endsWith(".yaml"));
     for (const file of yamlFiles) {
       try {
-        const content = fs12.readFileSync(path14.join(agentsDir, file), "utf-8");
+        const content = fs13.readFileSync(path15.join(agentsDir, file), "utf-8");
         const agent = yaml6.load(content);
         if (agent?.id && agent.name) {
           agentsWithIds.push({ id: agent.id, name: agent.name });
@@ -11435,7 +11525,7 @@ async function autoRenameAgentFiles(client, hubId, hubFolder, organizationId) {
   if (agentsWithIds.length === 0) {
     const yamlPath = resolveHubYamlPath(hubFolder);
     if (!yamlPath) return;
-    const yamlContent = fs12.readFileSync(yamlPath, "utf-8");
+    const yamlContent = fs13.readFileSync(yamlPath, "utf-8");
     const config = yaml6.load(yamlContent);
     agentsWithIds = (config.agents || []).filter((a) => !!a.id && !!a.name);
   }
@@ -11465,18 +11555,18 @@ async function autoRenameAgentFiles(client, hubId, hubFolder, organizationId) {
     }
   }
   if (renames.length === 0) return;
-  if (!fs12.existsSync(agentsDir)) return;
-  for (const file of fs12.readdirSync(agentsDir)) {
+  if (!fs13.existsSync(agentsDir)) return;
+  for (const file of fs13.readdirSync(agentsDir)) {
     if (file.startsWith("__rename_temp_") && (file.endsWith(".md") || file.endsWith(".yaml"))) {
       console.warn(`  Warning: removing orphaned temp file agents/${file}`);
-      fs12.unlinkSync(path14.join(agentsDir, file));
+      fs13.unlinkSync(path15.join(agentsDir, file));
     }
   }
   const renameFileIfExists = (dir, oldName, newName) => {
-    const oldPath = path14.join(dir, oldName);
-    const newPath = path14.join(dir, newName);
-    if (!fs12.existsSync(oldPath)) return false;
-    fs12.renameSync(oldPath, newPath);
+    const oldPath = path15.join(dir, oldName);
+    const newPath = path15.join(dir, newName);
+    if (!fs13.existsSync(oldPath)) return false;
+    fs13.renameSync(oldPath, newPath);
     return true;
   };
   const oldSlugs = new Set(renames.map((r) => r.oldSlug));
@@ -11509,9 +11599,9 @@ async function autoRenameAgentFiles(client, hubId, hubFolder, organizationId) {
     }
   } else {
     for (const { oldSlug, newSlug } of renames) {
-      const hasOldFile = extensions.some((ext) => fs12.existsSync(path14.join(agentsDir, `${oldSlug}${ext}`)));
+      const hasOldFile = extensions.some((ext) => fs13.existsSync(path15.join(agentsDir, `${oldSlug}${ext}`)));
       if (!hasOldFile) continue;
-      const hasNewFile = extensions.some((ext) => fs12.existsSync(path14.join(agentsDir, `${newSlug}${ext}`)));
+      const hasNewFile = extensions.some((ext) => fs13.existsSync(path15.join(agentsDir, `${newSlug}${ext}`)));
       if (hasNewFile) {
         console.warn(`  Warning: skipping rename agents/${oldSlug}.* \u2192 agents/${newSlug}.* (target already exists)`);
         continue;
@@ -11526,7 +11616,7 @@ async function autoRenameAgentFiles(client, hubId, hubFolder, organizationId) {
   if (completedRenames.length === 0) return;
   const mainYamlPath = resolveHubYamlPath(hubFolder);
   if (mainYamlPath) {
-    const mainYamlContent = fs12.readFileSync(mainYamlPath, "utf-8");
+    const mainYamlContent = fs13.readFileSync(mainYamlPath, "utf-8");
     const substitutionMap = /* @__PURE__ */ new Map();
     for (const { oldSlug, newSlug } of completedRenames) {
       substitutionMap.set(`agents/${oldSlug}.md`, `agents/${newSlug}.md`);
@@ -11537,8 +11627,8 @@ async function autoRenameAgentFiles(client, hubId, hubFolder, organizationId) {
       (_match, prefix, pathMatch) => `${prefix}${substitutionMap.get(pathMatch) ?? pathMatch}`
     );
     if (updatedYaml !== mainYamlContent) {
-      fs12.writeFileSync(mainYamlPath, updatedYaml, "utf-8");
-      console.log(`  Updated instructions paths in ${path14.basename(mainYamlPath)}`);
+      fs13.writeFileSync(mainYamlPath, updatedYaml, "utf-8");
+      console.log(`  Updated instructions paths in ${path15.basename(mainYamlPath)}`);
     }
   }
 }
@@ -11599,7 +11689,7 @@ async function pushSingleHub(client, hubId, hubFolder, autoConfirm, organization
 function selectExistingHub(workspaceDir, allHubs, selector, wsLabel) {
   if (selector) {
     const match = allHubs.find(
-      (h) => h.hubId === selector || path14.basename(h.hubFolder) === selector
+      (h) => h.hubId === selector || path15.basename(h.hubFolder) === selector
     );
     if (!match) {
       console.error(`No hub matching --hub ${selector} found in ${wsLabel}/.`);
@@ -11642,7 +11732,7 @@ New hub: "${newHub.hubName}" (${hubType})`);
     process.exit(1);
   }
   console.log(`Hub created: ${createdHub.hub_name} (${hubId})`);
-  const content = fs12.readFileSync(hubYamlPath, "utf-8");
+  const content = fs13.readFileSync(hubYamlPath, "utf-8");
   const hasVersion = content.match(/^version:\s/m);
   let updated;
   if (hasVersion) {
@@ -11658,7 +11748,7 @@ hub_id: "${hubId}"
 hub_environment: preview
 ${content}`;
   }
-  fs12.writeFileSync(hubYamlPath, updated, "utf-8");
+  fs13.writeFileSync(hubYamlPath, updated, "utf-8");
   autoBindIfUnbound(hubId);
   await pushSingleHub(client, hubId, newHub.hubFolder, opts.autoConfirm, opts.organizationId, { skipAgentRename: true });
 }
@@ -11667,7 +11757,7 @@ function reportUnresolvedPushTarget(reason, existingHubs, newHubs, selector, wsL
     if (existingHubs.length > 0) {
       console.error(`No pushable hub found in ${wsLabel}/ \u2014 only read-only production mirror folder(s). Edit the linked preview hub, pull one, or create a new hub with \`wayai create\`:`);
       for (const h of existingHubs) {
-        console.error(`  ${path14.basename(h.hubFolder)} (${h.hubId}, production mirror)`);
+        console.error(`  ${path15.basename(h.hubFolder)} (${h.hubId}, production mirror)`);
       }
     } else {
       console.error(`No hub folders found. Create hub files in ${wsLabel}/<hub>/hub.yaml with \`hub: { name: ... }\` and run \`wayai push\` (or \`wayai create\`).`);
@@ -11680,10 +11770,10 @@ function reportUnresolvedPushTarget(reason, existingHubs, newHubs, selector, wsL
     console.error(`Multiple hub folders found in ${wsLabel}/. Pass --hub <uuid|folder-name> to choose, or run from inside a hub folder:`);
   }
   for (const h of existingHubs) {
-    console.error(`  ${path14.basename(h.hubFolder)} (${h.hubId})`);
+    console.error(`  ${path15.basename(h.hubFolder)} (${h.hubId})`);
   }
   for (const h of newHubs) {
-    console.error(`  ${path14.basename(h.hubFolder)} (new \u2014 "${h.hubName}")`);
+    console.error(`  ${path15.basename(h.hubFolder)} (new \u2014 "${h.hubName}")`);
   }
   process.exit(1);
 }
@@ -11697,7 +11787,12 @@ async function pushCommand(args2) {
   const gitRoot = findGitRoot();
   const wsLabel = hubsDirLabel(gitRoot);
   if (gitRoot) warnLayoutOnce(gitRoot);
-  if (!fs12.existsSync(workspaceDir)) {
+  if (gitRoot) {
+    for (const file of ensureWorkspaceFiles(gitRoot)) {
+      console.error(`Created ${file}`);
+    }
+  }
+  if (!fs13.existsSync(workspaceDir)) {
     console.error(`No ${wsLabel}/ directory found. Run \`wayai pull\` first or create hub files in ${wsLabel}/<hub>/hub.yaml.`);
     process.exit(1);
   }
@@ -11716,8 +11811,8 @@ async function pushCommand(args2) {
     if (label) {
       console.warn("Note: --label is only used when creating a new hub. To change an existing hub's label, use `wayai relabel`.");
     }
-    console.log(`Target hub: ${path14.basename(existing.hubFolder)} (${existing.hubId})`);
-    assertHubMatchesBinding(existing.hubId, path14.basename(existing.hubFolder));
+    console.log(`Target hub: ${path15.basename(existing.hubFolder)} (${existing.hubId})`);
+    assertHubMatchesBinding(existing.hubId, path15.basename(existing.hubFolder));
     await pushSingleHub(client, existing.hubId, existing.hubFolder, autoConfirm, organizationId);
     return;
   }
@@ -11736,6 +11831,7 @@ var init_push = __esm({
     init_utils();
     init_workspace();
     init_layout();
+    init_workspace_files();
     init_repo_config();
     init_hub_binding();
   }
@@ -11746,8 +11842,8 @@ var create_exports = {};
 __export(create_exports, {
   createCommand: () => createCommand
 });
-import * as path15 from "path";
-import * as fs13 from "fs";
+import * as path16 from "path";
+import * as fs14 from "fs";
 function parseArgs6(args2) {
   let autoConfirm = false;
   let folderSelector;
@@ -11774,7 +11870,7 @@ async function createCommand(args2) {
   const gitRoot = findGitRoot();
   const wsLabel = hubsDirLabel(gitRoot);
   if (gitRoot) warnLayoutOnce(gitRoot);
-  if (!fs13.existsSync(workspaceDir)) {
+  if (!fs14.existsSync(workspaceDir)) {
     console.error(`No ${wsLabel}/ directory found. Create hub files in ${wsLabel}/<hub>/hub.yaml with \`hub: { name: ... }\` first.`);
     process.exit(1);
   }
@@ -11783,7 +11879,7 @@ async function createCommand(args2) {
   const resolution = resolveNewHubForCreate(workspaceDir, existingHubs, newHubs, folderSelector);
   if (!resolution.ok) {
     if (resolution.reason === "exists") {
-      const folder = path15.basename(resolution.existing.hubFolder);
+      const folder = path16.basename(resolution.existing.hubFolder);
       console.error(`Hub "${folder}" already exists (${resolution.existing.hubId}). Use \`wayai push --hub ${folder}\` to update it.`);
       process.exit(1);
     }
@@ -11797,7 +11893,7 @@ async function createCommand(args2) {
     }
     console.error(`Multiple new hub folders found in ${wsLabel}/. Pass the folder name (\`wayai create <folder>\`) or run from inside one:`);
     for (const h of newHubs) {
-      console.error(`  ${path15.basename(h.hubFolder)} (new \u2014 "${h.hubName}")`);
+      console.error(`  ${path16.basename(h.hubFolder)} (new \u2014 "${h.hubName}")`);
     }
     process.exit(1);
   }
@@ -11967,12 +12063,12 @@ function typeMatches2(typeField, allowed) {
   if (Array.isArray(typeField)) return typeField.every((t) => typeof t === "string" && allowed.has(t));
   return false;
 }
-function validateSchema2(schema, path26, errors, opts = {}) {
+function validateSchema2(schema, path27, errors, opts = {}) {
   if (typeof schema === "boolean") return;
   const depth = opts.depth ?? 0;
   if (depth > MAX_SCHEMA_DEPTH2) {
     errors.push({
-      path: path26 || "<root>",
+      path: path27 || "<root>",
       message: `schema nesting exceeds ${MAX_SCHEMA_DEPTH2} levels`,
       suggestion: "Flatten the schema; LLM providers reject deeply nested tool input_schemas."
     });
@@ -11980,7 +12076,7 @@ function validateSchema2(schema, path26, errors, opts = {}) {
   }
   if (!isRecord2(schema)) {
     errors.push({
-      path: path26,
+      path: path27,
       message: `expected object, got ${schema === null ? "null" : typeof schema}`
     });
     return;
@@ -11988,14 +12084,14 @@ function validateSchema2(schema, path26, errors, opts = {}) {
   if (opts.isRoot) {
     if ("type" in schema && schema.type !== "object") {
       errors.push({
-        path: path26 ? `${path26}.type` : "type",
+        path: path27 ? `${path27}.type` : "type",
         message: `root type must be 'object', got ${JSON.stringify(schema.type)}`,
         suggestion: "Tool parameters at the root must be an object: `{ type: 'object', properties: { ... } }`."
       });
     }
   } else if ("type" in schema && !typeMatches2(schema.type, ALLOWED_TYPES2)) {
     errors.push({
-      path: `${path26}.type`,
+      path: `${path27}.type`,
       message: `type must be one of ${[...ALLOWED_TYPES2].join("/")} or an array of those, got ${JSON.stringify(schema.type)}`
     });
   }
@@ -12004,25 +12100,25 @@ function validateSchema2(schema, path26, errors, opts = {}) {
     if (typeof e === "string") {
       const isPlaceholder = PLACEHOLDER_TOKENS2.includes(e);
       errors.push({
-        path: `${path26}.enum`,
+        path: `${path27}.enum`,
         message: `enum must be a non-empty array of primitives, got string ${JSON.stringify(e)}`,
         suggestion: isPlaceholder ? "Set `operation: 'update_kanban_status'` on the tool and ensure at least one hub.kanban_status has `allowsAgentUpdate: true` so the platform can render the placeholder into a valid array." : 'Wrap the value in an array: `enum: ["value"]`.'
       });
     } else if (!Array.isArray(e)) {
       errors.push({
-        path: `${path26}.enum`,
+        path: `${path27}.enum`,
         message: `enum must be a non-empty array of primitives, got ${typeof e}`
       });
     } else if (e.length === 0) {
       errors.push({
-        path: `${path26}.enum`,
+        path: `${path27}.enum`,
         message: "enum must not be empty"
       });
     } else {
       for (let i = 0; i < e.length; i++) {
         if (!isPrimitive2(e[i])) {
           errors.push({
-            path: `${path26}.enum[${i}]`,
+            path: `${path27}.enum[${i}]`,
             message: `enum entry must be a primitive (string/number/boolean/null), got ${typeof e[i]}`
           });
         }
@@ -12032,7 +12128,7 @@ function validateSchema2(schema, path26, errors, opts = {}) {
   for (const key of ["exclusiveMinimum", "exclusiveMaximum"]) {
     if (key in schema && typeof schema[key] === "boolean") {
       errors.push({
-        path: `${path26}.${key}`,
+        path: `${path27}.${key}`,
         message: `${key} as boolean is draft-04 syntax; draft 2020-12 requires a numeric value`,
         suggestion: `Replace with the numeric bound, e.g. \`${key}: 0\`.`
       });
@@ -12041,45 +12137,45 @@ function validateSchema2(schema, path26, errors, opts = {}) {
   if ("properties" in schema) {
     if (!isRecord2(schema.properties)) {
       errors.push({
-        path: `${path26}.properties`,
+        path: `${path27}.properties`,
         message: `properties must be an object, got ${Array.isArray(schema.properties) ? "array" : typeof schema.properties}`
       });
     } else {
       for (const [propName, propSchema] of Object.entries(schema.properties)) {
-        validateSchema2(propSchema, `${path26}.properties.${propName}`, errors, { depth: depth + 1 });
+        validateSchema2(propSchema, `${path27}.properties.${propName}`, errors, { depth: depth + 1 });
       }
     }
   }
   if (schemaTypeIncludes2(schema, "array") && "items" in schema) {
     if (Array.isArray(schema.items)) {
-      schema.items.forEach((sub, i) => validateSchema2(sub, `${path26}.items[${i}]`, errors, { depth: depth + 1 }));
+      schema.items.forEach((sub, i) => validateSchema2(sub, `${path27}.items[${i}]`, errors, { depth: depth + 1 }));
     } else {
-      validateSchema2(schema.items, `${path26}.items`, errors, { depth: depth + 1 });
+      validateSchema2(schema.items, `${path27}.items`, errors, { depth: depth + 1 });
     }
   }
   for (const key of SUBSCHEMA_OBJECT_KEYWORDS2) {
     if (key in schema && isRecord2(schema[key])) {
-      validateSchema2(schema[key], `${path26}.${key}`, errors, { depth: depth + 1 });
+      validateSchema2(schema[key], `${path27}.${key}`, errors, { depth: depth + 1 });
     }
   }
   for (const key of SUBSCHEMA_LIST_KEYWORDS2) {
     const list = schema[key];
     if (Array.isArray(list)) {
-      list.forEach((sub, i) => validateSchema2(sub, `${path26}.${key}[${i}]`, errors, { depth: depth + 1 }));
+      list.forEach((sub, i) => validateSchema2(sub, `${path27}.${key}[${i}]`, errors, { depth: depth + 1 }));
     }
   }
   for (const key of SUBSCHEMA_MAP_KEYWORDS2) {
     const map = schema[key];
     if (isRecord2(map)) {
       for (const [name, sub] of Object.entries(map)) {
-        validateSchema2(sub, `${path26}.${key}.${name}`, errors, { depth: depth + 1 });
+        validateSchema2(sub, `${path27}.${key}.${name}`, errors, { depth: depth + 1 });
       }
     }
   }
   const reportedPaths = new Set(errors.map((e) => e.path));
   for (const [k, v] of Object.entries(schema)) {
     if (typeof v !== "string") continue;
-    const fieldPath = `${path26}.${k}`;
+    const fieldPath = `${path27}.${k}`;
     if (reportedPaths.has(fieldPath)) continue;
     for (const token of PLACEHOLDER_TOKENS2) {
       if (v === token) {
@@ -12235,10 +12331,10 @@ function refineHubAsCodeLanes2(config, ctx) {
     }
   }
 }
-function isSafeTemplatePath2(path26) {
-  if (path26.length === 0 || path26.length > 300) return false;
-  if (path26.startsWith("/") || path26.includes("\\")) return false;
-  const segments = path26.split("/");
+function isSafeTemplatePath2(path27) {
+  if (path27.length === 0 || path27.length > 300) return false;
+  if (path27.startsWith("/") || path27.includes("\\")) return false;
+  const segments = path27.split("/");
   return segments.every(
     (seg) => seg.length > 0 && seg !== "." && seg !== ".." && /^[A-Za-z0-9._-]+$/.test(seg)
   );
@@ -12266,9 +12362,9 @@ function isPlainObject(value) {
   const proto = Object.getPrototypeOf(value);
   return proto === Object.prototype || proto === null;
 }
-function isSanitizableSliceFile(path26) {
-  if (!/\.ya?ml$/i.test(path26)) return false;
-  return path26 !== "resources" && !path26.startsWith("resources/");
+function isSanitizableSliceFile(path27) {
+  if (!/\.ya?ml$/i.test(path27)) return false;
+  return path27 !== "resources" && !path27.startsWith("resources/");
 }
 function distinctUsesBackends(uses) {
   return [...new Set((uses ?? []).map((u) => u.backend))];
@@ -14888,8 +14984,8 @@ var replicate_exports = {};
 __export(replicate_exports, {
   replicateCommand: () => replicateCommand
 });
-import * as fs14 from "fs";
-import * as path16 from "path";
+import * as fs15 from "fs";
+import * as path17 from "path";
 function parseArgs8(args2) {
   let label;
   let hubSelector;
@@ -14935,7 +15031,7 @@ async function replicateCommand(args2) {
     payload.preview_label,
     payload.branch_name
   );
-  fs14.mkdirSync(path16.dirname(hubFolder), { recursive: true });
+  fs15.mkdirSync(path17.dirname(hubFolder), { recursive: true });
   writeHubFolder(hubFolder, payload);
   await downloadBinaryResourceFiles(hubFolder, payload);
   hubFolder = autoRenameHubFolder(
@@ -14947,8 +15043,8 @@ async function replicateCommand(args2) {
     payload.branch_name
   );
   autoBindIfUnbound(previewHubId);
-  console.log(`Preview written to ${path16.basename(hubFolder)}`);
-  console.log(`  Switch to it with: wayai use ${path16.basename(hubFolder)}`);
+  console.log(`Preview written to ${path17.basename(hubFolder)}`);
+  console.log(`  Switch to it with: wayai use ${path17.basename(hubFolder)}`);
 }
 var init_replicate = __esm({
   "src/commands/replicate.ts"() {
@@ -14970,7 +15066,7 @@ var relabel_exports = {};
 __export(relabel_exports, {
   relabelCommand: () => relabelCommand
 });
-import * as path17 from "path";
+import * as path18 from "path";
 function parseArgs9(args2) {
   let label;
   let clear = false;
@@ -15014,7 +15110,7 @@ async function relabelCommand(args2) {
     } else {
       console.error(`Multiple hubs found in ${wsLabel}/. Pass --hub <uuid|folder-name> to choose, or run from inside a hub folder:`);
       for (const h of previewHubs) {
-        console.error(`  ${path17.basename(h.hubFolder)} (${h.hubId})`);
+        console.error(`  ${path18.basename(h.hubFolder)} (${h.hubId})`);
       }
     }
     process.exit(1);
@@ -15023,7 +15119,7 @@ async function relabelCommand(args2) {
     console.log("This is a read-only production mirror \u2014 production hubs have no preview label. Relabel the linked preview hub instead.");
     return;
   }
-  assertHubMatchesBinding(target.hubId, path17.basename(target.hubFolder));
+  assertHubMatchesBinding(target.hubId, path18.basename(target.hubFolder));
   console.log(normalizedLabel ? `Setting preview label to "${normalizedLabel}"...` : "Clearing preview label...");
   const { data } = await client.relabelPreview(target.hubId, normalizedLabel);
   const row = data[0];
@@ -15039,7 +15135,7 @@ async function relabelCommand(args2) {
   );
   console.log(serverLabel ? `Preview label set to "${serverLabel}".` : "Preview label cleared.");
   if (finalFolder !== target.hubFolder) {
-    console.log(`Hub folder is now ${path17.basename(finalFolder)}`);
+    console.log(`Hub folder is now ${path18.basename(finalFolder)}`);
   }
 }
 var init_relabel = __esm({
@@ -15065,7 +15161,7 @@ __export(publish_exports, {
   renderHubDiff: () => renderHubDiff,
   runPublish: () => runPublish
 });
-import * as path18 from "path";
+import * as path19 from "path";
 function parseArgs10(args2) {
   let autoConfirm = false;
   let hubSelector;
@@ -15171,7 +15267,7 @@ async function publishCommand(args2) {
       return;
     }
   }
-  assertHubMatchesBinding(hubId, hubFolder ? path18.basename(hubFolder) : void 0);
+  assertHubMatchesBinding(hubId, hubFolder ? path19.basename(hubFolder) : void 0);
   await runPublish(client, { hubId, localConfig, organizationId, autoConfirm });
 }
 var STATUS_STYLE;
@@ -15203,7 +15299,7 @@ var use_exports = {};
 __export(use_exports, {
   useCommand: () => useCommand
 });
-import * as path19 from "path";
+import * as path20 from "path";
 async function useCommand(args2) {
   const target = args2[0];
   if (!target || target.startsWith("-")) {
@@ -15225,7 +15321,7 @@ async function useCommand(args2) {
     const match = findHubByFolderName(workspaceDir, target);
     if (!match) {
       const newHubs = scanNewHubs(workspaceDir);
-      const pending = newHubs.find((h) => path19.basename(h.hubFolder) === target);
+      const pending = newHubs.find((h) => path20.basename(h.hubFolder) === target);
       if (pending) {
         console.error(
           `"${target}" is a new hub that hasn't been created on the platform yet, so it has no id to bind to.
@@ -15236,10 +15332,10 @@ Create it first \u2014 the worktree binds automatically afterward:
       }
       console.error(`No hub matching "${target}" found in ${wsLabel}/. Pass a UUID or a folder name from:`);
       for (const h of scanWorkspaceHubs(workspaceDir)) {
-        console.error(`  ${path19.basename(h.hubFolder)} (${h.hubId})`);
+        console.error(`  ${path20.basename(h.hubFolder)} (${h.hubId})`);
       }
       for (const h of newHubs) {
-        console.error(`  ${path19.basename(h.hubFolder)} (new \u2014 "${h.hubName}", run \`wayai create ${path19.basename(h.hubFolder)}\`)`);
+        console.error(`  ${path20.basename(h.hubFolder)} (new \u2014 "${h.hubName}", run \`wayai create ${path20.basename(h.hubFolder)}\`)`);
       }
       process.exit(1);
     }
@@ -15278,11 +15374,11 @@ __export(migrate_exports, {
   migrateCommand: () => migrateCommand
 });
 import { execFileSync as execFileSync3 } from "child_process";
-import * as fs15 from "fs";
-import * as path20 from "path";
+import * as fs16 from "fs";
+import * as path21 from "path";
 function isTracked(gitRoot, p) {
   try {
-    execFileSync3("git", ["ls-files", "--error-unmatch", "--", path20.relative(gitRoot, p)], {
+    execFileSync3("git", ["ls-files", "--error-unmatch", "--", path21.relative(gitRoot, p)], {
       cwd: gitRoot,
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -15292,10 +15388,10 @@ function isTracked(gitRoot, p) {
   }
 }
 function moveDir(gitRoot, from, to) {
-  fs15.mkdirSync(path20.dirname(to), { recursive: true });
+  fs16.mkdirSync(path21.dirname(to), { recursive: true });
   if (isTracked(gitRoot, from)) {
     try {
-      execFileSync3("git", ["mv", path20.relative(gitRoot, from), path20.relative(gitRoot, to)], {
+      execFileSync3("git", ["mv", path21.relative(gitRoot, from), path21.relative(gitRoot, to)], {
         cwd: gitRoot,
         stdio: ["pipe", "pipe", "pipe"]
       });
@@ -15303,7 +15399,7 @@ function moveDir(gitRoot, from, to) {
     } catch {
     }
   }
-  fs15.renameSync(from, to);
+  fs16.renameSync(from, to);
   return "fs";
 }
 async function migrateCommand(_args) {
@@ -15312,12 +15408,12 @@ async function migrateCommand(_args) {
     console.error("Not inside a git repository.");
     process.exit(1);
   }
-  const rel = (p) => path20.relative(gitRoot, p);
-  const newWs = path20.join(gitRoot, WAYAI_LAYOUT.wsDir);
-  const legacyWs = path20.join(gitRoot, WAYAI_LAYOUT.legacy.wsDir);
-  const legacyOrg = path20.join(gitRoot, WAYAI_LAYOUT.legacy.orgAtRoot);
-  const newHubs = path20.join(newWs, WAYAI_LAYOUT.hubsSubdir);
-  const newOrg = path20.join(newWs, WAYAI_LAYOUT.orgSubdir);
+  const rel = (p) => path21.relative(gitRoot, p);
+  const newWs = path21.join(gitRoot, WAYAI_LAYOUT.wsDir);
+  const legacyWs = path21.join(gitRoot, WAYAI_LAYOUT.legacy.wsDir);
+  const legacyOrg = path21.join(gitRoot, WAYAI_LAYOUT.legacy.orgAtRoot);
+  const newHubs = path21.join(newWs, WAYAI_LAYOUT.hubsSubdir);
+  const newOrg = path21.join(newWs, WAYAI_LAYOUT.orgSubdir);
   const hasLegacyWs = isDirectory(legacyWs);
   const hasLegacyOrg = isDirectory(legacyOrg);
   if (!hasLegacyWs && !hasLegacyOrg) {
@@ -16654,8 +16750,8 @@ var eval_capture_exports = {};
 __export(eval_capture_exports, {
   evalCaptureCommand: () => evalCaptureCommand
 });
-import * as fs16 from "fs";
-import * as path21 from "path";
+import * as fs17 from "fs";
+import * as path22 from "path";
 import * as yaml7 from "js-yaml";
 function isValidSetName(name) {
   if (name.length === 0 || name === "." || name === "..") return false;
@@ -16721,15 +16817,15 @@ async function evalCaptureCommand(args2) {
   const setFolderName = targetSetName;
   const scenarioName = parsed.evalName ?? `Capture ${parsed.conversationId.slice(0, 8)}`;
   const slug = slugify(scenarioName);
-  const evalsDir = path21.join(hubFolder, "evals");
-  const targetDir = path21.join(evalsDir, setFolderName);
-  const targetPath = path21.join(targetDir, `${slug}.yaml`);
-  if (!targetPath.startsWith(evalsDir + path21.sep)) {
-    console.error(`Resolved path "${path21.relative(hubFolder, targetPath)}" escapes evals/. Aborting.`);
+  const evalsDir = path22.join(hubFolder, "evals");
+  const targetDir = path22.join(evalsDir, setFolderName);
+  const targetPath = path22.join(targetDir, `${slug}.yaml`);
+  if (!targetPath.startsWith(evalsDir + path22.sep)) {
+    console.error(`Resolved path "${path22.relative(hubFolder, targetPath)}" escapes evals/. Aborting.`);
     process.exit(1);
   }
-  if (fs16.existsSync(targetPath)) {
-    console.error(`File already exists: ${path21.relative(hubFolder, targetPath)}. Use --name to choose a different name.`);
+  if (fs17.existsSync(targetPath)) {
+    console.error(`File already exists: ${path22.relative(hubFolder, targetPath)}. Use --name to choose a different name.`);
     process.exit(1);
   }
   console.log("Resolving scenario set...");
@@ -16761,9 +16857,9 @@ async function evalCaptureCommand(args2) {
     ...captured.evaluator_instructions ? { evaluator_instructions: captured.evaluator_instructions } : {}
   };
   const yamlObj = buildEvalYamlObject(evalEntry, slug);
-  fs16.mkdirSync(targetDir, { recursive: true });
-  fs16.writeFileSync(targetPath, yaml7.dump(yamlObj, YAML_DUMP_OPTIONS), "utf-8");
-  const relPath = path21.relative(process.cwd(), targetPath);
+  fs17.mkdirSync(targetDir, { recursive: true });
+  fs17.writeFileSync(targetPath, yaml7.dump(yamlObj, YAML_DUMP_OPTIONS), "utf-8");
+  const relPath = path22.relative(process.cwd(), targetPath);
   console.log(`
 Wrote ${relPath}`);
   console.log("Run `wayai pull` to refresh the agent display name, then commit. The scenario is already on the platform.");
@@ -17990,23 +18086,23 @@ var init_set_connection_credential = __esm({
 });
 
 // src/lib/org-workspace.ts
-import * as fs17 from "fs";
-import * as path22 from "path";
+import * as fs18 from "fs";
+import * as path23 from "path";
 import * as yaml8 from "js-yaml";
 function getOrgDir(gitRoot) {
   return resolveLayout(gitRoot).orgDir;
 }
 function orgManifestExists(orgDir) {
-  return fs17.existsSync(path22.join(orgDir, ORG_MANIFEST_NAME));
+  return fs18.existsSync(path23.join(orgDir, ORG_MANIFEST_NAME));
 }
 function parseOrgResources(orgDir) {
-  const manifestPath = path22.join(orgDir, ORG_MANIFEST_NAME);
+  const manifestPath = path23.join(orgDir, ORG_MANIFEST_NAME);
   let manifest = {};
-  if (fs17.existsSync(manifestPath)) {
-    manifest = yaml8.load(fs17.readFileSync(manifestPath, "utf-8")) ?? {};
+  if (fs18.existsSync(manifestPath)) {
+    manifest = yaml8.load(fs18.readFileSync(manifestPath, "utf-8")) ?? {};
   }
   const rawResources = Array.isArray(manifest.resources) ? manifest.resources : [];
-  const resourcesDir = path22.join(orgDir, "resources");
+  const resourcesDir = path23.join(orgDir, "resources");
   const resources = rawResources.map((res) => {
     const resource = { name: res.name };
     if (res.id) resource.id = res.id;
@@ -18018,8 +18114,8 @@ function parseOrgResources(orgDir) {
     if (res.environment) resource.environment = res.environment;
     if (Array.isArray(res.tags)) resource.tags = res.tags;
     if (Array.isArray(res.folders)) resource.folders = res.folders;
-    const resDir = path22.join(resourcesDir, slugify(resource.name));
-    if (fs17.existsSync(resDir)) {
+    const resDir = path23.join(resourcesDir, slugify(resource.name));
+    if (fs18.existsSync(resDir)) {
       const files = scanResourceFiles(resDir, "");
       if (files.length > 0) resource.files = files;
     }
@@ -18028,28 +18124,28 @@ function parseOrgResources(orgDir) {
   return { version: 1, resources };
 }
 function writeOrgResources(orgDir, payload) {
-  fs17.mkdirSync(orgDir, { recursive: true });
+  fs18.mkdirSync(orgDir, { recursive: true });
   const resources = payload.resources ?? [];
   const manifestResources = resources.map((r) => {
     const { files: _files, ...rest } = r;
     return rest;
   });
-  fs17.writeFileSync(
-    path22.join(orgDir, ORG_MANIFEST_NAME),
+  fs18.writeFileSync(
+    path23.join(orgDir, ORG_MANIFEST_NAME),
     yaml8.dump({ version: 1, resources: manifestResources }, YAML_DUMP_OPTIONS),
     "utf-8"
   );
-  const resourcesDir = path22.join(orgDir, "resources");
+  const resourcesDir = path23.join(orgDir, "resources");
   const currentSlugs = /* @__PURE__ */ new Set();
   for (const resource of resources) {
     const resSlug = slugify(resource.name);
     currentSlugs.add(resSlug);
-    writeResourceFileTree(path22.join(resourcesDir, resSlug), resource.files || []);
+    writeResourceFileTree(path23.join(resourcesDir, resSlug), resource.files || []);
   }
-  if (fs17.existsSync(resourcesDir)) {
-    for (const entry of fs17.readdirSync(resourcesDir, { withFileTypes: true })) {
+  if (fs18.existsSync(resourcesDir)) {
+    for (const entry of fs18.readdirSync(resourcesDir, { withFileTypes: true })) {
       if (entry.isDirectory() && !currentSlugs.has(entry.name)) {
-        fs17.rmSync(path22.join(resourcesDir, entry.name), { recursive: true, force: true });
+        fs18.rmSync(path23.join(resourcesDir, entry.name), { recursive: true, force: true });
       }
     }
   }
@@ -18058,7 +18154,7 @@ async function downloadOrgBinaryFiles(orgDir, payload) {
   let count = 0;
   for (const resource of payload.resources ?? []) {
     if (!resource.files) continue;
-    const resDir = path22.join(orgDir, "resources", slugify(resource.name));
+    const resDir = path23.join(orgDir, "resources", slugify(resource.name));
     count += await downloadBinaryFiles(resDir, resource.files);
   }
   if (count > 0) console.log(`Downloaded ${count} binary resource file(s).`);
@@ -18314,20 +18410,20 @@ var init_list = __esm({
 });
 
 // src/lib/template-files.ts
-import * as fs18 from "fs";
-import * as path23 from "path";
+import * as fs19 from "fs";
+import * as path24 from "path";
 function readDirToFileMap(rootDir) {
   const out = {};
   function walk(dir, prefix) {
-    const entries = fs18.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    const entries = fs19.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
-      const abs = path23.join(dir, entry.name);
+      const abs = path24.join(dir, entry.name);
       const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
       if (entry.isDirectory()) walk(abs, rel);
-      else if (entry.isFile()) out[rel] = fs18.readFileSync(abs, "utf-8");
+      else if (entry.isFile()) out[rel] = fs19.readFileSync(abs, "utf-8");
     }
   }
-  if (fs18.existsSync(rootDir)) walk(rootDir, "");
+  if (fs19.existsSync(rootDir)) walk(rootDir, "");
   return out;
 }
 function detectCollisions(targetDir, files) {
@@ -18336,7 +18432,7 @@ function detectCollisions(targetDir, files) {
     if (!isSafeTemplatePath2(rel)) {
       throw new Error(`Refusing to inspect unsafe template path: ${rel}`);
     }
-    if (fs18.existsSync(path23.join(targetDir, rel))) collisions.push(rel);
+    if (fs19.existsSync(path24.join(targetDir, rel))) collisions.push(rel);
   }
   return collisions.sort((a, b) => a.localeCompare(b));
 }
@@ -18346,9 +18442,9 @@ function writeFileMap(targetDir, files) {
     if (!isSafeTemplatePath2(rel)) {
       throw new Error(`Refusing to write unsafe template path: ${rel}`);
     }
-    const abs = path23.join(targetDir, rel);
-    fs18.mkdirSync(path23.dirname(abs), { recursive: true });
-    fs18.writeFileSync(abs, body, "utf-8");
+    const abs = path24.join(targetDir, rel);
+    fs19.mkdirSync(path24.dirname(abs), { recursive: true });
+    fs19.writeFileSync(abs, body, "utf-8");
     written.push(rel);
   }
   return written;
@@ -18356,20 +18452,20 @@ function writeFileMap(targetDir, files) {
 function listDirRelFiles(dir) {
   const out = [];
   function walk(d, prefix) {
-    for (const entry of fs18.readdirSync(d, { withFileTypes: true })) {
+    for (const entry of fs19.readdirSync(d, { withFileTypes: true })) {
       const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
-      if (entry.isDirectory()) walk(path23.join(d, entry.name), rel);
+      if (entry.isDirectory()) walk(path24.join(d, entry.name), rel);
       else if (entry.isFile()) out.push(rel);
     }
   }
-  if (fs18.existsSync(dir)) walk(dir, "");
+  if (fs19.existsSync(dir)) walk(dir, "");
   return out;
 }
 function writeSliceSnapshot(targetDir, files) {
   const keep = new Set(Object.keys(files));
   const removed = listDirRelFiles(targetDir).filter((rel) => !keep.has(rel)).sort((a, b) => a.localeCompare(b));
   const written = writeFileMap(targetDir, files).sort((a, b) => a.localeCompare(b));
-  if (fs18.existsSync(targetDir)) cleanOrphanFiles(targetDir, "", keep);
+  if (fs19.existsSync(targetDir)) cleanOrphanFiles(targetDir, "", keep);
   return { written, removed };
 }
 var init_template_files = __esm({
@@ -18385,7 +18481,7 @@ var templates_exports = {};
 __export(templates_exports, {
   templateCommand: () => templateCommand
 });
-import * as path24 from "path";
+import * as path25 from "path";
 async function templateCommand(args2) {
   const [sub, ...rest] = args2;
   switch (sub) {
@@ -18501,8 +18597,8 @@ async function runTemplatePull(rest) {
     console.log(`Template "${slug}" has no WayAI slice${hint}`);
     return;
   }
-  const targetDir = path24.join(resolveLayout(gitRoot).hubsDir, slug);
-  const relTarget = path24.relative(gitRoot, targetDir);
+  const targetDir = path25.join(resolveLayout(gitRoot).hubsDir, slug);
+  const relTarget = path25.relative(gitRoot, targetDir);
   const collisions = detectCollisions(targetDir, detail.files);
   if (dryRun) {
     const planned = Object.keys(detail.files).sort((a, b) => a.localeCompare(b));
@@ -18676,8 +18772,8 @@ var admin_exports = {};
 __export(admin_exports, {
   adminCommand: () => adminCommand
 });
-import * as fs19 from "fs";
-import * as path25 from "path";
+import * as fs20 from "fs";
+import * as path26 from "path";
 import * as yaml10 from "js-yaml";
 async function adminCommand(args2) {
   const [group, ...afterGroup] = args2;
@@ -18985,7 +19081,7 @@ async function runArchiveRead(positional, flagArgs) {
       exitOnApiError(err);
       throw err;
     }
-    fs19.writeFileSync(outPath, zip);
+    fs20.writeFileSync(outPath, zip);
     console.log(`Wrote ${zip.byteLength} bytes to ${outPath}`);
     return;
   }
@@ -19117,15 +19213,15 @@ function loadTemplateManifest(slug) {
     console.error("Not in a git repository. Run from the tutorials/ authoring repo.");
     process.exit(1);
   }
-  const templateDir = path25.join(resolveTemplatesDir(gitRoot), slug);
-  const manifestPath = path25.join(templateDir, "template.yaml");
-  if (!fs19.existsSync(manifestPath)) {
-    console.error(`template.yaml not found at ${path25.relative(gitRoot, manifestPath)}`);
+  const templateDir = path26.join(resolveTemplatesDir(gitRoot), slug);
+  const manifestPath = path26.join(templateDir, "template.yaml");
+  if (!fs20.existsSync(manifestPath)) {
+    console.error(`template.yaml not found at ${path26.relative(gitRoot, manifestPath)}`);
     process.exit(1);
   }
   let manifest;
   try {
-    manifest = templateYamlSchema2.parse(yaml10.load(fs19.readFileSync(manifestPath, "utf-8")));
+    manifest = templateYamlSchema2.parse(yaml10.load(fs20.readFileSync(manifestPath, "utf-8")));
   } catch (err) {
     console.error(`Invalid template.yaml: ${err instanceof Error ? err.message : String(err)}`);
     process.exit(1);
@@ -19155,20 +19251,20 @@ async function runTemplatePush(positional) {
     const wayaiEntry = manifest.wayai.locales[locale];
     let wayaiFiles;
     if (wayaiEntry) {
-      const sliceDir = path25.resolve(templateDir, wayaiEntry.source);
-      if (!fs19.existsSync(sliceDir)) {
+      const sliceDir = path26.resolve(templateDir, wayaiEntry.source);
+      if (!fs20.existsSync(sliceDir)) {
         console.error(`wayai source not found for ${locale}: ${wayaiEntry.source} (resolved ${sliceDir})`);
         process.exit(1);
       }
       if (!isInsideTemplateDir(sliceDir, templateDir)) {
         console.warn(
-          `Note: ${locale} source points at a live hub (${wayaiEntry.source}); it can go stale on a hub recreate. Run \`wayai admin template freeze ${slug} --locale ${locale} --from ${path25.basename(sliceDir)}\` to commit a stable frozen slice.`
+          `Note: ${locale} source points at a live hub (${wayaiEntry.source}); it can go stale on a hub recreate. Run \`wayai admin template freeze ${slug} --locale ${locale} --from ${path26.basename(sliceDir)}\` to commit a stable frozen slice.`
         );
       }
       wayaiFiles = readDirToFileMap(sliceDir);
     }
-    const readmePath = path25.join(templateDir, `README.${locale}.md`);
-    const readmeMarkdown = fs19.existsSync(readmePath) ? fs19.readFileSync(readmePath, "utf-8") : "";
+    const readmePath = path26.join(templateDir, `README.${locale}.md`);
+    const readmeMarkdown = fs20.existsSync(readmePath) ? fs20.readFileSync(readmePath, "utf-8") : "";
     locales[locale] = {
       readmeMarkdown,
       ...wayaiFiles && { wayaiFiles },
@@ -19179,9 +19275,9 @@ async function runTemplatePush(positional) {
   }
   let hero;
   if (manifest.hero) {
-    const heroPath = path25.resolve(templateDir, manifest.hero);
-    if (fs19.existsSync(heroPath)) {
-      hero = { filename: path25.basename(heroPath), dataBase64: fs19.readFileSync(heroPath).toString("base64") };
+    const heroPath = path26.resolve(templateDir, manifest.hero);
+    if (fs20.existsSync(heroPath)) {
+      hero = { filename: path26.basename(heroPath), dataBase64: fs20.readFileSync(heroPath).toString("base64") };
     } else {
       console.error(`Warning: hero not found at ${manifest.hero}; skipping.`);
     }
@@ -19207,7 +19303,7 @@ async function runTemplatePush(positional) {
   }
 }
 function isInsideTemplateDir(dest, templateDir) {
-  return dest === templateDir || dest.startsWith(templateDir + path25.sep);
+  return dest === templateDir || dest.startsWith(templateDir + path26.sep);
 }
 async function runTemplateFreeze(positional, flagArgs) {
   const slug = positional[0];
@@ -19268,7 +19364,7 @@ async function runTemplateFreeze(positional, flagArgs) {
     process.exit(1);
   }
   const entry = manifest.wayai.locales[targetLocale];
-  const dest = path25.resolve(templateDir, entry.source);
+  const dest = path26.resolve(templateDir, entry.source);
   if (!isInsideTemplateDir(dest, templateDir) || dest === templateDir) {
     console.error(
       `source for "${targetLocale}" must be a committed path inside ${slug}/ (e.g. "./${targetLocale}/slice"), but resolved to:
@@ -19287,7 +19383,7 @@ Set it to a subdir of the template folder and re-run freeze.`
     const hubs = scanWorkspaceHubs(hubsDir);
     if (hubs.length) {
       console.error("Available hubs:");
-      for (const h of hubs) console.error(`  ${path25.basename(h.hubFolder)} (${h.hubId})`);
+      for (const h of hubs) console.error(`  ${path26.basename(h.hubFolder)} (${h.hubId})`);
     }
     console.error(`
 Pass --from <folder|uuid>${selector ? "." : " or run `wayai use <hub>` first."}`);
@@ -19295,12 +19391,12 @@ Pass --from <folder|uuid>${selector ? "." : " or run `wayai use <hub>` first."}`
   }
   const liveFiles = readDirToFileMap(hubFolder);
   if (Object.keys(liveFiles).length === 0) {
-    console.error(`Source hub folder has no files to freeze: ${path25.relative(gitRoot, hubFolder)}`);
+    console.error(`Source hub folder has no files to freeze: ${path26.relative(gitRoot, hubFolder)}`);
     process.exit(1);
   }
   const sanitized = sanitizeWayaiSliceFiles(liveFiles);
-  const relDest = path25.relative(gitRoot, dest);
-  const relSrc = path25.relative(gitRoot, hubFolder);
+  const relDest = path26.relative(gitRoot, dest);
+  const relSrc = path26.relative(gitRoot, hubFolder);
   if (dryRun) {
     const existing = new Set(listDirRelFiles(dest));
     const nextKeys = new Set(Object.keys(sanitized));
@@ -19360,7 +19456,7 @@ async function runTemplatePull2(positional, flagArgs) {
     console.log(JSON.stringify(detail, null, 2));
     return;
   }
-  const target = outDir ? path25.resolve(outDir) : path25.join(process.cwd(), "template-store-pull", slug);
+  const target = outDir ? path26.resolve(outDir) : path26.join(process.cwd(), "template-store-pull", slug);
   const written = writeFileMap(target, detail.files);
   console.log(`Pulled "${slug}" from the store \u2192 ${target} (${written.length} file${written.length === 1 ? "" : "s"}).`);
   const uses = detail.uses ?? [];
@@ -19383,13 +19479,13 @@ async function runSkillInstall(positional) {
     throw err;
   }
   const root = findGitRoot() ?? process.cwd();
-  const present = HARNESS_SKILL_DIRS.filter((dir) => fs19.existsSync(path25.join(root, dir)));
+  const present = HARNESS_SKILL_DIRS.filter((dir) => fs20.existsSync(path26.join(root, dir)));
   const targets = present.length > 0 ? present : HARNESS_SKILL_DIRS;
   const fileCount = Object.keys(res.files).length;
   const relDirs = targets.map((harness) => {
-    const targetDir = path25.join(root, harness, "skills", name);
+    const targetDir = path26.join(root, harness, "skills", name);
     writeFileMap(targetDir, res.files);
-    return `${path25.relative(root, targetDir)}/`;
+    return `${path26.relative(root, targetDir)}/`;
   });
   console.log(`Installed skill "${name}" (${fileCount} file${fileCount === 1 ? "" : "s"}) \u2192 ${relDirs.join(", ")}`);
   console.log("Reload your agent (e.g. restart Claude Code) to pick up the skill.");
@@ -20668,7 +20764,7 @@ var init_update = __esm({
 init_sentry();
 import { readFileSync as readFileSync18 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname9, join as join24 } from "path";
+import { dirname as dirname9, join as join25 } from "path";
 
 // src/lib/errors.ts
 init_api_client();
@@ -20848,7 +20944,7 @@ Run \`wayai admin skill install\` to update.`);
 
 // src/index.ts
 var __dirname = dirname9(fileURLToPath2(import.meta.url));
-var pkg = JSON.parse(readFileSync18(join24(__dirname, "..", "package.json"), "utf-8"));
+var pkg = JSON.parse(readFileSync18(join25(__dirname, "..", "package.json"), "utf-8"));
 var [, , command, ...args] = process.argv;
 var isBackgroundRefresh = command === REFRESH_COMMAND;
 if (!isBackgroundRefresh) initSentry(command, pkg.version);