mover-os 4.3.2 → 4.4.0

package/README.md

@@ -6,7 +6,7 @@
 
 Mover OS turns Obsidian into an AI-powered execution engine. It audits your behavior against your stated strategy, extracts reusable knowledge from daily work, and evolves based on your corrections.
 
-**Works best with Claude Code.** Supports 13 AI coding agents.
+**Works best with Claude Code.** Supports 14 AI coding agents.
 
 **Version:** 4.3 | **Status:** Production
 
@@ -22,7 +22,7 @@ Mover OS turns Obsidian into an AI-powered execution engine. It audits your beha
 - **Escalating Friction** — 4 levels of pushback when you drift from your plan. Speed bumps, not walls.
 - **Correction Lifecycle** — Correct the AI and it proposes a fix, waits for approval, and updates its own rules.
 - **Entity Memory** — Remembers people, organizations, and decisions across sessions.
-- **22 Connected Workflows** — Each one hands off to the next. You never wonder what to do next.
+- **23 Connected Workflows** — Each one hands off to the next. You never wonder what to do next.
 
 ---
 
@@ -91,7 +91,7 @@ bash src/install/link.sh
 
 ## Supported Agents
 
-Works with **13 AI coding agents.** The installer auto-detects and configures each one:
+Works with **14 AI coding agents.** The installer auto-detects and configures each one:
 
 | Agent | What Gets Installed |
 |-------|---------------------|

package/install.js

@@ -58,15 +58,34 @@ const red = (s) => `${S.red}${s}${S.reset}`;
 const gray = (s) => `${S.gray}${s}${S.reset}`;
 const strip = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
 
