@piut/cli 3.7.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" }));
@@ -240,14 +562,16 @@ async function listVaultFiles(key) {
   }
   return res.json();
 }
-async function uploadVaultFile(key, filename, content) {
+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({ filename, content })
+    body: JSON.stringify(payload)
   });
   if (!res.ok) {
     const body = await res.json().catch(() => ({ error: "Unknown error" }));
@@ -282,8 +606,9 @@ async function deleteVaultFile(key, filename) {
 }
 
 // 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}` });
@@ -298,7 +623,7 @@ function machineHeaders(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 = [
   {
@@ -329,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) => ({
@@ -378,7 +703,11 @@ var TOOLS = [
     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",
@@ -463,28 +792,31 @@ var TOOLS = [
 ];
 
 // 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 {
@@ -505,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;
 }
@@ -576,10 +928,10 @@ function extractSlugFromConfig(piutConfig) {
 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);
@@ -587,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).
@@ -631,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")) {
@@ -641,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 };
     }
@@ -650,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";
@@ -693,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"
   );
@@ -716,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");
@@ -744,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;
@@ -833,6 +1188,7 @@ var Spinner = class {
 };
 
 // src/types.ts
+init_esm_shims();
 var CliError = class extends Error {
   constructor(message) {
     super(message || "");
@@ -884,15 +1240,15 @@ async function setupCommand(options) {
   for (const tool of TOOLS) {
     if (toolFilter && tool.id !== toolFilter) continue;
     if (tool.skillOnly) continue;
-    const paths = resolveConfigPaths(tool.configPaths);
-    for (const configPath of paths) {
-      const exists = fs4.existsSync(configPath);
-      const parentExists = fs4.existsSync(path6.dirname(configPath));
+    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 && !!tool.configKey && isPiutConfigured(configPath, tool.configKey);
+        const configured2 = exists && !!configKey && isPiutConfigured(filePath, configKey);
         let staleKey = false;
-        if (configured2 && tool.configKey) {
-          const piutConfig = getPiutConfig(configPath, tool.configKey);
+        if (configured2 && configKey) {
+          const piutConfig = getPiutConfig(filePath, configKey);
           if (piutConfig) {
             const existingKey = extractKeyFromConfig(piutConfig);
             if (existingKey && existingKey !== apiKey) {
@@ -906,7 +1262,8 @@ async function setupCommand(options) {
         }
         detected.push({
           tool,
-          configPath,
+          configPath: filePath,
+          resolvedConfigKey: configKey,
           exists,
           alreadyConfigured: configured2 && !staleKey,
           staleKey
@@ -996,9 +1353,9 @@ async function setupCommand(options) {
       }
       if (quickSuccess) continue;
     }
-    if (tool.generateConfig && tool.configKey) {
+    if (tool.generateConfig && det.resolvedConfigKey) {
       const serverConfig = tool.generateConfig(slug, apiKey);
-      mergeConfig(configPath, tool.configKey, serverConfig);
+      mergeConfig(configPath, det.resolvedConfigKey, serverConfig);
       configured.push(tool.name);
       toolLine(tool.name, success("configured"), "\u2714");
     }
@@ -1026,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 });
@@ -1042,8 +1399,8 @@ async function setupCommand(options) {
     console.log(dim("  Verifying..."));
     for (const det of selected) {
       if (!configured.includes(det.tool.name)) continue;
-      if (!det.tool.configKey) 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 {
@@ -1084,51 +1441,20 @@ function isCommandAvailable(cmd) {
 }
 
 // src/commands/status.ts
-import fs9 from "fs";
-import os7 from "os";
-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",
@@ -1142,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",
@@ -1498,7 +1520,6 @@ var SKIP_HOME_DIRS = /* @__PURE__ */ new Set([
   ".Trash"
 ]);
 var INCLUDE_DOT_DIRS = /* @__PURE__ */ new Set([
-  ".claude",
   ".cursor",
   ".windsurf",
   ".openclaw",
@@ -1508,26 +1529,27 @@ var INCLUDE_DOT_DIRS = /* @__PURE__ */ new Set([
   ".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);
         }
@@ -1538,64 +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",
-  ".gemini",
-  ".openclaw",
-  ".mcporter",
-  ".paperclip"
-]);
-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) {
@@ -1612,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;
@@ -1630,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);
         }
@@ -1654,36 +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"),
-    path10.join(home2, ".gemini", "MEMORY.md"),
-    path10.join(home2, ".paperclip", "IDENTITY.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 });
@@ -1692,11 +1678,11 @@ 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` });
@@ -1706,114 +1692,26 @@ function collectConfigFiles(projects, onProgress) {
   }
   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)
-        });
-      }
-    } 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
-    }
-  };
-}
 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 {};
@@ -1822,13 +1720,13 @@ 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 {
   }
 }
@@ -1845,7 +1743,7 @@ 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;
@@ -1897,17 +1795,17 @@ async function statusCommand(options = {}) {
     await verifyStatus();
     return;
   }
-  const thisHostname = os7.hostname();
+  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 {
@@ -1928,8 +1826,8 @@ async function statusCommand(options = {}) {
   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);
       }
     }
@@ -2000,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 {
@@ -2045,17 +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) {
     if (!tool.configKey) continue;
-    const paths = resolveConfigPaths(tool.configPaths);
-    for (const configPath of paths) {
-      if (fs10.existsSync(configPath) && isPiutConfigured(configPath, tool.configKey)) {
-        configured.push({ tool, configPath });
+    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;
       }
     }
@@ -2084,9 +1983,9 @@ async function removeCommand() {
   if (!proceed) return;
   console.log();
   const removedNames = [];
-  for (const { tool, configPath } of selected) {
-    if (!tool.configKey) continue;
-    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");
@@ -2105,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 os8 from "os";
+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";
@@ -2222,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);
+  const projects = detectProjects(allScanDirs, onProgress);
+  const globalConfigs = collectGlobalConfigFiles(onProgress);
+  const projectConfigs = collectProjectConfigFiles(projects, onProgress);
+  const allConfigs = [...globalConfigs, ...projectConfigs];
   console.log();
-  console.log(success(`  \u2713 Scan complete: ${scanResult.totalFiles} files found across ${scanResult.folders.length} folders (local only)`));
-  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();
@@ -2296,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 {
@@ -2396,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 = os8.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];
-    }
+    console.log(chalk5.red(`  \u2717 ${msg}`));
+    throw new CliError(msg);
   }
-  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];
-    }
-  }
-  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();
@@ -2512,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",
@@ -2550,19 +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) => fs11.existsSync(path13.join(p.path, ".gemini"))
+    detect: (p) => fs9.existsSync(path11.join(p.path, ".gemini"))
   },
   {
     tool: "Paperclip",
     filePath: "AGENTS.md",
     strategy: "append",
-    detect: (p) => fs11.existsSync(path13.join(p.path, ".paperclip"))
+    detect: (p) => fs9.existsSync(path11.join(p.path, ".paperclip"))
   }
 ];
 var DEDICATED_FILE_CONTENT = `## p\u0131ut Context (MCP Server: piut-context)
@@ -2597,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;
@@ -2620,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."));
@@ -2637,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",
@@ -2690,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}`;
@@ -2705,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
     });
@@ -2719,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"));
@@ -2737,11 +2567,11 @@ 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++;
@@ -2751,7 +2581,7 @@ async function connectCommand(options) {
   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, {
@@ -2770,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",
@@ -2787,7 +2618,7 @@ var APPEND_FILES = [
 ];
 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;
@@ -2795,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
     ];
@@ -2809,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 {
@@ -2818,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,
@@ -2840,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,
@@ -2856,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,
@@ -2883,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})`)}`,
@@ -2894,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
     });
@@ -2912,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 {
@@ -2960,6 +2791,7 @@ async function disconnectCommand(options) {
 }
 
 // src/commands/login.ts
+init_esm_shims();
 import chalk7 from "chalk";
 async function loginCommand() {
   try {
@@ -2975,6 +2807,7 @@ async function loginCommand() {
 }
 
 // src/commands/logout.ts
+init_esm_shims();
 async function logoutCommand() {
   banner();
   const config = readStore();
@@ -2991,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";
@@ -3092,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();
@@ -3142,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,
@@ -3160,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";
@@ -3184,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--;
@@ -3260,10 +3096,24 @@ async function doctorCommand(options) {
 }
 
 // src/commands/vault.ts
-import fs14 from "fs";
-import path15 from "path";
+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`;
@@ -3301,22 +3151,31 @@ async function vaultListCommand(options) {
 }
 async function vaultUploadCommand(filePath, options) {
   const key = resolveApiKey(options);
-  const resolved = path15.resolve(filePath);
-  if (!fs14.existsSync(resolved)) {
+  const resolved = path13.resolve(filePath);
+  if (!fs12.existsSync(resolved)) {
     console.log(chalk11.red(`  File not found: ${filePath}`));
     throw new CliError();
   }
-  const stat = fs14.statSync(resolved);
+  const stat = fs12.statSync(resolved);
   if (!stat.isFile()) {
     console.log(chalk11.red(`  Not a file: ${filePath}`));
     throw new CliError();
   }
-  const filename = path15.basename(resolved);
-  const content = fs14.readFileSync(resolved, "utf-8");
+  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);
+    const result = await uploadVaultFile(key, filename, content, encoding);
     spinner.stop();
     console.log(success(`  Uploaded ${result.filename}`) + dim(` (${formatSize2(result.sizeBytes)})`));
     if (result.summary) {
@@ -3334,8 +3193,8 @@ async function vaultReadCommand(filename, options) {
   try {
     const file = await readVaultFile(key, filename);
     if (options.output) {
-      const outPath = path15.resolve(options.output);
-      fs14.writeFileSync(outPath, file.content, "utf-8");
+      const outPath = path13.resolve(options.output);
+      fs12.writeFileSync(outPath, file.content, "utf-8");
       console.log(success(`  Saved to ${outPath}`));
       console.log();
     } else {
@@ -3367,11 +3226,25 @@ async function vaultDeleteCommand(filename, options) {
 }
 
 // src/commands/interactive.ts
-import { select as select3, confirm as confirm8, checkbox as checkbox6, Separator } from "@inquirer/prompts";
-import fs15 from "fs";
-import path16 from "path";
+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 chalk12 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;
@@ -3443,7 +3316,7 @@ 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: [
@@ -3567,7 +3440,7 @@ async function interactiveMenu() {
       } else if (err instanceof CliError) {
         console.log();
       } else {
-        console.log(chalk12.red(`  Error: ${err.message}`));
+        console.log(chalk13.red(`  Error: ${err.message}`));
         console.log();
       }
     }
@@ -3590,20 +3463,20 @@ async function handleUndeploy(apiKey) {
     console.log(dim("  Run ") + brand("piut deploy") + dim(" to re-deploy anytime."));
     console.log();
   } catch (err) {
-    console.log(chalk12.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 = fs15.existsSync(configPath);
-      const parentExists = fs15.existsSync(path16.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 && !!tool.configKey && 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;
       }
     }
@@ -3639,7 +3512,7 @@ async function handleConnectTools(apiKey, validation) {
     value: d,
     checked: d.connected
   }));
-  const selected = await checkbox6({
+  const selected = await checkbox5({
     message: "Select tools to keep connected (toggle with space):",
     choices
   });
@@ -3651,17 +3524,17 @@ async function handleConnectTools(apiKey, validation) {
     return;
   }
   console.log();
-  for (const { tool, configPath } of toConnect) {
-    if (tool.generateConfig && tool.configKey) {
+  for (const { tool, configPath, resolvedConfigKey } of toConnect) {
+    if (tool.generateConfig && resolvedConfigKey) {
       const serverConfig = tool.generateConfig(slug, apiKey);
-      mergeConfig(configPath, tool.configKey, serverConfig);
+      mergeConfig(configPath, resolvedConfigKey, serverConfig);
       toolLine(tool.name, success("connected"), "\u2714");
     }
   }
   const removedNames = [];
-  for (const { tool, configPath } of toDisconnect) {
-    if (!tool.configKey) continue;
-    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");
@@ -3709,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
   });
@@ -3723,29 +3596,29 @@ async function handleManageProjects(apiKey, validation) {
   console.log();
   const copilotTool = TOOLS.find((t) => t.id === "copilot");
   for (const { project } of toConnect) {
-    const projectName = path16.basename(project.path);
+    const projectName = path15.basename(project.path);
     writePiutConfig(project.path, { slug, apiKey, serverUrl });
     await writePiutSkill(project.path, slug, apiKey);
     ensureGitignored(project.path);
     if (copilotTool) {
-      const hasCopilot = fs15.existsSync(path16.join(project.path, ".github", "copilot-instructions.md")) || fs15.existsSync(path16.join(project.path, ".github"));
+      const hasCopilot = fs14.existsSync(path15.join(project.path, ".github", "copilot-instructions.md")) || fs14.existsSync(path15.join(project.path, ".github"));
       if (hasCopilot) {
-        const vscodeMcpPath = path16.join(project.path, ".vscode", "mcp.json");
+        const vscodeMcpPath = path15.join(project.path, ".vscode", "mcp.json");
         const serverConfig = copilotTool.generateConfig(slug, apiKey);
         mergeConfig(vscodeMcpPath, copilotTool.configKey, serverConfig);
       }
     }
     for (const rule of RULE_FILES) {
       if (!rule.detect(project)) continue;
-      const absPath = path16.join(project.path, rule.filePath);
-      if (fs15.existsSync(absPath) && hasPiutReference2(absPath)) continue;
-      if (rule.strategy === "create" || !fs15.existsSync(absPath)) {
+      const absPath = path15.join(project.path, rule.filePath);
+      if (fs14.existsSync(absPath) && hasPiutReference2(absPath)) continue;
+      if (rule.strategy === "create" || !fs14.existsSync(absPath)) {
         const isAppendType = rule.strategy === "append";
         const content = isAppendType ? PROJECT_SKILL_SNIPPET + "\n" : DEDICATED_FILE_CONTENT;
-        fs15.mkdirSync(path16.dirname(absPath), { recursive: true });
-        fs15.writeFileSync(absPath, content, "utf-8");
+        fs14.mkdirSync(path15.dirname(absPath), { recursive: true });
+        fs14.writeFileSync(absPath, content, "utf-8");
       } else {
-        fs15.appendFileSync(absPath, APPEND_SECTION);
+        fs14.appendFileSync(absPath, APPEND_SECTION);
       }
     }
     toolLine(projectName, success("connected"), "\u2714");
@@ -3761,24 +3634,24 @@ async function handleManageProjects(apiKey, validation) {
     });
   }
   for (const { project } of toDisconnect) {
-    const projectName = path16.basename(project.path);
+    const projectName = path15.basename(project.path);
     for (const dedicatedFile of DEDICATED_FILES) {
-      const absPath = path16.join(project.path, dedicatedFile);
-      if (fs15.existsSync(absPath) && hasPiutReference2(absPath)) {
+      const absPath = path15.join(project.path, dedicatedFile);
+      if (fs14.existsSync(absPath) && hasPiutReference2(absPath)) {
         try {
-          fs15.unlinkSync(absPath);
+          fs14.unlinkSync(absPath);
         } catch {
         }
       }
     }
     for (const appendFile of APPEND_FILES) {
-      const absPath = path16.join(project.path, appendFile);
-      if (fs15.existsSync(absPath) && hasPiutReference2(absPath)) {
+      const absPath = path15.join(project.path, appendFile);
+      if (fs14.existsSync(absPath) && hasPiutReference2(absPath)) {
         removePiutSection(absPath);
       }
     }
-    const vscodeMcpPath = path16.join(project.path, ".vscode", "mcp.json");
-    if (fs15.existsSync(vscodeMcpPath) && isPiutConfigured(vscodeMcpPath, "servers")) {
+    const vscodeMcpPath = path15.join(project.path, ".vscode", "mcp.json");
+    if (fs14.existsSync(vscodeMcpPath) && isPiutConfigured(vscodeMcpPath, "servers")) {
       removeFromConfig(vscodeMcpPath, "servers");
     }
     removePiutDir(project.path);
@@ -3823,7 +3696,7 @@ async function handleVaultView(apiKey) {
   console.log();
   console.log(dim(`  ${data.usage.fileCount} file(s), ${formatSize3(data.usage.totalBytes)} / ${formatSize3(data.usage.maxBytes)} used`));
   console.log();
-  const action = await select3({
+  const action = await select2({
     message: "Actions:",
     choices: [
       { name: "Delete a file", value: "delete" },
@@ -3836,7 +3709,7 @@ async function handleVaultView(apiKey) {
       name: `${f.filename}  ${dim(`(${formatSize3(f.sizeBytes)})`)}`,
       value: f.filename
     }));
-    const filename = await select3({
+    const filename = await select2({
       message: "Which file to delete?",
       choices: fileChoices
     });
@@ -3850,37 +3723,55 @@ async function handleVaultView(apiKey) {
         console.log(success(`  Deleted ${filename}`));
         console.log();
       } catch (err) {
-        console.log(chalk12.red(`  ${err.message}`));
+        console.log(chalk13.red(`  ${err.message}`));
         console.log();
       }
     }
   }
 }
 async function handleVaultUpload(apiKey) {
-  const { input: input3 } = await import("@inquirer/prompts");
-  const filePath = await input3({ message: "File path:" });
-  if (!filePath.trim()) return;
-  const resolved = path16.resolve(filePath);
-  if (!fs15.existsSync(resolved) || !fs15.statSync(resolved).isFile()) {
-    console.log(chalk12.red(`  File not found: ${filePath}`));
+  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 filename = path16.basename(resolved);
-  const content = fs15.readFileSync(resolved, "utf-8");
-  const spinner = new Spinner();
-  spinner.start(`Uploading ${filename}...`);
-  try {
-    const result = await uploadVaultFile(apiKey, filename, content);
-    spinner.stop();
-    console.log(success(`  Uploaded ${result.filename}`) + dim(` (${formatSize3(result.sizeBytes)})`));
-    if (result.summary) console.log(dim(`  ${result.summary}`));
-    console.log();
-  } catch (err) {
-    spinner.stop();
-    console.log(chalk12.red(`  ${err.message}`));
+  console.log();
+  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}`));
+    }
+  }
+  if (uploaded > 0) {
     console.log();
+    console.log(success(`  ${uploaded} file${uploaded === 1 ? "" : "s"} uploaded to vault.`));
   }
+  console.log();
 }
 async function handleViewBrain(apiKey) {
   console.log(dim("  Loading brain..."));
@@ -3924,11 +3815,11 @@ async function handleViewBrain(apiKey) {
         console.log();
         const msg = err.message;
         if (msg === "REQUIRES_SUBSCRIPTION") {
-          console.log(chalk12.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(chalk12.red(`  \u2717 ${msg}`));
+          console.log(chalk13.red(`  \u2717 ${msg}`));
         }
         console.log();
       }
@@ -3937,7 +3828,7 @@ async function handleViewBrain(apiKey) {
 }
 
 // src/cli.ts
-var VERSION = "3.7.0";
+var VERSION = "3.8.0";
 function withExit(fn) {
   return async (...args2) => {
     try {
@@ -3953,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));