@piut/cli 3.6.0 → 3.8.0

package/dist/cli.js

@@ -1,16 +1,338 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/lib/tree-prompt.ts
+var tree_prompt_exports = {};
+__export(tree_prompt_exports, {
+  collapseNode: () => collapseNode,
+  default: () => tree_prompt_default,
+  expandNode: () => expandNode,
+  getParentIndex: () => getParentIndex,
+  loadChildren: () => loadChildren,
+  shouldShowInTree: () => shouldShowInTree
+});
+import fs13 from "fs";
+import path14 from "path";
+import os8 from "os";
+import {
+  createPrompt,
+  useState,
+  useKeypress,
+  usePagination,
+  useRef,
+  isUpKey,
+  isDownKey,
+  isSpaceKey,
+  isEnterKey
+} from "@inquirer/core";
+import chalk12 from "chalk";
+function shouldShowInTree(name) {
+  if (TREE_SKIP.has(name)) return false;
+  if (name.startsWith(".") && !TREE_INCLUDE_DOT_DIRS.has(name)) return false;
+  return true;
+}
+function shouldShowFile(name) {
+  if (name.startsWith(".")) return false;
+  const ext = path14.extname(name).toLowerCase();
+  return !HIDDEN_FILE_EXTENSIONS.has(ext);
+}
+function loadChildren(parentPath, parentDepth, includeFiles = false) {
+  try {
+    const entries = fs13.readdirSync(parentPath, { withFileTypes: true });
+    const dirs = [];
+    const files = [];
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (!shouldShowInTree(entry.name)) continue;
+        dirs.push({
+          path: path14.join(parentPath, entry.name),
+          name: entry.name,
+          depth: parentDepth + 1,
+          expanded: false,
+          selected: false,
+          children: null
+        });
+      } else if (includeFiles && entry.isFile()) {
+        if (!shouldShowFile(entry.name)) continue;
+        files.push({
+          path: path14.join(parentPath, entry.name),
+          name: entry.name,
+          depth: parentDepth + 1,
+          expanded: false,
+          selected: false,
+          children: null,
+          isFile: true
+        });
+      }
+    }
+    dirs.sort((a, b) => a.name.localeCompare(b.name));
+    files.sort((a, b) => a.name.localeCompare(b.name));
+    return [...dirs, ...files];
+  } catch {
+    return [];
+  }
+}
+function expandNode(items, index, children) {
+  const result = [...items];
+  result[index] = { ...result[index], expanded: true, children, empty: children.length === 0 };
+  result.splice(index + 1, 0, ...children);
+  return result;
+}
+function collapseNode(items, index) {
+  const node = items[index];
+  const result = [...items];
+  result[index] = { ...result[index], expanded: false };
+  let removeCount = 0;
+  for (let i = index + 1; i < result.length; i++) {
+    if (result[i].depth > node.depth) {
+      removeCount++;
+    } else {
+      break;
+    }
+  }
+  if (removeCount > 0) {
+    result.splice(index + 1, removeCount);
+  }
+  return result;
+}
+function getParentIndex(items, index) {
+  const targetDepth = items[index].depth - 1;
+  for (let i = index - 1; i >= 0; i--) {
+    if (items[i].depth === targetDepth) return i;
+  }
+  return index;
+}
+var TREE_SKIP, TREE_INCLUDE_DOT_DIRS, HIDDEN_FILE_EXTENSIONS, treePrompt, tree_prompt_default;
+var init_tree_prompt = __esm({
+  "src/lib/tree-prompt.ts"() {
+    "use strict";
+    init_esm_shims();
+    TREE_SKIP = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".git",
+      "__pycache__",
+      ".venv",
+      "venv",
+      "dist",
+      "build",
+      ".next",
+      ".nuxt",
+      ".output",
+      ".Trash",
+      "Library",
+      ".cache",
+      ".npm",
+      ".yarn",
+      ".pnpm-store",
+      "Caches",
+      "Cache",
+      ".piut",
+      "Applications",
+      "Public",
+      "Movies",
+      "Music",
+      "Pictures",
+      "Templates"
+    ]);
+    TREE_INCLUDE_DOT_DIRS = /* @__PURE__ */ new Set([
+      ".cursor",
+      ".windsurf",
+      ".openclaw",
+      ".zed",
+      ".github",
+      ".amazonq",
+      ".gemini",
+      ".mcporter",
+      ".paperclip",
+      ".vscode"
+    ]);
+    HIDDEN_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
+      ".png",
+      ".jpg",
+      ".jpeg",
+      ".gif",
+      ".svg",
+      ".ico",
+      ".webp",
+      ".bmp",
+      ".tiff",
+      ".heic",
+      ".mp3",
+      ".mp4",
+      ".wav",
+      ".aac",
+      ".flac",
+      ".ogg",
+      ".avi",
+      ".mov",
+      ".mkv",
+      ".wmv",
+      ".webm",
+      ".zip",
+      ".tar",
+      ".gz",
+      ".bz2",
+      ".xz",
+      ".7z",
+      ".rar",
+      ".dmg",
+      ".iso",
+      ".exe",
+      ".dll",
+      ".so",
+      ".dylib",
+      ".o",
+      ".a",
+      ".wasm",
+      ".class",
+      ".jar",
+      ".pyc",
+      ".pyo",
+      ".ttf",
+      ".otf",
+      ".woff",
+      ".woff2",
+      ".eot",
+      ".lock",
+      ".map"
+    ]);
+    treePrompt = createPrompt((config, done) => {
+      const root = config.root ?? os8.homedir();
+      const pageSize = config.pageSize ?? 15;
+      const mode = config.mode ?? "folders";
+      const includeFiles = mode === "files";
+      const prefix = chalk12.green("?");
+      const childrenCache = useRef(/* @__PURE__ */ new Map()).current;
+      const [items, setItems] = useState(() => {
+        const rootChildren = loadChildren(root, -1, includeFiles);
+        childrenCache.set(root, rootChildren);
+        return rootChildren;
+      });
+      const [active, setActive] = useState(0);
+      const [done_, setDone] = useState(false);
+      useKeypress((event) => {
+        if (done_) return;
+        if (isEnterKey(event)) {
+          const selected = items.filter((n) => n.selected).map((n) => n.path);
+          setDone(true);
+          done(selected);
+          return;
+        }
+        if (isUpKey(event)) {
+          setActive(Math.max(0, active - 1));
+          return;
+        }
+        if (isDownKey(event)) {
+          setActive(Math.min(items.length - 1, active + 1));
+          return;
+        }
+        if (isSpaceKey(event)) {
+          const node = items[active];
+          if (includeFiles && !node.isFile) return;
+          if (!includeFiles && node.isFile) return;
+          const updated = [...items];
+          updated[active] = { ...updated[active], selected: !updated[active].selected };
+          setItems(updated);
+          return;
+        }
+        if (event.name === "right") {
+          const node = items[active];
+          if (node.isFile) return;
+          if (node.expanded) return;
+          let children;
+          if (childrenCache.has(node.path)) {
+            children = childrenCache.get(node.path);
+          } else {
+            children = loadChildren(node.path, node.depth, includeFiles);
+            childrenCache.set(node.path, children);
+          }
+          setItems(expandNode(items, active, children));
+          return;
+        }
+        if (event.name === "left") {
+          const node = items[active];
+          if (!node.isFile && node.expanded) {
+            setItems(collapseNode(items, active));
+          } else {
+            const parentIdx = getParentIndex(items, active);
+            setActive(parentIdx);
+          }
+          return;
+        }
+      });
+      if (done_) {
+        const selected = items.filter((n) => n.selected);
+        const label = includeFiles ? "file" : "folder";
+        const summary = selected.length === 0 ? chalk12.dim(`no ${label}s selected`) : selected.map((n) => n.isFile ? n.name : n.path).join(", ");
+        return `${prefix} ${config.message} ${chalk12.cyan(summary)}`;
+      }
+      const page = usePagination({
+        items,
+        active,
+        pageSize,
+        loop: false,
+        renderItem({ item, isActive }) {
+          const indent = "  ".repeat(item.depth + 1);
+          if (item.isFile) {
+            const marker2 = item.selected ? chalk12.green("\u25CF ") : "\u25CB ";
+            const line2 = `${indent}  ${marker2}${item.name}`;
+            return isActive ? chalk12.cyan(line2) : line2;
+          }
+          const icon = item.expanded ? "\u25BE" : "\u25B8";
+          const name = `${item.name}/`;
+          const suffix = item.error ? chalk12.dim(" (permission denied)") : item.empty ? chalk12.dim(" (empty)") : "";
+          if (includeFiles) {
+            const line2 = `${indent}${icon} ${name}${suffix}`;
+            return isActive ? chalk12.cyan(line2) : chalk12.dim(line2);
+          }
+          const marker = item.selected ? chalk12.green("\u25CF ") : "\u25CB ";
+          const line = `${indent}${icon} ${marker}${name}${suffix}`;
+          return isActive ? chalk12.cyan(line) : line;
+        }
+      });
+      const selectHint = includeFiles ? "space select file" : "space select";
+      const help = chalk12.dim(`  \u2191\u2193 navigate  \u2192 expand  \u2190 collapse  ${selectHint}  enter done`);
+      const header = chalk12.dim(`  ${root}`);
+      return `${prefix} ${config.message}
+${help}
+${header}
+${page}`;
+    });
+    tree_prompt_default = treePrompt;
+  }
+});
 
 // src/cli.ts
+init_esm_shims();
 import { Command } from "commander";
 
 // src/commands/setup.ts
+init_esm_shims();
 import fs4 from "fs";
-import path6 from "path";
+import path7 from "path";
 import { execSync } from "child_process";
 import { password, confirm, checkbox } from "@inquirer/prompts";
 import chalk2 from "chalk";
 
 // src/lib/api.ts
+init_esm_shims();
 import os from "os";
 import crypto from "crypto";
 var API_BASE = process.env.PIUT_API_BASE || "https://piut.com";
@@ -36,7 +358,7 @@ async function loginWithEmail(email, password3) {
   }
   return res.json();
 }
