@krishivpb60/aether-ai-cli 1.3.7 → 1.3.9

package/HIGHLIGHTS.md

@@ -1,3 +1,16 @@
+# Aether CLI v1.3.9 Highlights
+- **Microphone Audio Input & Transcription (`/mic`)**:
+  - Adds `/mic` voice command to record audio directly from your microphone inside the terminal session.
+  - Implements native zero-dependency audio recording on Windows using the WinMM Multimedia Control Interface (MCI) via PowerShell.
+  - Automatically transcribes speech using Google Gemini (base64 inlineData), Groq Whisper, or OpenAI Whisper.
+  - Populates the active readline prompt buffer directly with the transcribed text so you can review, edit, and send it.
+
+# Aether CLI v1.3.8 Highlights
+- **OpenCode TUI Welcome & Navigation**:
+  - Implements a stunning, responsive OpenCode-style TUI System State dashboard.
+  - Adds `/cd <path>` workspace directory navigation command with directory-only Tab autocomplete.
+  - Automatically displays packaging environment info (`npm` vs `pip`).
+
 # Aether CLI v1.3.7 Highlights
 - **Readme Updates**:
   - Updates documentation to display interactive Git TUI, Autopilot debug loop, and Web Telemetry Dashboard companion commands.

package/README.md

@@ -32,6 +32,7 @@
 - 🤖 **Autopilot Debug Loop** — Automatically correct build/test failures using AI self-correcting feedback loop
 - 🌿 **Interactive Git TUI** — Beautiful cyberpunk ASCII branch tree commit history & interactive file staging checkbox menu
 - 📊 **Web HUD Dashboard** — Companion local zero-dependency telemetry dashboard displaying real-time latencies & provider status
+- 🎤 **Voice Microphone Input** — Record voice input directly from your terminal and transcribe it to text using Google Gemini or Whisper
 - 🔄 **Failover Mesh** — Automatic failback across all configured providers
 - 🔢 **Local Math Solver** — Evaluates mathematical expressions without an API call
 - 🤖 **Krylo Companion** — Offline cyberpunk companion bot when no API keys are configured
@@ -197,6 +198,7 @@ Inside interactive chat mode, use these slash commands:
 | `/autopilot <mode\|debug [cmd]>` | View/switch autopilot safety level or run autonomous debug loop |
 | `/git` | Launch interactive cyberpunk Git TUI and file stager checkbox menu |
 | `/dashboard` | Spawn zero-dependency local web server and launch telemetry dashboard HUD |
+| `/mic` | Record audio voice input from microphone and transcribe to text |
 | `/tokens` | View detailed session token usage and exchanges telemetry |
 | `/update` | Force check for updates and update Aether CLI manually |
 | `/review` | Run git diff and stream an AI code review |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krishivpb60/aether-ai-cli",
