@basementuniverse/kanbn 2.0.0 → 2.5.0

package/src/main.js

@@ -7,12 +7,48 @@ const utility = require("./utility");
 const yaml = require("yamljs");
 const humanizeDuration = require("humanize-duration");
 const rimraf = require("rimraf");
+const gitUser = require("./git-user");
+const actions = require("./actions");
 
 const DEFAULT_FOLDER_NAME = ".kanbn";
 const DEFAULT_INDEX_FILE_NAME = "index.md";
 const DEFAULT_TASKS_FOLDER_NAME = "tasks";
 const DEFAULT_ARCHIVE_FOLDER_NAME = "archive";
 
+// Slugs that always resolve to the main board, whatever the index file is called
+const MAIN_BOARD_ALIASES = ["main", "default"];
+
+// Options that describe the workspace rather than a single board. They are only ever read from the
+// config file (or, when there isn't one, from the main board's front matter) - if one of these turns
+// up in a secondary board's front matter it is ignored, and `kanbn validate` reports it
+const WORKSPACE_SCOPED_OPTIONS = [
+  "mainFolder",
+  "indexFile",
+  "taskFolder",
+  "archiveFolder",
+  "defaultBoard",
+  "boards",
+  "customFields",
+  "contributors",
+  "dateFormat",
+  "defaultTaskWorkload",
+  "taskWorkloadTags",
+];
+
+// Options that a secondary board inherits from the main board's front matter. When there is no
+// config file the main board's front matter is doing double duty - it holds the workspace options
+// *and* the main board's own board-scoped ones - so only this allowlist propagates. Anything else
+// there (startedColumns, hiddenColumns, views, custom field column linkages, ...) belongs to the
+// main board alone, and a secondary board that wants it has to say so itself
+const WORKSPACE_INHERITED_OPTIONS = [...WORKSPACE_SCOPED_OPTIONS, "sprints"];
+
+// Keys inside the `boards` config option that aren't board slugs
+const RESERVED_BOARDS_CONFIG_KEYS = ["exclude", "order"];
+
+// History event types that belong to the task rather than to a board, so they count when replaying
+// for any board. Archiving removes a task from every board, and progress is a property of the task
+const BOARD_AGNOSTIC_EVENT_TYPES = ["progress", "archived"];
+
 // Date normalisation intervals measured in milliseconds
 const SECOND = 1000;
 const MINUTE = 60 * SECOND;
@@ -65,6 +101,53 @@ async function exists(path) {
   return true;
 }
 
