@refrakt-md/plan 0.9.5 → 0.9.6

package/dist/pipeline.js

@@ -3,15 +3,18 @@ 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';
 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) {
@@ -129,6 +132,15 @@ const PRIORITY_SENTIMENT = {
 const SEVERITY_SENTIMENT = {
     critical: 'negative', major: 'caution', minor: 'neutral', trivial: 'neutral',
 };
+const SPEC_STATUS_SENTIMENT = {
+    draft: 'neutral', review: 'caution', accepted: 'positive', superseded: 'caution', deprecated: 'negative',
+};
+const DECISION_STATUS_SENTIMENT = {
+    proposed: 'neutral', accepted: 'positive', superseded: 'caution', deprecated: 'negative',
+};
+const MILESTONE_STATUS_SENTIMENT = {
+    planning: 'neutral', active: 'positive', complete: 'positive',
+};
 /** Build a metadata badge matching the dimension system output */
 function buildMetaBadge(label, value, opts) {
     const labelAttrs = { 'data-meta-label': '' };
@@ -144,12 +156,12 @@ function buildMetaBadge(label, value, opts) {
         attrs['data-meta-sentiment'] = opts.sentiment;
     return new Tag('span', attrs, [labelEl, valueEl]);
 }
-/** Build a compact summary card Tag for a work/bug entity */
+/** Build a compact summary card Tag for any plan entity */
 function buildEntityCard(entity) {
-    const id = String(entity.data.id ?? entity.id);
+    const type = entity.type;
+    const id = String(type === 'milestone' ? (entity.data.name ?? entity.id) : (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 }),
@@ -157,7 +169,10 @@ function buildEntityCard(entity) {
     const headerRight = [];
     const statusSentiment = type === 'work' ? WORK_STATUS_SENTIMENT[status]
         : type === 'bug' ? BUG_STATUS_SENTIMENT[status]
-            : undefined;
+            : type === 'spec' ? SPEC_STATUS_SENTIMENT[status]
+                : type === 'decision' ? DECISION_STATUS_SENTIMENT[status]
+                    : type === 'milestone' ? MILESTONE_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);
@@ -190,6 +205,21 @@ function buildEntityCard(entity) {
         if (severity)
             footerBadges.push(buildMetaBadge('Severity:', severity, { metaType: 'category', metaRank: 'secondary', sentiment: SEVERITY_SENTIMENT[severity] }));
     }
+    else if (type === 'spec') {
+        const version = String(entity.data.version ?? '');
+        if (version)
+            footerBadges.push(buildMetaBadge('Version:', version, { metaType: 'quantity', metaRank: 'secondary' }));
+    }
+    else if (type === 'decision') {
+        const date = String(entity.data.date ?? '');
+        if (date)
+            footerBadges.push(buildMetaBadge('Date:', date, { metaType: 'temporal', metaRank: 'secondary' }));
+    }
+    else if (type === 'milestone') {
+        const target = String(entity.data.target ?? '');
+        if (target)
+            footerBadges.push(buildMetaBadge('Target:', target, { metaType: 'temporal', metaRank: 'secondary' }));
+    }
     const milestone = String(entity.data.milestone ?? '');
     if (milestone)
         footerBadges.push(buildMetaBadge('Milestone:', milestone, { metaType: 'tag', metaRank: 'secondary', labelHidden: true }));
@@ -207,9 +237,6 @@ function buildEntityCard(entity) {
         'data-id': id,
     }, children);
 }
-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);
@@ -234,15 +261,61 @@ function buildDecisionEntry(entity) {
         'data-id': id,
     }, children);
 }
