kanbango 3.6.2 → 5.1.0

package/config-wizard.js

@@ -0,0 +1,441 @@
+/**
+ * Interactive checkbox TUI for backlog/kanbango.json.
+ * Zero deps. Injectable stdin/stdout for tests (fake TTY + setRawMode).
+ */
+const fs = require('fs').promises;
+const path = require('path');
+
+const CONFIG_REL = path.join('backlog', 'kanbango.json');
+
+const DEFAULT_ANSWERS = {
+  testing: false,
+  testingAgent: false,
+  review: false,
+  reviewAgent: false
+};
+
+const ITEMS = [
+  { key: 'testing', label: 'Testing column (QA gate)' },
+  { key: 'testingAgent', label: 'Auto QA agent (qa-tester)', dependsOn: 'testing' },
+  { key: 'review', label: 'Review column (Temida gate)' },
+  { key: 'reviewAgent', label: 'Auto review agent (temida)', dependsOn: 'review' }
+];
+
+const NON_TTY_HINT =
+  'Run kanban config in a terminal to enable auto QA/review gates (backlog/kanbango.json).';
+
+const IGNORABLE_STREAM_CODES = new Set(['ERR_INVALID_STATE', 'EIO', 'ERR_STREAM_DESTROYED']);
+
+function cloneAnswers(source = DEFAULT_ANSWERS) {
+  return {
+    testing: Boolean(source.testing),
+    testingAgent: Boolean(source.testingAgent),
+    review: Boolean(source.review),
+    reviewAgent: Boolean(source.reviewAgent)
+  };
+}
+
+function agentEnabled(field) {
+  if (field === undefined) return true;
+  if (typeof field === 'string') return true;
+  if (!field || typeof field !== 'object') return false;
+  return field.enabled !== false;
+}
+
+/**
+ * Map wizard answers → kanbango.json body consumed by workflow.js.
+ * Agent flags forced off when their column is off.
+ * workflow.enabled = true when any agent is on.
+ */
+function answersToConfig(answers) {
+  const a = cloneAnswers(answers);
+  const testing = a.testing;
+  const review = a.review;
+  const testingAgent = testing && a.testingAgent;
+  const reviewAgent = review && a.reviewAgent;
+  return {
+    columns: {
+      testing: { enabled: testing, label: 'Testing' },
+      review: { enabled: review, label: 'Review' }
+    },
+    workflow: {
+      enabled: testingAgent || reviewAgent,
+      testing_agent: { enabled: testingAgent, name: 'qa-tester' },
+      review_agent: { enabled: reviewAgent, name: 'temida' }
+    }
+  };
+}
+
+/** Prefill answers from file body or loadConfig-shaped object. */
+function configToAnswers(config) {
+  if (!config || typeof config !== 'object') return cloneAnswers();
+  const cols = config.columns || {};
+  const testingOn = !(cols.testing && cols.testing.enabled === false);
+  const reviewOn = !(cols.review && cols.review.enabled === false);
+  const wf = (config.workflow && typeof config.workflow === 'object')
+    ? config.workflow
+    : config;
+  return {
+    testing: testingOn,
+    testingAgent: testingOn && agentEnabled(wf.testing_agent),
+    review: reviewOn,
+    reviewAgent: reviewOn && agentEnabled(wf.review_agent)
+  };
+}
+
+function isInteractive(stdin = process.stdin, stdout = process.stdout) {
+  return Boolean(stdin && stdin.isTTY && stdout && stdout.isTTY);
+}
+
+function configPath(cwd = process.cwd()) {
+  return path.join(cwd, CONFIG_REL);
+}
+
+async function configExists(cwd = process.cwd()) {
+  try {
+    await fs.access(configPath(cwd));
+    return true;
+  } catch (error) {
+    if (error && error.code === 'ENOENT') return false;
+    throw error;
+  }
+}
+
+function configInvalid(message, hint) {
+  const err = new Error(message);
+  err.code = 'CONFIG_INVALID';
+  err.hint = hint;
+  return err;
+}
+
+/**
+ * Read existing file. Throws CONFIG_INVALID on bad JSON/shape (never silent).
+ * Returns null on ENOENT.
+ */
+async function readConfigFile(cwd = process.cwd()) {
+  const filePath = configPath(cwd);
+  let raw;
+  try {
+    raw = await fs.readFile(filePath, 'utf-8');
+  } catch (error) {
+    if (error && error.code === 'ENOENT') return null;
+    throw error;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw configInvalid(
+      `backlog/kanbango.json is not valid JSON: ${error.message}`,
+      'Fix JSON syntax or remove the file, then run kanban config'
+    );
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw configInvalid(
+      'backlog/kanbango.json root must be an object',
+      'Use { "workflow": { ... }, "columns": { ... } }'
+    );
+  }
+  return parsed;
+}
+
+async function writeConfigFile(body, cwd = process.cwd()) {
+  const filePath = configPath(cwd);
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, JSON.stringify(body, null, 2) + '\n', 'utf-8');
+  return filePath;
+}
+
+function renderFrame(answers, cursor) {
+  const lines = [
+    'kanbango project config',
+    'Space toggle · ↑↓/jk move · Enter save · q cancel',
+    ''
+  ];
+  for (let i = 0; i < ITEMS.length; i++) {
+    const item = ITEMS[i];
+    const disabled = item.dependsOn && !answers[item.dependsOn];
+    const on = disabled ? false : Boolean(answers[item.key]);
+    const mark = on ? '[x]' : '[ ]';
+    const pointer = i === cursor ? '>' : ' ';
+    const suffix = disabled ? ' (off — enable column first)' : '';
+    lines.push(`${pointer} ${mark} ${item.label}${suffix}`);
+  }
+  lines.push('');
+  lines.push('Save writes backlog/kanbango.json');
+  return lines.join('\n');
+}
+
+function applyToggle(answers, key) {
+  const next = cloneAnswers(answers);
+  const item = ITEMS.find((entry) => entry.key === key);
+  if (!item) return next;
+  if (item.dependsOn && !next[item.dependsOn]) return next;
+  const wasOn = next[key];
+  next[key] = !wasOn;
+  if (key === 'testing' && !next.testing) next.testingAgent = false;
+  if (key === 'review' && !next.review) next.reviewAgent = false;
+  if (key === 'testing' && next.testing && !wasOn) next.testingAgent = true;
+  if (key === 'review' && next.review && !wasOn) next.reviewAgent = true;
+  return next;
+}
+
+function isIgnorableStreamError(error) {
+  return Boolean(error && IGNORABLE_STREAM_CODES.has(error.code));
+}
+
+function restoreRawMode(stdin, previousRaw) {
+  if (typeof stdin.setRawMode !== 'function') return;
+  try {
+    stdin.setRawMode(previousRaw);
+  } catch (error) {
+    if (!isIgnorableStreamError(error)) throw error;
+  }
+}
+
+function safePause(stdin) {
+  if (typeof stdin.pause !== 'function') return;
+  try {
+    stdin.pause();
+  } catch (error) {
+    if (!isIgnorableStreamError(error)) throw error;
+  }
+}
+
+function paintFrame(stdout, answers, cursor) {
+  if (typeof stdout.write !== 'function') return;
+  if (stdout.isTTY) stdout.write('\x1b[2J\x1b[H');
+  stdout.write(renderFrame(answers, cursor) + '\n');
+}
+
+/** Parse one key. action: move|toggle|save|cancel|noop */
+function handleKey(ch, code, seqTail) {
+  if (code === 3) return { action: 'cancel' };
+  if (ch === 'q' || ch === 'Q') return { action: 'cancel' };
+  if (ch === '\r' || ch === '\n') return { action: 'save' };
+  if (ch === ' ') return { action: 'toggle' };
+  if (ch === 'j') return { action: 'move', delta: 1 };
+  if (ch === 'k') return { action: 'move', delta: -1 };
+  if (ch === '\x1b' && seqTail[0] === '[' && (seqTail[1] === 'A' || seqTail[1] === 'B')) {
+    return { action: 'move', delta: seqTail[1] === 'A' ? -1 : 1, consume: 2 };
+  }
+  return { action: 'noop' };
+}
+
+function applyKeyResult(state, result) {
+  if (result.action === 'toggle') {
+    state.answers = applyToggle(state.answers, ITEMS[state.cursor].key);
+    return 'paint';
+  }
+  if (result.action === 'move') {
+    state.cursor = (state.cursor + result.delta + ITEMS.length) % ITEMS.length;
+    return 'paint';
+  }
+  return result.action;
+}
+
+function makeSessionCleanup(stdin, getRawState, onData) {
+  return function cleanup() {
+    if (typeof stdin.removeListener === 'function') {
+      stdin.removeListener('data', onData);
+    }
+    const raw = getRawState();
+    if (raw.hasRaw && raw.rawWasSet) {
+      restoreRawMode(stdin, raw.previousRaw);
+      raw.rawWasSet = false;
+    }
+    safePause(stdin);
+  };
+}
+
+function processWizardChunk(chunk, state, finish, stdout) {
+  const s = Buffer.isBuffer(chunk) ? chunk.toString('utf-8') : String(chunk);
+  let i = 0;
+  while (i < s.length) {
+    const result = handleKey(s[i], s.charCodeAt(i), s.slice(i + 1));
+    i += 1 + (result.consume || 0);
+    const outcome = applyKeyResult(state, result);
+    if (outcome === 'cancel') {
+      finish(null);
+      return true;
+    }
+    if (outcome === 'save') {
+      finish(cloneAnswers(state.answers));
+      return true;
+    }
+    if (outcome === 'paint') paintFrame(stdout, state.answers, state.cursor);
+  }
+  return false;
+}
+
+function enableRawInput(stdin, raw) {
+  if (raw.hasRaw) {
+    raw.previousRaw = Boolean(stdin.isRaw);
+    stdin.setRawMode(true);
+    raw.rawWasSet = true;
+  }
+  if (typeof stdin.resume === 'function') stdin.resume();
+  if (typeof stdin.setEncoding === 'function') stdin.setEncoding('utf-8');
+}
+
+function attachWizardSession(stdin, stdout, initial) {
+  const state = { answers: cloneAnswers(initial), cursor: 0 };
+  let settled = false;
+  const raw = {
+    hasRaw: typeof stdin.setRawMode === 'function',
+    rawWasSet: false,
+    previousRaw: false
+  };
+  let resolveFn;
+  let rejectFn;
+  let cleanup;
+
+  function finish(value) {
+    if (settled) return;
+    settled = true;
+    cleanup();
+    resolveFn(value);
+  }
+
+  function fail(error) {
+    if (settled) return;
+    settled = true;
+    cleanup();
+    rejectFn(error);
+  }
+
+  function onData(chunk) {
+    processWizardChunk(chunk, state, finish, stdout);
+  }
+
+  cleanup = makeSessionCleanup(stdin, () => raw, onData);
+
+  function start(resolve, reject) {
+    resolveFn = resolve;
+    rejectFn = reject;
+    try {
+      enableRawInput(stdin, raw);
+      stdin.on('data', onData);
+      paintFrame(stdout, state.answers, state.cursor);
+    } catch (error) {
+      fail(error);
+    }
+  }
+
+  return { start, cleanup };
+}
+
+/**
+ * Run checkbox TUI. Resolves to answers, or null on cancel.
+ * Requires TTY-like stdin/stdout. Always restores raw mode + removes listeners.
+ */
+function runWizard({
+  stdin = process.stdin,
+  stdout = process.stdout,
+  initial = DEFAULT_ANSWERS
+} = {}) {
+  if (!isInteractive(stdin, stdout)) {
+    const err = new Error('Interactive terminal required');
+    err.code = 'NOT_TTY';
+    err.hint = 'Run kanban config in a terminal (stdin and stdout must be TTY)';
+    return Promise.reject(err);
+  }
+  const session = attachWizardSession(stdin, stdout, initial);
+  return new Promise((resolve, reject) => session.start(resolve, reject));
+}
+
+async function saveAnswers(answers, cwd, log) {
+  const body = answersToConfig(answers);
+  const filePath = await writeConfigFile(body, cwd);
+  const rel = path.relative(cwd, filePath) || CONFIG_REL;
+  log(`✓ Wrote ${rel}`);
+  return { wrote: true, path: filePath, body };
+}
+
+async function wizardSaveOrCancel(run, cancelMessage, cwd, log) {
+  const answers = await run();
+  if (answers === null) {
+    log(cancelMessage);
+    return { wrote: false, reason: 'cancelled' };
+  }
+  return saveAnswers(answers, cwd, log);
+}
+
+function resolveIo(opts = {}) {
+  return {
+    cwd: opts.cwd || process.cwd(),
+    stdin: opts.stdin || process.stdin,
+    stdout: opts.stdout || process.stdout,
+    log: opts.log || console.log
+  };
+}
+
+function requireInteractive(stdin, stdout) {
+  if (isInteractive(stdin, stdout)) return;
+  const err = new Error('Interactive terminal required');
+  err.code = 'NOT_TTY';
+  err.hint = NON_TTY_HINT;
+  throw err;
+}
+
+/**
+ * init / mcp-init: prompt only when file missing + TTY.
+ * Never overwrites existing file. Never blocks non-TTY.
+ */
+async function maybeCreateConfigOnInit(opts = {}) {
+  const { cwd, stdin, stdout, log } = resolveIo(opts);
+  if (await configExists(cwd)) {
+    return { wrote: false, reason: 'exists' };
+  }
+  if (!isInteractive(stdin, stdout)) {
+    log(NON_TTY_HINT);
+    return { wrote: false, reason: 'non_tty' };
+  }
+  return wizardSaveOrCancel(
+    () => runWizard({ stdin, stdout, initial: DEFAULT_ANSWERS }),
+    '• Config wizard cancelled — no kanbango.json written',
+    cwd,
+    log
+  );
+}
+
+/**
+ * kanban config: always require TTY. Prefill from existing valid file.
+ * Malformed existing file → throw CONFIG_INVALID (do not open TUI / do not replace).
+ */
+async function runConfigCommand(opts = {}) {
+  const { cwd, stdin, stdout, log } = resolveIo(opts);
+  requireInteractive(stdin, stdout);
+
+  let initial = cloneAnswers();
+  const existing = await readConfigFile(cwd);
+  if (existing) initial = configToAnswers(existing);
+
+  return wizardSaveOrCancel(
+    () => runWizard({ stdin, stdout, initial }),
+    '• Config wizard cancelled — file unchanged',
+    cwd,
+    log
+  );
+}
+
+module.exports = {
+  DEFAULT_ANSWERS,
+  ITEMS,
+  CONFIG_REL,
+  NON_TTY_HINT,
+  answersToConfig,
+  configToAnswers,
+  cloneAnswers,
+  isInteractive,
+  configPath,
+  configExists,
+  readConfigFile,
+  writeConfigFile,
+  renderFrame,
+  applyToggle,
+  handleKey,
+  runWizard,
+  maybeCreateConfigOnInit,
+  runConfigCommand
+};

