specsmd 0.1.51 → 0.1.53

package/lib/dashboard/git/changes.js

@@ -0,0 +1,330 @@
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+function runGit(args, cwd, options = {}) {
+  const acceptedStatuses = Array.isArray(options.acceptedStatuses) && options.acceptedStatuses.length > 0
+    ? options.acceptedStatuses
+    : [0];
+  const result = spawnSync('git', args, {
+    cwd,
+    encoding: 'utf8',
+    maxBuffer: 10 * 1024 * 1024
+  });
+
+  if (result.error) {
+    return {
+      ok: false,
+      error: result.error.message || String(result.error),
+      stdout: '',
+      stderr: ''
+    };
+  }
+
+  if (typeof result.status === 'number' && !acceptedStatuses.includes(result.status)) {
+    return {
+      ok: false,
+      error: String(result.stderr || '').trim() || `git exited with code ${result.status}`,
+      stdout: String(result.stdout || ''),
+      stderr: String(result.stderr || '')
+    };
+  }
+
+  return {
+    ok: true,
+    error: null,
+    stdout: String(result.stdout || ''),
+    stderr: String(result.stderr || '')
+  };
+}
+
+function findGitRoot(worktreePath) {
+  if (typeof worktreePath !== 'string' || worktreePath.trim() === '') {
+    return null;
+  }
+
+  const probe = runGit(['rev-parse', '--show-toplevel'], worktreePath);
+  if (!probe.ok) {
+    return null;
+  }
+
+  const root = probe.stdout.trim();
+  return root === '' ? null : root;
+}
+
+function parseBranchSummary(line) {
+  const raw = String(line || '').replace(/^##\s*/, '').trim();
+  if (raw === '') {
+    return {
+      branch: '(unknown)',
+      upstream: null,
+      ahead: 0,
+      behind: 0,
+      detached: false
+    };
+  }
+
+  if (raw.startsWith('HEAD ')) {
+    return {
+      branch: '(detached)',
+      upstream: null,
+      ahead: 0,
+      behind: 0,
+      detached: true
+    };
+  }
+
+  const [branchPart, trackingPartRaw] = raw.split(/\s+/, 2);
+  let branch = branchPart;
+  let upstream = null;
+  if (branch.includes('...')) {
+    const [name, remote] = branch.split('...', 2);
+    branch = name || '(unknown)';
+    upstream = remote || null;
+  }
+
+  const trackingPart = typeof trackingPartRaw === 'string' ? trackingPartRaw : '';
+  const aheadMatch = trackingPart.match(/ahead\s+(\d+)/);
+  const behindMatch = trackingPart.match(/behind\s+(\d+)/);
+  const ahead = aheadMatch ? Number.parseInt(aheadMatch[1], 10) : 0;
+  const behind = behindMatch ? Number.parseInt(behindMatch[1], 10) : 0;
+
+  return {
+    branch: branch || '(unknown)',
+    upstream,
+    ahead: Number.isFinite(ahead) ? ahead : 0,
+    behind: Number.isFinite(behind) ? behind : 0,
+    detached: false
+  };
+}
+
+function parseStatusEntry(line, repoRoot) {
+  const raw = String(line || '');
+  if (raw.trim() === '' || raw.startsWith('## ')) {
+    return null;
+  }
+
+  const code = raw.slice(0, 2);
+  const statusX = code.charAt(0);
+  const statusY = code.charAt(1);
+  const remainder = raw.length > 3 ? raw.slice(3) : '';
+
+  let relativePath = remainder.trim();
+  if (relativePath.includes(' -> ')) {
+    const parts = relativePath.split(' -> ');
+    relativePath = parts[parts.length - 1].trim();
+  }
+
+  const absolutePath = relativePath === ''
+    ? ''
+    : path.join(repoRoot, relativePath);
+  const isUntracked = code === '??';
+  const isConflicted = statusX === 'U'
+    || statusY === 'U'
+    || code === 'AA'
+    || code === 'DD';
+  const isStaged = !isUntracked && statusX !== ' ';
+  const isUnstaged = !isUntracked && statusY !== ' ';
+
+  return {
+    code,
+    statusX,
+    statusY,
+    relativePath,
+    absolutePath,
+    staged: isStaged,
+    unstaged: isUnstaged,
+    untracked: isUntracked,
+    conflicted: isConflicted
+  };
+}
+
+function buildBucketItem(entry, bucket) {
+  return {
+    key: `${bucket}:${entry.relativePath}`,
+    bucket,
+    code: entry.code,
+    path: entry.absolutePath,
+    relativePath: entry.relativePath,
+    label: entry.relativePath
+  };
+}
+
+function listGitChanges(worktreePath) {
+  const gitRoot = findGitRoot(worktreePath);
+  if (!gitRoot) {
+    return {
+      available: false,
+      rootPath: null,
+      branch: '(not a git repo)',
+      upstream: null,
+      ahead: 0,
+      behind: 0,
+      detached: false,
+      clean: true,
+      counts: {
+        total: 0,
+        staged: 0,
+        unstaged: 0,
+        untracked: 0,
+        conflicted: 0
+      },
+      staged: [],
+      unstaged: [],
+      untracked: [],
+      conflicted: [],
+      generatedAt: new Date().toISOString()
+    };
+  }
+
+  const statusResult = runGit(
+    ['-c', 'color.ui=false', '-c', 'core.quotepath=false', 'status', '--porcelain', '--branch', '--untracked-files=all'],
+    gitRoot
+  );
+
+  if (!statusResult.ok) {
+    return {
+      available: false,
+      rootPath: gitRoot,
+      branch: '(status unavailable)',
+      upstream: null,
+      ahead: 0,
+      behind: 0,
+      detached: false,
+      clean: true,
+      counts: {
+        total: 0,
+        staged: 0,
+        unstaged: 0,
+        untracked: 0,
+        conflicted: 0
+      },
+      staged: [],
+      unstaged: [],
+      untracked: [],
+      conflicted: [],
+      error: statusResult.error,
+      generatedAt: new Date().toISOString()
+    };
+  }
+
+  const lines = statusResult.stdout.split(/\r?\n/).filter(Boolean);
+  const branchInfo = parseBranchSummary(lines[0] || '');
+
+  const staged = [];
+  const unstaged = [];
+  const untracked = [];
+  const conflicted = [];
+
+  for (const line of lines.slice(1)) {
+    const entry = parseStatusEntry(line, gitRoot);
+    if (!entry || entry.relativePath === '') {
+      continue;
+    }
+    if (entry.conflicted) {
+      conflicted.push(buildBucketItem(entry, 'conflicted'));
+    }
+    if (entry.staged) {
+      staged.push(buildBucketItem(entry, 'staged'));
+    }
+    if (entry.unstaged) {
+      unstaged.push(buildBucketItem(entry, 'unstaged'));
+    }
+    if (entry.untracked) {
+      untracked.push(buildBucketItem(entry, 'untracked'));
+    }
+  }
+
+  const uniqueCount = new Set([
+    ...staged.map((item) => item.relativePath),
+    ...unstaged.map((item) => item.relativePath),
+    ...untracked.map((item) => item.relativePath),
+    ...conflicted.map((item) => item.relativePath)
+  ]).size;
+
+  return {
+    available: true,
+    rootPath: gitRoot,
+    branch: branchInfo.branch,
+    upstream: branchInfo.upstream,
+    ahead: branchInfo.ahead,
+    behind: branchInfo.behind,
+    detached: branchInfo.detached,
+    clean: uniqueCount === 0,
+    counts: {
+      total: uniqueCount,
+      staged: staged.length,
+      unstaged: unstaged.length,
+      untracked: untracked.length,
+      conflicted: conflicted.length
+    },
+    staged,
+    unstaged,
+    untracked,
+    conflicted,
+    generatedAt: new Date().toISOString()
+  };
+}
+
+function readUntrackedFileDiff(repoRoot, absolutePath) {
+  const exists = typeof absolutePath === 'string' && absolutePath !== '' && fs.existsSync(absolutePath);
+  if (!exists) {
+    return '';
+  }
+
+  const result = runGit(
+    ['-c', 'color.ui=always', '--no-pager', 'diff', '--no-index', '--', '/dev/null', absolutePath],
+    repoRoot,
+    { acceptedStatuses: [0, 1] }
+  );
+  if (!result.ok) {
+    return '';
+  }
+  return result.stdout;
+}
+
+function loadGitDiffPreview(changeEntry) {
+  const bucket = typeof changeEntry?.bucket === 'string' ? changeEntry.bucket : 'unstaged';
+  const repoRoot = typeof changeEntry?.repoRoot === 'string'
+    ? changeEntry.repoRoot
+    : (typeof changeEntry?.workspacePath === 'string' ? findGitRoot(changeEntry.workspacePath) : null);
+  const relativePath = typeof changeEntry?.relativePath === 'string' ? changeEntry.relativePath : '';
+  const absolutePath = typeof changeEntry?.path === 'string' ? changeEntry.path : '';
+
+  if (!repoRoot) {
+    return '[git] repository is unavailable for preview.';
+  }
+  if (relativePath === '') {
+    return '[git] no file selected.';
+  }
+
+  if (bucket === 'untracked') {
+    const rawDiff = readUntrackedFileDiff(repoRoot, absolutePath);
+    if (rawDiff.trim() !== '') {
+      return rawDiff;
+    }
+  }
+
+  const args = ['-c', 'color.ui=always', '--no-pager', 'diff'];
+  if (bucket === 'staged') {
+    args.push('--cached');
+  }
+  args.push('--', relativePath);
+
+  const result = runGit(args, repoRoot);
+  if (!result.ok) {
+    return `[git] unable to load diff: ${result.error}`;
+  }
+
+  const output = result.stdout.trim();
+  if (output === '') {
+    return '[git] no diff output for this file.';
+  }
+
+  return result.stdout;
+}
+
+module.exports = {
+  listGitChanges,
+  loadGitDiffPreview
+};

package/lib/dashboard/index.js

@@ -8,6 +8,7 @@ const { parseSimpleDashboard } = require('./simple/parser');
 const { formatDashboardText } = require('./tui/renderer');
 const { createDashboardApp } = require('./tui/app');
 const { discoverGitWorktrees, pickWorktree, pathExistsAsDirectory } = require('./git/worktrees');
+const { listGitChanges } = require('./git/changes');
 
 function parseRefreshMs(raw) {
   const parsed = Number.parseInt(String(raw || '1000'), 10);
@@ -602,7 +603,8 @@ async function runFlowDashboard(options, flow, availableFlows = []) {
       snapshot: {
         ...selectedResult.snapshot,
         workspacePath: selectedWorktree?.path || selectedResult.snapshot?.workspacePath || workspacePath,
-        dashboardWorktrees: envelope
+        dashboardWorktrees: envelope,
+        gitChanges: listGitChanges(selectedWorktree?.path || workspacePath)
       }
     };
   };

package/lib/dashboard/tui/app.js

@@ -5,6 +5,7 @@ const stringWidthModule = require('string-width');
 const sliceAnsiModule = require('slice-ansi');
 const { createWatchRuntime } = require('../runtime/watch-runtime');
 const { createInitialUIState } = require('./store');
+const { loadGitDiffPreview } = require('../git/changes');
 
 const stringWidth = typeof stringWidthModule === 'function'
   ? stringWidthModule
@@ -64,6 +65,7 @@ function resolveIconSet() {
     runs: '[R]',
     overview: '[O]',
     health: '[H]',
+    git: '[G]',
     runFile: '*',
     activeFile: '>',
     groupCollapsed: '>',
@@ -74,6 +76,7 @@ function resolveIconSet() {
     runs: '󰑮',
     overview: '󰍉',
     health: '󰓦',
+    git: '󰊢',
     runFile: '󰈔',
     activeFile: '󰜴',
     groupCollapsed: '󰐕',
@@ -118,6 +121,11 @@ function truncate(value, width) {
   return `${sliceAnsi(text, 0, bodyWidth)}${ellipsis}`;
 }
 
+function resolveFrameWidth(columns) {
+  const safeColumns = Number.isFinite(columns) ? Math.max(1, Math.floor(columns)) : 120;
+  return safeColumns > 24 ? safeColumns - 1 : safeColumns;
+}
+
 function normalizePanelLine(line) {
   if (line && typeof line === 'object' && !Array.isArray(line)) {
     return {
@@ -1120,7 +1128,47 @@ function getPanelTitles(flow, snapshot) {
     files: 'Run Files',
     pending: 'Pending Queue',
     completed: 'Recent Completed Runs',
-    otherWorktrees: 'Other Worktrees: Active Runs'
+    otherWorktrees: 'Other Worktrees: Active Runs',
+    git: 'Git Changes'
+  };
+}
+
+function getGitChangesSnapshot(snapshot) {
+  const gitChanges = snapshot?.gitChanges;
+  if (!gitChanges || typeof gitChanges !== 'object') {
+    return {
+      available: false,
+      branch: '(unavailable)',
+      upstream: null,
+      ahead: 0,
+      behind: 0,
+      counts: {
+        total: 0,
+        staged: 0,
+        unstaged: 0,
+        untracked: 0,
+        conflicted: 0
+      },
+      staged: [],
+      unstaged: [],
+      untracked: [],
+      conflicted: [],
+      clean: true
+    };
+  }
+  return {
+    ...gitChanges,
+    counts: gitChanges.counts || {
+      total: 0,
+      staged: 0,
+      unstaged: 0,
+      untracked: 0,
+      conflicted: 0
+    },
+    staged: Array.isArray(gitChanges.staged) ? gitChanges.staged : [],
+    unstaged: Array.isArray(gitChanges.unstaged) ? gitChanges.unstaged : [],
+    untracked: Array.isArray(gitChanges.untracked) ? gitChanges.untracked : [],
+    conflicted: Array.isArray(gitChanges.conflicted) ? gitChanges.conflicted : []
   };
 }
 
@@ -1300,6 +1348,9 @@ function getSectionOrderForView(view, options = {}) {
   if (view === 'health') {
     return ['standards', 'stats', 'warnings', 'error-details'];
   }
+  if (view === 'git') {
+    return ['git-changes'];
+  }
   const sections = [];
   if (includeWorktrees) {
     sections.push('worktrees');
@@ -1640,6 +1691,10 @@ function formatScope(scope) {
   if (scope === 'upcoming') return 'UPNEXT';
   if (scope === 'completed') return 'DONE';
   if (scope === 'intent') return 'INTENT';
+  if (scope === 'staged') return 'STAGED';
+  if (scope === 'unstaged') return 'UNSTAGED';
+  if (scope === 'untracked') return 'UNTRACKED';
+  if (scope === 'conflicted') return 'CONFLICT';
   return 'FILE';
 }
 
@@ -2054,9 +2109,15 @@ function collectAidlcIntentContextFiles(snapshot, intentId) {
 }
 
 function filterExistingFiles(files) {
-  return (Array.isArray(files) ? files : []).filter((file) =>
-    file && typeof file.path === 'string' && typeof file.label === 'string' && fileExists(file.path)
-  );
+  return (Array.isArray(files) ? files : []).filter((file) => {
+    if (!file || typeof file.path !== 'string' || typeof file.label !== 'string') {
+      return false;
+    }
+    if (file.allowMissing === true) {
+      return true;
+    }
+    return fileExists(file.path);
+  });
 }
 
 function buildPendingGroups(snapshot, flow) {
@@ -2191,6 +2252,49 @@ function buildCompletedGroups(snapshot, flow) {
   return groups;
 }
 
+function buildGitChangeGroups(snapshot) {
+  const git = getGitChangesSnapshot(snapshot);
+
+  if (!git.available) {
+    return [];
+  }
+
+  const makeFiles = (items, scope) => items.map((item) => ({
+    label: item.relativePath,
+    path: item.path || path.join(git.rootPath || snapshot?.workspacePath || '', item.relativePath || ''),
+    scope,
+    allowMissing: true,
+    previewType: 'git-diff',
+    repoRoot: git.rootPath || snapshot?.workspacePath || '',
+    relativePath: item.relativePath || '',
+    bucket: item.bucket || scope
+  }));
+
+  const groups = [];
+  groups.push({
+    key: 'git:staged',
+    label: `staged (${git.counts.staged || 0})`,
+    files: makeFiles(git.staged, 'staged')
+  });
+  groups.push({
+    key: 'git:unstaged',
+    label: `unstaged (${git.counts.unstaged || 0})`,
+    files: makeFiles(git.unstaged, 'unstaged')
+  });
+  groups.push({
+    key: 'git:untracked',
+    label: `untracked (${git.counts.untracked || 0})`,
+    files: makeFiles(git.untracked, 'untracked')
+  });
+  groups.push({
+    key: 'git:conflicted',
+    label: `conflicts (${git.counts.conflicted || 0})`,
+    files: makeFiles(git.conflicted, 'conflicted')
+  });
+
+  return groups;
+}
+
 function toExpandableRows(groups, emptyLabel, expandedGroups) {
   if (!Array.isArray(groups) || groups.length === 0) {
     return [{
@@ -2221,12 +2325,16 @@ function toExpandableRows(groups, emptyLabel, expandedGroups) {
       for (let index = 0; index < files.length; index += 1) {
         const file = files[index];
         rows.push({
-          kind: 'file',
+          kind: file.previewType === 'git-diff' ? 'git-file' : 'file',
           key: `${group.key}:file:${file.path}:${index}`,
           label: file.label,
           path: file.path,
           scope: file.scope || 'file',
-          selectable: true
+          selectable: true,
+          previewType: file.previewType,
+          repoRoot: file.repoRoot,
+          relativePath: file.relativePath,
+          bucket: file.bucket
         });
       }
     }
@@ -2261,7 +2369,7 @@ function buildInteractiveRowsLines(rows, selectedIndex, icons, width, isFocusedS
       };
     }
 
-    if (row.kind === 'file') {
+    if (row.kind === 'file' || row.kind === 'git-file') {
       const scope = row.scope ? `[${formatScope(row.scope)}] ` : '';
       return {
         text: truncate(`${cursor}   ${icons.runFile} ${scope}${row.label}`, width),
@@ -2298,13 +2406,17 @@ function getSelectedRow(rows, selectedIndex) {
 }
 
 function rowToFileEntry(row) {
-  if (!row || row.kind !== 'file' || typeof row.path !== 'string') {
+  if (!row || (row.kind !== 'file' && row.kind !== 'git-file') || typeof row.path !== 'string') {
     return null;
   }
   return {
     label: row.label || path.basename(row.path),
     path: row.path,
-    scope: row.scope || 'file'
+    scope: row.scope || 'file',
+    previewType: row.previewType,
+    repoRoot: row.repoRoot,
+    relativePath: row.relativePath,
+    bucket: row.bucket
   };
 }
 
@@ -2401,9 +2513,9 @@ function buildQuickHelpText(view, options = {}) {
   const isSimple = String(flow || '').toLowerCase() === 'simple';
   const activeLabel = isAidlc ? 'active bolt' : (isSimple ? 'active spec' : 'active run');
 
-  const parts = ['1/2/3/4 tabs', 'g/G sections'];
+  const parts = ['1/2/3/4/5 tabs', 'g/G sections'];
 
-  if (view === 'runs' || view === 'intents' || view === 'completed' || view === 'health') {
+  if (view === 'runs' || view === 'intents' || view === 'completed' || view === 'health' || view === 'git') {
     if (previewOpen) {
       parts.push('tab pane', '↑/↓ nav/scroll', 'v/space close');
     } else {
@@ -2415,6 +2527,8 @@ function buildQuickHelpText(view, options = {}) {
       parts.push('b worktrees', 'u others');
     }
     parts.push('a current', 'f files');
+  } else if (view === 'git') {
+    parts.push('d changes', 'c/A/p/P git(soon)');
   }
   parts.push(`tab1 ${activeLabel}`);
 
@@ -2426,6 +2540,57 @@ function buildQuickHelpText(view, options = {}) {
   return parts.join(' | ');
 }
 
+function buildLazyGitCommandStrip(view, options = {}) {
+  const {
+    hasWorktrees = false,
+    previewOpen = false
+  } = options;
+
+  const parts = [];
+
+  if (view === 'runs') {
+    if (hasWorktrees) {
+      parts.push('b worktrees');
+    }
+    parts.push('a current', 'f files', 'enter expand');
+  } else if (view === 'intents') {
+    parts.push('n next', 'x completed', 'enter expand');
+  } else if (view === 'completed') {
+    parts.push('c completed', 'enter expand');
+  } else if (view === 'health') {
+    parts.push('s standards', 't stats', 'w warnings');
+  } else if (view === 'git') {
+    parts.push('d changes', 'space preview', 'c commit (soon)', 'A amend (soon)', 'p push (soon)', 'P pull (soon)');
+  }
+
+  if (previewOpen) {
+    parts.push('tab pane', 'j/k scroll');
+  } else {
+    parts.push('v preview');
+  }
+
+  parts.push('1-5 views', 'g/G panels', 'r refresh', '? help', 'q quit');
+  return parts.join(' | ');
+}
+
+function buildLazyGitCommandLogLine(options = {}) {
+  const {
+    statusLine = '',
+    activeFlow = 'fire',
+    watchEnabled = true,
+    watchStatus = 'watching',
+    selectedWorktreeLabel = null
+  } = options;
+
+  if (typeof statusLine === 'string' && statusLine.trim() !== '') {
+    return `Command Log | ${statusLine}`;
+  }
+
+  const watchLabel = watchEnabled ? watchStatus : 'off';
+  const worktreeSegment = selectedWorktreeLabel ? ` | wt:${selectedWorktreeLabel}` : '';
+  return `Command Log | flow:${String(activeFlow || 'fire').toUpperCase()} | watch:${watchLabel}${worktreeSegment} | ready`;
+}
+
 function buildHelpOverlayLines(options = {}) {
   const {
     view = 'runs',
@@ -2445,7 +2610,7 @@ function buildHelpOverlayLines(options = {}) {
     { text: 'Global', color: 'cyan', bold: true },
     'q or Ctrl+C quit',
     'r refresh snapshot',
-    `1 active ${itemLabel} | 2 intents | 3 completed ${itemPlural} | 4 standards/health`,
+    `1 active ${itemLabel} | 2 intents | 3 completed ${itemPlural} | 4 standards/health | 5 git changes`,
     'g next section | G previous section',
     'h/? toggle this shortcuts overlay',
     'esc close overlays (help/preview/fullscreen)',
@@ -2483,6 +2648,10 @@ function buildHelpOverlayLines(options = {}) {
     { text: 'Tab 4 Standards/Health', color: 'magenta', bold: true },
     `s standards | t stats | w warnings${showErrorSection ? ' | e errors' : ''}`,
     { text: '', color: undefined, bold: false },
+    { text: 'Tab 5 Git Changes', color: 'yellow', bold: true },
+    'select changed files and preview diffs',
+    'commit/push/pull shortcuts are shown in footer for LazyGit-style hierarchy',
+    { text: '', color: undefined, bold: false },
     { text: `Current view: ${String(view || 'runs').toUpperCase()}`, color: 'gray', bold: false }
   );
 
@@ -2601,20 +2770,27 @@ function buildPreviewLines(fileEntry, width, scrollOffset, options = {}) {
     return [{ text: truncate('No file selected', width), color: 'gray', bold: false }];
   }
 
-  let content;
-  try {
-    content = fs.readFileSync(fileEntry.path, 'utf8');
-  } catch (error) {
-    return [{
-      text: truncate(`Unable to read ${fileEntry.label || fileEntry.path}: ${error.message}`, width),
-      color: 'red',
-      bold: false
-    }];
+  const isGitPreview = fileEntry.previewType === 'git-diff';
+  let rawLines = [];
+  if (isGitPreview) {
+    const diffText = loadGitDiffPreview(fileEntry);
+    rawLines = String(diffText || '').split(/\r?\n/);
+  } else {
+    let content;
+    try {
+      content = fs.readFileSync(fileEntry.path, 'utf8');
+    } catch (error) {
+      return [{
+        text: truncate(`Unable to read ${fileEntry.label || fileEntry.path}: ${error.message}`, width),
+        color: 'red',
+        bold: false
+      }];
+    }
+    rawLines = String(content).split(/\r?\n/);
   }
 
-  const rawLines = String(content).split(/\r?\n/);
   const headLine = {
-    text: truncate(`file: ${fileEntry.path}`, width),
+    text: truncate(`${isGitPreview ? 'diff' : 'file'}: ${fileEntry.path}`, width),
     color: 'cyan',
     bold: true
   };
@@ -2625,7 +2801,34 @@ function buildPreviewLines(fileEntry, width, scrollOffset, options = {}) {
 
   const highlighted = cappedLines.map((rawLine, index) => {
     const prefixedLine = `${String(index + 1).padStart(4, ' ')} | ${rawLine}`;
-    const { color, bold, togglesCodeBlock } = colorizeMarkdownLine(rawLine, inCodeBlock);
+    let color;
+    let bold;
+    let togglesCodeBlock = false;
+
+    if (isGitPreview) {
+      if (rawLine.startsWith('+++ ') || rawLine.startsWith('--- ') || rawLine.startsWith('diff --git')) {
+        color = 'cyan';
+        bold = true;
+      } else if (rawLine.startsWith('@@')) {
+        color = 'magenta';
+        bold = true;
+      } else if (rawLine.startsWith('+')) {
+        color = 'green';
+        bold = false;
+      } else if (rawLine.startsWith('-')) {
+        color = 'red';
+        bold = false;
+      } else {
+        color = undefined;
+        bold = false;
+      }
+    } else {
+      const markdownStyle = colorizeMarkdownLine(rawLine, inCodeBlock);
+      color = markdownStyle.color;
+      bold = markdownStyle.bold;
+      togglesCodeBlock = markdownStyle.togglesCodeBlock;
+    }
+
     if (togglesCodeBlock) {
       inCodeBlock = !inCodeBlock;
     }
@@ -2720,7 +2923,7 @@ function createDashboardApp(deps) {
       focused
     } = props;
 
-    const contentWidth = Math.max(18, width - 4);
+    const contentWidth = Math.max(1, width - (dense ? 2 : 4));
     const visibleLines = fitLines(lines, maxLines, contentWidth);
     const panelBorderColor = focused ? 'cyan' : (borderColor || 'gray');
     const titleColor = focused ? 'black' : 'cyan';
@@ -2772,7 +2975,8 @@ function createDashboardApp(deps) {
       { id: 'runs', label: `1 ${icons.runs} ${primaryLabel}` },
       { id: 'intents', label: `2 ${icons.overview} INTENTS` },
       { id: 'completed', label: `3 ${icons.runs} ${completedLabel}` },
-      { id: 'health', label: `4 ${icons.health} STANDARDS/HEALTH` }
+      { id: 'health', label: `4 ${icons.health} STANDARDS/HEALTH` },
+      { id: 'git', label: `5 ${icons.git} GIT CHANGES` }
     ];
     const maxWidth = Math.max(8, Math.floor(width));
     const segments = [];
@@ -2902,7 +3106,8 @@ function createDashboardApp(deps) {
       runs: 'current-run',
       intents: 'intent-status',
       completed: 'completed-runs',
-      health: 'standards'
+      health: 'standards',
+      git: 'git-changes'
     });
     const [selectionBySection, setSelectionBySection] = useState({
       worktrees: 0,
@@ -2914,7 +3119,8 @@ function createDashboardApp(deps) {
       standards: 0,
       stats: 0,
       warnings: 0,
-      'error-details': 0
+      'error-details': 0,
+      'git-changes': 0
     });
     const [expandedGroups, setExpandedGroups] = useState({});
     const [previewTarget, setPreviewTarget] = useState(null);
@@ -3068,6 +3274,37 @@ function createDashboardApp(deps) {
         'No error details'
       )
       : toLoadingRows('Loading error details...', 'error-loading');
+    const gitRows = shouldHydrateSecondaryTabs
+      ? (() => {
+        const git = getGitChangesSnapshot(snapshot);
+        const tracking = git.upstream
+          ? `${git.upstream} (${git.ahead > 0 ? `ahead ${git.ahead}` : 'ahead 0'}, ${git.behind > 0 ? `behind ${git.behind}` : 'behind 0'})`
+          : 'no upstream';
+        const headerRows = [{
+          kind: 'info',
+          key: 'git:branch',
+          label: git.available
+            ? `branch ${git.branch}${git.detached ? ' [detached]' : ''} | ${tracking}`
+            : 'git: repository unavailable in selected worktree',
+          color: git.available ? 'cyan' : 'red',
+          bold: true,
+          selectable: false
+        }, {
+          kind: 'info',
+          key: 'git:counts',
+          label: `changes ${git.counts.total || 0} | staged ${git.counts.staged || 0} | unstaged ${git.counts.unstaged || 0} | untracked ${git.counts.untracked || 0} | conflicts ${git.counts.conflicted || 0}`,
+          color: 'gray',
+          bold: false,
+          selectable: false
+        }];
+        const groups = toExpandableRows(
+          buildGitChangeGroups(snapshot),
+          git.available ? 'Working tree clean' : 'No git changes',
+          expandedGroups
+        );
+        return [...headerRows, ...groups];
+      })()
+      : toLoadingRows('Loading git changes...', 'git-loading');
 
     const rowsBySection = {
       worktrees: worktreeRows,
@@ -3079,7 +3316,8 @@ function createDashboardApp(deps) {
       standards: standardsRows,
       stats: statsRows,
       warnings: warningsRows,
-      'error-details': errorDetailsRows
+      'error-details': errorDetailsRows,
+      'git-changes': gitRows
     };
     const worktreeItems = getWorktreeItems(snapshot);
     const selectedWorktree = getSelectedWorktree(snapshot);
@@ -3269,6 +3507,12 @@ function createDashboardApp(deps) {
         return;
       }
 
+      if (input === '5') {
+        setUi((previous) => ({ ...previous, view: 'git' }));
+        setPaneFocus('main');
+        return;
+      }
+
       if ((input === ']' || input === 'm') && availableFlowIds.length > 1) {
         snapshotHashRef.current = safeJsonHash(null);
         errorHashRef.current = null;
@@ -3291,13 +3535,15 @@ function createDashboardApp(deps) {
           standards: 0,
           stats: 0,
           warnings: 0,
-          'error-details': 0
+          'error-details': 0,
+          'git-changes': 0
         });
         setSectionFocus({
           runs: 'current-run',
           intents: 'intent-status',
           completed: 'completed-runs',
-          health: 'standards'
+          health: 'standards',
+          git: 'git-changes'
         });
         setOverviewIntentFilter('next');
         setExpandedGroups({});
@@ -3332,13 +3578,15 @@ function createDashboardApp(deps) {
           standards: 0,
           stats: 0,
           warnings: 0,
-          'error-details': 0
+          'error-details': 0,
+          'git-changes': 0
         });
         setSectionFocus({
           runs: 'current-run',
           intents: 'intent-status',
           completed: 'completed-runs',
-          health: 'standards'
+          health: 'standards',
+          git: 'git-changes'
         });
         setOverviewIntentFilter('next');
         setExpandedGroups({});
@@ -3442,6 +3690,27 @@ function createDashboardApp(deps) {
           setSectionFocus((previous) => ({ ...previous, health: 'error-details' }));
           return;
         }
+      } else if (ui.view === 'git') {
+        if (input === 'd') {
+          setSectionFocus((previous) => ({ ...previous, git: 'git-changes' }));
+          return;
+        }
+        if (input === 'c') {
+          setStatusLine('Git commit action is not wired yet (footer mirrors LazyGit command hierarchy).');
+          return;
+        }
+        if (input === 'A') {
+          setStatusLine('Git amend action is not wired yet (footer mirrors LazyGit command hierarchy).');
+          return;
+        }
+        if (input === 'p') {
+          setStatusLine('Git push action is not wired yet (footer mirrors LazyGit command hierarchy).');
+          return;
+        }
+        if (input === 'P') {
+          setStatusLine('Git pull action is not wired yet (footer mirrors LazyGit command hierarchy).');
+          return;
+        }
       }
 
       if (key.escape) {
@@ -3651,16 +3920,16 @@ function createDashboardApp(deps) {
     useEffect(() => {
       if (!stdout || typeof stdout.on !== 'function') {
         setTerminalSize({
-          columns: process.stdout.columns || 120,
-          rows: process.stdout.rows || 40
+          columns: Math.max(1, process.stdout.columns || 120),
+          rows: Math.max(1, process.stdout.rows || 40)
         });
         return undefined;
       }
 
       const updateSize = () => {
         setTerminalSize({
-          columns: stdout.columns || process.stdout.columns || 120,
-          rows: stdout.rows || process.stdout.rows || 40
+          columns: Math.max(1, stdout.columns || process.stdout.columns || 120),
+          rows: Math.max(1, stdout.rows || process.stdout.rows || 40)
         });
 
         // Resize in some terminals can leave stale frame rows behind.
@@ -3672,6 +3941,9 @@ function createDashboardApp(deps) {
 
       updateSize();
       stdout.on('resize', updateSize);
+      if (process.stdout !== stdout && typeof process.stdout.on === 'function') {
+        process.stdout.on('resize', updateSize);
+      }
 
       return () => {
         if (typeof stdout.off === 'function') {
@@ -3679,6 +3951,13 @@ function createDashboardApp(deps) {
         } else if (typeof stdout.removeListener === 'function') {
           stdout.removeListener('resize', updateSize);
         }
+        if (process.stdout !== stdout) {
+          if (typeof process.stdout.off === 'function') {
+            process.stdout.off('resize', updateSize);
+          } else if (typeof process.stdout.removeListener === 'function') {
+            process.stdout.removeListener('resize', updateSize);
+          }
+        }
       };
     }, [stdout]);
 
@@ -3717,7 +3996,9 @@ function createDashboardApp(deps) {
       });
 
       runtime.start();
-      const fallbackIntervalMs = Math.max(refreshMs, 5000);
+      const fallbackIntervalMs = ui.view === 'git'
+        ? Math.max(refreshMs, 1000)
+        : Math.max(refreshMs, 5000);
       const interval = setInterval(() => {
         void refresh();
       }, fallbackIntervalMs);
@@ -3726,7 +4007,7 @@ function createDashboardApp(deps) {
         clearInterval(interval);
         void runtime.close();
       };
-    }, [watchEnabled, refreshMs, refresh, rootPath, workspacePath, resolveRootPathForFlow, resolveRootPathsForFlow, activeFlow, worktreeWatchSignature, selectedWorktreeId]);
+    }, [watchEnabled, refreshMs, refresh, rootPath, workspacePath, resolveRootPathForFlow, resolveRootPathsForFlow, activeFlow, ui.view, worktreeWatchSignature, selectedWorktreeId]);
 
     useEffect(() => {
       if (!stdout || typeof stdout.write !== 'function') {
@@ -3741,37 +4022,31 @@ function createDashboardApp(deps) {
     const cols = Number.isFinite(terminalSize.columns) ? terminalSize.columns : (process.stdout.columns || 120);
     const rows = Number.isFinite(terminalSize.rows) ? terminalSize.rows : (process.stdout.rows || 40);
 
-    const fullWidth = Math.max(40, cols - 1);
+    const fullWidth = resolveFrameWidth(cols);
     const showFlowBar = availableFlowIds.length > 1;
-    const showFooterHelpLine = rows >= 10;
+    const showCommandLogLine = rows >= 8;
+    const showCommandStrip = rows >= 9;
     const showErrorPanel = Boolean(error) && rows >= 18;
     const showGlobalErrorPanel = showErrorPanel && ui.view !== 'health' && !ui.showHelp && !worktreeOverlayOpen;
     const showErrorInline = Boolean(error) && !showErrorPanel && !worktreeOverlayOpen;
     const showApprovalBanner = approvalGateLine !== '' && !ui.showHelp && !worktreeOverlayOpen;
-    const showStatusLine = statusLine !== '';
+    const showLegacyStatusLine = statusLine !== '' && !showCommandLogLine;
     const densePanels = rows <= 28 || cols <= 120;
 
     const reservedRows =
       2 +
       (showFlowBar ? 1 : 0) +
       (showApprovalBanner ? 1 : 0) +
-      (showFooterHelpLine ? 1 : 0) +
+      (showCommandLogLine ? 1 : 0) +
+      (showCommandStrip ? 1 : 0) +
       (showGlobalErrorPanel ? 5 : 0) +
       (showErrorInline ? 1 : 0) +
-      (showStatusLine ? 1 : 0);
+      (showLegacyStatusLine ? 1 : 0);
     const frameSafetyRows = 2;
     const contentRowsBudget = Math.max(4, rows - reservedRows - frameSafetyRows);
     const ultraCompact = rows <= 14;
     const panelTitles = getPanelTitles(activeFlow, snapshot);
-    const splitPreviewLayout = previewOpen && !overlayPreviewOpen && !ui.showHelp && !worktreeOverlayOpen && cols >= 110 && rows >= 16;
-    const mainPaneWidth = splitPreviewLayout
-      ? Math.max(34, Math.floor((fullWidth - 1) * 0.52))
-      : fullWidth;
-    const previewPaneWidth = splitPreviewLayout
-      ? Math.max(30, fullWidth - mainPaneWidth - 1)
-      : fullWidth;
-    const mainCompactWidth = Math.max(18, mainPaneWidth - 4);
-    const previewCompactWidth = Math.max(18, previewPaneWidth - 4);
+    const compactWidth = Math.max(18, fullWidth - 4);
 
     const sectionLines = Object.fromEntries(
       Object.entries(rowsBySection).map(([sectionKey, sectionRows]) => [
@@ -3780,14 +4055,14 @@ function createDashboardApp(deps) {
           sectionRows,
           selectionBySection[sectionKey] || 0,
           icons,
-          mainCompactWidth,
+          compactWidth,
           paneFocus === 'main' && focusedSection === sectionKey
         )
       ])
     );
     const effectivePreviewTarget = previewTarget || selectedFocusedFile;
     const previewLines = previewOpen
-      ? buildPreviewLines(effectivePreviewTarget, previewCompactWidth, previewScroll, {
+      ? buildPreviewLines(effectivePreviewTarget, compactWidth, previewScroll, {
         fullDocument: overlayPreviewOpen
       })
       : [];
@@ -3808,6 +4083,17 @@ function createDashboardApp(deps) {
       availableFlowCount: availableFlowIds.length,
       hasWorktrees: worktreeSectionEnabled
     });
+    const commandStripText = buildLazyGitCommandStrip(ui.view, {
+      hasWorktrees: worktreeSectionEnabled,
+      previewOpen
+    });
+    const commandLogLine = buildLazyGitCommandLogLine({
+      statusLine,
+      activeFlow,
+      watchEnabled,
+      watchStatus,
+      selectedWorktreeLabel
+    });
 
     let panelCandidates;
     if (ui.showHelp) {
@@ -3885,6 +4171,15 @@ function createDashboardApp(deps) {
           borderColor: 'red'
         });
       }
+    } else if (ui.view === 'git') {
+      panelCandidates = [
+        {
+          key: 'git-changes',
+          title: panelTitles.git || 'Git Changes',
+          lines: sectionLines['git-changes'],
+          borderColor: 'yellow'
+        }
+      ];
     } else {
       panelCandidates = [];
       if (worktreeSectionEnabled) {
@@ -3919,7 +4214,7 @@ function createDashboardApp(deps) {
       }
     }
 
-    if (!ui.showHelp && previewOpen && !overlayPreviewOpen && !splitPreviewLayout) {
+    if (!ui.showHelp && previewOpen && !overlayPreviewOpen) {
       panelCandidates.push({
         key: 'preview',
         title: `Preview: ${effectivePreviewTarget?.label || 'unknown'}`,
@@ -3928,7 +4223,7 @@ function createDashboardApp(deps) {
       });
     }
 
-    if (ultraCompact && !splitPreviewLayout) {
+    if (ultraCompact) {
       if (previewOpen) {
         panelCandidates = panelCandidates.filter((panel) => panel && (panel.key === focusedSection || panel.key === 'preview'));
       } else {
@@ -3938,6 +4233,12 @@ function createDashboardApp(deps) {
     }
 
     const panels = allocateSingleColumnPanels(panelCandidates, contentRowsBudget);
+    const lazyGitHierarchyLayout = !ui.showHelp
+      && !worktreeOverlayOpen
+      && !overlayPreviewOpen
+      && !ultraCompact
+      && fullWidth >= 96
+      && panelCandidates.length > 1;
 
     const renderPanel = (panel, index, width, isFocused) => React.createElement(SectionPanel, {
       key: panel.key,
@@ -3952,14 +4253,21 @@ function createDashboardApp(deps) {
     });
 
     let contentNode;
-    if (splitPreviewLayout && !overlayPreviewOpen) {
-      const previewBodyLines = Math.max(1, contentRowsBudget - 3);
-      const previewPanel = {
-        key: 'preview-split',
-        title: `Preview: ${effectivePreviewTarget?.label || 'unknown'}`,
-        lines: previewLines,
-        borderColor: 'magenta',
-        maxLines: previewBodyLines
+    if (lazyGitHierarchyLayout) {
+      const preferredRightPanel = previewOpen && !overlayPreviewOpen
+        ? panelCandidates.find((panel) => panel?.key === 'preview')
+        : null;
+      const focusedPanel = panelCandidates.find((panel) => panel?.key === focusedSection);
+      const rightPanelBase = preferredRightPanel
+        || focusedPanel
+        || panelCandidates[panelCandidates.length - 1];
+      const leftCandidates = panelCandidates.filter((panel) => panel?.key !== rightPanelBase?.key);
+      const leftWidth = Math.max(30, Math.min(Math.floor(fullWidth * 0.38), fullWidth - 36));
+      const rightWidth = Math.max(34, fullWidth - leftWidth - 1);
+      const leftPanels = allocateSingleColumnPanels(leftCandidates, contentRowsBudget);
+      const rightPanel = {
+        ...rightPanelBase,
+        maxLines: Math.max(4, contentRowsBudget)
       };
 
       contentNode = React.createElement(
@@ -3967,33 +4275,39 @@ function createDashboardApp(deps) {
         { width: fullWidth, flexDirection: 'row' },
         React.createElement(
           Box,
-          { width: mainPaneWidth, flexDirection: 'column' },
-          ...panels.map((panel, index) => React.createElement(SectionPanel, {
+          { width: leftWidth, flexDirection: 'column' },
+          ...leftPanels.map((panel, index) => React.createElement(SectionPanel, {
             key: panel.key,
             title: panel.title,
             lines: panel.lines,
-            width: mainPaneWidth,
+            width: leftWidth,
             maxLines: panel.maxLines,
             borderColor: panel.borderColor,
-            marginBottom: densePanels ? 0 : (index === panels.length - 1 ? 0 : 1),
+            marginBottom: densePanels ? 0 : (index === leftPanels.length - 1 ? 0 : 1),
             dense: densePanels,
             focused: paneFocus === 'main' && panel.key === focusedSection
           }))
         ),
-        React.createElement(Box, { width: 1 }, React.createElement(Text, null, ' ')),
         React.createElement(
           Box,
-          { width: previewPaneWidth, flexDirection: 'column' },
+          { width: 1, justifyContent: 'center' },
+          React.createElement(Text, { color: 'gray' }, '│')
+        ),
+        React.createElement(
+          Box,
+          { width: rightWidth, flexDirection: 'column' },
           React.createElement(SectionPanel, {
-            key: previewPanel.key,
-            title: previewPanel.title,
-            lines: previewPanel.lines,
-            width: previewPaneWidth,
-            maxLines: previewPanel.maxLines,
-            borderColor: previewPanel.borderColor,
+            key: rightPanel.key,
+            title: rightPanel.title,
+            lines: rightPanel.lines,
+            width: rightWidth,
+            maxLines: rightPanel.maxLines,
+            borderColor: rightPanel.borderColor,
             marginBottom: 0,
             dense: densePanels,
-            focused: paneFocus === 'preview'
+            focused: rightPanel.key === 'preview'
+              ? paneFocus === 'preview'
+              : (paneFocus === 'main' && rightPanel.key === focusedSection)
           })
         )
       );
@@ -4043,12 +4357,25 @@ function createDashboardApp(deps) {
         })
         : null,
       ...(Array.isArray(contentNode) ? contentNode : [contentNode]),
-      statusLine !== ''
+      showLegacyStatusLine
         ? React.createElement(Text, { color: 'yellow' }, truncate(statusLine, fullWidth))
         : null,
-      showFooterHelpLine
-        ? React.createElement(Text, { color: 'gray' }, truncate(quickHelpText, fullWidth))
-        : null
+      showCommandLogLine
+        ? React.createElement(
+          Text,
+          { color: 'white', backgroundColor: 'gray', bold: true },
+          truncate(commandLogLine, fullWidth)
+        )
+        : null,
+      showCommandStrip
+        ? React.createElement(
+          Text,
+          { color: 'white', backgroundColor: 'blue', bold: true },
+          truncate(commandStripText, fullWidth)
+        )
+        : (rows >= 10
+          ? React.createElement(Text, { color: 'gray' }, truncate(quickHelpText, fullWidth))
+          : null)
     );
   }
 

package/lib/dashboard/tui/store.js

@@ -15,12 +15,15 @@ function cycleView(current) {
   if (current === 'completed') {
     return 'health';
   }
+  if (current === 'health') {
+    return 'git';
+  }
   return 'runs';
 }
 
 function cycleViewBackward(current) {
   if (current === 'runs') {
-    return 'health';
+    return 'git';
   }
   if (current === 'intents') {
     return 'runs';
@@ -28,7 +31,10 @@ function cycleViewBackward(current) {
   if (current === 'completed') {
     return 'intents';
   }
-  return 'completed';
+  if (current === 'health') {
+    return 'completed';
+  }
+  return 'health';
 }
 
 module.exports = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specsmd",
-  "version": "0.1.51",
+  "version": "0.1.53",
   "description": "Multi-agent orchestration system for AI-native software development. Delivers AI-DLC, Agile, and custom SDLC flows as markdown-based agent systems.",
   "main": "lib/installer.js",
   "bin": {