set flag Matches_fsi.

static boolean hotwire_over_bot = false;

static int maxAnswerLength = 1000, shortenTo = 200;
static int askSelfMax = 10;

static L<S> botIDs = litlist("#1002317");
static L<S> generalReleaseBots = litlist();
static new L<Class> bots;
static new L<S> activeBots;
static Map<S, Class> botsByID = synchroTreeMap();

static new L<S> disabledBots;

// information for "answer" functions
static new ThreadLocal<S> userName;
static new ThreadLocal<S> slackTS;
static new ThreadLocal<S> channelName;
static new ThreadLocal<S> dialogID;
static new ThreadLocal<S> actualURI;
static ThreadLocal<Map<S, S>> uploadFiles = new ThreadLocal;
static new ThreadLocal<Boolean> attn;
static new ThreadLocal<Boolean> dedicated;
static new ThreadLocal<S> originalLine;
static new ThreadLocal<S> answeringBot;
static ThreadLocal<Set<S>> involvedBots = new ThreadLocal; // bots involved with making the current answer
static new ThreadLocal<S> postAs;
static new ThreadLocal<S> botIcon;

static volatile S loadingBotID;
static volatile Class loadingBot;
static volatile boolean loaded;

static new L<Map> history; // stores all processed user questions (not whole chat log)

static volatile S lastAnswerBy;
static volatile L<S> lastInvolvedBots;

static void coreInit() {
  load("disabledBots");
  reload();
  readLog();
  
  loaded = true;
}

static S answerImpl(S s, boolean generalRelease) {
  new Matches m;
  
  S whoSaidThat = lastAnswerBy;
  L<S> involvedBots = main.lastInvolvedBots;
  
  L<S> tok = javaTok(s);
  if (isInteger(get(tok, 1)) && eq(get(tok, 3), ":")) {
    Class bot = getBot(get(tok, 1));
    if (bot == null)
      ret "Bot not found: " + get(tok, 1);
    s = join(subList(tok, 5));
    S answer = callDehBots(litlist(bot), s);
    ret empty(answer) ? "(no answer)" : answer;
  }
  
  if "get home page bot" exceptionToUser {
    if (!hasField(mc(), "homePageBotID"))
      ret "Eleu was compiled without web integration";
      
    ret str(get(mc(), "homePageBotID"));
  }
  
  if (master()) {
    if "set home page bot *" exceptionToUser {
      S id = m.fsi(0);
      if (!hasField(mc(), "homePageBotID"))
        ret "Eleu was compiled without web integration";
        
      set(mc(), "homePageBotID", id);
      call(mc(), "save", "homePageBotID");
      ret format("OK, home page bot ID set to *", id);
    }
    
    if "set no home page bot *" exceptionToUser {
      S id = m.fsi(0);
      if (!hasField(mc(), "homePageBotID"))
        ret "Eleu was compiled without web integration";
        
      set(mc(), "homePageBotID", null);
      call(mc(), "save", "homePageBotID");
      ret format("OK, home page bot ID set to null");
    }
    
    if "disable bot *" {
      setAdd(disabledBots, formatSnippetID(m.unq(0)));
      save("disabledBots");
      ret "OK";
    }
    
    if "enable bot *" {
      disabledBots.remove(formatSnippetID(m.unq(0)));
      save("disabledBots");
      ret "OK";
    }
  }
  
  if (match("reboot", s) && master()) {
    int n = l(bots);
    cleanUp(bots);
    bots.clear();
    
    thread {
      sleepSeconds(1);
      
      // take latest args from source
      S vmArgs = cast loadVariableDefinition("vmArgs");
      
      directNohupJavax(getProgramID(), vmArgs);
      System.exit(100);
    }
    ret n(n, "bot") + " cleaned up. Rebooting...";
  }
  
  if (match("who said that", s))
    ret (whoSaidThat == null ? "what?" : whoSaidThat) + " / " + structure(lastInvolvedBots);
  
  if (match("reload", s) && master()) {
    time { reload(); }
    ret l(bots) + "/" + l(botIDs) + " bots reloaded in "+ getLastTiming() + " ms.";
  }
  
  if (match("reload *", s, m) && isSnippetID(m.unq(0)) && master()) {
    reload(m.unq(0));
    ret "Bot " + formatSnippetID(m.unq(0)) + " reloaded.";
  }
  
  if (match("list bots", s)) {
    S answer = "Active bots: " + structure(activeBots);
    L<S> inactiveBots = diff(botIDs, activeBots);
    if (!inactiveBots.isEmpty())
      answer += ". Inactive/disabled bots: " + structure(inactiveBots);
    if (!disabledBots.isEmpty())
      answer += ". Disabled bots: " + structure(disabledBots);
    ret answer;
  }
    
  if (match("test", s))
    ret "test me yes test me please!";
    
  ret callDehBots(generalRelease ? getGeneralReleaseBots() : bots, s);
}

static S callDehBots(L<Class> bots, S s) {
  answeringBot.set(null);
  involvedBots.set(new TreeSet);
  postAs.set(null);
  botIcon.set(null);
  for (Class c : bots) try {
    S botID = getBotID(c);
    if (disabledBots.contains(formatSnippetID(botID))) continue;
    //print("Calling bot " + botID);
    S answer = callStaticAnswerMethod(c, s);
    if (!empty(answer)) {
      S whoSaidIt = or((S) getOpt(c, "whoSaidThat"), botID);
      answeringBot.set(whoSaidIt);
      involvedBots.get().add(formatSnippetID(whoSaidIt));
      lastAnswerBy = whoSaidIt;
      lastInvolvedBots = new ArrayList(involvedBots.get());
      print("Answering bot: " + whoSaidIt);
      ret answer;
    }
  } catch (Throwable e) {
    print("Error calling " + getProgramID(c) + ":\n" + getStackTrace(e));
  }
  ret null;
}