+/**
+ * Convert a board file name into a board slug, i.e. "design.md" -> "design"
+ * @param {string} fileName The board file name
+ * @return {string} The board slug
+ */
+function boardSlugFromFileName(fileName) {
+  return path.basename(fileName, path.extname(fileName));
+}
+
+/**
+ * Copy an object, leaving out the specified keys
+ * @param {object} o The object to copy
+ * @param {string[]} keys The keys to leave out
+ * @return {object} A copy of the object without the specified keys
+ */
+function omitKeys(o, keys) {
+  return Object.fromEntries(Object.entries(o).filter(([key]) => keys.indexOf(key) === -1));
+}
+
+/**
+ * Record which options belong to a board's own front matter, so that saving the board writes exactly
+ * these rather than everything it inherited from the workspace
+ * @param {object} index The index object
+ * @param {object} ownOptions The options that belong to this board
+ * @return {object} The index object
+ */
+function setOwnOptions(index, ownOptions) {
+  Object.defineProperty(index, "ownOptions", {
+    value: { ...ownOptions },
+    enumerable: false,
+    writable: true,
+    configurable: true,
+  });
+  return index;
+}
+
+/**
+ * Compare two option values structurally, so that an option inherited from the workspace can be told
+ * apart from one that a board operation has actually changed
+ * @param {any} a
+ * @param {any} b
+ * @return {boolean} True if the two values are equivalent
+ */
+function sameOptionValue(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+
 /**
  * Get a list of all tracked task ids
  * @param {object} index The index object
@@ -81,6 +164,77 @@ function getTrackedTaskIds(index, columnName = null) {
   );
 }
 
+/**
+ * Check whether a preserved column content entry is a simple task: a single-line list item, rather
+ * than a block of prose or an empty line. Only these can be addressed from the CLI
+ * @param {object} entry A column content entry
+ * @return {boolean} True if the entry is a simple task
+ */
+function isSimpleTask(entry) {
+  return !entry.block && !!entry.text && entry.text.indexOf("\n") === -1;
+}
+
+/**
+ * Remove a preserved column content entry from a column. Positions are unique within a column, so
+ * they identify an entry
+ * @param {object} index The index object
+ * @param {string} columnName The column to remove from
+ * @param {number} position The entry's position
+ * @return {object} The modified index object
+ */
+function removeColumnContent(index, columnName, position) {
+  if (!index.columnContent || !(columnName in index.columnContent)) {
+    return index;
+  }
+  index.columnContent[columnName] = index.columnContent[columnName].filter(
+    (entry) => entry.position !== position
+  );
+  if (!index.columnContent[columnName].length) {
+    delete index.columnContent[columnName];
+  }
+  if (!Object.keys(index.columnContent).length) {
+    delete index.columnContent;
+  }
+  return index;
+}
+
+/**
+ * Add a preserved column content entry to a column
+ * @param {object} index The index object
+ * @param {string} columnName The column to add to
+ * @param {object} entry The entry to add
+ * @param {?number} [position=null] The position to add it at, or the end of the column if null
+ * @return {object} The modified index object
+ */
+function addColumnContent(index, columnName, entry, position = null) {
+  if (!index.columnContent) {
+    index.columnContent = {};
+  }
+  if (!(columnName in index.columnContent)) {
+    index.columnContent[columnName] = [];
+  }
+
+  // A position counts every entry in the column, tasks and content alike, so the end of the column
+  // is past both of them
+  const columnLength = index.columns[columnName].length + index.columnContent[columnName].length;
+  index.columnContent[columnName].push({
+    ...entry,
+    position: position === null ? columnLength : Math.max(Math.min(position, columnLength), 0),
+  });
+  return index;
+}
+
+/**
+ * Check whether a line in a column looks like a task link with a typo in it, e.g. a missing closing
+ * bracket. A checkbox item (`- [ ] ...`) is an ordinary line rather than a broken link
+ * @param {string} raw The raw line
+ * @return {boolean} True if the line looks like a malformed task link
+ */
+function looksLikeMalformedTaskLink(raw) {
+  const text = String(raw).replace(/^\s*(?:[-*+]|\d+\.)\s+/, "");
+  return /^\[/.test(text) && !/^\[[ xX]\]/.test(text);
+}
+
 /**
    * Get a task path from the id
    * @param {string} tasksPath The path to the tasks folder
@@ -223,29 +377,143 @@ function setTaskMetadata(taskData, property, value) {
   return taskData;
 }
 
+/**
+ * Work out which fields an update actually changed
+ *
+ * Reserved fields are left out: `updated` changes on every update, so including it would make the
+ * payload say nothing
+ * @param {object} before The task before the update
+ * @param {object} after The task after it
+ * @return {string[]} The names of the fields that changed
+ */
+function changedFields(before, after) {
+  const fields = new Set();
+  if (before.name !== after.name) {
+    fields.add("name");
+  }
+  if (before.description !== after.description) {
+    fields.add("description");
+  }
+  const beforeMetadata = before.metadata || {};
+  const afterMetadata = after.metadata || {};
+  for (const field of new Set([...Object.keys(beforeMetadata), ...Object.keys(afterMetadata)])) {
+    if (actions.RESERVED_FIELDS.indexOf(field) !== -1) {
+      continue;
+    }
+    if (JSON.stringify(beforeMetadata[field]) !== JSON.stringify(afterMetadata[field])) {
+      fields.add(field);
+    }
+  }
+  return [...fields];
+}
+
+/**
+ * Normalise a contributors option into a consistent object form
+ *
+ * A contributor can be written as a bare name or as an object, and both mean the same thing - the
+ * shorthand is what most workspaces will ever need, and requiring `- name: gordon` for a bare name
+ * is the kind of ceremony that stops an optional feature being adopted. Everything downstream sees
+ * the object form
+ * @param {any} contributors The raw contributors option
+ * @return {object[]} The normalised contributors
+ */
+function normaliseContributors(contributors) {
+  if (!Array.isArray(contributors)) {
+    return [];
+  }
+  const result = [];
+  for (const contributor of contributors) {
+    const source = typeof contributor === "string" ? { name: contributor } : contributor;
+    if (source === null || typeof source !== "object" || typeof source.name !== "string") {
+      continue;
+    }
+    const name = source.name.trim();
+    if (!name) {
+      continue;
+    }
+    const normalised = {
+      name,
+      displayName: typeof source.displayName === "string" && source.displayName ? source.displayName : name,
+      aliases: Array.isArray(source.aliases)
+        ? source.aliases.filter((alias) => typeof alias === "string" && alias.trim()).map((alias) => alias.trim())
+        : [],
+    };
+    if (typeof source.email === "string" && source.email) {
+      normalised.email = source.email;
+    }
+
+    // Purely presentational, for avatar chips in a UI. Kanbn stores and serves it, and never
+    // interprets it
+    if (typeof source.colour === "string" && source.colour) {
+      normalised.colour = source.colour;
+    }
+    result.push(normalised);
+  }
+  return result;
+}
+
+/**
+ * Find the contributor a value refers to, matching against the canonical name, the display name and
+ * any aliases, case-insensitively
+ * @param {object[]} contributors Normalised contributors
+ * @param {?string} value The value to look up
+ * @return {?object} The matching contributor, or null if there isn't one
+ */
+function matchContributor(contributors, value) {
+  if (typeof value !== "string" || !value.trim()) {
+    return null;
+  }
+  const needle = value.trim().toLowerCase();
+  return (
+    contributors.find(
+      (contributor) =>
+        contributor.name.toLowerCase() === needle ||
+        contributor.displayName.toLowerCase() === needle ||
+        contributor.aliases.some((alias) => alias.toLowerCase() === needle)
+    ) || null
+  );
+}
+
+/**
+ * Find the contributor with a given email address, case-insensitively
+ * @param {object[]} contributors Normalised contributors
+ * @param {?string} email The email address to look up
+ * @return {?object} The matching contributor, or null if there isn't one
+ */
+function matchContributorEmail(contributors, email) {
+  if (typeof email !== "string" || !email.trim()) {
+    return null;
+  }
+  const needle = email.trim().toLowerCase();
+  return contributors.find((contributor) => (contributor.email || "").toLowerCase() === needle) || null;
+}
+
 /**
  * Append a structured history event to a task
  * @param {object} taskData The task object
  * @param {object} historyEvent The history event payload
+ * @param {?string} [boardSlug=null] The board the event happened on, or null for the main board
+ * @param {?string} [author=null] The user the event is attributed to, or null for no attribution
  * @return {object} The modified task object
  */
-function appendTaskHistory(taskData, historyEvent) {
+function appendTaskHistory(taskData, historyEvent, boardSlug = null, author = null) {
   if (!('history' in taskData) || taskData.history === null) {
     taskData.history = [];
   }
   taskData.history.push({
     date: new Date(),
-    ...historyEvent
+    ...historyEvent,
+
+    // Events on the main board carry no board key, so a single-board workspace writes exactly the
+    // history it always has
+    ...(boardSlug === null ? {} : { board: boardSlug }),
+
+    // Likewise, a machine with no resolvable user writes no author key at all
+    ...(author ? { author } : {})
   });
   return taskData;
 }
 
-/**
- * Check if a task is completed
- * @param {object} index
- * @param {object} task
- * @return {boolean} True if the task is in a completed column or has a completed date
- */
 /**
  * Get the name of the metadata field that holds a task's started date for this board. Boards can
  * point this at a custom date field so that several boards can track their own started/completed
@@ -266,10 +534,75 @@ function getCompletedField(index) {
   return ("completedField" in index.options && index.options.completedField) || DEFAULT_COMPLETED_FIELD;
 }
 
+/**
+ * Find the column a task is currently in
+ * @param {object} index The index object
+ * @param {object} task The task object
+ * @return {?string} The column name, or null if the task isn't in the index
+ */
+function getTaskColumn(index, task) {
+  return findTaskColumn(index, task.id || utility.getTaskId(task.name));
+}
+
+/**
+ * Check if a task has been started, based on its metadata
+ * @param {object} index The index object
+ * @param {object} task The task object
+ * @return {boolean} True if the task has a started date
+ */
+function taskStarted(index, task) {
+  return getStartedField(index) in task.metadata;
+}
+
+/**
+ * Check if a task is completed, based on its metadata
+ * @param {object} index The index object
+ * @param {object} task The task object
+ * @return {boolean} True if the task has a completed date
+ */
 function taskCompleted(index, task) {
   return getCompletedField(index) in task.metadata;
 }
 
+/**
+ * Check if a task is in one of this board's started columns. A board that declares no
+ * startedColumns has no notion of work in progress, so nothing is in a started column
+ * @param {object} index The index object
+ * @param {object} task The task object
+ * @return {boolean} True if the task is in a started column
+ */
+function taskInStartedColumn(index, task) {
+  const startedColumns = "startedColumns" in index.options ? index.options.startedColumns : [];
+  const column = getTaskColumn(index, task);
+  return column !== null && startedColumns.indexOf(column) !== -1;
+}
+
+/**
+ * Check if a task is in one of this board's completed columns
+ * @param {object} index The index object
+ * @param {object} task The task object
+ * @return {boolean} True if the task is in a completed column
+ */
+function taskInCompletedColumn(index, task) {
+  const completedColumns = "completedColumns" in index.options ? index.options.completedColumns : [];
+  const column = getTaskColumn(index, task);
+  return column !== null && completedColumns.indexOf(column) !== -1;
+}
+
+/**
+ * Check if a task is overdue - i.e. it has a due date in the past and hasn't been completed. A task
+ * with no due date is never overdue, and neither is a completed task, however late it was
+ * @param {object} index The index object
+ * @param {object} task The task object
+ * @return {boolean} True if the task is overdue
+ */
+function taskOverdue(index, task) {
+  if (!("due" in task.metadata) || taskCompleted(index, task)) {
+    return false;
+  }
+  return new Date() - task.metadata.due > 0;
+}
+
 /**
  * Flatten a task's metadata and computed values into a single object that can be used for sorting
  * @param {object} index The index object
@@ -298,6 +631,12 @@ function taskSortFields(index, task) {
     comments: task.comments.map((comment) => `${comment.author} ${comment.text}`).join("\n"),
     workload: taskWorkload(index, task),
     progress: taskProgress(index, task),
+    column: getTaskColumn(index, task) || "",
+    overdue: taskOverdue(index, task),
+    isStarted: taskStarted(index, task),
+    isCompleted: taskCompleted(index, task),
+    inStartedColumn: taskInStartedColumn(index, task),
+    inCompletedColumn: taskInCompletedColumn(index, task),
   };
 }
 
@@ -331,8 +670,11 @@ function sortColumnInIndex(index, tasks, columnName, sorters) {
   // Sort the tasks in the target column using their flattened sort fields
   tasks = sortTasksWithFields(index, tasks, sorters);
 
-  // Save the list of tasks back to the index
-  index.columns[columnName] = tasks.map((task) => task.id);
+  // Save the list of tasks back to the index. A task whose file is missing can't be loaded, so it
+  // isn't in the sorted list - keep it in the column rather than dropping it from the board
+  const sortedTaskIds = tasks.map((task) => task.id);
+  const unsortedTaskIds = index.columns[columnName].filter((taskId) => sortedTaskIds.indexOf(taskId) === -1);
+  index.columns[columnName] = [...sortedTaskIds, ...unsortedTaskIds];
   return index;
 }
 
@@ -511,6 +853,37 @@ function filterTasks(index, tasks, filters) {
       result = false;
     }
 
+    // Overdue
+    if ("overdue" in filters && !booleanFilter(filters.overdue, taskOverdue(index, task))) {
+      result = false;
+    }
+
+    // Started, from the task's metadata
+    if ("is-started" in filters && !booleanFilter(filters["is-started"], taskStarted(index, task))) {
+      result = false;
+    }
+
+    // Completed, from the task's metadata
+    if ("is-completed" in filters && !booleanFilter(filters["is-completed"], taskCompleted(index, task))) {
+      result = false;
+    }
+
+    // In a started column on this board
+    if (
+      "in-started-column" in filters &&
+      !booleanFilter(filters["in-started-column"], taskInStartedColumn(index, task))
+    ) {
+      result = false;
+    }
+
+    // In a completed column on this board
+    if (
+      "in-completed-column" in filters &&
+      !booleanFilter(filters["in-completed-column"], taskInCompletedColumn(index, task))
+    ) {
+      result = false;
+    }
+
     // Assigned
     if (
       "assigned" in filters &&
@@ -658,6 +1031,17 @@ function numberFilter(filter, input) {
   return input >= Math.min(...filter) && input <= Math.max(...filter);
 }
 
+/**
+ * Check if the input matches a boolean, or if multiple booleans are passed in, check if the input
+ * matches any of them
+ * @param {boolean|boolean[]} filter A filter boolean or array of filter booleans
+ * @param {boolean} input The value to match against
+ * @return {boolean} True if the input matches the boolean filter
+ */
+function booleanFilter(filter, input) {
+  return utility.arrayArg(filter).some((value) => !!value === !!input);
+}
+
 /**
  * Calculate task workload
  * @param {object} index The index object
@@ -781,17 +1165,37 @@ function getTaskProgressAtDate(task, date) {
   return Math.max(0, Math.min(progress, 1));
 }
 
+/**
+ * Check whether a history event counts when replaying for a board. An event belongs to a board if it
+ * names that board, or if it names none and we're replaying for the main board - which is exactly
+ * what makes every task file written before boards existed replay the way it always has
+ * @param {object} historyEvent The history event
+ * @param {?string} [boardSlug=null] The board being replayed for, or null for the main board
+ * @return {boolean} True if the event counts for this board
+ */
+function historyEventOnBoard(historyEvent, boardSlug = null) {
+  if (BOARD_AGNOSTIC_EVENT_TYPES.indexOf(historyEvent.type) !== -1) {
+    return true;
+  }
+  if ("board" in historyEvent && historyEvent.board) {
+    return historyEvent.board === boardSlug;
+  }
+  return boardSlug === null;
+}
+
 /**
  * Get timeline dates for a task in a period. For history-enabled tasks this uses all history event dates,
  * otherwise it falls back to created/started/completed dates.
  * @param {object} task
  * @param {Date} from
  * @param {Date} to
+ * @param {?string} [boardSlug=null] The board to replay for, or null for the main board
  * @return {Date[]}
  */
-function getTaskTimelineDates(task, from, to) {
+function getTaskTimelineDates(task, from, to, boardSlug = null) {
   if ("history" in task && Array.isArray(task.history) && task.history.length > 0) {
     return task.history
+      .filter((historyEvent) => historyEventOnBoard(historyEvent, boardSlug))
       .map((historyEvent) => historyEvent.date)
       .filter((date) => date && date >= from && date <= to);
   }
@@ -1150,13 +1554,15 @@ function countActiveTasksAtDate(index, tasks, date) {
  * @param {object} index
  * @param {object[]} tasks
  * @param {Date} date
+ * @param {?string} [boardSlug=null] The board to replay for, or null for the main board
  * @return {object[]} A list of event objects, with event type and task id
  */
-function getTaskEventsAtDate(index, tasks, date) {
+function getTaskEventsAtDate(index, tasks, date, boardSlug = null) {
   return tasks
     .map((task) => {
       if ("history" in task && Array.isArray(task.history) && task.history.length > 0) {
         return task.history
+          .filter((historyEvent) => historyEventOnBoard(historyEvent, boardSlug))
           .filter((historyEvent) => historyEvent.date && historyEvent.date.getTime() === date.getTime())
           .map((historyEvent) => ({
             eventType: historyEvent.type,
@@ -1280,20 +1686,103 @@ function updateColumnLinkedCustomField(
   return taskData;
 }
 
+// The parts of this module the actions engine needs. Passing them in rather than requiring main.js
+// from actions.js keeps the engine free of filesystem and workspace knowledge, and free of a
+// circular require
+const ACTION_HELPERS = {
+  filterTasks,
+  getTaskMetadata,
+  setTaskMetadata,
+  appendTaskHistory
+};
+
 class Kanbn {
   ROOT = process.cwd();
   CONFIG_YAML = path.join(this.ROOT, "kanbn.yml");
   CONFIG_JSON = path.join(this.ROOT, "kanbn.json");
 
-  // Memoize config
-  configMemo = null;
+  // The board this instance is scoped to, or null for the main board
+  boardSlug = null;
 
-  constructor(root = null) {
+  // Boards named in an archived task's metadata that no longer existed when it was restored, set by
+  // restoreTask() for the caller to report
+  lastRestoreWarnings = [];
+
+  // Rules that were skipped during the last operation, set by runActions() for the caller to report
+  lastActionWarnings = [];
+
+  // Whether scripted actions run for operations on this instance. Actions are ordinary declarative
+  // rules with no code execution, so this is a convenience for stepping around a misbehaving rule
+  // rather than a safety control
+  actionsEnabled = true;
+
+  /**
+   * @param {?string} [root=null] The workspace root folder
+   * @param {object} [options={}] Instance options: `board` scopes this instance to a board, `caches`
+   * lets a board-scoped clone share its parent's memoized config
+   */
+  constructor(root = null, options = {}) {
     if(root) {
       this.ROOT = root
       this.CONFIG_YAML = path.join(this.ROOT, "kanbn.yml");
       this.CONFIG_JSON = path.join(this.ROOT, "kanbn.json");
     }
+    this.caches = options.caches || { config: null, workspaceOptions: null };
+    this.boardSlug = options.board || null;
+    if (options.actions === false) {
+      this.actionsEnabled = false;
+    }
+  }
+
+  // Memoized config, kept in the shared cache object so that board-scoped clones don't each re-read it
+  get configMemo() {
+    return this.caches.config;
+  }
+
+  set configMemo(value) {
+    this.caches.config = value;
+  }
+
+  /**
+   * Get a copy of this instance scoped to another board. The returned instance shares this one's
+   * cached config, so scoping to a board costs no extra file reads
+   * @param {?string} [slug=null] The board slug, or null/"main"/"default" for the main board
+   * @return {Kanbn} A board-scoped Kanbn instance
+   */
+  board(slug = null) {
+    if (slug === null || slug === undefined || slug === "") {
+      return this.boardSlug === null
+        ? this
+        : new Kanbn(this.ROOT, { caches: this.caches, actions: this.actionsEnabled });
+    }
+    return new Kanbn(this.ROOT, {
+      board: String(slug).trim(),
+      caches: this.caches,
+      actions: this.actionsEnabled
+    });
+  }
+
+  /**
+   * Get an instance that runs no actions
+   *
+   * Used for the writes one operation makes on another's behalf - archiving removes the task from
+   * every board, and that removal is part of the archive, not a deletion anyone wrote a rule for
+   * @return {Kanbn} An instance with actions disabled
+   */
+  withoutActions() {
+    if (!this.actionsEnabled) {
+      return this;
+    }
+    return new Kanbn(this.ROOT, { board: this.boardSlug, caches: this.caches, actions: false });
+  }
+
+  /**
+   * Alias for board()
+   * @param {?string} [slug=null] The board slug
+   * @return {Kanbn} A board-scoped Kanbn instance
+   */
+  withBoard(slug = null) {
+    return this.board(slug);
   }
 
   /**
@@ -1313,6 +1802,7 @@ class Kanbn {
     } else {
       await fs.promises.writeFile(this.CONFIG_JSON, JSON.stringify(config, null, 4));
     }
+    this.caches.workspaceOptions = null;
   }
 
   /**
@@ -1344,7 +1834,8 @@ class Kanbn {
    * Clear cached config
    */
   clearConfigCache() {
-    this.configMemo = null;
+    this.caches.config = null;
+    this.caches.workspaceOptions = null;
   }
 
   /**
@@ -1404,11 +1895,64 @@ class Kanbn {
   }
 
   /**
-   * Get the index path
+   * Get the main board's slug. This is the index file name without its extension, so a workspace with
+   * a customised `indexFile` gets a main board slug to match
+   * @return {Promise<string>} The main board slug
+   */
+  async getMainBoardSlug() {
+    return boardSlugFromFileName(await this.getIndexFileName());
+  }
+
+  /**
+   * Resolve a board slug, mapping the reserved aliases and an absent slug onto the main board
+   * @param {?string} [slug=undefined] The board slug, defaulting to this instance's board
+   * @return {Promise<string>} The resolved board slug
+   */
+  async resolveBoardSlug(slug = undefined) {
+    if (slug === undefined) {
+      slug = this.boardSlug;
+    }
+    const mainBoardSlug = await this.getMainBoardSlug();
+    if (slug === null || slug === undefined || slug === "") {
+      return mainBoardSlug;
+    }
+    slug = String(slug).trim();
+    if (MAIN_BOARD_ALIASES.indexOf(slug.toLowerCase()) !== -1) {
+      return mainBoardSlug;
+    }
+    return slug;
+  }
+
+  /**
+   * Check if a slug refers to the main board
+   * @param {?string} [slug=undefined] The board slug, defaulting to this instance's board
+   * @return {Promise<boolean>} True if the slug refers to the main board
+   */
+  async isMainBoard(slug = undefined) {
+    return (await this.resolveBoardSlug(slug)) === (await this.getMainBoardSlug());
+  }
+
+  /**
+   * Get the file path for a board. The main board keeps its configured index file name, every other
+   * board is a sibling markdown file named after its slug
+   * @param {?string} [slug=undefined] The board slug, defaulting to this instance's board
+   * @return {Promise<string>} The board file path
+   */
+  async getBoardPath(slug = undefined) {
+    const resolvedSlug = await this.resolveBoardSlug(slug);
+    const mainFolder = await this.getMainFolder();
+    if (resolvedSlug === (await this.getMainBoardSlug())) {
+      return path.join(mainFolder, await this.getIndexFileName());
+    }
+    return path.join(mainFolder, `${resolvedSlug}.md`);
+  }
+
+  /**
+   * Get the index path. This is the path of the board this instance is scoped to
    * @return {Promise<string>} The kanbn index path
    */
   async getIndexPath() {
-    return path.join(await this.getMainFolder(), await this.getIndexFileName());
+    return this.getBoardPath();
   }
 
   /**
@@ -1469,8 +2013,6 @@ class Kanbn {
     if ("due" in task.metadata) {
       const dueData = {};
 
-      // A task is overdue if it's due date is in the past and the task is not in a completed column
-      // or doesn't have a completed dates
       const completedField = getCompletedField(index);
       const completedDate = completedField in task.metadata ? task.metadata[completedField] : null;
 
@@ -1487,7 +2029,7 @@ class Kanbn {
       dueData.completed = completed;
       dueData.completedDate = completedDate;
       dueData.dueDate = task.metadata.due;
-      dueData.overdue = !completed && delta > 0;
+      dueData.overdue = taskOverdue(index, task);
       dueData.dueDelta = delta;
 
       // Prepare a due message for the task
@@ -1518,61 +2060,304 @@ class Kanbn {
   }
 
   /**
-   * Overwrite the index file with the specified data
-   * @param {object} indexData Index data to save
+   * Get the workspace-scoped options. These live in the config file if there is one, and in the main
+   * board's front matter if there isn't - which means loading a secondary board also means reading the
+   * main board. The result is memoized so that costs one extra file read per process, not per board
+   * @return {Promise<object>} The workspace options
    */
-  async saveIndex(indexData) {
-    // Apply column sorting if any sorters are defined in options
-    if ("columnSorting" in indexData.options && Object.keys(indexData.options.columnSorting).length) {
-      for (let columnName in indexData.options.columnSorting) {
-        indexData = sortColumnInIndex(
-          indexData,
-          await this.loadAllTrackedTasks(indexData, columnName),
-          columnName,
-          indexData.options.columnSorting[columnName]
-        );
-      }
-    }
+  async getWorkspaceOptions() {
+    return (await this.loadWorkspaceOptions()).options;
+  }
 
-    // If there is a separate config file, save options to this file
-    let ignoreOptions = false;
-    if (await this.configExists()) {
-      await this.saveConfig(indexData.options);
-      ignoreOptions = true;
+  /**
+   * Load the workspace options along with where they came from, since that decides how much of them
+   * a secondary board inherits
+   * @return {Promise<{options: object, fromConfig: boolean}>} The workspace options and their source
+   */
+  async loadWorkspaceOptions() {
+    if (this.caches.workspaceOptions === null) {
+      const config = await this.getConfig();
+      if (config !== null) {
+        this.caches.workspaceOptions = { options: { ...config }, fromConfig: true };
+      } else {
+        let options = {};
+        try {
+          const mainBoardData = await fs.promises.readFile(
+            await this.getBoardPath(await this.getMainBoardSlug()),
+            { encoding: "utf-8" }
+          );
+          options = parseIndex.md2json(mainBoardData).options;
+        } catch (error) {
+          // A missing or unparseable main board leaves secondary boards with defaults only. This is
+          // reported by validate rather than thrown, so that one broken file doesn't break every board
+          options = {};
+        }
+        this.caches.workspaceOptions = { options, fromConfig: false };
+      }
     }
-
-    // Save index
-    await fs.promises.writeFile(await this.getIndexPath(), parseIndex.json2md(indexData, ignoreOptions));
+    return this.caches.workspaceOptions;
   }
 
   /**
-   * Load the index file and parse it to an object
-   * @return {Promise<object>} The index object
+   * Normalise a contributors option into a consistent object form. Exposed so that callers holding
+   * an index object (the VSCode extension, for one) don't have to reimplement the shorthand rules
+   * @param {any} contributors The raw contributors option
+   * @return {object[]} The normalised contributors
    */
-  async loadIndex() {
-    let indexData = "";
-    try {
-      indexData = await fs.promises.readFile(await this.getIndexPath(), { encoding: "utf-8" });
-    } catch (error) {
-      throw new Error(`Couldn't access index file: ${error.message}`);
-    }
-    const index = parseIndex.md2json(indexData);
+  normaliseContributors(contributors) {
+    return normaliseContributors(contributors);
+  }
 
-    // If configuration settings exist in a separate config file, merge them with index options
-    const config = await this.getConfig();
-    if (config !== null) {
-      index.options = { ...index.options, ...config };
-    }
-    return index;
+  /**
+   * Get the workspace's contributors, normalised to the object form
+   *
+   * Contributors are advisory: they're a convenience list, not an access control list, and nothing
+   * anywhere validates `assigned` or a comment `author` against them
+   * @return {Promise<object[]>} The normalised contributors, or an empty array if none are declared
+   */
+  async getContributors() {
+    return normaliseContributors((await this.getWorkspaceOptions()).contributors);
   }
 
   /**
-   * Overwrite a task file with the specified data
-   * @param {string} path The task path
-   * @param {object} taskData The task data
+   * Find the contributor a value refers to, matching against the canonical name, the display name
+   * and any aliases, case-insensitively
+   * @param {?string} value The value to look up
+   * @return {Promise<?object>} The matching contributor, or null if there isn't one
    */
-  async saveTask(path, taskData) {
-    await fs.promises.writeFile(path, parseTask.json2md(taskData));
+  async findContributor(value) {
+    return matchContributor(await this.getContributors(), value);
+  }
+
+  /**
+   * Work out who the current user is, as the value that would be written into `assigned` or a
+   * comment `author`
+   *
+   * In order, first match wins:
+   *  1. the KANBN_USER environment variable, used verbatim
+   *  2. `git config user.email` matched against a contributor's email
+   *  3. `git config user.name` matched against a contributor's name, display name or aliases
+   *  4. `git config user.name` as-is
+   *  5. null
+   *
+   * With no contributors declared this is exactly what the git username has always been, so a
+   * workspace that ignores contributors sees no change. With contributors declared it canonicalises:
+   * a machine whose git says "Gordon Larrigan" writes "gordon", because that's what the workspace has
+   * agreed to call him
+   * @return {Promise<?string>} The current user, or null if there's nothing to go on
+   */
+  async currentUser() {
+    // An explicitly set user is used exactly as given - it's the escape hatch for a machine whose
+    // git identity is wrong, or which has none
+    const envUser = (process.env.KANBN_USER || "").trim();
+    if (envUser) {
+      return envUser;
+    }
+
+    const contributors = await this.getContributors();
+    if (contributors.length) {
+      const byEmail = matchContributorEmail(contributors, gitUser.email());
+      if (byEmail !== null) {
+        return byEmail.name;
+      }
+      const byName = matchContributor(contributors, gitUser.name());
+      if (byName !== null) {
+        return byName.name;
+      }
+    }
+    return gitUser.name();
+  }
+
+  /**
+   * Get the options a secondary board inherits from the workspace. A config file is workspace-level
+   * by construction, so all of it is inherited; the main board's front matter is that board's own
+   * file, so only the workspace-scoped keys in it are
+   * @return {Promise<object>} The inherited options
+   */
+  async getInheritedBoardOptions() {
+    const { options, fromConfig } = await this.loadWorkspaceOptions();
+    if (fromConfig) {
+      return { ...options };
+    }
+    return Object.fromEntries(
+      Object.entries(options).filter(([key]) => WORKSPACE_INHERITED_OPTIONS.indexOf(key) !== -1)
+    );
+  }
+
+  /**
+   * Get the per-board options declared for a board in the config file's `boards` key, if any
+   * @param {?string} [slug=undefined] The board slug, defaulting to this instance's board
+   * @return {Promise<object>} The board's options from config, or an empty object
+   */
+  async getBoardConfig(slug = undefined) {
+    const resolvedSlug = await this.resolveBoardSlug(slug);
+    const config = await this.getConfig();
+    if (config === null || typeof config.boards !== "object" || config.boards === null) {
+      return {};
+    }
+    if (RESERVED_BOARDS_CONFIG_KEYS.indexOf(resolvedSlug) !== -1) {
+      return {};
+    }
+    const boardConfig = config.boards[resolvedSlug];
+    return typeof boardConfig === "object" && boardConfig !== null && !Array.isArray(boardConfig)
+      ? { ...boardConfig }
+      : {};
+  }
+
+  /**
+   * Layer a board's own front matter options over the workspace options
+   * @param {string} resolvedSlug The resolved board slug
+   * @param {object} ownOptions The options taken from the board file's front matter
+   * @return {Promise<object>} The resolved options
+   */
+  async resolveBoardOptions(resolvedSlug, ownOptions) {
+    // The main board is where the workspace options live, so there is nothing to layer: this is
+    // exactly the behaviour Kanbn has always had
+    if (resolvedSlug === (await this.getMainBoardSlug())) {
+      const config = await this.getConfig();
+      return config !== null ? { ...ownOptions, ...config } : { ...ownOptions };
+    }
+
+    // Workspace-scoped keys in a secondary board's front matter are ignored - one task file has to
+    // parse identically for every board that references it. validate reports them
+    return {
+      ...(await this.getInheritedBoardOptions()),
+      ...(await this.getBoardConfig(resolvedSlug)),
+      ...omitKeys(ownOptions, WORKSPACE_SCOPED_OPTIONS),
+    };
+  }
+
+  /**
+   * Work out which options belong in a secondary board's own front matter, so that options inherited
+   * from the workspace aren't copied into every board file the first time it is saved
+   * @param {string} resolvedSlug The resolved board slug
+   * @param {object} indexData The board data being saved
+   * @return {Promise<object>} The options to write to the board file's front matter
+   */
+  async getOwnBoardOptions(resolvedSlug, indexData) {
+    const previousOwnOptions = indexData.ownOptions ? { ...indexData.ownOptions } : {};
+    const inheritedOptions = {
+      ...(await this.getInheritedBoardOptions()),
+      ...(await this.getBoardConfig(resolvedSlug)),
+    };
+    const options = indexData.options || {};
+    const ownOptions = { ...previousOwnOptions };
+    for (const [key, value] of Object.entries(options)) {
+      if (WORKSPACE_SCOPED_OPTIONS.indexOf(key) !== -1) {
+        continue;
+      }
+
+      // Keep anything the board already declared, and pick up anything that differs from what the
+      // workspace provides - i.e. anything this operation actually changed
+      if (key in previousOwnOptions || !(key in inheritedOptions) || !sameOptionValue(inheritedOptions[key], value)) {
+        ownOptions[key] = value;
+      }
+    }
+
+    // Drop anything that has been removed from the board's options entirely
+    for (const key of Object.keys(ownOptions)) {
+      if (!(key in options)) {
+        delete ownOptions[key];
+      }
+    }
+    return ownOptions;
+  }
+
+  /**
+   * Overwrite a board file with the specified data
+   * @param {?string} slug The board slug, or null for the main board
+   * @param {object} indexData Board data to save
+   */
+  async saveBoard(slug, indexData) {
+    const resolvedSlug = await this.resolveBoardSlug(slug);
+
+    // Apply column sorting if any sorters are defined in options
+    if ("columnSorting" in indexData.options && Object.keys(indexData.options.columnSorting).length) {
+      for (let columnName in indexData.options.columnSorting) {
+        indexData = sortColumnInIndex(
+          indexData,
+          await this.loadAllTrackedTasks(indexData, columnName),
+          columnName,
+          indexData.options.columnSorting[columnName]
+        );
+      }
+    }
+
+    const boardPath = await this.getBoardPath(resolvedSlug);
+    if (resolvedSlug === (await this.getMainBoardSlug())) {
+
+      // If there is a separate config file, save options to this file
+      let ignoreOptions = false;
+      if (await this.configExists()) {
+        await this.saveConfig(indexData.options);
+        ignoreOptions = true;
+      }
+
+      // The main board owns the workspace options, so any cached copy is now stale
+      this.caches.workspaceOptions = null;
+      await fs.promises.writeFile(boardPath, parseIndex.json2md(indexData, ignoreOptions));
+      return;
+    }
+
+    // A secondary board's options always live in its own front matter, and workspace-scoped options
+    // are never written to the config file as a side effect of a board-local operation
+    const ownOptions = await this.getOwnBoardOptions(resolvedSlug, indexData);
+    await fs.promises.writeFile(
+      boardPath,
+      parseIndex.json2md({ ...indexData, options: ownOptions }, false)
+    );
+  }
+
+  /**
+   * Load a board file and parse it to an object
+   * @param {?string} [slug=undefined] The board slug, defaulting to this instance's board
+   * @return {Promise<object>} The board object
+   */
+  async loadBoard(slug = undefined) {
+    const resolvedSlug = await this.resolveBoardSlug(slug);
+    const isMainBoard = resolvedSlug === (await this.getMainBoardSlug());
+    let boardData = "";
+    try {
+      boardData = await fs.promises.readFile(await this.getBoardPath(resolvedSlug), { encoding: "utf-8" });
+    } catch (error) {
+      throw new Error(
+        isMainBoard
+          ? `Couldn't access index file: ${error.message}`
+          : `Couldn't access board file for board "${resolvedSlug}": ${error.message}`
+      );
+    }
+    const index = parseIndex.md2json(boardData);
+
+    // Remember which options came from this board's own front matter, so that saving it again doesn't
+    // persist everything it inherited from the workspace
+    setOwnOptions(index, index.options);
+    index.options = await this.resolveBoardOptions(resolvedSlug, index.options);
+    return index;
+  }
+
+  /**
+   * Overwrite the index file with the specified data
+   * @param {object} indexData Index data to save
+   */
+  async saveIndex(indexData) {
+    return this.saveBoard(this.boardSlug, indexData);
+  }
+
+  /**
+   * Load the index file and parse it to an object
+   * @return {Promise<object>} The index object
+   */
+  async loadIndex() {
+    return this.loadBoard(this.boardSlug);
+  }
+
+  /**
+   * Overwrite a task file with the specified data
+   * @param {string} path The task path
+   * @param {object} taskData The task data
+   */
+  async saveTask(path, taskData) {
+    await fs.promises.writeFile(path, parseTask.json2md(taskData));
   }
 
   /**
@@ -1601,11 +2386,262 @@ class Kanbn {
     const result = [];
     const trackedTasks = getTrackedTaskIds(index, columnName);
     for (let taskId of trackedTasks) {
-      result.push(await this.loadTask(taskId));
+      try {
+        result.push(await this.loadTask(taskId));
+      } catch (error) {
+
+        // A board referencing a task file that doesn't exist is a broken reference, not a reason to
+        // fail: it happens whenever a board file and a task file arrive in different commits. Skip
+        // it and carry on - findMissingTaskFiles() and validate report it. Anything else (an
+        // unreadable or unparseable file) still throws, because that is a file with contents that
+        // can't be trusted rather than a file that isn't there
+        if (!(await this.taskFileExists(taskId))) {
+          continue;
+        }
+        throw error;
+      }
     }
     return result;
   }
 
+  /**
+   * Find tasks that this board references but which have no task file
+   * @param {?object} [index=null] The index object, or null to load it
+   * @return {Promise<object[]>} A list of {task, column} for each missing task file
+   */
+  async findMissingTaskFiles(index = null) {
+    if (index === null) {
+      index = await this.getIndex();
+    }
+    const missing = [];
+    for (const [columnName, taskIds] of Object.entries(index.columns)) {
+      for (const taskId of taskIds) {
+        if (!(await this.taskFileExists(taskId))) {
+          missing.push({ task: taskId, column: columnName });
+        }
+      }
+    }
+    return missing;
+  }
+
+  /**
+   * Get this board's simple tasks - lines in a column that aren't task links. A simple task has a
+   * title and a column and nothing else: no id, no metadata, no dates, and no presence in any of
+   * kanbn's reporting. It can be moved, removed, or promoted into a real task
+   *
+   * When an input string is given, this returns the simple tasks matching it. Real tasks always win,
+   * so callers should resolve a task id first and only fall back to this when nothing matched
+   * @param {?string} [input=null] A title to match, or null for every simple task on this board
+   * @param {?object} [index=null] The index object, or null to load it
+   * @return {Promise<object[]>} The matching simple tasks, each with a column, position and text
+   */
+  async findSimpleTasks(input = null, index = null) {
+    if (index === null) {
+      index = await this.getIndex();
+    }
+    const simpleTasks = [];
+    for (const [columnName, entries] of Object.entries(index.columnContent || {})) {
+      for (const entry of entries) {
+        if (isSimpleTask(entry)) {
+          simpleTasks.push({ column: columnName, position: entry.position, text: entry.text, raw: entry.raw });
+        }
+      }
+    }
+    if (input === null) {
+      return simpleTasks;
+    }
+
+    // Match on the title exactly first, then ignoring case, then on the slugified title, so that
+    // `kanbn move "Buy milk"` and `kanbn move buy-milk` both find the same line
+    const matchers = [
+      (simpleTask) => simpleTask.text === input,
+      (simpleTask) => simpleTask.text.toLowerCase() === String(input).toLowerCase(),
+      (simpleTask) => utility.getTaskId(simpleTask.text) === utility.getTaskId(String(input)),
+    ];
+    for (const matcher of matchers) {
+      const matches = simpleTasks.filter(matcher);
+      if (matches.length) {
+        return matches;
+      }
+    }
+    return [];
+  }
+
+  /**
+   * Resolve a string to exactly one simple task on this board, or throw
+   * @param {string} input The title to match
+   * @param {?object} [index=null] The index object, or null to load it
+   * @return {Promise<object>} The matching simple task
+   */
+  async getSimpleTask(input, index = null) {
+    const matches = await this.findSimpleTasks(input, index);
+    if (!matches.length) {
+      throw new Error(`No simple task found matching "${input}"`);
+    }
+
+    // Two lines with the same title are two different lines, and picking one of them silently would
+    // eventually move or delete the wrong one
+    if (matches.length > 1) {
+      throw new Error(
+        `"${input}" matches ${matches.length} simple tasks (${matches
+          .map((match) => `"${match.text}" in ${match.column}`)
+          .join(", ")})`
+      );
+    }
+    return matches[0];
+  }
+
+  /**
+   * Move a simple task to another column on this board
+   * @param {string} input The title to match
+   * @param {string} columnName The column to move it to
+   * @param {?number} [position=null] The position in the target column, or the end of it if null
+   * @return {Promise<object>} The simple task that was moved, with the column it came from
+   */
+  async moveSimpleTask(input, columnName, position = null) {
+    let index = await this.getIndex();
+    if (!(columnName in index.columns)) {
+      throw new Error(`Column "${columnName}" doesn't exist`);
+    }
+    const simpleTask = await this.getSimpleTask(input, index);
+    index = removeColumnContent(index, simpleTask.column, simpleTask.position);
+    index = addColumnContent(index, columnName, { text: simpleTask.text, raw: simpleTask.raw }, position);
+    await this.saveIndex(index);
+    return { ...simpleTask, toColumn: columnName };
+  }
+
+  /**
+   * Move a simple task from this board onto another one. A simple task is content in a board file
+   * rather than a shared task file, so this moves the line: it leaves this board and joins the other
+   * @param {string} input The title to match
+   * @param {string} targetSlug The board to move it to
+   * @param {?string} [columnName=null] The column on the target board, or its first column if null
+   * @param {?number} [position=null] The position in the target column, or the end of it if null
+   * @return {Promise<object>} The simple task that was moved, with the board and column it went to
+   */
+  async moveSimpleTaskToBoard(input, targetSlug, columnName = null, position = null) {
+    const target = this.board(targetSlug);
+    const targetBoardSlug = await target.resolveBoardSlug();
+    if (!(await target.initialised())) {
+      throw new Error(`Board "${targetBoardSlug}" doesn't exist`);
+    }
+    if (targetBoardSlug === (await this.resolveBoardSlug())) {
+      throw new Error(`Simple task "${input}" is already on board "${targetBoardSlug}"`);
+    }
+    let index = await this.getIndex();
+    const simpleTask = await this.getSimpleTask(input, index);
+    let targetIndex = await target.getIndex();
+    const targetColumnNames = Object.keys(targetIndex.columns);
+    if (!targetColumnNames.length) {
+      throw new Error(`Board "${targetBoardSlug}" has no columns`);
+    }
+    const targetColumn = columnName === null ? targetColumnNames[0] : columnName;
+    if (!(targetColumn in targetIndex.columns)) {
+      throw new Error(`Column "${targetColumn}" doesn't exist on board "${targetBoardSlug}"`);
+    }
+
+    // Write the target board first: a line that ends up on both boards is visible and easy to fix,
+    // where a line removed from one board and never added to the other is gone
+    targetIndex = addColumnContent(
+      targetIndex,
+      targetColumn,
+      { text: simpleTask.text, raw: simpleTask.raw },
+      position
+    );
+    await target.saveIndex(targetIndex);
+    index = removeColumnContent(index, simpleTask.column, simpleTask.position);
+    await this.saveIndex(index);
+    return { ...simpleTask, toBoard: targetBoardSlug, toColumn: targetColumn };
+  }
+
+  /**
+   * Remove a simple task from this board. There is no file to delete and nothing to archive - the
+   * line is the whole of it
+   * @param {string} input The title to match
+   * @return {Promise<object>} The simple task that was removed
+   */
+  async deleteSimpleTask(input) {
+    let index = await this.getIndex();
+    const simpleTask = await this.getSimpleTask(input, index);
+    index = removeColumnContent(index, simpleTask.column, simpleTask.position);
+    await this.saveIndex(index);
+    return simpleTask;
+  }
+
+  /**
+   * Turn a simple task into a real task file, in the column it was already in. The created date is
+   * the moment of promotion: a line carries no history, so there is no earlier date to know
+   * @param {string} input The title to match
+   * @param {?string} [columnName=null] The column to create the task in, or its own column if null
+   * @return {Promise<string>} The id of the task that was created
+   */
+  async promoteSimpleTask(input, columnName = null) {
+    const index = await this.getIndex();
+    const simpleTask = await this.getSimpleTask(input, index);
+    const targetColumn = columnName === null ? simpleTask.column : columnName;
+    if (!(targetColumn in index.columns)) {
+      throw new Error(`Column "${targetColumn}" doesn't exist`);
+    }
+
+    // Check for a clash before writing anything, so that a promotion that can't happen doesn't take
+    // the line with it
+    const taskId = utility.getTaskId(simpleTask.text);
+    if (await this.taskFileExists(taskId)) {
+      throw new Error(`A task with id "${taskId}" already exists`);
+    }
+    if (taskInIndex(index, taskId)) {
+      throw new Error(`A task with id "${taskId}" is already in the index`);
+    }
+
+    // Create the task first: a leftover line beside a real task is reported by validate and is easy
+    // to fix, where a line deleted for a task that was never created is gone
+    await this.createTask({ name: simpleTask.text }, targetColumn);
+    await this.saveIndex(removeColumnContent(await this.getIndex(), simpleTask.column, simpleTask.position));
+    return taskId;
+  }
+
+  /**
+   * Find lines in this board's columns that aren't task links. These are preserved verbatim and
+   * ignored by every command, but a line that looks like it was meant to be a task link is worth
+   * pointing out - it's the one way a task can silently stop being tracked
+   * @param {?object} [index=null] The index object, or null to load it
+   * @return {Promise<object[]>} A list of warnings, each with a board, column, type and message
+   */
+  async findColumnContentWarnings(index = null) {
+    if (index === null) {
+      index = await this.getIndex();
+    }
+    const boardSlug = await this.resolveBoardSlug();
+    const warnings = [];
+    for (const [columnName, entries] of Object.entries(index.columnContent || {})) {
+      for (const entry of entries) {
+
+        // A line that starts with link punctuation was probably meant to be a task link and has a
+        // typo in it, which would otherwise look exactly like a task that has vanished from the
+        // board. A checkbox item is an ordinary line, not a broken link
+        let type = "non-task-line";
+        let message = `column "${columnName}" contains a line that isn't a task link: ${entry.raw}`;
+        if (looksLikeMalformedTaskLink(entry.raw)) {
+          type = "malformed-task-link";
+          message = `column "${columnName}" contains a line that looks like a malformed task link: ${entry.raw}`;
+
+          // A line naming a task file that exists is almost certainly a task the user expects to be
+          // tracked, written without the link. It isn't, and this is the only warning that says so
+        } else if (
+          (await this.taskFileExists(entry.text)) ||
+          (await this.taskFileExists(utility.getTaskId(entry.text)))
+        ) {
+          type = "untracked-task-line";
+          message =
+            `column "${columnName}" contains a line naming a task file that exists, but it isn't a ` +
+            `link so the task isn't tracked: ${entry.raw}`;
+        }
+        warnings.push({ board: boardSlug, column: columnName, type, text: entry.text, message });
+      }
+    }
+    return warnings;
+  }
+
   /**
    * Load a task file from the archive and parse it to an object
    * @param {string} taskId The task id
@@ -1648,11 +2684,703 @@ class Kanbn {
     return await exists(await this.getIndexPath());
   }
 
+  /**
+   * Check if the workspace has been initialised, regardless of which board this instance is scoped to
+   * @return {Promise<boolean>} True if the main board exists
+   */
+  async workspaceInitialised() {
+    return await exists(await this.getBoardPath(await this.getMainBoardSlug()));
+  }
+
+  /**
+   * Get the slugs that can't be used for a board, because they would collide with the main board, one
+   * of its aliases, or one of the workspace's folders
+   * @return {Promise<string[]>} The reserved board slugs
+   */
+  async getReservedBoardSlugs() {
+    return [
+      ...MAIN_BOARD_ALIASES,
+      DEFAULT_INDEX_FILE_NAME,
+      boardSlugFromFileName(DEFAULT_INDEX_FILE_NAME),
+      await this.getMainBoardSlug(),
+      DEFAULT_TASKS_FOLDER_NAME,
+      DEFAULT_ARCHIVE_FOLDER_NAME,
+      await this.getTaskFolderName(),
+      await this.getArchiveFolderName(),
+    ];
+  }
+
+  /**
+   * Check that a slug can be used for a new board, throwing a descriptive error if it can't
+   * @param {string} slug The board slug to check
+   * @return {Promise<string>} The validated slug
+   */
+  async validateBoardSlug(slug) {
+    if (!slug || typeof slug !== "string" || !slug.trim()) {
+      throw new Error("Board slug cannot be empty");
+    }
+    slug = slug.trim();
+    if (slug !== utility.paramCase(slug)) {
+      throw new Error(`Board slug "${slug}" is not valid, try "${utility.paramCase(slug)}"`);
+    }
+    if ((await this.getReservedBoardSlugs()).indexOf(slug) !== -1) {
+      throw new Error(`Board slug "${slug}" is reserved`);
+    }
+    return slug;
+  }
+
+  /**
+   * Get the boards config from the config file, i.e. the exclude list and display order
+   * @return {Promise<{exclude: string[], order: string[]}>} The boards config
+   */
+  async getBoardsConfig() {
+    const config = await this.getConfig();
+    const boards =
+      config !== null && typeof config.boards === "object" && config.boards !== null && !Array.isArray(config.boards)
+        ? config.boards
+        : {};
+    return {
+      exclude: (Array.isArray(boards.exclude) ? boards.exclude : []).map(boardSlugFromFileName),
+      order: (Array.isArray(boards.order) ? boards.order : []).map(boardSlugFromFileName),
+    };
+  }
+
+  /**
+   * Find all boards in the workspace. Boards are discovered by globbing markdown files directly inside
+   * the main folder, so the task and archive folders are excluded by construction. A file counts as a
+   * board if it parses as an index; anything that doesn't is ignored here and reported by validate
+   * @return {Promise<object[]>} A list of boards, main board first unless an explicit order says otherwise
+   */
+  async listBoards() {
+    const mainFolder = await this.getMainFolder();
+    if (!(await exists(mainFolder))) {
+      return [];
+    }
+    const mainBoardSlug = await this.getMainBoardSlug();
+    const { exclude, order } = await this.getBoardsConfig();
+    const boardPaths = await glob(`${mainFolder}/*.md`);
+    const boards = [];
+    for (const boardPath of boardPaths) {
+      const slug = boardSlugFromFileName(boardPath);
+      if (exclude.indexOf(slug) !== -1) {
+        continue;
+      }
+      let boardData = null;
+      try {
+        boardData = parseIndex.md2json(await fs.promises.readFile(boardPath, { encoding: "utf-8" }));
+      } catch (error) {
+        continue;
+      }
+      boards.push({
+        slug,
+        path: boardPath,
+        name: boardData.name,
+        description: boardData.description,
+        main: slug === mainBoardSlug,
+      });
+    }
+
+    // Order: anything named in the config order first, in that order, then the main board, then the
+    // rest alphabetically
+    boards.sort((a, b) => {
+      const aOrder = order.indexOf(a.slug), bOrder = order.indexOf(b.slug);
+      if (aOrder !== -1 || bOrder !== -1) {
+        if (aOrder === -1) { return 1; }
+        if (bOrder === -1) { return -1; }
+        return aOrder - bOrder;
+      }
+      if (a.main !== b.main) {
+        return a.main ? -1 : 1;
+      }
+      return a.slug.localeCompare(b.slug);
+    });
+    return boards;
+  }
+
+  /**
+   * Work out which board a command should target: the --board argument, then the KANBN_BOARD
+   * environment variable, then the defaultBoard option, then the main board
+   * @param {?string} [slug=null] The board slug given on the command line, if any
+   * @return {Promise<?string>} The target board slug, or null for the main board
+   */
+  async resolveTargetBoard(slug = null) {
+    if (slug !== null && slug !== undefined && String(slug).trim() !== "") {
+      return String(slug).trim();
+    }
+    if (process.env.KANBN_BOARD && process.env.KANBN_BOARD.trim() !== "") {
+      return process.env.KANBN_BOARD.trim();
+    }
+    const workspaceOptions = await this.getWorkspaceOptions();
+    if (workspaceOptions.defaultBoard && String(workspaceOptions.defaultBoard).trim() !== "") {
+      return String(workspaceOptions.defaultBoard).trim();
+    }
+    return null;
+  }
+
+  /**
+   * Get a Kanbn instance scoped to the board a command's arguments point at
+   * @param {object} [args={}] The parsed command arguments
+   * @return {Promise<Kanbn>} A board-scoped Kanbn instance
+   */
+  async boardFromArgs(args = {}) {
+    return this.board(await this.resolveTargetBoard(utility.strArg(args.board) || null));
+  }
+
+  /**
+   * List boards with the information `kanbn boards` displays: everything listBoards() returns, plus
+   * column and task counts, completion percentage and the file's last modified date
+   * @return {Promise<object[]>} A list of boards with summary information
+   */
+  async getBoardsSummary() {
+    const boards = await this.listBoards();
+    const result = [];
+    for (const board of boards) {
+      const summary = { ...board, columns: 0, tasks: 0, completed: 0, completedPercentage: 0, modified: null };
+      try {
+        const boardData = await this.loadBoard(board.slug);
+        const tasks = await this.loadAllTrackedTasks(boardData);
+        summary.columns = Object.keys(boardData.columns).length;
+        summary.tasks = tasks.length;
+        summary.completed = tasks.filter((task) => taskCompleted(boardData, task)).length;
+        summary.completedPercentage = summary.tasks
+          ? Math.round((summary.completed / summary.tasks) * 100)
+          : 0;
+      } catch (error) {
+        // A board that can't be loaded is still worth listing; validate reports the reason
+      }
+      try {
+        summary.modified = (await fs.promises.stat(board.path)).mtime;
+      } catch (error) {
+        summary.modified = null;
+      }
+      result.push(summary);
+    }
+    return result;
+  }
+
+  /**
+   * Get every task that appears on more than one board, with the column it occupies on each
+   * @param {boolean} [allTasks=false] True to include tasks that only appear on one board
+   * @return {Promise<object[]>} A list of tasks and their board membership
+   */
+  async getCrossBoardTasks(allTasks = false) {
+    const membership = {};
+    for (const board of await this.listBoards()) {
+      let boardData = null;
+      try {
+        boardData = await this.loadBoard(board.slug);
+      } catch (error) {
+        continue;
+      }
+      for (const [columnName, taskIds] of Object.entries(boardData.columns)) {
+        for (const taskId of taskIds) {
+          if (!(taskId in membership)) {
+            membership[taskId] = {};
+          }
+          membership[taskId][board.slug] = columnName;
+        }
+      }
+    }
+    return Object.entries(membership)
+      .filter(([, boards]) => allTasks || Object.keys(boards).length > 1)
+      .map(([id, boards]) => ({ id, boards }))
+      .sort((a, b) => a.id.localeCompare(b.id));
+  }
+
+  /**
+   * Get the value to record in a history event's `board` key for this instance's board. The main
+   * board records nothing, which is what keeps existing task files valid and unchanged
+   * @return {Promise<?string>} The board slug, or null for the main board
+   */
+  async historyBoard() {
+    return (await this.isMainBoard()) ? null : await this.resolveBoardSlug();
+  }
+
+  /**
+   * Get the action rules that apply to this board
+   *
+   * Rules layer like any other option: a config file value applies workspace-wide, a board's own
+   * front matter applies to that board. `actionsFile` points at a file holding the same list, for
+   * workspaces whose rule sets have outgrown their front matter
+   * @param {?object} [index=null] The index object, or null to load it
+   * @return {Promise<object[]>} The rules
+   */
+  async getActionRules(index = null) {
+    if (index === null) {
+      index = await this.getIndex();
+    }
+    const options = index.options || {};
+    const inlineActions = "actions" in options && options.actions !== null;
+    const actionsFile = "actionsFile" in options && options.actionsFile ? String(options.actionsFile) : null;
+
+    // One overriding or extending the other would invent a second merge rule for the sake of a case
+    // nobody needs, so having both is an error the author has to resolve
+    if (inlineActions && actionsFile !== null) {
+      throw new Error('"actions" and "actionsFile" can\'t both be set - use one or the other');
+    }
+    if (actionsFile !== null) {
+      const filePath = path.join(await this.getMainFolder(), actionsFile);
+      if (!(await exists(filePath))) {
+        throw new Error(`actionsFile "${actionsFile}" doesn't exist`);
+      }
+
+      // A rule set that quietly stops existing is worse than one that fails loudly, so an
+      // unreadable or unparseable file is an error rather than "no rules"
+      return actions.parseActionsFile(await fs.promises.readFile(filePath, { encoding: "utf-8" }), actionsFile);
+    }
+    return actions.normaliseRules(options.actions || []);
+  }
+
+  /**
+   * Check whether actions should run at all
+   * @return {boolean} True if actions are enabled
+   */
+  actionsAllowed() {
+    if (!this.actionsEnabled) {
+      return false;
+    }
+    const disabled = process.env.KANBN_NO_ACTIONS;
+    return !(disabled && disabled !== "0" && disabled !== "false");
+  }
+
+  /**
+   * Get the value to record in a history event's `board` key for another board
+   * @param {string} slug The board slug
+   * @return {Promise<?string>} The board slug, or null for the main board
+   */
+  async historyBoardFor(slug) {
+    return slug === (await this.getMainBoardSlug()) ? null : slug;
+  }
+
+  /**
+   * Run the rules that match an event and fold everything they produce into the in-memory state
+   *
+   * Nothing is written here. Every verb becomes a patch to a task or to the index that the operation
+   * was already going to write, which is what makes a rule that fails leave the workspace alone, and
+   * what makes "actions never fire actions" structural: the writes this produces are performed with
+   * no event assembly at all
+   * @param {object} params The event, the in-memory index and task, and the operation's timestamp
+   * @return {Promise<?object>} The action result, or null if no rules ran
+   */
+  async runActions({ eventTypes, index, taskId, taskData, payload, date, taskBoards = null }) {
+    this.lastActionWarnings = [];
+    if (!this.actionsAllowed()) {
+      return null;
+    }
+    const boardSlug = await this.resolveBoardSlug();
+
+    // A task on its way to being created hasn't been through the parser yet, so it has no id. The
+    // filter vocabulary and the relation graph are both keyed on it
+    if (!taskData.id) {
+      taskData.id = taskId;
+    }
+    const rules = await this.getActionRules(index);
+
+    // Archiving, restoring and deleting affect every board, so the board a command happened to be
+    // run from is an arbitrary choice of whose rules to fire. A rule elsewhere can opt in to hearing
+    // about them whoever triggered them - which is why this is collected before the early return:
+    // a board with no rules of its own can still be the one an archive was run from
+    let borrowed = [];
+    if (
+      taskBoards !== false &&
+      eventTypes.some((eventType) => actions.WORKSPACE_WIDE_EVENTS.indexOf(eventType) !== -1) &&
+      (await this.listBoards()).length > 1
+    ) {
+      borrowed = await this.borrowedActionRules(taskId, boardSlug, eventTypes, taskBoards);
+    }
+    if (!rules.length && !borrowed.length) {
+      return null;
+    }
+
+    // Configuration errors fail the operation before anything is written. Checking the whole rule
+    // set rather than just the matching rules means a typo is reported the first time any command
+    // runs, not the first time that one rule would have fired
+    if (rules.length) {
+      const context = { columns: Object.keys(index.columns) };
+      if (
+        rules.some(
+          (rule) =>
+            Array.isArray(rule.then) &&
+            rule.then.some((verb) => verb !== null && typeof verb === "object" && "addToBoard" in verb)
+        )
+      ) {
+        context.boards = (await this.listBoards()).map((board) => board.slug);
+      }
+      const errors = actions.findRuleErrors(rules, context);
+      if (errors.length) {
+        throw new Error(`Invalid actions:${errors.map((error) => `\n  ${error}`).join("")}`);
+      }
+    }
+
+    // This board's rules run first, then the ones that asked to listen from elsewhere
+    const relevant = [...rules.filter((rule) => eventTypes.indexOf(rule.on) !== -1), ...borrowed];
+    if (!relevant.length) {
+      return null;
+    }
+    const result = await actions.run({
+      rules: relevant,
+      eventTypes,
+      payload: { ...payload, board: boardSlug, boardSlug, isMainBoard: await this.isMainBoard() },
+      index,
+      task: taskData,
+      date,
+      user: await this.currentUser(),
+      boardSlug,
+      helpers: ACTION_HELPERS,
+      loadTask: async (id) => {
+        try {
+          return await this.loadTask(id);
+        } catch (error) {
+          return null;
+        }
+      },
+      loadAllTasks: async () => await this.loadAllTrackedTasks(index)
+    });
+
+    // Appended rather than replaced: collecting the rules can warn too, and those warnings matter
+    this.lastActionWarnings.push(...result.warnings);
+
+    // Board memberships and cross-task moves are recorded in the task's history the same way the
+    // equivalent manual operations are, attributed to the rule rather than to a person
+    for (const add of result.patch.boardAdds) {
+      taskData = appendTaskHistory(
+        taskData,
+        { date, type: "added", column: add.column },
+        await this.historyBoardFor(add.board),
+        add.author
+      );
+    }
+    for (const target of result.targets) {
+      for (const add of target.boardAdds) {
+        target.task = appendTaskHistory(
+          target.task,
+          { date, type: "added", column: add.column },
+          await this.historyBoardFor(add.board),
+          add.author
+        );
+      }
+      if (target.moveTo === null) {
+        continue;
+      }
+
+      // A target that isn't on this board has no row in this index to move, and a target already in
+      // the column it would be moved to is a no-op rather than an event
+      if (!taskInIndex(index, target.task.id)) {
+        this.lastActionWarnings.push(
+          `skipped moving "${target.task.id}": it isn't on board "${boardSlug}"`
+        );
+        target.moveTo = null;
+        continue;
+      }
+      const fromColumn = findTaskColumn(index, target.task.id);
+      if (fromColumn === target.moveTo.column) {
+        target.moveTo = null;
+        continue;
+      }
+      target.task = appendTaskHistory(
+        target.task,
+        { date, type: "moved", fromColumn, toColumn: target.moveTo.column },
+        await this.historyBoard(),
+        target.moveTo.author
+      );
+      target.task = setTaskMetadata(target.task, "updated", date);
+      index = removeTaskFromIndex(index, target.task.id);
+      index = addTaskToIndex(index, target.task.id, target.moveTo.column, target.moveTo.position);
+    }
+    result.index = index;
+    result.taskData = taskData;
+    return result;
+  }
+
+  /**
+   * Collect the rules on other boards that have opted in to hearing about a workspace-wide event
+   *
+   * Board membership is per-board data and can't conflict, but rule verbs write the single shared
+   * task file, where two boards' rules genuinely can. So the acting board decides what gets written
+   * by default, and a rule elsewhere has to say that it wants to listen
+   * @param {string} taskId The task the event fired for
+   * @param {string} boardSlug The acting board
+   * @param {string[]} eventTypes The events that fired
+   * @param {?string[]} [knownBoards=null] The boards this operation affects, when the index can't say
+   * @return {Promise<object[]>} The rules to run after this board's own
+   */
+  async borrowedActionRules(taskId, boardSlug, eventTypes, knownBoards = null) {
+    // A task being restored isn't on any board yet, so the caller has to say which boards it is
+    // about to rejoin. Everywhere else the index is the authority
+    const taskBoards = (knownBoards === null
+      ? Object.keys(await this.findTaskBoards(taskId))
+      : knownBoards
+    ).filter((slug) => slug !== boardSlug);
+    if (!taskBoards.length) {
+      return [];
+    }
+
+    // Board order is whatever `kanbn boards` shows, so which rule wins when two of them write the
+    // same field is at least stable and inspectable
+    const ordered = (await this.listBoards()).map((board) => board.slug).filter((slug) => taskBoards.indexOf(slug) !== -1);
+    const borrowed = [];
+    for (const slug of ordered) {
+      const otherBoard = this.board(slug);
+      let otherRules = [];
+      try {
+        otherRules = await otherBoard.getActionRules();
+      } catch (error) {
+        this.lastActionWarnings.push(`skipped board "${slug}" rules: ${error.message}`);
+        continue;
+      }
+      const listening = otherRules.filter((rule) => rule.anyBoard === true && eventTypes.indexOf(rule.on) !== -1);
+      if (!listening.length) {
+        continue;
+      }
+
+      // Another board's mistake shouldn't fail a command that didn't ask for that board. Its rules
+      // are skipped instead, and kanbn validate --all-boards reports why
+      const errors = actions.findRuleErrors(listening, {
+        columns: Object.keys((await otherBoard.getIndex()).columns)
+      });
+      if (errors.length) {
+        this.lastActionWarnings.push(`skipped board "${slug}" rules: ${errors[0]}`);
+        continue;
+      }
+      borrowed.push(...listening);
+    }
+    return borrowed;
+  }
+
+  /**
+   * Write the task files and board memberships a rule asked for
+   *
+   * These come after the operation's own writes because they are separate files: the patches were
+   * all computed before anything was written, so a failure here can't leave a half-applied rule
+   * @param {?object} result The action result, or null if no rules ran
+   * @param {string} taskId The id of the task the event fired for
+   */
+  async completeActions(result, taskId) {
+    if (result === null) {
+      return;
+    }
+    const taskFolder = await this.getTaskFolderPath();
+    for (const target of result.targets) {
+      await this.saveTask(getTaskPath(taskFolder, target.task.id), target.task);
+    }
+    const boardAdds = [
+      ...result.patch.boardAdds.map((add) => ({ ...add, taskId })),
+      ...result.targets.flatMap((target) => target.boardAdds.map((add) => ({ ...add, taskId: target.task.id })))
+    ];
+    const thisBoardSlug = await this.resolveBoardSlug();
+    for (const add of boardAdds) {
+      const slug = await this.resolveBoardSlug(add.board);
+      if (slug === thisBoardSlug) {
+        continue;
+      }
+      if (!(await this.boardExists(slug))) {
+        this.lastActionWarnings.push(`skipped adding "${add.taskId}" to board "${add.board}": no such board`);
+        continue;
+      }
+      const otherBoard = this.board(slug);
+      const otherIndex = await otherBoard.loadIndex();
+      if (!(add.column in otherIndex.columns)) {
+        this.lastActionWarnings.push(
+          `skipped adding "${add.taskId}" to board "${add.board}": no column "${add.column}"`
+        );
+        continue;
+      }
+      if (taskInIndex(otherIndex, add.taskId)) {
+        continue;
+      }
+      await otherBoard.saveIndex(addTaskToIndex(otherIndex, add.taskId, add.column));
+    }
+  }
+
+  /**
+   * Work out which derived events an operation fired
+   *
+   * `task.started` and `task.completed` aren't operations - they're transitions, computed from the
+   * state before the operation and the state it is about to write, so a rule meaning "when this is
+   * done" doesn't have to duplicate the board's column list. They're computed before any rule runs,
+   * so a rule that sets a completed date doesn't fire task.completed
+   * @param {object} index The index object
+   * @param {?object} before The task as it was, or null if it didn't exist
+   * @param {object} after The task the operation is about to write
+   * @return {string[]} The derived event types that fired
+   */
+  derivedEvents(index, before, after) {
+    const events = [];
+    if (!taskStarted(index, { ...after, metadata: before === null ? {} : before.metadata }) && taskStarted(index, after)) {
+      events.push("task.started");
+    }
+    if (
+      !taskCompleted(index, { ...after, metadata: before === null ? {} : before.metadata }) &&
+      taskCompleted(index, after)
+    ) {
+      events.push("task.completed");
+    }
+    return events;
+  }
+
+  /**
+   * Check if a board exists
+   * @param {string} slug The board slug
+   * @return {Promise<boolean>} True if the board file exists
+   */
+  async boardExists(slug) {
+    return await exists(await this.getBoardPath(slug));
+  }
+
+  /**
+   * Create a new board
+   * @param {string} slug The board slug
+   * @param {object} [options={}] The board's name, description, columns and options
+   * @return {Promise<string>} The created board's slug
+   */
+  async createBoard(slug, options = {}) {
+    const validatedSlug = await this.validateBoardSlug(slug);
+    if (await this.boardExists(validatedSlug)) {
+      throw new Error(`Board "${validatedSlug}" already exists`);
+    }
+    if (!(await this.workspaceInitialised())) {
+      throw new Error("Not initialised in this folder");
+    }
+    const columns =
+      "columns" in options && options.columns.length ? options.columns : defaultInitialiseOptions.columns;
+
+    // A new board only picks up the default started and completed columns if it actually has columns
+    // by those names - a design board with Ideas/Designing/Signed Off shouldn't silently claim that
+    // "In Progress" started work and "Done" finished it
+    const boardOptions = "options" in options ? { ...options.options } : {};
+    for (const [key, defaultColumns] of Object.entries(defaultInitialiseOptions.options)) {
+      if (key in boardOptions) {
+        continue;
+      }
+      const matchingColumns = defaultColumns.filter((columnName) => columns.indexOf(columnName) !== -1);
+      if (matchingColumns.length) {
+        boardOptions[key] = matchingColumns;
+      }
+    }
+
+    const board = {
+      name: "name" in options && options.name ? options.name : validatedSlug,
+      description: "description" in options ? options.description : "",
+      options: boardOptions,
+      columns: Object.fromEntries(columns.map((columnName) => [columnName, []])),
+    };
+
+    // Options passed to createBoard are deliberate, so they're written to the board file even when
+    // the workspace happens to provide the same value
+    setOwnOptions(board, boardOptions);
+    await this.saveBoard(validatedSlug, board);
+    return validatedSlug;
+  }
+
+  /**
+   * Delete a board file. Tasks referenced only by this board become untracked; their files are left
+   * alone, since boards own membership and tasks are shared
+   * @param {string} slug The board slug
+   * @return {Promise<string[]>} The ids of tasks that are no longer referenced by any board
+   */
+  async deleteBoard(slug) {
+    const resolvedSlug = await this.resolveBoardSlug(slug);
+    if (await this.isMainBoard(resolvedSlug)) {
+      throw new Error("The main board cannot be deleted");
+    }
+    if (!(await this.boardExists(resolvedSlug))) {
+      throw new Error(`Board "${resolvedSlug}" doesn't exist`);
+    }
+    const orphaned = await this.findOrphanedTasks(resolvedSlug);
+    await fs.promises.unlink(await this.getBoardPath(resolvedSlug));
+    return orphaned;
+  }
+
+  /**
+   * Find the tasks that would become untracked if a board were deleted, i.e. the tasks it references
+   * that no other board references
+   * @param {string} slug The board slug
+   * @return {Promise<string[]>} The ids of tasks referenced only by this board
+   */
+  async findOrphanedTasks(slug) {
+    const resolvedSlug = await this.resolveBoardSlug(slug);
+    const taskIds = [...getTrackedTaskIds(await this.loadBoard(resolvedSlug))];
+    const orphaned = [];
+    for (const taskId of taskIds) {
+      const boards = await this.findTaskBoards(taskId);
+      if (Object.keys(boards).filter((boardSlug) => boardSlug !== resolvedSlug).length === 0) {
+        orphaned.push(taskId);
+      }
+    }
+    return orphaned;
+  }
+
+  /**
+   * Rename a board
+   * @param {string} slug The board slug
+   * @param {string} newSlug The new board slug
+   * @param {?string} [newName=null] An optional new display name for the board
+   * @return {Promise<string>} The new slug
+   */
+  async renameBoard(slug, newSlug, newName = null) {
+    const resolvedSlug = await this.resolveBoardSlug(slug);
+    if (await this.isMainBoard(resolvedSlug)) {
+      throw new Error("The main board cannot be renamed");
+    }
+    if (!(await this.boardExists(resolvedSlug))) {
+      throw new Error(`Board "${resolvedSlug}" doesn't exist`);
+    }
+    const validatedSlug = await this.validateBoardSlug(newSlug);
+    if (validatedSlug !== resolvedSlug && (await this.boardExists(validatedSlug))) {
+      throw new Error(`Board "${validatedSlug}" already exists`);
+    }
+    const board = await this.loadBoard(resolvedSlug);
+    if (newName !== null) {
+      board.name = newName;
+    }
+    if (validatedSlug !== resolvedSlug) {
+      await fs.promises.rename(await this.getBoardPath(resolvedSlug), await this.getBoardPath(validatedSlug));
+    }
+    await this.saveBoard(validatedSlug, board);
+    return validatedSlug;
+  }
+
+  /**
+   * Find every board that references a task, and the column it occupies on each
+   * @param {string} taskId The task id
+   * @return {Promise<Record<string, string>>} A map of board slug to column name
+   */
+  async findTaskBoards(taskId) {
+    const result = {};
+    for (const board of await this.listBoards()) {
+      let boardData = null;
+      try {
+        boardData = await this.loadBoard(board.slug);
+      } catch (error) {
+        continue;
+      }
+      const columnName = findTaskColumn(boardData, taskId);
+      if (columnName !== null) {
+        result[board.slug] = columnName;
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Alias for findTaskBoards(), used when displaying a task's board membership
+   * @param {string} taskId The task id
+   * @return {Promise<Record<string, string>>} A map of board slug to column name
+   */
+  async getTaskBoardColumns(taskId) {
+    return this.findTaskBoards(taskId);
+  }
+
   /**
    * Initialise a kanbn board in the current working directory
    * @param {object} [options={}] Initial columns and other config options
    */
   async initialise(options = {}) {
+    // A board-scoped instance initialises its own board rather than the workspace
+    if (!(await this.isMainBoard())) {
+      return this.initialiseBoard(this.boardSlug, options);
+    }
+
     // Check if a main folder is defined in an existing config file
     const mainFolder = await this.getMainFolder();
 
@@ -1703,6 +3431,52 @@ class Kanbn {
     await this.saveIndex(index);
   }
 
+  /**
+   * Create a secondary board, or update an existing one's name, description, columns and options
+   * @param {string} slug The board slug
+   * @param {object} [options={}] The board's name, description, columns and options
+   * @return {Promise<string>} The board slug
+   */
+  async initialiseBoard(slug, options = {}) {
+    const resolvedSlug = await this.resolveBoardSlug(slug);
+    if (!(await this.boardExists(resolvedSlug))) {
+      return this.createBoard(resolvedSlug, options);
+    }
+    if (Object.keys(options).length === 0) {
+      return resolvedSlug;
+    }
+
+    // The board already exists, so update it in the same way initialise() updates the main board
+    const board = await this.loadBoard(resolvedSlug);
+    "name" in options && options.name && (board.name = options.name);
+    "description" in options && (board.description = options.description);
+    if ("options" in options) {
+      board.options = Object.assign(board.options, options.options);
+      setOwnOptions(board, { ...board.ownOptions, ...options.options });
+    }
+    "columns" in options &&
+      (board.columns = Object.assign(
+        board.columns,
+        Object.fromEntries(
+          options.columns.map((columnName) => [
+            columnName,
+            columnName in board.columns ? board.columns[columnName] : [],
+          ])
+        )
+      ));
+    await this.saveBoard(resolvedSlug, board);
+    return resolvedSlug;
+  }
+
+  /**
+   * Check if a task file exists, regardless of whether any board references it
+   * @param {string} taskId The task id to check
+   * @return {Promise<boolean>} True if the task file exists
+   */
+  async taskFileExists(taskId) {
+    return exists(getTaskPath(await this.getTaskFolderPath(), removeFileExtension(taskId)));
+  }
+
   /**
    * Check if a task file exists and is in the index, otherwise throw an error
    * @param {string} taskId The task id to check
@@ -1786,24 +3560,51 @@ class Kanbn {
       throw new Error(`A task with id "${taskId}" is already in the index`);
     }
 
+    // Stamp every date this call writes with the same timestamp, so that the created date and the
+    // column-linked dates can't disagree by a millisecond
+    const now = new Date();
+
     // Set the created date
-    taskData = setTaskMetadata(taskData, "created", new Date());
+    taskData = setTaskMetadata(taskData, "created", now);
 
     // Add initial history event
     taskData = appendTaskHistory(taskData, {
+      date: now,
       type: 'created',
       column: columnName,
       fromProgress: 0,
       toProgress: getTaskMetadata(taskData, 'progress') || 0
-    });
+    }, await this.historyBoard(), await this.currentUser());
 
     // Update task metadata dates
-    taskData = updateColumnLinkedCustomFields(index, taskData, columnName);
-    await this.saveTask(taskPath, taskData);
+    const beforeActions = { ...taskData, metadata: {} };
+    taskData = updateColumnLinkedCustomFields(index, taskData, columnName, now);
 
-    // Add the task to the index
+    // Add the task to the index before running rules, so that a rule filtering on the task's column
+    // sees the column it is being created in
     index = addTaskToIndex(index, taskId, columnName);
+
+    // Run actions and fold whatever they produce into the writes below
+    const result = await this.runActions({
+      eventTypes: ["task.created", ...this.derivedEvents(index, beforeActions, taskData)],
+      index,
+      taskId,
+      taskData,
+      payload: { column: columnName },
+      date: now
+    });
+    if (result !== null) {
+      ({ index, taskData } = result);
+      if (result.patch.moveTo !== null && result.patch.moveTo.column !== columnName) {
+        columnName = result.patch.moveTo.column;
+        index = removeTaskFromIndex(index, taskId);
+        index = addTaskToIndex(index, taskId, columnName, result.patch.moveTo.position);
+        taskData = updateColumnLinkedCustomFields(index, taskData, columnName, now);
+      }
+    }
+    await this.saveTask(taskPath, taskData);
     await this.saveIndex(index);
+    await this.completeActions(result, taskId);
     return taskId;
   }
 
@@ -1839,17 +3640,59 @@ class Kanbn {
     // Load task data
     let taskData = await this.loadTask(taskId);
     const taskPath = getTaskPath(await this.getTaskFolderPath(), taskId);
+    const now = new Date();
+
+    // Record the task joining this board. Board membership has no other representation in a task
+    // file, so without this event a board's history has no record of the task ever arriving
+    taskData = appendTaskHistory(taskData, {
+      date: now,
+      type: 'added',
+      column: columnName
+    }, await this.historyBoard(), await this.currentUser());
 
     // Update task metadata dates
-    taskData = updateColumnLinkedCustomFields(index, taskData, columnName);
-    await this.saveTask(taskPath, taskData);
+    const beforeActions = { ...taskData, metadata: { ...taskData.metadata } };
+    taskData = updateColumnLinkedCustomFields(index, taskData, columnName, now);
 
-    // Add the task to the column and save the index
+    // Add the task to the column before running rules, so that a rule filtering on the task's
+    // column sees the column it is joining
     index = addTaskToIndex(index, taskId, columnName);
+
+    // Run actions and fold whatever they produce into the writes below
+    const result = await this.runActions({
+      eventTypes: ["task.addedToBoard", ...this.derivedEvents(index, beforeActions, taskData)],
+      index,
+      taskId,
+      taskData,
+      payload: { column: columnName, board: await this.resolveBoardSlug() },
+      date: now
+    });
+    if (result !== null) {
+      ({ index, taskData } = result);
+      if (result.patch.moveTo !== null && result.patch.moveTo.column !== columnName) {
+        columnName = result.patch.moveTo.column;
+        index = removeTaskFromIndex(index, taskId);
+        index = addTaskToIndex(index, taskId, columnName, result.patch.moveTo.position);
+        taskData = updateColumnLinkedCustomFields(index, taskData, columnName, now);
+      }
+    }
+    await this.saveTask(taskPath, taskData);
     await this.saveIndex(index);
+    await this.completeActions(result, taskId);
     return taskId;
   }
 
+  /**
+   * Add an existing task to this board. Boards own membership, so the same task file can be added to
+   * any number of boards, in a different column on each
+   * @param {string} taskId The task id
+   * @param {string} columnName The column to add the task to
+   * @return {Promise<string>} The id of the task that was added
+   */
+  async addTaskToBoard(taskId, columnName) {
+    return this.addUntrackedTaskToIndex(taskId, columnName);
+  }
+
   /**
    * Get a list of tracked tasks (i.e. tasks that are listed in the index)
    * @param {?string} [columnName=null] The optional column name to filter tasks by
@@ -1884,8 +3727,69 @@ class Kanbn {
     const files = await glob(`${await this.getTaskFolderPath()}/*.md`);
     const untrackedTasks = new Set(files.map((task) => path.parse(task).name));
 
-    // Return the set difference
-    return new Set([...untrackedTasks].filter((x) => !trackedTasks.has(x)));
+    // Return the set difference
+    return new Set([...untrackedTasks].filter((x) => !trackedTasks.has(x)));
+  }
+
+  /**
+   * Find tasks that no board references at all. "Tracked" is workspace-scoped: a task is tracked if
+   * any board references it, so a task can be missing from this board and still be tracked
+   * @return {Promise<Set<string>>} A set of untracked task ids
+   */
+  async findWorkspaceUntrackedTasks() {
+    if (!(await this.workspaceInitialised())) {
+      throw new Error("Not initialised in this folder");
+    }
+
+    // Collect the tasks referenced by every board
+    const trackedTasks = new Set();
+    for (const board of await this.listBoards()) {
+      try {
+        for (const taskId of getTrackedTaskIds(await this.loadBoard(board.slug))) {
+          trackedTasks.add(taskId);
+        }
+      } catch (error) {
+        continue;
+      }
+    }
+
+    // Get all tasks in the tasks folder and return the set difference
+    const files = await glob(`${await this.getTaskFolderPath()}/*.md`);
+    return new Set(files.map((task) => path.parse(task).name).filter((taskId) => !trackedTasks.has(taskId)));
+  }
+
+  /**
+   * Find tasks that other boards track but this one doesn't - the "what could I pull onto this board"
+   * list
+   * @return {Promise<Record<string, Record<string, string>>>} A map of task id to board slug to column
+   */
+  async findTasksOnOtherBoards() {
+    const thisBoardSlug = await this.resolveBoardSlug();
+    const trackedHere = getTrackedTaskIds(await this.loadIndex());
+    const result = {};
+    for (const board of await this.listBoards()) {
+      if (board.slug === thisBoardSlug) {
+        continue;
+      }
+      let boardData = null;
+      try {
+        boardData = await this.loadBoard(board.slug);
+      } catch (error) {
+        continue;
+      }
+      for (const [columnName, taskIds] of Object.entries(boardData.columns)) {
+        for (const taskId of taskIds) {
+          if (trackedHere.has(taskId)) {
+            continue;
+          }
+          if (!(taskId in result)) {
+            result[taskId] = {};
+          }
+          result[taskId][board.slug] = columnName;
+        }
+      }
+    }
+    return result;
   }
 
   /**
@@ -1933,18 +3837,57 @@ class Kanbn {
       throw new Error(`Column "${columnName}" doesn't exist`);
     }
 
+    // Stamp every date this call writes with the same timestamp, so that the updated date and the
+    // history event it records can't disagree by a millisecond
+    const now = new Date();
+
     // Set the updated date
-    taskData = setTaskMetadata(taskData, "updated", new Date());
+    taskData = setTaskMetadata(taskData, "updated", now);
 
     // Add history for progress changes only
     const originalProgress = getTaskMetadata(originalTaskData, 'progress') || 0;
     const updatedProgress = getTaskMetadata(taskData, 'progress') || 0;
     if (originalProgress !== updatedProgress) {
       taskData = appendTaskHistory(taskData, {
+        date: now,
         type: 'progress',
         fromProgress: originalProgress,
         toProgress: updatedProgress
-      });
+      }, null, await this.currentUser());
+    }
+
+    // Run actions. A task.updated rule that moves the task redirects the move this call was going
+    // to make, or makes one of its own if the caller didn't ask for a column change
+    const result = await this.runActions({
+      eventTypes: ["task.updated", ...this.derivedEvents(index, originalTaskData, taskData)],
+      index,
+      taskId,
+      taskData,
+      payload: { changedFields: changedFields(originalTaskData, taskData), unsetFields: [...unsetFields] },
+      date: now
+    });
+    let rulePosition = null;
+    if (result !== null) {
+      ({ index, taskData } = result);
+      if (result.patch.moveTo !== null) {
+        rulePosition = result.patch.moveTo.position;
+        if (columnName === null) {
+          const fromColumn = findTaskColumn(index, taskId);
+          if (fromColumn !== result.patch.moveTo.column) {
+            taskData = appendTaskHistory(
+              taskData,
+              { date: now, type: "moved", fromColumn, toColumn: result.patch.moveTo.column },
+              await this.historyBoard(),
+              result.patch.moveTo.author
+            );
+            index = removeTaskFromIndex(index, taskId);
+            index = addTaskToIndex(index, taskId, result.patch.moveTo.column, rulePosition);
+            taskData = updateColumnLinkedCustomFields(index, taskData, result.patch.moveTo.column, now);
+          }
+        } else {
+          columnName = result.patch.moveTo.column;
+        }
+      }
     }
 
     // Save task
@@ -1952,12 +3895,17 @@ class Kanbn {
 
     // Move the task if we're updating the column
     if (columnName) {
-      await this.moveTask(taskId, columnName);
+      // The move is a nested operation that fires its own rules, and reports its own skips. Keep
+      // this call's warnings in front of them rather than letting the move discard them
+      const updateWarnings = [...this.lastActionWarnings];
+      await this.moveTask(taskId, columnName, rulePosition);
+      this.lastActionWarnings = [...updateWarnings, ...this.lastActionWarnings];
 
       // Otherwise save the index
     } else {
       await this.saveIndex(index);
     }
+    await this.completeActions(result, taskId);
 
     // Remove any explicitly unset metadata fields last. This has to happen after the move, because
     // moving into a started or completed column stamps the linked date fields - an explicit unset
@@ -2005,10 +3953,20 @@ class Kanbn {
       throw new Error(`A task with id "${newTaskId}" already exists`);
     }
 
-    // Check that a task with the new id isn't already indexed
+    // Check that a task with the new id isn't already indexed, on this board or any other - the id
+    // is the file name, so it has to be free everywhere
     if (taskInIndex(index, newTaskId)) {
       throw new Error(`A task with id "${newTaskId}" is already in the index`);
     }
+    const boardsWithNewId = Object.keys(await this.findTaskBoards(newTaskId));
+    if (boardsWithNewId.length) {
+      throw new Error(
+        `A task with id "${newTaskId}" is already on board "${boardsWithNewId[0]}"`
+      );
+    }
+
+    // Note every board that references this task before anything is written
+    const otherBoards = await this.findTaskBoards(taskId);
 
     // Update the task name and updated date
     let taskData = await this.loadTask(taskId);
@@ -2019,7 +3977,17 @@ class Kanbn {
     // Rename the task file
     await fs.promises.rename(getTaskPath(await this.getTaskFolderPath(), taskId), newTaskPath);
 
-    // Update the task id in the index
+    // Update the task id in the index, and in every other board that references it - the task file
+    // has moved, so a board still pointing at the old id would have a broken link
+    const thisBoardSlug = await this.resolveBoardSlug();
+    for (const slug of Object.keys(otherBoards)) {
+      if (slug === thisBoardSlug) {
+        continue;
+      }
+      const otherBoard = this.board(slug);
+      const otherIndex = await otherBoard.loadIndex();
+      await otherBoard.saveIndex(renameTaskInIndex(otherIndex, taskId, newTaskId));
+    }
     index = renameTaskInIndex(index, taskId, newTaskId);
     await this.saveIndex(index);
     return newTaskId;
@@ -2031,9 +3999,10 @@ class Kanbn {
    * @param {string} columnName The name of the column that the task will be moved to
    * @param {?number} [position=null] The position to move the task to within the target column
    * @param {boolean} [relative=false] Treat the position argument as relative instead of absolute
+   * @param {boolean} [add=false] Add the task to this board if it isn't on it yet (secondary boards only)
    * @return {Promise<string>} The id of the task that was moved
    */
-  async moveTask(taskId, columnName, position = null, relative = false) {
+  async moveTask(taskId, columnName, position = null, relative = false, add = false) {
     // Check if this folder has been initialised
     if (!(await this.initialised())) {
       throw new Error("Not initialised in this folder");
@@ -2048,7 +4017,18 @@ class Kanbn {
     // Get index and make sure the task is indexed
     let index = await this.loadIndex();
     if (!taskInIndex(index, taskId)) {
-      throw new Error(`Task "${taskId}" is not in the index`);
+
+      // Moving a task onto a board it isn't on yet adds it, so that membership doesn't have to be a
+      // separate step. Only on a secondary board: on the main board this stays the error it has
+      // always been
+      if (!add || (await this.isMainBoard())) {
+        throw new Error(`Task "${taskId}" is not in the index`);
+      }
+      if (!(columnName in index.columns)) {
+        throw new Error(`Column "${columnName}" doesn't exist`);
+      }
+      await this.addTaskToBoard(taskId, columnName);
+      return taskId;
     }
 
     // Make sure the target column exists
@@ -2074,12 +4054,12 @@ class Kanbn {
         type: 'moved',
         fromColumn: currentColumnName,
         toColumn: columnName
-      });
+      }, await this.historyBoard(), await this.currentUser());
     }
 
     // Update task metadata dates
+    const beforeActions = { ...taskData, metadata: { ...taskData.metadata } };
     taskData = updateColumnLinkedCustomFields(index, taskData, columnName, moveDate);
-    await this.saveTask(getTaskPath(await this.getTaskFolderPath(), taskId), taskData);
 
     // If we're moving the task to a new position, calculate the absolute position
     const currentPosition = index.columns[currentColumnName].indexOf(taskId);
@@ -2093,7 +4073,39 @@ class Kanbn {
     // Remove the task from its current column and add it to the new column
     index = removeTaskFromIndex(index, taskId);
     index = addTaskToIndex(index, taskId, columnName, position);
+
+    // Run actions. A rule that moves the task changes the destination of the write that was already
+    // about to happen, rather than performing a second move
+    const eventTypes = this.derivedEvents(index, beforeActions, taskData);
+    if (currentColumnName !== columnName) {
+      eventTypes.unshift("task.moved");
+    }
+    const result = await this.runActions({
+      eventTypes,
+      index,
+      taskId,
+      taskData,
+      payload: { fromColumn: currentColumnName, toColumn: columnName },
+      date: moveDate
+    });
+    if (result !== null) {
+      ({ index, taskData } = result);
+      if (result.patch.moveTo !== null && result.patch.moveTo.column !== columnName) {
+        const ruleColumn = result.patch.moveTo.column;
+        taskData = appendTaskHistory(
+          taskData,
+          { date: moveDate, type: "moved", fromColumn: columnName, toColumn: ruleColumn },
+          await this.historyBoard(),
+          result.patch.moveTo.author
+        );
+        index = removeTaskFromIndex(index, taskId);
+        index = addTaskToIndex(index, taskId, ruleColumn, result.patch.moveTo.position);
+        taskData = updateColumnLinkedCustomFields(index, taskData, ruleColumn, moveDate);
+      }
+    }
+    await this.saveTask(getTaskPath(await this.getTaskFolderPath(), taskId), taskData);
     await this.saveIndex(index);
+    await this.completeActions(result, taskId);
     return taskId;
   }
 
@@ -2101,9 +4113,10 @@ class Kanbn {
    * Remove a task from the index and optionally delete the task file as well
    * @param {string} taskId The id of the task to remove
    * @param {boolean} [removeFile=false] True if the task file should be removed
+   * @param {boolean} [allBoards=false] True to remove the task from every board that references it
    * @return {Promise<string>} The id of the task that was deleted
    */
-  async deleteTask(taskId, removeFile = false) {
+  async deleteTask(taskId, removeFile = false, allBoards = false) {
     // Check if this folder has been initialised
     if (!(await this.initialised())) {
       throw new Error("Not initialised in this folder");
@@ -2116,14 +4129,67 @@ class Kanbn {
       throw new Error(`Task "${taskId}" is not in the index`);
     }
 
+    // A task file is shared, so deleting it out from under another board would break that board.
+    // Removing the task from this board only is always safe, and is what happens without --all-boards
+    const thisBoardSlug = await this.resolveBoardSlug();
+    const otherBoards = Object.keys(await this.findTaskBoards(taskId)).filter((slug) => slug !== thisBoardSlug);
+    if (removeFile && otherBoards.length && !allBoards) {
+      throw new Error(
+        `Task "${taskId}" is on ${otherBoards.length} other ${otherBoards.length === 1 ? "board" : "boards"} ` +
+          `(${otherBoards.join(", ")})`
+      );
+    }
+
+    // Run actions before anything is removed, so that a rule's targets are selected from the task's
+    // relations while the task is still there to have them
+    const columnName = findTaskColumn(index, taskId);
+    const taskFileExists = await exists(getTaskPath(await this.getTaskFolderPath(), taskId));
+    let result = null;
+    if (taskFileExists) {
+      result = await this.runActions({
+        eventTypes: ["task.deleted"],
+        index,
+        taskId,
+        taskData: await this.loadTask(taskId),
+        payload: { fromColumn: columnName, removeFile, allBoards },
+
+        // Removing a task from one board isn't a workspace-wide operation, whatever the event is
+        // called, so the other boards' rules have nothing to hear about
+        taskBoards: allBoards ? null : false,
+        date: new Date()
+      });
+      if (result !== null) {
+        index = result.index;
+      }
+    }
+
     // Remove the task from whichever column it's in
     index = removeTaskFromIndex(index, taskId);
 
-    // Optionally remove the task file as well
+    // Record the task leaving this board, but only when the task file survives - a removed event on
+    // a file that's about to be deleted records nothing anyone can read
+    if (!removeFile && (await exists(getTaskPath(await this.getTaskFolderPath(), taskId)))) {
+      let taskData = await this.loadTask(taskId);
+      taskData = appendTaskHistory(taskData, {
+        type: 'removed',
+        fromColumn: columnName
+      }, await this.historyBoard(), await this.currentUser());
+      await this.saveTask(getTaskPath(await this.getTaskFolderPath(), taskId), taskData);
+    }
+
+    // Optionally remove the task from every other board, and remove the task file as well
+    if (allBoards) {
+      for (const slug of otherBoards) {
+        const otherBoard = this.board(slug);
+        const otherIndex = await otherBoard.loadIndex();
+        await otherBoard.saveIndex(removeTaskFromIndex(otherIndex, taskId));
+      }
+    }
     if (removeFile && (await exists(getTaskPath(await this.getTaskFolderPath(), taskId)))) {
       await fs.promises.unlink(getTaskPath(await this.getTaskFolderPath(), taskId));
     }
     await this.saveIndex(index);
+    await this.completeActions(result, taskId);
     return taskId;
   }
 
@@ -2149,6 +4215,38 @@ class Kanbn {
     });
   }
 
+  /**
+   * Search every board in the workspace. A task on several boards appears once, annotated with the
+   * board and column it occupies on each
+   * @param {object} [filters={}] The filters to apply
+   * @param {boolean} [quiet=false] Only return task ids if true, otherwise return full task details
+   * @return {Promise<object[]|string[]>} A list of matching tasks, or task ids
+   */
+  async searchAllBoards(filters = {}, quiet = false) {
+    if (!(await this.workspaceInitialised())) {
+      throw new Error("Not initialised in this folder");
+    }
+    const results = new Map();
+    for (const board of await this.listBoards()) {
+      let matches = [];
+      try {
+        matches = await this.board(board.slug).search(filters, quiet);
+      } catch (error) {
+        continue;
+      }
+      for (const match of matches) {
+        const taskId = quiet ? match : match.id;
+        if (!results.has(taskId)) {
+          results.set(taskId, quiet ? taskId : { ...match, boards: {} });
+        }
+        if (!quiet) {
+          results.get(taskId).boards[board.slug] = match.column;
+        }
+      }
+    }
+    return [...results.values()];
+  }
+
   /**
    * Output project status information
    * @param {boolean} [quiet=false] Output full or partial status information
@@ -2175,14 +4273,30 @@ class Kanbn {
       name: index.name,
     };
 
+    // Name the board this status applies to, but only once there is more than one board - a
+    // single-board workspace produces exactly the output it always has
+    const boards = await this.listBoards();
+    if (boards.length > 1) {
+      result.board = await this.resolveBoardSlug();
+    }
+
     // Get un-tracked tasks if required
     if (untracked) {
-      result.untrackedTasks = [...(await this.findUntrackedTasks())].map((taskId) => `${taskId}.md`);
+
+      // Untracked means "on no board at all", which is workspace-scoped
+      result.untrackedTasks = [...(await this.findWorkspaceUntrackedTasks())].map((taskId) => `${taskId}.md`);
 
       // If output is quiet, output a list of untracked task filenames
       if (quiet) {
         return result.untrackedTasks;
       }
+
+      // Tasks that are tracked, but not on this board. This is the useful half of the answer: it's
+      // the list of work that could be pulled onto this board
+      const tasksOnOtherBoards = await this.findTasksOnOtherBoards();
+      if (Object.keys(tasksOnOtherBoards).length) {
+        result.tasksOnOtherBoards = tasksOnOtherBoards;
+      }
     }
 
     // Get basic project status information
@@ -2418,6 +4532,25 @@ class Kanbn {
       return errors;
     }
 
+    // Action rules are configuration: a rule that names an unknown event or verb is wrong in the
+    // file, and an operation that meets one fails before writing anything, so it belongs here
+    // rather than in the warnings
+    try {
+      const rules = await this.getActionRules(index);
+      const context = { columns: Object.keys(index.columns) };
+      if (await this.workspaceInitialised()) {
+        context.boards = (await this.listBoards()).map((board) => board.slug);
+      }
+      for (const error of actions.findRuleErrors(rules, context)) {
+        errors.push({ task: null, errors: `actions: ${error}` });
+      }
+    } catch (error) {
+      errors.push({ task: null, errors: `actions: ${error.message}` });
+    }
+    if (errors.length) {
+      return errors;
+    }
+
     // Load & parse tasks
     const trackedTasks = getTrackedTaskIds(index);
     for (let taskId of trackedTasks) {
@@ -2443,6 +4576,350 @@ class Kanbn {
     return true;
   }
 
+  /**
+   * Validate every board in the workspace, and the tasks each of them references
+   * @param {boolean} [save=false] Re-save each board and its tasks
+   * @return {Promise<object[]|boolean>} A list of errors, or true if there were none
+   */
+  async validateAllBoards(save = false) {
+    if (!(await this.workspaceInitialised())) {
+      throw new Error("Not initialised in this folder");
+    }
+    const errors = [];
+    for (const board of await this.listBoards()) {
+      const result = await this.board(board.slug).validate(save);
+      if (result !== true) {
+        errors.push(...result.map((error) => ({ board: board.slug, ...error })));
+      }
+    }
+    return errors.length ? errors : true;
+  }
+
+  /**
+   * Check a workspace for multi-board problems. These are reported rather than thrown: every one of
+   * them is a workspace that still works, just not the way its author probably meant it to
+   * @return {Promise<object[]>} A list of warnings, each with a type, a message and the board it applies to
+   */
+  async findBoardWarnings() {
+    if (!(await this.workspaceInitialised())) {
+      throw new Error("Not initialised in this folder");
+    }
+    const warnings = [];
+    const mainBoardSlug = await this.getMainBoardSlug();
+    const boards = await this.listBoards();
+    const boardSlugs = new Set(boards.map((board) => board.slug));
+    const { exclude } = await this.getBoardsConfig();
+
+    // Markdown files beside the boards that don't parse as one. These are ignored during ordinary
+    // commands, which is the right default, but the user should be able to find out why
+    const mainFolder = await this.getMainFolder();
+    for (const filePath of await glob(`${mainFolder}/*.md`)) {
+      const slug = boardSlugFromFileName(filePath);
+      if (boardSlugs.has(slug)) {
+        continue;
+      }
+      if (exclude.indexOf(slug) !== -1) {
+        warnings.push({
+          board: slug,
+          type: "excluded-board",
+          message: `"${path.basename(filePath)}" is excluded by the boards.exclude config and isn't treated as a board`
+        });
+        continue;
+      }
+      try {
+        parseIndex.md2json(await fs.promises.readFile(filePath, { encoding: "utf-8" }));
+      } catch (error) {
+        warnings.push({
+          board: slug,
+          type: "unparseable-board",
+          message: `"${path.basename(filePath)}" doesn't parse as a board and is being ignored: ${error.message}`
+        });
+      }
+    }
+
+    const stampingBoards = [];
+    const knownBoards = new Set(boardSlugs);
+    const taskBoardColumns = {};
+    for (const board of boards) {
+      let boardData = null;
+      try {
+        boardData = await this.loadBoard(board.slug);
+      } catch (error) {
+        continue;
+      }
+
+      // Workspace-scoped options in a secondary board's front matter are ignored, and silently
+      // ignoring them would leave the user wondering why they had no effect
+      if (board.slug !== mainBoardSlug) {
+        const rawOptions = boardData.ownOptions || {};
+        for (const key of Object.keys(rawOptions)) {
+          if (WORKSPACE_SCOPED_OPTIONS.indexOf(key) !== -1) {
+            warnings.push({
+              board: board.slug,
+              type: "workspace-scoped-option",
+              message: `"${key}" is a workspace-scoped option and is ignored in a board file`
+            });
+          }
+        }
+      }
+
+      // More than one board writing the same shared completed field means whichever board is touched
+      // first silently owns that date for the whole workspace
+      if ("completedColumns" in boardData.options && boardData.options.completedColumns.length) {
+        stampingBoards.push({ slug: board.slug, field: getCompletedField(boardData) });
+      }
+
+      // Sprints are assumed to be in order: the last one is taken as the current sprint, and each
+      // one runs until the next one starts
+      const sprints = "sprints" in boardData.options ? boardData.options.sprints : [];
+      for (let i = 1; i < sprints.length; i++) {
+        if (new Date(sprints[i].start) < new Date(sprints[i - 1].start)) {
+          warnings.push({
+            board: board.slug,
+            type: "sprints-out-of-order",
+            message: `sprint "${sprints[i].name}" starts before "${sprints[i - 1].name}"`
+          });
+          break;
+        }
+      }
+
+      // A task can only be in one column per board
+      for (const [columnName, taskIds] of Object.entries(boardData.columns)) {
+        for (const taskId of taskIds) {
+          if (!(taskId in taskBoardColumns)) {
+            taskBoardColumns[taskId] = {};
+          }
+          if (board.slug in taskBoardColumns[taskId]) {
+            warnings.push({
+              board: board.slug,
+              type: "duplicate-task",
+              message: `task "${taskId}" appears in both "${taskBoardColumns[taskId][board.slug]}" and "${columnName}"`
+            });
+          } else {
+            taskBoardColumns[taskId][board.slug] = columnName;
+          }
+        }
+      }
+    }
+
+    // Several boards stamping the same shared field
+    const fields = {};
+    for (const { slug, field } of stampingBoards) {
+      if (!(field in fields)) {
+        fields[field] = [];
+      }
+      fields[field].push(slug);
+    }
+    for (const [field, slugs] of Object.entries(fields)) {
+      if (slugs.length > 1) {
+        warnings.push({
+          board: null,
+          type: "multiple-stamping-authorities",
+          message:
+            `boards ${slugs.map((slug) => `"${slug}"`).join(", ")} all stamp "${field}" - ` +
+            'whichever is touched first owns that date for every board'
+        });
+      }
+    }
+
+    // Tasks referenced by a board with no file behind them
+    for (const [taskId, taskBoards] of Object.entries(taskBoardColumns)) {
+      if (!(await this.taskFileExists(taskId))) {
+        warnings.push({
+          board: Object.keys(taskBoards)[0],
+          type: "missing-task-file",
+          message: `task "${taskId}" is referenced by ${Object.keys(taskBoards).join(", ")} but has no file`
+        });
+      }
+    }
+
+    // Tasks that no board references at all
+    for (const taskId of await this.findWorkspaceUntrackedTasks()) {
+      warnings.push({
+        board: null,
+        type: "untracked-task",
+        message: `task "${taskId}" isn't on any board`
+      });
+    }
+
+    // History events naming a board that has been deleted. These never match a board during replay,
+    // so they're harmless - but they're the only trace a deleted board leaves behind
+    const reportedBoards = new Set();
+    for (const taskId of Object.keys(taskBoardColumns)) {
+      let taskData = null;
+      try {
+        taskData = await this.loadTask(taskId);
+      } catch (error) {
+        continue;
+      }
+      for (const historyEvent of taskData.history || []) {
+        if (historyEvent.board && !knownBoards.has(historyEvent.board) && !reportedBoards.has(historyEvent.board)) {
+          reportedBoards.add(historyEvent.board);
+          warnings.push({
+            board: historyEvent.board,
+            type: "unknown-board-in-history",
+            message: `history events name board "${historyEvent.board}", which doesn't exist`
+          });
+        }
+      }
+    }
+    return warnings;
+  }
+
+  /**
+   * Collect every distinct value used in an `assigned` field or a comment `author` across the
+   * workspace's task files, along with where each one is used
+   *
+   * Tasks are workspace-scoped - a task file can be referenced by several boards - so this reads the
+   * task folder rather than any one board. Task files that don't parse are skipped: this is a
+   * reporting helper, and `kanbn validate` is where a broken file gets reported
+   * @return {Promise<Map<string, object>>} A map of value to usage entry
+   */
+  async collectContributorValues() {
+    if (!(await this.workspaceInitialised())) {
+      throw new Error("Not initialised in this folder");
+    }
+    const values = new Map();
+    const record = (value, taskId, field) => {
+      if (typeof value !== "string" || !value.trim()) {
+        return;
+      }
+      const key = value.trim();
+      if (!values.has(key)) {
+        values.set(key, { value: key, assigned: 0, comments: 0, tasks: new Set() });
+      }
+      const entry = values.get(key);
+      entry[field]++;
+      entry.tasks.add(taskId);
+    };
+    for (const taskPath of await glob(`${await this.getTaskFolderPath()}/*.md`)) {
+      const taskId = path.parse(taskPath).name;
+      let taskData = null;
+      try {
+        taskData = await this.loadTask(taskId);
+      } catch (error) {
+        continue;
+      }
+      record(getTaskMetadata(taskData, "assigned"), taskId, "assigned");
+      for (const comment of taskData.comments || []) {
+        record(comment.author, taskId, "comments");
+      }
+    }
+    return values;
+  }
+
+  /**
+   * Report how the workspace's contributors are actually used, and which names are in use that the
+   * contributors list doesn't know about
+   *
+   * The second half is the point: adopting contributors in a workspace with 200 existing tasks
+   * otherwise means grepping. This is read-only - rewriting "Gordon" to "gordon" across every task
+   * file is a bulk mutation and belongs to its own command, with its own dry run
+   * @return {Promise<{contributors: object[], unknown: object[]}>} Usage per known contributor, and
+   * every value in use that isn't one
+   */
+  async getContributorUsage() {
+    const contributors = await this.getContributors();
+    const values = await this.collectContributorValues();
+    const usage = contributors.map((contributor) => ({
+      ...contributor,
+      assigned: 0,
+      comments: 0,
+      tasks: new Set(),
+      spellings: []
+    }));
+    const unknown = [];
+    for (const entry of [...values.values()].sort((a, b) => a.value.localeCompare(b.value))) {
+      const result = {
+        value: entry.value,
+        assigned: entry.assigned,
+        comments: entry.comments,
+        tasks: [...entry.tasks].sort()
+      };
+      const contributor = matchContributor(contributors, entry.value);
+      if (contributor === null) {
+        unknown.push(result);
+        continue;
+      }
+      const target = usage.find((u) => u.name === contributor.name);
+      target.assigned += entry.assigned;
+      target.comments += entry.comments;
+
+      // Counted as a set, so a task naming the same person twice under two spellings is one task
+      for (const taskId of entry.tasks) {
+        target.tasks.add(taskId);
+      }
+      target.spellings.push(result);
+    }
+    return {
+      contributors: usage.map((contributor) => ({ ...contributor, tasks: contributor.tasks.size })),
+      unknown
+    };
+  }
+
+  /**
+   * Find things about this board's action rules that are legal but probably not what the author meant
+   *
+   * Rules that are wrong in the file are errors, reported by validate(). These are the ones that
+   * work: two rules writing the same field on the same event, or a rule using @me where no user can
+   * be resolved
+   * @return {Promise<object[]>} A list of warnings
+   */
+  async findActionWarnings() {
+    if (!(await this.initialised())) {
+      throw new Error("Not initialised in this folder");
+    }
+    let rules = [];
+    try {
+      rules = await this.getActionRules();
+    } catch (error) {
+      // A rule set that can't be read is an error rather than a warning, and validate reports it
+      return [];
+    }
+    if (!rules.length) {
+      return [];
+    }
+    return actions.findRuleWarnings(rules, { hasUser: (await this.currentUser()) !== null });
+  }
+
+  /**
+   * Find tasks whose assigned user or comment author isn't a known contributor
+   *
+   * Contributors are advisory, so this is a warning and never an error: `assigned` and `author` stay
+   * free text, and a name that isn't in the list is written, read and filtered exactly as before.
+   * Nothing is reported at all when the workspace declares no contributors
+   * @return {Promise<object[]>} A list of warnings
+   */
+  async findContributorWarnings() {
+    const contributors = await this.getContributors();
+    if (!contributors.length) {
+      return [];
+    }
+    const warnings = [];
+    for (const entry of [...(await this.collectContributorValues()).values()].sort((a, b) =>
+      a.value.localeCompare(b.value)
+    )) {
+      if (matchContributor(contributors, entry.value) !== null) {
+        continue;
+      }
+
+      // A comment written by a rule is authored by the rule, not by a person, so it is never a
+      // missing contributor
+      if (entry.value === actions.ACTION_AUTHOR_PREFIX || entry.value.startsWith(`${actions.ACTION_AUTHOR_PREFIX}/`)) {
+        continue;
+      }
+      for (const taskId of [...entry.tasks].sort()) {
+        warnings.push({
+          task: taskId,
+          type: "unknown-contributor",
+          value: entry.value,
+          message: `"${entry.value}" isn't a known contributor`
+        });
+      }
+    }
+    return warnings;
+  }
+
   /**
    * Find tasks whose started/completed dates disagree with the column they're in
    *
@@ -2608,19 +5085,28 @@ class Kanbn {
       throw new Error("Not initialised in this folder");
     }
 
-    // Get index and make sure it has a list of sprints in the options
+    // Sprints are workspace-level unless a board declares its own list. Adding a sprint from a
+    // secondary board that hasn't declared one appends to the workspace list rather than quietly
+    // forking it - a fork would be invisible and would freeze that board out of every future
+    // workspace sprint. Creating a board-local list stays a deliberate front-matter edit
     const index = await this.loadIndex();
-    if (!("sprints" in index.options)) {
-      index.options.sprints = [];
+    const isMainBoard = await this.isMainBoard();
+    const boardOwnsSprints = !isMainBoard && "sprints" in (index.ownOptions || {});
+    const target = isMainBoard || boardOwnsSprints ? this : this.board(await this.getMainBoardSlug());
+    const targetIndex = target === this ? index : await target.loadIndex();
+
+    if (!("sprints" in targetIndex.options)) {
+      targetIndex.options.sprints = [];
     }
-    const sprintNumber = index.options.sprints.length + 1;
+    const sprintNumber = targetIndex.options.sprints.length + 1;
     const sprint = {
       start: start,
     };
 
-    // If the name is blank, generate a default name
+    // If the name is blank, generate a default name. A board-local list prefixes the board name, so
+    // that two boards generating their own "Sprint 1" can still be told apart
     if (!name) {
-      sprint.name = `Sprint ${sprintNumber}`;
+      sprint.name = boardOwnsSprints ? `${index.name} Sprint ${sprintNumber}` : `Sprint ${sprintNumber}`;
     } else {
       sprint.name = name;
     }
@@ -2630,9 +5116,12 @@ class Kanbn {
       sprint.description = description;
     }
 
-    // Add sprint and save the index
-    index.options.sprints.push(sprint);
-    await this.saveIndex(index);
+    // Add sprint and save the board that owns the list
+    targetIndex.options.sprints.push(sprint);
+    await target.saveIndex(targetIndex);
+
+    // Tell the caller which list this went into, so the CLI can say so
+    sprint.board = boardOwnsSprints ? await this.resolveBoardSlug() : null;
     return sprint;
   }
 
@@ -2654,6 +5143,14 @@ class Kanbn {
 
     // Get index and tasks
     const index = await this.loadIndex();
+
+    // Burndown measures work in flight, which a board with no started columns has no notion of. An
+    // empty chart looks like a bug, so say what's actually missing
+    if (!("startedColumns" in index.options) || !index.options.startedColumns.length) {
+      throw new Error(
+        `Board "${await this.resolveBoardSlug()}" declares no startedColumns, so it has no notion of work in progress`
+      );
+    }
     const startedField = getStartedField(index);
     const completedField = getCompletedField(index);
     const tasks = [...(await this.loadAllTrackedTasks(index))]
@@ -2800,6 +5297,10 @@ class Kanbn {
       });
     }
 
+    // Datapoints are placed and annotated from this board's history, so activity on another board
+    // doesn't put markers on this board's chart
+    const historyBoard = await this.historyBoard();
+
     // Get workload datapoints for each period
     series.forEach((s) => {
       s.dataPoints = [
@@ -2807,23 +5308,23 @@ class Kanbn {
           x: s.from,
           y: getWorkloadAtDate(index, tasks, s.from),
           count: countActiveTasksAtDate(index, tasks, s.from),
-          tasks: getTaskEventsAtDate(index, tasks, s.from),
+          tasks: getTaskEventsAtDate(index, tasks, s.from, historyBoard),
         },
         ...tasks
-          .map((task) => getTaskTimelineDates(task, s.from, s.to))
+          .map((task) => getTaskTimelineDates(task, s.from, s.to, historyBoard))
           .flat()
           .filter((d) => d)
           .map((x) => ({
             x,
             y: getWorkloadAtDate(index, tasks, x),
             count: countActiveTasksAtDate(index, tasks, x),
-            tasks: getTaskEventsAtDate(index, tasks, x),
+            tasks: getTaskEventsAtDate(index, tasks, x, historyBoard),
           })),
         {
           x: s.to,
           y: getWorkloadAtDate(index, tasks, s.to),
           count: countActiveTasksAtDate(index, tasks, s.to),
-          tasks: getTaskEventsAtDate(index, tasks, s.to),
+          tasks: getTaskEventsAtDate(index, tasks, s.to, historyBoard),
         },
       ].sort((a, b) => a.x.getTime() - b.x.getTime());
     });
@@ -2849,6 +5350,9 @@ class Kanbn {
       ? null
       : new Set(taskIds.map((taskId) => removeFileExtension(taskId)));
 
+    // Show this board's history, plus the events that aren't board-scoped at all
+    const historyBoard = await this.historyBoard();
+
     // Build date filter periods from sprints and/or dates
     const periods = [];
     const indexSprints = "sprints" in index.options && index.options.sprints.length ? index.options.sprints : null;
@@ -2941,6 +5445,7 @@ class Kanbn {
 
         const historyEvents = ("history" in task && Array.isArray(task.history) ? task.history : [])
           .filter((historyEvent) => historyEvent.date instanceof Date)
+          .filter((historyEvent) => historyEventOnBoard(historyEvent, historyBoard))
           .map((historyEvent) => {
             const event = { ...historyEvent };
             delete event.date;
@@ -3032,7 +5537,7 @@ class Kanbn {
    * @param {string} author The comment author
    * @return {Promise<string>} The task id
    */
-  async comment(taskId, text, author) {
+  async comment(taskId, text, author = "") {
     // Check if this folder has been initialised
     if (!(await this.initialised())) {
       throw new Error("Not initialised in this folder");
@@ -3056,16 +5561,54 @@ class Kanbn {
     }
 
     // Add the comment
-    const taskData = await this.loadTask(taskId);
+    let taskData = await this.loadTask(taskId);
     const taskPath = getTaskPath(await this.getTaskFolderPath(), taskId);
+    const now = new Date();
     taskData.comments.push({
       text,
-      author,
-      date: new Date(),
+
+      // An author is optional, and a machine with no resolvable user has none. Serialising null
+      // fails schema validation, so the task could never be written back
+      author: author || "",
+      date: now,
+    });
+
+    // Run actions
+    const result = await this.runActions({
+      eventTypes: ["task.commented"],
+      index,
+      taskId,
+      taskData,
+      payload: { comment: text },
+      date: now
     });
+    if (result !== null) {
+      ({ taskData } = result);
+      index = result.index;
+      if (result.patch.moveTo !== null) {
+        const fromColumn = findTaskColumn(index, taskId);
+        if (fromColumn !== result.patch.moveTo.column) {
+          taskData = appendTaskHistory(
+            taskData,
+            { date: now, type: "moved", fromColumn, toColumn: result.patch.moveTo.column },
+            await this.historyBoard(),
+            result.patch.moveTo.author
+          );
+          index = removeTaskFromIndex(index, taskId);
+          index = addTaskToIndex(index, taskId, result.patch.moveTo.column, result.patch.moveTo.position);
+          taskData = updateColumnLinkedCustomFields(index, taskData, result.patch.moveTo.column, now);
+        }
+      }
+    }
 
     // Save the task
     await this.saveTask(taskPath, taskData);
+
+    // Commenting doesn't touch the index, so it is only written when a rule moved something
+    if (result !== null && (result.patch.moveTo !== null || result.targets.some((target) => target.moveTo !== null))) {
+      await this.saveIndex(index);
+    }
+    await this.completeActions(result, taskId);
     return taskId;
   }
 
@@ -3130,17 +5673,44 @@ class Kanbn {
     const taskColumn = findTaskColumn(index, taskId);
     taskData = setTaskMetadata(taskData, "column", taskColumn);
 
-    // Add history event
+    // Archiving removes a task from every board, so remember where it was on each of them. The
+    // single `column` key is kept for the main board, so archives written before boards existed -
+    // and archives of tasks that are only on one board - are unchanged
+    const taskBoards = await this.findTaskBoards(taskId);
+    if (Object.keys(taskBoards).length > 1) {
+      taskData = setTaskMetadata(taskData, "columns", taskBoards);
+    }
+
+    // Add history event. Archiving isn't board-scoped, so the event carries no board key
+    const now = new Date();
     taskData = appendTaskHistory(taskData, {
       type: 'archived',
       fromColumn: taskColumn
+    }, null, await this.currentUser());
+
+    // Run actions
+    const result = await this.runActions({
+      eventTypes: ["task.archived"],
+      index,
+      taskId,
+      taskData,
+      payload: { fromColumn: taskColumn },
+      date: now
     });
+    if (result !== null) {
+      ({ index, taskData } = result);
+      if (result.targets.some((target) => target.moveTo !== null)) {
+        await this.saveIndex(index);
+      }
+    }
 
     // Save the task inside the archive folder
     await this.saveTask(archivedTaskPath, taskData);
+    await this.completeActions(result, taskId);
 
-    // Remove the original task
-    await this.deleteTask(taskId, true);
+    // Remove the original task from every board that references it. This removal is part of the
+    // archive rather than a deletion anyone wrote a rule for, so it fires nothing
+    await this.withoutActions().deleteTask(taskId, true, true);
 
     return taskId;
   }
@@ -3149,9 +5719,11 @@ class Kanbn {
    * Restore a task from the archive
    * @param {string} taskId The task id
    * @param {?string} [columnName=null] The column to restore the task to
+   * @param {boolean} [singleBoard=false] Restore only to this board, rather than to every board the
+   * task was on when it was archived
    * @return {Promise<string>} The task id
    */
-  async restoreTask(taskId, columnName = null) {
+  async restoreTask(taskId, columnName = null, singleBoard = false) {
     // Check if this folder has been initialised
     if (!(await this.initialised())) {
       throw new Error("Not initialised in this folder");
@@ -3192,21 +5764,93 @@ class Kanbn {
     // Load the task from the archive
     let taskData = await this.loadArchivedTask(taskId);
     let actualColumnName = columnName || getTaskMetadata(taskData, "column") || columns[0];
+
+    // Work out which other boards this task was on when it was archived. A board that has since been
+    // deleted is skipped with a warning rather than failing the restore
+    const thisBoardSlug = await this.resolveBoardSlug();
+    const archivedColumns = getTaskMetadata(taskData, "columns") || {};
+    const otherBoards = [];
+    const missingBoards = [];
+    this.lastRestoreWarnings = [];
+    if (!singleBoard) {
+      for (const [slug, archivedColumn] of Object.entries(archivedColumns)) {
+        if (slug === thisBoardSlug) {
+          continue;
+        }
+        if (await this.boardExists(slug)) {
+          otherBoards.push([slug, archivedColumn]);
+        } else {
+          missingBoards.push(slug);
+        }
+      }
+    }
     taskData = setTaskMetadata(taskData, "column", undefined);
+    if ("metadata" in taskData && "columns" in taskData.metadata) {
+      taskData = setTaskMetadata(taskData, "columns", undefined);
+    }
+
+    // Stamp every date this call writes with the same timestamp, so that the history event and the
+    // column-linked dates can't disagree by a millisecond
+    const now = new Date();
 
     // Add history event
     taskData = appendTaskHistory(taskData, {
+      date: now,
       type: 'restored',
       toColumn: actualColumnName
-    });
+    }, null, await this.currentUser());
 
-    // Update task metadata dates and save task
-    taskData = updateColumnLinkedCustomFields(index, taskData, actualColumnName);
-    await this.saveTask(taskPath, taskData);
+    // Update task metadata dates
+    const beforeActions = { ...taskData, metadata: { ...taskData.metadata } };
+    taskData = updateColumnLinkedCustomFields(index, taskData, actualColumnName, now);
 
-    // Add the task to the column and save the index
+    // Add the task to the column before running rules, so that a rule filtering on the task's
+    // column sees the column it is being restored to
     index = addTaskToIndex(index, taskId, actualColumnName);
+
+    // Run actions
+    const result = await this.runActions({
+      eventTypes: ["task.restored", ...this.derivedEvents(index, beforeActions, taskData)],
+      index,
+      taskId,
+      taskData,
+      payload: { toColumn: actualColumnName },
+
+      // The task isn't on any board yet, so the index can't say which boards this affects
+      taskBoards: [thisBoardSlug, ...otherBoards.map(([slug]) => slug)],
+      date: now
+    });
+    if (result !== null) {
+      ({ index, taskData } = result);
+      if (result.patch.moveTo !== null && result.patch.moveTo.column !== actualColumnName) {
+        actualColumnName = result.patch.moveTo.column;
+        index = removeTaskFromIndex(index, taskId);
+        index = addTaskToIndex(index, taskId, actualColumnName, result.patch.moveTo.position);
+        taskData = updateColumnLinkedCustomFields(index, taskData, actualColumnName, now);
+      }
+    }
+    await this.saveTask(taskPath, taskData);
     await this.saveIndex(index);
+    await this.completeActions(result, taskId);
+
+    // Restore the task to every other board it was on, falling back to that board's first column if
+    // the column it used to be in has since gone
+    for (const [slug, archivedColumn] of otherBoards) {
+      const otherBoard = this.board(slug);
+      const otherIndex = await otherBoard.loadIndex();
+      const otherColumns = Object.keys(otherIndex.columns);
+      if (!otherColumns.length) {
+        missingBoards.push(slug);
+        continue;
+      }
+      await otherBoard.addTaskToBoard(
+        taskId,
+        archivedColumn in otherIndex.columns ? archivedColumn : otherColumns[0]
+      );
+    }
+    // Boards the task used to be on that no longer exist, for the caller to report. Restoring is
+    // best-effort: a deleted board shouldn't stop the task coming back to the boards that remain
+    this.lastRestoreWarnings = missingBoards;
 
     // Delete the archived task file
     await fs.promises.unlink(archivedTaskPath);