+/**
+ * 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);
+}
+/**
+ * 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;
+}
+/** 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.
  * Maps entityId → array of referenced entity IDs (with type).
  * 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 +350,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,7 +365,7 @@ export const planPipelineHooks = {
             });
         }
     },
-    aggregate(registry) {
+    aggregate(registry, ctx) {
         // Build bidirectional relationship index from ID references
         const relationships = new Map();
         function addRel(id, rel) {
@@ -301,6 +380,63 @@ export const planPipelineHooks = {
                 allEntities.set(entity.id, entity);
             }
         }
+        // Track IDs already linked via source= to avoid duplicate 'related' edges
+        const sourceLinked = new Set();
+        // Process structured source= references → implements / implemented-by (or informs / informed-by for decisions)
+        for (const [fromId, refs] of _sourceReferences) {
+            const fromEntity = allEntities.get(fromId);
+            if (!fromEntity)
+                continue;
+            // Decisions use informs/informed-by; work/bug use implements/implemented-by
+            const isDecision = fromEntity.type === 'decision';
+            const forwardKind = isDecision ? 'informs' : 'implements';
+            const reverseKind = isDecision ? 'informed-by' : 'implemented-by';
+            for (const ref of refs) {
+                const toEntity = allEntities.get(ref.id);
+                if (!toEntity)
+                    continue;
+                sourceLinked.add(`${fromId}→${ref.id}`);
+                // A implements/informs B
+                addRel(fromId, {
+                    fromId, fromType: fromEntity.type,
+                    toId: ref.id, toType: toEntity.type,
+                    kind: forwardKind,
+                });
+                // B is implemented-by/informed-by A
+                addRel(ref.id, {
+                    fromId: ref.id, fromType: toEntity.type,
+                    toId: fromId, toType: fromEntity.type,
+                    kind: reverseKind,
+                });
+            }
+        }
+        // Track IDs already linked via depends-on to avoid duplicate 'related' edges
+        const depLinked = new Set();
+        // Process scanner dependency data → depends-on / dependency-of
+        for (const [fromId, depIds] of _scannerDependencies) {
+            const fromEntity = allEntities.get(fromId);
+            if (!fromEntity)
+                continue;
+            for (const depId of depIds) {
+                const toEntity = allEntities.get(depId);
+                if (!toEntity)
+                    continue;
+                depLinked.add(`${fromId}→${depId}`);
+                // A depends-on B
+                addRel(fromId, {
+                    fromId, fromType: fromEntity.type,
+                    toId: depId, toType: toEntity.type,
+                    kind: 'depends-on',
+                });
+                // B is dependency-of A
+                addRel(depId, {
+                    fromId: depId, fromType: toEntity.type,
+                    toId: fromId, toType: fromEntity.type,
+                    kind: 'dependency-of',
+                });
+            }
+        }
+        // Process text-based ID references → blocks / blocked-by / related
         for (const [fromId, refs] of _idReferences) {
             const fromEntity = allEntities.get(fromId);
             if (!fromEntity)
@@ -309,6 +445,11 @@ export const planPipelineHooks = {
                 const toEntity = allEntities.get(ref.id);
                 if (!toEntity)
                     continue; // Reference to unknown entity — skip
+                // Skip if already linked via source= attribute or dependency
+                if (sourceLinked.has(`${fromId}→${ref.id}`))
+                    continue;
+                if (depLinked.has(`${fromId}→${ref.id}`))
+                    continue;
                 // Determine relationship kind
                 // If entity A has status "blocked" and references entity B, A is "blocked-by" B
                 const fromStatus = String(fromEntity.data.status ?? '');
@@ -342,6 +483,37 @@ export const planPipelineHooks = {
                 }
             }
         }
+        // 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 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'),
             bugEntities: registry.getAll('bug'),
@@ -349,6 +521,8 @@ export const planPipelineHooks = {
             specEntities: registry.getAll('spec'),
             milestoneEntities: registry.getAll('milestone'),
             relationships,
+            history,
+            repositoryUrl,
         };
     },
     postProcess(page, aggregated) {
@@ -377,6 +551,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 +567,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 +575,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 +882,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 +1200,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 +1247,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