@learnrudi/cli 1.5.0 → 1.7.0

package/dist/index.cjs

@@ -186,6 +186,7 @@ __export(src_exports, {
   PACKAGE_KINDS: () => PACKAGE_KINDS2,
   RUNTIMES_DOWNLOAD_BASE: () => RUNTIMES_DOWNLOAD_BASE,
   RUNTIMES_RELEASE_VERSION: () => RUNTIMES_RELEASE_VERSION,
+  STACKS_RELEASE_VERSION: () => STACKS_RELEASE_VERSION,
   checkCache: () => checkCache,
   clearCache: () => clearCache,
   computeHash: () => computeHash,
@@ -377,24 +378,72 @@ function getPackageKinds() {
 async function downloadPackage(pkg, destPath, options = {}) {
   const { onProgress } = options;
   const registryPath = pkg.path;
-  for (const basePath of getLocalRegistryPaths()) {
-    const registryDir = import_path2.default.dirname(basePath);
-    const pkgSourcePath = import_path2.default.join(registryDir, registryPath);
-    if (import_fs2.default.existsSync(pkgSourcePath)) {
-      const stat = import_fs2.default.statSync(pkgSourcePath);
-      if (stat.isFile()) {
-        const destDir = import_path2.default.dirname(destPath);
-        if (!import_fs2.default.existsSync(destDir)) {
-          import_fs2.default.mkdirSync(destDir, { recursive: true });
-        }
-        import_fs2.default.copyFileSync(pkgSourcePath, destPath);
-      } else {
-        await copyDirectory(pkgSourcePath, destPath);
+  if (!import_fs2.default.existsSync(destPath)) {
+    import_fs2.default.mkdirSync(destPath, { recursive: true });
+  }
+  onProgress?.({ phase: "downloading", package: pkg.name || pkg.id });
+  if (pkg.kind === "stack" || registryPath.includes("/stacks/")) {
+    await downloadStackTarball(pkg, destPath, onProgress);
+    return { success: true, path: destPath };
+  }
+  if (registryPath.endsWith(".md")) {
+    const url = `${GITHUB_RAW_BASE}/${registryPath}`;
+    const response = await fetch(url, {
+      headers: { "User-Agent": "rudi-cli/2.0" }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to download ${registryPath}: HTTP ${response.status}`);
+    }
+    const content = await response.text();
+    const destDir = import_path2.default.dirname(destPath);
+    if (!import_fs2.default.existsSync(destDir)) {
+      import_fs2.default.mkdirSync(destDir, { recursive: true });
+    }
+    import_fs2.default.writeFileSync(destPath, content);
+    return { success: true, path: destPath };
+  }
+  throw new Error(`Unsupported package type: ${registryPath}`);
+}
+async function downloadStackTarball(pkg, destPath, onProgress) {
+  const stackName = pkg.id?.replace("stack:", "") || import_path2.default.basename(pkg.path);
+  const version = pkg.version || "1.0.0";
+  const tarballName = `${stackName}-${version}.tar.gz`;
+  const url = `${STACKS_DOWNLOAD_BASE}/${STACKS_RELEASE_VERSION}/${tarballName}`;
+  onProgress?.({ phase: "downloading", package: stackName, url });
+  const tempDir = import_path2.default.join(PATHS.cache, "downloads");
+  if (!import_fs2.default.existsSync(tempDir)) {
+    import_fs2.default.mkdirSync(tempDir, { recursive: true });
+  }
+  const tempFile = import_path2.default.join(tempDir, tarballName);
+  try {
+    const response = await fetch(url, {
+      headers: {
+        "User-Agent": "rudi-cli/2.0",
+        "Accept": "application/octet-stream"
       }
-      return { success: true, path: destPath };
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to download ${stackName}: HTTP ${response.status}`);
+    }
+    const buffer = await response.arrayBuffer();
+    import_fs2.default.writeFileSync(tempFile, Buffer.from(buffer));
+    onProgress?.({ phase: "extracting", package: stackName });
+    if (import_fs2.default.existsSync(destPath)) {
+      import_fs2.default.rmSync(destPath, { recursive: true });
+    }
+    import_fs2.default.mkdirSync(destPath, { recursive: true });
+    const { execSync: execSync7 } = await import("child_process");
+    execSync7(`tar -xzf "${tempFile}" -C "${destPath}"`, {
+      stdio: "pipe"
+    });
+    import_fs2.default.unlinkSync(tempFile);
+    onProgress?.({ phase: "complete", package: stackName, path: destPath });
+  } catch (error) {
+    if (import_fs2.default.existsSync(tempFile)) {
+      import_fs2.default.unlinkSync(tempFile);
     }
+    throw new Error(`Failed to install ${stackName}: ${error.message}`);
   }
-  throw new Error(`Package source not found: ${registryPath}`);
 }
 async function downloadRuntime(runtime, version, destPath, options = {}) {
   const { onProgress } = options;
@@ -425,8 +474,8 @@ async function downloadRuntime(runtime, version, destPath, options = {}) {
       import_fs2.default.rmSync(destPath, { recursive: true });
     }
     import_fs2.default.mkdirSync(destPath, { recursive: true });
-    const { execSync: execSync5 } = await import("child_process");
-    execSync5(`tar -xzf "${tempFile}" -C "${destPath}" --strip-components=1`, {
+    const { execSync: execSync7 } = await import("child_process");
+    execSync7(`tar -xzf "${tempFile}" -C "${destPath}" --strip-components=1`, {
       stdio: "pipe"
     });
     import_fs2.default.unlinkSync(tempFile);
@@ -464,7 +513,7 @@ async function downloadTool(toolName, destPath, options = {}) {
     import_fs2.default.rmSync(destPath, { recursive: true });
   }
   import_fs2.default.mkdirSync(destPath, { recursive: true });
-  const { execSync: execSync5 } = await import("child_process");
+  const { execSync: execSync7 } = await import("child_process");
   const downloads = toolManifest.downloads?.[platformArch];
   if (downloads && Array.isArray(downloads)) {
     const downloadedUrls = /* @__PURE__ */ new Set();
@@ -493,11 +542,11 @@ async function downloadTool(toolName, destPath, options = {}) {
         onProgress?.({ phase: "extracting", tool: toolName, binary: import_path2.default.basename(binary) });
         const archiveType = type || guessArchiveType(urlFilename);
         if (archiveType === "zip") {
-          execSync5(`unzip -o "${tempFile}" -d "${destPath}"`, { stdio: "pipe" });
+          execSync7(`unzip -o "${tempFile}" -d "${destPath}"`, { stdio: "pipe" });
         } else if (archiveType === "tar.xz") {
-          execSync5(`tar -xJf "${tempFile}" -C "${destPath}"`, { stdio: "pipe" });
+          execSync7(`tar -xJf "${tempFile}" -C "${destPath}"`, { stdio: "pipe" });
         } else if (archiveType === "tar.gz" || archiveType === "tgz") {
-          execSync5(`tar -xzf "${tempFile}" -C "${destPath}"`, { stdio: "pipe" });
+          execSync7(`tar -xzf "${tempFile}" -C "${destPath}"`, { stdio: "pipe" });
         } else {
           throw new Error(`Unsupported archive type: ${archiveType}`);
         }
@@ -544,11 +593,11 @@ async function downloadTool(toolName, destPath, options = {}) {
       onProgress?.({ phase: "extracting", tool: toolName });
       const archiveType = extractConfig.type || guessArchiveType(urlFilename);
       if (archiveType === "zip") {
-        execSync5(`unzip -o "${tempFile}" -d "${destPath}"`, { stdio: "pipe" });
+        execSync7(`unzip -o "${tempFile}" -d "${destPath}"`, { stdio: "pipe" });
       } else if (archiveType === "tar.xz") {
-        execSync5(`tar -xJf "${tempFile}" -C "${destPath}"`, { stdio: "pipe" });
+        execSync7(`tar -xJf "${tempFile}" -C "${destPath}"`, { stdio: "pipe" });
       } else if (archiveType === "tar.gz" || archiveType === "tgz") {
-        execSync5(`tar -xzf "${tempFile}" -C "${destPath}"`, { stdio: "pipe" });
+        execSync7(`tar -xzf "${tempFile}" -C "${destPath}"`, { stdio: "pipe" });
       } else {
         throw new Error(`Unsupported archive type: ${archiveType}`);
       }
@@ -671,22 +720,7 @@ async function computeHash(filePath) {
     stream.on("error", reject);
   });
 }
-async function copyDirectory(src, dest) {
-  import_fs2.default.mkdirSync(dest, { recursive: true });
-  const entries = import_fs2.default.readdirSync(src, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = import_path2.default.join(src, entry.name);
-    const destPath = import_path2.default.join(dest, entry.name);
-    if (entry.isDirectory()) {
-      if (entry.name !== "node_modules" && entry.name !== ".git") {
-        await copyDirectory(srcPath, destPath);
-      }
-    } else {
-      import_fs2.default.copyFileSync(srcPath, destPath);
-    }
-  }
-}
-var import_fs2, import_path2, import_crypto, DEFAULT_REGISTRY_URL, RUNTIMES_DOWNLOAD_BASE, CACHE_TTL, PACKAGE_KINDS2, KIND_PLURALS, RUNTIMES_RELEASE_VERSION;
+var import_fs2, import_path2, import_crypto, DEFAULT_REGISTRY_URL, RUNTIMES_DOWNLOAD_BASE, CACHE_TTL, PACKAGE_KINDS2, KIND_PLURALS, GITHUB_RAW_BASE, STACKS_DOWNLOAD_BASE, STACKS_RELEASE_VERSION, RUNTIMES_RELEASE_VERSION;
 var init_src2 = __esm({
   "../packages/registry-client/src/index.js"() {
     import_fs2 = __toESM(require("fs"), 1);
@@ -700,6 +734,9 @@ var init_src2 = __esm({
     KIND_PLURALS = {
       binary: "binaries"
     };
+    GITHUB_RAW_BASE = "https://raw.githubusercontent.com/learn-rudi/registry/main";
+    STACKS_DOWNLOAD_BASE = "https://github.com/learn-rudi/registry/releases/download";
+    STACKS_RELEASE_VERSION = "stacks-v1.0.0";
     RUNTIMES_RELEASE_VERSION = "v1.0.0";
   }
 });
@@ -781,17 +818,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path18) {
-      const ctrl = callVisitor(key, node, visitor, path18);
+    function visit_(key, node, visitor, path24) {
+      const ctrl = callVisitor(key, node, visitor, path24);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path18, ctrl);
-        return visit_(key, ctrl, visitor, path18);
+        replaceNode(key, path24, ctrl);
+        return visit_(key, ctrl, visitor, path24);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path18 = Object.freeze(path18.concat(node));
+          path24 = Object.freeze(path24.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path18);
+            const ci = visit_(i, node.items[i], visitor, path24);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -802,13 +839,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path18 = Object.freeze(path18.concat(node));
-          const ck = visit_("key", node.key, visitor, path18);
+          path24 = Object.freeze(path24.concat(node));
+          const ck = visit_("key", node.key, visitor, path24);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path18);
+          const cv = visit_("value", node.value, visitor, path24);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -829,17 +866,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path18) {
-      const ctrl = await callVisitor(key, node, visitor, path18);
+    async function visitAsync_(key, node, visitor, path24) {
+      const ctrl = await callVisitor(key, node, visitor, path24);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path18, ctrl);
-        return visitAsync_(key, ctrl, visitor, path18);
+        replaceNode(key, path24, ctrl);
+        return visitAsync_(key, ctrl, visitor, path24);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path18 = Object.freeze(path18.concat(node));
+          path24 = Object.freeze(path24.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path18);
+            const ci = await visitAsync_(i, node.items[i], visitor, path24);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -850,13 +887,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path18 = Object.freeze(path18.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path18);
+          path24 = Object.freeze(path24.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path24);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path18);
+          const cv = await visitAsync_("value", node.value, visitor, path24);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -883,23 +920,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path18) {
+    function callVisitor(key, node, visitor, path24) {
       if (typeof visitor === "function")
-        return visitor(key, node, path18);
+        return visitor(key, node, path24);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path18);
+        return visitor.Map?.(key, node, path24);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path18);
+        return visitor.Seq?.(key, node, path24);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path18);
+        return visitor.Pair?.(key, node, path24);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path18);
+        return visitor.Scalar?.(key, node, path24);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path18);
+        return visitor.Alias?.(key, node, path24);
       return void 0;
     }
-    function replaceNode(key, path18, node) {
-      const parent = path18[path18.length - 1];
+    function replaceNode(key, path24, node) {
+      const parent = path24[path24.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -1507,10 +1544,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path18, value) {
+    function collectionFromPath(schema, path24, value) {
       let v = value;
-      for (let i = path18.length - 1; i >= 0; --i) {
-        const k = path18[i];
+      for (let i = path24.length - 1; i >= 0; --i) {
+        const k = path24[i];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a = [];
           a[k] = v;
@@ -1529,7 +1566,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path18) => path18 == null || typeof path18 === "object" && !!path18[Symbol.iterator]().next().done;
+    var isEmptyPath = (path24) => path24 == null || typeof path24 === "object" && !!path24[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -1559,11 +1596,11 @@ var require_Collection = __commonJS({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path18, value) {
-        if (isEmptyPath(path18))
+      addIn(path24, value) {
+        if (isEmptyPath(path24))
           this.add(value);
         else {
-          const [key, ...rest] = path18;
+          const [key, ...rest] = path24;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -1577,8 +1614,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path18) {
-        const [key, ...rest] = path18;
+      deleteIn(path24) {
+        const [key, ...rest] = path24;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -1592,8 +1629,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path18, keepScalar) {
-        const [key, ...rest] = path18;
+      getIn(path24, keepScalar) {
+        const [key, ...rest] = path24;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -1611,8 +1648,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path18) {
-        const [key, ...rest] = path18;
+      hasIn(path24) {
+        const [key, ...rest] = path24;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -1622,8 +1659,8 @@ var require_Collection = __commonJS({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path18, value) {
-        const [key, ...rest] = path18;
+      setIn(path24, value) {
+        const [key, ...rest] = path24;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -4127,9 +4164,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path18, value) {
+      addIn(path24, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path18, value);
+          this.contents.addIn(path24, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -4204,14 +4241,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path18) {
-        if (Collection.isEmptyPath(path18)) {
+      deleteIn(path24) {
+        if (Collection.isEmptyPath(path24)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path18) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path24) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -4226,10 +4263,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path18, keepScalar) {
-        if (Collection.isEmptyPath(path18))
+      getIn(path24, keepScalar) {
+        if (Collection.isEmptyPath(path24))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path18, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path24, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -4240,10 +4277,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path18) {
-        if (Collection.isEmptyPath(path18))
+      hasIn(path24) {
+        if (Collection.isEmptyPath(path24))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path18) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path24) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -4260,13 +4297,13 @@ var require_Document = __commonJS({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path18, value) {
-        if (Collection.isEmptyPath(path18)) {
+      setIn(path24, value) {
+        if (Collection.isEmptyPath(path24)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path18), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path24), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path18, value);
+          this.contents.setIn(path24, value);
         }
       }
       /**
@@ -6218,9 +6255,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path18) => {
+    visit.itemAtPath = (cst, path24) => {
       let item = cst;
-      for (const [field, index] of path18) {
+      for (const [field, index] of path24) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -6229,23 +6266,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path18) => {
-      const parent = visit.itemAtPath(cst, path18.slice(0, -1));
-      const field = path18[path18.length - 1][0];
+    visit.parentCollection = (cst, path24) => {
+      const parent = visit.itemAtPath(cst, path24.slice(0, -1));
+      const field = path24[path24.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path18, item, visitor) {
-      let ctrl = visitor(item, path18);
+    function _visit(path24, item, visitor) {
+      let ctrl = visitor(item, path24);
       if (typeof ctrl === "symbol")
         return ctrl;
       for (const field of ["key", "value"]) {
         const token = item[field];
         if (token && "items" in token) {
           for (let i = 0; i < token.items.length; ++i) {
-            const ci = _visit(Object.freeze(path18.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path24.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -6256,10 +6293,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path18);
+            ctrl = ctrl(item, path24);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path18) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path24) : ctrl;
     }
     exports2.visit = visit;
   }
@@ -7544,14 +7581,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs20 = this.flowScalar(this.type);
+              const fs26 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map.items.push({ start, key: fs20, sep: [] });
+                map.items.push({ start, key: fs26, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs20);
+                this.stack.push(fs26);
               } else {
-                Object.assign(it, { key: fs20, sep: [] });
+                Object.assign(it, { key: fs26, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -7679,13 +7716,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs20 = this.flowScalar(this.type);
+              const fs26 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs20, sep: [] });
+                fc.items.push({ start: [], key: fs26, sep: [] });
               else if (it.sep)
-                this.stack.push(fs20);
+                this.stack.push(fs26);
               else
-                Object.assign(it, { key: fs20, sep: [] });
+                Object.assign(it, { key: fs26, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -11186,8 +11223,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path18) {
-      let input = path18;
+    function removeDotSegments(path24) {
+      let input = path24;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -11386,8 +11423,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path18, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path18 && path18 !== "/" ? path18 : void 0;
+        const [path24, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path24 && path24 !== "/" ? path24 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -14740,12 +14777,12 @@ var require_dist2 = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats2(ajv2, list, fs20, exportName) {
+    function addFormats2(ajv2, list, fs26, exportName) {
       var _a;
       var _b;
       (_a = (_b = ajv2.opts.code).formats) !== null && _a !== void 0 ? _a : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv2.addFormat(f, fs20[f]);
+        ajv2.addFormat(f, fs26[f]);
     }
     module2.exports = exports2 = formatsPlugin;
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -14819,6 +14856,9 @@ rudi - RUDI CLI
 USAGE
   rudi <command> [options]
 
+SETUP
+  init                  Bootstrap RUDI (download runtimes, create shims)
+
 INTROSPECTION
   home                  Show ~/.rudi structure and installed packages
   stacks                List installed stacks
@@ -14941,12 +14981,15 @@ ARGUMENTS
 
 OPTIONS
   --json           Output as JSON
+  --detected       Show MCP servers from agent configs (stacks only)
+  --category=X     Filter prompts by category
 
 EXAMPLES
   rudi list
   rudi list stacks
+  rudi list stacks --detected     Show MCP servers in Claude/Gemini/Codex
   rudi list binaries
-  rudi list agents
+  rudi list prompts --category=coding
 `,
     secrets: `
 rudi secrets - Manage secrets
@@ -15016,6 +15059,33 @@ EXAMPLES
   rudi import sessions claude       Import only Claude sessions
   rudi import sessions --dry-run    Preview without importing
   rudi import status                Check what's available to import
+`,
+    init: `
+rudi init - Bootstrap RUDI environment
+
+USAGE
+  rudi init [options]
+
+OPTIONS
+  --force            Reinitialize even if already set up
+  --skip-downloads   Skip downloading runtimes/binaries
+  --quiet            Minimal output (for programmatic use)
+
+WHAT IT DOES
+  1. Creates ~/.rudi directory structure (if missing)
+  2. Downloads bundled runtimes (Node.js, Python) if not installed
+  3. Downloads essential binaries (sqlite3, ripgrep) if not installed
+  4. Creates/updates shims in ~/.rudi/shims/
+  5. Initializes the database (if missing)
+  6. Creates settings.json (if missing)
+
+NOTE: Safe to run multiple times - only creates what's missing.
+
+EXAMPLES
+  rudi init
+  rudi init --force
+  rudi init --skip-downloads
+  rudi init --quiet
 `,
     home: `
 rudi home - Show ~/.rudi structure and status
@@ -15317,7 +15387,7 @@ async function installSinglePackage(pkg, options = {}) {
     onProgress?.({ phase: "downloading", package: pkg.id });
     if (pkg.npmPackage) {
       try {
-        const { execSync: execSync5 } = await import("child_process");
+        const { execSync: execSync7 } = await import("child_process");
         if (!import_fs4.default.existsSync(installPath)) {
           import_fs4.default.mkdirSync(installPath, { recursive: true });
         }
@@ -15325,16 +15395,16 @@ async function installSinglePackage(pkg, options = {}) {
         const resourcesPath = process.env.RESOURCES_PATH;
         const npmCmd = resourcesPath ? import_path4.default.join(resourcesPath, "bundled-runtimes", "node", "bin", "npm") : "npm";
         if (!import_fs4.default.existsSync(import_path4.default.join(installPath, "package.json"))) {
-          execSync5(`"${npmCmd}" init -y`, { cwd: installPath, stdio: "pipe" });
+          execSync7(`"${npmCmd}" init -y`, { cwd: installPath, stdio: "pipe" });
         }
-        execSync5(`"${npmCmd}" install ${pkg.npmPackage}`, { cwd: installPath, stdio: "pipe" });
+        execSync7(`"${npmCmd}" install ${pkg.npmPackage}`, { cwd: installPath, stdio: "pipe" });
         if (pkg.postInstall) {
           onProgress?.({ phase: "postInstall", package: pkg.id, message: pkg.postInstall });
           const postInstallCmd = pkg.postInstall.replace(
             /^npx\s+(\S+)/,
             `"${import_path4.default.join(installPath, "node_modules", ".bin", "$1")}"`
           );
-          execSync5(postInstallCmd, { cwd: installPath, stdio: "pipe" });
+          execSync7(postInstallCmd, { cwd: installPath, stdio: "pipe" });
         }
         import_fs4.default.writeFileSync(
           import_path4.default.join(installPath, "manifest.json"),
@@ -15356,15 +15426,15 @@ async function installSinglePackage(pkg, options = {}) {
     }
     if (pkg.pipPackage) {
       try {
-        const { execSync: execSync5 } = await import("child_process");
+        const { execSync: execSync7 } = await import("child_process");
         if (!import_fs4.default.existsSync(installPath)) {
           import_fs4.default.mkdirSync(installPath, { recursive: true });
         }
         onProgress?.({ phase: "installing", package: pkg.id, message: `pip install ${pkg.pipPackage}` });
         const pythonPath = import_path4.default.join(PATHS.runtimes, "python", "bin", "python3");
         const pythonCmd = import_fs4.default.existsSync(pythonPath) ? pythonPath : "python3";
-        execSync5(`"${pythonCmd}" -m venv "${installPath}/venv"`, { stdio: "pipe" });
-        execSync5(`"${installPath}/venv/bin/pip" install ${pkg.pipPackage}`, { stdio: "pipe" });
+        execSync7(`"${pythonCmd}" -m venv "${installPath}/venv"`, { stdio: "pipe" });
+        execSync7(`"${installPath}/venv/bin/pip" install ${pkg.pipPackage}`, { stdio: "pipe" });
         import_fs4.default.writeFileSync(
           import_path4.default.join(installPath, "manifest.json"),
           JSON.stringify({
@@ -15586,7 +15656,7 @@ async function listInstalled(kind) {
   return packages;
 }
 async function installStackDependencies(stackPath, onProgress) {
-  const { execSync: execSync5 } = await import("child_process");
+  const { execSync: execSync7 } = await import("child_process");
   const nodePath = import_path4.default.join(stackPath, "node");
   if (import_fs4.default.existsSync(nodePath)) {
     const packageJsonPath = import_path4.default.join(nodePath, "package.json");
@@ -15594,7 +15664,7 @@ async function installStackDependencies(stackPath, onProgress) {
       onProgress?.({ phase: "installing-deps", message: "Installing Node.js dependencies..." });
       try {
         const npmCmd = await findNpmExecutable();
-        execSync5(`"${npmCmd}" install`, { cwd: nodePath, stdio: "pipe" });
+        execSync7(`"${npmCmd}" install`, { cwd: nodePath, stdio: "pipe" });
       } catch (error) {
         console.warn(`Warning: Failed to install Node.js dependencies: ${error.message}`);
       }
@@ -15607,8 +15677,8 @@ async function installStackDependencies(stackPath, onProgress) {
       onProgress?.({ phase: "installing-deps", message: "Installing Python dependencies..." });
       try {
         const pythonCmd = await findPythonExecutable();
-        execSync5(`"${pythonCmd}" -m venv venv`, { cwd: pythonPath, stdio: "pipe" });
-        execSync5("./venv/bin/pip install -r requirements.txt", { cwd: pythonPath, stdio: "pipe" });
+        execSync7(`"${pythonCmd}" -m venv venv`, { cwd: pythonPath, stdio: "pipe" });
+        execSync7("./venv/bin/pip install -r requirements.txt", { cwd: pythonPath, stdio: "pipe" });
       } catch (error) {
         console.warn(`Warning: Failed to install Python dependencies: ${error.message}`);
       }
@@ -15960,407 +16030,319 @@ Total: ${totalCount} package(s) available`);
 }
 
 // src/commands/install.js
-var fs7 = __toESM(require("fs/promises"), 1);
-var path7 = __toESM(require("path"), 1);
+var fs8 = __toESM(require("fs/promises"), 1);
+var path8 = __toESM(require("path"), 1);
+var import_child_process2 = require("child_process");
 
-// src/utils/mcp-registry.js
-var fs6 = __toESM(require("fs/promises"), 1);
+// src/commands/secrets-store.js
+var fs6 = __toESM(require("fs"), 1);
 var path6 = __toESM(require("path"), 1);
-var os2 = __toESM(require("os"), 1);
-var HOME = os2.homedir();
-var AGENT_CONFIGS = {
-  claude: path6.join(HOME, ".claude", "settings.json"),
-  codex: path6.join(HOME, ".codex", "config.toml"),
-  gemini: path6.join(HOME, ".gemini", "settings.json")
-};
-async function readJson(filePath) {
+init_src();
+var SECRETS_FILE = path6.join(PATHS.home, "secrets.json");
+function ensureSecretsFile() {
+  const dir = path6.dirname(SECRETS_FILE);
+  if (!fs6.existsSync(dir)) {
+    fs6.mkdirSync(dir, { recursive: true });
+  }
+  if (!fs6.existsSync(SECRETS_FILE)) {
+    fs6.writeFileSync(SECRETS_FILE, "{}", { mode: 384 });
+  } else {
+    try {
+      fs6.chmodSync(SECRETS_FILE, 384);
+    } catch {
+    }
+  }
+}
+function loadSecrets() {
+  ensureSecretsFile();
   try {
-    const content = await fs6.readFile(filePath, "utf-8");
+    const content = fs6.readFileSync(SECRETS_FILE, "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
   }
 }
-async function writeJson(filePath, data) {
-  const dir = path6.dirname(filePath);
-  await fs6.mkdir(dir, { recursive: true });
-  await fs6.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+function saveSecrets(secrets) {
+  ensureSecretsFile();
+  fs6.writeFileSync(SECRETS_FILE, JSON.stringify(secrets, null, 2), {
+    encoding: "utf-8",
+    mode: 384
+  });
 }
-function parseTomlValue(value) {
-  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-    return value.slice(1, -1);
-  }
-  if (value.startsWith("[") && value.endsWith("]")) {
-    const inner = value.slice(1, -1).trim();
-    if (!inner) return [];
-    const items = [];
-    let current = "";
-    let inQuote = false;
-    let quoteChar = "";
-    for (const char of inner) {
-      if ((char === '"' || char === "'") && !inQuote) {
-        inQuote = true;
-        quoteChar = char;
-      } else if (char === quoteChar && inQuote) {
-        inQuote = false;
-        items.push(current);
-        current = "";
-      } else if (char === "," && !inQuote) {
-      } else if (inQuote) {
-        current += char;
-      }
-    }
-    return items;
-  }
-  if (value === "true") return true;
-  if (value === "false") return false;
-  const num = Number(value);
-  if (!isNaN(num)) return num;
-  return value;
+async function getSecret(name) {
+  const secrets = loadSecrets();
+  return secrets[name] || null;
 }
-function parseToml(content) {
-  const result = {};
-  const lines = content.split("\n");
-  let currentTable = [];
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) continue;
-    const tableMatch = trimmed.match(/^\[([^\]]+)\]$/);
-    if (tableMatch) {
-      currentTable = tableMatch[1].split(".");
-      let obj = result;
-      for (const key of currentTable) {
-        obj[key] = obj[key] || {};
-        obj = obj[key];
-      }
-      continue;
-    }
-    const kvMatch = trimmed.match(/^([^=]+)=(.*)$/);
-    if (kvMatch) {
-      const key = kvMatch[1].trim();
-      let value = kvMatch[2].trim();
-      const parsed = parseTomlValue(value);
-      let obj = result;
-      for (const tableKey of currentTable) {
-        obj = obj[tableKey];
-      }
-      obj[key] = parsed;
+async function setSecret(name, value) {
+  const secrets = loadSecrets();
+  secrets[name] = value;
+  saveSecrets(secrets);
+  return true;
+}
+async function removeSecret(name) {
+  const secrets = loadSecrets();
+  delete secrets[name];
+  saveSecrets(secrets);
+  return true;
+}
+async function listSecrets() {
+  const secrets = loadSecrets();
+  return Object.keys(secrets).sort();
+}
+async function hasSecret(name) {
+  const secrets = loadSecrets();
+  return secrets[name] !== void 0 && secrets[name] !== null && secrets[name] !== "";
+}
+async function getMaskedSecrets() {
+  const secrets = loadSecrets();
+  const masked = {};
+  for (const [name, value] of Object.entries(secrets)) {
+    if (value && typeof value === "string" && value.length > 8) {
+      masked[name] = value.slice(0, 4) + "..." + value.slice(-4);
+    } else if (value && typeof value === "string" && value.length > 0) {
+      masked[name] = "****";
+    } else {
+      masked[name] = "(pending)";
     }
   }
-  return result;
+  return masked;
 }
-function tomlValue(value) {
-  if (typeof value === "string") {
-    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
-  }
-  if (typeof value === "boolean") {
-    return value ? "true" : "false";
-  }
-  if (typeof value === "number") {
-    return String(value);
-  }
-  if (Array.isArray(value)) {
-    const items = value.map((v) => tomlValue(v));
-    return `[${items.join(", ")}]`;
-  }
-  return String(value);
+function getStorageInfo() {
+  return {
+    backend: "file",
+    file: SECRETS_FILE,
+    permissions: "0600 (owner read/write only)"
+  };
 }
-function stringifyToml(config, prefix = "") {
-  const lines = [];
-  for (const [key, value] of Object.entries(config)) {
-    if (typeof value !== "object" || Array.isArray(value)) {
-      lines.push(`${key} = ${tomlValue(value)}`);
+
+// src/utils/agents.js
+var import_fs6 = __toESM(require("fs"), 1);
+var import_path6 = __toESM(require("path"), 1);
+var import_os2 = __toESM(require("os"), 1);
+var AGENT_CONFIGS2 = [
+  // Claude Desktop (Anthropic)
+  {
+    id: "claude-desktop",
+    name: "Claude Desktop",
+    key: "mcpServers",
+    paths: {
+      darwin: ["Library/Application Support/Claude/claude_desktop_config.json"],
+      win32: ["AppData/Roaming/Claude/claude_desktop_config.json"],
+      linux: [".config/claude/claude_desktop_config.json"]
     }
-  }
-  for (const [key, value] of Object.entries(config)) {
-    if (typeof value === "object" && !Array.isArray(value)) {
-      const tablePath = prefix ? `${prefix}.${key}` : key;
-      const hasSimpleValues = Object.values(value).some(
-        (v) => typeof v !== "object" || Array.isArray(v)
-      );
-      if (hasSimpleValues) {
-        lines.push("");
-        lines.push(`[${tablePath}]`);
-      }
-      const nested = stringifyToml(value, tablePath);
-      if (nested.trim()) {
-        lines.push(nested);
-      }
+  },
+  // Claude Code CLI (Anthropic)
+  {
+    id: "claude-code",
+    name: "Claude Code",
+    key: "mcpServers",
+    paths: {
+      darwin: [".claude.json"],
+      // User scope (all projects)
+      win32: [".claude.json"],
+      linux: [".claude.json"]
+    }
+  },
+  // Cursor (Anysphere)
+  {
+    id: "cursor",
+    name: "Cursor",
+    key: "mcpServers",
+    paths: {
+      darwin: [".cursor/mcp.json"],
+      win32: [".cursor/mcp.json"],
+      linux: [".cursor/mcp.json"]
+    }
+  },
+  // Windsurf (Codeium)
+  {
+    id: "windsurf",
+    name: "Windsurf",
+    key: "mcpServers",
+    paths: {
+      darwin: [".codeium/windsurf/mcp_config.json"],
+      win32: [".codeium/windsurf/mcp_config.json"],
+      linux: [".codeium/windsurf/mcp_config.json"]
+    }
+  },
+  // Cline (VS Code extension)
+  {
+    id: "cline",
+    name: "Cline",
+    key: "mcpServers",
+    paths: {
+      darwin: ["Documents/Cline/cline_mcp_settings.json"],
+      win32: ["Documents/Cline/cline_mcp_settings.json"],
+      linux: ["Documents/Cline/cline_mcp_settings.json"]
+    }
+  },
+  // Zed Editor
+  {
+    id: "zed",
+    name: "Zed",
+    key: "context_servers",
+    // Zed uses different key
+    paths: {
+      darwin: [".zed/settings.json"],
+      win32: [".config/zed/settings.json"],
+      linux: [".config/zed/settings.json"]
+    }
+  },
+  // VS Code / GitHub Copilot
+  {
+    id: "vscode",
+    name: "VS Code",
+    key: "servers",
+    paths: {
+      darwin: ["Library/Application Support/Code/User/mcp.json"],
+      win32: ["AppData/Roaming/Code/User/mcp.json"],
+      linux: [".config/Code/User/mcp.json"]
+    }
+  },
+  // Gemini CLI (Google)
+  {
+    id: "gemini",
+    name: "Gemini",
+    key: "mcpServers",
+    paths: {
+      darwin: [".gemini/settings.json"],
+      win32: [".gemini/settings.json"],
+      linux: [".gemini/settings.json"]
+    }
+  },
+  // Codex CLI (OpenAI)
+  {
+    id: "codex",
+    name: "Codex",
+    key: "mcpServers",
+    paths: {
+      darwin: [".codex/config.json", ".codex/settings.json"],
+      win32: [".codex/config.json", ".codex/settings.json"],
+      linux: [".codex/config.json", ".codex/settings.json"]
+    }
+  }
+];
+function getAgentConfigPaths(agentConfig) {
+  const home = import_os2.default.homedir();
+  const platform = process.platform;
+  const relativePaths = agentConfig.paths[platform] || agentConfig.paths.linux || [];
+  return relativePaths.map((p) => import_path6.default.join(home, p));
+}
+function findAgentConfig(agentConfig) {
+  const paths = getAgentConfigPaths(agentConfig);
+  for (const configPath of paths) {
+    if (import_fs6.default.existsSync(configPath)) {
+      return configPath;
     }
   }
-  return lines.join("\n");
+  return null;
 }
-async function readToml(filePath) {
+function readAgentMcpServers(agentConfig) {
+  const configPath = findAgentConfig(agentConfig);
+  if (!configPath) return [];
   try {
-    const content = await fs6.readFile(filePath, "utf-8");
-    return parseToml(content);
-  } catch {
-    return {};
+    const content = JSON.parse(import_fs6.default.readFileSync(configPath, "utf-8"));
+    const mcpServers = content[agentConfig.key] || {};
+    return Object.entries(mcpServers).map(([name, config]) => {
+      const command = config.command || config.path || config.command?.path;
+      return {
+        name,
+        agent: agentConfig.id,
+        agentName: agentConfig.name,
+        command: command || "unknown",
+        args: config.args,
+        cwd: config.cwd,
+        env: config.env ? Object.keys(config.env) : [],
+        // Just list env var names, not values
+        configFile: configPath
+      };
+    });
+  } catch (e) {
+    return [];
   }
 }
-async function writeToml(filePath, data) {
-  const dir = path6.dirname(filePath);
-  await fs6.mkdir(dir, { recursive: true });
-  await fs6.writeFile(filePath, stringifyToml(data), "utf-8");
-}
-function parseEnvFile(content) {
-  const env = {};
-  const lines = content.split("\n");
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) continue;
-    const eqIndex = trimmed.indexOf("=");
-    if (eqIndex === -1) continue;
-    const key = trimmed.slice(0, eqIndex).trim();
-    let value = trimmed.slice(eqIndex + 1).trim();
-    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-      value = value.slice(1, -1);
-    }
-    if (value) {
-      env[key] = value;
-    }
+function detectAllMcpServers() {
+  const servers = [];
+  for (const agentConfig of AGENT_CONFIGS2) {
+    const agentServers = readAgentMcpServers(agentConfig);
+    servers.push(...agentServers);
   }
-  return env;
+  return servers;
 }
-async function readStackEnv(installPath) {
-  const envPath = path6.join(installPath, ".env");
-  try {
-    const content = await fs6.readFile(envPath, "utf-8");
-    return parseEnvFile(content);
-  } catch {
-    return {};
-  }
+function getInstalledAgents() {
+  return AGENT_CONFIGS2.filter((agent) => findAgentConfig(agent) !== null).map((agent) => ({
+    id: agent.id,
+    name: agent.name,
+    configFile: findAgentConfig(agent)
+  }));
 }
-async function buildMcpConfig(stackId, installPath, manifest) {
-  let command;
-  let args = [];
-  const cwd = installPath;
-  const resolveRelativePath2 = (value) => {
-    if (!value || path6.isAbsolute(value)) return value;
-    const isPathLike = value.startsWith(".") || value.includes("/") || value.includes("\\");
-    return isPathLike ? path6.join(installPath, value) : value;
-  };
-  if (manifest.command) {
-    const cmdArray = Array.isArray(manifest.command) ? manifest.command : [manifest.command];
-    command = resolveRelativePath2(cmdArray[0]);
-    args = cmdArray.slice(1).map((arg) => resolveRelativePath2(arg));
-  } else if (manifest.mcp) {
-    command = resolveRelativePath2(manifest.mcp.command);
-    args = (manifest.mcp.args || []).map((arg) => resolveRelativePath2(arg));
-    if (manifest.mcp.entry) {
-      args = args.map(
-        (arg) => arg === manifest.mcp.entry ? path6.join(installPath, manifest.mcp.entry) : arg
-      );
+function getMcpServerSummary() {
+  const summary = {};
+  for (const agentConfig of AGENT_CONFIGS2) {
+    const configPath = findAgentConfig(agentConfig);
+    if (configPath) {
+      const servers = readAgentMcpServers(agentConfig);
+      summary[agentConfig.id] = {
+        name: agentConfig.name,
+        configFile: configPath,
+        serverCount: servers.length,
+        servers: servers.map((s) => s.name)
+      };
     }
-  } else {
-    return null;
   }
-  const optimized = await optimizeEntryPoint(installPath, command, args);
-  if (optimized) {
-    command = optimized.command;
-    args = optimized.args;
-  }
-  const env = await readStackEnv(installPath);
-  const config = {
-    command,
-    cwd
-  };
-  if (args.length > 0) {
-    config.args = args;
-  }
-  if (Object.keys(env).length > 0) {
-    config.env = env;
-  }
-  return config;
+  return summary;
 }
-async function optimizeEntryPoint(installPath, command, args) {
-  if (command !== "npx" || !args.includes("tsx")) {
-    return null;
-  }
-  const tsFileIndex = args.findIndex((arg) => arg.endsWith(".ts"));
-  if (tsFileIndex === -1) {
-    return null;
-  }
-  const tsFile = args[tsFileIndex];
-  const jsFile = tsFile.replace("/src/", "/dist/").replace(".ts", ".js");
-  const jsPath = path6.isAbsolute(jsFile) ? jsFile : path6.join(installPath, jsFile);
+
+// src/commands/install.js
+async function loadManifest(installPath) {
+  const manifestPath = path8.join(installPath, "manifest.json");
   try {
-    await fs6.access(jsPath);
-    return {
-      command: "node",
-      args: [jsPath]
-    };
+    const content = await fs8.readFile(manifestPath, "utf-8");
+    return JSON.parse(content);
   } catch {
     return null;
   }
 }
-async function registerMcpClaude(stackId, installPath, manifest) {
-  const configPath = AGENT_CONFIGS.claude;
+async function installDependencies(stackPath, manifest) {
+  const runtime = manifest?.runtime || "node";
   try {
-    const mcpConfig = await buildMcpConfig(stackId, installPath, manifest);
-    if (!mcpConfig) {
-      return { success: true, skipped: true };
-    }
-    mcpConfig.type = "stdio";
-    const settings = await readJson(configPath);
-    if (!settings.mcpServers) {
-      settings.mcpServers = {};
-    }
-    settings.mcpServers[stackId] = mcpConfig;
-    await writeJson(configPath, settings);
-    console.log(`  Registered MCP in Claude: ${stackId}`);
-    return { success: true };
-  } catch (error) {
-    console.error(`  Failed to register MCP in Claude: ${error.message}`);
-    return { success: false, error: error.message };
-  }
-}
-async function unregisterMcpClaude(stackId) {
-  const configPath = AGENT_CONFIGS.claude;
-  try {
-    const settings = await readJson(configPath);
-    if (!settings.mcpServers || !settings.mcpServers[stackId]) {
-      return { success: true, skipped: true };
-    }
-    delete settings.mcpServers[stackId];
-    await writeJson(configPath, settings);
-    console.log(`  Unregistered MCP from Claude: ${stackId}`);
-    return { success: true };
-  } catch (error) {
-    console.error(`  Failed to unregister MCP from Claude: ${error.message}`);
-    return { success: false, error: error.message };
-  }
-}
-async function registerMcpCodex(stackId, installPath, manifest) {
-  const configPath = AGENT_CONFIGS.codex;
-  try {
-    const mcpConfig = await buildMcpConfig(stackId, installPath, manifest);
-    if (!mcpConfig) {
-      return { success: true, skipped: true };
-    }
-    const config = await readToml(configPath);
-    if (!config.mcp_servers) {
-      config.mcp_servers = {};
-    }
-    config.mcp_servers[stackId] = mcpConfig;
-    await writeToml(configPath, config);
-    console.log(`  Registered MCP in Codex: ${stackId}`);
-    return { success: true };
-  } catch (error) {
-    console.error(`  Failed to register MCP in Codex: ${error.message}`);
-    return { success: false, error: error.message };
-  }
-}
-async function unregisterMcpCodex(stackId) {
-  const configPath = AGENT_CONFIGS.codex;
-  try {
-    const config = await readToml(configPath);
-    if (!config.mcp_servers || !config.mcp_servers[stackId]) {
-      return { success: true, skipped: true };
-    }
-    delete config.mcp_servers[stackId];
-    await writeToml(configPath, config);
-    console.log(`  Unregistered MCP from Codex: ${stackId}`);
-    return { success: true };
-  } catch (error) {
-    console.error(`  Failed to unregister MCP from Codex: ${error.message}`);
-    return { success: false, error: error.message };
-  }
-}
-async function registerMcpGemini(stackId, installPath, manifest) {
-  const configPath = AGENT_CONFIGS.gemini;
-  try {
-    const mcpConfig = await buildMcpConfig(stackId, installPath, manifest);
-    if (!mcpConfig) {
-      return { success: true, skipped: true };
-    }
-    const settings = await readJson(configPath);
-    if (!settings.mcpServers) {
-      settings.mcpServers = {};
-    }
-    settings.mcpServers[stackId] = mcpConfig;
-    await writeJson(configPath, settings);
-    console.log(`  Registered MCP in Gemini: ${stackId}`);
-    return { success: true };
-  } catch (error) {
-    console.error(`  Failed to register MCP in Gemini: ${error.message}`);
-    return { success: false, error: error.message };
-  }
-}
-async function unregisterMcpGemini(stackId) {
-  const configPath = AGENT_CONFIGS.gemini;
-  try {
-    const settings = await readJson(configPath);
-    if (!settings.mcpServers || !settings.mcpServers[stackId]) {
-      return { success: true, skipped: true };
+    if (runtime === "node") {
+      const packageJsonPath = path8.join(stackPath, "package.json");
+      try {
+        await fs8.access(packageJsonPath);
+      } catch {
+        return { installed: false, reason: "No package.json" };
+      }
+      const nodeModulesPath = path8.join(stackPath, "node_modules");
+      try {
+        await fs8.access(nodeModulesPath);
+        return { installed: false, reason: "Dependencies already installed" };
+      } catch {
+      }
+      console.log(`  Installing npm dependencies...`);
+      (0, import_child_process2.execSync)("npm install --production", {
+        cwd: stackPath,
+        stdio: "pipe"
+        // Suppress output
+      });
+      return { installed: true };
+    } else if (runtime === "python") {
+      const requirementsPath = path8.join(stackPath, "requirements.txt");
+      try {
+        await fs8.access(requirementsPath);
+      } catch {
+        return { installed: false, reason: "No requirements.txt" };
+      }
+      console.log(`  Installing pip dependencies...`);
+      (0, import_child_process2.execSync)("pip install -r requirements.txt", {
+        cwd: stackPath,
+        stdio: "pipe"
+      });
+      return { installed: true };
     }
-    delete settings.mcpServers[stackId];
-    await writeJson(configPath, settings);
-    console.log(`  Unregistered MCP from Gemini: ${stackId}`);
-    return { success: true };
+    return { installed: false, reason: `Unknown runtime: ${runtime}` };
   } catch (error) {
-    console.error(`  Failed to unregister MCP from Gemini: ${error.message}`);
-    return { success: false, error: error.message };
-  }
-}
-async function getInstalledAgents() {
-  const agentsDir = path6.join(HOME, ".rudi", "agents");
-  const installed = [];
-  for (const agent of ["claude", "codex", "gemini"]) {
-    const agentPath = path6.join(agentsDir, agent);
-    try {
-      await fs6.access(agentPath);
-      installed.push(agent);
-    } catch {
-    }
-  }
-  return installed;
-}
-async function registerMcpAll(stackId, installPath, manifest, targetAgents = null) {
-  const agents = targetAgents || await getInstalledAgents();
-  const results = {};
-  for (const agent of agents) {
-    switch (agent) {
-      case "claude":
-        results.claude = await registerMcpClaude(stackId, installPath, manifest);
-        break;
-      case "codex":
-        results.codex = await registerMcpCodex(stackId, installPath, manifest);
-        break;
-      case "gemini":
-        results.gemini = await registerMcpGemini(stackId, installPath, manifest);
-        break;
-    }
-  }
-  return results;
-}
-async function unregisterMcpAll(stackId, targetAgents = null) {
-  const agents = targetAgents || await getInstalledAgents();
-  const results = {};
-  for (const agent of agents) {
-    switch (agent) {
-      case "claude":
-        results.claude = await unregisterMcpClaude(stackId);
-        break;
-      case "codex":
-        results.codex = await unregisterMcpCodex(stackId);
-        break;
-      case "gemini":
-        results.gemini = await unregisterMcpGemini(stackId);
-        break;
-    }
-  }
-  return results;
-}
-
-// src/commands/install.js
-async function loadManifest(installPath) {
-  const manifestPath = path7.join(installPath, "manifest.json");
-  try {
-    const content = await fs7.readFile(manifestPath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return null;
+    return { installed: false, error: error.message };
   }
 }
 function getManifestSecrets(manifest) {
@@ -16370,67 +16352,56 @@ function getSecretName(secret) {
   if (typeof secret === "string") return secret;
   return secret.name || secret.key;
 }
-function getSecretDescription(secret) {
-  if (typeof secret !== "object" || !secret) return null;
-  return secret.description || secret.label || null;
-}
 function getSecretLink(secret) {
   if (typeof secret !== "object" || !secret) return null;
   return secret.link || secret.helpUrl || null;
 }
-function getSecretLabel(secret) {
-  if (typeof secret !== "object" || !secret) return null;
-  return secret.label || secret.name || secret.key || null;
-}
-async function createEnvFile(installPath, manifest) {
+async function checkSecrets(manifest) {
   const secrets = getManifestSecrets(manifest);
-  if (!secrets.length) return null;
-  const envPath = path7.join(installPath, ".env");
-  try {
-    await fs7.access(envPath);
-    console.log(`  .env file already exists, preserving existing secrets`);
-    return envPath;
-  } catch {
-  }
-  const lines = [];
-  lines.push("# Environment variables for this stack");
-  lines.push("# Fill in your API keys below");
-  lines.push("");
+  const found = [];
+  const missing = [];
   for (const secret of secrets) {
     const key = getSecretName(secret);
-    const description = getSecretDescription(secret);
-    const helpUrl = getSecretLink(secret);
-    if (description) {
-      lines.push(`# ${description}`);
+    const isRequired = typeof secret === "object" ? secret.required !== false : true;
+    const exists = await hasSecret(key);
+    if (exists) {
+      found.push(key);
+    } else if (isRequired) {
+      missing.push(key);
     }
-    if (helpUrl) {
-      lines.push(`# Get yours: ${helpUrl}`);
+  }
+  return { found, missing };
+}
+async function parseEnvExample(installPath) {
+  const examplePath = path8.join(installPath, ".env.example");
+  try {
+    const content = await fs8.readFile(examplePath, "utf-8");
+    const keys = [];
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const match = trimmed.match(/^([A-Z][A-Z0-9_]*)=/);
+      if (match) {
+        keys.push(match[1]);
+      }
     }
-    lines.push(`${key}=`);
-    lines.push("");
+    return keys;
+  } catch {
+    return [];
   }
-  await fs7.writeFile(envPath, lines.join("\n"), "utf-8");
-  return envPath;
 }
 async function cmdInstall(args, flags) {
   const pkgId = args[0];
   if (!pkgId) {
     console.error("Usage: rudi install <package>");
-    console.error("       rudi install <package> --agent=claude        (register to Claude only)");
-    console.error("       rudi install <package> --agent=claude,codex  (register to specific agents)");
-    console.error("Example: rudi install pdf-creator");
+    console.error("Example: rudi install slack");
+    console.error("");
+    console.error("After installing, run:");
+    console.error("  rudi secrets set <KEY>    # Configure required secrets");
+    console.error("  rudi integrate all        # Wire up your agents");
     process.exit(1);
   }
   const force = flags.force || false;
-  let targetAgents = null;
-  if (flags.agent) {
-    const validAgents = ["claude", "codex", "gemini"];
-    targetAgents = flags.agent.split(",").map((a) => a.trim()).filter((a) => validAgents.includes(a));
-    if (targetAgents.length === 0) {
-      console.error(`Invalid --agent value. Valid agents: ${validAgents.join(", ")}`);
-      process.exit(1);
-    }
-  }
   console.log(`Resolving ${pkgId}...`);
   try {
     const resolved = await resolvePackage(pkgId);
@@ -16453,27 +16424,41 @@ Dependencies:`);
         console.log(`  - ${dep.id} ${status}`);
       }
     }
-    if (resolved.requires?.secrets?.length > 0) {
-      console.log(`
-Required secrets:`);
-      for (const secret of resolved.requires.secrets) {
-        const name = typeof secret === "string" ? secret : secret.name;
-        console.log(`  - ${name}`);
-      }
-    }
+    console.log(`
+Dependency check:`);
     const depCheck = checkAllDependencies(resolved);
     if (depCheck.results.length > 0) {
-      console.log(`
-System dependencies:`);
       for (const line of formatDependencyResults(depCheck.results)) {
         console.log(line);
       }
-      if (!depCheck.satisfied && !force) {
-        console.error(`
-\u2717 Missing required dependencies. Install them first or use --force to skip.`);
-        process.exit(1);
+    }
+    const secretsCheck = { found: [], missing: [] };
+    if (resolved.requires?.secrets?.length > 0) {
+      for (const secret of resolved.requires.secrets) {
+        const name = typeof secret === "string" ? secret : secret.name;
+        const isRequired = typeof secret === "object" ? secret.required !== false : true;
+        const exists = await hasSecret(name);
+        if (exists) {
+          secretsCheck.found.push(name);
+          console.log(`  \u2713 ${name} (from secrets store)`);
+        } else if (isRequired) {
+          secretsCheck.missing.push(name);
+          console.log(`  \u25CB ${name} - not configured`);
+        } else {
+          console.log(`  \u25CB ${name} (optional)`);
+        }
       }
     }
+    if (!depCheck.satisfied && !force) {
+      console.error(`
+\u2717 Missing required dependencies. Install them first:`);
+      for (const r of depCheck.results.filter((r2) => !r2.available)) {
+        console.error(`    rudi install ${r.type}:${r.name}`);
+      }
+      console.error(`
+Or use --force to install anyway.`);
+      process.exit(1);
+    }
     console.log(`
 Installing...`);
     const result = await installPackage(pkgId, {
@@ -16498,29 +16483,70 @@ Installing...`);
       if (resolved.kind === "stack") {
         const manifest = await loadManifest(result.path);
         if (manifest) {
-          const stackId = resolved.id.replace(/^stack:/, "");
-          const envPath = await createEnvFile(result.path, manifest);
-          await registerMcpAll(stackId, result.path, manifest, targetAgents);
-          const secrets = getManifestSecrets(manifest);
-          if (secrets.length > 0) {
-            console.log(`
-\u26A0\uFE0F  This stack requires configuration:`);
-            console.log(`  Edit: ${envPath}`);
+          const depResult = await installDependencies(result.path, manifest);
+          if (depResult.installed) {
+            console.log(`  \u2713 Dependencies installed`);
+          } else if (depResult.error) {
+            console.log(`  \u26A0 Failed to install dependencies: ${depResult.error}`);
+          }
+          const { found, missing } = await checkSecrets(manifest);
+          const envExampleKeys = await parseEnvExample(result.path);
+          for (const key of envExampleKeys) {
+            if (!found.includes(key) && !missing.includes(key)) {
+              const exists = await hasSecret(key);
+              if (!exists) {
+                missing.push(key);
+              } else {
+                found.push(key);
+              }
+            }
+          }
+          if (missing.length > 0) {
+            for (const key of missing) {
+              const existing = await getSecret(key);
+              if (existing === null) {
+                await setSecret(key, "");
+              }
+            }
+          }
+          console.log(`
+Next steps:`);
+          if (missing.length > 0) {
             console.log(`
-  Required secrets:`);
-            for (const secret of secrets) {
-              const key = getSecretName(secret);
-              const label = getSecretLabel(secret) || key;
-              console.log(`    - ${label} (${key})`);
+  1. Configure secrets (${missing.length} pending):`);
+            for (const key of missing) {
+              const secret = getManifestSecrets(manifest).find(
+                (s) => (typeof s === "string" ? s : s.name) === key
+              );
+              const helpUrl = getSecretLink(secret);
+              console.log(`     rudi secrets set ${key} "<your-value>"`);
+              if (helpUrl) {
+                console.log(`     # Get yours: ${helpUrl}`);
+              }
             }
             console.log(`
-  After adding secrets, run: rudi run ${pkgId}`);
-            return;
+     Check status: rudi secrets list`);
+          } else if (found.length > 0) {
+            console.log(`
+  1. Secrets: \u2713 ${found.length} configured`);
+          } else {
+            console.log(`
+  1. Secrets: \u2713 None required`);
+          }
+          const agents = getInstalledAgents();
+          if (agents.length > 0) {
+            console.log(`
+  2. Wire up your agents:`);
+            console.log(`     rudi integrate all`);
+            console.log(`     # Detected: ${agents.map((a) => a.name).join(", ")}`);
           }
+          console.log(`
+  3. Restart your agent to use the stack`);
+          return;
         }
       }
       console.log(`
-Run with: rudi run ${pkgId}`);
+\u2713 Installed successfully.`);
     } else {
       console.error(`
 \u2717 Installation failed: ${result.error}`);
@@ -16536,38 +16562,28 @@ Run with: rudi run ${pkgId}`);
 }
 
 // ../packages/runner/src/spawn.js
-var import_child_process2 = require("child_process");
-var import_path7 = __toESM(require("path"), 1);
-var import_fs7 = __toESM(require("fs"), 1);
+var import_child_process3 = require("child_process");
+var import_path8 = __toESM(require("path"), 1);
+var import_fs8 = __toESM(require("fs"), 1);
 
 // ../packages/runner/src/secrets.js
-var import_fs6 = __toESM(require("fs"), 1);
-var import_path6 = __toESM(require("path"), 1);
-var import_os2 = __toESM(require("os"), 1);
-var SECRETS_PATH = import_path6.default.join(import_os2.default.homedir(), ".rudi", "secrets.json");
-function loadSecrets() {
-  if (!import_fs6.default.existsSync(SECRETS_PATH)) {
+var import_fs7 = __toESM(require("fs"), 1);
+var import_path7 = __toESM(require("path"), 1);
+var import_os3 = __toESM(require("os"), 1);
+var SECRETS_PATH = import_path7.default.join(import_os3.default.homedir(), ".rudi", "secrets.json");
+function loadSecrets2() {
+  if (!import_fs7.default.existsSync(SECRETS_PATH)) {
     return {};
   }
   try {
-    const content = import_fs6.default.readFileSync(SECRETS_PATH, "utf-8");
+    const content = import_fs7.default.readFileSync(SECRETS_PATH, "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
   }
 }
-function saveSecrets(secrets) {
-  const dir = import_path6.default.dirname(SECRETS_PATH);
-  if (!import_fs6.default.existsSync(dir)) {
-    import_fs6.default.mkdirSync(dir, { recursive: true });
-  }
-  import_fs6.default.writeFileSync(SECRETS_PATH, JSON.stringify(secrets, null, 2), {
-    mode: 384
-    // Read/write only for owner
-  });
-}
 async function getSecrets(required) {
-  const allSecrets = loadSecrets();
+  const allSecrets = loadSecrets2();
   const result = {};
   for (const req of required) {
     const name = typeof req === "string" ? req : req.name;
@@ -16580,8 +16596,8 @@ async function getSecrets(required) {
   }
   return result;
 }
-function checkSecrets(required) {
-  const allSecrets = loadSecrets();
+function checkSecrets2(required) {
+  const allSecrets = loadSecrets2();
   const missing = [];
   for (const req of required) {
     const name = typeof req === "string" ? req : req.name;
@@ -16595,34 +16611,12 @@ function checkSecrets(required) {
     missing
   };
 }
-function setSecret(name, value) {
-  const secrets = loadSecrets();
-  secrets[name] = value;
-  saveSecrets(secrets);
-}
-function removeSecret(name) {
-  const secrets = loadSecrets();
-  delete secrets[name];
-  saveSecrets(secrets);
-}
 function listSecretNames() {
-  const secrets = loadSecrets();
+  const secrets = loadSecrets2();
   return Object.keys(secrets);
 }
-function getMaskedSecrets() {
-  const secrets = loadSecrets();
-  const masked = {};
-  for (const [name, value] of Object.entries(secrets)) {
-    if (typeof value === "string" && value.length > 8) {
-      masked[name] = value.slice(0, 4) + "..." + value.slice(-4);
-    } else {
-      masked[name] = "***";
-    }
-  }
-  return masked;
-}
 function redactSecrets(text, secrets) {
-  const allSecrets = secrets || loadSecrets();
+  const allSecrets = secrets || loadSecrets2();
   let result = text;
   for (const value of Object.values(allSecrets)) {
     if (typeof value === "string" && value.length > 3) {
@@ -16632,27 +16626,18 @@ function redactSecrets(text, secrets) {
   }
   return result;
 }
-function exportToEnv() {
-  const secrets = loadSecrets();
-  const lines = [];
-  for (const [name, value] of Object.entries(secrets)) {
-    const escaped = String(value).replace(/'/g, "'\\''");
-    lines.push(`export ${name}='${escaped}'`);
-  }
-  return lines.join("\n");
-}
 
 // ../packages/runner/src/spawn.js
 async function runStack(id, options = {}) {
   const { inputs = {}, cwd, env = {}, onStdout, onStderr, onExit, signal } = options;
   const startTime = Date.now();
   const packagePath = getPackagePath(id);
-  const manifestPath = import_path7.default.join(packagePath, "manifest.json");
-  const { default: fs20 } = await import("fs");
-  if (!fs20.existsSync(manifestPath)) {
+  const manifestPath = import_path8.default.join(packagePath, "manifest.json");
+  const { default: fs26 } = await import("fs");
+  if (!fs26.existsSync(manifestPath)) {
     throw new Error(`Stack manifest not found: ${id}`);
   }
-  const manifest = JSON.parse(fs20.readFileSync(manifestPath, "utf-8"));
+  const manifest = JSON.parse(fs26.readFileSync(manifestPath, "utf-8"));
   const { command, args } = resolveCommandFromManifest(manifest, packagePath);
   const secrets = await getSecrets(manifest.requires?.secrets || []);
   const runEnv = {
@@ -16663,7 +16648,7 @@ async function runStack(id, options = {}) {
     RUDI_PACKAGE_ID: id,
     RUDI_PACKAGE_PATH: packagePath
   };
-  const proc = (0, import_child_process2.spawn)(command, args, {
+  const proc = (0, import_child_process3.spawn)(command, args, {
     cwd: cwd || packagePath,
     env: runEnv,
     stdio: ["pipe", "pipe", "pipe"],
@@ -16708,15 +16693,15 @@ async function runStack(id, options = {}) {
 }
 function getCommand(runtime) {
   const runtimeName = runtime.replace("runtime:", "");
-  const runtimePath = import_path7.default.join(PATHS.runtimes, runtimeName);
+  const runtimePath = import_path8.default.join(PATHS.runtimes, runtimeName);
   const binaryPaths = [
-    import_path7.default.join(runtimePath, "bin", runtimeName === "python" ? "python3" : runtimeName),
-    import_path7.default.join(runtimePath, "bin", runtimeName),
-    import_path7.default.join(runtimePath, runtimeName === "python" ? "python3" : runtimeName),
-    import_path7.default.join(runtimePath, runtimeName)
+    import_path8.default.join(runtimePath, "bin", runtimeName === "python" ? "python3" : runtimeName),
+    import_path8.default.join(runtimePath, "bin", runtimeName),
+    import_path8.default.join(runtimePath, runtimeName === "python" ? "python3" : runtimeName),
+    import_path8.default.join(runtimePath, runtimeName)
   ];
   for (const binPath of binaryPaths) {
-    if (import_fs7.default.existsSync(binPath)) {
+    if (import_fs8.default.existsSync(binPath)) {
       return binPath;
     }
   }
@@ -16740,7 +16725,7 @@ function resolveCommandFromManifest(manifest, packagePath) {
     return { command: command2, args };
   }
   const entry = manifest.entry || "index.js";
-  const entryPath = import_path7.default.join(packagePath, entry);
+  const entryPath = import_path8.default.join(packagePath, entry);
   const runtime = manifest.runtime || "runtime:node";
   const command = getCommand(runtime);
   return { command, args: [entryPath] };
@@ -16749,21 +16734,21 @@ function resolveRelativePath(value, basePath) {
   if (typeof value !== "string" || value.startsWith("-")) {
     return value;
   }
-  if (import_path7.default.isAbsolute(value)) {
+  if (import_path8.default.isAbsolute(value)) {
     return value;
   }
   if (value.includes("/") || value.startsWith(".")) {
-    return import_path7.default.join(basePath, value);
+    return import_path8.default.join(basePath, value);
   }
   return value;
 }
 
 // ../packages/manifest/src/stack.js
 var import_yaml2 = __toESM(require_dist(), 1);
-var import_fs8 = __toESM(require("fs"), 1);
-var import_path8 = __toESM(require("path"), 1);
+var import_fs9 = __toESM(require("fs"), 1);
+var import_path9 = __toESM(require("path"), 1);
 function parseStackManifest(filePath) {
-  const content = import_fs8.default.readFileSync(filePath, "utf-8");
+  const content = import_fs9.default.readFileSync(filePath, "utf-8");
   return parseStackYaml(content, filePath);
 }
 function parseStackYaml(content, source = "stack.yaml") {
@@ -16881,8 +16866,8 @@ function validateStackManifest(manifest, source) {
 function findStackManifest(dir) {
   const candidates = ["stack.yaml", "stack.yml", "manifest.yaml", "manifest.yml"];
   for (const filename of candidates) {
-    const filePath = import_path8.default.join(dir, filename);
-    if (import_fs8.default.existsSync(filePath)) {
+    const filePath = import_path9.default.join(dir, filename);
+    if (import_fs9.default.existsSync(filePath)) {
       return filePath;
     }
   }
@@ -17037,8 +17022,8 @@ var validatePromptInternal = ajv.compile(promptSchema);
 var validateRuntimeInternal = ajv.compile(runtimeSchema);
 
 // src/commands/run.js
-var import_fs9 = __toESM(require("fs"), 1);
-var import_path9 = __toESM(require("path"), 1);
+var import_fs10 = __toESM(require("fs"), 1);
+var import_path10 = __toESM(require("path"), 1);
 async function cmdRun(args, flags) {
   const stackId = args[0];
   if (!stackId) {
@@ -17059,9 +17044,9 @@ async function cmdRun(args, flags) {
     if (manifestPath) {
       manifest = parseStackManifest(manifestPath);
     } else {
-      const jsonPath = import_path9.default.join(packagePath, "manifest.json");
-      if (import_fs9.default.existsSync(jsonPath)) {
-        manifest = JSON.parse(import_fs9.default.readFileSync(jsonPath, "utf-8"));
+      const jsonPath = import_path10.default.join(packagePath, "manifest.json");
+      if (import_fs10.default.existsSync(jsonPath)) {
+        manifest = JSON.parse(import_fs10.default.readFileSync(jsonPath, "utf-8"));
       }
     }
   } catch (error) {
@@ -17075,7 +17060,7 @@ async function cmdRun(args, flags) {
   console.log(`Running: ${manifest.name || stackId}`);
   const requiredSecrets = manifest.requires?.secrets || [];
   if (requiredSecrets.length > 0) {
-    const { satisfied, missing } = checkSecrets(requiredSecrets);
+    const { satisfied, missing } = checkSecrets2(requiredSecrets);
     if (!satisfied) {
       console.error(`
 Missing required secrets:`);
@@ -17152,6 +17137,66 @@ async function cmdList(args, flags) {
       process.exit(1);
     }
   }
+  if (flags.detected && kind === "agent") {
+    const installedAgents = getInstalledAgents();
+    const summary = getMcpServerSummary();
+    if (flags.json) {
+      console.log(JSON.stringify({ installedAgents, summary }, null, 2));
+      return;
+    }
+    console.log(`
+DETECTED AI AGENTS (${installedAgents.length}/${AGENT_CONFIGS2.length}):`);
+    console.log("\u2500".repeat(50));
+    for (const agent of AGENT_CONFIGS2) {
+      const installed = installedAgents.find((a) => a.id === agent.id);
+      const serverCount = summary[agent.id]?.serverCount || 0;
+      if (installed) {
+        console.log(`  \u2713 ${agent.name}`);
+        console.log(`    ${serverCount} MCP server(s)`);
+        console.log(`    ${installed.configFile}`);
+      } else {
+        console.log(`  \u25CB ${agent.name} (not installed)`);
+      }
+    }
+    console.log(`
+Installed: ${installedAgents.length} of ${AGENT_CONFIGS2.length} agents`);
+    return;
+  }
+  if (flags.detected && kind === "stack") {
+    const servers = detectAllMcpServers();
+    if (flags.json) {
+      console.log(JSON.stringify(servers, null, 2));
+      return;
+    }
+    if (servers.length === 0) {
+      console.log("No MCP servers detected in agent configs.");
+      console.log("\nChecked these agents:");
+      for (const agent of AGENT_CONFIGS2) {
+        console.log(`  - ${agent.name}`);
+      }
+      return;
+    }
+    const byAgent = {};
+    for (const server of servers) {
+      if (!byAgent[server.agent]) byAgent[server.agent] = [];
+      byAgent[server.agent].push(server);
+    }
+    console.log(`
+DETECTED MCP SERVERS (${servers.length}):`);
+    console.log("\u2500".repeat(50));
+    for (const [agentId, agentServers] of Object.entries(byAgent)) {
+      const agentName = agentServers[0]?.agentName || agentId;
+      console.log(`
+  ${agentName.toUpperCase()} (${agentServers.length}):`);
+      for (const server of agentServers) {
+        console.log(`    \u{1F4E6} ${server.name}`);
+        console.log(`       ${server.command} ${server.cwd ? `(${server.cwd})` : ""}`);
+      }
+    }
+    console.log(`
+Total: ${servers.length} MCP server(s) configured`);
+    return;
+  }
   try {
     let packages = await listInstalled(kind);
     const categoryFilter = flags.category;
@@ -17181,68 +17226,267 @@ Install with: rudi install <package>`);
         if (!byCategory[cat]) byCategory[cat] = [];
         byCategory[cat].push(pkg);
       }
-      console.log(`
-PROMPTS (${packages.length}):`);
-      console.log("\u2500".repeat(50));
-      for (const [category, prompts] of Object.entries(byCategory).sort()) {
-        console.log(`
-  ${category.toUpperCase()} (${prompts.length}):`);
-        for (const pkg of prompts) {
-          const icon = pkg.icon ? `${pkg.icon} ` : "";
-          console.log(`    ${icon}${pkg.id || `prompt:${pkg.name}`}`);
-          if (pkg.description) {
-            console.log(`      ${pkg.description}`);
-          }
-          if (pkg.tags && pkg.tags.length > 0) {
-            console.log(`      Tags: ${pkg.tags.join(", ")}`);
-          }
-        }
+      console.log(`
+PROMPTS (${packages.length}):`);
+      console.log("\u2500".repeat(50));
+      for (const [category, prompts] of Object.entries(byCategory).sort()) {
+        console.log(`
+  ${category.toUpperCase()} (${prompts.length}):`);
+        for (const pkg of prompts) {
+          const icon = pkg.icon ? `${pkg.icon} ` : "";
+          console.log(`    ${icon}${pkg.id || `prompt:${pkg.name}`}`);
+          if (pkg.description) {
+            console.log(`      ${pkg.description}`);
+          }
+          if (pkg.tags && pkg.tags.length > 0) {
+            console.log(`      Tags: ${pkg.tags.join(", ")}`);
+          }
+        }
+      }
+      console.log(`
+Total: ${packages.length} prompt(s)`);
+      console.log(`
+Filter by category: rudi list prompts --category=coding`);
+      return;
+    }
+    const grouped = {
+      stack: packages.filter((p) => p.kind === "stack"),
+      prompt: packages.filter((p) => p.kind === "prompt"),
+      runtime: packages.filter((p) => p.kind === "runtime"),
+      binary: packages.filter((p) => p.kind === "binary"),
+      agent: packages.filter((p) => p.kind === "agent")
+    };
+    let total = 0;
+    for (const [pkgKind, pkgs] of Object.entries(grouped)) {
+      if (pkgs.length === 0) continue;
+      if (kind && kind !== pkgKind) continue;
+      console.log(`
+${headingForKind2(pkgKind)} (${pkgs.length}):`);
+      console.log("\u2500".repeat(50));
+      for (const pkg of pkgs) {
+        const icon = pkg.icon ? `${pkg.icon} ` : "";
+        console.log(`  ${icon}${pkg.id || `${pkgKind}:${pkg.name}`}`);
+        console.log(`    Version: ${pkg.version || "unknown"}`);
+        if (pkg.description) {
+          console.log(`    ${pkg.description}`);
+        }
+        if (pkg.category) {
+          console.log(`    Category: ${pkg.category}`);
+        }
+        if (pkg.tags && pkg.tags.length > 0) {
+          console.log(`    Tags: ${pkg.tags.join(", ")}`);
+        }
+        if (pkg.installedAt) {
+          console.log(`    Installed: ${new Date(pkg.installedAt).toLocaleDateString()}`);
+        }
+        total++;
+      }
+    }
+    console.log(`
+Total: ${total} package(s)`);
+  } catch (error) {
+    console.error(`Failed to list packages: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+// src/utils/mcp-registry.js
+var fs13 = __toESM(require("fs/promises"), 1);
+var path13 = __toESM(require("path"), 1);
+var os4 = __toESM(require("os"), 1);
+var HOME = os4.homedir();
+async function readJson(filePath) {
+  try {
+    const content = await fs13.readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+async function writeJson(filePath, data) {
+  const dir = path13.dirname(filePath);
+  await fs13.mkdir(dir, { recursive: true });
+  await fs13.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+}
+function parseTomlValue(value) {
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  if (value.startsWith("[") && value.endsWith("]")) {
+    const inner = value.slice(1, -1).trim();
+    if (!inner) return [];
+    const items = [];
+    let current = "";
+    let inQuote = false;
+    let quoteChar = "";
+    for (const char of inner) {
+      if ((char === '"' || char === "'") && !inQuote) {
+        inQuote = true;
+        quoteChar = char;
+      } else if (char === quoteChar && inQuote) {
+        inQuote = false;
+        items.push(current);
+        current = "";
+      } else if (char === "," && !inQuote) {
+      } else if (inQuote) {
+        current += char;
+      }
+    }
+    return items;
+  }
+  if (value === "true") return true;
+  if (value === "false") return false;
+  const num = Number(value);
+  if (!isNaN(num)) return num;
+  return value;
+}
+function parseToml(content) {
+  const result = {};
+  const lines = content.split("\n");
+  let currentTable = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const tableMatch = trimmed.match(/^\[([^\]]+)\]$/);
+    if (tableMatch) {
+      currentTable = tableMatch[1].split(".");
+      let obj = result;
+      for (const key of currentTable) {
+        obj[key] = obj[key] || {};
+        obj = obj[key];
+      }
+      continue;
+    }
+    const kvMatch = trimmed.match(/^([^=]+)=(.*)$/);
+    if (kvMatch) {
+      const key = kvMatch[1].trim();
+      let value = kvMatch[2].trim();
+      const parsed = parseTomlValue(value);
+      let obj = result;
+      for (const tableKey of currentTable) {
+        obj = obj[tableKey];
+      }
+      obj[key] = parsed;
+    }
+  }
+  return result;
+}
+function tomlValue(value) {
+  if (typeof value === "string") {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (typeof value === "number") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    const items = value.map((v) => tomlValue(v));
+    return `[${items.join(", ")}]`;
+  }
+  return String(value);
+}
+function stringifyToml(config, prefix = "") {
+  const lines = [];
+  for (const [key, value] of Object.entries(config)) {
+    if (typeof value !== "object" || Array.isArray(value)) {
+      lines.push(`${key} = ${tomlValue(value)}`);
+    }
+  }
+  for (const [key, value] of Object.entries(config)) {
+    if (typeof value === "object" && !Array.isArray(value)) {
+      const tablePath = prefix ? `${prefix}.${key}` : key;
+      const hasSimpleValues = Object.values(value).some(
+        (v) => typeof v !== "object" || Array.isArray(v)
+      );
+      if (hasSimpleValues) {
+        lines.push("");
+        lines.push(`[${tablePath}]`);
+      }
+      const nested = stringifyToml(value, tablePath);
+      if (nested.trim()) {
+        lines.push(nested);
       }
-      console.log(`
-Total: ${packages.length} prompt(s)`);
-      console.log(`
-Filter by category: rudi list prompts --category=coding`);
-      return;
     }
-    const grouped = {
-      stack: packages.filter((p) => p.kind === "stack"),
-      prompt: packages.filter((p) => p.kind === "prompt"),
-      runtime: packages.filter((p) => p.kind === "runtime"),
-      binary: packages.filter((p) => p.kind === "binary"),
-      agent: packages.filter((p) => p.kind === "agent")
-    };
-    let total = 0;
-    for (const [pkgKind, pkgs] of Object.entries(grouped)) {
-      if (pkgs.length === 0) continue;
-      if (kind && kind !== pkgKind) continue;
-      console.log(`
-${headingForKind2(pkgKind)} (${pkgs.length}):`);
-      console.log("\u2500".repeat(50));
-      for (const pkg of pkgs) {
-        const icon = pkg.icon ? `${pkg.icon} ` : "";
-        console.log(`  ${icon}${pkg.id || `${pkgKind}:${pkg.name}`}`);
-        console.log(`    Version: ${pkg.version || "unknown"}`);
-        if (pkg.description) {
-          console.log(`    ${pkg.description}`);
-        }
-        if (pkg.category) {
-          console.log(`    Category: ${pkg.category}`);
-        }
-        if (pkg.tags && pkg.tags.length > 0) {
-          console.log(`    Tags: ${pkg.tags.join(", ")}`);
-        }
-        if (pkg.installedAt) {
-          console.log(`    Installed: ${new Date(pkg.installedAt).toLocaleDateString()}`);
-        }
-        total++;
-      }
+  }
+  return lines.join("\n");
+}
+async function readToml(filePath) {
+  try {
+    const content = await fs13.readFile(filePath, "utf-8");
+    return parseToml(content);
+  } catch {
+    return {};
+  }
+}
+async function writeToml(filePath, data) {
+  const dir = path13.dirname(filePath);
+  await fs13.mkdir(dir, { recursive: true });
+  await fs13.writeFile(filePath, stringifyToml(data), "utf-8");
+}
+async function unregisterMcpCodex(stackId) {
+  const configPath = AGENT_CONFIGS.codex;
+  try {
+    const config = await readToml(configPath);
+    if (!config.mcp_servers || !config.mcp_servers[stackId]) {
+      return { success: true, skipped: true };
     }
-    console.log(`
-Total: ${total} package(s)`);
+    delete config.mcp_servers[stackId];
+    await writeToml(configPath, config);
+    console.log(`  Unregistered MCP from Codex: ${stackId}`);
+    return { success: true };
   } catch (error) {
-    console.error(`Failed to list packages: ${error.message}`);
-    process.exit(1);
+    console.error(`  Failed to unregister MCP from Codex: ${error.message}`);
+    return { success: false, error: error.message };
+  }
+}
+function getInstalledAgentIds() {
+  return getInstalledAgents().map((a) => a.id);
+}
+async function unregisterMcpGeneric(agentId, stackId) {
+  const agentConfig = AGENT_CONFIGS2.find((a) => a.id === agentId);
+  if (!agentConfig) {
+    return { success: false, error: `Unknown agent: ${agentId}` };
+  }
+  const configPath = findAgentConfig(agentConfig);
+  if (!configPath) {
+    return { success: true, skipped: true, reason: "Agent not installed" };
+  }
+  if (agentId === "codex") {
+    return unregisterMcpCodex(stackId);
+  }
+  try {
+    const settings = await readJson(configPath);
+    const key = agentConfig.key;
+    if (!settings[key] || !settings[key][stackId]) {
+      return { success: true, skipped: true, reason: "Server not found" };
+    }
+    delete settings[key][stackId];
+    await writeJson(configPath, settings);
+    console.log(`  Unregistered MCP from ${agentConfig.name}: ${stackId}`);
+    return { success: true, configPath };
+  } catch (error) {
+    console.error(`  Failed to unregister MCP from ${agentConfig.name}: ${error.message}`);
+    return { success: false, error: error.message };
+  }
+}
+async function unregisterMcpAll(stackId, targetAgents = null) {
+  let agentIds = getInstalledAgentIds();
+  if (targetAgents && targetAgents.length > 0) {
+    const idMap = {
+      "claude": "claude-code",
+      "codex": "codex",
+      "gemini": "gemini"
+    };
+    const targetIds = targetAgents.map((a) => idMap[a] || a);
+    agentIds = agentIds.filter((id) => targetIds.includes(id));
+  }
+  const results = {};
+  for (const agentId of agentIds) {
+    results[agentId] = await unregisterMcpGeneric(agentId, stackId);
   }
+  return results;
 }
 
 // src/commands/remove.js
@@ -17381,89 +17625,136 @@ async function cmdSecrets(args, flags) {
     case "set":
       await secretsSet(args.slice(1), flags);
       break;
+    case "get":
+      await secretsGet(args.slice(1), flags);
+      break;
     case "list":
     case "ls":
-      secretsList(flags);
+      await secretsList(flags);
       break;
     case "remove":
     case "rm":
     case "delete":
-      secretsRemove(args.slice(1), flags);
+      await secretsRemove(args.slice(1), flags);
       break;
-    case "export":
-      secretsExport(flags);
+    case "info":
+      secretsInfo();
       break;
     default:
       console.log(`
-rudi secrets - Manage secrets
+rudi secrets - Manage secrets (stored in ${getStorageInfo().backend})
 
 COMMANDS
-  set <name>       Set a secret (prompts for value)
+  set <name>       Set a secret (prompts for value securely)
+  get <name>       Get a secret value (for scripts)
   list             List configured secrets (values masked)
   remove <name>    Remove a secret
-  export           Export as environment variables
+  info             Show storage backend info
 
 EXAMPLES
-  rudi secrets set VERCEL_TOKEN
+  rudi secrets set SLACK_BOT_TOKEN
   rudi secrets list
   rudi secrets remove GITHUB_TOKEN
+
+SECURITY
+  Secrets are stored in macOS Keychain when available.
+  Fallback uses encrypted JSON at ~/.rudi/secrets.json
 `);
   }
 }
 async function secretsSet(args, flags) {
   const name = args[0];
+  const valueArg = args[1];
   if (!name) {
-    console.error("Usage: rudi secrets set <name>");
-    console.error("Example: rudi secrets set VERCEL_TOKEN");
+    console.error("Usage: rudi secrets set <name> [value]");
+    console.error("");
+    console.error("Examples:");
+    console.error("  rudi secrets set SLACK_BOT_TOKEN              # Interactive prompt");
+    console.error('  rudi secrets set SLACK_BOT_TOKEN "xoxb-..."   # Direct value');
     process.exit(1);
   }
   if (!/^[A-Z][A-Z0-9_]*$/.test(name)) {
     console.error("Secret name should be UPPER_SNAKE_CASE");
-    console.error("Example: VERCEL_TOKEN, GITHUB_API_KEY");
+    console.error("Example: SLACK_BOT_TOKEN, GITHUB_API_KEY");
     process.exit(1);
   }
-  const existing = loadSecrets();
-  if (existing[name] && !flags.force) {
+  const exists = await hasSecret(name);
+  if (exists && !flags.force) {
     console.log(`Secret ${name} already exists.`);
     console.log("Use --force to overwrite.");
     process.exit(0);
   }
-  const value = await promptSecret(`Enter value for ${name}: `);
+  let value = valueArg;
+  if (!value) {
+    if (process.stdin.isTTY) {
+      value = await promptSecret(`Enter value for ${name}: `);
+    } else {
+      console.error("No value provided.");
+      console.error("Usage: rudi secrets set <name> <value>");
+      process.exit(1);
+    }
+  }
   if (!value) {
     console.error("No value provided");
     process.exit(1);
   }
-  setSecret(name, value);
-  console.log(`\u2713 Secret ${name} saved`);
+  await setSecret(name, value);
+  const info = getStorageInfo();
+  console.log(`\u2713 Secret ${name} saved (${info.backend})`);
+}
+async function secretsGet(args, flags) {
+  const name = args[0];
+  if (!name) {
+    console.error("Usage: rudi secrets get <name>");
+    process.exit(1);
+  }
+  const value = await getSecret(name);
+  if (value) {
+    process.stdout.write(value);
+  } else {
+    process.exit(1);
+  }
 }
-function secretsList(flags) {
-  const names = listSecretNames();
+async function secretsList(flags) {
+  const names = await listSecrets();
   if (names.length === 0) {
     console.log("No secrets configured.");
     console.log("\nSet with: rudi secrets set <name>");
     return;
   }
   if (flags.json) {
-    console.log(JSON.stringify(getMaskedSecrets(), null, 2));
+    const masked2 = await getMaskedSecrets();
+    console.log(JSON.stringify(masked2, null, 2));
     return;
   }
-  const masked = getMaskedSecrets();
-  console.log("\nConfigured secrets:");
+  const masked = await getMaskedSecrets();
+  const info = getStorageInfo();
+  const pending = Object.values(masked).filter((v) => v === "(pending)").length;
+  const configured = names.length - pending;
+  console.log(`
+Secrets (${info.backend}):`);
   console.log("\u2500".repeat(50));
-  for (const name of names.sort()) {
-    console.log(`  ${name.padEnd(25)} ${masked[name]}`);
+  for (const name of names) {
+    const status = masked[name] === "(pending)" ? "\u25CB" : "\u2713";
+    console.log(`  ${status} ${name.padEnd(28)} ${masked[name]}`);
+  }
+  console.log("\u2500".repeat(50));
+  if (pending > 0) {
+    console.log(`  ${configured} configured, ${pending} pending`);
+    console.log(`
+  Set pending: rudi secrets set <name> "<value>"`);
+  } else {
+    console.log(`  ${configured} configured`);
   }
-  console.log(`
-Total: ${names.length} secret(s)`);
 }
-function secretsRemove(args, flags) {
+async function secretsRemove(args, flags) {
   const name = args[0];
   if (!name) {
     console.error("Usage: rudi secrets remove <name>");
     process.exit(1);
   }
-  const existing = loadSecrets();
-  if (!existing[name]) {
+  const allNames = await listSecrets();
+  if (!allNames.includes(name)) {
     console.error(`Secret not found: ${name}`);
     process.exit(1);
   }
@@ -17472,17 +17763,19 @@ function secretsRemove(args, flags) {
     console.log("Run with --force to confirm.");
     process.exit(0);
   }
-  removeSecret(name);
+  await removeSecret(name);
   console.log(`\u2713 Secret ${name} removed`);
 }
-function secretsExport(flags) {
-  const exports2 = exportToEnv();
-  if (!exports2) {
-    console.log("No secrets to export.");
-    return;
-  }
-  console.log("# Add to your shell profile:");
-  console.log(exports2);
+function secretsInfo() {
+  const info = getStorageInfo();
+  console.log("\nSecrets Storage:");
+  console.log("\u2500".repeat(50));
+  console.log(`  Backend: ${info.backend}`);
+  console.log(`  File: ${info.file}`);
+  console.log(`  Permissions: ${info.permissions}`);
+  console.log("");
+  console.log("  Security: File permissions (0600) protect secrets.");
+  console.log("  Same approach as AWS CLI, SSH, GitHub CLI.");
 }
 function promptSecret(prompt) {
   return new Promise((resolve) => {
@@ -17517,13 +17810,13 @@ function promptSecret(prompt) {
 }
 
 // src/commands/db.js
-var import_fs11 = require("fs");
-var import_path11 = require("path");
+var import_fs12 = require("fs");
+var import_path12 = require("path");
 
 // ../packages/db/src/index.js
 var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
-var import_path10 = __toESM(require("path"), 1);
-var import_fs10 = __toESM(require("fs"), 1);
+var import_path11 = __toESM(require("path"), 1);
+var import_fs11 = __toESM(require("fs"), 1);
 init_src();
 
 // ../packages/db/src/schema.js
@@ -18260,9 +18553,9 @@ var DB_PATH = PATHS.dbFile;
 var db = null;
 function getDb(options = {}) {
   if (!db) {
-    const dbDir = import_path10.default.dirname(DB_PATH);
-    if (!import_fs10.default.existsSync(dbDir)) {
-      import_fs10.default.mkdirSync(dbDir, { recursive: true });
+    const dbDir = import_path11.default.dirname(DB_PATH);
+    if (!import_fs11.default.existsSync(dbDir)) {
+      import_fs11.default.mkdirSync(dbDir, { recursive: true });
     }
     db = new import_better_sqlite3.default(DB_PATH, {
       readonly: options.readonly || false
@@ -18275,7 +18568,7 @@ function getDb(options = {}) {
   return db;
 }
 function isDatabaseInitialized() {
-  if (!import_fs10.default.existsSync(DB_PATH)) {
+  if (!import_fs11.default.existsSync(DB_PATH)) {
     return false;
   }
   try {
@@ -18295,7 +18588,7 @@ function getDbPath() {
 }
 function getDbSize() {
   try {
-    const stats = import_fs10.default.statSync(DB_PATH);
+    const stats = import_fs11.default.statSync(DB_PATH);
     return stats.size;
   } catch {
     return null;
@@ -18556,12 +18849,12 @@ function dbBackup(args, flags) {
   let backupPath = args[0];
   if (!backupPath) {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-    backupPath = (0, import_path11.join)((0, import_path11.dirname)(dbPath), `rudi-backup-${timestamp}.db`);
+    backupPath = (0, import_path12.join)((0, import_path12.dirname)(dbPath), `rudi-backup-${timestamp}.db`);
   }
   if (backupPath.startsWith("~")) {
-    backupPath = (0, import_path11.join)(process.env.HOME || "", backupPath.slice(1));
+    backupPath = (0, import_path12.join)(process.env.HOME || "", backupPath.slice(1));
   }
-  if ((0, import_fs11.existsSync)(backupPath) && !flags.force) {
+  if ((0, import_fs12.existsSync)(backupPath) && !flags.force) {
     console.error(`Backup file already exists: ${backupPath}`);
     console.error("Use --force to overwrite.");
     process.exit(1);
@@ -18573,7 +18866,7 @@ function dbBackup(args, flags) {
     const db3 = getDb();
     db3.exec("VACUUM INTO ?", [backupPath]);
   } catch (e) {
-    (0, import_fs11.copyFileSync)(dbPath, backupPath);
+    (0, import_fs12.copyFileSync)(dbPath, backupPath);
   }
   const size = getDbSize();
   console.log(`  Size:   ${formatBytes(size)}`);
@@ -18678,24 +18971,24 @@ function dbTables(flags) {
 }
 
 // src/commands/import.js
-var import_fs12 = require("fs");
-var import_path12 = require("path");
-var import_os3 = require("os");
+var import_fs13 = require("fs");
+var import_path13 = require("path");
+var import_os4 = require("os");
 var import_crypto2 = require("crypto");
 var PROVIDERS = {
   claude: {
     name: "Claude Code",
-    baseDir: (0, import_path12.join)((0, import_os3.homedir)(), ".claude", "projects"),
+    baseDir: (0, import_path13.join)((0, import_os4.homedir)(), ".claude", "projects"),
     pattern: /\.jsonl$/
   },
   codex: {
     name: "Codex",
-    baseDir: (0, import_path12.join)((0, import_os3.homedir)(), ".codex", "sessions"),
+    baseDir: (0, import_path13.join)((0, import_os4.homedir)(), ".codex", "sessions"),
     pattern: /\.jsonl$/
   },
   gemini: {
     name: "Gemini",
-    baseDir: (0, import_path12.join)((0, import_os3.homedir)(), ".gemini", "sessions"),
+    baseDir: (0, import_path13.join)((0, import_os4.homedir)(), ".gemini", "sessions"),
     pattern: /\.jsonl$/
   }
 };
@@ -18762,7 +19055,7 @@ async function importSessions(args, flags) {
     console.log(`
 \u25B6 ${provider.name}`);
     console.log(`  Source: ${provider.baseDir}`);
-    if (!(0, import_fs12.existsSync)(provider.baseDir)) {
+    if (!(0, import_fs13.existsSync)(provider.baseDir)) {
       console.log(`  \u26A0 Directory not found, skipping`);
       continue;
     }
@@ -18805,14 +19098,14 @@ async function importSessions(args, flags) {
     const now = Date.now();
     const maxAgeMs = maxAgeDays ? maxAgeDays * 24 * 60 * 60 * 1e3 : null;
     for (const filepath of files) {
-      const sessionId = (0, import_path12.basename)(filepath, ".jsonl");
+      const sessionId = (0, import_path13.basename)(filepath, ".jsonl");
       if (existingIds.has(sessionId)) {
         skipped.existing++;
         continue;
       }
       let stat;
       try {
-        stat = (0, import_fs12.statSync)(filepath);
+        stat = (0, import_fs13.statSync)(filepath);
       } catch (e) {
         skipped.error++;
         continue;
@@ -18910,7 +19203,7 @@ function showImportStatus(flags) {
   }
   console.log("\nProvider directories:");
   for (const [key, provider] of Object.entries(PROVIDERS)) {
-    const exists = (0, import_fs12.existsSync)(provider.baseDir);
+    const exists = (0, import_fs13.existsSync)(provider.baseDir);
     let count = 0;
     if (exists) {
       const files = findSessionFiles(provider.baseDir, provider.pattern);
@@ -18924,10 +19217,10 @@ function showImportStatus(flags) {
   console.log("To import: rudi import sessions [provider]");
 }
 function findSessionFiles(dir, pattern, files = []) {
-  if (!(0, import_fs12.existsSync)(dir)) return files;
+  if (!(0, import_fs13.existsSync)(dir)) return files;
   try {
-    for (const entry of (0, import_fs12.readdirSync)(dir, { withFileTypes: true })) {
-      const fullPath = (0, import_path12.join)(dir, entry.name);
+    for (const entry of (0, import_fs13.readdirSync)(dir, { withFileTypes: true })) {
+      const fullPath = (0, import_path13.join)(dir, entry.name);
       if (entry.isDirectory()) {
         findSessionFiles(fullPath, pattern, files);
       } else if (pattern.test(entry.name)) {
@@ -18940,11 +19233,11 @@ function findSessionFiles(dir, pattern, files = []) {
 }
 function parseSessionFile(filepath, provider) {
   try {
-    const stat = (0, import_fs12.statSync)(filepath);
-    const content = (0, import_fs12.readFileSync)(filepath, "utf-8");
+    const stat = (0, import_fs13.statSync)(filepath);
+    const content = (0, import_fs13.readFileSync)(filepath, "utf-8");
     const lines = content.split("\n").filter((l) => l.trim());
     if (lines.length === 0) return null;
-    const sessionId = (0, import_path12.basename)(filepath, ".jsonl");
+    const sessionId = (0, import_path13.basename)(filepath, ".jsonl");
     const isAgent = sessionId.startsWith("agent-");
     let title = null;
     let cwd = null;
@@ -18976,11 +19269,11 @@ function parseSessionFile(filepath, provider) {
       title = isAgent ? "Agent Session" : "Imported Session";
     }
     if (!cwd) {
-      const parentDir = (0, import_path12.basename)((0, import_path12.dirname)(filepath));
+      const parentDir = (0, import_path13.basename)((0, import_path13.dirname)(filepath));
       if (parentDir.startsWith("-")) {
         cwd = parentDir.replace(/-/g, "/").replace(/^\//, "/");
       } else {
-        cwd = (0, import_os3.homedir)();
+        cwd = (0, import_os4.homedir)();
       }
     }
     return {
@@ -19000,7 +19293,7 @@ function parseSessionFile(filepath, provider) {
 }
 
 // src/commands/doctor.js
-var import_fs13 = __toESM(require("fs"), 1);
+var import_fs14 = __toESM(require("fs"), 1);
 async function cmdDoctor(args, flags) {
   console.log("RUDI Health Check");
   console.log("\u2550".repeat(50));
@@ -19018,12 +19311,12 @@ async function cmdDoctor(args, flags) {
     { path: PATHS.cache, name: "Cache" }
   ];
   for (const dir of dirs) {
-    const exists = import_fs13.default.existsSync(dir.path);
+    const exists = import_fs14.default.existsSync(dir.path);
     const status = exists ? "\u2713" : "\u2717";
     console.log(`  ${status} ${dir.name}: ${dir.path}`);
     if (!exists) {
       issues.push(`Missing directory: ${dir.name}`);
-      fixes.push(() => import_fs13.default.mkdirSync(dir.path, { recursive: true }));
+      fixes.push(() => import_fs14.default.mkdirSync(dir.path, { recursive: true }));
     }
   }
   console.log("\n\u{1F4BE} Database");
@@ -19123,8 +19416,8 @@ async function cmdDoctor(args, flags) {
 }
 
 // src/commands/home.js
-var import_fs14 = __toESM(require("fs"), 1);
-var import_path13 = __toESM(require("path"), 1);
+var import_fs15 = __toESM(require("fs"), 1);
+var import_path14 = __toESM(require("path"), 1);
 function formatBytes2(bytes) {
   if (bytes === 0) return "0 B";
   const k = 1024;
@@ -19133,16 +19426,16 @@ function formatBytes2(bytes) {
   return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + " " + sizes[i];
 }
 function getDirSize(dir) {
-  if (!import_fs14.default.existsSync(dir)) return 0;
+  if (!import_fs15.default.existsSync(dir)) return 0;
   let size = 0;
   try {
-    const entries = import_fs14.default.readdirSync(dir, { withFileTypes: true });
+    const entries = import_fs15.default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = import_path13.default.join(dir, entry.name);
+      const fullPath = import_path14.default.join(dir, entry.name);
       if (entry.isDirectory()) {
         size += getDirSize(fullPath);
       } else {
-        size += import_fs14.default.statSync(fullPath).size;
+        size += import_fs15.default.statSync(fullPath).size;
       }
     }
   } catch {
@@ -19150,9 +19443,9 @@ function getDirSize(dir) {
   return size;
 }
 function countItems(dir) {
-  if (!import_fs14.default.existsSync(dir)) return 0;
+  if (!import_fs15.default.existsSync(dir)) return 0;
   try {
-    return import_fs14.default.readdirSync(dir).filter((f) => !f.startsWith(".")).length;
+    return import_fs15.default.readdirSync(dir).filter((f) => !f.startsWith(".")).length;
   } catch {
     return 0;
   }
@@ -19179,7 +19472,7 @@ async function cmdHome(args, flags) {
     for (const dir of dirs2) {
       data.directories[dir.key] = {
         path: dir.path,
-        exists: import_fs14.default.existsSync(dir.path),
+        exists: import_fs15.default.existsSync(dir.path),
         items: countItems(dir.path),
         size: getDirSize(dir.path)
       };
@@ -19204,7 +19497,7 @@ async function cmdHome(args, flags) {
     { name: "cache", path: PATHS.cache, icon: "\u{1F4BE}", desc: "Registry cache" }
   ];
   for (const dir of dirs) {
-    const exists = import_fs14.default.existsSync(dir.path);
+    const exists = import_fs15.default.existsSync(dir.path);
     const count = countItems(dir.path);
     const size = getDirSize(dir.path);
     console.log(`${dir.icon} ${dir.name}/`);
@@ -19214,52 +19507,299 @@ async function cmdHome(args, flags) {
     } else {
       console.log(`   (not created)`);
     }
-    console.log();
+    console.log();
+  }
+  console.log("\u{1F4BE} Database");
+  const dbPath = import_path14.default.join(PATHS.home, "rudi.db");
+  if (import_fs15.default.existsSync(dbPath)) {
+    const dbSize = getDbSize() || import_fs15.default.statSync(dbPath).size;
+    console.log(`   ${formatBytes2(dbSize)}`);
+    console.log(`   ${dbPath}`);
+  } else {
+    console.log(`   Not initialized`);
+  }
+  console.log();
+  console.log("\u2550".repeat(60));
+  console.log("Installed Packages");
+  console.log("\u2550".repeat(60));
+  const kinds = ["stack", "prompt", "runtime", "binary", "agent"];
+  let total = 0;
+  for (const kind of kinds) {
+    const packages = getInstalledPackages(kind);
+    const label = kind === "binary" ? "Binaries" : `${kind.charAt(0).toUpperCase() + kind.slice(1)}s`;
+    console.log(`  ${label.padEnd(12)} ${packages.length}`);
+    if (packages.length > 0 && flags.verbose) {
+      for (const pkg of packages.slice(0, 3)) {
+        console.log(`    - ${pkg.name || pkg.id}`);
+      }
+      if (packages.length > 3) {
+        console.log(`    ... and ${packages.length - 3} more`);
+      }
+    }
+    total += packages.length;
+  }
+  console.log("\u2500".repeat(30));
+  console.log(`  ${"Total".padEnd(12)} ${total}`);
+  console.log("\n\u{1F4CB} Quick Commands");
+  console.log("\u2500".repeat(30));
+  console.log("  rudi list stacks      Show installed stacks");
+  console.log("  rudi list runtimes    Show installed runtimes");
+  console.log("  rudi list binaries    Show installed binaries");
+  console.log("  rudi doctor --all     Check system dependencies");
+  console.log("  rudi db stats         Database statistics");
+}
+
+// src/commands/init.js
+var import_fs16 = __toESM(require("fs"), 1);
+var import_path15 = __toESM(require("path"), 1);
+var import_promises = require("stream/promises");
+var import_fs17 = require("fs");
+var import_child_process4 = require("child_process");
+init_src();
+init_src2();
+var RELEASES_BASE = "https://github.com/learn-rudi/registry/releases/download/v1.0.0";
+var BUNDLED_RUNTIMES = ["node", "python"];
+var ESSENTIAL_BINARIES = ["sqlite", "ripgrep"];
+async function cmdInit(args, flags) {
+  const force = flags.force || false;
+  const skipDownloads = flags["skip-downloads"] || false;
+  const quiet = flags.quiet || false;
+  if (!quiet) {
+    console.log("\u2550".repeat(60));
+    console.log("RUDI Initialization");
+    console.log("\u2550".repeat(60));
+    console.log(`Home: ${PATHS.home}`);
+    console.log();
+  }
+  const actions = { created: [], skipped: [], failed: [] };
+  if (!quiet) console.log("1. Checking directory structure...");
+  ensureDirectories();
+  const dirs = [
+    PATHS.stacks,
+    PATHS.prompts,
+    PATHS.runtimes,
+    PATHS.binaries,
+    PATHS.agents,
+    PATHS.cache,
+    import_path15.default.join(PATHS.home, "shims")
+  ];
+  for (const dir of dirs) {
+    const dirName = import_path15.default.basename(dir);
+    if (!import_fs16.default.existsSync(dir)) {
+      import_fs16.default.mkdirSync(dir, { recursive: true });
+      actions.created.push(`dir:${dirName}`);
+      if (!quiet) console.log(`   + ${dirName}/ (created)`);
+    } else {
+      actions.skipped.push(`dir:${dirName}`);
+      if (!quiet) console.log(`   \u2713 ${dirName}/ (exists)`);
+    }
+  }
+  if (!skipDownloads) {
+    if (!quiet) console.log("\n2. Checking runtimes...");
+    const index = await fetchIndex();
+    const platform = getPlatformArch();
+    for (const runtimeName of BUNDLED_RUNTIMES) {
+      const runtime = index.packages?.runtimes?.official?.find(
+        (r) => r.id === `runtime:${runtimeName}` || r.id === runtimeName
+      );
+      if (!runtime) {
+        actions.failed.push(`runtime:${runtimeName}`);
+        if (!quiet) console.log(`   \u26A0 ${runtimeName}: not found in registry`);
+        continue;
+      }
+      const destPath = import_path15.default.join(PATHS.runtimes, runtimeName);
+      if (import_fs16.default.existsSync(destPath) && !force) {
+        actions.skipped.push(`runtime:${runtimeName}`);
+        if (!quiet) console.log(`   \u2713 ${runtimeName}: already installed`);
+        continue;
+      }
+      try {
+        await downloadRuntime2(runtime, runtimeName, destPath, platform);
+        actions.created.push(`runtime:${runtimeName}`);
+        if (!quiet) console.log(`   + ${runtimeName}: installed`);
+      } catch (error) {
+        actions.failed.push(`runtime:${runtimeName}`);
+        if (!quiet) console.log(`   \u2717 ${runtimeName}: ${error.message}`);
+      }
+    }
+    if (!quiet) console.log("\n3. Checking essential binaries...");
+    for (const binaryName of ESSENTIAL_BINARIES) {
+      const binary = index.packages?.binaries?.official?.find(
+        (b) => b.id === `binary:${binaryName}` || b.id === binaryName || b.name?.toLowerCase() === binaryName
+      );
+      if (!binary) {
+        actions.failed.push(`binary:${binaryName}`);
+        if (!quiet) console.log(`   \u26A0 ${binaryName}: not found in registry`);
+        continue;
+      }
+      const destPath = import_path15.default.join(PATHS.binaries, binaryName);
+      if (import_fs16.default.existsSync(destPath) && !force) {
+        actions.skipped.push(`binary:${binaryName}`);
+        if (!quiet) console.log(`   \u2713 ${binaryName}: already installed`);
+        continue;
+      }
+      try {
+        await downloadBinary(binary, binaryName, destPath, platform);
+        actions.created.push(`binary:${binaryName}`);
+        if (!quiet) console.log(`   + ${binaryName}: installed`);
+      } catch (error) {
+        actions.failed.push(`binary:${binaryName}`);
+        if (!quiet) console.log(`   \u2717 ${binaryName}: ${error.message}`);
+      }
+    }
+  } else {
+    if (!quiet) console.log("\n2-3. Skipping downloads (--skip-downloads)");
+  }
+  if (!quiet) console.log("\n4. Updating shims...");
+  const shimsDir = import_path15.default.join(PATHS.home, "shims");
+  const shimCount = await createShims(shimsDir, quiet);
+  if (shimCount > 0) {
+    actions.created.push(`shims:${shimCount}`);
+  }
+  if (!quiet) console.log("\n5. Checking database...");
+  const dbPath = import_path15.default.join(PATHS.home, "rudi.db");
+  const dbExists = import_fs16.default.existsSync(dbPath);
+  try {
+    const result = initSchema();
+    if (dbExists) {
+      actions.skipped.push("database");
+      if (!quiet) console.log(`   \u2713 Database exists (v${result.version})`);
+    } else {
+      actions.created.push("database");
+      if (!quiet) console.log(`   + Database created (v${result.version})`);
+    }
+  } catch (error) {
+    actions.failed.push("database");
+    if (!quiet) console.log(`   \u2717 Database error: ${error.message}`);
+  }
+  if (!quiet) console.log("\n6. Checking settings...");
+  const settingsPath = import_path15.default.join(PATHS.home, "settings.json");
+  if (!import_fs16.default.existsSync(settingsPath)) {
+    const settings = {
+      version: "1.0.0",
+      initialized: (/* @__PURE__ */ new Date()).toISOString(),
+      theme: "system"
+    };
+    import_fs16.default.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+    actions.created.push("settings");
+    if (!quiet) console.log("   + settings.json created");
+  } else {
+    actions.skipped.push("settings");
+    if (!quiet) console.log("   \u2713 settings.json exists");
+  }
+  if (!quiet) {
+    console.log("\n" + "\u2550".repeat(60));
+    if (actions.created.length > 0) {
+      console.log(`\u2713 RUDI initialized! (${actions.created.length} items created, ${actions.skipped.length} already existed)`);
+    } else {
+      console.log("\u2713 RUDI is up to date! (all items already existed)");
+    }
+    console.log("\u2550".repeat(60));
+    if (actions.created.includes("settings")) {
+      const shimsPath = import_path15.default.join(PATHS.home, "shims");
+      console.log("\nAdd to your shell profile (~/.zshrc or ~/.bashrc):");
+      console.log(`  export PATH="${shimsPath}:$PATH"`);
+      console.log("\nThen run:");
+      console.log("  rudi home     # View your setup");
+      console.log("  rudi doctor   # Check health");
+    }
+  }
+  return actions;
+}
+async function downloadRuntime2(runtime, name, destPath, platform) {
+  let url;
+  if (runtime.upstream?.[platform]) {
+    url = runtime.upstream[platform];
+  } else if (runtime.download?.[platform]) {
+    url = `${RELEASES_BASE}/${runtime.download[platform]}`;
+  } else {
+    throw new Error(`No download for ${platform}`);
+  }
+  await downloadAndExtract(url, destPath, name);
+}
+async function downloadBinary(binary, name, destPath, platform) {
+  let url;
+  if (binary.upstream?.[platform]) {
+    url = binary.upstream[platform];
+  } else if (binary.download?.[platform]) {
+    url = `${RELEASES_BASE}/${binary.download[platform]}`;
+  } else {
+    throw new Error(`No download for ${platform}`);
+  }
+  await downloadAndExtract(url, destPath, name, binary.extract);
+}
+async function downloadAndExtract(url, destPath, name, extractConfig) {
+  const tempFile = import_path15.default.join(PATHS.cache, `${name}-download.tar.gz`);
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}`);
+  }
+  if (!import_fs16.default.existsSync(destPath)) {
+    import_fs16.default.mkdirSync(destPath, { recursive: true });
+  }
+  const fileStream = (0, import_fs17.createWriteStream)(tempFile);
+  await (0, import_promises.pipeline)(response.body, fileStream);
+  try {
+    (0, import_child_process4.execSync)(`tar -xzf "${tempFile}" -C "${destPath}" --strip-components=1`, {
+      stdio: "pipe"
+    });
+  } catch {
+    (0, import_child_process4.execSync)(`tar -xzf "${tempFile}" -C "${destPath}"`, { stdio: "pipe" });
+  }
+  import_fs16.default.unlinkSync(tempFile);
+}
+async function createShims(shimsDir, quiet = false) {
+  const shims = [];
+  const runtimeShims = {
+    node: "runtimes/node/bin/node",
+    npm: "runtimes/node/bin/npm",
+    npx: "runtimes/node/bin/npx",
+    python: "runtimes/python/bin/python3",
+    python3: "runtimes/python/bin/python3",
+    pip: "runtimes/python/bin/pip3",
+    pip3: "runtimes/python/bin/pip3"
+  };
+  const binaryShims = {
+    sqlite3: "binaries/sqlite/sqlite3",
+    rg: "binaries/ripgrep/rg",
+    ripgrep: "binaries/ripgrep/rg"
+  };
+  for (const [shimName, targetPath] of Object.entries(runtimeShims)) {
+    const fullTarget = import_path15.default.join(PATHS.home, targetPath);
+    const shimPath = import_path15.default.join(shimsDir, shimName);
+    if (import_fs16.default.existsSync(fullTarget)) {
+      createShim(shimPath, fullTarget);
+      shims.push(shimName);
+    }
   }
-  console.log("\u{1F4BE} Database");
-  const dbPath = import_path13.default.join(PATHS.home, "rudi.db");
-  if (import_fs14.default.existsSync(dbPath)) {
-    const dbSize = getDbSize() || import_fs14.default.statSync(dbPath).size;
-    console.log(`   ${formatBytes2(dbSize)}`);
-    console.log(`   ${dbPath}`);
-  } else {
-    console.log(`   Not initialized`);
+  for (const [shimName, targetPath] of Object.entries(binaryShims)) {
+    const fullTarget = import_path15.default.join(PATHS.home, targetPath);
+    const shimPath = import_path15.default.join(shimsDir, shimName);
+    if (import_fs16.default.existsSync(fullTarget)) {
+      createShim(shimPath, fullTarget);
+      shims.push(shimName);
+    }
   }
-  console.log();
-  console.log("\u2550".repeat(60));
-  console.log("Installed Packages");
-  console.log("\u2550".repeat(60));
-  const kinds = ["stack", "prompt", "runtime", "binary", "agent"];
-  let total = 0;
-  for (const kind of kinds) {
-    const packages = getInstalledPackages(kind);
-    const label = kind === "binary" ? "Binaries" : `${kind.charAt(0).toUpperCase() + kind.slice(1)}s`;
-    console.log(`  ${label.padEnd(12)} ${packages.length}`);
-    if (packages.length > 0 && flags.verbose) {
-      for (const pkg of packages.slice(0, 3)) {
-        console.log(`    - ${pkg.name || pkg.id}`);
-      }
-      if (packages.length > 3) {
-        console.log(`    ... and ${packages.length - 3} more`);
-      }
+  if (!quiet) {
+    if (shims.length > 0) {
+      console.log(`   \u2713 ${shims.length} shims: ${shims.join(", ")}`);
+    } else {
+      console.log("   \u26A0 No shims (runtimes/binaries not installed)");
     }
-    total += packages.length;
   }
-  console.log("\u2500".repeat(30));
-  console.log(`  ${"Total".padEnd(12)} ${total}`);
-  console.log("\n\u{1F4CB} Quick Commands");
-  console.log("\u2500".repeat(30));
-  console.log("  rudi list stacks      Show installed stacks");
-  console.log("  rudi list runtimes    Show installed runtimes");
-  console.log("  rudi list binaries    Show installed binaries");
-  console.log("  rudi doctor --all     Check system dependencies");
-  console.log("  rudi db stats         Database statistics");
+  return shims.length;
+}
+function createShim(shimPath, targetPath) {
+  if (import_fs16.default.existsSync(shimPath)) {
+    import_fs16.default.unlinkSync(shimPath);
+  }
+  import_fs16.default.symlinkSync(targetPath, shimPath);
 }
 
 // src/commands/update.js
-var import_fs15 = __toESM(require("fs"), 1);
-var import_path14 = __toESM(require("path"), 1);
-var import_child_process3 = require("child_process");
+var import_fs18 = __toESM(require("fs"), 1);
+var import_path16 = __toESM(require("path"), 1);
+var import_child_process5 = require("child_process");
 init_src();
 init_src2();
 async function cmdUpdate(args, flags) {
@@ -19284,7 +19824,7 @@ async function cmdUpdate(args, flags) {
 async function updatePackage(pkgId, flags) {
   const [kind, name] = parsePackageId(pkgId);
   const installPath = getPackagePath(pkgId);
-  if (!import_fs15.default.existsSync(installPath)) {
+  if (!import_fs18.default.existsSync(installPath)) {
     return { success: false, error: "Package not installed" };
   }
   const pkg = await getPackage(pkgId);
@@ -19294,7 +19834,7 @@ async function updatePackage(pkgId, flags) {
   console.log(`Updating ${pkgId}...`);
   if (pkg.npmPackage) {
     try {
-      (0, import_child_process3.execSync)(`npm install ${pkg.npmPackage}@latest`, {
+      (0, import_child_process5.execSync)(`npm install ${pkg.npmPackage}@latest`, {
         cwd: installPath,
         stdio: flags.verbose ? "inherit" : "pipe"
       });
@@ -19307,11 +19847,11 @@ async function updatePackage(pkgId, flags) {
   }
   if (pkg.pipPackage) {
     try {
-      const venvPip = import_path14.default.join(installPath, "venv", "bin", "pip");
-      (0, import_child_process3.execSync)(`"${venvPip}" install --upgrade ${pkg.pipPackage}`, {
+      const venvPip = import_path16.default.join(installPath, "venv", "bin", "pip");
+      (0, import_child_process5.execSync)(`"${venvPip}" install --upgrade ${pkg.pipPackage}`, {
         stdio: flags.verbose ? "inherit" : "pipe"
       });
-      const versionOutput = (0, import_child_process3.execSync)(`"${venvPip}" show ${pkg.pipPackage} | grep Version`, {
+      const versionOutput = (0, import_child_process5.execSync)(`"${venvPip}" show ${pkg.pipPackage} | grep Version`, {
         encoding: "utf-8"
       });
       const version = versionOutput.split(":")[1]?.trim();
@@ -19323,9 +19863,9 @@ async function updatePackage(pkgId, flags) {
   }
   if (kind === "runtime" && !pkg.npmPackage && !pkg.pipPackage) {
     try {
-      const { downloadRuntime: downloadRuntime2 } = await Promise.resolve().then(() => (init_src2(), src_exports));
-      import_fs15.default.rmSync(installPath, { recursive: true, force: true });
-      await downloadRuntime2(name, pkg.version || "latest", installPath, {
+      const { downloadRuntime: downloadRuntime3 } = await Promise.resolve().then(() => (init_src2(), src_exports));
+      import_fs18.default.rmSync(installPath, { recursive: true, force: true });
+      await downloadRuntime3(name, pkg.version || "latest", installPath, {
         onProgress: (p) => {
           if (flags.verbose) console.log(`  ${p.phase}...`);
         }
@@ -19344,8 +19884,8 @@ async function updateAll(flags) {
   let failed = 0;
   for (const kind of kinds) {
     const dir = kind === "runtime" ? PATHS.runtimes : kind === "stack" ? PATHS.stacks : PATHS.prompts;
-    if (!import_fs15.default.existsSync(dir)) continue;
-    const entries = import_fs15.default.readdirSync(dir, { withFileTypes: true });
+    if (!import_fs18.default.existsSync(dir)) continue;
+    const entries = import_fs18.default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
       const pkgId = `${kind}:${entry.name}`;
@@ -19364,14 +19904,14 @@ Updated ${updated} package(s)${failed > 0 ? `, ${failed} failed` : ""}`);
 }
 function getInstalledVersion(installPath, npmPackage) {
   try {
-    const pkgJsonPath = import_path14.default.join(installPath, "node_modules", npmPackage.replace("@", "").split("/")[0], "package.json");
-    if (import_fs15.default.existsSync(pkgJsonPath)) {
-      const pkgJson = JSON.parse(import_fs15.default.readFileSync(pkgJsonPath, "utf-8"));
+    const pkgJsonPath = import_path16.default.join(installPath, "node_modules", npmPackage.replace("@", "").split("/")[0], "package.json");
+    if (import_fs18.default.existsSync(pkgJsonPath)) {
+      const pkgJson = JSON.parse(import_fs18.default.readFileSync(pkgJsonPath, "utf-8"));
       return pkgJson.version;
     }
-    const rootPkgPath = import_path14.default.join(installPath, "package.json");
-    if (import_fs15.default.existsSync(rootPkgPath)) {
-      const rootPkg = JSON.parse(import_fs15.default.readFileSync(rootPkgPath, "utf-8"));
+    const rootPkgPath = import_path16.default.join(installPath, "package.json");
+    if (import_fs18.default.existsSync(rootPkgPath)) {
+      const rootPkg = JSON.parse(import_fs18.default.readFileSync(rootPkgPath, "utf-8"));
       const dep = rootPkg.dependencies?.[npmPackage];
       if (dep) return dep.replace(/[\^~]/, "");
     }
@@ -19380,30 +19920,30 @@ function getInstalledVersion(installPath, npmPackage) {
   return null;
 }
 function updateRuntimeMetadata(installPath, updates) {
-  const metaPath = import_path14.default.join(installPath, "runtime.json");
+  const metaPath = import_path16.default.join(installPath, "runtime.json");
   try {
     let meta = {};
-    if (import_fs15.default.existsSync(metaPath)) {
-      meta = JSON.parse(import_fs15.default.readFileSync(metaPath, "utf-8"));
+    if (import_fs18.default.existsSync(metaPath)) {
+      meta = JSON.parse(import_fs18.default.readFileSync(metaPath, "utf-8"));
     }
     meta = { ...meta, ...updates };
-    import_fs15.default.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
+    import_fs18.default.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
   } catch {
   }
 }
 
 // db/index.js
 var import_better_sqlite32 = __toESM(require("better-sqlite3"), 1);
-var import_path15 = __toESM(require("path"), 1);
-var import_os4 = __toESM(require("os"), 1);
-var import_fs16 = __toESM(require("fs"), 1);
-var RUDI_HOME2 = import_path15.default.join(import_os4.default.homedir(), ".rudi");
-var DB_PATH2 = import_path15.default.join(RUDI_HOME2, "rudi.db");
+var import_path17 = __toESM(require("path"), 1);
+var import_os5 = __toESM(require("os"), 1);
+var import_fs19 = __toESM(require("fs"), 1);
+var RUDI_HOME2 = import_path17.default.join(import_os5.default.homedir(), ".rudi");
+var DB_PATH2 = import_path17.default.join(RUDI_HOME2, "rudi.db");
 var db2 = null;
 function getDb2(options = {}) {
   if (!db2) {
-    if (!import_fs16.default.existsSync(RUDI_HOME2)) {
-      import_fs16.default.mkdirSync(RUDI_HOME2, { recursive: true });
+    if (!import_fs19.default.existsSync(RUDI_HOME2)) {
+      import_fs19.default.mkdirSync(RUDI_HOME2, { recursive: true });
     }
     db2 = new import_better_sqlite32.default(DB_PATH2, {
       readonly: options.readonly || false
@@ -19561,7 +20101,7 @@ function getBeforeCrashLogs() {
 }
 
 // src/commands/logs.js
-var import_fs17 = __toESM(require("fs"), 1);
+var import_fs20 = __toESM(require("fs"), 1);
 function parseTimeAgo(str) {
   const match = str.match(/^(\d+)([smhd])$/);
   if (!match) return null;
@@ -19661,7 +20201,7 @@ function exportLogs(logs, filepath, format) {
       });
       content = JSON.stringify(formatted, null, 2);
   }
-  import_fs17.default.writeFileSync(filepath, content, "utf-8");
+  import_fs20.default.writeFileSync(filepath, content, "utf-8");
   return filepath;
 }
 function printStats(stats) {
@@ -19787,9 +20327,9 @@ async function handleLogsCommand(args, flags) {
 }
 
 // src/commands/which.js
-var fs18 = __toESM(require("fs/promises"), 1);
-var path16 = __toESM(require("path"), 1);
-var import_child_process4 = require("child_process");
+var fs21 = __toESM(require("fs/promises"), 1);
+var path19 = __toESM(require("path"), 1);
+var import_child_process6 = require("child_process");
 init_src();
 async function cmdWhich(args, flags) {
   const stackId = args[0];
@@ -19857,7 +20397,7 @@ Installed stacks:`);
     if (runtimeInfo.entry) {
       console.log("");
       console.log("Run MCP server directly:");
-      const entryPath = path16.join(stackPath, runtimeInfo.entry);
+      const entryPath = path19.join(stackPath, runtimeInfo.entry);
       if (runtimeInfo.runtime === "node") {
         console.log(`  echo '{"jsonrpc":"2.0","method":"tools/list","id":1}' | node ${entryPath}`);
       } else if (runtimeInfo.runtime === "python") {
@@ -19876,27 +20416,27 @@ Installed stacks:`);
 async function detectRuntime(stackPath) {
   const runtimes = ["node", "python"];
   for (const runtime of runtimes) {
-    const runtimePath = path16.join(stackPath, runtime);
+    const runtimePath = path19.join(stackPath, runtime);
     try {
-      await fs18.access(runtimePath);
+      await fs21.access(runtimePath);
       if (runtime === "node") {
-        const distEntry = path16.join(runtimePath, "dist", "index.js");
-        const srcEntry = path16.join(runtimePath, "src", "index.ts");
+        const distEntry = path19.join(runtimePath, "dist", "index.js");
+        const srcEntry = path19.join(runtimePath, "src", "index.ts");
         try {
-          await fs18.access(distEntry);
+          await fs21.access(distEntry);
           return { runtime: "node", entry: `${runtime}/dist/index.js` };
         } catch {
           try {
-            await fs18.access(srcEntry);
+            await fs21.access(srcEntry);
             return { runtime: "node", entry: `${runtime}/src/index.ts` };
           } catch {
             return { runtime: "node", entry: null };
           }
         }
       } else if (runtime === "python") {
-        const entry = path16.join(runtimePath, "src", "index.py");
+        const entry = path19.join(runtimePath, "src", "index.py");
         try {
-          await fs18.access(entry);
+          await fs21.access(entry);
           return { runtime: "python", entry: `${runtime}/src/index.py` };
         } catch {
           return { runtime: "python", entry: null };
@@ -19912,21 +20452,21 @@ async function checkAuth(stackPath, runtime) {
   const authFiles = [];
   let configured = false;
   if (runtime === "node" || runtime === "python") {
-    const runtimePath = path16.join(stackPath, runtime);
-    const tokenPath = path16.join(runtimePath, "token.json");
+    const runtimePath = path19.join(stackPath, runtime);
+    const tokenPath = path19.join(runtimePath, "token.json");
     try {
-      await fs18.access(tokenPath);
+      await fs21.access(tokenPath);
       authFiles.push(`${runtime}/token.json`);
       configured = true;
     } catch {
-      const accountsPath = path16.join(runtimePath, "accounts");
+      const accountsPath = path19.join(runtimePath, "accounts");
       try {
-        const accounts = await fs18.readdir(accountsPath);
+        const accounts = await fs21.readdir(accountsPath);
         for (const account of accounts) {
           if (account.startsWith(".")) continue;
-          const accountTokenPath = path16.join(accountsPath, account, "token.json");
+          const accountTokenPath = path19.join(accountsPath, account, "token.json");
           try {
-            await fs18.access(accountTokenPath);
+            await fs21.access(accountTokenPath);
             authFiles.push(`${runtime}/accounts/${account}/token.json`);
             configured = true;
           } catch {
@@ -19936,9 +20476,9 @@ async function checkAuth(stackPath, runtime) {
       }
     }
   }
-  const envPath = path16.join(stackPath, ".env");
+  const envPath = path19.join(stackPath, ".env");
   try {
-    const envContent = await fs18.readFile(envPath, "utf-8");
+    const envContent = await fs21.readFile(envPath, "utf-8");
     const hasValues = envContent.split("\n").some((line) => {
       const trimmed = line.trim();
       if (!trimmed || trimmed.startsWith("#")) return false;
@@ -19967,7 +20507,7 @@ async function checkAuth(stackPath, runtime) {
 }
 function checkIfRunning(stackName) {
   try {
-    const result = (0, import_child_process4.execSync)(`ps aux | grep "${stackName}" | grep -v grep || true`, {
+    const result = (0, import_child_process6.execSync)(`ps aux | grep "${stackName}" | grep -v grep || true`, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "ignore"]
       // Suppress stderr
@@ -19982,9 +20522,9 @@ function checkIfRunning(stackName) {
 }
 
 // src/commands/auth.js
-var fs19 = __toESM(require("fs/promises"), 1);
-var path17 = __toESM(require("path"), 1);
-var import_child_process5 = require("child_process");
+var fs22 = __toESM(require("fs/promises"), 1);
+var path20 = __toESM(require("path"), 1);
+var import_child_process7 = require("child_process");
 init_src();
 var net = __toESM(require("net"), 1);
 async function findAvailablePort(basePort = 3456) {
@@ -20015,26 +20555,26 @@ function isPortAvailable(port) {
 async function detectRuntime2(stackPath) {
   const runtimes = ["node", "python"];
   for (const runtime of runtimes) {
-    const runtimePath = path17.join(stackPath, runtime);
+    const runtimePath = path20.join(stackPath, runtime);
     try {
-      await fs19.access(runtimePath);
+      await fs22.access(runtimePath);
       if (runtime === "node") {
-        const authTs = path17.join(runtimePath, "src", "auth.ts");
-        const authJs = path17.join(runtimePath, "dist", "auth.js");
+        const authTs = path20.join(runtimePath, "src", "auth.ts");
+        const authJs = path20.join(runtimePath, "dist", "auth.js");
         try {
-          await fs19.access(authTs);
+          await fs22.access(authTs);
           return { runtime: "node", authScript: authTs, useTsx: true };
         } catch {
           try {
-            await fs19.access(authJs);
+            await fs22.access(authJs);
             return { runtime: "node", authScript: authJs, useTsx: false };
           } catch {
           }
         }
       } else if (runtime === "python") {
-        const authPy = path17.join(runtimePath, "src", "auth.py");
+        const authPy = path20.join(runtimePath, "src", "auth.py");
         try {
-          await fs19.access(authPy);
+          await fs22.access(authPy);
           return { runtime: "python", authScript: authPy, useTsx: false };
         } catch {
         }
@@ -20084,14 +20624,14 @@ Installed stacks:`);
     console.log(`Using port: ${port}`);
     console.log("");
     let cmd;
-    const cwd = path17.dirname(authInfo.authScript);
+    const cwd = path20.dirname(authInfo.authScript);
     if (authInfo.runtime === "node") {
-      const distAuth = path17.join(cwd, "..", "dist", "auth.js");
+      const distAuth = path20.join(cwd, "..", "dist", "auth.js");
       let useBuiltInPort = false;
       let tempAuthScript = null;
       try {
-        await fs19.access(distAuth);
-        const distContent = await fs19.readFile(distAuth, "utf-8");
+        await fs22.access(distAuth);
+        const distContent = await fs22.readFile(distAuth, "utf-8");
         if (distContent.includes("findAvailablePort")) {
           console.log("Using compiled authentication script...");
           cmd = `node ${distAuth}${accountEmail ? ` ${accountEmail}` : ""}`;
@@ -20100,11 +20640,11 @@ Installed stacks:`);
       } catch {
       }
       if (!useBuiltInPort) {
-        const authContent = await fs19.readFile(authInfo.authScript, "utf-8");
+        const authContent = await fs22.readFile(authInfo.authScript, "utf-8");
         const tempExt = authInfo.useTsx ? ".ts" : ".mjs";
-        tempAuthScript = path17.join(cwd, "..", `auth-temp${tempExt}`);
+        tempAuthScript = path20.join(cwd, "..", `auth-temp${tempExt}`);
         const modifiedContent = authContent.replace(/localhost:3456/g, `localhost:${port}`).replace(/server\.listen\(3456/g, `server.listen(${port}`);
-        await fs19.writeFile(tempAuthScript, modifiedContent);
+        await fs22.writeFile(tempAuthScript, modifiedContent);
         if (authInfo.useTsx) {
           cmd = `npx tsx ${tempAuthScript}${accountEmail ? ` ${accountEmail}` : ""}`;
         } else {
@@ -20114,17 +20654,17 @@ Installed stacks:`);
       console.log("Starting OAuth flow...");
       console.log("");
       try {
-        (0, import_child_process5.execSync)(cmd, {
+        (0, import_child_process7.execSync)(cmd, {
           cwd,
           stdio: "inherit"
         });
         if (tempAuthScript) {
-          await fs19.unlink(tempAuthScript);
+          await fs22.unlink(tempAuthScript);
         }
       } catch (error) {
         if (tempAuthScript) {
           try {
-            await fs19.unlink(tempAuthScript);
+            await fs22.unlink(tempAuthScript);
           } catch {
           }
         }
@@ -20134,7 +20674,7 @@ Installed stacks:`);
       cmd = `python3 ${authInfo.authScript}${accountEmail ? ` ${accountEmail}` : ""}`;
       console.log("Starting OAuth flow...");
       console.log("");
-      (0, import_child_process5.execSync)(cmd, {
+      (0, import_child_process7.execSync)(cmd, {
         cwd,
         stdio: "inherit",
         env: {
@@ -20155,6 +20695,657 @@ Installed stacks:`);
   }
 }
 
+// src/commands/mcp.js
+var fs23 = __toESM(require("fs"), 1);
+var path21 = __toESM(require("path"), 1);
+var import_child_process8 = require("child_process");
+init_src();
+function getBundledRuntime(runtime) {
+  const platform = process.platform;
+  if (runtime === "node") {
+    const nodePath = platform === "win32" ? path21.join(PATHS.runtimes, "node", "node.exe") : path21.join(PATHS.runtimes, "node", "bin", "node");
+    if (fs23.existsSync(nodePath)) {
+      return nodePath;
+    }
+  }
+  if (runtime === "python") {
+    const pythonPath = platform === "win32" ? path21.join(PATHS.runtimes, "python", "python.exe") : path21.join(PATHS.runtimes, "python", "bin", "python3");
+    if (fs23.existsSync(pythonPath)) {
+      return pythonPath;
+    }
+  }
+  return null;
+}
+function getBundledNpx() {
+  const platform = process.platform;
+  const npxPath = platform === "win32" ? path21.join(PATHS.runtimes, "node", "npx.cmd") : path21.join(PATHS.runtimes, "node", "bin", "npx");
+  if (fs23.existsSync(npxPath)) {
+    return npxPath;
+  }
+  return null;
+}
+function loadManifest2(stackPath) {
+  const manifestPath = path21.join(stackPath, "manifest.json");
+  if (!fs23.existsSync(manifestPath)) {
+    return null;
+  }
+  return JSON.parse(fs23.readFileSync(manifestPath, "utf-8"));
+}
+function getRequiredSecrets(manifest) {
+  const secrets = manifest?.requires?.secrets || manifest?.secrets || [];
+  return secrets.map((s) => ({
+    name: typeof s === "string" ? s : s.name || s.key,
+    required: typeof s === "object" ? s.required !== false : true
+  }));
+}
+async function buildEnv(manifest) {
+  const env = { ...process.env };
+  const requiredSecrets = getRequiredSecrets(manifest);
+  const missing = [];
+  for (const secret of requiredSecrets) {
+    const value = await getSecret(secret.name);
+    if (value) {
+      env[secret.name] = value;
+    } else if (secret.required) {
+      missing.push(secret.name);
+    }
+  }
+  return { env, missing };
+}
+async function cmdMcp(args, flags) {
+  const stackName = args[0];
+  if (!stackName) {
+    console.error("Usage: rudi mcp <stack>");
+    console.error("");
+    console.error("This command is typically called by agent shims, not directly.");
+    console.error("");
+    console.error("Example: rudi mcp slack");
+    process.exit(1);
+  }
+  const stackPath = path21.join(PATHS.stacks, stackName);
+  if (!fs23.existsSync(stackPath)) {
+    console.error(`Stack not found: ${stackName}`);
+    console.error(`Expected at: ${stackPath}`);
+    console.error("");
+    console.error(`Install with: rudi install ${stackName}`);
+    process.exit(1);
+  }
+  const manifest = loadManifest2(stackPath);
+  if (!manifest) {
+    console.error(`No manifest.json found in stack: ${stackName}`);
+    process.exit(1);
+  }
+  const { env, missing } = await buildEnv(manifest);
+  if (missing.length > 0 && !flags.force) {
+    console.error(`Missing required secrets for ${stackName}:`);
+    for (const name of missing) {
+      console.error(`  - ${name}`);
+    }
+    console.error("");
+    console.error(`Set with: rudi secrets set ${missing[0]}`);
+    process.exit(1);
+  }
+  let command = manifest.command;
+  if (!command || command.length === 0) {
+    if (manifest.mcp?.command) {
+      const mcpCmd = manifest.mcp.command;
+      const mcpArgs = manifest.mcp.args || [];
+      command = [mcpCmd, ...mcpArgs];
+    }
+  }
+  if (!command || command.length === 0) {
+    console.error(`No command defined in manifest for: ${stackName}`);
+    process.exit(1);
+  }
+  const runtime = manifest.runtime || manifest.mcp?.runtime || "node";
+  const resolvedCommand = command.map((part, i) => {
+    if (i === 0) {
+      if (part === "node") {
+        const bundledNode = getBundledRuntime("node");
+        if (bundledNode) return bundledNode;
+      } else if (part === "npx") {
+        const bundledNpx = getBundledNpx();
+        if (bundledNpx) return bundledNpx;
+      } else if (part === "python" || part === "python3") {
+        const bundledPython = getBundledRuntime("python");
+        if (bundledPython) return bundledPython;
+      }
+      return part;
+    }
+    if (part.startsWith("./") || part.startsWith("../") || !path21.isAbsolute(part)) {
+      const resolved = path21.join(stackPath, part);
+      if (fs23.existsSync(resolved)) {
+        return resolved;
+      }
+    }
+    return part;
+  });
+  const [cmd, ...cmdArgs] = resolvedCommand;
+  const bundledNodeBin = path21.join(PATHS.runtimes, "node", "bin");
+  const bundledPythonBin = path21.join(PATHS.runtimes, "python", "bin");
+  if (fs23.existsSync(bundledNodeBin) || fs23.existsSync(bundledPythonBin)) {
+    const runtimePaths = [];
+    if (fs23.existsSync(bundledNodeBin)) runtimePaths.push(bundledNodeBin);
+    if (fs23.existsSync(bundledPythonBin)) runtimePaths.push(bundledPythonBin);
+    env.PATH = runtimePaths.join(path21.delimiter) + path21.delimiter + (env.PATH || "");
+  }
+  if (flags.debug) {
+    console.error(`[rudi mcp] Stack: ${stackName}`);
+    console.error(`[rudi mcp] Path: ${stackPath}`);
+    console.error(`[rudi mcp] Runtime: ${runtime}`);
+    console.error(`[rudi mcp] Command: ${cmd} ${cmdArgs.join(" ")}`);
+    console.error(`[rudi mcp] Secrets loaded: ${getRequiredSecrets(manifest).length - missing.length}`);
+    if (getBundledRuntime(runtime)) {
+      console.error(`[rudi mcp] Using bundled ${runtime} runtime`);
+    } else {
+      console.error(`[rudi mcp] Using system ${runtime} (no bundled runtime found)`);
+    }
+  }
+  const child = (0, import_child_process8.spawn)(cmd, cmdArgs, {
+    cwd: stackPath,
+    env,
+    stdio: "inherit"
+    // MCP uses stdio for communication
+  });
+  child.on("error", (err) => {
+    console.error(`Failed to start MCP server: ${err.message}`);
+    process.exit(1);
+  });
+  child.on("exit", (code) => {
+    process.exit(code || 0);
+  });
+}
+
+// src/commands/integrate.js
+var fs24 = __toESM(require("fs"), 1);
+var path22 = __toESM(require("path"), 1);
+var import_os6 = __toESM(require("os"), 1);
+init_src();
+var HOME2 = import_os6.default.homedir();
+var SHIM_PATH = path22.join(PATHS.home, "shims", "rudi-mcp");
+function getInstalledStacks() {
+  const stacksDir = PATHS.stacks;
+  if (!fs24.existsSync(stacksDir)) return [];
+  return fs24.readdirSync(stacksDir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).filter((d) => fs24.existsSync(path22.join(stacksDir, d.name, "manifest.json"))).map((d) => d.name);
+}
+function ensureShim() {
+  const shimsDir = path22.dirname(SHIM_PATH);
+  if (!fs24.existsSync(shimsDir)) {
+    fs24.mkdirSync(shimsDir, { recursive: true });
+  }
+  const shimContent = `#!/usr/bin/env bash
+set -euo pipefail
+# Try rudi in PATH first, fall back to npx
+if command -v rudi &> /dev/null; then
+  exec rudi mcp "$1"
+else
+  exec npx --yes @learnrudi/cli mcp "$1"
+fi
+`;
+  if (fs24.existsSync(SHIM_PATH)) {
+    const existing = fs24.readFileSync(SHIM_PATH, "utf-8");
+    if (existing === shimContent) {
+      return { created: false, path: SHIM_PATH };
+    }
+  }
+  fs24.writeFileSync(SHIM_PATH, shimContent, { mode: 493 });
+  return { created: true, path: SHIM_PATH };
+}
+function backupConfig(configPath) {
+  if (!fs24.existsSync(configPath)) return null;
+  const backupPath = configPath + ".backup." + Date.now();
+  fs24.copyFileSync(configPath, backupPath);
+  return backupPath;
+}
+function readJsonConfig(configPath) {
+  if (!fs24.existsSync(configPath)) {
+    return {};
+  }
+  try {
+    return JSON.parse(fs24.readFileSync(configPath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeJsonConfig(configPath, config) {
+  const dir = path22.dirname(configPath);
+  if (!fs24.existsSync(dir)) {
+    fs24.mkdirSync(dir, { recursive: true });
+  }
+  fs24.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+function buildMcpEntry(stackName, agentId) {
+  const base = {
+    command: SHIM_PATH,
+    args: [stackName]
+  };
+  if (agentId === "claude-desktop" || agentId === "claude-code") {
+    return { type: "stdio", ...base };
+  }
+  return base;
+}
+async function integrateAgent(agentId, stacks, flags) {
+  const agentConfig = AGENT_CONFIGS2.find((a) => a.id === agentId);
+  if (!agentConfig) {
+    console.error(`Unknown agent: ${agentId}`);
+    return { success: false, error: "Unknown agent" };
+  }
+  const configPath = findAgentConfig(agentConfig);
+  const configDir = configPath ? path22.dirname(configPath) : null;
+  const targetPath = configPath || path22.join(HOME2, agentConfig.paths[process.platform]?.[0] || agentConfig.paths.darwin[0]);
+  console.log(`
+${agentConfig.name}:`);
+  console.log(`  Config: ${targetPath}`);
+  if (fs24.existsSync(targetPath)) {
+    const backup = backupConfig(targetPath);
+    if (backup && flags.verbose) {
+      console.log(`  Backup: ${backup}`);
+    }
+  }
+  const config = readJsonConfig(targetPath);
+  const key = agentConfig.key;
+  if (!config[key]) {
+    config[key] = {};
+  }
+  let added = 0;
+  let updated = 0;
+  for (const stackName of stacks) {
+    const entry = buildMcpEntry(stackName, agentId);
+    const existing = config[key][stackName];
+    if (!existing) {
+      config[key][stackName] = entry;
+      added++;
+    } else if (existing.command !== entry.command || JSON.stringify(existing.args) !== JSON.stringify(entry.args)) {
+      config[key][stackName] = entry;
+      updated++;
+    }
+  }
+  if (added > 0 || updated > 0) {
+    writeJsonConfig(targetPath, config);
+    console.log(`  Added: ${added}, Updated: ${updated}`);
+  } else {
+    console.log(`  Already up to date`);
+  }
+  return { success: true, added, updated };
+}
+async function cmdIntegrate(args, flags) {
+  const target = args[0];
+  if (!target) {
+    console.log(`
+rudi integrate - Wire RUDI stacks into agent configs
+
+USAGE
+  rudi integrate <agent>     Integrate with specific agent
+  rudi integrate all         Integrate with all detected agents
+  rudi integrate --list      Show detected agents
+
+AGENTS
+  claude       Claude Desktop + Claude Code
+  cursor       Cursor IDE
+  windsurf     Windsurf IDE
+  vscode       VS Code / GitHub Copilot
+  gemini       Gemini CLI
+  codex        OpenAI Codex CLI
+  zed          Zed Editor
+
+OPTIONS
+  --verbose    Show detailed output
+  --dry-run    Show what would be done without making changes
+
+EXAMPLES
+  rudi integrate claude
+  rudi integrate all
+`);
+    return;
+  }
+  if (flags.list || target === "list") {
+    const installed = getInstalledAgents();
+    console.log("\nDetected agents:");
+    for (const agent of installed) {
+      console.log(`  \u2713 ${agent.name}`);
+      console.log(`    ${agent.configFile}`);
+    }
+    if (installed.length === 0) {
+      console.log("  (none detected)");
+    }
+    return;
+  }
+  const stacks = getInstalledStacks();
+  if (stacks.length === 0) {
+    console.log("No stacks installed. Install with: rudi install <stack>");
+    return;
+  }
+  console.log(`
+Integrating ${stacks.length} stack(s)...`);
+  const shimResult = ensureShim();
+  if (shimResult.created) {
+    console.log(`Created shim: ${shimResult.path}`);
+  }
+  let targetAgents = [];
+  if (target === "all") {
+    targetAgents = getInstalledAgents().map((a) => a.id);
+    if (targetAgents.length === 0) {
+      console.log("No agents detected.");
+      return;
+    }
+  } else if (target === "claude") {
+    targetAgents = ["claude-desktop", "claude-code"].filter((id) => {
+      const agent = AGENT_CONFIGS2.find((a) => a.id === id);
+      return agent && findAgentConfig(agent);
+    });
+    if (targetAgents.length === 0) {
+      targetAgents = ["claude-code"];
+    }
+  } else {
+    const idMap = {
+      "cursor": "cursor",
+      "windsurf": "windsurf",
+      "vscode": "vscode",
+      "gemini": "gemini",
+      "codex": "codex",
+      "zed": "zed",
+      "cline": "cline"
+    };
+    const agentId = idMap[target] || target;
+    targetAgents = [agentId];
+  }
+  if (flags["dry-run"]) {
+    console.log("\nDry run - would integrate:");
+    for (const agentId of targetAgents) {
+      const agent = AGENT_CONFIGS2.find((a) => a.id === agentId);
+      console.log(`  ${agent?.name || agentId}:`);
+      for (const stack of stacks) {
+        console.log(`    - ${stack}`);
+      }
+    }
+    return;
+  }
+  const results = [];
+  for (const agentId of targetAgents) {
+    const result = await integrateAgent(agentId, stacks, flags);
+    results.push({ agent: agentId, ...result });
+  }
+  const successful = results.filter((r) => r.success);
+  console.log(`
+\u2713 Integrated with ${successful.length} agent(s)`);
+  console.log("\nRestart your agent(s) to use the new stacks.");
+}
+
+// src/commands/migrate.js
+var fs25 = __toESM(require("fs"), 1);
+var path23 = __toESM(require("path"), 1);
+var import_os7 = __toESM(require("os"), 1);
+init_src();
+var HOME3 = import_os7.default.homedir();
+var OLD_PROMPT_STACK = path23.join(HOME3, ".prompt-stack");
+var SHIM_PATH2 = path23.join(PATHS.home, "shims", "rudi-mcp");
+function getOldStacks() {
+  const stacksDir = path23.join(OLD_PROMPT_STACK, "stacks");
+  if (!fs25.existsSync(stacksDir)) return [];
+  return fs25.readdirSync(stacksDir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).filter((d) => {
+    const hasManifest = fs25.existsSync(path23.join(stacksDir, d.name, "manifest.json"));
+    const hasPackage = fs25.existsSync(path23.join(stacksDir, d.name, "package.json"));
+    return hasManifest || hasPackage;
+  }).map((d) => d.name);
+}
+function copyStack(stackName) {
+  const oldPath = path23.join(OLD_PROMPT_STACK, "stacks", stackName);
+  const newPath = path23.join(PATHS.stacks, stackName);
+  if (!fs25.existsSync(oldPath)) {
+    return { success: false, error: "Source not found" };
+  }
+  if (fs25.existsSync(newPath)) {
+    return { success: true, skipped: true, reason: "Already exists" };
+  }
+  if (!fs25.existsSync(PATHS.stacks)) {
+    fs25.mkdirSync(PATHS.stacks, { recursive: true });
+  }
+  copyRecursive(oldPath, newPath);
+  return { success: true, copied: true };
+}
+function copyRecursive(src, dest) {
+  const stat = fs25.statSync(src);
+  if (stat.isDirectory()) {
+    fs25.mkdirSync(dest, { recursive: true });
+    for (const child of fs25.readdirSync(src)) {
+      copyRecursive(path23.join(src, child), path23.join(dest, child));
+    }
+  } else {
+    fs25.copyFileSync(src, dest);
+  }
+}
+function ensureShim2() {
+  const shimsDir = path23.dirname(SHIM_PATH2);
+  if (!fs25.existsSync(shimsDir)) {
+    fs25.mkdirSync(shimsDir, { recursive: true });
+  }
+  const shimContent = `#!/usr/bin/env bash
+set -euo pipefail
+if command -v rudi &> /dev/null; then
+  exec rudi mcp "$1"
+else
+  exec npx --yes @learnrudi/cli mcp "$1"
+fi
+`;
+  fs25.writeFileSync(SHIM_PATH2, shimContent, { mode: 493 });
+}
+function buildNewEntry(stackName, agentId) {
+  const base = {
+    command: SHIM_PATH2,
+    args: [stackName]
+  };
+  if (agentId === "claude-desktop" || agentId === "claude-code") {
+    return { type: "stdio", ...base };
+  }
+  return base;
+}
+function isOldEntry(entry) {
+  if (!entry) return false;
+  const command = entry.command || "";
+  const args = entry.args || [];
+  const cwd = entry.cwd || "";
+  return command.includes(".prompt-stack") || args.some((a) => typeof a === "string" && a.includes(".prompt-stack")) || cwd.includes(".prompt-stack");
+}
+function migrateAgentConfig(agentConfig, installedStacks, flags) {
+  const configPath = findAgentConfig(agentConfig);
+  if (!configPath) return { skipped: true, reason: "Config not found" };
+  let config;
+  try {
+    config = JSON.parse(fs25.readFileSync(configPath, "utf-8"));
+  } catch {
+    return { skipped: true, reason: "Could not parse config" };
+  }
+  const key = agentConfig.key;
+  const mcpServers = config[key] || {};
+  let updated = 0;
+  let removed = 0;
+  const changes = [];
+  for (const [name, entry] of Object.entries(mcpServers)) {
+    if (isOldEntry(entry)) {
+      if (installedStacks.includes(name)) {
+        const newEntry = buildNewEntry(name, agentConfig.id);
+        mcpServers[name] = newEntry;
+        updated++;
+        changes.push({ name, action: "updated" });
+      } else if (flags.removeOrphans) {
+        delete mcpServers[name];
+        removed++;
+        changes.push({ name, action: "removed (not installed)" });
+      } else {
+        changes.push({ name, action: "skipped (not installed in .rudi)" });
+      }
+    }
+  }
+  if (updated > 0 || removed > 0) {
+    const backupPath = configPath + ".backup." + Date.now();
+    fs25.copyFileSync(configPath, backupPath);
+    config[key] = mcpServers;
+    fs25.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  }
+  return { updated, removed, changes };
+}
+async function cmdMigrate(args, flags) {
+  const subcommand = args[0];
+  if (!subcommand || subcommand === "help") {
+    console.log(`
+rudi migrate - Migrate from .prompt-stack to .rudi
+
+USAGE
+  rudi migrate status         Show what needs to be migrated
+  rudi migrate stacks         Copy stacks from .prompt-stack to .rudi
+  rudi migrate configs        Update agent configs to use new shim
+  rudi migrate all            Do everything
+
+OPTIONS
+  --remove-orphans    Remove entries for stacks not installed in .rudi
+  --dry-run           Show what would be done without making changes
+`);
+    return;
+  }
+  if (subcommand === "status") {
+    await migrateStatus();
+    return;
+  }
+  if (subcommand === "stacks") {
+    await migrateStacks(flags);
+    return;
+  }
+  if (subcommand === "configs") {
+    await migrateConfigs(flags);
+    return;
+  }
+  if (subcommand === "all") {
+    await migrateStacks(flags);
+    console.log("");
+    await migrateConfigs(flags);
+    return;
+  }
+  console.error(`Unknown subcommand: ${subcommand}`);
+  console.error("Run: rudi migrate help");
+}
+async function migrateStatus() {
+  console.log("\n=== Migration Status ===\n");
+  const oldStacks = getOldStacks();
+  console.log(`Old .prompt-stack stacks: ${oldStacks.length}`);
+  if (oldStacks.length > 0) {
+    for (const name of oldStacks) {
+      const existsInRudi = fs25.existsSync(path23.join(PATHS.stacks, name));
+      const status = existsInRudi ? "\u2713 (already in .rudi)" : "\u25CB (needs migration)";
+      console.log(`  ${status} ${name}`);
+    }
+  }
+  const newStacksDir = PATHS.stacks;
+  let newStacks = [];
+  if (fs25.existsSync(newStacksDir)) {
+    newStacks = fs25.readdirSync(newStacksDir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).map((d) => d.name);
+  }
+  console.log(`
+New .rudi stacks: ${newStacks.length}`);
+  if (newStacks.length > 0) {
+    for (const name of newStacks) {
+      console.log(`  \u2713 ${name}`);
+    }
+  }
+  console.log("\n=== Agent Configs ===\n");
+  for (const agentConfig of AGENT_CONFIGS2) {
+    const configPath = findAgentConfig(agentConfig);
+    if (!configPath) continue;
+    let config;
+    try {
+      config = JSON.parse(fs25.readFileSync(configPath, "utf-8"));
+    } catch {
+      continue;
+    }
+    const mcpServers = config[agentConfig.key] || {};
+    const entries = Object.entries(mcpServers);
+    const oldEntries = entries.filter(([_, e]) => isOldEntry(e));
+    const newEntries = entries.filter(([_, e]) => !isOldEntry(e));
+    if (entries.length === 0) continue;
+    console.log(`${agentConfig.name}:`);
+    console.log(`  Config: ${configPath}`);
+    console.log(`  Old entries: ${oldEntries.length}`);
+    console.log(`  New entries: ${newEntries.length}`);
+    if (oldEntries.length > 0) {
+      console.log("  Needs update:");
+      for (const [name] of oldEntries) {
+        const installed = newStacks.includes(name);
+        const status = installed ? "(ready)" : "(not in .rudi)";
+        console.log(`    - ${name} ${status}`);
+      }
+    }
+    console.log("");
+  }
+  console.log("Run: rudi migrate all");
+}
+async function migrateStacks(flags) {
+  console.log("=== Migrating Stacks ===\n");
+  const oldStacks = getOldStacks();
+  if (oldStacks.length === 0) {
+    console.log("No stacks found in .prompt-stack");
+    return;
+  }
+  console.log(`Found ${oldStacks.length} stack(s) in .prompt-stack
+`);
+  for (const name of oldStacks) {
+    if (flags.dryRun) {
+      const exists = fs25.existsSync(path23.join(PATHS.stacks, name));
+      console.log(`  [dry-run] ${name}: ${exists ? "would skip (exists)" : "would copy"}`);
+    } else {
+      const result = copyStack(name);
+      if (result.skipped) {
+        console.log(`  \u25CB ${name}: skipped (${result.reason})`);
+      } else if (result.copied) {
+        console.log(`  \u2713 ${name}: copied to .rudi/stacks/`);
+      } else {
+        console.log(`  \u2717 ${name}: ${result.error}`);
+      }
+    }
+  }
+  if (!flags.dryRun) {
+    console.log(`
+Stacks migrated to: ${PATHS.stacks}`);
+  }
+}
+async function migrateConfigs(flags) {
+  console.log("=== Updating Agent Configs ===\n");
+  if (!flags.dryRun) {
+    ensureShim2();
+    console.log(`Shim ready: ${SHIM_PATH2}
+`);
+  }
+  let installedStacks = [];
+  if (fs25.existsSync(PATHS.stacks)) {
+    installedStacks = fs25.readdirSync(PATHS.stacks, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).map((d) => d.name);
+  }
+  for (const agentConfig of AGENT_CONFIGS2) {
+    const configPath = findAgentConfig(agentConfig);
+    if (!configPath) continue;
+    if (flags.dryRun) {
+      console.log(`${agentConfig.name}:`);
+      console.log(`  [dry-run] Would update entries using .prompt-stack paths`);
+      continue;
+    }
+    const result = migrateAgentConfig(agentConfig, installedStacks, flags);
+    if (result.skipped) {
+      continue;
+    }
+    console.log(`${agentConfig.name}:`);
+    console.log(`  Config: ${configPath}`);
+    if (result.changes && result.changes.length > 0) {
+      for (const change of result.changes) {
+        console.log(`    ${change.action}: ${change.name}`);
+      }
+    }
+    if (result.updated > 0 || result.removed > 0) {
+      console.log(`  Updated: ${result.updated}, Removed: ${result.removed}`);
+    } else {
+      console.log(`  No changes needed`);
+    }
+    console.log("");
+  }
+  console.log("Restart your agents to use the updated configs.");
+}
+
 // src/index.js
 var VERSION = "2.0.0";
 async function main() {
@@ -20205,6 +21396,11 @@ async function main() {
       case "check":
         await cmdDoctor(args, flags);
         break;
+      case "init":
+      case "bootstrap":
+      case "setup":
+        await cmdInit(args, flags);
+        break;
       case "update":
       case "upgrade":
         await cmdUpdate(args, flags);
@@ -20222,6 +21418,15 @@ async function main() {
       case "login":
         await cmdAuth(args, flags);
         break;
+      case "mcp":
+        await cmdMcp(args, flags);
+        break;
+      case "integrate":
+        await cmdIntegrate(args, flags);
+        break;
+      case "migrate":
+        await cmdMigrate(args, flags);
+        break;
       case "home":
       case "status":
         await cmdHome(args, flags);