@piut/cli 3.5.1 → 3.7.0

package/dist/cli.js

@@ -24,7 +24,19 @@ async function validateKey(key) {
   }
   return res.json();
 }
-async function* buildBrainStreaming(key, input2) {
+async function loginWithEmail(email, password3) {
+  const res = await fetch(`${API_BASE}/api/cli/login`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ email, password: password3 })
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(body.error || `Login failed (HTTP ${res.status})`);
+  }
+  return res.json();
+}
+async function* buildBrainStreaming(key, input3) {
   const res = await fetch(`${API_BASE}/api/cli/build-brain`, {
     method: "POST",
     headers: {
@@ -32,7 +44,7 @@ async function* buildBrainStreaming(key, input2) {
       "Content-Type": "application/json",
       Accept: "text/event-stream"
     },
-    body: JSON.stringify(input2)
+    body: JSON.stringify(input3)
   });
   if (!res.ok) {
     const body = await res.json().catch(() => ({ error: "Unknown error" }));
@@ -110,7 +122,10 @@ async function pingMcp(serverUrl, key, toolName) {
       headers: {
         Authorization: `Bearer ${key}`,
         "Content-Type": "application/json",
-        "User-Agent": `piut-cli (configured: ${toolName})`
+        "User-Agent": `piut-cli (configured: ${toolName})`,
+        "X-Piut-Hostname": os.hostname(),
+        "X-Piut-Machine-Id": getMachineId(),
+        "X-Piut-Tool": toolName
       },
       body: JSON.stringify({
         jsonrpc: "2.0",
@@ -155,6 +170,9 @@ function getMachineId() {
   const hostname = os.hostname();
   return crypto.createHash("sha256").update(hostname).digest("hex").slice(0, 16);
 }
+function getHostname() {
+  return os.hostname();
+}
 async function registerProject(key, project) {
   const res = await fetch(`${API_BASE}/api/cli/projects`, {
     method: "POST",
@@ -184,6 +202,19 @@ async function unregisterProject(key, projectPath, machineId) {
     throw new Error(body.error || `Unregister project failed (HTTP ${res.status})`);
   }
 }
+async function deleteConnections(key, toolNames) {
+  try {
+    await fetch(`${API_BASE}/api/mcp/connections`, {
+      method: "DELETE",
+      headers: {
+        Authorization: `Bearer ${key}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ toolNames })
+    });
+  } catch {
+  }
+}
 async function unpublishServer(key) {
   const res = await fetch(`${API_BASE}/api/mcp/publish`, {
     method: "POST",
@@ -199,12 +230,73 @@ async function unpublishServer(key) {
   }
   return res.json();
 }
+async function listVaultFiles(key) {
+  const res = await fetch(`${API_BASE}/api/cli/vault`, {
+    headers: { Authorization: `Bearer ${key}` }
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(body.error || `Failed to list vault files (HTTP ${res.status})`);
+  }
+  return res.json();
+}
+async function uploadVaultFile(key, filename, content) {
+  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 })
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(body.error || `Upload failed (HTTP ${res.status})`);
+  }
+  return res.json();
+}
+async function readVaultFile(key, filename) {
+  const encoded = encodeURIComponent(filename);
+  const res = await fetch(`${API_BASE}/api/cli/vault/${encoded}`, {
+    headers: { Authorization: `Bearer ${key}` }
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(body.error || `Failed to read vault file (HTTP ${res.status})`);
+  }
+  return res.json();
+}
+async function deleteVaultFile(key, filename) {
+  const res = await fetch(`${API_BASE}/api/cli/vault`, {
+    method: "DELETE",
+    headers: {
+      Authorization: `Bearer ${key}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ filename })
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({ error: "Unknown error" }));
+    throw new Error(body.error || `Delete failed (HTTP ${res.status})`);
+  }
+}
 
 // src/lib/tools.ts
 import os2 from "os";
 import path from "path";
+import crypto2 from "crypto";
 var MCP_URL = (slug) => `https://piut.com/api/mcp/${slug}`;
 var AUTH_HEADER = (key) => ({ Authorization: `Bearer ${key}` });
+function getMachineId2() {
+  return crypto2.createHash("sha256").update(os2.hostname()).digest("hex").slice(0, 16);
+}
+function machineHeaders(toolName) {
+  return {
+    "X-Piut-Hostname": os2.hostname(),
+    "X-Piut-Machine-Id": getMachineId2(),
+    "X-Piut-Tool": toolName
+  };
+}
 function appData() {
   return process.env.APPDATA || path.join(os2.homedir(), "AppData", "Roaming");
 }
@@ -216,18 +308,19 @@ var TOOLS = [
     configPaths: {
       darwin: ["~/.claude.json"],
       win32: ["~/.claude.json"],
-      linux: ["~/.claude.json"]
+      linux: ["~/.claude.json"],
+      project: [".mcp.json"]
     },
     skillFilePath: "CLAUDE.md",
     quickCommand: (slug, key) => `claude mcp add-json piut-context '${JSON.stringify({
       type: "http",
       url: MCP_URL(slug),
-      headers: AUTH_HEADER(key)
+      headers: { ...AUTH_HEADER(key), ...machineHeaders("Claude Code") }
     })}'`,
     generateConfig: (slug, key) => ({
       type: "http",
       url: MCP_URL(slug),
-      headers: AUTH_HEADER(key)
+      headers: { ...AUTH_HEADER(key), ...machineHeaders("Claude Code") }
     })
   },
   {
@@ -263,7 +356,7 @@ var TOOLS = [
     skillFilePath: ".cursor/rules/piut.mdc",
     generateConfig: (slug, key) => ({
       url: MCP_URL(slug),
-      headers: AUTH_HEADER(key)
+      headers: { ...AUTH_HEADER(key), ...machineHeaders("Cursor") }
     })
   },
   {
@@ -278,7 +371,7 @@ var TOOLS = [
     skillFilePath: ".windsurf/rules/piut.md",
     generateConfig: (slug, key) => ({
       serverUrl: MCP_URL(slug),
-      headers: AUTH_HEADER(key)
+      headers: { ...AUTH_HEADER(key), ...machineHeaders("Windsurf") }
     })
   },
   {
@@ -292,7 +385,7 @@ var TOOLS = [
     generateConfig: (slug, key) => ({
       type: "http",
       url: MCP_URL(slug),
-      headers: AUTH_HEADER(key)
+      headers: { ...AUTH_HEADER(key), ...machineHeaders("GitHub Copilot") }
     })
   },
   {
@@ -308,7 +401,7 @@ var TOOLS = [
     generateConfig: (slug, key) => ({
       type: "http",
       url: MCP_URL(slug),
-      headers: AUTH_HEADER(key)
+      headers: { ...AUTH_HEADER(key), ...machineHeaders("Amazon Q") }
     })
   },
   {
@@ -323,9 +416,49 @@ var TOOLS = [
     generateConfig: (slug, key) => ({
       settings: {
         url: MCP_URL(slug),
-        headers: AUTH_HEADER(key)
+        headers: { ...AUTH_HEADER(key), ...machineHeaders("Zed") }
       }
     })
+  },
+  {
+    id: "gemini-cli",
+    name: "Gemini CLI",
+    configKey: "mcpServers",
+    configPaths: {
+      darwin: ["~/.gemini/settings.json"],
+      win32: ["~/.gemini/settings.json"],
+      linux: ["~/.gemini/settings.json"],
+      project: [".gemini/settings.json"]
+    },
+    generateConfig: (slug, key) => ({
+      httpUrl: MCP_URL(slug),
+      headers: { ...AUTH_HEADER(key), ...machineHeaders("Gemini CLI") }
+    })
+  },
+  {
+    id: "openclaw",
+    name: "OpenClaw",
+    configKey: "mcpServers",
+    configPaths: {
+      darwin: ["~/.mcporter/mcporter.json", "~/.openclaw/workspace/config/mcporter.json"],
+      win32: ["~/.mcporter/mcporter.json", "~/.openclaw/workspace/config/mcporter.json"],
+      linux: ["~/.mcporter/mcporter.json", "~/.openclaw/workspace/config/mcporter.json"]
+    },
+    quickCommand: (slug, key) => `npx mcporter config add piut-context ${MCP_URL(slug)} --header "Authorization=Bearer ${key}"`,
+    generateConfig: (slug, key) => ({
+      url: MCP_URL(slug),
+      headers: { ...AUTH_HEADER(key), ...machineHeaders("OpenClaw") }
+    })
+  },
+  {
+    id: "paperclip",
+    name: "Paperclip",
+    skillOnly: true,
+    configPaths: {
+      darwin: ["~/.paperclip/config.json"],
+      win32: ["~/.paperclip/config.json"],
+      linux: ["~/.paperclip/config.json"]
+    }
   }
 ];
 
@@ -418,6 +551,28 @@ function extractKeyFromConfig(piutConfig) {
   }
   return null;
 }
+function extractSlugFromConfig(piutConfig) {
+  const slugFromUrl = (u) => {
+    if (typeof u !== "string") return null;
+    const m = u.match(/\/api\/mcp\/([^/?#]+)/);
+    return m ? m[1] : null;
+  };
+  const fromUrl = slugFromUrl(piutConfig.url) || slugFromUrl(piutConfig.serverUrl) || slugFromUrl(piutConfig.httpUrl);
+  if (fromUrl) return fromUrl;
+  const settings = piutConfig.settings;
+  if (settings) {
+    const fromSettings = slugFromUrl(settings.url);
+    if (fromSettings) return fromSettings;
+  }
+  const args2 = piutConfig.args;
+  if (Array.isArray(args2)) {
+    for (const arg of args2) {
+      const fromArg = slugFromUrl(arg);
+      if (fromArg) return fromArg;
+    }
+  }
+  return null;
+}
 function removeFromConfig(filePath, configKey) {
   const config = readConfig(filePath);
   if (!config) return false;
@@ -728,20 +883,25 @@ async function setupCommand(options) {
   const toolFilter = options.tool;
   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));
       if (exists || parentExists) {
-        const configured2 = exists && isPiutConfigured(configPath, tool.configKey);
+        const configured2 = exists && !!tool.configKey && isPiutConfigured(configPath, tool.configKey);
         let staleKey = false;
-        if (configured2) {
+        if (configured2 && tool.configKey) {
           const piutConfig = getPiutConfig(configPath, tool.configKey);
           if (piutConfig) {
             const existingKey = extractKeyFromConfig(piutConfig);
             if (existingKey && existingKey !== apiKey) {
               staleKey = true;
             }
+            const existingSlug = extractSlugFromConfig(piutConfig);
+            if (existingSlug && existingSlug !== slug) {
+              staleKey = true;
+            }
           }
         }
         detected.push({
@@ -757,7 +917,6 @@ async function setupCommand(options) {
   }
   if (detected.length === 0) {
     console.log(warning("  No supported AI tools detected."));
-    console.log(dim("  Supported: Claude Code, Claude Desktop, Cursor, Windsurf, GitHub Copilot, Amazon Q, Zed"));
     console.log(dim("  See https://piut.com/docs for manual setup."));
     console.log();
     return;
@@ -809,7 +968,7 @@ async function setupCommand(options) {
       try {
         execSync(tool.quickCommand(slug, apiKey), { stdio: "pipe" });
         const claudeJson = expandPath("~/.claude.json");
-        const written = getPiutConfig(claudeJson, tool.configKey);
+        const written = tool.configKey ? getPiutConfig(claudeJson, tool.configKey) : null;
         if (written) {
           quickSuccess = true;
           configured.push(tool.name);
@@ -818,7 +977,7 @@ async function setupCommand(options) {
         }
         try {
           execSync(tool.quickCommand(slug, apiKey) + " --scope user", { stdio: "pipe" });
-          const retryCheck = getPiutConfig(claudeJson, tool.configKey);
+          const retryCheck = tool.configKey ? getPiutConfig(claudeJson, tool.configKey) : null;
           if (retryCheck) {
             quickSuccess = true;
             configured.push(tool.name);
@@ -837,10 +996,12 @@ async function setupCommand(options) {
       }
       if (quickSuccess) continue;
     }
-    const serverConfig = tool.generateConfig(slug, apiKey);
-    mergeConfig(configPath, tool.configKey, serverConfig);
-    configured.push(tool.name);
-    toolLine(tool.name, success("configured"), "\u2714");
+    if (tool.generateConfig && tool.configKey) {
+      const serverConfig = tool.generateConfig(slug, apiKey);
+      mergeConfig(configPath, tool.configKey, serverConfig);
+      configured.push(tool.name);
+      toolLine(tool.name, success("configured"), "\u2714");
+    }
   }
   if (!options.skipSkill && configured.length > 0) {
     const addSkill = options.yes ? true : await confirm({
@@ -881,6 +1042,7 @@ 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 (piutConfig) {
         toolLine(det.tool.name, success("config verified"), "\u2714");
@@ -922,15 +1084,463 @@ function isCommandAvailable(cmd) {
 }
 
 // src/commands/status.ts
-import fs7 from "fs";
-import path9 from "path";
+import fs9 from "fs";
+import os7 from "os";
+import path12 from "path";
 import chalk3 from "chalk";
 
 // src/lib/brain-scanner.ts
-import fs5 from "fs";
+import fs7 from "fs";
+import path10 from "path";
+import os5 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"
+]);
+var AI_CONFIG_FILENAMES = /* @__PURE__ */ new Set([
+  "CLAUDE.md",
+  ".cursorrules",
+  ".windsurfrules",
+  ".rules",
+  ".clinerules",
+  "AGENTS.md",
+  "CONVENTIONS.md",
+  "MEMORY.md",
+  "SOUL.md",
+  "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";
 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_HOME_DIRS = /* @__PURE__ */ new Set([
+  "Library",
+  "Applications",
+  "Public",
+  "Movies",
+  "Music",
+  "Pictures",
+  "Templates",
+  ".Trash"
+]);
+var INCLUDE_DOT_DIRS = /* @__PURE__ */ new Set([
+  ".claude",
+  ".cursor",
+  ".windsurf",
+  ".openclaw",
+  ".zed",
+  ".github",
+  ".amazonq",
+  ".gemini",
+  ".mcporter",
+  ".paperclip"
+]);
+function getDefaultScanDirs() {
+  const dirs = [];
+  try {
+    const entries = fs6.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));
+    }
+  } catch {
+  }
+  const cloudStorage = path9.join(home, "Library", "CloudStorage");
+  try {
+    if (fs6.existsSync(cloudStorage) && fs6.statSync(cloudStorage).isDirectory()) {
+      const entries = fs6.readdirSync(cloudStorage, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const fullPath = path9.join(cloudStorage, entry.name);
+        if (!dirs.includes(fullPath)) {
+          dirs.push(fullPath);
+        }
+      }
+    }
+  } catch {
+  }
+  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",
@@ -952,21 +1562,6 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([
   "Cache",
   ".piut"
 ]);
-var FULL_READ_FILES = /* @__PURE__ */ new Set([
-  "README.md",
-  "CLAUDE.md",
-  ".cursorrules",
-  ".windsurfrules",
-  ".rules",
-  ".clinerules",
-  "AGENTS.md",
-  "CONVENTIONS.md",
-  "MEMORY.md",
-  "SOUL.md",
-  "IDENTITY.md"
-]);
-var MAX_FILE_SIZE = 100 * 1024;
-var RECENT_DAYS = 30;
 var SCAN_DOT_DIRS = /* @__PURE__ */ new Set([
   ".claude",
   ".cursor",
@@ -974,57 +1569,33 @@ var SCAN_DOT_DIRS = /* @__PURE__ */ new Set([
   ".github",
   ".zed",
   ".amazonq",
-  ".vscode"
+  ".vscode",
+  ".gemini",
+  ".openclaw",
+  ".mcporter",
+  ".paperclip"
 ]);
 function shouldSkipDir(name) {
-  if (name.startsWith(".") && !SCAN_DOT_DIRS.has(name)) {
-    return true;
-  }
+  if (name.startsWith(".") && !SCAN_DOT_DIRS.has(name)) return true;
   return SKIP_DIRS.has(name);
 }
-function readFileSafe(filePath) {
-  try {
-    const stat = fs5.statSync(filePath);
-    if (stat.size > MAX_FILE_SIZE) return null;
-    if (!stat.isFile()) return null;
-    return fs5.readFileSync(filePath, "utf-8");
-  } catch {
-    return null;
-  }
-}
-function getFolderTree(dir, depth = 0, maxDepth = 3) {
-  if (depth >= maxDepth) return [];
-  const entries = [];
-  try {
-    const items = fs5.readdirSync(dir, { withFileTypes: true });
-    for (const item of items) {
-      if (!item.isDirectory()) continue;
-      if (shouldSkipDir(item.name)) continue;
-      const indent = "  ".repeat(depth);
-      entries.push(`${indent}${item.name}/`);
-      entries.push(...getFolderTree(path7.join(dir, item.name), depth + 1, maxDepth));
-    }
-  } catch {
-  }
-  return entries;
-}
 function isProject(dirPath) {
-  return fs5.existsSync(path7.join(dirPath, ".git")) || fs5.existsSync(path7.join(dirPath, "package.json")) || fs5.existsSync(path7.join(dirPath, "Cargo.toml")) || fs5.existsSync(path7.join(dirPath, "pyproject.toml")) || fs5.existsSync(path7.join(dirPath, "go.mod"));
+  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"));
 }
 function buildProjectInfo(projectPath) {
-  const hasPkgJson = fs5.existsSync(path7.join(projectPath, "package.json"));
+  const hasPkgJson = fs7.existsSync(path10.join(projectPath, "package.json"));
   let description = "";
   if (hasPkgJson) {
     try {
-      const pkg = JSON.parse(fs5.readFileSync(path7.join(projectPath, "package.json"), "utf-8"));
+      const pkg = JSON.parse(fs7.readFileSync(path10.join(projectPath, "package.json"), "utf-8"));
       description = pkg.description || "";
     } catch {
     }
   }
-  const readmePath = path7.join(projectPath, "README.md");
-  if (!description && fs5.existsSync(readmePath)) {
-    const content = readFileSafe(readmePath);
-    if (content) {
+  const readmePath = path10.join(projectPath, "README.md");
+  if (!description && fs7.existsSync(readmePath)) {
+    try {
+      const content = fs7.readFileSync(readmePath, "utf-8");
       const lines = content.split("\n");
       let foundHeading = false;
       for (const line of lines) {
@@ -1037,18 +1608,19 @@ function buildProjectInfo(projectPath) {
           break;
         }
       }
+    } catch {
     }
   }
   return {
-    name: path7.basename(projectPath),
+    name: path10.basename(projectPath),
     path: projectPath,
     description,
-    hasClaudeMd: fs5.existsSync(path7.join(projectPath, "CLAUDE.md")) || fs5.existsSync(path7.join(projectPath, ".claude", "rules")),
-    hasCursorRules: fs5.existsSync(path7.join(projectPath, ".cursorrules")) || fs5.existsSync(path7.join(projectPath, ".cursor", "rules")),
-    hasWindsurfRules: fs5.existsSync(path7.join(projectPath, ".windsurfrules")) || fs5.existsSync(path7.join(projectPath, ".windsurf", "rules")),
-    hasCopilotInstructions: fs5.existsSync(path7.join(projectPath, ".github", "copilot-instructions.md")) || fs5.existsSync(path7.join(projectPath, ".github", "instructions")),
-    hasConventionsMd: fs5.existsSync(path7.join(projectPath, "CONVENTIONS.md")) || fs5.existsSync(path7.join(projectPath, ".amazonq", "rules")),
-    hasZedRules: fs5.existsSync(path7.join(projectPath, ".rules"))
+    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"))
   };
 }
 var MAX_PROJECT_DEPTH = 4;
@@ -1058,17 +1630,17 @@ function detectProjects(scanDirs, onProgress) {
   function walk(dir, depth) {
     if (depth > MAX_PROJECT_DEPTH) return;
     try {
-      const items = fs5.readdirSync(dir, { withFileTypes: true });
+      const items = fs7.readdirSync(dir, { withFileTypes: true });
       for (const item of items) {
         if (!item.isDirectory()) continue;
         if (shouldSkipDir(item.name)) continue;
-        const fullPath = path7.join(dir, item.name);
+        const fullPath = path10.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(home, "~")})` });
+          onProgress?.({ phase: "projects", message: `${info.name} (${fullPath.replace(home2, "~")})` });
         } else {
           walk(fullPath, depth + 1);
         }
@@ -1081,150 +1653,150 @@ function detectProjects(scanDirs, onProgress) {
   }
   return projects;
 }
+var MAX_CONFIG_SIZE = 100 * 1024;
 function collectConfigFiles(projects, onProgress) {
   const configs = [];
   const globalPaths = [
-    path7.join(home, ".claude", "MEMORY.md"),
-    path7.join(home, ".claude", "CLAUDE.md"),
-    path7.join(home, ".openclaw", "workspace", "SOUL.md"),
-    path7.join(home, ".openclaw", "workspace", "MEMORY.md")
+    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")
   ];
   for (const gp of globalPaths) {
-    const content = readFileSafe(gp);
-    if (content && content.trim()) {
-      const name = `~/${path7.relative(home, gp)}`;
-      configs.push({ name, content });
-      onProgress?.({ phase: "configs", message: name });
-    }
-  }
-  for (const project of projects) {
-    for (const fileName of FULL_READ_FILES) {
-      const filePath = path7.join(project.path, fileName);
-      const content = readFileSafe(filePath);
-      if (content && content.trim()) {
-        const name = `${project.name}/${fileName}`;
+    try {
+      const stat = fs7.statSync(gp);
+      if (!stat.isFile() || stat.size > MAX_CONFIG_SIZE) continue;
+      const content = fs7.readFileSync(gp, "utf-8");
+      if (content.trim()) {
+        const name = `~/${path10.relative(home2, gp)}`;
         configs.push({ name, content });
         onProgress?.({ phase: "configs", message: name });
       }
+    } catch {
     }
-    const pkgPath = path7.join(project.path, "package.json");
-    const pkgContent = readFileSafe(pkgPath);
-    if (pkgContent) {
+  }
+  for (const project of projects) {
+    for (const fileName of AI_CONFIG_FILENAMES) {
+      const filePath = path10.join(project.path, fileName);
       try {
-        const pkg = JSON.parse(pkgContent);
-        const summary = JSON.stringify({ name: pkg.name, description: pkg.description }, null, 2);
-        const name = `${project.name}/package.json`;
-        configs.push({ name, content: summary });
-        onProgress?.({ phase: "configs", message: name });
+        const stat = fs7.statSync(filePath);
+        if (!stat.isFile() || stat.size > MAX_CONFIG_SIZE) continue;
+        const content = fs7.readFileSync(filePath, "utf-8");
+        if (content.trim()) {
+          const name = `${project.name}/${fileName}`;
+          configs.push({ name, content });
+          onProgress?.({ phase: "configs", message: name });
+        }
       } catch {
       }
     }
+    const pkgPath = path10.join(project.path, "package.json");
+    try {
+      const stat = fs7.statSync(pkgPath);
+      if (stat.isFile() && stat.size <= MAX_CONFIG_SIZE) {
+        const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
+        const summary = JSON.stringify({ name: pkg.name, description: pkg.description }, null, 2);
+        configs.push({ name: `${project.name}/package.json`, content: summary });
+        onProgress?.({ phase: "configs", message: `${project.name}/package.json` });
+      }
+    } catch {
+    }
   }
   return configs;
 }
-function collectRecentDocs(projects, onProgress) {
-  const docs = [];
-  const cutoff = Date.now() - RECENT_DAYS * 24 * 60 * 60 * 1e3;
+var MAX_SCAN_DEPTH = 6;
+var MAX_FILES = 500;
+async function scanFilesInDirs(dirs, onProgress) {
+  const files = [];
   const seen = /* @__PURE__ */ new Set();
-  for (const project of projects) {
+  function walk(dir, depth) {
+    if (depth > MAX_SCAN_DEPTH) return [];
+    const found = [];
     try {
-      const items = fs5.readdirSync(project.path, { withFileTypes: true });
+      const items = fs7.readdirSync(dir, { withFileTypes: true });
       for (const item of items) {
-        if (!item.isFile()) continue;
-        if (!item.name.endsWith(".md")) continue;
-        if (FULL_READ_FILES.has(item.name)) continue;
-        if (item.name.startsWith(".")) continue;
-        const filePath = path7.join(project.path, item.name);
-        if (seen.has(filePath)) continue;
-        seen.add(filePath);
-        try {
-          const stat = fs5.statSync(filePath);
-          if (stat.mtimeMs < cutoff) continue;
-          if (stat.size > MAX_FILE_SIZE) continue;
-          const content = fs5.readFileSync(filePath, "utf-8");
-          if (content.trim()) {
-            const name = `${project.name}/${item.name}`;
-            docs.push({ name, content });
-            onProgress?.({ phase: "docs", message: name });
+        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 {
         }
       }
     } catch {
     }
+    return found;
   }
-  return docs.slice(0, 20);
-}
-var SKIP_HOME_DIRS = /* @__PURE__ */ new Set([
-  "Library",
-  "Applications",
-  "Public",
-  "Movies",
-  "Music",
-  "Pictures",
-  "Templates",
-  ".Trash"
-]);
-var INCLUDE_DOT_DIRS = /* @__PURE__ */ new Set([
-  ".claude",
-  ".cursor",
-  ".windsurf",
-  ".openclaw",
-  ".zed",
-  ".github",
-  ".amazonq"
-]);
-function getDefaultScanDirs() {
-  const dirs = [];
-  try {
-    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(path7.join(home, entry.name));
-    }
-  } catch {
+  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 cloudStorage = path7.join(home, "Library", "CloudStorage");
-  try {
-    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 = path7.join(cloudStorage, entry.name);
-        if (!dirs.includes(fullPath)) {
-          dirs.push(fullPath);
-        }
+  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 {
     }
-  } catch {
-  }
-  if (dirs.length === 0) {
-    dirs.push(home);
   }
-  return dirs;
+  return files;
 }
-function scanForBrain(folders, onProgress) {
-  const scanDirs = folders || getDefaultScanDirs();
+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 dir of scanDirs) {
-    folderTree.push(`${path7.basename(dir)}/`);
-    folderTree.push(...getFolderTree(dir, 1));
+  for (const folder of scanResult.folders) {
+    if (selectedSet.has(folder.path)) {
+      folderTree.push(`${folder.displayPath}/ (${folder.fileCount} files)`);
+    }
   }
-  const projects = detectProjects(scanDirs, onProgress);
-  const configFiles = collectConfigFiles(projects, onProgress);
-  const recentDocuments = collectRecentDocs(projects, onProgress);
+  const personalDocuments = selectedFiles.map((f) => ({
+    name: f.displayPath,
+    content: f.content,
+    format: f.format
+  }));
   return {
     summary: {
       folders: folderTree,
-      projects: projects.map((p) => ({
+      projects: scanResult.projects.map((p) => ({
         name: p.name,
-        path: p.path.replace(home, "~"),
+        path: p.path.replace(home2, "~"),
         description: p.description
       })),
-      configFiles,
-      recentDocuments
+      configFiles: scanResult.configFiles,
+      recentDocuments: [],
+      personalDocuments
     }
   };
 }
@@ -1234,14 +1806,14 @@ function scanForProjects(folders) {
 }
 
 // src/lib/store.ts
-import fs6 from "fs";
-import path8 from "path";
-import os5 from "os";
-var CONFIG_DIR = path8.join(os5.homedir(), ".piut");
-var CONFIG_FILE2 = path8.join(CONFIG_DIR, "config.json");
+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");
 function readStore() {
   try {
-    const raw = fs6.readFileSync(CONFIG_FILE2, "utf-8");
+    const raw = fs8.readFileSync(CONFIG_FILE2, "utf-8");
     return JSON.parse(raw);
   } catch {
     return {};
@@ -1250,18 +1822,19 @@ function readStore() {
 function updateStore(updates) {
   const config = readStore();
   const updated = { ...config, ...updates };
-  fs6.mkdirSync(CONFIG_DIR, { recursive: true });
-  fs6.writeFileSync(CONFIG_FILE2, JSON.stringify(updated, null, 2) + "\n", "utf-8");
+  fs8.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs8.writeFileSync(CONFIG_FILE2, JSON.stringify(updated, null, 2) + "\n", "utf-8");
   return updated;
 }
 function clearStore() {
   try {
-    fs6.unlinkSync(CONFIG_FILE2);
+    fs8.unlinkSync(CONFIG_FILE2);
   } catch {
   }
 }
 
 // src/commands/status.ts
+var API_BASE3 = process.env.PIUT_API_BASE || "https://piut.com";
 var PIUT_FILES = [
   "CLAUDE.md",
   ".cursor/rules/piut.mdc",
@@ -1272,25 +1845,67 @@ var PIUT_FILES = [
 ];
 function hasPiutReference(filePath) {
   try {
-    const content = fs7.readFileSync(filePath, "utf-8");
+    const content = fs9.readFileSync(filePath, "utf-8");
     return content.includes("p\u0131ut Context") || content.includes("piut Context");
   } catch {
     return false;
   }
 }
+async function fetchRemoteConnections(key) {
+  try {
+    const res = await fetch(`${API_BASE3}/api/mcp/connections`, {
+      headers: { Authorization: `Bearer ${key}` }
+    });
+    if (!res.ok) return [];
+    const data = await res.json();
+    return data.connections || [];
+  } catch {
+    return [];
+  }
+}
+async function fetchRemoteProjects(key) {
+  try {
+    const res = await fetch(`${API_BASE3}/api/cli/projects`, {
+      headers: { Authorization: `Bearer ${key}` }
+    });
+    if (!res.ok) return [];
+    const data = await res.json();
+    return data.projects || [];
+  } catch {
+    return [];
+  }
+}
+function machineLabel(hostname, machineId) {
+  if (hostname) return hostname;
+  if (machineId && machineId !== "unknown") return machineId.slice(0, 8);
+  return "unknown";
+}
+function timeAgo(dateStr) {
+  const diff = Date.now() - new Date(dateStr).getTime();
+  const minutes = Math.floor(diff / 6e4);
+  if (minutes < 1) return "just now";
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  if (days < 7) return `${days}d ago`;
+  return new Date(dateStr).toLocaleDateString();
+}
 async function statusCommand(options = {}) {
   banner();
   if (options.verify) {
     await verifyStatus();
     return;
   }
-  console.log("  AI tool configuration:");
+  const thisHostname = os7.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 (!fs7.existsSync(configPath)) continue;
+      if (!fs9.existsSync(configPath)) continue;
       foundAny = true;
       const configured = isPiutConfigured(configPath, tool.configKey);
       if (configured) {
@@ -1306,15 +1921,15 @@ async function statusCommand(options = {}) {
     console.log(dim("  Run ") + brand("piut setup") + dim(" to configure your AI tools."));
   }
   console.log();
-  console.log("  Connected projects:");
+  console.log(`  Connected projects on this machine:`);
   console.log();
   const projects = scanForProjects();
   let connectedCount = 0;
   for (const project of projects) {
     const connectedFiles = [];
     for (const file of PIUT_FILES) {
-      const absPath = path9.join(project.path, file);
-      if (fs7.existsSync(absPath) && hasPiutReference(absPath)) {
+      const absPath = path12.join(project.path, file);
+      if (fs9.existsSync(absPath) && hasPiutReference(absPath)) {
         connectedFiles.push(file);
       }
     }
@@ -1331,6 +1946,33 @@ async function statusCommand(options = {}) {
     console.log(dim(`  ${connectedCount} project(s) connected to your brain.`));
   }
   console.log();
+  const store = readStore();
+  if (store.apiKey) {
+    const [remoteConnections, remoteProjects] = await Promise.all([
+      fetchRemoteConnections(store.apiKey),
+      fetchRemoteProjects(store.apiKey)
+    ]);
+    const otherMachineConns = remoteConnections.filter((c) => c.machine_id !== thisMachineId);
+    const otherMachineProjects = remoteProjects.filter((p) => p.machineId !== thisMachineId);
+    if (otherMachineConns.length > 0 || otherMachineProjects.length > 0) {
+      console.log(`  Other machines:`);
+      console.log();
+      if (otherMachineConns.length > 0) {
+        for (const conn of otherMachineConns) {
+          const machine = machineLabel(conn.hostname, conn.machine_id);
+          const age = timeAgo(conn.last_connected_at);
+          console.log(dim(`  ${conn.tool_name}`) + dim(` @${machine}`) + dim(` \u2014 ${conn.request_count} requests, ${age}`));
+        }
+      }
+      if (otherMachineProjects.length > 0) {
+        for (const proj of otherMachineProjects) {
+          const machine = machineLabel(proj.hostname, proj.machineId);
+          console.log(dim(`  ${proj.projectName}`) + dim(` @${machine}:${proj.projectPath}`));
+        }
+      }
+      console.log();
+    }
+  }
 }
 async function verifyStatus() {
   const store = readStore();
@@ -1360,7 +2002,7 @@ async function verifyStatus() {
   for (const tool of TOOLS) {
     const paths = resolveConfigPaths(tool.configPaths);
     for (const configPath of paths) {
-      if (!fs7.existsSync(configPath)) continue;
+      if (!fs9.existsSync(configPath)) continue;
       const piutConfig = getPiutConfig(configPath, tool.configKey);
       if (!piutConfig) {
         toolLine(tool.name, dim("installed, not connected"), "\u25CB");
@@ -1403,15 +2045,16 @@ async function verifyStatus() {
 }
 
 // src/commands/remove.ts
-import fs8 from "fs";
+import fs10 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 (fs8.existsSync(configPath) && isPiutConfigured(configPath, tool.configKey)) {
+      if (fs10.existsSync(configPath) && isPiutConfigured(configPath, tool.configKey)) {
         configured.push({ tool, configPath });
         break;
       }
@@ -1440,134 +2083,220 @@ 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);
     if (removed) {
+      removedNames.push(tool.name);
       toolLine(tool.name, success("removed"), "\u2714");
     } else {
       toolLine(tool.name, warning("not found"), "\xD7");
     }
   }
+  const store = readStore();
+  if (store.apiKey && removedNames.length > 0) {
+    deleteConnections(store.apiKey, removedNames).catch(() => {
+    });
+  }
   console.log();
   console.log(dim("  Restart your AI tools for changes to take effect."));
   console.log();
 }
 
 // src/commands/build.ts
-import { select, checkbox as checkbox3, input, confirm as confirm3 } from "@inquirer/prompts";
+import { select as select2, checkbox as checkbox3, input as input2, confirm as confirm3 } from "@inquirer/prompts";
 import chalk5 from "chalk";
-import os6 from "os";
+import os8 from "os";
 
 // src/lib/auth.ts
-import { password as password2 } from "@inquirer/prompts";
+import { select, input, password as password2 } from "@inquirer/prompts";
+import { exec } from "child_process";
 import chalk4 from "chalk";
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  exec(`${cmd} "${url}"`);
+}
+async function loginWithEmailFlow() {
+  const email = await input({
+    message: "Email:",
+    validate: (v) => v.includes("@") || "Enter a valid email address"
+  });
+  const pw = await password2({
+    message: "Password:",
+    mask: "*"
+  });
+  console.log(dim("  Authenticating..."));
+  const result = await loginWithEmail(email, pw);
+  return {
+    apiKey: result.apiKey,
+    validation: {
+      slug: result.slug,
+      displayName: result.displayName,
+      serverUrl: result.serverUrl,
+      planType: result.planType,
+      status: result.status,
+      _contractVersion: result._contractVersion
+    }
+  };
+}
+async function pasteKeyFlow() {
+  const apiKey = await password2({
+    message: "Enter your p\u0131ut API key:",
+    mask: "*",
+    validate: (v) => v.startsWith("pb_") || "Key must start with pb_"
+  });
+  console.log(dim("  Validating key..."));
+  const validation = await validateKey(apiKey);
+  return { apiKey, validation };
+}
+async function browserFlow() {
+  const url = "https://piut.com/dashboard/keys";
+  console.log(dim(`  Opening ${brand(url)}...`));
+  openBrowser(url);
+  console.log(dim("  Copy your API key from the dashboard, then paste it here."));
+  console.log();
+  return pasteKeyFlow();
+}
+async function promptLogin() {
+  const method = await select({
+    message: "How would you like to connect?",
+    choices: [
+      {
+        name: "Log in with email",
+        value: "email",
+        description: "Use your p\u0131ut email and password"
+      },
+      {
+        name: "Log in with browser",
+        value: "browser",
+        description: "Open piut.com to get your API key"
+      },
+      {
+        name: "Paste API key",
+        value: "api-key",
+        description: "Enter an API key directly"
+      }
+    ]
+  });
+  switch (method) {
+    case "email":
+      return loginWithEmailFlow();
+    case "browser":
+      return browserFlow();
+    case "api-key":
+      return pasteKeyFlow();
+  }
+}
 async function resolveApiKeyWithResult(keyOption) {
   const config = readStore();
   let apiKey = keyOption || config.apiKey;
-  if (!apiKey) {
-    apiKey = await password2({
-      message: "Enter your p\u0131ut API key:",
-      mask: "*",
-      validate: (v) => v.startsWith("pb_") || "Key must start with pb_"
-    });
+  if (apiKey) {
+    console.log(dim("  Validating key..."));
+    let result;
+    try {
+      result = await validateKey(apiKey);
+    } catch (err) {
+      console.log(chalk4.red(`  \u2717 ${err.message}`));
+      console.log(dim("  Get a key at https://piut.com/dashboard/keys"));
+      throw new CliError(err.message);
+    }
+    const label = result.slug ? `${result.displayName} (${result.slug})` : result.displayName;
+    console.log(success(`  \u2713 Connected as ${label}`));
+    updateStore({ apiKey });
+    return { apiKey, ...result };
   }
-  console.log(dim("  Validating key..."));
-  let result;
   try {
-    result = await validateKey(apiKey);
+    const { apiKey: newKey, validation } = await promptLogin();
+    const label = validation.slug ? `${validation.displayName} (${validation.slug})` : validation.displayName;
+    console.log(success(`  \u2713 Connected as ${label}`));
+    updateStore({ apiKey: newKey });
+    return { apiKey: newKey, ...validation };
   } catch (err) {
     console.log(chalk4.red(`  \u2717 ${err.message}`));
-    console.log(dim("  Get a key at https://piut.com/dashboard/keys"));
     throw new CliError(err.message);
   }
-  const label = result.slug ? `${result.displayName} (${result.slug})` : result.displayName;
-  console.log(success(`  \u2713 Connected as ${label}`));
-  updateStore({ apiKey });
-  return { apiKey, ...result };
 }
 
 // src/commands/build.ts
 async function buildCommand(options) {
   banner();
   const { apiKey, serverUrl } = await resolveApiKeyWithResult(options.key);
-  let scanFolders;
+  let scanDirs;
   if (options.folders) {
-    scanFolders = options.folders.split(",").map((f) => expandPath(f.trim()));
-  }
-  const cwd = process.cwd();
-  const cwdDisplay = cwd.replace(os6.homedir(), "~");
-  if (!scanFolders) {
-    console.log(dim(`  Current directory: `) + cwdDisplay);
-    console.log(dim(`  We'll scan for AI config files and projects here.`));
+    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();
-    const mode = await select({
-      message: "How do you want to build your brain?",
-      choices: [
-        { name: `Scan this directory (${cwdDisplay})`, value: "cwd", description: "Scan current directory for projects and config files" },
-        { name: "Select folder(s)...", value: "folders", description: "Choose a different directory to scan" }
-      ]
-    });
-    if (mode === "cwd") {
-      scanFolders = [cwd];
-    } else {
-      const defaults = getDefaultScanDirs();
-      const CUSTOM_VALUE = "__custom__";
-      const choices = [
-        ...defaults.map((d) => ({ name: d.replace(os6.homedir(), "~"), value: d })),
-        { name: chalk5.dim("Enter a custom path..."), value: CUSTOM_VALUE }
-      ];
-      const selected = await checkbox3({
-        message: "Which folders should we scan?",
-        choices,
-        required: true
-      });
-      if (selected.includes(CUSTOM_VALUE)) {
-        const custom = await input({
-          message: "Enter folder path(s), comma-separated:"
-        });
-        const customPaths = custom.split(",").map((f) => expandPath(f.trim())).filter(Boolean);
-        scanFolders = [
-          ...selected.filter((v) => v !== CUSTOM_VALUE),
-          ...customPaths
-        ];
-      } else {
-        scanFolders = selected;
-      }
-      if (scanFolders.length === 0) {
-        console.log(chalk5.yellow("  No folders selected."));
-        return;
-      }
-    }
+    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();
+  console.log(dim("  Scanning locally \u2014 no data is shared..."));
   console.log();
-  let projectCount = 0;
-  let configCount = 0;
-  let docCount = 0;
+  let fileCount = 0;
   const onProgress = (progress) => {
-    if (progress.phase === "projects") {
-      projectCount++;
-      console.log(dim(`  [${projectCount}] ${progress.message}`));
+    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") {
+      console.log(dim(`  [project] ${progress.message}`));
     } else if (progress.phase === "configs") {
-      configCount++;
-      console.log(dim(`  [${configCount}] ${progress.message}`));
-    } else if (progress.phase === "docs") {
-      docCount++;
-      console.log(dim(`  [${docCount}] ${progress.message}`));
+      console.log(dim(`  [config] ${progress.message}`));
+    }
+  };
+  const scanResult = await scanFolders(scanDirs, onProgress);
+  console.log();
+  console.log(success(`  \u2713 Scan complete: ${scanResult.totalFiles} files found across ${scanResult.folders.length} folders (local only)`));
+  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."));
+    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."));
+    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();
+    console.log(dim(`  Privacy policy: ${brand("https://piut.com/privacy")}`));
+    console.log();
+    const consent = await confirm3({
+      message: "Send files and build your brain?",
+      default: false
+    });
+    if (!consent) {
+      console.log();
+      console.log(dim("  Build cancelled. No files were sent."));
+      console.log();
+      return;
     }
-  };
-  const brainInput = scanForBrain(scanFolders, onProgress);
-  const projCount = brainInput.summary.projects.length;
-  const cfgCount = brainInput.summary.configFiles.length;
-  const dcCount = brainInput.summary.recentDocuments.length;
-  console.log();
-  console.log(success(`  Scanned: ${projCount} projects, ${cfgCount} config files, ${dcCount} recent docs`));
-  console.log();
-  if (projCount === 0 && cfgCount === 0) {
-    console.log(chalk5.yellow("  No projects or config files found to build from."));
-    console.log(dim("  Try running from a directory with your projects, or use --folders."));
-    console.log();
-    return;
   }
+  const brainInput = buildBrainInput(scanResult, selectedFolderPaths);
   const spinner = new Spinner();
   spinner.start("Generating brain...");
   try {
@@ -1672,6 +2401,78 @@ async function buildCommand(options) {
     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];
+    }
+  }
+  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
 import chalk6 from "chalk";
@@ -1711,33 +2512,33 @@ async function deployCommand(options) {
 }
 
 // src/commands/connect.ts
-import fs9 from "fs";
-import path10 from "path";
+import fs11 from "fs";
+import path13 from "path";
 import { checkbox as checkbox4 } from "@inquirer/prompts";
 var RULE_FILES = [
   {
     tool: "Claude Code",
     filePath: "CLAUDE.md",
     strategy: "append",
-    detect: (p) => p.hasClaudeMd || fs9.existsSync(path10.join(p.path, ".claude"))
+    detect: (p) => p.hasClaudeMd || fs11.existsSync(path13.join(p.path, ".claude"))
   },
   {
     tool: "Cursor",
     filePath: ".cursor/rules/piut.mdc",
     strategy: "create",
-    detect: (p) => p.hasCursorRules || fs9.existsSync(path10.join(p.path, ".cursor"))
+    detect: (p) => p.hasCursorRules || fs11.existsSync(path13.join(p.path, ".cursor"))
   },
   {
     tool: "Windsurf",
     filePath: ".windsurf/rules/piut.md",
     strategy: "create",
-    detect: (p) => p.hasWindsurfRules || fs9.existsSync(path10.join(p.path, ".windsurf"))
+    detect: (p) => p.hasWindsurfRules || fs11.existsSync(path13.join(p.path, ".windsurf"))
   },
   {
     tool: "GitHub Copilot",
     filePath: ".github/copilot-instructions.md",
     strategy: "append",
-    detect: (p) => p.hasCopilotInstructions || fs9.existsSync(path10.join(p.path, ".github"))
+    detect: (p) => p.hasCopilotInstructions || fs11.existsSync(path13.join(p.path, ".github"))
   },
   {
     tool: "Amazon Q",
@@ -1749,7 +2550,19 @@ var RULE_FILES = [
     tool: "Zed",
     filePath: ".zed/rules.md",
     strategy: "create",
-    detect: (p) => p.hasZedRules || fs9.existsSync(path10.join(p.path, ".zed"))
+    detect: (p) => p.hasZedRules || fs11.existsSync(path13.join(p.path, ".zed"))
+  },
+  {
+    tool: "Gemini CLI",
+    filePath: "GEMINI.md",
+    strategy: "append",
+    detect: (p) => fs11.existsSync(path13.join(p.path, ".gemini"))
+  },
+  {
+    tool: "Paperclip",
+    filePath: "AGENTS.md",
+    strategy: "append",
+    detect: (p) => fs11.existsSync(path13.join(p.path, ".paperclip"))
   }
 ];
 var DEDICATED_FILE_CONTENT = `## p\u0131ut Context (MCP Server: piut-context)
@@ -1784,7 +2597,7 @@ Full skill reference: .piut/skill.md
 `;
 function hasPiutReference2(filePath) {
   try {
-    const content = fs9.readFileSync(filePath, "utf-8");
+    const content = fs11.readFileSync(filePath, "utf-8");
     return content.includes("p\u0131ut Context") || content.includes("piut Context");
   } catch {
     return false;
@@ -1807,13 +2620,13 @@ async function connectCommand(options) {
     console.log();
     return;
   }
-  let scanFolders;
+  let scanFolders2;
   if (options.folders) {
-    scanFolders = options.folders.split(",").map((f) => expandPath(f.trim()));
+    scanFolders2 = options.folders.split(",").map((f) => expandPath(f.trim()));
   }
   console.log();
   console.log(dim("  Scanning for projects..."));
-  const projects = scanForProjects(scanFolders);
+  const projects = scanForProjects(scanFolders2);
   if (projects.length === 0) {
     console.log(warning("  No projects found."));
     console.log(dim("  Try running from a directory with your projects, or use --folders."));
@@ -1824,20 +2637,20 @@ async function connectCommand(options) {
   for (const project of projects) {
     for (const rule of RULE_FILES) {
       if (!rule.detect(project)) continue;
-      const absPath = path10.join(project.path, rule.filePath);
-      if (fs9.existsSync(absPath) && hasPiutReference2(absPath)) continue;
+      const absPath = path13.join(project.path, rule.filePath);
+      if (fs11.existsSync(absPath) && hasPiutReference2(absPath)) continue;
       actions.push({
         project,
         tool: rule.tool,
         filePath: rule.filePath,
         absPath,
-        action: rule.strategy === "create" || !fs9.existsSync(absPath) ? "create" : "append"
+        action: rule.strategy === "create" || !fs11.existsSync(absPath) ? "create" : "append"
       });
     }
     const hasAnyAction = actions.some((a) => a.project === project);
     if (!hasAnyAction) {
-      const claudeMdPath = path10.join(project.path, "CLAUDE.md");
-      if (!fs9.existsSync(claudeMdPath)) {
+      const claudeMdPath = path13.join(project.path, "CLAUDE.md");
+      if (!fs11.existsSync(claudeMdPath)) {
         actions.push({
           project,
           tool: "Claude Code",
@@ -1877,7 +2690,7 @@ async function connectCommand(options) {
   console.log();
   const projectChoices = [];
   for (const [projectPath, projectActions] of byProject) {
-    const projectName = path10.basename(projectPath);
+    const projectName = path13.basename(projectPath);
     const desc = projectActions.map((a) => {
       const verb = a.action === "create" ? "will create" : "will append to";
       return `${verb} ${a.filePath}`;
@@ -1906,15 +2719,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 = path10.basename(projectPath);
+    const projectName = path13.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 = fs9.existsSync(path10.join(projectPath, ".github", "copilot-instructions.md")) || fs9.existsSync(path10.join(projectPath, ".github"));
+      const hasCopilot = fs11.existsSync(path13.join(projectPath, ".github", "copilot-instructions.md")) || fs11.existsSync(path13.join(projectPath, ".github"));
       if (hasCopilot) {
-        const vscodeMcpPath = path10.join(projectPath, ".vscode", "mcp.json");
+        const vscodeMcpPath = path13.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"));
@@ -1924,26 +2737,28 @@ async function connectCommand(options) {
       if (action.action === "create") {
         const isAppendType = RULE_FILES.find((r) => r.filePath === action.filePath)?.strategy === "append";
         const content = isAppendType ? PROJECT_SKILL_SNIPPET + "\n" : DEDICATED_FILE_CONTENT;
-        fs9.mkdirSync(path10.dirname(action.absPath), { recursive: true });
-        fs9.writeFileSync(action.absPath, content, "utf-8");
+        fs11.mkdirSync(path13.dirname(action.absPath), { recursive: true });
+        fs11.writeFileSync(action.absPath, content, "utf-8");
         console.log(success(`  \u2713 ${projectName}/${action.filePath}`) + dim(" \u2014 created"));
       } else {
-        fs9.appendFileSync(action.absPath, APPEND_SECTION);
+        fs11.appendFileSync(action.absPath, APPEND_SECTION);
         console.log(success(`  \u2713 ${projectName}/${action.filePath}`) + dim(" \u2014 appended"));
       }
       connected++;
     }
   }
   const machineId = getMachineId();
+  const hostname = getHostname();
   for (const projectPath of selectedPaths) {
     const projectActions = byProject.get(projectPath) || [];
-    const projectName = path10.basename(projectPath);
+    const projectName = path13.basename(projectPath);
     const toolsDetected = [...new Set(projectActions.map((a) => a.tool))];
     const configFilesWritten = projectActions.map((a) => a.filePath);
     registerProject(apiKey, {
       projectName,
       projectPath,
       machineId,
+      hostname,
       toolsDetected,
       configFiles: configFilesWritten
     }).catch(() => {
@@ -1955,8 +2770,8 @@ async function connectCommand(options) {
 }
 
 // src/commands/disconnect.ts
-import fs10 from "fs";
-import path11 from "path";
+import fs12 from "fs";
+import path14 from "path";
 import { checkbox as checkbox5, confirm as confirm5 } from "@inquirer/prompts";
 var DEDICATED_FILES = /* @__PURE__ */ new Set([
   ".cursor/rules/piut.mdc",
@@ -1966,11 +2781,13 @@ var DEDICATED_FILES = /* @__PURE__ */ new Set([
 var APPEND_FILES = [
   "CLAUDE.md",
   ".github/copilot-instructions.md",
-  "CONVENTIONS.md"
+  "CONVENTIONS.md",
+  "GEMINI.md",
+  "AGENTS.md"
 ];
 function hasPiutReference3(filePath) {
   try {
-    const content = fs10.readFileSync(filePath, "utf-8");
+    const content = fs12.readFileSync(filePath, "utf-8");
     return content.includes("p\u0131ut Context") || content.includes("piut Context");
   } catch {
     return false;
@@ -1978,7 +2795,7 @@ function hasPiutReference3(filePath) {
 }
 function removePiutSection(filePath) {
   try {
-    let content = fs10.readFileSync(filePath, "utf-8");
+    let content = fs12.readFileSync(filePath, "utf-8");
     const patterns = [
       /\n*## p[ıi]ut Context[\s\S]*?(?=\n## |\n---\n|$)/g
     ];
@@ -1992,7 +2809,7 @@ function removePiutSection(filePath) {
     }
     if (changed) {
       content = content.replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
-      fs10.writeFileSync(filePath, content, "utf-8");
+      fs12.writeFileSync(filePath, content, "utf-8");
     }
     return changed;
   } catch {
@@ -2001,18 +2818,18 @@ function removePiutSection(filePath) {
 }
 async function disconnectCommand(options) {
   banner();
-  let scanFolders;
+  let scanFolders2;
   if (options.folders) {
-    scanFolders = options.folders.split(",").map((f) => expandPath(f.trim()));
+    scanFolders2 = options.folders.split(",").map((f) => expandPath(f.trim()));
   }
   console.log(dim("  Scanning for connected projects..."));
-  const projects = scanForProjects(scanFolders);
+  const projects = scanForProjects(scanFolders2);
   const actions = [];
   for (const project of projects) {
-    const projectName = path11.basename(project.path);
+    const projectName = path14.basename(project.path);
     for (const dedicatedFile of DEDICATED_FILES) {
-      const absPath = path11.join(project.path, dedicatedFile);
-      if (fs10.existsSync(absPath) && hasPiutReference3(absPath)) {
+      const absPath = path14.join(project.path, dedicatedFile);
+      if (fs12.existsSync(absPath) && hasPiutReference3(absPath)) {
         actions.push({
           projectPath: project.path,
           projectName,
@@ -2023,8 +2840,8 @@ async function disconnectCommand(options) {
       }
     }
     for (const appendFile of APPEND_FILES) {
-      const absPath = path11.join(project.path, appendFile);
-      if (fs10.existsSync(absPath) && hasPiutReference3(absPath)) {
+      const absPath = path14.join(project.path, appendFile);
+      if (fs12.existsSync(absPath) && hasPiutReference3(absPath)) {
         actions.push({
           projectPath: project.path,
           projectName,
@@ -2039,12 +2856,12 @@ async function disconnectCommand(options) {
         projectPath: project.path,
         projectName,
         filePath: ".piut/",
-        absPath: path11.join(project.path, ".piut"),
+        absPath: path14.join(project.path, ".piut"),
         action: "remove-dir"
       });
     }
-    const vscodeMcpPath = path11.join(project.path, ".vscode", "mcp.json");
-    if (fs10.existsSync(vscodeMcpPath) && isPiutConfigured(vscodeMcpPath, "servers")) {
+    const vscodeMcpPath = path14.join(project.path, ".vscode", "mcp.json");
+    if (fs12.existsSync(vscodeMcpPath) && isPiutConfigured(vscodeMcpPath, "servers")) {
       actions.push({
         projectPath: project.path,
         projectName,
@@ -2066,7 +2883,7 @@ async function disconnectCommand(options) {
   }
   console.log();
   const projectChoices = Array.from(byProject.entries()).map(([projectPath, projectActions]) => {
-    const name = path11.basename(projectPath);
+    const name = path14.basename(projectPath);
     const files = projectActions.map((a) => a.filePath).join(", ");
     return {
       name: `${name} ${dim(`(${files})`)}`,
@@ -2095,11 +2912,11 @@ async function disconnectCommand(options) {
   let disconnected = 0;
   for (const projectPath of selectedPaths) {
     const projectActions = byProject.get(projectPath) || [];
-    const projectName = path11.basename(projectPath);
+    const projectName = path14.basename(projectPath);
     for (const action of projectActions) {
       if (action.action === "delete") {
         try {
-          fs10.unlinkSync(action.absPath);
+          fs12.unlinkSync(action.absPath);
           console.log(success(`  \u2713 ${projectName}/${action.filePath}`) + dim(" \u2014 deleted"));
           disconnected++;
         } catch {
@@ -2142,6 +2959,21 @@ async function disconnectCommand(options) {
   console.log();
 }
 
+// src/commands/login.ts
+import chalk7 from "chalk";
+async function loginCommand() {
+  try {
+    const { apiKey, validation } = await promptLogin();
+    const label = validation.slug ? `${validation.displayName} (${validation.slug})` : validation.displayName;
+    console.log(success(`  \u2713 Connected as ${label}`));
+    updateStore({ apiKey });
+    console.log(dim("  API key saved. You can now use all p\u0131ut commands."));
+  } catch (err) {
+    console.log(chalk7.red(`  \u2717 ${err.message}`));
+    throw new CliError(err.message);
+  }
+}
+
 // src/commands/logout.ts
 async function logoutCommand() {
   banner();
@@ -2159,11 +2991,11 @@ async function logoutCommand() {
 }
 
 // src/commands/update.ts
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 
 // src/lib/update-check.ts
 import { execFile } from "child_process";
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 import { confirm as confirm6 } from "@inquirer/prompts";
 var PACKAGE_NAME = "@piut/cli";
 function isNpx() {
@@ -2200,7 +3032,7 @@ async function checkForUpdate(currentVersion) {
   const updateCmd = npx ? `npx ${PACKAGE_NAME}@latest` : `npm install -g ${PACKAGE_NAME}@latest`;
   console.log();
   console.log(brand("  Update available!") + dim(` ${currentVersion} \u2192 ${latest}`));
-  console.log(dim(`  Run ${chalk7.bold(updateCmd)} to update`));
+  console.log(dim(`  Run ${chalk8.bold(updateCmd)} to update`));
   console.log();
   if (npx) return;
   try {
@@ -2212,12 +3044,12 @@ async function checkForUpdate(currentVersion) {
       console.log(dim("  Updating..."));
       const ok = await runUpdate();
       if (ok) {
-        console.log(chalk7.green(`  \u2713 Updated to v${latest}`));
+        console.log(chalk8.green(`  \u2713 Updated to v${latest}`));
         console.log(dim("  Restart the CLI to use the new version."));
         process.exit(0);
       } else {
-        console.log(chalk7.yellow(`  Could not auto-update. Run manually:`));
-        console.log(chalk7.bold(`  npm install -g ${PACKAGE_NAME}@latest`));
+        console.log(chalk8.yellow(`  Could not auto-update. Run manually:`));
+        console.log(chalk8.bold(`  npm install -g ${PACKAGE_NAME}@latest`));
         console.log();
       }
     }
@@ -2232,7 +3064,7 @@ async function updateCommand(currentVersion) {
   console.log(dim("  Checking for updates..."));
   const latest = await getLatestVersion();
   if (!latest) {
-    console.log(chalk8.yellow("  Could not reach the npm registry. Check your connection."));
+    console.log(chalk9.yellow("  Could not reach the npm registry. Check your connection."));
     return;
   }
   if (!isNewer(currentVersion, latest)) {
@@ -2244,7 +3076,7 @@ async function updateCommand(currentVersion) {
   if (isNpx()) {
     console.log();
     console.log(dim("  You're running via npx. Use the latest version with:"));
-    console.log(chalk8.bold(`  npx ${PACKAGE_NAME2}@latest`));
+    console.log(chalk9.bold(`  npx ${PACKAGE_NAME2}@latest`));
     console.log();
     return;
   }
@@ -2254,14 +3086,14 @@ async function updateCommand(currentVersion) {
     console.log(success(`  \u2713 Updated to v${latest}`));
     console.log(dim("  Restart the CLI to use the new version."));
   } else {
-    console.log(chalk8.yellow("  Could not auto-update. Run manually:"));
-    console.log(chalk8.bold(`  npm install -g ${PACKAGE_NAME2}@latest`));
+    console.log(chalk9.yellow("  Could not auto-update. Run manually:"));
+    console.log(chalk9.bold(`  npm install -g ${PACKAGE_NAME2}@latest`));
   }
 }
 
 // src/commands/doctor.ts
-import fs11 from "fs";
-import chalk9 from "chalk";
+import fs13 from "fs";
+import chalk10 from "chalk";
 async function doctorCommand(options) {
   if (!options.json) banner();
   const result = {
@@ -2312,7 +3144,7 @@ async function doctorCommand(options) {
   for (const tool of TOOLS) {
     const paths = resolveConfigPaths(tool.configPaths);
     for (const configPath of paths) {
-      if (!fs11.existsSync(configPath)) continue;
+      if (!fs13.existsSync(configPath)) continue;
       const piutConfig = getPiutConfig(configPath, tool.configKey);
       if (!piutConfig) {
         result.tools.push({
@@ -2417,59 +3249,155 @@ async function doctorCommand(options) {
     const staleTools = result.tools.filter((t) => t.keyMatch === "stale" && !t.fixed);
     if (staleTools.length > 0 && !options.fix) {
       console.log();
-      console.log(dim("  Fix stale configs: ") + chalk9.cyan("piut doctor --fix"));
+      console.log(dim("  Fix stale configs: ") + chalk10.cyan("piut doctor --fix"));
     }
     if (!result.key.valid) {
-      console.log(dim("  Set a valid key: ") + chalk9.cyan("piut setup --key pb_YOUR_KEY"));
+      console.log(dim("  Set a valid key: ") + chalk10.cyan("piut setup --key pb_YOUR_KEY"));
     }
   }
   console.log();
   if (result.issues > 0) throw new CliError(`${result.issues} issue(s) found`);
 }
 
+// src/commands/vault.ts
+import fs14 from "fs";
+import path15 from "path";
+import chalk11 from "chalk";
+import { confirm as confirm7 } from "@inquirer/prompts";
+function formatSize2(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function resolveApiKey(options) {
+  const key = options.key || readStore().apiKey;
+  if (!key) {
+    console.log(warning("  No API key found."));
+    console.log(dim("  Run ") + brand("piut login") + dim(" first, or pass --key."));
+    throw new CliError();
+  }
+  return key;
+}
+async function vaultListCommand(options) {
+  const key = resolveApiKey(options);
+  const data = await listVaultFiles(key);
+  if (data.files.length === 0) {
+    console.log(dim("  No files in vault."));
+    console.log(dim("  Upload with: ") + brand("piut vault upload <file>"));
+    console.log();
+    return;
+  }
+  console.log();
+  for (const file of data.files) {
+    const size = dim(`(${formatSize2(file.sizeBytes)})`);
+    console.log(`  ${file.filename}  ${size}`);
+    if (file.summary) {
+      console.log(dim(`    ${file.summary}`));
+    }
+  }
+  console.log();
+  console.log(dim(`  ${data.usage.fileCount} file(s), ${formatSize2(data.usage.totalBytes)} / ${formatSize2(data.usage.maxBytes)} used`));
+  console.log();
+}
+async function vaultUploadCommand(filePath, options) {
+  const key = resolveApiKey(options);
+  const resolved = path15.resolve(filePath);
+  if (!fs14.existsSync(resolved)) {
+    console.log(chalk11.red(`  File not found: ${filePath}`));
+    throw new CliError();
+  }
+  const stat = fs14.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 spinner = new Spinner();
+  spinner.start(`Uploading ${filename}...`);
+  try {
+    const result = await uploadVaultFile(key, filename, content);
+    spinner.stop();
+    console.log(success(`  Uploaded ${result.filename}`) + dim(` (${formatSize2(result.sizeBytes)})`));
+    if (result.summary) {
+      console.log(dim(`  ${result.summary}`));
+    }
+    console.log();
+  } catch (err) {
+    spinner.stop();
+    console.log(chalk11.red(`  ${err.message}`));
+    throw new CliError();
+  }
+}
+async function vaultReadCommand(filename, options) {
+  const key = resolveApiKey(options);
+  try {
+    const file = await readVaultFile(key, filename);
+    if (options.output) {
+      const outPath = path15.resolve(options.output);
+      fs14.writeFileSync(outPath, file.content, "utf-8");
+      console.log(success(`  Saved to ${outPath}`));
+      console.log();
+    } else {
+      console.log();
+      console.log(file.content);
+    }
+  } catch (err) {
+    console.log(chalk11.red(`  ${err.message}`));
+    throw new CliError();
+  }
+}
+async function vaultDeleteCommand(filename, options) {
+  const key = resolveApiKey(options);
+  if (!options.yes) {
+    const confirmed = await confirm7({
+      message: `Delete "${filename}" from vault? This cannot be undone.`,
+      default: false
+    });
+    if (!confirmed) return;
+  }
+  try {
+    await deleteVaultFile(key, filename);
+    console.log(success(`  Deleted ${filename}`));
+    console.log();
+  } catch (err) {
+    console.log(chalk11.red(`  ${err.message}`));
+    throw new CliError();
+  }
+}
+
 // src/commands/interactive.ts
-import { select as select2, confirm as confirm7, checkbox as checkbox6, password as password3 } from "@inquirer/prompts";
-import fs12 from "fs";
-import path12 from "path";
-import chalk10 from "chalk";
+import { select as select3, confirm as confirm8, checkbox as checkbox6, Separator } from "@inquirer/prompts";
+import fs15 from "fs";
+import path16 from "path";
+import { exec as exec2 } from "child_process";
+import chalk12 from "chalk";
 async function authenticate() {
   const config = readStore();
-  let apiKey = config.apiKey;
+  const apiKey = config.apiKey;
   if (apiKey) {
     try {
-      const result2 = await validateKey(apiKey);
-      console.log(success(`  Connected as ${result2.displayName}`));
-      return { apiKey, validation: result2 };
+      const result = await validateKey(apiKey);
+      console.log(success(`  Connected as ${result.displayName}`));
+      return { apiKey, validation: result };
     } catch {
       console.log(dim("  Saved key expired. Please re-authenticate."));
-      apiKey = void 0;
     }
   }
-  console.log(dim("  Connect to p\u0131ut:"));
-  console.log(dim("    > Log in at piut.com"));
-  console.log(dim("    > Enter p\u0131ut API key"));
-  console.log();
-  apiKey = await password3({
-    message: "Enter your p\u0131ut API key:",
-    mask: "*",
-    validate: (v) => v.startsWith("pb_") || "Key must start with pb_"
-  });
-  console.log(dim("  Validating key..."));
-  let result;
-  try {
-    result = await validateKey(apiKey);
-  } catch (err) {
-    console.log(chalk10.red(`  \u2717 ${err.message}`));
-    console.log(dim("  Get a key at https://piut.com/dashboard/keys"));
-    process.exit(1);
-  }
-  console.log(success(`  \u2713 Connected as ${result.displayName}`));
-  updateStore({ apiKey });
-  return { apiKey, validation: result };
+  const { apiKey: newKey, validation } = await promptLogin();
+  const label = validation.slug ? `${validation.displayName} (${validation.slug})` : validation.displayName;
+  console.log(success(`  \u2713 Connected as ${label}`));
+  updateStore({ apiKey: newKey });
+  return { apiKey: newKey, validation };
 }
 function isPromptCancellation(err) {
   return !!(err && typeof err === "object" && "name" in err && err.name === "ExitPromptError");
 }
+function openInBrowser(url) {
+  const platform = process.platform;
+  const cmd = platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
+  exec2(`${cmd} ${url}`);
+}
 async function interactiveMenu() {
   banner();
   let apiKey;
@@ -2482,7 +3410,7 @@ async function interactiveMenu() {
     console.log(warning("  You haven\u2019t built a brain yet."));
     console.log(dim("  Your brain is how AI tools learn about you \u2014 your projects, preferences, and context."));
     console.log();
-    const wantBuild = await confirm7({
+    const wantBuild = await confirm8({
       message: "Build your brain now?",
       default: true
     });
@@ -2498,7 +3426,7 @@ async function interactiveMenu() {
     console.log(warning("  Your brain is built but not deployed yet."));
     console.log(dim("  Deploy it to make your MCP server live so AI tools can read your brain."));
     console.log();
-    const wantDeploy = await confirm7({
+    const wantDeploy = await confirm8({
       message: "Deploy your brain now?",
       default: true
     });
@@ -2515,49 +3443,58 @@ async function interactiveMenu() {
     const isDeployed = currentValidation.status === "active";
     let action;
     try {
-      action = await select2({
+      action = await select3({
         message: "What would you like to do?",
+        loop: false,
         choices: [
           {
-            name: hasBrain ? "Rebuild Brain" : "Build Brain",
+            name: "My Brain",
+            value: "view-brain",
+            description: "View all 5 brain sections",
+            disabled: !hasBrain && "(build brain first)"
+          },
+          {
+            name: "Build Brain",
             value: "build",
             description: hasBrain ? "Rebuild your brain from your files" : "Build your brain from your files"
           },
+          {
+            name: "Edit Brain",
+            value: "edit-brain",
+            description: "Open piut.com to edit your brain",
+            disabled: !hasBrain && "(build brain first)"
+          },
+          new Separator(),
           {
             name: isDeployed ? "Undeploy Brain" : "Deploy Brain",
             value: "deploy",
             description: isDeployed ? "Take your MCP server offline" : "Publish your MCP server (requires paid account)"
           },
+          new Separator(),
           {
             name: "Connect Tools",
             value: "connect-tools",
-            description: "Configure AI tools to use your MCP server",
-            disabled: !isDeployed && "(deploy brain first)"
-          },
-          {
-            name: "Disconnect Tools",
-            value: "disconnect-tools",
-            description: "Remove p\u0131ut from AI tool configs",
+            description: "Manage which AI tools use your MCP server",
             disabled: !isDeployed && "(deploy brain first)"
           },
           {
             name: "Connect Projects",
             value: "connect-projects",
-            description: "Add brain references to project config files",
+            description: "Manage brain references in project config files",
             disabled: !isDeployed && "(deploy brain first)"
           },
+          new Separator(),
           {
-            name: "Disconnect Projects",
-            value: "disconnect-projects",
-            description: "Remove brain references from project configs",
-            disabled: !isDeployed && "(deploy brain first)"
+            name: "View Files",
+            value: "vault-view",
+            description: "List and manage files in your vault"
           },
           {
-            name: "View Brain",
-            value: "view-brain",
-            description: "View all 5 brain sections",
-            disabled: !hasBrain && "(build brain first)"
+            name: "Upload Files",
+            value: "vault-upload",
+            description: "Upload a file to your vault"
           },
+          new Separator(),
           {
             name: "Status",
             value: "status",
@@ -2581,9 +3518,15 @@ async function interactiveMenu() {
     if (action === "exit") return;
     try {
       switch (action) {
+        case "view-brain":
+          await handleViewBrain(apiKey);
+          break;
         case "build":
           await buildCommand({ key: apiKey });
           break;
+        case "edit-brain":
+          handleEditBrain();
+          break;
         case "deploy":
           if (isDeployed) {
             await handleUndeploy(apiKey);
@@ -2594,17 +3537,14 @@ async function interactiveMenu() {
         case "connect-tools":
           await handleConnectTools(apiKey, currentValidation);
           break;
-        case "disconnect-tools":
-          await handleDisconnectTools();
-          break;
         case "connect-projects":
-          await connectCommand({ key: apiKey });
+          await handleManageProjects(apiKey, currentValidation);
           break;
-        case "disconnect-projects":
-          await disconnectCommand({});
+        case "vault-view":
+          await handleVaultView(apiKey);
           break;
-        case "view-brain":
-          await handleViewBrain(apiKey);
+        case "vault-upload":
+          await handleVaultUpload(apiKey);
           break;
         case "status":
           statusCommand();
@@ -2627,7 +3567,7 @@ async function interactiveMenu() {
       } else if (err instanceof CliError) {
         console.log();
       } else {
-        console.log(chalk10.red(`  Error: ${err.message}`));
+        console.log(chalk12.red(`  Error: ${err.message}`));
         console.log();
       }
     }
@@ -2638,7 +3578,7 @@ async function interactiveMenu() {
   }
 }
 async function handleUndeploy(apiKey) {
-  const confirmed = await confirm7({
+  const confirmed = await confirm8({
     message: "Undeploy your brain? AI tools will lose access to your MCP server.",
     default: false
   });
@@ -2650,115 +3590,297 @@ async function handleUndeploy(apiKey) {
     console.log(dim("  Run ") + brand("piut deploy") + dim(" to re-deploy anytime."));
     console.log();
   } catch (err) {
-    console.log(chalk10.red(`  \u2717 ${err.message}`));
+    console.log(chalk12.red(`  \u2717 ${err.message}`));
   }
 }
 async function handleConnectTools(apiKey, validation) {
   const { slug } = validation;
-  const unconfigured = [];
-  const alreadyConnected = [];
+  const detected = [];
   for (const tool of TOOLS) {
     const paths = resolveConfigPaths(tool.configPaths);
     for (const configPath of paths) {
-      const exists = fs12.existsSync(configPath);
-      const parentExists = fs12.existsSync(path12.dirname(configPath));
+      const exists = fs15.existsSync(configPath);
+      const parentExists = fs15.existsSync(path16.dirname(configPath));
       if (exists || parentExists) {
-        if (exists && isPiutConfigured(configPath, tool.configKey)) {
-          alreadyConnected.push(tool.name);
-        } else {
-          unconfigured.push({ tool, configPath });
-        }
+        const connected = exists && !!tool.configKey && isPiutConfigured(configPath, tool.configKey);
+        detected.push({ tool, configPath, connected });
         break;
       }
     }
   }
-  if (unconfigured.length === 0) {
-    if (alreadyConnected.length > 0) {
-      console.log(dim("  All detected tools are already connected."));
-    } else {
-      console.log(warning("  No supported AI tools detected."));
-      console.log(dim("  Supported: Claude Code, Claude Desktop, Cursor, Windsurf, GitHub Copilot, Amazon Q, Zed"));
-    }
+  if (detected.length === 0) {
+    console.log(warning("  No supported AI tools detected."));
     console.log();
     return;
   }
-  if (alreadyConnected.length > 0) {
-    console.log(dim(`  Already connected: ${alreadyConnected.join(", ")}`));
+  const mcpTools = detected.filter((d) => !d.tool.skillOnly);
+  const skillOnlyTools = detected.filter((d) => d.tool.skillOnly);
+  const connectedCount = mcpTools.filter((d) => d.connected).length;
+  const availableCount = mcpTools.length - connectedCount;
+  if (connectedCount > 0 || availableCount > 0) {
+    const parts = [];
+    if (connectedCount > 0) parts.push(`${connectedCount} connected`);
+    if (availableCount > 0) parts.push(`${availableCount} available`);
+    if (skillOnlyTools.length > 0) parts.push(`${skillOnlyTools.length} skill-only`);
+    console.log(dim(`  ${parts.join(", ")}`));
+  }
+  console.log();
+  if (mcpTools.length === 0) {
+    console.log(dim("  Detected tools are skill-only (no MCP config to manage)."));
+    if (skillOnlyTools.length > 0) {
+      console.log(dim(`  Skill-only: ${skillOnlyTools.map((d) => d.tool.name).join(", ")}`));
+    }
+    console.log(dim('  Use "Connect Projects" to add skill files to your projects.'));
     console.log();
+    return;
   }
-  const choices = unconfigured.map((u) => ({
-    name: u.tool.name,
-    value: u,
-    checked: true
+  const choices = mcpTools.map((d) => ({
+    name: `${d.tool.name}${d.connected ? dim(" (connected)") : ""}`,
+    value: d,
+    checked: d.connected
   }));
   const selected = await checkbox6({
-    message: "Select tools to connect:",
+    message: "Select tools to keep connected (toggle with space):",
     choices
   });
-  if (selected.length === 0) {
-    console.log(dim("  No tools selected."));
+  const toConnect = selected.filter((s) => !s.connected);
+  const toDisconnect = mcpTools.filter((d) => d.connected && !selected.includes(d));
+  if (toConnect.length === 0 && toDisconnect.length === 0) {
+    console.log(dim("  No changes."));
+    console.log();
     return;
   }
   console.log();
-  for (const { tool, configPath } of selected) {
-    const serverConfig = tool.generateConfig(slug, apiKey);
-    mergeConfig(configPath, tool.configKey, serverConfig);
-    toolLine(tool.name, success("connected"), "\u2714");
+  for (const { tool, configPath } of toConnect) {
+    if (tool.generateConfig && tool.configKey) {
+      const serverConfig = tool.generateConfig(slug, apiKey);
+      mergeConfig(configPath, tool.configKey, 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);
+    if (removed) {
+      removedNames.push(tool.name);
+      toolLine(tool.name, warning("disconnected"), "\u2714");
+    }
   }
-  if (validation.serverUrl) {
+  if (skillOnlyTools.length > 0) {
+    console.log(dim(`  Skill-only (use "Connect Projects"): ${skillOnlyTools.map((d) => d.tool.name).join(", ")}`));
+  }
+  if (toConnect.length > 0 && validation.serverUrl) {
     await Promise.all(
-      selected.map(({ tool }) => pingMcp(validation.serverUrl, apiKey, tool.name))
+      toConnect.map(({ tool }) => pingMcp(validation.serverUrl, apiKey, tool.name))
     );
   }
+  if (removedNames.length > 0) {
+    deleteConnections(apiKey, removedNames).catch(() => {
+    });
+  }
   console.log();
   console.log(dim("  Restart your AI tools for changes to take effect."));
   console.log();
 }
-async function handleDisconnectTools() {
-  const configured = [];
-  for (const tool of TOOLS) {
-    const paths = resolveConfigPaths(tool.configPaths);
-    for (const configPath of paths) {
-      if (fs12.existsSync(configPath) && isPiutConfigured(configPath, tool.configKey)) {
-        configured.push({ tool, configPath });
-        break;
-      }
-    }
-  }
-  if (configured.length === 0) {
-    console.log(dim("  p\u0131ut is not configured in any detected AI tools."));
+async function handleManageProjects(apiKey, validation) {
+  const { slug, serverUrl } = validation;
+  console.log(dim("  Scanning for projects..."));
+  const projects = scanForProjects();
+  if (projects.length === 0) {
+    console.log(warning("  No projects found."));
+    console.log(dim("  Try running from a directory with your projects."));
     console.log();
     return;
   }
-  const choices = configured.map((c) => ({
-    name: c.tool.name,
-    value: c
+  const items = projects.map((p) => ({
+    project: p,
+    connected: hasPiutDir(p.path)
+  }));
+  const connectedCount = items.filter((i) => i.connected).length;
+  const availableCount = items.length - connectedCount;
+  const parts = [];
+  if (connectedCount > 0) parts.push(`${connectedCount} connected`);
+  if (availableCount > 0) parts.push(`${availableCount} available`);
+  console.log(dim(`  ${parts.join(", ")}`));
+  console.log();
+  const choices = items.map((i) => ({
+    name: `${i.project.name}${i.connected ? dim(" (connected)") : ""}`,
+    value: i,
+    checked: i.connected
   }));
   const selected = await checkbox6({
-    message: "Select tools to disconnect:",
+    message: "Select projects to keep connected (toggle with space):",
     choices
   });
-  if (selected.length === 0) {
-    console.log(dim("  No tools selected."));
+  const toConnect = selected.filter((s) => !s.connected);
+  const toDisconnect = items.filter((i) => i.connected && !selected.includes(i));
+  if (toConnect.length === 0 && toDisconnect.length === 0) {
+    console.log(dim("  No changes."));
+    console.log();
     return;
   }
-  const proceed = await confirm7({
-    message: `Disconnect p\u0131ut from ${selected.length} tool(s)?`,
-    default: false
-  });
-  if (!proceed) return;
   console.log();
-  for (const { tool, configPath } of selected) {
-    const removed = removeFromConfig(configPath, tool.configKey);
-    if (removed) {
-      toolLine(tool.name, success("disconnected"), "\u2714");
-    } else {
-      toolLine(tool.name, warning("not found"), "\xD7");
+  const copilotTool = TOOLS.find((t) => t.id === "copilot");
+  for (const { project } of toConnect) {
+    const projectName = path16.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"));
+      if (hasCopilot) {
+        const vscodeMcpPath = path16.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 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");
+      } else {
+        fs15.appendFileSync(absPath, APPEND_SECTION);
+      }
+    }
+    toolLine(projectName, success("connected"), "\u2714");
+    const machineId = getMachineId();
+    const toolsDetected = RULE_FILES.filter((r) => r.detect(project)).map((r) => r.tool);
+    registerProject(apiKey, {
+      projectName,
+      projectPath: project.path,
+      machineId,
+      toolsDetected,
+      configFiles: RULE_FILES.filter((r) => r.detect(project)).map((r) => r.filePath)
+    }).catch(() => {
+    });
+  }
+  for (const { project } of toDisconnect) {
+    const projectName = path16.basename(project.path);
+    for (const dedicatedFile of DEDICATED_FILES) {
+      const absPath = path16.join(project.path, dedicatedFile);
+      if (fs15.existsSync(absPath) && hasPiutReference2(absPath)) {
+        try {
+          fs15.unlinkSync(absPath);
+        } catch {
+        }
+      }
+    }
+    for (const appendFile of APPEND_FILES) {
+      const absPath = path16.join(project.path, appendFile);
+      if (fs15.existsSync(absPath) && hasPiutReference2(absPath)) {
+        removePiutSection(absPath);
+      }
+    }
+    const vscodeMcpPath = path16.join(project.path, ".vscode", "mcp.json");
+    if (fs15.existsSync(vscodeMcpPath) && isPiutConfigured(vscodeMcpPath, "servers")) {
+      removeFromConfig(vscodeMcpPath, "servers");
+    }
+    removePiutDir(project.path);
+    toolLine(projectName, warning("disconnected"), "\u2714");
+    const machineId = getMachineId();
+    unregisterProject(apiKey, project.path, machineId).catch(() => {
+    });
   }
   console.log();
-  console.log(dim("  Restart your AI tools for changes to take effect."));
+  if (toConnect.length > 0) {
+    console.log(success(`  ${toConnect.length} project(s) connected.`));
+  }
+  if (toDisconnect.length > 0) {
+    console.log(success(`  ${toDisconnect.length} project(s) disconnected.`));
+  }
+  console.log();
+}
+function handleEditBrain() {
+  console.log(dim("  Opening piut.com/dashboard..."));
+  openInBrowser("https://piut.com/dashboard");
+  console.log(success("  \u2713 Opened in browser."));
+  console.log();
+}
+function formatSize3(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+async function handleVaultView(apiKey) {
+  const data = await listVaultFiles(apiKey);
+  if (data.files.length === 0) {
+    console.log(dim('  Vault is empty. Use "Upload Files" to add files.'));
+    console.log();
+    return;
+  }
+  console.log();
+  for (const file of data.files) {
+    const size = dim(`(${formatSize3(file.sizeBytes)})`);
+    console.log(`  ${file.filename}  ${size}`);
+    if (file.summary) console.log(dim(`    ${file.summary}`));
+  }
+  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({
+    message: "Actions:",
+    choices: [
+      { name: "Delete a file", value: "delete" },
+      { name: "Back", value: "back" }
+    ]
+  });
+  if (action === "back") return;
+  if (action === "delete") {
+    const fileChoices = data.files.map((f) => ({
+      name: `${f.filename}  ${dim(`(${formatSize3(f.sizeBytes)})`)}`,
+      value: f.filename
+    }));
+    const filename = await select3({
+      message: "Which file to delete?",
+      choices: fileChoices
+    });
+    const confirmed = await confirm8({
+      message: `Delete "${filename}"? This cannot be undone.`,
+      default: false
+    });
+    if (confirmed) {
+      try {
+        await deleteVaultFile(apiKey, filename);
+        console.log(success(`  Deleted ${filename}`));
+        console.log();
+      } catch (err) {
+        console.log(chalk12.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}`));
+    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();
+  }
 }
 async function handleViewBrain(apiKey) {
   console.log(dim("  Loading brain..."));
@@ -2788,7 +3910,7 @@ async function handleViewBrain(apiKey) {
   if (hasUnpublishedChanges) {
     console.log(warning("  You have unpublished changes."));
     console.log();
-    const wantPublish = await confirm7({
+    const wantPublish = await confirm8({
       message: "Publish now?",
       default: true
     });
@@ -2802,11 +3924,11 @@ async function handleViewBrain(apiKey) {
         console.log();
         const msg = err.message;
         if (msg === "REQUIRES_SUBSCRIPTION") {
-          console.log(chalk10.yellow("  Deploy requires an active subscription ($10/mo)."));
+          console.log(chalk12.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(chalk10.red(`  \u2717 ${msg}`));
+          console.log(chalk12.red(`  \u2717 ${msg}`));
         }
         console.log();
       }
@@ -2815,7 +3937,7 @@ async function handleViewBrain(apiKey) {
 }
 
 // src/cli.ts
-var VERSION = "3.5.1";
+var VERSION = "3.7.0";
 function withExit(fn) {
   return async (...args2) => {
     try {
@@ -2838,8 +3960,14 @@ program.command("disconnect").description("Remove brain references from project
 program.command("setup").description("Auto-detect and configure AI tools (MCP config)").option("-k, --key <key>", "API key (prompts interactively if not provided)").option("-t, --tool <id>", "Configure a single tool (claude-code, cursor, windsurf, etc.)").option("-y, --yes", "Skip interactive prompts (auto-select all detected tools)").option("--project", "Prefer project-local config files").option("--skip-skill", "Skip skill.md file placement").action(withExit(setupCommand));
 program.command("status").description("Show brain, deployment, and connected projects").option("--verify", "Validate API key, check tool configs, and test MCP endpoint").action(withExit(statusCommand));
 program.command("remove").description("Remove all p\u0131ut configurations").action(withExit(removeCommand));
+program.command("login").description("Authenticate with p\u0131ut (email, browser, or API key)").action(withExit(loginCommand));
 program.command("logout").description("Remove saved API key").action(logoutCommand);
 program.command("doctor").description("Diagnose and fix connection issues").option("-k, --key <key>", "API key to verify against").option("--fix", "Auto-fix stale configurations").option("--json", "Output results as JSON").action(withExit(doctorCommand));
+var vault = program.command("vault").description("Manage your file vault (upload, list, read, delete)");
+vault.command("list").description("List all files in your vault").option("-k, --key <key>", "API key").action(withExit(vaultListCommand));
+vault.command("upload <file>").description("Upload a file to your vault").option("-k, --key <key>", "API key").action(withExit(vaultUploadCommand));
+vault.command("read <filename>").description("Read a file from your vault").option("-k, --key <key>", "API key").option("-o, --output <path>", "Save to a local file instead of printing").action(withExit(vaultReadCommand));
+vault.command("delete <filename>").description("Delete a file from your vault").option("-k, --key <key>", "API key").option("-y, --yes", "Skip confirmation prompt").action(withExit(vaultDeleteCommand));
 program.command("update").description("Check for and install CLI updates").action(() => updateCommand(VERSION));
 var args = process.argv.slice(2);
 if (args.includes("--version") || args.includes("-V")) {