-  "version": "1.3.7",
+  "version": "1.3.9",
   "description": "Aether Core AI — A cyberpunk command-line AI assistant with multi-mode reasoning, 12-node failover mesh, file context injection, and offline fallbacks.",
   "main": "src/cli.js",
   "bin": {

package/src/chat.js

@@ -139,14 +139,16 @@ export async function startChat(options = {}) {
       "/theme", "/themes", "/history-clear", "/game", "/abort", "/cmd", "/write",
       "/commit", "/run", "/history", "/autopilot", "/tokens", "/update",
       "/review", "/diagnose", "/explain", "/refactor", "/bug", "/doc", "/translate",
-      "/search", "/git", "/dashboard"
+      "/search", "/git", "/dashboard", "/cd", "/mic"
     ];
     const customCmds = aiConfig.CUSTOM_COMMANDS || {};
     const commands = [...builtIn, ...Object.keys(customCmds)];
 
-    // File path autocompletion on /attach
-    if (line.startsWith("/attach ")) {
-      const query = line.slice(8);
+    // File path autocompletion on /attach or /cd
+    if (line.startsWith("/attach ") || line.startsWith("/cd ")) {
+      const isCd = line.startsWith("/cd ");
+      const prefix = isCd ? "/cd " : "/attach ";
+      const query = line.slice(prefix.length);
       const lastSlash = Math.max(query.lastIndexOf("/"), query.lastIndexOf("\\"));
       let searchDir = ".";
       let searchPrefix = query;
@@ -169,8 +171,10 @@ export async function startChat(options = {}) {
               const fullPath = searchDir === "." || searchDir === sep ? f : join(searchDir, f);
               const fullResolved = resolve(fullPath);
               const isDir = statSync(fullResolved).isDirectory();
-              return `/attach ${fullPath}${isDir ? "/" : ""}`;
-            });
+              if (isCd && !isDir) return null;
+              return `${prefix}${fullPath}${isDir ? "/" : ""}`;
+            })
+            .filter(Boolean);
           return [hits.length ? hits : [], line];
         }
       } catch (e) {
@@ -428,7 +432,7 @@ export async function startChat(options = {}) {
         "/theme", "/themes", "/history-clear", "/game", "/abort", "/cmd",
         "/guess", "/write", "/commit", "/run", "/history", "/autopilot", "/tokens",
         "/update", "/review", "/diagnose", "/explain", "/refactor", "/bug", "/doc",
-        "/translate", "/search", "/git", "/dashboard"
+        "/translate", "/search", "/git", "/dashboard", "/cd", "/mic"
       ];
       
       const customCmds = aiConfig.CUSTOM_COMMANDS || {};
@@ -507,6 +511,10 @@ async function handleCommand(input, ctx) {
       showBanner(ctx.currentMode.name);
       break;
 
+    case "/cd":
+      await handleCd(args, ctx);
+      break;
+
     case "/export":
       await handleExport(ctx.history);
       break;
@@ -609,6 +617,10 @@ async function handleCommand(input, ctx) {
       await handleDashboardCommand(ctx);
       break;
 
+    case "/mic":
+      await handleMicInput(ctx);
+      break;
+
     case "/tokens":
       await handleTokensDisplay(ctx);
       break;
@@ -638,6 +650,7 @@ function showHelp(aiConfig) {
   console.log(keyValue("/themes", "List available visual themes"));
   console.log(keyValue("/attach <path>", "Attach a file for context (supports Tab path autocomplete!)"));
   console.log(keyValue("/files", "List attached files"));
+  console.log(keyValue("/cd <path>", "Change current working directory of this session (supports Tab path autocomplete!)"));
   console.log(keyValue("/clear", "Clear terminal screen and reprint banner"));
   console.log(keyValue("/providers", "Show active AI providers"));
   console.log(keyValue("/export", "Export conversation to file"));
@@ -646,6 +659,7 @@ function showHelp(aiConfig) {
   console.log(keyValue("/autopilot <mode|debug [cmd]>", "View/switch autopilot level (off, safe, workspace, machine) or run autonomous debug loop"));
   console.log(keyValue("/git", "Launch interactive Git branch tree, history, and file staging TUI"));
   console.log(keyValue("/dashboard", "Spawn web-based local cyberpunk telemetry dashboard companion"));
+  console.log(keyValue("/mic", "Record audio voice input from microphone and transcribe to text"));
   console.log(keyValue("/tokens", "View detailed session token usage and exchanges telemetry"));
   console.log(keyValue("/update", "Force check for updates and update Aether CLI manually"));
   console.log(keyValue("/game", "Start the local mainframe hacking mini-game"));
@@ -719,6 +733,41 @@ function showModes() {
   }
 }
 
+async function handleCd(args, ctx) {
+  const { homedir } = await import("node:os");
+  if (args.length === 0) {
+    try {
+      const home = homedir();
+      process.chdir(home);
+      console.log("\n" + label.system + " " + colors.success(`Changed directory to: `) + colors.text(home) + "\n");
+    } catch (err) {
+      console.log("\n" + label.error + " " + colors.danger(`Failed to change directory: ${err.message}`) + "\n");
+    }
+    return;
+  }
+
+  const targetPath = args.join(" ").trim();
+  const resolvedPath = resolve(targetPath);
+
+  try {
+    if (!existsSync(resolvedPath)) {
+      console.log("\n" + label.error + " " + colors.danger(`Directory does not exist: ${targetPath}`) + "\n");
+      return;
+    }
+
+    const stat = statSync(resolvedPath);
+    if (!stat.isDirectory()) {
+      console.log("\n" + label.error + " " + colors.danger(`Path is not a directory: ${targetPath}`) + "\n");
+      return;
+    }
+
+    process.chdir(resolvedPath);
+    console.log("\n" + label.system + " " + colors.success(`Changed directory to: `) + colors.text(resolvedPath) + "\n");
+  } catch (err) {
+    console.log("\n" + label.error + " " + colors.danger(`Failed to change directory: ${err.message}`) + "\n");
+  }
+}
+
 async function handleAttach(args, ctx) {
   const filePath = args.join(" ").trim();
   if (!filePath) {
@@ -2182,3 +2231,81 @@ export async function handleDashboardCommand(ctx) {
   }
 }
 
+/**
+ * Handles recording audio voice from microphone and transcribing to text input.
+ */
+export async function handleMicInput(ctx) {
+  const { startRecording, transcribeAudioFile } = await import("./mic.js");
+  const { join } = await import("node:path");
+  const { tmpdir } = await import("node:os");
+  const fs = await import("node:fs");
+
+  const apiKeyExists = ctx.aiConfig.GOOGLE_API_KEY || ctx.aiConfig.GROQ_API_KEY || ctx.aiConfig.OPENAI_API_KEY;
+  if (!apiKeyExists) {
+    console.log("\n" + label.error + " " + colors.danger("No API keys found for speech-to-text. Please configure GOOGLE_API_KEY, GROQ_API_KEY, or OPENAI_API_KEY.\n"));
+    return;
+  }
+
+  const wavPath = join(tmpdir(), `aether_mic_${Date.now()}.wav`);
+  let handle;
+
+  try {
+    handle = await startRecording(wavPath);
+  } catch (err) {
+    console.log("\n" + label.error + " " + colors.danger(`Failed to start recording: ${err.message}\n`));
+    return;
+  }
+
+  console.log("\n" + label.system + " " + colors.brand("🎤 AUDIO VOICE INPUT"));
+  console.log(separator("─"));
+  console.log(colors.accent("  Recording started..."));
+  console.log("  " + colors.muted("Speak into your microphone."));
+  console.log("  " + colors.brand("Press [Enter] to STOP and transcribe..."));
+  console.log(separator("─"));
+
+  ctx.rl.pause();
+
+  await new Promise((resolve) => {
+    function onData(chunk) {
+      if (chunk === "\r" || chunk === "\n" || chunk === "\r\n") {
+        process.stdin.removeListener("data", onData);
+        resolve();
+      }
+    }
+    process.stdin.on("data", onData);
+  });
+
+  ctx.rl.resume();
+
+  console.log("");
+  const spinner = createSpinner("transcribe");
+  spinner.start("Stopping recording and transcribing...");
+
+  try {
+    await handle.stop();
+    const text = await transcribeAudioFile(wavPath, ctx.aiConfig);
+    spinner.stop();
+
+    if (fs.existsSync(wavPath)) {
+      try { fs.unlinkSync(wavPath); } catch (e) {}
+    }
+
+    if (!text.trim()) {
+      console.log("\n" + label.system + " " + colors.warning("No speech detected or transcription was empty.\n"));
+      return;
+    }
+
+    console.log("\n" + label.system + " " + colors.success("✓ Transcribed text:"));
+    console.log("  " + colors.text(`"${text}"`));
+    console.log("");
+
+    ctx.rl.write(text);
+  } catch (err) {
+    spinner.stop();
+    if (fs.existsSync(wavPath)) {
+      try { fs.unlinkSync(wavPath); } catch (e) {}
+    }
+    console.log("\n" + label.error + " " + colors.danger(`Transcription failed: ${err.message}\n`));
+  }
+}
+

package/src/mic.js

@@ -0,0 +1,220 @@
+// ═══════════════════════════════════════════════════════════
+// AETHER AI CLI — Voice Input / Microphone Engine
+// ═══════════════════════════════════════════════════════════
+
+import { spawn } from "node:child_process";
+import { platform } from "node:os";
+import fs from "node:fs";
+
+/**
+ * Starts audio recording from the microphone and returns a handle to stop it.
+ * @param {string} wavPath - Path where the .wav file will be saved
+ * @returns {Promise<{ stop: () => Promise<void> }>}
+ */
+export async function startRecording(wavPath) {
+  if (fs.existsSync(wavPath)) {
+    try {
+      fs.unlinkSync(wavPath);
+    } catch (e) {
+      // Ignore
+    }
+  }
+
+  const isWin = platform() === "win32";
+
+  if (isWin) {
+    // Windows: Use native WinMM MCI API via a background PowerShell process
+    const ps = spawn("powershell", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", "-"], {
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+
+    ps.stdin.write(`Add-Type -MemberDefinition '[DllImport("winmm.dll", CharSet = CharSet.Ansi)] public static extern int mciSendString(string cmd, System.Text.StringBuilder ret, int len, IntPtr cb);' -Name WinMM -Namespace Win32\r\n`);
+    ps.stdin.write(`[Win32.WinMM]::mciSendString("open new Type waveaudio Alias myRecorder", $null, 0, [IntPtr]::Zero)\r\n`);
+    ps.stdin.write(`[Win32.WinMM]::mciSendString("record myRecorder", $null, 0, [IntPtr]::Zero)\r\n`);
+
+    return {
+      stop: () => {
+        return new Promise((resolve) => {
+          ps.on("close", () => {
+            resolve();
+          });
+          const escapedPath = wavPath.replace(/\\/g, "\\\\");
+          ps.stdin.write(`[Win32.WinMM]::mciSendString('save myRecorder "${escapedPath}"', $null, 0, [IntPtr]::Zero)\r\n`);
+          ps.stdin.write(`[Win32.WinMM]::mciSendString("close myRecorder", $null, 0, [IntPtr]::Zero)\r\n`);
+          ps.stdin.write("exit\r\n");
+          ps.stdin.end();
+        });
+      }
+    };
+  } else {
+    // macOS / Linux: Try spawning standard command-line recording tools
+    let cmd = "";
+    let args = [];
+
+    // Check if sox/rec is available (highest quality/reliability)
+    if (await commandExists("rec")) {
+      cmd = "rec";
+      args = ["-q", wavPath];
+    } else if (await commandExists("arecord")) {
+      cmd = "arecord";
+      args = ["-f", "cd", "-t", "wav", wavPath];
+    } else if (await commandExists("ffmpeg")) {
+      cmd = "ffmpeg";
+      const isMac = platform() === "darwin";
+      args = isMac
+        ? ["-y", "-f", "avfoundation", "-i", ":0", wavPath]
+        : ["-y", "-f", "alsa", "-i", "default", wavPath];
+    } else {
+      throw new Error("No recording utility found. On Windows, recording is native. On macOS/Linux, please install 'sox', 'arecord', or 'ffmpeg'.");
+    }
+
+    const proc = spawn(cmd, args, { stdio: "ignore" });
+
+    return {
+      stop: () => {
+        return new Promise((resolve) => {
+          proc.on("close", () => {
+            resolve();
+          });
+          proc.kill("SIGTERM");
+        });
+      }
+    };
+  }
+}
+
+/**
+ * Helper to check if a command exists in the environment PATH.
+ */
+function commandExists(name) {
+  return new Promise((resolve) => {
+    const isWin = platform() === "win32";
+    const checkCmd = isWin ? "where" : "which";
+    const check = spawn(checkCmd, [name], { stdio: "ignore" });
+    check.on("close", (code) => {
+      resolve(code === 0);
+    });
+  });
+}
+
+/**
+ * Transcribes a local audio WAV file using the configured AI providers.
+ * Priority: Google Gemini -> Groq Whisper -> OpenAI Whisper.
+ * @param {string} wavPath - Path to the WAV file
+ * @param {object} aiConfig - Active AI configuration
+ * @returns {Promise<string>} Transcribed text
+ */
+export async function transcribeAudioFile(wavPath, aiConfig) {
+  if (!fs.existsSync(wavPath)) {
+    throw new Error(`Audio file not found: ${wavPath}`);
+  }
+
+  const fileBuffer = fs.readFileSync(wavPath);
+
+  // 1. Google Gemini Transcription
+  if (aiConfig.GOOGLE_API_KEY) {
+    const base64Audio = fileBuffer.toString("base64");
+    const model = "gemini-2.5-flash";
+    const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${aiConfig.GOOGLE_API_KEY}`;
+
+    const body = {
+      contents: [
+        {
+          role: "user",
+          parts: [
+            {
+              inlineData: {
+                mimeType: "audio/wav",
+                data: base64Audio
+              }
+            },
+            {
+              text: "Transcribe this audio file exactly as spoken. Output ONLY the plain transcription text, with no extra formatting, conversational filler, timestamps, or commentary. If there is no speech, output an empty string."
+            }
+          ]
+        }
+      ]
+    };
+
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Gemini transcription error: ${response.statusText}. ${errorText}`);
+    }
+
+    const data = await response.json();
+    const candidate = data.candidates?.[0];
+    if (!candidate) {
+      return "";
+    }
+
+    const text = candidate.content?.parts
+      ?.map((p) => p.text)
+      .filter(Boolean)
+      .join("") || "";
+
+    // Clean up timestamps if returned (e.g. 00:00:23)
+    const cleaned = text.trim();
+    if (/^\d{2}:\d{2}:\d{2}$/.test(cleaned)) {
+      return "";
+    }
+    return cleaned;
+  }
+
+  // 2. Groq Whisper / OpenAI Whisper
+  let apiKey = aiConfig.GROQ_API_KEY;
+  let url = "https://api.groq.com/openai/v1/audio/transcriptions";
+  let modelName = "whisper-large-v3";
+
+  if (!apiKey) {
+    apiKey = aiConfig.OPENAI_API_KEY;
+    url = "https://api.openai.com/v1/audio/transcriptions";
+    modelName = "whisper-1";
+  }
+
+  if (!apiKey) {
+    throw new Error("No API key configured for speech-to-text. Please configure GOOGLE_API_KEY, GROQ_API_KEY, or OPENAI_API_KEY.");
+  }
+
+  const boundary = "----WebKitFormBoundary" + Math.random().toString(36).substring(2);
+
+  const header = 
+    `--${boundary}\r\n` +
+    `Content-Disposition: form-data; name="file"; filename="audio.wav"\r\n` +
+    `Content-Type: audio/wav\r\n\r\n`;
+
+  const modelPart = 
+    `\r\n--${boundary}\r\n` +
+    `Content-Disposition: form-data; name="model"\r\n\r\n${modelName}\r\n`;
+
+  const footer = `--${boundary}--\r\n`;
+
+  const body = Buffer.concat([
+    Buffer.from(header, 'utf-8'),
+    fileBuffer,
+    Buffer.from(modelPart, 'utf-8'),
+    Buffer.from(footer, 'utf-8')
+  ]);
+
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${apiKey}`,
+      "Content-Type": `multipart/form-data; boundary=${boundary}`
+    },
+    body: body
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Whisper transcription error: ${response.statusText}. ${errorText}`);
+  }
+
+  const data = await response.json();
+  return (data.text || "").trim();
+}

package/src/ui/banner.js

@@ -2,11 +2,37 @@
 // AETHER AI CLI — ASCII Art Welcome Banner
 // ═══════════════════════════════════════════════════════════
 
+import os from "node:os";
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
 import chalk from "chalk";
-import { colors, separator, bullet } from "./theme.js";
+import { colors, separator, modeBadge } from "./theme.js";
+import { getActiveProviders } from "../ai/providers.js";
+import { MODES } from "../modes.js";
+
+// ANSI escape code strip regex
+const ANSI_REGEX = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
+
+function getVisibleLength(str) {
+  return str.replace(ANSI_REGEX, "").length;
+}
+
+function loadConfigSync() {
+  try {
+    const configPath = join(homedir(), ".aether", "config.json");
+    if (existsSync(configPath)) {
+      const raw = readFileSync(configPath, "utf-8");
+      return JSON.parse(raw);
+    }
+  } catch (e) {
+    // Ignore
+  }
+  return {};
+}
 
 /**
- * Displays the cyberpunk-styled Aether ASCII art banner.
+ * Displays the cyberpunk-styled Aether ASCII art banner and OpenCode-style system info.
  * @param {string} [currentMode='titan'] - The currently active mode name
  */
 export function showBanner(currentMode = "titan") {
@@ -15,7 +41,8 @@ export function showBanner(currentMode = "titan") {
   const c3 = colors.accent3;
   const dim = colors.dim;
 
-  const art = [
+  // 1. ASCII Art Logo
+  const logo = [
     "",
     c1("  ╔═══════════════════════════════════════════════════════════╗"),
     c1("  ║") + c2("     █████╗ ███████╗████████╗██╗  ██╗███████╗██████╗    ") + c1("║"),
@@ -25,36 +52,152 @@ export function showBanner(currentMode = "titan") {
     c1("  ║") + c3("    ██║  ██║███████╗   ██║   ██║  ██║███████╗██║  ██║   ") + c1("║"),
     c1("  ║") + dim("    ╚═╝  ╚═╝╚══════╝   ╚═╝   ╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝   ") + c1("║"),
     c1("  ╚═══════════════════════════════════════════════════════════╝"),
-    "",
-    c1("  ⚡ ") + colors.text.bold("Aether Core AI v110") + colors.dim(" — Fusion Command Station"),
-    c2("  ◈  ") + colors.muted(`Active Mode: `) + modeLabel(currentMode),
-    "",
-    separator("─"),
-    "",
-    bullet("Type your prompt and press " + colors.accent("Enter") + " to query."),
-    bullet("Use " + colors.accent("/help") + " for all commands."),
-    bullet("Use " + colors.accent("/mode <name>") + " to switch reasoning mode."),
-    bullet("Use " + colors.accent("/attach <file>") + " to add file context."),
-    bullet("Use " + colors.accent("/exit") + " or " + colors.accent("Ctrl+C") + " to quit."),
-    "",
-    separator("─"),
-    "",
-  ];
+  ].join("\n");
 
-  console.log(art.join("\n"));
-}
+  console.log(logo);
 
-/**
- * Gets a styled label for the given mode.
- * @param {string} mode - Mode name
- * @returns {string} Styled mode label
- */
-function modeLabel(mode) {
-  const labels = {
-    synthesis: colors.accent3.bold("Synthesis v2.5"),
-    research:  colors.accent2.bold("Research v104"),
-    architect: colors.magenta.bold("Architect v55"),
-    titan:     colors.accent.bold("Titan Fusion v110"),
+  // 2. Fetch User & System Context
+  let username = "Explorer";
+  try {
+    username = os.userInfo().username;
+  } catch (e) {
+    username = process.env.USER || process.env.USERNAME || "Explorer";
+  }
+
+  const cwd = process.cwd();
+  const home = homedir();
+  let displayCwd = cwd;
+  if (cwd.startsWith(home)) {
+    displayCwd = "~" + cwd.slice(home.length);
+  }
+
+  const config = loadConfigSync();
+  const active = getActiveProviders(config);
+
+  const activeNames = active.length > 0
+    ? [...new Set(active.map(a => a.provider.name))].join(", ")
+    : "Local math & offline logic only";
+
+  const meshStatusText = active.length > 0
+    ? colors.success(`● Online (${active.length} active node${active.length === 1 ? "" : "s"})`)
+    : colors.warning(`○ Offline (Local fallbacks active)`);
+
+  const modeDetails = MODES[currentMode.toLowerCase()] || MODES.titan;
+  const modeText = modeBadge(currentMode) || colors.accent.bold(modeDetails.label);
+
+  const shortDescriptions = {
+    synthesis: "Balanced reasoning with clean structure.",
+    research:  "Deep analysis with evidence-based reasoning.",
+    architect: "Systems thinking with build plans.",
+    titan:     "Ultimate reasoning fusion of Codex & Claude Code.",
   };
-  return labels[mode?.toLowerCase()] || labels.titan;
+  const desc = shortDescriptions[currentMode.toLowerCase()] || shortDescriptions.titan;
+
+  let version = "1.3.8";
+  try {
+    const pkgUrl = new URL("../../package.json", import.meta.url);
+    const pkg = JSON.parse(readFileSync(pkgUrl, "utf-8"));
+    version = pkg.version || "1.3.8";
+  } catch (e) {
+    // Fallback
+  }
+
+  // 3. Render System Status Box
+  const columns = process.stdout.columns || 80;
+  const boxWidth = Math.max(76, Math.min(90, columns - 4));
+  const maxValueWidth = boxWidth - 20;
+
+  // Truncate values to fit the box cleanly
+  let workspaceValue = displayCwd;
+  if (workspaceValue.length > maxValueWidth) {
+    workspaceValue = "..." + workspaceValue.slice(-(maxValueWidth - 3));
+  }
+
+  let engineValue = activeNames;
+  if (engineValue.length > maxValueWidth) {
+    engineValue = engineValue.slice(0, maxValueWidth - 3) + "...";
+  }
+
+  // Truncate description to ensure total mode value (badge + sep + desc) fits within maxValueWidth
+  const modeBadgeText = getVisibleLength(modeText);
+  const maxDescWidth = maxValueWidth - modeBadgeText - 3; // 3 for " — "
+  let descValue = desc;
+  if (descValue.length > maxDescWidth) {
+    descValue = descValue.slice(0, Math.max(10, maxDescWidth - 3)) + "...";
+  }
+  const modeRowValue = `${modeText} ${colors.dim(`— ${descValue}`)}`;
+
+  function formatRow(label, value) {
+    const spaces = " ".repeat(Math.max(0, 14 - getVisibleLength(label)));
+    return `${label}${spaces}${value}`;
+  }
+
+  const packagerText = process.env.AETHER_PACKAGER === "pip"
+    ? "pip (aether-ai-agent-cli)"
+    : "npm (@krishivpb60/aether-ai-cli)";
+
+  const rows = [
+    formatRow(` ${colors.muted("📂 Workspace")}`, colors.text(workspaceValue)),
+    formatRow(` ${colors.muted("🧠 Mode")}`, modeRowValue),
+    formatRow(` ${colors.muted("🟢 Network")}`, meshStatusText),
+    formatRow(` ${colors.muted("⚙️  Engine")}`, colors.text(engineValue)),
+    formatRow(` ${colors.muted("📦 Packager")}`, colors.text(packagerText)),
+  ];
+
+  console.log(`\n  ⚡ ${colors.brand("AETHER COMMAND STATION v" + version)} • Welcome back, ${colors.accent(username)}`);
+
+  // Draw Box
+  const leftLine = "═".repeat(2);
+  const rightLine = "═".repeat(boxWidth - 21);
+  const top = dim(`  ╔${leftLine} `) + colors.brand("SYSTEM STATE") + dim(` ${rightLine}╗`);
+  console.log(top);
+  for (const row of rows) {
+    const visibleLen = getVisibleLength(row);
+    const padding = " ".repeat(Math.max(0, boxWidth - visibleLen - 2));
+    console.log(dim("  ║ ") + row + padding + dim(" ║"));
+  }
+  console.log(dim(`  ╚${"═".repeat(boxWidth - 2)}╝`));
+
+  // 4. Quick Starter Cards (two columns)
+  const starters = [
+    { cmd: "/explain", desc: "Analyze files in workspace" },
+    { cmd: "/review",  desc: "Review git changes (diffs)" },
+    { cmd: "/diagnose",desc: "Auto-heal failing tests" },
+    { cmd: "/dashboard",desc: "Launch visual telemetry HUD" },
+    { cmd: "/autopilot",desc: "Start autonomous debug loop" },
+    { cmd: "/game",    desc: "Play mainframe hacking game" },
+  ];
+
+  console.log(`\n  ⚡ ${colors.brand("QUICK COMMAND STARTERS")}`);
+  if (boxWidth >= 80) {
+    // Print 2 columns
+    for (let i = 0; i < starters.length; i += 2) {
+      const s1 = starters[i];
+      const s2 = starters[i + 1];
+
+      const col1 = `   ${colors.accent(s1.cmd.padEnd(11))} ${colors.text(s1.desc.padEnd(28))}`;
+      const col2 = s2 ? `   ${colors.accent(s2.cmd.padEnd(11))} ${colors.text(s2.desc)}` : "";
+
+      console.log(col1 + col2);
+    }
+  } else {
+    // Print 1 column
+    for (const s of starters) {
+      console.log(`   ${colors.accent(s.cmd.padEnd(11))} ${colors.text(s.desc)}`);
+    }
+  }
+
+  // 5. Help / Footer info
+  console.log("\n" + separator("─"));
+  const footer = [
+    colors.dim("  Press "),
+    colors.accent("Tab"),
+    colors.dim(" to autocomplete file paths • Type "),
+    colors.accent("/help"),
+    colors.dim(" for all commands • "),
+    colors.accent("Ctrl+C"),
+    colors.dim(" to exit session")
+  ].join("");
+  console.log(footer);
+  console.log(separator("─") + "\n");
 }

package/src/ui/dashboard.html

@@ -76,7 +76,7 @@
     }
 
     .hud-frame::after {
-      content: "AETHER CLI V1.3.7";
+      content: "AETHER CLI V1.3.9";
       position: absolute;
       bottom: -12px;
       right: 20px;