@pikaa-ai/pikaa 0.3.1 → 0.3.5

package/dist/cli.js

@@ -2,8 +2,8 @@
 // @bun
 
 // src/cli/index.ts
-import { resolve as resolve23 } from "path";
-import { existsSync as existsSync21 } from "fs";
+import { resolve as resolve22 } from "path";
+import { existsSync as existsSync20 } from "fs";
 import { createInterface } from "readline";
 
 // src/auth/store.ts
@@ -21,11 +21,32 @@ class CredentialsStore {
       return null;
     try {
       const raw = readFileSync(this.filePath, "utf8");
-      return JSON.parse(raw);
+      const creds = JSON.parse(raw);
+      if (creds && creds.idToken && (!creds.user || !creds.user.username)) {
+        try {
+          const parts = creds.idToken.split(".");
+          if (parts[1]) {
+            const payload = JSON.parse(Buffer.from(parts[1], "base64").toString("utf8"));
+            creds.user = {
+              ...creds.user,
+              id: creds.user?.id || payload.sub,
+              email: creds.user?.email || payload.email || payload["https://api.openai.com/profile"]?.email,
+              username: creds.user?.username || payload.preferred_username || payload.username || payload.name || (payload.email ? payload.email.split("@")[0] : undefined),
+              role: creds.user?.role || payload.role,
+              plan: creds.user?.plan || payload["https://api.openai.com/auth"]?.chatgpt_plan_type || payload.plan || payload.tier
+            };
+          }
+        } catch {}
+      }
+      return creds;
     } catch {
       return null;
     }
   }
