@basementuniverse/kanbn 1.0.1 → 1.1.1

package/PLANS.md

@@ -0,0 +1,9 @@
+# Future plans
+
+* multiple boards
+* epics / stories
+* swimlanes
+* list of contributors in index config
+    * dropdown in vsce taskeditor
+    * optional autopopulate from git user
+* web UI

package/README.md

@@ -39,6 +39,7 @@ Where <command> is one of:
   archive ....... Archive a task
   restore ....... Restore a task from the archive
   remove-all .... Remove the kanbn board and all tasks
+  history ....... Show task history
 
 For more help with commands, try:
 

package/docs/commands/gantt.txt

@@ -3,14 +3,10 @@
 
 Show a gantt chart for tracked tasks.
 
-Tasks are ordered using `depends-on` relations when present. The chart uses task dates, workload, and the optional
-`postponed` metadata field to estimate when work can start.
+Tasks are ordered using `depends-on` relations when present. The chart prioritizes optional `plannedStart`/`plannedFinish` metadata when arranging bars, then falls back through `started`/`completed` dates, and finally uses workload-based best-effort scheduling when no timeline dates are available.
 The rendered chart includes:
-  • A unified date axis at the bottom for easy time reference
-  • A vertical "now" line marking the current date (if within the chart range)
-  • Dependency arrows (└─→) showing which tasks depend on others
-  • Task bars with progress indicators: █ (completed), ▓ (in progress), ░ (not started)
-  • A blocked indicator (⧗) showing tasks delayed by dependencies
+  Dependency arrows (└─→) showing which tasks depend on others
+  A blocked indicator (⧗) showing tasks delayed by dependencies
 
 Options:
   {b}kanbn gantt --json{b}

package/docs/commands/history.txt

@@ -0,0 +1,29 @@
+{b}kanbn history{b}
+{b}kanbn hi{b}
+
+Show a chronological listing of task events.
+
+Options:
+  {b}kanbn history --json{b}
+  {b}kanbn history -j{b}
+    Output raw history data in JSON format.
+
+  {b}kanbn history --sprint N|"name"{b}
+  {b}kanbn history -p N|"name"{b}
+    Filter history to one or more sprints.
+    This option can be repeated to include multiple sprints.
+
+  {b}kanbn history --date "date"{b}
+  {b}kanbn history -d "date"{b}
+    Filter history by date.
+    If one date is provided, show history from this date up to the present date.
+    If two or more dates are provided, show history from the earliest to latest date.
+
+  {b}kanbn history --assigned "user"{b}
+  {b}kanbn history -a "user"{b}
+    Filter for tasks assigned to a specific user.
+
+  {b}kanbn history --task "task-id"{b}
+  {b}kanbn history -t "task-id"{b}
+    Filter for one or more task ids.
+    This option can be repeated.

package/docs/task-structure.md

@@ -13,7 +13,8 @@ progress: 0.5
 started: 2021-03-21T04:58:38.653Z
 completed: 2021-03-21T04:58:38.653Z
 due: 2021-03-21T04:58:38.653Z
-postponed: 2021-03-20T04:58:38.653Z
+plannedStart: 2021-03-20T04:58:38.653Z
+plannedFinish: 2021-03-24T04:58:38.653Z
 ---
 
 # Task Name
@@ -117,10 +118,13 @@ The date and time that the task was completed.
 
 The date and time that the task is due to be completed.
 
-### `postponed`
+### `plannedStart`
 
-The date and time after which the task should be scheduled. Gantt chart rendering uses this value as an explicit
-start-floor when present.
+An optional date and time used as a preferred start point for gantt scheduling.
+
+### `plannedFinish`
+
+An optional date and time used as a preferred finish point for gantt scheduling.
 
 ## Sub-tasks
 

package/example/.kanbn/index.md

@@ -1,18 +1,21 @@
 ---
 startedColumns:
-  - In Progress
+  - 'In Progress'
 completedColumns:
   - Done
 sprints:
-  - start: 2026-05-06T09:00:00.000Z
-    name: Foundation Sprint
-    description: Baseline product and infrastructure work.
-  - start: 2026-06-10T09:00:00.000Z
-    name: Workflow Sprint
-    description: Core team workflow and onboarding features.
-  - start: 2026-07-08T09:00:00.000Z
-    name: Stabilisation Sprint
-    description: Reliability and release readiness improvements.
+  -
+    start: 2026-07-01T09:00:00.000Z
+    name: 'Foundation Sprint'
+    description: 'Baseline product and infrastructure work.'
+  -
+    start: 2026-07-08T09:00:00.000Z
+    name: 'Workflow Sprint'
+    description: 'Core team workflow and onboarding features.'
+  -
+    start: 2026-07-15T09:00:00.000Z
+    name: 'Stabilisation Sprint'
+    description: 'Reliability and release readiness improvements.'
 taskWorkloadTags:
   Tiny: 1
   Small: 2

package/example/.kanbn/tasks/build-invoice-download-endpoint.md

@@ -1,11 +1,13 @@
 ---
 created: 2026-07-05T10:00:00.000Z
-updated: 2026-07-06T10:00:00.000Z
+updated: 2026-07-24T22:28:06.841Z
 tags:
   - Platform
   - Medium
 progress: 0
 due: 2026-07-07T10:00:00.000Z
+plannedStart: 2026-07-06T14:05:13.527Z
+plannedFinish: 2026-07-11T11:20:37.323Z
 ---
 
 # Build Invoice Download Endpoint

package/example/.kanbn/tasks/create-self-serve-cancellation-flow.md

@@ -6,7 +6,7 @@ tags:
   - Large
 progress: 0
 due: 2026-07-11T10:00:00.000Z
