@piut/cli 3.9.0 → 3.10.0

package/dist/cli.js

@@ -28,9 +28,9 @@ __export(tree_prompt_exports, {
   loadChildren: () => loadChildren,
   shouldShowInTree: () => shouldShowInTree
 });
-import fs14 from "fs";
-import path14 from "path";
-import os8 from "os";
+import fs15 from "fs";
+import path16 from "path";
+import os9 from "os";
 import {
   createPrompt,
   useState,
@@ -50,19 +50,19 @@ function shouldShowInTree(name) {
 }
 function shouldShowFile(name) {
   if (name.startsWith(".")) return false;
-  const ext = path14.extname(name).toLowerCase();
+  const ext = path16.extname(name).toLowerCase();
   return !HIDDEN_FILE_EXTENSIONS.has(ext);
 }
 function loadChildren(parentPath, parentDepth, includeFiles = false) {
   try {
-    const entries = fs14.readdirSync(parentPath, { withFileTypes: true });
+    const entries = fs15.readdirSync(parentPath, { withFileTypes: true });
     const dirs = [];
     const files = [];
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (!shouldShowInTree(entry.name)) continue;
         dirs.push({
-          path: path14.join(parentPath, entry.name),
+          path: path16.join(parentPath, entry.name),
           name: entry.name,
           depth: parentDepth + 1,
           expanded: false,
@@ -72,7 +72,7 @@ function loadChildren(parentPath, parentDepth, includeFiles = false) {
       } else if (includeFiles && entry.isFile()) {
         if (!shouldShowFile(entry.name)) continue;
         files.push({
-          path: path14.join(parentPath, entry.name),
+          path: path16.join(parentPath, entry.name),
           name: entry.name,
           depth: parentDepth + 1,
           expanded: false,
@@ -214,7 +214,7 @@ var init_tree_prompt = __esm({
       ".map"
     ]);
     treePrompt = createPrompt((config, done) => {
-      const root = config.root ?? os8.homedir();
+      const root = config.root ?? os9.homedir();
       const pageSize = config.pageSize ?? 15;
       const mode = config.mode ?? "folders";
       const includeFiles = mode === "files";
@@ -325,9 +325,9 @@ import { Command } from "commander";
 
 // src/commands/setup.ts
 init_esm_shims();
-import fs4 from "fs";
-import path7 from "path";
-import { execSync } from "child_process";
+import fs6 from "fs";
+import path9 from "path";
+import { execSync as execSync2 } from "child_process";
 import { password, confirm, checkbox } from "@inquirer/prompts";
 import chalk2 from "chalk";
 
@@ -641,7 +641,7 @@ var TOOLS = [
       project: [".mcp.json"]
     },
     skillFilePath: "CLAUDE.md",
-    quickCommand: (slug, key) => `claude mcp add-json piut-context '${JSON.stringify({
+    quickCommand: (slug, key) => `claude mcp add-json piut '${JSON.stringify({
       type: "http",
       url: MCP_URL(slug),
       headers: { ...AUTH_HEADER(key), ...machineHeaders("Claude Code") }
@@ -776,7 +776,7 @@ var TOOLS = [
       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}"`,
+    quickCommand: (slug, key) => `npx mcporter config add piut ${MCP_URL(slug)} --header "Authorization=Bearer ${key}"`,
     generateConfig: (slug, key) => ({
       url: MCP_URL(slug),
       headers: { ...AUTH_HEADER(key), ...machineHeaders("OpenClaw") }
@@ -820,6 +820,8 @@ function resolveConfigPaths(tool) {
 init_esm_shims();
 import fs from "fs";
 import path4 from "path";
+var SERVER_KEY = "piut";
+var LEGACY_SERVER_KEY = "piut-context";
 function readConfig(filePath) {
   let raw;
   try {
@@ -867,12 +869,13 @@ function isPiutConfigured(filePath, configKey) {
   const config = readConfig(filePath);
   if (!config) return false;
   const servers = resolveKeyPath(config, configKey);
-  return !!servers?.["piut-context"];
+  return !!(servers?.[SERVER_KEY] || servers?.[LEGACY_SERVER_KEY]);
 }
 function mergeConfig(filePath, configKey, serverConfig) {
   const existing = readConfig(filePath) || {};
   const servers = resolveKeyPath(existing, configKey) || {};
-  servers["piut-context"] = serverConfig;
+  delete servers[LEGACY_SERVER_KEY];
+  servers[SERVER_KEY] = serverConfig;
   setAtKeyPath(existing, configKey, servers);
   writeConfig(filePath, existing);
 }
@@ -880,7 +883,7 @@ function getPiutConfig(filePath, configKey) {
   const config = readConfig(filePath);
   if (!config) return null;
   const servers = resolveKeyPath(config, configKey);
-  const piut = servers?.["piut-context"];
+  const piut = servers?.[SERVER_KEY] || servers?.[LEGACY_SERVER_KEY];
   return piut ?? null;
 }
 function extractKeyFromConfig(piutConfig) {
@@ -932,8 +935,11 @@ function removeFromConfig(filePath, configKey) {
   const config = readConfig(filePath);
   if (!config) return false;
   const servers = resolveKeyPath(config, configKey);
-  if (!servers?.["piut-context"]) return false;
-  delete servers["piut-context"];
+  const hasNew = !!servers?.[SERVER_KEY];
+  const hasLegacy = !!servers?.[LEGACY_SERVER_KEY];
+  if (!hasNew && !hasLegacy) return false;
+  delete servers[SERVER_KEY];
+  delete servers[LEGACY_SERVER_KEY];
   if (Object.keys(servers).length === 0 && !configKey.includes(".")) {
     delete config[configKey];
   }
@@ -945,7 +951,7 @@ function removeFromConfig(filePath, configKey) {
 init_esm_shims();
 import fs2 from "fs";
 import path5 from "path";
-var SKILL_SNIPPET = `## p\u0131ut Context (MCP Server: piut-context)
+var SKILL_SNIPPET = `## p\u0131ut Context (MCP Server: piut)
 
 This project uses p\u0131ut for persistent personal context via MCP (Model Context Protocol).
 p\u0131ut provides MCP tools \u2014 do NOT read local .piut/ files directly. Use the MCP tools.
@@ -965,7 +971,7 @@ p\u0131ut provides MCP tools \u2014 do NOT read local .piut/ files directly. Use
 4. Never read .piut/config.json directly \u2014 always use the MCP tools
 
 Skill reference: https://raw.githubusercontent.com/M-Flat-Inc/piut/main/skill.md`;
-var PROJECT_SKILL_SNIPPET = `## p\u0131ut Context (MCP Server: piut-context)
+var PROJECT_SKILL_SNIPPET = `## p\u0131ut Context (MCP Server: piut)
 
 This project uses p\u0131ut for persistent personal context via MCP (Model Context Protocol).
 p\u0131ut provides MCP tools \u2014 do NOT read local .piut/ files directly. Use the MCP tools.
@@ -1114,6 +1120,42 @@ function hasPiutDir(projectPath) {
   return fs3.existsSync(path6.join(piutDir(projectPath), CONFIG_FILE));
 }
 
+// src/lib/global-install.ts
+init_esm_shims();
+import { execSync } from "child_process";
+import fs5 from "fs";
+import path8 from "path";
+import os5 from "os";
+
+// src/lib/store.ts
+init_esm_shims();
+import fs4 from "fs";
+import path7 from "path";
+import os4 from "os";
+var CONFIG_DIR = path7.join(os4.homedir(), ".piut");
+var CONFIG_FILE2 = path7.join(CONFIG_DIR, "config.json");
+function readStore() {
+  try {
+    const raw = fs4.readFileSync(CONFIG_FILE2, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function updateStore(updates) {
+  const config = readStore();
+  const updated = { ...config, ...updates };
+  fs4.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs4.writeFileSync(CONFIG_FILE2, JSON.stringify(updated, null, 2) + "\n", "utf-8");
+  return updated;
+}
+function clearStore() {
+  try {
+    fs4.unlinkSync(CONFIG_FILE2);
+  } catch {
+  }
+}
+
 // src/lib/ui.ts
 init_esm_shims();
 import chalk from "chalk";
@@ -1200,6 +1242,65 @@ var Spinner = class {
   }
 };
 
+// src/lib/global-install.ts
+function isPiutInPath() {
+  try {
+    execSync(process.platform === "win32" ? "where piut" : "which piut", { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getShellProfile() {
+  const shell = process.env.SHELL || "";
+  const home2 = os5.homedir();
+  if (shell.includes("zsh")) {
+    return path8.join(home2, ".zshrc");
+  }
+  if (shell.includes("bash")) {
+    const profile = path8.join(home2, ".bash_profile");
+    if (process.platform === "darwin" && fs5.existsSync(profile)) {
+      return profile;
+    }
+    return path8.join(home2, ".bashrc");
+  }
+  return null;
+}
+function addShellAlias(profilePath) {
+  try {
+    const content = fs5.existsSync(profilePath) ? fs5.readFileSync(profilePath, "utf-8") : "";
+    if (content.includes("alias piut=") || content.includes("piut()")) {
+      return true;
+    }
+    const alias = '\n# p\u0131ut CLI shortcut\nalias piut="npx @piut/cli"\n';
+    fs5.appendFileSync(profilePath, alias);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function offerGlobalInstall() {
+  if (isPiutInPath()) return;
+  const store = readStore();
+  if (store.globalInstallOffered) return;
+  updateStore({ globalInstallOffered: true });
+  try {
+    execSync("npm install -g @piut/cli", { stdio: "pipe", timeout: 3e4 });
+    if (isPiutInPath()) {
+      console.log(dim("  Installed `piut` command for quick access"));
+      return;
+    }
+  } catch {
+  }
+  const profile = getShellProfile();
+  if (profile) {
+    if (addShellAlias(profile)) {
+      console.log(dim(`  Added \`piut\` shortcut to ${path8.basename(profile)}`));
+      return;
+    }
+  }
+}
+
 // src/types.ts
 init_esm_shims();
 var CliError = class extends Error {
@@ -1255,8 +1356,8 @@ async function setupCommand(options) {
     if (tool.skillOnly) continue;
     const paths = resolveConfigPaths(tool);
     for (const { filePath, configKey } of paths) {
-      const exists = fs4.existsSync(filePath);
-      const parentExists = fs4.existsSync(path7.dirname(filePath));
+      const exists = fs6.existsSync(filePath);
+      const parentExists = fs6.existsSync(path9.dirname(filePath));
       if (exists || parentExists) {
         const configured2 = exists && !!configKey && isPiutConfigured(filePath, configKey);
         let staleKey = false;
@@ -1336,7 +1437,7 @@ async function setupCommand(options) {
     if (tool.id === "claude-code" && tool.quickCommand && isCommandAvailable("claude")) {
       let quickSuccess = false;
       try {
-        execSync(tool.quickCommand(slug, apiKey), { stdio: "pipe" });
+        execSync2(tool.quickCommand(slug, apiKey), { stdio: "pipe" });
         const claudeJson = expandPath("~/.claude.json");
         const written = tool.configKey ? getPiutConfig(claudeJson, tool.configKey) : null;
         if (written) {
@@ -1346,7 +1447,7 @@ async function setupCommand(options) {
           continue;
         }
         try {
-          execSync(tool.quickCommand(slug, apiKey) + " --scope user", { stdio: "pipe" });
+          execSync2(tool.quickCommand(slug, apiKey) + " --scope user", { stdio: "pipe" });
           const retryCheck = tool.configKey ? getPiutConfig(claudeJson, tool.configKey) : null;
           if (retryCheck) {
             quickSuccess = true;
@@ -1396,7 +1497,7 @@ async function setupCommand(options) {
   }
   if (configured.length > 0) {
     const cwd = process.cwd();
-    const isProject2 = fs4.existsSync(path7.join(cwd, ".git")) || fs4.existsSync(path7.join(cwd, "package.json"));
+    const isProject2 = fs6.existsSync(path9.join(cwd, ".git")) || fs6.existsSync(path9.join(cwd, "package.json"));
     if (isProject2) {
       const { serverUrl } = validationResult;
       writePiutConfig(cwd, { slug, apiKey, serverUrl });
@@ -1438,6 +1539,7 @@ async function setupCommand(options) {
   if (skipped.length > 0) {
     console.log(dim(`  Skipped: ${skipped.join(", ")}`));
   }
+  await offerGlobalInstall();
   console.log();
   console.log(dim("  Restart your AI tools for changes to take effect."));
   console.log(dim('  Verify: ask any AI "What do you know about me from my context?"'));
@@ -1446,7 +1548,7 @@ async function setupCommand(options) {
 }
 function isCommandAvailable(cmd) {
   try {
-    execSync(process.platform === "win32" ? `where ${cmd}` : `which ${cmd}`, { stdio: "pipe" });
+    execSync2(process.platform === "win32" ? `where ${cmd}` : `which ${cmd}`, { stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -1455,16 +1557,16 @@ function isCommandAvailable(cmd) {
 
 // src/commands/status.ts
 init_esm_shims();
-import fs7 from "fs";
-import os6 from "os";
-import path10 from "path";
+import fs8 from "fs";
+import os7 from "os";
+import path11 from "path";
 import chalk3 from "chalk";
 
 // src/lib/brain-scanner.ts
 init_esm_shims();
-import fs5 from "fs";
-import path8 from "path";
-import os4 from "os";
+import fs7 from "fs";
+import path10 from "path";
+import os6 from "os";
 
 // src/lib/file-types.ts
 init_esm_shims();
@@ -1483,7 +1585,7 @@ var AI_CONFIG_FILENAMES = /* @__PURE__ */ new Set([
 ]);
 
 // src/lib/brain-scanner.ts
-var home = os4.homedir();
+var home = os6.homedir();
 var SKIP_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -1547,22 +1649,22 @@ var INCLUDE_DOT_DIRS = /* @__PURE__ */ new Set([
 function getDefaultScanDirs() {
   const dirs = [];
   try {
-    const entries = fs5.readdirSync(home, { withFileTypes: true });
+    const entries = fs7.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(path8.join(home, entry.name));
+      dirs.push(path10.join(home, entry.name));
     }
   } catch {
   }
-  const cloudStorage = path8.join(home, "Library", "CloudStorage");
+  const cloudStorage = path10.join(home, "Library", "CloudStorage");
   try {
-    if (fs5.existsSync(cloudStorage) && fs5.statSync(cloudStorage).isDirectory()) {
-      const entries = fs5.readdirSync(cloudStorage, { withFileTypes: true });
+    if (fs7.existsSync(cloudStorage) && fs7.statSync(cloudStorage).isDirectory()) {
+      const entries = fs7.readdirSync(cloudStorage, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
-        const fullPath = path8.join(cloudStorage, entry.name);
+        const fullPath = path10.join(cloudStorage, entry.name);
         if (!dirs.includes(fullPath)) {
           dirs.push(fullPath);
         }
@@ -1574,22 +1676,22 @@ function getDefaultScanDirs() {
   return dirs;
 }
 function isProject(dirPath) {
-  return fs5.existsSync(path8.join(dirPath, ".git")) || fs5.existsSync(path8.join(dirPath, "package.json")) || fs5.existsSync(path8.join(dirPath, "Cargo.toml")) || fs5.existsSync(path8.join(dirPath, "pyproject.toml")) || fs5.existsSync(path8.join(dirPath, "go.mod"));
+  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(path8.join(projectPath, "package.json"));
+  const hasPkgJson = fs7.existsSync(path10.join(projectPath, "package.json"));
   let description = "";
   if (hasPkgJson) {
     try {
-      const pkg = JSON.parse(fs5.readFileSync(path8.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 = path8.join(projectPath, "README.md");
-  if (!description && fs5.existsSync(readmePath)) {
+  const readmePath = path10.join(projectPath, "README.md");
+  if (!description && fs7.existsSync(readmePath)) {
     try {
-      const content = fs5.readFileSync(readmePath, "utf-8");
+      const content = fs7.readFileSync(readmePath, "utf-8");
       const lines = content.split("\n");
       let foundHeading = false;
       for (const line of lines) {
@@ -1606,15 +1708,15 @@ function buildProjectInfo(projectPath) {
     }
   }
   return {
-    name: path8.basename(projectPath),
+    name: path10.basename(projectPath),
     path: projectPath,
     description,
-    hasClaudeMd: fs5.existsSync(path8.join(projectPath, "CLAUDE.md")) || fs5.existsSync(path8.join(projectPath, ".claude", "rules")),
-    hasCursorRules: fs5.existsSync(path8.join(projectPath, ".cursorrules")) || fs5.existsSync(path8.join(projectPath, ".cursor", "rules")),
-    hasWindsurfRules: fs5.existsSync(path8.join(projectPath, ".windsurfrules")) || fs5.existsSync(path8.join(projectPath, ".windsurf", "rules")),
-    hasCopilotInstructions: fs5.existsSync(path8.join(projectPath, ".github", "copilot-instructions.md")) || fs5.existsSync(path8.join(projectPath, ".github", "instructions")),
-    hasConventionsMd: fs5.existsSync(path8.join(projectPath, "CONVENTIONS.md")) || fs5.existsSync(path8.join(projectPath, ".amazonq", "rules")),
-    hasZedRules: fs5.existsSync(path8.join(projectPath, ".rules"))
+    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;
@@ -1624,11 +1726,11 @@ 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 = path8.join(dir, item.name);
+        const fullPath = path10.join(dir, item.name);
         if (seen.has(fullPath)) continue;
         seen.add(fullPath);
         if (isProject(fullPath)) {
@@ -1652,20 +1754,20 @@ var MAX_BRAIN_INPUT_BYTES = 1e6;
 function collectGlobalConfigFiles(onProgress) {
   const configs = [];
   const globalPaths = [
-    path8.join(home, ".claude", "MEMORY.md"),
-    path8.join(home, ".claude", "CLAUDE.md"),
-    path8.join(home, ".openclaw", "workspace", "SOUL.md"),
-    path8.join(home, ".openclaw", "workspace", "MEMORY.md"),
-    path8.join(home, ".gemini", "MEMORY.md"),
-    path8.join(home, ".paperclip", "IDENTITY.md")
+    path10.join(home, ".claude", "MEMORY.md"),
+    path10.join(home, ".claude", "CLAUDE.md"),
+    path10.join(home, ".openclaw", "workspace", "SOUL.md"),
+    path10.join(home, ".openclaw", "workspace", "MEMORY.md"),
+    path10.join(home, ".gemini", "MEMORY.md"),
+    path10.join(home, ".paperclip", "IDENTITY.md")
   ];
   for (const gp of globalPaths) {
     try {
-      const stat = fs5.statSync(gp);
+      const stat = fs7.statSync(gp);
       if (!stat.isFile() || stat.size > MAX_CONFIG_SIZE) continue;
-      const content = fs5.readFileSync(gp, "utf-8");
+      const content = fs7.readFileSync(gp, "utf-8");
       if (content.trim()) {
-        const name = path8.relative(home, gp);
+        const name = path10.relative(home, gp);
         configs.push({ name, content });
         onProgress?.({ phase: "configs", message: name });
       }
@@ -1678,11 +1780,11 @@ function collectProjectConfigFiles(projects, onProgress) {
   const configs = [];
   for (const project of projects) {
     for (const fileName of AI_CONFIG_FILENAMES) {
-      const filePath = path8.join(project.path, fileName);
+      const filePath = path10.join(project.path, fileName);
       try {
-        const stat = fs5.statSync(filePath);
+        const stat = fs7.statSync(filePath);
         if (!stat.isFile() || stat.size > MAX_CONFIG_SIZE) continue;
-        const content = fs5.readFileSync(filePath, "utf-8");
+        const content = fs7.readFileSync(filePath, "utf-8");
         if (content.trim()) {
           const name = `${project.name}/${fileName}`;
           configs.push({ name, content });
@@ -1691,11 +1793,11 @@ function collectProjectConfigFiles(projects, onProgress) {
       } catch {
       }
     }
-    const pkgPath = path8.join(project.path, "package.json");
+    const pkgPath = path10.join(project.path, "package.json");
     try {
-      const stat = fs5.statSync(pkgPath);
+      const stat = fs7.statSync(pkgPath);
       if (stat.isFile() && stat.size <= MAX_CONFIG_SIZE) {
-        const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
+        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` });
@@ -1715,35 +1817,6 @@ function formatSize(bytes) {
   return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
 }
 
-// src/lib/store.ts
-init_esm_shims();
-import fs6 from "fs";
-import path9 from "path";
-import os5 from "os";
-var CONFIG_DIR = path9.join(os5.homedir(), ".piut");
-var CONFIG_FILE2 = path9.join(CONFIG_DIR, "config.json");
-function readStore() {
-  try {
-    const raw = fs6.readFileSync(CONFIG_FILE2, "utf-8");
-    return JSON.parse(raw);
-  } catch {
-    return {};
-  }
-}
-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");
-  return updated;
-}
-function clearStore() {
-  try {
-    fs6.unlinkSync(CONFIG_FILE2);
-  } catch {
-  }
-}
-
 // src/commands/status.ts
 var API_BASE3 = process.env.PIUT_API_BASE || "https://piut.com";
 var PIUT_FILES = [
@@ -1756,7 +1829,7 @@ var PIUT_FILES = [
 ];
 function hasPiutReference(filePath) {
   try {
-    const content = fs7.readFileSync(filePath, "utf-8");
+    const content = fs8.readFileSync(filePath, "utf-8");
     return content.includes("p\u0131ut Context") || content.includes("piut Context");
   } catch {
     return false;
@@ -1808,7 +1881,7 @@ async function statusCommand(options = {}) {
     await verifyStatus();
     return;
   }
-  const thisHostname = os6.hostname();
+  const thisHostname = os7.hostname();
   const thisMachineId = getMachineId2();
   console.log(`  AI tools on this machine ${dim(`(${thisHostname})`)}:`);
   console.log();
@@ -1816,7 +1889,7 @@ async function statusCommand(options = {}) {
   for (const tool of TOOLS) {
     const paths = resolveConfigPaths(tool);
     for (const { filePath, configKey } of paths) {
-      if (!fs7.existsSync(filePath)) continue;
+      if (!fs8.existsSync(filePath)) continue;
       foundAny = true;
       const configured = isPiutConfigured(filePath, configKey);
       if (configured) {
@@ -1839,8 +1912,8 @@ async function statusCommand(options = {}) {
   for (const project of projects) {
     const connectedFiles = [];
     for (const file of PIUT_FILES) {
-      const absPath = path10.join(project.path, file);
-      if (fs7.existsSync(absPath) && hasPiutReference(absPath)) {
+      const absPath = path11.join(project.path, file);
+      if (fs8.existsSync(absPath) && hasPiutReference(absPath)) {
         connectedFiles.push(file);
       }
     }
@@ -1913,7 +1986,7 @@ async function verifyStatus() {
   for (const tool of TOOLS) {
     const paths = resolveConfigPaths(tool);
     for (const { filePath, configKey } of paths) {
-      if (!fs7.existsSync(filePath)) continue;
+      if (!fs8.existsSync(filePath)) continue;
       const piutConfig = getPiutConfig(filePath, configKey);
       if (!piutConfig) {
         toolLine(tool.name, dim("installed, not connected"), "\u25CB");
@@ -1957,7 +2030,7 @@ async function verifyStatus() {
 
 // src/commands/remove.ts
 init_esm_shims();
-import fs8 from "fs";
+import fs9 from "fs";
 import { checkbox as checkbox2, confirm as confirm2 } from "@inquirer/prompts";
 async function removeCommand() {
   banner();
@@ -1966,7 +2039,7 @@ async function removeCommand() {
     if (!tool.configKey) continue;
     const paths = resolveConfigPaths(tool);
     for (const { filePath, configKey } of paths) {
-      if (fs8.existsSync(filePath) && isPiutConfigured(filePath, configKey)) {
+      if (fs9.existsSync(filePath) && isPiutConfigured(filePath, configKey)) {
         configured.push({ tool, configPath: filePath, resolvedConfigKey: configKey });
         break;
       }
@@ -2020,7 +2093,7 @@ async function removeCommand() {
 init_esm_shims();
 import { confirm as confirm3 } from "@inquirer/prompts";
 import chalk5 from "chalk";
-import os7 from "os";
+import os8 from "os";
 
 // src/lib/auth.ts
 init_esm_shims();
@@ -2224,10 +2297,95 @@ async function resolveApiKeyWithResult(keyOption) {
   }
 }
 
+// src/lib/sync.ts
+init_esm_shims();
+import fs10 from "fs";
+import path12 from "path";
+function syncStaleConfigs(slug, apiKey, serverUrl) {
+  const updated = [];
+  for (const tool of TOOLS) {
+    if (tool.skillOnly || !tool.generateConfig || !tool.configKey) continue;
+    const paths = resolveConfigPaths(tool);
+    for (const { filePath, configKey } of paths) {
+      if (!fs10.existsSync(filePath)) continue;
+      const piutConfig = getPiutConfig(filePath, configKey);
+      if (!piutConfig) continue;
+      const existingKey = extractKeyFromConfig(piutConfig);
+      const existingSlug = extractSlugFromConfig(piutConfig);
+      const keyStale = !!existingKey && existingKey !== apiKey;
+      const slugStale = !!existingSlug && existingSlug !== slug;
+      if (keyStale || slugStale) {
+        const newConfig = tool.generateConfig(slug, apiKey);
+        mergeConfig(filePath, configKey, newConfig);
+        updated.push(tool.name);
+      }
+      break;
+    }
+  }
+  const cwd = process.cwd();
+  const existing = readPiutConfig(cwd);
+  if (existing && (existing.apiKey !== apiKey || existing.slug !== slug)) {
+    writePiutConfig(cwd, { slug, apiKey, serverUrl });
+    updated.push(".piut/config.json");
+  }
+  return updated;
+}
+function getConfiguredToolNames() {
+  const names = [];
+  for (const tool of TOOLS) {
+    if (tool.skillOnly || !tool.configKey) continue;
+    const paths = resolveConfigPaths(tool);
+    for (const { filePath, configKey } of paths) {
+      if (!fs10.existsSync(filePath)) continue;
+      if (getPiutConfig(filePath, configKey)) {
+        names.push(tool.name);
+        break;
+      }
+    }
+  }
+  return names;
+}
+async function cycleConfigEntry(filePath, configKey, freshConfig) {
+  removeFromConfig(filePath, configKey);
+  await new Promise((resolve) => setTimeout(resolve, 500));
+  mergeConfig(filePath, configKey, freshConfig);
+}
+async function cycleMcpConfigs(slug, apiKey) {
+  for (const tool of TOOLS) {
+    if (tool.skillOnly || !tool.generateConfig || !tool.configKey) continue;
+    const paths = resolveConfigPaths(tool);
+    for (const { filePath, configKey } of paths) {
+      if (!fs10.existsSync(filePath)) continue;
+      if (!getPiutConfig(filePath, configKey)) continue;
+      await cycleConfigEntry(filePath, configKey, tool.generateConfig(slug, apiKey));
+      break;
+    }
+  }
+}
+async function cycleProjectConfigs(slug, apiKey, serverUrl) {
+  const projects = scanForProjects();
+  const refreshed = [];
+  const vscodeTool = TOOLS.find((t) => t.id === "vscode");
+  for (const project of projects) {
+    if (!hasPiutDir(project.path)) continue;
+    const projectName = path12.basename(project.path);
+    writePiutConfig(project.path, { slug, apiKey, serverUrl });
+    await writePiutSkill(project.path, slug, apiKey);
+    if (vscodeTool?.generateConfig && vscodeTool.configKey) {
+      const vscodeMcpPath = path12.join(project.path, ".vscode", "mcp.json");
+      if (fs10.existsSync(vscodeMcpPath) && isPiutConfigured(vscodeMcpPath, "servers")) {
+        await cycleConfigEntry(vscodeMcpPath, "servers", vscodeTool.generateConfig(slug, apiKey));
+      }
+    }
+    refreshed.push(projectName);
+  }
+  return refreshed;
+}
+
 // src/commands/build.ts
 async function buildCommand(options) {
   banner();
-  const { apiKey, serverUrl } = await resolveApiKeyWithResult(options.key);
+  const { apiKey, serverUrl, slug } = await resolveApiKeyWithResult(options.key);
   console.log(dim("  \u2501\u2501\u2501 BUILD YOUR BRAIN \u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"));
   console.log();
   console.log(dim("  Scanning for AI config files..."));
@@ -2289,7 +2447,7 @@ async function buildCommand(options) {
       return;
     }
   }
-  const home2 = os7.homedir();
+  const home2 = os8.homedir();
   const brainInput = {
     summary: {
       projects: projects.map((p) => ({
@@ -2300,9 +2458,9 @@ async function buildCommand(options) {
       configFiles: allConfigs
     }
   };
-  await streamBuild(apiKey, serverUrl, brainInput, options);
+  await streamBuild(apiKey, serverUrl, slug, brainInput, options);
 }
-async function streamBuild(apiKey, serverUrl, brainInput, options) {
+async function streamBuild(apiKey, serverUrl, slug, brainInput, options) {
   const spinner = new Spinner();
   spinner.start("Generating brain...");
   try {
@@ -2381,6 +2539,7 @@ async function streamBuild(apiKey, serverUrl, brainInput, options) {
         console.log(`  ${brand(serverUrl)}`);
         console.log(dim("  (accessible only with secure authentication)"));
         console.log();
+        await cycleMcpConfigs(slug, apiKey);
       } catch (err) {
         console.log();
         const msg = err.message;
@@ -2427,6 +2586,7 @@ async function deployCommand(options) {
     console.log(`  ${brand(serverUrl)}`);
     console.log(dim("  (securely accessible only with authentication)"));
     console.log();
+    await cycleMcpConfigs(slug, apiKey);
     console.log(dim("  Next: run ") + brand("piut connect") + dim(" to add brain references to your projects."));
     console.log();
   } catch (err) {
@@ -2447,33 +2607,33 @@ async function deployCommand(options) {
 
 // src/commands/connect.ts
 init_esm_shims();
-import fs9 from "fs";
-import path11 from "path";
+import fs11 from "fs";
+import path13 from "path";
 import { checkbox as checkbox3 } from "@inquirer/prompts";
 var RULE_FILES = [
   {
     tool: "Claude Code",
     filePath: "CLAUDE.md",
     strategy: "append",
-    detect: (p) => p.hasClaudeMd || fs9.existsSync(path11.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(path11.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(path11.join(p.path, ".windsurf"))
+    detect: (p) => p.hasWindsurfRules || fs11.existsSync(path13.join(p.path, ".windsurf"))
   },
   {
     tool: "VS Code",
     filePath: ".github/copilot-instructions.md",
     strategy: "append",
-    detect: (p) => p.hasCopilotInstructions || fs9.existsSync(path11.join(p.path, ".github"))
+    detect: (p) => p.hasCopilotInstructions || fs11.existsSync(path13.join(p.path, ".github"))
   },
   {
     tool: "Amazon Q",
@@ -2485,22 +2645,22 @@ var RULE_FILES = [
     tool: "Zed",
     filePath: ".zed/rules.md",
     strategy: "create",
-    detect: (p) => p.hasZedRules || fs9.existsSync(path11.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) => fs9.existsSync(path11.join(p.path, ".gemini"))
+    detect: (p) => fs11.existsSync(path13.join(p.path, ".gemini"))
   },
   {
     tool: "Paperclip",
     filePath: "AGENTS.md",
     strategy: "append",
-    detect: (p) => fs9.existsSync(path11.join(p.path, ".paperclip"))
+    detect: (p) => fs11.existsSync(path13.join(p.path, ".paperclip"))
   }
 ];
-var DEDICATED_FILE_CONTENT = `## p\u0131ut Context (MCP Server: piut-context)
+var DEDICATED_FILE_CONTENT = `## p\u0131ut Context (MCP Server: piut)
 
 This project uses p\u0131ut for persistent personal context via MCP (Model Context Protocol).
 p\u0131ut provides MCP tools \u2014 do NOT read local .piut/ files directly. Use the MCP tools.
@@ -2523,7 +2683,7 @@ Full skill reference: .piut/skill.md
 `;
 var APPEND_SECTION = `
 
-## p\u0131ut Context (MCP Server: piut-context)
+## p\u0131ut Context (MCP Server: piut)
 
 p\u0131ut provides MCP tools for persistent personal context. Do NOT read local .piut/ files.
 Available tools: \`get_context\`, \`get_section\`, \`search_brain\`, \`append_brain\`, \`update_brain\`, \`prompt_brain\`
@@ -2532,7 +2692,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;
@@ -2572,20 +2732,20 @@ async function connectCommand(options) {
   for (const project of projects) {
     for (const rule of RULE_FILES) {
       if (!rule.detect(project)) continue;
-      const absPath = path11.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 = path11.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",
@@ -2625,7 +2785,7 @@ async function connectCommand(options) {
   console.log();
   const projectChoices = [];
   for (const [projectPath, projectActions] of byProject) {
-    const projectName = path11.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}`;
@@ -2654,15 +2814,15 @@ async function connectCommand(options) {
   const vscodeTool = TOOLS.find((t) => t.id === "vscode");
   for (const projectPath of selectedPaths) {
     const projectActions = byProject.get(projectPath) || [];
-    const projectName = path11.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 (vscodeTool) {
-      const hasVscode = fs9.existsSync(path11.join(projectPath, ".github", "copilot-instructions.md")) || fs9.existsSync(path11.join(projectPath, ".github"));
+      const hasVscode = fs11.existsSync(path13.join(projectPath, ".github", "copilot-instructions.md")) || fs11.existsSync(path13.join(projectPath, ".github"));
       if (hasVscode) {
-        const vscodeMcpPath = path11.join(projectPath, ".vscode", "mcp.json");
+        const vscodeMcpPath = path13.join(projectPath, ".vscode", "mcp.json");
         const serverConfig = vscodeTool.generateConfig(slug, apiKey);
         mergeConfig(vscodeMcpPath, vscodeTool.configKey, serverConfig);
         console.log(success(`  \u2713 ${projectName}/.vscode/mcp.json`) + dim(" \u2014 VS Code MCP"));
@@ -2672,11 +2832,11 @@ async function connectCommand(options) {
       if (action.action === "create") {
         const isAppendType = RULE_FILES.find((r) => r.filePath === action.filePath)?.strategy === "append";
         const content = isAppendType ? PROJECT_SKILL_SNIPPET + "\n" : DEDICATED_FILE_CONTENT;
-        fs9.mkdirSync(path11.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++;
@@ -2686,7 +2846,7 @@ async function connectCommand(options) {
   const hostname = getHostname();
   for (const projectPath of selectedPaths) {
     const projectActions = byProject.get(projectPath) || [];
-    const projectName = path11.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, {
@@ -2706,8 +2866,8 @@ async function connectCommand(options) {
 
 // src/commands/disconnect.ts
 init_esm_shims();
-import fs10 from "fs";
-import path12 from "path";
+import fs12 from "fs";
+import path14 from "path";
 import { checkbox as checkbox4, confirm as confirm5 } from "@inquirer/prompts";
 var DEDICATED_FILES = /* @__PURE__ */ new Set([
   ".cursor/rules/piut.mdc",
@@ -2723,7 +2883,7 @@ var APPEND_FILES = [
 ];
 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;
@@ -2731,7 +2891,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
     ];
@@ -2745,7 +2905,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 {
@@ -2762,10 +2922,10 @@ async function disconnectCommand(options) {
   const projects = scanForProjects(scanFolders);
   const actions = [];
   for (const project of projects) {
-    const projectName = path12.basename(project.path);
+    const projectName = path14.basename(project.path);
     for (const dedicatedFile of DEDICATED_FILES) {
-      const absPath = path12.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,
@@ -2776,8 +2936,8 @@ async function disconnectCommand(options) {
       }
     }
     for (const appendFile of APPEND_FILES) {
-      const absPath = path12.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,
@@ -2792,12 +2952,12 @@ async function disconnectCommand(options) {
         projectPath: project.path,
         projectName,
         filePath: ".piut/",
-        absPath: path12.join(project.path, ".piut"),
+        absPath: path14.join(project.path, ".piut"),
         action: "remove-dir"
       });
     }
-    const vscodeMcpPath = path12.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,
@@ -2819,7 +2979,7 @@ async function disconnectCommand(options) {
   }
   console.log();
   const projectChoices = Array.from(byProject.entries()).map(([projectPath, projectActions]) => {
-    const name = path12.basename(projectPath);
+    const name = path14.basename(projectPath);
     const files = projectActions.map((a) => a.filePath).join(", ");
     return {
       name: `${name} ${dim(`(${files})`)}`,
@@ -2848,11 +3008,11 @@ async function disconnectCommand(options) {
   let disconnected = 0;
   for (const projectPath of selectedPaths) {
     const projectActions = byProject.get(projectPath) || [];
-    const projectName = path12.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 {
@@ -2866,7 +3026,7 @@ async function disconnectCommand(options) {
       } else if (action.action === "remove-mcp") {
         try {
           removeFromConfig(action.absPath, "servers");
-          console.log(success(`  \u2713 ${projectName}/${action.filePath}`) + dim(" \u2014 piut-context removed"));
+          console.log(success(`  \u2713 ${projectName}/${action.filePath}`) + dim(" \u2014 piut removed"));
           disconnected++;
         } catch {
           console.log(warning(`  \u2717 ${projectName}/${action.filePath}`) + dim(" \u2014 could not update"));
@@ -3033,7 +3193,7 @@ async function updateCommand(currentVersion) {
 
 // src/commands/doctor.ts
 init_esm_shims();
-import fs11 from "fs";
+import fs13 from "fs";
 import chalk10 from "chalk";
 async function doctorCommand(options) {
   if (!options.json) banner();
@@ -3085,7 +3245,7 @@ async function doctorCommand(options) {
   for (const tool of TOOLS) {
     const paths = resolveConfigPaths(tool);
     for (const { filePath: configPath, configKey: resolvedKey } of paths) {
-      if (!fs11.existsSync(configPath)) continue;
+      if (!fs13.existsSync(configPath)) continue;
       const piutConfig = getPiutConfig(configPath, resolvedKey);
       if (!piutConfig) {
         result.tools.push({
@@ -3185,6 +3345,12 @@ async function doctorCommand(options) {
   }
   if (result.issues === 0) {
     console.log(success("  All checks passed."));
+    if (result.mcp.ok && result.tools.some((t) => t.configured)) {
+      console.log();
+      console.log(dim("  Tip: If your AI tool can't access your brain but everything"));
+      console.log(dim("  checks out here, try toggling the MCP server off and on in"));
+      console.log(dim("  your tool's settings. MCP connections can go stale."));
+    }
   } else {
     console.log(warning(`  ${result.issues} issue(s) found.`));
     const staleTools = result.tools.filter((t) => t.keyMatch === "stale" && !t.fixed);
@@ -3200,10 +3366,49 @@ async function doctorCommand(options) {
   if (result.issues > 0) throw new CliError(`${result.issues} issue(s) found`);
 }
 
+// src/commands/refresh.ts
+init_esm_shims();
+async function refreshCommand(options) {
+  banner();
+  const { apiKey, slug, serverUrl, status } = await resolveApiKeyWithResult(options.key);
+  const configuredTools = getConfiguredToolNames();
+  const isDeployed = status === "active";
+  if (configuredTools.length === 0 && !isDeployed) {
+    console.log();
+    console.log(warning("  Nothing to refresh."));
+    console.log(dim("  Run ") + brand("piut setup") + dim(" first to configure your AI tools."));
+    console.log();
+    return;
+  }
+  console.log(dim("  Refreshing..."));
+  if (isDeployed) {
+    try {
+      await publishServer(apiKey);
+      console.log(success("  \u2713 Server republished"));
+    } catch {
+      console.log(warning("  \u2717 Could not republish server"));
+    }
+  }
+  if (configuredTools.length > 0) {
+    await cycleMcpConfigs(slug, apiKey);
+    console.log(success("  \u2713 Refreshed MCP connections"));
+    console.log(dim(`    Cycled: ${configuredTools.join(", ")}`));
+  }
+  const refreshedProjects = await cycleProjectConfigs(slug, apiKey, serverUrl);
+  if (refreshedProjects.length > 0) {
+    console.log(success("  \u2713 Refreshed connected projects"));
+    console.log(dim(`    Updated: ${refreshedProjects.join(", ")}`));
+  }
+  console.log();
+  console.log(dim("  Tools that watch config files will reconnect automatically."));
+  console.log(dim("  If a tool doesn't refresh, restart it manually."));
+  console.log();
+}
+
 // src/commands/vault.ts
 init_esm_shims();
-import fs12 from "fs";
-import path13 from "path";
+import fs14 from "fs";
+import path15 from "path";
 import chalk11 from "chalk";
 import { confirm as confirm7 } from "@inquirer/prompts";
 var DOCUMENT_EXTENSIONS = /* @__PURE__ */ new Set([
@@ -3256,26 +3461,26 @@ async function vaultListCommand(options) {
 }
 async function vaultUploadCommand(filePath, options) {
   const key = resolveApiKey(options);
-  const resolved = path13.resolve(filePath);
-  if (!fs12.existsSync(resolved)) {
+  const resolved = path15.resolve(filePath);
+  if (!fs14.existsSync(resolved)) {
     console.log(chalk11.red(`  File not found: ${filePath}`));
     throw new CliError();
   }
-  const stat = fs12.statSync(resolved);
+  const stat = fs14.statSync(resolved);
   if (!stat.isFile()) {
     console.log(chalk11.red(`  Not a file: ${filePath}`));
     throw new CliError();
   }
-  const filename = path13.basename(resolved);
+  const filename = path15.basename(resolved);
   const ext = filename.includes(".") ? filename.split(".").pop()?.toLowerCase() || "" : "";
   const isDocument = DOCUMENT_EXTENSIONS.has(ext);
   let content;
   let encoding;
   if (isDocument) {
-    content = fs12.readFileSync(resolved).toString("base64");
+    content = fs14.readFileSync(resolved).toString("base64");
     encoding = "base64";
   } else {
-    content = fs12.readFileSync(resolved, "utf-8");
+    content = fs14.readFileSync(resolved, "utf-8");
   }
   const spinner = new Spinner();
   spinner.start(`Uploading ${filename}...`);
@@ -3298,8 +3503,8 @@ async function vaultReadCommand(filename, options) {
   try {
     const file = await readVaultFile(key, filename);
     if (options.output) {
-      const outPath = path13.resolve(options.output);
-      fs12.writeFileSync(outPath, file.content, "utf-8");
+      const outPath = path15.resolve(options.output);
+      fs14.writeFileSync(outPath, file.content, "utf-8");
       console.log(success(`  Saved to ${outPath}`));
       console.log();
     } else {
@@ -3333,45 +3538,10 @@ async function vaultDeleteCommand(filename, options) {
 // src/commands/interactive.ts
 init_esm_shims();
 import { select as select2, confirm as confirm8, checkbox as checkbox5, Separator } from "@inquirer/prompts";
-import fs15 from "fs";
-import path15 from "path";
+import fs16 from "fs";
+import path17 from "path";
 import { exec as exec2 } from "child_process";
 import chalk13 from "chalk";
-
-// src/lib/sync.ts
-init_esm_shims();
-import fs13 from "fs";
-function syncStaleConfigs(slug, apiKey, serverUrl) {
-  const updated = [];
-  for (const tool of TOOLS) {
-    if (tool.skillOnly || !tool.generateConfig || !tool.configKey) continue;
-    const paths = resolveConfigPaths(tool);
-    for (const { filePath, configKey } of paths) {
-      if (!fs13.existsSync(filePath)) continue;
-      const piutConfig = getPiutConfig(filePath, configKey);
-      if (!piutConfig) continue;
-      const existingKey = extractKeyFromConfig(piutConfig);
-      const existingSlug = extractSlugFromConfig(piutConfig);
-      const keyStale = !!existingKey && existingKey !== apiKey;
-      const slugStale = !!existingSlug && existingSlug !== slug;
-      if (keyStale || slugStale) {
-        const newConfig = tool.generateConfig(slug, apiKey);
-        mergeConfig(filePath, configKey, newConfig);
-        updated.push(tool.name);
-      }
-      break;
-    }
-  }
-  const cwd = process.cwd();
-  const existing = readPiutConfig(cwd);
-  if (existing && (existing.apiKey !== apiKey || existing.slug !== slug)) {
-    writePiutConfig(cwd, { slug, apiKey, serverUrl });
-    updated.push(".piut/config.json");
-  }
-  return updated;
-}
-
-// src/commands/interactive.ts
 var DOCUMENT_EXTENSIONS2 = /* @__PURE__ */ new Set([
   "pdf",
   "docx",
@@ -3426,6 +3596,34 @@ async function interactiveMenu() {
   if (synced.length > 0) {
     console.log(dim(`  Updated ${synced.length} stale config(s): ${synced.join(", ")}`));
   }
+  await offerGlobalInstall();
+  const configuredTools = getConfiguredToolNames();
+  const isDeployed = currentValidation.status === "active";
+  if (configuredTools.length > 0 || isDeployed) {
+    const parts = [];
+    if (isDeployed) {
+      try {
+        await publishServer(apiKey);
+        parts.push("server");
+      } catch {
+      }
+    }
+    if (configuredTools.length > 0) {
+      await cycleMcpConfigs(currentValidation.slug, apiKey);
+      parts.push(`${configuredTools.length} tool(s)`);
+    }
+    const refreshedProjects = await cycleProjectConfigs(
+      currentValidation.slug,
+      apiKey,
+      currentValidation.serverUrl
+    );
+    if (refreshedProjects.length > 0) {
+      parts.push(`${refreshedProjects.length} project(s)`);
+    }
+    if (parts.length > 0) {
+      console.log(dim(`  Refreshed: ${parts.join(", ")}`));
+    }
+  }
   console.log();
   if (currentValidation.status === "no_brain") {
     console.log(warning("  You haven\u2019t built a brain yet."));
@@ -3461,7 +3659,7 @@ async function interactiveMenu() {
   }
   while (true) {
     const hasBrain = currentValidation.status !== "no_brain";
-    const isDeployed = currentValidation.status === "active";
+    const isDeployed2 = currentValidation.status === "active";
     let action;
     try {
       action = await select2({
@@ -3487,22 +3685,22 @@ async function interactiveMenu() {
           },
           new Separator(),
           {
-            name: isDeployed ? "Undeploy Brain" : "Deploy Brain",
+            name: isDeployed2 ? "Undeploy Brain" : "Deploy Brain",
             value: "deploy",
-            description: isDeployed ? "Take your MCP server offline" : "Publish your MCP server (requires paid account)"
+            description: isDeployed2 ? "Take your MCP server offline" : "Publish your MCP server (requires paid account)"
           },
           new Separator(),
           {
             name: "Connect Tools",
             value: "connect-tools",
             description: "Manage which AI tools use your MCP server",
-            disabled: !isDeployed && "(deploy brain first)"
+            disabled: !isDeployed2 && "(deploy brain first)"
           },
           {
             name: "Connect Projects",
             value: "connect-projects",
             description: "Manage brain references in project config files",
-            disabled: !isDeployed && "(deploy brain first)"
+            disabled: !isDeployed2 && "(deploy brain first)"
           },
           new Separator(),
           {
@@ -3549,7 +3747,7 @@ async function interactiveMenu() {
           handleEditBrain();
           break;
         case "deploy":
-          if (isDeployed) {
+          if (isDeployed2) {
             await handleUndeploy(apiKey);
           } else {
             await deployCommand({ key: apiKey });
@@ -3620,8 +3818,8 @@ async function handleConnectTools(apiKey, validation) {
   for (const tool of TOOLS) {
     const paths = resolveConfigPaths(tool);
     for (const { filePath, configKey } of paths) {
-      const exists = fs15.existsSync(filePath);
-      const parentExists = fs15.existsSync(path15.dirname(filePath));
+      const exists = fs16.existsSync(filePath);
+      const parentExists = fs16.existsSync(path17.dirname(filePath));
       if (exists || parentExists) {
         const connected = exists && !!configKey && isPiutConfigured(filePath, configKey);
         detected.push({ tool, configPath: filePath, resolvedConfigKey: configKey, connected });
@@ -3744,29 +3942,29 @@ async function handleManageProjects(apiKey, validation) {
   console.log();
   const copilotTool = TOOLS.find((t) => t.id === "copilot");
   for (const { project } of toConnect) {
-    const projectName = path15.basename(project.path);
+    const projectName = path17.basename(project.path);
     writePiutConfig(project.path, { slug, apiKey, serverUrl });
     await writePiutSkill(project.path, slug, apiKey);
     ensureGitignored(project.path);
     if (copilotTool) {
-      const hasCopilot = fs15.existsSync(path15.join(project.path, ".github", "copilot-instructions.md")) || fs15.existsSync(path15.join(project.path, ".github"));
+      const hasCopilot = fs16.existsSync(path17.join(project.path, ".github", "copilot-instructions.md")) || fs16.existsSync(path17.join(project.path, ".github"));
       if (hasCopilot) {
-        const vscodeMcpPath = path15.join(project.path, ".vscode", "mcp.json");
+        const vscodeMcpPath = path17.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 = path15.join(project.path, rule.filePath);
-      if (fs15.existsSync(absPath) && hasPiutReference2(absPath)) continue;
-      if (rule.strategy === "create" || !fs15.existsSync(absPath)) {
+      const absPath = path17.join(project.path, rule.filePath);
+      if (fs16.existsSync(absPath) && hasPiutReference2(absPath)) continue;
+      if (rule.strategy === "create" || !fs16.existsSync(absPath)) {
         const isAppendType = rule.strategy === "append";
         const content = isAppendType ? PROJECT_SKILL_SNIPPET + "\n" : DEDICATED_FILE_CONTENT;
-        fs15.mkdirSync(path15.dirname(absPath), { recursive: true });
-        fs15.writeFileSync(absPath, content, "utf-8");
+        fs16.mkdirSync(path17.dirname(absPath), { recursive: true });
+        fs16.writeFileSync(absPath, content, "utf-8");
       } else {
-        fs15.appendFileSync(absPath, APPEND_SECTION);
+        fs16.appendFileSync(absPath, APPEND_SECTION);
       }
     }
     toolLine(projectName, success("connected"), "\u2714");
@@ -3782,24 +3980,24 @@ async function handleManageProjects(apiKey, validation) {
     });
   }
   for (const { project } of toDisconnect) {
-    const projectName = path15.basename(project.path);
+    const projectName = path17.basename(project.path);
     for (const dedicatedFile of DEDICATED_FILES) {
-      const absPath = path15.join(project.path, dedicatedFile);
-      if (fs15.existsSync(absPath) && hasPiutReference2(absPath)) {
+      const absPath = path17.join(project.path, dedicatedFile);
+      if (fs16.existsSync(absPath) && hasPiutReference2(absPath)) {
         try {
-          fs15.unlinkSync(absPath);
+          fs16.unlinkSync(absPath);
         } catch {
         }
       }
     }
     for (const appendFile of APPEND_FILES) {
-      const absPath = path15.join(project.path, appendFile);
-      if (fs15.existsSync(absPath) && hasPiutReference2(absPath)) {
+      const absPath = path17.join(project.path, appendFile);
+      if (fs16.existsSync(absPath) && hasPiutReference2(absPath)) {
         removePiutSection(absPath);
       }
     }
-    const vscodeMcpPath = path15.join(project.path, ".vscode", "mcp.json");
-    if (fs15.existsSync(vscodeMcpPath) && isPiutConfigured(vscodeMcpPath, "servers")) {
+    const vscodeMcpPath = path17.join(project.path, ".vscode", "mcp.json");
+    if (fs16.existsSync(vscodeMcpPath) && isPiutConfigured(vscodeMcpPath, "servers")) {
       removeFromConfig(vscodeMcpPath, "servers");
     }
     removePiutDir(project.path);
@@ -3891,16 +4089,16 @@ async function handleVaultUpload(apiKey) {
   console.log();
   let uploaded = 0;
   for (const filePath of files) {
-    const filename = path15.basename(filePath);
+    const filename = path17.basename(filePath);
     const ext = filename.includes(".") ? filename.split(".").pop()?.toLowerCase() || "" : "";
     const isDocument = DOCUMENT_EXTENSIONS2.has(ext);
     let content;
     let encoding;
     if (isDocument) {
-      content = fs15.readFileSync(filePath).toString("base64");
+      content = fs16.readFileSync(filePath).toString("base64");
       encoding = "base64";
     } else {
-      content = fs15.readFileSync(filePath, "utf-8");
+      content = fs16.readFileSync(filePath, "utf-8");
     }
     const spinner = new Spinner();
     spinner.start(`Uploading ${filename}...`);
@@ -3976,7 +4174,7 @@ async function handleViewBrain(apiKey) {
 }
 
 // src/cli.ts
-var VERSION = "3.9.0";
+var VERSION = "3.10.0";
 function withExit(fn) {
   return async (...args2) => {
     try {
@@ -4002,6 +4200,7 @@ program.command("remove").description("Remove all p\u0131ut configurations").act
 program.command("login").description("Authenticate with p\u0131ut (email, browser, or API key)").action(withExit(loginCommand));
 program.command("logout").description("Remove saved API key").action(logoutCommand);
 program.command("doctor").description("Diagnose and fix connection issues").option("-k, --key <key>", "API key to verify against").option("--fix", "Auto-fix stale configurations").option("--json", "Output results as JSON").action(withExit(doctorCommand));
+program.command("refresh").description("Force all configured tools to reconnect to your MCP server").option("-k, --key <key>", "API key").action(withExit(refreshCommand));
 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));