mover-os 4.5.3 → 4.5.5

package/install.js

@@ -716,9 +716,14 @@ const DOWNLOAD_URL = "https://moveros.dev/api/download";
 
 async function downloadPayload(key) {
   const https = require("https");
-  const tmpDir = path.join(os.tmpdir(), `moveros-${Date.now()}`);
-  fs.mkdirSync(tmpDir, { recursive: true });
-  const tarPath = path.join(tmpDir, "payload.tar.gz");
+  const moverDir = path.join(os.homedir(), ".mover");
+  fs.mkdirSync(moverDir, { recursive: true, mode: 0o700 });
+  // Clean old staged src/ before extracting fresh
+  const stagedSrc = path.join(moverDir, "src");
+  if (fs.existsSync(stagedSrc)) {
+    fs.rmSync(stagedSrc, { recursive: true, force: true });
+  }
+  const tarPath = path.join(moverDir, "payload.tar.gz");
 
   // Download tarball
   await new Promise((resolve, reject) => {
@@ -778,9 +783,9 @@ async function downloadPayload(key) {
     req.end();
   });
 
-  // Extract tarball
+  // Extract tarball into ~/.mover/ (produces ~/.mover/src/)
   try {
-    execSync(`tar -xzf "${tarPath}" -C "${tmpDir}"`, { stdio: "ignore" });
+    execSync(`tar -xzf "${tarPath}" -C "${moverDir}"`, { stdio: "ignore" });
   } catch {
     throw new Error("Failed to extract payload. Ensure 'tar' is available.");
   }
@@ -788,7 +793,7 @@ async function downloadPayload(key) {
   // Clean up tarball
   try { fs.unlinkSync(tarPath); } catch {}
 
-  return tmpDir;
+  return moverDir;
 }
 
 // ─── Path helpers ────────────────────────────────────────────────────────────
@@ -1088,6 +1093,83 @@ function detectChanges(bundleDir, vaultPath, selectedAgentIds) {
   return result;
 }
 
+function autoBackupBeforeUpdate(changes, selectedAgentIds, vaultPath) {
+  const home = os.homedir();
+  const targetIds = expandTargetIds(selectedAgentIds);
+  const now = new Date();
+  const ts = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}_${String(now.getHours()).padStart(2, "0")}${String(now.getMinutes()).padStart(2, "0")}`;
+  const backupRoot = path.join(home, ".mover", "backups", `pre-update-${ts}`);
+  let backed = 0;
+
+  const backup = (src, relPath) => {
+    if (!fs.existsSync(src)) return;
+    const dest = path.join(backupRoot, relPath);
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    try { fs.copyFileSync(src, dest); backed++; } catch {}
+  };
+
+  // Workflows
+  const wfDests = [
+    targetIds.includes("claude-code") && path.join(home, ".claude", "commands"),
+    targetIds.includes("cursor") && path.join(home, ".cursor", "commands"),
+    targetIds.includes("antigravity") && path.join(home, ".gemini", "antigravity", "global_workflows"),
+  ].filter(Boolean);
+  for (const f of changes.workflows.filter((x) => x.status === "changed")) {
+    for (const dir of wfDests) {
+      backup(path.join(dir, f.file), path.join("workflows", path.basename(dir), f.file));
+    }
+  }
+
+  // Hooks
+  if (targetIds.includes("claude-code")) {
+    for (const f of changes.hooks.filter((x) => x.status === "changed")) {
+      backup(path.join(home, ".claude", "hooks", f.file), path.join("hooks", f.file));
+    }
+  }
+
+  // Rules
+  if (changes.rules === "changed") {
+    const rulesDests = [
+      targetIds.includes("claude-code") && path.join(home, ".claude", "CLAUDE.md"),
+      targetIds.includes("gemini-cli") && path.join(home, ".gemini", "GEMINI.md"),
+      targetIds.includes("cursor") && path.join(home, ".cursor", "rules", "mover-os.mdc"),
+    ].filter(Boolean);
+    for (const p of rulesDests) {
+      backup(p, path.join("rules", path.basename(p)));
+    }
+  }
+
+  // Skills
+  const skillsDests = [
+    targetIds.includes("claude-code") && path.join(home, ".claude", "skills"),
+    targetIds.includes("cursor") && path.join(home, ".cursor", "skills"),
+    targetIds.includes("cline") && path.join(home, ".cline", "skills"),
+  ].filter(Boolean);
+  for (const f of (changes.skills || []).filter((x) => x.status === "changed")) {
+    for (const dir of skillsDests) {
+      const skillFile = path.join(dir, f.file, "SKILL.md");
+      if (fs.existsSync(skillFile)) {
+        backup(skillFile, path.join("skills", f.file, path.basename(dir), "SKILL.md"));
+      }
+    }
+  }
+
+  // Statusline
+  if (changes.statusline === "changed" && targetIds.includes("claude-code")) {
+    backup(path.join(home, ".claude", "statusline.js"), "statusline.js");
+  }
+
+  // Templates
+  for (const f of changes.templates.filter((x) => x.status === "changed")) {
+    backup(path.join(vaultPath, f.file), path.join("templates", f.file));
+  }
+
+  if (backed > 0) {
+    statusLine("ok", "Auto-backup", `${backed} files → ${dim(backupRoot)}`);
+  }
+  return backed;
+}
+
 function countChanges(changes) {
   let n = 0;
   n += changes.workflows.filter((f) => f.status !== "unchanged").length;
@@ -1998,19 +2080,19 @@ async function fetchPrayerTimes(city, country) {
   const https = require("https");
   const year = new Date().getFullYear();
   const allTimes = {};
+  let failedMonths = 0;
 
   for (let month = 1; month <= 12; month++) {
     try {
       const url = `https://api.aladhan.com/v1/calendarByCity/${year}/${month}?city=${encodeURIComponent(city)}&country=${encodeURIComponent(country)}&method=15`;
       const body = await new Promise((resolve, reject) => {
-        const req = https.request(url, { method: "GET", timeout: 10000 }, (res) => {
+        const req = https.get(url, { timeout: 10000 }, (res) => {
           let data = "";
           res.on("data", (c) => (data += c));
           res.on("end", () => resolve(data));
         });
         req.on("error", reject);
         req.on("timeout", () => { req.destroy(); reject(new Error("Timeout")); });
-        req.end();
       });
 
       const json = JSON.parse(body);
@@ -2027,9 +2109,11 @@ async function fetchPrayerTimes(city, country) {
             isha: t.Isha.replace(/\s*\(.*\)/, ""),
           };
         }
+      } else {
+        failedMonths++;
       }
     } catch {
-      // Skip failed months — partial data is still useful
+      failedMonths++;
     }
   }
 
