@diagrammo/dgmo 0.7.2 → 0.8.0

package/src/initiative-status/parser.ts

@@ -11,11 +11,11 @@ import type {
   ISGroup,
   InitiativeStatus,
 } from './types';
-import { VALID_STATUSES } from './types';
+import { VALID_STATUSES, STATUS_ALIASES } from './types';
 import { inferParticipantType } from '../sequence/participant-inference';
 import { matchTagBlockHeading, injectDefaultTagMetadata, validateTagValues } from '../utils/tag-groups';
 import type { TagGroup } from '../utils/tag-groups';
-import { extractColor } from '../utils/parsing';
+import { extractColor, parseFirstLine, ALL_CHART_TYPES, OPTION_NOCOLON_RE } from '../utils/parsing';
 
 // ============================================================
 // Heuristic — does this content look like an initiative-status diagram?
@@ -35,8 +35,10 @@ export function looksLikeInitiativeStatus(content: string): boolean {
     if (!trimmed || trimmed.startsWith('//')) continue;
     if (trimmed.match(/^chart\s*:/i)) continue;
     if (trimmed.match(/^title\s*:/i)) continue;
+    // Skip new-style first line (bare chart type name)
+    if (parseFirstLine(trimmed)) continue;
     if (trimmed.includes('->')) hasArrow = true;
-    if (/\|\s*(done|wip|todo|na)\s*$/i.test(trimmed)) hasStatus = true;
+    if (/\|\s*(done|doing|wip|blocked|paused|waiting|todo|na)\s*$/i.test(trimmed)) hasStatus = true;
     // Indented arrow is a strong signal — only initiative-status uses this
     const isIndented = line.length > 0 && line !== trimmed && /^\s/.test(line);
     if (isIndented && (trimmed.startsWith('->') || /^-[^>].*->/.test(trimmed))) hasIndentedArrow = true;
@@ -80,18 +82,36 @@ export function parseNodeMetadata(
       // key: value pair
       const rawKey = trimmed.slice(0, colonIdx).trim().toLowerCase();
       const value = trimmed.slice(colonIdx + 1).trim();
-      // Resolve alias to group name
-      const resolvedKey = aliasMap.get(rawKey) ?? rawKey;
-      metadata[resolvedKey] = value;
+
+      // Handle explicit `status: keyword` form
+      if (rawKey === 'status') {
+        hadStatusWord = true;
+        const lower = value.toLowerCase();
+        const canonical = STATUS_ALIASES[lower] ?? lower;
+        if (VALID_STATUSES.includes(canonical)) {
+          status = canonical as InitiativeStatus;
+        } else if (lineNum !== undefined && diagnostics) {
+          const allKnown = [...VALID_STATUSES, ...Object.keys(STATUS_ALIASES)];
+          const hint = suggest(lower, allKnown);
+          const msg = `Unknown status "${value}"${hint ? `. ${hint}` : ''}`;
+          diagnostics.push(makeDgmoError(lineNum, msg, 'warning'));
+        }
+      } else {
+        // Resolve alias to group name
+        const resolvedKey = aliasMap.get(rawKey) ?? rawKey;
+        metadata[resolvedKey] = value;
+      }
     } else {
-      // Bare word — check if it's a status keyword
+      // Bare word — check if it's a status keyword (or alias)
       hadStatusWord = true;
       const lower = trimmed.toLowerCase();
-      if (VALID_STATUSES.includes(lower)) {
-        status = lower as InitiativeStatus;
+      const canonical = STATUS_ALIASES[lower] ?? lower;
+      if (VALID_STATUSES.includes(canonical)) {
+        status = canonical as InitiativeStatus;
       } else if (lineNum !== undefined && diagnostics) {
         // Unknown bare word — likely a status typo, emit warning
-        const hint = suggest(lower, VALID_STATUSES);
+        const allKnown = [...VALID_STATUSES, ...Object.keys(STATUS_ALIASES)];
+        const hint = suggest(lower, allKnown);
         const msg = `Unknown status "${trimmed}"${hint ? `. ${hint}` : ''}`;
         diagnostics.push(makeDgmoError(lineNum, msg, 'warning'));
       }
@@ -108,10 +128,12 @@ export function parseNodeMetadata(
 function parseStatus(raw: string, line: number, diagnostics: DgmoError[]): InitiativeStatus {
   const trimmed = raw.trim().toLowerCase();
   if (!trimmed) return 'na';
-  if (VALID_STATUSES.includes(trimmed)) return trimmed as InitiativeStatus;
+  const canonical = STATUS_ALIASES[trimmed] ?? trimmed;
+  if (VALID_STATUSES.includes(canonical)) return canonical as InitiativeStatus;
 
   // Unknown status — emit warning with suggestion
-  const hint = suggest(trimmed, VALID_STATUSES);
+  const allKnown = [...VALID_STATUSES, ...Object.keys(STATUS_ALIASES)];
+  const hint = suggest(trimmed, allKnown);
   const msg = `Unknown status "${raw.trim()}"${hint ? `. ${hint}` : ''}`;
   diagnostics.push(makeDgmoError(line, msg, 'warning'));
   return null;
@@ -165,36 +187,32 @@ export function parseInitiativeStatus(content: string): ParsedInitiativeStatus {
     // Skip blanks and comments
     if (!trimmed || trimmed.startsWith('//')) continue;
 
-    // chart: header
-    const chartMatch = trimmed.match(/^chart\s*:\s*(.+)/i);
-    if (chartMatch) {
-      const chartType = chartMatch[1].trim().toLowerCase();
-      if (chartType !== 'initiative-status') {
-        const diag = makeDgmoError(lineNum, `Expected chart type "initiative-status", got "${chartType}"`);
+    // First line: chart type + optional title (new syntax: `initiative-status My Dashboard`)
+    const firstLineResult = parseFirstLine(trimmed);
+    if (firstLineResult && !contentStarted) {
+      if (firstLineResult.chartType !== 'initiative-status') {
+        const diag = makeDgmoError(lineNum, `Expected chart type "initiative-status", got "${firstLineResult.chartType}"`);
         result.diagnostics.push(diag);
         result.error = formatDgmoError(diag);
         return result;
       }
+      if (firstLineResult.title) {
+        result.title = firstLineResult.title;
+        result.titleLineNumber = lineNum;
+      }
       continue;
     }
 
-    // title: header
-    const titleMatch = trimmed.match(/^title\s*:\s*(.+)/i);
-    if (titleMatch) {
-      result.title = titleMatch[1].trim();
-      result.titleLineNumber = lineNum;
-      continue;
-    }
-
-    // hide: directive — parse before tag blocks and content
-    const hideMatch = trimmed.match(/^hide\s*:\s*(.+)/i);
-    if (hideMatch) {
+    // hide directive (no colon): `hide phase Planning, phase Review`
+    const hideMatch = trimmed.match(/^hide\s+(.+)/i);
+    if (hideMatch && !trimmed.match(/^hide\s*\|/)) {
+      // Parse comma-separated tag-value pairs: `phase Planning, phase Review`
       const pairs = hideMatch[1].split(',');
       for (const pair of pairs) {
-        const colonIdx = pair.indexOf(':');
-        if (colonIdx >= 0) {
-          const groupKey = pair.slice(0, colonIdx).trim().toLowerCase();
-          const value = pair.slice(colonIdx + 1).trim().toLowerCase();
+        const tokens = pair.trim().split(/\s+/);
+        if (tokens.length >= 2) {
+          const groupKey = tokens[0].toLowerCase();
+          const value = tokens.slice(1).join(' ').toLowerCase();
           if (groupKey && value) {
             if (!result.initialHiddenTagValues.has(groupKey)) {
               result.initialHiddenTagValues.set(groupKey, new Set());
@@ -206,6 +224,20 @@ export function parseInitiativeStatus(content: string): ParsedInitiativeStatus {
       continue;
     }
 
+    // Options (space-separated, non-indented): `active-tag Priority`
+    if (!contentStarted && measureIndent(raw) === 0) {
+      const optMatch = trimmed.match(OPTION_NOCOLON_RE);
+      if (optMatch) {
+        const key = optMatch[1].toLowerCase();
+        const value = optMatch[2].trim();
+        // Only recognize known option keys (not node content)
+        if (key === 'active-tag' || key === 'sort') {
+          result.options[key] = value;
+          continue;
+        }
+      }
+    }
+
     // Tag group heading — must be checked BEFORE group/node/edge matching
     const tagBlockMatch = matchTagBlockHeading(trimmed);
     if (tagBlockMatch) {
@@ -216,7 +248,10 @@ export function parseInitiativeStatus(content: string): ParsedInitiativeStatus {
         continue;
       }
       if (tagBlockMatch.deprecated) {
-        pushWarning(lineNum, `'## ${tagBlockMatch.name}' is deprecated for tag groups — use 'tag: ${tagBlockMatch.name}' instead`);
+        result.diagnostics.push(
+          makeDgmoError(lineNum, `'## ${tagBlockMatch.name}' is no longer supported — use 'tag ${tagBlockMatch.name}' instead`)
+        );
+        continue;
       }
       currentTagGroup = {
         name: tagBlockMatch.name,
@@ -227,35 +262,47 @@ export function parseInitiativeStatus(content: string): ParsedInitiativeStatus {
       if (tagBlockMatch.alias) {
         aliasMap.set(tagBlockMatch.alias.toLowerCase(), tagBlockMatch.name.toLowerCase());
       }
+      // Handle inline values from single-line tag declaration
+      if (tagBlockMatch.inlineValues) {
+        for (const rawVal of tagBlockMatch.inlineValues) {
+          const { label, color } = extractColor(rawVal);
+          currentTagGroup.entries.push({
+            value: label,
+            color: color ?? '',
+            lineNumber: lineNum,
+          });
+        }
+        // First entry is the default
+        if (currentTagGroup.entries.length > 0) {
+          currentTagGroup.defaultValue = currentTagGroup.entries[0].value;
+        }
+      }
       result.tagGroups.push(currentTagGroup);
       continue;
     }
 
-    // Tag group entries (indented Value(color) [default] under tag heading)
+    // Tag group entries (indented Value(color) under tag heading — first value is the default)
     if (currentTagGroup && !contentStarted) {
       const indent = measureIndent(raw);
       if (indent > 0) {
-        const isDefault = /\bdefault\s*$/i.test(trimmed);
-        const entryText = isDefault
-          ? trimmed.replace(/\s+default\s*$/i, '').trim()
-          : trimmed;
-        const { label, color } = extractColor(entryText);
-        if (isDefault) {
-          currentTagGroup.defaultValue = label;
-        }
+        const { label, color } = extractColor(trimmed);
         currentTagGroup.entries.push({
           value: label,
           color: color ?? '',
           lineNumber: lineNum,
         });
+        // First entry is the default
+        if (currentTagGroup.entries.length === 1) {
+          currentTagGroup.defaultValue = label;
+        }
         continue;
       }
       // Non-indented line after tag group — close and fall through
       currentTagGroup = null;
     }
 
-    // Group header: [Group Name]
-    const groupMatch = trimmed.match(/^\[(.+)\]\s*$/);
+    // Group header: [Group Name] or [Group Name] | metadata
+    const groupMatch = trimmed.match(/^\[(.+?)\]\s*(?:\|\s*(.+))?$/);
     if (groupMatch) {
       contentStarted = true;
       currentTagGroup = null;
@@ -263,7 +310,26 @@ export function parseInitiativeStatus(content: string): ParsedInitiativeStatus {
       if (currentGroup) {
         result.groups.push(currentGroup);
       }
-      currentGroup = { label: groupMatch[1], nodeLabels: [], lineNumber: lineNum };
+      const groupMeta: Record<string, string> = {};
+      if (groupMatch[2]) {
+        // Parse pipe metadata for group (only key:value pairs, no status)
+        const items = groupMatch[2].split(',');
+        for (const item of items) {
+          const ci = item.indexOf(':');
+          if (ci >= 0) {
+            const rawKey = item.slice(0, ci).trim().toLowerCase();
+            const value = item.slice(ci + 1).trim();
+            const resolvedKey = aliasMap.get(rawKey) ?? rawKey;
+            groupMeta[resolvedKey] = value;
+          }
+        }
+      }
+      currentGroup = {
+        label: groupMatch[1],
+        nodeLabels: [],
+        lineNumber: lineNum,
+        metadata: Object.keys(groupMeta).length > 0 ? groupMeta : undefined,
+      };
       continue;
     }
 
@@ -307,6 +373,14 @@ export function parseInitiativeStatus(content: string): ParsedInitiativeStatus {
       } else {
         nodeLabels.add(node.label);
       }
+      // Cascade group metadata into node (group provides defaults, node overrides)
+      if (currentGroup && isIndented && currentGroup.metadata) {
+        for (const [key, val] of Object.entries(currentGroup.metadata)) {
+          if (!(key in node.metadata)) {
+            node.metadata[key] = val;
+          }
+        }
+      }
       result.nodes.push(node);
       // Add to current group if indented
       if (currentGroup && isIndented) {
@@ -395,7 +469,7 @@ function parseEdgeLine(
   // or:     <source> -<label>-> <target> [| <status>]
 
   // Check for labeled arrow form: SOURCE -LABEL-> TARGET [| status]
-  const labeledMatch = trimmed.match(/^(\S+)\s+-(.+)->\s+(.+)$/);
+  const labeledMatch = trimmed.match(/^(\S+)\s*-(.+)->\s*(.+)$/);
   if (labeledMatch) {
     const source = labeledMatch[1];
     const label = labeledMatch[2].trim();

package/src/initiative-status/renderer.ts

@@ -10,15 +10,15 @@ import {
   LEGEND_HEIGHT,
   LEGEND_PILL_PAD,
   LEGEND_PILL_FONT_SIZE,
-  LEGEND_PILL_FONT_W,
   LEGEND_CAPSULE_PAD,
   LEGEND_DOT_R,
   LEGEND_ENTRY_FONT_SIZE,
-  LEGEND_ENTRY_FONT_W,
   LEGEND_ENTRY_DOT_GAP,
   LEGEND_ENTRY_TRAIL,
   LEGEND_GROUP_GAP,
+  measureLegendText,
 } from '../utils/legend-constants';
+import { TITLE_FONT_SIZE, TITLE_FONT_WEIGHT, TITLE_Y } from '../utils/title-constants';
 import { contrastText, mix } from '../palettes/color-utils';
 import type { TagGroup } from '../utils/tag-groups';
 import type { PaletteColors } from '../palettes';
@@ -55,11 +55,12 @@ const COLLAPSE_BAR_HEIGHT = 6;
 
 function statusColor(status: InitiativeStatus, palette: PaletteColors, isDark: boolean): string {
   switch (status) {
-    case 'done': return palette.colors.green;
-    case 'wip':  return palette.colors.yellow;
-    case 'todo': return palette.colors.red;
-    case 'na':   return isDark ? palette.colors.gray : '#2e3440';
-    default:     return palette.textMuted;
+    case 'done':    return palette.colors.green;
+    case 'doing':   return palette.colors.blue;
+    case 'blocked': return palette.colors.orange;
+    case 'todo':    return palette.colors.red;
+    case 'na':      return isDark ? palette.colors.gray : '#2e3440';
+    default:        return palette.textMuted;
   }
 }
 
@@ -91,13 +92,14 @@ interface ISLegendEntry {
 }
 
 const IS_STATUS_LABELS: Record<string, string> = {
-  done: 'Done',
-  wip:  'In Progress',
-  todo: 'To Do',
-  na:   'N/A',
+  done:    'Done',
+  doing:   'In Progress',
+  blocked: 'Blocked',
+  todo:    'To Do',
+  na:      'N/A',
 };
 
-const IS_STATUS_ORDER: InitiativeStatus[] = ['todo', 'wip', 'done', 'na'];
+const IS_STATUS_ORDER: InitiativeStatus[] = ['todo', 'blocked', 'doing', 'done', 'na'];
 
 function collectStatuses(parsed: ParsedInitiativeStatus): ISLegendEntry[] {
   const present = new Set<string>();
@@ -114,7 +116,7 @@ const LEGEND_GROUP_NAME = 'Status';
 function legendEntriesWidth(entries: ISLegendEntry[]): number {
   let w = 0;
   for (const e of entries) {
-    w += LEGEND_DOT_R * 2 + LEGEND_ENTRY_DOT_GAP + e.label.length * LEGEND_ENTRY_FONT_W + LEGEND_ENTRY_TRAIL;
+    w += LEGEND_DOT_R * 2 + LEGEND_ENTRY_DOT_GAP + measureLegendText(e.label, LEGEND_ENTRY_FONT_SIZE) + LEGEND_ENTRY_TRAIL;
   }
   return w;
 }
@@ -556,11 +558,11 @@ export function renderInitiativeStatus(
       .append('text')
       .attr('class', 'chart-title')
       .attr('x', width / 2)
-      .attr('y', 30)
+      .attr('y', TITLE_Y)
       .attr('text-anchor', 'middle')
       .attr('fill', palette.text)
-      .attr('font-size', '20px')
-      .attr('font-weight', '700')
+      .attr('font-size', TITLE_FONT_SIZE)
+      .attr('font-weight', TITLE_FONT_WEIGHT)
       .style('cursor', onClickItem && parsed.titleLineNumber ? 'pointer' : 'default')
       .text(parsed.title);
 
@@ -599,7 +601,7 @@ export function renderInitiativeStatus(
         color: statusColor(e.statusKey, palette, isDark),
         value: e.statusKey ?? 'na',
       }));
-      const pillW = LEGEND_GROUP_NAME.length * LEGEND_PILL_FONT_W + LEGEND_PILL_PAD;
+      const pillW = measureLegendText(LEGEND_GROUP_NAME, LEGEND_PILL_FONT_SIZE) + LEGEND_PILL_PAD;
       const entrW = legendEntriesWidth(legendEntries);
       legendGroups.push({
         name: LEGEND_GROUP_NAME,
@@ -617,10 +619,10 @@ export function renderInitiativeStatus(
         color: e.color || palette.textMuted,
         value: e.value.toLowerCase(),
       }));
-      const pillW = tg.name.length * LEGEND_PILL_FONT_W + LEGEND_PILL_PAD;
+      const pillW = measureLegendText(tg.name, LEGEND_PILL_FONT_SIZE) + LEGEND_PILL_PAD;
       let entrW = 0;
       for (const e of entries) {
-        entrW += LEGEND_DOT_R * 2 + LEGEND_ENTRY_DOT_GAP + e.label.length * LEGEND_ENTRY_FONT_W + LEGEND_ENTRY_TRAIL;
+        entrW += LEGEND_DOT_R * 2 + LEGEND_ENTRY_DOT_GAP + measureLegendText(e.label, LEGEND_ENTRY_FONT_SIZE) + LEGEND_ENTRY_TRAIL;
       }
       legendGroups.push({
         name: tg.name,
@@ -645,7 +647,7 @@ export function renderInitiativeStatus(
     let totalLegendW = 0;
     for (const lg of visibleLegendGroups) {
       const isActive = lg.isStatus ? isStatusExpanded : (activeKey === lg.key);
-      const pillW = lg.name.length * LEGEND_PILL_FONT_W + LEGEND_PILL_PAD;
+      const pillW = measureLegendText(lg.name, LEGEND_PILL_FONT_SIZE) + LEGEND_PILL_PAD;
       totalLegendW += isActive ? lg.width : pillW;
       totalLegendW += LEGEND_GROUP_GAP;
     }
@@ -663,7 +665,7 @@ export function renderInitiativeStatus(
 
     for (const lg of visibleLegendGroups) {
       const isActive = lg.isStatus ? isStatusExpanded : (activeKey === lg.key);
-      const pillW = lg.name.length * LEGEND_PILL_FONT_W + LEGEND_PILL_PAD;
+      const pillW = measureLegendText(lg.name, LEGEND_PILL_FONT_SIZE) + LEGEND_PILL_PAD;
       const pillH = LEGEND_HEIGHT - (isActive ? LEGEND_CAPSULE_PAD * 2 : 0);
       const groupW = isActive ? lg.width : pillW;
 
@@ -674,6 +676,11 @@ export function renderInitiativeStatus(
         .attr('data-legend-group', lg.key)
         .style('cursor', 'pointer');
 
+      // Mark inactive pills so exports can hide them
+      if (!isActive) {
+        gEl.attr('data-export-ignore', 'true');
+      }
+
       if (isActive) {
         // Outer capsule background
         gEl.append('rect')
@@ -724,18 +731,33 @@ export function renderInitiativeStatus(
         // Determine which values are hidden for this group
         const hiddenSet = !lg.isStatus ? hiddenTagValues?.get(lg.key) : undefined;
 
-        let entryX = pillXOff + pillW + 4;
+        // Render each entry in its own <g> with local coordinates,
+        // positioned via transform so we can reflow after measuring.
+        const entryStartX = pillXOff + pillW + 4;
+        const entryData: { g: d3Selection.Selection<SVGGElement, unknown, null, undefined>; textEl: SVGTextElement; estimatedW: number }[] = [];
+        let estimatedX = entryStartX;
+
         for (const entry of lg.entries) {
           const isHidden = hiddenSet?.has(entry.value) ?? false;
+          const estimatedTextW = measureLegendText(entry.label, LEGEND_ENTRY_FONT_SIZE);
 
           const entryG = gEl.append('g')
             .attr('data-legend-entry', entry.value)
-            .style('cursor', !lg.isStatus ? 'pointer' : 'default');
+            .attr('transform', `translate(${estimatedX}, 0)`)
+            .style('cursor', 'pointer');
+
+          // Transparent hit-area rect
+          const entryW = LEGEND_DOT_R * 2 + LEGEND_ENTRY_DOT_GAP + estimatedTextW + LEGEND_ENTRY_TRAIL;
+          entryG.append('rect')
+            .attr('x', -2)
+            .attr('y', 0)
+            .attr('width', entryW + 4)
+            .attr('height', LEGEND_HEIGHT)
+            .attr('fill', 'transparent');
 
           if (isHidden) {
-            // Hidden: hollow ring + dimmed text (strikethrough-like)
             entryG.append('circle')
-              .attr('cx', entryX + LEGEND_DOT_R)
+              .attr('cx', LEGEND_DOT_R)
               .attr('cy', LEGEND_HEIGHT / 2)
               .attr('r', LEGEND_DOT_R)
               .attr('fill', 'none')
@@ -743,16 +765,15 @@ export function renderInitiativeStatus(
               .attr('stroke-width', 1.2)
               .attr('opacity', 0.5);
           } else {
-            // Visible: solid dot
             entryG.append('circle')
-              .attr('cx', entryX + LEGEND_DOT_R)
+              .attr('cx', LEGEND_DOT_R)
               .attr('cy', LEGEND_HEIGHT / 2)
               .attr('r', LEGEND_DOT_R)
               .attr('fill', entry.color);
           }
 
-          entryG.append('text')
-            .attr('x', entryX + LEGEND_DOT_R * 2 + LEGEND_ENTRY_DOT_GAP)
+          const textEl = entryG.append('text')
+            .attr('x', LEGEND_DOT_R * 2 + LEGEND_ENTRY_DOT_GAP)
             .attr('y', LEGEND_HEIGHT / 2 + LEGEND_ENTRY_FONT_SIZE / 2 - 1)
             .attr('font-size', LEGEND_ENTRY_FONT_SIZE)
             .attr('fill', palette.textMuted)
@@ -761,7 +782,20 @@ export function renderInitiativeStatus(
             .attr('text-decoration', isHidden ? 'line-through' : 'none')
             .text(entry.label);
 
-          entryX += LEGEND_DOT_R * 2 + LEGEND_ENTRY_DOT_GAP + entry.label.length * LEGEND_ENTRY_FONT_W + LEGEND_ENTRY_TRAIL;
+          entryData.push({ g: entryG, textEl: textEl.node()!, estimatedW: estimatedTextW });
+          estimatedX += LEGEND_DOT_R * 2 + LEGEND_ENTRY_DOT_GAP + estimatedTextW + LEGEND_ENTRY_TRAIL;
+        }
+
+        // Reflow using measured text widths for even spacing
+        let reflowX = entryStartX;
+        for (const ed of entryData) {
+          const measuredW = ed.textEl.getComputedTextLength?.() ?? 0;
+          const textW = measuredW > 0 ? measuredW : ed.estimatedW;
+          ed.g.attr('transform', `translate(${reflowX}, 0)`);
+          // Update hit-area rect width to match actual width
+          const actualEntryW = LEGEND_DOT_R * 2 + LEGEND_ENTRY_DOT_GAP + textW + LEGEND_ENTRY_TRAIL;
+          ed.g.select('rect').attr('width', actualEntryW + 4);
+          reflowX += actualEntryW;
         }
       }
 
@@ -992,7 +1026,7 @@ export function renderInitiativeStatus(
         .attr('stroke', 'transparent')
         .attr('stroke-width', Math.max(6, Math.round(16 / (edge.parallelCount ?? 1))));
 
-      edgeG
+      const edgePath = edgeG
         .append('path')
         .attr('d', pathD)
         .attr('fill', 'none')
@@ -1000,6 +1034,11 @@ export function renderInitiativeStatus(
         .attr('stroke-width', EDGE_STROKE_WIDTH)
         .attr('marker-end', `url(#${markerId})`)
         .attr('class', 'is-edge');
+
+      // Dashed stroke for 'todo' edges
+      if (edge.status === 'todo') {
+        edgePath.attr('stroke-dasharray', '6 3');
+      }
     }
 
     // Edge label placed on its own path
@@ -1072,6 +1111,18 @@ export function renderInitiativeStatus(
     const stroke = nodeStroke(node.status, palette, isDark);
     renderNodeShape(nodeG, node.shape, node.width, node.height, fill, stroke);
 
+    // Apply dashed border for 'todo' status
+    if (node.status === 'todo') {
+      nodeG.selectAll('rect, ellipse, polygon, circle')
+        .each(function () {
+          const el = d3Selection.select(this);
+          // Only dash stroked elements (not fills or transparent hit areas)
+          if (el.attr('stroke') && el.attr('stroke') !== 'none' && el.attr('stroke') !== 'transparent') {
+            el.attr('stroke-dasharray', '6 3');
+          }
+        });
+    }
+
     const textColor = contrastText(fill, '#eceff4', '#2e3440');
 
     // Label placement: actors put label below the figure, others center inside

package/src/initiative-status/types.ts

@@ -6,9 +6,16 @@ import type { DgmoError } from '../diagnostics';
 import type { ParticipantType } from '../sequence/parser';
 import type { TagGroup } from '../utils/tag-groups';
 
-export type InitiativeStatus = 'done' | 'wip' | 'todo' | 'na' | null;
+export type InitiativeStatus = 'done' | 'doing' | 'blocked' | 'todo' | 'na' | null;
 
-export const VALID_STATUSES: readonly string[] = ['done', 'wip', 'todo', 'na'];
+export const VALID_STATUSES: readonly string[] = ['done', 'doing', 'blocked', 'todo', 'na'];
+
+/** Aliases that map to canonical status values during parsing. */
+export const STATUS_ALIASES: Record<string, string> = {
+  wip: 'doing',
+  paused: 'blocked',
+  waiting: 'blocked',
+};
 
 export interface ISNode {
   label: string;
@@ -31,6 +38,7 @@ export interface ISGroup {
   label: string;
   nodeLabels: string[];
   lineNumber: number;
+  metadata?: Record<string, string>;
 }
 
 export interface ParsedInitiativeStatus {