hubify 1.0.0 → 1.5.0

package/dist/index.js

@@ -7,9 +7,9 @@ import {
 } from "./chunk-FW7BS3MW.js";
 
 // src/index.ts
-import { Command as Command53 } from "commander";
-import chalk56 from "chalk";
-import fs26 from "fs";
+import { Command as Command58 } from "commander";
+import chalk61 from "chalk";
+import fs28 from "fs";
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/external.js
 var external_exports = {};
@@ -489,8 +489,8 @@ function getErrorMap() {
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
 var 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
@@ -606,11 +606,11 @@ var errorUtil;
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.js
 var 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() {
@@ -4410,7 +4410,7 @@ var rl = readline.createInterface({
   input: process.stdin,
   output: process.stdout
 });
-var question = (prompt) => new Promise((resolve11) => rl.question(prompt, resolve11));
+var question = (prompt) => new Promise((resolve12) => rl.question(prompt, resolve12));
 var initCommand = new Command("init").description("Initialize Hubify in the current project or globally").option("--agent-id <id>", "Set agent ID").option("--platform <name>", "Set platform (claude-code, cursor, etc.)").option("--global", "Initialize global config (~/.hubify)").option("--non-interactive", "Skip prompts, use defaults").action(async (options) => {
   const spinner = ora();
   const isGlobal = options.global;
@@ -5806,15 +5806,15 @@ var challengesCommand = new Command5("challenges").description("View and respond
 var respondCommand = new Command5("respond").description("Respond to a verification challenge").argument("<challenge-id>", "Challenge ID to respond to").option("--agent-id <id>", "Agent ID (default: cli-user)").option("--output <text>", "Full output from re-execution").option("--output-file <path>", "Read output from file").action(async (challengeId, options) => {
   const spinner = ora5();
   const client = getClient();
-  const fs27 = await import("fs");
+  const fs29 = await import("fs");
   const resolvedAgentId = options.agentId || process.env.HUBIFY_AGENT_ID || "cli-user";
   try {
     let output = options.output;
     if (options.outputFile) {
-      if (!fs27.existsSync(options.outputFile)) {
+      if (!fs29.existsSync(options.outputFile)) {
         throw new Error(`Output file not found: ${options.outputFile}`);
       }
-      output = fs27.readFileSync(options.outputFile, "utf-8");
+      output = fs29.readFileSync(options.outputFile, "utf-8");
     }
     if (!output) {
       throw new Error("Must provide --output or --output-file");
@@ -5923,11 +5923,11 @@ function formatVerificationLevel(level) {
 }
 async function readStdinJson() {
   if (process.stdin.isTTY) return {};
-  const raw = await new Promise((resolve11, reject) => {
+  const raw = await new Promise((resolve12, reject) => {
     let data = "";
     process.stdin.setEncoding("utf8");
     process.stdin.on("data", (chunk) => data += chunk);
-    process.stdin.on("end", () => resolve11(data));
+    process.stdin.on("end", () => resolve12(data));
     process.stdin.on("error", reject);
   });
   const trimmed = raw.trim();
@@ -5974,7 +5974,7 @@ Skill not found: ${skill}
 \u{1F504} Checking ${skillsToUpdate.length} skill(s) for updates...
 `));
     spinner.start("Checking for updates...");
-    await new Promise((resolve11) => setTimeout(resolve11, 500));
+    await new Promise((resolve12) => setTimeout(resolve12, 500));
     spinner.stop();
     const updates = skillsToUpdate.map((name) => ({
       name,
@@ -6002,7 +6002,7 @@ Skill not found: ${skill}
     }
     spinner.start("Applying updates...");
     for (const update of availableUpdates) {
-      await new Promise((resolve11) => setTimeout(resolve11, 200));
+      await new Promise((resolve12) => setTimeout(resolve12, 200));
     }
     spinner.succeed(`Updated ${availableUpdates.length} skill(s)`);
     console.log();
@@ -6837,9 +6837,9 @@ async function fetchSkillMd(entry) {
     `SKILL.md`
   ];
   for (const branch of branches) {
-    for (const path26 of paths) {
+    for (const path27 of paths) {
       try {
-        const url = `https://raw.githubusercontent.com/${entry.owner}/${entry.repo}/${branch}/${path26}`;
+        const url = `https://raw.githubusercontent.com/${entry.owner}/${entry.repo}/${branch}/${path27}`;
         const response = await fetch(url);
         if (response.ok) {
           return await response.text();
@@ -8119,7 +8119,7 @@ var createReadline = () => readline2.createInterface({
   input: process.stdin,
   output: process.stdout
 });
-var question2 = (rl4, prompt) => new Promise((resolve11) => rl4.question(prompt, resolve11));
+var question2 = (rl4, prompt) => new Promise((resolve12) => rl4.question(prompt, resolve12));
 function getAnthropicApiKey() {
   if (process.env.ANTHROPIC_API_KEY) {
     return process.env.ANTHROPIC_API_KEY;
@@ -14580,11 +14580,11 @@ async function fetchGitHubApi2(endpoint) {
     return null;
   }
 }
-async function fetchRawContent2(owner, repo, path26, branch = "main") {
+async function fetchRawContent2(owner, repo, path27, branch = "main") {
   const branches = [branch, "master"];
   for (const b of branches) {
     try {
-      const url = `https://raw.githubusercontent.com/${owner}/${repo}/${b}/${path26}`;
+      const url = `https://raw.githubusercontent.com/${owner}/${repo}/${b}/${path27}`;
       const headers = { "User-Agent": "hubify-cli" };
       const token = process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
       if (token) {
@@ -14934,7 +14934,7 @@ function formatDuration2(ms) {
 }
 async function runSeedCommand(source, options) {
   const { spawn } = await import("child_process");
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     const args = [source.commandName];
     if (options.dryRun) args.push("--dry-run");
     if (options.force) args.push("--force");
@@ -14955,7 +14955,7 @@ async function runSeedCommand(source, options) {
       const importMatch = stdout.match(/Imported:\s*(\d+)/);
       const skipMatch = stdout.match(/Skipped:\s*(\d+)/);
       const failMatch = stdout.match(/Failed:\s*(\d+)/);
-      resolve11({
+      resolve12({
         imported: importMatch ? parseInt(importMatch[1]) : 0,
         skipped: skipMatch ? parseInt(skipMatch[1]) : 0,
         failed: failMatch ? parseInt(failMatch[1]) : code !== 0 ? source.skillCount : 0,
@@ -14963,7 +14963,7 @@ async function runSeedCommand(source, options) {
       });
     });
     proc.on("error", () => {
-      resolve11({
+      resolve12({
         imported: 0,
         skipped: 0,
         failed: source.skillCount,
@@ -15673,8 +15673,8 @@ soulCommand.command("create").description("Create a new soul interactively").act
     output: process.stdout
   });
   const question5 = (prompt) => {
-    return new Promise((resolve11) => {
-      rl4.question(prompt, resolve11);
+    return new Promise((resolve12) => {
+      rl4.question(prompt, resolve12);
     });
   };
   try {
@@ -15911,8 +15911,8 @@ soulCommand.command("fork").argument("<name>", "Name of the soul to fork").descr
         output: process.stdout
       });
       const question5 = (prompt) => {
-        return new Promise((resolve11) => {
-          rl4.question(prompt, resolve11);
+        return new Promise((resolve12) => {
+          rl4.question(prompt, resolve12);
         });
       };
       const nameInput = await question5(
@@ -20869,11 +20869,11 @@ squadCommand.command("init").description("Initialize a local squad from a pack t
       return;
     }
     spinner.text = "Generating local files...";
-    const fs27 = await import("fs");
-    const path26 = await import("path");
+    const fs29 = await import("fs");
+    const path27 = await import("path");
     const dir = options.dir || ".hubify";
-    const basePath = path26.resolve(process.cwd(), dir);
-    fs27.mkdirSync(basePath, { recursive: true });
+    const basePath = path27.resolve(process.cwd(), dir);
+    fs29.mkdirSync(basePath, { recursive: true });
     const squadMd = [
       `# ${pack.display_name}`,
       "",
@@ -20901,7 +20901,7 @@ squadCommand.command("init").description("Initialize a local squad from a pack t
         ""
       ].filter(Boolean).join("\n"))
     ].join("\n");
-    fs27.writeFileSync(path26.join(basePath, "squad.md"), squadMd);
+    fs29.writeFileSync(path27.join(basePath, "squad.md"), squadMd);
     const missionMd = [
       `# Mission Brief`,
       "",
@@ -20922,12 +20922,12 @@ ${pack.default_phases.map((p, i) => `${i + 1}. ${p.name}`).join("\n")}` : "",
       `## Notes`,
       `<!-- Additional context, constraints, or references -->`
     ].join("\n");
-    fs27.writeFileSync(path26.join(basePath, "mission.md"), missionMd);
-    const agentsDir = path26.join(basePath, "agents");
-    fs27.mkdirSync(agentsDir, { recursive: true });
+    fs29.writeFileSync(path27.join(basePath, "mission.md"), missionMd);
+    const agentsDir = path27.join(basePath, "agents");
+    fs29.mkdirSync(agentsDir, { recursive: true });
     for (const member of pack.members) {
-      const memberDir = path26.join(agentsDir, member.role);
-      fs27.mkdirSync(memberDir, { recursive: true });
+      const memberDir = path27.join(agentsDir, member.role);
+      fs29.mkdirSync(memberDir, { recursive: true });
       const agentMd = [
         `# Agent: ${member.role}`,
         "",
@@ -20943,7 +20943,7 @@ ${pack.default_phases.map((p, i) => `${i + 1}. ${p.name}`).join("\n")}` : "",
         member.default_tools ? `## Tools
 ${member.default_tools.map((t) => `- ${t}`).join("\n")}` : ""
       ].join("\n");
-      fs27.writeFileSync(path26.join(memberDir, "agent.md"), agentMd);
+      fs29.writeFileSync(path27.join(memberDir, "agent.md"), agentMd);
       const soulMd = [
         `# Soul: ${member.soul_name}`,
         "",
@@ -20956,7 +20956,7 @@ ${member.default_tools.map((t) => `- ${t}`).join("\n")}` : ""
         `## Responsibilities`,
         ...member.responsibilities.map((r) => `- ${r}`)
       ].join("\n");
-      fs27.writeFileSync(path26.join(memberDir, "soul.md"), soulMd);
+      fs29.writeFileSync(path27.join(memberDir, "soul.md"), soulMd);
     }
     spinner.succeed(`Squad initialized in ${dir}/`);
     console.log();
@@ -21084,6 +21084,70 @@ squadCommand.command("event").description("Post a manual event to the squad acti
     process.exit(1);
   }
 });
+squadCommand.command("pause <squad-id>").description("Pause a deployed squad (disables standups and autonomy)").option("--owner <id>", "Owner user ID").action(async (squadId, options) => {
+  const spinner = ora26();
+  try {
+    spinner.start("Pausing squad...");
+    const client = getClient();
+    await client.mutation(
+      toFunctionName(api.squads.pauseSquad),
+      { squad_id: squadId, owner_id: options.owner || "" }
+    );
+    spinner.succeed("Squad paused");
+    console.log(chalk29.yellow("\n  Standups and autonomy processing disabled."));
+    console.log(chalk29.gray("  Use `hubify squad resume` to re-enable.\n"));
+  } catch (error) {
+    spinner.fail("Failed to pause squad");
+    console.error(chalk29.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+});
+squadCommand.command("resume <squad-id>").description("Resume a paused squad (re-enables standups and autonomy)").option("--owner <id>", "Owner user ID").action(async (squadId, options) => {
+  const spinner = ora26();
+  try {
+    spinner.start("Resuming squad...");
+    const client = getClient();
+    await client.mutation(
+      toFunctionName(api.squads.resumeSquad),
+      { squad_id: squadId, owner_id: options.owner || "" }
+    );
+    spinner.succeed("Squad resumed");
+    console.log(chalk29.green("\n  Standups and autonomy processing re-enabled.\n"));
+  } catch (error) {
+    spinner.fail("Failed to resume squad");
+    console.error(chalk29.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+});
+squadCommand.command("remove <squad-id>").description("Remove a deployed squad from your workspace (marks as deprecated)").option("--owner <id>", "Owner user ID").option("--force", "Skip confirmation").action(async (squadId, options) => {
+  const spinner = ora26();
+  try {
+    if (!options.force) {
+      const readline7 = await import("readline");
+      const rl4 = readline7.createInterface({ input: process.stdin, output: process.stdout });
+      const answer = await new Promise((resolve12) => {
+        rl4.question(chalk29.yellow("  Remove this squad? This cannot be undone. (y/N): "), resolve12);
+      });
+      rl4.close();
+      if (answer.toLowerCase() !== "y") {
+        console.log(chalk29.gray("  Cancelled.\n"));
+        return;
+      }
+    }
+    spinner.start("Removing squad...");
+    const client = getClient();
+    await client.mutation(
+      toFunctionName(api.squads.removeSquad),
+      { squad_id: squadId, owner_id: options.owner || "" }
+    );
+    spinner.succeed("Squad removed");
+    console.log(chalk29.red("\n  Squad deprecated and removed from workspace.\n"));
+  } catch (error) {
+    spinner.fail("Failed to remove squad");
+    console.error(chalk29.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+});
 
 // src/commands/skill-gen.ts
 import { Command as Command27 } from "commander";
@@ -21663,7 +21727,7 @@ async function promptForResult() {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     console.log();
     console.log(chalk31.cyan("  Execution complete. Please report the result:"));
     console.log();
@@ -21675,11 +21739,11 @@ async function promptForResult() {
       rl4.close();
       const choice = answer.toLowerCase().trim();
       if (choice === "s" || choice === "success") {
-        resolve11(true);
+        resolve12(true);
       } else if (choice === "f" || choice === "failed" || choice === "fail") {
-        resolve11(false);
+        resolve12(false);
       } else {
-        resolve11(void 0);
+        resolve12(void 0);
       }
     });
   });
@@ -21799,7 +21863,7 @@ var rl2 = readline5.createInterface({
   input: process.stdin,
   output: process.stdout
 });
-var question3 = (prompt) => new Promise((resolve11) => rl2.question(prompt, resolve11));
+var question3 = (prompt) => new Promise((resolve12) => rl2.question(prompt, resolve12));
 var hubInitCommand = new Command29("workspace-init").description("Initialize a Hubify hub in the current directory").option("--name <name>", "Hub name (defaults to directory name)").option("--non-interactive", "Skip prompts, use defaults").action(async (options) => {
   const spinner = ora29();
   try {
@@ -22052,6 +22116,188 @@ function saveConnectState(state) {
   if (!fs13.existsSync(dir)) fs13.mkdirSync(dir, { recursive: true });
   fs13.writeFileSync(HUBIFY_STATE_FILE, JSON.stringify(state, null, 2));
 }
+function collectDirFiles(dirPath, extensions) {
+  const files = [];
+  let bundle = "";
+  let totalBytes = 0;
+  if (!fs13.existsSync(dirPath)) return { files, bundle, totalBytes };
+  const entries = fs13.readdirSync(dirPath);
+  for (const entry of entries) {
+    if (!extensions.some((ext) => entry.endsWith(ext))) continue;
+    const fullPath = path13.join(dirPath, entry);
+    try {
+      const stat = fs13.statSync(fullPath);
+      const content = fs13.readFileSync(fullPath, "utf-8");
+      const hash = hashContent(content);
+      files.push({ path: entry, size: stat.size, hash, mtime: stat.mtimeMs });
+      bundle += `
+
+### ${entry}
+
+${content}`;
+      totalBytes += stat.size;
+    } catch {
+    }
+  }
+  return { files, bundle: bundle.trimStart(), totalBytes };
+}
+async function pushContextFile(filePath, contextType, hubId, machineId) {
+  if (!fs13.existsSync(filePath)) return null;
+  const content = fs13.readFileSync(filePath, "utf-8");
+  const stat = fs13.statSync(filePath);
+  const fileHash = hashContent(content);
+  const client = getClient();
+  const result = await client.mutation(toFunctionName(api.workspaceSync.pushWorkspaceContext), {
+    hub_id: hubId,
+    local_machine_id: machineId,
+    context_type: contextType,
+    content,
+    file_hash: fileHash,
+    timestamp: stat.mtimeMs,
+    metadata: {
+      file_count: 1,
+      total_size: content.length
+    }
+  });
+  return { status: result.status, bytes: content.length };
+}
+async function pushContextDir(dirPath, contextType, extensions, hubId, machineId) {
+  const { files, bundle, totalBytes } = collectDirFiles(dirPath, extensions);
+  if (files.length === 0) return null;
+  const bundleHash = hashContent(bundle);
+  const client = getClient();
+  const result = await client.mutation(toFunctionName(api.workspaceSync.pushWorkspaceContext), {
+    hub_id: hubId,
+    local_machine_id: machineId,
+    context_type: contextType,
+    content: bundle,
+    file_hash: bundleHash,
+    timestamp: Date.now(),
+    metadata: {
+      file_count: files.length,
+      total_size: totalBytes,
+      files
+    }
+  });
+  return { status: result.status, fileCount: files.length, bytes: totalBytes };
+}
+async function pullWorkspaceContextToLocal(projectRoot, hubId) {
+  const client = getClient();
+  let pulled = 0;
+  let unchanged = 0;
+  let bytes = 0;
+  const contexts = await client.query(toFunctionName(api.workspaceSync.pullWorkspaceContext), {
+    hub_id: hubId
+  });
+  for (const [contextType, data] of Object.entries(contexts)) {
+    if (!data?.content) continue;
+    const fileMap = {
+      soul: path13.join(projectRoot, "SOUL.md"),
+      memory: path13.join(projectRoot, "MEMORY.md"),
+      agents: path13.join(projectRoot, "AGENTS.md")
+    };
+    if (fileMap[contextType]) {
+      const localPath = fileMap[contextType];
+      const localHash = fs13.existsSync(localPath) ? hashContent(fs13.readFileSync(localPath, "utf-8")) : null;
+      if (localHash === data.file_hash) {
+        unchanged++;
+        continue;
+      }
+      const localMtime = fs13.existsSync(localPath) ? fs13.statSync(localPath).mtimeMs : 0;
+      if (data.file_timestamp && localMtime > data.file_timestamp) {
+        unchanged++;
+        continue;
+      }
+      fs13.writeFileSync(localPath, data.content, "utf-8");
+      bytes += data.content.length;
+      pulled++;
+    } else if (contextType === "memories" && data.content) {
+      const memoriesDir = path13.join(projectRoot, "memory");
+      if (!fs13.existsSync(memoriesDir)) {
+        fs13.mkdirSync(memoriesDir, { recursive: true });
+      }
+      const outPath = path13.join(memoriesDir, "cloud-sync.md");
+      const localHash = fs13.existsSync(outPath) ? hashContent(fs13.readFileSync(outPath, "utf-8")) : null;
+      if (localHash !== data.file_hash) {
+        fs13.writeFileSync(outPath, data.content, "utf-8");
+        bytes += data.content.length;
+        pulled++;
+      } else {
+        unchanged++;
+      }
+    }
+  }
+  return { pulled, unchanged, bytes };
+}
+async function pushFullWorkspaceContext(projectRoot, hubId, machineId) {
+  const contextTypes = [];
+  let totalFiles = 0;
+  let totalBytes = 0;
+  let unchanged = 0;
+  const soulResult = await pushContextFile(
+    path13.join(projectRoot, "SOUL.md"),
+    "soul",
+    hubId,
+    machineId
+  ).catch(() => null);
+  if (soulResult) {
+    if (soulResult.status === "unchanged") {
+      unchanged++;
+    } else {
+      contextTypes.push("soul");
+      totalFiles++;
+      totalBytes += soulResult.bytes;
+    }
+  }
+  const agentsResult = await pushContextFile(
+    path13.join(projectRoot, "AGENTS.md"),
+    "agents",
+    hubId,
+    machineId
+  ).catch(() => null);
+  if (agentsResult) {
+    if (agentsResult.status === "unchanged") {
+      unchanged++;
+    } else {
+      contextTypes.push("agents");
+      totalFiles++;
+      totalBytes += agentsResult.bytes;
+    }
+  }
+  const memResult = await pushContextDir(
+    path13.join(projectRoot, "memory"),
+    "memories",
+    [".md"],
+    hubId,
+    machineId
+  ).catch(() => null);
+  if (memResult) {
+    if (memResult.status === "unchanged") {
+      unchanged++;
+    } else {
+      contextTypes.push("memories");
+      totalFiles += memResult.fileCount;
+      totalBytes += memResult.bytes;
+    }
+  }
+  const skillsResult = await pushContextDir(
+    path13.join(projectRoot, "skills"),
+    "skills",
+    [".md", ".ts", ".js", ".yaml", ".yml"],
+    hubId,
+    machineId
+  ).catch(() => null);
+  if (skillsResult) {
+    if (skillsResult.status === "unchanged") {
+      unchanged++;
+    } else {
+      contextTypes.push("skills");
+      totalFiles += skillsResult.fileCount;
+      totalBytes += skillsResult.bytes;
+    }
+  }
+  return { contextTypes, totalFiles, totalBytes, unchanged };
+}
 async function pushLocalMemoryToHub(memoryDir, hubId, agentId, platform2, cache) {
   if (!fs13.existsSync(memoryDir)) return { pushed: 0, unchanged: 0 };
   const client = getClient();
@@ -22144,7 +22390,7 @@ async function pullHubMemoryToLocal(memoryDir, hubId, agentId, cache) {
   }
   return { pulled };
 }
-var createHubConnectCommand = () => new Command30("connect").description("Connect this machine to a Hubify hub and start local\u2194cloud memory sync").option("--platform <name>", "Platform name (openclaw, claude-code, cursor, etc.)").option("--hub-id <id>", "Hub ID (overrides HUB.yaml)").option("--subdomain <name>", "Hub subdomain (e.g. 'houston' for houston.hubify.com)").option("--memory-dir <path>", "Local memory directory to sync (default: ~/clawd/memory)").option("--watch", "Keep process running and watch for file changes").option("--once", "Sync once and exit (no watch loop)").action(async (options) => {
+var createHubConnectCommand = () => new Command30("connect").description("Connect this machine to a Hubify hub and start local\u2194cloud memory sync").option("--platform <name>", "Platform name (openclaw, claude-code, cursor, etc.)").option("--hub-id <id>", "Hub ID (overrides HUB.yaml)").option("--subdomain <name>", "Hub subdomain (e.g. 'houston' for houston.hubify.com)").option("--memory-dir <path>", "Local memory directory to sync (default: ~/clawd/memory)").option("--watch", "Keep process running and watch for file changes").option("--once", "Sync once and exit (no watch loop)").option("--full", "Sync full workspace context (SOUL.md, AGENTS.md, memory/, skills/) in addition to memory files").action(async (options) => {
   const spinner = ora30();
   try {
     console.log(chalk33.cyan("\n\u{1F517} Hubify Connect \u2014 Local \u2194 Cloud Sync\n"));
@@ -22250,6 +22496,33 @@ var createHubConnectCommand = () => new Command30("connect").description("Connec
     state.last_sync_at = Date.now();
     saveConnectState(state);
     console.log(chalk33.green(`  \u2705 Pushed: ${pushResult.pushed} files  |  Pulled: ${pullResult.pulled} files  |  Unchanged: ${pushResult.unchanged}`));
+    if (options.full) {
+      console.log(chalk33.cyan("\n\u{1F4E6} Full workspace context sync...\n"));
+      const projectRoot = process.cwd();
+      try {
+        const wsSpinner = ora30("Pushing workspace context (SOUL.md, AGENTS.md, memory/, skills/)...").start();
+        const wsResult = await pushFullWorkspaceContext(projectRoot, hubId, machineId);
+        wsSpinner.succeed(
+          `Workspace push complete \u2014 ` + chalk33.green(`${wsResult.totalFiles} files`) + chalk33.gray(` (${(wsResult.totalBytes / 1024).toFixed(1)} KB)`) + (wsResult.unchanged > 0 ? chalk33.gray(`  ${wsResult.unchanged} unchanged`) : "")
+        );
+        if (wsResult.contextTypes.length > 0) {
+          console.log(chalk33.gray(`  Context types: ${wsResult.contextTypes.join(", ")}`));
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(chalk33.yellow(`  Warning: workspace context push failed (${msg})`));
+      }
+      try {
+        const pullSpinner = ora30("Pulling workspace context from cloud...").start();
+        const wsPull = await pullWorkspaceContextToLocal(projectRoot, hubId);
+        pullSpinner.succeed(
+          `Workspace pull complete \u2014 ` + chalk33.green(`${wsPull.pulled} files updated`) + chalk33.gray(`  ${wsPull.unchanged} already in sync`) + (wsPull.bytes > 0 ? chalk33.gray(`  (${(wsPull.bytes / 1024).toFixed(1)} KB)`) : "")
+        );
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(chalk33.yellow(`  Warning: workspace context pull failed (${msg})`));
+      }
+    }
     if (options.once) {
       console.log(chalk33.gray("\n  Sync complete (--once mode). Exiting.\n"));
       process.exit(0);
@@ -22268,6 +22541,18 @@ var createHubConnectCommand = () => new Command30("connect").description("Connec
           if (p.pushed > 0 || q.pulled > 0) {
             console.log(chalk33.gray(`  [${now}] \u2191 ${p.pushed} pushed  \u2193 ${q.pulled} pulled`));
           }
+          if (options.full) {
+            const projectRoot = process.cwd();
+            const wsResult = await pushFullWorkspaceContext(projectRoot, hubId, machineId).catch(() => null);
+            const wsPull = await pullWorkspaceContextToLocal(projectRoot, hubId).catch(() => null);
+            if (wsResult && (wsResult.totalFiles > 0 || wsResult.unchanged === 0)) {
+              const pulled = wsPull?.pulled ?? 0;
+              const pushed = wsResult.totalFiles;
+              if (pushed > 0 || pulled > 0) {
+                console.log(chalk33.gray(`  [${now}] workspace \u2191 ${pushed} ctx  \u2193 ${pulled} ctx`));
+              }
+            }
+          }
           state.last_sync_at = Date.now();
           saveConnectState(state);
         } catch (err) {
@@ -22305,9 +22590,12 @@ var createHubConnectCommand = () => new Command30("connect").description("Connec
     } else {
       console.log(chalk33.green("\n\u2705 Hub connected!\n"));
       console.log(chalk33.white("Next steps:"));
-      console.log(chalk33.cyan("  hubify connect --watch") + chalk33.gray("  \u2014 keep running and auto-sync"));
-      console.log(chalk33.cyan("  hubify status") + chalk33.gray("           \u2014 show sync status & connected machines"));
-      console.log(chalk33.cyan("  hubify connect --once") + chalk33.gray("   \u2014 sync once and exit"));
+      console.log(chalk33.cyan("  hubify connect --watch") + chalk33.gray("       \u2014 keep running and auto-sync"));
+      console.log(chalk33.cyan("  hubify connect --watch --full") + chalk33.gray("  \u2014 auto-sync + full workspace context"));
+      console.log(chalk33.cyan("  hubify status") + chalk33.gray("                \u2014 show sync status & connected machines"));
+      console.log(chalk33.cyan("  hubify sync push") + chalk33.gray("             \u2014 push workspace context once"));
+      console.log(chalk33.cyan("  hubify sync pull") + chalk33.gray("             \u2014 pull workspace context from cloud"));
+      console.log(chalk33.cyan("  hubify connect --once") + chalk33.gray("        \u2014 sync once and exit"));
       console.log();
       console.log(chalk33.gray(`  State saved to: ${HUBIFY_STATE_FILE}`));
       console.log();
@@ -22681,14 +22969,14 @@ ${content}`,
   }
   return stats;
 }
-function createApiProxy(path26 = []) {
+function createApiProxy(path27 = []) {
   return new Proxy(() => {
   }, {
     get(_target, prop) {
-      return createApiProxy([...path26, prop]);
+      return createApiProxy([...path27, prop]);
     },
     apply() {
-      return path26.join(":");
+      return path27.join(":");
     }
   });
 }
@@ -23307,7 +23595,7 @@ var rl3 = readline6.createInterface({
   input: process.stdin,
   output: process.stdout
 });
-var question4 = (prompt) => new Promise((resolve11) => rl3.question(prompt, resolve11));
+var question4 = (prompt) => new Promise((resolve12) => rl3.question(prompt, resolve12));
 var hubCommand = new Command34("hub").description("Manage .hub manifest files for skills and agents");
 var initSubcommand = new Command34("init").description("Create a .hub manifest file for a skill, agent, or soul").argument("[directory]", "Directory containing the skill/agent (default: current directory)").option("--type <type>", "Type: skill, agent, or soul", "skill").option("--name <name>", "Name for the .hub file").option("--non-interactive", "Skip prompts, use defaults").action(async (directory, options) => {
   const spinner = ora34();
@@ -24166,6 +24454,8 @@ import chalk38 from "chalk";
 import ora35 from "ora";
 import fs19 from "fs";
 import path19 from "path";
+import crypto5 from "crypto";
+import os10 from "os";
 function readHubifyFrameworkType(workDir) {
   const configPath = path19.join(workDir, "hubify.json");
   if (!fs19.existsSync(configPath)) return null;
@@ -24384,9 +24674,406 @@ var statsCommand3 = new Command35("stats").description("Show sync statistics").a
     throw error;
   }
 });
+function hashContent3(content) {
+  return crypto5.createHash("sha256").update(content).digest("hex");
+}
+function collectDirFiles2(dirPath, extensions) {
+  const files = [];
+  let bundle = "";
+  let totalBytes = 0;
+  if (!fs19.existsSync(dirPath)) return { files, bundle, totalBytes };
+  for (const entry of fs19.readdirSync(dirPath)) {
+    if (!extensions.some((ext) => entry.endsWith(ext))) continue;
+    const fullPath = path19.join(dirPath, entry);
+    try {
+      const stat = fs19.statSync(fullPath);
+      const content = fs19.readFileSync(fullPath, "utf-8");
+      files.push({ path: entry, size: stat.size, hash: hashContent3(content), mtime: stat.mtimeMs });
+      bundle += `
+
+### ${entry}
+
+${content}`;
+      totalBytes += stat.size;
+    } catch {
+    }
+  }
+  return { files, bundle: bundle.trimStart(), totalBytes };
+}
+function resolveHubId(options) {
+  if (options.hub) return options.hub;
+  const stateFile = path19.join(os10.homedir(), ".hubify", "connect-state.json");
+  if (fs19.existsSync(stateFile)) {
+    try {
+      const state = JSON.parse(fs19.readFileSync(stateFile, "utf-8"));
+      if (state.hub_id) return state.hub_id;
+    } catch {
+    }
+  }
+  let dir = process.cwd();
+  while (dir !== "/" && dir !== os10.homedir()) {
+    const yamlPath = path19.join(dir, "HUB.yaml");
+    if (fs19.existsSync(yamlPath)) {
+      try {
+        const lines = fs19.readFileSync(yamlPath, "utf-8").split("\n");
+        for (const line of lines) {
+          const m = line.match(/^\s*id\s*:\s*(.+)/);
+          if (m) return m[1].trim().replace(/^["']|["']$/g, "");
+        }
+      } catch {
+      }
+    }
+    dir = path19.dirname(dir);
+  }
+  return null;
+}
+function getMachineId2() {
+  const stateFile = path19.join(os10.homedir(), ".hubify", "connect-state.json");
+  if (fs19.existsSync(stateFile)) {
+    try {
+      const state = JSON.parse(fs19.readFileSync(stateFile, "utf-8"));
+      if (state.machine_id) return state.machine_id;
+    } catch {
+    }
+  }
+  return crypto5.createHash("sha256").update(os10.hostname()).digest("hex").slice(0, 16);
+}
+var pushCommand = new Command35("push").description("Push local workspace context (SOUL.md, AGENTS.md, memory/, skills/) to Convex hub").option("--hub <id>", "Hub ID (default: from connect-state or HUB.yaml)").option("--dir <path>", "Project root to sync from (default: current directory)").option("--dry-run", "Show what would be pushed without actually pushing").action(async (options) => {
+  const spinner = ora35();
+  const client = getClient();
+  console.log(chalk38.cyan("\n  Workspace Sync \u2014 Push\n"));
+  const hubId = resolveHubId(options);
+  if (!hubId) {
+    console.log(chalk38.red("  No hub ID found."));
+    console.log(chalk38.yellow("  Run 'hubify connect' first, or pass --hub <id>"));
+    process.exit(1);
+  }
+  const machineId = getMachineId2();
+  const projectRoot = options.dir ? path19.resolve(options.dir) : process.cwd();
+  console.log(chalk38.gray(`  Hub:     ${hubId.slice(0, 20)}...`));
+  console.log(chalk38.gray(`  Root:    ${projectRoot}`));
+  if (options.dryRun) console.log(chalk38.yellow("  Mode:    dry-run (no writes)\n"));
+  else console.log();
+  const results = [];
+  let totalConflicts = 0;
+  const soulPath = path19.join(projectRoot, "SOUL.md");
+  spinner.start("Checking SOUL.md...");
+  if (fs19.existsSync(soulPath)) {
+    try {
+      const content = fs19.readFileSync(soulPath, "utf-8");
+      const stat = fs19.statSync(soulPath);
+      const fileHash = hashContent3(content);
+      const conflictCheck = await client.query(toFunctionName(api.workspaceSync.checkSyncStatus), {
+        hub_id: hubId,
+        local_file_hashes: { soul: fileHash }
+      });
+      if (!conflictCheck.in_sync) totalConflicts += conflictCheck.conflicts.length;
+      if (!options.dryRun) {
+        const res = await client.mutation(toFunctionName(api.workspaceSync.pushWorkspaceContext), {
+          hub_id: hubId,
+          local_machine_id: machineId,
+          context_type: "soul",
+          content,
+          file_hash: fileHash,
+          timestamp: stat.mtimeMs,
+          metadata: { file_count: 1, total_size: content.length }
+        });
+        results.push({ type: "soul (SOUL.md)", status: res.status, files: 1, bytes: content.length });
+        spinner.succeed(`SOUL.md \u2014 ${res.status}  (${content.length} bytes)`);
+      } else {
+        results.push({ type: "soul (SOUL.md)", status: "dry-run", files: 1, bytes: content.length });
+        spinner.info(`SOUL.md \u2014 would push  (${content.length} bytes)`);
+      }
+    } catch (err) {
+      spinner.fail(`SOUL.md failed: ${err instanceof Error ? err.message : err}`);
+    }
+  } else {
+    spinner.info("SOUL.md \u2014 not found, skipping");
+  }
+  const agentsPath = path19.join(projectRoot, "AGENTS.md");
+  spinner.start("Checking AGENTS.md...");
+  if (fs19.existsSync(agentsPath)) {
+    try {
+      const content = fs19.readFileSync(agentsPath, "utf-8");
+      const stat = fs19.statSync(agentsPath);
+      const fileHash = hashContent3(content);
+      const conflictCheck = await client.query(toFunctionName(api.workspaceSync.checkSyncStatus), {
+        hub_id: hubId,
+        local_file_hashes: { agents: fileHash }
+      });
+      if (!conflictCheck.in_sync) totalConflicts += conflictCheck.conflicts.length;
+      if (!options.dryRun) {
+        const res = await client.mutation(toFunctionName(api.workspaceSync.pushWorkspaceContext), {
+          hub_id: hubId,
+          local_machine_id: machineId,
+          context_type: "agents",
+          content,
+          file_hash: fileHash,
+          timestamp: stat.mtimeMs,
+          metadata: { file_count: 1, total_size: content.length }
+        });
+        results.push({ type: "agents (AGENTS.md)", status: res.status, files: 1, bytes: content.length });
+        spinner.succeed(`AGENTS.md \u2014 ${res.status}  (${content.length} bytes)`);
+      } else {
+        results.push({ type: "agents (AGENTS.md)", status: "dry-run", files: 1, bytes: content.length });
+        spinner.info(`AGENTS.md \u2014 would push  (${content.length} bytes)`);
+      }
+    } catch (err) {
+      spinner.fail(`AGENTS.md failed: ${err instanceof Error ? err.message : err}`);
+    }
+  } else {
+    spinner.info("AGENTS.md \u2014 not found, skipping");
+  }
+  const memoryDir = path19.join(projectRoot, "memory");
+  spinner.start("Checking memory/...");
+  const memData = collectDirFiles2(memoryDir, [".md"]);
+  if (memData.files.length > 0) {
+    try {
+      const bundleHash = hashContent3(memData.bundle);
+      const conflictCheck = await client.query(toFunctionName(api.workspaceSync.checkSyncStatus), {
+        hub_id: hubId,
+        local_file_hashes: { memories: bundleHash }
+      });
+      if (!conflictCheck.in_sync) totalConflicts += conflictCheck.conflicts.length;
+      if (!options.dryRun) {
+        const res = await client.mutation(toFunctionName(api.workspaceSync.pushWorkspaceContext), {
+          hub_id: hubId,
+          local_machine_id: machineId,
+          context_type: "memories",
+          content: memData.bundle,
+          file_hash: bundleHash,
+          timestamp: Date.now(),
+          metadata: { file_count: memData.files.length, total_size: memData.totalBytes, files: memData.files }
+        });
+        results.push({ type: "memories (memory/)", status: res.status, files: memData.files.length, bytes: memData.totalBytes });
+        spinner.succeed(`memory/ \u2014 ${res.status}  (${memData.files.length} files, ${(memData.totalBytes / 1024).toFixed(1)} KB)`);
+      } else {
+        results.push({ type: "memories (memory/)", status: "dry-run", files: memData.files.length, bytes: memData.totalBytes });
+        spinner.info(`memory/ \u2014 would push  (${memData.files.length} files, ${(memData.totalBytes / 1024).toFixed(1)} KB)`);
+      }
+    } catch (err) {
+      spinner.fail(`memory/ failed: ${err instanceof Error ? err.message : err}`);
+    }
+  } else {
+    spinner.info("memory/ \u2014 no .md files found, skipping");
+  }
+  const skillsDir = path19.join(projectRoot, "skills");
+  spinner.start("Checking skills/...");
+  const skillsData = collectDirFiles2(skillsDir, [".md", ".ts", ".js", ".yaml", ".yml"]);
+  if (skillsData.files.length > 0) {
+    try {
+      const bundleHash = hashContent3(skillsData.bundle);
+      const conflictCheck = await client.query(toFunctionName(api.workspaceSync.checkSyncStatus), {
+        hub_id: hubId,
+        local_file_hashes: { skills: bundleHash }
+      });
+      if (!conflictCheck.in_sync) totalConflicts += conflictCheck.conflicts.length;
+      if (!options.dryRun) {
+        const res = await client.mutation(toFunctionName(api.workspaceSync.pushWorkspaceContext), {
+          hub_id: hubId,
+          local_machine_id: machineId,
+          context_type: "skills",
+          content: skillsData.bundle,
+          file_hash: bundleHash,
+          timestamp: Date.now(),
+          metadata: { file_count: skillsData.files.length, total_size: skillsData.totalBytes, files: skillsData.files }
+        });
+        results.push({ type: "skills (skills/)", status: res.status, files: skillsData.files.length, bytes: skillsData.totalBytes });
+        spinner.succeed(`skills/ \u2014 ${res.status}  (${skillsData.files.length} files, ${(skillsData.totalBytes / 1024).toFixed(1)} KB)`);
+      } else {
+        results.push({ type: "skills (skills/)", status: "dry-run", files: skillsData.files.length, bytes: skillsData.totalBytes });
+        spinner.info(`skills/ \u2014 would push  (${skillsData.files.length} files, ${(skillsData.totalBytes / 1024).toFixed(1)} KB)`);
+      }
+    } catch (err) {
+      spinner.fail(`skills/ failed: ${err instanceof Error ? err.message : err}`);
+    }
+  } else {
+    spinner.info("skills/ \u2014 no files found, skipping");
+  }
+  const totalFiles = results.reduce((n, r) => n + r.files, 0);
+  const totalBytes = results.reduce((n, r) => n + r.bytes, 0);
+  const pushed = results.filter((r) => r.status !== "unchanged" && r.status !== "dry-run").length;
+  const unchanged = results.filter((r) => r.status === "unchanged").length;
+  console.log(chalk38.cyan("\n  Push Summary\n"));
+  console.log(chalk38.white("  Context types:  ") + chalk38.yellow(results.length.toString()));
+  console.log(chalk38.white("  Files synced:   ") + chalk38.green(totalFiles.toString()));
+  console.log(chalk38.white("  Bytes pushed:   ") + chalk38.gray(`${(totalBytes / 1024).toFixed(1)} KB`));
+  console.log(chalk38.white("  Unchanged:      ") + chalk38.gray(unchanged.toString()));
+  if (totalConflicts > 0) {
+    console.log(chalk38.white("  Conflicts:      ") + chalk38.red(totalConflicts.toString()));
+    console.log(chalk38.yellow("\n  Resolve conflicts with: hubify sync resolve --hub <id>"));
+  }
+  console.log();
+  process.exit(0);
+});
+var pullCommand = new Command35("pull").description("Pull latest workspace context from Convex hub to local files").option("--hub <id>", "Hub ID (default: from connect-state or HUB.yaml)").option("--dir <path>", "Project root to write files into (default: current directory)").option("--dry-run", "Show what would be written without making changes").option("--force", "Overwrite local files even if local version is newer").action(async (options) => {
+  const spinner = ora35();
+  const client = getClient();
+  console.log(chalk38.cyan("\n  Workspace Sync \u2014 Pull\n"));
+  const hubId = resolveHubId(options);
+  if (!hubId) {
+    console.log(chalk38.red("  No hub ID found."));
+    console.log(chalk38.yellow("  Run 'hubify connect' first, or pass --hub <id>"));
+    process.exit(1);
+  }
+  const projectRoot = options.dir ? path19.resolve(options.dir) : process.cwd();
+  console.log(chalk38.gray(`  Hub:     ${hubId.slice(0, 20)}...`));
+  console.log(chalk38.gray(`  Root:    ${projectRoot}`));
+  if (options.dryRun) console.log(chalk38.yellow("  Mode:    dry-run (no writes)\n"));
+  else console.log();
+  spinner.start("Fetching workspace context from cloud...");
+  let contexts;
+  try {
+    contexts = await client.query(toFunctionName(api.workspaceSync.pullWorkspaceContext), {
+      hub_id: hubId
+    });
+    spinner.succeed(`Fetched ${Object.keys(contexts).length} context type(s) from cloud`);
+  } catch (err) {
+    spinner.fail(`Pull failed: ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+  }
+  let pulled = 0;
+  let unchanged = 0;
+  let conflicts = 0;
+  let totalBytes = 0;
+  const writtenFiles = [];
+  const fileMap = {
+    soul: path19.join(projectRoot, "SOUL.md"),
+    memory: path19.join(projectRoot, "MEMORY.md"),
+    agents: path19.join(projectRoot, "AGENTS.md")
+  };
+  for (const [contextType, data] of Object.entries(contexts)) {
+    if (!data?.content) {
+      console.log(chalk38.gray(`  ${contextType}: (empty, skipping)`));
+      continue;
+    }
+    const syncedAt = new Date(data.synced_at).toLocaleString();
+    if (fileMap[contextType]) {
+      const localPath = fileMap[contextType];
+      const localExists = fs19.existsSync(localPath);
+      const localContent = localExists ? fs19.readFileSync(localPath, "utf-8") : null;
+      const localHash = localContent ? hashContent3(localContent) : null;
+      if (localHash === data.file_hash) {
+        console.log(chalk38.gray(`  ${path19.basename(localPath)} \u2014 already in sync`));
+        unchanged++;
+        continue;
+      }
+      const localMtime = localExists ? fs19.statSync(localPath).mtimeMs : 0;
+      const isConflict = localExists && !options.force && data.file_timestamp && localMtime > data.file_timestamp;
+      if (isConflict) {
+        console.log(
+          chalk38.yellow(`  ${path19.basename(localPath)} \u2014 CONFLICT`) + chalk38.gray(` (local: ${new Date(localMtime).toLocaleString()}, cloud: ${syncedAt})`)
+        );
+        console.log(chalk38.gray(`    Use --force to overwrite local, or 'hubify sync resolve' to choose`));
+        conflicts++;
+        continue;
+      }
+      if (!options.dryRun) {
+        fs19.writeFileSync(localPath, data.content, "utf-8");
+        writtenFiles.push(path19.basename(localPath));
+      }
+      console.log(
+        chalk38.green(`  ${path19.basename(localPath)} \u2014 ${options.dryRun ? "would update" : "updated"}`) + chalk38.gray(`  (${data.content.length} bytes, synced ${syncedAt})`)
+      );
+      pulled++;
+      totalBytes += data.content.length;
+    } else if (contextType === "memories") {
+      const memoriesDir = path19.join(projectRoot, "memory");
+      if (data.metadata?.files && Array.isArray(data.metadata.files)) {
+        if (!options.dryRun) fs19.mkdirSync(memoriesDir, { recursive: true });
+        const sections = data.content.split(/\n\n### /);
+        let fileCount = 0;
+        for (const section of sections) {
+          const newlineIdx = section.indexOf("\n");
+          if (newlineIdx === -1) continue;
+          const filename = section.slice(0, newlineIdx).replace(/^### /, "");
+          const fileContent = section.slice(newlineIdx + 2);
+          const outPath = path19.join(memoriesDir, filename);
+          const localHash = fs19.existsSync(outPath) ? hashContent3(fs19.readFileSync(outPath, "utf-8")) : null;
+          const cloudHash = hashContent3(fileContent);
+          if (localHash === cloudHash) {
+            unchanged++;
+            continue;
+          }
+          const localMtime = fs19.existsSync(outPath) ? fs19.statSync(outPath).mtimeMs : 0;
+          const isConflict = fs19.existsSync(outPath) && !options.force && data.file_timestamp && localMtime > data.file_timestamp;
+          if (isConflict) {
+            conflicts++;
+            continue;
+          }
+          if (!options.dryRun) fs19.writeFileSync(outPath, fileContent, "utf-8");
+          fileCount++;
+          totalBytes += fileContent.length;
+        }
+        console.log(
+          chalk38.green(`  memory/ \u2014 ${options.dryRun ? "would update" : "updated"} ${fileCount} file(s)`) + chalk38.gray(`  (synced ${syncedAt})`)
+        );
+        pulled += fileCount;
+      } else {
+        const outPath = path19.join(memoriesDir, "cloud-sync.md");
+        if (!options.dryRun) {
+          fs19.mkdirSync(memoriesDir, { recursive: true });
+          fs19.writeFileSync(outPath, data.content, "utf-8");
+        }
+        console.log(
+          chalk38.green(`  memory/cloud-sync.md \u2014 ${options.dryRun ? "would update" : "updated"}`) + chalk38.gray(`  (${data.content.length} bytes)`)
+        );
+        pulled++;
+        totalBytes += data.content.length;
+      }
+    } else if (contextType === "skills") {
+      const skillsDir = path19.join(projectRoot, "skills");
+      if (!options.dryRun) fs19.mkdirSync(skillsDir, { recursive: true });
+      const sections = data.content.split(/\n\n### /);
+      let fileCount = 0;
+      for (const section of sections) {
+        const newlineIdx = section.indexOf("\n");
+        if (newlineIdx === -1) continue;
+        const filename = section.slice(0, newlineIdx).replace(/^### /, "");
+        const fileContent = section.slice(newlineIdx + 2);
+        const outPath = path19.join(skillsDir, filename);
+        const localHash = fs19.existsSync(outPath) ? hashContent3(fs19.readFileSync(outPath, "utf-8")) : null;
+        if (localHash === hashContent3(fileContent)) {
+          unchanged++;
+          continue;
+        }
+        const localMtime = fs19.existsSync(outPath) ? fs19.statSync(outPath).mtimeMs : 0;
+        const isConflict = fs19.existsSync(outPath) && !options.force && data.file_timestamp && localMtime > data.file_timestamp;
+        if (isConflict) {
+          conflicts++;
+          continue;
+        }
+        if (!options.dryRun) fs19.writeFileSync(outPath, fileContent, "utf-8");
+        fileCount++;
+        totalBytes += fileContent.length;
+      }
+      if (fileCount > 0) {
+        console.log(
+          chalk38.green(`  skills/ \u2014 ${options.dryRun ? "would update" : "updated"} ${fileCount} file(s)`) + chalk38.gray(`  (synced ${syncedAt})`)
+        );
+        pulled += fileCount;
+      } else {
+        console.log(chalk38.gray(`  skills/ \u2014 already in sync (${sections.length - 1} skills)`));
+        unchanged++;
+      }
+    }
+  }
+  console.log(chalk38.cyan("\n  Pull Summary\n"));
+  console.log(chalk38.white("  Files updated:  ") + chalk38.green(pulled.toString()));
+  console.log(chalk38.white("  Bytes received: ") + chalk38.gray(`${(totalBytes / 1024).toFixed(1)} KB`));
+  console.log(chalk38.white("  Unchanged:      ") + chalk38.gray(unchanged.toString()));
+  if (conflicts > 0) {
+    console.log(chalk38.white("  Conflicts:      ") + chalk38.red(conflicts.toString()));
+    console.log(chalk38.yellow("\n  Use --force to overwrite local files, or resolve manually."));
+  }
+  console.log();
+  process.exit(0);
+});
 syncCommand.addCommand(statusCommand);
 syncCommand.addCommand(logsCommand);
 syncCommand.addCommand(statsCommand3);
+syncCommand.addCommand(pushCommand);
+syncCommand.addCommand(pullCommand);
 
 // src/commands/test.ts
 import { Command as Command36 } from "commander";
@@ -24547,7 +25234,7 @@ echo "=== Test Complete ==="
 }
 async function mockSandboxExecution(skillContent, skillName, criteria) {
   console.log(chalk39.yellow("\n  \u26A0 E2B API key not configured - running mock sandbox test\n"));
-  await new Promise((resolve11) => setTimeout(resolve11, 1500));
+  await new Promise((resolve12) => setTimeout(resolve12, 1500));
   const securityViolations = [];
   if (/curl.*\|.*sh|wget.*\|.*bash|rm\s+-rf\s+\//i.test(skillContent)) {
     securityViolations.push("Dangerous shell pattern detected");
@@ -25744,6 +26431,7 @@ function formatTrajectory(trajectory) {
 import { Command as Command40 } from "commander";
 import chalk43 from "chalk";
 import ora40 from "ora";
+import { execSync } from "child_process";
 function timeAgo(ts) {
   const delta = Date.now() - ts;
   if (delta < 6e4) return "just now";
@@ -26010,32 +26698,255 @@ var publishSubcommand = new Command40("publish").description("Publish research f
     spinner.fail(error.message || "Failed to publish findings");
   }
 });
-researchCommand.addCommand(listSubcommand2);
-researchCommand.addCommand(proposeSubcommand);
-researchCommand.addCommand(updateSubcommand2);
-researchCommand.addCommand(joinSubcommand);
-researchCommand.addCommand(viewSubcommand);
-researchCommand.addCommand(approveSubcommand);
-researchCommand.addCommand(startSubcommand);
-researchCommand.addCommand(completeSubcommand);
-researchCommand.addCommand(publishSubcommand);
-
-// src/commands/auth.ts
-import { Command as Command41 } from "commander";
-import chalk44 from "chalk";
-import ora41 from "ora";
-import fs21 from "fs";
-import path21 from "path";
-import os10 from "os";
-import crypto5 from "crypto";
-var CREDENTIALS_DIR = path21.join(os10.homedir(), ".hubify");
-var CREDENTIALS_FILE = path21.join(CREDENTIALS_DIR, "credentials.json");
-function hashToken(token) {
-  return crypto5.createHash("sha256").update(token).digest("hex");
-}
-function loadCredentials() {
+var toolsCommand = new Command40("tools").description("Manage the hubify-research Python toolkit on workspaces");
+var toolsCheckSubcommand = new Command40("check").description("Validate research environment (API keys + connectivity)").option("--test", "Also run connectivity tests").action(async (options) => {
+  const spinner = ora40("Checking research environment...").start();
   try {
-    if (fs21.existsSync(CREDENTIALS_FILE)) {
+    const cmd = options.test ? "python3 -m hubify_research check --test" : "python3 -m hubify_research check";
+    const output = execSync(cmd, { encoding: "utf-8", timeout: 3e4 });
+    spinner.stop();
+    console.log(output);
+  } catch (error) {
+    spinner.fail("Environment check failed");
+    if (error.stdout) console.log(error.stdout);
+    if (error.stderr) console.error(chalk43.red(error.stderr));
+  }
+});
+var toolsInstallSubcommand = new Command40("install").description("Install hubify-research toolkit (pip install)").option("--dev", "Install in development mode (editable)").action(async (options) => {
+  const spinner = ora40("Installing hubify-research...").start();
+  try {
+    const cmd = options.dev ? "pip install -e packages/sdk/python/" : "pip install hubify-research";
+    const output = execSync(cmd, { encoding: "utf-8", timeout: 12e4 });
+    spinner.succeed("hubify-research installed");
+    console.log(chalk43.gray(output.trim().split("\n").slice(-3).join("\n")));
+  } catch (error) {
+    spinner.fail("Installation failed");
+    if (error.stderr) console.error(chalk43.red(error.stderr));
+  }
+});
+toolsCommand.addCommand(toolsCheckSubcommand);
+toolsCommand.addCommand(toolsInstallSubcommand);
+var searchSubcommand2 = new Command40("search").description("Search literature across NASA ADS, arXiv, Semantic Scholar, Perplexity").argument("<query>", "Search query").option("--category <cat>", "arXiv category filter (e.g., cs.AI, astro-ph.CO)").action(async (query, options) => {
+  const spinner = ora40("Searching literature...").start();
+  try {
+    const env = { ...process.env, HUBIFY_SEARCH_QUERY: query };
+    if (options.category) env.HUBIFY_SEARCH_CATEGORY = options.category;
+    const output = execSync(
+      `python3 -c "import os, json; from hubify_research.literature import search; print(json.dumps(search(os.environ['HUBIFY_SEARCH_QUERY'], max_results=5, category=os.environ.get('HUBIFY_SEARCH_CATEGORY')), indent=2, default=str))"`,
+      { encoding: "utf-8", timeout: 6e4, env }
+    );
+    spinner.stop();
+    console.log(output);
+  } catch (error) {
+    spinner.fail("Search failed");
+    if (error.stdout) console.log(error.stdout);
+    if (error.stderr) console.error(chalk43.red(error.stderr));
+  }
+});
+var verifySubcommand = new Command40("verify").description("Verify a mathematical equation via Wolfram Alpha + DeepSeek R1").argument("<equation>", "Mathematical expression to verify").option("--expected <value>", "Expected result for comparison").action(async (equation, options) => {
+  const spinner = ora40("Verifying equation...").start();
+  try {
+    const expected = options.expected || "";
+    const output = execSync(
+      `python3 -c "import os, json; from hubify_research.computation import verify_equation; print(json.dumps(verify_equation(os.environ['EQ'], os.environ['EX']), indent=2, default=str))"`,
+      {
+        encoding: "utf-8",
+        timeout: 18e4,
+        env: { ...process.env, EQ: equation, EX: expected }
+      }
+    );
+    spinner.stop();
+    console.log(output);
+  } catch (error) {
+    spinner.fail("Verification failed");
+    if (error.stdout) console.log(error.stdout);
+    if (error.stderr) console.error(chalk43.red(error.stderr));
+  }
+});
+var gpuCommand = new Command40("gpu").description("Manage RunPod GPU pods for research");
+var gpuStatusSubcommand = new Command40("status").description("Show RunPod pod status").argument("[pod-id]", "Specific pod ID (optional)").action(async (podId) => {
+  const spinner = ora40("Loading GPU status...").start();
+  try {
+    if (podId && !/^[a-zA-Z0-9_-]+$/.test(podId)) {
+      spinner.fail("Invalid pod ID format");
+      return;
+    }
+    const cmd = podId ? `python3 -m hubify_research gpu status ${podId}` : "python3 -m hubify_research gpu status";
+    const output = execSync(cmd, { encoding: "utf-8", timeout: 3e4 });
+    spinner.stop();
+    console.log(output);
+  } catch (error) {
+    spinner.fail("Failed to get GPU status");
+    if (error.stdout) console.log(error.stdout);
+    if (error.stderr) console.error(chalk43.red(error.stderr));
+  }
+});
+var gpuCreateSubcommand = new Command40("create").description("Create a new RunPod GPU pod").option("--name <name>", "Pod name", "hubify-research").option("--gpu <type>", "GPU type", "NVIDIA RTX 4090").action(async (options) => {
+  const spinner = ora40(`Creating RunPod pod (${options.gpu})...`).start();
+  try {
+    const output = execSync(
+      `python3 -c "import os, json; from hubify_research.gpu.runpod import create_pod; print(json.dumps(create_pod(name=os.environ['POD_NAME'], gpu_type=os.environ['GPU_TYPE']), indent=2, default=str))"`,
+      { encoding: "utf-8", timeout: 6e4, env: { ...process.env, POD_NAME: options.name, GPU_TYPE: options.gpu } }
+    );
+    spinner.succeed("Pod created");
+    console.log(output);
+  } catch (error) {
+    spinner.fail("Failed to create pod");
+    if (error.stdout) console.log(error.stdout);
+    if (error.stderr) console.error(chalk43.red(error.stderr));
+  }
+});
+var gpuListSubcommand = new Command40("list").description("List available GPU types with pricing").action(async () => {
+  const spinner = ora40("Loading GPU types...").start();
+  try {
+    const output = execSync("python3 -m hubify_research gpu gpus", {
+      encoding: "utf-8",
+      timeout: 3e4
+    });
+    spinner.stop();
+    console.log(output);
+  } catch (error) {
+    spinner.fail("Failed to list GPUs");
+    if (error.stderr) console.error(chalk43.red(error.stderr));
+  }
+});
+gpuCommand.addCommand(gpuStatusSubcommand);
+gpuCommand.addCommand(gpuCreateSubcommand);
+gpuCommand.addCommand(gpuListSubcommand);
+var labsCommand = new Command40("labs").description("Manage research labs \u2014 dedicated research workspaces");
+var labsCreateSubcommand = new Command40("create").description("Create a new research lab").argument("<name>", "Lab name").option("--compute <tier>", "Compute tier: e2b, fly, or runpod", "e2b").option("--budget-usd <amount>", "Budget in USD").option("--budget-hours <hours>", "Time budget in hours").action(async (name, options) => {
+  const spinner = ora40("Creating research lab...").start();
+  try {
+    const client = getClient();
+    const result = await client.mutation(toFunctionName(api.researchLabs.createResearchLab), {
+      name,
+      compute_tier: options.compute,
+      auto_publish_findings: true,
+      budget_usd: options.budgetUsd ? parseFloat(options.budgetUsd) : void 0,
+      budget_hours: options.budgetHours ? parseFloat(options.budgetHours) : void 0
+    });
+    spinner.succeed(`Research lab created: ${name}`);
+    console.log(chalk43.gray(`  Hub ID: ${result.hub_id}`));
+  } catch (error) {
+    spinner.fail("Failed to create research lab");
+    console.error(chalk43.red(error.message));
+  }
+});
+var labsSummarySubcommand = new Command40("summary").description("Get research lab summary \u2014 missions, experiments, findings").argument("<hub-id>", "Hub ID of the research lab").action(async (hubId) => {
+  const spinner = ora40("Loading lab summary...").start();
+  try {
+    const client = getClient();
+    const summary = await client.query(toFunctionName(api.researchLabs.getLabSummary), {
+      hub_id: hubId
+    });
+    spinner.stop();
+    if (!summary) {
+      console.log(chalk43.yellow("Research lab not found"));
+      return;
+    }
+    console.log(chalk43.bold(`
+  ${summary.hub_name} (${summary.hub_type})`));
+    console.log(chalk43.gray("  " + "\u2500".repeat(40)));
+    console.log(`  Missions:     ${summary.missions.active} active / ${summary.missions.total} total`);
+    console.log(`  Experiments:  ${summary.experiments.total} run ($${summary.experiments.total_cost_usd.toFixed(2)})`);
+    console.log(`  Best metric:  ${summary.experiments.best_metric.toFixed(4)}`);
+    console.log(`  Findings:     ${summary.knowledge.findings} published`);
+    console.log(`  Threads:      ${summary.knowledge.total_threads} (score: ${summary.knowledge.total_score})`);
+  } catch (error) {
+    spinner.fail("Failed to load summary");
+    console.error(chalk43.red(error.message));
+  }
+});
+var labsListSubcommand = new Command40("list").description("List all research labs").action(async () => {
+  const spinner = ora40("Loading research labs...").start();
+  try {
+    const client = getClient();
+    const labs = await client.query(toFunctionName(api.researchLabs.listLabs), {});
+    spinner.stop();
+    if (labs.length === 0) {
+      console.log(chalk43.yellow("No research labs found. Create one with: hubify research labs create <name>"));
+      return;
+    }
+    console.log(chalk43.bold(`
+  Research Labs (${labs.length})`));
+    for (const lab of labs) {
+      const tier = lab.research_config?.compute_tier ?? "\u2014";
+      console.log(`  ${chalk43.cyan(lab.name)} [${tier}] \u2014 ${lab._id}`);
+    }
+  } catch (error) {
+    spinner.fail("Failed to list labs");
+    console.error(chalk43.red(error.message));
+  }
+});
+var labsToolkitSubcommand = new Command40("toolkit").description("Show research toolkit status and capabilities").action(async () => {
+  const client = getClient();
+  const status = await client.query(toFunctionName(api.researchLabs.getToolkitStatus), {});
+  console.log(chalk43.bold(`
+  ${status.toolkit} v${status.version}`));
+  console.log(chalk43.gray("  " + "\u2500".repeat(40)));
+  for (const mod of status.modules) {
+    console.log(`  ${chalk43.cyan(mod.name.padEnd(16))} ${mod.description}`);
+  }
+  console.log(`
+  Install: ${chalk43.green(status.install)}`);
+  console.log(`  Check:   ${chalk43.green(status.cli)}`);
+});
+labsCommand.addCommand(labsCreateSubcommand);
+labsCommand.addCommand(labsSummarySubcommand);
+labsCommand.addCommand(labsListSubcommand);
+labsCommand.addCommand(labsToolkitSubcommand);
+var findingCommand = new Command40("finding").description("Publish a research finding to knowledge threads").argument("<title>", "Finding title").option("--hub <hub-id>", "Hub ID to publish to").option("--mission <mission-id>", "Link to research mission").option("--body <body>", "Finding body (detailed description)").option("--confidence <score>", "Confidence score 0-1").option("--tags <tags>", "Comma-separated tags").action(async (title, options) => {
+  const spinner = ora40("Publishing finding...").start();
+  try {
+    const client = getClient();
+    const result = await client.mutation(toFunctionName(api.researchLabs.publishFinding), {
+      hub_id: options.hub,
+      title,
+      body: options.body || title,
+      mission_id: options.mission || void 0,
+      author_agent_id: "cli-user",
+      tags: options.tags ? options.tags.split(",").map((t) => t.trim()) : void 0,
+      confidence: options.confidence ? parseFloat(options.confidence) : void 0
+    });
+    spinner.succeed("Finding published");
+    console.log(chalk43.gray(`  Thread ID: ${result.thread_id}`));
+  } catch (error) {
+    spinner.fail("Failed to publish finding");
+    console.error(chalk43.red(error.message));
+  }
+});
+researchCommand.addCommand(listSubcommand2);
+researchCommand.addCommand(proposeSubcommand);
+researchCommand.addCommand(updateSubcommand2);
+researchCommand.addCommand(joinSubcommand);
+researchCommand.addCommand(viewSubcommand);
+researchCommand.addCommand(approveSubcommand);
+researchCommand.addCommand(startSubcommand);
+researchCommand.addCommand(completeSubcommand);
+researchCommand.addCommand(publishSubcommand);
+researchCommand.addCommand(toolsCommand);
+researchCommand.addCommand(searchSubcommand2);
+researchCommand.addCommand(verifySubcommand);
+researchCommand.addCommand(gpuCommand);
+researchCommand.addCommand(labsCommand);
+researchCommand.addCommand(findingCommand);
+
+// src/commands/auth.ts
+import { Command as Command41 } from "commander";
+import chalk44 from "chalk";
+import ora41 from "ora";
+import fs21 from "fs";
+import path21 from "path";
+import os11 from "os";
+import crypto6 from "crypto";
+var CREDENTIALS_DIR = path21.join(os11.homedir(), ".hubify");
+var CREDENTIALS_FILE = path21.join(CREDENTIALS_DIR, "credentials.json");
+function hashToken(token) {
+  return crypto6.createHash("sha256").update(token).digest("hex");
+}
+function loadCredentials() {
+  try {
+    if (fs21.existsSync(CREDENTIALS_FILE)) {
       const raw = fs21.readFileSync(CREDENTIALS_FILE, "utf-8");
       return JSON.parse(raw);
     }
@@ -26919,7 +27830,7 @@ ingestCommand.command("logs").description("View ingest operation logs").option("
 import { Command as Command46 } from "commander";
 import chalk48 from "chalk";
 import ora45 from "ora";
-var labsCommand = new Command46("labs").description("Hubify Labs \u2014 autonomous experiment swarms and research DAGs").addCommand(labsStatusCommand()).addCommand(labsMissionCommand()).addCommand(labsFrontierCommand()).addCommand(labsDagCommand()).addCommand(labsBestPathCommand()).addCommand(labsChannelsCommand()).addCommand(labsLaunchCommand()).addCommand(labsLaunchResearchCommand()).addCommand(labsListExperimentableCommand()).addCommand(labsSuggestCommand());
+var labsCommand2 = new Command46("labs").description("Hubify Labs \u2014 autonomous experiment swarms and research DAGs").addCommand(labsStatusCommand()).addCommand(labsMissionCommand()).addCommand(labsFrontierCommand()).addCommand(labsDagCommand()).addCommand(labsBestPathCommand()).addCommand(labsChannelsCommand()).addCommand(labsLaunchCommand()).addCommand(labsLaunchResearchCommand()).addCommand(labsListExperimentableCommand()).addCommand(labsSuggestCommand());
 function labsStatusCommand() {
   return new Command46("status").description("Show active experiment missions").option("--limit <n>", "Max missions to show", "10").option("--json", "Output as JSON").action(async (options) => {
     const spinner = ora45("Fetching experiment missions...").start();
@@ -27106,16 +28017,16 @@ function labsBestPathCommand() {
     const spinner = ora45("Tracing best path...").start();
     try {
       const client = getClient();
-      const path26 = await client.query(
+      const path27 = await client.query(
         toFunctionName(api.experimentDag.getBestPath),
         { mission_id: missionId }
       );
       spinner.stop();
       if (options.json) {
-        console.log(JSON.stringify(path26, null, 2));
+        console.log(JSON.stringify(path27, null, 2));
         return;
       }
-      const nodes = path26;
+      const nodes = path27;
       if (nodes.length === 0) {
         console.log(chalk48.dim("\n  No best path found.\n"));
         return;
@@ -28170,57 +29081,78 @@ function typeIcon(type) {
       return chalk55.blue("FINDING");
     case "technique":
       return chalk55.white("TECHNIQUE");
+    case "experiment_result":
+      return chalk55.yellow("EXPERIMENT");
+    case "failure_lesson":
+      return chalk55.red("FAILURE");
     case "failure-lesson":
       return chalk55.red("FAILURE");
     default:
       return chalk55.dim(type.toUpperCase());
   }
 }
+function toBackendType(type) {
+  const map = {
+    "failure-lesson": "failure_lesson",
+    "experiment-result": "experiment_result"
+  };
+  return map[type] ?? type;
+}
 function collectiveFeedCommand() {
-  return new Command52("feed").description("Show the global collective intelligence feed").option("--limit <n>", "Max entries", "50").option("--type <type>", "Filter: learning, evolution, improvement, all", "all").option("--json", "Output as JSON").action(async (options) => {
+  return new Command52("feed").description("Show the global collective intelligence feed").option("--limit <n>", "Max entries", "50").option("--type <type>", "Filter: learning, pattern, finding, technique, experiment-result, failure-lesson, all", "all").option("--json", "Output as JSON").action(async (options) => {
     const spinner = ora51("Pulling collective intelligence feed...").start();
     try {
       const client = getClient();
-      const [feed, recentLearnings] = await Promise.all([
+      const limit = parseInt(options.limit);
+      const collectiveArgs = { limit };
+      if (options.type !== "all") {
+        collectiveArgs.type = toBackendType(options.type);
+      }
+      const [collectiveFeed, singularityFeed] = await Promise.all([
         client.query(
-          toFunctionName(api.singularity.getIntelligenceFeed),
-          { limit: parseInt(options.limit), type: options.type }
+          toFunctionName(api.collective.getFeed),
+          collectiveArgs
         ),
         client.query(
-          toFunctionName(api.learning.getRecentEnriched),
-          { limit: parseInt(options.limit) }
-        )
+          toFunctionName(api.singularity.getIntelligenceFeed),
+          { limit, type: options.type }
+        ).catch(() => [])
+        // graceful fallback if singularity unavailable
       ]);
       spinner.stop();
+      const collectiveEntries = collectiveFeed;
+      const singularityEntries = singularityFeed;
       if (options.json) {
-        console.log(JSON.stringify({ feed, recentLearnings }, null, 2));
+        console.log(JSON.stringify({ collective: collectiveEntries, singularity: singularityEntries }, null, 2));
         return;
       }
-      const feedEntries = feed;
-      const learningEntries = recentLearnings;
       const unified = [];
-      for (const entry of feedEntries) {
+      for (const entry of collectiveEntries) {
         unified.push({
           type: entry.type ?? "learning",
-          title: entry.title ?? entry.skill_name ?? "\u2014",
-          detail: entry.details ?? entry.description ?? "",
-          source: entry.agent_id ?? "network",
-          timestamp: entry.timestamp ?? entry._creationTime ?? Date.now()
+          title: entry.title ?? "\u2014",
+          detail: entry.content ?? "",
+          source: entry.source_agent_id ?? "collective",
+          timestamp: entry.created_at ?? entry._creationTime ?? Date.now(),
+          origin: "collective"
         });
       }
-      for (const log of learningEntries) {
-        const type = log.improvement ? "improvement" : log.result === "fail" ? "failure-lesson" : "learning";
-        if (options.type !== "all" && options.type !== type) continue;
+      for (const entry of singularityEntries) {
+        const isDupe = unified.some(
+          (u) => u.title === (entry.title ?? entry.skill_name) && Math.abs(u.timestamp - (entry.timestamp ?? 0)) < 1e3
+        );
+        if (isDupe) continue;
         unified.push({
-          type,
-          title: log.skillName ?? log.skill_name ?? "unknown",
-          detail: log.improvement ?? log.note ?? log.error_message ?? `${log.result} execution`,
-          source: log.agent_id ?? "unknown",
-          timestamp: log._creationTime ?? Date.now()
+          type: entry.type ?? "learning",
+          title: entry.title ?? entry.skill_name ?? "\u2014",
+          detail: entry.details ?? entry.description ?? "",
+          source: entry.agent_id ?? "network",
+          timestamp: entry.timestamp ?? entry._creationTime ?? Date.now(),
+          origin: "singularity"
         });
       }
       unified.sort((a, b) => b.timestamp - a.timestamp);
-      const display = unified.slice(0, parseInt(options.limit));
+      const display = unified.slice(0, limit);
       if (display.length === 0) {
         console.log(chalk55.dim("\n  No collective intelligence entries found.\n"));
         return;
@@ -28237,7 +29169,7 @@ function collectiveFeedCommand() {
           const detail = entry.detail.length > 120 ? entry.detail.slice(0, 117) + "..." : entry.detail;
           console.log(`    ${chalk55.dim(detail)}`);
         }
-        console.log(`    ${chalk55.dim("source:")} ${chalk55.dim(entry.source)}`);
+        console.log(`    ${chalk55.dim("source:")} ${chalk55.dim(entry.source)} ${chalk55.dim("via")} ${chalk55.dim(entry.origin)}`);
         console.log();
       }
     } catch (error) {
@@ -28247,8 +29179,8 @@ function collectiveFeedCommand() {
   });
 }
 function collectiveShareCommand() {
-  return new Command52("share").description("Share an insight to the collective intelligence").argument("<type>", "Insight type: learning, pattern, finding, technique, failure-lesson").argument("<content>", "The insight content to share").option("--skill <name>", "Link to a skill name").option("--confidence <n>", "Confidence score 0-1", "0.7").option("--tags <tags>", "Comma-separated tags").option("--context <ctx>", "What you were doing when you learned this").option("--agent <id>", "Agent ID (defaults to cli-agent)").option("--json", "Output as JSON").action(async (type, content, options) => {
-    const validTypes = ["learning", "pattern", "finding", "technique", "failure-lesson"];
+  return new Command52("share").description("Share an insight to the collective intelligence").argument("<type>", "Insight type: learning, pattern, finding, technique, experiment-result, failure-lesson").argument("<content>", "The insight content to share").option("--skill <name>", "Link to a skill name").option("--confidence <n>", "Confidence score 0-1", "0.7").option("--tags <tags>", "Comma-separated tags").option("--context <ctx>", "What you were doing when you learned this").option("--agent <id>", "Agent ID (defaults to cli-agent)").option("--workspace <id>", "Workspace ID").option("--json", "Output as JSON").action(async (type, content, options) => {
+    const validTypes = ["learning", "pattern", "finding", "technique", "experiment-result", "failure-lesson"];
     if (!validTypes.includes(type)) {
       console.log(chalk55.red(`
   Invalid type: ${type}`));
@@ -28259,32 +29191,23 @@ function collectiveShareCommand() {
     const spinner = ora51("Sharing insight to collective...").start();
     try {
       const client = getClient();
-      const skillName = options.skill ?? "general";
       const agentId = options.agent ?? "cli-agent";
       const confidence = parseFloat(options.confidence);
-      const resultMap = {
-        "learning": "success",
-        "pattern": "success",
-        "finding": "success",
-        "technique": "success",
-        "failure-lesson": "fail"
-      };
       const tags = options.tags ? options.tags.split(",").map((t) => t.trim()) : [];
-      const contextNote = options.context ? `
-[context] ${options.context}` : "";
-      const tagNote = tags.length > 0 ? `
-[tags] ${tags.join(", ")}` : "";
-      const fullNote = `[${type}] ${content}${contextNote}${tagNote}`;
+      const title = content.length > 80 ? content.slice(0, 77) + "..." : content;
+      const backendType = toBackendType(type);
       const result = await client.mutation(
-        toFunctionName(api.learning.report),
+        toFunctionName(api.collective.shareInsight),
         {
-          skill_name: skillName,
-          skill_version: "latest",
-          agent_id: agentId,
-          platform: "cli",
-          result: resultMap[type],
-          note: fullNote,
-          improvement: type === "pattern" || type === "technique" ? content : void 0
+          type: backendType,
+          title,
+          content,
+          context: options.context,
+          source_agent_id: agentId,
+          source_workspace_id: options.workspace,
+          source_skill_name: options.skill,
+          tags: tags.length > 0 ? tags : void 0,
+          confidence
         }
       );
       spinner.stop();
@@ -28293,10 +29216,13 @@ function collectiveShareCommand() {
         return;
       }
       console.log(chalk55.bold("\n  Insight shared to collective"));
+      console.log(`  ${chalk55.dim("id:")}         ${result?.id ?? "\u2014"}`);
       console.log(`  ${chalk55.dim("type:")}       ${typeIcon(type)}`);
-      console.log(`  ${chalk55.dim("skill:")}      ${skillName}`);
+      if (options.skill) {
+        console.log(`  ${chalk55.dim("skill:")}      ${options.skill}`);
+      }
       console.log(`  ${chalk55.dim("confidence:")} ${confidence}`);
-      console.log(`  ${chalk55.dim("content:")}    ${content.length > 80 ? content.slice(0, 77) + "..." : content}`);
+      console.log(`  ${chalk55.dim("content:")}    ${title}`);
       if (tags.length > 0) {
         console.log(`  ${chalk55.dim("tags:")}       ${tags.join(", ")}`);
       }
@@ -28309,8 +29235,6 @@ function collectiveShareCommand() {
     } catch (error) {
       spinner.fail("Failed to share insight");
       console.error(chalk55.red(error.message));
-      console.log(chalk55.dim("\n  Make sure the skill exists in the registry."));
-      console.log(chalk55.dim("  Use --skill <name> to link to a specific skill.\n"));
     }
   });
 }
@@ -28319,28 +29243,50 @@ function collectiveTrendingCommand() {
     const spinner = ora51("Analyzing network trends...").start();
     try {
       const client = getClient();
-      const [trending, feed] = await Promise.all([
+      const days = parseInt(options.days);
+      const limit = parseInt(options.limit);
+      const [collectiveTrending, singularityTrending] = await Promise.all([
         client.query(
-          toFunctionName(api.singularity.getTrendingSkills),
-          { days: parseInt(options.days), limit: parseInt(options.limit) }
+          toFunctionName(api.collective.getTrending),
+          { days, limit }
         ),
         client.query(
-          toFunctionName(api.singularity.getIntelligenceFeed),
-          { limit: 10, type: "all" }
-        )
+          toFunctionName(api.singularity.getTrendingSkills),
+          { days, limit }
+        ).catch(() => [])
       ]);
       spinner.stop();
+      const insights = collectiveTrending;
+      const skills = singularityTrending;
       if (options.json) {
-        console.log(JSON.stringify({ trending, feed }, null, 2));
+        console.log(JSON.stringify({ insights, skills }, null, 2));
         return;
       }
-      const skills = trending;
-      const feedEntries = feed;
       console.log(chalk55.bold(`
-  Trending in the Collective (last ${options.days} days)
+  Trending in the Collective (last ${days} days)
 `));
+      if (insights.length > 0) {
+        console.log(chalk55.dim("  --- Top validated insights ---\n"));
+        for (let i = 0; i < insights.length; i++) {
+          const ins = insights[i];
+          const impact = (ins.validations ?? 0) + (ins.applications ?? 0);
+          const time = relativeTime(ins.created_at ?? ins._creationTime ?? Date.now());
+          console.log(
+            `  ${chalk55.dim(`${(i + 1).toString().padStart(2)}.`)} ${typeIcon(ins.type)} ${chalk55.bold(ins.title ?? "\u2014")} ${chalk55.dim(time)}`
+          );
+          console.log(
+            `      ${ins.validations ?? 0} validations  ${ins.applications ?? 0} applications  impact: ${impact}  conf: ${((ins.confidence ?? 0) * 100).toFixed(0)}%`
+          );
+          if (ins.content) {
+            const content = ins.content.length > 100 ? ins.content.slice(0, 97) + "..." : ins.content;
+            console.log(`      ${chalk55.dim(content)}`);
+          }
+        }
+      } else {
+        console.log(chalk55.dim("  No trending insights in the last " + days + " days."));
+      }
       if (skills.length > 0) {
-        console.log(chalk55.dim("  --- Skills the network is learning about ---\n"));
+        console.log(chalk55.dim("\n  --- Trending skills (network-wide) ---\n"));
         for (let i = 0; i < skills.length; i++) {
           const s = skills[i];
           const rate = (s.success_rate * 100).toFixed(0);
@@ -28352,20 +29298,6 @@ function collectiveTrendingCommand() {
             `      ${s.executions} executions  ${bar} ${rate}% success  ${s.unique_agents} agents`
           );
         }
-      } else {
-        console.log(chalk55.dim("  No trending skills in the last " + options.days + " days."));
-      }
-      if (feedEntries.length > 0) {
-        console.log(chalk55.dim("\n  --- Active intelligence ---\n"));
-        for (const entry of feedEntries) {
-          const time = relativeTime(entry.timestamp ?? entry._creationTime ?? Date.now());
-          console.log(
-            `  ${typeIcon(entry.type ?? "learning")} ${chalk55.bold(entry.title ?? "\u2014")} ${chalk55.dim(time)}`
-          );
-          if (entry.details) {
-            console.log(`    ${chalk55.dim(entry.details)}`);
-          }
-        }
       }
       console.log();
     } catch (error) {
@@ -28375,57 +29307,34 @@ function collectiveTrendingCommand() {
   });
 }
 function collectiveSearchCommand() {
-  return new Command52("search").description("Search collective knowledge").argument("<query>", "Search query").option("--limit <n>", "Max results", "20").option("--json", "Output as JSON").action(async (query, options) => {
+  return new Command52("search").description("Search collective knowledge").argument("<query>", "Search query").option("--type <type>", "Filter by type").option("--limit <n>", "Max results", "20").option("--json", "Output as JSON").action(async (query, options) => {
     const spinner = ora51(`Searching collective for "${query}"...`).start();
     try {
       const client = getClient();
       const limit = parseInt(options.limit);
       let results = [];
-      let source = "knowledge";
+      let source = "collective";
       try {
-        const knowledgeResults = await client.query(
-          toFunctionName(api.hubKnowledge.searchAll),
-          { query, limit }
+        const searchArgs = { query, limit };
+        if (options.type) {
+          searchArgs.type = toBackendType(options.type);
+        }
+        const collectiveResults = await client.query(
+          toFunctionName(api.collective.search),
+          searchArgs
         );
-        results = knowledgeResults;
+        results = collectiveResults;
       } catch {
-        source = "feed";
-        const [feed, learnings] = await Promise.all([
-          client.query(
-            toFunctionName(api.singularity.getIntelligenceFeed),
-            { limit, type: "all" }
-          ),
-          client.query(
-            toFunctionName(api.learning.getRecentEnriched),
-            { limit }
-          )
-        ]);
-        const feedEntries = feed;
-        const learningEntries = learnings;
-        const queryLower = query.toLowerCase();
-        for (const entry of feedEntries) {
-          const text = `${entry.title ?? ""} ${entry.description ?? ""} ${entry.details ?? ""}`.toLowerCase();
-          if (text.includes(queryLower)) {
-            results.push({
-              type: entry.type ?? "learning",
-              title: entry.title ?? "\u2014",
-              content: entry.description ?? entry.details ?? "",
-              timestamp: entry.timestamp,
-              source: "feed"
-            });
-          }
-        }
-        for (const log of learningEntries) {
-          const text = `${log.skillName ?? ""} ${log.note ?? ""} ${log.improvement ?? ""} ${log.error_message ?? ""}`.toLowerCase();
-          if (text.includes(queryLower)) {
-            results.push({
-              type: log.improvement ? "improvement" : "learning",
-              title: log.skillName ?? log.skill_name ?? "\u2014",
-              content: log.note ?? log.improvement ?? log.error_message ?? "",
-              timestamp: log._creationTime,
-              source: log.agent_id ?? "unknown"
-            });
-          }
+        source = "knowledge";
+        try {
+          const knowledgeResults = await client.query(
+            toFunctionName(api.hubKnowledge.searchAll),
+            { query, limit }
+          );
+          results = knowledgeResults;
+        } catch {
+          source = "none";
+          results = [];
         }
       }
       spinner.stop();
@@ -28443,7 +29352,7 @@ function collectiveSearchCommand() {
   Collective Search: "${query}" (${results.length} results, via ${source})
 `));
       for (const r of results.slice(0, limit)) {
-        const time = r.timestamp ? relativeTime(r.timestamp) : "";
+        const time = r.created_at ?? r.timestamp ?? r._creationTime ? relativeTime(r.created_at ?? r.timestamp ?? r._creationTime) : "";
         const rType = r.type ?? r.kind ?? "knowledge";
         console.log(
           `  ${typeIcon(rType)} ${chalk55.bold(r.title ?? r.name ?? "\u2014")} ${chalk55.dim(time)}`
@@ -28453,8 +29362,11 @@ function collectiveSearchCommand() {
           const truncated = content.length > 120 ? content.slice(0, 117) + "..." : content;
           console.log(`    ${chalk55.dim(truncated)}`);
         }
-        if (r.source) {
-          console.log(`    ${chalk55.dim("source:")} ${r.source}`);
+        if (r.source_agent_id ?? r.source) {
+          console.log(`    ${chalk55.dim("source:")} ${r.source_agent_id ?? r.source}`);
+        }
+        if (r.tags && r.tags.length > 0) {
+          console.log(`    ${chalk55.dim("tags:")} ${r.tags.join(", ")}`);
         }
         console.log();
       }
@@ -28465,105 +29377,96 @@ function collectiveSearchCommand() {
   });
 }
 function collectiveInsightsCommand() {
-  return new Command52("insights").description("Aggregated view: top patterns, common failures, most validated learnings").option("--days <n>", "Lookback period in days", "30").option("--json", "Output as JSON").action(async (options) => {
+  return new Command52("insights").description("Aggregated view: breakdown by type, validations, applications, unique agents/workspaces").option("--days <n>", "Lookback period for trending", "30").option("--json", "Output as JSON").action(async (options) => {
     const spinner = ora51("Aggregating collective insights...").start();
     try {
       const client = getClient();
       const days = parseInt(options.days);
-      const [trending, feed, recentLearnings] = await Promise.all([
+      const [stats, trending] = await Promise.all([
         client.query(
-          toFunctionName(api.singularity.getTrendingSkills),
-          { days, limit: 50 }
-        ),
-        client.query(
-          toFunctionName(api.singularity.getIntelligenceFeed),
-          { limit: 10, type: "all" }
+          toFunctionName(api.collective.getStats),
+          {}
         ),
         client.query(
-          toFunctionName(api.learning.getRecentEnriched),
-          { limit: 50 }
+          toFunctionName(api.collective.getTrending),
+          { days, limit: 50 }
         )
       ]);
       spinner.stop();
-      const skills = trending;
-      const feedEntries = feed;
-      const learnings = recentLearnings;
+      const s = stats;
+      const trendingInsights = trending;
       if (options.json) {
-        console.log(JSON.stringify({ trending: skills, feed: feedEntries, learnings }, null, 2));
+        console.log(JSON.stringify({ stats: s, trending: trendingInsights }, null, 2));
         return;
       }
       console.log(chalk55.bold(`
-  Collective Insights (last ${days} days)
+  Collective Intelligence Overview
 `));
-      const topSkills = skills.filter((s) => s.success_rate >= 0.8).slice(0, 5);
-      if (topSkills.length > 0) {
-        console.log(chalk55.dim("  --- Most validated skills ---\n"));
-        for (const s of topSkills) {
-          const rate = (s.success_rate * 100).toFixed(0);
+      const byType = s.by_type ?? {};
+      const typeEntries = Object.entries(byType).sort((a, b) => b[1] - a[1]);
+      if (typeEntries.length > 0) {
+        console.log(chalk55.dim("  --- Insight breakdown by type ---\n"));
+        for (const [typeName, count] of typeEntries) {
+          const bar = miniBar(Math.min(count / Math.max(s.total_insights, 1), 1));
           console.log(
-            `  ${chalk55.green("+")} ${chalk55.bold(s.name)} \u2014 ${rate}% success across ${s.unique_agents} agents (${s.executions} runs)`
+            `  ${typeIcon(typeName)} ${chalk55.bold(String(count).padStart(5))}  ${bar}  ${typeName}`
           );
         }
         console.log();
       }
-      const failures = learnings.filter((l) => l.result === "fail");
-      const failureSkills = {};
-      for (const f of failures) {
-        const name = f.skillName ?? f.skill_name ?? "unknown";
-        failureSkills[name] = (failureSkills[name] ?? 0) + 1;
-      }
-      const topFailures = Object.entries(failureSkills).sort((a, b) => b[1] - a[1]).slice(0, 5);
-      if (topFailures.length > 0) {
-        console.log(chalk55.dim("  --- Common failure points ---\n"));
-        for (const [name, count] of topFailures) {
+      console.log(chalk55.dim("  --- Network summary ---\n"));
+      console.log(`  ${chalk55.dim("total insights:")}       ${s.total_insights ?? 0}`);
+      console.log(`  ${chalk55.dim("total validations:")}    ${s.total_validations ?? 0}`);
+      console.log(`  ${chalk55.dim("total applications:")}   ${s.total_applications ?? 0}`);
+      console.log(`  ${chalk55.dim("unique agents:")}        ${s.unique_agents ?? 0}`);
+      console.log(`  ${chalk55.dim("unique workspaces:")}    ${s.unique_workspaces ?? 0}`);
+      console.log();
+      if (trendingInsights.length > 0) {
+        console.log(chalk55.dim(`  --- Top trending (last ${days} days) ---
+`));
+        for (let i = 0; i < Math.min(trendingInsights.length, 10); i++) {
+          const ins = trendingInsights[i];
+          const impact = (ins.validations ?? 0) + (ins.applications ?? 0);
+          const time = relativeTime(ins.created_at ?? ins._creationTime ?? Date.now());
+          console.log(
+            `  ${chalk55.dim(`${(i + 1).toString().padStart(2)}.`)} ${typeIcon(ins.type)} ${chalk55.bold(ins.title ?? "\u2014")} ${chalk55.dim(time)}`
+          );
           console.log(
-            `  ${chalk55.red("x")} ${chalk55.bold(name)} \u2014 ${count} failure${count > 1 ? "s" : ""}`
+            `      ${ins.validations ?? 0} validations, ${ins.applications ?? 0} applications, impact: ${impact}`
           );
-          const recentFail = failures.find((f) => (f.skillName ?? f.skill_name) === name);
-          if (recentFail?.error_message) {
-            const err = recentFail.error_message.length > 100 ? recentFail.error_message.slice(0, 97) + "..." : recentFail.error_message;
-            console.log(`    ${chalk55.dim(err)}`);
+          if (ins.content) {
+            const content = ins.content.length > 100 ? ins.content.slice(0, 97) + "..." : ins.content;
+            console.log(`      ${chalk55.dim(content)}`);
           }
         }
         console.log();
       }
-      const improvements = learnings.filter((l) => l.improvement);
-      if (improvements.length > 0) {
-        console.log(chalk55.dim("  --- Recent improvement suggestions ---\n"));
-        for (const imp of improvements.slice(0, 5)) {
-          const skill = imp.skillName ?? imp.skill_name ?? "\u2014";
-          const text = imp.improvement.length > 100 ? imp.improvement.slice(0, 97) + "..." : imp.improvement;
-          const time = relativeTime(imp._creationTime ?? Date.now());
+      const validated = [...trendingInsights].sort((a, b) => (b.validations ?? 0) - (a.validations ?? 0)).slice(0, 5);
+      const hasValidated = validated.some((v) => (v.validations ?? 0) > 0);
+      if (hasValidated) {
+        console.log(chalk55.dim("  --- Most validated ---\n"));
+        for (const v of validated) {
+          if ((v.validations ?? 0) === 0) continue;
           console.log(
-            `  ${chalk55.cyan(">")} ${chalk55.bold(skill)} ${chalk55.dim(time)}`
+            `  ${chalk55.green("+")} ${chalk55.bold(v.title ?? "\u2014")} \u2014 ${v.validations} validations from ${v.source_agent_id ?? "network"}`
           );
-          console.log(`    ${chalk55.dim(text)}`);
         }
         console.log();
       }
-      if (feedEntries.length > 0) {
-        console.log(chalk55.dim("  --- Active experiments ---\n"));
-        for (const entry of feedEntries.slice(0, 5)) {
+      const failures = trendingInsights.filter((i) => i.type === "failure_lesson");
+      if (failures.length > 0) {
+        console.log(chalk55.dim("  --- Recent failure lessons ---\n"));
+        for (const f of failures.slice(0, 5)) {
           console.log(
-            `  ${typeIcon(entry.type ?? "learning")} ${chalk55.bold(entry.title ?? "\u2014")}`
+            `  ${chalk55.red("x")} ${chalk55.bold(f.title ?? "\u2014")}`
           );
-          if (entry.details) {
-            console.log(`    ${chalk55.dim(entry.details)}`);
+          if (f.content) {
+            const text = f.content.length > 100 ? f.content.slice(0, 97) + "..." : f.content;
+            console.log(`    ${chalk55.dim(text)}`);
           }
         }
         console.log();
       }
-      const totalExec = skills.reduce((sum, s) => sum + s.executions, 0);
-      const avgSuccess = skills.length > 0 ? skills.reduce((sum, s) => sum + s.success_rate, 0) / skills.length : 0;
-      const totalAgents = new Set(skills.flatMap((s) => Array.from({ length: s.unique_agents }, (_, i) => `${s.name}-${i}`))).size;
-      console.log(chalk55.dim("  --- Network summary ---\n"));
-      console.log(`  ${chalk55.dim("total skills tracked:")}  ${skills.length}`);
-      console.log(`  ${chalk55.dim("total executions:")}      ${totalExec}`);
-      console.log(`  ${chalk55.dim("avg success rate:")}      ${(avgSuccess * 100).toFixed(1)}%`);
-      console.log(`  ${chalk55.dim("recent learnings:")}      ${learnings.length}`);
-      console.log(`  ${chalk55.dim("improvements pending:")}  ${improvements.length}`);
-      console.log(`  ${chalk55.dim("failures tracked:")}      ${failures.length}`);
-      console.log();
     } catch (error) {
       spinner.fail("Failed to aggregate insights");
       console.error(chalk55.red(error.message));
@@ -28571,164 +29474,95 @@ function collectiveInsightsCommand() {
   });
 }
 function collectiveSyncCommand() {
-  return new Command52("sync").description("Pull latest relevant insights from network into local workspace").option("--workspace <hub_id>", "Workspace/hub ID").option("--limit <n>", "Max insights to pull", "25").option("--dir <path>", "Output directory", ".hubify/collective").option("--json", "Output as JSON").action(async (options) => {
+  return new Command52("sync").description("Pull latest insights from collective into local workspace as organized markdown").option("--limit <n>", "Max insights to pull", "50").option("--dir <path>", "Output directory", ".hubify/collective").option("--json", "Output as JSON").action(async (options) => {
     const spinner = ora51("Syncing collective intelligence to local workspace...").start();
     try {
       const client = getClient();
       const limit = parseInt(options.limit);
-      const [feed, trending, recentLearnings] = await Promise.all([
-        client.query(
-          toFunctionName(api.singularity.getIntelligenceFeed),
-          { limit: 10, type: "all" }
-        ),
-        client.query(
-          toFunctionName(api.singularity.getTrendingSkills),
-          { days: 7, limit }
-        ),
-        client.query(
-          toFunctionName(api.learning.getRecentEnriched),
-          { limit }
-        )
-      ]);
+      const collectiveFeed = await client.query(
+        toFunctionName(api.collective.getFeed),
+        { limit }
+      );
       spinner.stop();
-      const feedEntries = feed;
-      const skills = trending;
-      const learnings = recentLearnings;
+      const entries = collectiveFeed;
       if (options.json) {
-        console.log(JSON.stringify({ feed: feedEntries, trending: skills, learnings }, null, 2));
+        console.log(JSON.stringify(entries, null, 2));
         return;
       }
       const outDir = path25.resolve(process.cwd(), options.dir);
       fs25.mkdirSync(outDir, { recursive: true });
       const now = (/* @__PURE__ */ new Date()).toISOString();
       let filesWritten = 0;
-      if (skills.length > 0) {
-        let md = `# Trending Skills
-
-_Synced: ${now}_
-
-`;
-        for (let i = 0; i < skills.length; i++) {
-          const s = skills[i];
-          const rate = (s.success_rate * 100).toFixed(0);
-          md += `${i + 1}. **${s.name}** \u2014 ${s.executions} executions, ${rate}% success, ${s.unique_agents} agents
-`;
-        }
-        fs25.writeFileSync(path25.join(outDir, "trending-skills.md"), md);
-        filesWritten++;
-      }
-      if (learnings.length > 0) {
-        let md = `# Recent Learnings
-
-_Synced: ${now}_
-
-`;
-        for (const l of learnings) {
-          const skill = l.skillName ?? l.skill_name ?? "unknown";
-          const result = l.result ?? "unknown";
-          const time = new Date(l._creationTime ?? Date.now()).toISOString();
-          md += `## ${skill} (${result})
-`;
-          md += `_${time}_ | agent: ${l.agent_id ?? "unknown"} | platform: ${l.platform ?? "unknown"}_
-
-`;
-          if (l.note) md += `> ${l.note}
-
-`;
-          if (l.improvement) md += `**Improvement:** ${l.improvement}
-
-`;
-          if (l.error_message) md += `**Error:** ${l.error_message}
-
-`;
-          md += `---
-
-`;
-        }
-        fs25.writeFileSync(path25.join(outDir, "recent-learnings.md"), md);
-        filesWritten++;
-      }
-      if (feedEntries.length > 0) {
-        let md = `# Active Experiments
-
-_Synced: ${now}_
-
-`;
-        for (const entry of feedEntries) {
-          md += `## ${entry.title ?? "Untitled"}
-`;
-          md += `Type: ${entry.type ?? "unknown"}
-
-`;
-          if (entry.description) md += `${entry.description}
-
-`;
-          if (entry.details) md += `Progress: ${entry.details}
-
-`;
-          md += `---
-
-`;
-        }
-        fs25.writeFileSync(path25.join(outDir, "active-experiments.md"), md);
-        filesWritten++;
-      }
-      const improvements = learnings.filter((l) => l.improvement);
-      if (improvements.length > 0) {
-        let md = `# Patterns & Improvements
+      const grouped = {};
+      for (const entry of entries) {
+        const type = entry.type ?? "learning";
+        if (!grouped[type]) grouped[type] = [];
+        grouped[type].push(entry);
+      }
+      const fileMap = {
+        learning: "learnings.md",
+        pattern: "patterns.md",
+        finding: "findings.md",
+        technique: "techniques.md",
+        experiment_result: "experiment-results.md",
+        failure_lesson: "failure-lessons.md"
+      };
+      const headerMap = {
+        learning: "Learnings",
+        pattern: "Patterns",
+        finding: "Findings",
+        technique: "Techniques",
+        experiment_result: "Experiment Results",
+        failure_lesson: "Failure Lessons"
+      };
+      for (const [type, items] of Object.entries(grouped)) {
+        const filename = fileMap[type] ?? `${type}.md`;
+        const header = headerMap[type] ?? type.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+        let md = `# ${header}
 
 _Synced: ${now}_
+_Source: Hubify Collective Intelligence_
 
 `;
-        md += `These are improvement suggestions extracted from the collective.
-
-`;
-        for (const imp of improvements) {
-          const skill = imp.skillName ?? imp.skill_name ?? "unknown";
-          md += `### ${skill}
-`;
-          md += `${imp.improvement}
-
+        for (const item of items) {
+          const time = new Date(item.created_at ?? item._creationTime ?? Date.now()).toISOString();
+          const confidence = item.confidence ? ` | confidence: ${(item.confidence * 100).toFixed(0)}%` : "";
+          const validations = item.validations ? ` | ${item.validations} validations` : "";
+          const applications = item.applications ? ` | ${item.applications} applications` : "";
+          md += `## ${item.title ?? "Untitled"}
 `;
-        }
-        fs25.writeFileSync(path25.join(outDir, "patterns.md"), md);
-        filesWritten++;
-      }
-      const failures = learnings.filter((l) => l.result === "fail");
-      if (failures.length > 0) {
-        let md = `# Failure Lessons
-
-_Synced: ${now}_
+          md += `_${time}_ | agent: ${item.source_agent_id ?? "unknown"}${confidence}${validations}${applications}
 
 `;
-        md += `Learn from what went wrong across the network.
+          if (item.content) {
+            md += `${item.content}
 
 `;
-        for (const f of failures) {
-          const skill = f.skillName ?? f.skill_name ?? "unknown";
-          md += `### ${skill}
-`;
-          if (f.error_message) md += `**Error:** ${f.error_message}
+          }
+          if (item.context) {
+            md += `**Context:** ${item.context}
 
 `;
-          if (f.note) md += `> ${f.note}
+          }
+          if (item.tags && item.tags.length > 0) {
+            md += `**Tags:** ${item.tags.join(", ")}
 
 `;
+          }
           md += `---
 
 `;
         }
-        fs25.writeFileSync(path25.join(outDir, "failures.md"), md);
+        fs25.writeFileSync(path25.join(outDir, filename), md);
         filesWritten++;
       }
+      const totalEntries = entries.length;
+      const typeBreakdown = Object.entries(grouped).map(([type, items]) => `${type}: ${items.length}`).join(", ");
       console.log(chalk55.bold("\n  Collective intelligence synced to local workspace\n"));
       console.log(`  ${chalk55.dim("directory:")}   ${outDir}`);
       console.log(`  ${chalk55.dim("files:")}       ${filesWritten} files written`);
-      console.log(`  ${chalk55.dim("skills:")}      ${skills.length} trending`);
-      console.log(`  ${chalk55.dim("learnings:")}   ${learnings.length} recent`);
-      console.log(`  ${chalk55.dim("experiments:")} ${feedEntries.length} active`);
-      console.log(`  ${chalk55.dim("patterns:")}    ${improvements.length} improvement suggestions`);
-      console.log(`  ${chalk55.dim("failures:")}    ${failures.length} tracked`);
+      console.log(`  ${chalk55.dim("insights:")}    ${totalEntries} total`);
+      console.log(`  ${chalk55.dim("breakdown:")}   ${typeBreakdown || "none"}`);
       console.log();
       console.log(chalk55.dim("  Files are markdown \u2014 ready for agent consumption."));
       console.log(chalk55.dim(`  Add ${options.dir}/ to your agent's context for smarter decisions.`));
@@ -28745,64 +29579,1491 @@ function miniBar(ratio) {
   return chalk55.green("\u2588".repeat(filled)) + chalk55.dim("\u2591".repeat(empty));
 }
 
-// src/index.ts
-function getCliVersion() {
-  try {
-    const pkgUrl = new URL("../package.json", import.meta.url);
-    const pkg = JSON.parse(fs26.readFileSync(pkgUrl, "utf8"));
-    return pkg.version || "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}
-var VERSION = getCliVersion();
-var BANNER = `
-${chalk56.cyan("    __  __      __    _ ____     ")}
-${chalk56.cyan("   / / / /_  __/ /_  (_) __/_  __")}
-${chalk56.cyan("  / /_/ / / / / __ \\/ / /_/ / / /")}
-${chalk56.cyan(" / __  / /_/ / /_/ / / __/ /_/ / ")}
-${chalk56.cyan("/_/ /_/\\__,_/_.___/_/_/  \\__, /  ")}
-${chalk56.cyan("                        /____/   ")}
+// src/commands/vault.ts
+import { Command as Command53 } from "commander";
+import chalk56 from "chalk";
+import ora52 from "ora";
+import crypto7 from "crypto";
+function relativeTime2(ts) {
+  const diff = Date.now() - ts;
+  const mins = Math.floor(diff / 6e4);
+  const hrs = Math.floor(mins / 60);
+  const days = Math.floor(hrs / 24);
+  if (days > 0) return `${days}d ago`;
+  if (hrs > 0) return `${hrs}h ago`;
+  if (mins > 0) return `${mins}m ago`;
+  return "just now";
+}
+function encrypt(text, passphrase) {
+  const key = crypto7.scryptSync(passphrase, "hubify-vault-salt", 32);
+  const iv = crypto7.randomBytes(16);
+  const cipher = crypto7.createCipheriv("aes-256-cbc", key, iv);
+  let encrypted = cipher.update(text, "utf8", "hex");
+  encrypted += cipher.final("hex");
+  return iv.toString("hex") + ":" + encrypted;
+}
+function decrypt(encrypted, passphrase) {
+  const key = crypto7.scryptSync(passphrase, "hubify-vault-salt", 32);
+  const [ivHex, encHex] = encrypted.split(":");
+  const iv = Buffer.from(ivHex, "hex");
+  const decipher = crypto7.createDecipheriv("aes-256-cbc", key, iv);
+  let decrypted = decipher.update(encHex, "hex", "utf8");
+  decrypted += decipher.final("utf8");
+  return decrypted;
+}
+function vaultListCommand() {
+  return new Command53("list").description("List vault entries for a workspace").argument("<hub_id>", "Hub/workspace ID").option("--owner <id>", "Owner ID", "user_default").option("--json", "Output as JSON").action(async (hubId, options) => {
+    const spinner = ora52("Fetching vault entries...").start();
+    try {
+      const client = getClient();
+      const entries = await client.query(
+        toFunctionName(api.vault.listVaultEntries),
+        { hub_id: hubId, owner_id: options.owner }
+      );
+      spinner.stop();
+      if (options.json) {
+        console.log(JSON.stringify(entries, null, 2));
+        return;
+      }
+      if (!entries || entries.length === 0) {
+        console.log(chalk56.gray("\n  No vault entries. Add one with:"));
+        console.log(chalk56.cyan("  hubify vault store <hub_id> --service github --type api_key --value <key>\n"));
+        return;
+      }
+      console.log(chalk56.cyan(`
+  Vault (${entries.length} entries)
+`));
+      for (const entry of entries) {
+        const typeColor = entry.type === "api_key" ? chalk56.yellow : entry.type === "mcp" ? chalk56.blue : chalk56.green;
+        console.log(
+          `  ${typeColor(entry.type.padEnd(12))} ${chalk56.white(entry.service.padEnd(20))} ` + chalk56.gray(`agents: ${entry.granted_agents.join(", ") || "none"}`) + (entry.last_accessed ? chalk56.dim(`  last used ${relativeTime2(entry.last_accessed)}`) : "")
+        );
+      }
+      console.log();
+    } catch (error) {
+      spinner.fail("Failed to list vault entries");
+      console.error(chalk56.red(`  ${error.message}`));
+    }
+  });
+}
+function vaultStoreCommand() {
+  return new Command53("store").description("Store a credential in the vault").argument("<hub_id>", "Hub/workspace ID").requiredOption("--service <name>", "Service name (e.g., github, openai, slack)").requiredOption("--type <type>", "Entry type: api_key, mcp, oauth_token").requiredOption("--value <value>", "The secret value to store").option("--owner <id>", "Owner ID", "user_default").option("--agents <agents>", "Comma-separated agent IDs granted access", "all").option("--passphrase <p>", "Encryption passphrase", "hubify-default-key").action(async (hubId, options) => {
+    const validTypes = ["api_key", "mcp", "oauth_token"];
+    if (!validTypes.includes(options.type)) {
+      console.log(chalk56.red(`
+  Invalid type: ${options.type}. Must be one of: ${validTypes.join(", ")}
+`));
+      process.exit(1);
+    }
+    const spinner = ora52(`Encrypting and storing ${options.service} credential...`).start();
+    try {
+      const client = getClient();
+      const encrypted = encrypt(options.value, options.passphrase);
+      const agents = options.agents.split(",").map((a) => a.trim());
+      await client.mutation(
+        toFunctionName(api.vault.addVaultEntry),
+        {
+          hub_id: hubId,
+          owner_id: options.owner,
+          entry: {
+            id: `${options.service}-${options.type}-${Date.now()}`,
+            type: options.type,
+            service: options.service,
+            encrypted_config: encrypted,
+            granted_agents: agents
+          }
+        }
+      );
+      spinner.succeed(`Stored ${options.service} credential`);
+      console.log(chalk56.gray(`  Type:    ${options.type}`));
+      console.log(chalk56.gray(`  Agents:  ${agents.join(", ")}`));
+      console.log(chalk56.gray(`  Hub:     ${hubId}`));
+      console.log();
+    } catch (error) {
+      spinner.fail("Failed to store credential");
+      console.error(chalk56.red(`  ${error.message}`));
+    }
+  });
+}
+function vaultGetCommand() {
+  return new Command53("get").description("Retrieve a credential from the vault (requires agent access)").argument("<hub_id>", "Hub/workspace ID").requiredOption("--service <name>", "Service name").option("--agent <id>", "Requesting agent ID", "cli-user").option("--passphrase <p>", "Decryption passphrase", "hubify-default-key").option("--json", "Output as JSON").action(async (hubId, options) => {
+    const spinner = ora52(`Retrieving ${options.service} credential...`).start();
+    try {
+      const client = getClient();
+      const result = await client.mutation(
+        toFunctionName(api.vault.getVaultEntry),
+        {
+          hub_id: hubId,
+          service: options.service,
+          requesting_agent: options.agent
+        }
+      );
+      spinner.stop();
+      if (!result) {
+        console.log(chalk56.yellow(`
+  No credential found for service: ${options.service}
+`));
+        return;
+      }
+      if (result.error) {
+        console.log(chalk56.red(`
+  Access denied: ${result.error}
+`));
+        process.exit(1);
+      }
+      const decrypted = decrypt(result.encrypted_config, options.passphrase);
+      if (options.json) {
+        console.log(JSON.stringify({ service: result.service, type: result.type, value: decrypted }, null, 2));
+        return;
+      }
+      console.log(chalk56.cyan(`
+  ${result.service} (${result.type})
+`));
+      console.log(chalk56.white(`  ${decrypted}`));
+      console.log();
+    } catch (error) {
+      spinner.fail("Failed to retrieve credential");
+      console.error(chalk56.red(`  ${error.message}`));
+    }
+  });
+}
+function vaultRevokeCommand() {
+  return new Command53("revoke").description("Delete a vault entry").argument("<hub_id>", "Hub/workspace ID").requiredOption("--entry-id <id>", "Entry ID to revoke").action(async (hubId, options) => {
+    const spinner = ora52("Revoking vault entry...").start();
+    try {
+      const client = getClient();
+      await client.mutation(
+        toFunctionName(api.vault.deleteVaultEntry),
+        { hub_id: hubId, entry_id: options.entryId }
+      );
+      spinner.succeed("Vault entry revoked");
+      console.log(chalk56.gray(`  Entry ${options.entryId} has been removed.
+`));
+    } catch (error) {
+      spinner.fail("Failed to revoke entry");
+      console.error(chalk56.red(`  ${error.message}`));
+    }
+  });
+}
+function vaultGrantCommand() {
+  return new Command53("grant").description("Update which agents can access a vault entry").argument("<hub_id>", "Hub/workspace ID").requiredOption("--entry-id <id>", "Entry ID").requiredOption("--agents <agents>", "Comma-separated agent IDs (or 'all')").action(async (hubId, options) => {
+    const spinner = ora52("Updating access grants...").start();
+    try {
+      const client = getClient();
+      const agents = options.agents.split(",").map((a) => a.trim());
+      await client.mutation(
+        toFunctionName(api.vault.updateVaultEntryGrants),
+        { hub_id: hubId, entry_id: options.entryId, granted_agents: agents }
+      );
+      spinner.succeed("Access grants updated");
+      console.log(chalk56.gray(`  Agents: ${agents.join(", ")}
+`));
+    } catch (error) {
+      spinner.fail("Failed to update grants");
+      console.error(chalk56.red(`  ${error.message}`));
+    }
+  });
+}
+function vaultAuditCommand() {
+  return new Command53("audit").description("View access log for a vault service").argument("<hub_id>", "Hub/workspace ID").requiredOption("--service <name>", "Service name").option("--limit <n>", "Max entries", "20").option("--json", "Output as JSON").action(async (hubId, options) => {
+    const spinner = ora52("Fetching access log...").start();
+    try {
+      const client = getClient();
+      const logs = await client.query(
+        toFunctionName(api.vault.getVaultAccessLog),
+        { hub_id: hubId, service: options.service, limit: parseInt(options.limit) }
+      );
+      spinner.stop();
+      if (options.json) {
+        console.log(JSON.stringify(logs, null, 2));
+        return;
+      }
+      if (!logs || logs.length === 0) {
+        console.log(chalk56.gray(`
+  No access logs for ${options.service}
+`));
+        return;
+      }
+      console.log(chalk56.cyan(`
+  Access Log: ${options.service} (${logs.length} entries)
+`));
+      for (const log of logs) {
+        console.log(
+          `  ${chalk56.gray(relativeTime2(log.timestamp).padEnd(12))} ${chalk56.white(log.agent_id.padEnd(20))} ` + chalk56.dim(log.operation)
+        );
+      }
+      console.log();
+    } catch (error) {
+      spinner.fail("Failed to fetch access log");
+      console.error(chalk56.red(`  ${error.message}`));
+    }
+  });
+}
+var vaultCommand = new Command53("vault").description("Manage tool credentials and API keys for workspace agents").addCommand(vaultListCommand()).addCommand(vaultStoreCommand()).addCommand(vaultGetCommand()).addCommand(vaultRevokeCommand()).addCommand(vaultGrantCommand()).addCommand(vaultAuditCommand());
+
+// src/commands/reports.ts
+import { Command as Command54 } from "commander";
+import chalk57 from "chalk";
+import ora53 from "ora";
+var reportsCommand = new Command54("reports").description("Weekly intelligence reports \u2014 network activity, skills, experiments").addCommand(reportsLatestCommand()).addCommand(reportsListCommand()).addCommand(reportsViewCommand());
+function reportsLatestCommand() {
+  return new Command54("latest").description("Show the most recent weekly intelligence report").option("--json", "Output as raw JSON").action(async (options) => {
+    const spinner = ora53("Fetching latest report...").start();
+    try {
+      const client = getClient();
+      const report = await client.query(
+        toFunctionName("weeklyReport:getLatestReport"),
+        {}
+      );
+      spinner.stop();
+      if (!report) {
+        console.log(chalk57.dim("  No weekly reports available yet."));
+        return;
+      }
+      if (options.json) {
+        console.log(JSON.stringify(report, null, 2));
+        return;
+      }
+      printFullReport(report);
+    } catch (error) {
+      spinner.fail("Failed to fetch latest report");
+      console.error(chalk57.red(error.message));
+    }
+  });
+}
+function reportsListCommand() {
+  return new Command54("list").description("List available weekly reports").option("--limit <n>", "Number of reports to show", "10").option("--json", "Output as raw JSON").action(async (options) => {
+    const spinner = ora53("Fetching report list...").start();
+    try {
+      const client = getClient();
+      const reports = await client.query(
+        toFunctionName("weeklyReport:listReports"),
+        { limit: parseInt(options.limit) }
+      );
+      spinner.stop();
+      if (options.json) {
+        console.log(JSON.stringify(reports, null, 2));
+        return;
+      }
+      const list = reports;
+      if (list.length === 0) {
+        console.log(chalk57.dim("  No weekly reports available yet."));
+        return;
+      }
+      console.log(chalk57.bold(`
+  Weekly Intelligence Reports (${list.length})
+`));
+      console.log(
+        chalk57.dim("  ") + chalk57.white("Week Start".padEnd(14)) + chalk57.white("Week End".padEnd(14)) + chalk57.white("Generated".padEnd(24)) + chalk57.white("Executions".padEnd(12)) + chalk57.white("New Skills".padEnd(12)) + chalk57.white("Experiments")
+      );
+      console.log(chalk57.dim("  " + "\u2500".repeat(88)));
+      for (const r of list) {
+        const weekStart = formatDate3(r.week_start).padEnd(14);
+        const weekEnd = formatDate3(r.week_end).padEnd(14);
+        const generated = new Date(r.generated_at).toLocaleString().padEnd(24);
+        const executions = String(r.stats?.total_executions ?? "\u2014").padEnd(12);
+        const newSkills = String(r.stats?.new_skills ?? "\u2014").padEnd(12);
+        const experiments = String(r.stats?.active_experiments ?? "\u2014");
+        console.log(
+          chalk57.dim("  ") + chalk57.cyan(weekStart) + chalk57.dim(weekEnd) + chalk57.dim(generated) + chalk57.yellow(executions) + chalk57.green(newSkills) + chalk57.dim(experiments)
+        );
+      }
+      console.log();
+      console.log(chalk57.dim("  Use `hubify reports view --date <YYYY-MM-DD>` to view a specific week."));
+      console.log();
+    } catch (error) {
+      spinner.fail("Failed to fetch report list");
+      console.error(chalk57.red(error.message));
+    }
+  });
+}
+function reportsViewCommand() {
+  return new Command54("view").description("View report for a specific week").requiredOption("--date <date>", "ISO date string within the week (e.g. 2026-03-10)").option("--json", "Output as raw JSON").action(async (options) => {
+    const spinner = ora53(`Fetching report for ${options.date}...`).start();
+    try {
+      const parsed = Date.parse(options.date);
+      if (isNaN(parsed)) {
+        spinner.fail("Invalid date");
+        console.error(chalk57.red(`  Could not parse date: ${options.date}`));
+        console.error(chalk57.dim("  Expected ISO format, e.g. 2026-03-10"));
+        process.exit(1);
+      }
+      const client = getClient();
+      const report = await client.query(
+        toFunctionName("weeklyReport:getReportByWeek"),
+        { date: parsed }
+      );
+      spinner.stop();
+      if (!report) {
+        console.log(chalk57.dim(`  No report found for the week containing ${options.date}.`));
+        return;
+      }
+      if (options.json) {
+        console.log(JSON.stringify(report, null, 2));
+        return;
+      }
+      printFullReport(report);
+    } catch (error) {
+      spinner.fail("Failed to fetch report");
+      console.error(chalk57.red(error.message));
+    }
+  });
+}
+function printFullReport(r) {
+  const weekStart = formatDate3(r.week_start);
+  const weekEnd = formatDate3(r.week_end);
+  const generated = new Date(r.generated_at).toLocaleString();
+  console.log();
+  console.log(chalk57.bold(`  Weekly Intelligence Report`));
+  console.log(chalk57.dim(`  ${weekStart} \u2192 ${weekEnd}  \xB7  generated ${generated}`));
+  console.log(chalk57.dim("  " + "\u2500".repeat(60)));
+  const s = r.stats ?? {};
+  console.log();
+  console.log(chalk57.bold("  Overview"));
+  console.log();
+  const delta = s.execution_delta_pct ?? 0;
+  const deltaStr = delta >= 0 ? chalk57.green(`+${delta.toFixed(1)}%`) : chalk57.red(`${delta.toFixed(1)}%`);
+  console.log(`  ${chalk57.dim("Executions:          ")} ${chalk57.yellow(s.total_executions ?? 0)}  ${deltaStr} vs last week`);
+  console.log(`  ${chalk57.dim("New skills:          ")} ${chalk57.cyan(s.new_skills ?? 0)}`);
+  console.log(`  ${chalk57.dim("Skills evolved:      ")} ${chalk57.cyan(s.skills_evolved ?? 0)}`);
+  console.log(`  ${chalk57.dim("New learnings:       ")} ${s.new_learnings ?? 0}`);
+  console.log(`  ${chalk57.dim("New agents:          ")} ${s.new_agents ?? 0}`);
+  console.log(`  ${chalk57.dim("Security scans:      ")} ${s.security_scans ?? 0}`);
+  console.log(`  ${chalk57.dim("Collective insights: ")} ${s.collective_insights_shared ?? 0}`);
+  console.log(`  ${chalk57.dim("Active experiments:  ")} ${s.active_experiments ?? 0}`);
+  if (r.top_used_skills?.length) {
+    console.log();
+    console.log(chalk57.bold("  Top Used Skills"));
+    console.log();
+    console.log(
+      chalk57.dim("  ") + chalk57.dim("Skill".padEnd(36)) + chalk57.dim("Executions".padEnd(12)) + chalk57.dim("Success Rate")
+    );
+    console.log(chalk57.dim("  " + "\u2500".repeat(62)));
+    for (let i = 0; i < r.top_used_skills.length; i++) {
+      const sk = r.top_used_skills[i];
+      const rank = chalk57.dim(`${i + 1}.`.padEnd(4));
+      const name = chalk57.cyan(sk.name.padEnd(32));
+      const execs = chalk57.yellow(String(sk.executions).padEnd(12));
+      const rate = formatSuccessRate(sk.success_rate);
+      console.log(`  ${rank}${name}${execs}${rate}`);
+    }
+  }
+  if (r.top_improving_skills?.length) {
+    console.log();
+    console.log(chalk57.bold("  Top Improving Skills"));
+    console.log();
+    console.log(
+      chalk57.dim("  ") + chalk57.dim("Skill".padEnd(36)) + chalk57.dim("Confidence".padEnd(12)) + chalk57.dim("Delta")
+    );
+    console.log(chalk57.dim("  " + "\u2500".repeat(62)));
+    for (let i = 0; i < r.top_improving_skills.length; i++) {
+      const sk = r.top_improving_skills[i];
+      const rank = chalk57.dim(`${i + 1}.`.padEnd(4));
+      const name = chalk57.cyan(sk.name.padEnd(32));
+      const conf = `${(sk.confidence * 100).toFixed(1)}%`.padEnd(12);
+      const delta2 = sk.confidence_delta >= 0 ? chalk57.green(`+${(sk.confidence_delta * 100).toFixed(1)}%`) : chalk57.red(`${(sk.confidence_delta * 100).toFixed(1)}%`);
+      console.log(`  ${rank}${name}${conf}${delta2}`);
+    }
+  }
+  if (r.new_skills_list?.length) {
+    console.log();
+    console.log(chalk57.bold("  New Skills This Week"));
+    console.log();
+    for (const sk of r.new_skills_list) {
+      const conf = `${(sk.confidence * 100).toFixed(0)}%`;
+      console.log(
+        `  ${chalk57.green("+")} ${chalk57.cyan(sk.name)}  ` + chalk57.dim(`conf ${conf}  executions ${sk.executions}`)
+      );
+    }
+  }
+  if (r.evolution_events?.length) {
+    console.log();
+    console.log(chalk57.bold("  Evolution Events"));
+    console.log();
+    for (const ev of r.evolution_events) {
+      const time = new Date(ev.timestamp).toLocaleString();
+      const typeLabel = formatEvolutionType(ev.event_type);
+      console.log(`  ${typeLabel} ${chalk57.cyan(ev.skill_name)}  ${chalk57.dim(time)}`);
+    }
+  }
+  if (r.top_platforms?.length) {
+    console.log();
+    console.log(chalk57.bold("  Top Platforms"));
+    console.log();
+    for (const p of r.top_platforms) {
+      console.log(`  ${chalk57.dim("\xB7")} ${p.platform.padEnd(20)} ${chalk57.yellow(p.executions)} executions`);
+    }
+  }
+  if (r.failure_patterns?.length) {
+    console.log();
+    console.log(chalk57.bold("  Failure Patterns"));
+    console.log();
+    for (const fp of r.failure_patterns) {
+      console.log(`  ${chalk57.red("!")} ${fp.pattern}  ${chalk57.dim(`(${fp.count} occurrences)`)}`);
+      if (fp.affected_skills?.length) {
+        console.log(`    ${chalk57.dim("affected:")} ${fp.affected_skills.join(", ")}`);
+      }
+    }
+  }
+  if (r.experiment_missions?.length) {
+    console.log();
+    console.log(chalk57.bold("  Experiment Missions"));
+    console.log();
+    for (const m of r.experiment_missions) {
+      const statusColor = m.status === "completed" ? chalk57.green : m.status === "active" ? chalk57.cyan : chalk57.dim;
+      console.log(`  ${statusColor(`[${m.status}]`)} ${chalk57.bold(m.title)}`);
+      console.log(`    ${chalk57.dim("experiments completed:")} ${m.experiments_completed}`);
+      if (m.best_metric != null) {
+        console.log(`    ${chalk57.dim("best metric:")} ${m.best_metric}`);
+      }
+    }
+  }
+  if (r.highlights?.length) {
+    console.log();
+    console.log(chalk57.bold("  Highlights"));
+    console.log();
+    for (const h of r.highlights) {
+      console.log(`  ${chalk57.yellow("\u203A")} ${h}`);
+    }
+  }
+  console.log();
+}
+function formatDate3(ts) {
+  return new Date(ts).toISOString().slice(0, 10);
+}
+function formatSuccessRate(rate) {
+  const pct = `${(rate * 100).toFixed(1)}%`;
+  if (rate >= 0.8) return chalk57.green(pct);
+  if (rate >= 0.5) return chalk57.yellow(pct);
+  return chalk57.red(pct);
+}
+function formatEvolutionType(eventType) {
+  switch (eventType) {
+    case "promoted":
+      return chalk57.green("[promoted]");
+    case "canary":
+      return chalk57.yellow("[canary]  ");
+    case "merged":
+      return chalk57.cyan("[merged]  ");
+    case "rejected":
+      return chalk57.red("[rejected]");
+    default:
+      return chalk57.dim(`[${eventType}]`);
+  }
+}
+
+// src/commands/mission.ts
+import { Command as Command55 } from "commander";
+import chalk58 from "chalk";
+import ora54 from "ora";
+var missionCommand = new Command55("mission").description("Autonomous Mission Runner \u2014 Ralph Loop").addCommand(missionListCommand()).addCommand(missionCreateCommand()).addCommand(missionRunCommand()).addCommand(missionStatusCommand()).addCommand(missionStopCommand()).addCommand(missionAgentsCommand());
+function missionListCommand() {
+  return new Command55("list").description("List missions").option("--status <status>", "Filter by status (proposed|approved|active|completed)").option("--limit <n>", "Max results", "20").option("--json", "Output as JSON").action(async (options) => {
+    const client = getClient();
+    const spinner = ora54("Fetching missions...").start();
+    try {
+      const missions = await client.query(toFunctionName(api.research.listMissions), {
+        status: options.status,
+        limit: parseInt(options.limit)
+      });
+      spinner.stop();
+      if (options.json) {
+        console.log(JSON.stringify(missions, null, 2));
+        return;
+      }
+      if (!missions || missions.length === 0) {
+        console.log(chalk58.dim("No missions found."));
+        return;
+      }
+      console.log(chalk58.bold(`
+  Missions (${missions.length})
+`));
+      for (const m of missions) {
+        const statusColor = m.status === "active" ? chalk58.green : m.status === "completed" ? chalk58.blue : m.status === "proposed" ? chalk58.yellow : chalk58.dim;
+        console.log(`  ${statusColor("\u25CF")} ${chalk58.bold(m.title)}`);
+        console.log(`    ${chalk58.dim("ID:")} ${m._id}`);
+        console.log(`    ${chalk58.dim("Type:")} ${m.mission_type}  ${chalk58.dim("Status:")} ${statusColor(m.status)}`);
+        if (m.experiment_config?.experiments_completed !== void 0) {
+          console.log(`    ${chalk58.dim("Experiments:")} ${m.experiment_config.experiments_completed}/${m.experiment_config.max_experiments}`);
+        }
+        console.log();
+      }
+    } catch (e) {
+      spinner.fail(e.message);
+    }
+  });
+}
+function missionCreateCommand() {
+  return new Command55("create").description("Create a new research mission").argument("<hub_id>", "Hub ID to create mission in").requiredOption("--title <title>", "Mission title").requiredOption("--question <question>", "Research question").option("--type <type>", "Mission type", "technical").option("--methodology <method>", "Research methodology").option("--description <desc>", "Detailed description").option("--max-experiments <n>", "Max experiments", "50").option("--time-hours <n>", "Time budget in hours", "24").option("--max-cost <n>", "Max cost in USD", "5.00").option("--metric <name>", "Primary metric name", "quality_score").option("--direction <dir>", "Metric direction (maximize|minimize)", "maximize").option("--json", "Output as JSON").action(async (hubId, options) => {
+    const client = getClient();
+    const spinner = ora54("Creating mission...").start();
+    try {
+      const result = await client.mutation(toFunctionName(api.research.proposeMission), {
+        hub_id: hubId,
+        title: options.title,
+        description: options.description || options.title,
+        research_question: options.question,
+        methodology: options.methodology,
+        mission_type: options.type,
+        proposed_by: "cli-user",
+        experiment_config: {
+          enabled: true,
+          primary_metric: options.metric,
+          metric_direction: options.direction,
+          budget_minutes_per_experiment: 15,
+          max_experiments: parseInt(options.maxExperiments),
+          time_budget_hours: parseInt(options.timeHours),
+          max_cost_usd: parseFloat(options.maxCost),
+          minimum_improvement_threshold: 0.01
+        }
+      });
+      spinner.succeed("Mission created");
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log(`
+  ${chalk58.bold("Mission ID:")} ${result}`);
+        console.log(`  ${chalk58.dim("Next:")} hubify mission run ${result}`);
+      }
+    } catch (e) {
+      spinner.fail(e.message);
+    }
+  });
+}
+function missionRunCommand() {
+  return new Command55("run").description("Run autonomous mission loop (Ralph Loop)").argument("<mission_id>", "Mission ID to run").option("--cycles <n>", "Max cycles before stopping (0 = until budget exhausted)", "0").option("--interval <ms>", "Delay between cycles in ms", "2000").option("--dry-run", "Show what would happen without executing").action(async (missionId, options) => {
+    const client = getClient();
+    const maxCycles = parseInt(options.cycles);
+    const interval = parseInt(options.interval);
+    console.log(chalk58.bold("\n  Ralph Loop \u2014 Autonomous Mission Runner\n"));
+    console.log(`  ${chalk58.dim("Mission:")} ${missionId}`);
+    console.log(`  ${chalk58.dim("Max cycles:")} ${maxCycles || "unlimited (budget-limited)"}`);
+    console.log(`  ${chalk58.dim("Interval:")} ${interval}ms`);
+    console.log();
+    const spinner = ora54("Loading mission...").start();
+    let mission;
+    try {
+      mission = await client.query(toFunctionName(api.research.getMission), {
+        id: missionId
+      });
+      if (!mission) {
+        spinner.fail("Mission not found");
+        return;
+      }
+      spinner.succeed(`${mission.title} (${mission.status})`);
+    } catch (e) {
+      spinner.fail(e.message);
+      return;
+    }
+    if (mission.status === "proposed") {
+      const approveSpinner = ora54("Auto-approving mission...").start();
+      try {
+        await client.mutation(toFunctionName(api.research.approveMission), {
+          mission_id: missionId,
+          approved_by: "ralph-loop"
+        });
+        approveSpinner.succeed("Mission approved");
+      } catch (e) {
+        approveSpinner.fail(e.message);
+      }
+    }
+    if (mission.status === "proposed" || mission.status === "approved") {
+      const startSpinner = ora54("Starting mission...").start();
+      try {
+        await client.mutation(toFunctionName(api.research.startMission), {
+          mission_id: missionId
+        });
+        startSpinner.succeed("Mission started");
+      } catch (e) {
+        startSpinner.fail(e.message);
+        return;
+      }
+    }
+    const config = mission.experiment_config;
+    if (config) {
+      console.log(chalk58.dim("\n  Budget:"));
+      console.log(`    Experiments: ${config.experiments_completed || 0}/${config.max_experiments}`);
+      console.log(`    Time: ${config.time_budget_hours}h`);
+      console.log(`    Cost: $${(config.cost_spent_usd || 0).toFixed(2)}/$${config.max_cost_usd}`);
+      console.log(`    Metric: ${config.primary_metric} (${config.metric_direction})`);
+      if (config.best_metric_value !== void 0) {
+        console.log(`    Best: ${config.best_metric_value}`);
+      }
+    }
+    if (options.dryRun) {
+      console.log(chalk58.yellow("\n  Dry run \u2014 no experiments will be executed."));
+      return;
+    }
+    console.log(chalk58.green("\n  \u26A1 Entering Ralph Loop...\n"));
+    let cycle = 0;
+    let consecutiveFailures = 0;
+    const maxConsecutiveFailures = 5;
+    while (true) {
+      cycle++;
+      if (maxCycles > 0 && cycle > maxCycles) {
+        console.log(chalk58.yellow(`
+  Reached max cycles (${maxCycles}). Stopping.`));
+        break;
+      }
+      const cycleSpinner = ora54(`Cycle ${cycle}: Checking frontier...`).start();
+      try {
+        const summary = await client.query(toFunctionName(api.research.getExperimentSummary), {
+          mission_id: missionId
+        });
+        if (!summary) {
+          cycleSpinner.fail("Could not fetch experiment summary");
+          break;
+        }
+        const expConfig = summary.config;
+        if (expConfig) {
+          if (expConfig.experiments_completed >= expConfig.max_experiments) {
+            cycleSpinner.info(`Budget exhausted: ${expConfig.experiments_completed}/${expConfig.max_experiments} experiments`);
+            break;
+          }
+          if (expConfig.cost_spent_usd >= expConfig.max_cost_usd) {
+            cycleSpinner.info(`Cost budget exhausted: $${expConfig.cost_spent_usd.toFixed(2)}/$${expConfig.max_cost_usd}`);
+            break;
+          }
+        }
+        const frontier = await client.query(toFunctionName(api.experimentDag.getLeaves), {
+          mission_id: missionId,
+          limit: 5
+        });
+        if (!frontier || frontier.length === 0) {
+          cycleSpinner.warn("No frontier nodes available \u2014 waiting...");
+          consecutiveFailures++;
+          if (consecutiveFailures >= maxConsecutiveFailures) {
+            console.log(chalk58.yellow(`
+  ${maxConsecutiveFailures} consecutive failures. Stopping.`));
+            break;
+          }
+          await sleep2(interval * 2);
+          continue;
+        }
+        cycleSpinner.text = `Cycle ${cycle}: Triggering experiment (frontier: ${frontier.length} nodes)...`;
+        const triggerResult = await client.mutation(toFunctionName(api.experimentRunner.triggerCycle), {
+          mission_id: missionId
+        });
+        if (!triggerResult.triggered) {
+          cycleSpinner.info(`Cycle ${cycle}: Budget exhausted (${triggerResult.reason})`);
+          break;
+        }
+        consecutiveFailures = 0;
+        const completed = triggerResult.experiments_completed || 0;
+        const max = triggerResult.max_experiments || 0;
+        const cost = triggerResult.cost_spent_usd || 0;
+        const maxCost = triggerResult.max_cost_usd || 0;
+        const best = expConfig?.best_metric_value;
+        const pct = max > 0 ? Math.round(completed / max * 100) : 0;
+        const bar = progressBar3(pct, 20);
+        cycleSpinner.succeed(
+          `Cycle ${cycle}: ${bar} ${completed}/${max} experiments \xB7 $${cost.toFixed(2)}/$${maxCost.toFixed(2)} \xB7 best: ${best ?? "\u2014"}`
+        );
+      } catch (e) {
+        cycleSpinner.fail(`Cycle ${cycle}: ${e.message}`);
+        consecutiveFailures++;
+        if (consecutiveFailures >= maxConsecutiveFailures) {
+          console.log(chalk58.red(`
+  ${maxConsecutiveFailures} consecutive failures. Stopping.`));
+          break;
+        }
+      }
+      await sleep2(interval);
+    }
+    console.log(chalk58.bold("\n  Ralph Loop completed.\n"));
+    try {
+      const finalSummary = await client.query(toFunctionName(api.research.getExperimentSummary), {
+        mission_id: missionId
+      });
+      if (finalSummary?.config) {
+        const c = finalSummary.config;
+        console.log(`  Experiments: ${c.experiments_completed}/${c.max_experiments}`);
+        console.log(`  Cost: $${(c.cost_spent_usd || 0).toFixed(2)}/$${c.max_cost_usd}`);
+        console.log(`  Best metric: ${c.best_metric_value ?? "none"}`);
+        if (c.best_node_id) {
+          console.log(`  Best node: ${c.best_node_id}`);
+        }
+      }
+      if (finalSummary?.stats) {
+        console.log(`  DAG: ${finalSummary.stats.total_nodes} nodes, depth ${finalSummary.stats.max_depth}`);
+        console.log(`  Success rate: ${Math.round(finalSummary.stats.completed_nodes / Math.max(finalSummary.stats.total_nodes, 1) * 100)}%`);
+      }
+    } catch {
+    }
+    console.log(`
+  ${chalk58.dim("View results:")} hubify mission status ${missionId}`);
+    console.log(`  ${chalk58.dim("Best path:")} hubify labs best-path ${missionId}
+`);
+  });
+}
+function missionStatusCommand() {
+  return new Command55("status").description("Show mission progress and DAG stats").argument("<mission_id>", "Mission ID").option("--json", "Output as JSON").action(async (missionId, options) => {
+    const client = getClient();
+    const spinner = ora54("Fetching mission status...").start();
+    try {
+      const [mission, summary, dagStats] = await Promise.all([
+        client.query(toFunctionName(api.research.getMission), { id: missionId }),
+        client.query(toFunctionName(api.research.getExperimentSummary), { mission_id: missionId }),
+        client.query(toFunctionName(api.experimentDag.getDAGStats), { mission_id: missionId })
+      ]);
+      spinner.stop();
+      if (!mission) {
+        console.log(chalk58.red("Mission not found."));
+        return;
+      }
+      if (options.json) {
+        console.log(JSON.stringify({ mission, summary, dagStats }, null, 2));
+        return;
+      }
+      const statusColor = mission.status === "active" ? chalk58.green : mission.status === "completed" ? chalk58.blue : chalk58.yellow;
+      console.log(chalk58.bold(`
+  ${mission.title}`));
+      console.log(`  ${chalk58.dim("Status:")} ${statusColor(mission.status)}  ${chalk58.dim("Type:")} ${mission.mission_type}`);
+      console.log(`  ${chalk58.dim("Question:")} ${mission.research_question}`);
+      if (summary?.config) {
+        const c = summary.config;
+        const pct = c.max_experiments > 0 ? Math.round(c.experiments_completed / c.max_experiments * 100) : 0;
+        console.log(chalk58.bold("\n  Experiment Budget"));
+        console.log(`  ${progressBar3(pct, 30)} ${c.experiments_completed}/${c.max_experiments} experiments (${pct}%)`);
+        console.log(`  Cost: $${(c.cost_spent_usd || 0).toFixed(2)} / $${c.max_cost_usd}`);
+        console.log(`  Metric: ${c.primary_metric} (${c.metric_direction})`);
+        if (c.best_metric_value !== void 0) {
+          console.log(`  ${chalk58.green("Best:")} ${c.best_metric_value}`);
+        }
+      }
+      if (dagStats) {
+        console.log(chalk58.bold("\n  DAG Stats"));
+        console.log(`  Total nodes: ${dagStats.total_nodes}`);
+        console.log(`  Completed: ${dagStats.completed_nodes} / Running: ${dagStats.running_nodes} / Reverted: ${dagStats.reverted_nodes}`);
+        console.log(`  Max depth: ${dagStats.max_depth}`);
+        console.log(`  Frontier: ${dagStats.frontier_size} nodes`);
+        console.log(`  Agents: ${dagStats.unique_agents}`);
+      }
+      console.log();
+    } catch (e) {
+      spinner.fail(e.message);
+    }
+  });
+}
+function missionStopCommand() {
+  return new Command55("stop").description("Complete a mission").argument("<mission_id>", "Mission ID").option("--conclusion <text>", "Conclusion summary").action(async (missionId, options) => {
+    const client = getClient();
+    const spinner = ora54("Completing mission...").start();
+    try {
+      await client.mutation(toFunctionName(api.research.completeMission), {
+        mission_id: missionId,
+        conclusion: options.conclusion || "Mission completed via Ralph Loop CLI."
+      });
+      spinner.succeed("Mission completed");
+    } catch (e) {
+      spinner.fail(e.message);
+    }
+  });
+}
+function missionAgentsCommand() {
+  return new Command55("agents").description("Show best-fit agents for a mission (uses agent dispatch scoring)").argument("<mission_id>", "Mission ID").option("--limit <n>", "Max agents", "10").option("--json", "Output as JSON").action(async (missionId, options) => {
+    const client = getClient();
+    const spinner = ora54("Scoring agents for mission...").start();
+    try {
+      const [candidates, available] = await Promise.all([
+        client.query(toFunctionName(api.agentDispatch.pickBestAgent), {
+          mission_id: missionId
+        }).catch(() => null),
+        client.query(toFunctionName(api.agentDispatch.listAvailableAgents), {
+          limit: parseInt(options.limit)
+        })
+      ]);
+      spinner.stop();
+      if (options.json) {
+        console.log(JSON.stringify({ candidates, available }, null, 2));
+        return;
+      }
+      if (candidates && candidates.length > 0) {
+        console.log(chalk58.bold("\n  Best-fit agents for this mission\n"));
+        for (let i = 0; i < candidates.length; i++) {
+          const c = candidates[i];
+          const score = ((c.score ?? 0) * 100).toFixed(0);
+          console.log(
+            `  ${chalk58.dim(`${(i + 1).toString().padStart(2)}.`)} ${chalk58.bold(c.agent_id || c.username || "unknown")} ${chalk58.green(`${score}%`)} match ${chalk58.dim(`rep: ${((c.reputation ?? 0) * 100).toFixed(0)}%`)}`
+          );
+        }
+        console.log();
+      }
+      const agents = available;
+      if (agents && agents.length > 0) {
+        console.log(chalk58.bold(`  Available agents (${agents.length})
+`));
+        for (const a of agents) {
+          const rep = ((a.reputation ?? 0) * 100).toFixed(0);
+          const load = a.running_tasks ?? 0;
+          console.log(
+            `  ${chalk58.white((a.agent_id || a.username || "\u2014").padEnd(24))} rep: ${chalk58.green(`${rep}%`.padEnd(6))} load: ${load === 0 ? chalk58.green("idle") : chalk58.yellow(`${load} tasks`)} ${chalk58.dim(a.platform || "")}`
+          );
+        }
+        console.log();
+      } else {
+        console.log(chalk58.dim("\n  No available agents found.\n"));
+      }
+    } catch (e) {
+      spinner.fail(e.message);
+    }
+  });
+}
+function sleep2(ms) {
+  return new Promise((resolve12) => setTimeout(resolve12, ms));
+}
+function progressBar3(pct, width) {
+  const filled = Math.round(pct / 100 * width);
+  const empty = width - filled;
+  return chalk58.green("\u2588".repeat(filled)) + chalk58.dim("\u2591".repeat(empty));
+}
+
+// src/commands/meta.ts
+import { Command as Command56 } from "commander";
+import chalk59 from "chalk";
+import ora55 from "ora";
+import * as fs26 from "fs";
+import * as path26 from "path";
+import { parse as parseYaml10 } from "yaml";
+function getMetaSkillsDir() {
+  const thisDir = path26.dirname(new URL(import.meta.url).pathname);
+  const pkgRoot = path26.resolve(thisDir, "..", "..");
+  return path26.join(pkgRoot, "meta-skills");
+}
+function getProjectSkillsDir() {
+  return path26.join(process.cwd(), ".hubify", "skills");
+}
+function parseFrontmatter3(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  try {
+    return parseYaml10(match[1]);
+  } catch {
+    return {};
+  }
+}
+function loadMetaSkills() {
+  const metaDir = getMetaSkillsDir();
+  if (!fs26.existsSync(metaDir)) {
+    return [];
+  }
+  const skills = [];
+  const entries = fs26.readdirSync(metaDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const skillMdPath = path26.join(metaDir, entry.name, "SKILL.md");
+    if (!fs26.existsSync(skillMdPath)) continue;
+    const content = fs26.readFileSync(skillMdPath, "utf-8");
+    const fm = parseFrontmatter3(content);
+    skills.push({
+      name: fm.name || `hubify/${entry.name}`,
+      dir: entry.name,
+      version: typeof fm.version === "string" ? fm.version : String(fm.version || "1.0.0"),
+      description: fm.description || "",
+      category: fm.category || "meta",
+      triggers: Array.isArray(fm.triggers) ? fm.triggers : [],
+      outputs: Array.isArray(fm.outputs) ? fm.outputs : []
+    });
+  }
+  return skills;
+}
+function metaListCommand() {
+  return new Command56("list").description("List available meta-skills").option("--json", "Output as JSON").action(async (options) => {
+    const skills = loadMetaSkills();
+    if (skills.length === 0) {
+      console.log(chalk59.dim("\n  No meta-skills found.\n"));
+      return;
+    }
+    if (options.json) {
+      console.log(JSON.stringify(skills, null, 2));
+      return;
+    }
+    console.log(chalk59.bold("\n  Hubify Meta-Skills\n"));
+    console.log(chalk59.gray("  System skills that help agents interact with the Hubify platform.\n"));
+    for (const skill of skills) {
+      console.log(
+        `  ${chalk59.cyan(skill.name.padEnd(26))} ${chalk59.white(`v${skill.version}`)}  ${chalk59.gray(skill.description)}`
+      );
+      if (skill.triggers.length > 0) {
+        console.log(
+          `  ${" ".repeat(26)} ${chalk59.dim("triggers:")} ${chalk59.dim(skill.triggers.slice(0, 3).join(", "))}`
+        );
+      }
+      console.log();
+    }
+    const projectDir = getProjectSkillsDir();
+    if (fs26.existsSync(projectDir)) {
+      const installed = skills.filter(
+        (s) => fs26.existsSync(path26.join(projectDir, s.dir, "SKILL.md"))
+      );
+      if (installed.length > 0) {
+        console.log(
+          chalk59.green(`  ${installed.length}/${skills.length} installed in this project`)
+        );
+      } else {
+        console.log(chalk59.dim("  None installed in this project."));
+        console.log(chalk59.dim("  Run: hubify meta install"));
+      }
+    } else {
+      console.log(chalk59.dim("  Not a Hubify project. Run: hubify init"));
+    }
+    console.log();
+  });
+}
+function metaInstallCommand() {
+  return new Command56("install").description("Install meta-skills into the current project").argument("[name]", "Specific meta-skill to install (e.g., find-skills). Installs all if omitted.").option("--force", "Overwrite existing meta-skills").action(async (name, options) => {
+    const spinner = ora55();
+    const skills = loadMetaSkills();
+    if (skills.length === 0) {
+      console.log(chalk59.red("\n  No meta-skills found in package.\n"));
+      process.exit(1);
+    }
+    const toInstall = name ? skills.filter((s) => s.dir === name || s.name === name || s.name === `hubify/${name}`) : skills;
+    if (toInstall.length === 0) {
+      console.log(chalk59.red(`
+  Meta-skill "${name}" not found.`));
+      console.log(chalk59.gray("  Available: " + skills.map((s) => s.dir).join(", ")));
+      console.log();
+      process.exit(1);
+    }
+    const projectDir = getProjectSkillsDir();
+    const metaDir = getMetaSkillsDir();
+    if (!fs26.existsSync(projectDir)) {
+      fs26.mkdirSync(projectDir, { recursive: true });
+    }
+    spinner.start(`Installing ${toInstall.length} meta-skill(s)...`);
+    let installed = 0;
+    let skipped = 0;
+    for (const skill of toInstall) {
+      const srcDir = path26.join(metaDir, skill.dir);
+      const destDir = path26.join(projectDir, skill.dir);
+      if (fs26.existsSync(destDir) && !options.force) {
+        skipped++;
+        continue;
+      }
+      fs26.mkdirSync(destDir, { recursive: true });
+      const srcFile = path26.join(srcDir, "SKILL.md");
+      const destFile = path26.join(destDir, "SKILL.md");
+      fs26.copyFileSync(srcFile, destFile);
+      installed++;
+    }
+    if (installed > 0 && skipped > 0) {
+      spinner.succeed(
+        `Installed ${installed} meta-skill(s), skipped ${skipped} (already installed)`
+      );
+    } else if (installed > 0) {
+      spinner.succeed(`Installed ${installed} meta-skill(s)`);
+    } else {
+      spinner.info(`All ${skipped} meta-skill(s) already installed (use --force to overwrite)`);
+    }
+    console.log(chalk59.gray(`
+  Location: ${projectDir}`));
+    if (installed > 0) {
+      console.log(chalk59.gray("  Installed:"));
+      for (const skill of toInstall) {
+        const destDir = path26.join(projectDir, skill.dir);
+        if (fs26.existsSync(path26.join(destDir, "SKILL.md"))) {
+          console.log(`    ${chalk59.cyan(skill.name)}`);
+        }
+      }
+    }
+    console.log();
+  });
+}
+function metaRunCommand() {
+  return new Command56("run").description("Execute a meta-skill").argument("<name>", "Meta-skill name (e.g., find-skills, create-skill)").argument("[args...]", "Arguments to pass to the meta-skill").option("--json", "Output as JSON").action(async (name, args, options) => {
+    const spinner = ora55();
+    const skills = loadMetaSkills();
+    const skill = skills.find(
+      (s) => s.dir === name || s.name === name || s.name === `hubify/${name}`
+    );
+    if (!skill) {
+      console.log(chalk59.red(`
+  Meta-skill "${name}" not found.`));
+      console.log(chalk59.gray("  Available: " + skills.map((s) => s.dir).join(", ")));
+      console.log();
+      process.exit(1);
+    }
+    const query = args.join(" ");
+    switch (skill.dir) {
+      case "find-skills":
+        await runFindSkills(query, options, spinner);
+        break;
+      case "create-skill":
+        await runCreateSkill(query, options, spinner);
+        break;
+      case "update-skills":
+        await runUpdateSkills(query, options, spinner);
+        break;
+      case "chain-skills":
+        await runChainSkills(query, options, spinner);
+        break;
+      default:
+        console.log(chalk59.yellow(`
+  Meta-skill "${skill.name}" does not have a run handler yet.`));
+        console.log(chalk59.gray("  You can read its instructions:"));
+        console.log(chalk59.cyan(`    cat ${path26.join(getMetaSkillsDir(), skill.dir, "SKILL.md")}`));
+        console.log();
+    }
+  });
+}
+async function runFindSkills(query, options, spinner) {
+  if (!query) {
+    console.log(chalk59.red("\n  Usage: hubify meta run find-skills <search query>"));
+    console.log(chalk59.gray("  Example: hubify meta run find-skills web scraping\n"));
+    process.exit(1);
+  }
+  spinner.start(`Searching registry for "${query}"...`);
+  try {
+    const client = getClient();
+    const results = await client.query(toFunctionName(api.skills.search), {
+      query,
+      limit: 10
+    });
+    spinner.stop();
+    const skills = results;
+    if (options.json) {
+      console.log(JSON.stringify(skills, null, 2));
+      return;
+    }
+    if (!skills || skills.length === 0) {
+      console.log(chalk59.dim(`
+  No skills found for "${query}".`));
+      console.log(chalk59.dim("  Try broader search terms or different keywords.\n"));
+      return;
+    }
+    console.log(chalk59.bold(`
+  Results for "${query}" (${skills.length} found)
+`));
+    for (let i = 0; i < skills.length; i++) {
+      const s = skills[i];
+      const confidence = typeof s.confidence === "number" ? s.confidence.toFixed(2) : "0.00";
+      const executions = s.executions || 0;
+      const verified = s.verification_level ? `L${s.verification_level}` : "L0";
+      console.log(
+        `  ${chalk59.dim(`${i + 1}.`)} ${chalk59.bold(s.name)}`
+      );
+      console.log(
+        `     ${chalk59.dim("Confidence:")} ${chalk59.white(confidence)} ${chalk59.dim("|")} ${chalk59.dim("Verified:")} ${chalk59.white(verified)} ${chalk59.dim("|")} ${chalk59.dim("Executions:")} ${chalk59.white(String(executions))}`
+      );
+      if (s.description) {
+        console.log(`     ${chalk59.gray(s.description)}`);
+      }
+      console.log();
+    }
+    console.log(chalk59.dim("  Install a skill: hubify install <skill-name>"));
+    console.log(chalk59.dim("  More details:    hubify info <skill-name>\n"));
+  } catch (error) {
+    spinner.fail("Search failed");
+    console.error(chalk59.red(`  ${error.message}
+`));
+  }
+}
+async function runCreateSkill(description, options, spinner) {
+  if (!description) {
+    console.log(chalk59.red("\n  Usage: hubify meta run create-skill <description>"));
+    console.log(chalk59.gray('  Example: hubify meta run create-skill "skill for parsing CSV files"\n'));
+    process.exit(1);
+  }
+  console.log(chalk59.bold("\n  Create Skill\n"));
+  console.log(chalk59.gray("  Delegating to the skill generator...\n"));
+  console.log(chalk59.white("  Run this command directly:"));
+  console.log(chalk59.cyan(`    hubify generate "${description}"
+`));
+  console.log(chalk59.gray("  Options:"));
+  console.log(chalk59.gray("    --category <cat>    Skill category"));
+  console.log(chalk59.gray("    --name <name>       Override auto-generated name"));
+  console.log(chalk59.gray("    --publish           Auto-publish after generation"));
+  console.log(chalk59.gray("    --template          Use template-based generation (no AI)"));
+  console.log(chalk59.gray("    --dry-run           Preview without saving"));
+  try {
+    spinner.start("Queuing generation in registry...");
+    const client = getClient();
+    const result = await client.mutation(
+      toFunctionName(api.skillGeneration.queueGeneration),
+      {
+        prompt: description,
+        requested_by: process.env.USER || "cli",
+        category: "coding"
+      }
+    );
+    spinner.succeed("Generation queued in registry");
+    const r = result;
+    if (r && r._id) {
+      console.log(chalk59.gray(`
+  Generation ID: ${r._id}`));
+      console.log(chalk59.gray("  Check status: hubify skill-gen list\n"));
+    }
+  } catch {
+    spinner.info("Remote generation not available. Use hubify generate locally.");
+    console.log();
+  }
+}
+async function runUpdateSkills(skillName, options, spinner) {
+  const projectDir = getProjectSkillsDir();
+  if (!fs26.existsSync(projectDir)) {
+    console.log(chalk59.red("\n  No .hubify/skills directory found."));
+    console.log(chalk59.gray("  Run: hubify init\n"));
+    process.exit(1);
+  }
+  spinner.start("Scanning installed skills...");
+  const entries = fs26.readdirSync(projectDir, { withFileTypes: true });
+  const installed = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const skillMdPath = path26.join(projectDir, entry.name, "SKILL.md");
+    if (!fs26.existsSync(skillMdPath)) continue;
+    const content = fs26.readFileSync(skillMdPath, "utf-8");
+    const fm = parseFrontmatter3(content);
+    const name = fm.name || entry.name;
+    const version = typeof fm.version === "string" ? fm.version : String(fm.version || "0.0.0");
+    if (skillName && name !== skillName && entry.name !== skillName) continue;
+    installed.push({ name, localVersion: version, dir: entry.name });
+  }
+  if (installed.length === 0) {
+    spinner.info(skillName ? `Skill "${skillName}" not found locally.` : "No installed skills found.");
+    console.log();
+    return;
+  }
+  spinner.text = `Checking updates for ${installed.length} skill(s)...`;
+  const client = getClient();
+  const updates = [];
+  const upToDate = [];
+  const notInRegistry = [];
+  for (const skill of installed) {
+    try {
+      const lookupName = skill.name.replace(/^hubify\//, "");
+      const remote = await client.query(toFunctionName(api.skills.getByName), {
+        name: lookupName
+      });
+      if (!remote) {
+        notInRegistry.push(skill.name);
+        continue;
+      }
+      const r = remote;
+      const remoteVersion = r.version || "0.0.0";
+      const confidence = r.confidence || 0;
+      if (remoteVersion !== skill.localVersion) {
+        updates.push({
+          name: skill.name,
+          local: skill.localVersion,
+          remote: remoteVersion,
+          confidence
+        });
+      } else {
+        upToDate.push(skill.name);
+      }
+    } catch {
+      notInRegistry.push(skill.name);
+    }
+  }
+  spinner.stop();
+  if (options.json) {
+    console.log(JSON.stringify({ updates, upToDate, notInRegistry }, null, 2));
+    return;
+  }
+  console.log(chalk59.bold(`
+  Skill Update Check (${installed.length} installed)
+`));
+  if (updates.length > 0) {
+    console.log(chalk59.yellow(`  Updates available (${updates.length}):
+`));
+    for (const u of updates) {
+      console.log(`    ${chalk59.bold(u.name)}`);
+      console.log(
+        `      ${chalk59.dim("Local:")} ${u.local} ${chalk59.dim("->")} ${chalk59.green(u.remote)}  ${chalk59.dim("Confidence:")} ${u.confidence.toFixed(2)}`
+      );
+    }
+    console.log();
+    console.log(chalk59.dim("  Update a skill: hubify install <skill-name>"));
+  } else {
+    console.log(chalk59.green("  All skills are up to date."));
+  }
+  if (upToDate.length > 0) {
+    console.log(chalk59.dim(`
+  Up to date (${upToDate.length}): ${upToDate.join(", ")}`));
+  }
+  if (notInRegistry.length > 0) {
+    console.log(chalk59.dim(`
+  Not in registry (${notInRegistry.length}): ${notInRegistry.join(", ")}`));
+  }
+  console.log();
+}
+async function runChainSkills(skillList, options, spinner) {
+  if (!skillList) {
+    console.log(chalk59.red("\n  Usage: hubify meta run chain-skills <skill1,skill2,skill3>"));
+    console.log(chalk59.gray("  Example: hubify meta run chain-skills web-research,data-analysis,email-draft\n"));
+    process.exit(1);
+  }
+  const skillNames = skillList.split(",").map((s) => s.trim()).filter(Boolean);
+  if (skillNames.length < 2) {
+    console.log(chalk59.red("\n  A chain requires at least 2 skills."));
+    console.log(chalk59.gray("  Separate skill names with commas.\n"));
+    process.exit(1);
+  }
+  spinner.start(`Validating ${skillNames.length} skills...`);
+  const client = getClient();
+  const validSkills = [];
+  const missing = [];
+  for (const name of skillNames) {
+    try {
+      const result = await client.query(toFunctionName(api.skills.getByName), { name });
+      if (result) {
+        const r = result;
+        validSkills.push({
+          name: r.name,
+          description: r.description || "",
+          confidence: r.confidence || 0
+        });
+      } else {
+        missing.push(name);
+      }
+    } catch {
+      missing.push(name);
+    }
+  }
+  spinner.stop();
+  if (missing.length > 0) {
+    console.log(chalk59.yellow(`
+  Warning: ${missing.length} skill(s) not found in registry:`));
+    for (const m of missing) {
+      console.log(chalk59.dim(`    - ${m}`));
+    }
+    console.log(chalk59.dim("  These steps will still be included in the chain definition.\n"));
+  }
+  const chainName = skillNames.slice(0, 3).join("-then-");
+  const steps = skillNames.map((name, i) => ({
+    id: `step_${i + 1}`,
+    skill_name: name,
+    depends_on: i === 0 ? [] : [`step_${i}`],
+    on_fail: i === skillNames.length - 1 ? "abort" : "retry"
+  }));
+  const chainDef = {
+    name: chainName,
+    description: `Chain: ${skillNames.join(" -> ")}`,
+    steps
+  };
+  if (options.json) {
+    console.log(JSON.stringify(chainDef, null, 2));
+    return;
+  }
+  console.log(chalk59.bold(`
+  Skill Chain: ${chainName}
+`));
+  console.log(chalk59.gray(`  Flow: ${skillNames.join(chalk59.dim(" -> "))}
+`));
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    const valid = validSkills.find((s) => s.name === step.skill_name);
+    const statusIcon = valid ? chalk59.green("[OK]") : chalk59.yellow("[??]");
+    const conf = valid ? chalk59.dim(`(${valid.confidence.toFixed(2)})`) : "";
+    console.log(
+      `  ${chalk59.dim(`${i + 1}.`)} ${statusIcon} ${chalk59.bold(step.skill_name)} ${conf}`
+    );
+    if (valid?.description) {
+      console.log(`     ${chalk59.gray(valid.description)}`);
+    }
+    console.log(
+      `     ${chalk59.dim("on_fail:")} ${step.on_fail} ${chalk59.dim("| depends:")} ${step.depends_on.length === 0 ? "none" : step.depends_on.join(", ")}`
+    );
+  }
+  console.log(chalk59.gray("\n  To create this workflow:"));
+  console.log(chalk59.cyan(`    hubify workflow create --name "${chainName}" --steps '${JSON.stringify(steps)}'`));
+  console.log(chalk59.gray("\n  To run an existing workflow:"));
+  console.log(chalk59.cyan(`    hubify workflow run ${chainName}
+`));
+}
+var metaCommand = new Command56("meta").description("Meta-skills \u2014 system skills for interacting with the Hubify platform").addCommand(metaListCommand()).addCommand(metaInstallCommand()).addCommand(metaRunCommand());
+
+// src/commands/self-update.ts
+import { Command as Command57 } from "commander";
+import chalk60 from "chalk";
+import ora56 from "ora";
+import { execSync as execSync2 } from "child_process";
+import fs27 from "fs";
+function getCliVersion() {
+  try {
+    const pkgUrl = new URL("../../package.json", import.meta.url);
+    const pkg = JSON.parse(fs27.readFileSync(pkgUrl, "utf8"));
+    return pkg.version || "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function getLatestNpmVersion(packageName) {
+  try {
+    const output = execSync2(`npm view ${packageName} version`, {
+      encoding: "utf-8",
+      timeout: 15e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return output.trim();
+  } catch {
+    return null;
+  }
+}
+function isNewerVersion(current, latest) {
+  const c = current.split(".").map(Number);
+  const l = latest.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((l[i] ?? 0) > (c[i] ?? 0)) return true;
+    if ((l[i] ?? 0) < (c[i] ?? 0)) return false;
+  }
+  return false;
+}
+var selfUpdateCommand = new Command57("self-update").description("Check for and install CLI updates").option("--check", "Only check for updates, do not install").option("--force", "Force reinstall even if already up to date").action(async (options) => {
+  const currentVersion = getCliVersion();
+  console.log();
+  console.log(
+    chalk60.cyan.bold("  Hubify Self-Update")
+  );
+  console.log(
+    chalk60.gray(`  Current version: ${currentVersion}`)
+  );
+  console.log();
+  const spinner = ora56("Checking for updates...").start();
+  const latestVersion = getLatestNpmVersion("hubify");
+  if (!latestVersion) {
+    spinner.fail("Could not reach npm registry.");
+    console.log(
+      chalk60.gray(
+        "\n  Check your internet connection and try again.\n"
+      )
+    );
+    return;
+  }
+  spinner.stop();
+  const hasUpdate = isNewerVersion(currentVersion, latestVersion);
+  if (!hasUpdate && !options.force) {
+    console.log(
+      chalk60.green(`  Already up to date (v${currentVersion}).`)
+    );
+    console.log();
+    return;
+  }
+  if (hasUpdate) {
+    console.log(
+      chalk60.white(
+        `  Update available: ${chalk60.gray(currentVersion)} -> ${chalk60.green(latestVersion)}`
+      )
+    );
+    console.log();
+  } else if (options.force) {
+    console.log(
+      chalk60.yellow(`  Forcing reinstall of v${latestVersion}...`)
+    );
+    console.log();
+  }
+  if (options.check) {
+    if (hasUpdate) {
+      console.log(
+        chalk60.gray(
+          "  Run " + chalk60.cyan("hubify self-update") + " to install the update."
+        )
+      );
+    }
+    console.log();
+    return;
+  }
+  const updateSpinner = ora56(
+    `Installing hubify@${latestVersion}...`
+  ).start();
+  try {
+    execSync2(`npm install -g hubify@${latestVersion}`, {
+      encoding: "utf-8",
+      timeout: 12e4,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    updateSpinner.succeed(
+      `Updated to hubify@${latestVersion}`
+    );
+    console.log();
+    console.log(
+      chalk60.green("  Update complete!") + chalk60.gray(
+        " Run " + chalk60.cyan("hubify --version") + " to confirm."
+      )
+    );
+    console.log();
+  } catch (err) {
+    updateSpinner.fail("Update failed.");
+    console.log();
+    const errMsg = err instanceof Error ? err.message : String(err);
+    if (errMsg.includes("EACCES") || errMsg.includes("permission")) {
+      console.log(
+        chalk60.yellow(
+          "  Permission denied. Try running with sudo:"
+        )
+      );
+      console.log(
+        chalk60.cyan(
+          `    sudo npm install -g hubify@${latestVersion}`
+        )
+      );
+    } else {
+      console.log(chalk60.red(`  ${errMsg}`));
+    }
+    console.log();
+  }
+});
+
+// src/index.ts
+function getCliVersion2() {
+  try {
+    const pkgUrl = new URL("../package.json", import.meta.url);
+    const pkg = JSON.parse(fs28.readFileSync(pkgUrl, "utf8"));
+    return pkg.version || "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+var VERSION = getCliVersion2();
+var BANNER = `
+${chalk61.cyan("    __  __      __    _ ____     ")}
+${chalk61.cyan("   / / / /_  __/ /_  (_) __/_  __")}
+${chalk61.cyan("  / /_/ / / / / __ \\/ / /_/ / / /")}
+${chalk61.cyan(" / __  / /_/ / /_/ / / __/ /_/ / ")}
+${chalk61.cyan("/_/ /_/\\__,_/_.___/_/_/  \\__, /  ")}
+${chalk61.cyan("                        /____/   ")}
 `;
-var TAGLINE = chalk56.gray("  The living intelligence layer for Agent Skills");
+var TAGLINE = chalk61.gray("  The living intelligence layer for Agent Skills");
 function showWelcome() {
   console.log(BANNER);
   console.log(TAGLINE);
   console.log();
-  console.log(chalk56.white.bold("  Welcome to Hubify!"));
+  console.log(chalk61.white.bold("  Welcome to Hubify!"));
   console.log();
-  console.log(chalk56.gray("  Hubify is the universal skill registry for AI coding agents."));
-  console.log(chalk56.gray("  Discover, install, and share agent skills with trust metrics."));
+  console.log(chalk61.gray("  Hubify is the universal skill registry for AI coding agents."));
+  console.log(chalk61.gray("  Discover, install, and share agent skills with trust metrics."));
   console.log();
-  console.log(chalk56.cyan.bold("  Quick Start"));
-  console.log(chalk56.gray("  -----------"));
+  console.log(chalk61.cyan.bold("  Quick Start"));
+  console.log(chalk61.gray("  -----------"));
   console.log();
-  console.log(chalk56.white("  1. Initialize Hubify in your project:"));
-  console.log(chalk56.cyan("     $ hubify init"));
+  console.log(chalk61.white("  1. Initialize Hubify in your project:"));
+  console.log(chalk61.cyan("     $ hubify init"));
   console.log();
-  console.log(chalk56.white("  2. Search for skills:"));
-  console.log(chalk56.cyan('     $ hubify search "react best practices"'));
+  console.log(chalk61.white("  2. Search for skills:"));
+  console.log(chalk61.cyan('     $ hubify search "react best practices"'));
   console.log();
-  console.log(chalk56.white("  3. Install a skill:"));
-  console.log(chalk56.cyan("     $ hubify install vercel-react-best-practices"));
+  console.log(chalk61.white("  3. Install a skill:"));
+  console.log(chalk61.cyan("     $ hubify install vercel-react-best-practices"));
   console.log();
-  console.log(chalk56.white("  4. Report your execution results:"));
-  console.log(chalk56.cyan("     $ hubify report vercel-react-best-practices --success"));
+  console.log(chalk61.white("  4. Report your execution results:"));
+  console.log(chalk61.cyan("     $ hubify report vercel-react-best-practices --success"));
   console.log();
-  console.log(chalk56.cyan.bold("  Common Commands"));
-  console.log(chalk56.gray("  ---------------"));
+  console.log(chalk61.cyan.bold("  Common Commands"));
+  console.log(chalk61.gray("  ---------------"));
   console.log();
-  console.log(chalk56.white("  hubify search <query>      ") + chalk56.gray("Search for skills"));
-  console.log(chalk56.white("  hubify install <skill>     ") + chalk56.gray("Install a skill locally"));
-  console.log(chalk56.white("  hubify info <skill>        ") + chalk56.gray("View skill details"));
-  console.log(chalk56.white("  hubify list                ") + chalk56.gray("List installed skills"));
-  console.log(chalk56.white("  hubify publish <path>      ") + chalk56.gray("Publish your skill"));
-  console.log(chalk56.white("  hubify stats               ") + chalk56.gray("View registry statistics"));
+  console.log(chalk61.white("  hubify search <query>      ") + chalk61.gray("Search for skills"));
+  console.log(chalk61.white("  hubify install <skill>     ") + chalk61.gray("Install a skill locally"));
+  console.log(chalk61.white("  hubify info <skill>        ") + chalk61.gray("View skill details"));
+  console.log(chalk61.white("  hubify list                ") + chalk61.gray("List installed skills"));
+  console.log(chalk61.white("  hubify publish <path>      ") + chalk61.gray("Publish your skill"));
+  console.log(chalk61.white("  hubify stats               ") + chalk61.gray("View registry statistics"));
   console.log();
-  console.log(chalk56.gray("  Run ") + chalk56.cyan("hubify --help") + chalk56.gray(" for all commands."));
-  console.log(chalk56.gray("  Run ") + chalk56.cyan("hubify <command> --help") + chalk56.gray(" for command details."));
+  console.log(chalk61.gray("  Run ") + chalk61.cyan("hubify --help") + chalk61.gray(" for all commands."));
+  console.log(chalk61.gray("  Run ") + chalk61.cyan("hubify <command> --help") + chalk61.gray(" for command details."));
   console.log();
-  console.log(chalk56.gray("  ") + chalk56.dim(`v${VERSION}`) + chalk56.gray(" | ") + chalk56.dim(REGISTRY_URL));
+  console.log(chalk61.gray("  ") + chalk61.dim(`v${VERSION}`) + chalk61.gray(" | ") + chalk61.dim(REGISTRY_URL));
   console.log();
 }
 function formatGroupedHelp() {
@@ -28810,10 +31071,10 @@ function formatGroupedHelp() {
   sections.push(BANNER);
   sections.push(TAGLINE);
   sections.push("");
-  sections.push(chalk56.white.bold("Usage:") + chalk56.gray(" hubify [command] [options]"));
+  sections.push(chalk61.white.bold("Usage:") + chalk61.gray(" hubify [command] [options]"));
   sections.push("");
-  sections.push(chalk56.cyan.bold("Souls"));
-  sections.push(chalk56.gray("  AI personality and behavior templates"));
+  sections.push(chalk61.cyan.bold("Souls"));
+  sections.push(chalk61.gray("  AI personality and behavior templates"));
   sections.push("");
   sections.push(formatCommand("soul list", "List all available souls"));
   sections.push(formatCommand("soul info <name>", "View detailed information about a soul"));
@@ -28822,8 +31083,8 @@ function formatGroupedHelp() {
   sections.push(formatCommand("soul publish <path>", "Publish a soul to the registry"));
   sections.push(formatCommand("soul search <query>", "Search for souls by description"));
   sections.push("");
-  sections.push(chalk56.cyan.bold("Tools"));
-  sections.push(chalk56.gray("  Standardized tool definitions and integrations"));
+  sections.push(chalk61.cyan.bold("Tools"));
+  sections.push(chalk61.gray("  Standardized tool definitions and integrations"));
   sections.push("");
   sections.push(formatCommand("tool list", "List all tools in the registry"));
   sections.push(formatCommand("tool info <name>", "View detailed information about a tool"));
@@ -28831,8 +31092,8 @@ function formatGroupedHelp() {
   sections.push(formatCommand("tool search <query>", "Search for tools by description"));
   sections.push(formatCommand("tool stats", "Show tool registry statistics"));
   sections.push("");
-  sections.push(chalk56.cyan.bold("Skills"));
-  sections.push(chalk56.gray("  Discovery and management of agent skills"));
+  sections.push(chalk61.cyan.bold("Skills"));
+  sections.push(chalk61.gray("  Discovery and management of agent skills"));
   sections.push("");
   sections.push(formatCommand("search <query>", "Search for skills by name, description, or tags"));
   sections.push(formatCommand("info <skill>", "View detailed information about a skill"));
@@ -28841,8 +31102,8 @@ function formatGroupedHelp() {
   sections.push(formatCommand("list", "List installed skills in project or globally"));
   sections.push(formatCommand("update [skill]", "Update installed skills to latest versions"));
   sections.push("");
-  sections.push(chalk56.cyan.bold("Publishing"));
-  sections.push(chalk56.gray("  Create and share your own skills"));
+  sections.push(chalk61.cyan.bold("Publishing"));
+  sections.push(chalk61.gray("  Create and share your own skills"));
   sections.push("");
   sections.push(formatCommand("init", "Initialize Hubify in your project"));
   sections.push(formatCommand("publish <path>", "Publish a skill to the registry"));
@@ -28850,31 +31111,31 @@ function formatGroupedHelp() {
   sections.push(formatCommand("evolve <skill>", "Evolve a skill based on feedback"));
   sections.push(formatCommand("import <url>", "Import a skill from external source"));
   sections.push("");
-  sections.push(chalk56.cyan.bold(".hub Manifests"));
-  sections.push(chalk56.gray("  Manage skill/agent manifest files"));
+  sections.push(chalk61.cyan.bold(".hub Manifests"));
+  sections.push(chalk61.gray("  Manage skill/agent manifest files"));
   sections.push("");
   sections.push(formatCommand("hub init [dir]", "Create a .hub manifest file"));
   sections.push(formatCommand("hub validate <file>", "Validate a .hub file against schema"));
   sections.push(formatCommand("hub update <file>", "Update hashes and timestamps"));
   sections.push(formatCommand("hub info <file>", "Display .hub file information"));
   sections.push("");
-  sections.push(chalk56.cyan.bold("Analytics"));
-  sections.push(chalk56.gray("  Track and report skill executions"));
+  sections.push(chalk61.cyan.bold("Analytics"));
+  sections.push(chalk61.gray("  Track and report skill executions"));
   sections.push("");
   sections.push(formatCommand("report <skill>", "Report skill execution results"));
   sections.push(formatCommand("report stats [skill]", "View execution statistics"));
   sections.push(formatCommand("report leaderboard", "Show top skills by executions"));
   sections.push(formatCommand("stats", "View registry-wide statistics"));
   sections.push("");
-  sections.push(chalk56.cyan.bold("Authentication"));
-  sections.push(chalk56.gray("  Manage CLI authentication and API tokens"));
+  sections.push(chalk61.cyan.bold("Authentication"));
+  sections.push(chalk61.gray("  Manage CLI authentication and API tokens"));
   sections.push("");
   sections.push(formatCommand("auth login --token <t>", "Authenticate with an API token"));
   sections.push(formatCommand("auth whoami", "Show current identity and token status"));
   sections.push(formatCommand("auth logout", "Remove stored credentials"));
   sections.push("");
-  sections.push(chalk56.cyan.bold("Learning & Evolution"));
-  sections.push(chalk56.gray("  Skill intelligence, evolution tracking, and canary management"));
+  sections.push(chalk61.cyan.bold("Learning & Evolution"));
+  sections.push(chalk61.gray("  Skill intelligence, evolution tracking, and canary management"));
   sections.push("");
   sections.push(formatCommand("learn stats <skill>", "Get learning statistics for a skill"));
   sections.push(formatCommand("learn lineage <skill>", "Show full evolution tree"));
@@ -28883,8 +31144,8 @@ function formatGroupedHelp() {
   sections.push(formatCommand("learn triggers <skill>", "Detect evolution triggers"));
   sections.push(formatCommand("learn status <skill>", "Evolution status overview"));
   sections.push("");
-  sections.push(chalk56.cyan.bold("Labs"));
-  sections.push(chalk56.gray("  Experiment swarms, DAGs, and frontier discovery"));
+  sections.push(chalk61.cyan.bold("Labs"));
+  sections.push(chalk61.gray("  Experiment swarms, DAGs, and frontier discovery"));
   sections.push("");
   sections.push(formatCommand("labs status", "Show active experiment missions"));
   sections.push(formatCommand("labs launch <skill>", "Launch an experiment swarm"));
@@ -28893,16 +31154,16 @@ function formatGroupedHelp() {
   sections.push(formatCommand("labs best-path <id>", "Show best path through DAG"));
   sections.push(formatCommand("labs suggest <id>", "AI-suggested next experiments"));
   sections.push("");
-  sections.push(chalk56.cyan.bold("Research"));
-  sections.push(chalk56.gray("  Multi-agent research missions"));
+  sections.push(chalk61.cyan.bold("Research"));
+  sections.push(chalk61.gray("  Multi-agent research missions"));
   sections.push("");
   sections.push(formatCommand("research list", "Browse research missions"));
   sections.push(formatCommand("research propose <hub>", "Propose a new research mission"));
   sections.push(formatCommand("research view <id>", "View mission details"));
   sections.push(formatCommand("research publish <id>", "Publish findings as knowledge"));
   sections.push("");
-  sections.push(chalk56.cyan.bold("Collective Intelligence"));
-  sections.push(chalk56.gray("  Cross-workspace knowledge sharing and discovery"));
+  sections.push(chalk61.cyan.bold("Collective Intelligence"));
+  sections.push(chalk61.gray("  Cross-workspace knowledge sharing and discovery"));
   sections.push("");
   sections.push(formatCommand("collective feed", "Global collective intelligence feed"));
   sections.push(formatCommand("collective share <t> <c>", "Share an insight to the collective"));
@@ -28910,8 +31171,18 @@ function formatGroupedHelp() {
   sections.push(formatCommand("collective search <q>", "Search collective knowledge"));
   sections.push(formatCommand("collective sync", "Pull latest insights into workspace"));
   sections.push("");
-  sections.push(chalk56.cyan.bold("Network"));
-  sections.push(chalk56.gray("  Singularity layer, workspace management, and knowledge"));
+  sections.push(chalk61.cyan.bold("Vault"));
+  sections.push(chalk61.gray("  Manage tool credentials and API keys for workspace agents"));
+  sections.push("");
+  sections.push(formatCommand("vault list <hub>", "List vault entries for a workspace"));
+  sections.push(formatCommand("vault store <hub>", "Store an encrypted credential"));
+  sections.push(formatCommand("vault get <hub>", "Retrieve a credential (agent-scoped)"));
+  sections.push(formatCommand("vault revoke <hub>", "Delete a vault entry"));
+  sections.push(formatCommand("vault grant <hub>", "Update agent access for an entry"));
+  sections.push(formatCommand("vault audit <hub>", "View access log for a service"));
+  sections.push("");
+  sections.push(chalk61.cyan.bold("Network"));
+  sections.push(chalk61.gray("  Singularity layer, workspace management, and knowledge"));
   sections.push("");
   sections.push(formatCommand("network feed", "Global intelligence feed"));
   sections.push(formatCommand("network trending", "Trending skills across network"));
@@ -28920,8 +31191,38 @@ function formatGroupedHelp() {
   sections.push(formatCommand("knowledge search <q>", "Search hub knowledge"));
   sections.push(formatCommand("usage", "View usage breakdown"));
   sections.push("");
-  sections.push(chalk56.cyan.bold("Advanced"));
-  sections.push(chalk56.gray("  Seeding and administration"));
+  sections.push(chalk61.cyan.bold("Reports"));
+  sections.push(chalk61.gray("  Weekly network intelligence reports"));
+  sections.push("");
+  sections.push(formatCommand("reports latest", "View the latest weekly report"));
+  sections.push(formatCommand("reports list", "List available weekly reports"));
+  sections.push(formatCommand("reports view --date <d>", "View report for a specific week"));
+  sections.push("");
+  sections.push(chalk61.cyan.bold("Missions"));
+  sections.push(chalk61.gray("  Autonomous mission runner \u2014 Ralph Loop"));
+  sections.push("");
+  sections.push(formatCommand("mission list", "List active missions"));
+  sections.push(formatCommand("mission create <hub>", "Create a new mission"));
+  sections.push(formatCommand("mission run <id>", "Run autonomous loop until budget exhausted"));
+  sections.push(formatCommand("mission status <id>", "Show mission progress and DAG stats"));
+  sections.push(formatCommand("mission agents <id>", "Best-fit agents for a mission"));
+  sections.push(formatCommand("mission stop <id>", "Complete a mission"));
+  sections.push("");
+  sections.push(chalk61.cyan.bold("Meta-Skills"));
+  sections.push(chalk61.gray("  System skills for interacting with the Hubify platform"));
+  sections.push("");
+  sections.push(formatCommand("meta list", "List available meta-skills"));
+  sections.push(formatCommand("meta install [name]", "Install meta-skills into project"));
+  sections.push(formatCommand("meta run <name> [args]", "Execute a meta-skill"));
+  sections.push("");
+  sections.push(chalk61.cyan.bold("System"));
+  sections.push(chalk61.gray("  Self-update and system maintenance"));
+  sections.push("");
+  sections.push(formatCommand("self-update", "Check for and install CLI updates"));
+  sections.push(formatCommand("self-update --check", "Only check, don't install"));
+  sections.push("");
+  sections.push(chalk61.cyan.bold("Advanced"));
+  sections.push(chalk61.gray("  Seeding and administration"));
   sections.push("");
   sections.push(formatCommand("ingest skills-sh", "Ingest skills from skills.sh canonical registry"));
   sections.push(formatCommand("ingest status", "Check status of ingest operations"));
@@ -28936,48 +31237,48 @@ function formatGroupedHelp() {
   sections.push(formatCommand("seed-souls", "Seed 30 built-in AI souls"));
   sections.push(formatCommand("seed-tools", "Seed 40 core tools"));
   sections.push("");
-  sections.push(chalk56.cyan.bold("Examples"));
+  sections.push(chalk61.cyan.bold("Examples"));
   sections.push("");
-  sections.push(chalk56.gray("  # Search for TypeScript skills"));
-  sections.push(chalk56.white("  $ hubify search typescript --category coding"));
+  sections.push(chalk61.gray("  # Search for TypeScript skills"));
+  sections.push(chalk61.white("  $ hubify search typescript --category coding"));
   sections.push("");
-  sections.push(chalk56.gray("  # Install a skill with minimum confidence"));
-  sections.push(chalk56.white("  $ hubify install react-hooks --min-confidence 0.8"));
+  sections.push(chalk61.gray("  # Install a skill with minimum confidence"));
+  sections.push(chalk61.white("  $ hubify install react-hooks --min-confidence 0.8"));
   sections.push("");
-  sections.push(chalk56.gray("  # Report a successful execution"));
-  sections.push(chalk56.white("  $ hubify report my-skill --success --duration 1500"));
+  sections.push(chalk61.gray("  # Report a successful execution"));
+  sections.push(chalk61.white("  $ hubify report my-skill --success --duration 1500"));
   sections.push("");
-  sections.push(chalk56.gray("  # Publish a skill with dry-run"));
-  sections.push(chalk56.white("  $ hubify publish ./my-skill --dry-run"));
+  sections.push(chalk61.gray("  # Publish a skill with dry-run"));
+  sections.push(chalk61.white("  $ hubify publish ./my-skill --dry-run"));
   sections.push("");
-  sections.push(chalk56.cyan.bold("Shell Completions"));
+  sections.push(chalk61.cyan.bold("Shell Completions"));
   sections.push("");
-  sections.push(chalk56.gray("  Enable tab completion for hubify commands:"));
+  sections.push(chalk61.gray("  Enable tab completion for hubify commands:"));
   sections.push("");
-  sections.push(chalk56.gray("  # Bash"));
-  sections.push(chalk56.white("  $ hubify completion bash >> ~/.bashrc"));
+  sections.push(chalk61.gray("  # Bash"));
+  sections.push(chalk61.white("  $ hubify completion bash >> ~/.bashrc"));
   sections.push("");
-  sections.push(chalk56.gray("  # Zsh"));
-  sections.push(chalk56.white("  $ hubify completion zsh >> ~/.zshrc"));
+  sections.push(chalk61.gray("  # Zsh"));
+  sections.push(chalk61.white("  $ hubify completion zsh >> ~/.zshrc"));
   sections.push("");
-  sections.push(chalk56.gray("  # Fish"));
-  sections.push(chalk56.white("  $ hubify completion fish > ~/.config/fish/completions/hubify.fish"));
+  sections.push(chalk61.gray("  # Fish"));
+  sections.push(chalk61.white("  $ hubify completion fish > ~/.config/fish/completions/hubify.fish"));
   sections.push("");
-  sections.push(chalk56.gray("Version: ") + chalk56.white(VERSION));
-  sections.push(chalk56.gray("Documentation: ") + chalk56.cyan("https://hubify.com/docs"));
-  sections.push(chalk56.gray("Report issues: ") + chalk56.cyan("https://github.com/houstongolden/hubify/issues"));
+  sections.push(chalk61.gray("Version: ") + chalk61.white(VERSION));
+  sections.push(chalk61.gray("Documentation: ") + chalk61.cyan("https://hubify.com/docs"));
+  sections.push(chalk61.gray("Report issues: ") + chalk61.cyan("https://github.com/houstongolden/hubify/issues"));
   sections.push("");
   return sections.join("\n");
 }
 function formatCommand(name, desc) {
   const paddedName = name.padEnd(24);
-  return chalk56.white(`  ${paddedName}`) + chalk56.gray(desc);
+  return chalk61.white(`  ${paddedName}`) + chalk61.gray(desc);
 }
 function generateBashCompletion() {
   return `# hubify bash completion
 _hubify_completions() {
     local cur="\${COMP_WORDS[COMP_CWORD]}"
-    local commands="soul tool search install execute run info list init publish report update generate evolve import integrate workflow squad stats auth learn labs research collective network memory workspace knowledge usage seed-all seed-anthropic seed-clawhub seed-skillssh seed-github seed-community seed-bootstrap seed-souls seed-tools completion"
+    local commands="soul tool search install execute run info list init publish report update generate evolve import integrate workflow squad stats auth learn labs research collective network memory workspace knowledge usage vault reports mission meta hub hub-connect sync test agent collaborate scan audit detect ingest seed-all seed-anthropic seed-clawhub seed-skillssh seed-github seed-community seed-bootstrap seed-souls seed-tools completion"
 
     if [[ \${COMP_CWORD} -eq 1 ]]; then
         COMPREPLY=( $(compgen -W "\${commands}" -- "\${cur}") )
@@ -29008,6 +31309,28 @@ _hubify() {
         'evolve:Evolve a skill'
         'import:Import from external source'
         'stats:View registry statistics'
+        'auth:Manage authentication'
+        'learn:Learning and evolution'
+        'labs:Experiment swarms'
+        'research:Research missions'
+        'collective:Collective intelligence'
+        'network:Singularity network'
+        'memory:Agent memory'
+        'workspace:Workspace management'
+        'knowledge:Hub knowledge'
+        'usage:Usage and billing'
+        'vault:Credential vault'
+        'reports:Weekly intelligence reports'
+        'mission:Autonomous missions'
+        'meta:Meta-skills for Hubify platform'
+        'hub:Hub manifests'
+        'hub-connect:Connect to hub'
+        'sync:Sync operations'
+        'agent:Agent management'
+        'collaborate:Collaboration sessions'
+        'scan:Security scanning'
+        'audit:Skills audit'
+        'ingest:Ingest from registries'
         'seed-all:Seed from all sources'
         'seed-anthropic:Seed from Anthropic'
         'seed-clawhub:Seed from ClawHub'
@@ -29053,6 +31376,28 @@ complete -c hubify -n "__fish_use_subcommand" -a "generate" -d "Generate a new s
 complete -c hubify -n "__fish_use_subcommand" -a "evolve" -d "Evolve a skill"
 complete -c hubify -n "__fish_use_subcommand" -a "import" -d "Import from external source"
 complete -c hubify -n "__fish_use_subcommand" -a "stats" -d "View registry statistics"
+complete -c hubify -n "__fish_use_subcommand" -a "auth" -d "Manage authentication"
+complete -c hubify -n "__fish_use_subcommand" -a "learn" -d "Learning and evolution"
+complete -c hubify -n "__fish_use_subcommand" -a "labs" -d "Experiment swarms"
+complete -c hubify -n "__fish_use_subcommand" -a "research" -d "Research missions"
+complete -c hubify -n "__fish_use_subcommand" -a "collective" -d "Collective intelligence"
+complete -c hubify -n "__fish_use_subcommand" -a "network" -d "Singularity network"
+complete -c hubify -n "__fish_use_subcommand" -a "memory" -d "Agent memory"
+complete -c hubify -n "__fish_use_subcommand" -a "workspace" -d "Workspace management"
+complete -c hubify -n "__fish_use_subcommand" -a "knowledge" -d "Hub knowledge"
+complete -c hubify -n "__fish_use_subcommand" -a "usage" -d "Usage and billing"
+complete -c hubify -n "__fish_use_subcommand" -a "vault" -d "Credential vault"
+complete -c hubify -n "__fish_use_subcommand" -a "reports" -d "Weekly intelligence reports"
+complete -c hubify -n "__fish_use_subcommand" -a "mission" -d "Autonomous missions"
+complete -c hubify -n "__fish_use_subcommand" -a "meta" -d "Meta-skills"
+complete -c hubify -n "__fish_use_subcommand" -a "hub" -d "Hub manifests"
+complete -c hubify -n "__fish_use_subcommand" -a "hub-connect" -d "Connect to hub"
+complete -c hubify -n "__fish_use_subcommand" -a "sync" -d "Sync operations"
+complete -c hubify -n "__fish_use_subcommand" -a "agent" -d "Agent management"
+complete -c hubify -n "__fish_use_subcommand" -a "collaborate" -d "Collaboration sessions"
+complete -c hubify -n "__fish_use_subcommand" -a "scan" -d "Security scanning"
+complete -c hubify -n "__fish_use_subcommand" -a "audit" -d "Skills audit"
+complete -c hubify -n "__fish_use_subcommand" -a "ingest" -d "Ingest from registries"
 complete -c hubify -n "__fish_use_subcommand" -a "seed-all" -d "Seed from all sources"
 complete -c hubify -n "__fish_use_subcommand" -a "seed-anthropic" -d "Seed from Anthropic"
 complete -c hubify -n "__fish_use_subcommand" -a "seed-clawhub" -d "Seed from ClawHub"
@@ -29064,7 +31409,7 @@ complete -c hubify -n "__fish_use_subcommand" -a "seed-tools" -d "Seed core tool
 complete -c hubify -n "__fish_use_subcommand" -a "completion" -d "Generate shell completions"
 `;
 }
-var program = new Command53();
+var program = new Command58();
 program.name("hubify").description("The living intelligence layer for Agent Skills").version(VERSION, "-v, --version", "Display version number").configureHelp({
   formatHelp: () => formatGroupedHelp()
 });
@@ -29110,14 +31455,19 @@ program.addCommand(researchCommand);
 program.addCommand(authCommand);
 program.addCommand(scanCommand);
 program.addCommand(auditCommand);
-program.addCommand(labsCommand);
+program.addCommand(labsCommand2);
 program.addCommand(networkCommand);
 program.addCommand(memoryCommand);
 program.addCommand(workspaceCommand);
 program.addCommand(knowledgeCommand);
 program.addCommand(usageCommand);
 program.addCommand(collectiveCommand);
-var completionCommand = new Command53("completion").description("Generate shell completion scripts").argument("<shell>", "Shell type: bash, zsh, or fish").action((shell) => {
+program.addCommand(vaultCommand);
+program.addCommand(reportsCommand);
+program.addCommand(missionCommand);
+program.addCommand(metaCommand);
+program.addCommand(selfUpdateCommand);
+var completionCommand = new Command58("completion").description("Generate shell completion scripts").argument("<shell>", "Shell type: bash, zsh, or fish").action((shell) => {
   switch (shell.toLowerCase()) {
     case "bash":
       console.log(generateBashCompletion());
@@ -29129,16 +31479,16 @@ var completionCommand = new Command53("completion").description("Generate shell
       console.log(generateFishCompletion());
       break;
     default:
-      console.error(chalk56.red(`Unknown shell: ${shell}`));
-      console.error(chalk56.gray("Supported shells: bash, zsh, fish"));
+      console.error(chalk61.red(`Unknown shell: ${shell}`));
+      console.error(chalk61.gray("Supported shells: bash, zsh, fish"));
       process.exit(1);
   }
 });
 program.addCommand(completionCommand);
-var doctorCommand = new Command53("doctor").description("Diagnose Hubify configuration and connectivity").action(async () => {
+var doctorCommand = new Command58("doctor").description("Diagnose Hubify configuration and connectivity").action(async () => {
   console.log(BANNER);
-  console.log(chalk56.cyan.bold("  Hubify Doctor"));
-  console.log(chalk56.gray("  Checking your setup...\n"));
+  console.log(chalk61.cyan.bold("  Hubify Doctor"));
+  console.log(chalk61.gray("  Checking your setup...\n"));
   const checks = [];
   const nodeVersion = process.version;
   const majorVersion = parseInt(nodeVersion.slice(1).split(".")[0]);
@@ -29147,17 +31497,17 @@ var doctorCommand = new Command53("doctor").description("Diagnose Hubify configu
   } else {
     checks.push({ name: "Node.js version", status: "fail", message: `${nodeVersion} (>= 20 required)` });
   }
-  const os11 = await import("os");
-  const fs27 = await import("fs");
-  const path26 = await import("path");
-  const globalConfigPath = path26.join(os11.homedir(), ".hubify", "config.yaml");
-  if (fs27.existsSync(globalConfigPath)) {
+  const os12 = await import("os");
+  const fs29 = await import("fs");
+  const path27 = await import("path");
+  const globalConfigPath = path27.join(os12.homedir(), ".hubify", "config.yaml");
+  if (fs29.existsSync(globalConfigPath)) {
     checks.push({ name: "Global config", status: "pass", message: globalConfigPath });
   } else {
     checks.push({ name: "Global config", status: "warn", message: "Not found (run: hubify init --global)" });
   }
-  const localConfigPath = path26.join(process.cwd(), ".hubify", "config.yaml");
-  if (fs27.existsSync(localConfigPath)) {
+  const localConfigPath = path27.join(process.cwd(), ".hubify", "config.yaml");
+  if (fs29.existsSync(localConfigPath)) {
     checks.push({ name: "Project config", status: "pass", message: localConfigPath });
   } else {
     checks.push({ name: "Project config", status: "warn", message: "Not found (run: hubify init)" });
@@ -29176,26 +31526,26 @@ var doctorCommand = new Command53("doctor").description("Diagnose Hubify configu
     let color;
     switch (check.status) {
       case "pass":
-        icon = chalk56.green("  [PASS]");
-        color = chalk56.white;
+        icon = chalk61.green("  [PASS]");
+        color = chalk61.white;
         break;
       case "fail":
-        icon = chalk56.red("  [FAIL]");
-        color = chalk56.red;
+        icon = chalk61.red("  [FAIL]");
+        color = chalk61.red;
         hasFailure = true;
         break;
       case "warn":
-        icon = chalk56.yellow("  [WARN]");
-        color = chalk56.yellow;
+        icon = chalk61.yellow("  [WARN]");
+        color = chalk61.yellow;
         break;
     }
-    console.log(`${icon} ${chalk56.white(check.name.padEnd(20))} ${color(check.message)}`);
+    console.log(`${icon} ${chalk61.white(check.name.padEnd(20))} ${color(check.message)}`);
   }
   console.log();
   if (hasFailure) {
-    console.log(chalk56.red("  Some checks failed. Please resolve the issues above."));
+    console.log(chalk61.red("  Some checks failed. Please resolve the issues above."));
   } else {
-    console.log(chalk56.green("  All checks passed! Hubify is ready to use."));
+    console.log(chalk61.green("  All checks passed! Hubify is ready to use."));
   }
   console.log();
 });
@@ -29207,7 +31557,7 @@ program.exitOverride((err) => {
   if (err.code === "commander.unknownCommand") {
     const unknownCommand = process.argv[2];
     console.log();
-    console.log(chalk56.red(`  Error: Unknown command '${unknownCommand}'`));
+    console.log(chalk61.red(`  Error: Unknown command '${unknownCommand}'`));
     console.log();
     const commands = [
       "search",
@@ -29237,26 +31587,26 @@ program.exitOverride((err) => {
       (cmd) => cmd.includes(unknownCommand) || unknownCommand.includes(cmd.slice(0, 3)) || levenshteinDistance(cmd, unknownCommand) <= 2
     );
     if (similar.length > 0) {
-      console.log(chalk56.gray("  Did you mean one of these?"));
+      console.log(chalk61.gray("  Did you mean one of these?"));
       for (const cmd of similar.slice(0, 3)) {
-        console.log(chalk56.cyan(`    hubify ${cmd}`));
+        console.log(chalk61.cyan(`    hubify ${cmd}`));
       }
       console.log();
     }
-    console.log(chalk56.gray("  Run ") + chalk56.cyan("hubify --help") + chalk56.gray(" to see all available commands."));
+    console.log(chalk61.gray("  Run ") + chalk61.cyan("hubify --help") + chalk61.gray(" to see all available commands."));
     console.log();
     process.exit(1);
   }
   if (err.code === "commander.missingArgument") {
     console.log();
-    console.log(chalk56.red(`  Error: ${err.message}`));
+    console.log(chalk61.red(`  Error: ${err.message}`));
     console.log();
-    console.log(chalk56.gray("  Run ") + chalk56.cyan(`hubify ${process.argv[2]} --help`) + chalk56.gray(" for usage details."));
+    console.log(chalk61.gray("  Run ") + chalk61.cyan(`hubify ${process.argv[2]} --help`) + chalk61.gray(" for usage details."));
     console.log();
     process.exit(1);
   }
   console.error();
-  console.error(chalk56.red("  Error:"), err.message);
+  console.error(chalk61.red("  Error:"), err.message);
   console.error();
   process.exit(1);
 });
@@ -29285,19 +31635,19 @@ function levenshteinDistance(a, b) {
 }
 process.on("unhandledRejection", (reason) => {
   console.error();
-  console.error(chalk56.red("  Unexpected error:"));
+  console.error(chalk61.red("  Unexpected error:"));
   if (reason instanceof Error) {
-    console.error(chalk56.red(`  ${reason.message}`));
+    console.error(chalk61.red(`  ${reason.message}`));
     if (reason.message.includes("ECONNREFUSED") || reason.message.includes("fetch")) {
       console.error();
-      console.error(chalk56.yellow("  Tip: Check your internet connection or run 'hubify doctor' to diagnose."));
+      console.error(chalk61.yellow("  Tip: Check your internet connection or run 'hubify doctor' to diagnose."));
     }
     if (reason.message.includes("not found")) {
       console.error();
-      console.error(chalk56.yellow("  Tip: Try 'hubify search <query>' to find available skills."));
+      console.error(chalk61.yellow("  Tip: Try 'hubify search <query>' to find available skills."));
     }
   } else {
-    console.error(chalk56.red(`  ${String(reason)}`));
+    console.error(chalk61.red(`  ${String(reason)}`));
   }
   console.error();
   process.exit(1);