maestro-flow 0.3.12 → 0.3.13

package/dist/src/hooks/statusline.js

@@ -1,55 +1,27 @@
 /**
- * Maestro Statusline Hook — Powerline × Notion style
+ * Maestro Statusline Hook — Two-line colored text
  *
- * Renders a Nerd-Font Powerline statusline with muted Notion-inspired colors.
- * Segments are conditionally shown — empty segments are omitted for a clean line.
- *
- * Segments (left → right):
- *   Model | Phase | Coordinator | Task | Team | Directory+Git | Context bar
+ * Line 1: Model | Coordinator | Task | Team | Dir+Git | Context
+ * Line 2: Milestone ◆Phase | Session chain (ANL-001→PLN-001→EXC-001→VRF-001 ✓)
  *
  * Input (stdin JSON from Claude Code):
  *   { model, workspace, session_id, context_window }
  *
- * Output (stdout): formatted Powerline string
+ * Output (stdout): formatted ANSI string (1 or 2 lines)
  */
 import { readFileSync, readdirSync, statSync, existsSync, writeFileSync } from 'node:fs';
 import { join, basename } from 'node:path';
 import { homedir, tmpdir } from 'node:os';
 import { execSync } from 'node:child_process';
-import { AUTO_COMPACT_BUFFER_PCT, BRIDGE_PREFIX, ANSI_RESET, ANSI_BOLD, PL_SEP, ICONS, GIT_ICONS, SEGMENT_BG, SEGMENT_FG, TEXT_COLORS, ansiBg, ansiFg, getCtxLevel, getStatuslineStyle, } from './constants.js';
+import { AUTO_COMPACT_BUFFER_PCT, BRIDGE_PREFIX, ANSI_RESET, ICONS, GIT_ICONS, TEXT_COLORS, ansiFg, getCtxLevel, } from './constants.js';
 import { readCoordBridge } from './coordinator-tracker.js';
 import { resolveSelf } from '../tools/team-members.js';
 import { readRecentActivity } from '../tools/team-activity.js';
 import { findWorkspaceRoot } from './workspace.js';
 // ---------------------------------------------------------------------------
-// Renderers
+// Renderer
 // ---------------------------------------------------------------------------