package/index.html

@@ -238,6 +238,23 @@ header h1 { font-size: 14px; font-weight: 700; letter-spacing: -0.2px; }
   border-radius: 10px;
   padding: 1px 7px;
 }
+.now-context {
+  font-size: 10px;
+  font-weight: 700;
+  color: var(--active);
+  margin-left: auto;
+  letter-spacing: 0;
+  text-transform: none;
+}
+.card-blocked {
+  font-size: 10px;
+  font-weight: 700;
+  color: #991b1b;
+  background: #fee2e2;
+  border-radius: 4px;
+  padding: 1px 6px;
+  margin-top: 6px;
+}
 .now-cards {
   display: flex;
   flex-wrap: wrap;
@@ -793,31 +810,11 @@ header h1 { font-size: 14px; font-weight: 700; letter-spacing: -0.2px; }
       <div class="now-head">
         <span class="now-title">NOW</span>
         <span class="now-count" id="now-count">0</span>
+        <span class="now-context" id="now-context"></span>
       </div>
       <div class="now-cards" id="now-cards"></div>
     </div>
-    <div id="board-cols">
-      <div class="col" data-col="icebox">
-        <div class="col-head icebox">Icebox <span class="ch-count" id="cnt-icebox">0</span></div>
-        <div class="col-body" id="col-icebox"></div>
-      </div>
-      <div class="col" data-col="planned">
-        <div class="col-head planned">Planned <span class="ch-count" id="cnt-planned">0</span></div>
-        <div class="col-body" id="col-planned"></div>
-      </div>
-      <div class="col" data-col="testing">
-        <div class="col-head testing">Testing <span class="ch-count" id="cnt-testing">0</span></div>
-        <div class="col-body" id="col-testing"></div>
-      </div>
-      <div class="col" data-col="review">
-        <div class="col-head review">Review <span class="ch-count" id="cnt-review">0</span></div>
-        <div class="col-body" id="col-review"></div>
-      </div>
-      <div class="col" data-col="done">
-        <div class="col-head done">Done <span class="ch-count" id="cnt-done">0</span></div>
-        <div class="col-body" id="col-done"></div>
-      </div>
-    </div>
+    <div id="board-cols"></div>
   </section>
 
   <aside id="paper">
@@ -830,8 +827,8 @@ header h1 { font-size: 14px; font-weight: 700; letter-spacing: -0.2px; }
 <script src="/vendor/fenced-text.js"></script>
 <script src="/vendor/mermaid.min.js"></script>
 <script>
-// Board columns exclude active — active lives in NOW only.
-const BOARD_COLS = [
+// Board columns exclude active — active lives in NOW only. Filled from /api/config.
+let BOARD_COLS = [
   { id: "icebox",  label: "Icebox" },
   { id: "planned", label: "Planned" },
   { id: "testing", label: "Testing" },
@@ -839,10 +836,20 @@ const BOARD_COLS = [
   { id: "done",    label: "Done" }
 ];
 // Move order: icebox ↔ planned ↔ active(NOW) ↔ testing ↔ review ↔ done
-const MOVE_ORDER = ["icebox", "planned", "active", "testing", "review", "done"];
+let MOVE_ORDER = ["icebox", "planned", "active", "testing", "review", "done"];
+let COLUMN_TRANSITIONS = {
+  icebox: ["planned"],
+  planned: ["active", "icebox", "testing"],
+  active: ["planned", "testing", "icebox"],
+  testing: ["active", "review"],
+  review: ["active", "done"],
+  done: ["active"]
+};
+let boardConfig = null;
 
 let allTasks = [];
 let allEpicEntities = [];
+let agentContext = null;
 /** @type {null|string} null=all, "—"=no epic, "E001"=epic id */
 let filterKey = null;
 /** @type {null|{kind:'task'|'epic', id:string}} */
@@ -852,16 +859,70 @@ let dirtyEdits = {};
 let dirtyEpicEdits = {};
 let showArchived = false;
 
+function applyBoardConfig(cfg) {
+  if (!cfg || typeof cfg !== "object") return;
+  boardConfig = cfg;
+  if (Array.isArray(cfg.board_columns) && cfg.board_columns.length) {
+    BOARD_COLS = cfg.board_columns.map((c) => ({ id: c.id, label: c.label || c.id }));
+  }
+  if (Array.isArray(cfg.move_order) && cfg.move_order.length) {
+    MOVE_ORDER = cfg.move_order.slice();
+  }
+  if (cfg.transitions && typeof cfg.transitions === "object") {
+    COLUMN_TRANSITIONS = cfg.transitions;
+  }
+  rebuildBoardColsDom();
+  rebuildNewTaskColSelect();
+}
+
+function rebuildBoardColsDom() {
+  const host = document.getElementById("board-cols");
+  if (!host) return;
+  host.innerHTML = BOARD_COLS.map((col) => `
+    <div class="col" data-col="${escHtml(col.id)}">
+      <div class="col-head ${escHtml(col.id)}">${escHtml(col.label)} <span class="ch-count" id="cnt-${escHtml(col.id)}">0</span></div>
+      <div class="col-body" id="col-${escHtml(col.id)}"></div>
+    </div>
+  `).join("");
+}
+
+function rebuildNewTaskColSelect() {
+  const sel = document.getElementById("ne-col");
+  if (!sel) return;
+  const opts = [
+    { id: "icebox", label: "Icebox" },
+    { id: "planned", label: "Planned" },
+    { id: "active", label: "NOW (active)" }
+  ];
+  for (const col of BOARD_COLS) {
+    if (col.id === "icebox" || col.id === "planned" || col.id === "done") continue;
+    opts.push({ id: col.id, label: col.label });
+  }
+  opts.push({ id: "done", label: "Done" });
+  const prev = sel.value || "planned";
+  sel.innerHTML = opts.map((o) =>
+    `<option value="${escHtml(o.id)}"${o.id === prev || (o.id === "planned" && !opts.some((x) => x.id === prev)) ? " selected" : ""}>${escHtml(o.label)}</option>`
+  ).join("");
+}
+
 // ── Load & render ─────────────────────────────────────────────────────────────
 
 async function load() {
   const q = showArchived ? "?include_archived=true" : "";
-  const [boardRes, epicsRes] = await Promise.all([
+  const [boardRes, epicsRes, configRes, contextRes] = await Promise.all([
     fetch("/api/board" + q),
-    fetch("/api/epics" + q)
+    fetch("/api/epics" + q),
+    fetch("/api/config"),
+    fetch("/api/context")
   ]);
+  if (!configRes.ok) {
+    toast('Board config failed to load — using default columns', true);
+  } else {
+    applyBoardConfig(await configRes.json());
+  }
   allTasks = await boardRes.json();
   allEpicEntities = epicsRes.ok ? await epicsRes.json() : [];
+  agentContext = contextRes.ok ? await contextRes.json() : null;
   refreshEpicDatalist();
   // Drop paper target if entity vanished
   if (paperTarget) {
@@ -988,6 +1049,17 @@ function makeRailItem({ key, title, idLabel, count, status, on, entity }) {
 function renderNow(tasks) {
   const active = tasks.filter(t => t.column === "active");
   document.getElementById("now-count").textContent = String(active.length);
+  const ctxEl = document.getElementById("now-context");
+  if (ctxEl) {
+    const action = agentContext && agentContext.next_action;
+    if (!action) {
+      ctxEl.textContent = "";
+    } else {
+      const bits = ["next_action: " + action];
+      if (agentContext.task_id) bits.push(agentContext.task_id);
+      ctxEl.textContent = bits.join(" · ");
+    }
+  }
   const wrap = document.getElementById("now-cards");
   wrap.innerHTML = "";
   if (active.length === 0) {
@@ -1034,15 +1106,6 @@ function currentEpicRef() {
   return "";
 }
 
-const COLUMN_TRANSITIONS = {
-  icebox: ["planned"],
-  planned: ["active", "icebox", "testing"],
-  active: ["planned", "testing", "icebox"],
-  testing: ["active", "review"],
-  review: ["active", "done"],
-  done: ["active"]
-};
-
 function getNeighborCols(colId) {
   const allowed = COLUMN_TRANSITIONS[colId] || [];
   const idx = MOVE_ORDER.indexOf(colId);
@@ -1091,6 +1154,15 @@ function renderCard(task, colId) {
   titleEl.textContent = displayTitle;
   card.appendChild(titleEl);
 
+  const unmet = Array.isArray(task.unmet_dependencies) ? task.unmet_dependencies : [];
+  if (task.blocked || unmet.length > 0) {
+    const blockedEl = el("div", "card-blocked");
+    blockedEl.textContent = unmet.length
+      ? "blocked by " + unmet.join(", ")
+      : "blocked";
+    card.appendChild(blockedEl);
+  }
+
   if (totalT > 0 && colId !== "icebox") {
     const pr = el("div", "prog-row");
     pr.innerHTML = `
@@ -1228,6 +1300,13 @@ function renderTaskPaperView(paper, task) {
   ];
   if (task.epic_id) badges.push({ text: task.epic_id, cls: "" });
   if (task.plan && task.plan.status) badges.push({ text: "plan:" + task.plan.status, cls: "" });
+  const paperUnmet = Array.isArray(task.unmet_dependencies) ? task.unmet_dependencies : [];
+  if (task.blocked || paperUnmet.length > 0) {
+    badges.push({
+      text: paperUnmet.length ? "blocked by " + paperUnmet.join(", ") : "blocked",
+      cls: ""
+    });
+  }
 
   const actions = [
     makePaperBtn("Edit", "btn-sm btn-confirm", () => { paperEditing = true; render(); }),
@@ -1260,6 +1339,15 @@ function renderTaskPaperView(paper, task) {
     body.appendChild(renderDetailListSection("Test Cases", task.test_cases));
   }
   if (task.notes) body.appendChild(renderDetailSection("Notes", task.notes));
+  if (task.depends_on && task.depends_on.length) {
+    body.appendChild(renderDetailListSection("Depends on", task.depends_on));
+  }
+  if (paperUnmet.length) {
+    body.appendChild(renderDetailListSection("blocked by", paperUnmet));
+  }
+  if (task.files && task.files.length) {
+    body.appendChild(renderDetailListSection("Files", task.files));
+  }
 
   const subtasks = task.subtasks || [];
   if (subtasks.length > 0) {