@@ -3776,27 +3860,29 @@ async function cmdPrayer(opts) {
     barLn();
     const city = await textInput({ label: "City", placeholder: "London" });
     if (city === null) return;
+    if (!city.trim()) { barLn(yellow("  City cannot be empty.")); return; }
     const country = await textInput({ label: "Country", placeholder: "United Kingdom" });
     if (country === null) return;
+    if (!country.trim()) { barLn(yellow("  Country cannot be empty.")); return; }
     barLn();
 
-    if (city && country) {
-      const sp = spinner("Fetching prayer times (12 months)");
-      const result = await fetchPrayerTimes(city.trim(), country.trim());
-      if (result && Object.keys(result.times).length > 0) {
-        fs.writeFileSync(ttPath, JSON.stringify(result, null, 2), "utf8");
-        sp.stop(`Saved ${Object.keys(result.times).length} days`);
-        barLn(dim("  These are calculated adhan times, not mosque jama'ah times."));
-        barLn(dim("  For your mosque's specific times, choose 'Paste mosque timetable'."));
-      } else {
-        sp.stop(yellow("Could not fetch. Check city/country spelling."));
-      }
+    const sp = spinner("Fetching prayer times (12 months)");
+    const result = await fetchPrayerTimes(city.trim(), country.trim());
+    if (result && Object.keys(result.times).length > 0) {
+      fs.writeFileSync(ttPath, JSON.stringify(result, null, 2), "utf8");
+      sp.stop(`Saved ${Object.keys(result.times).length} days`);
+      barLn(dim("  These are calculated adhan times, not mosque jama'ah times."));
+      barLn(dim("  For your mosque's specific times, choose 'Paste mosque timetable'."));
+
+      // Auto-enable
+      if (!cfg.settings) cfg.settings = {};
+      cfg.settings.show_prayer_times = true;
+      fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2), "utf8");
+    } else {
+      sp.stop(yellow("Could not fetch prayer times."));
+      barLn(yellow("  Check the city/country spelling and try again."));
+      barLn(dim("  Example: City = London, Country = United Kingdom"));
     }