-/**
- * Powerline mode: colored background segments with arrow separators.
- * Separator uses bold ANSI to make the V-chevron more prominent.
- */
-function renderPowerline(segments) {
-    if (segments.length === 0)
-        return '';
-    let out = '';
-    for (let i = 0; i < segments.length; i++) {
-        const seg = segments[i];
-        out += ansiBg(seg.bg) + ansiFg(seg.fg) + ` ${seg.text} `;
-        if (i < segments.length - 1) {
-            // Bold separator: fg = current bg, bg = next bg → Powerline dovetail
-            out += ANSI_BOLD + ansiFg(seg.bg) + ansiBg(segments[i + 1].bg) + PL_SEP + ANSI_RESET;
-        }
-        else {
-            // Last segment: arrow fades into terminal background
-            out += ANSI_RESET + ANSI_BOLD + ansiFg(seg.bg) + PL_SEP + ANSI_RESET;
-        }
-    }
-    return out;
-}
-/**
- * Colored-text mode: colored text on transparent background, pipe separators.
- * Similar style to CCometixLine reference.
- */
+/** Colored text on transparent background, pipe separators */
 function renderColoredText(segments) {
     if (segments.length === 0)
         return '';
@@ -65,26 +37,26 @@ function renderColoredText(segments) {
 // ---------------------------------------------------------------------------
 // Context usage
 // ---------------------------------------------------------------------------
-/** Normalize remaining% to usable context (accounts for autocompact buffer) */
 function normalizeUsage(remaining) {
     const usableRemaining = Math.max(0, ((remaining - AUTO_COMPACT_BUFFER_PCT) / (100 - AUTO_COMPACT_BUFFER_PCT)) * 100);
     return Math.max(0, Math.min(100, Math.round(100 - usableRemaining)));
 }
-/** Build context bar text: "icon ██████░░░░ 62%" */
 function buildContextText(usedPct) {
     const filled = Math.floor(usedPct / 10);
     const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(10 - filled);
     return `${ICONS.ctx} ${bar} ${usedPct}%`;
 }
-/** Get context segment colors by level */
-function getCtxColors(level) {
-    const map = {
-        ok: { bg: SEGMENT_BG.ctxOk, fg: SEGMENT_FG.ctxOk },
-        warn: { bg: SEGMENT_BG.ctxWarn, fg: SEGMENT_FG.ctxWarn },
-        alert: { bg: SEGMENT_BG.ctxAlert, fg: SEGMENT_FG.ctxAlert },
-        crit: { bg: SEGMENT_BG.ctxCrit, fg: SEGMENT_FG.ctxCrit },
-    };
-    return map[level];
+/** Format token count: 1234 → "1.2k", 123456 → "123k" */
+function formatTokens(n) {
+    if (n < 1000)
+        return String(n);
+    if (n < 10000)
+        return (n / 1000).toFixed(1) + 'k';
+    return Math.round(n / 1000) + 'k';
+}
+/** Build token usage text: "↑12k ↓3k Σ15k" */
+function buildTokenText(input, output) {
+    return `↑${formatTokens(input)} ↓${formatTokens(output)} Σ${formatTokens(input + output)}`;
 }
 // ---------------------------------------------------------------------------
 // Bridge
@@ -107,7 +79,6 @@ function writeBridge(session, remaining, usedPct) {
 // ---------------------------------------------------------------------------
 // Data readers
 // ---------------------------------------------------------------------------
-/** Read current in-progress task from Claude Code todos */
 function readCurrentTask(session) {
     const claudeDir = process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
     const todosDir = join(claudeDir, 'todos');
@@ -133,8 +104,63 @@ function readCurrentTask(session) {
 const emptyWf = {
     milestone: '', currentPhase: 0, currentStep: 0, status: '',
     total: 0, completed: 0, inProgress: 0, planned: 0, workspaceRoot: '',
+    chains: [], orphans: [], currentTaskId: '',
 };
-/** Read milestone + phase progress from .workflow/state.json */
+/**
+ * Build dependency chains from artifacts.
+ * Walk depends_on links: find roots (no depends_on), then follow forward.
+ */
+function buildChains(artifacts) {
+    if (artifacts.length === 0)
+        return { chains: [], orphans: [] };
+    const byId = new Map();
+    for (const a of artifacts)
+        byId.set(a.id, a);
+    // Build forward map: parent → children
+    const children = new Map();
+    const hasParent = new Set();
+    for (const a of artifacts) {
+        const deps = a.depends_on;
+        if (!deps)
+            continue;
+        const depIds = Array.isArray(deps) ? deps : [deps];
+        for (const depId of depIds) {
+            if (byId.has(depId)) {
+                hasParent.add(a.id);
+                const existing = children.get(depId) || [];
+                existing.push(a.id);
+                children.set(depId, existing);
+            }
+        }
+    }
+    // Roots: artifacts with no parent in this set
+    const roots = artifacts.filter(a => !hasParent.has(a.id));
+    const visited = new Set();
+    const chains = [];
+    for (const root of roots) {
+        if (visited.has(root.id))
+            continue;
+        const chain = [];
+        let current = root.id;
+        while (current && !visited.has(current)) {
+            visited.add(current);
+            const art = byId.get(current);
+            if (art)
+                chain.push(art);
+            // Follow first child (linear chain)
+            const kids = children.get(current);
+            current = kids?.[0];
+        }
+        if (chain.length > 0) {
+            const allCompleted = chain.every(a => a.status === 'completed');
+            chains.push({ artifacts: chain, allCompleted });
+        }
+    }
+    // Orphans: not visited by any chain walk
+    const orphans = artifacts.filter(a => !visited.has(a.id));
+    return { chains, orphans };
+}
+/** Read milestone + artifact chains from .workflow/state.json */
 function readWorkflowState(dir) {
     const root = findWorkspaceRoot(dir);
     if (!root)
@@ -147,13 +173,67 @@ function readWorkflowState(dir) {
         const result = { ...emptyWf, workspaceRoot: root };
         if (state.current_milestone)
             result.milestone = state.current_milestone;
-        if (state.current_phase)
-            result.currentPhase = state.current_phase;
-        if (state.current_step)
-            result.currentStep = state.current_step;
         if (state.status)
             result.status = state.status;
-        if (state.phases_summary) {
+        const rawArtifacts = Array.isArray(state.artifacts) ? state.artifacts : [];
+        const milestone = Array.isArray(state.milestones)
+            ? state.milestones.find((m) => m.name === state.current_milestone || m.id === state.current_milestone)
+            : null;
+        const phases = milestone?.phases ?? [];
+        // Filter to current milestone artifacts
+        const msArtifacts = rawArtifacts
+            .filter(a => a.milestone === state.current_milestone && a.id && a.type && a.status)
+            .map(a => ({
+            id: a.id,
+            type: a.type,
+            status: a.status,
+            phase: a.phase ?? null,
+            path: a.path ?? '',
+            depends_on: a.depends_on ?? null,
+        }));
+        if (phases.length > 0 && msArtifacts.length > 0) {
+            result.total = phases.length;
+            let completed = 0, inProgress = 0, planned = 0;
+            for (const p of phases) {
+                const phaseArts = msArtifacts.filter(a => a.phase === p);
+                if (phaseArts.some(a => a.type === 'execute' && a.status === 'completed')) {
+                    completed++;
+                    continue;
+                }
+                if (phaseArts.some(a => a.type === 'plan' && a.status === 'completed')) {
+                    planned++;
+                    inProgress++;
+                    continue;
+                }
+                if (phaseArts.length > 0) {
+                    inProgress++;
+                }
+            }
+            result.completed = completed;
+            result.inProgress = inProgress;
+            result.planned = planned;
+            // Current phase
+            for (const p of phases) {
+                if (msArtifacts.some(a => a.phase === p && a.status === 'in_progress')) {
+                    result.currentPhase = p;
+                    break;
+                }
+            }
+            if (!result.currentPhase) {
+                for (const p of phases) {
+                    if (!msArtifacts.some(a => a.type === 'execute' && a.phase === p && a.status === 'completed')) {
+                        result.currentPhase = p;
+                        break;
+                    }
+                }
+            }
+            // Build chains
+            const { chains, orphans } = buildChains(msArtifacts);
+            result.chains = chains;
+            result.orphans = orphans;
+        }
+        else if (state.phases_summary) {
+            // v1 fallback
             const s = state.phases_summary;
             if (typeof s.total === 'number')
                 result.total = s.total;
@@ -161,17 +241,13 @@ function readWorkflowState(dir) {
                 result.completed = s.completed;
             if (typeof s.in_progress === 'number')
                 result.inProgress = s.in_progress;
+            if (state.current_phase)
+                result.currentPhase = state.current_phase;
         }
-        // Count how many phases have plan artifacts
-        if (result.total > 0) {
-            let planned = 0;
-            for (let p = 1; p <= result.total; p++) {
-                const planPath = join(root, '.workflow', 'scratch', `P${p}`, 'plan.json');
-                if (existsSync(planPath))
-                    planned++;
-            }
-            result.planned = planned;
-        }
+        if (state.current_step)
+            result.currentStep = state.current_step;
+        if (state.current_task_id)
+            result.currentTaskId = state.current_task_id;
         return result;
     }
     catch {
@@ -207,21 +283,20 @@ function readGitInfo(dir) {
     }
 }
 function formatGitSuffix(git) {
-    let status = '';
+    const parts = [];
     if (git.conflict)
-        status += GIT_ICONS.conflict;
+        parts.push(GIT_ICONS.conflict);
     else if (git.dirty)
-        status += GIT_ICONS.dirty;
-    else
-        status += GIT_ICONS.clean;
+        parts.push(GIT_ICONS.dirty);
     if (git.ahead > 0)
-        status += `${GIT_ICONS.ahead}${git.ahead}`;
+        parts.push(`${GIT_ICONS.ahead}${git.ahead}`);
     if (git.behind > 0)
-        status += `${GIT_ICONS.behind}${git.behind}`;
-    return `${ICONS.git} ${git.branch} ${status}`;
+        parts.push(`${GIT_ICONS.behind}${git.behind}`);
+    const suffix = parts.length > 0 ? ` ${parts.join('')}` : '';
+    return `${ICONS.git} ${git.branch}${suffix}`;
 }
 // ---------------------------------------------------------------------------
-// Teammate activity segment (team-lite Wave 3B)
+// Teammate activity segment
 // ---------------------------------------------------------------------------
 const TEAM_CACHE_TTL_MS = 10_000;
 const TEAM_WINDOW_MIN = 30;
@@ -231,30 +306,23 @@ function teamCachePath(session) {
 }
 function writeTeamCache(path, segment) {
     try {
-        const data = { ts: Date.now(), segment };
-        writeFileSync(path, JSON.stringify(data));
-    }
-    catch {
-        // Best-effort
+        writeFileSync(path, JSON.stringify({ ts: Date.now(), segment }));
     }
+    catch { /* best-effort */ }
     return segment;
 }
 function shortTaskId(taskId) {
     const idx = taskId.lastIndexOf('-');
-    if (idx < 0)
-        return taskId;
-    return taskId.slice(idx + 1) || taskId;
+    return idx < 0 ? taskId : (taskId.slice(idx + 1) || taskId);
 }
 function formatTeammate(name, evt) {
     if (typeof evt.phase_id === 'number' && typeof evt.task_id === 'string' && evt.task_id) {
         return `${name} (P${evt.phase_id}/${shortTaskId(evt.task_id)})`;
     }
-    if (typeof evt.phase_id === 'number') {
+    if (typeof evt.phase_id === 'number')
         return `${name} (P${evt.phase_id})`;
-    }
-    if (typeof evt.target === 'string' && evt.target) {
+    if (typeof evt.target === 'string' && evt.target)
         return `${name} (${evt.target})`;
-    }
     return name;
 }
 export function buildTeamSegment(session) {
@@ -263,16 +331,11 @@ export function buildTeamSegment(session) {
         if (existsSync(cachePath)) {
             try {
                 const cached = JSON.parse(readFileSync(cachePath, 'utf8'));
-                if (cached &&
-                    typeof cached.ts === 'number' &&
-                    typeof cached.segment === 'string' &&
-                    Date.now() - cached.ts < TEAM_CACHE_TTL_MS) {
+                if (cached && typeof cached.ts === 'number' && typeof cached.segment === 'string' && Date.now() - cached.ts < TEAM_CACHE_TTL_MS) {
                     return cached.segment;
                 }
             }
-            catch {
-                // Corrupt cache — recompute
-            }
+            catch { /* corrupt cache */ }
         }
         const self = resolveSelf();
         if (!self)
@@ -294,9 +357,8 @@ export function buildTeamSegment(session) {
             }
             const prevT = Date.parse(prev.ts);
             const curT = Date.parse(evt.ts);
-            if (!Number.isNaN(curT) && (Number.isNaN(prevT) || curT >= prevT)) {
+            if (!Number.isNaN(curT) && (Number.isNaN(prevT) || curT >= prevT))
                 latest.set(key, evt);
-            }
         }
         if (latest.size === 0)
             return writeTeamCache(cachePath, '');
@@ -305,13 +367,12 @@ export function buildTeamSegment(session) {
             const tb = Date.parse(b.ts);
             return (Number.isNaN(tb) ? 0 : tb) - (Number.isNaN(ta) ? 0 : ta);
         });
-        const inline = ordered.slice(0, TEAM_MAX_INLINE).map((evt) => formatTeammate(evt.user, evt));
+        const inline = ordered.slice(0, TEAM_MAX_INLINE).map(evt => formatTeammate(evt.user, evt));
         let body = inline.join(' | ');
         const extra = ordered.length - inline.length;
         if (extra > 0)
             body += ` +${extra}`;
-        const segment = `\u{1F465} ${body}`;
-        return writeTeamCache(cachePath, segment);
+        return writeTeamCache(cachePath, `\u{1F465} ${body}`);
     }
     catch {
         return '';
@@ -333,7 +394,6 @@ export function buildCoordinatorSegment(session) {
         const isPaused = status === 'paused' || status === 'step_paused';
         const progress = isPaused ? 'P' : `${steps_completed}/${steps_total}`;
         const stepLabel = current_step?.skill ?? '';
-        // chain_name → stepLabel [progress]
         const parts = [];
         if (chain_name)
             parts.push(chain_name);
@@ -346,9 +406,73 @@ export function buildCoordinatorSegment(session) {
     }
 }
 // ---------------------------------------------------------------------------
+// Chain renderer — session chain for line 2+
+// ---------------------------------------------------------------------------
+/** Type abbreviation and color */
+const TYPE_META = {
+    analyze: { abbr: 'A', color: TEXT_COLORS.model },
+    plan: { abbr: 'P', color: TEXT_COLORS.milestone },
+    execute: { abbr: 'E', color: TEXT_COLORS.phase },
+    verify: { abbr: 'V', color: TEXT_COLORS.coord },
+    brainstorm: { abbr: 'B', color: TEXT_COLORS.team },
+    spec: { abbr: 'S', color: TEXT_COLORS.dir },
+    review: { abbr: 'R', color: TEXT_COLORS.ctxAlert },
+    debug: { abbr: 'D', color: TEXT_COLORS.ctxCrit },
+    test: { abbr: 'T', color: TEXT_COLORS.ctxOk },
+};
+/** Color a type abbreviation */
+function colorType(type) {
+    const meta = TYPE_META[type] ?? { abbr: type[0]?.toUpperCase() ?? '?', color: TEXT_COLORS.task };
+    return ansiFg(meta.color) + meta.abbr + ANSI_RESET;
+}
+/** Extract readable slug from artifact path */
+function extractSlug(art) {
+    const b = basename(art.path || '');
+    // scratch/analyze-auth-2026-04-20 → auth
+    // phases/01-auth-multi-tenant → auth-multi-tenant
+    // scratch/20260421-review-P1-auth → auth
+    return b
+        .replace(/^\d+-/, '') // leading number prefix
+        .replace(/^\d{8}-/, '') // YYYYMMDD- prefix
+        .replace(/^(analyze|plan|execute|verify|brainstorm|spec|review|debug|test)-/, '') // type prefix
+        .replace(/-\d{4}-\d{2}-\d{2}$/, '') // trailing date
+        .replace(/-P\d+/, '') // -P1, -P2
+        || art.type;
+}
+/** Status suffix */
+function statusSuffix(status) {
+    const map = {
+        completed: { icon: '✓', color: TEXT_COLORS.ctxOk },
+        in_progress: { icon: '●', color: TEXT_COLORS.ctxWarn },
+        failed: { icon: '✗', color: TEXT_COLORS.ctxCrit },
+        pending: { icon: '○', color: TEXT_COLORS.separator },
+    };
+    const s = map[status];
+    return s ? ansiFg(s.color) + s.icon + ANSI_RESET : '';
+}
+/** Render chain: auth: A→P→E→R→D→T→V ✓ */
+function renderChain(chain) {
+    const arrow = ansiFg(TEXT_COLORS.separator) + '→' + ANSI_RESET;
+    const slug = extractSlug(chain.artifacts[0]);
+    const types = chain.artifacts.map(a => colorType(a.type));
+    const lastArt = chain.artifacts[chain.artifacts.length - 1];
+    const slugLabel = ansiFg(TEXT_COLORS.task) + slug + ANSI_RESET;
+    const flow = types.join(arrow);
+    const suffix = chain.allCompleted
+        ? ' ' + ansiFg(TEXT_COLORS.ctxOk) + '✓' + ANSI_RESET
+        : ' ' + statusSuffix(lastArt.status);
+    return `${slugLabel} ${flow}${suffix}`;
+}
+/** Render orphan: brainstorm-ux B ✓ */
+function renderOrphan(art) {
+    const slug = extractSlug(art);
+    const slugLabel = ansiFg(TEXT_COLORS.task) + slug + ANSI_RESET;
+    return `${slugLabel} ${colorType(art.type)} ${statusSuffix(art.status)}`;
+}
+// ---------------------------------------------------------------------------
 // Main formatter
 // ---------------------------------------------------------------------------
-/** Main statusline handler — processes input and returns Powerline string */
+/** Main statusline handler — two-line output */
 export function formatStatusline(data) {
     const model = data.model?.display_name || 'Claude';
     const dir = data.workspace?.current_dir || process.cwd();
@@ -366,98 +490,76 @@ export function formatStatusline(data) {
         if (session)
             writeBridge(session, remaining, usedPct);
     }
-    // ---- Build segments ----
+    // ---- Line 1: Model | Coord | Task | Team | Dir+Git | Context ----
     const segments = [];
-    // 1. Model
-    segments.push({
-        key: 'model',
-        text: `${ICONS.model} ${model}`,
-        bg: SEGMENT_BG.model,
-        fg: SEGMENT_FG.model,
-    });
-    // 2. Milestone (conditional — shown when workflow has milestones)
-    if (wf.milestone) {
-        let msText = `${ICONS.milestone} ${wf.milestone}`;
-        if (wf.total > 0)
-            msText += ` ${wf.completed}/${wf.total}`;
-        segments.push({
-            key: 'milestone',
-            text: msText,
-            bg: SEGMENT_BG.milestone,
-            fg: SEGMENT_FG.milestone,
-        });
-    }
-    // 3. Phase (conditional — shows current phase + status detail)
-    if (wf.currentPhase) {
-        let phaseText = `${ICONS.phase} P${wf.currentPhase}`;
-        if (wf.currentStep)
-            phaseText += `.${wf.currentStep}`;
-        const tags = [];
-        if (wf.planned > 0)
-            tags.push(`${wf.planned}plan`);
-        if (wf.inProgress > 0)
-            tags.push(`${wf.inProgress}run`);
-        if (tags.length > 0)
-            phaseText += ` [${tags.join(' ')}]`;
-        segments.push({
-            key: 'phase',
-            text: phaseText,
-            bg: SEGMENT_BG.phase,
-            fg: SEGMENT_FG.phase,
-        });
-    }
-    // 4. Coordinator + chain (conditional)
-    if (coord) {
-        segments.push({
-            key: 'coord',
-            text: `${ICONS.coord} ${coord}`,
-            bg: SEGMENT_BG.coord,
-            fg: SEGMENT_FG.coord,
-        });
-    }
-    // 5. Task (conditional)
-    if (task) {
-        segments.push({
-            key: 'task',
-            text: `${ICONS.task} ${task}`,
-            bg: SEGMENT_BG.task,
-            fg: SEGMENT_FG.task,
-        });
-    }
-    // 6. Team (conditional)
-    if (team) {
-        segments.push({
-            key: 'team',
-            text: `${ICONS.team} ${team}`,
-            bg: SEGMENT_BG.team,
-            fg: SEGMENT_FG.team,
-        });
-    }
-    // 7. Directory + Git
+    segments.push({ key: 'model', text: `${ICONS.model} ${model}` });
+    if (coord)
+        segments.push({ key: 'coord', text: `${ICONS.coord} ${coord}` });
+    if (task)
+        segments.push({ key: 'task', text: `${ICONS.task} ${task}` });
+    if (team)
+        segments.push({ key: 'team', text: `${ICONS.team} ${team}` });
     let dirText = `${ICONS.dir} ${basename(dir)}`;
     if (git)
         dirText += `  ${formatGitSuffix(git)}`;
-    segments.push({
-        key: 'dir',
-        text: dirText,
-        bg: SEGMENT_BG.dir,
-        fg: SEGMENT_FG.dir,
-    });
-    // 8. Context bar (conditional — only when data available)
+    segments.push({ key: 'dir', text: dirText });
+    // Token usage + lines changed
+    const inputTokens = data.context_window?.total_input_tokens;
+    const outputTokens = data.context_window?.total_output_tokens;
+    const linesAdded = data.cost?.total_lines_added ?? 0;
+    const linesRemoved = data.cost?.total_lines_removed ?? 0;
+    const statParts = [];
+    if (inputTokens != null && outputTokens != null && (inputTokens > 0 || outputTokens > 0)) {
+        statParts.push(buildTokenText(inputTokens, outputTokens));
+    }
+    if (linesAdded > 0 || linesRemoved > 0) {
+        const added = ansiFg(TEXT_COLORS.ctxOk) + `+${linesAdded}` + ANSI_RESET;
+        const removed = ansiFg(TEXT_COLORS.ctxCrit) + `-${linesRemoved}` + ANSI_RESET;
+        statParts.push(`${added} ${removed}`);
+    }
+    if (statParts.length > 0) {
+        segments.push({ key: 'task', text: statParts.join(' ') });
+    }
+    // Context bar
     if (remaining != null) {
         const level = getCtxLevel(usedPct);
-        const colors = getCtxColors(level);
         const ctxKey = `ctx${level.charAt(0).toUpperCase()}${level.slice(1)}`;
-        segments.push({
-            key: ctxKey,
-            text: buildContextText(usedPct),
-            bg: colors.bg,
-            fg: colors.fg,
-        });
+        segments.push({ key: ctxKey, text: buildContextText(usedPct) });
+    }
+    const line1 = renderColoredText(segments);
+    // ---- Line 2: Milestone ◆Phase | Session chains (conditional) ----
+    if (!wf.milestone)
+        return line1;
+    const sep = ansiFg(TEXT_COLORS.separator) + ' | ' + ANSI_RESET;
+    const dot = ansiFg(TEXT_COLORS.separator) + ' · ' + ANSI_RESET;
+    // Milestone + phase header
+    let header = ansiFg(TEXT_COLORS.milestone) + `${ICONS.milestone} ${wf.milestone}` + ANSI_RESET;
+    if (wf.total > 0)
+        header += ansiFg(TEXT_COLORS.milestone) + ` ${wf.completed}/${wf.total}` + ANSI_RESET;
+    if (wf.currentPhase)
+        header += ' ' + ansiFg(TEXT_COLORS.phase) + `${ICONS.phase} P${wf.currentPhase}` + ANSI_RESET;
+    // Session chains
+    const chainParts = [];
+    for (const chain of wf.chains) {
+        chainParts.push(renderChain(chain));
+    }
+    for (const orphan of wf.orphans) {
+        chainParts.push(renderOrphan(orphan));
+    }
+    if (chainParts.length === 0) {
+        return line1 + '\n' + header;
+    }
+    // Auto multi-line: ≤2 chains → single line, >2 → one chain per line
+    if (chainParts.length <= 2) {
+        const line2 = header + sep + chainParts.join(dot);
+        return line1 + '\n' + line2;
+    }
+    // Multi-line: header on line 2, each chain on its own line
+    const lines = [line1, header];
+    for (const part of chainParts) {
+        lines.push('  ' + part);
     }
-    // ---- Render ----
-    const style = getStatuslineStyle();
-    return style === 'powerline' ? renderPowerline(segments) : renderColoredText(segments);
+    return lines.join('\n');
 }
 /** Entry point — reads stdin JSON, writes formatted statusline to stdout */
 export function runStatusline() {