-postponed: 2026-07-20T10:00:00.000Z
+plannedStart: 2026-07-20T10:00:00.000Z
 ---
 
 # Create Self-serve Cancellation Flow

package/example/.kanbn/tasks/optimize-dashboard-first-load.md

@@ -8,7 +8,7 @@ assigned: Ava
 progress: 0.4
 started: 2026-07-06T10:00:00.000Z
 due: 2026-07-07T10:00:00.000Z
-postponed: 2026-07-22T10:00:00.000Z
+plannedStart: 2026-07-22T10:00:00.000Z
 ---
 
 # Optimize Dashboard First Load

package/example/.kanbn/tasks/prototype-report-export-scheduler.md

@@ -6,7 +6,7 @@ tags:
   - Large
 progress: 0
 due: 2026-07-07T10:00:00.000Z
-postponed: 2026-07-18T10:00:00.000Z
+plannedStart: 2026-07-18T10:00:00.000Z
 ---
 
 # Prototype Report Export Scheduler

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basementuniverse/kanbn",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "description": "A CLI Kanban application",
   "main": "index.js",
   "scripts": {

package/routes/add.json

@@ -16,6 +16,8 @@
       "tag",
       "relation",
       "due",
+      "plannedStart",
+      "plannedFinish",
       "progress"
     ],
     "alias": {

package/routes/edit.json

@@ -19,6 +19,8 @@
       "relation",
       "remove-relation",
       "due",
+      "plannedStart",
+      "plannedFinish",
       "progress"
     ],
     "alias": {

package/routes/find.json

@@ -28,6 +28,8 @@
       "started",
       "completed",
       "due",
+      "plannedStart",
+      "plannedFinish",
       "workload",
       "progress",
       "assigned"

package/routes/history.json

@@ -0,0 +1,27 @@
+{
+	"name": "Task History",
+	"commands": [
+		"history",
+		"hi"
+	],
+	"args": {
+		"boolean": [
+			"json"
+		],
+		"string": [
+			"date",
+			"sprint",
+			"assigned",
+			"task"
+		],
+		"alias": {
+			"json": ["j"],
+			"date": ["d"],
+			"sprint": ["p"],
+			"assigned": ["a"],
+			"task": ["t"]
+		}
+	},
+	"controller": "./src/controller/history",
+	"help": "./docs/commands/history.txt"
+}

package/routes/sort.json

@@ -27,6 +27,8 @@
       "started",
       "completed",
       "due",
+      "plannedStart",
+      "plannedFinish",
       "workload",
       "progress",
       "assigned"

package/skills/kanbn-replan/SKILL.md

@@ -0,0 +1,121 @@
+---
+name: kanbn-replan
+description: Recalculate unfinished Kanbn task dates from the current project state, preserving completed tasks and writing updated scheduled dates back to existing task markdown files.
+---
+
+# Kanbn Replan
+
+Use this skill when a Kanbn board needs to be rescheduled after time has passed, work was paused, or the current Gantt chart shows that unfinished work no longer fits the available timeline.
+
+Do not use this skill to redesign scope, rewrite completed tasks, or invent new task structure. Keep the workflow focused on rescheduling existing incomplete work.
+
+## Core Contract
+
+Your output must stay inside the Kanbn task surface:
+
+- `.kanbn/index.md`
+- `.kanbn/tasks/*.md`
+
+You may read the current board and gantt output, but the end result should be a revised schedule for existing tasks, not a new plan.
+
+Do not modify completed tasks unless the user explicitly asks to reopen them. Leave completed task descriptions, relations, and completion history intact.
+
+## When to Use
+
+Use this skill when the user wants to:
+
+- move overdue work forward to a realistic schedule
+- reschedule unfinished tasks after a long interruption
+- spread work out to reduce overload
+- refresh `started`, `plannedStart`, `plannedFinish`, and `due` dates for incomplete tasks
+- inspect Gantt output and derive a revised schedule from it
+
+## Workflow
+
+### 1. Inspect the current board state
+
+Gather the current planning context before making edits:
+
+- current date
+- tracked tasks and their columns
+- task metadata relevant to scheduling (`started`, `plannedStart`, `plannedFinish`, `due`, `progress`, workload tags)
+- dependency relations
+- the current Gantt layout
+
+Prefer `kanbn gantt -j` for the machine-readable schedule. If the replanning should be anchored to a specific point in time, pass `--now "date"` so the schedule is evaluated against the intended date.
+
+### 2. Decide what is in scope
+
+Reschedule only incomplete work.
+
+Treat these as locked unless the user says otherwise:
+
+- tasks marked complete
+- completed subtasks that should remain completed
+- task names, descriptions, comments, and history
+- dependency structure, unless the task graph itself is wrong and must be repaired to make the schedule valid
+
+If a task is incomplete but already in progress, preserve evidence of work where that matters. Prefer updating scheduling metadata over rewriting task content.
+
+### 3. Rebuild the schedule
+
+Use the gantt data and dependency order to decide new dates.
+
+General rules:
+
+- dependency order wins over wishful dates
+- `plannedStart` should be the earliest preferred start floor when present
+- `plannedFinish` should be the preferred finish target when present
+- `started` should reflect when work actually begins or resumes
+- `due` should reflect the target finish date for the current schedule
+- if a task would otherwise overlap too much with adjacent work, shift it later rather than ignoring the overload
+- if the user has returned after a long gap, treat incomplete tasks as candidates for re-baselining from the current date forward
+
+When task size information is available, use it to distribute work more realistically. If exact sizing is missing, use the gantt layout, task relations, and existing metadata as the primary signals.
+
+If `kanbn gantt -j` reports dependency cycles, stop and resolve or report them before rescheduling dependent tasks.
+
+### 4. Edit task files directly
+
+Update the existing `.kanbn/tasks/*.md` files rather than creating a new board.
+
+Prefer minimal metadata changes:
+
+- keep task titles and descriptions stable
+- update only the date fields needed to express the new plan
+- preserve completed tasks exactly as they are
+- avoid changing `created`, `completed`, comments, or history unless the user explicitly asks
+
+If the task file format uses front matter or a `Metadata` section, keep it valid and consistent with the repo docs.
+
+### 5. Verify the result
+
+After editing, validate the board:
+
+1. Run `kanbn validate`
+2. Re-run `kanbn gantt -j` to confirm the new dates produce a coherent schedule
+3. Check for obvious dependency or date regressions
+4. Fix any malformed task files before stopping
+
+## Scheduling Heuristics
+
+Use these heuristics when the user has not specified a custom policy:
+
+- keep completed tasks unchanged
+- schedule tasks in dependency order
+- move overdue unfinished tasks forward if they cannot realistically finish on their original due dates
+- avoid piling every incomplete task onto the earliest possible date
+- keep `due` dates aligned with the revised execution window
+- if a task has no meaningful `started` date yet, set it when work is planned to resume rather than inventing a long-past start
+- use workload tags and any existing custom scheduling fields as additional inputs when the board defines them
+
+## References
+
+Use the repo docs as the source of truth for the data model and commands:
+
+- `docs/commands/gantt.txt`
+- `docs/commands/edit.txt`
+- `docs/commands/validate.txt`
+- `docs/task-structure.md`
+- `docs/index-structure.md`
+

package/src/controller/add.js

@@ -23,10 +23,15 @@ async function interactiveCreateTask(taskData, taskIds, columnName, columnNames)
     'due' in taskData.metadata &&
     taskData.metadata.due != null
   );
