fix(board): archive finished task cards and complete an overall card

A group that has finished hundreds of cards kept shipping every one of them to
each board read, and an overall card stayed working after its last child
completed. The tasks read now returns active work only; `archive: true` is the
same read including the finished rows, so the client's Done column shows a
bounded slice of it. Finishing or cancelling the last open child completes the
overall card through the same move a person would make.

Fixes #1252
Written-by: Dev-1

Author: HugoXK

changelog.d/1252-board-archive.changed.md

@@ -0,0 +1 @@
+A finished task card leaves the task board's active list, and the Done column shows the newest 20 archived cards; a group's overall card now completes when its last child finishes or is cancelled (#1252).

core/client.js

@@ -8854,6 +8854,10 @@ function shortId(id) {
   const hex = String(id ?? "").replace(/^task-/, "");
   return `#${hex.slice(-6)}`;
 }
+var ARCHIVE_SHOWN = 20;
+function boardTasksFor(tasks, archive, limit = ARCHIVE_SHOWN) {
+  return [...tasks ?? [], ...(archive ?? []).slice(0, limit)];
+}
 function boardColumns(tasks) {
   const columns = { "not-started": [], "in-progress": [], done: [] };
   for (const task of tasks ?? []) {
@@ -8974,19 +8978,27 @@ function lanesOf(tasks, roster) {
   }
   return order.map((id) => ({ id, name: botName(roster, map.get(id)[0]) || id, tasks: map.get(id) }));
 }
+var upsert = (list, task) => list.some((item) => item.id === task.id) ? list.map((item) => item.id === task.id ? task : item) : [...list, task];
+var without = (list, id) => list.filter((item) => item.id !== id);
 function useBoardTasks(actions, scope) {
   const [own, setOwn] = (0, import_react17.useState)([]);
   const [groupTasks, setGroupTasks] = (0, import_react17.useState)([]);
+  const [archive, setArchive] = (0, import_react17.useState)([]);
   const key = scope?.kind === "group" ? `group:${scope.roomId}` : "own";
   (0, import_react17.useEffect)(() => {
     let stopped = false;
     const load = () => {
-      const job = scope?.kind === "group" ? Promise.resolve(actions?.tasks?.({ roomId: scope.roomId })) : Promise.resolve(actions?.tasks?.());
+      const query = scope?.kind === "group" ? { roomId: scope.roomId } : {};
+      const job = scope?.kind === "group" ? Promise.resolve(actions?.tasks?.(query)) : Promise.resolve(actions?.tasks?.());
       void job.then((list) => {
         if (stopped || !Array.isArray(list)) return;
         if (scope?.kind === "group") setGroupTasks(list);
         else setOwn(list);
       }).catch(() => void 0);
+      void Promise.resolve(actions?.tasks?.({ ...query, archive: true })).then((list) => {
+        if (stopped || !Array.isArray(list)) return;
+        setArchive(list.filter((task) => columnOf(task) === "done"));
+      }).catch(() => void 0);
     };
     load();
     const timer = setInterval(load, POLL_MS4);
@@ -8997,11 +9009,13 @@ function useBoardTasks(actions, scope) {
   }, [key]);
   const tasks = scope?.kind === "group" ? groupTasks : own.filter((task) => !scope?.botId || task.ownerBotId === scope.botId);
   const replace = (task) => {
-    const write = (list) => list.some((item) => item.id === task.id) ? list.map((item) => item.id === task.id ? task : item) : [...list, task];
-    if (scope?.kind === "group") setGroupTasks(write);
-    else setOwn(write);
+    const done2 = columnOf(task) === "done";
+    if (scope?.kind === "group") setGroupTasks((list) => done2 ? without(list, task.id) : upsert(list, task));
+    else setOwn((list) => done2 ? without(list, task.id) : upsert(list, task));
+    setArchive((list) => done2 ? [task, ...without(list, task.id)] : without(list, task.id));
   };
-  return { own, tasks, replace };
+  const done = scope?.kind === "group" ? archive : archive.filter((task) => !scope?.botId || task.ownerBotId === scope.botId);
+  return { own, tasks, archive: done, replace };
 }
 function RailButton({ row, selected, meta, onSelect }) {
   return (0, import_react17.createElement)(
@@ -9210,11 +9224,12 @@ function KanbanDialog({ roster, actions, leaving = false }) {
   const [dragging, setDragging] = (0, import_react17.useState)(null);
   const [error, setError] = (0, import_react17.useState)("");
   const [draft, setDraft] = (0, import_react17.useState)("");
-  const { own, tasks, replace } = useBoardTasks(actions, scope);
+  const { own, tasks, archive, replace } = useBoardTasks(actions, scope);
+  const boardTasks = boardTasksFor(tasks, archive);
   const close = (0, import_react17.useCallback)(() => actions.closeBoard(), []);
   useEscape(close);
   const counts2 = {};
-  for (const task of own) {
+  for (const task of [...own, ...archive]) {
     const id = task.ownerBotId;
     const bucket = counts2[id] ?? (counts2[id] = { done: 0, total: 0 });
     if (task.status === "cancelled" || task.status === "failed") continue;
@@ -9266,7 +9281,7 @@ function KanbanDialog({ roster, actions, leaving = false }) {
       ),
       view === "delivery" ? (0, import_react17.createElement)(DeliveryView, { actions }) : (0, import_react17.createElement)(BoardView, {
         roster,
-        tasks,
+        tasks: boardTasks,
         rail,
         scope,
         counts: counts2,

core/src/client/kanban.js

@@ -24,6 +24,14 @@ export function shortId(id) {
   return `#${hex.slice(-6)}`
 }
 
+// #1252: the board lists active work; the Done column reads a bounded slice of the archive,
+// so a room with hundreds of finished cards still renders a column, not the whole history.
+export const ARCHIVE_SHOWN = 20
+
+export function boardTasksFor(tasks, archive, limit = ARCHIVE_SHOWN) {
+  return [...(tasks ?? []), ...(archive ?? []).slice(0, limit)]
+}
+
 export function boardColumns(tasks) {
   const columns = { 'not-started': [], 'in-progress': [], done: [] }
   for (const task of tasks ?? []) {
@@ -150,34 +158,47 @@ function lanesOf(tasks, roster) {
   return order.map(id => ({ id, name: botName(roster, map.get(id)[0]) || id, tasks: map.get(id) }))
 }
 
+const upsert = (list, task) => (list.some(item => item.id === task.id) ? list.map(item => item.id === task.id ? task : item) : [...list, task])
+const without = (list, id) => list.filter(item => item.id !== id)
+
 export function useBoardTasks(actions, scope) {
   const [own, setOwn] = useState([])
   const [groupTasks, setGroupTasks] = useState([])
+  const [archive, setArchive] = useState([])
   const key = scope?.kind === 'group' ? `group:${scope.roomId}` : 'own'
   useEffect(() => {
     let stopped = false
     const load = () => {
+      const query = scope?.kind === 'group' ? { roomId: scope.roomId } : {}
+      // #1252: the default list is active work, so the Done column asks for the archive.
       const job = scope?.kind === 'group'
-        ? Promise.resolve(actions?.tasks?.({ roomId: scope.roomId }))
+        ? Promise.resolve(actions?.tasks?.(query))
         : Promise.resolve(actions?.tasks?.())
       // A reading host or an older core has no board; keep the list already shown.
       void job.then((list) => {
         if (stopped || !Array.isArray(list)) return
         if (scope?.kind === 'group') setGroupTasks(list)
         else setOwn(list)
       }).catch(() => undefined)
+      void Promise.resolve(actions?.tasks?.({ ...query, archive: true })).then((list) => {
+        if (stopped || !Array.isArray(list)) return
+        setArchive(list.filter(task => columnOf(task) === 'done'))
+      }).catch(() => undefined)
     }
     load()
     const timer = setInterval(load, POLL_MS)
     return () => { stopped = true; clearInterval(timer) }
   }, [key])
   const tasks = scope?.kind === 'group' ? groupTasks : own.filter(task => !scope?.botId || task.ownerBotId === scope.botId)
+  // A finished card moves off the active list into the archive immediately, before the next poll.
   const replace = (task) => {
-    const write = (list) => (list.some(item => item.id === task.id) ? list.map(item => item.id === task.id ? task : item) : [...list, task])
-    if (scope?.kind === 'group') setGroupTasks(write)
-    else setOwn(write)
+    const done = columnOf(task) === 'done'
+    if (scope?.kind === 'group') setGroupTasks(list => done ? without(list, task.id) : upsert(list, task))
+    else setOwn(list => done ? without(list, task.id) : upsert(list, task))
+    setArchive(list => done ? [task, ...without(list, task.id)] : without(list, task.id))
   }
-  return { own, tasks, replace }
+  const done = scope?.kind === 'group' ? archive : archive.filter(task => !scope?.botId || task.ownerBotId === scope.botId)
+  return { own, tasks, archive: done, replace }
 }
 
 function RailButton({ row, selected, meta, onSelect }) {
@@ -338,11 +359,12 @@ export function KanbanDialog({ roster, actions, leaving = false }) {
   const [dragging, setDragging] = useState(null)
   const [error, setError] = useState('')
   const [draft, setDraft] = useState('')
-  const { own, tasks, replace } = useBoardTasks(actions, scope)
+  const { own, tasks, archive, replace } = useBoardTasks(actions, scope)
+  const boardTasks = boardTasksFor(tasks, archive)
   const close = useCallback(() => actions.closeBoard(), [])
   useEscape(close)
   const counts = {}
-  for (const task of own) {
+  for (const task of [...own, ...archive]) {
     const id = task.ownerBotId
     const bucket = counts[id] ?? (counts[id] = { done: 0, total: 0 })
     if (task.status === 'cancelled' || task.status === 'failed') continue
@@ -385,7 +407,7 @@ export function KanbanDialog({ roster, actions, leaving = false }) {
       view === 'delivery'
         ? h(DeliveryView, { actions })
         : h(BoardView, {
-            roster, tasks, rail, scope, counts, dragging, error, draft,
+            roster, tasks: boardTasks, rail, scope, counts, dragging, error, draft,
             onDraft: setDraft, onSelect: setScope, onMove: move, onDrag: setDragging, onCreate: create,
           })))
 }

core/src/host/tasks.js

@@ -292,9 +292,23 @@ export function install(rt) {
       transition(task, next, actor, extra)
       if (next === 'result-ready') task.result = { kind: 'summary', summary: (task.note || 'Completed').slice(0, 2000) }
     }
+    if (target === 'accepted') settleOverall(task)
     return true
   }
 
+  // #1252: a group whose last child finishes otherwise leaves its overall card working forever,
+  // so the room board keeps a card nobody can close. Finishing or cancelling the last open child
+  // completes the overall card, with the same write a person's own move makes.
+  function settleOverall(child) {
+    const parent = child?.parentId ? store()[child.parentId] : undefined
+    if (parent === undefined || parent.kind !== 'group' || !openTask(parent)) return false
+    if (!['open', 'claimed', 'working'].includes(parent.status)) return false
+    if (Object.values(store()).some(task => task.parentId === parent.id && openTask(task))) return false
+    const moved = applyColumn(parent, 'done', null, 'last child completed')
+    if (moved) parent.progress = 100
+    return moved
+  }
+
   function applyFields(task, body) {
     const title = body.title !== undefined ? readTitle(body.title) : undefined
     if (title !== undefined) {
@@ -764,7 +778,10 @@ export function install(rt) {
           // the room query, so a plain list never becomes a group-admin view.
           rows = all.filter(task => mayAct(task, actor) || ancestorOwned(actor, task.ownerBotId))
         }
-        return rows.sort((a, b) => a.createdAt - b.createdAt).map(view)
+        // #1252: the board lists active work; the archive is the same read with a flag, so a
+        // group that has finished hundreds of cards does not ship them on every poll.
+        const shown = body.archive === true ? rows : rows.filter(openTask)
+        return shown.sort((a, b) => a.createdAt - b.createdAt).map(view)
       }
       case 'task-create': {
         const botId = String(body.botId ?? '')
@@ -866,6 +883,7 @@ export function install(rt) {
         if (task === undefined) throw stale(`no task ${String(body.id ?? '')}`)
         requireRequester(task, actor)
         transition(task, 'accepted', actor)
+        settleOverall(task)
         requestWriteBack(task, 'accepted', undefined, actor)
         await save()
         return view(task)
@@ -888,6 +906,7 @@ export function install(rt) {
         if (task === undefined) throw stale(`no task ${String(body.id ?? '')}`)
         requireRequester(task, actor)
         transition(task, 'cancelled', actor)
+        settleOverall(task)
         await save()
         return view(task)
       }

core/test/bot-tasks.test.js

@@ -138,7 +138,7 @@ test('a Bot records conversation tasks and the owner moves them across the board
   await first.stop({ keepHome: true })
   const restored = await start(t, { home: first.home })
   app = restored
-  const saved = (await list(restored.call, alice.sessionToken, { botId: 's' })).find(task => task.id === open.id)
+  const saved = (await list(restored.call, alice.sessionToken, { botId: 's', archive: true })).find(task => task.id === open.id)
   assert.equal(saved.status, 'accepted')
   assert.equal(saved.progress, 100)
   assert.equal(saved.priority, 'high')
@@ -434,3 +434,56 @@ test('the board asks the owning Bot for the comment a decision needs, and takes
   assert.equal(late.writeBack.wakes, 2, "the count stays with the record")
   assert.equal(late.status, "accepted")
 })
+
+// #1252: a finished card leaves the active list, or a long-lived group's board grows without
+// bound; the archive is the same read with a flag, not a second endpoint.
+test('#1252: a room board lists active work only, and the archive is explicit', async (t) => {
+  const app = await start(t)
+  t.after(() => app.stop())
+  const alice = await app.signIn('Alice')
+  await app.track('a', { tasks: [
+    { title: 'Keep this moving', group: 'War', column: 'in-progress', progress: 30 },
+    { title: 'This one is done', group: 'War', column: 'in-progress', progress: 10 },
+  ] })
+  const before = await list(app.call, alice.sessionToken, { roomId: 'war' })
+  const finished = before.find(task => task.title === 'This one is done')
+  const done = await app.call('task-update', { id: finished.id, column: 'done' }, alice.sessionToken)
+  assert.equal(done.ok, true, JSON.stringify(done))
+
+  const active = await list(app.call, alice.sessionToken, { roomId: 'war' })
+  assert.equal(active.some(task => task.id === finished.id), false, 'a done card leaves the room board by default')
+  assert.equal(active.some(task => task.title === 'Keep this moving'), true, 'unfinished work stays')
+
+  const all = await list(app.call, alice.sessionToken, { roomId: 'war', archive: true })
+  assert.equal(all.some(task => task.id === finished.id), true, 'the archive still carries the finished card')
+  assert.equal(all.length, active.length + 1)
+})
+
+// #1252: an overall card with no open child left has to be able to complete, or a group keeps a
+// card working that nobody can close.
+test('#1252: the last child completing completes the overall card instead of leaving it working', async (t) => {
+  const app = await start(t)
+  t.after(() => app.stop())
+  const alice = await app.signIn('Alice')
+  await app.track('a', { tasks: [
+    { title: 'Ship the note', overall: true, group: 'War' },
+    { title: 'Write it', parent: 'Ship the note', assignee: 'Writer', group: 'War' },
+    { title: 'Review it', parent: 'Ship the note', assignee: 'ChiefA', group: 'War' },
+  ] })
+  const room = await list(app.call, alice.sessionToken, { roomId: 'war' })
+  const overall = room.find(task => task.kind === 'group')
+  const write = room.find(task => task.title === 'Write it')
+  const review = room.find(task => task.title === 'Review it')
+
+  const firstMove = await app.call('task-update', { id: write.id, column: 'done' }, alice.sessionToken)
+  assert.equal(firstMove.ok, true, JSON.stringify(firstMove))
+  const afterOne = (await list(app.call, alice.sessionToken, { roomId: 'war' })).find(task => task.id === overall.id)
+  assert.equal(afterOne.status, 'open', 'one child still open keeps the overall card where it was')
+
+  const lastMove = await app.call('task-update', { id: review.id, column: 'done' }, alice.sessionToken)
+  assert.equal(lastMove.ok, true, JSON.stringify(lastMove))
+  const parent = (await list(app.call, alice.sessionToken, { roomId: 'war', archive: true })).find(task => task.id === overall.id)
+  assert.equal(parent.status, 'accepted', 'the overall card completes with its last child')
+  assert.equal(columnOf(parent), 'done')
+  assert.equal(parent.progress, 100)
+})

core/test/kanban.test.js

@@ -29,7 +29,7 @@ runInNewContext(bundle.outputFiles[0].text, {
     return platform[name]
   },
 })
-const { BoardView, KanbanDialog, boardColumns, boardRail, canMoveTask, columnTree, shortId } = module.exports
+const { ARCHIVE_SHOWN, BoardView, KanbanDialog, boardColumns, boardTasksFor, boardRail, canMoveTask, columnTree, shortId } = module.exports
 
 const expand = (node) => {
   if (Array.isArray(node)) return node.flatMap(expand)
@@ -193,3 +193,18 @@ test('the Delivery view drops the Bot rail, while Tasks keeps it (#1173)', () =>
   // No snapshot yet is the honest one-line empty state until the first read lands.
   assert.match(textOf(deliveryView), /No snapshot yet/)
 })
+
+// #1252: the Done column is archive, not the board. A room with hundreds of finished cards
+// still renders one bounded slice of it.
+test('#1252: a group board renders a bounded archive instead of every finished card', () => {
+  const active = [{ id: 'task-live', ownerBotId: 'a', title: 'Live', status: 'working', updatedAt: 100 }]
+  const archive = Array.from({ length: 37 }, (_, i) => ({
+    id: `task-done-${i}`, ownerBotId: 'a', title: `Done ${i}`, status: 'accepted', progress: 100, updatedAt: i,
+  }))
+  const merged = boardTasksFor(active, archive)
+  assert.equal(merged.length, 1 + ARCHIVE_SHOWN)
+  const columns = boardColumns(merged)
+  assert.equal(columns['in-progress'].length, 1)
+  assert.equal(columns.done.length, ARCHIVE_SHOWN)
+  assert.equal(columns.done[0].id, 'task-done-19', 'the column reads newest first within the slice')
+})

core/test/tasks.test.js

@@ -91,7 +91,7 @@ async function start(t, config = {}) {
 }
 
 const statusOf = async (call, token, id) => {
-  const list = await call('tasks', {}, token)
+  const list = await call('tasks', { archive: true }, token)
   assert.equal(list.ok, true, JSON.stringify(list))
   return list.value.find(task => task.id === id)
 }