-async function* buildBrainStreaming(key, input3) {
+async function* buildBrainStreaming(key, input2) {
   const res = await fetch(`${API_BASE}/api/cli/build-brain`, {
     method: "POST",
     headers: {
@@ -44,7 +366,7 @@ async function* buildBrainStreaming(key, input3) {
       "Content-Type": "application/json",
       Accept: "text/event-stream"
     },
-    body: JSON.stringify(input3)
+    body: JSON.stringify(input2)
   });
   if (!res.ok) {
     const body = await res.json().catch(() => ({ error: "Unknown error" }));
@@ -122,7 +444,10 @@ async function pingMcp(serverUrl, key, toolName) {
       headers: {
         Authorization: `Bearer ${key}`,
         "Content-Type": "application/json",
-        "User-Agent": `piut-cli (configured: ${toolName})`
+        "User-Agent": `piut-cli (configured: ${toolName})`,
+        "X-Piut-Hostname": os.hostname(),
+        "X-Piut-Machine-Id": getMachineId(),
+        "X-Piut-Tool": toolName
       },
       body: JSON.stringify({
         jsonrpc: "2.0",
@@ -167,6 +492,9 @@ function getMachineId() {
   const hostname = os.hostname();
   return crypto.createHash("sha256").update(hostname).digest("hex").slice(0, 16);
 }
+function getHostname() {
+  return os.hostname();
+}
 async function registerProject(key, project) {
   const res = await fetch(`${API_BASE}/api/cli/projects`, {
     method: "POST",
@@ -209,57 +537,93 @@ async function deleteConnections(key, toolNames) {
   } catch {
   }
 }
-async function resyncBrain(serverUrl, key, content) {
-  const res = await fetch(serverUrl, {
+async function unpublishServer(key) {
+  const res = await fetch(`${API_BASE}/api/mcp/publish`, {
     method: "POST",
     headers: {
       Authorization: `Bearer ${key}`,
       "Content-Type": "application/json"
     },
-    body: JSON.stringify({
-      jsonrpc: "2.0",
-      id: 1,
-      method: "tools/call",
-      params: {
-        name: "update_brain",
-        arguments: { content }
-      }
-    })
+    body: JSON.stringify({ published: false })
   });
   if (!res.ok) {
-    throw new Error(`Resync failed (HTTP ${res.status})`);
+    const body = await res.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(body.error || `Unpublish failed (HTTP ${res.status})`);
   }
-  const data = await res.json();
-  if (data.error) {
-    throw new Error(data.error.message || "Resync failed");
+  return res.json();
+}
+async function listVaultFiles(key) {
+  const res = await fetch(`${API_BASE}/api/cli/vault`, {
+    headers: { Authorization: `Bearer ${key}` }
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(body.error || `Failed to list vault files (HTTP ${res.status})`);
   }
-  const resultContent = data.result?.content;
-  const text = Array.isArray(resultContent) && resultContent[0]?.text ? resultContent[0].text : "Brain updated";
-  return { summary: text };
+  return res.json();
 }
-async function unpublishServer(key) {
-  const res = await fetch(`${API_BASE}/api/mcp/publish`, {
+async function uploadVaultFile(key, filename, content, encoding) {
+  const payload = { filename, content };
+  if (encoding) payload.encoding = encoding;
+  const res = await fetch(`${API_BASE}/api/cli/vault/upload`, {
     method: "POST",
     headers: {
       Authorization: `Bearer ${key}`,
       "Content-Type": "application/json"
     },
-    body: JSON.stringify({ published: false })
+    body: JSON.stringify(payload)
   });
   if (!res.ok) {
     const body = await res.json().catch(() => ({ error: "Unknown error" }));
-    throw new Error(body.error || `Unpublish failed (HTTP ${res.status})`);
+    throw new Error(body.error || `Upload failed (HTTP ${res.status})`);
+  }
+  return res.json();
+}
+async function readVaultFile(key, filename) {
+  const encoded = encodeURIComponent(filename);
+  const res = await fetch(`${API_BASE}/api/cli/vault/${encoded}`, {
+    headers: { Authorization: `Bearer ${key}` }
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(body.error || `Failed to read vault file (HTTP ${res.status})`);
   }
   return res.json();
 }
+async function deleteVaultFile(key, filename) {
+  const res = await fetch(`${API_BASE}/api/cli/vault`, {
+    method: "DELETE",
+    headers: {
+      Authorization: `Bearer ${key}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ filename })
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(body.error || `Delete failed (HTTP ${res.status})`);
+  }
+}
 
 // src/lib/tools.ts
+init_esm_shims();
 import os2 from "os";
-import path from "path";
+import path2 from "path";
+import crypto2 from "crypto";
 var MCP_URL = (slug) => `https://piut.com/api/mcp/${slug}`;
 var AUTH_HEADER = (key) => ({ Authorization: `Bearer ${key}` });
+function getMachineId2() {
+  return crypto2.createHash("sha256").update(os2.hostname()).digest("hex").slice(0, 16);
+}
+function machineHeaders(toolName) {
+  return {
+    "X-Piut-Hostname": os2.hostname(),
+    "X-Piut-Machine-Id": getMachineId2(),
+    "X-Piut-Tool": toolName
+  };
+}
 function appData() {
-  return process.env.APPDATA || path.join(os2.homedir(), "AppData", "Roaming");
+  return process.env.APPDATA || path2.join(os2.homedir(), "AppData", "Roaming");
 }
 var TOOLS = [
   {
@@ -269,18 +633,19 @@ var TOOLS = [
     configPaths: {
       darwin: ["~/.claude.json"],
       win32: ["~/.claude.json"],
-      linux: ["~/.claude.json"]
+      linux: ["~/.claude.json"],
+      project: [".mcp.json"]
     },
     skillFilePath: "CLAUDE.md",
     quickCommand: (slug, key) => `claude mcp add-json piut-context '${JSON.stringify({
       type: "http",
       url: MCP_URL(slug),
-      headers: AUTH_HEADER(key)
+      headers: { ...AUTH_HEADER(key), ...machineHeaders("Claude Code") }
     })}'`,
     generateConfig: (slug, key) => ({
       type: "http",
       url: MCP_URL(slug),
-      headers: AUTH_HEADER(key)
+      headers: { ...AUTH_HEADER(key), ...machineHeaders("Claude Code") }
     })
   },
   {
@@ -289,7 +654,7 @@ var TOOLS = [
     configKey: "mcpServers",
     configPaths: {
       darwin: ["~/Library/Application Support/Claude/claude_desktop_config.json"],
-      win32: [path.join(appData(), "Claude", "claude_desktop_config.json")],
+      win32: [path2.join(appData(), "Claude", "claude_desktop_config.json")],
       linux: ["~/.config/Claude/claude_desktop_config.json"]
     },
     generateConfig: (slug, key) => ({
@@ -316,7 +681,7 @@ var TOOLS = [
     skillFilePath: ".cursor/rules/piut.mdc",
     generateConfig: (slug, key) => ({
       url: MCP_URL(slug),
-      headers: AUTH_HEADER(key)
+      headers: { ...AUTH_HEADER(key), ...machineHeaders("Cursor") }
     })
   },
   {
@@ -331,21 +696,25 @@ var TOOLS = [
     skillFilePath: ".windsurf/rules/piut.md",
     generateConfig: (slug, key) => ({
       serverUrl: MCP_URL(slug),
-      headers: AUTH_HEADER(key)
+      headers: { ...AUTH_HEADER(key), ...machineHeaders("Windsurf") }
     })
   },
   {
     id: "copilot",
     name: "GitHub Copilot",
     configKey: "servers",
+    globalConfigKey: "mcp.servers",
     configPaths: {
+      darwin: ["~/Library/Application Support/Code/User/settings.json"],
+      win32: [path2.join(appData(), "Code", "User", "settings.json")],
+      linux: ["~/.config/Code/User/settings.json"],
       project: [".vscode/mcp.json"]
     },
     skillFilePath: ".github/copilot-instructions.md",
     generateConfig: (slug, key) => ({
       type: "http",
       url: MCP_URL(slug),
-      headers: AUTH_HEADER(key)
+      headers: { ...AUTH_HEADER(key), ...machineHeaders("GitHub Copilot") }
     })
   },
   {
@@ -361,7 +730,7 @@ var TOOLS = [
     generateConfig: (slug, key) => ({
       type: "http",
       url: MCP_URL(slug),
-      headers: AUTH_HEADER(key)
+      headers: { ...AUTH_HEADER(key), ...machineHeaders("Amazon Q") }
     })
   },
   {
@@ -376,35 +745,78 @@ var TOOLS = [
     generateConfig: (slug, key) => ({
       settings: {
         url: MCP_URL(slug),
-        headers: AUTH_HEADER(key)
+        headers: { ...AUTH_HEADER(key), ...machineHeaders("Zed") }
       }
     })
+  },
+  {
+    id: "gemini-cli",
+    name: "Gemini CLI",
+    configKey: "mcpServers",
+    configPaths: {
+      darwin: ["~/.gemini/settings.json"],
+      win32: ["~/.gemini/settings.json"],
+      linux: ["~/.gemini/settings.json"],
+      project: [".gemini/settings.json"]
+    },
+    generateConfig: (slug, key) => ({
+      httpUrl: MCP_URL(slug),
+      headers: { ...AUTH_HEADER(key), ...machineHeaders("Gemini CLI") }
+    })
+  },
+  {
+    id: "openclaw",
+    name: "OpenClaw",
+    configKey: "mcpServers",
+    configPaths: {
+      darwin: ["~/.mcporter/mcporter.json", "~/.openclaw/workspace/config/mcporter.json"],
+      win32: ["~/.mcporter/mcporter.json", "~/.openclaw/workspace/config/mcporter.json"],
+      linux: ["~/.mcporter/mcporter.json", "~/.openclaw/workspace/config/mcporter.json"]
+    },
+    quickCommand: (slug, key) => `npx mcporter config add piut-context ${MCP_URL(slug)} --header "Authorization=Bearer ${key}"`,
+    generateConfig: (slug, key) => ({
+      url: MCP_URL(slug),
+      headers: { ...AUTH_HEADER(key), ...machineHeaders("OpenClaw") }
+    })
+  },
+  {
+    id: "paperclip",
+    name: "Paperclip",
+    skillOnly: true,
+    configPaths: {
+      darwin: ["~/.paperclip/config.json"],
+      win32: ["~/.paperclip/config.json"],
+      linux: ["~/.paperclip/config.json"]
+    }
   }
 ];
 
 // src/lib/paths.ts
+init_esm_shims();
 import os3 from "os";
-import path2 from "path";
+import path3 from "path";
 function expandPath(p) {
   return p.replace(/^~/, os3.homedir());
 }
-function resolveConfigPaths(configPaths) {
+function resolveConfigPaths(tool) {
   const resolved = [];
+  const configKey = tool.configKey || "";
   const platformKey = process.platform;
-  const globalPaths = configPaths[platformKey] || [];
+  const globalPaths = tool.configPaths[platformKey] || [];
   for (const p of globalPaths) {
-    resolved.push(expandPath(p));
+    resolved.push({ filePath: expandPath(p), configKey: tool.globalConfigKey || configKey });
   }
-  const projectPaths = configPaths.project || [];
+  const projectPaths = tool.configPaths.project || [];
   for (const p of projectPaths) {
-    resolved.push(path2.resolve(process.cwd(), p));
+    resolved.push({ filePath: path3.resolve(process.cwd(), p), configKey });
   }
   return resolved;
 }
 
 // src/lib/config.ts
+init_esm_shims();
 import fs from "fs";
-import path3 from "path";
+import path4 from "path";
 function readConfig(filePath) {
   let raw;
   try {
@@ -425,26 +837,46 @@ function readConfig(filePath) {
   }
 }
 function writeConfig(filePath, data) {
-  fs.mkdirSync(path3.dirname(filePath), { recursive: true });
+  fs.mkdirSync(path4.dirname(filePath), { recursive: true });
   fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
 }
+function resolveKeyPath(config, keyPath) {
+  const parts = keyPath.split(".");
+  let current = config;
+  for (const part of parts) {
+    if (current === void 0 || current === null || typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function setAtKeyPath(config, keyPath, value) {
+  const parts = keyPath.split(".");
+  let current = config;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (!current[parts[i]] || typeof current[parts[i]] !== "object") {
+      current[parts[i]] = {};
+    }
+    current = current[parts[i]];
+  }
+  current[parts[parts.length - 1]] = value;
+}
 function isPiutConfigured(filePath, configKey) {
   const config = readConfig(filePath);
   if (!config) return false;
-  const servers = config[configKey];
+  const servers = resolveKeyPath(config, configKey);
   return !!servers?.["piut-context"];
 }
 function mergeConfig(filePath, configKey, serverConfig) {
   const existing = readConfig(filePath) || {};
-  const servers = existing[configKey] || {};
+  const servers = resolveKeyPath(existing, configKey) || {};
   servers["piut-context"] = serverConfig;
-  existing[configKey] = servers;
+  setAtKeyPath(existing, configKey, servers);
   writeConfig(filePath, existing);
 }
 function getPiutConfig(filePath, configKey) {
   const config = readConfig(filePath);
   if (!config) return null;
-  const servers = config[configKey];
+  const servers = resolveKeyPath(config, configKey);
   const piut = servers?.["piut-context"];
   return piut ?? null;
 }
@@ -471,13 +903,35 @@ function extractKeyFromConfig(piutConfig) {
   }
   return null;
 }
+function extractSlugFromConfig(piutConfig) {
+  const slugFromUrl = (u) => {
+    if (typeof u !== "string") return null;
+    const m = u.match(/\/api\/mcp\/([^/?#]+)/);
+    return m ? m[1] : null;
+  };
+  const fromUrl = slugFromUrl(piutConfig.url) || slugFromUrl(piutConfig.serverUrl) || slugFromUrl(piutConfig.httpUrl);
+  if (fromUrl) return fromUrl;
+  const settings = piutConfig.settings;
+  if (settings) {
+    const fromSettings = slugFromUrl(settings.url);
+    if (fromSettings) return fromSettings;
+  }
+  const args2 = piutConfig.args;
+  if (Array.isArray(args2)) {
+    for (const arg of args2) {
+      const fromArg = slugFromUrl(arg);
+      if (fromArg) return fromArg;
+    }
+  }
+  return null;
+}
 function removeFromConfig(filePath, configKey) {
   const config = readConfig(filePath);
   if (!config) return false;
-  const servers = config[configKey];
+  const servers = resolveKeyPath(config, configKey);
   if (!servers?.["piut-context"]) return false;
   delete servers["piut-context"];
-  if (Object.keys(servers).length === 0) {
+  if (Object.keys(servers).length === 0 && !configKey.includes(".")) {
     delete config[configKey];
   }
   writeConfig(filePath, config);
@@ -485,8 +939,9 @@ function removeFromConfig(filePath, configKey) {
 }
 
 // src/lib/skill.ts
+init_esm_shims();
 import fs2 from "fs";
-import path4 from "path";
+import path5 from "path";
 var SKILL_SNIPPET = `## p\u0131ut Context (MCP Server: piut-context)
 
 This project uses p\u0131ut for persistent personal context via MCP (Model Context Protocol).
@@ -529,7 +984,7 @@ p\u0131ut provides MCP tools \u2014 do NOT read local .piut/ files directly. Use
 Full skill reference: .piut/skill.md`;
 var SEPARATOR = "\n\n---\n\n";
 function placeSkillFile(filePath) {
-  const absPath = path4.isAbsolute(filePath) ? filePath : path4.resolve(process.cwd(), filePath);
+  const absPath = path5.isAbsolute(filePath) ? filePath : path5.resolve(process.cwd(), filePath);
   try {
     const existing = fs2.readFileSync(absPath, "utf-8");
     if (existing.includes("p\u0131ut Context")) {
@@ -539,7 +994,7 @@ function placeSkillFile(filePath) {
     return { created: false, appended: true };
   } catch (err) {
     if (err.code === "ENOENT") {
-      fs2.mkdirSync(path4.dirname(absPath), { recursive: true });
+      fs2.mkdirSync(path5.dirname(absPath), { recursive: true });
       fs2.writeFileSync(absPath, SKILL_SNIPPET + "\n", "utf-8");
       return { created: true, appended: false };
     }
@@ -548,8 +1003,9 @@ function placeSkillFile(filePath) {
 }
 
 // src/lib/piut-dir.ts
+init_esm_shims();
 import fs3 from "fs";
-import path5 from "path";
+import path6 from "path";
 var API_BASE2 = process.env.PIUT_API_BASE || "https://piut.com";
 var PIUT_DIR = ".piut";
 var CONFIG_FILE = "config.json";
@@ -591,13 +1047,13 @@ Protocol: JSON-RPC 2.0 over HTTPS
 4. Use \`append_brain\` for quick notes and facts
 `;
 function piutDir(projectPath) {
-  return path5.join(projectPath, PIUT_DIR);
+  return path6.join(projectPath, PIUT_DIR);
 }
 function writePiutConfig(projectPath, config) {
   const dir = piutDir(projectPath);
   fs3.mkdirSync(dir, { recursive: true });
   fs3.writeFileSync(
-    path5.join(dir, CONFIG_FILE),
+    path6.join(dir, CONFIG_FILE),
     JSON.stringify(config, null, 2) + "\n",
     "utf-8"
   );
@@ -614,10 +1070,10 @@ async function writePiutSkill(projectPath, slug, apiKey) {
     content = MINIMAL_SKILL_CONTENT;
   }
   content = content.replaceAll("{{slug}}", slug).replaceAll("{{key}}", apiKey);
-  fs3.writeFileSync(path5.join(dir, SKILL_FILE), content, "utf-8");
+  fs3.writeFileSync(path6.join(dir, SKILL_FILE), content, "utf-8");
 }
 function ensureGitignored(projectPath) {
-  const gitignorePath = path5.join(projectPath, ".gitignore");
+  const gitignorePath = path6.join(projectPath, ".gitignore");
   let content = "";
   try {
     content = fs3.readFileSync(gitignorePath, "utf-8");
@@ -642,10 +1098,11 @@ function removePiutDir(projectPath) {
   return true;
 }
 function hasPiutDir(projectPath) {
-  return fs3.existsSync(path5.join(piutDir(projectPath), CONFIG_FILE));
+  return fs3.existsSync(path6.join(piutDir(projectPath), CONFIG_FILE));
 }
 
 // src/lib/ui.ts
+init_esm_shims();
 import chalk from "chalk";
 var brand = chalk.hex("#8B5CF6");
 var success = chalk.green;
@@ -731,6 +1188,7 @@ var Spinner = class {
 };
 
 // src/types.ts
+init_esm_shims();
 var CliError = class extends Error {
   constructor(message) {
     super(message || "");
@@ -781,25 +1239,31 @@ async function setupCommand(options) {
   const toolFilter = options.tool;
   for (const tool of TOOLS) {
     if (toolFilter && tool.id !== toolFilter) continue;
-    const paths = resolveConfigPaths(tool.configPaths);
-    for (const configPath of paths) {
-      const exists = fs4.existsSync(configPath);
-      const parentExists = fs4.existsSync(path6.dirname(configPath));
+    if (tool.skillOnly) continue;
+    const paths = resolveConfigPaths(tool);
+    for (const { filePath, configKey } of paths) {
+      const exists = fs4.existsSync(filePath);
+      const parentExists = fs4.existsSync(path7.dirname(filePath));
       if (exists || parentExists) {
-        const configured2 = exists && isPiutConfigured(configPath, tool.configKey);
+        const configured2 = exists && !!configKey && isPiutConfigured(filePath, configKey);
         let staleKey = false;
-        if (configured2) {
-          const piutConfig = getPiutConfig(configPath, tool.configKey);
+        if (configured2 && configKey) {
+          const piutConfig = getPiutConfig(filePath, configKey);
           if (piutConfig) {
             const existingKey = extractKeyFromConfig(piutConfig);
             if (existingKey && existingKey !== apiKey) {
               staleKey = true;
             }
+            const existingSlug = extractSlugFromConfig(piutConfig);
+            if (existingSlug && existingSlug !== slug) {
+              staleKey = true;
+            }
           }
         }
         detected.push({
           tool,
-          configPath,
+          configPath: filePath,
+          resolvedConfigKey: configKey,
           exists,
           alreadyConfigured: configured2 && !staleKey,
           staleKey
@@ -810,7 +1274,6 @@ async function setupCommand(options) {
   }
   if (detected.length === 0) {
     console.log(warning("  No supported AI tools detected."));
-    console.log(dim("  Supported: Claude Code, Claude Desktop, Cursor, Windsurf, GitHub Copilot, Amazon Q, Zed"));
     console.log(dim("  See https://piut.com/docs for manual setup."));
     console.log();
     return;
@@ -862,7 +1325,7 @@ async function setupCommand(options) {
       try {
         execSync(tool.quickCommand(slug, apiKey), { stdio: "pipe" });
         const claudeJson = expandPath("~/.claude.json");
-        const written = getPiutConfig(claudeJson, tool.configKey);
+        const written = tool.configKey ? getPiutConfig(claudeJson, tool.configKey) : null;
         if (written) {
           quickSuccess = true;
           configured.push(tool.name);
@@ -871,7 +1334,7 @@ async function setupCommand(options) {
         }
         try {
           execSync(tool.quickCommand(slug, apiKey) + " --scope user", { stdio: "pipe" });
-          const retryCheck = getPiutConfig(claudeJson, tool.configKey);
+          const retryCheck = tool.configKey ? getPiutConfig(claudeJson, tool.configKey) : null;
           if (retryCheck) {
             quickSuccess = true;
             configured.push(tool.name);
@@ -890,10 +1353,12 @@ async function setupCommand(options) {
       }
       if (quickSuccess) continue;
     }
-    const serverConfig = tool.generateConfig(slug, apiKey);
-    mergeConfig(configPath, tool.configKey, serverConfig);
-    configured.push(tool.name);
-    toolLine(tool.name, success("configured"), "\u2714");
+    if (tool.generateConfig && det.resolvedConfigKey) {
+      const serverConfig = tool.generateConfig(slug, apiKey);
+      mergeConfig(configPath, det.resolvedConfigKey, serverConfig);
+      configured.push(tool.name);
+      toolLine(tool.name, success("configured"), "\u2714");
+    }
   }
   if (!options.skipSkill && configured.length > 0) {
     const addSkill = options.yes ? true : await confirm({
@@ -918,7 +1383,7 @@ async function setupCommand(options) {
   }
   if (configured.length > 0) {
     const cwd = process.cwd();
-    const isProject2 = fs4.existsSync(path6.join(cwd, ".git")) || fs4.existsSync(path6.join(cwd, "package.json"));
+    const isProject2 = fs4.existsSync(path7.join(cwd, ".git")) || fs4.existsSync(path7.join(cwd, "package.json"));
     if (isProject2) {
       const { serverUrl } = validationResult;
       writePiutConfig(cwd, { slug, apiKey, serverUrl });
@@ -934,7 +1399,8 @@ async function setupCommand(options) {
     console.log(dim("  Verifying..."));
     for (const det of selected) {
       if (!configured.includes(det.tool.name)) continue;
-      const piutConfig = getPiutConfig(det.configPath, det.tool.configKey);
+      if (!det.resolvedConfigKey) continue;
+      const piutConfig = getPiutConfig(det.configPath, det.resolvedConfigKey);
       if (piutConfig) {
         toolLine(det.tool.name, success("config verified"), "\u2714");
       } else {
@@ -975,50 +1441,20 @@ function isCommandAvailable(cmd) {
 }
 
 // src/commands/status.ts
-import fs9 from "fs";
-import path12 from "path";
+init_esm_shims();
+import fs7 from "fs";
+import os6 from "os";
+import path10 from "path";
 import chalk3 from "chalk";
 
 // src/lib/brain-scanner.ts
-import fs7 from "fs";
-import path10 from "path";
-import os5 from "os";
+init_esm_shims();
+import fs5 from "fs";
+import path8 from "path";
+import os4 from "os";
 
 // src/lib/file-types.ts
-import path7 from "path";
-var DOCUMENT_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".pdf",
-  ".docx",
-  ".doc",
-  ".pptx",
-  ".pages",
-  ".key",
-  ".rtf",
-  ".odt",
-  ".odp",
-  ".eml",
-  ".mbox"
-]);
-var PLAIN_TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".md",
-  ".markdown",
-  ".txt",
-  ".csv",
-  ".xml",
-  ".html",
-  ".htm",
-  ".json",
-  ".yaml",
-  ".yml",
-  ".toml",
-  ".rst",
-  ".adoc",
-  ".tex",
-  ".ini",
-  ".cfg",
-  ".conf",
-  ".log"
-]);
+init_esm_shims();
 var AI_CONFIG_FILENAMES = /* @__PURE__ */ new Set([
   "CLAUDE.md",
   ".cursorrules",
@@ -1032,350 +1468,46 @@ var AI_CONFIG_FILENAMES = /* @__PURE__ */ new Set([
   "IDENTITY.md",
   "copilot-instructions.md"
 ]);
-var PARSEABLE_EXTENSIONS = /* @__PURE__ */ new Set([
-  ...DOCUMENT_EXTENSIONS,
-  ...PLAIN_TEXT_EXTENSIONS
-]);
-var EXCLUDED_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".js",
-  ".ts",
-  ".jsx",
-  ".tsx",
-  ".mjs",
-  ".cjs",
-  ".py",
-  ".pyw",
-  ".pyi",
-  ".rs",
-  ".go",
-  ".java",
-  ".kt",
-  ".scala",
-  ".clj",
-  ".c",
-  ".cpp",
-  ".cc",
-  ".h",
-  ".hpp",
-  ".cs",
-  ".rb",
-  ".php",
-  ".swift",
-  ".m",
-  ".mm",
-  ".lua",
-  ".r",
-  ".jl",
-  ".zig",
-  ".nim",
-  ".v",
-  ".sh",
-  ".bash",
-  ".zsh",
-  ".fish",
-  ".ps1",
-  ".bat",
-  ".cmd",
-  ".sql",
-  ".graphql",
-  ".gql",
-  ".proto",
-  ".css",
-  ".scss",
-  ".sass",
-  ".less",
-  ".styl",
-  ".xls",
-  ".xlsx",
-  ".numbers",
-  ".sqlite",
-  ".db",
-  ".dat",
-  ".parquet",
-  ".avro",
-  ".png",
-  ".jpg",
-  ".jpeg",
-  ".gif",
-  ".svg",
-  ".ico",
-  ".webp",
-  ".bmp",
-  ".tiff",
-  ".heic",
-  ".mp3",
-  ".mp4",
-  ".wav",
-  ".aac",
-  ".flac",
-  ".ogg",
-  ".avi",
-  ".mov",
-  ".mkv",
-  ".wmv",
-  ".webm",
-  ".zip",
-  ".tar",
-  ".gz",
-  ".bz2",
-  ".xz",
-  ".7z",
-  ".rar",
-  ".dmg",
-  ".iso",
-  ".exe",
-  ".dll",
-  ".so",
-  ".dylib",
-  ".o",
-  ".a",
-  ".wasm",
-  ".class",
-  ".jar",
-  ".pyc",
-  ".pyo",
-  ".ttf",
-  ".otf",
-  ".woff",
-  ".woff2",
-  ".eot",
-  ".lock",
-  ".map",
-  ".min.js",
-  ".min.css"
-]);
-function canParse(filename) {
-  return PARSEABLE_EXTENSIONS.has(path7.extname(filename).toLowerCase());
-}
-function isAiConfigFile(filename) {
-  return AI_CONFIG_FILENAMES.has(path7.basename(filename));
-}
-function getFileCategory(filename) {
-  const base = path7.basename(filename);
-  if (AI_CONFIG_FILENAMES.has(base)) return "config";
-  const ext = path7.extname(filename).toLowerCase();
-  if (DOCUMENT_EXTENSIONS.has(ext)) return "document";
-  if (PLAIN_TEXT_EXTENSIONS.has(ext)) return "text";
-  if (EXCLUDED_EXTENSIONS.has(ext)) return "excluded";
-  return "unknown";
-}
 
-// src/lib/file-parsers.ts
-import fs5 from "fs";
-import path8 from "path";
-var MAX_RAW_SIZE = 500 * 1024;
-var MAX_EXTRACTED_TEXT = 100 * 1024;
-function truncate(text) {
-  if (text.length <= MAX_EXTRACTED_TEXT) return text;
-  return text.slice(0, MAX_EXTRACTED_TEXT);
-}
-function stripHtml(html) {
-  return html.replace(/<br\s*\/?>/gi, "\n").replace(/<\/p>/gi, "\n").replace(/<\/div>/gi, "\n").replace(/<\/li>/gi, "\n").replace(/<[^>]+>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").replace(/\n{3,}/g, "\n\n").trim();
-}
-async function parsePdf(buffer) {
-  const { PDFParse } = await import("pdf-parse");
-  const parser = new PDFParse({ data: new Uint8Array(buffer) });
-  const result = await parser.getText();
-  return result.text;
-}
-async function parseDocx(buffer) {
-  const { extractRawText } = await import("mammoth");
-  const result = await extractRawText({ buffer });
-  return result.value;
-}
-async function parsePptx(buffer) {
-  const JSZip = (await import("jszip")).default;
-  const zip = await JSZip.loadAsync(buffer);
-  const texts = [];
-  const slideFiles = Object.keys(zip.files).filter((name) => /^ppt\/slides\/slide\d+\.xml$/i.test(name)).sort((a, b) => {
-    const numA = parseInt(a.match(/slide(\d+)/)?.[1] || "0");
-    const numB = parseInt(b.match(/slide(\d+)/)?.[1] || "0");
-    return numA - numB;
-  });
-  for (const slidePath of slideFiles) {
-    const xml = await zip.files[slidePath].async("string");
-    const matches = xml.match(/<a:t[^>]*>([^<]*)<\/a:t>/g);
-    if (matches) {
-      texts.push(matches.map((m) => m.replace(/<[^>]+>/g, "")).join(" "));
-    }
-  }
-  return texts.join("\n\n");
-}
-async function parseAppleDoc(buffer) {
-  const JSZip = (await import("jszip")).default;
-  const zip = await JSZip.loadAsync(buffer);
-  if (zip.files["preview.pdf"]) {
-    const pdfBuf = await zip.files["preview.pdf"].async("nodebuffer");
-    try {
-      return await parsePdf(pdfBuf);
-    } catch {
-    }
-  }
-  const texts = [];
-  for (const [name, file] of Object.entries(zip.files)) {
-    if (name.endsWith(".iwa") && !file.dir) {
-      try {
-        const buf = await file.async("nodebuffer");
-        const str = buf.toString("utf-8");
-        const readable = str.match(/[\x20-\x7E\xC0-\xFF]{4,}/g);
-        if (readable) {
-          texts.push(...readable.filter((s) => s.length > 10));
-        }
-      } catch {
-      }
-    }
-  }
-  return texts.join("\n\n");
-}
-async function parseRtf(buffer) {
-  const { fromString } = await import("@iarna/rtf-to-html");
-  return new Promise((resolve, reject) => {
-    fromString(buffer.toString("utf-8"), (err, html) => {
-      if (err) {
-        reject(err);
-        return;
-      }
-      resolve(stripHtml(html));
-    });
-  });
-}
-async function parseOpenDocument(buffer) {
-  const JSZip = (await import("jszip")).default;
-  const zip = await JSZip.loadAsync(buffer);
-  const contentXml = zip.files["content.xml"];
-  if (!contentXml) return "";
-  return stripHtml(await contentXml.async("string"));
-}
-function parseEml(buffer) {
-  const content = buffer.toString("utf-8");
-  const boundaryMatch = content.match(/boundary="?([^\s"]+)"?/i);
-  if (boundaryMatch) {
-    const parts = content.split(`--${boundaryMatch[1]}`);
-    for (const part of parts) {
-      if (/content-type:\s*text\/plain/i.test(part)) {
-        const bodyStart = part.indexOf("\n\n");
-        if (bodyStart !== -1) return part.slice(bodyStart + 2).trim();
-      }
-    }
-  }
-  const headerEnd = content.indexOf("\n\n");
-  if (headerEnd !== -1) {
-    const body = content.slice(headerEnd + 2);
-    if (!/<html/i.test(body.slice(0, 200))) return body.trim();
-    return stripHtml(body);
-  }
-  return content.trim();
-}
-function parseMbox(buffer) {
-  const content = buffer.toString("utf-8");
-  const messages = content.split(/^From /m).filter(Boolean);
-  const texts = [];
-  for (const msg of messages.slice(0, 50)) {
-    const headerEnd = msg.indexOf("\n\n");
-    if (headerEnd !== -1) {
-      const body = msg.slice(headerEnd + 2);
-      texts.push(!/<html/i.test(body.slice(0, 200)) ? body.trim() : stripHtml(body));
-    }
-  }
-  return texts.join("\n\n---\n\n");
-}
-async function extractTextFromFile(filePath) {
-  const ext = path8.extname(filePath).toLowerCase();
-  try {
-    const stat = fs5.statSync(filePath);
-    if (!stat.isFile()) return null;
-    if (stat.size > MAX_RAW_SIZE) return null;
-  } catch {
-    return null;
-  }
-  if (PLAIN_TEXT_EXTENSIONS.has(ext)) {
-    try {
-      return truncate(fs5.readFileSync(filePath, "utf-8"));
-    } catch {
-      return null;
-    }
-  }
-  if (!DOCUMENT_EXTENSIONS.has(ext)) return null;
-  try {
-    const buffer = fs5.readFileSync(filePath);
-    let text;
-    switch (ext) {
-      case ".pdf":
-        text = await parsePdf(buffer);
-        break;
-      case ".docx":
-      case ".doc":
-        text = await parseDocx(buffer);
-        break;
-      case ".pptx":
-        text = await parsePptx(buffer);
-        break;
-      case ".pages":
-      case ".key":
-        text = await parseAppleDoc(buffer);
-        break;
-      case ".rtf":
-        text = await parseRtf(buffer);
-        break;
-      case ".odt":
-      case ".odp":
-        text = await parseOpenDocument(buffer);
-        break;
-      case ".eml":
-        text = parseEml(buffer);
-        break;
-      case ".mbox":
-        text = parseMbox(buffer);
-        break;
-      default:
-        return null;
-    }
-    return truncate(text);
-  } catch {
-    return null;
-  }
-}
-function formatSize(bytes) {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}
-
-// src/lib/folder-tree.ts
-import fs6 from "fs";
-import path9 from "path";
-import os4 from "os";
+// src/lib/brain-scanner.ts
 var home = os4.homedir();
-function displayPath(p) {
-  return p.startsWith(home) ? "~" + p.slice(home.length) : p;
-}
-function groupFilesByFolder(files) {
-  const map = /* @__PURE__ */ new Map();
-  for (const file of files) {
-    const folder = file.folder;
-    if (!map.has(folder)) map.set(folder, []);
-    map.get(folder).push(file);
-  }
-  const results = [];
-  for (const [folderPath, folderFiles] of map) {
-    results.push({
-      path: folderPath,
-      displayPath: displayPath(folderPath),
-      files: folderFiles,
-      fileCount: folderFiles.length,
-      totalBytes: folderFiles.reduce((sum, f) => sum + f.sizeBytes, 0)
-    });
-  }
-  results.sort((a, b) => a.displayPath.localeCompare(b.displayPath));
-  return results;
-}
-function formatFolderChoice(folder) {
-  return `${folder.displayPath} \u2014 ${folder.fileCount} file${folder.fileCount === 1 ? "" : "s"} (${formatSize(folder.totalBytes)})`;
-}
-function formatSelectionSummary(folders) {
-  const totalFiles = folders.reduce((sum, f) => sum + f.fileCount, 0);
-  const totalBytes = folders.reduce((sum, f) => sum + f.totalBytes, 0);
-  return `${folders.length} folder${folders.length === 1 ? "" : "s"} selected (${totalFiles} file${totalFiles === 1 ? "" : "s"}, ${formatSize(totalBytes)})`;
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "__pycache__",
+  ".venv",
+  "venv",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  ".output",
+  ".Trash",
+  "Library",
+  ".cache",
+  ".npm",
+  ".yarn",
+  ".pnpm-store",
+  "Caches",
+  "Cache",
+  ".piut"
+]);
+var SCAN_DOT_DIRS = /* @__PURE__ */ new Set([
+  ".cursor",
+  ".windsurf",
+  ".github",
+  ".zed",
+  ".amazonq",
+  ".vscode",
+  ".gemini",
+  ".openclaw",
+  ".mcporter",
+  ".paperclip"
+  // .claude intentionally excluded — useful files collected by collectGlobalConfigFiles()
+]);
+function shouldSkipDir(name) {
+  if (name.startsWith(".") && !SCAN_DOT_DIRS.has(name)) return true;
+  return SKIP_DIRS.has(name);
 }
 var SKIP_HOME_DIRS = /* @__PURE__ */ new Set([
   "Library",
@@ -1388,33 +1520,36 @@ var SKIP_HOME_DIRS = /* @__PURE__ */ new Set([
   ".Trash"
 ]);
 var INCLUDE_DOT_DIRS = /* @__PURE__ */ new Set([
-  ".claude",
   ".cursor",
   ".windsurf",
   ".openclaw",
   ".zed",
   ".github",
-  ".amazonq"
+  ".amazonq",
+  ".gemini",
+  ".mcporter",
+  ".paperclip"
+  // .claude excluded — useful files collected by collectGlobalConfigFiles()
 ]);
 function getDefaultScanDirs() {
   const dirs = [];
   try {
-    const entries = fs6.readdirSync(home, { withFileTypes: true });
+    const entries = fs5.readdirSync(home, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       if (entry.name.startsWith(".") && !INCLUDE_DOT_DIRS.has(entry.name)) continue;
       if (SKIP_HOME_DIRS.has(entry.name)) continue;
-      dirs.push(path9.join(home, entry.name));
+      dirs.push(path8.join(home, entry.name));
     }
   } catch {
   }
-  const cloudStorage = path9.join(home, "Library", "CloudStorage");
+  const cloudStorage = path8.join(home, "Library", "CloudStorage");
   try {
-    if (fs6.existsSync(cloudStorage) && fs6.statSync(cloudStorage).isDirectory()) {
-      const entries = fs6.readdirSync(cloudStorage, { withFileTypes: true });
+    if (fs5.existsSync(cloudStorage) && fs5.statSync(cloudStorage).isDirectory()) {
+      const entries = fs5.readdirSync(cloudStorage, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
-        const fullPath = path9.join(cloudStorage, entry.name);
+        const fullPath = path8.join(cloudStorage, entry.name);
         if (!dirs.includes(fullPath)) {
           dirs.push(fullPath);
         }
@@ -1425,60 +1560,23 @@ function getDefaultScanDirs() {
   if (dirs.length === 0) dirs.push(home);
   return dirs;
 }
-
-// src/lib/brain-scanner.ts
-var home2 = os5.homedir();
-var SKIP_DIRS = /* @__PURE__ */ new Set([
-  "node_modules",
-  ".git",
-  "__pycache__",
-  ".venv",
-  "venv",
-  "dist",
-  "build",
-  ".next",
-  ".nuxt",
-  ".output",
-  ".Trash",
-  "Library",
-  ".cache",
-  ".npm",
-  ".yarn",
-  ".pnpm-store",
-  "Caches",
-  "Cache",
-  ".piut"
-]);
-var SCAN_DOT_DIRS = /* @__PURE__ */ new Set([
-  ".claude",
-  ".cursor",
-  ".windsurf",
-  ".github",
-  ".zed",
-  ".amazonq",
-  ".vscode"
-]);
-function shouldSkipDir(name) {
-  if (name.startsWith(".") && !SCAN_DOT_DIRS.has(name)) return true;
-  return SKIP_DIRS.has(name);
-}
 function isProject(dirPath) {
-  return fs7.existsSync(path10.join(dirPath, ".git")) || fs7.existsSync(path10.join(dirPath, "package.json")) || fs7.existsSync(path10.join(dirPath, "Cargo.toml")) || fs7.existsSync(path10.join(dirPath, "pyproject.toml")) || fs7.existsSync(path10.join(dirPath, "go.mod"));
+  return fs5.existsSync(path8.join(dirPath, ".git")) || fs5.existsSync(path8.join(dirPath, "package.json")) || fs5.existsSync(path8.join(dirPath, "Cargo.toml")) || fs5.existsSync(path8.join(dirPath, "pyproject.toml")) || fs5.existsSync(path8.join(dirPath, "go.mod"));
 }
 function buildProjectInfo(projectPath) {
-  const hasPkgJson = fs7.existsSync(path10.join(projectPath, "package.json"));
+  const hasPkgJson = fs5.existsSync(path8.join(projectPath, "package.json"));
   let description = "";
   if (hasPkgJson) {
     try {
-      const pkg = JSON.parse(fs7.readFileSync(path10.join(projectPath, "package.json"), "utf-8"));
+      const pkg = JSON.parse(fs5.readFileSync(path8.join(projectPath, "package.json"), "utf-8"));
       description = pkg.description || "";
     } catch {
     }
   }
-  const readmePath = path10.join(projectPath, "README.md");
-  if (!description && fs7.existsSync(readmePath)) {
+  const readmePath = path8.join(projectPath, "README.md");
+  if (!description && fs5.existsSync(readmePath)) {
     try {
-      const content = fs7.readFileSync(readmePath, "utf-8");
+      const content = fs5.readFileSync(readmePath, "utf-8");
       const lines = content.split("\n");
       let foundHeading = false;
       for (const line of lines) {
@@ -1495,15 +1593,15 @@ function buildProjectInfo(projectPath) {
     }
   }
   return {
-    name: path10.basename(projectPath),
+    name: path8.basename(projectPath),
     path: projectPath,
     description,
-    hasClaudeMd: fs7.existsSync(path10.join(projectPath, "CLAUDE.md")) || fs7.existsSync(path10.join(projectPath, ".claude", "rules")),
-    hasCursorRules: fs7.existsSync(path10.join(projectPath, ".cursorrules")) || fs7.existsSync(path10.join(projectPath, ".cursor", "rules")),
-    hasWindsurfRules: fs7.existsSync(path10.join(projectPath, ".windsurfrules")) || fs7.existsSync(path10.join(projectPath, ".windsurf", "rules")),
-    hasCopilotInstructions: fs7.existsSync(path10.join(projectPath, ".github", "copilot-instructions.md")) || fs7.existsSync(path10.join(projectPath, ".github", "instructions")),
-    hasConventionsMd: fs7.existsSync(path10.join(projectPath, "CONVENTIONS.md")) || fs7.existsSync(path10.join(projectPath, ".amazonq", "rules")),
-    hasZedRules: fs7.existsSync(path10.join(projectPath, ".rules"))
+    hasClaudeMd: fs5.existsSync(path8.join(projectPath, "CLAUDE.md")) || fs5.existsSync(path8.join(projectPath, ".claude", "rules")),
+    hasCursorRules: fs5.existsSync(path8.join(projectPath, ".cursorrules")) || fs5.existsSync(path8.join(projectPath, ".cursor", "rules")),
+    hasWindsurfRules: fs5.existsSync(path8.join(projectPath, ".windsurfrules")) || fs5.existsSync(path8.join(projectPath, ".windsurf", "rules")),
+    hasCopilotInstructions: fs5.existsSync(path8.join(projectPath, ".github", "copilot-instructions.md")) || fs5.existsSync(path8.join(projectPath, ".github", "instructions")),
+    hasConventionsMd: fs5.existsSync(path8.join(projectPath, "CONVENTIONS.md")) || fs5.existsSync(path8.join(projectPath, ".amazonq", "rules")),
+    hasZedRules: fs5.existsSync(path8.join(projectPath, ".rules"))
   };
 }
 var MAX_PROJECT_DEPTH = 4;
@@ -1513,17 +1611,17 @@ function detectProjects(scanDirs, onProgress) {
   function walk(dir, depth) {
     if (depth > MAX_PROJECT_DEPTH) return;
     try {
-      const items = fs7.readdirSync(dir, { withFileTypes: true });
+      const items = fs5.readdirSync(dir, { withFileTypes: true });
       for (const item of items) {
         if (!item.isDirectory()) continue;
         if (shouldSkipDir(item.name)) continue;
-        const fullPath = path10.join(dir, item.name);
+        const fullPath = path8.join(dir, item.name);
         if (seen.has(fullPath)) continue;
         seen.add(fullPath);
         if (isProject(fullPath)) {
           const info = buildProjectInfo(fullPath);
           projects.push(info);
-          onProgress?.({ phase: "projects", message: `${info.name} (${fullPath.replace(home2, "~")})` });
+          onProgress?.({ phase: "projects", message: `${info.name} (${fullPath})` });
         } else {
           walk(fullPath, depth + 1);
         }
@@ -1537,34 +1635,41 @@ function detectProjects(scanDirs, onProgress) {
   return projects;
 }
 var MAX_CONFIG_SIZE = 100 * 1024;
-function collectConfigFiles(projects, onProgress) {
+var MAX_BRAIN_INPUT_BYTES = 1e6;
+function collectGlobalConfigFiles(onProgress) {
   const configs = [];
   const globalPaths = [
-    path10.join(home2, ".claude", "MEMORY.md"),
-    path10.join(home2, ".claude", "CLAUDE.md"),
-    path10.join(home2, ".openclaw", "workspace", "SOUL.md"),
-    path10.join(home2, ".openclaw", "workspace", "MEMORY.md")
+    path8.join(home, ".claude", "MEMORY.md"),
+    path8.join(home, ".claude", "CLAUDE.md"),
+    path8.join(home, ".openclaw", "workspace", "SOUL.md"),
+    path8.join(home, ".openclaw", "workspace", "MEMORY.md"),
+    path8.join(home, ".gemini", "MEMORY.md"),
+    path8.join(home, ".paperclip", "IDENTITY.md")
   ];
   for (const gp of globalPaths) {
     try {
-      const stat = fs7.statSync(gp);
+      const stat = fs5.statSync(gp);
       if (!stat.isFile() || stat.size > MAX_CONFIG_SIZE) continue;
-      const content = fs7.readFileSync(gp, "utf-8");
+      const content = fs5.readFileSync(gp, "utf-8");
       if (content.trim()) {
-        const name = `~/${path10.relative(home2, gp)}`;
+        const name = path8.relative(home, gp);
         configs.push({ name, content });
         onProgress?.({ phase: "configs", message: name });
       }
     } catch {
     }
   }
+  return configs;
+}
+function collectProjectConfigFiles(projects, onProgress) {
+  const configs = [];
   for (const project of projects) {
     for (const fileName of AI_CONFIG_FILENAMES) {
-      const filePath = path10.join(project.path, fileName);
+      const filePath = path8.join(project.path, fileName);
       try {
-        const stat = fs7.statSync(filePath);
+        const stat = fs5.statSync(filePath);
         if (!stat.isFile() || stat.size > MAX_CONFIG_SIZE) continue;
-        const content = fs7.readFileSync(filePath, "utf-8");
+        const content = fs5.readFileSync(filePath, "utf-8");
         if (content.trim()) {
           const name = `${project.name}/${fileName}`;
           configs.push({ name, content });
@@ -1573,128 +1678,40 @@ function collectConfigFiles(projects, onProgress) {
       } catch {
       }
     }
-    const pkgPath = path10.join(project.path, "package.json");
+    const pkgPath = path8.join(project.path, "package.json");
     try {
-      const stat = fs7.statSync(pkgPath);
+      const stat = fs5.statSync(pkgPath);
       if (stat.isFile() && stat.size <= MAX_CONFIG_SIZE) {
-        const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
+        const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
         const summary = JSON.stringify({ name: pkg.name, description: pkg.description }, null, 2);
-        configs.push({ name: `${project.name}/package.json`, content: summary });
-        onProgress?.({ phase: "configs", message: `${project.name}/package.json` });
-      }
-    } catch {
-    }
-  }
-  return configs;
-}
-var MAX_SCAN_DEPTH = 6;
-var MAX_FILES = 500;
-async function scanFilesInDirs(dirs, onProgress) {
-  const files = [];
-  const seen = /* @__PURE__ */ new Set();
-  function walk(dir, depth) {
-    if (depth > MAX_SCAN_DEPTH) return [];
-    const found = [];
-    try {
-      const items = fs7.readdirSync(dir, { withFileTypes: true });
-      for (const item of items) {
-        if (item.isDirectory()) {
-          if (!shouldSkipDir(item.name)) {
-            found.push(...walk(path10.join(dir, item.name), depth + 1));
-          }
-        } else if (item.isFile()) {
-          if (canParse(item.name) && !isAiConfigFile(item.name)) {
-            const fullPath = path10.join(dir, item.name);
-            if (!seen.has(fullPath)) {
-              seen.add(fullPath);
-              found.push(fullPath);
-            }
-          }
-        }
-      }
-    } catch {
-    }
-    return found;
-  }
-  const allPaths = [];
-  for (const dir of dirs) {
-    onProgress?.({ phase: "scanning", message: displayPath(dir) });
-    allPaths.push(...walk(dir, 0));
-    if (allPaths.length > MAX_FILES) break;
-  }
-  const pathsToProcess = allPaths.slice(0, MAX_FILES);
-  for (const filePath of pathsToProcess) {
-    try {
-      const stat = fs7.statSync(filePath);
-      onProgress?.({ phase: "parsing", message: displayPath(filePath) });
-      const content = await extractTextFromFile(filePath);
-      if (content && content.trim()) {
-        const category = getFileCategory(filePath);
-        files.push({
-          path: filePath,
-          displayPath: displayPath(filePath),
-          content,
-          format: category === "document" ? path10.extname(filePath).slice(1) : "text",
-          sizeBytes: stat.size,
-          folder: path10.dirname(filePath)
-        });
+        configs.push({ name: `${project.name}/package.json`, content: summary });
+        onProgress?.({ phase: "configs", message: `${project.name}/package.json` });
       }
     } catch {
     }
   }
-  return files;
-}
-async function scanFolders(dirs, onProgress) {
-  const allFiles = await scanFilesInDirs(dirs, onProgress);
-  const folders = groupFilesByFolder(allFiles);
-  const projects = detectProjects(dirs, onProgress);
-  const configFiles = collectConfigFiles(projects, onProgress);
-  const totalFiles = allFiles.length;
-  const totalBytes = allFiles.reduce((sum, f) => sum + f.sizeBytes, 0);
-  return { folders, configFiles, projects, allFiles, totalFiles, totalBytes };
-}
-function buildBrainInput(scanResult, selectedFolderPaths) {
-  const selectedSet = new Set(selectedFolderPaths);
-  const selectedFiles = scanResult.allFiles.filter((f) => selectedSet.has(f.folder));
-  const folderTree = [];
-  for (const folder of scanResult.folders) {
-    if (selectedSet.has(folder.path)) {
-      folderTree.push(`${folder.displayPath}/ (${folder.fileCount} files)`);
-    }
-  }
-  const personalDocuments = selectedFiles.map((f) => ({
-    name: f.displayPath,
-    content: f.content,
-    format: f.format
-  }));
-  return {
-    summary: {
-      folders: folderTree,
-      projects: scanResult.projects.map((p) => ({
-        name: p.name,
-        path: p.path.replace(home2, "~"),
-        description: p.description
-      })),
-      configFiles: scanResult.configFiles,
-      recentDocuments: [],
-      personalDocuments
-    }
-  };
+  return configs;
 }
 function scanForProjects(folders) {
   const scanDirs = folders || getDefaultScanDirs();
   return detectProjects(scanDirs);
 }
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
 
 // src/lib/store.ts
-import fs8 from "fs";
-import path11 from "path";
-import os6 from "os";
-var CONFIG_DIR = path11.join(os6.homedir(), ".piut");
-var CONFIG_FILE2 = path11.join(CONFIG_DIR, "config.json");
+init_esm_shims();
+import fs6 from "fs";
+import path9 from "path";
+import os5 from "os";
+var CONFIG_DIR = path9.join(os5.homedir(), ".piut");
+var CONFIG_FILE2 = path9.join(CONFIG_DIR, "config.json");
 function readStore() {
   try {
-    const raw = fs8.readFileSync(CONFIG_FILE2, "utf-8");
+    const raw = fs6.readFileSync(CONFIG_FILE2, "utf-8");
     return JSON.parse(raw);
   } catch {
     return {};
@@ -1703,18 +1720,19 @@ function readStore() {
 function updateStore(updates) {
   const config = readStore();
   const updated = { ...config, ...updates };
-  fs8.mkdirSync(CONFIG_DIR, { recursive: true });
-  fs8.writeFileSync(CONFIG_FILE2, JSON.stringify(updated, null, 2) + "\n", "utf-8");
+  fs6.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs6.writeFileSync(CONFIG_FILE2, JSON.stringify(updated, null, 2) + "\n", "utf-8");
   return updated;
 }
 function clearStore() {
   try {
-    fs8.unlinkSync(CONFIG_FILE2);
+    fs6.unlinkSync(CONFIG_FILE2);
   } catch {
   }
 }
 
 // src/commands/status.ts
+var API_BASE3 = process.env.PIUT_API_BASE || "https://piut.com";
 var PIUT_FILES = [
   "CLAUDE.md",
   ".cursor/rules/piut.mdc",
@@ -1725,27 +1743,69 @@ var PIUT_FILES = [
 ];
 function hasPiutReference(filePath) {
   try {
-    const content = fs9.readFileSync(filePath, "utf-8");
+    const content = fs7.readFileSync(filePath, "utf-8");
     return content.includes("p\u0131ut Context") || content.includes("piut Context");
   } catch {
     return false;
   }
 }
+async function fetchRemoteConnections(key) {
+  try {
+    const res = await fetch(`${API_BASE3}/api/mcp/connections`, {
+      headers: { Authorization: `Bearer ${key}` }
+    });
+    if (!res.ok) return [];
+    const data = await res.json();
+    return data.connections || [];
+  } catch {
+    return [];
+  }
+}
+async function fetchRemoteProjects(key) {
+  try {
+    const res = await fetch(`${API_BASE3}/api/cli/projects`, {
+      headers: { Authorization: `Bearer ${key}` }
+    });
+    if (!res.ok) return [];
+    const data = await res.json();
+    return data.projects || [];
+  } catch {
+    return [];
+  }
+}
+function machineLabel(hostname, machineId) {
+  if (hostname) return hostname;
+  if (machineId && machineId !== "unknown") return machineId.slice(0, 8);
+  return "unknown";
+}
+function timeAgo(dateStr) {
+  const diff = Date.now() - new Date(dateStr).getTime();
+  const minutes = Math.floor(diff / 6e4);
+  if (minutes < 1) return "just now";
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  if (days < 7) return `${days}d ago`;
+  return new Date(dateStr).toLocaleDateString();
+}
 async function statusCommand(options = {}) {
   banner();
   if (options.verify) {
     await verifyStatus();
     return;
   }
-  console.log("  AI tool configuration:");
+  const thisHostname = os6.hostname();
+  const thisMachineId = getMachineId2();
+  console.log(`  AI tools on this machine ${dim(`(${thisHostname})`)}:`);
   console.log();
   let foundAny = false;
   for (const tool of TOOLS) {
-    const paths = resolveConfigPaths(tool.configPaths);
-    for (const configPath of paths) {
-      if (!fs9.existsSync(configPath)) continue;
+    const paths = resolveConfigPaths(tool);
+    for (const { filePath, configKey } of paths) {
+      if (!fs7.existsSync(filePath)) continue;
       foundAny = true;
-      const configured = isPiutConfigured(configPath, tool.configKey);
+      const configured = isPiutConfigured(filePath, configKey);
       if (configured) {
         toolLine(tool.name, success("connected"), "\u2714");
       } else {
@@ -1759,15 +1819,15 @@ async function statusCommand(options = {}) {
     console.log(dim("  Run ") + brand("piut setup") + dim(" to configure your AI tools."));
   }
   console.log();
-  console.log("  Connected projects:");
+  console.log(`  Connected projects on this machine:`);
   console.log();
   const projects = scanForProjects();
   let connectedCount = 0;
   for (const project of projects) {
     const connectedFiles = [];
     for (const file of PIUT_FILES) {
-      const absPath = path12.join(project.path, file);
-      if (fs9.existsSync(absPath) && hasPiutReference(absPath)) {
+      const absPath = path10.join(project.path, file);
+      if (fs7.existsSync(absPath) && hasPiutReference(absPath)) {
         connectedFiles.push(file);
       }
     }
@@ -1784,6 +1844,33 @@ async function statusCommand(options = {}) {
     console.log(dim(`  ${connectedCount} project(s) connected to your brain.`));
   }
   console.log();
+  const store = readStore();
+  if (store.apiKey) {
+    const [remoteConnections, remoteProjects] = await Promise.all([
+      fetchRemoteConnections(store.apiKey),
+      fetchRemoteProjects(store.apiKey)
+    ]);
+    const otherMachineConns = remoteConnections.filter((c) => c.machine_id !== thisMachineId);
+    const otherMachineProjects = remoteProjects.filter((p) => p.machineId !== thisMachineId);
+    if (otherMachineConns.length > 0 || otherMachineProjects.length > 0) {
+      console.log(`  Other machines:`);
+      console.log();
+      if (otherMachineConns.length > 0) {
+        for (const conn of otherMachineConns) {
+          const machine = machineLabel(conn.hostname, conn.machine_id);
+          const age = timeAgo(conn.last_connected_at);
+          console.log(dim(`  ${conn.tool_name}`) + dim(` @${machine}`) + dim(` \u2014 ${conn.request_count} requests, ${age}`));
+        }
+      }
+      if (otherMachineProjects.length > 0) {
+        for (const proj of otherMachineProjects) {
+          const machine = machineLabel(proj.hostname, proj.machineId);
+          console.log(dim(`  ${proj.projectName}`) + dim(` @${machine}:${proj.projectPath}`));
+        }
+      }
+      console.log();
+    }
+  }
 }
 async function verifyStatus() {
   const store = readStore();
@@ -1811,19 +1898,19 @@ async function verifyStatus() {
   console.log();
   console.log("  Tool Configurations");
   for (const tool of TOOLS) {
-    const paths = resolveConfigPaths(tool.configPaths);
-    for (const configPath of paths) {
-      if (!fs9.existsSync(configPath)) continue;
-      const piutConfig = getPiutConfig(configPath, tool.configKey);
+    const paths = resolveConfigPaths(tool);
+    for (const { filePath, configKey } of paths) {
+      if (!fs7.existsSync(filePath)) continue;
+      const piutConfig = getPiutConfig(filePath, configKey);
       if (!piutConfig) {
         toolLine(tool.name, dim("installed, not connected"), "\u25CB");
         break;
       }
-      const configKey = extractKeyFromConfig(piutConfig);
-      if (configKey && configKey === store.apiKey) {
+      const extractedKey = extractKeyFromConfig(piutConfig);
+      if (extractedKey && extractedKey === store.apiKey) {
         toolLine(tool.name, success("key matches"), "\u2714");
-      } else if (configKey) {
-        const masked = configKey.slice(0, 6) + "...";
+      } else if (extractedKey) {
+        const masked = extractedKey.slice(0, 6) + "...";
         toolLine(tool.name, chalk3.red(`key STALE (${masked})`), "\u2717");
         issues++;
       } else {
@@ -1856,16 +1943,18 @@ async function verifyStatus() {
 }
 
 // src/commands/remove.ts
-import fs10 from "fs";
+init_esm_shims();
+import fs8 from "fs";
 import { checkbox as checkbox2, confirm as confirm2 } from "@inquirer/prompts";
 async function removeCommand() {
   banner();
   const configured = [];
   for (const tool of TOOLS) {
-    const paths = resolveConfigPaths(tool.configPaths);
-    for (const configPath of paths) {
-      if (fs10.existsSync(configPath) && isPiutConfigured(configPath, tool.configKey)) {
-        configured.push({ tool, configPath });
+    if (!tool.configKey) continue;
+    const paths = resolveConfigPaths(tool);
+    for (const { filePath, configKey } of paths) {
+      if (fs8.existsSync(filePath) && isPiutConfigured(filePath, configKey)) {
+        configured.push({ tool, configPath: filePath, resolvedConfigKey: configKey });
         break;
       }
     }
@@ -1894,8 +1983,9 @@ async function removeCommand() {
   if (!proceed) return;
   console.log();
   const removedNames = [];
-  for (const { tool, configPath } of selected) {
-    const removed = removeFromConfig(configPath, tool.configKey);
+  for (const { tool, configPath, resolvedConfigKey } of selected) {
+    if (!resolvedConfigKey) continue;
+    const removed = removeFromConfig(configPath, resolvedConfigKey);
     if (removed) {
       removedNames.push(tool.name);
       toolLine(tool.name, success("removed"), "\u2714");
@@ -1914,11 +2004,13 @@ async function removeCommand() {
 }
 
 // src/commands/build.ts
-import { select as select2, checkbox as checkbox3, input as input2, confirm as confirm3 } from "@inquirer/prompts";
+init_esm_shims();
+import { confirm as confirm3 } from "@inquirer/prompts";
 import chalk5 from "chalk";
 import os7 from "os";
 
 // src/lib/auth.ts
+init_esm_shims();
 import { select, input, password as password2 } from "@inquirer/prompts";
 import { exec } from "child_process";
 import chalk4 from "chalk";
@@ -2031,66 +2123,53 @@ async function resolveApiKeyWithResult(keyOption) {
 async function buildCommand(options) {
   banner();
   const { apiKey, serverUrl } = await resolveApiKeyWithResult(options.key);
-  let scanDirs;
-  if (options.folders) {
-    scanDirs = options.folders.split(",").map((f) => expandPath(f.trim()));
-  } else {
-    console.log(dim("  \u2501\u2501\u2501 BUILD YOUR BRAIN \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"));
-    console.log();
-    console.log(dim("  This is a local scan only \u2014 no files leave your machine"));
-    console.log(dim("  until you review and explicitly approve."));
-    console.log();
-    scanDirs = await selectFolders();
-  }
-  if (scanDirs.length === 0) {
-    console.log(chalk5.yellow("  No folders selected."));
-    return;
-  }
+  console.log(dim("  \u2501\u2501\u2501 BUILD YOUR BRAIN \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"));
   console.log();
-  console.log(dim("  Scanning locally \u2014 no data is shared..."));
+  console.log(dim("  Scanning for AI config files..."));
   console.log();
-  let fileCount = 0;
+  const cwd = process.cwd();
+  const homeDirs = getDefaultScanDirs();
+  const allScanDirs = [cwd, ...homeDirs.filter((d) => !d.startsWith(cwd) && !cwd.startsWith(d))];
   const onProgress = (progress) => {
-    if (progress.phase === "scanning") {
-      console.log(dim(`  ${progress.message}`));
-    } else if (progress.phase === "parsing") {
-      fileCount++;
-      console.log(dim(`    [${fileCount}] ${progress.message}`));
-    } else if (progress.phase === "projects") {
+    if (progress.phase === "projects") {
       console.log(dim(`  [project] ${progress.message}`));
     } else if (progress.phase === "configs") {
       console.log(dim(`  [config] ${progress.message}`));
     }
   };
-  const scanResult = await scanFolders(scanDirs, onProgress);
-  console.log();
-  console.log(success(`  \u2713 Scan complete: ${scanResult.totalFiles} files found across ${scanResult.folders.length} folders (local only)`));
+  const projects = detectProjects(allScanDirs, onProgress);
+  const globalConfigs = collectGlobalConfigFiles(onProgress);
+  const projectConfigs = collectProjectConfigFiles(projects, onProgress);
+  const allConfigs = [...globalConfigs, ...projectConfigs];
   console.log();
-  if (scanResult.totalFiles === 0 && scanResult.configFiles.length === 0) {
-    console.log(chalk5.yellow("  No parseable files found in the selected folders."));
-    console.log(dim("  Try scanning a different directory, or use --folders to specify paths."));
+  if (allConfigs.length > 0) {
+    console.log(success(`  \u2713 Found ${allConfigs.length} config file${allConfigs.length === 1 ? "" : "s"} in ${projects.length} project${projects.length === 1 ? "" : "s"}`));
+  } else {
+    console.log(dim("  No AI config files found."));
+  }
+  const totalBytes = allConfigs.reduce((sum, c) => sum + Buffer.byteLength(c.content, "utf-8"), 0);
+  const totalFiles = allConfigs.length;
+  if (totalFiles === 0) {
+    console.log();
+    console.log(chalk5.yellow("  No config files found to build your brain."));
+    console.log(dim("  Add AI config files (CLAUDE.md, .cursorrules, etc.) to your projects,"));
+    console.log(dim("  or upload documents via: piut vault upload <file>"));
     console.log();
     return;
   }
-  let selectedFolderPaths;
-  if (options.yes || scanResult.folders.length === 0) {
-    selectedFolderPaths = scanResult.folders.map((f) => f.path);
-  } else {
-    selectedFolderPaths = await reviewFolders(scanResult);
-  }
-  if (selectedFolderPaths.length === 0 && scanResult.configFiles.length === 0) {
-    console.log(chalk5.yellow("  No folders selected."));
+  if (totalBytes > MAX_BRAIN_INPUT_BYTES) {
+    console.log();
+    console.log(chalk5.yellow(`  Total data: ${formatSize(totalBytes)} exceeds the 1MB limit.`));
+    console.log();
     return;
   }
-  const selectedFolders = scanResult.folders.filter((f) => selectedFolderPaths.includes(f.path));
-  const totalSelectedFiles = selectedFolders.reduce((sum, f) => sum + f.fileCount, 0) + scanResult.configFiles.length;
   if (!options.yes) {
     console.log();
     console.log(dim("  \u2501\u2501\u2501 READY TO BUILD \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"));
     console.log();
-    console.log(dim(`  ${totalSelectedFiles} files will be sent to p\u0131ut and processed by Claude`));
-    console.log(dim("  Sonnet to design your brain. File contents are used for"));
-    console.log(dim("  brain generation only and are not retained."));
+    console.log(dim(`  ${totalFiles} file${totalFiles === 1 ? "" : "s"} (${formatSize(totalBytes)}) will be processed by Claude Sonnet to design your brain.`));
+    console.log(dim("  File contents are used for brain generation only and"));
+    console.log(dim(`  are not retained by p\u0131ut.`));
     console.log();
     console.log(dim(`  Privacy policy: ${brand("https://piut.com/privacy")}`));
     console.log();
@@ -2105,7 +2184,20 @@ async function buildCommand(options) {
       return;
     }
   }
-  const brainInput = buildBrainInput(scanResult, selectedFolderPaths);
+  const home2 = os7.homedir();
+  const brainInput = {
+    summary: {
+      projects: projects.map((p) => ({
+        name: p.name,
+        path: p.path.replace(home2, "~"),
+        description: p.description
+      })),
+      configFiles: allConfigs
+    }
+  };
+  await streamBuild(apiKey, serverUrl, brainInput, options);
+}
+async function streamBuild(apiKey, serverUrl, brainInput, options) {
   const spinner = new Spinner();
   spinner.start("Generating brain...");
   try {
@@ -2205,85 +2297,13 @@ async function buildCommand(options) {
     spinner.stop();
     if (err instanceof CliError) throw err;
     const msg = err.message || "Unknown error";
-    const hint = msg === "terminated" || msg.includes("network") || msg.includes("fetch") ? "The build was interrupted. This can happen if your scan data is very large. Try using --folders to limit which directories are scanned." : msg;
-    console.log(chalk5.red(`  \u2717 ${hint}`));
-    throw new CliError(hint);
-  }
-}
-async function selectFolders() {
-  const defaults = getDefaultScanDirs();
-  const homeDir = os7.homedir();
-  const ALL_VALUE = "__all__";
-  const CUSTOM_VALUE = "__custom__";
-  const choices = [
-    { name: `All home folders (~) ${chalk5.dim("(Recommended)")}`, value: ALL_VALUE },
-    { name: chalk5.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"), value: "__sep__", disabled: true },
-    ...defaults.map((d) => ({ name: displayPath(d), value: d })),
-    { name: chalk5.dim("Browse to a folder..."), value: CUSTOM_VALUE }
-  ];
-  const selected = await checkbox3({
-    message: "Select folders to scan:",
-    choices,
-    required: true
-  });
-  let scanDirs;
-  if (selected.includes(ALL_VALUE)) {
-    scanDirs = defaults;
-  } else {
-    scanDirs = selected.filter((v) => v !== CUSTOM_VALUE);
-    if (selected.includes(CUSTOM_VALUE)) {
-      const custom = await input2({
-        message: "Enter folder path(s), comma-separated:"
-      });
-      const customPaths = custom.split(",").map((f) => expandPath(f.trim())).filter(Boolean);
-      scanDirs = [...scanDirs, ...customPaths];
-    }
-  }
-  if (scanDirs.length > 0 && !selected.includes(ALL_VALUE)) {
-    console.log();
-    console.log(dim("  Selected:"));
-    for (const d of scanDirs) {
-      console.log(dim(`    ${displayPath(d)}`));
-    }
-    const addMore = await select2({
-      message: "Add more folders or continue?",
-      choices: [
-        { name: "Continue with scan", value: "continue" },
-        { name: "Add another folder...", value: "add" }
-      ]
-    });
-    if (addMore === "add") {
-      const extra = await input2({
-        message: "Enter folder path(s), comma-separated:"
-      });
-      const extraPaths = extra.split(",").map((f) => expandPath(f.trim())).filter(Boolean);
-      scanDirs = [...scanDirs, ...extraPaths];
-    }
+    console.log(chalk5.red(`  \u2717 ${msg}`));
+    throw new CliError(msg);
   }
-  return scanDirs;
-}
-async function reviewFolders(scanResult) {
-  if (scanResult.folders.length === 0) return [];
-  console.log(dim("  \u2501\u2501\u2501 REVIEW SCANNED FOLDERS \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"));
-  console.log();
-  console.log(dim("  All folders selected by default. Deselect any you want to exclude."));
-  console.log();
-  const choices = scanResult.folders.map((folder) => ({
-    name: formatFolderChoice(folder),
-    value: folder.path,
-    checked: true
-  }));
-  const selected = await checkbox3({
-    message: "Select folders to include in your brain:",
-    choices
-  });
-  const selectedFolders = scanResult.folders.filter((f) => selected.includes(f.path));
-  console.log();
-  console.log(dim(`  ${formatSelectionSummary(selectedFolders)}`));
-  return selected;
 }
 
 // src/commands/deploy.ts
+init_esm_shims();
 import chalk6 from "chalk";
 async function deployCommand(options) {
   banner();
@@ -2321,33 +2341,34 @@ async function deployCommand(options) {
 }
 
 // src/commands/connect.ts
-import fs11 from "fs";
-import path13 from "path";
-import { checkbox as checkbox4 } from "@inquirer/prompts";
+init_esm_shims();
+import fs9 from "fs";
+import path11 from "path";
+import { checkbox as checkbox3 } from "@inquirer/prompts";
 var RULE_FILES = [
   {
     tool: "Claude Code",
     filePath: "CLAUDE.md",
     strategy: "append",
-    detect: (p) => p.hasClaudeMd || fs11.existsSync(path13.join(p.path, ".claude"))
+    detect: (p) => p.hasClaudeMd || fs9.existsSync(path11.join(p.path, ".claude"))
   },
   {
     tool: "Cursor",
     filePath: ".cursor/rules/piut.mdc",
     strategy: "create",
-    detect: (p) => p.hasCursorRules || fs11.existsSync(path13.join(p.path, ".cursor"))
+    detect: (p) => p.hasCursorRules || fs9.existsSync(path11.join(p.path, ".cursor"))
   },
   {
     tool: "Windsurf",
     filePath: ".windsurf/rules/piut.md",
     strategy: "create",
-    detect: (p) => p.hasWindsurfRules || fs11.existsSync(path13.join(p.path, ".windsurf"))
+    detect: (p) => p.hasWindsurfRules || fs9.existsSync(path11.join(p.path, ".windsurf"))
   },
   {
     tool: "GitHub Copilot",
     filePath: ".github/copilot-instructions.md",
     strategy: "append",
-    detect: (p) => p.hasCopilotInstructions || fs11.existsSync(path13.join(p.path, ".github"))
+    detect: (p) => p.hasCopilotInstructions || fs9.existsSync(path11.join(p.path, ".github"))
   },
   {
     tool: "Amazon Q",
@@ -2359,7 +2380,19 @@ var RULE_FILES = [
     tool: "Zed",
     filePath: ".zed/rules.md",
     strategy: "create",
-    detect: (p) => p.hasZedRules || fs11.existsSync(path13.join(p.path, ".zed"))
+    detect: (p) => p.hasZedRules || fs9.existsSync(path11.join(p.path, ".zed"))
+  },
+  {
+    tool: "Gemini CLI",
+    filePath: "GEMINI.md",
+    strategy: "append",
+    detect: (p) => fs9.existsSync(path11.join(p.path, ".gemini"))
+  },
+  {
+    tool: "Paperclip",
+    filePath: "AGENTS.md",
+    strategy: "append",
+    detect: (p) => fs9.existsSync(path11.join(p.path, ".paperclip"))
   }
 ];
 var DEDICATED_FILE_CONTENT = `## p\u0131ut Context (MCP Server: piut-context)
@@ -2394,7 +2427,7 @@ Full skill reference: .piut/skill.md
 `;
 function hasPiutReference2(filePath) {
   try {
-    const content = fs11.readFileSync(filePath, "utf-8");
+    const content = fs9.readFileSync(filePath, "utf-8");
     return content.includes("p\u0131ut Context") || content.includes("piut Context");
   } catch {
     return false;
@@ -2417,13 +2450,13 @@ async function connectCommand(options) {
     console.log();
     return;
   }
-  let scanFolders2;
+  let scanFolders;
   if (options.folders) {
-    scanFolders2 = options.folders.split(",").map((f) => expandPath(f.trim()));
+    scanFolders = options.folders.split(",").map((f) => expandPath(f.trim()));
   }
   console.log();
   console.log(dim("  Scanning for projects..."));
-  const projects = scanForProjects(scanFolders2);
+  const projects = scanForProjects(scanFolders);
   if (projects.length === 0) {
     console.log(warning("  No projects found."));
     console.log(dim("  Try running from a directory with your projects, or use --folders."));
@@ -2434,20 +2467,20 @@ async function connectCommand(options) {
   for (const project of projects) {
     for (const rule of RULE_FILES) {
       if (!rule.detect(project)) continue;
-      const absPath = path13.join(project.path, rule.filePath);
-      if (fs11.existsSync(absPath) && hasPiutReference2(absPath)) continue;
+      const absPath = path11.join(project.path, rule.filePath);
+      if (fs9.existsSync(absPath) && hasPiutReference2(absPath)) continue;
       actions.push({
         project,
         tool: rule.tool,
         filePath: rule.filePath,
         absPath,
-        action: rule.strategy === "create" || !fs11.existsSync(absPath) ? "create" : "append"
+        action: rule.strategy === "create" || !fs9.existsSync(absPath) ? "create" : "append"
       });
     }
     const hasAnyAction = actions.some((a) => a.project === project);
     if (!hasAnyAction) {
-      const claudeMdPath = path13.join(project.path, "CLAUDE.md");
-      if (!fs11.existsSync(claudeMdPath)) {
+      const claudeMdPath = path11.join(project.path, "CLAUDE.md");
+      if (!fs9.existsSync(claudeMdPath)) {
         actions.push({
           project,
           tool: "Claude Code",
@@ -2487,7 +2520,7 @@ async function connectCommand(options) {
   console.log();
   const projectChoices = [];
   for (const [projectPath, projectActions] of byProject) {
-    const projectName = path13.basename(projectPath);
+    const projectName = path11.basename(projectPath);
     const desc = projectActions.map((a) => {
       const verb = a.action === "create" ? "will create" : "will append to";
       return `${verb} ${a.filePath}`;
@@ -2502,7 +2535,7 @@ async function connectCommand(options) {
   if (options.yes) {
     selectedPaths = Array.from(byProject.keys());
   } else {
-    selectedPaths = await checkbox4({
+    selectedPaths = await checkbox3({
       message: "Select projects to connect:",
       choices: projectChoices
     });
@@ -2516,15 +2549,15 @@ async function connectCommand(options) {
   const copilotTool = TOOLS.find((t) => t.id === "copilot");
   for (const projectPath of selectedPaths) {
     const projectActions = byProject.get(projectPath) || [];
-    const projectName = path13.basename(projectPath);
+    const projectName = path11.basename(projectPath);
     writePiutConfig(projectPath, { slug, apiKey, serverUrl });
     await writePiutSkill(projectPath, slug, apiKey);
     ensureGitignored(projectPath);
     console.log(success(`  \u2713 ${projectName}/.piut/`) + dim(" \u2014 credentials + skill"));
     if (copilotTool) {
-      const hasCopilot = fs11.existsSync(path13.join(projectPath, ".github", "copilot-instructions.md")) || fs11.existsSync(path13.join(projectPath, ".github"));
+      const hasCopilot = fs9.existsSync(path11.join(projectPath, ".github", "copilot-instructions.md")) || fs9.existsSync(path11.join(projectPath, ".github"));
       if (hasCopilot) {
-        const vscodeMcpPath = path13.join(projectPath, ".vscode", "mcp.json");
+        const vscodeMcpPath = path11.join(projectPath, ".vscode", "mcp.json");
         const serverConfig = copilotTool.generateConfig(slug, apiKey);
         mergeConfig(vscodeMcpPath, copilotTool.configKey, serverConfig);
         console.log(success(`  \u2713 ${projectName}/.vscode/mcp.json`) + dim(" \u2014 Copilot MCP"));
@@ -2534,26 +2567,28 @@ async function connectCommand(options) {
       if (action.action === "create") {
         const isAppendType = RULE_FILES.find((r) => r.filePath === action.filePath)?.strategy === "append";
         const content = isAppendType ? PROJECT_SKILL_SNIPPET + "\n" : DEDICATED_FILE_CONTENT;
-        fs11.mkdirSync(path13.dirname(action.absPath), { recursive: true });
-        fs11.writeFileSync(action.absPath, content, "utf-8");
+        fs9.mkdirSync(path11.dirname(action.absPath), { recursive: true });
+        fs9.writeFileSync(action.absPath, content, "utf-8");
         console.log(success(`  \u2713 ${projectName}/${action.filePath}`) + dim(" \u2014 created"));
       } else {
-        fs11.appendFileSync(action.absPath, APPEND_SECTION);
+        fs9.appendFileSync(action.absPath, APPEND_SECTION);
         console.log(success(`  \u2713 ${projectName}/${action.filePath}`) + dim(" \u2014 appended"));
       }
       connected++;
     }
   }
   const machineId = getMachineId();
+  const hostname = getHostname();
   for (const projectPath of selectedPaths) {
     const projectActions = byProject.get(projectPath) || [];
-    const projectName = path13.basename(projectPath);
+    const projectName = path11.basename(projectPath);
     const toolsDetected = [...new Set(projectActions.map((a) => a.tool))];
     const configFilesWritten = projectActions.map((a) => a.filePath);
     registerProject(apiKey, {
       projectName,
       projectPath,
       machineId,
+      hostname,
       toolsDetected,
       configFiles: configFilesWritten
     }).catch(() => {
@@ -2565,9 +2600,10 @@ async function connectCommand(options) {
 }
 
 // src/commands/disconnect.ts
-import fs12 from "fs";
-import path14 from "path";
-import { checkbox as checkbox5, confirm as confirm5 } from "@inquirer/prompts";
+init_esm_shims();
+import fs10 from "fs";
+import path12 from "path";
+import { checkbox as checkbox4, confirm as confirm5 } from "@inquirer/prompts";
 var DEDICATED_FILES = /* @__PURE__ */ new Set([
   ".cursor/rules/piut.mdc",
   ".windsurf/rules/piut.md",
@@ -2576,11 +2612,13 @@ var DEDICATED_FILES = /* @__PURE__ */ new Set([
 var APPEND_FILES = [
   "CLAUDE.md",
   ".github/copilot-instructions.md",
-  "CONVENTIONS.md"
+  "CONVENTIONS.md",
+  "GEMINI.md",
+  "AGENTS.md"
 ];
 function hasPiutReference3(filePath) {
   try {
-    const content = fs12.readFileSync(filePath, "utf-8");
+    const content = fs10.readFileSync(filePath, "utf-8");
     return content.includes("p\u0131ut Context") || content.includes("piut Context");
   } catch {
     return false;
@@ -2588,7 +2626,7 @@ function hasPiutReference3(filePath) {
 }
 function removePiutSection(filePath) {
   try {
-    let content = fs12.readFileSync(filePath, "utf-8");
+    let content = fs10.readFileSync(filePath, "utf-8");
     const patterns = [
       /\n*## p[ıi]ut Context[\s\S]*?(?=\n## |\n---\n|$)/g
     ];
@@ -2602,7 +2640,7 @@ function removePiutSection(filePath) {
     }
     if (changed) {
       content = content.replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
-      fs12.writeFileSync(filePath, content, "utf-8");
+      fs10.writeFileSync(filePath, content, "utf-8");
     }
     return changed;
   } catch {
@@ -2611,18 +2649,18 @@ function removePiutSection(filePath) {
 }
 async function disconnectCommand(options) {
   banner();
-  let scanFolders2;
+  let scanFolders;
   if (options.folders) {
-    scanFolders2 = options.folders.split(",").map((f) => expandPath(f.trim()));
+    scanFolders = options.folders.split(",").map((f) => expandPath(f.trim()));
   }
   console.log(dim("  Scanning for connected projects..."));
-  const projects = scanForProjects(scanFolders2);
+  const projects = scanForProjects(scanFolders);
   const actions = [];
   for (const project of projects) {
-    const projectName = path14.basename(project.path);
+    const projectName = path12.basename(project.path);
     for (const dedicatedFile of DEDICATED_FILES) {
-      const absPath = path14.join(project.path, dedicatedFile);
-      if (fs12.existsSync(absPath) && hasPiutReference3(absPath)) {
+      const absPath = path12.join(project.path, dedicatedFile);
+      if (fs10.existsSync(absPath) && hasPiutReference3(absPath)) {
         actions.push({
           projectPath: project.path,
           projectName,
@@ -2633,8 +2671,8 @@ async function disconnectCommand(options) {
       }
     }
     for (const appendFile of APPEND_FILES) {
-      const absPath = path14.join(project.path, appendFile);
-      if (fs12.existsSync(absPath) && hasPiutReference3(absPath)) {
+      const absPath = path12.join(project.path, appendFile);
+      if (fs10.existsSync(absPath) && hasPiutReference3(absPath)) {
         actions.push({
           projectPath: project.path,
           projectName,
@@ -2649,12 +2687,12 @@ async function disconnectCommand(options) {
         projectPath: project.path,
         projectName,
         filePath: ".piut/",
-        absPath: path14.join(project.path, ".piut"),
+        absPath: path12.join(project.path, ".piut"),
         action: "remove-dir"
       });
     }
-    const vscodeMcpPath = path14.join(project.path, ".vscode", "mcp.json");
-    if (fs12.existsSync(vscodeMcpPath) && isPiutConfigured(vscodeMcpPath, "servers")) {
+    const vscodeMcpPath = path12.join(project.path, ".vscode", "mcp.json");
+    if (fs10.existsSync(vscodeMcpPath) && isPiutConfigured(vscodeMcpPath, "servers")) {
       actions.push({
         projectPath: project.path,
         projectName,
@@ -2676,7 +2714,7 @@ async function disconnectCommand(options) {
   }
   console.log();
   const projectChoices = Array.from(byProject.entries()).map(([projectPath, projectActions]) => {
-    const name = path14.basename(projectPath);
+    const name = path12.basename(projectPath);
     const files = projectActions.map((a) => a.filePath).join(", ");
     return {
       name: `${name} ${dim(`(${files})`)}`,
@@ -2687,7 +2725,7 @@ async function disconnectCommand(options) {
   if (options.yes) {
     selectedPaths = Array.from(byProject.keys());
   } else {
-    selectedPaths = await checkbox5({
+    selectedPaths = await checkbox4({
       message: "Select projects to disconnect:",
       choices: projectChoices
     });
@@ -2705,11 +2743,11 @@ async function disconnectCommand(options) {
   let disconnected = 0;
   for (const projectPath of selectedPaths) {
     const projectActions = byProject.get(projectPath) || [];
-    const projectName = path14.basename(projectPath);
+    const projectName = path12.basename(projectPath);
     for (const action of projectActions) {
       if (action.action === "delete") {
         try {
-          fs12.unlinkSync(action.absPath);
+          fs10.unlinkSync(action.absPath);
           console.log(success(`  \u2713 ${projectName}/${action.filePath}`) + dim(" \u2014 deleted"));
           disconnected++;
         } catch {
@@ -2753,6 +2791,7 @@ async function disconnectCommand(options) {
 }
 
 // src/commands/login.ts
+init_esm_shims();
 import chalk7 from "chalk";
 async function loginCommand() {
   try {
@@ -2768,6 +2807,7 @@ async function loginCommand() {
 }
 
 // src/commands/logout.ts
+init_esm_shims();
 async function logoutCommand() {
   banner();
   const config = readStore();
@@ -2784,9 +2824,11 @@ async function logoutCommand() {
 }
 
 // src/commands/update.ts
+init_esm_shims();
 import chalk9 from "chalk";
 
 // src/lib/update-check.ts
+init_esm_shims();
 import { execFile } from "child_process";
 import chalk8 from "chalk";
 import { confirm as confirm6 } from "@inquirer/prompts";
@@ -2885,7 +2927,8 @@ async function updateCommand(currentVersion) {
 }
 
 // src/commands/doctor.ts
-import fs13 from "fs";
+init_esm_shims();
+import fs11 from "fs";
 import chalk10 from "chalk";
 async function doctorCommand(options) {
   if (!options.json) banner();
@@ -2935,10 +2978,10 @@ async function doctorCommand(options) {
   }
   let toolsFixed = 0;
   for (const tool of TOOLS) {
-    const paths = resolveConfigPaths(tool.configPaths);
-    for (const configPath of paths) {
-      if (!fs13.existsSync(configPath)) continue;
-      const piutConfig = getPiutConfig(configPath, tool.configKey);
+    const paths = resolveConfigPaths(tool);
+    for (const { filePath: configPath, configKey: resolvedKey } of paths) {
+      if (!fs11.existsSync(configPath)) continue;
+      const piutConfig = getPiutConfig(configPath, resolvedKey);
       if (!piutConfig) {
         result.tools.push({
           name: tool.name,
@@ -2953,13 +2996,13 @@ async function doctorCommand(options) {
         }
         break;
       }
-      const configKey = extractKeyFromConfig(piutConfig);
-      const configPrefix = configKey ? configKey.slice(0, 7) + "..." : "(none)";
+      const extractedKey = extractKeyFromConfig(piutConfig);
+      const configPrefix = extractedKey ? extractedKey.slice(0, 7) + "..." : "(none)";
       let keyMatch = "missing";
-      if (!configKey) {
+      if (!extractedKey) {
         keyMatch = "missing";
         result.issues++;
-      } else if (apiKey && configKey === apiKey) {
+      } else if (apiKey && extractedKey === apiKey) {
         keyMatch = "match";
       } else {
         keyMatch = "stale";
@@ -2977,7 +3020,7 @@ async function doctorCommand(options) {
       };
       if (keyMatch === "stale" && options.fix && apiKey && result.key.valid && result.key.slug) {
         const serverConfig = tool.generateConfig(result.key.slug, apiKey);
-        mergeConfig(configPath, tool.configKey, serverConfig);
+        mergeConfig(configPath, resolvedKey, serverConfig);
         toolResult.fixed = true;
         toolResult.keyMatch = "match";
         result.issues--;
@@ -3052,13 +3095,156 @@ async function doctorCommand(options) {
   if (result.issues > 0) throw new CliError(`${result.issues} issue(s) found`);
 }
 
+// src/commands/vault.ts
+init_esm_shims();
+import fs12 from "fs";
+import path13 from "path";
+import chalk11 from "chalk";
+import { confirm as confirm7 } from "@inquirer/prompts";
+var DOCUMENT_EXTENSIONS = /* @__PURE__ */ new Set([
+  "pdf",
+  "docx",
+  "doc",
+  "pptx",
+  "pages",
+  "key",
+  "rtf",
+  "odt",
+  "odp",
+  "eml",
+  "mbox"
+]);
+function formatSize2(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function resolveApiKey(options) {
+  const key = options.key || readStore().apiKey;
+  if (!key) {
+    console.log(warning("  No API key found."));
+    console.log(dim("  Run ") + brand("piut login") + dim(" first, or pass --key."));
+    throw new CliError();
+  }
+  return key;
+}
+async function vaultListCommand(options) {
+  const key = resolveApiKey(options);
+  const data = await listVaultFiles(key);
+  if (data.files.length === 0) {
+    console.log(dim("  No files in vault."));
+    console.log(dim("  Upload with: ") + brand("piut vault upload <file>"));
+    console.log();
+    return;
+  }
+  console.log();
+  for (const file of data.files) {
+    const size = dim(`(${formatSize2(file.sizeBytes)})`);
+    console.log(`  ${file.filename}  ${size}`);
+    if (file.summary) {
+      console.log(dim(`    ${file.summary}`));
+    }
+  }
+  console.log();
+  console.log(dim(`  ${data.usage.fileCount} file(s), ${formatSize2(data.usage.totalBytes)} / ${formatSize2(data.usage.maxBytes)} used`));
+  console.log();
+}
+async function vaultUploadCommand(filePath, options) {
+  const key = resolveApiKey(options);
+  const resolved = path13.resolve(filePath);
+  if (!fs12.existsSync(resolved)) {
+    console.log(chalk11.red(`  File not found: ${filePath}`));
+    throw new CliError();
+  }
+  const stat = fs12.statSync(resolved);
+  if (!stat.isFile()) {
+    console.log(chalk11.red(`  Not a file: ${filePath}`));
+    throw new CliError();
+  }
+  const filename = path13.basename(resolved);
+  const ext = filename.includes(".") ? filename.split(".").pop()?.toLowerCase() || "" : "";
+  const isDocument = DOCUMENT_EXTENSIONS.has(ext);
+  let content;
+  let encoding;
+  if (isDocument) {
+    content = fs12.readFileSync(resolved).toString("base64");
+    encoding = "base64";
+  } else {
+    content = fs12.readFileSync(resolved, "utf-8");
+  }
+  const spinner = new Spinner();
+  spinner.start(`Uploading ${filename}...`);
+  try {
+    const result = await uploadVaultFile(key, filename, content, encoding);
+    spinner.stop();
+    console.log(success(`  Uploaded ${result.filename}`) + dim(` (${formatSize2(result.sizeBytes)})`));
+    if (result.summary) {
+      console.log(dim(`  ${result.summary}`));
+    }
+    console.log();
+  } catch (err) {
+    spinner.stop();
+    console.log(chalk11.red(`  ${err.message}`));
+    throw new CliError();
+  }
+}
+async function vaultReadCommand(filename, options) {
+  const key = resolveApiKey(options);
+  try {
+    const file = await readVaultFile(key, filename);
+    if (options.output) {
+      const outPath = path13.resolve(options.output);
+      fs12.writeFileSync(outPath, file.content, "utf-8");
+      console.log(success(`  Saved to ${outPath}`));
+      console.log();
+    } else {
+      console.log();
+      console.log(file.content);
+    }
+  } catch (err) {
+    console.log(chalk11.red(`  ${err.message}`));
+    throw new CliError();
+  }
+}
+async function vaultDeleteCommand(filename, options) {
+  const key = resolveApiKey(options);
+  if (!options.yes) {
+    const confirmed = await confirm7({
+      message: `Delete "${filename}" from vault? This cannot be undone.`,
+      default: false
+    });
+    if (!confirmed) return;
+  }
+  try {
+    await deleteVaultFile(key, filename);
+    console.log(success(`  Deleted ${filename}`));
+    console.log();
+  } catch (err) {
+    console.log(chalk11.red(`  ${err.message}`));
+    throw new CliError();
+  }
+}
+
 // src/commands/interactive.ts
-import { select as select3, confirm as confirm7, checkbox as checkbox6, Separator } from "@inquirer/prompts";
+init_esm_shims();
+import { select as select2, confirm as confirm8, checkbox as checkbox5, Separator } from "@inquirer/prompts";
 import fs14 from "fs";
 import path15 from "path";
 import { exec as exec2 } from "child_process";
-import os8 from "os";
-import chalk11 from "chalk";
+import chalk13 from "chalk";
+var DOCUMENT_EXTENSIONS2 = /* @__PURE__ */ new Set([
+  "pdf",
+  "docx",
+  "doc",
+  "pptx",
+  "pages",
+  "key",
+  "rtf",
+  "odt",
+  "odp",
+  "eml",
+  "mbox"
+]);
 async function authenticate() {
   const config = readStore();
   const apiKey = config.apiKey;
@@ -3097,7 +3283,7 @@ async function interactiveMenu() {
     console.log(warning("  You haven\u2019t built a brain yet."));
     console.log(dim("  Your brain is how AI tools learn about you \u2014 your projects, preferences, and context."));
     console.log();
-    const wantBuild = await confirm7({
+    const wantBuild = await confirm8({
       message: "Build your brain now?",
       default: true
     });
@@ -3113,7 +3299,7 @@ async function interactiveMenu() {
     console.log(warning("  Your brain is built but not deployed yet."));
     console.log(dim("  Deploy it to make your MCP server live so AI tools can read your brain."));
     console.log();
-    const wantDeploy = await confirm7({
+    const wantDeploy = await confirm8({
       message: "Deploy your brain now?",
       default: true
     });
@@ -3130,15 +3316,28 @@ async function interactiveMenu() {
     const isDeployed = currentValidation.status === "active";
     let action;
     try {
-      action = await select3({
+      action = await select2({
         message: "What would you like to do?",
         loop: false,
         choices: [
           {
-            name: hasBrain ? "Resync Brain" : "Build Brain",
+            name: "My Brain",
+            value: "view-brain",
+            description: "View all 5 brain sections",
+            disabled: !hasBrain && "(build brain first)"
+          },
+          {
+            name: "Build Brain",
             value: "build",
-            description: hasBrain ? "Rescan your files and merge updates into your brain" : "Build your brain from your files"
+            description: hasBrain ? "Rebuild your brain from your files" : "Build your brain from your files"
+          },
+          {
+            name: "Edit Brain",
+            value: "edit-brain",
+            description: "Open piut.com to edit your brain",
+            disabled: !hasBrain && "(build brain first)"
           },
+          new Separator(),
           {
             name: isDeployed ? "Undeploy Brain" : "Deploy Brain",
             value: "deploy",
@@ -3159,23 +3358,21 @@ async function interactiveMenu() {
           },
           new Separator(),
           {
-            name: "Edit Brain",
-            value: "edit-brain",
-            description: "Open piut.com to edit your brain",
-            disabled: !hasBrain && "(build brain first)"
+            name: "View Files",
+            value: "vault-view",
+            description: "List and manage files in your vault"
           },
           {
-            name: "View Brain",
-            value: "view-brain",
-            description: "View all 5 brain sections",
-            disabled: !hasBrain && "(build brain first)"
+            name: "Upload Files",
+            value: "vault-upload",
+            description: "Upload a file to your vault"
           },
+          new Separator(),
           {
             name: "Status",
             value: "status",
             description: "Show brain, deployment, and connected tools/projects"
           },
-          new Separator(),
           {
             name: "Logout",
             value: "logout",
@@ -3194,12 +3391,14 @@ async function interactiveMenu() {
     if (action === "exit") return;
     try {
       switch (action) {
+        case "view-brain":
+          await handleViewBrain(apiKey);
+          break;
         case "build":
-          if (hasBrain) {
-            await handleResyncBrain(apiKey, currentValidation);
-          } else {
-            await buildCommand({ key: apiKey });
-          }
+          await buildCommand({ key: apiKey });
+          break;
+        case "edit-brain":
+          handleEditBrain();
           break;
         case "deploy":
           if (isDeployed) {
@@ -3214,11 +3413,11 @@ async function interactiveMenu() {
         case "connect-projects":
           await handleManageProjects(apiKey, currentValidation);
           break;
-        case "edit-brain":
-          handleEditBrain();
+        case "vault-view":
+          await handleVaultView(apiKey);
           break;
-        case "view-brain":
-          await handleViewBrain(apiKey);
+        case "vault-upload":
+          await handleVaultUpload(apiKey);
           break;
         case "status":
           statusCommand();
@@ -3241,7 +3440,7 @@ async function interactiveMenu() {
       } else if (err instanceof CliError) {
         console.log();
       } else {
-        console.log(chalk11.red(`  Error: ${err.message}`));
+        console.log(chalk13.red(`  Error: ${err.message}`));
         console.log();
       }
     }
@@ -3252,7 +3451,7 @@ async function interactiveMenu() {
   }
 }
 async function handleUndeploy(apiKey) {
-  const confirmed = await confirm7({
+  const confirmed = await confirm8({
     message: "Undeploy your brain? AI tools will lose access to your MCP server.",
     default: false
   });
@@ -3264,69 +3463,86 @@ async function handleUndeploy(apiKey) {
     console.log(dim("  Run ") + brand("piut deploy") + dim(" to re-deploy anytime."));
     console.log();
   } catch (err) {
-    console.log(chalk11.red(`  \u2717 ${err.message}`));
+    console.log(chalk13.red(`  \u2717 ${err.message}`));
   }
 }
 async function handleConnectTools(apiKey, validation) {
   const { slug } = validation;
   const detected = [];
   for (const tool of TOOLS) {
-    const paths = resolveConfigPaths(tool.configPaths);
-    for (const configPath of paths) {
-      const exists = fs14.existsSync(configPath);
-      const parentExists = fs14.existsSync(path15.dirname(configPath));
+    const paths = resolveConfigPaths(tool);
+    for (const { filePath, configKey } of paths) {
+      const exists = fs14.existsSync(filePath);
+      const parentExists = fs14.existsSync(path15.dirname(filePath));
       if (exists || parentExists) {
-        const connected = exists && isPiutConfigured(configPath, tool.configKey);
-        detected.push({ tool, configPath, connected });
+        const connected = exists && !!configKey && isPiutConfigured(filePath, configKey);
+        detected.push({ tool, configPath: filePath, resolvedConfigKey: configKey, connected });
         break;
       }
     }
   }
   if (detected.length === 0) {
     console.log(warning("  No supported AI tools detected."));
-    console.log(dim("  Supported: Claude Code, Claude Desktop, Cursor, Windsurf, GitHub Copilot, Amazon Q, Zed"));
     console.log();
     return;
   }
-  const connectedCount = detected.filter((d) => d.connected).length;
-  const availableCount = detected.length - connectedCount;
+  const mcpTools = detected.filter((d) => !d.tool.skillOnly);
+  const skillOnlyTools = detected.filter((d) => d.tool.skillOnly);
+  const connectedCount = mcpTools.filter((d) => d.connected).length;
+  const availableCount = mcpTools.length - connectedCount;
   if (connectedCount > 0 || availableCount > 0) {
     const parts = [];
     if (connectedCount > 0) parts.push(`${connectedCount} connected`);
     if (availableCount > 0) parts.push(`${availableCount} available`);
+    if (skillOnlyTools.length > 0) parts.push(`${skillOnlyTools.length} skill-only`);
     console.log(dim(`  ${parts.join(", ")}`));
   }
   console.log();
-  const choices = detected.map((d) => ({
+  if (mcpTools.length === 0) {
+    console.log(dim("  Detected tools are skill-only (no MCP config to manage)."));
+    if (skillOnlyTools.length > 0) {
+      console.log(dim(`  Skill-only: ${skillOnlyTools.map((d) => d.tool.name).join(", ")}`));
+    }
+    console.log(dim('  Use "Connect Projects" to add skill files to your projects.'));
+    console.log();
+    return;
+  }
+  const choices = mcpTools.map((d) => ({
     name: `${d.tool.name}${d.connected ? dim(" (connected)") : ""}`,
     value: d,
     checked: d.connected
   }));
-  const selected = await checkbox6({
+  const selected = await checkbox5({
     message: "Select tools to keep connected (toggle with space):",
     choices
   });
   const toConnect = selected.filter((s) => !s.connected);
-  const toDisconnect = detected.filter((d) => d.connected && !selected.includes(d));
+  const toDisconnect = mcpTools.filter((d) => d.connected && !selected.includes(d));
   if (toConnect.length === 0 && toDisconnect.length === 0) {
     console.log(dim("  No changes."));
     console.log();
     return;
   }
   console.log();
-  for (const { tool, configPath } of toConnect) {
-    const serverConfig = tool.generateConfig(slug, apiKey);
-    mergeConfig(configPath, tool.configKey, serverConfig);
-    toolLine(tool.name, success("connected"), "\u2714");
+  for (const { tool, configPath, resolvedConfigKey } of toConnect) {
+    if (tool.generateConfig && resolvedConfigKey) {
+      const serverConfig = tool.generateConfig(slug, apiKey);
+      mergeConfig(configPath, resolvedConfigKey, serverConfig);
+      toolLine(tool.name, success("connected"), "\u2714");
+    }
   }
   const removedNames = [];
-  for (const { tool, configPath } of toDisconnect) {
-    const removed = removeFromConfig(configPath, tool.configKey);
+  for (const { tool, configPath, resolvedConfigKey } of toDisconnect) {
+    if (!resolvedConfigKey) continue;
+    const removed = removeFromConfig(configPath, resolvedConfigKey);
     if (removed) {
       removedNames.push(tool.name);
       toolLine(tool.name, warning("disconnected"), "\u2714");
     }
   }
+  if (skillOnlyTools.length > 0) {
+    console.log(dim(`  Skill-only (use "Connect Projects"): ${skillOnlyTools.map((d) => d.tool.name).join(", ")}`));
+  }
   if (toConnect.length > 0 && validation.serverUrl) {
     await Promise.all(
       toConnect.map(({ tool }) => pingMcp(validation.serverUrl, apiKey, tool.name))
@@ -3366,7 +3582,7 @@ async function handleManageProjects(apiKey, validation) {
     value: i,
     checked: i.connected
   }));
-  const selected = await checkbox6({
+  const selected = await checkbox5({
     message: "Select projects to keep connected (toggle with space):",
     choices
   });
@@ -3459,96 +3675,103 @@ function handleEditBrain() {
   console.log(success("  \u2713 Opened in browser."));
   console.log();
 }
-function formatScanContent(input3) {
-  const { summary } = input3;
-  const parts = [];
-  parts.push("The user has re-scanned their filesystem. Below is updated information about their projects, config files, and documents. Please merge this into the existing brain sections, preserving existing content and updating what has changed.");
-  parts.push("");
-  if (summary.folders.length > 0) {
-    parts.push(`## Folder Structure
-${summary.folders.join("\n")}`);
-  }
-  if (summary.projects.length > 0) {
-    const projectLines = summary.projects.map(
-      (p) => `- **${p.name}** (${p.path})${p.description ? ` \u2014 ${p.description}` : ""}`
-    );
-    parts.push(`## Projects Found
-${projectLines.join("\n")}`);
-  }
-  const totalFiles = (summary.configFiles?.length || 0) + (summary.recentDocuments?.length || 0) + (summary.personalDocuments?.length || 0);
-  const fileLimit = totalFiles <= 10 ? 1e4 : totalFiles <= 30 ? 5e3 : totalFiles <= 60 ? 3e3 : 2e3;
-  if (summary.configFiles.length > 0) {
-    const configBlocks = summary.configFiles.map(
-      (f) => `### ${f.name}
-\`\`\`
-${f.content.slice(0, fileLimit)}
-\`\`\``
-    );
-    parts.push(`## AI Config Files
-${configBlocks.join("\n\n")}`);
-  }
-  if (summary.recentDocuments.length > 0) {
-    const docBlocks = summary.recentDocuments.map(
-      (f) => `### ${f.name}
-${f.content.slice(0, fileLimit)}`
-    );
-    parts.push(`## Recent Documents
-${docBlocks.join("\n\n")}`);
+function formatSize3(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+async function handleVaultView(apiKey) {
+  const data = await listVaultFiles(apiKey);
+  if (data.files.length === 0) {
+    console.log(dim('  Vault is empty. Use "Upload Files" to add files.'));
+    console.log();
+    return;
   }
-  if (summary.personalDocuments && summary.personalDocuments.length > 0) {
-    const docBlocks = summary.personalDocuments.map(
-      (f) => `### ${f.name}
-${f.content.slice(0, fileLimit)}`
-    );
-    parts.push(`## Personal Documents
-${docBlocks.join("\n\n")}`);
+  console.log();
+  for (const file of data.files) {
+    const size = dim(`(${formatSize3(file.sizeBytes)})`);
+    console.log(`  ${file.filename}  ${size}`);
+    if (file.summary) console.log(dim(`    ${file.summary}`));
   }
-  let result = parts.join("\n\n");
-  if (result.length > 4e5) {
-    result = result.slice(0, 4e5);
+  console.log();
+  console.log(dim(`  ${data.usage.fileCount} file(s), ${formatSize3(data.usage.totalBytes)} / ${formatSize3(data.usage.maxBytes)} used`));
+  console.log();
+  const action = await select2({
+    message: "Actions:",
+    choices: [
+      { name: "Delete a file", value: "delete" },
+      { name: "Back", value: "back" }
+    ]
+  });
+  if (action === "back") return;
+  if (action === "delete") {
+    const fileChoices = data.files.map((f) => ({
+      name: `${f.filename}  ${dim(`(${formatSize3(f.sizeBytes)})`)}`,
+      value: f.filename
+    }));
+    const filename = await select2({
+      message: "Which file to delete?",
+      choices: fileChoices
+    });
+    const confirmed = await confirm8({
+      message: `Delete "${filename}"? This cannot be undone.`,
+      default: false
+    });
+    if (confirmed) {
+      try {
+        await deleteVaultFile(apiKey, filename);
+        console.log(success(`  Deleted ${filename}`));
+        console.log();
+      } catch (err) {
+        console.log(chalk13.red(`  ${err.message}`));
+        console.log();
+      }
+    }
   }
-  return result;
 }
-async function handleResyncBrain(apiKey, validation) {
-  if (!validation.serverUrl) {
-    console.log(warning("  Brain must be deployed before resyncing."));
-    console.log(dim("  Run ") + brand("piut deploy") + dim(" first."));
+async function handleVaultUpload(apiKey) {
+  const treePrompt2 = (await Promise.resolve().then(() => (init_tree_prompt(), tree_prompt_exports))).default;
+  const files = await treePrompt2({
+    message: "Select files to upload:",
+    mode: "files"
+  });
+  if (files.length === 0) {
+    console.log(dim("  No files selected."));
     console.log();
     return;
   }
-  const cwd = process.cwd();
-  const cwdDisplay = cwd.replace(os8.homedir(), "~");
-  console.log(dim(`  Scanning ${cwdDisplay}...`));
-  const scanResult = await scanFolders([cwd]);
-  const allFolderPaths = scanResult.folders.map((f) => f.path);
-  const brainInput = buildBrainInput(scanResult, allFolderPaths);
-  const projCount = brainInput.summary.projects.length;
-  const cfgCount = brainInput.summary.configFiles.length;
-  const dcCount = (brainInput.summary.personalDocuments?.length || 0) + brainInput.summary.recentDocuments.length;
-  console.log(success(`  Scanned: ${projCount} projects, ${cfgCount} config files, ${dcCount} docs`));
   console.log();
-  if (projCount === 0 && cfgCount === 0) {
-    console.log(chalk11.yellow("  No projects or config files found to resync from."));
-    console.log();
-    return;
+  let uploaded = 0;
+  for (const filePath of files) {
+    const filename = path15.basename(filePath);
+    const ext = filename.includes(".") ? filename.split(".").pop()?.toLowerCase() || "" : "";
+    const isDocument = DOCUMENT_EXTENSIONS2.has(ext);
+    let content;
+    let encoding;
+    if (isDocument) {
+      content = fs14.readFileSync(filePath).toString("base64");
+      encoding = "base64";
+    } else {
+      content = fs14.readFileSync(filePath, "utf-8");
+    }
+    const spinner = new Spinner();
+    spinner.start(`Uploading ${filename}...`);
+    try {
+      const result = await uploadVaultFile(apiKey, filename, content, encoding);
+      spinner.stop();
+      console.log(success(`  Uploaded ${result.filename}`) + dim(` (${formatSize3(result.sizeBytes)})`));
+      if (result.summary) console.log(dim(`  ${result.summary}`));
+      uploaded++;
+    } catch (err) {
+      spinner.stop();
+      console.log(chalk13.red(`  ${err.message}`));
+    }
   }
-  const content = formatScanContent(brainInput);
-  const spinner = new Spinner();
-  spinner.start("Resyncing brain...");
-  try {
-    const result = await resyncBrain(validation.serverUrl, apiKey, content);
-    spinner.stop();
-    console.log();
-    console.log(success("  \u2713 Brain resynced."));
-    console.log(dim(`  ${result.summary}`));
-    console.log();
-  } catch (err) {
-    spinner.stop();
-    const msg = err.message;
-    console.log(chalk11.red(`  \u2717 ${msg}`));
+  if (uploaded > 0) {
     console.log();
-    throw new CliError(msg);
+    console.log(success(`  ${uploaded} file${uploaded === 1 ? "" : "s"} uploaded to vault.`));
   }
+  console.log();
 }
 async function handleViewBrain(apiKey) {
   console.log(dim("  Loading brain..."));
@@ -3578,7 +3801,7 @@ async function handleViewBrain(apiKey) {
   if (hasUnpublishedChanges) {
     console.log(warning("  You have unpublished changes."));
     console.log();
-    const wantPublish = await confirm7({
+    const wantPublish = await confirm8({
       message: "Publish now?",
       default: true
     });
@@ -3592,11 +3815,11 @@ async function handleViewBrain(apiKey) {
         console.log();
         const msg = err.message;
         if (msg === "REQUIRES_SUBSCRIPTION") {
-          console.log(chalk11.yellow("  Deploy requires an active subscription ($10/mo)."));
+          console.log(chalk13.yellow("  Deploy requires an active subscription ($10/mo)."));
           console.log(`  Subscribe at: ${brand("https://piut.com/dashboard/billing")}`);
           console.log(dim("  14-day free trial included."));
         } else {
-          console.log(chalk11.red(`  \u2717 ${msg}`));
+          console.log(chalk13.red(`  \u2717 ${msg}`));
         }
         console.log();
       }
@@ -3605,7 +3828,7 @@ async function handleViewBrain(apiKey) {
 }
 
 // src/cli.ts
-var VERSION = "3.6.0";
+var VERSION = "3.8.0";
 function withExit(fn) {
   return async (...args2) => {
     try {
@@ -3621,7 +3844,7 @@ program.name("piut").description("Build your AI brain instantly. Deploy it as an
   if (actionCommand.name() === "update") return;
   return checkForUpdate(VERSION);
 }).action(interactiveMenu);
-program.command("build").description("Build or rebuild your brain from your files").option("-k, --key <key>", "API key").option("--folders <paths>", "Comma-separated folder paths to scan").option("-y, --yes", "Auto-publish after build").option("--no-publish", "Skip publish prompt after build").action(withExit(buildCommand));
+program.command("build").description("Build or rebuild your brain from your AI config files").option("-k, --key <key>", "API key").option("-y, --yes", "Auto-publish after build").option("--no-publish", "Skip publish prompt after build").action(withExit(buildCommand));
 program.command("deploy").description("Publish your MCP server (requires paid account)").option("-k, --key <key>", "API key").action(withExit(deployCommand));
 program.command("connect").description("Add brain references to project config files").option("-k, --key <key>", "API key").option("-y, --yes", "Skip interactive prompts").option("--folders <paths>", "Comma-separated folder paths to scan").action(withExit(connectCommand));
 program.command("disconnect").description("Remove brain references from project config files").option("-y, --yes", "Skip interactive prompts").option("--folders <paths>", "Comma-separated folder paths to scan").action(withExit(disconnectCommand));
@@ -3631,6 +3854,11 @@ program.command("remove").description("Remove all p\u0131ut configurations").act
 program.command("login").description("Authenticate with p\u0131ut (email, browser, or API key)").action(withExit(loginCommand));
 program.command("logout").description("Remove saved API key").action(logoutCommand);
 program.command("doctor").description("Diagnose and fix connection issues").option("-k, --key <key>", "API key to verify against").option("--fix", "Auto-fix stale configurations").option("--json", "Output results as JSON").action(withExit(doctorCommand));
+var vault = program.command("vault").description("Manage your file vault (upload, list, read, delete)");
+vault.command("list").description("List all files in your vault").option("-k, --key <key>", "API key").action(withExit(vaultListCommand));
+vault.command("upload <file>").description("Upload a file to your vault").option("-k, --key <key>", "API key").action(withExit(vaultUploadCommand));
+vault.command("read <filename>").description("Read a file from your vault").option("-k, --key <key>", "API key").option("-o, --output <path>", "Save to a local file instead of printing").action(withExit(vaultReadCommand));
+vault.command("delete <filename>").description("Delete a file from your vault").option("-k, --key <key>", "API key").option("-y, --yes", "Skip confirmation prompt").action(withExit(vaultDeleteCommand));
 program.command("update").description("Check for and install CLI updates").action(() => updateCommand(VERSION));
 var args = process.argv.slice(2);
 if (args.includes("--version") || args.includes("-V")) {