+  getUser() {
+    const creds = this.load();
+    return creds?.user;
+  }
   save(credentials) {
     const dir = resolve(this.filePath, "..");
     if (!existsSync(dir)) {
@@ -52,6 +73,16 @@ class CredentialsStore {
     const creds = this.load();
     return creds?.baseUrl;
   }
+  getDefaultModel() {
+    const creds = this.load();
+    return creds?.defaultModel || creds?.model;
+  }
+  setDefaultModel(model) {
+    const existing = this.load() || { accessToken: "" };
+    existing.defaultModel = model;
+    existing.model = model;
+    this.save(existing);
+  }
 }
 
 // src/client/model-client.ts
@@ -114,7 +145,7 @@ class DefaultModelClientSession {
         if (toolCalls.length > 0) {
           messages.push({
             role: "assistant",
-            content: null,
+            content: cleanedContent || null,
             tool_calls: toolCalls
           });
           i = j - 1;
@@ -270,6 +301,8 @@ class DefaultModelClientSession {
           const dataStr = trimmed.slice(6);
           if (dataStr === "[DONE]") {
             for (const tc of pendingToolCalls.values()) {
+              if (!tc.name || !tc.name.trim())
+                continue;
               let parsedArgs = {};
               try {
                 parsedArgs = JSON.parse(tc.arguments);
@@ -384,6 +417,8 @@ class DefaultModelClientSession {
         }
       }
       for (const tc of pendingToolCalls.values()) {
+        if (!tc.name || !tc.name.trim())
+          continue;
         let parsedArgs = {};
         try {
           parsedArgs = JSON.parse(tc.arguments);
@@ -912,6 +947,8 @@ async function runTurn(session, turnContext, input) {
       }
       if (toolCallRequests.length > 0) {
         for (const toolCall of toolCallRequests) {
+          if (!toolCall.name || !toolCall.name.trim())
+            continue;
           const functionCallItem = {
             id: `call_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
             type: "function_call",
@@ -4629,6 +4666,13 @@ class SessionPersistenceManager {
     this.bindSession(session, restored.thread.role);
     return session;
   }
+  loadSession(threadId) {
+    try {
+      return this.store.restoreSession(threadId);
+    } catch {
+      return null;
+    }
+  }
   listSessions(options) {
     return this.store.listThreads(options);
   }
@@ -4657,6 +4701,7 @@ class SkillsLoader {
   includeGlobal;
   includeBuiltIn;
   disabledSkills;
+  skillsCache = new Map;
   constructor(optionsOrRoots = {}) {
     if (Array.isArray(optionsOrRoots)) {
       this.customRoots = optionsOrRoots;
@@ -4673,17 +4718,24 @@ class SkillsLoader {
       ]);
     }
   }
+  clearCache() {
+    this.skillsCache.clear();
+  }
   disableSkill(name) {
     const key = name.trim().toLowerCase();
     this.disabledSkills.add(key);
+    this.clearCache();
     return true;
   }
   enableSkill(name) {
     const key = name.trim().toLowerCase();
-    return this.disabledSkills.delete(key);
+    const res = this.disabledSkills.delete(key);
+    this.clearCache();
+    return res;
   }
   toggleSkill(name) {
     const key = name.trim().toLowerCase();
+    this.clearCache();
     if (this.disabledSkills.has(key)) {
       this.disabledSkills.delete(key);
       return true;
@@ -4700,6 +4752,7 @@ class SkillsLoader {
   }
   setBuiltInEnabled(enabled) {
     this.includeBuiltIn = enabled;
+    this.clearCache();
   }
   getDiscoveryRoots(cwd) {
     const roots = [resolve13(cwd, ".agents", "skills")];
@@ -4725,6 +4778,12 @@ class SkillsLoader {
     return this.listSkills(cwd, options);
   }
   listSkills(cwd, options) {
+    const cacheKey = `${cwd}:${options?.includeDisabled ?? false}`;
+    const cached = this.skillsCache.get(cacheKey);
+    const now = Date.now();
+    if (cached && now - cached.timestamp < 30000) {
+      return cached.skills;
+    }
     const roots = this.getDiscoveryRoots(cwd);
     const discovered = new Map;
     for (const root of roots) {
@@ -4747,7 +4806,9 @@ class SkillsLoader {
         }
       } catch {}
     }
-    return Array.from(discovered.values());
+    const result = Array.from(discovered.values());
+    this.skillsCache.set(cacheKey, { timestamp: now, skills: result });
+    return result;
   }
   loadSkill(cwd, skillName) {
     if (this.isSkillDisabled(skillName)) {
@@ -4771,20 +4832,32 @@ class SkillsLoader {
       return null;
     }
   }
-  parseSkillFrontmatter(filePath, fallbackName, rootDir, cwd) {
+  parseSkillFrontmatter(filePath, dirName, root, cwd) {
     try {
       const raw = readFileSync9(filePath, "utf8");
       const { attributes } = this.extractFrontmatterAndBody(raw);
-      const isWorkspace = filePath.startsWith(resolve13(cwd, ".agents"));
-      const isBuiltIn = filePath.includes(join6("groupy", "skills")) || rootDir.endsWith("skills") || attributes.source === "built-in";
-      const scope = isWorkspace ? "workspace" : isBuiltIn ? "built-in" : "global";
+      let scope = "global";
+      const normPath = filePath.toLowerCase().replace(/\\/g, "/");
+      const normCwd = cwd.toLowerCase().replace(/\\/g, "/");
+      const normRoot = root.toLowerCase().replace(/\\/g, "/");
+      if (normRoot.includes(".agents") || normRoot === `${normCwd}/skills` || normPath.startsWith(normCwd) || this.customRoots.some((r) => normPath.startsWith(resolve13(r).toLowerCase().replace(/\\/g, "/")))) {
+        scope = "workspace";
+      } else if (normRoot.includes("groupy") && (normRoot.endsWith("skills") || normRoot.includes("plugins"))) {
+        scope = "built-in";
+      }
+      const name = attributes["name"] || dirName;
+      const description = attributes["description"] || "Autonomous agent skill";
+      const shortDescription = attributes["short-description"] || attributes["summary"];
       return {
-        name: attributes.name || fallbackName,
-        description: attributes.description || "Specialized skill workflow.",
-        shortDescription: attributes.short_description || attributes.shortDescription,
+        name,
+        description,
+        shortDescription,
         path: filePath,
-        rootDir,
-        scope
+        rootDir: root,
+        dirPath: resolve13(filePath, ".."),
+        scope,
+        enabled: true,
+        tags: attributes["tags"] ? attributes["tags"].split(",").map((t) => t.trim()) : undefined
       };
     } catch {
       return null;
@@ -4793,17 +4866,20 @@ class SkillsLoader {
   extractFrontmatterAndBody(raw) {
     const attributes = {};
     let body = raw;
-    const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
-    if (match) {
-      const frontmatterText = match[1] || "";
-      body = match[2] || "";
-      for (const line of frontmatterText.split(`
-`)) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith("#"))
-          continue;
-        const colonIdx = trimmed.indexOf(":");
-        if (colonIdx > 0) {
+    if (raw.startsWith("---")) {
+      const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+      if (match) {
+        const yamlContent = match[1] ?? "";
+        body = match[2] ?? "";
+        const lines = yamlContent.split(`
+`);
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || trimmed.startsWith("#"))
+            continue;
+          const colonIdx = trimmed.indexOf(":");
+          if (colonIdx === -1)
+            continue;
           const key = trimmed.slice(0, colonIdx).trim();
           let val = trimmed.slice(colonIdx + 1).trim();
           if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
@@ -4819,22 +4895,23 @@ class SkillsLoader {
     const skills = this.listSkills(cwd, { includeDisabled: false });
     if (skills.length === 0)
       return "";
-    const prioritySkills = skills.filter((s) => s.scope === "workspace" || s.scope === "built-in");
+    const workspaceSkills = skills.filter((s) => s.scope === "workspace");
+    const builtInSkills = skills.filter((s) => s.scope === "built-in");
     const otherSkills = skills.filter((s) => s.scope !== "workspace" && s.scope !== "built-in");
-    const selectedSkills = [...prioritySkills, ...otherSkills].slice(0, 250);
+    const selectedSkills = [...workspaceSkills, ...builtInSkills, ...otherSkills].slice(0, 150);
     const lines = selectedSkills.map((s) => {
       const desc = s.shortDescription || s.description;
       return `- **${s.name}**: ${desc}`;
     });
     const suffix = skills.length > selectedSkills.length ? `
-... and ${skills.length - selectedSkills.length} additional skills available via load_skill.` : "";
+... and ${skills.length - selectedSkills.length} additional domain skills available via \`load_skill\`.` : "";
     return `
 ## Available Domain Skills
 <available_skills>
 ${lines.join(`
 `)}${suffix}
 </available_skills>
-When tackling complex specialized tasks that match any of these skills (e.g., scientific computing, biology/bioinformatics, chemistry, physics, quantum computing, machine learning, mathematics, security auditing, UI frontend design, systematic debugging, TDD), you MUST autonomously use the \`load_skill\` tool to retrieve full instructions before implementing.`;
+When tackling complex specialized tasks that match any of these skills, autonomously use the \`load_skill\` tool to retrieve full instructions before implementing.`;
   }
 }
 
@@ -5582,18 +5659,24 @@ class LiveSpinner {
   setShimmer(enabled) {
     this.enableShimmer = enabled;
   }
-  start(message = "Thinking...") {
+  start(message = "Thinking...", customStartTime) {
     if (this.isSpinning) {
+      if (customStartTime !== undefined) {
+        this.startTime = customStartTime;
+      }
       this.update(message);
       return;
     }
     this.isSpinning = true;
     this.currentMessage = message;
-    this.startTime = performance.now();
+    this.startTime = customStartTime !== undefined ? customStartTime : performance.now();
     this.frameIndex = 0;
     this.render();
     this.restartTimer();
   }
+  setStartTime(timeMs) {
+    this.startTime = timeMs;
+  }
   restartTimer() {
     if (this.timer) {
       clearInterval(this.timer);
@@ -5759,7 +5842,7 @@ function renderDiff(lines, opts = {}) {
   if (opts.filePath) {
     const headerText = `  ${opts.filePath}`;
     const padded = headerText.padEnd(termWidth);
-    out.push(`${ESC2}48;2;30;30;40m${ESC2}38;2;200;180;255m${ESC2}1m${padded}${R}`);
+    out.push(`${ESC2}48;2;36;36;42m${ESC2}38;2;230;230;235m${ESC2}1m${padded}${R}`);
   }
   let i = 0;
   while (i < lines.length) {
@@ -5880,7 +5963,6 @@ function getPackageMetadata() {
     const currentDir = typeof __dirname !== "undefined" ? __dirname : dirname8(fileURLToPath(import.meta.url));
     searchDirs.push(currentDir);
   } catch {}
-  searchDirs.push(process.cwd());
   for (const startDir of searchDirs) {
     let current = resolve17(startDir);
     for (let depth = 0;depth < 5; depth++) {
@@ -5888,7 +5970,7 @@ function getPackageMetadata() {
       if (existsSync17(candidate)) {
         try {
           const content = JSON.parse(readFileSync12(candidate, "utf8"));
-          if (content && typeof content.version === "string") {
+          if (content && typeof content.version === "string" && (content.name === "@pikaa-ai/pikaa" || content.name === "pikaa" || content.bin?.pikaa || content.bin?.groupy)) {
             const cleanName = content.name?.startsWith("@") ? content.name.split("/")[1] || content.name : content.name || "pikaa";
             cachedMetadata = {
               name: cleanName,
@@ -5905,9 +5987,23 @@ function getPackageMetadata() {
       current = parent;
     }
   }
+  try {
+    const cwdCandidate = join8(process.cwd(), "package.json");
+    if (existsSync17(cwdCandidate)) {
+      const content = JSON.parse(readFileSync12(cwdCandidate, "utf8"));
+      if (content && typeof content.version === "string" && (content.name === "@pikaa-ai/pikaa" || content.name === "pikaa" || content.bin?.pikaa || content.bin?.groupy)) {
+        cachedMetadata = {
+          name: "pikaa",
+          version: content.version,
+          description: content.description
+        };
+        return cachedMetadata;
+      }
+    }
+  } catch {}
   cachedMetadata = {
     name: "pikaa",
-    version: "0.3.1"
+    version: "0.3.2"
   };
   return cachedMetadata;
 }
@@ -5918,55 +6014,145 @@ function getCliVersion(options = {}) {
 }
 
 // src/cli/ui/animation/banner-animation.ts
-function getResponsiveWidth() {
-  const cols = typeof process.stdout?.columns === "number" ? process.stdout.columns : 80;
-  return Math.min(68, Math.max(48, cols - 6));
-}
-function formatBoxLine(content, innerWidth, border = "\x1B[38;2;47;47;51m", reset = "\x1B[0m") {
-  const visible = content.replace(/\x1b\[[0-9;]*m/g, "");
-  const pad = Math.max(0, innerWidth - visible.length);
-  return `  ${border}\u2502${reset}${content}${" ".repeat(pad)}${border}\u2502${reset}`;
-}
-function formatMenuLine(label, key = "", innerWidth, fg2, keyDim, reset) {
-  const left = `  ${fg2}${label}${reset}`;
-  const right = key ? `${keyDim}${key}${reset}  ` : "  ";
-  const leftVis = `  ${label}`;
-  const rightVis = key ? `${key}  ` : "  ";
-  const spaceCount = Math.max(1, innerWidth - leftVis.length - rightVis.length);
-  return `${left}${" ".repeat(spaceCount)}${right}`;
+import { homedir as homedir8 } from "os";
+import { execSync } from "child_process";
+var ROSE = "\x1B[38;2;205;105;74m";
+var ROSE_DIM = "\x1B[38;2;120;60;45m";
+var WHITE = "\x1B[38;2;255;255;255m";
+var GRAY = "\x1B[38;2;148;148;148m";
+var BOLD = "\x1B[1m";
+var ITALIC = "\x1B[3m";
+var RESET = "\x1B[0m";
+function shortenPath(cwd) {
+  const home = homedir8();
+  if (cwd.startsWith(home)) {
+    return `~${cwd.slice(home.length).replace(/\\/g, "/")}`;
+  }
+  return cwd.replace(/\\/g, "/");
+}
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function center(str, width) {
+  const vis = stripAnsi(str);
+  if (vis.length >= width)
+    return truncate(str, width);
+  const padLeft = Math.floor((width - vis.length) / 2);
+  const padRight = width - vis.length - padLeft;
+  return " ".repeat(padLeft) + str + " ".repeat(padRight);
+}
+function padRight(str, width) {
+  const vis = stripAnsi(str);
+  if (vis.length > width)
+    return truncate(str, width);
+  return str + " ".repeat(Math.max(0, width - vis.length));
+}
+function truncate(str, maxLen) {
+  const vis = stripAnsi(str);
+  if (vis.length <= maxLen)
+    return str;
+  return vis.slice(0, Math.max(0, maxLen - 1)) + "\u2026";
+}
+function getGitBranch(cwd) {
+  try {
+    return execSync("git rev-parse --abbrev-ref HEAD", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return null;
+  }
 }
 
 class BannerAnimator {
   static async play(info, options = {}) {
-    const isTTY = Boolean(process.stdout.isTTY);
-    const shouldAnimate = options.animate ?? (isTTY && true);
-    if (!shouldAnimate) {
-      this.renderStatic(info);
-      return;
-    }
     this.renderStatic(info);
   }
-  static renderStatic(info, options = {}) {
+  static renderStatic(info, _options) {
     const version = info.version || getCliVersion({ prefix: true });
-    const amber = "\x1B[38;2;224;175;104m";
-    const fg2 = "\x1B[38;2;232;232;232m";
-    const dim = "\x1B[38;2;122;122;122m";
-    const gray = "\x1B[38;2;139;139;144m";
-    const keyDim = "\x1B[38;2;106;106;106m";
-    const border = "\x1B[38;2;47;47;51m";
-    const reset = "\x1B[0m";
-    const width = getResponsiveWidth();
+    const storedUser = new CredentialsStore().getUser();
+    let rawUser = info.user || "";
+    if (!rawUser || rawUser.toLowerCase() === "authenticated" || rawUser.toLowerCase() === "default") {
+      rawUser = storedUser?.username || (storedUser?.email ? storedUser.email.split("@")[0] : undefined) || process.env.GROUPY_USER || process.env.USER || process.env.USERNAME || "Developer";
+    }
+    const user = rawUser.charAt(0).toUpperCase() + rawUser.slice(1);
+    const shortCwd = shortenPath(info.cwd);
+    const modelName = info.model.includes("/") ? info.model.split("/").pop() || info.model : info.model;
+    const rawPlan = info.plan || storedUser?.plan || process.env.GROUPY_PLAN || process.env.GROUPY_TIER || process.env.PIKAA_PLAN || process.env.PIKAA_TIER || "Pro";
+    const planFormatted = rawPlan.charAt(0).toUpperCase() + rawPlan.slice(1).toLowerCase();
+    const modelLine = `${modelName} \xB7 Groupy ${planFormatted}`;
+    const branchName = info.branch || getGitBranch(info.cwd) || "main";
+    const branchLine = `\uE0A0 ${branchName}`;
+    const cols = typeof process.stdout?.columns === "number" ? process.stdout.columns : 80;
+    const totalInnerWidth = Math.min(80, Math.max(68, cols - 6));
+    if (totalInnerWidth >= 70) {
+      this.renderTwoColumn(totalInnerWidth, version, user, modelLine, branchLine, shortCwd);
+    } else {
+      this.renderSingleColumn(totalInnerWidth, version, user, modelLine, branchLine, shortCwd);
+    }
+  }
+  static renderTwoColumn(totalInnerWidth, version, user, modelLine, branchLine, cwd) {
+    const leftWidth = 30;
+    const rightContentWidth = totalInnerWidth - leftWidth - 4;
+    const sprite = [
+      `${ROSE} \u2597\u2584\u2584\u2584\u2584\u2596        ${RESET}`,
+      `${ROSE}\u2590\u2588 \u2584\u2584 \u2588\u258C\u2584\u2584\u2584\u2584\u2584\u2584\u2584${RESET}`,
+      `${ROSE}\u2590\u2588 \u2580\u2580 \u2588\u258C \u2588  \u2588 \u2588${RESET}`,
+      `${ROSE} \u259D\u2580\u2580\u2580\u2580\u2598  \u2580  \u2580 \u2580${RESET}`
+    ];
+    const leftLines = [
+      center(`${BOLD}${WHITE}Welcome back ${user}!${RESET}`, leftWidth),
+      center(sprite[0], leftWidth),
+      center(sprite[1], leftWidth),
+      center(sprite[2], leftWidth),
+      center(sprite[3], leftWidth),
+      center(`${GRAY}${truncate(modelLine, leftWidth)}${RESET}`, leftWidth),
+      center(`${GRAY}${truncate(branchLine, leftWidth)}${RESET}`, leftWidth),
+      center(`${GRAY}${truncate(cwd, leftWidth)}${RESET}`, leftWidth)
+    ];
+    const rightLines = [
+      `${BOLD}${ROSE}Tips for getting started${RESET}`,
+      `${WHITE}${truncate("Ask Groupy to create a new app or clone a repo", rightContentWidth)}${RESET}`,
+      `${ROSE}${"\u2500".repeat(rightContentWidth)}${RESET}`,
+      `${BOLD}${ROSE}What's new in ${version}${RESET}`,
+      `${WHITE}${truncate("Persistent default AI model (/model)", rightContentWidth)}${RESET}`,
+      `${WHITE}${truncate("Isolated Git worktree task runner (/worktrees)", rightContentWidth)}${RESET}`,
+      `${ITALIC}${GRAY}Type /release-notes for full changelog${RESET}`,
+      ``
+    ];
+    const maxRows = Math.max(leftLines.length, rightLines.length);
+    const topDashes = Math.max(2, totalInnerWidth - (15 + version.length));
+    console.log();
+    console.log(`  ${ROSE}\u250C\u2500 ${ROSE}${BOLD}Groupy Code${RESET} ${GRAY}${version}${RESET} ${ROSE}${"\u2500".repeat(topDashes)}\u2510${RESET}`);
+    for (let i = 0;i < maxRows; i++) {
+      const left = leftLines[i] || " ".repeat(leftWidth);
+      const right = rightLines[i] || "";
+      const rightFormatted = padRight(right, rightContentWidth);
+      console.log(`  ${ROSE}\u2502${RESET}${left} ${ROSE_DIM}\u2502${RESET} ${rightFormatted} ${ROSE}\u2502${RESET}`);
+    }
+    console.log(`  ${ROSE}\u2514${"\u2500".repeat(totalInnerWidth)}\u2518${RESET}`);
+    console.log();
+  }
+  static renderSingleColumn(totalInnerWidth, version, user, modelLine, branchLine, cwd) {
+    const topDashes = Math.max(2, totalInnerWidth - (15 + version.length));
     console.log();
-    console.log(`  ${border}\u250C${"\u2500".repeat(width)}\u2510${reset}`);
-    console.log(formatBoxLine(`  ${fg2}\x1B[1mGroupy Build Beta\x1B[0m ${dim}${version}${reset}`, width, border, reset));
-    console.log(formatBoxLine(`  ${amber}\x1B[1mGroupy is here!\x1B[0m`, width, border, reset));
-    console.log(formatBoxLine(`  ${gray}Autonomous agent engine with skills, tools & worktree${reset}`, width, border, reset));
-    console.log(formatBoxLine(``, width, border, reset));
-    console.log(formatBoxLine(formatMenuLine("New worktree", "ctrl+w", width, fg2, keyDim, reset), width, border, reset));
-    console.log(formatBoxLine(formatMenuLine("Resume session", "ctrl+s", width, fg2, keyDim, reset), width, border, reset));
-    console.log(formatBoxLine(formatMenuLine(`Model: ${info.model}`, "", width, fg2, keyDim, reset), width, border, reset));
-    console.log(formatBoxLine(formatMenuLine("Quit", "ctrl+q", width, fg2, keyDim, reset), width, border, reset));
-    console.log(`  ${border}\u2514${"\u2500".repeat(width)}\u2518${reset}`);
+    console.log(`  ${ROSE}\u250C\u2500 ${ROSE}${BOLD}Groupy Code${RESET} ${GRAY}${version}${RESET} ${ROSE}${"\u2500".repeat(topDashes)}\u2510${RESET}`);
+    const lines = [
+      center(`${BOLD}${WHITE}Welcome back ${user}!${RESET}`, totalInnerWidth),
+      center(`${ROSE} \u2597\u2584\u2584\u2584\u2584\u2596        ${RESET}`, totalInnerWidth),
+      center(`${ROSE}\u2590\u2588 \u2584\u2584 \u2588\u258C\u2584\u2584\u2584\u2584\u2584\u2584\u2584${RESET}`, totalInnerWidth),
+      center(`${ROSE}\u2590\u2588 \u2580\u2580 \u2588\u258C \u2588  \u2588 \u2588${RESET}`, totalInnerWidth),
+      center(`${ROSE} \u259D\u2580\u2580\u2580\u2580\u2598  \u2580  \u2580 \u2580${RESET}`, totalInnerWidth),
+      center(`${GRAY}${modelLine}${RESET}`, totalInnerWidth),
+      center(`${GRAY}${branchLine} \xB7 ${cwd}${RESET}`, totalInnerWidth),
+      `${ROSE}${"\u2500".repeat(totalInnerWidth)}${RESET}`,
+      ` ${BOLD}${ROSE}Tips:${RESET} ${WHITE}${truncate("Ask Groupy to create a new app or inspect code", totalInnerWidth - 8)}${RESET}`
+    ];
+    for (const line of lines) {
+      console.log(`  ${ROSE}\u2502${RESET}${padRight(line, totalInnerWidth)}${ROSE}\u2502${RESET}`);
+    }
+    console.log(`  ${ROSE}\u2514${"\u2500".repeat(totalInnerWidth)}\u2518${RESET}`);
     console.log();
   }
 }
@@ -5981,20 +6167,11 @@ function formatTaskProgressPlan(plan2, explanation) {
 function formatTurnSummary(metrics) {
   CliFormatter.formatTurnSummary(metrics);
 }
-function formatTaskStepStart(step, toolName, args) {
-  const argsSummary = Object.entries(args).map(([k, v]) => {
-    const valStr = typeof v === "string" ? `"${v.length > 35 ? v.slice(0, 32) + "..." : v}"` : JSON.stringify(v);
-    return `${style.dim(k)}=${style.cyan(valStr)}`;
-  }).join(" ");
-  const dot = "\x1B[38;2;224;175;104m\u23FA\x1B[0m";
-  console.log(`  ${dot} ${style.bold(toolName)} ${argsSummary ? `${style.dim("(")}${argsSummary}${style.dim(")")}` : ""}`);
-}
 function formatTaskStepFinish(step, toolName, args, output, isError = false) {
-  const dot = isError ? "\x1B[38;2;247;118;142m\u23FA\x1B[0m" : "\x1B[38;2;78;169;111m\u23FA\x1B[0m";
+  const dot = isError ? "\x1B[38;2;247;118;142m\u25CF\x1B[0m" : "\x1B[38;2;78;169;111m\u25CF\x1B[0m";
   const toolNameDisplay = style.bold(toolName);
   if (toolName === "apply_patch" && typeof args.targetContent === "string" && typeof args.replacementContent === "string") {
     const targetFile = args.path ? String(args.path) : undefined;
-    console.log(`  ${dot} ${style.bold("Update")} ${style.dim(`(${targetFile || ""})`)}`);
     CliFormatter.formatPatchDiff(targetFile, args.targetContent, args.replacementContent);
     return;
   }
@@ -6015,7 +6192,7 @@ function formatTaskStepFinish(step, toolName, args, output, isError = false) {
   }
   const argsSummary = Object.entries(args).map(([k, v]) => {
     const valStr = typeof v === "string" ? `"${v.length > 35 ? v.slice(0, 32) + "..." : v}"` : JSON.stringify(v);
-    return `${style.dim(k)}=${style.cyan(valStr)}`;
+    return `${style.dim(k)}=\x1B[38;2;170;175;190m${valStr}\x1B[0m`;
   }).join(" ");
   console.log(`  ${dot} ${toolNameDisplay} ${argsSummary ? `${style.dim("(")}${argsSummary}${style.dim(")")}` : ""}`);
   if (summary) {
@@ -6038,8 +6215,8 @@ class CliFormatter {
     const innerWidth = 54;
     const padLine = (content) => {
       const visibleLen2 = style.stripAnsi(content).length;
-      const padRight = Math.max(0, innerWidth - visibleLen2);
-      return `  ${style.yellow("\u2502")}  ${content}${" ".repeat(padRight)}${style.yellow("\u2502")}`;
+      const padRight2 = Math.max(0, innerWidth - visibleLen2);
+      return `  ${style.yellow("\u2502")}  ${content}${" ".repeat(padRight2)}${style.yellow("\u2502")}`;
     };
     const topBorder = `  ${style.yellow("\u256D")}${style.yellow("\u2500".repeat(innerWidth + 2))}${style.yellow("\u256E")}`;
     const bottomBorder = `  ${style.yellow("\u2570")}${style.yellow("\u2500".repeat(innerWidth + 2))}${style.yellow("\u256F")}`;
@@ -6090,9 +6267,9 @@ class CliFormatter {
   static formatToolCall(toolName, args) {
     const argsSummary = Object.entries(args).map(([k, v]) => {
       const valStr = typeof v === "string" ? `"${v.length > 40 ? v.slice(0, 37) + "..." : v}"` : JSON.stringify(v);
-      return `${style.dim(k)}=${style.cyan(valStr)}`;
+      return `${style.dim(k)}=\x1B[38;2;170;175;190m${valStr}\x1B[0m`;
     }).join(" ");
-    const dot = "\x1B[38;2;78;169;111m\u23FA\x1B[0m";
+    const dot = "\x1B[38;2;78;169;111m\u25CF\x1B[0m";
     console.log(`  ${dot} ${style.bold(toolName)} ${argsSummary ? `${style.dim("(")}${argsSummary}${style.dim(")")}` : ""}`);
   }
   static formatPatchDiff(filePath, oldSrc, newSrc) {
@@ -6100,9 +6277,9 @@ class CliFormatter {
     if (lines.length === 0)
       return;
     if (filePath) {
-      const dot = "\x1B[38;2;78;169;111m\u23FA\x1B[0m";
+      const dot = "\x1B[38;2;78;169;111m\u25CF\x1B[0m";
       const arrow = "\x1B[38;2;86;95;137m\u23BF\x1B[0m";
-      console.log(`  ${dot} ${style.bold("Update")} \x1B[38;2;86;95;137m(\x1B[38;2;125;207;255m${filePath}\x1B[38;2;86;95;137m)\x1B[0m`);
+      console.log(`  ${dot} ${style.bold("Update")} \x1B[38;2;140;140;150m(\x1B[38;2;220;220;230m${filePath}\x1B[38;2;140;140;150m)\x1B[0m`);
       console.log(`    ${arrow} ${style.dim("Applied patch diff hunks")}`);
     }
     console.log(renderDiff(lines, { filePath }));
@@ -6190,18 +6367,18 @@ ${preview}${more}`);
     const ACTIVE = "\x1B[38;5;174m\u25FC\x1B[0m";
     const PENDING = "\x1B[38;5;246m\u25FB\x1B[0m";
     const DIM = "\x1B[38;5;246m";
-    const RESET = "\x1B[0m";
+    const RESET2 = "\x1B[0m";
     for (let i = 0;i < plan2.length; i++) {
       const item = plan2[i];
       if (!item)
         continue;
       const prefix = i === 0 ? "  \u23BF " : "    ";
       if (item.status === "completed") {
-        console.log(`  ${DIM}${prefix}${RESET}${DONE} \x1B[9m\x1B[38;5;246m${item.step}\x1B[0m`);
+        console.log(`  ${DIM}${prefix}${RESET2}${DONE} \x1B[9m\x1B[38;5;246m${item.step}\x1B[0m`);
       } else if (item.status === "in_progress") {
-        console.log(`  ${DIM}${prefix}${RESET}${ACTIVE} \x1B[1m\x1B[38;5;174m${item.step}\x1B[0m`);
+        console.log(`  ${DIM}${prefix}${RESET2}${ACTIVE} \x1B[1m\x1B[38;5;174m${item.step}\x1B[0m`);
       } else {
-        console.log(`  ${DIM}${prefix}${RESET}${PENDING} \x1B[38;5;246m${item.step}\x1B[0m`);
+        console.log(`  ${DIM}${prefix}${RESET2}${PENDING} \x1B[38;5;246m${item.step}\x1B[0m`);
       }
     }
     console.log();
@@ -6287,13 +6464,12 @@ ${preview}${more}`);
 // src/cli/ui/line-editor.ts
 import readline from "readline";
 var keypressEventsInitialized = false;
-var globalRawMode = false;
 function ensureKeypressInitialized() {
   if (!keypressEventsInitialized && process.stdin.isTTY) {
     readline.emitKeypressEvents(process.stdin);
     keypressEventsInitialized = true;
     process.on("exit", () => {
-      if (globalRawMode && process.stdin.isTTY) {
+      if (process.stdin.isTTY) {
         try {
           process.stdin.setRawMode(false);
         } catch {}
@@ -6330,10 +6506,9 @@ class InteractiveLineEditor {
       let scrollTop = 0;
       let renderedMenuLines = 0;
       let popupDismissed = false;
-      if (!globalRawMode && process.stdin.isTTY) {
+      if (process.stdin.isTTY) {
         try {
           process.stdin.setRawMode(true);
-          globalRawMode = true;
         } catch {}
       }
       process.stdin.resume();
@@ -6387,11 +6562,7 @@ class InteractiveLineEditor {
       };
       const clearMenu = () => {
         if (renderedMenuLines > 0) {
-          for (let i = 0;i < renderedMenuLines; i++) {
-            process.stdout.write(`
-\x1B[2K`);
-          }
-          process.stdout.write(`\x1B[${renderedMenuLines}A\r`);
+          process.stdout.write("\x1B[J");
           renderedMenuLines = 0;
         }
       };
@@ -6411,22 +6582,22 @@ class InteractiveLineEditor {
           const RULE_COLOR = "\x1B[38;2;80;80;88m";
           const ACTIVE_COLOR = "\x1B[38;2;225;225;225m";
           const INACTIVE_COLOR = "\x1B[38;2;139;139;144m";
-          const RESET = "\x1B[0m";
-          menuLines.push(`  ${RULE_COLOR}${rule}${RESET}`);
+          const RESET2 = "\x1B[0m";
+          menuLines.push(`  ${RULE_COLOR}${rule}${RESET2}`);
           for (let i = 0;i < visibleMatches.length; i++) {
             const cmd = visibleMatches[i];
             const actualIdx = scrollTop + i;
             const isSelected = actualIdx === selectedIndex;
-            const marker = isSelected ? `${ACTIVE_COLOR}\u276F${RESET}` : " ";
+            const marker = isSelected ? `${ACTIVE_COLOR}\u276F${RESET2}` : " ";
             const rawName = cmd.name.padEnd(16).slice(0, 16);
             const rawDesc = cmd.description.length > 48 ? cmd.description.slice(0, 45) + "..." : cmd.description;
             if (isSelected) {
-              menuLines.push(`  ${marker} \x1B[1m${ACTIVE_COLOR}${rawName}${RESET}  \x1B[1m${ACTIVE_COLOR}${rawDesc}${RESET}`);
+              menuLines.push(`  ${marker} \x1B[1m${ACTIVE_COLOR}${rawName}${RESET2}  \x1B[1m${ACTIVE_COLOR}${rawDesc}${RESET2}`);
             } else {
-              menuLines.push(`  ${marker} ${INACTIVE_COLOR}${rawName}${RESET}  ${INACTIVE_COLOR}${rawDesc}${RESET}`);
+              menuLines.push(`  ${marker} ${INACTIVE_COLOR}${rawName}${RESET2}  ${INACTIVE_COLOR}${rawDesc}${RESET2}`);
             }
           }
-          menuLines.push(`  ${RULE_COLOR}${rule}${RESET}`);
+          menuLines.push(`  ${RULE_COLOR}${rule}${RESET2}`);
           for (const line of menuLines) {
             process.stdout.write(`
 \x1B[2K${line}`);
@@ -6482,6 +6653,11 @@ class InteractiveLineEditor {
       const cleanupAndResolve = (result) => {
         clearMenu();
         process.stdin.removeListener("keypress", onKeypress);
+        if (process.stdin.isTTY) {
+          try {
+            process.stdin.setRawMode(false);
+          } catch {}
+        }
         if (result.trim().length > 0 && !result.startsWith("/")) {
           process.stdout.write(`\r\x1B[2K${CliFormatter.formatClaudeUserPrompt(result)}
 
@@ -6506,10 +6682,9 @@ class InteractiveLineEditor {
             return;
           }
           clearMenu();
-          if (globalRawMode && process.stdin.isTTY) {
+          if (process.stdin.isTTY) {
             try {
               process.stdin.setRawMode(false);
-              globalRawMode = false;
             } catch {}
           }
           process.stdin.removeListener("keypress", onKeypress);
@@ -6631,9 +6806,11 @@ class InteractiveLineEditor {
           }
           return;
         }
-        if (_str && !key.ctrl && !key.meta) {
-          buffer = buffer.slice(0, cursor) + _str + buffer.slice(cursor);
-          cursor += _str.length;
+        const char = _str || key.sequence || (key.name && key.name.length === 1 ? key.name : "");
+        if (char && !key.ctrl && !key.meta && char !== "\r" && char !== `
+`) {
+          buffer = buffer.slice(0, cursor) + char + buffer.slice(cursor);
+          cursor += char.length;
           selectedIndex = 0;
           scrollTop = 0;
           popupDismissed = false;
@@ -6646,163 +6823,481 @@ class InteractiveLineEditor {
   }
 }
 
-// src/cli/ui/animation/types.ts
-var ALL_ANIMATION_VARIANTS = [
-  "default",
-  "groupy",
-  "mesosfer",
-  "blocks",
-  "dots",
-  "hash",
-  "hbars",
-  "vbars",
-  "shapes",
-  "slug"
-];
-var DEFAULT_FRAME_TICK_MS = 80;
-// src/cli/ui/animation/frames-loader.ts
-import { existsSync as existsSync18, readFileSync as readFileSync13 } from "fs";
-import { join as join9, resolve as resolve18 } from "path";
-var __dirname = "/home/runner/work/agent-cli/agent-cli/src/cli/ui/animation";
-
-class FramesLoader {
-  static cache = new Map;
-  static assetsDir = resolve18(__dirname, "../../../../assets/frames");
-  static setAssetsDir(customDir) {
-    this.assetsDir = customDir;
-    this.cache.clear();
-  }
-  static getAssetsDir() {
-    return this.assetsDir;
-  }
-  static getFrames(variant) {
-    if (this.cache.has(variant)) {
-      return this.cache.get(variant);
-    }
-    const variantDir = join9(this.assetsDir, variant);
-    if (!existsSync18(variantDir)) {
-      return [];
-    }
-    const frames = [];
-    for (let i = 1;i <= 36; i++) {
-      const framePath = join9(variantDir, `frame_${i}.txt`);
-      if (existsSync18(framePath)) {
-        try {
-          const content = readFileSync13(framePath, "utf-8");
-          frames.push(content);
-        } catch {}
-      }
-    }
-    this.cache.set(variant, frames);
-    return frames;
-  }
-  static preloadAll() {
-    for (const variant of ALL_ANIMATION_VARIANTS) {
-      this.getFrames(variant);
-    }
-  }
-}
-// src/cli/ui/animation/ascii-animation.ts
-class AsciiAnimation {
-  variant;
-  frameTickMs;
-  startTime;
-  currentFrameIndex = 0;
-  colorFn;
-  constructor(options = {}) {
-    this.variant = options.variant || "default";
-    this.frameTickMs = options.frameTickMs ?? DEFAULT_FRAME_TICK_MS;
-    this.startTime = Date.now();
-    this.colorFn = options.colorFn;
-    if (options.assetsDir) {
-      FramesLoader.setAssetsDir(options.assetsDir);
-    }
-  }
-  getFrames() {
-    return FramesLoader.getFrames(this.variant);
-  }
-  currentFrame(now = Date.now()) {
-    const frames = this.getFrames();
-    if (frames.length === 0)
-      return "";
-    if (this.frameTickMs === 0) {
-      return frames[0] || "";
+// src/cli/ui/prompt.ts
+import readline2 from "readline";
+async function promptChoice(config) {
+  const { message, choices, defaultIndex = 0 } = config;
+  if (!process.stdin.isTTY) {
+    if (!process.stdin.readable) {
+      return choices[defaultIndex]?.value ?? choices[0].value;
     }
-    const elapsedMs = Math.max(0, now - this.startTime);
-    const frameIndex = Math.floor(elapsedMs / this.frameTickMs) % frames.length;
-    const rawFrame = frames[frameIndex] || "";
-    return this.colorFn ? this.colorFn(rawFrame) : rawFrame;
-  }
-  nextFrame() {
-    const frames = this.getFrames();
-    if (frames.length === 0)
-      return "";
-    const rawFrame = frames[this.currentFrameIndex % frames.length] || "";
-    this.currentFrameIndex = (this.currentFrameIndex + 1) % frames.length;
-    return this.colorFn ? this.colorFn(rawFrame) : rawFrame;
-  }
-  setVariant(variant) {
-    this.variant = variant;
-    this.currentFrameIndex = 0;
-    this.startTime = Date.now();
-  }
-  getVariant() {
-    return this.variant;
-  }
-  pickRandomVariant() {
-    const available = ALL_ANIMATION_VARIANTS.filter((v) => v !== this.variant);
-    const randomIndex = Math.floor(Math.random() * available.length);
-    const nextVariant = available[randomIndex] || "default";
-    this.setVariant(nextVariant);
-    return nextVariant;
+    return new Promise((resolve18) => {
+      const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
+      const hint = choices.map((c3) => c3.isDefault ? `[${c3.key.toUpperCase()}]` : `[${c3.key}]`).join("/");
+      let resolved = false;
+      const doResolve = (val) => {
+        if (!resolved) {
+          resolved = true;
+          rl.close();
+          resolve18(val);
+        }
+      };
+      rl.question(`${message} ${hint}: `, (answer) => {
+        const trimmed = answer.trim().toLowerCase();
+        const matched = choices.find((c3) => c3.key.toLowerCase() === trimmed);
+        doResolve(matched ? matched.value : choices[defaultIndex].value);
+      });
+      rl.on("close", () => {
+        doResolve(choices[defaultIndex].value);
+      });
+    });
   }
-  async play(durationMs = 3000, options = {}) {
-    const frames = this.getFrames();
-    if (frames.length === 0)
-      return;
-    const hideCursor = "\x1B[?25l";
-    const showCursor = "\x1B[?25h";
-    const resetCursor = "\x1B[H";
-    if (process.stdout.isTTY) {
-      process.stdout.write(hideCursor);
-      if (options.clearScreen) {
-        process.stdout.write("\x1B[2J\x1B[H");
-      }
-    }
-    const start = Date.now();
+  return new Promise((resolve18) => {
+    let selectedIndex = defaultIndex;
+    if (selectedIndex < 0 || selectedIndex >= choices.length)
+      selectedIndex = 0;
+    readline2.emitKeypressEvents(process.stdin);
+    const wasRaw = process.stdin.isRaw;
     try {
-      while (Date.now() - start < durationMs) {
-        if (options.signal?.aborted)
-          break;
-        const frame = this.currentFrame();
-        if (options.onFrame) {
-          options.onFrame(frame, this.currentFrameIndex);
-        } else if (process.stdout.isTTY) {
-          process.stdout.write(resetCursor + frame);
+      process.stdin.setRawMode(true);
+    } catch {}
+    process.stdin.resume();
+    const render = () => {
+      const parts = choices.map((choice, idx) => {
+        const isSelected = idx === selectedIndex;
+        const keyTag = `[${choice.key}]`;
+        if (isSelected) {
+          return `${c.bgBrand}${c.white}${c.bold} \u276F ${keyTag} ${choice.label} ${c.reset}`;
         }
-        await new Promise((resolve19) => setTimeout(resolve19, this.frameTickMs));
+        return `${style.dim(`  ${keyTag} ${choice.label}`)}`;
+      });
+      process.stdout.write(`\r\x1B[2K  ${style.bold(message)}
+\r\x1B[2K${parts.join("  ")}`);
+    };
+    const cleanup = (confirmedChoice) => {
+      process.stdin.removeListener("keypress", onKeypress);
+      try {
+        process.stdin.setRawMode(wasRaw ?? false);
+      } catch {}
+      process.stdout.write(`\r\x1B[1A\r\x1B[2K  ${style.bold(message)} ${style.cyan(`[${confirmedChoice.key}] ${confirmedChoice.label}`)}
+\r\x1B[2K`);
+      resolve18(confirmedChoice.value);
+    };
+    const onKeypress = (_str, key) => {
+      if (!key)
+        return;
+      if (key.ctrl && key.name === "c") {
+        cleanup(choices.find((c3) => c3.key.toLowerCase() === "n") || choices[defaultIndex]);
+        return;
+      }
+      if (key.name === "escape") {
+        cleanup(choices.find((c3) => c3.key.toLowerCase() === "n") || choices[defaultIndex]);
+        return;
+      }
+      if (key.name === "return" || key.name === "enter") {
+        cleanup(choices[selectedIndex]);
+        return;
+      }
+      if (key.name === "left") {
+        selectedIndex = (selectedIndex - 1 + choices.length) % choices.length;
+        process.stdout.write("\x1B[1A");
+        render();
+        return;
+      }
+      if (key.name === "right" || key.name === "tab") {
+        selectedIndex = (selectedIndex + 1) % choices.length;
+        process.stdout.write("\x1B[1A");
+        render();
+        return;
       }
-    } finally {
-      if (process.stdout.isTTY) {
-        process.stdout.write(showCursor);
+      const char = _str ? _str.toLowerCase() : key.name ? key.name.toLowerCase() : "";
+      if (char) {
+        const directMatch = choices.find((c3) => c3.key.toLowerCase() === char);
+        if (directMatch) {
+          cleanup(directMatch);
+          return;
+        }
       }
+    };
+    process.stdin.on("keypress", onKeypress);
+    render();
+  });
+}
+async function promptToolApproval(params) {
+  const options = [
+    { key: "a", label: "Yes, and don't ask again for anything (always-approve mode)", value: "always" },
+    { key: "y", label: "Yes, proceed", value: "yes", isDefault: true },
+    { key: "n", label: "No, reject (type to add feedback)", value: "no" }
+  ];
+  const title = params.description || `Tool Execution: ${params.toolName}`;
+  const command = params.command || params.toolName;
+  const BORDER = "\x1B[38;5;8m\u2502\x1B[0m";
+  const FG = "\x1B[38;2;225;225;225m";
+  const MUTED = "\x1B[38;2;139;139;144m";
+  const DIM = "\x1B[38;2;108;108;108m";
+  const RESET2 = "\x1B[0m";
+  console.log();
+  console.log(`  ${BORDER} ${FG}${title}${RESET2}`);
+  console.log(`  ${BORDER} ${MUTED}${command}${RESET2}`);
+  console.log(`  ${BORDER}`);
+  const renderCard = (selected) => {
+    for (let i = 0;i < options.length; i++) {
+      const opt = options[i];
+      const active = i === selected;
+      const radio = active ? `${FG}(\u25CF)${RESET2}` : `${DIM}(\u25CB)${RESET2}`;
+      const num = `${FG}${i + 1}${RESET2}`;
+      const label = active ? `\x1B[1m${FG}${opt.label}${RESET2}` : `${MUTED}${opt.label}${RESET2}`;
+      console.log(`  ${BORDER} ${num} ${radio} ${label}`);
     }
+    console.log(`  ${BORDER}`);
+    console.log(`  ${FG}${selected + 1}/${options.length}${RESET2}${DIM}:select \u2502 ${FG}Ctrl+o${RESET2}${DIM}:yolo \u2502 ${FG}Ctrl+c${RESET2}${DIM}:cancel${RESET2}`);
+  };
+  if (!process.stdin.isTTY || false || !process.stdin.readable) {
+    renderCard(1);
+    return "yes";
   }
+  return new Promise((resolve18) => {
+    let selectedIndex = 1;
+    readline2.emitKeypressEvents(process.stdin);
+    const wasRaw = process.stdin.isRaw;
+    try {
+      process.stdin.setRawMode(true);
+    } catch {}
+    process.stdin.resume();
+    const render = () => {
+      renderCard(selectedIndex);
+    };
+    const cleanup = (val) => {
+      process.stdin.removeListener("keypress", onKeypress);
+      try {
+        process.stdin.setRawMode(wasRaw ?? false);
+      } catch {}
+      console.log();
+      resolve18(val);
+    };
+    const onKeypress = (_str, key) => {
+      if (!key)
+        return;
+      if (key.ctrl && key.name === "c") {
+        cleanup("no");
+        return;
+      }
+      if (key.ctrl && key.name === "o") {
+        cleanup("always");
+        return;
+      }
+      if (key.name === "up") {
+        selectedIndex = (selectedIndex - 1 + options.length) % options.length;
+        process.stdout.write(`\x1B[5A`);
+        render();
+        return;
+      }
+      if (key.name === "down") {
+        selectedIndex = (selectedIndex + 1) % options.length;
+        process.stdout.write(`\x1B[5A`);
+        render();
+        return;
+      }
+      if (key.name === "return" || key.name === "enter" || _str === " ") {
+        cleanup(options[selectedIndex].value);
+        return;
+      }
+      if (_str === "1") {
+        cleanup(options[0].value);
+        return;
+      }
+      if (_str === "2") {
+        cleanup(options[1].value);
+        return;
+      }
+      if (_str === "3") {
+        cleanup(options[2].value);
+        return;
+      }
+      if (_str?.toLowerCase() === "y") {
+        cleanup("yes");
+        return;
+      }
+      if (_str?.toLowerCase() === "n") {
+        cleanup("no");
+        return;
+      }
+      if (_str?.toLowerCase() === "a") {
+        cleanup("always");
+        return;
+      }
+    };
+    process.stdin.on("keypress", onKeypress);
+    render();
+  });
 }
-// src/security/scanner.ts
-import { existsSync as existsSync19, readdirSync as readdirSync6, readFileSync as readFileSync14, statSync as statSync3 } from "fs";
-import { join as join10, relative as relative2, resolve as resolve19 } from "path";
-var SECURITY_RULES = [
-  {
-    id: "SEC-001",
-    category: "Secrets Leakage",
-    severity: "CRITICAL",
-    pattern: /sk-(?:proj-)?[A-Za-z0-9-_]{20,}/,
-    description: "Hardcoded OpenAI API key detected in source code.",
-    recommendation: "Store API keys in environment variables (e.g. process.env.OPENAI_API_KEY) or a secure vault."
-  },
-  {
-    id: "SEC-002",
+async function promptUserQuestion(params) {
+  const { question, options = [] } = params;
+  const boxWidth = Math.min(process.stdout.columns ?? 80, 75);
+  const border = "\u2500".repeat(Math.max(10, boxWidth - 20));
+  console.log(`
+  ${style.cyan("\u250C\u2500\u2500")} ${style.bold("AI Question")} ${style.cyan(border)}`);
+  const qLines = question.split(`
+`);
+  for (const line of qLines) {
+    console.log(`  ${style.cyan("\u2502")}  ${style.bold(line)}`);
+  }
+  if (options.length > 0) {
+    console.log(`  ${style.cyan("\u2502")}`);
+    options.forEach((opt, idx) => {
+      const numTag = style.cyan(`[${idx + 1}]`);
+      const isRec = opt.includes("(Recommended)") || opt.includes("(recommended)");
+      const optText = isRec ? opt.replace(/\(Recommended\)/i, style.green("(Recommended)")) : opt;
+      console.log(`  ${style.cyan("\u2502")}  ${numTag} ${optText}`);
+    });
+  }
+  console.log(`  ${style.cyan("\u2514" + "\u2500".repeat(Math.max(10, boxWidth - 4)))}
+`);
+  if (!process.stdin.isTTY || false || !process.stdin.readable) {
+    return options[0] || "yes";
+  }
+  return new Promise((resolve18) => {
+    const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
+    const promptLabel = options.length > 0 ? `Select [1-${options.length}] or type custom response: ` : `Your response: `;
+    rl.question(`  ${style.bold(promptLabel)}`, (answer) => {
+      rl.close();
+      const trimmed = answer.trim();
+      if (!trimmed) {
+        const fallback = options[0] || "";
+        console.log(style.dim(`  \u21B3 Default: ${fallback || "(empty)"}
+`));
+        resolve18(fallback);
+        return;
+      }
+      const num = parseInt(trimmed, 10);
+      if (!isNaN(num) && num >= 1 && num <= options.length) {
+        const picked = options[num - 1];
+        console.log(style.green(`  \u2714 Selected: ${picked}
+`));
+        resolve18(picked);
+        return;
+      }
+      if (options.length === 2) {
+        if (/^(y|yes)$/i.test(trimmed)) {
+          console.log(style.green(`  \u2714 Selected: ${options[0]}
+`));
+          resolve18(options[0]);
+          return;
+        }
+        if (/^(n|no)$/i.test(trimmed)) {
+          console.log(style.green(`  \u2714 Selected: ${options[1]}
+`));
+          resolve18(options[1]);
+          return;
+        }
+      }
+      console.log(style.green(`  \u2714 Answer: ${trimmed}
+`));
+      resolve18(trimmed);
+    });
+  });
+}
+async function promptInteractiveList(config) {
+  const {
+    title,
+    items,
+    mode = "select",
+    defaultIndex = 0,
+    maxVisible = 8,
+    emptyMessage = "No items available.",
+    onToggle,
+    onAction,
+    customKeyHints
+  } = config;
+  if (!process.stdin.isTTY || false || !process.stdin.readable) {
+    return {
+      selectedIndex: defaultIndex,
+      selectedItem: items[defaultIndex] || items[0],
+      action: "select"
+    };
+  }
+  if (items.length === 0) {
+    console.log(`
+  ${style.dim(emptyMessage)}
+`);
+    return { selectedIndex: -1, action: "close" };
+  }
+  return new Promise((resolve18) => {
+    let selectedIndex = Math.max(0, Math.min(defaultIndex, items.length - 1));
+    let scrollTop = 0;
+    let renderedLines = 0;
+    readline2.emitKeypressEvents(process.stdin);
+    const wasRaw = process.stdin.isRaw;
+    try {
+      process.stdin.setRawMode(true);
+    } catch {}
+    process.stdin.resume();
+    process.stdout.write("\x1B[?25l");
+    const BOX_WIDTH = Math.min(process.stdout.columns ?? 80, 76);
+    const ensureVisible = () => {
+      const visibleCount = Math.min(items.length, maxVisible);
+      if (selectedIndex < scrollTop) {
+        scrollTop = selectedIndex;
+      } else if (selectedIndex >= scrollTop + visibleCount) {
+        scrollTop = selectedIndex + 1 - visibleCount;
+      }
+      if (scrollTop < 0)
+        scrollTop = 0;
+      const maxScroll = Math.max(0, items.length - visibleCount);
+      if (scrollTop > maxScroll)
+        scrollTop = maxScroll;
+    };
+    const render = () => {
+      ensureVisible();
+      const visibleCount = Math.min(items.length, maxVisible);
+      const visibleItems = items.slice(scrollTop, scrollTop + visibleCount);
+      const lines = [];
+      const headerBorder = "\u2500".repeat(Math.max(10, BOX_WIDTH - title.length - 8));
+      lines.push(`  \x1B[38;2;140;140;150m\u250C\u2500\u2500\x1B[0m ${style.bold(title)} \x1B[38;2;140;140;150m${headerBorder}\u2510\x1B[0m`);
+      for (let i = 0;i < visibleItems.length; i++) {
+        const item = visibleItems[i];
+        const actualIdx = scrollTop + i;
+        const isCurrent = actualIdx === selectedIndex;
+        const marker = isCurrent ? "\x1B[38;2;217;119;87m\u276F\x1B[0m" : " ";
+        let checkSymbol = "";
+        if (mode === "toggle") {
+          checkSymbol = item.checked ? "\x1B[38;2;78;169;111m[\u2714 ENABLED]\x1B[0m " : "\x1B[38;2;120;120;125m[\u25CB DISABLED]\x1B[0m";
+        } else if (item.checked !== undefined) {
+          checkSymbol = item.checked ? "\x1B[38;2;78;169;111m(\u25CF)\x1B[0m " : "\x1B[38;2;120;120;125m(\u25CB)\x1B[0m ";
+        }
+        const badgeStr = item.badge ? ` ${style.dim(`(${item.badge})`)}` : "";
+        const labelStr = isCurrent ? style.bold(item.label) : item.label;
+        lines.push(`  \x1B[38;2;140;140;150m\u2502\x1B[0m ${marker} ${checkSymbol} ${labelStr}${badgeStr}`);
+        if (item.description) {
+          const descIndent = " ".repeat(mode === "toggle" ? 17 : 7);
+          const maxDescLen = BOX_WIDTH - descIndent.length - 6;
+          const trimmedDesc = item.description.length > maxDescLen ? item.description.slice(0, maxDescLen - 3) + "..." : item.description;
+          lines.push(`  \x1B[38;2;140;140;150m\u2502\x1B[0m ${descIndent}${style.dim(trimmedDesc)}`);
+        }
+      }
+      const moreAbove = scrollTop;
+      const moreBelow = Math.max(0, items.length - (scrollTop + visibleCount));
+      let scrollInfo = "";
+      if (moreAbove > 0 && moreBelow > 0) {
+        scrollInfo = `[\u2191 ${moreAbove} more \xB7 \u2193 ${moreBelow} more]`;
+      } else if (moreBelow > 0) {
+        scrollInfo = `[\u2193 ${moreBelow} more below]`;
+      } else if (moreAbove > 0) {
+        scrollInfo = `[\u2191 ${moreAbove} more above]`;
+      }
+      const defaultHints = mode === "toggle" ? "\u2191/\u2193: navigate \xB7 Space: toggle \xB7 a: all \xB7 d: none \xB7 Enter/Esc: done" : "\u2191/\u2193: navigate \xB7 Enter: select \xB7 Esc: cancel";
+      const hintText = customKeyHints || (scrollInfo ? `${scrollInfo} ${defaultHints}` : defaultHints);
+      lines.push(`  \x1B[38;2;140;140;150m\u2502\x1B[0m`);
+      lines.push(`  \x1B[38;2;140;140;150m\u2502\x1B[0m  ${style.dim(hintText)}`);
+      lines.push(`  \x1B[38;2;140;140;150m\u2514\u2500\u2500${"\u2500".repeat(Math.max(10, BOX_WIDTH - 6))}\u2518\x1B[0m`);
+      let buffer = "";
+      if (renderedLines > 0) {
+        buffer += `\x1B[${renderedLines}A\r`;
+      }
+      buffer += lines.map((l) => `\x1B[2K${l}`).join(`
+`) + `
+`;
+      if (renderedLines > lines.length) {
+        buffer += "\x1B[J";
+      }
+      process.stdout.write(buffer);
+      renderedLines = lines.length;
+    };
+    const cleanup = (res) => {
+      if (renderedLines > 0) {
+        process.stdout.write(`\x1B[${renderedLines}A\r\x1B[J\x1B[?25h`);
+        renderedLines = 0;
+      } else {
+        process.stdout.write("\x1B[?25h");
+      }
+      process.stdin.removeListener("keypress", onKeypress);
+      try {
+        process.stdin.setRawMode(wasRaw ?? false);
+      } catch {}
+      resolve18(res);
+    };
+    const onKeypress = async (_str, key) => {
+      if (!key)
+        return;
+      if (key.ctrl && key.name === "c" || key.name === "escape" || _str === "q" || _str === "Q") {
+        cleanup({
+          selectedIndex,
+          selectedItem: items[selectedIndex],
+          action: "close"
+        });
+        return;
+      }
+      if (key.name === "up" || _str === "k") {
+        selectedIndex = (selectedIndex - 1 + items.length) % items.length;
+        render();
+        return;
+      }
+      if (key.name === "down" || _str === "j") {
+        selectedIndex = (selectedIndex + 1) % items.length;
+        render();
+        return;
+      }
+      if (_str === " " || _str === "t" || _str === "T") {
+        const item = items[selectedIndex];
+        if (item) {
+          item.checked = !item.checked;
+          if (onToggle) {
+            await onToggle(item, selectedIndex);
+          }
+        }
+        render();
+        return;
+      }
+      if (key.name === "return" || key.name === "enter") {
+        if (mode === "toggle") {
+          cleanup({
+            selectedIndex,
+            selectedItem: items[selectedIndex],
+            action: "close"
+          });
+        } else {
+          cleanup({
+            selectedIndex,
+            selectedItem: items[selectedIndex],
+            action: "select"
+          });
+        }
+        return;
+      }
+      if (_str && onAction) {
+        const item = items[selectedIndex];
+        const shouldExit = await onAction(_str.toLowerCase(), item, selectedIndex);
+        if (shouldExit) {
+          cleanup({
+            selectedIndex,
+            selectedItem: item,
+            action: "custom",
+            keyName: _str.toLowerCase()
+          });
+          return;
+        }
+        render();
+      }
+    };
+    process.stdin.on("keypress", onKeypress);
+    render();
+  });
+}
+
+// src/security/scanner.ts
+import { existsSync as existsSync18, readdirSync as readdirSync5, readFileSync as readFileSync13, statSync as statSync3 } from "fs";
+import { join as join9, relative as relative2, resolve as resolve18 } from "path";
+var SECURITY_RULES = [
+  {
+    id: "SEC-001",
+    category: "Secrets Leakage",
+    severity: "CRITICAL",
+    pattern: /sk-(?:proj-)?[A-Za-z0-9-_]{20,}/,
+    description: "Hardcoded OpenAI API key detected in source code.",
+    recommendation: "Store API keys in environment variables (e.g. process.env.OPENAI_API_KEY) or a secure vault."
+  },
+  {
+    id: "SEC-002",
     category: "Secrets Leakage",
     severity: "CRITICAL",
     pattern: /AKIA[0-9A-Z]{16}/,
@@ -6923,24 +7418,24 @@ var IGNORED_FILES = new Set([
 ]);
 async function runSecurityScan(targetDir, options = {}) {
   const startTime = performance.now();
-  const root = resolve19(targetDir);
+  const root = resolve18(targetDir);
   const isDirectTestDir = targetDir.includes("test") || Boolean(options.includeTests);
   const maxFiles = options.maxFiles || 2000;
   const findings = [];
   let scannedCount = 0;
   function walk(current) {
-    if (scannedCount >= maxFiles || !existsSync19(current))
+    if (scannedCount >= maxFiles || !existsSync18(current))
       return;
     let entries;
     try {
-      entries = readdirSync6(current);
+      entries = readdirSync5(current);
     } catch {
       return;
     }
     for (const entry of entries) {
       if (scannedCount >= maxFiles)
         break;
-      const fullPath = join10(current, entry);
+      const fullPath = join9(current, entry);
       let stat;
       try {
         stat = statSync3(fullPath);
@@ -6971,7 +7466,7 @@ async function runSecurityScan(targetDir, options = {}) {
   function scanFile(filePath, baseRoot, ext, out) {
     let content;
     try {
-      content = readFileSync14(filePath, "utf8");
+      content = readFileSync13(filePath, "utf8");
     } catch {
       return;
     }
@@ -7018,41 +7513,40 @@ async function runSecurityScan(targetDir, options = {}) {
 }
 
 // src/mcp/servers/chrome-devtools/index.ts
-import { resolve as resolve20 } from "path";
+import { resolve as resolve19 } from "path";
 
 // src/mcp/servers/chrome-devtools/server.ts
 if (false) {}
 
 // src/mcp/servers/chrome-devtools/index.ts
 var __dirname = "/home/runner/work/agent-cli/agent-cli/src/mcp/servers/chrome-devtools";
-var CHROME_DEVTOOLS_MCP_SERVER_PATH = resolve20(__dirname, "server.ts");
+var CHROME_DEVTOOLS_MCP_SERVER_PATH = resolve19(__dirname, "server.ts");
 
 // src/mcp/servers/web-search/index.ts
-import { resolve as resolve21 } from "path";
+import { resolve as resolve20 } from "path";
 
 // src/mcp/servers/web-search/server.ts
 if (false) {}
 
 // src/mcp/servers/web-search/index.ts
 var __dirname = "/home/runner/work/agent-cli/agent-cli/src/mcp/servers/web-search";
-var WEB_SEARCH_MCP_SERVER_PATH = resolve21(__dirname, "server.ts");
+var WEB_SEARCH_MCP_SERVER_PATH = resolve20(__dirname, "server.ts");
 
 // src/mcp/servers/sqlite/index.ts
-import { resolve as resolve22 } from "path";
+import { resolve as resolve21 } from "path";
 
 // src/mcp/servers/sqlite/server.ts
 if (false) {}
 
 // src/mcp/servers/sqlite/index.ts
 var __dirname = "/home/runner/work/agent-cli/agent-cli/src/mcp/servers/sqlite";
-var SQLITE_MCP_SERVER_PATH = resolve22(__dirname, "server.ts");
+var SQLITE_MCP_SERVER_PATH = resolve21(__dirname, "server.ts");
 
 // src/cli/commands.ts
 var AVAILABLE_SLASH_COMMANDS = [
   { name: "/help", description: "Show command list and help menu" },
   { name: "/stats", description: "Display session runtime, turn stats & sub-agent status" },
   { name: "/model", description: "Select or switch active AI model" },
-  { name: "/models", description: "List available AI models from gateway" },
   { name: "/reasoning", description: "Toggle internal reasoning chain visibility" },
   { name: "/login", description: "Authenticate with backend provider" },
   { name: "/whoami", description: "Check backend authentication status" },
@@ -7060,11 +7554,11 @@ var AVAILABLE_SLASH_COMMANDS = [
   { name: "/memories", description: "View learned preferences & memories" },
   { name: "/worktrees", description: "List active isolated Git Worktrees" },
   { name: "/sessions", description: "List saved past sessions from SQLite store" },
-  { name: "/roles", description: "List available agent roles & nicknames" },
+  { name: "/role", description: "Select and inspect specialized agent roles & personas" },
   { name: "/security", description: "Scan codebase for vulnerabilities & secrets (Strix)" },
   { name: "/agents", description: "List active sub-agents & execution status" },
   { name: "/mcp", description: "List connected Model Context Protocol servers" },
-  { name: "/animate", description: "Preview 36-frame ASCII art animation variants" },
+  { name: "/release-notes", description: "View changelog and what's new in this version" },
   { name: "/compact", description: "Trigger manual token history compaction" },
   { name: "/clear", description: "Clear terminal screen" },
   { name: "/logout", description: "Clear stored authentication credentials" },
@@ -7077,7 +7571,7 @@ async function handleSlashCommand(input, ctx) {
     case "/":
     case "/?":
     case "/help":
-      printHelp();
+      await printHelp(ctx);
       return true;
     case "/stats":
     case "/time":
@@ -7091,17 +7585,7 @@ async function handleSlashCommand(input, ctx) {
     case "/reasoning":
     case "/think":
     case "/thinking":
-      if (ctx.repl) {
-        ctx.repl.showReasoning = !ctx.repl.showReasoning;
-        const stateStr = ctx.repl.showReasoning ? style.green("Visible") : style.yellow("Hidden (default)");
-        console.log(`
-  Reasoning display: [${stateStr}]
-`);
-      } else {
-        console.log(style.dim(`
-  Reasoning display is hidden by default.
-`));
-      }
+      await handleReasoningCommand(ctx, args[0]);
       return true;
     case "/login":
       await handleInteractiveLogin(args[0]);
@@ -7113,8 +7597,9 @@ async function handleSlashCommand(input, ctx) {
       new CredentialsStore().clear();
       console.log(style.green("Successfully logged out. Credentials cleared."));
       return true;
+    case "/role":
     case "/roles":
-      printRoles(ctx);
+      await handleRolesCommand(ctx, args[0]);
       return true;
     case "/agents":
       printAgents(ctx);
@@ -7124,7 +7609,7 @@ async function handleSlashCommand(input, ctx) {
       return true;
     case "/skills":
     case "/skill":
-      handleSkillsCommand(ctx, args);
+      await handleSkillsCommand(ctx, args);
       return true;
     case "/memories":
     case "/memory":
@@ -7135,7 +7620,8 @@ async function handleSlashCommand(input, ctx) {
       await printWorktrees(ctx);
       return true;
     case "/sessions":
-      printSessions(ctx);
+    case "/session":
+      await printSessions(ctx);
       return true;
     case "/security":
     case "/audit":
@@ -7143,9 +7629,13 @@ async function handleSlashCommand(input, ctx) {
     case "/pentest":
       await handleSecurityCommand(ctx, args);
       return true;
-    case "/animate":
-    case "/animation":
-      await handleAnimate(args[0]);
+    case "/release-notes":
+    case "/release-note":
+    case "/releasenotes":
+    case "/releasenote":
+    case "/changelog":
+    case "/whatsnew":
+      printReleaseNotes();
       return true;
     case "/compact":
       console.log(style.brand("\u25C6 Compacting conversation history..."));
@@ -7174,75 +7664,133 @@ async function handleSlashCommand(input, ctx) {
       return true;
   }
 }
-function printHelp() {
-  console.log();
-  console.log(style.bold("  Available Slash Commands:"));
-  for (const cmd of AVAILABLE_SLASH_COMMANDS) {
-    const pad = cmd.name.padEnd(12, " ");
-    console.log(`    ${style.cyan(pad)} ${style.dim(cmd.description)}`);
+async function printHelp(ctx) {
+  if (!process.stdin.isTTY || false || !process.stdin.readable) {
+    console.log();
+    console.log(style.bold("  Available Slash Commands:"));
+    for (const cmd of AVAILABLE_SLASH_COMMANDS) {
+      const pad = cmd.name.padEnd(12, " ");
+      console.log(`    ${style.cyan(pad)} ${style.dim(cmd.description)}`);
+    }
+    console.log();
+    return;
   }
-  console.log();
+  const items = AVAILABLE_SLASH_COMMANDS.map((c4) => ({
+    id: c4.name,
+    label: c4.name,
+    description: c4.description
+  }));
+  const res = await promptInteractiveList({
+    title: "\u26A1 Slash Commands Palette",
+    items,
+    mode: "select",
+    maxVisible: 10,
+    customKeyHints: "\u2191/\u2193: navigate \xB7 Enter: run command \xB7 Esc: close"
+  });
+  if (res.action === "select" && res.selectedItem && ctx) {
+    console.log(style.dim(`
+  Executing ${res.selectedItem.id} ...
+`));
+    await handleSlashCommand(res.selectedItem.id, ctx);
+  }
+}
+async function handleReasoningCommand(ctx, arg) {
+  if (!ctx.repl) {
+    console.log(style.dim(`
+  Reasoning display is hidden by default.
+`));
+    return;
+  }
+  if (arg) {
+    const lower = arg.toLowerCase();
+    if (lower === "on" || lower === "show" || lower === "true") {
+      ctx.repl.showReasoning = true;
+    } else if (lower === "off" || lower === "hide" || lower === "false") {
+      ctx.repl.showReasoning = false;
+    } else {
+      ctx.repl.showReasoning = !ctx.repl.showReasoning;
+    }
+    const stateStr2 = ctx.repl.showReasoning ? style.green("Visible") : style.yellow("Hidden (default)");
+    console.log(`
+  Reasoning display: [${stateStr2}]
+`);
+    return;
+  }
+  const current = ctx.repl.showReasoning;
+  const choice = await promptChoice({
+    message: `AI Reasoning Stream (Currently: ${current ? "Visible" : "Hidden"}):`,
+    choices: [
+      { key: "h", label: "Hidden (in spinner)", value: false, isDefault: !current },
+      { key: "v", label: "Visible (live stream)", value: true, isDefault: current },
+      { key: "t", label: "Toggle state", value: !current }
+    ],
+    defaultIndex: current ? 1 : 0
+  });
+  ctx.repl.showReasoning = choice;
+  const stateStr = ctx.repl.showReasoning ? style.green("Visible") : style.yellow("Hidden (default)");
+  console.log(`
+  Reasoning display updated to: [${stateStr}]
+`);
 }
 async function handleModelSelection(ctx, modelArg) {
+  const credStore = new CredentialsStore;
   if (modelArg && modelArg.trim().length > 0) {
     const chosen = modelArg.trim();
     ctx.session.model = chosen;
+    credStore.setDefaultModel(chosen);
     console.log(style.green(`
-\u2713 Active model switched to: ${style.bold(chosen)}
+  \u2713 Default model switched and saved to: ${style.bold(chosen)}
 `));
     return;
   }
-  const creds = new CredentialsStore().load();
+  const creds = credStore.load();
   const baseUrl = creds?.baseUrl || process.env.GROUPY_BASE_URL || "https://api.groupy-hub.store/v1";
   const apiKey = creds?.accessToken || process.env.GROUPY_API_KEY;
-  console.log(style.dim(`
-  Fetching models from ${baseUrl}/models ...`));
   let models = [];
   try {
     const headers = {};
     if (apiKey)
       headers["Authorization"] = `Bearer ${apiKey}`;
-    const res = await fetch(`${baseUrl}/models`, { headers });
-    if (res.ok) {
-      const data = await res.json();
+    const res2 = await fetch(`${baseUrl}/models`, { headers });
+    if (res2.ok) {
+      const data = await res2.json();
       models = data.data || [];
     }
   } catch {}
-  console.log();
-  console.log(style.bold("  Available Models:"));
   if (models.length === 0) {
-    console.log(style.dim("    (No remote models returned by provider)"));
-    console.log(`    Current Model: ${style.brandBold(ctx.session.model)}`);
-  } else {
-    for (let i = 0;i < models.length; i++) {
-      const m = models[i];
-      const isActive = m.id.toLowerCase() === ctx.session.model.toLowerCase();
-      const tag = isActive ? style.green(" (active)") : "";
-      const owner = m.owned_by ? style.dim(` (${m.owned_by})`) : "";
-      console.log(`    [${style.cyan(String(i + 1))}] ${style.bold(m.id)}${owner}${tag}`);
-    }
-  }
-  console.log();
-  const promptText = models.length > 0 ? `  Select model [1-${models.length}] or type model name: ` : `  Enter new model name: `;
-  const promptEditor = new InteractiveLineEditor({ promptSymbol: promptText });
-  const rawAnswer = await promptEditor.readLine();
-  const answer = rawAnswer.trim();
-  if (!answer) {
-    console.log(style.dim(`  Model unchanged.
-`));
-    return;
+    models = [
+      { id: "gemini-2.5-flash", owned_by: "google" },
+      { id: "claude-3-5-sonnet", owned_by: "anthropic" },
+      { id: "claude-3-7-sonnet", owned_by: "anthropic" },
+      { id: "gpt-4o", owned_by: "openai" },
+      { id: "deepseek-r1", owned_by: "deepseek" },
+      { id: "qwen-2.5-coder", owned_by: "alibaba" }
+    ];
   }
-  const num = parseInt(answer, 10);
-  if (!isNaN(num) && num >= 1 && num <= models.length) {
-    const chosen = models[num - 1].id;
+  const items = models.map((m) => ({
+    id: m.id,
+    label: m.id,
+    badge: m.owned_by ? `provider: ${m.owned_by}` : undefined,
+    checked: m.id.toLowerCase() === ctx.session.model.toLowerCase()
+  }));
+  const activeIdx = Math.max(0, models.findIndex((m) => m.id.toLowerCase() === ctx.session.model.toLowerCase()));
+  const res = await promptInteractiveList({
+    title: `\uD83E\uDD16 Select Default AI Model (Current: ${ctx.session.model})`,
+    items,
+    mode: "select",
+    defaultIndex: activeIdx,
+    customKeyHints: "\u2191/\u2193: navigate \xB7 Enter: set as default model \xB7 Esc: keep current"
+  });
+  if (res.action === "select" && res.selectedItem) {
+    const chosen = res.selectedItem.id;
     ctx.session.model = chosen;
+    credStore.setDefaultModel(chosen);
     console.log(style.green(`
-  \u2713 Active model switched to: ${style.bold(chosen)}
+  \u2713 Default model switched and saved to: ${style.bold(chosen)}
 `));
   } else {
-    ctx.session.model = answer;
-    console.log(style.green(`
-  \u2713 Active model switched to: ${style.bold(answer)}
+    console.log(style.dim(`
+  Model unchanged.
 `));
   }
 }
@@ -7313,25 +7861,100 @@ async function printWorktrees(ctx) {
     return;
   }
   const worktrees = await manager.listWorktrees(ctx.session.cwd);
-  console.log();
   if (worktrees.length === 0) {
-    console.log(style.dim("  No Git Worktrees active or directory is not a Git repo."));
-  } else {
+    console.log(style.dim(`
+  No Git Worktrees active or directory is not a Git repo.
+`));
+    return;
+  }
+  if (!process.stdin.isTTY || false || !process.stdin.readable) {
+    console.log();
     console.log(style.bold("  Active Git Worktrees:"));
     for (const w of worktrees) {
       const typeTag = w.isMain ? style.cyan("[MAIN]") : style.yellow("[ISOLATED WORKTREE]");
       console.log(`    \u2022 ${typeTag} ${style.bold(w.branch)}: ${style.dim(w.path)}`);
     }
+    console.log();
+    return;
   }
-  console.log();
+  const items = worktrees.map((w) => ({
+    id: w.branch,
+    label: `${w.isMain ? "[MAIN]" : "[WORKTREE]"} ${w.branch}`,
+    description: w.path,
+    badge: w.isMain ? "main repo" : "isolated"
+  }));
+  await promptInteractiveList({
+    title: `\uD83C\uDF33 Active Git Worktrees (${worktrees.length} branches)`,
+    items,
+    mode: "select",
+    customKeyHints: "\u2191/\u2193: navigate \xB7 Esc: exit"
+  });
 }
-function printRoles(ctx) {
+async function handleRolesCommand(ctx, roleArg) {
   const spawner = ctx.spawner;
-  if (!spawner) {
-    console.log(style.yellow("Multi-agent spawner not active."));
+  const roleRegistry = spawner?.roleRegistry || new AgentRoleRegistry;
+  const roles = roleRegistry.listRoles();
+  if (roleArg) {
+    const role = roleRegistry.getRole(roleArg.toLowerCase());
+    if (role) {
+      displayRoleDetails(role);
+      return;
+    } else {
+      console.log(style.yellow(`
+  Unknown role: "${roleArg}". Available roles: ${roles.map((r) => r.name).join(", ")}
+`));
+      return;
+    }
+  }
+  if (!process.stdin.isTTY || false || !process.stdin.readable) {
+    printRoles(ctx);
     return;
   }
-  const roles = spawner.roleRegistry.listRoles();
+  const items = roles.map((r) => {
+    const tools4 = r.allowedToolNames ? r.allowedToolNames.join(", ") : "all tools";
+    return {
+      id: r.name,
+      label: r.name,
+      description: `${r.description} \xB7 [${tools4}]`,
+      badge: r.name === "default" ? "primary" : undefined
+    };
+  });
+  const res = await promptInteractiveList({
+    title: `\uD83C\uDFAD Agent Roles & Specialized Personas (${roles.length} roles)`,
+    items,
+    mode: "select",
+    customKeyHints: "\u2191/\u2193: navigate \xB7 Enter: view details \xB7 Esc: close"
+  });
+  if (res.action === "select" && res.selectedItem) {
+    const role = roleRegistry.getRole(res.selectedItem.id);
+    if (role) {
+      displayRoleDetails(role);
+    }
+  }
+}
+function displayRoleDetails(role) {
+  const boxWidth = Math.min(process.stdout.columns ?? 80, 75);
+  const border = "\u2500".repeat(Math.max(10, boxWidth - role.name.length - 16));
+  const tools4 = role.allowedToolNames ? role.allowedToolNames.join(", ") : "all tools";
+  const nicks = role.nicknameCandidates ? role.nicknameCandidates.join(", ") : "none";
+  console.log();
+  console.log(`  ${style.cyan("\u250C\u2500\u2500")} ${style.bold(`Role: ${role.name}`)} ${style.cyan(border)}`);
+  console.log(`  ${style.cyan("\u2502")}  ${style.bold("Description:")} ${role.description}`);
+  console.log(`  ${style.cyan("\u2502")}  ${style.bold("Allowed Tools:")} ${style.dim(`[${tools4}]`)}`);
+  console.log(`  ${style.cyan("\u2502")}  ${style.bold("Nicknames:")} ${style.dim(`[${nicks}]`)}`);
+  console.log(`  ${style.cyan("\u2502")}`);
+  console.log(`  ${style.cyan("\u2502")}  ${style.bold("System Prompt:")}`);
+  for (const line of role.systemPrompt.split(`
+`)) {
+    console.log(`  ${style.cyan("\u2502")}    ${style.dim(line)}`);
+  }
+  console.log(`  ${style.cyan("\u2514" + "\u2500".repeat(Math.max(10, boxWidth - 4)))}
+`);
+}
+function printRoles(ctx) {
+  const spawner = ctx.spawner;
+  const roleRegistry = spawner?.roleRegistry || new AgentRoleRegistry;
+  const roles = roleRegistry.listRoles();
   console.log();
   console.log(style.bold("  Configured Agent Roles:"));
   for (const r of roles) {
@@ -7368,7 +7991,7 @@ function printAgents(ctx) {
   }
   console.log();
 }
-function handleSkillsCommand(ctx, args) {
+async function handleSkillsCommand(ctx, args) {
   const loader = ctx.skillsLoader;
   if (!loader) {
     console.log(style.yellow("Skills loader not active."));
@@ -7416,10 +8039,14 @@ function handleSkillsCommand(ctx, args) {
     return;
   }
   const skills = loader.listSkills(ctx.session.cwd, { includeDisabled: true });
-  console.log();
   if (skills.length === 0) {
-    console.log(style.dim("  No domain skills discovered in .agents/skills/ or ~/.groupy/skills/"));
-  } else {
+    console.log(style.dim(`
+  No domain skills discovered in .agents/skills/ or ~/.groupy/skills/
+`));
+    return;
+  }
+  if (!process.stdin.isTTY || false || !process.stdin.readable) {
+    console.log();
     console.log(style.bold("  Available Domain Skills (Built-in, Workspace, & Global):"));
     for (const s of skills) {
       const isEnabled = !loader.isSkillDisabled(s.name);
@@ -7429,9 +8056,43 @@ function handleSkillsCommand(ctx, args) {
       console.log(`      ${style.dim(s.description)}`);
     }
     console.log();
-    console.log(style.dim("  Commands: /skills disable <name> | /skills enable <name> | /skills toggle <name>"));
+    return;
   }
-  console.log();
+  const items = skills.map((s) => ({
+    id: s.name,
+    label: s.name,
+    description: s.description,
+    badge: s.scope,
+    checked: !loader.isSkillDisabled(s.name)
+  }));
+  await promptInteractiveList({
+    title: `\uD83E\uDDE9 Domain Skills Manager (${skills.length} available)`,
+    items,
+    mode: "toggle",
+    maxVisible: 8,
+    onToggle: (item) => {
+      loader.toggleSkill(item.id);
+    },
+    onAction: (key) => {
+      if (key === "a") {
+        for (const s of skills)
+          loader.enableSkill(s.name);
+        for (const it of items)
+          it.checked = true;
+      } else if (key === "d") {
+        for (const s of skills)
+          loader.disableSkill(s.name);
+        for (const it of items)
+          it.checked = false;
+      }
+      return false;
+    },
+    customKeyHints: "\u2191/\u2193: navigate \xB7 Space: toggle on/off \xB7 a: all on \xB7 d: all off \xB7 Enter/Esc: done"
+  });
+  const activeCount = skills.filter((s) => !loader.isSkillDisabled(s.name)).length;
+  console.log(`
+  ${style.green("\u2713")} Skills configuration updated: ${style.bold(String(activeCount))} active, ${style.dim(`${skills.length - activeCount} disabled`)}
+`);
 }
 function printMemories(ctx) {
   const store2 = ctx.memoryStore;
@@ -7451,24 +8112,63 @@ function printMemories(ctx) {
   }
   console.log();
 }
-function printSessions(ctx) {
+async function printSessions(ctx) {
   const storage = ctx.storageManager;
   if (!storage) {
     console.log(style.yellow("Session persistence manager not active."));
     return;
   }
   const threads = storage.listSessions();
-  console.log();
   if (threads.length === 0) {
-    console.log(style.dim("  No saved sessions in SQLite database."));
-  } else {
+    console.log(style.dim(`
+  No saved sessions in SQLite database.
+`));
+    return;
+  }
+  if (!process.stdin.isTTY || false || !process.stdin.readable) {
+    console.log();
     console.log(style.bold("  Saved Sessions in SQLite Store:"));
     for (const t of threads) {
       const dateStr = new Date(t.updatedAt).toLocaleString();
       console.log(`    \u2022 ${style.cyan(t.id)} [${style.dim(t.model)}] - ${style.dim(dateStr)} (${t.itemsCount} items)`);
     }
+    console.log();
+    return;
+  }
+  const items = threads.map((t) => {
+    const dateStr = new Date(t.updatedAt).toLocaleString();
+    return {
+      id: t.id,
+      label: t.id,
+      description: `${t.model} \xB7 ${t.itemsCount} items \xB7 ${dateStr}`
+    };
+  });
+  const res = await promptInteractiveList({
+    title: `\uD83D\uDDC4\uFE0F Saved SQLite Sessions (${threads.length} total)`,
+    items,
+    mode: "select",
+    onAction: (key, item, idx) => {
+      if (key === "d") {
+        storage.deleteSession(item.id);
+        items.splice(idx, 1);
+        console.log(style.yellow(`
+  \u2715 Deleted session ${item.id}`));
+      }
+      return false;
+    },
+    customKeyHints: "\u2191/\u2193: navigate \xB7 Enter: resume session \xB7 d: delete \xB7 Esc: exit"
+  });
+  if (res.action === "select" && res.selectedItem) {
+    const session = storage.loadSession(res.selectedItem.id);
+    if (session) {
+      ctx.session.setHistory(session.items);
+      if (session.thread.model)
+        ctx.session.model = session.thread.model;
+      console.log(style.green(`
+  \u2713 Resumed past session: ${style.bold(res.selectedItem.id)} (${session.items.length} items)
+`));
+    }
   }
-  console.log();
 }
 function printSessionStats(ctx) {
   const uptimeMs = ctx.repl ? Date.now() - ctx.repl.sessionStartTime : 0;
@@ -7503,38 +8203,6 @@ function printSessionStats(ctx) {
   console.log(style.bold("  \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   console.log();
 }
-async function handleAnimate(variantName) {
-  const chosen = variantName?.toLowerCase();
-  if (chosen && ALL_ANIMATION_VARIANTS.includes(chosen)) {
-    console.log(`
-  ${style.brand("\u25C6")} Playing 36-frame animation variant: ${style.bold(chosen)}...
-`);
-    const anim2 = new AsciiAnimation({
-      variant: chosen,
-      frameTickMs: 60,
-      colorFn: (frame) => style.brand(frame)
-    });
-    await anim2.play(2500, { clearScreen: false });
-    console.log();
-    return;
-  }
-  console.log();
-  console.log(style.bold("  36-Frame ASCII Art Animation Catalog:"));
-  for (const v of ALL_ANIMATION_VARIANTS) {
-    console.log(`    \u2022 ${style.cyan(v)} - ${style.dim(`/animate ${v}`)}`);
-  }
-  console.log(`
-  ${style.dim("Playing random variant for 2 seconds...")}
-`);
-  const anim = new AsciiAnimation({
-    variant: "default",
-    frameTickMs: 60,
-    colorFn: (frame) => style.brand(frame)
-  });
-  anim.pickRandomVariant();
-  await anim.play(2000);
-  console.log();
-}
 async function handleSecurityCommand(ctx, args) {
   const sub = (args[0] || "scan").toLowerCase();
   const target = args[1] || ctx.session.cwd;
@@ -7757,184 +8425,97 @@ async function handleMcpCommand(ctx, args) {
 `));
     return;
   }
-  CliFormatter.printMcpServers(manager.listServers(), manager.getLoadedConfigFiles());
-}
-
-// src/cli/ui/prompt.ts
-import readline2 from "readline";
-async function promptToolApproval(params) {
-  const options = [
-    { key: "a", label: "Yes, and don't ask again for anything (always-approve mode)", value: "always" },
-    { key: "y", label: "Yes, proceed", value: "yes", isDefault: true },
-    { key: "n", label: "No, reject (type to add feedback)", value: "no" }
-  ];
-  const title = params.description || `Tool Execution: ${params.toolName}`;
-  const command = params.command || params.toolName;
-  const BORDER = "\x1B[38;5;8m\u2502\x1B[0m";
-  const FG = "\x1B[38;2;225;225;225m";
-  const MUTED = "\x1B[38;2;139;139;144m";
-  const DIM = "\x1B[38;2;108;108;108m";
-  const RESET = "\x1B[0m";
-  console.log();
-  console.log(`  ${BORDER} ${FG}${title}${RESET}`);
-  console.log(`  ${BORDER} ${MUTED}${command}${RESET}`);
-  console.log(`  ${BORDER}`);
-  const renderCard = (selected) => {
-    for (let i = 0;i < options.length; i++) {
-      const opt = options[i];
-      const active = i === selected;
-      const radio = active ? `${FG}(\u25CF)${RESET}` : `${DIM}(\u25CB)${RESET}`;
-      const num = `${FG}${i + 1}${RESET}`;
-      const label = active ? `\x1B[1m${FG}${opt.label}${RESET}` : `${MUTED}${opt.label}${RESET}`;
-      console.log(`  ${BORDER} ${num} ${radio} ${label}`);
-    }
-    console.log(`  ${BORDER}`);
-    console.log(`  ${FG}${selected + 1}/${options.length}${RESET}${DIM}:select \u2502 ${FG}Ctrl+o${RESET}${DIM}:yolo \u2502 ${FG}Ctrl+c${RESET}${DIM}:cancel${RESET}`);
-  };
+  const servers = manager.listServers();
+  const configFiles = manager.getLoadedConfigFiles();
   if (!process.stdin.isTTY || false || !process.stdin.readable) {
-    renderCard(1);
-    return "yes";
-  }
-  return new Promise((resolve23) => {
-    let selectedIndex = 1;
-    readline2.emitKeypressEvents(process.stdin);
-    const wasRaw = process.stdin.isRaw;
-    try {
-      process.stdin.setRawMode(true);
-    } catch {}
-    process.stdin.resume();
-    const render = () => {
-      renderCard(selectedIndex);
-    };
-    const cleanup = (val) => {
-      process.stdin.removeListener("keypress", onKeypress);
-      try {
-        process.stdin.setRawMode(wasRaw ?? false);
-      } catch {}
-      console.log();
-      resolve23(val);
-    };
-    const onKeypress = (_str, key) => {
-      if (!key)
-        return;
-      if (key.ctrl && key.name === "c") {
-        cleanup("no");
-        return;
-      }
-      if (key.ctrl && key.name === "o") {
-        cleanup("always");
-        return;
-      }
-      if (key.name === "up") {
-        selectedIndex = (selectedIndex - 1 + options.length) % options.length;
-        process.stdout.write(`\x1B[5A`);
-        render();
-        return;
-      }
-      if (key.name === "down") {
-        selectedIndex = (selectedIndex + 1) % options.length;
-        process.stdout.write(`\x1B[5A`);
-        render();
-        return;
-      }
-      if (key.name === "return" || key.name === "enter" || _str === " ") {
-        cleanup(options[selectedIndex].value);
-        return;
-      }
-      if (_str === "1") {
-        cleanup(options[0].value);
-        return;
-      }
-      if (_str === "2") {
-        cleanup(options[1].value);
-        return;
-      }
-      if (_str === "3") {
-        cleanup(options[2].value);
-        return;
-      }
-      if (_str?.toLowerCase() === "y") {
-        cleanup("yes");
-        return;
-      }
-      if (_str?.toLowerCase() === "n") {
-        cleanup("no");
-        return;
-      }
-      if (_str?.toLowerCase() === "a") {
-        cleanup("always");
-        return;
-      }
-    };
-    process.stdin.on("keypress", onKeypress);
-    render();
-  });
-}
-async function promptUserQuestion(params) {
-  const { question, options = [] } = params;
-  const boxWidth = Math.min(process.stdout.columns ?? 80, 75);
-  const border = "\u2500".repeat(Math.max(10, boxWidth - 20));
-  console.log(`
-  ${style.cyan("\u250C\u2500\u2500")} ${style.bold("AI Question")} ${style.cyan(border)}`);
-  const qLines = question.split(`
-`);
-  for (const line of qLines) {
-    console.log(`  ${style.cyan("\u2502")}  ${style.bold(line)}`);
-  }
-  if (options.length > 0) {
-    console.log(`  ${style.cyan("\u2502")}`);
-    options.forEach((opt, idx) => {
-      const numTag = style.cyan(`[${idx + 1}]`);
-      const isRec = opt.includes("(Recommended)") || opt.includes("(recommended)");
-      const optText = isRec ? opt.replace(/\(Recommended\)/i, style.green("(Recommended)")) : opt;
-      console.log(`  ${style.cyan("\u2502")}  ${numTag} ${optText}`);
-    });
+    CliFormatter.printMcpServers(servers, configFiles);
+    return;
   }
-  console.log(`  ${style.cyan("\u2514" + "\u2500".repeat(Math.max(10, boxWidth - 4)))}
-`);
-  if (!process.stdin.isTTY || false || !process.stdin.readable) {
-    return options[0] || "yes";
+  if (servers.length === 0) {
+    CliFormatter.printMcpServers(servers, configFiles);
+    return;
   }
-  return new Promise((resolve23) => {
-    const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
-    const promptLabel = options.length > 0 ? `Select [1-${options.length}] or type custom response: ` : `Your response: `;
-    rl.question(`  ${style.bold(promptLabel)}`, (answer) => {
-      rl.close();
-      const trimmed = answer.trim();
-      if (!trimmed) {
-        const fallback = options[0] || "";
-        console.log(style.dim(`  \u21B3 Default: ${fallback || "(empty)"}
-`));
-        resolve23(fallback);
-        return;
-      }
-      const num = parseInt(trimmed, 10);
-      if (!isNaN(num) && num >= 1 && num <= options.length) {
-        const picked = options[num - 1];
-        console.log(style.green(`  \u2714 Selected: ${picked}
-`));
-        resolve23(picked);
-        return;
-      }
-      if (options.length === 2) {
-        if (/^(y|yes)$/i.test(trimmed)) {
-          console.log(style.green(`  \u2714 Selected: ${options[0]}
-`));
-          resolve23(options[0]);
-          return;
-        }
-        if (/^(n|no)$/i.test(trimmed)) {
-          console.log(style.green(`  \u2714 Selected: ${options[1]}
-`));
-          resolve23(options[1]);
-          return;
+  const items = servers.map((s) => ({
+    id: s.name,
+    label: s.name,
+    badge: s.connected ? "Connected" : "Disconnected",
+    description: `${s.toolsCount} tools \xB7 ${s.resourcesCount} resources`,
+    checked: s.connected
+  }));
+  const res = await promptInteractiveList({
+    title: `\uD83D\uDD0C Connected MCP Servers (${servers.length} total)`,
+    items,
+    mode: "select",
+    onAction: async (key, item) => {
+      if (key === "t") {
+        console.log(style.dim(`
+  Pinging '${item.id}'...`));
+        const testRes = await manager.pingServer(item.id);
+        if (testRes.success) {
+          console.log(style.green(`  \u2713 PONG from '${item.id}' in ${testRes.durationMs}ms`));
+        } else {
+          console.log(style.red(`  \u2715 Ping failed: ${testRes.error}`));
         }
       }
-      console.log(style.green(`  \u2714 Answer: ${trimmed}
-`));
-      resolve23(trimmed);
-    });
+      return false;
+    },
+    customKeyHints: "\u2191/\u2193: navigate \xB7 Enter: inspect tools \xB7 t: ping test \xB7 Esc: exit"
   });
+  if (res.action === "select" && res.selectedItem) {
+    const client = manager.getClient(res.selectedItem.id);
+    if (client) {
+      CliFormatter.printMcpTools(res.selectedItem.id, client.getTools());
+    }
+  }
+}
+function printReleaseNotes() {
+  const version = getCliVersion({ prefix: true });
+  const ROSE2 = "\x1B[38;2;205;105;74m";
+  const WHITE2 = "\x1B[38;2;255;255;255m";
+  const GRAY2 = "\x1B[38;2;148;148;148m";
+  const BOLD2 = "\x1B[1m";
+  const RESET2 = "\x1B[0m";
+  function stripAnsi2(str) {
+    return str.replace(/\x1b\[[0-9;]*m/g, "");
+  }
+  function padLine(str, width) {
+    const vis = stripAnsi2(str);
+    return str + " ".repeat(Math.max(0, width - vis.length));
+  }
+  const totalInnerWidth = 74;
+  const contentLines = [
+    "",
+    "  " + BOLD2 + WHITE2 + "\uD83D\uDE80 What's New in " + version + " (Latest)" + RESET2,
+    "  " + ROSE2 + "\u2022" + RESET2 + " " + WHITE2 + BOLD2 + "Persistent Default AI Model" + RESET2 + ": Switch via " + ROSE2 + "/model" + RESET2 + " and save",
+    "    preference across sessions in ~/.groupy/credentials.json.",
+    "  " + ROSE2 + "\u2022" + RESET2 + " " + WHITE2 + BOLD2 + "Real-time Git Branch Detection" + RESET2 + ": Header displays active branch",
+    "    (\uE0A0 main) alongside user subscription tier (Groupy Pro / Max).",
+    "  " + ROSE2 + "\u2022" + RESET2 + " " + WHITE2 + BOLD2 + "Claude Code Terminal UI Parity" + RESET2 + ": Authentic pixel emblem, fieldset",
+    "    header box, user prompt badge pills, and streaming responses.",
+    "  " + ROSE2 + "\u2022" + RESET2 + " " + WHITE2 + BOLD2 + "Autonomous Sub-Agents & Roles" + RESET2 + ": Multi-agent spawner with roles",
+    "    (Pikaa, Heca, Bankli, Moli) and cryptographic action provenance.",
+    "  " + ROSE2 + "\u2022" + RESET2 + " " + WHITE2 + BOLD2 + "Model Context Protocol (MCP)" + RESET2 + ": Connect stdio & SSE servers with",
+    "    multi-config auto-discovery, tool hot-reloads, and ping tests.",
+    "  " + ROSE2 + "\u2022" + RESET2 + " " + WHITE2 + BOLD2 + "Isolated Git Worktrees" + RESET2 + ": Run risky tasks in isolated worktree",
+    "    branches without dirtying your main workspace (/worktrees).",
+    "  " + ROSE2 + "\u2022" + RESET2 + " " + WHITE2 + BOLD2 + "Strix-Inspired Security Auditor" + RESET2 + ": Automated scanner for exposed",
+    "    secrets, eval(), and SQL injection vulnerabilities (/security).",
+    "",
+    "  " + BOLD2 + WHITE2 + "\uD83D\uDCE6 Previous Highlights (v0.3.0 - v0.3.1)" + RESET2,
+    "  " + ROSE2 + "\u2022" + RESET2 + " " + WHITE2 + "Unified CI/CD Pipeline" + RESET2 + ": Single automated release packager on merge.",
+    "  " + ROSE2 + "\u2022" + RESET2 + " " + WHITE2 + "Interactive Question Flow" + RESET2 + ": Selectable multiple-choice dialogs.",
+    "  " + ROSE2 + "\u2022" + RESET2 + " " + WHITE2 + "Persistent Memory Store" + RESET2 + ": Learned user preferences in markdown.",
+    "",
+    "  " + GRAY2 + "Tip: Type " + ROSE2 + "/help" + GRAY2 + " to view all available commands." + RESET2
+  ];
+  const topDashes = Math.max(2, totalInnerWidth - (15 + version.length + 14));
+  console.log("");
+  console.log("  " + ROSE2 + "\u250C\u2500 " + ROSE2 + BOLD2 + "Groupy Code Release Notes" + RESET2 + " " + GRAY2 + version + RESET2 + " " + ROSE2 + "\u2500".repeat(topDashes) + "\u2510" + RESET2);
+  for (const line of contentLines) {
+    console.log("  " + ROSE2 + "\u2502" + RESET2 + padLine(line, totalInnerWidth) + ROSE2 + "\u2502" + RESET2);
+  }
+  console.log("  " + ROSE2 + "\u2514" + "\u2500".repeat(totalInnerWidth) + "\u2518" + RESET2);
+  console.log("");
 }
 
 // src/cli/ui/markdown.ts
@@ -8207,9 +8788,9 @@ class MarkdownHighlighter {
 }
 
 // src/cli/update-checker.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync10, readFileSync as readFileSync15, writeFileSync as writeFileSync7 } from "fs";
-import { homedir as homedir8 } from "os";
-import { join as join11 } from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync10, readFileSync as readFileSync14, writeFileSync as writeFileSync7 } from "fs";
+import { homedir as homedir9 } from "os";
+import { join as join10 } from "path";
 var CHECK_INTERVAL_MS = 12 * 60 * 60 * 1000;
 function parseSemver(v) {
   const clean = v.replace(/^v/, "").trim();
@@ -8230,8 +8811,8 @@ function isNewerVersion(current, remote) {
   return remPatch > curPatch;
 }
 function getUpdateCachePath() {
-  const baseDir = process.env.PIKAA_HOME || process.env.GROUPY_HOME || join11(homedir8(), ".pikaa");
-  return join11(baseDir, "update-cache.json");
+  const baseDir = process.env.PIKAA_HOME || process.env.GROUPY_HOME || join10(homedir9(), ".pikaa");
+  return join10(baseDir, "update-cache.json");
 }
 async function fetchLatestNpmVersion(packageName, timeoutMs = 1500) {
   const url = `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`;
@@ -8260,13 +8841,13 @@ async function checkForUpdates(options = {}) {
   }
   const meta = getPackageMetadata();
   const currentVersion = options.currentVersion || meta.version;
-  const packageName = options.packageName || (meta.name.startsWith("@") ? meta.name : `@pikaa-ai/${meta.name}`);
+  const packageName = options.packageName || "@pikaa-ai/pikaa";
   const cachePath = options.cachePath || getUpdateCachePath();
   const now = Date.now();
   let cached = null;
-  if (!options.force && existsSync20(cachePath)) {
+  if (!options.force && existsSync19(cachePath)) {
     try {
-      const raw = JSON.parse(readFileSync15(cachePath, "utf8"));
+      const raw = JSON.parse(readFileSync14(cachePath, "utf8"));
       if (raw && typeof raw.lastChecked === "number" && typeof raw.latestVersion === "string") {
         cached = raw;
         if (now - cached.lastChecked < CHECK_INTERVAL_MS) {
@@ -8294,8 +8875,8 @@ async function checkForUpdates(options = {}) {
     return null;
   }
   try {
-    const parentDir = join11(cachePath, "..");
-    if (!existsSync20(parentDir)) {
+    const parentDir = join10(cachePath, "..");
+    if (!existsSync19(parentDir)) {
       mkdirSync10(parentDir, { recursive: true });
     }
     const cacheData = {
@@ -8364,7 +8945,7 @@ class CliRepl {
           this.turnToolCalls = [];
           this.turnFilesModified.clear();
           this.turnCharsOut = 0;
-          this.spinner.start("Thinking...");
+          this.spinner.start("Thinking...", this.turnStartTime);
           break;
         case "ReasoningDelta":
         case "AgentReasoningDelta":
@@ -8408,20 +8989,17 @@ class CliRepl {
 `));
             this.reasoningStarted = false;
           }
-          this.spinner.stop();
           this.turnToolCalls.push(msg.toolName);
           this.activeToolArgs = msg.arguments || {};
           if ((msg.toolName === "apply_patch" || msg.toolName === "write_file") && msg.arguments && typeof msg.arguments.path === "string") {
             this.turnFilesModified.add(msg.arguments.path);
           }
-          console.log();
-          formatTaskStepStart(this.turnToolCalls.length, msg.toolName, msg.arguments);
-          this.spinner.start(`Executing [${this.turnToolCalls.length}] ${msg.toolName}...`);
+          this.spinner.start(`Executing [${this.turnToolCalls.length}] ${msg.toolName}...`, this.turnStartTime);
           break;
         case "ToolCallFinished":
           this.spinner.stop();
           formatTaskStepFinish(this.turnToolCalls.length, msg.toolName, this.activeToolArgs, msg.output, msg.isError);
-          this.spinner.start("Thinking deeply...");
+          this.spinner.start("Thinking deeply...", this.turnStartTime);
           break;
         case "InteractiveApprovalRequired":
         case "ApprovalRequired":
@@ -8435,7 +9013,7 @@ class CliRepl {
         case "PlanUpdated":
           this.spinner.stop();
           formatTaskProgressPlan(msg.plan, msg.explanation);
-          this.spinner.start("Executing next step...");
+          this.spinner.start("Executing next step...", this.turnStartTime);
           break;
         case "TurnCompleted":
           if (this.reasoningStarted) {
@@ -8471,9 +9049,9 @@ class CliRepl {
             filesModified: Array.from(this.turnFilesModified)
           });
           if (this.turnDoneResolver) {
-            const resolve23 = this.turnDoneResolver;
+            const resolve22 = this.turnDoneResolver;
             this.turnDoneResolver = undefined;
-            resolve23();
+            resolve22();
           }
           break;
         case "Error":
@@ -8489,9 +9067,9 @@ class CliRepl {
           console.error(style.red(`Error: ${msg.message}
 `));
           if (this.turnDoneResolver) {
-            const resolve23 = this.turnDoneResolver;
+            const resolve22 = this.turnDoneResolver;
             this.turnDoneResolver = undefined;
-            resolve23();
+            resolve22();
           }
           break;
       }
@@ -8503,10 +9081,10 @@ class CliRepl {
       if (decision === "always") {
         this.session.execPolicy.addRule(/.*/, "allow", "User allowed all actions for this session");
         this.session.resolveApproval(msg.approvalId, true);
-        this.spinner.start(`Executing approved action (auto-approved for session)...`);
+        this.spinner.start(`Executing approved action (auto-approved for session)...`, this.turnStartTime);
       } else if (decision === "yes") {
         this.session.resolveApproval(msg.approvalId, true);
-        this.spinner.start(`Executing approved action...`);
+        this.spinner.start(`Executing approved action...`, this.turnStartTime);
       } else {
         this.session.resolveApproval(msg.approvalId, false);
         console.log(style.dim("  Action rejected by user."));
@@ -8522,19 +9100,22 @@ class CliRepl {
         options: msg.options
       });
       this.session.resolveUserQuestion(msg.questionId, answer);
-      this.spinner.start(`Processing response and continuing...`);
+      this.spinner.start(`Processing response and continuing...`, this.turnStartTime);
     } catch {
       this.session.resolveUserQuestion(msg.questionId, "");
     }
   }
   async start() {
-    const creds = new CredentialsStore().load();
-    const accountUser = creds?.user?.username || creds?.user?.email || (creds?.accessToken ? "Authenticated" : undefined);
+    const credStore = new CredentialsStore;
+    const userInfo = credStore.getUser();
+    const accountUser = userInfo?.username || (userInfo?.email ? userInfo.email.split("@")[0] : undefined);
+    const userPlan = userInfo?.plan;
     await renderAnimatedGroupyBanner({
       user: accountUser,
       role: this.role,
       model: this.session.model,
-      cwd: this.session.cwd
+      cwd: this.session.cwd,
+      plan: userPlan
     });
     checkForUpdates().then((update) => {
       if (update?.updateAvailable) {
@@ -8554,9 +9135,9 @@ class CliRepl {
 `));
             this.isProcessing = false;
             if (this.turnDoneResolver) {
-              const resolve23 = this.turnDoneResolver;
+              const resolve22 = this.turnDoneResolver;
               this.turnDoneResolver = undefined;
-              resolve23();
+              resolve22();
             }
           }
         }
@@ -8588,8 +9169,8 @@ class CliRepl {
         }
       }
       try {
-        const turnPromise = new Promise((resolve23) => {
-          this.turnDoneResolver = resolve23;
+        const turnPromise = new Promise((resolve22) => {
+          this.turnDoneResolver = resolve22;
         });
         await this.session.submit({
           type: "TurnInput",
@@ -8623,7 +9204,7 @@ async function main() {
   const args = process.argv.slice(2);
   const credStore = new CredentialsStore;
   const savedCreds = credStore.load();
-  let model = process.env.GROUPY_MODEL || process.env.OPENAI_MODEL || "groupy";
+  let model = process.env.GROUPY_MODEL || process.env.OPENAI_MODEL || savedCreds?.defaultModel || savedCreds?.model || "groupy";
   let baseUrl = process.env.GROUPY_BASE_URL || process.env.OPENAI_BASE_URL || savedCreds?.baseUrl;
   let apiKey = process.env.GROUPY_API_KEY || process.env.OPENAI_API_KEY || savedCreds?.accessToken;
   let explicitBaseUrl;
@@ -8677,7 +9258,7 @@ async function main() {
       explicitApiKey = args[++i];
       apiKey = explicitApiKey || apiKey;
     } else if (arg === "--cwd" || arg === "-C") {
-      cwd = resolve23(args[++i] || cwd);
+      cwd = resolve22(args[++i] || cwd);
     } else if (arg === "--role" || arg === "-r") {
       role = args[++i] || role;
     } else if (arg === "--mcp") {
@@ -8703,11 +9284,11 @@ async function main() {
   const mcpManager = new McpManager;
   const candidateConfigs = [
     mcpConfigFile,
-    resolve23(cwd, ".mcp.json"),
-    resolve23(cwd, "mcp_config.json")
+    resolve22(cwd, ".mcp.json"),
+    resolve22(cwd, "mcp_config.json")
   ].filter(Boolean);
   for (const cfg of candidateConfigs) {
-    if (existsSync21(cfg)) {
+    if (existsSync20(cfg)) {
       try {
         await mcpManager.loadConfigFile(cfg);
         mcpManager.registerToolsIntoRouter(tools4);