static S getBotID(Class bot) {
  ret reverseLookup(botsByID, bot);
}

static int askSelfCounter;

static synchronized S askSelf(S s) {
  if (askSelfCounter >= askSelfMax)
    fail("Too much recursion asking myself (depth " + askSelfMax + ")");
  ++askSelfCounter;
  try {
    ret answer(s);
  } finally {
    --askSelfCounter;
  }
}

static synchronized S answer(S s) {
  ret answer(s, false);
}

static synchronized S answer(S s, boolean generalRelease) {
  long time = now();
  S a = "ERREUR";
  try {
    a = answerImpl(s, generalRelease);
  } finally {
    pcall {
      long x = now();
      // We should record which bot answered!
      Map map = litmap("startTime", time, "duration", x-time,
        "question", s, "answer", a, "botID", "?");
      printList(answerPriv(format("log timing *", structure(map))));
    }
  }
  ret a;
}

// can give multiple answers
static synchronized L<S> answerPriv(S s) {
  new L<S> l;
  for (Class bot : bots) pcall {
    S a = cast callOpt(bot, "answerPriv", s);
    if (!empty(a))
      l.add(a);
  }
  ret l;
}

static L<Class> getGeneralReleaseBots() {
  new L<Class> l;
  for (S botID : generalReleaseBots) {
    Class c = botsByID.get("" + parseSnippetID(botID));
    if (c != null)
      l.add(c);
  }
  ret l;
}

static void recordFeedback(S probableQuestion, S answer, S answerTime, S feedback, int score) {
  if (answer == null || probableQuestion == null) ret;

  Map data = litmap("realtime", now(), "question", probableQuestion, "answer", answer, "answertime", answerTime, "feedback", feedback, "score", score);
  print("Recording feedback: " + data);
  logQuoted(new File(programDir(), "feedback-log"), structure(data));
  logQuoted(new File(programDir(), "memory-log"), structure(data));
}

static void reloadLists() {
  botIDs = or((L<S>) loadVariableDefinition("botIDs"), botIDs);
  generalReleaseBots = or((L<S>) loadVariableDefinition("generalReleaseBots"), generalReleaseBots);
  botIDs.addAll(generalReleaseBots);
}

static void reload() {
  reloadLists();
  
  cleanUp(bots);
  activeBots = new ArrayList();
  botsByID.clear();
  for (S botID : botIDs)
    pcall {
      loadBot(botID);
    }
}

static void reload(S botID) {
  reloadLists();
  S parsedID = "" + parseSnippetID(botID);
  Class bot = botsByID.get(parsedID);
  if (bot != null) {
    cleanUp(bot);
    botsByID.remove(parsedID);
    activeBots.remove(formatSnippetID(botID));
    bots.remove(bot);
  }
  loadBot(botID);
}

static void loadBot(S botID) {
  botID = formatSnippetID(botID);
  if (!botIDs.contains(botID))
    fail("Bot not listed: " + botID);
    
  print("Loading bot: " + botID);
  Class c = hotwire_over_bot ? hotwire_overBot(botID) : hotwire(botID);
  setOpt(c, "mainBot", getMainClass());
  loadingBotID = botID;
  loadingBot = c;
  try {
    callMain(c);
    bots.add(c);
    activeBots.add(formatSnippetID(botID)); // only if loading doesn't fail
    botsByID.put("" + parseSnippetID(botID), c);
    print("Loaded bot: " + botID + ", bots now: " + l(activeBots));
  } finally {
    loadingBotID = null;
    loadingBot = null;
  }
}

static void readLog() {
  for (S prog : litlist("#1001915", getProgramID()))
    for (S s : scanLog(prog, "memory-log")) pcall {
      history.add((Map) safeUnstructure(s));
    }
  print(l(history) + " history entries.");
}

// query threadlocals (called by sub-bots)

static S getUserName() { ret userName.get(); }
static S getSlackTS() { ret slackTS.get(); }
static S getChannelName() { ret channelName.get(); }
static S getDialogID() { ret dialogID.get(); }
static S getActualURI() { ret actualURI.get(); }
static Map<S, S> getUploadFiles() { ret uploadFiles.get(); }
static S getOriginalLine() { ret originalLine.get(); }
static boolean isAddressed() { ret attn.get(); }
static boolean dedicated() { ret dedicated.get(); }
static Set getInvolvedBots() { ret involvedBots.get(); }

// get the sub-bot dispatcher (#1002317)
static O getDispatcher() {
  ret botsByID.get("" + parseSnippetID("#1002317"));
}

static Class getBot(S botID) {
  Class bot = botsByID.get("" + parseSnippetID(botID));
  if (bot == null) {
    O disp = getDispatcher();
    if (disp != null)
      ret (Class) call(disp, "getSubBot", botID);
  }
  ret bot;
}

static synchronized void historyAdd(Map logEntry) {
  logEntry.put("realtime", now());
  logEntry.put("dialogID", getDialogID());
  logEntry.put("involvedBots", toList(getInvolvedBots()));
  history.add(logEntry);
  logQuoted(new File(programDir(), "memory-log"), structure(logEntry));
}

static void postAs(S name) {
  postAs.set(name);
}

static void botIcon(S url) {
  botIcon.set(url);
}