dw-kit 1.3.6 → 1.6.0-rc.1

package/src/commands/task-new.mjs

@@ -0,0 +1,90 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import chalk from 'chalk';
+import { logEvent } from '../lib/telemetry.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const TASKS_DIR = '.dw/tasks';
+const TEMPLATE_REL = join('.dw', 'core', 'templates', 'v3', 'task.md');
+const BUNDLED_TEMPLATE = join(__dirname, '..', '..', '.dw', 'core', 'templates', 'v3', 'task.md');
+
+function todayIso() {
+  return new Date().toISOString().slice(0, 10);
+}
+
+function slugify(name) {
+  return name
+    .toLowerCase()
+    .trim()
+    .replace(/[^a-z0-9-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .replace(/-{2,}/g, '-')
+    .slice(0, 64);
+}
+
+function loadTemplate(rootDir) {
+  const local = join(rootDir, TEMPLATE_REL);
+  if (existsSync(local)) return readFileSync(local, 'utf8');
+  if (existsSync(BUNDLED_TEMPLATE)) return readFileSync(BUNDLED_TEMPLATE, 'utf8');
+  throw new Error(`v3 template not found at ${local} or ${BUNDLED_TEMPLATE}`);
+}
+
+export async function taskNewCommand(taskName, opts = {}) {
+  const rootDir = process.cwd();
+  if (!taskName) {
+    console.error(chalk.red('✗ Task name required.'));
+    console.error(chalk.dim('  Usage: dw task new <task-name> [--depth quick|standard|thorough] [--title "..."]'));
+    process.exit(1);
+  }
+
+  const slug = slugify(taskName);
+  if (!slug) {
+    console.error(chalk.red('✗ Invalid task name (empty after slugify).'));
+    process.exit(1);
+  }
+
+  const taskDir = join(rootDir, TASKS_DIR, slug);
+  if (existsSync(taskDir)) {
+    console.error(chalk.red(`✗ Task folder already exists: ${taskDir}`));
+    console.error(chalk.dim('  Pick a different name or remove the existing folder first.'));
+    process.exit(1);
+  }
+
+  const template = loadTemplate(rootDir);
+  const today = todayIso();
+  const title = opts.title || taskName;
+  const depth = opts.depth || 'standard';
+  const owner = opts.owner || process.env.DW_OWNER || process.env.USER || process.env.USERNAME || 'unknown';
+  const relatedAdr = opts.adr || 'none';
+  const targetShip = opts.target || 'TBD';
+
+  let filled = template
+    .replace('task_id: {task-name}', `task_id: ${slug}`)
+    .replace('created: {YYYY-MM-DD}', `created: "${today}"`)
+    .replace('last_updated: {YYYY-MM-DD}', `last_updated: "${today}"`)
+    .replace('phase: {free-form phase description}', `phase: Draft`)
+    .replace('owner: {name}', `owner: ${owner}`)
+    .replace('depth: quick | standard | thorough', `depth: ${depth}`)
+    .replace('related_adr: {ADR-NNNN | none}', `related_adr: ${relatedAdr}`)
+    .replace('target_ship: {milestone or TBD}', `target_ship: ${targetShip}`);
+
+  filled = filled.replace('# Timeline: {Task Title}', `# Timeline: ${title}`);
+
+  mkdirSync(taskDir, { recursive: true });
+  const target = join(taskDir, 'task.md');
+  writeFileSync(target, filled, 'utf8');
+
+  logEvent({ event: 'task', action: 'new', name: slug, depth }, rootDir);
+
+  console.log();
+  console.log(chalk.green('✓') + ` Created v3 task: ${chalk.cyan(slug)}`);
+  console.log(`  ${chalk.dim(target)}`);
+  console.log();
+  console.log(chalk.bold('  Next steps:'));
+  console.log(`    1. Fill in Section 2 (Intent & Scope) — subtasks, success criteria`);
+  console.log(`    2. ${chalk.cyan('dw task show ' + slug)}  — view snapshot`);
+  console.log(`    3. ${chalk.cyan('dw active')}              — refresh ACTIVE.md index`);
+  console.log();
+}

package/src/commands/task-render.mjs

@@ -0,0 +1,235 @@
+import { readFileSync, writeFileSync, existsSync, statSync, readdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import chalk from 'chalk';
+import { parseFrontmatter } from '../lib/frontmatter.mjs';
+import { parseTimeline, parseSubtaskTracker } from '../lib/timeline-parser.mjs';
+import { logEvent } from '../lib/telemetry.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const require = createRequire(import.meta.url);
+const TASKS_DIR = '.dw/tasks';
+
+function findV3Tasks(rootDir) {
+  const tasksRoot = join(rootDir, TASKS_DIR);
+  if (!existsSync(tasksRoot)) return [];
+  return readdirSync(tasksRoot)
+    .filter((e) => e !== 'archive' && e !== 'ACTIVE.md')
+    .map((e) => ({ name: e, path: join(tasksRoot, e) }))
+    .filter((e) => {
+      try { return statSync(e.path).isDirectory() && existsSync(join(e.path, 'task.md')); }
+      catch { return false; }
+    });
+}
+
+function extractManifest(taskDir) {
+  const timelineFile = join(taskDir, 'task.md');
+  if (!existsSync(timelineFile)) return null;
+  const content = readFileSync(timelineFile, 'utf8');
+  const fm = parseFrontmatter(content);
+  const parsed = parseTimeline(content);
+  const subtasks = parseSubtaskTracker(parsed.sections[3]?.text);
+
+  return {
+    task_id: fm.task_id || taskDir.split(/[\\/]/).pop(),
+    title: parsed.title || fm.task_id,
+    status: fm.status || 'Draft',
+    phase: fm.phase || '',
+    owner: fm.owner || '',
+    blockers: fm.blockers || 'none',
+    last_updated: fm.last_updated || '',
+    related_adr: fm.related_adr || 'none',
+    depth: fm.depth || 'standard',
+    subtasks,
+    schema_version: 'task-manifest@v1',
+  };
+}
+
+function resolveRenderer() {
+  try {
+    const pkgPath = require.resolve('dw-kit-render/package.json', { paths: [process.cwd(), __dirname] });
+    const pkgDir = dirname(pkgPath);
+    return pkgDir;
+  } catch {
+    const localCandidate = join(__dirname, '..', '..', 'packages', 'dw-kit-render', 'package.json');
+    if (existsSync(localCandidate)) return dirname(localCandidate);
+    return null;
+  }
+}
+
+async function renderViaSubpackage(manifest, outFile, formats) {
+  const pkgDir = resolveRenderer();
+  if (!pkgDir) {
+    return { ok: false, reason: 'sub-package-absent' };
+  }
+  try {
+    const moduleUrl = pathToFileURL(join(pkgDir, 'src', 'index.mjs')).href;
+    const mod = await import(moduleUrl);
+    if (typeof mod.renderTimeline !== 'function') {
+      return { ok: false, reason: 'renderTimeline-not-exported' };
+    }
+    const result = await mod.renderTimeline({ task: manifest, outFile, formats });
+    return { ok: true, result };
+  } catch (e) {
+    return { ok: false, reason: 'render-error', error: e.message };
+  }
+}
+
+function buildMermaidFallback(manifest) {
+  const lines = ['```mermaid', 'gantt', `    title ${manifest.title || manifest.task_id}`, '    dateFormat YYYY-MM-DD', '    axisFormat %m-%d'];
+  const today = new Date().toISOString().slice(0, 10);
+  let section = 'section Subtasks';
+  lines.push(`    ${section}`);
+  const items = manifest.subtasks || [];
+  for (const s of items.slice(0, 20)) {
+    const status = (s.status || '').trim();
+    const taskName = (s.name || s.id || 'Subtask').replace(/[:|]/g, ' ').slice(0, 60);
+    const date = s.date && /^\d{4}-\d{2}-\d{2}$/.test(s.date) ? s.date : today;
+    const ganttStatus = status.startsWith('✅') ? 'done' : status.startsWith('🟡') ? 'active' : status.startsWith('🔴') ? 'crit' : '';
+    const tag = ganttStatus ? `${ganttStatus}, ` : '';
+    lines.push(`    ${taskName}    :${tag}${date}, 1d`);
+  }
+  lines.push('```');
+  return lines.join('\n');
+}
+
+function ensureSvgRefInSection1(content) {
+  if (content.includes('![Timeline](./timeline.svg)') && !content.includes('<!-- ![Timeline](./timeline.svg) -->')) {
+    return content;
+  }
+  const commented = '<!-- ![Timeline](./timeline.svg) -->';
+  if (content.includes(commented)) {
+    return content.replace(commented, '![Timeline](./timeline.svg)');
+  }
+  const sec1Match = content.match(/^## 1\. Snapshot$/m);
+  if (!sec1Match) return content;
+  const insertAt = sec1Match.index;
+  return content.slice(0, insertAt) + '![Timeline](./timeline.svg)\n\n' + content.slice(insertAt);
+}
+
+function ensureMermaidInSection4(content, mermaidBlock) {
+  const sec4Match = content.match(/^## 4\. Timeline \/ Changelog\s*$/m);
+  if (!sec4Match) return content;
+  const insertAt = sec4Match.index + sec4Match[0].length;
+  const afterHeader = content.slice(insertAt);
+  const existingMermaid = afterHeader.match(/```mermaid[\s\S]*?```/);
+  if (existingMermaid && existingMermaid.index < 500) {
+    const startAbs = insertAt + existingMermaid.index;
+    return content.slice(0, startAbs) + mermaidBlock + content.slice(startAbs + existingMermaid[0].length);
+  }
+  return content.slice(0, insertAt) + '\n\n' + mermaidBlock + '\n' + afterHeader;
+}
+
+async function renderOne(taskDir, opts) {
+  const manifest = extractManifest(taskDir);
+  if (!manifest) {
+    return { ok: false, reason: 'no-timeline' };
+  }
+
+  const timelineFile = join(taskDir, 'task.md');
+  const svgOutFile = join(taskDir, 'timeline.svg');
+
+  if (opts.dryRun) {
+    console.log(chalk.cyan(`  --- Dry run: ${taskDir} ---`));
+    console.log(chalk.dim('  Manifest:'));
+    console.log(JSON.stringify(manifest, null, 2).split('\n').map((l) => '    ' + l).join('\n'));
+    return { ok: true, dryRun: true };
+  }
+
+  let svgWritten = false;
+  let usedFallback = false;
+  let renderError = null;
+
+  if (!opts.mermaidOnly) {
+    const r = await renderViaSubpackage(manifest, svgOutFile, opts.formats || ['svg']);
+    if (r.ok) {
+      svgWritten = true;
+    } else {
+      renderError = r;
+      usedFallback = true;
+    }
+  } else {
+    usedFallback = true;
+  }
+
+  const currentMd = readFileSync(timelineFile, 'utf8');
+  let updatedMd = currentMd;
+
+  if (svgWritten) {
+    updatedMd = ensureSvgRefInSection1(updatedMd);
+  }
+
+  if (usedFallback || opts.alwaysMermaid) {
+    const mermaidBlock = buildMermaidFallback(manifest);
+    updatedMd = ensureMermaidInSection4(updatedMd, mermaidBlock);
+  }
+
+  if (updatedMd !== currentMd) {
+    writeFileSync(timelineFile, updatedMd, 'utf8');
+  }
+
+  logEvent({
+    event: 'task',
+    action: 'render.run',
+    name: manifest.task_id,
+    svg: svgWritten,
+    fallback: usedFallback,
+    error: renderError?.reason,
+  }, process.cwd());
+
+  return {
+    ok: true,
+    svgWritten,
+    usedFallback,
+    renderError,
+    svgPath: svgWritten ? svgOutFile : null,
+    timelineUpdated: updatedMd !== currentMd,
+  };
+}
+
+export async function taskRenderCommand(taskName, opts = {}) {
+  const rootDir = process.cwd();
+  let targets;
+  if (taskName) {
+    targets = [{ name: taskName, path: join(rootDir, TASKS_DIR, taskName) }];
+  } else {
+    targets = findV3Tasks(rootDir);
+    if (targets.length === 0) {
+      console.log(chalk.dim('  No v3 tasks to render.'));
+      return;
+    }
+  }
+
+  console.log();
+  console.log(chalk.bold(`  Render ${targets.length} task${targets.length === 1 ? '' : 's'}${opts.dryRun ? ' (dry-run)' : ''}`));
+
+  let svgCount = 0;
+  let fallbackCount = 0;
+
+  for (const t of targets) {
+    const r = await renderOne(t.path, opts);
+    if (!r.ok) {
+      console.log(chalk.red(`  ✗  ${t.name} — ${r.reason || 'failed'}`));
+      continue;
+    }
+    if (r.dryRun) continue;
+    if (r.svgWritten) {
+      console.log(chalk.green(`  ✓  ${t.name} — ${r.svgPath}${r.timelineUpdated ? ' (+ md updated)' : ''}`));
+      svgCount++;
+    } else if (r.usedFallback) {
+      const msg = r.renderError?.reason === 'sub-package-absent'
+        ? 'dw-kit-render absent → Mermaid fallback in Section 4'
+        : `render failed (${r.renderError?.reason}) → Mermaid fallback`;
+      console.log(chalk.yellow(`  ⚠  ${t.name} — ${msg}`));
+      fallbackCount++;
+    }
+  }
+
+  console.log();
+  if (svgCount) console.log(chalk.green(`  SVG: ${svgCount} task${svgCount === 1 ? '' : 's'} rendered`));
+  if (fallbackCount) console.log(chalk.yellow(`  Mermaid fallback: ${fallbackCount} task${fallbackCount === 1 ? '' : 's'}`));
+  if (!svgCount && !fallbackCount && !opts.dryRun) console.log(chalk.dim(`  No rendering performed`));
+  console.log();
+}

package/src/commands/task-rotate.mjs

@@ -0,0 +1,168 @@
+import { readFileSync, writeFileSync, existsSync, appendFileSync, statSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import chalk from 'chalk';
+import { parseTimeline } from '../lib/timeline-parser.mjs';
+import { logEvent } from '../lib/telemetry.mjs';
+
+const TASKS_DIR = '.dw/tasks';
+const SECTION_4_MAX_LINES = 400;
+const KEEP_RECENT_ENTRIES = 8;
+
+function findV3Tasks(rootDir) {
+  const tasksRoot = join(rootDir, TASKS_DIR);
+  if (!existsSync(tasksRoot)) return [];
+  return readdirSync(tasksRoot)
+    .filter((e) => e !== 'archive' && e !== 'ACTIVE.md')
+    .map((e) => ({ name: e, path: join(tasksRoot, e) }))
+    .filter((e) => {
+      try { return statSync(e.path).isDirectory() && existsSync(join(e.path, 'task.md')); }
+      catch { return false; }
+    });
+}
+
+function splitChangelogEntries(text) {
+  const lines = text.split('\n');
+  const entries = [];
+  let header = [];
+  let current = null;
+  let preEntries = [];
+  for (const line of lines) {
+    const heading = line.match(/^###\s+/);
+    if (heading) {
+      if (current) entries.push(current);
+      current = { headerLine: line, bodyLines: [] };
+    } else if (current) {
+      current.bodyLines.push(line);
+    } else {
+      preEntries.push(line);
+    }
+  }
+  if (current) entries.push(current);
+  return { preEntries, entries };
+}
+
+function rotateTimeline(taskDir, opts = {}) {
+  const timelineFile = join(taskDir, 'task.md');
+  if (!existsSync(timelineFile)) {
+    return { ok: false, reason: 'no-timeline' };
+  }
+
+  const content = readFileSync(timelineFile, 'utf8');
+  const parsed = parseTimeline(content);
+  const sec4 = parsed.sections[4];
+  if (!sec4) return { ok: false, reason: 'no-section-4' };
+
+  const lineCount = sec4.text.split('\n').length;
+  if (lineCount <= SECTION_4_MAX_LINES) {
+    return { ok: true, rotated: false, lineCount, reason: 'under-cap' };
+  }
+
+  const { preEntries, entries } = splitChangelogEntries(sec4.text);
+  if (entries.length <= KEEP_RECENT_ENTRIES) {
+    return { ok: true, rotated: false, lineCount, reason: 'few-entries' };
+  }
+
+  const keep = entries.slice(0, KEEP_RECENT_ENTRIES);
+  const rotated = entries.slice(KEEP_RECENT_ENTRIES);
+
+  const historyFile = join(taskDir, 'timeline-history.md');
+  const today = new Date().toISOString().slice(0, 10);
+
+  const historyChunk = [
+    `<!-- Auto-rotated from task.md Section 4 on ${today} -->`,
+    '',
+    ...rotated.map((e) => [e.headerLine, ...e.bodyLines].join('\n').trimEnd()),
+    '',
+  ].join('\n');
+
+  if (opts.dryRun) {
+    return {
+      ok: true,
+      rotated: true,
+      dryRun: true,
+      lineCount,
+      historyFile,
+      rotatedCount: rotated.length,
+      kept: keep.length,
+    };
+  }
+
+  if (existsSync(historyFile)) {
+    appendFileSync(historyFile, '\n' + historyChunk, 'utf8');
+  } else {
+    const header = [
+      `# Timeline History — ${parsed.title || taskDir.split(/[\\/]/).pop()}`,
+      '',
+      '<!-- Auto-rotated overflow from task.md Section 4. Newest entries at top. -->',
+      '',
+    ].join('\n');
+    writeFileSync(historyFile, header + historyChunk, 'utf8');
+  }
+
+  const newSec4Body = [
+    `> Older entries auto-rotated to [\`timeline-history.md\`](./timeline-history.md) on ${today} (kept last ${KEEP_RECENT_ENTRIES}).`,
+    '',
+    preEntries.join('\n').trim(),
+    '',
+    ...keep.map((e) => [e.headerLine, ...e.bodyLines].join('\n').trimEnd()),
+  ].join('\n');
+
+  const sec4Header = '## 4. Timeline / Changelog';
+  const sec4Index = content.indexOf(sec4Header);
+  const afterSec4 = content.slice(sec4Index + sec4Header.length);
+  const nextSecMatch = afterSec4.match(/^##\s+/m);
+  const sec4EndIdx = nextSecMatch ? sec4Index + sec4Header.length + nextSecMatch.index : content.length;
+
+  const newContent = content.slice(0, sec4Index + sec4Header.length) + '\n\n' + newSec4Body + '\n\n' + content.slice(sec4EndIdx);
+  writeFileSync(timelineFile, newContent, 'utf8');
+
+  return {
+    ok: true,
+    rotated: true,
+    lineCount,
+    historyFile,
+    rotatedCount: rotated.length,
+    kept: keep.length,
+  };
+}
+
+export async function taskRotateCommand(taskName, opts = {}) {
+  const rootDir = process.cwd();
+
+  let targets;
+  if (taskName) {
+    targets = [{ name: taskName, path: join(rootDir, TASKS_DIR, taskName) }];
+  } else {
+    targets = findV3Tasks(rootDir);
+  }
+
+  if (targets.length === 0) {
+    if (!opts.quiet) console.log(chalk.dim('  No v3 tasks to rotate.'));
+    return;
+  }
+
+  let rotatedCount = 0;
+  for (const t of targets) {
+    const r = rotateTimeline(t.path, opts);
+    if (r.rotated) {
+      rotatedCount++;
+      if (!opts.quiet) {
+        console.log(chalk.green(`  ✓  ${t.name} — rotated ${r.rotatedCount} entries to timeline-history.md (kept ${r.kept})`));
+      }
+      logEvent({
+        event: 'task',
+        action: 'rotate.run',
+        name: t.name,
+        rotated: r.rotatedCount,
+        kept: r.kept,
+        dry_run: !!opts.dryRun,
+      }, rootDir);
+    } else if (!opts.quiet && r.ok) {
+      console.log(chalk.dim(`  · ${t.name} — under cap (${r.lineCount} lines)`));
+    }
+  }
+
+  if (!opts.quiet && rotatedCount === 0) {
+    console.log(chalk.dim(`  No rotations needed (Section 4 cap: ${SECTION_4_MAX_LINES} lines).`));
+  }
+}

package/src/commands/task-show.mjs

@@ -0,0 +1,137 @@
+import { readFileSync, existsSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import chalk from 'chalk';
+import { parseFrontmatter } from '../lib/frontmatter.mjs';
+import { parseTimeline, parseSubtaskTracker } from '../lib/timeline-parser.mjs';
+import { logEvent } from '../lib/telemetry.mjs';
+
+const TASKS_DIR = '.dw/tasks';
+
+const STATUS_COLOR = {
+  Draft: chalk.gray,
+  Approved: chalk.cyan,
+  'In Progress': chalk.yellow,
+  Blocked: chalk.red,
+  Paused: chalk.magenta,
+  Done: chalk.green,
+};
+
+const TRACKER_GLYPH_COLOR = {
+  '⬜': chalk.gray,
+  '🟡': chalk.yellow,
+  '✅': chalk.green,
+  '🔴': chalk.red,
+  '⏸': chalk.magenta,
+};
+
+function colorStatus(status) {
+  const fn = STATUS_COLOR[status] || chalk.white;
+  return fn.bold(status);
+}
+
+function colorTrackerStatus(s) {
+  for (const [glyph, color] of Object.entries(TRACKER_GLYPH_COLOR)) {
+    if (s.startsWith(glyph)) return color(s);
+  }
+  return s;
+}
+
+function resolveTaskDir(taskName, rootDir) {
+  if (taskName) return join(rootDir, TASKS_DIR, taskName);
+  const tasksRoot = join(rootDir, TASKS_DIR);
+  if (!existsSync(tasksRoot)) return null;
+  const candidates = readdirSync(tasksRoot)
+    .filter((e) => e !== 'archive' && e !== 'ACTIVE.md')
+    .map((e) => ({
+      name: e,
+      path: join(tasksRoot, e),
+    }))
+    .filter((e) => {
+      try { return statSync(e.path).isDirectory() && existsSync(join(e.path, 'task.md')); }
+      catch { return false; }
+    });
+  if (candidates.length === 0) return null;
+  if (candidates.length === 1) return candidates[0].path;
+  candidates.sort((a, b) => statSync(b.path).mtimeMs - statSync(a.path).mtimeMs);
+  return candidates[0].path;
+}
+
+export async function taskShowCommand(taskName, opts = {}) {
+  const rootDir = process.cwd();
+  const taskDir = resolveTaskDir(taskName, rootDir);
+
+  if (!taskDir) {
+    console.error(chalk.red('✗ No v3 task found.'));
+    console.error(chalk.dim('  Pass a task name or run from a project with .dw/tasks/{name}/task.md'));
+    process.exit(1);
+  }
+
+  const timelineFile = join(taskDir, 'task.md');
+  if (!existsSync(timelineFile)) {
+    console.error(chalk.red(`✗ Not a v3 task (no task.md): ${taskDir}`));
+    console.error(chalk.dim('  Run `dw task migrate` to upgrade v2 spec+tracking to v3.'));
+    process.exit(1);
+  }
+
+  const content = readFileSync(timelineFile, 'utf8');
+  const fm = parseFrontmatter(content);
+  const parsed = parseTimeline(content);
+
+  const taskId = fm.task_id || taskDir.split(/[\\/]/).pop();
+  logEvent({ event: 'task', action: 'show', name: taskId }, rootDir);
+
+  const width = 60;
+  const hr = chalk.dim('─'.repeat(width));
+
+  console.log();
+  console.log(chalk.bold.cyan(`  ${parsed.title || taskId}`));
+  console.log(`  ${hr}`);
+
+  const statusLine = colorStatus(fm.status || 'unknown');
+  const phase = fm.phase ? chalk.dim(` · ${fm.phase}`) : '';
+  console.log(`  ${chalk.bold('Status:')} ${statusLine}${phase}`);
+
+  if (fm.owner) console.log(`  ${chalk.bold('Owner:')}  ${fm.owner}`);
+  if (fm.depth) console.log(`  ${chalk.bold('Depth:')}  ${fm.depth}`);
+  if (fm.related_adr && fm.related_adr !== 'none') {
+    console.log(`  ${chalk.bold('ADR:')}    ${chalk.cyan(fm.related_adr)}`);
+  }
+  if (fm.target_ship) console.log(`  ${chalk.bold('Target:')} ${fm.target_ship}`);
+  if (fm.last_updated) console.log(`  ${chalk.bold('Updated:')} ${fm.last_updated}`);
+  const blockers = fm.blockers || 'none';
+  const blockersColor = blockers === 'none' ? chalk.green : chalk.red;
+  console.log(`  ${chalk.bold('Blockers:')} ${blockersColor(blockers)}`);
+
+  console.log(`  ${hr}`);
+
+  const tracker = parseSubtaskTracker(parsed.sections[3]?.text);
+  if (tracker.length > 0) {
+    console.log();
+    console.log(chalk.bold('  Subtask Tracker:'));
+    const idWidth = Math.max(4, ...tracker.map((r) => r.id.length));
+    for (const row of tracker) {
+      const id = row.id.padEnd(idWidth);
+      const status = colorTrackerStatus(row.status);
+      const date = row.date ? chalk.dim(` (${row.date})`) : '';
+      const truncatedName = row.name.length > 50 ? row.name.slice(0, 47) + '...' : row.name;
+      console.log(`    ${chalk.dim(id)}  ${status}  ${truncatedName}${date}`);
+    }
+  }
+
+  if (opts.verbose && parsed.sections[1]) {
+    console.log();
+    console.log(chalk.bold('  Snapshot:'));
+    const lines = parsed.sections[1].text.split('\n').filter(Boolean).slice(0, 10);
+    for (const l of lines) console.log(`    ${l}`);
+  }
+
+  console.log();
+  console.log(chalk.dim(`  File: ${timelineFile}`));
+  const svgPath = join(taskDir, 'timeline.svg');
+  if (existsSync(svgPath)) {
+    console.log(chalk.dim(`  SVG:  ${svgPath}`));
+  } else {
+    console.log(chalk.dim(`  SVG:  (not yet rendered — run \`dw task render\` or commit to trigger hook)`));
+  }
+  console.log();
+}