-  const postponedDateExists = (
+  const plannedStartDateExists = (
     'metadata' in taskData &&
-    'postponed' in taskData.metadata &&
-    taskData.metadata.postponed != null
+    'plannedStart' in taskData.metadata &&
+    taskData.metadata.plannedStart != null
+  );
+  const plannedFinishDateExists = (
+    'metadata' in taskData &&
+    'plannedFinish' in taskData.metadata &&
+    taskData.metadata.plannedFinish != null
   );
   const assignedExists = (
     'metadata' in taskData &&
@@ -83,18 +88,33 @@ async function interactiveCreateTask(taskData, taskIds, columnName, columnNames)
     },
     {
       type: 'confirm',
-      name: 'setPostponed',
-      message: 'Set a postponed date?',
+      name: 'setPlannedStart',
+      message: 'Set a planned start date?',
       default: false,
-      when: answers => !postponedDateExists
+      when: answers => !plannedStartDateExists
     },
     {
       type: 'datepicker',
-      name: 'postponed',
-      message: 'Postponed date:',
-      default: postponedDateExists ? taskData.metadata.postponed : new Date(),
+      name: 'plannedStart',
+      message: 'Planned start date:',
+      default: plannedStartDateExists ? taskData.metadata.plannedStart : new Date(),
       format: ['Y', '/', 'MM', '/', 'DD'],
-      when: answers => answers.setPostponed,
+      when: answers => answers.setPlannedStart,
+    },
+    {
+      type: 'confirm',
+      name: 'setPlannedFinish',
+      message: 'Set a planned finish date?',
+      default: false,
+      when: answers => !plannedFinishDateExists
+    },
+    {
+      type: 'datepicker',
+      name: 'plannedFinish',
+      message: 'Planned finish date:',
+      default: plannedFinishDateExists ? taskData.metadata.plannedFinish : new Date(),
+      format: ['Y', '/', 'MM', '/', 'DD'],
+      when: answers => answers.setPlannedFinish,
     },
     {
       type: 'confirm',
@@ -343,11 +363,20 @@ module.exports = async args => {
     }
   }
 
-  // Postponed date
-  if (args.postponed) {
-    taskData.metadata.postponed = chrono.parseDate(utility.strArg(args.postponed));
-    if (taskData.metadata.postponed === null) {
-      utility.error('Unable to parse postponed date');
+  // Planned start date
+  if (args.plannedStart) {
+    taskData.metadata.plannedStart = chrono.parseDate(utility.strArg(args.plannedStart));
+    if (taskData.metadata.plannedStart === null) {
+      utility.error('Unable to parse plannedStart date');
+      return;
+    }
+  }
+
+  // Planned finish date
+  if (args.plannedFinish) {
+    taskData.metadata.plannedFinish = chrono.parseDate(utility.strArg(args.plannedFinish));
+    if (taskData.metadata.plannedFinish === null) {
+      utility.error('Unable to parse plannedFinish date');
       return;
     }
   }
@@ -481,8 +510,11 @@ module.exports = async args => {
       if ('due' in answers) {
         taskData.metadata.due = answers.due;
       }
-      if ('postponed' in answers) {
-        taskData.metadata.postponed = answers.postponed;
+      if ('plannedStart' in answers) {
+        taskData.metadata.plannedStart = answers.plannedStart;
+      }
+      if ('plannedFinish' in answers) {
+        taskData.metadata.plannedFinish = answers.plannedFinish;
       }
       if ('assigned' in answers) {
         taskData.metadata.assigned = answers.assigned;

package/src/controller/edit.js

@@ -23,10 +23,15 @@ async function interactive(taskData, taskIds, columnName, columnNames) {
     'due' in taskData.metadata &&
     taskData.metadata.due != null
   );
-  const postponedDateExists = (
+  const plannedStartDateExists = (
     'metadata' in taskData &&
-    'postponed' in taskData.metadata &&
-    taskData.metadata.postponed != null
+    'plannedStart' in taskData.metadata &&
+    taskData.metadata.plannedStart != null
+  );
+  const plannedFinishDateExists = (
+    'metadata' in taskData &&
+    'plannedFinish' in taskData.metadata &&
+    taskData.metadata.plannedFinish != null
   );
   const assignedExists = (
     'metadata' in taskData &&
@@ -108,10 +113,10 @@ async function interactive(taskData, taskIds, columnName, columnNames) {
     },
     {
       type: 'expand',
-      name: 'editPostponed',
-      message: 'Edit or remove postponed date?',
+      name: 'editPlannedStart',
+      message: 'Edit or remove planned start date?',
       default: 'none',
-      when: answers => postponedDateExists,
+      when: answers => plannedStartDateExists,
       choices: [
         {
           key: 'e',
@@ -133,18 +138,58 @@ async function interactive(taskData, taskIds, columnName, columnNames) {
     },
     {
       type: 'confirm',
-      name: 'setPostponed',
-      message: 'Set a postponed date?',
+      name: 'setPlannedStart',
+      message: 'Set a planned start date?',
       default: false,
-      when: answers => !postponedDateExists
+      when: answers => !plannedStartDateExists
     },
     {
       type: 'datepicker',
-      name: 'postponed',
-      message: 'Postponed date:',
-      default: postponedDateExists ? taskData.metadata.postponed : new Date(),
+      name: 'plannedStart',
+      message: 'Planned start date:',
+      default: plannedStartDateExists ? taskData.metadata.plannedStart : new Date(),
       format: ['Y', '/', 'MM', '/', 'DD'],
-      when: answers => answers.setPostponed || answers.editPostponed === 'edit'
+      when: answers => answers.setPlannedStart || answers.editPlannedStart === 'edit'
+    },
+    {
+      type: 'expand',
+      name: 'editPlannedFinish',
+      message: 'Edit or remove planned finish date?',
+      default: 'none',
+      when: answers => plannedFinishDateExists,
+      choices: [
+        {
+          key: 'e',
+          name: 'Edit',
+          value: 'edit'
+        },
+        {
+          key: 'r',
+          name: 'Remove',
+          value: 'remove'
+        },
+        new inquirer.Separator(),
+        {
+          key: 'n',
+          name: 'Do nothing',
+          value: 'none'
+        }
+      ]
+    },
+    {
+      type: 'confirm',
+      name: 'setPlannedFinish',
+      message: 'Set a planned finish date?',
+      default: false,
+      when: answers => !plannedFinishDateExists
+    },
+    {
+      type: 'datepicker',
+      name: 'plannedFinish',
+      message: 'Planned finish date:',
+      default: plannedFinishDateExists ? taskData.metadata.plannedFinish : new Date(),
+      format: ['Y', '/', 'MM', '/', 'DD'],
+      when: answers => answers.setPlannedFinish || answers.editPlannedFinish === 'edit'
     },
     {
       type: 'expand',
@@ -475,14 +520,26 @@ module.exports = async args => {
     }
   }
 
-  // Postponed date
-  if (args.postponed) {
+  // Planned start date
+  if (args.plannedStart) {
     if (!('metadata' in taskData)) {
       taskData.metadata = {};
     }
-    taskData.metadata.postponed = chrono.parseDate(utility.strArg(args.postponed));
-    if (taskData.metadata.postponed === null) {
-      utility.error('Unable to parse postponed date');
+    taskData.metadata.plannedStart = chrono.parseDate(utility.strArg(args.plannedStart));
+    if (taskData.metadata.plannedStart === null) {
+      utility.error('Unable to parse plannedStart date');
+      return;
+    }
+  }
+
+  // Planned finish date
+  if (args.plannedFinish) {
+    if (!('metadata' in taskData)) {
+      taskData.metadata = {};
+    }
+    taskData.metadata.plannedFinish = chrono.parseDate(utility.strArg(args.plannedFinish));
+    if (taskData.metadata.plannedFinish === null) {
+      utility.error('Unable to parse plannedFinish date');
       return;
     }
   }
@@ -720,14 +777,24 @@ module.exports = async args => {
         taskData.metadata.due = answers.due;
       }
 
-      // Remove postponed date
-      if ('editPostponed' in answers && answers.editPostponed === 'remove') {
-        delete taskData.metadata.postponed;
+      // Remove planned start date
+      if ('editPlannedStart' in answers && answers.editPlannedStart === 'remove') {
+        delete taskData.metadata.plannedStart;
+      }
+
+      // Planned start date
+      if ('plannedStart' in answers) {
+        taskData.metadata.plannedStart = answers.plannedStart;
+      }
+
+      // Remove planned finish date
+      if ('editPlannedFinish' in answers && answers.editPlannedFinish === 'remove') {
+        delete taskData.metadata.plannedFinish;
       }
 
-      // Postponed date
-      if ('postponed' in answers) {
-        taskData.metadata.postponed = answers.postponed;
+      // Planned finish date
+      if ('plannedFinish' in answers) {
+        taskData.metadata.plannedFinish = answers.plannedFinish;
       }
 
       // Remove assigned

package/src/controller/find.js

@@ -53,8 +53,13 @@ const searchFields = [
     type: 'date'
   },
   {
-    name: 'Postponed',
-    field: 'postponed',
+    name: 'Planned start',
+    field: 'plannedStart',
+    type: 'date'
+  },
+  {
+    name: 'Planned finish',
+    field: 'plannedFinish',
     type: 'date'
   },
   {
@@ -369,7 +374,7 @@ module.exports = async args => {
     }
   }
   if ('workload' in filters){
-    if (!convertNumericFilters(filters, 'workoad')) {
+    if (!convertNumericFilters(filters, 'workload')) {
       utility.error('Workload filter value must be numeric');
       return;
     }
@@ -412,6 +417,18 @@ module.exports = async args => {
       return;
     }
   }
+  if ('plannedStart' in filters) {
+    if (!convertDateFilters(filters, 'plannedStart')) {
+      utility.error('Unable to parse plannedStart date');
+      return;
+    }
+  }
+  if ('plannedFinish' in filters) {
+    if (!convertDateFilters(filters, 'plannedFinish')) {
+      utility.error('Unable to parse plannedFinish date');
+      return;
+    }
+  }
 
   // Check and add custom field filters
   if ('customFields' in index.options) {

package/src/controller/gantt.js

@@ -64,7 +64,8 @@ function createChartCell() {
   return {
     bg: null,
     lineMask: 0,
-    arrowChar: null
+    arrowChar: null,
+    markerChar: null
   };
 }
 
@@ -121,6 +122,38 @@ function routeDependency(grid, sourceRow, sourceCol, targetRow, targetCol) {
   grid[targetRow][targetCol].arrowChar = targetCol >= routeCol ? '→' : '←';
 }
 
+function setMarker(cell, markerChar) {
+  if (!cell.arrowChar && !cell.markerChar) {
+    cell.markerChar = markerChar;
+  }
+}
+
+function routeIncomingExternalDependency(grid, row, targetCol) {
+  const arrowCol = Math.max(0, targetCol);
+  grid[row][arrowCol].arrowChar = '→';
+
+  if (arrowCol > 0) {
+    addMask(grid[row][arrowCol], DIR_LEFT);
+    addMask(grid[row][arrowCol - 1], DIR_RIGHT);
+  }
+  if (arrowCol > 1) {
+    setMarker(grid[row][arrowCol - 2], '…');
+  }
+}
+
+function routeOutgoingExternalDependency(grid, row, sourceCol, width) {
+  const arrowCol = Math.min(width - 1, sourceCol);
+  grid[row][arrowCol].arrowChar = '→';
+
+  if (arrowCol < width - 1) {
+    addMask(grid[row][arrowCol], DIR_RIGHT);
+    addMask(grid[row][arrowCol + 1], DIR_LEFT);
+  }
+  if (arrowCol < width - 2) {
+    setMarker(grid[row][arrowCol + 2], '…');
+  }
+}
+
 function buildDependencyOverlay(tasks, barGeometries, width) {
   const grid = createChartGrid(tasks.length, width);
   const taskRowMap = new Map(tasks.map((task, index) => [task.id, index]));
@@ -140,6 +173,14 @@ function buildDependencyOverlay(tasks, barGeometries, width) {
         barGeometries[targetRow].start
       );
     });
+
+    if (Array.isArray(task.externalIncomingDependencies) && task.externalIncomingDependencies.length > 0) {
+      routeIncomingExternalDependency(grid, targetRow, barGeometries[targetRow].start);
+    }
+
+    if (Array.isArray(task.externalOutgoingDependents) && task.externalOutgoingDependents.length > 0) {
+      routeOutgoingExternalDependency(grid, targetRow, barGeometries[targetRow].end, width);
+    }
   });
 
   return grid;
@@ -165,6 +206,10 @@ function renderChartRow(gridRow, barGeometry, barBackground, nowPosition) {
       return styleCell(lineChar, ANSI_FG_LINE, bg);
     }
 
+    if (cell.markerChar) {
+      return styleCell(cell.markerChar, ANSI_FG_LINE, bg);
+    }
+
     if (nowPosition === column) {
       return styleCell(NOW_MARKER, ANSI_FG_NOW, bg);
     }
@@ -363,10 +408,9 @@ module.exports = async args => {
       });
 
       // Render x-axis
-      console.log('');
       const [ticks, labels] = renderXAxisLabels(data.from, data.to, barWidth, dateFormat);
-      console.log(`  ${''.padEnd(maxNameWidth)} │${renderTickRow(ticks, nowPosition)}│`);
-      console.log(`  ${''.padEnd(maxNameWidth)} │${labels}│`);
+      console.log(`  ${''.padEnd(maxNameWidth)}  ${renderTickRow(ticks, nowPosition)}`);
+      console.log(`  ${''.padEnd(maxNameWidth)}  ${labels}`);
     }
   })
   .catch(error => {

package/src/controller/history.js

@@ -0,0 +1,105 @@
+const kanbn = require('../main');
+const utility = require('../utility');
+const chrono = require('chrono-node');
+const formatDate = require('dateformat');
+
+function formatHistoryEvent(event) {
+	const details = [];
+	if ('column' in event.event) {
+		details.push(`column: ${event.event.column}`);
+	}
+	if ('fromColumn' in event.event || 'toColumn' in event.event) {
+		details.push(`column: ${event.event.fromColumn || '?'} -> ${event.event.toColumn || '?'}`);
+	}
+	if ('fromProgress' in event.event || 'toProgress' in event.event) {
+		details.push(`progress: ${event.event.fromProgress || 0} -> ${event.event.toProgress || 0}`);
+	}
+	if ('author' in event.event && event.event.author) {
+		details.push(`author: ${event.event.author}`);
+	}
+	return details.join(', ');
+}
+
+function formatMetadataEvent(event, dateFormat) {
+	if (!('field' in event.event) || !('value' in event.event) || !(event.event.value instanceof Date)) {
+		return '';
+	}
+	return `${event.event.field}: ${formatDate(event.event.value, dateFormat)}`;
+}
+
+module.exports = async args => {
+
+	// Make sure kanbn has been initialised
+	if (!await kanbn.initialised()) {
+		utility.error('Kanbn has not been initialised in this folder\nTry running: {b}kanbn init{b}');
+		return;
+	}
+	const index = await kanbn.getIndex();
+
+	// Get sprint numbers or names
+	let sprints = null;
+	if (args.sprint) {
+		sprints = utility.arrayArg(args.sprint).map(s => {
+			const sprintNumber = parseInt(s);
+			return isNaN(sprintNumber) ? s : sprintNumber;
+		});
+	}
+
+	// Get dates
+	let dates = null;
+	if (args.date) {
+		dates = utility.arrayArg(args.date);
+		if (dates.length) {
+			for (let i = 0; i < dates.length; i++) {
+				const dateValue = chrono.parseDate(dates[i]);
+				if (dateValue === null) {
+					utility.error('Unable to parse date');
+					return;
+				}
+				dates[i] = dateValue;
+			}
+		}
+	}
+
+	// Get assigned
+	let assigned = null;
+	if (args.assigned) {
+		assigned = utility.strArg(args.assigned);
+	}
+
+	// Get task ids
+	let taskIds = null;
+	if (args.task) {
+		taskIds = utility.arrayArg(args.task).map((taskId) => utility.trimLeftEscapeCharacters(taskId));
+	}
+
+	kanbn
+	.history(sprints, dates, assigned, taskIds)
+	.then(data => {
+		if (args.json) {
+			console.log(JSON.stringify(data, null, 2));
+			return;
+		}
+
+		if (data.events.length === 0) {
+			console.log('No history events found');
+			return;
+		}
+
+		const dateFormat = kanbn.getDateFormat(index);
+		const lines = data.events.map((event) => {
+			const eventDetails = event.source === 'history'
+				? formatHistoryEvent(event)
+				: formatMetadataEvent(event, dateFormat);
+			const source = event.source === 'history' ? event.eventType : `metadata.${event.eventType}`;
+			const line = `${formatDate(event.date, dateFormat)} | ${event.task.id} | ${source}`;
+			return eventDetails
+				? `${line} | ${eventDetails}`
+				: line;
+		});
+		console.log(lines.join('\n'));
+	})
+	.catch(error => {
+		utility.error(error);
+	});
+};

package/src/controller/sort.js

@@ -123,10 +123,18 @@ const sorterFields = [
     filterable: false
   },
   {
-    name: 'Postponed date',
-    field: 'postponed',
+    name: 'Planned start date',
+    field: 'plannedStart',
     options: [
-      '--postponed'
+      '--plannedStart'
+    ],
+    filterable: false
+  },
+  {
+    name: 'Planned finish date',
+    field: 'plannedFinish',
+    options: [
+      '--plannedFinish'
     ],
     filterable: false
   },

package/src/main.js

@@ -266,7 +266,8 @@ function sortColumnInIndex(index, tasks, columnName, sorters) {
     started: "started" in task.metadata ? task.metadata.started : "",
     completed: "completed" in task.metadata ? task.metadata.completed : "",
     due: "due" in task.metadata ? task.metadata.due : "",
-    postponed: "postponed" in task.metadata ? task.metadata.postponed : "",
+    plannedStart: "plannedStart" in task.metadata ? task.metadata.plannedStart : "",
+    plannedFinish: "plannedFinish" in task.metadata ? task.metadata.plannedFinish : "",
     assigned: "assigned" in task.metadata ? task.metadata.assigned : "",
     countSubTasks: task.subTasks.length,
     subTasks: task.subTasks.map((subTask) => `[${subTask.completed ? "x" : ""}] ${subTask.text}`).join("\n"),
@@ -840,9 +841,10 @@ function endOfDay(date) {
  */
 function getTaskGanttAnchor(task) {
   return minDate([
-    task.metadata.postponed,
+    task.metadata.plannedStart,
     task.created,
     task.started,
+    task.metadata.plannedFinish,
     task.completed
   ]) || new Date(0);
 }
@@ -903,14 +905,26 @@ function findDependencyCycle(dependencyMap) {
  * @param {Date} now
  * @return {object}
  */
-function buildGanttSchedule(index, tasks, now) {
+function buildGanttSchedule(index, tasks, now, trackedTaskIds = new Set()) {
   const taskById = new Map(tasks.map((task) => [task.id, task]));
   const dependencyMap = new Map(tasks.map((task) => [task.id, new Set()]));
   const dependentsMap = new Map();
   const indegree = new Map(tasks.map((task) => [task.id, 0]));
+  const externalIncomingDependenciesMap = new Map(tasks.map((task) => [task.id, new Set()]));
+  const externalOutgoingDependentsMap = new Map(tasks.map((task) => [task.id, new Set()]));
+
+  const taskExistsInBoard = (taskId) => trackedTaskIds.has(taskId);
 
   const addDependencyEdge = (dependencyId, dependentId) => {
+    if (!taskById.has(dependentId)) {
+      throw new Error(`Task "${dependentId}" depends on missing task "${dependencyId}"`);
+    }
+
     if (!taskById.has(dependencyId)) {
+      if (taskExistsInBoard(dependencyId)) {
+        externalIncomingDependenciesMap.get(dependentId).add(dependencyId);
+        return;
+      }
       throw new Error(`Task "${dependentId}" depends on missing task "${dependencyId}"`);
     }
 
@@ -937,7 +951,13 @@ function buildGanttSchedule(index, tasks, now) {
       if (relationType === 'depends-on') {
         addDependencyEdge(relation.task, task.id);
       } else if (relationType === 'blocks') {
-        addDependencyEdge(task.id, relation.task);
+        if (taskById.has(relation.task)) {
+          addDependencyEdge(task.id, relation.task);
+        } else if (taskExistsInBoard(relation.task)) {
+          externalOutgoingDependentsMap.get(task.id).add(relation.task);
+        } else {
+          throw new Error(`Task "${task.id}" blocks missing task "${relation.task}"`);
+        }
       }
     });
   });
@@ -986,20 +1006,47 @@ function buildGanttSchedule(index, tasks, now) {
         .filter((scheduledDependency) => scheduledDependency)
         .map((scheduledDependency) => scheduledDependency.end)
     );
-    const taskBaseDate = maxDate([
-      task.created,
-      task.started,
-      task.metadata.postponed,
-    ]);
+    const hasPlannedStart = task.metadata.plannedStart instanceof Date;
+    const hasPlannedFinish = task.metadata.plannedFinish instanceof Date;
+    const hasStarted = task.started instanceof Date;
+    const hasCompleted = task.completed instanceof Date;
+
+    const duration = hasPlannedStart && hasPlannedFinish
+      ? Math.max(DAY, task.metadata.plannedFinish.getTime() - task.metadata.plannedStart.getTime())
+      : hasStarted && hasCompleted
+        ? Math.max(DAY, task.completed.getTime() - task.started.getTime())
+        : Math.max(DAY, Math.ceil(Math.max(1, task.workload)) * DAY);
+
+    const preferredStart = hasPlannedStart
+      ? task.metadata.plannedStart
+      : hasStarted
+        ? task.started
+        : task.created;
+    const finishHint = hasPlannedFinish
+      ? task.metadata.plannedFinish
+      : hasCompleted
+        ? task.completed
+        : null;
+
+    const derivedStartFromFinish = finishHint instanceof Date
+      ? new Date(finishHint.getTime() - duration)
+      : null;
+    const taskBaseDate = hasPlannedStart || hasStarted
+      ? preferredStart
+      : (derivedStartFromFinish || preferredStart);
+
     const scheduleAnchor = maxDate([
       taskBaseDate,
       dependencyEnd
     ]) || new Date(0);
-    const duration = task.completed instanceof Date && task.started instanceof Date
-      ? Math.max(DAY, task.completed.getTime() - task.started.getTime())
-      : Math.max(DAY, Math.ceil(Math.max(1, task.workload)) * DAY);
+
     let start = new Date(scheduleAnchor.getTime());
-    let end = task.completed instanceof Date ? new Date(task.completed.getTime()) : new Date(start.getTime() + duration);
+    let end = hasPlannedFinish
+      ? new Date(task.metadata.plannedFinish.getTime())
+      : hasCompleted
+        ? new Date(task.completed.getTime())
+        : new Date(start.getTime() + duration);
+
     if (end.getTime() < start.getTime()) {
       end = new Date(start.getTime() + duration);
     }
@@ -1007,9 +1054,11 @@ function buildGanttSchedule(index, tasks, now) {
     const scheduledTask = {
       ...task,
       dependencies,
+      externalIncomingDependencies: [...(externalIncomingDependenciesMap.get(task.id) || [])],
+      externalOutgoingDependents: [...(externalOutgoingDependentsMap.get(task.id) || [])],
       start,
       end,
-      blocked: dependencyEnd !== null && taskBaseDate !== null && dependencyEnd.getTime() > taskBaseDate.getTime()
+      blocked: dependencyEnd !== null && preferredStart instanceof Date && dependencyEnd.getTime() > preferredStart.getTime()
     };
     scheduleById.set(task.id, scheduledTask);
     scheduledTasks.push(scheduledTask);
@@ -2520,7 +2569,7 @@ class Kanbn {
         if (indexSprints === null) {
           throw new Error(`No sprints defined`);
         } else {
-          for (sprint of sprints) {
+          for (let sprint of sprints) {
             let sprintIndex = null;
 
             // Select sprint by number (1-based index)
@@ -2632,6 +2681,138 @@ class Kanbn {
     return { series };
   }
 
+  /**
+   * Get a chronological list of task events from metadata dates and structured task history
+   * @param {?string[]} [sprints=null] The sprint names or numbers to include, or null for no sprint filter
+   * @param {?Date[]} [dates=null] One or more dates to define a range filter, or null for no date filter
+   * @param {?string} [assigned=null] The assigned user to filter for, or null for no assigned filter
+   * @param {?string[]} [taskIds=null] One or more task ids to filter for, or null for no task id filter
+   * @return {Promise<object>} A list of chronological task history events
+   */
+  async history(sprints = null, dates = null, assigned = null, taskIds = null) {
+    // Check if this folder has been initialised
+    if (!(await this.initialised())) {
+      throw new Error("Not initialised in this folder");
+    }
+
+    const index = await this.loadIndex();
+    const selectedTaskIds = taskIds === null
+      ? null
+      : new Set(taskIds.map((taskId) => removeFileExtension(taskId)));
+
+    // 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;
+    if (sprints !== null) {
+      if (indexSprints === null) {
+        throw new Error("No sprints defined");
+      }
+      for (let sprint of sprints) {
+        let sprintIndex = null;
+
+        // Select sprint by number (1-based index)
+        if (typeof sprint === "number") {
+          if (sprint < 1 || sprint > indexSprints.length) {
+            throw new Error(`Sprint ${sprint} does not exist`);
+          }
+          sprintIndex = sprint - 1;
+
+          // Or select sprint by name
+        } else if (typeof sprint === "string") {
+          sprintIndex = indexSprints.findIndex((s) => s.name === sprint);
+          if (sprintIndex === -1) {
+            throw new Error(`No sprint found with name "${sprint}"`);
+          }
+        }
+
+        if (sprintIndex === null) {
+          throw new Error(`Invalid sprint "${sprint}"`);
+        }
+
+        periods.push({
+          type: "sprint",
+          label: indexSprints[sprintIndex].name,
+          from: new Date(indexSprints[sprintIndex].start),
+          to: sprintIndex < indexSprints.length - 1
+            ? new Date(indexSprints[sprintIndex + 1].start)
+            : new Date(),
+        });
+      }
+    }
+
+    if (dates !== null) {
+      periods.push({
+        type: "date",
+        from: new Date(Math.min(...dates)),
+        to: dates.length === 1 ? new Date() : new Date(Math.max(...dates)),
+      });
+    }
+
+    const includeEventDate = (date) => {
+      if (!(date instanceof Date) || isNaN(date.getTime())) {
+        return false;
+      }
+      if (periods.length === 0) {
+        return true;
+      }
+      return periods.some((period) => date >= period.from && date <= period.to);
+    };
+
+    const buildBaseTask = (task) => ({
+      id: task.id,
+      name: task.name,
+      assigned: getTaskMetadata(task, "assigned") || null,
+      column: findTaskColumn(index, task.id),
+    });
+
+    const tasks = await this.loadAllTrackedTasks(index);
+    let events = tasks
+      .filter((task) => {
+        const assignedUser = getTaskMetadata(task, "assigned") || null;
+        return (
+          (assigned === null || assignedUser === assigned) &&
+          (selectedTaskIds === null || selectedTaskIds.has(task.id))
+        );
+      })
+      .map((task) => {
+        const taskBase = buildBaseTask(task);
+
+        const metadataEvents = Object.entries(task.metadata)
+          .filter(([, value]) => value instanceof Date)
+          .map(([field, value]) => ({
+            date: value,
+            source: "metadata",
+            eventType: field,
+            task: taskBase,
+            event: {
+              field,
+              value,
+            },
+          }));
+
+        const historyEvents = ("history" in task && Array.isArray(task.history) ? task.history : [])
+          .filter((historyEvent) => historyEvent.date instanceof Date)
+          .map((historyEvent) => {
+            const event = { ...historyEvent };
+            delete event.date;
+            return {
+              date: historyEvent.date,
+              source: "history",
+              eventType: historyEvent.type,
+              task: taskBase,
+              event,
+            };
+          });
+
+        return [...metadataEvents, ...historyEvents];
+      })
+      .flat()
+      .filter((event) => includeEventDate(event.date));
+
+    events.sort((a, b) => compareValues(a.date, b.date) || compareValues(a.task.id, b.task.id));
+    return { periods, events };
+  }
+
   /**
    * Output gantt chart data
    * @param {?string} [assigned=null] The assigned user to filter for, or null for no assigned filter
@@ -2659,7 +2840,8 @@ class Kanbn {
           created,
           started: "started" in task.metadata ? task.metadata.started : false,
           completed: "completed" in task.metadata ? task.metadata.completed : false,
-          postponed: "postponed" in task.metadata ? task.metadata.postponed : false,
+          plannedStart: "plannedStart" in task.metadata ? task.metadata.plannedStart : false,
+          plannedFinish: "plannedFinish" in task.metadata ? task.metadata.plannedFinish : false,
           workload: taskWorkload(index, task),
           progress: taskProgress(index, task),
           column: taskColumn,
@@ -2688,7 +2870,8 @@ class Kanbn {
         }
       );
 
-    return buildGanttSchedule(index, tasks, effectiveNow);
+    const trackedTaskIds = getTrackedTaskIds(index);
+    return buildGanttSchedule(index, tasks, effectiveNow, trackedTaskIds);
   }
 
   /**

package/src/parse-task.js

@@ -65,7 +65,13 @@ function validateMetadataFromMarkdown(metadata) {
           { type: 'date'}
         ]
       },
-      'postponed': {
+      'plannedStart': {
+        oneOf: [
+          { type: 'string' },
+          { type: 'date'}
+        ]
+      },
+      'plannedFinish': {
         oneOf: [
           { type: 'string' },
           { type: 'date'}
@@ -98,7 +104,8 @@ function validateMetadataFromJSON(metadata) {
       'started': { type: 'date'},
       'completed': { type: 'date'},
       'due': { type: 'date'},
-      'postponed': { type: 'date'},
+      'plannedStart': { type: 'date'},
+      'plannedFinish': { type: 'date'},
       'progress': { type: 'number' },
       'tags': {
         type: 'array',
@@ -373,12 +380,19 @@ module.exports = {
         }
         metadata.due = dateValue;
       }
-      if ('postponed' in metadata && !(metadata.postponed instanceof Date)) {
-        const dateValue = chrono.parseDate(metadata.postponed);
+      if ('plannedStart' in metadata && !(metadata.plannedStart instanceof Date)) {
+        const dateValue = chrono.parseDate(metadata.plannedStart);
+        if (dateValue === null) {
+          throw new Error('unable to parse plannedStart date');
+        }
+        metadata.plannedStart = dateValue;
+      }
+      if ('plannedFinish' in metadata && !(metadata.plannedFinish instanceof Date)) {
+        const dateValue = chrono.parseDate(metadata.plannedFinish);
         if (dateValue === null) {
-          throw new Error('unable to parse postponed date');
+          throw new Error('unable to parse plannedFinish date');
         }
-        metadata.postponed = dateValue;
+        metadata.plannedFinish = dateValue;
       }
 
       // Check progress value