@pikaa-ai/pikaa 0.3.23 → 0.3.25

package/dist/cli.js

@@ -2,8 +2,8 @@
 // @bun
 
 // src/cli/index.ts
-import { resolve as resolve21 } from "path";
-import { existsSync as existsSync23 } from "fs";
+import { resolve as resolve22 } from "path";
+import { existsSync as existsSync24 } from "fs";
 import { createInterface } from "readline";
 
 // src/auth/store.ts
@@ -1910,6 +1910,12 @@ class WindowsSandbox {
       return null;
     }
     try {
+      if (this.jobObjectHandle) {
+        try {
+          this.kernel32.symbols.CloseHandle(this.jobObjectHandle);
+        } catch {}
+        this.jobObjectHandle = null;
+      }
       const jobHandle = this.kernel32.symbols.CreateJobObjectW(null, null);
       if (!jobHandle || jobHandle === 0) {
         return null;
@@ -5269,7 +5275,6 @@ class SessionPersistenceManager {
 // src/skills/loader.ts
 import { existsSync as existsSync16, readdirSync as readdirSync6, readFileSync as readFileSync9 } from "fs";
 import { resolve as resolve13, join as join8 } from "path";
-import { homedir as homedir3 } from "os";
 var __dirname = "/home/runner/work/agent-cli/agent-cli/src/skills";
 
 class SkillsLoader {
@@ -5345,7 +5350,7 @@ class SkillsLoader {
       }
     }
     if (this.includeGlobal) {
-      roots.push(getGlobalSkillsDir(), resolve13(homedir3(), ".gemini", "config", "skills"));
+      roots.push(getGlobalSkillsDir());
     }
     roots.push(...this.customRoots.map((r) => resolve13(r)));
     return roots.filter((r) => existsSync16(r));
@@ -5491,9 +5496,77 @@ When tackling complex specialized tasks that match any of these skills, autonomo
   }
 }
 
+// src/skills/installer.ts
+import { existsSync as existsSync17, mkdirSync as mkdirSync10, writeFileSync as writeFileSync5, rmSync as rmSync2 } from "fs";
+import { resolve as resolve14, join as join9 } from "path";
+async function installSkill(skillName, options) {
+  const cleanName = skillName.trim().toLowerCase().replace(/^@/, "");
+  if (!cleanName) {
+    throw new Error("Skill name cannot be empty.");
+  }
+  const credStore = new CredentialsStore;
+  const creds = credStore.load();
+  let backend = (options.backendUrl || process.env.PIKAA_BACKEND_URL || process.env.GROUPY_BACKEND_URL || creds?.baseUrl || "https://api.groupy-hub.store").replace(/\/+$/, "");
+  if (backend.endsWith("/v1")) {
+    backend = backend.slice(0, -3).replace(/\/+$/, "");
+  }
+  const endpoint = `${backend}/api/skills/${encodeURIComponent(cleanName)}`;
+  let resp;
+  try {
+    resp = await fetch(endpoint, {
+      headers: creds?.accessToken ? { Authorization: `Bearer ${creds.accessToken}` } : {}
+    });
+  } catch (netErr) {
+    throw new Error(`Failed to connect to backend at ${backend}: ${netErr.message}`);
+  }
+  if (!resp.ok) {
+    if (resp.status === 404) {
+      throw new Error(`Skill '${cleanName}' not found in catalog (${endpoint}).`);
+    }
+    const errText = await resp.text();
+    throw new Error(`Backend error (${resp.status}): ${errText}`);
+  }
+  const skillData = await resp.json();
+  if (!skillData.content) {
+    throw new Error(`Skill '${cleanName}' does not contain markdown content.`);
+  }
+  const scope = options.global ? "global" : "workspace";
+  const targetDir = options.global ? resolve14(getGlobalSkillsDir(), cleanName) : resolve14(options.cwd, ".agents", "skills", cleanName);
+  mkdirSync10(targetDir, { recursive: true });
+  const targetFile = join9(targetDir, "SKILL.md");
+  let fileContent = skillData.content;
+  if (!fileContent.startsWith("---")) {
+    const desc = skillData.description ? `description: "${skillData.description.replace(/"/g, "\\\"")}"
+` : "";
+    fileContent = `---
+name: ${cleanName}
+${desc}---
+
+${fileContent}`;
+  }
+  writeFileSync5(targetFile, fileContent, "utf-8");
+  return {
+    success: true,
+    skillName: cleanName,
+    title: skillData.title || cleanName,
+    targetPath: targetFile,
+    scope,
+    message: `Installed skill '${skillData.title || cleanName}' (@${cleanName}) into ${scope} at ${targetFile}`
+  };
+}
+function removeSkill(skillName, options) {
+  const cleanName = skillName.trim().toLowerCase().replace(/^@/, "");
+  const targetDir = options.global ? resolve14(getGlobalSkillsDir(), cleanName) : resolve14(options.cwd, ".agents", "skills", cleanName);
+  if (!existsSync17(targetDir)) {
+    return { success: false, targetDir, removed: false };
+  }
+  rmSync2(targetDir, { recursive: true, force: true });
+  return { success: true, targetDir, removed: true };
+}
+
 // src/memories/store.ts
-import { existsSync as existsSync17, readFileSync as readFileSync10, writeFileSync as writeFileSync5, mkdirSync as mkdirSync10, readdirSync as readdirSync7 } from "fs";
-import { resolve as resolve14, join as join9, basename, dirname as dirname8 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync10, writeFileSync as writeFileSync6, mkdirSync as mkdirSync11, readdirSync as readdirSync7 } from "fs";
+import { resolve as resolve15, join as join10, basename, dirname as dirname8 } from "path";
 import { createHash } from "crypto";
 class MemoryStore {
   globalPath;
@@ -5503,14 +5576,14 @@ class MemoryStore {
     this.customWorkspacePath = options.workspacePath;
   }
   findProjectRoot(cwd) {
-    let current = resolve14(cwd);
+    let current = resolve15(cwd);
     while (true) {
-      if (existsSync17(join9(current, ".git"))) {
+      if (existsSync18(join10(current, ".git"))) {
         return current;
       }
       const parent = dirname8(current);
       if (parent === current) {
-        return resolve14(cwd);
+        return resolve15(cwd);
       }
       current = parent;
     }
@@ -5518,30 +5591,30 @@ class MemoryStore {
   getProjectSlug(cwd) {
     const root = this.findProjectRoot(cwd);
     const folderName = basename(root).toLowerCase().replace(/[^a-z0-9_-]/g, "-") || "project";
-    const hash = createHash("sha256").update(resolve14(root)).digest("hex").slice(0, 6);
+    const hash = createHash("sha256").update(resolve15(root)).digest("hex").slice(0, 6);
     return `${folderName}-${hash}`;
   }
   getProjectMemoryDir(cwd) {
     if (this.customWorkspacePath) {
-      const dir2 = resolve14(this.customWorkspacePath);
-      if (!existsSync17(dir2)) {
+      const dir2 = resolve15(this.customWorkspacePath);
+      if (!existsSync18(dir2)) {
         try {
-          mkdirSync10(dir2, { recursive: true });
+          mkdirSync11(dir2, { recursive: true });
         } catch {}
       }
       return dir2;
     }
     const slug = this.getProjectSlug(cwd);
-    const dir = join9(getProjectsDir(), slug, "memory");
-    if (!existsSync17(dir)) {
+    const dir = join10(getProjectsDir(), slug, "memory");
+    if (!existsSync18(dir)) {
       try {
-        mkdirSync10(dir, { recursive: true });
+        mkdirSync11(dir, { recursive: true });
       } catch {}
     }
     return dir;
   }
   getMemoryIndexPath(cwd) {
-    return join9(this.getProjectMemoryDir(cwd), "MEMORY.md");
+    return join10(this.getProjectMemoryDir(cwd), "MEMORY.md");
   }
   normalizeCategory(raw) {
     const cat = raw.toLowerCase().trim();
@@ -5560,7 +5633,7 @@ class MemoryStore {
     const sanitizedName = params.name.toLowerCase().trim().replace(/[^a-z0-9_-]/g, "_").replace(/^_+|_+$/g, "") || `note_${Date.now()}`;
     const memoryDir = this.getProjectMemoryDir(params.cwd);
     const fileName = `${type}_${sanitizedName}.md`;
-    const filePath = join9(memoryDir, fileName);
+    const filePath = join10(memoryDir, fileName);
     const nowIso = new Date().toISOString();
     const cleanContent = params.content.trim();
     const desc = (params.description || cleanContent.split(`
@@ -5579,7 +5652,7 @@ class MemoryStore {
       ""
     ].join(`
 `);
-    writeFileSync5(filePath, frontmatter, "utf8");
+    writeFileSync6(filePath, frontmatter, "utf8");
     this.syncMemoryIndex(params.cwd);
     return {
       id: `mem_${sanitizedName}`,
@@ -5595,17 +5668,17 @@ class MemoryStore {
   }
   readTopicMemory(topicNameOrFile, cwd) {
     const memoryDir = this.getProjectMemoryDir(cwd);
-    let targetPath = join9(memoryDir, topicNameOrFile);
-    if (!existsSync17(targetPath)) {
+    let targetPath = join10(memoryDir, topicNameOrFile);
+    if (!existsSync18(targetPath)) {
       if (!topicNameOrFile.endsWith(".md")) {
-        targetPath = join9(memoryDir, `${topicNameOrFile}.md`);
+        targetPath = join10(memoryDir, `${topicNameOrFile}.md`);
       }
     }
-    if (!existsSync17(targetPath)) {
+    if (!existsSync18(targetPath)) {
       const files = readdirSync7(memoryDir);
       const match = files.find((f) => f.includes(topicNameOrFile));
       if (match) {
-        targetPath = join9(memoryDir, match);
+        targetPath = join10(memoryDir, match);
       } else {
         return null;
       }
@@ -5666,12 +5739,12 @@ class MemoryStore {
   }
   syncMemoryIndex(cwd) {
     const memoryDir = this.getProjectMemoryDir(cwd);
-    const indexPath = join9(memoryDir, "MEMORY.md");
-    const files = existsSync17(memoryDir) ? readdirSync7(memoryDir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md") : [];
+    const indexPath = join10(memoryDir, "MEMORY.md");
+    const files = existsSync18(memoryDir) ? readdirSync7(memoryDir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md") : [];
     const items = [];
     for (const f of files) {
       try {
-        const full = join9(memoryDir, f);
+        const full = join10(memoryDir, f);
         const parsed = this.parseTopicFile(readFileSync10(full, "utf8"), full);
         items.push({
           type: parsed.type,
@@ -5692,13 +5765,13 @@ class MemoryStore {
       indexLines.push(`- [${item.type}] **${item.name}**: ${item.desc} (topic: ${item.file})`);
     }
     const boundedLines = indexLines.slice(0, 200);
-    writeFileSync5(indexPath, boundedLines.join(`
+    writeFileSync6(indexPath, boundedLines.join(`
 `) + `
 `, "utf8");
   }
   loadMemoryIndex(cwd) {
     const indexPath = this.getMemoryIndexPath(cwd);
-    if (!existsSync17(indexPath))
+    if (!existsSync18(indexPath))
       return "";
     try {
       const raw = readFileSync10(indexPath, "utf8");
@@ -5714,13 +5787,13 @@ class MemoryStore {
   }
   listProjectMemories(cwd) {
     const memoryDir = this.getProjectMemoryDir(cwd);
-    if (!existsSync17(memoryDir))
+    if (!existsSync18(memoryDir))
       return [];
     const files = readdirSync7(memoryDir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md");
     const list = [];
     for (const f of files) {
       try {
-        const full = join9(memoryDir, f);
+        const full = join10(memoryDir, f);
         list.push(this.parseTopicFile(readFileSync10(full, "utf8"), full));
       } catch {}
     }
@@ -5772,11 +5845,11 @@ class MemoryStore {
 }
 
 // src/worktree/manager.ts
-import { resolve as resolve16, join as join10 } from "path";
-import { existsSync as existsSync18, mkdirSync as mkdirSync11, writeFileSync as writeFileSync6, readFileSync as readFileSync11 } from "fs";
+import { resolve as resolve17, join as join11 } from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync12, writeFileSync as writeFileSync7, readFileSync as readFileSync11 } from "fs";
 
 // src/worktree/git.ts
-import { resolve as resolve15 } from "path";
+import { resolve as resolve16 } from "path";
 var NON_INHERITABLE_GIT_ENV = [
   "GIT_DIR",
   "GIT_WORK_TREE",
@@ -5820,13 +5893,13 @@ async function getRepoRoot(cwd) {
   const res = await runGit(cwd, ["rev-parse", "--show-toplevel"]);
   if (res.exitCode !== 0 || !res.stdout)
     return null;
-  return resolve15(res.stdout);
+  return resolve16(res.stdout);
 }
 async function getMainRepoRoot(cwd) {
   const res = await runGit(cwd, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
   if (res.exitCode === 0 && res.stdout) {
-    const commonDir = resolve15(cwd, res.stdout);
-    return resolve15(commonDir, "..");
+    const commonDir = resolve16(cwd, res.stdout);
+    return resolve16(commonDir, "..");
   }
   return getRepoRoot(cwd);
 }
@@ -5856,7 +5929,7 @@ async function listWorktreesGit(repoRoot) {
     let isLocked = false;
     for (const line of lines) {
       if (line.startsWith("worktree ")) {
-        path = resolve15(line.slice(9).trim());
+        path = resolve16(line.slice(9).trim());
       } else if (line.startsWith("HEAD ")) {
         commitHash = line.slice(5).trim();
       } else if (line.startsWith("branch ")) {
@@ -5921,19 +5994,19 @@ class WorktreeManager {
     }
     const taskId = `task_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 6)}`;
     const branchName = options.branch || `groupy/${taskId}`;
-    const targetDir = options.worktreePath || (this.baseStorageDir ? resolve16(this.baseStorageDir, branchName.replace(/\//g, "_")) : resolve16(repoRoot, ".groupy", "worktrees", branchName.replace(/\//g, "_")));
-    const worktreeParent = resolve16(targetDir, "..");
-    if (!existsSync18(worktreeParent)) {
-      mkdirSync11(worktreeParent, { recursive: true });
+    const targetDir = options.worktreePath || (this.baseStorageDir ? resolve17(this.baseStorageDir, branchName.replace(/\//g, "_")) : resolve17(repoRoot, ".groupy", "worktrees", branchName.replace(/\//g, "_")));
+    const worktreeParent = resolve17(targetDir, "..");
+    if (!existsSync19(worktreeParent)) {
+      mkdirSync12(worktreeParent, { recursive: true });
     }
     const baseBranch = options.baseBranch || await getCurrentBranch(repoRoot);
     const result = await createWorktreeGit(repoRoot, targetDir, branchName, baseBranch);
     if (!result.success) {
       throw new Error(`Failed to create git worktree: ${result.error}`);
     }
-    const metaPath = join10(targetDir, "groupy-thread.json");
+    const metaPath = join11(targetDir, "groupy-thread.json");
     try {
-      writeFileSync6(metaPath, JSON.stringify({
+      writeFileSync7(metaPath, JSON.stringify({
         version: 1,
         ownerThreadId: options.threadId || null,
         branch: branchName,
@@ -5942,7 +6015,7 @@ class WorktreeManager {
       }, null, 2), "utf8");
     } catch {}
     const worktrees = await listWorktreesGit(repoRoot);
-    const created = worktrees.find((w) => resolve16(w.path) === resolve16(targetDir));
+    const created = worktrees.find((w) => resolve17(w.path) === resolve17(targetDir));
     return created || {
       path: targetDir,
       branch: branchName,
@@ -5957,8 +6030,8 @@ class WorktreeManager {
       return [];
     const worktrees = await listWorktreesGit(repoRoot);
     return worktrees.map((wt) => {
-      const metaPath = join10(wt.path, "groupy-thread.json");
-      if (existsSync18(metaPath)) {
+      const metaPath = join11(wt.path, "groupy-thread.json");
+      if (existsSync19(metaPath)) {
         try {
           const raw = JSON.parse(readFileSync11(metaPath, "utf8"));
           return { ...wt, threadId: raw.ownerThreadId || raw.threadId };
@@ -5968,7 +6041,7 @@ class WorktreeManager {
     });
   }
   async mergeWorktree(worktreePath, options = {}) {
-    const resolvedPath = resolve16(worktreePath);
+    const resolvedPath = resolve17(worktreePath);
     const repoRoot = await getMainRepoRoot(resolvedPath);
     if (!repoRoot) {
       return { success: false, message: "Worktree path is not a valid git repository." };
@@ -6005,7 +6078,7 @@ class WorktreeManager {
     };
   }
   async removeWorktree(worktreePath, deleteBranch = false) {
-    const resolvedPath = resolve16(worktreePath);
+    const resolvedPath = resolve17(worktreePath);
     const repoRoot = await getMainRepoRoot(resolvedPath);
     if (!repoRoot)
       return false;
@@ -6086,8 +6159,8 @@ class AuthClient {
     const authUrl = `${backendUrl}/api/auth/authorize?response_type=code&client_id=groupy-cli&redirect_uri=${encodeURIComponent(redirectUri)}&code_challenge=${encodeURIComponent(codeChallenge)}&code_challenge_method=S256&state=${state}&direct=1`;
     let serverResolve;
     let serverReject;
-    const codePromise = new Promise((resolve17, reject) => {
-      serverResolve = resolve17;
+    const codePromise = new Promise((resolve18, reject) => {
+      serverResolve = resolve18;
       serverReject = reject;
     });
     if (options.openBrowser !== false) {
@@ -6656,7 +6729,7 @@ function parsePatch(oldSrc, newSrc, contextLines = 3) {
 // package.json
 var package_default = {
   name: "@pikaa-ai/pikaa",
-  version: "0.3.23",
+  version: "0.3.25",
   description: "PIKAA CLI - AI coding agent that runs locally in your terminal.",
   main: "./dist/index.js",
   module: "./dist/index.js",
@@ -6672,7 +6745,6 @@ var package_default = {
     "bin",
     "templates",
     "assets",
-    "skills/**/SKILL.md",
     "README.md",
     "LICENSE"
   ],
@@ -6734,7 +6806,7 @@ function getCliVersion(options = {}) {
 }
 
 // src/cli/ui/animation/banner-animation.ts
-import { homedir as homedir4 } from "os";
+import { homedir as homedir3 } from "os";
 import { execSync } from "child_process";
 var ROSE = "\x1B[38;2;205;105;74m";
 var ROSE_DIM = "\x1B[38;2;120;60;45m";
@@ -6744,7 +6816,7 @@ var BOLD = "\x1B[1m";
 var ITALIC = "\x1B[3m";
 var RESET = "\x1B[0m";
 function shortenPath(cwd) {
-  const home = homedir4();
+  const home = homedir3();
   if (cwd.startsWith(home)) {
     return `~${cwd.slice(home.length).replace(/\\/g, "/")}`;
   }
@@ -7224,8 +7296,25 @@ import readline2 from "readline";
 import readline from "readline";
 var keypressEventsInitialized = false;
 var listeners = new Set;
+var rawModeState = null;
+function ensureRawMode(active) {
+  if (!process.stdin.isTTY)
+    return;
+  if (rawModeState === active)
+    return;
+  try {
+    process.stdin.setRawMode(active);
+    rawModeState = active;
+    if (active) {
+      process.stdin.resume();
+    }
+  } catch {}
+}
 function initGlobalKeypress() {
   if (!keypressEventsInitialized && process.stdin.isTTY) {
+    try {
+      process.stdin.on("error", () => {});
+    } catch {}
     readline.emitKeypressEvents(process.stdin);
     keypressEventsInitialized = true;
     process.stdin.on("keypress", (str, key) => {
@@ -7302,15 +7391,15 @@ class InteractiveLineEditor {
   }
   async readLine() {
     if (!process.stdin.isTTY) {
-      return new Promise((resolve17) => {
+      return new Promise((resolve18) => {
         const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
         rl.question(this.promptSymbol, (answer) => {
           rl.close();
-          resolve17(answer);
+          resolve18(answer);
         });
       });
     }
-    return new Promise((resolve17) => {
+    return new Promise((resolve18) => {
       let buffer = "";
       let cursor = 0;
       let selectedIndex = 0;
@@ -7318,12 +7407,7 @@ class InteractiveLineEditor {
       let popupDismissed = false;
       let lastCursorRowFromTop = 0;
       let unsubscribeKeypress = null;
-      if (process.stdin.isTTY) {
-        try {
-          process.stdin.setRawMode(true);
-        } catch {}
-      }
-      process.stdin.resume();
+      ensureRawMode(true);
       const getMatchingCommands = () => {
         if (!buffer.startsWith("/") || popupDismissed)
           return [];
@@ -7357,7 +7441,7 @@ class InteractiveLineEditor {
       };
       const getRule = () => {
         const cols = getTerminalCols();
-        const ruleLen = Math.max(10, cols - 4);
+        const ruleLen = Math.max(10, cols - 6);
         return "\u2500".repeat(ruleLen);
       };
       const ensureVisible = (totalItems, visibleRows) => {
@@ -7383,11 +7467,12 @@ class InteractiveLineEditor {
       const redraw = () => {
         const termCols = getTerminalCols();
         const visiblePromptWidth = this.promptSymbol.replace(/\x1b\[[0-9;]*m/g, "").length;
+        let frame = "";
         if (lastCursorRowFromTop > 0) {
-          process.stdout.write(`\x1B[${lastCursorRowFromTop}A`);
+          frame += `\x1B[${lastCursorRowFromTop}A`;
         }
-        process.stdout.write("\r\x1B[J");
-        process.stdout.write(`${this.promptSymbol}${buffer}`);
+        frame += "\r\x1B[J";
+        frame += `${this.promptSymbol}${buffer}`;
         const totalPromptChars = visiblePromptWidth + buffer.length;
         const promptRows = Math.max(1, Math.floor(totalPromptChars / termCols) + 1);
         const slashMatches = getMatchingCommands();
@@ -7395,7 +7480,7 @@ class InteractiveLineEditor {
         const fileMatches = activeFile ? getMatchingFiles(activeFile.query) : [];
         let menuRows = 0;
         if (buffer.startsWith("/") && !popupDismissed && slashMatches.length > 0) {
-          const BOX_WIDTH = Math.max(20, Math.min(termCols - 4, 120));
+          const BOX_WIDTH = Math.max(20, Math.min(termCols - 6, 120));
           const maxVisible = Math.min(slashMatches.length, 7);
           ensureVisible(slashMatches.length, maxVisible);
           const visibleMatches = slashMatches.slice(scrollTop, scrollTop + maxVisible);
@@ -7422,12 +7507,12 @@ class InteractiveLineEditor {
           }
           menuLines.push(`  ${RULE_COLOR2}${rule}${RESET2}`);
           for (const line of menuLines) {
-            process.stdout.write(`
-\x1B[2K${line}`);
+            frame += `
+\x1B[2K${line}`;
           }
           menuRows = menuLines.length;
         } else if (activeFile && !popupDismissed && fileMatches.length > 0) {
-          const BOX_WIDTH = Math.max(20, Math.min(termCols - 4, 120));
+          const BOX_WIDTH = Math.max(20, Math.min(termCols - 6, 120));
           const maxVisible = Math.min(fileMatches.length, 7);
           ensureVisible(fileMatches.length, maxVisible);
           const visibleMatches = fileMatches.slice(scrollTop, scrollTop + maxVisible);
@@ -7459,31 +7544,34 @@ class InteractiveLineEditor {
           menuLines.push(`  ${style.dim("\u2502")}${style.dim(footerPadded)}${style.dim("\u2502")}`);
           menuLines.push(`  ${style.dim("\u2514" + "\u2500".repeat(BOX_WIDTH) + "\u2518")}`);
           for (const line of menuLines) {
-            process.stdout.write(`
-\x1B[2K${line}`);
+            frame += `
+\x1B[2K${line}`;
           }
           menuRows = menuLines.length;
         } else {
           const RULE_COLOR2 = "\x1B[38;2;60;60;68m";
           const bottomRule = `  ${RULE_COLOR2}${getRule()}\x1B[0m`;
           const modeLine = this.getModeLine();
-          process.stdout.write(`
+          frame += `
 \x1B[2K${bottomRule}
-\x1B[2K${modeLine}`);
+\x1B[2K${modeLine}`;
           menuRows = 2;
         }
         const cursorCharsFromTop = visiblePromptWidth + cursor;
         const cursorRow = Math.floor(cursorCharsFromTop / termCols);
         const cursorCol = cursorCharsFromTop % termCols;
-        const moveUpRows = promptRows - 1 - cursorRow + menuRows;
+        const moveUpRows = Math.max(0, promptRows - 1 - cursorRow + menuRows);
         if (moveUpRows > 0) {
-          process.stdout.write(`\x1B[${moveUpRows}A`);
+          frame += `\x1B[${moveUpRows}A`;
         }
-        process.stdout.write("\r");
+        frame += "\r";
         if (cursorCol > 0) {
-          process.stdout.write(`\x1B[${cursorCol}C`);
+          frame += `\x1B[${cursorCol}C`;
         }
         lastCursorRowFromTop = cursorRow;
+        try {
+          process.stdout.write(frame);
+        } catch {}
       };
       const onResize = () => {
         redraw();
@@ -7499,24 +7587,24 @@ class InteractiveLineEditor {
           unsubscribeKeypress();
           unsubscribeKeypress = null;
         }
-        if (process.stdin.isTTY) {
-          try {
-            process.stdin.setRawMode(false);
-          } catch {}
-        }
+        ensureRawMode(false);
+        let cleanupFrame = "";
         if (lastCursorRowFromTop > 0) {
-          process.stdout.write(`\x1B[${lastCursorRowFromTop}A`);
+          cleanupFrame += `\x1B[${lastCursorRowFromTop}A`;
         }
-        process.stdout.write("\r\x1B[J");
+        cleanupFrame += "\r\x1B[J";
         if (result.trim().length > 0 && !result.startsWith("/")) {
-          process.stdout.write(`${CliFormatter.formatClaudeUserPrompt(result)}
+          cleanupFrame += `${CliFormatter.formatClaudeUserPrompt(result)}
 
-`);
+`;
         } else {
-          process.stdout.write(`
-`);
+          cleanupFrame += `
+`;
         }
-        resolve17(result);
+        try {
+          process.stdout.write(cleanupFrame);
+        } catch {}
+        resolve18(result);
       };
       const onKeypress = (_str, key) => {
         if (!key)
@@ -7704,7 +7792,7 @@ async function promptChoice(config) {
       const def = choices[defaultIndex] || choices[0];
       return def ? def.value : "";
     }
-    return new Promise((resolve17) => {
+    return new Promise((resolve18) => {
       const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
       const promptText = `  ${message} (${choices.map((c3) => `[${c3.key}] ${c3.label}`).join(", ")}): `;
       rl.question(promptText, (answer) => {
@@ -7712,23 +7800,20 @@ async function promptChoice(config) {
         const trimmed = answer.trim().toLowerCase();
         const match = choices.find((c3) => c3.key.toLowerCase() === trimmed);
         if (match) {
-          resolve17(match.value);
+          resolve18(match.value);
         } else {
           const def = choices[defaultIndex] || choices[0];
-          resolve17(def ? def.value : "");
+          resolve18(def ? def.value : "");
         }
       });
     });
   }
-  return new Promise((resolve17) => {
+  return new Promise((resolve18) => {
     let selectedIndex = defaultIndex;
     if (selectedIndex < 0 || selectedIndex >= choices.length)
       selectedIndex = 0;
-    const wasRaw = process.stdin.isRaw;
-    try {
-      process.stdin.setRawMode(true);
-    } catch {}
-    process.stdin.resume();
+    const wasRaw = process.stdin.isRaw ?? false;
+    ensureRawMode(true);
     const render = () => {
       const parts = choices.map((choice, idx) => {
         const isSelected = idx === selectedIndex;
@@ -7747,12 +7832,10 @@ async function promptChoice(config) {
         unsubscribe();
         unsubscribe = null;
       }
-      try {
-        process.stdin.setRawMode(wasRaw ?? false);
-      } catch {}
+      ensureRawMode(wasRaw);
       process.stdout.write(`\r\x1B[1A\r\x1B[2K  ${style.bold(message)} ${style.cyan(`[${confirmedChoice.key}] ${confirmedChoice.label}`)}
 \r\x1B[2K`);
-      resolve17(confirmedChoice.value);
+      resolve18(confirmedChoice.value);
     };
     const onKeypress = (_str, key) => {
       if (!key)
@@ -7818,13 +7901,10 @@ async function promptToolApproval(params) {
     renderCard(1);
     return "yes";
   }
-  return new Promise((resolve17) => {
+  return new Promise((resolve18) => {
     let selectedIndex = 1;
-    const wasRaw = process.stdin.isRaw;
-    try {
-      process.stdin.setRawMode(true);
-    } catch {}
-    process.stdin.resume();
+    const wasRaw = process.stdin.isRaw ?? false;
+    ensureRawMode(true);
     const render = () => {
       renderCard(selectedIndex);
     };
@@ -7834,11 +7914,9 @@ async function promptToolApproval(params) {
         unsubscribe();
         unsubscribe = null;
       }
-      try {
-        process.stdin.setRawMode(wasRaw ?? false);
-      } catch {}
+      ensureRawMode(wasRaw);
       console.log();
-      resolve17(val);
+      resolve18(val);
     };
     const onKeypress = (_str, key) => {
       if (!key)
@@ -7921,7 +7999,7 @@ async function promptUserQuestion(params) {
   if (!process.stdin.isTTY || false || !process.stdin.readable) {
     return options[0] || "yes";
   }
-  return new Promise((resolve17) => {
+  return new Promise((resolve18) => {
     const rl = readline3.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) => {
@@ -7931,7 +8009,7 @@ async function promptUserQuestion(params) {
         const fallback = options[0] || "";
         console.log(style.dim(`  \u21B3 Default: ${fallback || "(empty)"}
 `));
-        resolve17(fallback);
+        resolve18(fallback);
         return;
       }
       const num = parseInt(trimmed, 10);
@@ -7939,26 +8017,26 @@ async function promptUserQuestion(params) {
         const picked = options[num - 1];
         console.log(style.green(`  \u2714 Selected: ${picked}
 `));
-        resolve17(picked);
+        resolve18(picked);
         return;
       }
       if (options.length === 2) {
         if (/^(y|yes)$/i.test(trimmed)) {
           console.log(style.green(`  \u2714 Selected: ${options[0]}
 `));
-          resolve17(options[0]);
+          resolve18(options[0]);
           return;
         }
         if (/^(n|no)$/i.test(trimmed)) {
           console.log(style.green(`  \u2714 Selected: ${options[1]}
 `));
-          resolve17(options[1]);
+          resolve18(options[1]);
           return;
         }
       }
       console.log(style.green(`  \u2714 Answer: ${trimmed}
 `));
-      resolve17(trimmed);
+      resolve18(trimmed);
     });
   });
 }
@@ -7987,15 +8065,12 @@ async function promptInteractiveList(config) {
 `);
     return { selectedIndex: -1, action: "close" };
   }
-  return new Promise((resolve17) => {
+  return new Promise((resolve18) => {
     let selectedIndex = Math.max(0, Math.min(defaultIndex, items.length - 1));
     let scrollTop = 0;
     let renderedLines = 0;
-    const wasRaw = process.stdin.isRaw;
-    try {
-      process.stdin.setRawMode(true);
-    } catch {}
-    process.stdin.resume();
+    const wasRaw = process.stdin.isRaw ?? false;
+    ensureRawMode(true);
     process.stdout.write("\x1B[?25l");
     const BOX_WIDTH = Math.min(process.stdout.columns ?? 80, 76);
     const ensureVisible = () => {
@@ -8079,10 +8154,8 @@ async function promptInteractiveList(config) {
         unsubscribe();
         unsubscribe = null;
       }
-      try {
-        process.stdin.setRawMode(wasRaw ?? false);
-      } catch {}
-      resolve17(res);
+      ensureRawMode(wasRaw);
+      resolve18(res);
     };
     const onKeypress = async (_str, key) => {
       if (!key)
@@ -8153,8 +8226,8 @@ async function promptInteractiveList(config) {
 }
 
 // src/security/scanner.ts
-import { existsSync as existsSync19, readdirSync as readdirSync8, readFileSync as readFileSync12, statSync as statSync5 } from "fs";
-import { join as join11, relative as relative2, resolve as resolve17 } from "path";
+import { existsSync as existsSync20, readdirSync as readdirSync8, readFileSync as readFileSync12, statSync as statSync5 } from "fs";
+import { join as join12, relative as relative2, resolve as resolve18 } from "path";
 var SECURITY_RULES = [
   {
     id: "SEC-001",
@@ -8286,13 +8359,13 @@ var IGNORED_FILES = new Set([
 ]);
 async function runSecurityScan(targetDir, options = {}) {
   const startTime = performance.now();
-  const root = resolve17(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 || !existsSync20(current))
       return;
     let entries;
     try {
@@ -8303,7 +8376,7 @@ async function runSecurityScan(targetDir, options = {}) {
     for (const entry of entries) {
       if (scannedCount >= maxFiles)
         break;
-      const fullPath = join11(current, entry);
+      const fullPath = join12(current, entry);
       let stat;
       try {
         stat = statSync5(fullPath);
@@ -8381,38 +8454,38 @@ async function runSecurityScan(targetDir, options = {}) {
 }
 
 // src/mcp/servers/chrome-devtools/index.ts
-import { resolve as resolve18 } 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 = resolve18(__dirname, "server.ts");
+var CHROME_DEVTOOLS_MCP_SERVER_PATH = resolve19(__dirname, "server.ts");
 
 // src/mcp/servers/web-search/index.ts
-import { resolve as resolve19 } 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 = resolve19(__dirname, "server.ts");
+var WEB_SEARCH_MCP_SERVER_PATH = resolve20(__dirname, "server.ts");
 
 // src/mcp/servers/sqlite/index.ts
-import { resolve as resolve20 } 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 = resolve20(__dirname, "server.ts");
+var SQLITE_MCP_SERVER_PATH = resolve21(__dirname, "server.ts");
 
 // src/init/project-analyzer.ts
-import { existsSync as existsSync20, readFileSync as readFileSync13, readdirSync as readdirSync9 } from "fs";
-import { join as join12, basename as basename3 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync13, readdirSync as readdirSync9 } from "fs";
+import { join as join13, basename as basename3 } from "path";
 
 class ProjectAnalyzer {
   cwd;
@@ -8430,8 +8503,8 @@ class ProjectAnalyzer {
     const architectureNotes = [];
     const codeConventions = [];
     let description = readmeInfo.description;
-    const pkgPath = join12(this.cwd, "package.json");
-    if (existsSync20(pkgPath)) {
+    const pkgPath = join13(this.cwd, "package.json");
+    if (existsSync21(pkgPath)) {
       try {
         const pkg = JSON.parse(readFileSync13(pkgPath, "utf8"));
         if (!description && pkg.description)
@@ -8504,8 +8577,8 @@ class ProjectAnalyzer {
         }
       } catch {}
     }
-    const tsconfigPath = join12(this.cwd, "tsconfig.json");
-    if (existsSync20(tsconfigPath)) {
+    const tsconfigPath = join13(this.cwd, "tsconfig.json");
+    if (existsSync21(tsconfigPath)) {
       try {
         const tsconfig = JSON.parse(readFileSync13(tsconfigPath, "utf8"));
         if (tsconfig.compilerOptions?.strict) {
@@ -8516,8 +8589,8 @@ class ProjectAnalyzer {
         }
       } catch {}
     }
-    const cargoPath = join12(this.cwd, "Cargo.toml");
-    if (existsSync20(cargoPath)) {
+    const cargoPath = join13(this.cwd, "Cargo.toml");
+    if (existsSync21(cargoPath)) {
       try {
         commands.dev = commands.dev || "cargo run";
         commands.build = commands.build || "cargo build";
@@ -8526,8 +8599,8 @@ class ProjectAnalyzer {
         frameworks.push("Rust Cargo");
       } catch {}
     }
-    const goModPath = join12(this.cwd, "go.mod");
-    if (existsSync20(goModPath)) {
+    const goModPath = join13(this.cwd, "go.mod");
+    if (existsSync21(goModPath)) {
       try {
         commands.dev = commands.dev || "go run .";
         commands.build = commands.build || "go build ./...";
@@ -8536,37 +8609,37 @@ class ProjectAnalyzer {
         frameworks.push("Go Modules");
       } catch {}
     }
-    const pyprojectPath = join12(this.cwd, "pyproject.toml");
-    const requirementsPath = join12(this.cwd, "requirements.txt");
-    if (existsSync20(pyprojectPath) || existsSync20(requirementsPath)) {
+    const pyprojectPath = join13(this.cwd, "pyproject.toml");
+    const requirementsPath = join13(this.cwd, "requirements.txt");
+    if (existsSync21(pyprojectPath) || existsSync21(requirementsPath)) {
       commands.test = commands.test || "pytest";
       commands.lint = commands.lint || "ruff check .";
-      if (existsSync20(join12(this.cwd, "uv.lock"))) {
+      if (existsSync21(join13(this.cwd, "uv.lock"))) {
         frameworks.push("uv");
         commands.test = "uv run pytest";
-      } else if (existsSync20(join12(this.cwd, "poetry.lock"))) {
+      } else if (existsSync21(join13(this.cwd, "poetry.lock"))) {
         frameworks.push("Poetry");
         commands.test = "poetry run pytest";
       }
     }
-    if (existsSync20(join12(this.cwd, "Dockerfile"))) {
+    if (existsSync21(join13(this.cwd, "Dockerfile"))) {
       infrastructure.push("Docker");
       const sanitizedName = projectName.toLowerCase().replace(/[^a-z0-9_-]/g, "-").replace(/^-+|-+$/g, "");
       commands.dockerBuild = `docker build -t ${sanitizedName || "app"} .`;
     }
-    if (existsSync20(join12(this.cwd, "nginx.conf"))) {
+    if (existsSync21(join13(this.cwd, "nginx.conf"))) {
       infrastructure.push("Nginx");
     }
-    if (existsSync20(join12(this.cwd, "src/api.ts")) || existsSync20(join12(this.cwd, "src/api"))) {
+    if (existsSync21(join13(this.cwd, "src/api.ts")) || existsSync21(join13(this.cwd, "src/api"))) {
       architectureNotes.push("Backend API endpoints and network client logic are centralized in `src/api`.");
     }
-    if (existsSync20(join12(this.cwd, "src/components"))) {
+    if (existsSync21(join13(this.cwd, "src/components"))) {
       architectureNotes.push("Reusable UI presentation components live in `src/components/`.");
     }
-    if (existsSync20(join12(this.cwd, "src/types.ts")) || existsSync20(join12(this.cwd, "src/types"))) {
+    if (existsSync21(join13(this.cwd, "src/types.ts")) || existsSync21(join13(this.cwd, "src/types"))) {
       architectureNotes.push("Shared TypeScript data models and interfaces are defined in `src/types`.");
     }
-    if (existsSync20(join12(this.cwd, ".env.example"))) {
+    if (existsSync21(join13(this.cwd, ".env.example"))) {
       architectureNotes.push("Environment configuration template is in `.env.example`.");
     }
     if (commands.typecheck || commands.lint || commands.test) {
@@ -8583,7 +8656,7 @@ class ProjectAnalyzer {
     let hasExistingInstructions = false;
     let existingInstructionFile;
     for (const f of instructionFiles) {
-      if (existsSync20(join12(this.cwd, f))) {
+      if (existsSync21(join13(this.cwd, f))) {
         hasExistingInstructions = true;
         existingInstructionFile = f;
         break;
@@ -8664,8 +8737,8 @@ class ProjectAnalyzer {
   extractReadmeMetadata() {
     const readmeFiles = ["README.md", "readme.md", "README.MD"];
     for (const file of readmeFiles) {
-      const fullPath = join12(this.cwd, file);
-      if (existsSync20(fullPath)) {
+      const fullPath = join13(this.cwd, file);
+      if (existsSync21(fullPath)) {
         try {
           const content = readFileSync13(fullPath, "utf8");
           const lines = content.split(`
@@ -8690,8 +8763,8 @@ class ProjectAnalyzer {
     return {};
   }
   detectProjectName() {
-    const pkgPath = join12(this.cwd, "package.json");
-    if (existsSync20(pkgPath)) {
+    const pkgPath = join13(this.cwd, "package.json");
+    if (existsSync21(pkgPath)) {
       try {
         const pkg = JSON.parse(readFileSync13(pkgPath, "utf8"));
         if (pkg.name && pkg.name !== "frontend" && pkg.name !== "backend" && pkg.name !== "app") {
@@ -8699,16 +8772,16 @@ class ProjectAnalyzer {
         }
       } catch {}
     }
-    const cargoPath = join12(this.cwd, "Cargo.toml");
-    if (existsSync20(cargoPath)) {
+    const cargoPath = join13(this.cwd, "Cargo.toml");
+    if (existsSync21(cargoPath)) {
       try {
         const match = readFileSync13(cargoPath, "utf8").match(/name\s*=\s*"([^"]+)"/);
         if (match?.[1])
           return match[1];
       } catch {}
     }
-    const goModPath = join12(this.cwd, "go.mod");
-    if (existsSync20(goModPath)) {
+    const goModPath = join13(this.cwd, "go.mod");
+    if (existsSync21(goModPath)) {
       try {
         const match = readFileSync13(goModPath, "utf8").match(/module\s+([^\s]+)/);
         if (match?.[1])
@@ -8719,47 +8792,47 @@ class ProjectAnalyzer {
   }
   detectLanguages() {
     const langs = new Set;
-    if (existsSync20(join12(this.cwd, "tsconfig.json")) || this.hasFileWithExtension(".ts", ".tsx")) {
+    if (existsSync21(join13(this.cwd, "tsconfig.json")) || this.hasFileWithExtension(".ts", ".tsx")) {
       langs.add("TypeScript");
     }
-    if (existsSync20(join12(this.cwd, "package.json")) || this.hasFileWithExtension(".js", ".jsx", ".mjs")) {
+    if (existsSync21(join13(this.cwd, "package.json")) || this.hasFileWithExtension(".js", ".jsx", ".mjs")) {
       langs.add("JavaScript");
     }
-    if (existsSync20(join12(this.cwd, "Cargo.toml")) || this.hasFileWithExtension(".rs")) {
+    if (existsSync21(join13(this.cwd, "Cargo.toml")) || this.hasFileWithExtension(".rs")) {
       langs.add("Rust");
     }
-    if (existsSync20(join12(this.cwd, "go.mod")) || this.hasFileWithExtension(".go")) {
+    if (existsSync21(join13(this.cwd, "go.mod")) || this.hasFileWithExtension(".go")) {
       langs.add("Go");
     }
-    if (existsSync20(join12(this.cwd, "pyproject.toml")) || existsSync20(join12(this.cwd, "requirements.txt")) || this.hasFileWithExtension(".py")) {
+    if (existsSync21(join13(this.cwd, "pyproject.toml")) || existsSync21(join13(this.cwd, "requirements.txt")) || this.hasFileWithExtension(".py")) {
       langs.add("Python");
     }
-    if (existsSync20(join12(this.cwd, "pom.xml")) || existsSync20(join12(this.cwd, "build.gradle")) || this.hasFileWithExtension(".java")) {
+    if (existsSync21(join13(this.cwd, "pom.xml")) || existsSync21(join13(this.cwd, "build.gradle")) || this.hasFileWithExtension(".java")) {
       langs.add("Java");
     }
-    if (existsSync20(join12(this.cwd, "CMakeLists.txt")) || this.hasFileWithExtension(".cpp", ".c", ".h", ".hpp")) {
+    if (existsSync21(join13(this.cwd, "CMakeLists.txt")) || this.hasFileWithExtension(".cpp", ".c", ".h", ".hpp")) {
       langs.add("C/C++");
     }
     return Array.from(langs);
   }
   detectPackageManager() {
-    if (existsSync20(join12(this.cwd, "bun.lockb")) || existsSync20(join12(this.cwd, "bun.lock")))
+    if (existsSync21(join13(this.cwd, "bun.lockb")) || existsSync21(join13(this.cwd, "bun.lock")))
       return "bun";
-    if (existsSync20(join12(this.cwd, "pnpm-lock.yaml")))
+    if (existsSync21(join13(this.cwd, "pnpm-lock.yaml")))
       return "pnpm";
-    if (existsSync20(join12(this.cwd, "yarn.lock")))
+    if (existsSync21(join13(this.cwd, "yarn.lock")))
       return "yarn";
-    if (existsSync20(join12(this.cwd, "package-lock.json")))
+    if (existsSync21(join13(this.cwd, "package-lock.json")))
       return "npm";
-    if (existsSync20(join12(this.cwd, "Cargo.lock")) || existsSync20(join12(this.cwd, "Cargo.toml")))
+    if (existsSync21(join13(this.cwd, "Cargo.lock")) || existsSync21(join13(this.cwd, "Cargo.toml")))
       return "cargo";
-    if (existsSync20(join12(this.cwd, "uv.lock")))
+    if (existsSync21(join13(this.cwd, "uv.lock")))
       return "uv";
-    if (existsSync20(join12(this.cwd, "poetry.lock")))
+    if (existsSync21(join13(this.cwd, "poetry.lock")))
       return "poetry";
-    if (existsSync20(join12(this.cwd, "go.sum")) || existsSync20(join12(this.cwd, "go.mod")))
+    if (existsSync21(join13(this.cwd, "go.sum")) || existsSync21(join13(this.cwd, "go.mod")))
       return "go";
-    if (existsSync20(join12(this.cwd, "package.json")))
+    if (existsSync21(join13(this.cwd, "package.json")))
       return "npm";
     return;
   }
@@ -8773,17 +8846,17 @@ class ProjectAnalyzer {
   }
 }
 // src/init/init-command.ts
-import { existsSync as existsSync21, writeFileSync as writeFileSync7 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync22, writeFileSync as writeFileSync8 } from "fs";
+import { join as join14 } from "path";
 function runProjectInit(options = {}) {
   const cwd = options.cwd || process.cwd();
   const filename = options.filename || "AGENTS.md";
-  const targetPath = join13(cwd, filename);
+  const targetPath = join14(cwd, filename);
   const analyzer = new ProjectAnalyzer(cwd);
   const analysis = analyzer.analyze();
   const content = analyzer.generateAgentsMarkdown(analysis);
-  const alreadyExists = existsSync21(targetPath);
-  writeFileSync7(targetPath, content, "utf8");
+  const alreadyExists = existsSync22(targetPath);
+  writeFileSync8(targetPath, content, "utf8");
   return {
     success: true,
     filePath: targetPath,
@@ -8855,7 +8928,7 @@ var AVAILABLE_SLASH_COMMANDS = [
   { name: "/manual", description: "Switch to Manual Mode (all tools require user confirmation)" },
   { name: "/accept-edits", description: "Switch to Accept Edits Mode (file edits auto-approved, shell prompts)" },
   { name: "/plan", description: "Switch to Plan Mode (read-only planning, mutations blocked)" },
-  { name: "/skills", description: "List domain skills in workspace & global" },
+  { name: "/skills", description: "Manage domain skills (/skills, /skill add <name>, /skill remove <name>)" },
   { name: "/memories", description: "View learned preferences & memories" },
   { name: "/worktrees", description: "List active isolated Git Worktrees" },
   { name: "/resume", description: "Resume a previous conversation session (/resume [id])" },
@@ -9358,6 +9431,46 @@ async function handleSkillsCommand(ctx, args) {
   }
   const sub = (args[0] || "").toLowerCase();
   const target = (args[1] || "").toLowerCase();
+  if (sub === "install" || sub === "add") {
+    if (!target) {
+      console.log(style.yellow("Usage: /skill add <skill-name> [--global]"));
+      return;
+    }
+    const isGlobal = args.includes("--global") || args.includes("-g");
+    try {
+      console.log(style.dim(`
+  Fetching skill '${target}' from catalog...`));
+      const res = await installSkill(target, { cwd: ctx.session.cwd, global: isGlobal });
+      loader.clearCache();
+      console.log(style.green(`
+  \u2713 ${res.message}
+`));
+    } catch (err) {
+      console.log(style.red(`
+  \u2715 Failed to install skill: ${err.message}
+`));
+    }
+    return;
+  }
+  if (sub === "remove" || sub === "uninstall" || sub === "rm") {
+    if (!target) {
+      console.log(style.yellow("Usage: /skill remove <skill-name> [--global]"));
+      return;
+    }
+    const isGlobal = args.includes("--global") || args.includes("-g");
+    const res = removeSkill(target, { cwd: ctx.session.cwd, global: isGlobal });
+    loader.clearCache();
+    if (res.removed) {
+      console.log(style.green(`
+  \u2713 Skill '${target}' removed from ${res.targetDir}
+`));
+    } else {
+      console.log(style.yellow(`
+  \u2715 Skill '${target}' was not found in ${res.targetDir}
+`));
+    }
+    return;
+  }
   if (sub === "disable" || sub === "off") {
     if (!target) {
       console.log(style.yellow("Usage: /skills disable <skill-name>"));
@@ -10328,9 +10441,9 @@ class MarkdownHighlighter {
 }
 
 // src/cli/update-checker.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync12, readFileSync as readFileSync14, writeFileSync as writeFileSync8 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join14 } from "path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync13, readFileSync as readFileSync14, writeFileSync as writeFileSync9 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join15 } from "path";
 var CHECK_INTERVAL_MS = 12 * 60 * 60 * 1000;
 function parseSemver(v) {
   const clean = v.replace(/^v/, "").trim();
@@ -10351,8 +10464,8 @@ function isNewerVersion(current, remote) {
   return remPatch > curPatch;
 }
 function getUpdateCachePath() {
-  const baseDir = process.env.PIKAA_HOME || process.env.GROUPY_HOME || join14(homedir5(), ".pikaa");
-  return join14(baseDir, "update-cache.json");
+  const baseDir = process.env.PIKAA_HOME || process.env.GROUPY_HOME || join15(homedir4(), ".pikaa");
+  return join15(baseDir, "update-cache.json");
 }
 async function fetchLatestNpmVersion(packageName, timeoutMs = 1500) {
   const url = `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`;
@@ -10385,7 +10498,7 @@ async function checkForUpdates(options = {}) {
   const cachePath = options.cachePath || getUpdateCachePath();
   const now = Date.now();
   let cached = null;
-  if (!options.force && existsSync22(cachePath)) {
+  if (!options.force && existsSync23(cachePath)) {
     try {
       const raw = JSON.parse(readFileSync14(cachePath, "utf8"));
       if (raw && typeof raw.lastChecked === "number" && typeof raw.latestVersion === "string") {
@@ -10415,16 +10528,16 @@ async function checkForUpdates(options = {}) {
     return null;
   }
   try {
-    const parentDir = join14(cachePath, "..");
-    if (!existsSync22(parentDir)) {
-      mkdirSync12(parentDir, { recursive: true });
+    const parentDir = join15(cachePath, "..");
+    if (!existsSync23(parentDir)) {
+      mkdirSync13(parentDir, { recursive: true });
     }
     const cacheData = {
       lastChecked: now,
       latestVersion,
       packageName
     };
-    writeFileSync8(cachePath, JSON.stringify(cacheData, null, 2), "utf8");
+    writeFileSync9(cachePath, JSON.stringify(cacheData, null, 2), "utf8");
   } catch {}
   const updateAvailable = isNewerVersion(currentVersion, latestVersion);
   return updateAvailable ? {
@@ -10590,9 +10703,9 @@ class CliRepl {
             filesModified: Array.from(this.turnFilesModified)
           });
           if (this.turnDoneResolver) {
-            const resolve21 = this.turnDoneResolver;
+            const resolve22 = this.turnDoneResolver;
             this.turnDoneResolver = undefined;
-            resolve21();
+            resolve22();
           }
           break;
         case "Error":
@@ -10608,9 +10721,9 @@ class CliRepl {
           console.error(style.red(`Error: ${msg.message}
 `));
           if (this.turnDoneResolver) {
-            const resolve21 = this.turnDoneResolver;
+            const resolve22 = this.turnDoneResolver;
             this.turnDoneResolver = undefined;
-            resolve21();
+            resolve22();
           }
           break;
       }
@@ -10680,15 +10793,21 @@ class CliRepl {
 `));
             this.isProcessing = false;
             if (this.turnDoneResolver) {
-              const resolve21 = this.turnDoneResolver;
+              const resolve22 = this.turnDoneResolver;
               this.turnDoneResolver = undefined;
-              resolve21();
+              resolve22();
             }
           }
         }
       }
     });
     while (!this.isClosed) {
+      await new Promise((resolve22) => setTimeout(resolve22, 20));
+      if (typeof Bun !== "undefined" && typeof Bun.gc === "function") {
+        try {
+          Bun.gc(false);
+        } catch {}
+      }
       let rawLine;
       try {
         rawLine = await editor.readLine();
@@ -10719,8 +10838,8 @@ class CliRepl {
   }
   async submitTurn(text) {
     try {
-      const turnPromise = new Promise((resolve21) => {
-        this.turnDoneResolver = resolve21;
+      const turnPromise = new Promise((resolve22) => {
+        this.turnDoneResolver = resolve22;
       });
       await this.session.submit({
         type: "TurnInput",
@@ -10786,9 +10905,22 @@ async function main() {
     } else if (arg === "list" || arg === "sessions" || arg === "--list") {
       printSessionsList(storageManager);
       process.exit(0);
-    } else if (arg === "skills") {
-      printSkillsList(skillsLoader, cwd);
-      process.exit(0);
+    } else if (arg === "skills" || arg === "skill") {
+      const subAction = args[i + 1];
+      const target = args[i + 2];
+      const isGlobal = args.includes("--global") || args.includes("-g");
+      if (subAction && !subAction.startsWith("-")) {
+        await handleSkillCliCommand(subAction, target, {
+          cwd,
+          isGlobal,
+          baseUrl,
+          loader: skillsLoader
+        });
+        process.exit(0);
+      } else {
+        printSkillsList(skillsLoader, cwd);
+        process.exit(0);
+      }
     } else if (arg === "memories" || arg === "memory") {
       printMemoriesList(memoryStore, cwd);
       process.exit(0);
@@ -10810,7 +10942,7 @@ async function main() {
       explicitApiKey = args[++i];
       apiKey = explicitApiKey || apiKey;
     } else if (arg === "--cwd" || arg === "-C") {
-      cwd = resolve21(args[++i] || cwd);
+      cwd = resolve22(args[++i] || cwd);
     } else if (arg === "--role" || arg === "-r") {
       role = args[++i] || role;
     } else if (arg === "--mcp") {
@@ -10836,11 +10968,11 @@ async function main() {
   const mcpManager = new McpManager;
   const candidateConfigs = [
     mcpConfigFile,
-    resolve21(cwd, ".mcp.json"),
-    resolve21(cwd, "mcp_config.json")
+    resolve22(cwd, ".mcp.json"),
+    resolve22(cwd, "mcp_config.json")
   ].filter(Boolean);
   for (const cfg of candidateConfigs) {
-    if (existsSync23(cfg)) {
+    if (existsSync24(cfg)) {
       try {
         await mcpManager.loadConfigFile(cfg);
         mcpManager.registerToolsIntoRouter(tools4);
@@ -11043,6 +11175,62 @@ Resume a session with: ${style.bold("groupy --resume <thread_id>")}`);
   }
   console.log();
 }
+async function handleSkillCliCommand(action, targetName, options) {
+  const act = action.toLowerCase();
+  if (act === "add" || act === "install") {
+    if (!targetName) {
+      console.error(style.yellow(`
+Usage: pikaa skill add <skill-name> [--global]
+`));
+      process.exit(1);
+    }
+    try {
+      console.log(style.dim(`
+Fetching skill '${targetName}' from catalog...`));
+      const res = await installSkill(targetName, {
+        cwd: options.cwd,
+        global: options.isGlobal,
+        backendUrl: options.baseUrl
+      });
+      console.log(style.green(`
+\u2713 ${res.message}`));
+      console.log(style.dim(`  To start using this skill in an AI coding session, simply run: pikaa
+`));
+    } catch (err) {
+      console.error(style.red(`
+\u2715 Failed to install skill: ${err.message}
+`));
+      process.exit(1);
+    }
+  } else if (act === "remove" || act === "uninstall" || act === "rm") {
+    if (!targetName) {
+      console.error(style.yellow(`
+Usage: pikaa skill remove <skill-name> [--global]
+`));
+      process.exit(1);
+    }
+    const res = removeSkill(targetName, { cwd: options.cwd, global: options.isGlobal });
+    if (res.removed) {
+      console.log(style.green(`
+\u2713 Skill '${targetName}' removed from ${res.targetDir}
+`));
+    } else {
+      console.log(style.yellow(`
+\u2715 Skill '${targetName}' was not found in ${res.targetDir}
+`));
+    }
+  } else if (act === "list" || act === "ls") {
+    printSkillsList(options.loader, options.cwd);
+  } else {
+    if (act && !targetName) {
+      return handleSkillCliCommand("add", act, options);
+    }
+    console.error(style.yellow(`
+Unknown skill action '${action}'. Available: add, remove, list
+`));
+    process.exit(1);
+  }
+}
 function printSkillsList(loader, cwd) {
   const skills = loader.discoverSkills(cwd);
   console.log();