@arjunkhera/atlas 0.3.24 → 0.3.26

package/work/lib/questions.mjs

@@ -5,16 +5,13 @@
 // The verbs run behind the same door, the same journal and the same registry
 // checks as slice L1. Every record carries request_id and writer.
 import protectedPaths from '../protected-paths.json' with { type: 'json' };
-import { refuse, text, oneOf, isoDate, url, stringList, LIVE_LIFECYCLES } from './verb-fields.mjs';
+import { refuse, text, oneOf, isoDate, url, stringList } from './verb-fields.mjs';
+import { COSTS, COST_MEANING, ROW_LINE_MAX, oneLine, needsYou } from './view-rules.mjs';
+
+// R5 (the costs), R8 (the row width), the blocker rules and the needs-you
+// order live in view-rules.mjs, which the project view page also runs.
+export { COSTS, COST_MEANING, ROW_LINE_MAX, oneLine, CLEARED_LIFECYCLES, blockersOf, blocksOf } from './view-rules.mjs';
 
-// R5: the cost of waiting is a closed vocabulary, ranked. Index 0 costs most.
-export const COSTS = Object.freeze(['blocked-merge', 'paused-item', 'spend', 'date']);
-export const COST_MEANING = Object.freeze({
-  'blocked-merge': 'a merge waits on the answer',
-  'paused-item': 'the item is stopped until the answer comes',
-  spend: 'money runs while the answer waits',
-  date: 'a date is at risk',
-});
 // 'sweep' is the kind the slice L5 sweep record carries. It is a decision like
 // any other: the owner's words, dated, listing the items (design finding R7).
 export const DECISION_KINDS = Object.freeze(['decision', 'priority', 'answer', 'sweep']);
@@ -24,18 +21,9 @@ export const QUESTION_READ_VERBS = Object.freeze(['needs_me']);
 
 // R8: the row budget. Three visible lines; everything else folds under it.
 export const ROW_LINES = 3;
-export const ROW_LINE_MAX = 160;
 const MAX_OPEN_QUESTIONS = 500;
 const MAX_RENDERED = 20_000;
 
-export const oneLine = (value, max = ROW_LINE_MAX) => {
-  const flat = String(value ?? '').replace(/\s+/g, ' ').trim();
-  // Cut by code point, so a cut never leaves half an emoji: Postgres refuses
-  // a lone surrogate, and the whole write with it.
-  const chars = Array.from(flat);
-  return chars.length > max ? `${chars.slice(0, max - 1).join('')}…` : flat;
-};
-
 // R12: a scrub by pattern in receipt keep. The patterns are the ones the
 // sub-agents deny, in work/protected-paths.json. A (?i) prefix is Python and
 // Go spelling; JavaScript takes it as a flag.
@@ -101,28 +89,8 @@ export function waitsOnLine(waits) {
   return `waits on ${what}${waits.item ? ` ${waits.item}` : ''}${waits.note ? `: ${waits.note}` : ''}`;
 }
 
