@refrakt-md/plan 0.9.5 → 0.9.7

package/dist/pipeline.js

@@ -3,15 +3,20 @@ import { BACKLOG_SENTINEL } from './tags/backlog.js';
 import { DECISION_LOG_SENTINEL } from './tags/decision-log.js';
 import { PLAN_PROGRESS_SENTINEL } from './tags/plan-progress.js';
 import { PLAN_ACTIVITY_SENTINEL } from './tags/plan-activity.js';
+import { PLAN_HISTORY_SENTINEL } from './tags/plan-history.js';
 import { parseFilter, matchesFilter, sortEntities, groupEntities } from './filter.js';
+import { execSync } from 'node:child_process';
+import { extractBatchHistory, readHistoryCache, writeHistoryCache, } from './history.js';
+import { buildRelationships } from './relationships.js';
+import { buildEntityCard, buildDecisionEntry } from './cards.js';
 const { Tag } = Markdoc;
 const PLAN_RUNE_TYPES = new Set(['spec', 'work', 'bug', 'decision', 'milestone']);
 /** Fields to extract from each rune type's property meta tags */
 const RUNE_FIELDS = {
     spec: ['id', 'status', 'version', 'supersedes', 'tags', 'modified'],
-    work: ['id', 'status', 'priority', 'complexity', 'assignee', 'milestone', 'tags', 'modified'],
-    bug: ['id', 'status', 'severity', 'assignee', 'milestone', 'tags', 'modified'],
-    decision: ['id', 'status', 'date', 'supersedes', 'tags', 'modified'],
+    work: ['id', 'status', 'priority', 'complexity', 'assignee', 'milestone', 'source', 'tags', 'modified'],
+    bug: ['id', 'status', 'severity', 'assignee', 'milestone', 'source', 'tags', 'modified'],
+    decision: ['id', 'status', 'date', 'supersedes', 'source', 'tags', 'modified'],
     milestone: ['name', 'status', 'target', 'modified'],
 };
 function walkTags(node, fn) {
@@ -114,125 +119,44 @@ function formatModifiedDate(value) {
         return '';
     return new Date(ts).toISOString().slice(0, 10);
 }
-// ─── Sentiment maps (matching rune configs in config.ts) ───
-const WORK_STATUS_SENTIMENT = {
-    draft: 'neutral', ready: 'neutral', 'in-progress': 'neutral',
-    review: 'caution', done: 'positive', blocked: 'negative',
-};
-const BUG_STATUS_SENTIMENT = {
-    reported: 'neutral', confirmed: 'caution', 'in-progress': 'neutral',
-    fixed: 'positive', wontfix: 'neutral', duplicate: 'neutral',
-};
-const PRIORITY_SENTIMENT = {
-    critical: 'negative', high: 'caution', medium: 'neutral', low: 'neutral',
-};
-const SEVERITY_SENTIMENT = {
-    critical: 'negative', major: 'caution', minor: 'neutral', trivial: 'neutral',
-};
-/** Build a metadata badge matching the dimension system output */
-function buildMetaBadge(label, value, opts) {
-    const labelAttrs = { 'data-meta-label': '' };
-    if (opts.labelHidden)
-        labelAttrs['data-meta-label-hidden'] = '';
-    const labelEl = new Tag('span', labelAttrs, [label]);
-    const valueEl = new Tag('span', { 'data-meta-value': '' }, [value]);
-    const attrs = {
-        'data-meta-type': opts.metaType,
-        'data-meta-rank': opts.metaRank,
-    };
-    if (opts.sentiment)
-        attrs['data-meta-sentiment'] = opts.sentiment;
-    return new Tag('span', attrs, [labelEl, valueEl]);
+/**
+ * Module-level store for dependency refs extracted from ## Dependencies sections.
+ * Maps entityId → array of dependency entity IDs.
+ * Set by render-pipeline.ts from scanner data before register() runs.
+ */
+const _scannerDependencies = new Map();
+/** Set scanner dependency data for the pipeline's aggregate() hook to consume */
+export function setScannerDependencies(deps) {
+    _scannerDependencies.clear();
+    for (const [k, v] of deps)
+        _scannerDependencies.set(k, v);
 }
-/** Build a compact summary card Tag for a work/bug entity */
-function buildEntityCard(entity) {
-    const id = String(entity.data.id ?? entity.id);
-    const title = String(entity.data.title ?? '');
-    const status = String(entity.data.status ?? '');
-    const type = entity.type;
-    // Header: ID on the left, status + progress on the right
-    const headerLeft = [
-        buildMetaBadge('ID:', id, { metaType: 'id', metaRank: 'primary', labelHidden: true }),
-    ];
-    const headerRight = [];
-    const statusSentiment = type === 'work' ? WORK_STATUS_SENTIMENT[status]
-        : type === 'bug' ? BUG_STATUS_SENTIMENT[status]
-            : undefined;
-    headerRight.push(buildMetaBadge('Status:', status, { metaType: 'status', metaRank: 'primary', sentiment: statusSentiment, labelHidden: true }));
-    // Progress in header (no circle indicator)
-    const checkedCount = Number(entity.data.checkedCount ?? 0);
-    const totalCount = Number(entity.data.totalCount ?? 0);
-    if (totalCount > 0) {
-        headerRight.push(new Tag('span', {
-            class: 'rf-backlog__card-progress',
-            'data-checked': String(checkedCount),
-            'data-total': String(totalCount),
-        }, [`${checkedCount}/${totalCount}`]));
-    }
-    const header = new Tag('div', { 'data-section': 'header' }, [
-        new Tag('span', { class: 'rf-backlog__card-header-left' }, headerLeft),
-        new Tag('span', { class: 'rf-backlog__card-header-right' }, headerRight),
-    ]);
-    // Body: title
-    const titleEl = new Tag('div', { 'data-section': 'title' }, [title]);
-    // Footer: secondary metadata pills
-    const footerBadges = [];
-    if (type === 'work') {
-        const priority = String(entity.data.priority ?? '');
-        const complexity = String(entity.data.complexity ?? '');
-        if (priority)
-            footerBadges.push(buildMetaBadge('Priority:', priority, { metaType: 'category', metaRank: 'secondary', sentiment: PRIORITY_SENTIMENT[priority] }));
-        if (complexity && complexity !== 'unknown')
-            footerBadges.push(buildMetaBadge('Complexity:', complexity, { metaType: 'quantity', metaRank: 'secondary' }));
-    }
-    else if (type === 'bug') {
-        const severity = String(entity.data.severity ?? '');
-        if (severity)
-            footerBadges.push(buildMetaBadge('Severity:', severity, { metaType: 'category', metaRank: 'secondary', sentiment: SEVERITY_SENTIMENT[severity] }));
-    }
-    const milestone = String(entity.data.milestone ?? '');
-    if (milestone)
-        footerBadges.push(buildMetaBadge('Milestone:', milestone, { metaType: 'tag', metaRank: 'secondary', labelHidden: true }));
-    const sections = [header, titleEl];
-    if (footerBadges.length > 0) {
-        sections.push(new Tag('div', { 'data-section': 'footer' }, footerBadges));
-    }
-    const children = entity.sourceUrl
-        ? [new Tag('a', { class: 'rf-backlog__card-link', href: entity.sourceUrl }, sections)]
-        : sections;
-    return new Tag('article', {
-        class: 'rf-backlog__card',
-        'data-type': type,
-        'data-status': status,
-        'data-id': id,
-    }, children);
+/**
+ * Module-level store for the plan directory path.
+ * Set by render-pipeline.ts before aggregate() runs.
+ */
+let _planDir;
+/** Set the plan directory path for the pipeline's aggregate() hook to consume */
+export function setPlanDir(dir) {
+    _planDir = dir;
 }
-const DECISION_STATUS_SENTIMENT = {
-    proposed: 'neutral', accepted: 'positive', superseded: 'caution', deprecated: 'negative',
-};
-/** Build a decision log entry Tag */
-function buildDecisionEntry(entity) {
-    const id = String(entity.data.id ?? entity.id);
-    const title = String(entity.data.title ?? '');
-    const status = String(entity.data.status ?? '');
-    const date = String(entity.data.date ?? '');
-    const badges = [
-        buildMetaBadge('ID:', id, { metaType: 'id', metaRank: 'primary', labelHidden: true }),
-        buildMetaBadge('Status:', status, { metaType: 'status', metaRank: 'primary', sentiment: DECISION_STATUS_SENTIMENT[status], labelHidden: true }),
-    ];
-    if (date)
-        badges.push(buildMetaBadge('Date:', date, { metaType: 'temporal', metaRank: 'secondary' }));
-    const header = new Tag('div', { 'data-section': 'header' }, badges);
-    const titleEl = new Tag('div', { 'data-section': 'title' }, [title]);
-    const innerChildren = [header, titleEl];
-    const children = entity.sourceUrl
-        ? [new Tag('a', { class: 'rf-decision-log__link', href: entity.sourceUrl }, innerChildren)]
-        : innerChildren;
-    return new Tag('li', {
-        class: 'rf-decision-log__entry',
-        'data-status': status,
-        'data-id': id,
-    }, children);
+/** Parse a comma-separated `source` attribute into typed ID references */
+function parseSourceIds(source) {
+    if (!source)
+        return [];
+    const refs = [];
+    for (const raw of source.split(',')) {
+        const id = raw.trim();
+        if (!id)
+            continue;
+        const match = id.match(/^(WORK|SPEC|BUG|ADR)-\d+$/);
+        if (match) {
+            const type = ID_PREFIX_TO_TYPE[match[1]];
+            if (type)
+                refs.push({ id, type });
+        }
+    }
+    return refs;
 }
 /**
  * Module-level store for ID references found during registration.
@@ -240,9 +164,16 @@ function buildDecisionEntry(entity) {
  * Populated by register(), consumed by aggregate().
  */
 const _idReferences = new Map();
+/**
+ * Module-level store for structured source references (from source= attribute).
+ * Maps entityId → array of source entity IDs (with type).
+ * These produce 'implements' / 'implemented-by' relationships.
+ */
+const _sourceReferences = new Map();
 export const planPipelineHooks = {
     register(pages, registry, ctx) {
         _idReferences.clear();
+        _sourceReferences.clear();
         for (const page of pages) {
             walkTags(page.renderable, (tag) => {
                 const runeType = tag.attributes['data-rune'];
@@ -277,6 +208,12 @@ export const planPipelineHooks = {
                 if (refs.length > 0) {
                     _idReferences.set(entityId, refs);
                 }
+                // Extract structured source references from source= attribute
+                const sourceVal = String(data.source ?? '');
+                const sourceRefs = parseSourceIds(sourceVal).filter(r => r.id !== entityId);
+                if (sourceRefs.length > 0) {
+                    _sourceReferences.set(entityId, sourceRefs);
+                }
                 registry.register({
                     type: runeType,
                     id: entityId,
@@ -286,61 +223,46 @@ export const planPipelineHooks = {
             });
         }
     },
-    aggregate(registry) {
-        // Build bidirectional relationship index from ID references
-        const relationships = new Map();
-        function addRel(id, rel) {
-            if (!relationships.has(id))
-                relationships.set(id, []);
-            relationships.get(id).push(rel);
-        }
-        // Build a lookup of all registered entities for validation
+    aggregate(registry, ctx) {
+        // Build a lookup of all registered entities for relationship building
         const allEntities = new Map();
         for (const type of registry.getTypes()) {
             for (const entity of registry.getAll(type)) {
                 allEntities.set(entity.id, entity);
             }
         }
-        for (const [fromId, refs] of _idReferences) {
-            const fromEntity = allEntities.get(fromId);
-            if (!fromEntity)
-                continue;
-            for (const ref of refs) {
-                const toEntity = allEntities.get(ref.id);
-                if (!toEntity)
-                    continue; // Reference to unknown entity — skip
-                // Determine relationship kind
-                // If entity A has status "blocked" and references entity B, A is "blocked-by" B
-                const fromStatus = String(fromEntity.data.status ?? '');
-                const isBlockedBy = fromStatus === 'blocked';
-                if (isBlockedBy) {
-                    // A is blocked by B
-                    addRel(fromId, {
-                        fromId, fromType: fromEntity.type,
-                        toId: ref.id, toType: toEntity.type,
-                        kind: 'blocked-by',
-                    });
-                    // B blocks A
-                    addRel(ref.id, {
-                        fromId: ref.id, fromType: toEntity.type,
-                        toId: fromId, toType: fromEntity.type,
-                        kind: 'blocks',
-                    });
+        // Build bidirectional relationship index using extracted module
+        const relationships = buildRelationships(allEntities, _sourceReferences, _scannerDependencies, _idReferences);
+        // Extract git history for all entities
+        let history = new Map();
+        let repositoryUrl;
+        try {
+            const planDir = _planDir ?? 'plan';
+            const cache = readHistoryCache(planDir);
+            history = extractBatchHistory(planDir, '.', { cache });
+            writeHistoryCache(planDir, cache);
+            // Parse repository URL from git remote
+            try {
+                const remoteUrl = execSync('git remote get-url origin', {
+                    encoding: 'utf-8',
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                }).trim();
+                // Convert SSH URLs to HTTPS
+                const sshMatch = remoteUrl.match(/^git@([^:]+):(.+?)(?:\.git)?$/);
+                if (sshMatch) {
+                    repositoryUrl = `https://${sshMatch[1]}/${sshMatch[2]}`;
                 }
-                else {
-                    // General related reference (bidirectional)
-                    addRel(fromId, {
-                        fromId, fromType: fromEntity.type,
-                        toId: ref.id, toType: toEntity.type,
-                        kind: 'related',
-                    });
-                    addRel(ref.id, {
-                        fromId: ref.id, fromType: toEntity.type,
-                        toId: fromId, toType: fromEntity.type,
-                        kind: 'related',
-                    });
+                else if (remoteUrl.startsWith('https://')) {
+                    repositoryUrl = remoteUrl.replace(/\.git$/, '');
                 }
             }
+            catch {
+                // No remote configured
+            }
+        }
+        catch (err) {
+            // Git not available or not a git repo — history will be empty
+            ctx.warn(`Could not extract git history: ${err instanceof Error ? err.message : String(err)}`);
         }
         return {
             workEntities: registry.getAll('work'),
@@ -349,6 +271,8 @@ export const planPipelineHooks = {
             specEntities: registry.getAll('spec'),
             milestoneEntities: registry.getAll('milestone'),
             relationships,
+            history,
+            repositoryUrl,
         };
     },
     postProcess(page, aggregated) {
@@ -377,6 +301,11 @@ export const planPipelineHooks = {
                 modified = true;
                 return resolvePlanActivity(tag, planData);
             }
+            // Handle plan-history sentinel
+            if (tag.attributes['data-rune'] === 'plan-history' && hasSentinel(tag, PLAN_HISTORY_SENTINEL)) {
+                modified = true;
+                return resolvePlanHistory(tag, planData);
+            }
             // Inject auto-backlog into milestone rune tags
             if (tag.attributes['data-rune'] === 'milestone') {
                 const milestoneName = readField(tag, 'name');
@@ -388,7 +317,7 @@ export const planPipelineHooks = {
                     }
                 }
             }
-            // Inject relationships section into entity rune tags
+            // Wrap entity content in tab-group with Overview / Relationships / History panels
             if (PLAN_RUNE_TYPES.has(tag.attributes['data-rune'])) {
                 const runeType = tag.attributes['data-rune'];
                 const entityId = runeType === 'milestone'
@@ -396,12 +325,32 @@ export const planPipelineHooks = {
                     : readField(tag, 'id');
                 if (entityId) {
                     const rels = planData.relationships.get(entityId);
-                    if (rels && rels.length > 0) {
-                        const section = buildRelationshipsSection(rels, planData);
-                        if (section) {
-                            modified = true;
-                            return new Tag(tag.name, tag.attributes, [...tag.children, section]);
+                    const relationshipsSection = (rels && rels.length > 0)
+                        ? buildRelationshipsSection(rels, planData)
+                        : null;
+                    const historySection = buildAutoHistorySection(entityId, planData);
+                    // Only add tabs if there is content for at least one extra panel
+                    if (relationshipsSection || historySection) {
+                        modified = true;
+                        // Partition children: structural (meta fields, title, blurb) stay at top;
+                        // body content goes into the Overview tab panel.
+                        // Note: postProcess runs BEFORE the identity transform, so children
+                        // have data-name/data-field from createComponentRenderable but no
+                        // data-section or BEM classes yet.
+                        const PREAMBLE_NAMES = new Set(['title', 'blurb']);
+                        const structural = [];
+                        const bodyContent = [];
+                        for (const child of tag.children) {
+                            if (Markdoc.Tag.isTag(child) && (child.attributes['data-field'] != null ||
+                                PREAMBLE_NAMES.has(child.attributes['data-name']))) {
+                                structural.push(child);
+                            }
+                            else {
+                                bodyContent.push(child);
+                            }
                         }
+                        const tabWrapper = buildEntityTabGroup(bodyContent, relationshipsSection, historySection);
+                        return new Tag(tag.name, tag.attributes, [...structural, tabWrapper]);
                     }
                 }
             }
@@ -683,8 +632,289 @@ function resolvePlanActivity(tag, data) {
     newChildren.push(list);
     return new Tag(tag.name, tag.attributes, newChildren);
 }
-const KIND_ORDER = { 'blocked-by': 0, 'blocks': 1, 'related': 2 };
-const KIND_LABELS = { 'blocked-by': 'Blocked by', 'blocks': 'Blocks', 'related': 'Related' };
+// ─── Plan History Resolution ───
+function formatHistoryDate(isoDate) {
+    const d = new Date(isoDate);
+    const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+    return `${months[d.getMonth()]} ${d.getDate()}`;
+}
+function buildAttrChangeTag(change) {
+    const children = [
+        new Tag('span', { class: 'rf-plan-history__field' }, [change.field]),
+    ];
+    if (change.from !== null) {
+        children.push(new Tag('span', { class: 'rf-plan-history__value', 'data-type': 'remove' }, [change.from]));
+    }
+    if (change.from !== null && change.to !== null) {
+        children.push(new Tag('span', { class: 'rf-plan-history__arrow' }, ['→']));
+    }
+    if (change.to !== null) {
+        const prefix = change.from === null ? '+' : '';
+        children.push(new Tag('span', { class: 'rf-plan-history__value', 'data-type': 'add' }, [prefix + change.to]));
+    }
+    if (change.from !== null && change.to === null) {
+        // Removed attribute — show as removal only
+    }
+    return new Tag('span', { class: 'rf-plan-history__change' }, children);
+}
+function buildEventTag(event, repositoryUrl, collapseThreshold = 3) {
+    const dateTag = new Tag('time', { class: 'rf-plan-history__date' }, [formatHistoryDate(event.date)]);
+    const hashChildren = [event.shortHash];
+    const hashAttrs = { class: 'rf-plan-history__hash' };
+    if (repositoryUrl) {
+        const hashTag = new Tag('a', {
+            class: 'rf-plan-history__hash',
+            href: `${repositoryUrl}/commit/${event.hash}`,
+        }, [event.shortHash]);
+        return buildEventTagInner(event, dateTag, hashTag, collapseThreshold);
+    }
+    const hashTag = new Tag('code', hashAttrs, hashChildren);
+    return buildEventTagInner(event, dateTag, hashTag, collapseThreshold);
+}
+function buildEventTagInner(event, dateTag, hashTag, collapseThreshold) {
+    const changesChildren = [];
+    if (event.kind === 'created') {
+        const attrs = event.initialAttributes ?? {};
+        const parts = Object.entries(attrs)
+            .filter(([k]) => k !== 'id' && k !== 'name')
+            .map(([, v]) => v);
+        changesChildren.push(new Tag('span', { class: 'rf-plan-history__created' }, [`Created (${parts.join(', ')})`]));
+    }
+    if (event.attributeChanges) {
+        for (const change of event.attributeChanges) {
+            changesChildren.push(buildAttrChangeTag(change));
+        }
+    }
+    if (event.criteriaChanges) {
+        const items = event.criteriaChanges.map(c => {
+            const marker = c.action === 'checked' ? '☑' : c.action === 'unchecked' ? '☐' : c.action === 'added' ? '+' : '−';
+            return new Tag('li', { 'data-action': c.action }, [`${marker} ${c.text}`]);
+        });
+        // Collapse if over threshold
+        if (items.length > collapseThreshold) {
+            const visible = items.slice(0, collapseThreshold);
+            const remaining = items.length - collapseThreshold;
+            visible.push(new Tag('li', { class: 'rf-plan-history__more' }, [`+${remaining} more criteria`]));
+            changesChildren.push(new Tag('ul', { class: 'rf-plan-history__criteria' }, visible));
+        }
+        else {
+            changesChildren.push(new Tag('ul', { class: 'rf-plan-history__criteria' }, items));
+        }
+    }
+    if (event.kind === 'resolution') {
+        changesChildren.push(new Tag('span', { class: 'rf-plan-history__resolution' }, ['Resolution recorded']));
+    }
+    if (event.kind === 'content') {
+        changesChildren.push(new Tag('span', { class: 'rf-plan-history__content-edit' }, ['Content edited']));
+    }
+    const changesDiv = new Tag('div', { class: 'rf-plan-history__changes' }, changesChildren);
+    return new Tag('li', {
+        class: 'rf-plan-history__event',
+        'data-kind': event.kind,
+    }, [dateTag, hashTag, changesDiv]);
+}
+function resolvePlanHistory(tag, data) {
+    const entityId = readField(tag, 'id');
+    const limit = parseInt(readField(tag, 'limit') || '20', 10);
+    const typeFilter = readField(tag, 'type') || 'all';
+    const group = readField(tag, 'group') || 'commit';
+    const allEntities = [
+        ...data.workEntities,
+        ...data.bugEntities,
+        ...data.decisionEntities,
+        ...data.specEntities,
+        ...data.milestoneEntities,
+    ];
+    let listContent;
+    let isGlobal = false;
+    if (entityId) {
+        // Per-entity mode: find the entity's file path and look up its history
+        const entity = allEntities.find(e => e.id === entityId || e.data.name === entityId);
+        if (!entity) {
+            listContent = new Tag('ol', { 'data-name': 'events', class: 'rf-plan-history__events' }, [
+                new Tag('li', { class: 'rf-plan-history__empty' }, [`No history found for ${entityId}`]),
+            ]);
+        }
+        else {
+            // Find history by matching entity file path
+            let entityEvents = [];
+            for (const [file, events] of data.history) {
+                // Match by file path containing the entity ID or by checking attributes
+                if (events.length > 0 && events[0].initialAttributes) {
+                    const eventId = events[0].initialAttributes.id ?? events[0].initialAttributes.name;
+                    if (eventId === entityId) {
+                        entityEvents = events;
+                        break;
+                    }
+                }
+            }
+            // Reverse to newest-first, apply limit
+            const limited = [...entityEvents].reverse().slice(0, limit);
+            const items = limited.map(e => buildEventTag(e, data.repositoryUrl));
+            listContent = new Tag('ol', { 'data-name': 'events', class: 'rf-plan-history__events' }, items.length > 0 ? items : [new Tag('li', { class: 'rf-plan-history__empty' }, ['No history available'])]);
+        }
+    }
+    else {
+        // Global feed mode
+        isGlobal = true;
+        const typeSet = typeFilter !== 'all' ? new Set(typeFilter.split(',').map(t => t.trim())) : null;
+        const entityByFile = new Map(allEntities.map(e => {
+            // Try to find the file path from history keys
+            const filePath = e.data.file;
+            return [filePath ?? e.id, e];
+        }));
+        // Group events by commit
+        const commitMap = new Map();
+        for (const [file, events] of data.history) {
+            // Determine entity type for filtering
+            const firstEvent = events[0];
+            const initialType = firstEvent?.initialAttributes?.id?.split('-')[0]?.toLowerCase();
+            const entityTypeMap = { work: 'work', spec: 'spec', bug: 'bug', adr: 'decision' };
+            const entityType = entityTypeMap[initialType ?? ''];
+            if (typeSet && entityType && !typeSet.has(entityType))
+                continue;
+            const entityId = firstEvent?.initialAttributes?.id ?? firstEvent?.initialAttributes?.name ?? file;
+            for (const event of events) {
+                if (event.kind === 'content')
+                    continue; // Skip content events in global feed
+                let commitGroup = commitMap.get(event.hash);
+                if (!commitGroup) {
+                    commitGroup = {
+                        hash: event.hash,
+                        shortHash: event.shortHash,
+                        date: event.date,
+                        message: event.message,
+                        entities: [],
+                    };
+                    commitMap.set(event.hash, commitGroup);
+                }
+                commitGroup.entities.push({ id: String(entityId), event });
+            }
+        }
+        // Sort commits newest-first, apply limit
+        const sortedCommits = [...commitMap.values()]
+            .sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime())
+            .slice(0, limit);
+        const commitItems = sortedCommits.map(commit => {
+            const dateTag = new Tag('time', { class: 'rf-plan-history__date' }, [formatHistoryDate(commit.date)]);
+            const hashAttrs = { class: 'rf-plan-history__hash' };
+            let hashTag;
+            if (data.repositoryUrl) {
+                hashTag = new Tag('a', {
+                    class: 'rf-plan-history__hash',
+                    href: `${data.repositoryUrl}/commit/${commit.hash}`,
+                }, [commit.shortHash]);
+            }
+            else {
+                hashTag = new Tag('code', hashAttrs, [commit.shortHash]);
+            }
+            const messageTag = new Tag('span', { class: 'rf-plan-history__commit-message' }, [commit.message]);
+            const entitySummaries = commit.entities.map(({ id, event }) => {
+                const parts = [];
+                if (event.kind === 'created') {
+                    const attrs = event.initialAttributes ?? {};
+                    const vals = Object.entries(attrs).filter(([k]) => k !== 'id' && k !== 'name').map(([, v]) => v);
+                    parts.push(`Created (${vals.join(', ')})`);
+                }
+                if (event.attributeChanges) {
+                    for (const c of event.attributeChanges) {
+                        if (c.from === null)
+                            parts.push(`${c.field}: +${c.to}`);
+                        else if (c.to === null)
+                            parts.push(`${c.field}: -${c.from}`);
+                        else
+                            parts.push(`${c.field}: ${c.from} → ${c.to}`);
+                    }
+                }
+                if (event.criteriaChanges && event.criteriaChanges.length > 0) {
+                    const checked = event.criteriaChanges.filter(c => c.action === 'checked').length;
+                    const total = event.criteriaChanges.length;
+                    parts.push(`☑ ${checked}/${total}`);
+                }
+                if (event.kind === 'resolution')
+                    parts.push('Resolution recorded');
+                return new Tag('div', { class: 'rf-plan-history__entity-summary' }, [
+                    new Tag('span', { class: 'rf-plan-history__entity-id' }, [id]),
+                    new Tag('span', { class: 'rf-plan-history__entity-changes' }, [parts.join(', ')]),
+                ]);
+            });
+            return new Tag('li', { class: 'rf-plan-history__event' }, [
+                dateTag, hashTag, messageTag,
+                new Tag('div', { class: 'rf-plan-history__changes' }, entitySummaries),
+            ]);
+        });
+        listContent = new Tag('ol', { 'data-name': 'events', class: 'rf-plan-history__events' }, commitItems.length > 0 ? commitItems : [new Tag('li', { class: 'rf-plan-history__empty' }, ['No history available'])]);
+    }
+    const attrs = { ...tag.attributes };
+    if (isGlobal) {
+        attrs.class = ((attrs.class ?? '') + ' rf-plan-history--global').trim();
+    }
+    const newChildren = tag.children.filter((c) => !(Markdoc.Tag.isTag(c) && (c.attributes['data-field'] === PLAN_HISTORY_SENTINEL ||
+        c.attributes['data-name'] === 'events' ||
+        c.attributes['data-name'] === 'items')));
+    newChildren.push(listContent);
+    return new Tag(tag.name, attrs, newChildren);
+}
+/**
+ * Build a tab-group wrapper for entity pages with Overview, Relationships, and History panels.
+ * Emits the same HTML contract that tabsBehavior expects.
+ */
+function buildEntityTabGroup(bodyContent, relationshipsSection, historySection) {
+    const tabButtons = [];
+    const tabPanels = [];
+    // Overview tab (always present)
+    tabButtons.push(new Tag('button', {
+        role: 'tab',
+        class: 'rf-plan-entity-tabs__tab',
+        'data-tab': 'overview',
+    }, ['Overview']));
+    tabPanels.push(new Tag('div', {
+        role: 'tabpanel',
+        class: 'rf-plan-entity-tabs__panel',
+        'data-tab': 'overview',
+    }, bodyContent));
+    // Relationships tab (only if there are relationships)
+    if (relationshipsSection) {
+        tabButtons.push(new Tag('button', {
+            role: 'tab',
+            class: 'rf-plan-entity-tabs__tab',
+            'data-tab': 'relationships',
+        }, ['Relationships']));
+        tabPanels.push(new Tag('div', {
+            role: 'tabpanel',
+            class: 'rf-plan-entity-tabs__panel',
+            'data-tab': 'relationships',
+        }, [relationshipsSection]));
+    }
+    // History tab (only if there is history)
+    if (historySection) {
+        tabButtons.push(new Tag('button', {
+            role: 'tab',
+            class: 'rf-plan-entity-tabs__tab',
+            'data-tab': 'history',
+        }, ['History']));
+        tabPanels.push(new Tag('div', {
+            role: 'tabpanel',
+            class: 'rf-plan-entity-tabs__panel',
+            'data-tab': 'history',
+        }, [historySection]));
+    }
+    const tabList = new Tag('div', {
+        'data-name': 'tabs',
+        role: 'tablist',
+        class: 'rf-plan-entity-tabs__tabs',
+    }, tabButtons);
+    const panels = new Tag('div', {
+        'data-name': 'panels',
+        class: 'rf-plan-entity-tabs__panels',
+    }, tabPanels);
+    return new Tag('div', {
+        class: 'rf-plan-entity-tabs',
+        'data-rune': 'plan-entity-tabs',
+    }, [tabList, panels]);
+}
+const KIND_ORDER = { 'blocked-by': 0, 'blocks': 1, 'depends-on': 2, 'dependency-of': 3, 'implements': 4, 'implemented-by': 5, 'informs': 6, 'informed-by': 7, 'related': 8 };
+const KIND_LABELS = { 'blocked-by': 'Blocked by', 'blocks': 'Blocks', 'depends-on': 'Depends on', 'dependency-of': 'Dependency of', 'implements': 'Implements', 'implemented-by': 'Implemented by', 'informs': 'Informs', 'informed-by': 'Decisions', 'related': 'Related' };
 /** Look up an entity across all aggregated type arrays */
 function findEntity(id, data) {
     const allArrays = [data.workEntities, data.bugEntities, data.decisionEntities, data.specEntities, data.milestoneEntities];
@@ -720,37 +950,42 @@ function buildRelationshipsSection(rels, data) {
     for (const kind of sortedKinds) {
         const kindRels = byKind.get(kind);
         const label = KIND_LABELS[kind] || kind;
-        const items = [];
+        // "Informed by" renders decision entry cards
+        if (kind === 'informed-by') {
+            const entries = [];
+            for (const rel of kindRels) {
+                const target = findEntity(rel.toId, data);
+                if (target) {
+                    entries.push(buildDecisionEntry(target));
+                }
+            }
+            if (entries.length > 0) {
+                groups.push(new Tag('div', {
+                    class: 'rf-plan-relationships__group',
+                    'data-kind': kind,
+                }, [
+                    new Tag('h3', { class: 'rf-plan-relationships__group-title' }, [label]),
+                    new Tag('ol', { class: 'rf-plan-relationships__decisions' }, entries),
+                ]));
+            }
+            continue;
+        }
+        const cards = [];
         for (const rel of kindRels) {
-            const targetId = rel.toId;
-            const target = findEntity(targetId, data);
-            const title = target ? String(target.data.title ?? '') : '';
-            const status = target ? String(target.data.status ?? '') : '';
-            const type = target ? target.type : rel.toType;
-            const innerChildren = [
-                new Tag('span', { class: 'rf-plan-relationships__id' }, [targetId]),
-                new Tag('span', {
-                    class: 'rf-plan-relationships__status',
-                    'data-status': status,
-                }, [status]),
-                new Tag('span', { class: 'rf-plan-relationships__type' }, [type]),
-                ...(title ? [new Tag('span', { class: 'rf-plan-relationships__title' }, [title])] : []),
-            ];
-            const children = target?.sourceUrl
-                ? [new Tag('a', { class: 'rf-plan-relationships__link', href: target.sourceUrl }, innerChildren)]
-                : innerChildren;
-            items.push(new Tag('li', {
-                class: 'rf-plan-relationships__item',
+            const target = findEntity(rel.toId, data);
+            if (target) {
+                cards.push(buildEntityCard(target));
+            }
+        }
+        if (cards.length > 0) {
+            groups.push(new Tag('div', {
+                class: 'rf-plan-relationships__group',
                 'data-kind': kind,
-            }, children));
+            }, [
+                new Tag('h3', { class: 'rf-plan-relationships__group-title' }, [label]),
+                new Tag('div', { class: 'rf-plan-relationships__cards' }, cards),
+            ]));
         }
-        groups.push(new Tag('div', {
-            class: 'rf-plan-relationships__group',
-            'data-kind': kind,
-        }, [
-            new Tag('h3', { class: 'rf-plan-relationships__group-title' }, [label]),
-            new Tag('ul', { class: 'rf-plan-relationships__list' }, items),
-        ]));
     }
     if (groups.length === 0)
         return null;
@@ -762,4 +997,35 @@ function buildRelationshipsSection(rels, data) {
         ...groups,
     ]);
 }
+/**
+ * Build an auto-injected History section for an entity page.
+ * Returns null for entities with only a single commit (created and never modified).
+ */
+function buildAutoHistorySection(entityId, data) {
+    // Find history events by matching the entity ID in the first event's attributes
+    let entityEvents = [];
+    for (const [, events] of data.history) {
+        if (events.length > 0 && events[0].initialAttributes) {
+            const eventId = events[0].initialAttributes.id ?? events[0].initialAttributes.name;
+            if (eventId === entityId) {
+                entityEvents = events;
+                break;
+            }
+        }
+    }
+    // Skip entities with only a single commit (creation only) — no meaningful history
+    if (entityEvents.length <= 1)
+        return null;
+    // Build timeline (newest-first), limit to 20 events
+    const limited = [...entityEvents].reverse().slice(0, 20);
+    const items = limited.map(e => buildEventTag(e, data.repositoryUrl));
+    const list = new Tag('ol', { class: 'rf-plan-history__events' }, items);
+    return new Tag('section', {
+        class: 'rf-plan-history',
+        'data-name': 'history',
+    }, [
+        new Tag('h2', { class: 'rf-plan-history__heading' }, ['History']),
+        list,
+    ]);
+}
 //# sourceMappingURL=pipeline.js.map