-// Gradient text using 256-color palette (white → gray, matching website monochrome theme)
-const GRADIENT = [255, 255, 254, 253, 252, 251, 250, 249, 248, 247];
-function gradient(text) {
+// Gradient text using 256-color palette
+const GRADIENT_COOL = [39, 38, 44, 43, 49, 48, 84, 83, 119, 118]; // cyan → green sweep
+const GRADIENT_WARM = [255, 254, 253, 252, 251, 250, 249, 248, 247, 246]; // white → gray
+function gradient(text, palette = GRADIENT_WARM) {
   if (!IS_TTY) return text;
   const chars = [...text];
   return chars.map((ch, i) => {
     if (ch === " ") return ch;
-    const idx = Math.floor((i / Math.max(chars.length - 1, 1)) * (GRADIENT.length - 1));
-    return `${S.fg(GRADIENT[idx])}${ch}`;
+    const idx = Math.floor((i / Math.max(chars.length - 1, 1)) * (palette.length - 1));
+    return `${S.fg(palette[idx])}${ch}`;
+  }).join("") + S.reset;
+}
+
+// Animated gradient that sweeps a color wave across text
+function waveGradient(text, frame, totalFrames) {
+  if (!IS_TTY) return text;
+  const wave = [240, 244, 248, 252, 255, 255, 252, 248, 244, 240]; // dim → bright → dim
+  const chars = [...text];
+  const waveWidth = wave.length;
+  const progress = frame / totalFrames;
+  const waveCenter = Math.floor(progress * (chars.length + waveWidth)) - waveWidth / 2;
+  return chars.map((ch, i) => {
+    if (ch === " ") return ch;
+    const dist = i - waveCenter;
+    if (dist >= 0 && dist < waveWidth) {
+      return `${S.fg(wave[dist])}${ch}`;
+    }
+    return `${S.fg(240)}${ch}`; // dim base color
   }).join("") + S.reset;
 }
 
@@ -100,16 +119,70 @@ const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 async function printHeader(animate = IS_TTY) {
   ln();
   if (animate) {
-    // Animated logo reveal — line by line with gradient cascade
-    for (let i = 0; i < LOGO.length; i++) {
-      ln(gradient(LOGO[i]));
-      await sleep(30);
+    // Phase 1: Print logo dim (instant base)
+    for (const line of LOGO) {
+      ln(`${S.fg(236)}${line}${S.reset}`);
+    }
+
+    // Phase 2: Shine sweep — a bright band sweeps left to right across all lines
+    const maxLen = Math.max(...LOGO.map((l) => l.length));
+    const totalFrames = 24;
+    const shineWidth = 8; // width of the bright band
+    const trailLen = maxLen; // trail fills behind the shine
+
+    for (let frame = 0; frame <= totalFrames; frame++) {
+      w(`\x1b[${LOGO.length}A`);
+      const progress = frame / totalFrames;
+      // Shine position sweeps from left edge to past right edge
+      const shinePos = Math.floor(progress * (maxLen + shineWidth + 4)) - shineWidth;
+
+      for (const line of LOGO) {
+        const chars = [...line];
+        const rendered = chars.map((ch, ci) => {
+          if (ch === " ") return ch;
+          const relPos = ci - shinePos;
+          // Bright core of shine
+          if (relPos >= 0 && relPos < 2) return `${S.bold}${S.fg(255)}${ch}${S.reset}`;
+          if (relPos >= 2 && relPos < 4) return `${S.fg(255)}${ch}`;
+          if (relPos >= 4 && relPos < shineWidth) return `${S.fg(250)}${ch}`;
+          // Glow ahead of shine
+          if (relPos >= shineWidth && relPos < shineWidth + 3) return `${S.fg(244)}${ch}`;
+          // Trail behind shine — settled bright
+          if (relPos < 0 && ci < shinePos) return `${S.fg(251)}${ch}`;
+          // Not yet reached
+          return `${S.fg(236)}${ch}`;
+        }).join("") + S.reset;
+        w(`\x1b[2K${rendered}\n`);
+      }
+      await sleep(20);
+    }
+
+    // Phase 3: Final settle — clean gradient
+    w(`\x1b[${LOGO.length}A`);
+    for (const line of LOGO) {
+      w(`\x1b[2K${gradient(line)}\n`);
     }
   } else {
     for (const line of LOGO) ln(gradient(line));
   }
   ln();
-  ln(`  ${dim(`v${VERSION}`)}  ${gray("the agentic operating system for obsidian")}`);
+
+  // Compact info line
+  let infoRight = "";
+  try {
+    const cfgPath = path.join(os.homedir(), ".mover", "config.json");
+    if (fs.existsSync(cfgPath)) {
+      const cfg = JSON.parse(fs.readFileSync(cfgPath, "utf8"));
+      const vaultName = cfg.vaultPath ? path.basename(cfg.vaultPath) : null;
+      const agentCount = (cfg.agents || []).length;
+      const parts = [];
+      if (vaultName) parts.push(vaultName);
+      if (agentCount > 0) parts.push(`${agentCount} agent${agentCount > 1 ? "s" : ""}`);
+      if (parts.length > 0) infoRight = gray(parts.join(" · "));
+    }
+  } catch {}
+
+  ln(`  ${dim(`v${VERSION}`)}  ${gray("the agentic operating system for obsidian")}${infoRight ? `  ${infoRight}` : ""}`);
   ln();
   ln(gray("  ─────────────────────────────────────────────"));
   ln();
@@ -304,12 +377,26 @@ function interactiveSelect(items, { multi = false, preSelected = [], defaultInde
     const selected = new Set(preSelected);
     let prevLines = 0;
 
+    // Build list of selectable indices (skip separators)
+    const selectableIndices = items.map((item, i) => item._separator ? -1 : i).filter((i) => i >= 0);
+    let selectPos = selectableIndices.indexOf(defaultIndex);
+    if (selectPos < 0) selectPos = 0;
+    cursor = selectableIndices[selectPos] || 0;
+
     const render = () => {
       if (prevLines > 0) w(`\x1b[${prevLines}A`);
 
       let lines = 0;
       for (let i = 0; i < items.length; i++) {
         const item = items[i];
+
+        // Separator: render as category header
+        if (item._separator) {
+          w(`\x1b[2K${BAR_COLOR}│${S.reset}  ${dim(item.name)}\n`);
+          lines++;
+          continue;
+        }
+
         const active = i === cursor;
         const checked = selected.has(item.id);
 
@@ -344,8 +431,8 @@ function interactiveSelect(items, { multi = false, preSelected = [], defaultInde
     render();
 
     const handler = (data) => {
-      if (data === "\x1b[A") { cursor = (cursor - 1 + items.length) % items.length; }
-      else if (data === "\x1b[B") { cursor = (cursor + 1) % items.length; }
+      if (data === "\x1b[A") { selectPos = (selectPos - 1 + selectableIndices.length) % selectableIndices.length; cursor = selectableIndices[selectPos]; }
+      else if (data === "\x1b[B") { selectPos = (selectPos + 1) % selectableIndices.length; cursor = selectableIndices[selectPos]; }
       else if (data === " " && multi) {
         const id = items[cursor].id;
         if (selected.has(id)) selected.delete(id);
@@ -552,6 +639,8 @@ const CLI_COMMANDS = {
   settings: { desc: "View/edit config",                          alias: [] },
   backup:   { desc: "Manual backup wizard",                      alias: [] },
   restore:  { desc: "Restore from backup",                       alias: [] },
+  prayer:   { desc: "Manage prayer times",                        alias: [] },
+  help:     { desc: "Interactive guide to Mover OS",              alias: ["-h"] },
   test:     { desc: "Run integration tests (dev)",               alias: [], hidden: true },
 };
 
@@ -1512,14 +1601,155 @@ function generateClaudeSettings() {
   );
 }
 
+// ─── Prayer timetable helpers ───────────────────────────────────────────────
+
+function parsePrayerTimetable(lines) {
+  // Parse user-pasted mosque timetable into date-keyed JSON
+  // Supports various formats:
+  //   2026-03-08  05:20  13:00  16:15  18:01  19:45
+  //   March 8: Fajr 05:20, Dhuhr 13:00, ...
+  //   Tab/comma separated tables from spreadsheets
+  const times = {};
+  const prayerNames = ["fajr", "dhuhr", "asr", "maghrib", "isha"];
+  const monthNames = { jan: 1, feb: 2, mar: 3, apr: 4, may: 5, jun: 6, jul: 7, aug: 8, sep: 9, oct: 10, nov: 11, dec: 12,
+    january: 1, february: 2, march: 3, april: 4, june: 6, july: 7, august: 8, september: 9, october: 10, november: 11, december: 12 };
+  const currentYear = new Date().getFullYear();
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.toLowerCase() === "done") continue;
+
+    // Try ISO date format: 2026-03-08 ...
+    const isoMatch = trimmed.match(/^(\d{4}-\d{2}-\d{2})\s+(.+)/);
+    if (isoMatch) {
+      const dateKey = isoMatch[1];
+      const timeValues = isoMatch[2].match(/\d{1,2}:\d{2}/g);
+      if (timeValues && timeValues.length >= 5) {
+        times[dateKey] = {};
+        for (let i = 0; i < Math.min(5, timeValues.length); i++) {
+          times[dateKey][prayerNames[i]] = timeValues[i];
+        }
+      }
+      continue;
+    }
+
+    // Try month name format: March 8: ... or 8 March: ...
+    const monthMatch = trimmed.match(/(?:(\d{1,2})\s+)?(\w+)\s*(\d{1,2})?\s*[:\s]\s*(.+)/i);
+    if (monthMatch) {
+      const mName = monthMatch[2].toLowerCase();
+      const monthNum = monthNames[mName];
+      if (monthNum) {
+        const day = parseInt(monthMatch[1] || monthMatch[3]);
+        if (day >= 1 && day <= 31) {
+          const dateKey = `${currentYear}-${String(monthNum).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+          const timeValues = monthMatch[4].match(/\d{1,2}:\d{2}/g);
+          if (timeValues && timeValues.length >= 5) {
+            times[dateKey] = {};
+            for (let i = 0; i < Math.min(5, timeValues.length); i++) {
+              times[dateKey][prayerNames[i]] = timeValues[i];
+            }
+          }
+        }
+      }
+      continue;
+    }
+
+    // Try pure time extraction from tab/comma separated
+    const timeValues = trimmed.match(/\d{1,2}:\d{2}/g);
+    if (timeValues && timeValues.length >= 5) {
+      // Look for a date number at the start
+      const dayMatch = trimmed.match(/^(\d{1,2})\D/);
+      if (dayMatch) {
+        const day = parseInt(dayMatch[1]);
+        if (day >= 1 && day <= 31) {
+          // Best guess: current month
+          const now = new Date();
+          const dateKey = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+          times[dateKey] = {};
+          for (let i = 0; i < Math.min(5, timeValues.length); i++) {
+            times[dateKey][prayerNames[i]] = timeValues[i];
+          }
+        }
+      }
+    }
+  }
+
+  return {
+    mosque: "Custom",
+    type: "jamaah",
+    note: "Paste your mosque's yearly timetable into Claude and ask it to convert to this format.",
+    times,
+  };
+}
+
+async function fetchPrayerTimes(city, country) {
+  // Fetch 12 months of prayer times from aladhan.com API
+  const https = require("https");
+  const year = new Date().getFullYear();
+  const allTimes = {};
+
+  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) => {
+          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);
+      if (json.code === 200 && json.data) {
+        for (const day of json.data) {
+          const t = day.timings;
+          const d = day.date.gregorian;
+          const dateKey = `${d.year}-${d.month.number.toString().padStart(2, "0")}-${d.day.padStart(2, "0")}`;
+          allTimes[dateKey] = {
+            fajr: t.Fajr.replace(/\s*\(.*\)/, ""),
+            dhuhr: t.Dhuhr.replace(/\s*\(.*\)/, ""),
+            asr: t.Asr.replace(/\s*\(.*\)/, ""),
+            maghrib: t.Maghrib.replace(/\s*\(.*\)/, ""),
+            isha: t.Isha.replace(/\s*\(.*\)/, ""),
+          };
+        }
+      }
+    } catch {
+      // Skip failed months — partial data is still useful
+    }
+  }
+
+  return {
+    mosque: `Calculated (${city}, ${country})`,
+    type: "adhan",
+    note: "Calculated adhan times from aladhan.com. For mosque jama'ah times, run: moveros prayer",
+    city,
+    country,
+    times: allTimes,
+  };
+}
+
 // ─── .gitignore ─────────────────────────────────────────────────────────────
 function generateGitignore() {
-  return `# Mover OS — protected from git
-02_Areas/Engine/Dailies/
-02_Areas/Engine/Weekly Reviews/
-.obsidian/
-.trash/
-dev/
+  return `# Mover OS Engine — track core files only
+# Ignore everything by default
+*
+
+# Track core Engine files
+!.gitignore
+!Identity_Prime.md
+!Strategy.md
+!Active_Context.md
+!Goals.md
+!Auto_Learnings.md
+!Mover_Dossier.md
+!Metrics_Log.md
+!Voice_DNA.md
+!Daily_Template.md
+!Someday_Maybe.md
 `;
 }
 
@@ -1553,7 +1783,7 @@ function createVaultStructure(vaultPath) {
   return created;
 }
 
-function writeMoverConfig(vaultPath, agentIds, licenseKey) {
+function writeMoverConfig(vaultPath, agentIds, licenseKey, opts = {}) {
   const configDir = path.join(os.homedir(), ".mover");
   if (!fs.existsSync(configDir)) fs.mkdirSync(configDir, { recursive: true, mode: 0o700 });
   const configPath = path.join(configDir, "config.json");
@@ -1566,7 +1796,7 @@ function writeMoverConfig(vaultPath, agentIds, licenseKey) {
     installedAt: new Date().toISOString(),
   };
   if (licenseKey) config.licenseKey = licenseKey;
-  // If config exists, preserve installedAt and licenseKey from original install
+  // If config exists, preserve existing values
   if (fs.existsSync(configPath)) {
     try {
       const existing = JSON.parse(fs.readFileSync(configPath, "utf8"));
@@ -1575,9 +1805,18 @@ function writeMoverConfig(vaultPath, agentIds, licenseKey) {
       if (existing.feedbackWebhook) config.feedbackWebhook = existing.feedbackWebhook;
       if (existing.track_food !== undefined) config.track_food = existing.track_food;
       if (existing.track_sleep !== undefined) config.track_sleep = existing.track_sleep;
+      // Preserve settings block (prayer times, review_day, etc.)
+      if (existing.settings) config.settings = { ...existing.settings };
+      // Preserve prayer_times fallback
+      if (existing.prayer_times) config.prayer_times = existing.prayer_times;
       config.updatedAt = new Date().toISOString();
     } catch {}
   }
+  // Apply prayer setup from installer
+  if (opts.prayerSetup) {
+    if (!config.settings) config.settings = {};
+    config.settings.show_prayer_times = true;
+  }
   fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
   return configPath;
 }
@@ -2442,6 +2681,8 @@ const CLI_HANDLERS = {
   backup:   async (opts) => { await cmdBackup(opts); },
   restore:  async (opts) => { await cmdRestore(opts); },
   doctor:   async (opts) => { await cmdDoctor(opts); },
+  prayer:   async (opts) => { await cmdPrayer(opts); },
+  help:     async (opts) => { await cmdHelp(opts); },
   test:     async (opts) => { await cmdTest(opts); },
 };
 
@@ -2515,10 +2756,20 @@ async function cmdDoctor(opts) {
     statusLine(allOk ? "ok" : "warn", `  ${reg.name}`, checks.join(", "));
   }
 
-  // Git
+  // Engine Git
   barLn();
-  const hasGit = fs.existsSync(path.join(vault, ".git"));
-  statusLine(hasGit ? "ok" : "info", "Git", hasGit ? "initialized" : "not a git repo");
+  const engineGit = fs.existsSync(path.join(engineDir, ".git"));
+  statusLine(engineGit ? "ok" : "warn", "Engine Git", engineGit ? "initialized" : "not version controlled — run moveros install to fix");
+
+  // Engine gitignore
+  const engineGitignore = path.join(engineDir, ".gitignore");
+  if (engineGit && fs.existsSync(engineGitignore)) {
+    const gi = fs.readFileSync(engineGitignore, "utf8");
+    const isWhitelist = gi.includes("*") && gi.includes("!Identity_Prime.md");
+    statusLine(isWhitelist ? "ok" : "warn", "Engine .gitignore", isWhitelist ? "whitelist (core files only)" : "legacy format — re-run moveros install");
+  } else if (engineGit) {
+    statusLine("warn", "Engine .gitignore", "missing");
+  }
 
   barLn();
   barLn(dim("  Run moveros install or moveros update to fix any issues."));
@@ -2846,13 +3097,23 @@ async function cmdDiff(opts) {
     return;
   }
 
+  // Determine git root — Engine files use Engine's own repo
+  const engineDir = path.join(vault, "02_Areas", "Engine");
+  const isEngineFile = relPath.startsWith("02_Areas/Engine/") || relPath.startsWith("02_Areas\\Engine\\");
+  const gitCwd = isEngineFile && fs.existsSync(path.join(engineDir, ".git"))
+    ? engineDir
+    : vault;
+  const gitRelPath = isEngineFile && gitCwd === engineDir
+    ? path.basename(relPath)
+    : relPath;
+
   barLn(bold(`  ${path.basename(relPath)} — last ${days} days`));
   barLn();
 
   try {
     const log = execSync(
-      `git log --since="${days} days ago" --oneline --follow -- "${relPath}"`,
-      { cwd: vault, encoding: "utf8", timeout: 10000 }
+      `git log --since="${days} days ago" --oneline --follow -- "${gitRelPath}"`,
+      { cwd: gitCwd, encoding: "utf8", timeout: 10000 }
     ).trim();
 
     if (!log) {
@@ -3011,40 +3272,67 @@ async function cmdContext(opts) {
 
   const target = opts.rest[0];
   const home = os.homedir();
+  const cfgPath = path.join(home, ".mover", "config.json");
+  const agents = fs.existsSync(cfgPath)
+    ? (JSON.parse(fs.readFileSync(cfgPath, "utf8")).agents || [])
+    : [];
 
   if (!target) {
-    // Show all agents
-    barLn(bold("  Agent Context Overview"));
+    // Overview: show what each agent actually loads
+    barLn(bold("  What Your Agents See"));
     barLn();
-    const cfgPath = path.join(home, ".mover", "config.json");
-    const agents = fs.existsSync(cfgPath)
-      ? (JSON.parse(fs.readFileSync(cfgPath, "utf8")).agents || [])
-      : [];
 
     for (const agentId of agents) {
       const reg = AGENT_REGISTRY[agentId];
       if (!reg) continue;
-      let totalBytes = 0, fileCount = 0;
 
-      const countDir = (dir) => {
-        if (!fs.existsSync(dir)) return;
-        try {
-          for (const f of fs.readdirSync(dir, { withFileTypes: true })) {
-            if (f.isFile()) { totalBytes += fs.statSync(path.join(dir, f.name)).size; fileCount++; }
-            else if (f.isDirectory()) countDir(path.join(dir, f.name));
+      const parts = [];
+      let totalBytes = 0;
+
+      // Rules
+      if (reg.rules) {
+        const rp = reg.rules.dest(vault);
+        if (fs.existsSync(rp)) {
+          const sz = fs.statSync(rp).size;
+          totalBytes += sz;
+          parts.push(`rules ${dim(`${(sz / 1024).toFixed(0)}KB`)}`);
+        } else { parts.push(red("rules missing")); }
+      }
+
+      // Skills
+      if (reg.skills) {
+        const sp = reg.skills.dest(vault);
+        if (fs.existsSync(sp)) {
+          const skills = fs.readdirSync(sp, { withFileTypes: true }).filter((d) => d.isDirectory());
+          let skillBytes = 0;
+          for (const sk of skills) {
+            const sm = path.join(sp, sk.name, "SKILL.md");
+            if (fs.existsSync(sm)) skillBytes += fs.statSync(sm).size;
           }
-        } catch {}
-      };
+          totalBytes += skillBytes;
+          parts.push(`${skills.length} skills ${dim(`${(skillBytes / 1024).toFixed(0)}KB`)}`);
+        }
+      }
+
+      // Commands
+      if (reg.commands) {
+        const cp = reg.commands.dest(vault);
+        if (fs.existsSync(cp)) {
+          const cmds = fs.readdirSync(cp).filter((f) => f.endsWith(".md") || f.endsWith(".toml") || f.endsWith(".json"));
+          if (cmds.length > 0) parts.push(`${cmds.length} commands`);
+        }
+      }
 
-      if (reg.rules) { const rp = reg.rules.dest(vault); if (fs.existsSync(rp)) { totalBytes += fs.statSync(rp).size; fileCount++; } }
-      if (reg.skills) countDir(reg.skills.dest(vault));
-      if (reg.commands) countDir(reg.commands.dest(vault));
+      // Hooks
+      if (reg.hooks) parts.push(`${reg.hooks.events?.length || "?"} hook events`);
 
-      const tokens = Math.round(totalBytes / 4); // rough estimate: 4 bytes per token
-      const kb = (totalBytes / 1024).toFixed(1);
-      barLn(`  ${reg.name.padEnd(20)} ${String(fileCount).padStart(3)} files  ${String(kb).padStart(6)} KB  ~${tokens.toLocaleString()} tokens`);
+      const tokens = Math.round(totalBytes / 4);
+      const tokenWarn = tokens > 40000 ? red("heavy") : tokens > 20000 ? yellow("moderate") : green("lean");
+      barLn(`  ${bold(reg.name.padEnd(18))} ${parts.join(dim(" · "))}  ${dim("~")}${tokens.toLocaleString()} tok ${tokenWarn}`);
     }
     barLn();
+    barLn(dim("  Detail: moveros context <agent>"));
+    barLn();
     return;
   }
 
@@ -3052,43 +3340,249 @@ async function cmdContext(opts) {
   const reg = AGENT_REGISTRY[target] || Object.values(AGENT_REGISTRY).find((r) => r.name.toLowerCase().includes(target.toLowerCase()));
   if (!reg) { barLn(yellow(`  Unknown agent: ${target}`)); return; }
 
-  barLn(bold(`  ${reg.name} Context`));
+  barLn(bold(`  ${reg.name}`));
+  barLn(dim(`  Tier: ${reg.tier || "unknown"}`));
   barLn();
 
+  // Rules — show actual file path and key sections
   if (reg.rules) {
     const rp = reg.rules.dest(vault);
     if (fs.existsSync(rp)) {
-      const size = fs.statSync(rp).size;
-      statusLine("ok", "Rules", `${(size / 1024).toFixed(1)} KB  ${rp}`);
+      const content = fs.readFileSync(rp, "utf8");
+      const sz = Buffer.byteLength(content);
+      statusLine("ok", "Rules", `${(sz / 1024).toFixed(1)} KB`);
+      barLn(dim(`         ${rp}`));
+      // Show top-level headings as table of contents
+      const headings = content.match(/^## .+$/gm) || [];
+      if (headings.length > 0) {
+        barLn(dim("         Sections:"));
+        for (const h of headings.slice(0, 12)) barLn(dim(`           ${h.replace(/^## /, "")}`));
+        if (headings.length > 12) barLn(dim(`           ...+${headings.length - 12} more`));
+      }
     } else {
-      statusLine("fail", "Rules", "not found");
+      statusLine("fail", "Rules", "not installed");
     }
   }
 
+  // Skills — list actual skill names with trigger descriptions
   if (reg.skills) {
     const sp = reg.skills.dest(vault);
+    barLn();
     if (fs.existsSync(sp)) {
-      const skills = fs.readdirSync(sp, { withFileTypes: true }).filter((d) => d.isDirectory());
+      const skillDirs = fs.readdirSync(sp, { withFileTypes: true }).filter((d) => d.isDirectory());
       let totalChars = 0;
-      for (const sk of skills) {
+      const skillList = [];
+      for (const sk of skillDirs) {
         const sm = path.join(sp, sk.name, "SKILL.md");
-        if (fs.existsSync(sm)) totalChars += fs.statSync(sm).size;
+        if (fs.existsSync(sm)) {
+          const sc = fs.readFileSync(sm, "utf8");
+          totalChars += sc.length;
+          // Extract first line of description
+          const descMatch = sc.match(/^description:\s*["']?(.+?)["']?\s*$/m);
+          const desc = descMatch ? descMatch[1].slice(0, 55) : "";
+          skillList.push({ name: sk.name, desc });
+        }
+      }
+      statusLine("ok", "Skills", `${skillList.length} packs  (${(totalChars / 1024).toFixed(0)} KB descriptions)`);
+      for (const s of skillList) {
+        barLn(`         ${s.name.padEnd(25)} ${dim(s.desc)}`);
       }
-      statusLine("ok", "Skills", `${skills.length} packs  ${(totalChars / 1024).toFixed(1)} KB descriptions`);
     } else {
       statusLine("info", "Skills", "none installed");
     }
   }
 
+  // Commands — list actual command names
   if (reg.commands) {
     const cp = reg.commands.dest(vault);
+    barLn();
     if (fs.existsSync(cp)) {
       const files = fs.readdirSync(cp).filter((f) => !f.startsWith("."));
-      statusLine("ok", "Commands", `${files.length} files`);
+      statusLine("ok", "Commands", `${files.length} loaded`);
+      const cols = 4;
+      for (let i = 0; i < files.length; i += cols) {
+        const row = files.slice(i, i + cols).map((f) => f.replace(/\.(md|toml|json)$/, "").padEnd(18)).join(" ");
+        barLn(`         ${dim(row)}`);
+      }
     } else {
       statusLine("info", "Commands", "none installed");
     }
   }
+
+  // Hooks
+  if (reg.hooks) {
+    barLn();
+    statusLine("ok", "Hooks", `${reg.hooks.events?.length || 0} events`);
+    if (reg.hooks.events) barLn(dim(`         ${reg.hooks.events.join(", ")}`));
+  }
+
+  // Token budget summary
+  barLn();
+  let total = 0;
+  if (reg.rules) { const rp = reg.rules.dest(vault); if (fs.existsSync(rp)) total += fs.statSync(rp).size; }
+  if (reg.skills) {
+    const sp = reg.skills.dest(vault);
+    if (fs.existsSync(sp)) {
+      for (const sk of fs.readdirSync(sp, { withFileTypes: true }).filter((d) => d.isDirectory())) {
+        const sm = path.join(sp, sk.name, "SKILL.md");
+        if (fs.existsSync(sm)) total += fs.statSync(sm).size;
+      }
+    }
+  }
+  const tokens = Math.round(total / 4);
+  const pct = Math.round((tokens / 200000) * 100);
+  barLn(`  ${dim("Total context load:")} ~${tokens.toLocaleString()} tokens ${dim(`(${pct}% of 200K window)`)}`);
+  if (pct > 20) barLn(yellow(`  Warning: heavy context load may slow agent startup`));
+  barLn();
+}
+
+// ─── moveros prayer ─────────────────────────────────────────────────────────
+async function cmdPrayer(opts) {
+  const home = os.homedir();
+  const moverDir = path.join(home, ".mover");
+  const cfgPath = path.join(moverDir, "config.json");
+  const ttPath = path.join(moverDir, "prayer-timetable.json");
+
+  if (!fs.existsSync(moverDir)) fs.mkdirSync(moverDir, { recursive: true, mode: 0o700 });
+
+  // Show current state
+  barLn(bold("  Prayer Times"));
+  barLn();
+
+  let cfg = {};
+  if (fs.existsSync(cfgPath)) {
+    try { cfg = JSON.parse(fs.readFileSync(cfgPath, "utf8")); } catch {}
+  }
+
+  const enabled = cfg.settings?.show_prayer_times;
+  let tt = null;
+  if (fs.existsSync(ttPath)) {
+    try { tt = JSON.parse(fs.readFileSync(ttPath, "utf8")); } catch {}
+  }
+
+  if (tt && Object.keys(tt.times || {}).length > 0) {
+    statusLine("ok", "Source", `${tt.mosque || "Custom"} (${tt.type || "unknown"})`);
+    statusLine("ok", "Days", `${Object.keys(tt.times).length} entries`);
+
+    // Show today's times
+    const now = new Date();
+    const todayKey = `${now.getFullYear()}-${String(now.getMonth()+1).padStart(2,"0")}-${String(now.getDate()).padStart(2,"0")}`;
+    const today = tt.times[todayKey];
+    if (today) {
+      const nowMins = now.getHours() * 60 + now.getMinutes();
+      barLn();
+      barLn(dim("  Today:"));
+      for (const [name, time] of Object.entries(today)) {
+        const [h, m] = time.split(":").map(Number);
+        const pMins = h * 60 + m;
+        const isPast = pMins < nowMins;
+        const isNext = !isPast && pMins - nowMins < 60;
+        const icon = isPast ? dim("\u2713") : isNext ? yellow("\u25B8") : dim("\u25CB");
+        const fmt = isPast ? dim : isNext ? yellow : (s) => s;
+        barLn(`    ${icon} ${fmt(name.padEnd(10) + " " + time)}`);
+      }
+    } else {
+      barLn(yellow(`  No times for ${todayKey}. Timetable may need updating.`));
+    }
+  } else {
+    statusLine("warn", "Timetable", "not set up");
+  }
+
+  statusLine(enabled ? "ok" : "warn", "Status", enabled ? "enabled" : "disabled");
+  barLn();
+
+  // Menu
+  const items = [
+    { id: "fetch", name: "Fetch calculated times by city", tier: "Adhan times from aladhan.com" },
+    { id: "paste", name: "Paste mosque timetable", tier: "Jama'ah times — most accurate" },
+    { id: "toggle", name: enabled ? "Disable prayer times" : "Enable prayer times", tier: "Toggle visibility in status line" },
+    { id: "back", name: "Back", tier: "" },
+  ];
+
+  question("What would you like to do?");
+  barLn();
+  const choice = await interactiveSelect(items, { multi: false });
+
+  if (choice === "fetch") {
+    barLn();
+    const city = await textInput({ label: "City", placeholder: "London" });
+    const country = await textInput({ label: "Country", placeholder: "United Kingdom" });
+    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."));
+      }
+    }
+
+    // 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."));
+    barLn(dim("  Format examples:"));
+    barLn(dim("    2026-03-08  05:20  13:00  16:15  18:01  19:45"));
+    barLn(dim("    March 8: Fajr 05:20, Dhuhr 13:00, Asr 16:15, Maghrib 18:01, Isha 19:45"));
+    barLn(dim("  Type 'done' on a new line when finished."));
+    barLn();
+
+    const lines = [];
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    await new Promise((resolve) => {
+      const ask = () => {
+        rl.question(`${BAR_COLOR}\u2502${S.reset}  `, (line) => {
+          if (line.trim().toLowerCase() === "done" || line.trim() === "") {
+            rl.close();
+            resolve();
+            return;
+          }
+          lines.push(line);
+          ask();
+        });
+      };
+      ask();
+    });
+
+    if (lines.length > 0) {
+      // Ask for mosque name
+      const mosqueName = await textInput({ label: "Mosque name (optional)", placeholder: "My Local Mosque" });
+
+      const result = parsePrayerTimetable(lines);
+      if (mosqueName) result.mosque = mosqueName;
+      if (result && Object.keys(result.times).length > 0) {
+        // Merge with existing timetable if present
+        if (tt && tt.times) {
+          result.times = { ...tt.times, ...result.times };
+        }
+        fs.writeFileSync(ttPath, JSON.stringify(result, null, 2), "utf8");
+        barLn(`${green("\u2713")} Saved ${Object.keys(result.times).length} days`);
+      } else {
+        barLn(yellow("  Could not parse the timetable."));
+        barLn(dim("  Tip: paste it into Claude and ask to convert to this JSON format:"));
+        barLn(dim(`  { "times": { "2026-03-08": { "fajr": "05:20", "dhuhr": "13:00", ... } } }`));
+      }
+    }
+
+    // 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 === "toggle") {
+    if (!cfg.settings) cfg.settings = {};
+    cfg.settings.show_prayer_times = !enabled;
+    fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2), "utf8");
+    barLn(`${green("\u2713")} Prayer times ${cfg.settings.show_prayer_times ? "enabled" : "disabled"}`);
+  }
+
   barLn();
 }
 
@@ -3302,6 +3796,310 @@ async function cmdRestore(opts) {
   barLn();
 }
 
+// ─── moveros help ──────────────────────────────────────────────────────────
+async function cmdHelp(opts) {
+  // Interactive animated guide — paginated walkthrough of Mover OS
+  const pages = [
+    {
+      title: "Welcome to Mover OS",
+      body: [
+        `${bold("The agentic operating system for Obsidian.")}`,
+        "",
+        "Mover OS turns your Obsidian vault into an AI-powered execution engine.",
+        "It works across 16 AI coding agents — Claude Code, Cursor, Gemini,",
+        "Copilot, Codex, and more. Same brain, every editor.",
+        "",
+        `${dim("How it works:")}`,
+        `  ${cyan("1.")} Your ${bold("Engine")} stores who you are — identity, strategy, goals`,
+        `  ${cyan("2.")} ${bold("Workflows")} run your day — plan, execute, log, analyse, repeat`,
+        `  ${cyan("3.")} ${bold("Skills")} give your AI agents deep domain knowledge`,
+        `  ${cyan("4.")} The system ${bold("learns")} from your behavior and adapts`,
+        "",
+        `${dim("This guide walks through everything. Use ← → to navigate.")}`,
+      ],
+    },
+    {
+      title: "The Engine — Your Brain",
+      body: [
+        `${dim("Location:")} 02_Areas/Engine/`,
+        "",
+        `${bold("Core files that define you:")}`,
+        "",
+        `  ${cyan("Identity_Prime.md")}   Who you are — values, psychology, anti-identity`,
+        `  ${cyan("Strategy.md")}         What you're testing — current hypothesis`,
+        `  ${cyan("Active_Context.md")}   What's happening NOW — blockers, focus, state`,
+        `  ${cyan("Goals.md")}            Where you're going — 90d, 1yr, 10yr targets`,
+        `  ${cyan("Mover_Dossier.md")}    What you have — skills, capital, network`,
+        `  ${cyan("Auto_Learnings.md")}   What the AI notices — behavioral patterns`,
+        "",
+        `These files are ${bold("irreplaceable")}. The system never overwrites them.`,
+        "Every AI session reads them. Every workflow updates them.",
+        `Your Engine ${bold("evolves")} as you do.`,
+      ],
+    },
+    {
+      title: "Daily Rhythm — The Loop",
+      body: [
+        `${bold("The daily execution cycle:")}`,
+        "",
+        `  ${green("→")} ${bold("/morning")}         Start your day — energy check, set focus`,
+        `  ${green("→")} ${bold("[WORK]")}            Build, ship, create`,
+        `  ${green("→")} ${bold("/log")}              Capture what happened — syncs plan + state`,
+        `  ${green("→")} ${bold("/analyse-day")}      Brutal daily audit — patterns + verdict`,
+        `  ${green("→")} ${bold("/plan-tomorrow")}    Generate tomorrow's battle plan`,
+        "",
+        `${dim("Weekly:")}`,
+        `  ${green("→")} ${bold("/review-week")}      Sunday deep review + strategy validation`,
+        "",
+        `${dim("The rhythm is the system.")} Miss a day, patterns detect it.`,
+        "Miss three, /reboot triggers recovery protocol.",
+        `Every workflow hands off to the next — ${bold("no dead ends")}.`,
+      ],
+    },
+    {
+      title: "Workflows — 23 Commands",
+      body: [
+        `${bold("Daily:")}  /morning  /log  /analyse-day  /plan-tomorrow  /review-week`,
+        `${bold("Build:")}  /ignite  /overview  /refactor-plan  /capture  /debrief`,
+        `${bold("Think:")}  /debug-resistance  /pivot-strategy  /mover-ideas  /screenshot`,
+        `${bold("Grow:")}   /harvest  /history  /reboot`,
+        `${bold("Meta:")}   /setup  /update  /walkthrough  /migrate  /mover-check  /mover-report`,
+        "",
+        `${dim("Key concepts:")}`,
+        `  ${cyan("•")} ${bold("/ignite")} creates projects — brief + plan in one workflow`,
+        `  ${cyan("•")} ${bold("/debug-resistance")} diagnoses WHY you're avoiding something`,
+        `  ${cyan("•")} ${bold("/pivot-strategy")} formally changes direction with logging`,
+        `  ${cyan("•")} ${bold("/harvest")} extracts permanent knowledge to your Library`,
+        `  ${cyan("•")} ${bold("/screenshot")} does meta-analysis of your AI session patterns`,
+        "",
+        "Every command reads your Engine context and adapts to your state.",
+      ],
+    },
+    {
+      title: "Skills — Domain Intelligence",
+      body: [
+        `${bold("Skills give your AI agents specialized knowledge.")}`,
+        "",
+        `${dim("Categories:")}`,
+        `  ${cyan("dev")}        Debugging, TDD, refactoring, error handling, React`,
+        `  ${cyan("marketing")} Copywriting, SEO, CRO, social content, email`,
+        `  ${cyan("cro")}        Page optimization, forms, popups, paywalls, onboarding`,
+        `  ${cyan("strategy")}  Pricing, launch, competitors, referrals, analytics`,
+        `  ${cyan("seo")}        Audits, schema markup, programmatic SEO, content`,
+        `  ${cyan("design")}    UI/UX, frontend design, Obsidian markdown/canvas`,
+        `  ${cyan("obsidian")} JSON Canvas, Bases, Obsidian CLI, markdown`,
+        "",
+        `${dim("System skills (always active):")}`,
+        `  friction-enforcer  pattern-detector  plan-md-guardian`,
+        `  mover-os-context   workflow-router    daily-note-writer`,
+        "",
+        "Skills trigger automatically based on what you're doing.",
+      ],
+    },
+    {
+      title: "The Friction System",
+      body: [
+        `${bold("Your AI pushes back when you drift from your plan.")}`,
+        "",
+        `  ${dim("Level 1")} ${cyan("Surface")}    \"Your plan says X. You're working on Y.\"`,
+        `  ${dim("Level 2")} ${yellow("Justify")}   \"Why is this more important than your Single Test?\"`,
+        `  ${dim("Level 3")} ${red("Earn It")}     AI stops helping with off-plan work.`,
+        `  ${dim("Level 4")} ${red("Hard Block")} Destructive actions require explicit reason.`,
+        "",
+        `You can always push through Levels 1-3. Friction creates`,
+        `${bold("awareness")}, not walls. But the AI won't silently comply`,
+        "when you're avoiding the hard thing.",
+        "",
+        `${dim("Pre-Escalation Gate:")} If the work is exploration or compound`,
+        `value (not avoidance), it logs as ${dim("[COMPOUND]")} and doesn't escalate.`,
+      ],
+    },
+    {
+      title: "Pattern Detection",
+      body: [
+        `${bold("The system watches your behavior across sessions.")}`,
+        "",
+        `${dim("How it works:")}`,
+        `  ${cyan("1.")} AI observes recurring behavior (3+ data points)`,
+        `  ${cyan("2.")} Logs to Auto_Learnings.md with confidence score (1-5)`,
+        `  ${cyan("3.")} Patterns surface proactively in workflows`,
+        `  ${cyan("4.")} You confirm or dismiss — the system adapts`,
+        "",
+        `${dim("Pattern types:")}`,
+        `  ${yellow("Avoidance")}       Dodging specific tasks repeatedly`,
+        `  ${yellow("Time Drift")}      Working past shutdown, skipping rest`,
+        `  ${yellow("System Spree")}    Building tools instead of shipping`,
+        `  ${yellow("Scope Creep")}     Tasks growing beyond plan boundaries`,
+        `  ${yellow("Energy Cycles")}   Performance tied to sleep/food/time`,
+        "",
+        `Confidence 3+ patterns route to the workflow that fixes them.`,
+      ],
+    },
+    {
+      title: "16 AI Agents — One Brain",
+      body: [
+        `${bold("Mover OS installs to every major AI coding agent.")}`,
+        "",
+        `${dim("Full tier (rules + skills + commands + hooks):")}`,
+        `  Claude Code  Cursor  Cline  Windsurf  Gemini CLI`,
+        `  Copilot  Amazon Q  OpenCode  Kilo Code`,
+        "",
+        `${dim("Enhanced tier (rules + skills):")}`,
+        `  Codex  Amp  Roo Code  Antigravity`,
+        "",
+        `${dim("Basic tier (rules only):")}`,
+        `  Continue  Aider`,
+        "",
+        "Switch editors freely. Your identity, strategy, and patterns",
+        `follow you everywhere. The ${bold("Engine is the constant")}.`,
+        `Run ${cyan("moveros sync")} to update all agents at once.`,
+      ],
+    },
+    {
+      title: "CLI Commands",
+      body: [
+        `${bold("Terminal utilities — no AI session needed.")}`,
+        "",
+        `  ${cyan("moveros pulse")}      Dashboard — energy, tasks, streaks, blockers`,
+        `  ${cyan("moveros doctor")}     Health check across all installed agents`,
+        `  ${cyan("moveros capture")}    Quick capture — tasks, links, ideas from terminal`,
+        `  ${cyan("moveros who")}        Entity memory lookup — people, orgs, places`,
+        `  ${cyan("moveros sync")}       Update all agents to latest rules/skills`,
+        `  ${cyan("moveros context")}    See what each agent loads — rules, skills, tokens`,
+        `  ${cyan("moveros diff")}       Engine file evolution via git history`,
+        `  ${cyan("moveros replay")}     Session replay from Daily Notes`,
+        `  ${cyan("moveros settings")}   View/edit config — ${dim("settings set <key> <val>")}`,
+        `  ${cyan("moveros backup")}     Manual backup wizard (engine, areas, agents)`,
+        `  ${cyan("moveros restore")}    Restore from backup`,
+        `  ${cyan("moveros warm")}       Pre-warm an AI session with context`,
+      ],
+    },
+    {
+      title: "The Status Line",
+      body: [
+        `${bold("Your life, glanceable. Always visible in Claude Code.")}`,
+        "",
+        `  ${dim("Line 1:")} Model · Context% · Project(branch) · Lines · Time · Cost`,
+        `  ${dim("Line 2:")} Next task · Progress · Vitality · Prayer · Last log`,
+        `  ${dim("Line 3:")} Rate limits (5hr + 7day + extra usage)`,
+        "",
+        `${dim("Features:")}`,
+        `  ${cyan("•")} Next unchecked task from today's Daily Note`,
+        `  ${cyan("•")} Strategic task count (vitality excluded)`,
+        `  ${cyan("•")} Vitality slot machine — rotates reminders every minute`,
+        `  ${cyan("•")} Next prayer time (if ${dim("show_prayer_times: true")} in settings)`,
+        `  ${cyan("•")} Time since last /log — so you never forget`,
+        `  ${cyan("•")} Rate limit bars with reset times`,
+        "",
+        `All data from your vault. ${bold("No API calls")} except rate limits.`,
+      ],
+    },
+    {
+      title: "Getting Started",
+      body: [
+        `${bold("You're ready.")}`,
+        "",
+        `  ${cyan("1.")} Run ${bold("/setup")} in any AI agent to build your Engine`,
+        `  ${cyan("2.")} Run ${bold("/morning")} to start your first session`,
+        `  ${cyan("3.")} Work. Build. Ship.`,
+        `  ${cyan("4.")} Run ${bold("/log")} to capture what happened`,
+        `  ${cyan("5.")} Run ${bold("/plan-tomorrow")} before bed`,
+        "",
+        `${dim("Quick tips:")}`,
+        `  ${cyan("•")} ${bold("Single Test")} — one thing that makes the day a win`,
+        `  ${cyan("•")} ${bold("Sacrifice")} — what you won't do today (as important as what you will)`,
+        `  ${cyan("•")} The system gets smarter the more you use it`,
+        `  ${cyan("•")} Trust the Engine files — they're your memory between sessions`,
+        "",
+        `${dim("moveros.dev")}  ${dim("·")}  ${dim("$49 one-time")}  ${dim("·")}  ${dim("updates included")}`,
+      ],
+    },
+  ];
+
+  // Paginated display with keyboard navigation
+  let page = 0;
+
+  function renderPage() {
+    const p = pages[page];
+    // Clear screen area
+    w("\x1b[2J\x1b[H"); // clear screen, cursor to top
+    ln();
+
+    // Page indicator
+    const dots = pages.map((_, i) => i === page ? cyan("●") : dim("○")).join(" ");
+    ln(`  ${dots}`);
+    ln();
+
+    // Title with box
+    ln(`  ${S.cyan}┌${"─".repeat(56)}┐${S.reset}`);
+    const titlePad = Math.max(0, 54 - strip(p.title).length);
+    ln(`  ${S.cyan}│${S.reset} ${bold(p.title)}${" ".repeat(titlePad)} ${S.cyan}│${S.reset}`);
+    ln(`  ${S.cyan}└${"─".repeat(56)}┘${S.reset}`);
+    ln();
+
+    // Body
+    for (const line of p.body) {
+      ln(`  ${line}`);
+    }
+    ln();
+    ln();
+
+    // Navigation
+    const nav = [];
+    if (page > 0) nav.push(`${dim("←")} prev`);
+    if (page < pages.length - 1) nav.push(`${dim("→")} next`);
+    nav.push(`${dim("q")} quit`);
+    ln(`  ${dim(`${page + 1}/${pages.length}`)}  ${nav.join(dim("  ·  "))}`);
+  }
+
+  return new Promise((resolve) => {
+    if (!IS_TTY) {
+      // Non-interactive: dump all pages
+      for (const p of pages) {
+        ln(bold(`\n## ${p.title}\n`));
+        for (const line of p.body) ln(`  ${line}`);
+      }
+      resolve();
+      return;
+    }
+
+    const { stdin } = process;
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    w(S.hide);
+
+    renderPage();
+
+    const handler = (data) => {
+      if (data === "\x1b[C" || data === "l" || data === " ") {
+        if (page < pages.length - 1) { page++; renderPage(); }
+      } else if (data === "\x1b[D" || data === "h") {
+        if (page > 0) { page--; renderPage(); }
+      } else if (data === "q" || data === "\x1b" || data === "\x03") {
+        stdin.removeListener("data", handler);
+        stdin.setRawMode(false);
+        stdin.pause();
+        w(S.show);
+        w("\x1b[2J\x1b[H"); // clear
+        resolve();
+      } else if (data === "\r" || data === "\n") {
+        if (page < pages.length - 1) { page++; renderPage(); }
+        else {
+          stdin.removeListener("data", handler);
+          stdin.setRawMode(false);
+          stdin.pause();
+          w(S.show);
+          w("\x1b[2J\x1b[H");
+          resolve();
+        }
+      }
+    };
+
+    stdin.on("data", handler);
+  });
+}
+
 // ─── moveros test (dev only) ────────────────────────────────────────────────
 async function cmdTest(opts) { barLn(yellow("moveros test — not yet implemented.")); }
 
@@ -3312,11 +4110,12 @@ async function cmdMainMenu() {
     { header: "Dashboard", cmds: ["pulse", "replay", "diff"] },
     { header: "Agents", cmds: ["doctor", "sync", "context", "warm"] },
     { header: "Capture", cmds: ["capture", "who"] },
-    { header: "System", cmds: ["settings", "backup", "restore"] },
+    { header: "System", cmds: ["settings", "prayer", "backup", "restore", "help"] },
   ];
 
   const menuItems = [];
   for (const cat of categories) {
+    menuItems.push({ id: `_sep_${cat.header}`, name: `── ${cat.header}`, _separator: true });
     for (const cmd of cat.cmds) {
       const meta = CLI_COMMANDS[cmd];
       if (!meta || meta.hidden) continue;
@@ -3367,20 +4166,36 @@ async function main() {
   // ── Intro ──
   await printHeader();
 
-  // ── Route: no command → interactive menu ──
+  // ── Route: no command → interactive menu (persistent loop) ──
+  const lightCommands = ["pulse", "warm", "capture", "who", "diff", "sync", "replay", "context", "settings", "backup", "restore", "doctor", "prayer", "help", "test"];
+
   if (!opts.command) {
-    opts.command = await cmdMainMenu();
+    // Interactive loop — stay open like a real app
+    while (true) {
+      opts.command = await cmdMainMenu();
+      if (!opts.command) break; // user cancelled
+
+      if (lightCommands.includes(opts.command)) {
+        const handler = CLI_HANDLERS[opts.command];
+        if (handler) await handler(opts);
+        else barLn(yellow(`Command '${opts.command}' is not yet implemented.`));
+        opts.command = ""; // reset for next loop
+        barLn(dim("  Press enter to return to menu..."));
+        await new Promise((r) => { process.stdin.resume(); process.stdin.once("data", () => { process.stdin.pause(); r(); }); });
+        continue;
+      }
+      break; // install/update break out of loop into pre-flight
+    }
+    if (!opts.command) return;
   }
 
-  // ── Route: CLI commands that don't need pre-flight ──
-  const lightCommands = ["pulse", "warm", "capture", "who", "diff", "sync", "replay", "context", "settings", "backup", "restore", "doctor", "test"];
+  // ── Route: direct CLI command (non-interactive) ──
   if (lightCommands.includes(opts.command)) {
     const handler = CLI_HANDLERS[opts.command];
     if (handler) {
       await handler(opts);
     } else {
       barLn(yellow(`Command '${opts.command}' is not yet implemented.`));
-      barLn(dim("Coming soon in a future update."));
     }
     return;
   }
@@ -4031,6 +4846,101 @@ async function main() {
     installStatusLine = slChoice === "yes";
   }
 
+  // ── Prayer times (optional) ──
+  let prayerSetup = false;
+  {
+    barLn();
+    question("Would you like prayer time reminders?");
+    barLn(dim("  Shows next prayer time in the status line and Daily Notes."));
+    barLn(dim("  Designed for Muslims — skip if not relevant to you."));
+    barLn();
+
+    const ptChoice = await interactiveSelect(
+      [
+        { id: "yes", name: "Yes, set up prayer times", tier: "You can paste your mosque's timetable or fetch by city" },
+        { id: "no", name: "No, skip", tier: "You can enable later with: moveros prayer" },
+      ],
+      { multi: false, defaultIndex: 1 }
+    );
+    if (ptChoice === "yes") {
+      prayerSetup = true;
+      barLn();
+      question("How would you like to set up prayer times?");
+      barLn();
+
+      const method = await interactiveSelect(
+        [
+          { id: "paste", name: "Paste my mosque's timetable", tier: "Jama'ah times — most accurate for your local mosque" },
+          { id: "fetch", name: "Fetch calculated times by city", tier: "Adhan times from aladhan.com — good starting point" },
+          { id: "later", name: "I'll set it up later", tier: "Run: moveros prayer" },
+        ],
+        { multi: false, defaultIndex: 0 }
+      );
+
+      const moverDir = path.join(os.homedir(), ".mover");
+      if (!fs.existsSync(moverDir)) fs.mkdirSync(moverDir, { recursive: true, mode: 0o700 });
+
+      if (method === "paste") {
+        barLn();
+        barLn(dim("  Paste your mosque's timetable below."));
+        barLn(dim("  Format: one line per entry, any of these work:"));
+        barLn(dim("    2026-03-08  05:20  13:00  16:15  18:01  19:45"));
+        barLn(dim("    March 8: Fajr 05:20, Dhuhr 13:00, Asr 16:15, Maghrib 18:01, Isha 19:45"));
+        barLn(dim("  Or paste a whole table — the system will parse it."));
+        barLn(dim("  When done, type 'done' on a new line and press Enter."));
+        barLn();
+
+        const lines = [];
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        await new Promise((resolve) => {
+          const ask = () => {
+            rl.question(`${BAR_COLOR}\u2502${S.reset}  `, (line) => {
+              if (line.trim().toLowerCase() === "done" || line.trim() === "") {
+                rl.close();
+                resolve();
+                return;
+              }
+              lines.push(line);
+              ask();
+            });
+          };
+          ask();
+        });
+
+        if (lines.length > 0) {
+          const tt = parsePrayerTimetable(lines);
+          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");
+            barLn(`${green("\u2713")} ${dim(`Saved ${Object.keys(tt.times).length} days to prayer-timetable.json`)}`);
+          } else {
+            barLn(yellow("  Could not parse timetable. Run moveros prayer later to try again."));
+          }
+        }
+      } else if (method === "fetch") {
+        barLn();
+        const city = await textInput({ label: "City (e.g. London, Watford, Istanbul)", placeholder: "London" });
+        const country = await textInput({ label: "Country", placeholder: "United Kingdom" });
+        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"));
+          } else {
+            sp.stop(yellow("Could not fetch. Run moveros prayer later."));
+          }
+        }
+      }
+      // method === "later" → just enable the setting, no timetable yet
+    }
+  }
+
   // ── Install with animated spinners ──
   barLn();
   question(updateMode ? bold("Updating...") : bold("Installing..."));
@@ -4138,29 +5048,28 @@ async function main() {
     }
   }
 
-  // 7. .gitignore + git init (fresh install only)
+  // 7. Git init Engine folder only (fresh install only)
   if (!updateMode) {
     const hasGit = cmdExists("git");
     if (hasGit) {
-      const gitignorePath = path.join(vaultPath, ".gitignore");
-      if (!fs.existsSync(gitignorePath)) {
-        fs.writeFileSync(gitignorePath, generateGitignore(), "utf8");
-        sp = spinner(".gitignore");
-        await sleep(100);
-        sp.stop(".gitignore");
-        totalSteps++;
-      }
-      if (!fs.existsSync(path.join(vaultPath, ".git"))) {
-        sp = spinner("Git repository");
+      const engineDir = path.join(vaultPath, "02_Areas", "Engine");
+      const engineGit = path.join(engineDir, ".git");
+      if (!fs.existsSync(engineGit) && fs.existsSync(engineDir)) {
+        sp = spinner("Engine git repository");
         try {
-          execSync("git init", { cwd: vaultPath, stdio: "ignore" });
-          execSync("git add 01_Projects 02_Areas/Engine 03_Library 04_Archives .gitignore .mover-version CLAUDE.md", { cwd: vaultPath, stdio: "ignore" });
-          execSync('git commit -m "Initial commit — Mover OS v' + VERSION + '"', { cwd: vaultPath, stdio: "ignore" });
+          // .gitignore inside Engine (excludes Dailies + Weekly Reviews)
+          const gitignorePath = path.join(engineDir, ".gitignore");
+          if (!fs.existsSync(gitignorePath)) {
+            fs.writeFileSync(gitignorePath, generateGitignore(), "utf8");
+          }
+          execSync("git init", { cwd: engineDir, stdio: "ignore" });
+          execSync("git add -A", { cwd: engineDir, stdio: "ignore" });
+          execSync('git commit -m "Initial commit — Mover OS Engine v' + VERSION + '"', { cwd: engineDir, stdio: "ignore" });
           await sleep(300);
-          sp.stop("Git initialized");
+          sp.stop(`Engine git initialized  ${dim("02_Areas/Engine/")}`);
           totalSteps++;
         } catch {
-          sp.stop(dim("Git skipped"));
+          sp.stop(dim("Engine git skipped"));
         }
       }
     }
@@ -4172,7 +5081,7 @@ async function main() {
   }
 
   // 9. Write ~/.mover/config.json (both fresh + update)
-  writeMoverConfig(vaultPath, selectedIds, key);
+  writeMoverConfig(vaultPath, selectedIds, key, { prayerSetup });
 
   barLn();
 
@@ -4200,8 +5109,8 @@ async function main() {
   ln();
   ln(`  ${bold("What was installed")}`);
   ln();
-  ln(`  ${green("▸")} ${bold("22")} workflows    ${dim("slash commands for daily rhythm, projects, strategy")}`);
-  ln(`  ${green("▸")} ${bold("61")} skills        ${dim("curated packs for dev, marketing, CRO, design")}`);
+  ln(`  ${green("▸")} ${bold("23")} workflows    ${dim("slash commands for daily rhythm, projects, strategy")}`);
+  ln(`  ${green("▸")} ${bold("63")} skills        ${dim("curated packs for dev, marketing, CRO, design")}`);
   if (selectedIds.includes("claude-code")) {
     ln(`  ${green("▸")} ${bold("6")}  hooks         ${dim("lifecycle guards (engine protection, git safety)")}`);
   }
@@ -4241,6 +5150,17 @@ async function main() {
   ln();
   ln(`  ${dim("/morning → [work] → /log → /analyse-day → /plan-tomorrow")}`);
   ln();
+  ln(gray("  ─────────────────────────────────────────────"));
+  ln();
+  ln(`  ${bold("CLI commands")}  ${dim("(run from any terminal)")}`);
+  ln();
+  ln(`  ${green("▸")} ${bold("moveros pulse")}     ${dim("Dashboard — energy, tasks, streaks")}`);
+  ln(`  ${green("▸")} ${bold("moveros doctor")}    ${dim("Health check across all agents")}`);
+  ln(`  ${green("▸")} ${bold("moveros capture")}   ${dim("Quick inbox — tasks, links, ideas")}`);
+  ln(`  ${green("▸")} ${bold("moveros warm")}      ${dim("Pre-warm your next AI session")}`);
+  ln(`  ${green("▸")} ${bold("moveros sync")}      ${dim("Update all agents to latest")}`);
+  ln(`  ${green("▸")} ${bold("moveros")}           ${dim("Full menu with all commands")}`);
+  ln();
 }
 
 main().catch((err) => {

package/package.json

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