-// Work item additions, slice 2: the items that block an item, the items it
-// blocks, and one phrase for a row. lookup gives an item record by id, or
-// undefined when the view did not load it. A blocker that is delivered or
-// dropped no longer blocks; the row shows it as cleared.
-export const CLEARED_LIFECYCLES = Object.freeze(['done', 'dropped']);
-export function blockersOf(item, lookup) {
-  const list = Array.isArray(item?.fields?.blocked_by) ? item.fields.blocked_by : [];
-  return list.filter((entry) => entry && typeof entry.item === 'string').map((entry) => {
-    const other = lookup(entry.item);
-    // A blocker the view cannot find is archived or gone, so it blocks no more.
-    if (!other) return { item: entry.item, title: null, state: 'gone', cleared: true, ...(entry.note ? { note: entry.note } : {}) };
-    const lifecycle = other.fields?.lifecycle ?? 'unknown';
-    const cleared = CLEARED_LIFECYCLES.includes(lifecycle);
-    return { item: entry.item, title: oneLine(other.title, 60), state: cleared ? 'cleared' : (lifecycle === 'active' ? (other.fields?.stage ?? 'active') : lifecycle), cleared, ...(entry.note ? { note: entry.note } : {}) };
-  });
-}
-// Only a live item is still held up, so a delivered or dropped one leaves the
-// "blocks" list.
-export function blocksOf(item, all) {
-  return all.filter((other) => other.id !== item.id && LIVE_LIFECYCLES.includes(other.fields?.lifecycle) && Array.isArray(other.fields?.blocked_by) && other.fields.blocked_by.some((entry) => entry?.item === item.id))
-    .map((other) => ({ item: other.id, title: oneLine(other.title, 60) }));
-}
+// Work item additions, slice 2: one phrase for a row, from blockersOf and
+// blocksOf in view-rules.mjs.
 export function blockedPhrase(blockers, blocks) {
   const parts = [];
   if (blockers.length) parts.push(`blocked by: ${blockers.map((row) => `${row.title ?? row.item} (${row.state})`).join(', ')}`);
@@ -323,20 +291,14 @@ export function createQuestionVerbs(core) {
         catch (error) { items.set(id, null); unreadable.set(id, error?.status === 404 ? 'the item is not in the graph' : `the graph did not answer: ${error?.message ?? String(error)}`); }
       }
       const readAt = now();
-      const kept = [], omitted = [];
-      for (const row of open) {
-        const item = items.get(row.fields.item) ?? null;
-        const lifecycle = item?.fields?.lifecycle ?? 'unknown';
-        // Release 0.2.3: a question on a
-        // proposed or paused item still needs him, so it is a row. D3 rule 1
-        // kept active items only, and it hid real questions. A question on a
-        // done or dropped item is named, not dropped in silence.
-        if (!LIVE_LIFECYCLES.includes(lifecycle)) { omitted.push({ question_id: row.id, item: row.fields.item, item_lifecycle: lifecycle, reason: item ? `the item is ${lifecycle}; only a proposed, active or paused item can still need you` : (unreadable.get(row.fields.item) ?? 'the item cannot be read') }); continue; }
-        const cost = row.fields.cost;
-        const rank = COSTS.indexOf(cost);
+      // The order and the filter are the view rules, so the project view page
+      // gives the same rows from the same records.
+      const ordered = needsYou(open, (id) => items.get(id));
+      const omitted = ordered.omitted.map(({ question, item, lifecycle }) => ({ question_id: question.id, item: question.fields.item, item_lifecycle: lifecycle, reason: item ? `the item is ${lifecycle}; only a proposed, active or paused item can still need you` : (unreadable.get(question.fields.item) ?? 'the item cannot be read') }));
+      const kept = ordered.kept.map(({ question: row, item, lifecycle, cost, cost_rank: costRank }) => {
         const asked = row.fields.asked_by ?? {};
-        kept.push({
-          question_id: row.id, product: row.fields.product, item: item.id, item_lifecycle: lifecycle, cost, cost_rank: rank === -1 ? COSTS.length : rank,
+        return {
+          question_id: row.id, product: row.fields.product, item: item.id, item_lifecycle: lifecycle, cost, cost_rank: costRank,
           asked_at: row.fields.asked_at ?? row.created_at ?? '', asked_by: asked.agent ?? 'unknown',
           lines: [
             oneLine(row.fields.text),
@@ -345,9 +307,8 @@ export function createQuestionVerbs(core) {
           ],
           folded: { question: row.fields.text, context: row.fields.context ?? {}, asked_by: asked, item_title: item.title, item_stage: item.fields.stage ?? '', item_next_step: item.fields.next_step ?? '', item_waits_on: item.fields.waits_on ?? null },
           citation: { question: row.id, item: item.id, read_at: readAt },
-        });
-      }
-      kept.sort((a, b) => a.cost_rank - b.cost_rank || String(a.asked_at).localeCompare(String(b.asked_at)) || a.question_id.localeCompare(b.question_id));
+        };
+      });
       const products = [...new Set(kept.map((row) => row.product))].sort();
       const byProduct = products.map((product) => ({ product, rows: kept.filter((row) => row.product === product) }));
       const render = byProduct.map((group) => [`${group.product} — needs you (${group.rows.length})`, ...group.rows.flatMap((row, index) => row.lines.map((line, position) => `${position === 0 ? `${index + 1}. ` : '   '}${line}`))].join('\n')).join('\n\n');

package/work/lib/verb-fields.mjs

@@ -5,9 +5,9 @@
 import { createHash } from 'node:crypto';
 
 export const MAX_TEXT = 20_000;
-// The lifecycles a view counts as live work (release 0.2.3). A dropped item is
-// closed by the owner's word, and no live list names it.
-export const LIVE_LIFECYCLES = Object.freeze(['proposed', 'active', 'paused']);
+// The lifecycles a view counts as live work live in view-rules.mjs, which the
+// project view page also runs.
+export { LIVE_LIFECYCLES } from './view-rules.mjs';
 
 export class VerbError extends Error {
   constructor(message, code = 'refused') { super(message); this.name = 'VerbError'; this.code = code; }

package/work/lib/view-rules.mjs

@@ -0,0 +1,279 @@
+// The view rules: how tracker records become rows. One module, read by two
+// readers. The Atlas tools import it in a session (needs_me, in_flight, the
+// roundup). The project view page holds a copy of this file, put in by
+// `atlas view build`, and runs it in the viewer's browser. Design:
+// docs/design-docs/project-view (tracker item 6dd1761a).
+//
+// So this file imports nothing and touches no Node API, no DOM and no
+// network. Every function takes plain records, as Engram returns them, and
+// returns plain data.
+
+// The lifecycles a view counts as live work (release 0.2.3). A dropped item
+// is closed by the owner's word, and no live list names it.
+export const LIVE_LIFECYCLES = Object.freeze(['proposed', 'active', 'paused']);
+// A blocker that is delivered or dropped no longer blocks.
+export const CLEARED_LIFECYCLES = Object.freeze(['done', 'dropped']);
+// R5: the cost of waiting is a closed vocabulary, ranked. Index 0 costs most.
+export const COSTS = Object.freeze(['blocked-merge', 'paused-item', 'spend', 'date']);
+export const COST_MEANING = Object.freeze({
+  'blocked-merge': 'a merge waits on the answer',
+  'paused-item': 'the item is stopped until the answer comes',
+  spend: 'money runs while the answer waits',
+  date: 'a date is at risk',
+});
+// R8: one row line holds at most this many characters.
+export const ROW_LINE_MAX = 160;
+// The striped estimate of the Timeline, in days, from the size of an item.
+// The canvas board set hotfix 1 and standard 2; initiative is the design's.
+export const ESTIMATE_DAYS = Object.freeze({ hotfix: 1, standard: 2, initiative: 5 });
+// The order of the top level: live work first, closed work folded at the end.
+export const GROUPS = Object.freeze([
+  { key: 'active', name: 'In flight', lifecycles: ['active'] },
+  { key: 'proposed', name: 'Proposed', lifecycles: ['proposed'] },
+  { key: 'paused', name: 'Paused', lifecycles: ['paused'] },
+  { key: 'closed', name: 'Done and dropped', lifecycles: ['done', 'dropped'], folded: true },
+]);
+
+const DAY = 86_400_000;
+
+export const oneLine = (value, max = ROW_LINE_MAX) => {
+  const flat = String(value ?? '').replace(/\s+/g, ' ').trim();
+  // Cut by code point, so a cut never leaves half an emoji: Postgres refuses
+  // a lone surrogate, and the whole write with it.
+  const chars = Array.from(flat);
+  return chars.length > max ? `${chars.slice(0, max - 1).join('')}…` : flat;
+};
+
+// Work item additions, slice 2: the items that block an item, the items it
+// blocks. lookup gives an item record by id, or undefined when the view did
+// not load it.
+export function blockersOf(item, lookup) {
+  const list = Array.isArray(item?.fields?.blocked_by) ? item.fields.blocked_by : [];
+  return list.filter((entry) => entry && typeof entry.item === 'string').map((entry) => {
+    const other = lookup(entry.item);
+    // A blocker the view cannot find is archived or gone, so it blocks no more.
+    if (!other) return { item: entry.item, title: null, state: 'gone', cleared: true, ...(entry.note ? { note: entry.note } : {}) };
+    const lifecycle = other.fields?.lifecycle ?? 'unknown';
+    const cleared = CLEARED_LIFECYCLES.includes(lifecycle);
+    return { item: entry.item, title: oneLine(other.title, 60), state: cleared ? 'cleared' : (lifecycle === 'active' ? (other.fields?.stage ?? 'active') : lifecycle), cleared, ...(entry.note ? { note: entry.note } : {}) };
+  });
+}
+// Only a live item is still held up, so a delivered or dropped one leaves the
+// "blocks" list.
+export function blocksOf(item, all) {
+  return all.filter((other) => other.id !== item.id && LIVE_LIFECYCLES.includes(other.fields?.lifecycle) && Array.isArray(other.fields?.blocked_by) && other.fields.blocked_by.some((entry) => entry?.item === item.id))
+    .map((other) => ({ item: other.id, title: oneLine(other.title, 60) }));
+}
+
+// "Needs you": every open question on a live item, ordered by what waiting
+// costs, then by age, then by id. needs_me and the page both call this, so
+// the two lists are the same list. itemOf gives the item record, null when it
+// cannot be read, or undefined when the reader did not load it.
+export function needsYou(questions, itemOf) {
+  const kept = [], omitted = [];
+  for (const question of questions) {
+    if (question?.fields?.status !== 'open') continue;
+    const item = itemOf(question.fields.item) ?? null;
+    const lifecycle = item?.fields?.lifecycle ?? 'unknown';
+    // Release 0.2.3: a question on a proposed or paused item still needs the
+    // owner. A question on a done or dropped item is named, not dropped in
+    // silence.
+    if (!LIVE_LIFECYCLES.includes(lifecycle)) { omitted.push({ question, item, lifecycle }); continue; }
+    const rank = COSTS.indexOf(question.fields.cost);
+    kept.push({ question, item, lifecycle, cost: question.fields.cost, cost_rank: rank === -1 ? COSTS.length : rank, asked_at: question.fields.asked_at ?? question.created_at ?? '' });
+  }
+  kept.sort((a, b) => a.cost_rank - b.cost_rank || String(a.asked_at).localeCompare(String(b.asked_at)) || a.question.id.localeCompare(b.question.id));
+  return { kept, omitted };
+}
+
+// Sort one product's records by kind. The tags say the kind; an item is a
+// record with a lifecycle and none of the other tags.
+const KIND_TAGS = Object.freeze({ 'atlas-question': 'questions', 'atlas-decision': 'decisions', 'atlas-mark': 'marks', 'atlas-receipt': 'receipts', 'atlas-registry': 'registry' });
+export function classify(records) {
+  const out = { items: [], questions: [], decisions: [], marks: [], receipts: [], registry: [], other: [] };
+  for (const record of records) {
+    if (!record || typeof record.id !== 'string') continue;
+    if (record.state && record.state !== 'active') continue;
+    const tags = Array.isArray(record.tags) ? record.tags : [];
+    const kind = tags.map((tag) => KIND_TAGS[tag]).find(Boolean);
+    if (kind) out[kind].push(record);
+    else if (typeof record.fields?.lifecycle === 'string') out.items.push(record);
+    else out.other.push(record);
+  }
+  return out;
+}
+
+const time = (value) => { const at = Date.parse(value ?? ''); return Number.isNaN(at) ? null : at; };
+const day = (value) => (/^\d{4}-\d{2}-\d{2}$/.test(String(value ?? '')) ? time(`${value}T00:00:00Z`) : null);
+
+// The whole model of one product: the tree, the state of each row, the
+// chain, needs you, the detail of an item, and the Timeline bars.
+export function buildModel(records, { product = null, now = new Date().toISOString() } = {}) {
+  const sorted = classify(records);
+  const items = new Map(sorted.items.filter((item) => !product || !item.fields?.product || item.fields.product === product).map((item) => [item.id, item]));
+  const all = [...items.values()];
+  const lookup = (id) => items.get(id);
+  const lifecycleOf = (id) => items.get(id)?.fields?.lifecycle ?? 'unknown';
+
+  // Parts: split_from names the parent. A parent the view did not load makes
+  // the part a top-level row, so nothing hides.
+  const parentOf = (id) => { const parent = items.get(id)?.fields?.split_from; return typeof parent === 'string' && items.has(parent) && parent !== id ? parent : null; };
+  const kids = new Map();
+  for (const item of all) {
+    const parent = parentOf(item.id);
+    if (!parent) continue;
+    if (!kids.has(parent)) kids.set(parent, []);
+    kids.get(parent).push(item);
+  }
+  for (const list of kids.values()) list.sort((a, b) => (a.fields?.split_index ?? 0) - (b.fields?.split_index ?? 0) || a.title.localeCompare(b.title));
+  const childrenOf = (id) => (kids.get(id) ?? []).map((item) => item.id);
+  const ancestorsOf = (id) => { const out = []; const seen = new Set([id]); let at = parentOf(id); while (at && !seen.has(at)) { out.push(at); seen.add(at); at = parentOf(at); } return out; };
+  const depthOf = (id) => ancestorsOf(id).length;
+
+  const modified = (item) => String(item.updated_at ?? item.modified_at ?? item.created_at ?? '');
+  const roots = all.filter((item) => !parentOf(item.id)).sort((a, b) => modified(b).localeCompare(modified(a)) || a.title.localeCompare(b.title));
+  const groups = GROUPS.map((group) => ({ key: group.key, name: group.name, folded: !!group.folded, ids: roots.filter((item) => group.lifecycles.includes(item.fields?.lifecycle)).map((item) => item.id) }));
+  const known = new Set(GROUPS.flatMap((group) => group.lifecycles));
+  const strays = roots.filter((item) => !known.has(item.fields?.lifecycle)).map((item) => item.id);
+  if (strays.length) groups[groups.length - 1].ids.push(...strays);
+
+  const need = needsYou(sorted.questions, (id) => (items.has(id) ? items.get(id) : null));
+  const openQuestionsOf = (id) => need.kept.filter((row) => row.item?.id === id).map((row) => row.question);
+
+  const openBlockers = (id) => blockersOf(items.get(id), lookup).filter((row) => !row.cleared);
+  const blockedAncestor = (id) => ancestorsOf(id).find((parent) => openBlockers(parent).length > 0) ?? null;
+
+  // One state per row, the words of the locked "A with D" board.
+  function stateOf(id) {
+    const item = items.get(id);
+    const lifecycle = lifecycleOf(id);
+    const blockers = openBlockers(id);
+    const waitsWith = blockers.length ? null : blockedAncestor(id);
+    const questions = openQuestionsOf(id);
+    const blocks = blocksOf(item, all);
+    let kind;
+    if (lifecycle === 'done' || lifecycle === 'dropped') kind = lifecycle;
+    else if (blockers.length) kind = 'blocked';
+    else if (waitsWith) kind = 'waits-with';
+    else if (questions.length) kind = 'you';
+    else if (lifecycle === 'paused') kind = 'paused';
+    else if (lifecycle === 'active') kind = 'doing';
+    else kind = 'ready';
+    return { id, kind, lifecycle, stage: item.fields?.stage ?? '', tier: item.fields?.tier ?? 'standard', blockers, waitsWith, questions, blocks, ready: kind === 'ready' };
+  }
+
+  // The chain of D: what must finish before an item (its blockers and its
+  // parents' blockers, all the way back), and what waits on it (the items
+  // it blocks, all the way on, with their parts).
+  const dependentsOf = (id) => all.filter((other) => Array.isArray(other.fields?.blocked_by) && other.fields.blocked_by.some((entry) => entry?.item === id)).map((other) => other.id);
+  function chainOf(id) {
+    const before = [], after = [];
+    const up = (at) => {
+      for (const holder of [at, ...ancestorsOf(at)]) {
+        for (const row of blockersOf(items.get(holder), lookup)) {
+          if (!items.has(row.item) || before.includes(row.item) || row.item === id) continue;
+          before.push(row.item); up(row.item);
+        }
+      }
+    };
+    const down = (at) => {
+      for (const next of dependentsOf(at)) {
+        if (after.includes(next) || next === id) continue;
+        after.push(next);
+        const parts = (from) => { for (const kid of childrenOf(from)) { if (!after.includes(kid)) { after.push(kid); parts(kid); } } };
+        parts(next);
+        down(next);
+      }
+    };
+    up(id); down(id);
+    return { before, after };
+  }
+
+  const decisionsOf = (id) => sorted.decisions.filter((row) => (Array.isArray(row.fields?.items) && row.fields.items.includes(id))).sort((a, b) => String(b.fields?.date ?? '').localeCompare(String(a.fields?.date ?? '')));
+  const marksOf = (id) => sorted.marks.filter((row) => row.fields?.item === id).sort((a, b) => String(a.fields?.marked_at ?? '').localeCompare(String(b.fields?.marked_at ?? '')));
+  const questionsOf = (id) => sorted.questions.filter((row) => row.fields?.item === id).sort((a, b) => String(b.fields?.asked_at ?? '').localeCompare(String(a.fields?.asked_at ?? '')));
+
+  function detailOf(id) {
+    const item = items.get(id);
+    if (!item) return null;
+    const fields = item.fields ?? {};
+    return {
+      id, title: item.title, path: ancestorsOf(id).reverse().map((parent) => items.get(parent).title),
+      lifecycle: fields.lifecycle ?? 'unknown', stage: fields.stage ?? '', tier: fields.tier ?? '', driver: fields.driver ?? '',
+      next_step: fields.next_step ?? '', summary: fields.summary ?? '', scope: fields.scope?.text ?? '',
+      origin: fields.origin ?? null, waits_on: fields.waits_on ?? null, plan: fields.plan ?? null,
+      links: Array.isArray(fields.links) ? fields.links : [], tags: Array.isArray(item.tags) ? item.tags : [],
+      edits: Array.isArray(fields.edits) ? [...fields.edits].reverse() : [],
+      parts: childrenOf(id), questions: questionsOf(id), decisions: decisionsOf(id), marks: marksOf(id),
+      created_at: item.created_at ?? '', locked_at: fields.locked_at ?? '', delivered_at: fields.delivered_at ?? '',
+    };
+  }
+
+  // The Timeline of the locked board: real bars for work that happened, a
+  // striped estimate for the rest, from the size field. A planned date the
+  // owner set replaces the estimate. All times are epoch milliseconds.
+  const nowAt = time(now) ?? 0;
+  const startOf = (item) => day(item.fields?.plan?.start) ?? time(item.fields?.locked_at) ?? time(item.created_at) ?? nowAt;
+  const memo = new Map();
+  function spanOf(id, guard = new Set()) {
+    if (memo.has(id)) return memo.get(id);
+    if (guard.has(id)) return { from: nowAt, to: nowAt, kind: 'none', bars: [] };
+    guard.add(id);
+    const item = items.get(id);
+    const fields = item.fields ?? {};
+    const lifecycle = fields.lifecycle;
+    const plan = fields.plan ?? {};
+    const planStart = day(plan.start), planEnd = day(plan.end);
+    const estimate = (ESTIMATE_DAYS[fields.tier] ?? ESTIMATE_DAYS.standard) * DAY;
+    const bars = [];
+    if (lifecycle === 'done') {
+      const to = time(fields.delivered_at) ?? time(item.updated_at ?? item.modified_at) ?? nowAt;
+      bars.push({ kind: 'done', from: Math.min(startOf(item), to), to });
+    } else if (lifecycle === 'dropped') {
+      // A dropped item draws no bar.
+    } else if (lifecycle === 'active') {
+      const from = Math.min(startOf(item), nowAt);
+      bars.push({ kind: 'going', from, to: nowAt });
+      if (planEnd !== null && planEnd > nowAt) bars.push({ kind: 'planned', from: nowAt, to: planEnd + DAY });
+      else if (planEnd === null) bars.push({ kind: 'estimate', from: nowAt, to: nowAt + estimate });
+    } else if (lifecycle === 'proposed' || (lifecycle === 'paused' && planStart !== null)) {
+      if (planStart !== null || planEnd !== null) {
+        const from = planStart ?? Math.max(nowAt, (planEnd ?? nowAt) - estimate + DAY);
+        bars.push({ kind: 'planned', from, to: planEnd !== null ? planEnd + DAY : from + estimate });
+      } else {
+        // The estimate starts after every open blocker ends, and not before
+        // its parent can start.
+        let from = nowAt;
+        for (const holder of [id, ...ancestorsOf(id)]) {
+          for (const row of blockersOf(items.get(holder), lookup)) {
+            if (row.cleared || !items.has(row.item)) continue;
+            from = Math.max(from, spanOf(row.item, guard).to);
+          }
+        }
+        bars.push({ kind: 'estimate', from, to: from + estimate });
+      }
+    }
+    // A parent with parts spans its parts.
+    const parts = childrenOf(id).map((kid) => spanOf(kid, guard)).filter((span) => span.bars.length);
+    let from = bars.length ? Math.min(...bars.map((bar) => bar.from)) : null;
+    let to = bars.length ? Math.max(...bars.map((bar) => bar.to)) : null;
+    if (parts.length) {
+      from = Math.min(from ?? Infinity, ...parts.map((span) => span.from));
+      to = Math.max(to ?? -Infinity, ...parts.map((span) => span.to));
+    }
+    const marks = [];
+    for (const question of openQuestionsOf(id)) { const at = time(question.fields?.asked_at ?? question.created_at); if (at !== null) marks.push({ kind: 'asked', at, until: nowAt, question: question.id }); }
+    const deadline = day(plan.deadline);
+    if (deadline !== null) marks.push({ kind: 'deadline', at: deadline });
+    const span = { from: from ?? nowAt, to: to ?? nowAt, bars, marks, kind: lifecycle, hasParts: parts.length > 0 };
+    memo.set(id, span);
+    return span;
+  }
+
+  return {
+    product, now, items, all, groups, roots: roots.map((item) => item.id),
+    lookup, parentOf, childrenOf, ancestorsOf, depthOf, stateOf, chainOf, detailOf, spanOf,
+    needsYou: need.kept, needsYouOmitted: need.omitted,
+    questions: sorted.questions, decisions: sorted.decisions, marks: sorted.marks,
+  };
+}