-
-    // Auto-enable
-    if (!cfg.settings) cfg.settings = {};
-    cfg.settings.show_prayer_times = true;
-    fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2), "utf8");
   } else if (choice === "paste") {
     barLn();
     barLn(dim("  Paste your mosque's timetable below."));
@@ -4650,8 +4736,14 @@ async function cmdUpdateComprehensive(opts, bundleDir, startTime) {
         barLn(`${yellow("CLI update available:")} ${dim(localVer)} ${dim("\u2192")} ${green(npmVer)}`);
         const sp = spinner("Updating CLI");
         try {
-          execSync("npm i -g mover-os", { stdio: "ignore", timeout: 60000 });
-          sp.stop(`CLI updated to ${npmVer}`);
+          try {
+            execSync("npm i -g mover-os", { stdio: "ignore", timeout: 60000 });
+          } catch {
+            // Retry with sudo — use inherit so password prompt shows
+            sp.stop(dim("Needs elevated permissions..."));
+            execSync("sudo npm i -g mover-os", { stdio: "inherit", timeout: 120000 });
+          }
+          barLn(`${green("\u2713")} CLI updated to ${npmVer}`);
           barLn(dim("  Re-running with updated CLI..."));
           barLn();
           const args = process.argv.slice(2).concat("--_self-updated");
@@ -4662,7 +4754,7 @@ async function cmdUpdateComprehensive(opts, bundleDir, startTime) {
           process.exit(result.status || 0);
         } catch (e) {
           sp.stop(yellow(`CLI self-update failed: ${e.message}`));
-          barLn(dim("  Continuing with current version..."));
+          barLn(dim("  Try: sudo npm i -g mover-os"));
         }
       } else {
         statusLine("ok", "CLI", `up to date (${localVer})`);
@@ -4731,15 +4823,21 @@ async function cmdUpdateComprehensive(opts, bundleDir, startTime) {
     newVer = pkg.version || newVer;
   } catch {}
 
-  // Quick mode: skip interactive steps
+  // ── Stage only — no direct file overwrite ──
+  // Files are staged at ~/.mover/src/. The /update AI workflow handles
+  // the actual apply with merge support for user customizations.
+
+  const detectedAgents = AGENTS.filter((a) => a.detect());
+  const selectedIds = detectedAgents.map((a) => a.id);
+
+  // Quick mode: force-apply (CI/headless — no user customizations to protect)
   if (isQuick) {
-    const detectedAgents = AGENTS.filter((a) => a.detect());
     if (detectedAgents.length === 0) { outro(red("No AI agents detected.")); process.exit(1); }
-    const selectedIds = detectedAgents.map((a) => a.id);
     const changes = detectChanges(bundleDir, vaultPath, selectedIds);
     const totalChanged = countChanges(changes);
     displayChangeSummary(changes, installedVer, newVer);
     if (totalChanged === 0) { outro(green("Already up to date.")); return; }
+    autoBackupBeforeUpdate(changes, selectedIds, vaultPath);
     barLn(bold("Updating..."));
     barLn();
     createVaultStructure(vaultPath);
@@ -4764,117 +4862,15 @@ async function cmdUpdateComprehensive(opts, bundleDir, startTime) {
     writeMoverConfig(vaultPath, selectedIds);
     barLn();
     const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
-    outro(`${green("Done.")} ${totalChanged} files updated in ${elapsed}s. Run ${bold("/update")} if version bumped.`);
+    outro(`${green("Done.")} ${totalChanged} files updated in ${elapsed}s.`);
     return;
   }
 
+  // ── Interactive mode: stage + summary ──
   // Step 4: What's New
   showWhatsNew(installedVer, newVer);
 
-  // Step 5: Backup Offer
-  const engine = detectEngineFiles(vaultPath);
-  if (engine.exists) {
-    question("Back up before updating?");
-    barLn(dim("  Select what to save. Esc to skip."));
-    barLn();
-    const backupItems = [
-      { id: "engine", name: "Engine files", tier: "Identity, Strategy, Goals, Context" },
-    ];
-    if (fs.existsSync(path.join(vaultPath, "02_Areas"))) {
-      backupItems.push({ id: "areas", name: "Full Areas folder", tier: "Everything in 02_Areas/" });
-    }
-    const detectedForBackup = AGENTS.filter((a) => a.detect()).map((a) => a.id);
-    if (detectedForBackup.length > 0) {
-      backupItems.push({ id: "agents", name: "Agent configs", tier: `Rules, skills from ${detectedForBackup.length} agent(s)` });
-    }
-    const backupChoices = await interactiveSelect(backupItems, { multi: true, preSelected: ["engine"] });
-    if (backupChoices && backupChoices.length > 0) {
-      const now = new Date();
-      const ts = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}_${String(now.getHours()).padStart(2, "0")}${String(now.getMinutes()).padStart(2, "0")}`;
-      const archivesDir = path.join(vaultPath, "04_Archives");
-      if (backupChoices.includes("engine")) {
-        const engineDir = path.join(vaultPath, "02_Areas", "Engine");
-        const backupDir = path.join(archivesDir, `Engine_Backup_${ts}`);
-        try {
-          fs.mkdirSync(backupDir, { recursive: true });
-          let backed = 0;
-          for (const f of fs.readdirSync(engineDir).filter(f => fs.statSync(path.join(engineDir, f)).isFile())) {
-            fs.copyFileSync(path.join(engineDir, f), path.join(backupDir, f));
-            backed++;
-          }
-          statusLine("ok", "Backed up", `${backed} Engine files`);
-        } catch (err) { barLn(yellow(`  Backup failed: ${err.message}`)); }
-      }
-      if (backupChoices.includes("areas")) {
-        try {
-          copyDirRecursive(path.join(vaultPath, "02_Areas"), path.join(archivesDir, `Areas_Backup_${ts}`));
-          statusLine("ok", "Backed up", "Full Areas folder");
-        } catch (err) { barLn(yellow(`  Areas backup failed: ${err.message}`)); }
-      }
-      if (backupChoices.includes("agents")) {
-        try {
-          const agentBackupDir = path.join(archivesDir, `Agent_Backup_${ts}`);
-          fs.mkdirSync(agentBackupDir, { recursive: true });
-          let agentsBacked = 0;
-          for (const ag of AGENTS.filter((a) => a.detect())) {
-            const sel = AGENT_SELECTIONS.find((s) => s.id === ag.id);
-            const targets = sel ? sel.targets : [ag.id];
-            for (const targetId of targets) {
-              const reg = AGENT_REGISTRY[targetId];
-              if (!reg) continue;
-              const agDir = path.join(agentBackupDir, targetId);
-              fs.mkdirSync(agDir, { recursive: true });
-              // Back up rules file
-              if (reg.rules && reg.rules.dest) {
-                try {
-                  const rulesPath = reg.rules.dest(vaultPath);
-                  if (fs.existsSync(rulesPath)) {
-                    fs.copyFileSync(rulesPath, path.join(agDir, path.basename(rulesPath)));
-                    agentsBacked++;
-                  }
-                } catch {}
-              }
-              // Back up skills directory
-              if (reg.skills && reg.skills.dest) {
-                try {
-                  const skillsDir = reg.skills.dest(vaultPath);
-                  if (fs.existsSync(skillsDir)) {
-                    copyDirRecursive(skillsDir, path.join(agDir, "skills"));
-                    agentsBacked++;
-                  }
-                } catch {}
-              }
-            }
-          }
-          statusLine("ok", "Backed up", `${agentsBacked} agent config items`);
-        } catch (err) { barLn(yellow(`  Agent backup failed: ${err.message}`)); }
-      }
-    }
-    barLn();
-  }
-
-  // Step 6: Agent Management
-  const visibleAgents = AGENTS.filter((a) => !a.hidden);
-  const detectedIds = visibleAgents.filter((a) => a.detect()).map((a) => a.id);
-  const cfgPath = path.join(os.homedir(), ".mover", "config.json");
-  let currentAgents = [];
-  if (fs.existsSync(cfgPath)) {
-    try { currentAgents = JSON.parse(fs.readFileSync(cfgPath, "utf8")).agents || []; } catch {}
-  }
-  const preSelectedAgents = [...new Set([...detectedIds, ...currentAgents])];
-
-  question(`Agents ${dim("(add or remove)")}`);
-  barLn();
-  const agentItems = visibleAgents.map((a) => ({
-    ...a,
-    _detected: detectedIds.includes(a.id),
-  }));
-  const selectedIds = await interactiveSelect(agentItems, { multi: true, preSelected: preSelectedAgents });
-  if (!selectedIds || selectedIds.length === 0) return;
-  const selectedAgents = AGENTS.filter((a) => selectedIds.includes(a.id));
-  barLn();
-
-  // Step 7: Change Detection
+  // Step 5: Change Detection (compare staged vs installed)
   const changes = detectChanges(bundleDir, vaultPath, selectedIds);
   const totalChanged = countChanges(changes);
   question("Change Summary");
@@ -4884,125 +4880,77 @@ async function cmdUpdateComprehensive(opts, bundleDir, startTime) {
   if (totalChanged === 0) {
     barLn(green("  Already up to date."));
     barLn();
-    const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
-    outro(`${green("Done.")} No changes needed. ${dim(`(${elapsed}s)`)}`);
+    outro(green("No changes needed. Engine files may still need migration — run /update."));
     return;
   }
 
-  const applyChoice = await interactiveSelect([
-    { id: "all", name: "Yes, update all changed files", tier: "" },
-    { id: "select", name: "Select individually", tier: "" },
-    { id: "cancel", name: "Cancel", tier: "" },
-  ], { multi: false, defaultIndex: 0 });
-  if (!applyChoice || applyChoice === "cancel") { outro("Cancelled."); return; }
-
-  let selectedWorkflows = null;
-  let skipHooks = false, skipRules = false, skipTemplates = false;
-  if (applyChoice === "select") {
-    const changedItems = [];
-    const changedPreSelected = [];
-    for (const f of changes.workflows.filter((x) => x.status !== "unchanged")) {
-      const id = `wf:${f.file}`;
-      changedItems.push({ id, name: `/${f.file.replace(".md", "")}`, tier: dim(f.status === "new" ? "new" : "changed") });
-      changedPreSelected.push(id);
-    }
-    for (const f of changes.hooks.filter((x) => x.status !== "unchanged")) {
-      const id = `hook:${f.file}`;
-      changedItems.push({ id, name: f.file, tier: dim(f.status === "new" ? "new hook" : "hook") });
-      changedPreSelected.push(id);
-    }
-    if (changes.rules === "changed") {
-      changedItems.push({ id: "rules", name: "Global Rules", tier: dim("rules") });
-      changedPreSelected.push("rules");
-    }
-    for (const f of changes.templates.filter((x) => x.status !== "unchanged")) {
-      const id = `tmpl:${f.file}`;
-      changedItems.push({ id, name: f.file.replace(/\\/g, "/"), tier: dim(f.status === "new" ? "new" : "changed") });
-      changedPreSelected.push(id);
-    }
-    if (changedItems.length > 0) {
-      question("Select files to update");
-      barLn();
-      const selectedFileIds = await interactiveSelect(changedItems, { multi: true, preSelected: changedPreSelected });
-      if (!selectedFileIds) return;
-      const selectedWfFiles = selectedFileIds.filter((id) => id.startsWith("wf:")).map((id) => id.slice(3));
-      if (selectedWfFiles.length < changes.workflows.filter((x) => x.status !== "unchanged").length) {
-        selectedWorkflows = new Set(selectedWfFiles);
-      }
-      skipHooks = !selectedFileIds.some((id) => id.startsWith("hook:"));
-      skipRules = !selectedFileIds.includes("rules");
-      skipTemplates = !selectedFileIds.some((id) => id.startsWith("tmpl:"));
+  // ── Apply safe system files directly (no user customizations in these) ──
+  const home = os.homedir();
+  let appliedCount = 0;
+
+  // Hooks (shell scripts — users don't customize)
+  const hooksSrc = path.join(bundleDir, "src", "hooks");
+  if (fs.existsSync(hooksSrc) && selectedIds.some((id) => expandTargetIds([id]).includes("claude-code"))) {
+    const hooksDest = path.join(home, ".claude", "hooks");
+    fs.mkdirSync(hooksDest, { recursive: true });
+    for (const file of fs.readdirSync(hooksSrc).filter((f) => f.endsWith(".sh"))) {
+      fs.copyFileSync(path.join(hooksSrc, file), path.join(hooksDest, file));
+      try { fs.chmodSync(path.join(hooksDest, file), 0o755); } catch {}
+      appliedCount++;
     }
+    statusLine("ok", "Hooks", `${appliedCount} updated`);
   }
 
-  // Step 8: Apply Changes (with progress animation)
-  barLn();
-  question(bold("Applying updates"));
-  barLn();
-
-  const installSteps = [];
-  installSteps.push({ label: "Vault structure", fn: async () => { createVaultStructure(vaultPath); await sleep(100); } });
-  if (!skipTemplates) {
-    installSteps.push({ label: "Template files", fn: async () => { installTemplateFiles(bundleDir, vaultPath); await sleep(100); } });
+  // Statusline (single JS file — no user data)
+  const slSrc = path.join(bundleDir, "src", "hooks", "statusline.js");
+  const slDest = path.join(home, ".claude", "statusline.js");
+  if (fs.existsSync(slSrc)) {
+    fs.copyFileSync(slSrc, slDest);
+    // Ensure settings.json has statusLine config
+    const globalSettings = path.join(home, ".claude", "settings.json");
+    try {
+      const settings = fs.existsSync(globalSettings)
+        ? JSON.parse(fs.readFileSync(globalSettings, "utf8"))
+        : {};
+      if (!settings.statusLine) {
+        settings.statusLine = { type: "command", command: "node ~/.claude/statusline.js" };
+        fs.writeFileSync(globalSettings, JSON.stringify(settings, null, 2), "utf8");
+      }
+    } catch {}
+    statusLine("ok", "Statusline", "updated");
+    appliedCount++;
   }
 
-  const writtenFiles = new Set();
-  const skillOpts = { install: true, categories: null, workflows: selectedWorkflows, skipHooks, skipRules, skipTemplates, statusLine: changes.statusline !== "unchanged" };
-  for (const agent of selectedAgents) {
-    const sel = AGENT_SELECTIONS.find((s) => s.id === agent.id);
-    const targets = sel ? sel.targets : [agent.id];
-    for (const targetId of targets) {
-      const fn = AGENT_INSTALLERS[targetId];
-      if (!fn) continue;
-      const targetReg = AGENT_REGISTRY[targetId];
-      const displayName = targetReg ? targetReg.name : agent.name;
-      installSteps.push({ label: displayName, fn: async () => { fn(bundleDir, vaultPath, skillOpts, writtenFiles, targetId); await sleep(150); } });
-    }
-  }
+  // Vault structure + templates (safe scaffolding)
+  createVaultStructure(vaultPath);
+  installTemplateFiles(bundleDir, vaultPath);
 
-  await installProgress(installSteps);
+  // Update version marker
+  fs.writeFileSync(path.join(vaultPath, ".mover-version"), `${require("./package.json").version}\n`, "utf8");
+
+  // Stage confirmation for user-customizable files
+  const userFileChanges = changes.workflows.filter((f) => f.status !== "unchanged").length
+    + (changes.rules === "changed" ? 1 : 0)
+    + (changes.skills || []).filter((f) => f.status !== "unchanged").length;
 
-  // Step 9: Skills Refresh
   barLn();
-  const allSkills = findSkills(bundleDir);
-  if (allSkills.length > 0 && selectedAgents.some((a) => a.id !== "aider")) {
-    question("Refresh skill categories?");
-    barLn();
-    const catCounts = {};
-    for (const sk of allSkills) { catCounts[sk.category] = (catCounts[sk.category] || 0) + 1; }
-    const categoryItems = CATEGORY_META.map((c) => ({
-      id: c.id,
-      name: `${c.name}  ${dim(`(${catCounts[c.id] || 0})`)}`,
-      tier: dim(c.desc),
-    }));
-    const selectedCatIds = await interactiveSelect(categoryItems, { multi: true, preSelected: ["development", "obsidian"] });
-    if (selectedCatIds && selectedCatIds.length > 0) {
-      const catSet = new Set(selectedCatIds);
-      const refreshOpts = { install: true, categories: catSet, workflows: null };
-      for (const agent of selectedAgents) {
-        const sel = AGENT_SELECTIONS.find((s) => s.id === agent.id);
-        const targets = sel ? sel.targets : [agent.id];
-        for (const targetId of targets) {
-          const fn = AGENT_INSTALLERS[targetId];
-          if (fn) fn(bundleDir, vaultPath, refreshOpts, writtenFiles, targetId);
-        }
-      }
-      const skillCount = allSkills.filter((s) => s.category === "tools" || catSet.has(s.category)).length;
-      statusLine("ok", "Skills refreshed", `${skillCount} across ${selectedAgents.length} agent(s)`);
-    }
+  if (userFileChanges > 0) {
+    statusLine("ok", "Staged", `${userFileChanges} workflow/rule/skill updates at ${dim("~/.mover/src/")}`);
     barLn();
+    barLn(bold("  Next step:"));
+    barLn(`  Run ${bold("/update")} in your AI agent to apply workflow & rule changes.`);
+    barLn(dim("  Your customizations will be preserved — new version is the base,"));
+    barLn(dim("  your additions get carried forward."));
+  } else {
+    statusLine("ok", "System files", "all updated");
   }
-
-  // Update version marker + config
-  fs.writeFileSync(path.join(vaultPath, ".mover-version"), `${require("./package.json").version}\n`, "utf8");
-  writeMoverConfig(vaultPath, selectedIds, updateKey);
-
-  // Step 10: Summary + Success
   barLn();
-  await successAnimation(`Mover OS updated — ${totalChanged} files`);
-
   const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
-  outro(`${green("Done.")} ${dim(`${elapsed}s`)}  Run ${bold("/update")} in your agent to sync Engine.`);
+  if (userFileChanges > 0) {
+    outro(`System updated. Run ${bold("/update")} for workflows & rules. ${dim(`(${elapsed}s)`)}`);
+  } else {
+    outro(`${green("Done.")} All files up to date. ${dim(`(${elapsed}s)`)}`);
+  }
 }
 
 // ─── Vault Resolution Helper ─────────────────────────────────────────────────
@@ -5437,20 +5385,26 @@ async function main() {
       } else if (method === "fetch") {
         barLn();
         const city = await textInput({ label: "City (e.g. London, Watford, Istanbul)", placeholder: "London" });
-        const country = city ? await textInput({ label: "Country", placeholder: "United Kingdom" }) : null;
-        barLn();
-
-        if (city && country) {
-          const sp = spinner("Fetching prayer times");
-          const tt = await fetchPrayerTimes(city.trim(), country.trim());
-          if (tt && Object.keys(tt.times).length > 0) {
-            const ttPath = path.join(moverDir, "prayer-timetable.json");
-            fs.writeFileSync(ttPath, JSON.stringify(tt, null, 2), "utf8");
-            sp.stop(`Prayer times  ${dim(`${Object.keys(tt.times).length} days from aladhan.com`)}`);
-            barLn(dim("  Note: these are calculated adhan times, not mosque jama'ah times."));
-            barLn(dim("  For your mosque's specific times, run: moveros prayer"));
+        if (!city || !city.trim()) {
+          barLn(yellow("  City cannot be empty. Run moveros prayer later to set up."));
+        } else {
+          const country = await textInput({ label: "Country", placeholder: "United Kingdom" });
+          if (!country || !country.trim()) {
+            barLn(yellow("  Country cannot be empty. Run moveros prayer later to set up."));
           } else {
-            sp.stop(yellow("Could not fetch. Run moveros prayer later."));
+            barLn();
+            const sp = spinner("Fetching prayer times");
+            const tt = await fetchPrayerTimes(city.trim(), country.trim());
+            if (tt && Object.keys(tt.times).length > 0) {
+              const ttPath = path.join(moverDir, "prayer-timetable.json");
+              fs.writeFileSync(ttPath, JSON.stringify(tt, null, 2), "utf8");
+              sp.stop(`Prayer times  ${dim(`${Object.keys(tt.times).length} days from aladhan.com`)}`);
+              barLn(dim("  Note: these are calculated adhan times, not mosque jama'ah times."));
+              barLn(dim("  For your mosque's specific times, run: moveros prayer"));
+            } else {
+              sp.stop(yellow("Could not fetch prayer times."));
+              barLn(yellow("  Check city/country spelling. Run moveros prayer later to retry."));
+            }
           }
         }
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mover-os",
-  "version": "4.5.3",
+  "version": "4.5.5",
   "description": "The self-improving OS for AI agents. Turns Obsidian into an execution engine.",
   "bin": {
     "moveros": "install.js"