jeo-code 0.8.27 → 0.8.28

package/CHANGELOG.md

@@ -6,6 +6,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 The README mirrors the latest 5 entries — regenerate with `bun run changelog:sync`.
 
+## [0.8.28] - 2026-07-16
+_Improved the welcome UI's right-side table to display dynamic sections (What's New, Flow keys, Project pulse, and Session trail) matching gajae-code (gjc) >= 0.8.0 features._
+
+### Added
+- **Dynamic welcome UI right-side table** (`src/tui/components/welcome.ts`, `src/commands/launch.ts`) — replaced the static metadata table with dynamic sections: "What's New" (latest changelog items), "Flow keys" (keyboard shortcuts), "Project pulse" (TypeScript language service status), and "Session trail" (recent sessions with relative time ago formatting).
+
+### Verified
+- Full `bun test` — all tests pass.
+- `bun run typecheck` — no errors.
+
 ## [0.8.27] - 2026-07-16
 _Repeat-read recovery now survives both context-overflow and refusal-result elision without reopening mutating-call loops._
 

package/README.ja.md

@@ -283,11 +283,11 @@ CI は `.github/workflows/npm-publish.yml` で公開します — GitHub リリ
 ## 変更履歴 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.8.28]** (2026-07-16) — Improved the welcome UI's right-side table to display dynamic sections (What's New, Flow keys, Project pulse, and Session trail) matching gajae-code (gjc) >= 0.8.0 features.
 - **[0.8.27]** (2026-07-16) — Repeat-read recovery now survives both context-overflow and refusal-result elision without reopening mutating-call loops.
 - **[0.8.26]** (2026-07-14) — Model catalog cleanup (drop sub-4.6 Anthropic `claude-haiku-4-5` from the exposed catalog/aliases per user direction) plus a focused gap analysis against `gajae-code`'s (gjc) 0.8.0→0.10.1 release history (~200 PRs) — most of gjc's surface (RPC/ACP/coordinator-mcp/IRC-sidebar/psmux/Windows-team) doesn't exist in jeo's smaller architecture and was ruled out with direct evidence; a few genuinely applicable gaps were found and closed.
 - **[0.8.25]** (2026-07-13) — Post-audit follow-up: 0.8.24's fixture-repair subagent flagged (but, correctly, did not itself fix — out of its assigned scope) a case-sensitivity bug in the new PlanSchema maker→verifier ordering rule. Fixed.
 - **[0.8.24]** (2026-07-13) — Follow-up gap analysis against the same external "self-improving agent system" framework (Fable-5-style loops), continuing 0.8.23's audit into 4 more primitives: independent-verifier ENFORCEMENT (0.8.23 had the gate logic but nothing forced a plan to actually contain one), model-tier safety-boundary fallback (a false-positive safety refusal previously backed off forever on the SAME model instead of trying a genuinely different one — the pattern already shipped for rate limits), memory confidence that was self-assigned once instead of earned via a real verification event, and Dynamic Workflows (jeo had parallel fan-out but no sequential composition or real control flow across subagent calls). Closed all 4, the last one non-trivially: an in-process `AsyncFunction` (the same pattern `browser {run}` already ships) cannot be given a real wall-clock timeout — a synchronous bug in agent-authored code blocks jeo's own event loop forever, and `Promise.race` can never preempt it (verified empirically). Fixed by running Dynamic Workflows scripts in an isolated `Worker` (a genuinely separate OS thread `worker.terminate()` can preempt unconditionally, mirroring `bashTool`'s own SIGTERM/SIGKILL escalation on a spawned process) with `task()` bridged back to the main thread over a `postMessage` RPC — config/credentials never leave the main thread, and every dispatch (however the script shapes it) stays bounded by a real concurrency semaphore, not just a per-call count cap.
-- **[0.8.23]** (2026-07-12) — Gap analysis against an external "self-improving agent system" framework (Fable-5-style loops: independent verifiers, memory compounding, model-tier cost discipline, and scheduled routines) found jeo-code already had strong equivalents for most primitives — but 3 real gaps and 1 deliberately-scoped-safe gap. Closed all 4: skills that were "hand-authored, read-mostly, zero learning" now compound from real session failures; screenshots that were captured but never judged now close a real vision-verify loop; the `/goal` verifier and bulk fan-out dispatch that silently rode the same full-price model as the work they graded/executed now default to a cheap tier; and "runs without your laptop" is now achievable via a generated GitHub Actions template wrapping jeo's existing headless mode — with zero new attack surface inside jeo-code itself (no code-exec sandbox, no in-process scheduler/webhook receiver, both deliberately rejected as out of scope). Also absorbs 3 fixes shipped after 0.8.22 but never changelogged: a rate-limit fast-fallback audit that closed 4 real gaps, plus the cross-file `mock.module()` test-isolation class this release's own test additions collided with and fixed at its root cause.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.ko.md

@@ -284,11 +284,11 @@ CI는 `.github/workflows/npm-publish.yml`로 배포합니다 — GitHub 릴리
 ## 변경 이력 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.8.28]** (2026-07-16) — Improved the welcome UI's right-side table to display dynamic sections (What's New, Flow keys, Project pulse, and Session trail) matching gajae-code (gjc) >= 0.8.0 features.
 - **[0.8.27]** (2026-07-16) — Repeat-read recovery now survives both context-overflow and refusal-result elision without reopening mutating-call loops.
 - **[0.8.26]** (2026-07-14) — Model catalog cleanup (drop sub-4.6 Anthropic `claude-haiku-4-5` from the exposed catalog/aliases per user direction) plus a focused gap analysis against `gajae-code`'s (gjc) 0.8.0→0.10.1 release history (~200 PRs) — most of gjc's surface (RPC/ACP/coordinator-mcp/IRC-sidebar/psmux/Windows-team) doesn't exist in jeo's smaller architecture and was ruled out with direct evidence; a few genuinely applicable gaps were found and closed.
 - **[0.8.25]** (2026-07-13) — Post-audit follow-up: 0.8.24's fixture-repair subagent flagged (but, correctly, did not itself fix — out of its assigned scope) a case-sensitivity bug in the new PlanSchema maker→verifier ordering rule. Fixed.
 - **[0.8.24]** (2026-07-13) — Follow-up gap analysis against the same external "self-improving agent system" framework (Fable-5-style loops), continuing 0.8.23's audit into 4 more primitives: independent-verifier ENFORCEMENT (0.8.23 had the gate logic but nothing forced a plan to actually contain one), model-tier safety-boundary fallback (a false-positive safety refusal previously backed off forever on the SAME model instead of trying a genuinely different one — the pattern already shipped for rate limits), memory confidence that was self-assigned once instead of earned via a real verification event, and Dynamic Workflows (jeo had parallel fan-out but no sequential composition or real control flow across subagent calls). Closed all 4, the last one non-trivially: an in-process `AsyncFunction` (the same pattern `browser {run}` already ships) cannot be given a real wall-clock timeout — a synchronous bug in agent-authored code blocks jeo's own event loop forever, and `Promise.race` can never preempt it (verified empirically). Fixed by running Dynamic Workflows scripts in an isolated `Worker` (a genuinely separate OS thread `worker.terminate()` can preempt unconditionally, mirroring `bashTool`'s own SIGTERM/SIGKILL escalation on a spawned process) with `task()` bridged back to the main thread over a `postMessage` RPC — config/credentials never leave the main thread, and every dispatch (however the script shapes it) stays bounded by a real concurrency semaphore, not just a per-call count cap.
-- **[0.8.23]** (2026-07-12) — Gap analysis against an external "self-improving agent system" framework (Fable-5-style loops: independent verifiers, memory compounding, model-tier cost discipline, and scheduled routines) found jeo-code already had strong equivalents for most primitives — but 3 real gaps and 1 deliberately-scoped-safe gap. Closed all 4: skills that were "hand-authored, read-mostly, zero learning" now compound from real session failures; screenshots that were captured but never judged now close a real vision-verify loop; the `/goal` verifier and bulk fan-out dispatch that silently rode the same full-price model as the work they graded/executed now default to a cheap tier; and "runs without your laptop" is now achievable via a generated GitHub Actions template wrapping jeo's existing headless mode — with zero new attack surface inside jeo-code itself (no code-exec sandbox, no in-process scheduler/webhook receiver, both deliberately rejected as out of scope). Also absorbs 3 fixes shipped after 0.8.22 but never changelogged: a rate-limit fast-fallback audit that closed 4 real gaps, plus the cross-file `mock.module()` test-isolation class this release's own test additions collided with and fixed at its root cause.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.md

@@ -291,11 +291,11 @@ Huge thanks to [gajae-code](https://github.com/Yeachan-Heo/gajae-code) for the i
 ## Changelog
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.8.28]** (2026-07-16) — Improved the welcome UI's right-side table to display dynamic sections (What's New, Flow keys, Project pulse, and Session trail) matching gajae-code (gjc) >= 0.8.0 features.
 - **[0.8.27]** (2026-07-16) — Repeat-read recovery now survives both context-overflow and refusal-result elision without reopening mutating-call loops.
 - **[0.8.26]** (2026-07-14) — Model catalog cleanup (drop sub-4.6 Anthropic `claude-haiku-4-5` from the exposed catalog/aliases per user direction) plus a focused gap analysis against `gajae-code`'s (gjc) 0.8.0→0.10.1 release history (~200 PRs) — most of gjc's surface (RPC/ACP/coordinator-mcp/IRC-sidebar/psmux/Windows-team) doesn't exist in jeo's smaller architecture and was ruled out with direct evidence; a few genuinely applicable gaps were found and closed.
 - **[0.8.25]** (2026-07-13) — Post-audit follow-up: 0.8.24's fixture-repair subagent flagged (but, correctly, did not itself fix — out of its assigned scope) a case-sensitivity bug in the new PlanSchema maker→verifier ordering rule. Fixed.
 - **[0.8.24]** (2026-07-13) — Follow-up gap analysis against the same external "self-improving agent system" framework (Fable-5-style loops), continuing 0.8.23's audit into 4 more primitives: independent-verifier ENFORCEMENT (0.8.23 had the gate logic but nothing forced a plan to actually contain one), model-tier safety-boundary fallback (a false-positive safety refusal previously backed off forever on the SAME model instead of trying a genuinely different one — the pattern already shipped for rate limits), memory confidence that was self-assigned once instead of earned via a real verification event, and Dynamic Workflows (jeo had parallel fan-out but no sequential composition or real control flow across subagent calls). Closed all 4, the last one non-trivially: an in-process `AsyncFunction` (the same pattern `browser {run}` already ships) cannot be given a real wall-clock timeout — a synchronous bug in agent-authored code blocks jeo's own event loop forever, and `Promise.race` can never preempt it (verified empirically). Fixed by running Dynamic Workflows scripts in an isolated `Worker` (a genuinely separate OS thread `worker.terminate()` can preempt unconditionally, mirroring `bashTool`'s own SIGTERM/SIGKILL escalation on a spawned process) with `task()` bridged back to the main thread over a `postMessage` RPC — config/credentials never leave the main thread, and every dispatch (however the script shapes it) stays bounded by a real concurrency semaphore, not just a per-call count cap.
-- **[0.8.23]** (2026-07-12) — Gap analysis against an external "self-improving agent system" framework (Fable-5-style loops: independent verifiers, memory compounding, model-tier cost discipline, and scheduled routines) found jeo-code already had strong equivalents for most primitives — but 3 real gaps and 1 deliberately-scoped-safe gap. Closed all 4: skills that were "hand-authored, read-mostly, zero learning" now compound from real session failures; screenshots that were captured but never judged now close a real vision-verify loop; the `/goal` verifier and bulk fan-out dispatch that silently rode the same full-price model as the work they graded/executed now default to a cheap tier; and "runs without your laptop" is now achievable via a generated GitHub Actions template wrapping jeo's existing headless mode — with zero new attack surface inside jeo-code itself (no code-exec sandbox, no in-process scheduler/webhook receiver, both deliberately rejected as out of scope). Also absorbs 3 fixes shipped after 0.8.22 but never changelogged: a rate-limit fast-fallback audit that closed 4 real gaps, plus the cross-file `mock.module()` test-isolation class this release's own test additions collided with and fixed at its root cause.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.zh.md

@@ -283,11 +283,11 @@ CI 通过 `.github/workflows/npm-publish.yml` 发布 — GitHub 发布 release
 ## 更新日志 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.8.28]** (2026-07-16) — Improved the welcome UI's right-side table to display dynamic sections (What's New, Flow keys, Project pulse, and Session trail) matching gajae-code (gjc) >= 0.8.0 features.
 - **[0.8.27]** (2026-07-16) — Repeat-read recovery now survives both context-overflow and refusal-result elision without reopening mutating-call loops.
 - **[0.8.26]** (2026-07-14) — Model catalog cleanup (drop sub-4.6 Anthropic `claude-haiku-4-5` from the exposed catalog/aliases per user direction) plus a focused gap analysis against `gajae-code`'s (gjc) 0.8.0→0.10.1 release history (~200 PRs) — most of gjc's surface (RPC/ACP/coordinator-mcp/IRC-sidebar/psmux/Windows-team) doesn't exist in jeo's smaller architecture and was ruled out with direct evidence; a few genuinely applicable gaps were found and closed.
 - **[0.8.25]** (2026-07-13) — Post-audit follow-up: 0.8.24's fixture-repair subagent flagged (but, correctly, did not itself fix — out of its assigned scope) a case-sensitivity bug in the new PlanSchema maker→verifier ordering rule. Fixed.
 - **[0.8.24]** (2026-07-13) — Follow-up gap analysis against the same external "self-improving agent system" framework (Fable-5-style loops), continuing 0.8.23's audit into 4 more primitives: independent-verifier ENFORCEMENT (0.8.23 had the gate logic but nothing forced a plan to actually contain one), model-tier safety-boundary fallback (a false-positive safety refusal previously backed off forever on the SAME model instead of trying a genuinely different one — the pattern already shipped for rate limits), memory confidence that was self-assigned once instead of earned via a real verification event, and Dynamic Workflows (jeo had parallel fan-out but no sequential composition or real control flow across subagent calls). Closed all 4, the last one non-trivially: an in-process `AsyncFunction` (the same pattern `browser {run}` already ships) cannot be given a real wall-clock timeout — a synchronous bug in agent-authored code blocks jeo's own event loop forever, and `Promise.race` can never preempt it (verified empirically). Fixed by running Dynamic Workflows scripts in an isolated `Worker` (a genuinely separate OS thread `worker.terminate()` can preempt unconditionally, mirroring `bashTool`'s own SIGTERM/SIGKILL escalation on a spawned process) with `task()` bridged back to the main thread over a `postMessage` RPC — config/credentials never leave the main thread, and every dispatch (however the script shapes it) stays bounded by a real concurrency semaphore, not just a per-call count cap.
-- **[0.8.23]** (2026-07-12) — Gap analysis against an external "self-improving agent system" framework (Fable-5-style loops: independent verifiers, memory compounding, model-tier cost discipline, and scheduled routines) found jeo-code already had strong equivalents for most primitives — but 3 real gaps and 1 deliberately-scoped-safe gap. Closed all 4: skills that were "hand-authored, read-mostly, zero learning" now compound from real session failures; screenshots that were captured but never judged now close a real vision-verify loop; the `/goal` verifier and bulk fan-out dispatch that silently rode the same full-price model as the work they graded/executed now default to a cheap tier; and "runs without your laptop" is now achievable via a generated GitHub Actions template wrapping jeo's existing headless mode — with zero new attack surface inside jeo-code itself (no code-exec sandbox, no in-process scheduler/webhook receiver, both deliberately rejected as out of scope). Also absorbs 3 fixes shipped after 0.8.22 but never changelogged: a rate-limit fast-fallback audit that closed 4 real gaps, plus the cross-file `mock.module()` test-isolation class this release's own test additions collided with and fixed at its root cause.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jeo-code",
-  "version": "0.8.27",
+  "version": "0.8.28",
   "description": "Clean, highly optimized AI coding agent using spec-first loop",
   "type": "module",
   "main": "src/cli.ts",

package/src/commands/launch.ts

@@ -2129,6 +2129,25 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   const activeStartModel = sessionModel || defaultModel;
   const { provider: startProvider } = await describeModel(activeStartModel);
   const welcomeTheme = resolveTheme(process.env);
+
+  const formatTimeAgo = (isoString?: string): string => {
+    if (!isoString) return "unknown";
+    const diffMs = Date.now() - new Date(isoString).getTime();
+    const diffMins = Math.floor(diffMs / 60000);
+    if (diffMins < 1) return "just now";
+    if (diffMins < 60) return `${diffMins}m ago`;
+    const diffHours = Math.floor(diffMins / 60);
+    if (diffHours < 24) return `${diffHours}h ago`;
+    const diffDays = Math.floor(diffHours / 24);
+    return `${diffDays}d ago`;
+  };
+
+  const sessions = await listSessions(cwd || process.cwd());
+  const recentSessions = sessions.map(s => ({
+    name: s.title || s.preview || s.id,
+    timeAgo: formatTimeAgo(s.timestamp),
+  }));
+
   const welcomeData = {
     version: pkg.version,
     model: activeStartModel,
@@ -2137,6 +2156,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     thinking: sessionThinking ?? "medium",
     sessionId,
     contextFiles: contextFiles.map(f => f.path),
+    recentSessions,
     cols: terminalSize().cols,
     unicode: supportsUnicode(),
     color: welcomeTheme.color,

package/src/tui/components/welcome.ts

@@ -4,7 +4,24 @@ import * as os from "node:os";
 import { renderForgeMark, FORGE_MARK_ART_GRAND } from "./ascii-art";
 import { truncate, isTTY } from "../terminal";
 import { detectColorLevel, ColorLevel, visibleWidth } from "./color";
+import { parseChangelogSections, changelogText } from "../../util/whats-new";
 
+function getLatestChangelogItems(): { version: string; items: string[] } {
+  try {
+    const sections = parseChangelogSections(changelogText);
+    if (sections.length > 0) {
+      const latest = sections[0];
+      const items: string[] = [];
+      for (const g of latest.groups) {
+        for (const item of g.items) {
+          items.push(item);
+        }
+      }
+      return { version: latest.version, items };
+    }
+  } catch {}
+  return { version: "", items: [] };
+}
 export interface WelcomeData {
   version: string;
   model: string;
@@ -47,29 +64,99 @@ function shortenPath(p: string | undefined, maxWidth: number, unicode: boolean):
   return truncate(`${ell}${s.slice(-Math.max(1, maxWidth - visibleWidth(ell)))}`, maxWidth);
 }
 
-function metaRows(d: WelcomeData, width: number, unicode: boolean, useColor: boolean): string[] {
-  const labelWidth = 8;
-  const valueWidth = Math.max(1, width - labelWidth - 3);
-  const key = useColor ? chalk.dim : (s: string) => s;
-  const rows: string[] = [];
-  const push = (label: string, value: string): void => {
-    const lhs = key(padLine(label, labelWidth, "right"));
-    const rhs = truncate(value || "-", valueWidth);
-    rows.push(padLine(`${lhs} │ ${rhs}`, width));
+function renderRightColumn(d: WelcomeData, width: number, unicode: boolean, useColor: boolean): string[] {
+  const accent = useColor ? (d.accent ?? chalk.cyan) : (s: string) => s;
+  const dim = useColor ? chalk.dim : (s: string) => s;
+  const gray = useColor ? chalk.gray : (s: string) => s;
+  const bold = useColor ? chalk.bold : (s: string) => s;
+  const bulletChar = unicode ? "•" : "-";
+  const hChar = unicode ? "─" : "-";
+  const sepLine = dim(hChar.repeat(width));
+
+  const lines: string[] = [];
+
+  // 1. What's New
+  lines.push(padLine(` ${bold(accent("What's New"))}`, width));
+  const changelog = getLatestChangelogItems();
+  if (changelog.items.length > 0) {
+    const prefix = ` ${bulletChar} `;
+    const textWidth = Math.max(1, width - visibleWidth(prefix));
+    const shown = changelog.items.slice(0, 3);
+    for (const item of shown) {
+      const text = visibleWidth(item) > textWidth ? truncate(item, textWidth) : item;
+      lines.push(padLine(`${dim(prefix)}${gray(text)}`, width));
+    }
+  } else {
+    lines.push(padLine(gray(" Ready for your next prompt"), width));
+  }
+
+  lines.push(padLine(sepLine, width));
+
+  // 2. Flow keys
+  lines.push(padLine(` ${bold(accent("Flow keys"))}`, width));
+  const FLOW_KEY_ITEMS = [
+    { key: "/", label: "commands" },
+    { key: "tab", label: "complete" },
+    { key: "ctrl+l", label: "model" },
+    { key: "ctrl+c", label: "cancel" },
+    { key: "alt+enter", label: "newline" },
+  ];
+  const flowKeyItemText = (item: { key: string; label: string }) => {
+    const k = useColor ? chalk.dim(item.key) : item.key;
+    const l = useColor ? chalk.gray(item.label) : item.label;
+    return `${k} ${l}`;
   };
-  push("version", `v${d.version}`);
-  push("folder", shortenPath(d.cwd, valueWidth, unicode));
-  push("model", d.model);
-  if (d.provider) push("provider", d.provider);
-  if (d.thinking) push("thinking", d.thinking);
-  if (d.sessionId) push("session", d.sessionId.slice(0, 8));
-
-  const files = d.contextFiles ?? [];
-  if (files.length > 0 && width >= 28) {
-    const shown = files.slice(0, width >= 34 ? 3 : 2).map(f => path.basename(f));
-    push("files", shown.join(", ") + (files.length > shown.length ? ` +${files.length - shown.length}` : ""));
+  const dot = unicode ? "·" : "*";
+  const flowSep = ` ${dim(dot)} `;
+  let currentFlowLine = "";
+  const flowLines: string[] = [];
+  for (const item of FLOW_KEY_ITEMS) {
+    const segment = flowKeyItemText(item);
+    const next = currentFlowLine ? `${currentFlowLine}${flowSep}${segment}` : segment;
+    if (currentFlowLine && visibleWidth(next) > width - 2) {
+      flowLines.push(` ${currentFlowLine}`);
+      currentFlowLine = segment;
+    } else {
+      currentFlowLine = next;
+    }
+  }
+  if (currentFlowLine) flowLines.push(` ${currentFlowLine}`);
+  for (const line of flowLines.slice(0, 2)) {
+    lines.push(padLine(line, width));
   }
-  return rows;
+
+  lines.push(padLine(sepLine, width));
+
+  // 3. Project pulse
+  lines.push(padLine(` ${bold(accent("Project pulse"))}`, width));
+  const dotChar = unicode ? "●" : "*";
+  const lspStatus = useColor ? chalk.green(dotChar) : dotChar;
+  lines.push(padLine(` ${lspStatus} ${gray("TypeScript")} ${dim("ready")}`, width));
+
+  lines.push(padLine(sepLine, width));
+
+  // 4. Session trail
+  lines.push(padLine(` ${bold(accent("Session trail"))}`, width));
+  const recent = d.recentSessions ?? [];
+  if (recent.length > 0) {
+    const bulletPrefix = ` ${bulletChar} `;
+    const prefixWidth = visibleWidth(bulletPrefix);
+    for (const session of recent.slice(0, 3)) {
+      const timeSuffixRaw = ` (${session.timeAgo})`;
+      const timeWidth = visibleWidth(timeSuffixRaw);
+      const nameBudget = Math.max(1, width - prefixWidth - timeWidth);
+      const nameVis = visibleWidth(session.name);
+      const name = nameVis > nameBudget ? truncate(session.name, nameBudget) : session.name;
+      const bullet = useColor ? chalk.dim(bulletPrefix) : bulletPrefix;
+      const sName = useColor ? chalk.gray(name) : name;
+      const sTime = useColor ? chalk.dim(timeSuffixRaw) : timeSuffixRaw;
+      lines.push(padLine(`${bullet}${sName}${sTime}`, width));
+    }
+  } else {
+    lines.push(padLine(gray(" No saved sessions"), width));
+  }
+
+  return lines;
 }
 
 function centerColumn(lines: string[], width: number): string[] {
@@ -173,13 +260,9 @@ export function renderWelcome(d: WelcomeData): string[] {
 
   let content: string[];
   if (wideMeta) {
-    const tableTitle = useColor ? chalk.bold("workspace") : "workspace";
     const rightContent = [
       "",
-      padLine(tableTitle, rightWidth, "center"),
-      (useColor ? chalk.dim : (s: string) => s)(padLine("forge context", rightWidth, "center")),
-      "",
-      ...metaRows(d, rightWidth, unicode, useColor),
+      ...renderRightColumn(d, rightWidth, unicode, useColor),
       "",
     ];
     content = zipColumns(centerColumn(leftContent, leftWidth), rightContent, leftWidth, gap, rightWidth);

package/src/util/whats-new.ts

@@ -1,5 +1,6 @@
 import pkg from "../../package.json";
 import changelogText from "../../CHANGELOG.md" with { type: "text" };
+export { changelogText };
 import { compareVersions } from "../commands/update";
 import * as os from "node:os";
 import * as path from "node:path";